refactor: split cmd/roborev/main.go into focused files (#375)

## Summary
- Extract ~3,500 lines from `main.go` into 19 focused files, reducing it
to ~60 lines (global vars + root command setup)
- Follows the established pattern already used by `analyze.go`, `ci.go`,
`fix.go`, `run.go`, etc.: same `main` package, direct global access,
`xxxCmd()` returns `*cobra.Command`
- No behavioral changes; all tests pass unmodified

## New files

| File | Contents |
|------|----------|
| `env.go` | Git environment filtering, binary detection helpers |
| `daemon_lifecycle.go` | Test seam vars, daemon start/stop/restart,
registerRepo |
| `daemon_client.go` | HTTP client helpers (waitForJob, showReview,
findJobForCommit, etc.) |
| `helpers.go` | exitError, shortRef, shortJobRef, autoInstallHooks |
| `update.go` | Update command + PID-tracking restart logic |
| `review.go` | Review command + runLocalReview |
| `daemon_cmd.go` | Daemon subcommand group + daemonRunCmd |
| `init_cmd.go` | Init command |
| `hook.go` | install-hook, uninstall-hook |
| `wait.go` | Wait command |
| `status.go` | Status command |
| `list.go` | List command |
| `show.go` | Show command |
| `comment.go` | Comment, respond, address commands |
| `stream.go` | Stream command |
| `skills.go` | Skills command |
| `sync.go` | Sync command group |
| `check_agents.go` | Check-agents command |
| `version.go` | Version command |

## Test plan
- [x] `go build ./...` passes
- [x] `go vet ./...` passes
- [x] `go test ./cmd/roborev/...` passes (tests unmodified)
- [x] `go test ./...` full suite passes

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: wesm

cmd/roborev/check_agents.go

@@ -0,0 +1,120 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/roborev-dev/roborev/internal/agent"
+	"github.com/spf13/cobra"
+)
+
+func checkAgentsCmd() *cobra.Command {
+	var (
+		timeoutSecs int
+		agentFilter string
+		largePrompt bool
+	)
+
+	cmd := &cobra.Command{
+		Use:   "check-agents",
+		Short: "Check which agents are available and responding",
+		Long: `Check which agents are installed and can produce output.
+
+For each agent found on PATH, runs a short smoke-test prompt with a timeout
+to verify the agent is actually functional.
+
+Examples:
+  roborev check-agents                  # Check all agents
+  roborev check-agents --agent codex    # Check only codex
+  roborev check-agents --timeout 30     # 30 second timeout per agent
+  roborev check-agents --large-prompt   # Test with 33KB+ prompt (Windows limit check)`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			names := agent.Available()
+			sort.Strings(names)
+
+			timeout := time.Duration(timeoutSecs) * time.Second
+			smokePrompt := "Respond with exactly: OK"
+			if largePrompt {
+				smokePrompt = "Respond with exactly: OK\n" +
+					strings.Repeat("// padding line\n", 2200)
+			}
+
+			// Use current directory as repo path for the smoke test
+			repoPath, err := os.Getwd()
+			if err != nil {
+				repoPath = "."
+			}
+
+			var passed, failed, skipped int
+
+			for _, name := range names {
+				if name == "test" {
+					continue
+				}
+				if agentFilter != "" && name != agentFilter {
+					continue
+				}
+
+				a, _ := agent.Get(name)
+				if a == nil {
+					continue
+				}
+
+				cmdName := ""
+				if ca, ok := a.(agent.CommandAgent); ok {
+					cmdName = ca.CommandName()
+				}
+
+				if !agent.IsAvailable(name) {
+					fmt.Printf("  - %-14s %s (not found in PATH)\n", name, cmdName)
+					skipped++
+					continue
+				}
+
+				path, _ := exec.LookPath(cmdName)
+				fmt.Printf("  ? %-14s %s (%s) ... ", name, cmdName, path)
+
+				ctx, cancel := context.WithTimeout(context.Background(), timeout)
+				result, err := a.Review(ctx, repoPath, "HEAD", smokePrompt, nil)
+				cancel()
+
+				if err != nil {
+					fmt.Printf("FAIL\n")
+					// Indent each line of the error for readability
+					for line := range strings.SplitSeq(err.Error(), "\n") {
+						line = strings.TrimSpace(line)
+						if line != "" {
+							fmt.Printf("    %s\n", line)
+						}
+					}
+					failed++
+				} else if strings.TrimSpace(result) == "" {
+					fmt.Printf("FAIL (empty response)\n")
+					failed++
+				} else {
+					fmt.Printf("OK (%d bytes)\n", len(result))
+					passed++
+				}
+			}
+
+			fmt.Printf("\n%d passed, %d failed, %d skipped\n", passed, failed, skipped)
+			if failed > 0 {
+				return fmt.Errorf("%d agent(s) failed health check", failed)
+			}
+			return nil
+		},
+	}
+
+	cmd.SilenceUsage = true
+	cmd.Flags().IntVar(&timeoutSecs, "timeout", 60, "timeout in seconds per agent")
+	cmd.Flags().StringVar(&agentFilter, "agent", "", "check only this agent")
+	cmd.Flags().BoolVar(&largePrompt, "large-prompt", false,
+		"use a 33KB+ prompt to test Windows command-line limits")
+
+	return cmd
+}

