Update from https://github.com/cloudimpl/next-coder/commit/4989387d3d9235c936a8e90f063abb270d4e1014

Author: CloudimplBot

.github/workflows/publish-version.yml

@@ -0,0 +1,53 @@
+name: Publish version
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  create_tag:
+    runs-on: ubuntu-latest
+
+    steps:
+      # Step 1: Checkout the repository
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      # Step 2: Set up Git for tagging
+      - name: Set up Git for tagging
+        run: |
+          git config user.name "${{ github.actor }}"
+          git config user.email "${{ github.actor }}@users.noreply.github.com"
+
+      # Step 3: Get the latest tag and increment the minor version
+      - name: Get latest tag and increment
+        id: get_tag
+        run: |
+          # Fetch all tags
+          git fetch --tags
+
+          # Get the latest tag version
+          latest_tag=$(git describe --tags --abbrev=0 || echo "v0.0.0")
+          echo "Latest tag: $latest_tag"
+
+          # Extract the version numbers (major, minor, patch)
+          major=$(echo $latest_tag | cut -d. -f1 | cut -dv -f2)
+          minor=$(echo $latest_tag | cut -d. -f2)
+          patch=$(echo $latest_tag | cut -d. -f3)
+
+          # Increment the minor version and reset patch to 0
+          new_minor=$((minor + 1))
+          new_version="v${major}.${new_minor}.0"
+
+          # Write the new version to the GITHUB_OUTPUT file for later use
+          echo "tag=$new_version" >> $GITHUB_OUTPUT
+
+      # Step 4: Create and push the new tag
+      - name: Create new tag
+        run: |
+          new_tag="${{ steps.get_tag.outputs.tag }}"
+          git tag $new_tag
+          git push origin $new_tag

README.md

@@ -0,0 +1,3 @@
+module github.com/cloudimpl/poly-watcher
+
+go 1.23.0

go.mod

