test message

Author: Patel230

cmd/iterate/features_watch.go

@@ -28,7 +28,9 @@ var watchConfig = struct {
 	// exclude is a list of path substrings to ignore.
 	exclude []string
 }{
-	debounce: 300 * time.Millisecond,
+	// 2-second debounce: collect all file change events in the window and send
+	// ONE batched prompt listing every changed file instead of per-file prompts.
+	debounce: 2 * time.Second,
 	exclude:  []string{".git", "node_modules", ".iterate"},
 }
 
@@ -57,11 +59,16 @@ func startWatch(repoPath string) {
 }
 
 // runWatcher polls for file modifications using mtimes (no fsnotify dependency).
+// File change events are batched: all files that change within the debounce window
+// are collected and trigger a single test run, rather than one run per file.
 func runWatcher(ctx context.Context, repoPath string) {
 	snapshots := snapshotMTimes(repoPath)
 
 	var debounceTimer *time.Timer
 	var debounceMu sync.Mutex
+	// pendingChanged accumulates file paths seen during the current debounce window.
+	var pendingChanged []string
+	pendingSet := make(map[string]struct{})
 
 	ticker := time.NewTicker(500 * time.Millisecond)
 	defer ticker.Stop()
@@ -79,16 +86,29 @@ func runWatcher(ctx context.Context, repoPath string) {
 				continue
 			}
 
-			// Debounce: reset timer on each burst of changes.
+			// Accumulate changed files across the debounce window (deduplicated).
 			debounceMu.Lock()
+			for _, p := range changed {
+				if _, seen := pendingSet[p]; !seen {
+					pendingSet[p] = struct{}{}
+					pendingChanged = append(pendingChanged, p)
+				}
+			}
+
+			// Reset the timer: fire after debounce elapses with no new changes.
 			if debounceTimer != nil {
 				debounceTimer.Stop()
 			}
-			changedCopy := changed
+			// Capture the batch for the closure.
+			batchSnapshot := append([]string(nil), pendingChanged...)
+			pendingChanged = pendingChanged[:0]
+			for k := range pendingSet {
+				delete(pendingSet, k)
+			}
 			debounceTimer = time.AfterFunc(watchConfig.debounce, func() {
 				fmt.Printf("\n%s[watch] %d file(s) changed — running tests…%s\n",
-					colorYellow, len(changedCopy), colorReset)
-				for _, p := range changedCopy {
+					colorYellow, len(batchSnapshot), colorReset)
+				for _, p := range batchSnapshot {
 					rel, _ := filepath.Rel(repoPath, p)
 					fmt.Printf("  %s%s%s\n", colorDim, rel, colorReset)
 				}

internal/commands/autofix.go

@@ -0,0 +1,87 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"strconv"
+)
+
+// RegisterAutofixCommands adds the /autofix command.
+func RegisterAutofixCommands(r *Registry) {
+	r.Register(Command{
+		Name:        "/autofix",
+		Aliases:     []string{"/af"},
+		Description: "run tests, ask agent to fix failures, repeat up to N times (default 3)",
+		Category:    "dev",
+		Handler:     cmdAutofix,
+	})
+}
+
+// detectTestCmd returns the test command and args appropriate for the repo.
+func detectTestCmd(repoPath string) (string, []string) {
+	// Check for go.mod (most common for this project)
+	if _, err := exec.LookPath("go"); err == nil {
+		gomod := exec.Command("go", "env", "GOMOD")
+		gomod.Dir = repoPath
+		if out, err := gomod.Output(); err == nil && len(out) > 0 {
+			return "go", []string{"test", "./..."}
+		}
+	}
+	if _, err := exec.LookPath("npm"); err == nil {
+		pkg := exec.Command("npm", "run", "test", "--if-present")
+		pkg.Dir = repoPath
+		return "npm", []string{"test"}
+	}
+	if _, err := exec.LookPath("pytest"); err == nil {
+		return "pytest", []string{}
+	}
+	// Default fallback
+	return "go", []string{"test", "./..."}
+}
+
+func cmdAutofix(ctx Context) Result {
+	maxAttempts := 3
+	if ctx.HasArg(1) {
+		if v, err := strconv.Atoi(ctx.Arg(1)); err == nil && v > 0 {
+			maxAttempts = v
+		}
+	}
+
+	if ctx.REPL.StreamAndPrint == nil {
+		PrintError("agent not available for autofix")
+		return Result{Handled: true}
+	}
+
+	testCmd, testArgs := detectTestCmd(ctx.RepoPath)
+
+	for attempt := 1; attempt <= maxAttempts; attempt++ {
+		fmt.Printf("%s[attempt %d/%d]%s running %s %v\n",
+			ColorDim, attempt, maxAttempts, ColorReset, testCmd, testArgs)
+
+		cmd := exec.Command(testCmd, testArgs...)
+		cmd.Dir = ctx.RepoPath
+		output, err := cmd.CombinedOutput()
+
+		if err == nil {
+			PrintSuccess("tests passed on attempt %d/%d", attempt, maxAttempts)
+			return Result{Handled: true}
+		}
+
+		// Tests failed — print failure output
+		fmt.Printf("%s── Test failures ───────────────────%s\n", ColorDim, ColorReset)
+		fmt.Println(string(output))
+		fmt.Printf("%s──────────────────────────────────%s\n\n", ColorDim, ColorReset)
+
+		if attempt == maxAttempts {
+			break
+		}
+
+		// Ask agent to fix
+		prompt := fmt.Sprintf("The following tests are failing. Fix them:\n\n%s", string(output))
+		ctx.REPL.StreamAndPrint(context.Background(), ctx.Agent, prompt, ctx.RepoPath)
+	}
+
+	fmt.Printf("%sautofix gave up after %d attempts%s\n\n", ColorRed, maxAttempts, ColorReset)
+	return Result{Handled: true}
+}