cmd/roborev/comment.go

@@ -0,0 +1,217 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/roborev-dev/roborev/internal/git"
+	"github.com/spf13/cobra"
+)
+
+func commentCmd() *cobra.Command {
+	var (
+		commenter  string
+		message    string
+		forceJobID bool
+	)
+
+	cmd := &cobra.Command{
+		Use:   "comment <job_id|sha> [message]",
+		Short: "Add a comment to a review",
+		Long: `Add a comment or note to a review.
+
+The first argument can be either a job ID (numeric) or a commit SHA.
+Using job IDs is recommended since they are displayed in the TUI.
+
+Examples:
+  roborev comment 42 "Fixed the null pointer issue"
+  roborev comment 42 -m "Added missing error handling"
+  roborev comment abc123 "Addressed by refactoring"
+  roborev comment 42     # Opens editor for message
+  roborev comment --job 1234567 "msg"  # Force numeric arg as job ID`,
+		Args: cobra.RangeArgs(1, 2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ref := args[0]
+
+			// Check if ref is a job ID (numeric) or SHA
+			var jobID int64
+			var sha string
+
+			if forceJobID {
+				// --job flag: treat ref as job ID
+				id, err := strconv.ParseInt(ref, 10, 64)
+				if err != nil {
+					return fmt.Errorf("--job requires numeric job ID, got %q", ref)
+				}
+				jobID = id
+			} else {
+				// Auto-detect: try git object first, then job ID
+				// A numeric string could be either - check if it resolves as a git object first
+				if root, err := git.GetRepoRoot("."); err == nil {
+					if resolved, err := git.ResolveSHA(root, ref); err == nil {
+						sha = resolved
+					}
+				}
+
+				// If not a valid git object, try parsing as job ID
+				if sha == "" {
+					if id, err := strconv.ParseInt(ref, 10, 64); err == nil {
+						jobID = id
+					} else {
+						// Not a valid git object or job ID - use ref as-is
+						sha = ref
+					}
+				}
+			}
+
+			// Ensure daemon is running
+			if err := ensureDaemon(); err != nil {
+				return fmt.Errorf("daemon not running: %w", err)
+			}
+
+			// Message can be positional argument or flag
+			if len(args) > 1 {
+				message = args[1]
+			}
+
+			// If no message provided, open editor
+			if message == "" {
+				editor := os.Getenv("EDITOR")
+				if editor == "" {
+					editor = "vim"
+				}
+
+				tmpfile, err := os.CreateTemp("", "roborev-comment-*.md")
+				if err != nil {
+					return fmt.Errorf("create temp file: %w", err)
+				}
+				tmpfile.Close()
+				defer os.Remove(tmpfile.Name())
+
+				editorCmd := exec.Command(editor, tmpfile.Name())
+				editorCmd.Stdin = os.Stdin
+				editorCmd.Stdout = os.Stdout
+				editorCmd.Stderr = os.Stderr
+				if err := editorCmd.Run(); err != nil {
+					return fmt.Errorf("editor failed: %w", err)
+				}
+
+				content, err := os.ReadFile(tmpfile.Name())
+				if err != nil {
+					return fmt.Errorf("read comment: %w", err)
+				}
+				message = strings.TrimSpace(string(content))
+			}
+
+			if message == "" {
+				return fmt.Errorf("empty comment, aborting")
+			}
+
+			if commenter == "" {
+				commenter = os.Getenv("USER")
+				if commenter == "" {
+					commenter = "anonymous"
+				}
+			}
+
+			// Build request with either job_id or sha
+			reqData := map[string]any{
+				"commenter": commenter,
+				"comment":   message,
+			}
+			if jobID != 0 {
+				reqData["job_id"] = jobID
+			} else {
+				reqData["sha"] = sha
+			}
+
+			reqBody, _ := json.Marshal(reqData)
+
+			addr := getDaemonAddr()
+			resp, err := http.Post(addr+"/api/comment", "application/json", bytes.NewReader(reqBody))
+			if err != nil {
+				return fmt.Errorf("failed to connect to daemon: %w", err)
+			}
+			defer resp.Body.Close()
+
+			if resp.StatusCode != http.StatusCreated {
+				body, _ := io.ReadAll(resp.Body)
+				return fmt.Errorf("failed to add comment: %s", body)
+			}
+
+			fmt.Println("Comment added successfully")
+			return nil
+		},
+	}
+
+	cmd.Flags().StringVar(&commenter, "commenter", "", "commenter name (default: $USER)")
+	cmd.Flags().StringVarP(&message, "message", "m", "", "comment message (opens editor if not provided)")
+	cmd.Flags().BoolVar(&forceJobID, "job", false, "force argument to be treated as job ID (not SHA)")
+
+	return cmd
+}
+
+// respondCmd returns an alias for commentCmd
+func respondCmd() *cobra.Command {
+	cmd := commentCmd()
+	cmd.Use = "respond <job_id|sha> [message]"
+	cmd.Short = "Alias for 'comment' - add a comment to a review"
+	return cmd
+}
+
+func addressCmd() *cobra.Command {
+	var unaddress bool
+
+	cmd := &cobra.Command{
+		Use:   "address <job_id>",
+		Short: "Mark a review as addressed",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// Ensure daemon is running
+			if err := ensureDaemon(); err != nil {
+				return fmt.Errorf("daemon not running: %w", err)
+			}
+
+			jobID, err := strconv.ParseInt(args[0], 10, 64)
+			if err != nil || jobID <= 0 {
+				return fmt.Errorf("invalid job_id: %s", args[0])
+			}
+
+			addressed := !unaddress
+			reqBody, _ := json.Marshal(map[string]any{
+				"job_id":    jobID,
+				"addressed": addressed,
+			})
+
+			addr := getDaemonAddr()
+			resp, err := http.Post(addr+"/api/review/address", "application/json", bytes.NewReader(reqBody))
+			if err != nil {
+				return fmt.Errorf("failed to connect to daemon: %w", err)
+			}
+			defer resp.Body.Close()
+
+			if resp.StatusCode != http.StatusOK {
+				body, _ := io.ReadAll(resp.Body)
+				return fmt.Errorf("failed to mark review: %s", body)
+			}
+
+			if addressed {
+				fmt.Printf("Job %d marked as addressed\n", jobID)
+			} else {
+				fmt.Printf("Job %d marked as unaddressed\n", jobID)
+			}
+			return nil
+		},
+	}
+
+	cmd.Flags().BoolVar(&unaddress, "unaddress", false, "mark as unaddressed instead")
+
+	return cmd
+}