@@ -0,0 +1,224 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"hash/fnv"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+type Watcher struct {
+	dir          string
+	interval     time.Duration
+	buildCmd     string
+	runCmd       string
+	includes     []string
+	excludes     []string
+	depFile      string
+	depCmd       string
+	prevHash     uint64
+	prevDepMTime time.Time
+	process      *exec.Cmd
+	processMu    sync.Mutex
+}
+
+func NewWatcher(dir string, interval time.Duration, buildCmd, runCmd, depFile, depCmd string, includes, excludes []string) *Watcher {
+	return &Watcher{
+		dir:      dir,
+		interval: interval,
+		buildCmd: buildCmd,
+		runCmd:   runCmd,
+		depFile:  depFile,
+		depCmd:   depCmd,
+		includes: includes,
+		excludes: excludes,
+	}
+}
+
+func (w *Watcher) shouldProcess(relPath string) bool {
+	for _, ex := range w.excludes {
+		if strings.HasPrefix(relPath, ex) || strings.HasSuffix(relPath, ex) {
+			return false
+		}
+	}
+	if len(w.includes) == 0 {
+		return true
+	}
+	for _, in := range w.includes {
+		if strings.HasPrefix(relPath, in) || strings.HasSuffix(relPath, in) {
+			return true
+		}
+	}
+	return false
+}
+
+func (w *Watcher) hashDir() (uint64, bool, error) {
+	h := fnv.New64a()
+	depChanged := false
+
+	err := filepath.Walk(w.dir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		relPath, _ := filepath.Rel(w.dir, path)
+
+		if info.IsDir() {
+			if info.Name()[0] == '.' {
+				return filepath.SkipDir
+			}
+			if !w.shouldProcess(relPath) {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		if info.Name()[0] == '.' {
+			return nil
+		}
+		if !w.shouldProcess(relPath) {
+			return nil
+		}
+
+		h.Write([]byte(relPath))
+		h.Write([]byte(fmt.Sprintf("%d", info.Size())))
+		h.Write([]byte(info.ModTime().String()))
+
+		if w.depFile != "" && filepath.Base(path) == filepath.Base(w.depFile) {
+			if info.ModTime() != w.prevDepMTime {
+				depChanged = true
+				w.prevDepMTime = info.ModTime()
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		return 0, false, err
+	}
+	return h.Sum64(), depChanged, nil
+}
+
+func (w *Watcher) runShell(command string) error {
+	if command == "" {
+		return nil
+	}
+	cmd := exec.Command("/bin/sh", "-c", command)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func (w *Watcher) runBuild(depChanged bool) error {
+	if depChanged && w.depCmd != "" {
+		log.Printf("%s changed: running %s...\n", w.depFile, w.depCmd)
+		if err := w.runShell(w.depCmd); err != nil {
+			return err
+		}
+	}
+
+	log.Println("Running build command...")
+	return w.runShell(w.buildCmd)
+}
+
+func (w *Watcher) startApp() error {
+	w.processMu.Lock()
+	defer w.processMu.Unlock()
+
+	if w.process != nil && w.process.Process != nil {
+		log.Println("Stopping previous app process...")
+		_ = w.process.Process.Kill()
+		w.process = nil
+	}
+
+	log.Println("Starting app...")
+	cmd := exec.Command("/bin/sh", "-c", w.runCmd)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	w.process = cmd
+	go func() {
+		_ = cmd.Wait()
+		log.Println("App exited")
+		w.processMu.Lock()
+		w.process = nil
+		w.processMu.Unlock()
+	}()
+	return nil
+}
+
+func (w *Watcher) Run() {
+	for {
+		hash, depChanged, err := w.hashDir()
+		if err != nil {
+			log.Println("Error hashing dir:", err)
+			time.Sleep(w.interval)
+			continue
+		}
+
+		if hash != w.prevHash {
+			log.Println("Change detected, rebuilding...")
+			w.prevHash = hash
+
+			if err := w.runBuild(depChanged); err != nil {
+				log.Println("Build failed:", err)
+				time.Sleep(w.interval)
+				continue
+			}
+
+			if err := w.startApp(); err != nil {
+				log.Println("App start failed:", err)
+			}
+		}
+
+		time.Sleep(w.interval)
+	}
+}
+
+func printBanner() {
+	fmt.Println("🚀 Poly Watcher — The universal build-run watcher for your projects. Change it. Build it. Run it. Repeat.")
+	fmt.Println("Example:")
+	fmt.Println(`  poly-watcher --depfile=go.mod --depcommand="go mod tidy && go mod download" --build="go build -o myapp ." --run="./myapp" --include=.go --exclude=.git,.polycode`)
+	fmt.Println()
+}
+
+func main() {
+	printBanner()
+
+	dir := flag.String("dir", ".", "Working directory to watch")
+	buildCmd := flag.String("build", "echo 'No build command specified'", "Build command to run on change")
+	runCmd := flag.String("run", "echo 'No run command specified'", "Run command to execute built app")
+	depFile := flag.String("depfile", "", "Dependency file to monitor for changes (e.g. go.mod, package.json)")
+	depCmd := flag.String("depcommand", "", "Command to run when dependency file changes (e.g. 'go mod tidy', 'npm install')")
+	interval := flag.Duration("interval", 1*time.Second, "Polling interval (e.g. 1s, 500ms)")
+	includeDirs := flag.String("include", "", "Comma-separated list of include rules (prefix or suffix, e.g. '.go,services')")
+	excludeDirs := flag.String("exclude", "", "Comma-separated list of exclude rules (prefix or suffix, e.g. '.git,tmp')")
+
+	flag.Parse()
+
+	includes := []string{}
+	excludes := []string{}
+	if *includeDirs != "" {
+		includes = strings.Split(*includeDirs, ",")
+	}
+	if *excludeDirs != "" {
+		excludes = strings.Split(*excludeDirs, ",")
+	}
+
+	if err := os.Chdir(*dir); err != nil {
+		log.Fatalf("Failed to change directory: %v", err)
+	}
+
+	watcher := NewWatcher(".", *interval, *buildCmd, *runCmd, *depFile, *depCmd, includes, excludes)
+	log.Println("Starting watcher...")
+	watcher.Run()
+}