Add wingman automated code review system

.entire/.gitignore

@@ -3,3 +3,7 @@ settings.local.json
 metadata/
 current_session
 logs/
+wingman.lock
+wingman-state.json
+wingman-payload.json
+REVIEW.md

.golangci.yaml

@@ -104,6 +104,7 @@ linters:
         - grpc.DialOption
         - github.com/entireio/cli/cmd/entire/cli/agent.Agent
         - github.com/entireio/cli/cmd/entire/cli/strategy.Strategy
+        - github.com/entireio/cli/cmd/entire/cli/summarize.Generator
         - github.com/go-git/go-git/v6/plumbing/storer.ReferenceIter
         - github.com/go-git/go-git/v6/plumbing.EncodedObject
         - github.com/go-git/go-git/v6/storage.Storer

cmd/entire/cli/agent/claudecode/claude.go

@@ -3,11 +3,13 @@ package claudecode
 
 import (
 	"bufio"
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"regexp"
 	"time"
@@ -25,7 +27,11 @@ func init() {
 // ClaudeCodeAgent implements the Agent interface for Claude Code.
 //
 //nolint:revive // ClaudeCodeAgent is clearer than Agent in this context
-type ClaudeCodeAgent struct{}
+type ClaudeCodeAgent struct {
+	// CommandRunner allows injection of the command execution for testing.
+	// If nil, uses exec.CommandContext directly.
+	CommandRunner func(ctx context.Context, name string, args ...string) *exec.Cmd
+}
 
 // NewClaudeCodeAgent creates a new Claude Code agent instance.
 func NewClaudeCodeAgent() agent.Agent {

cmd/entire/cli/agent/claudecode/hooks.go

@@ -109,14 +109,15 @@ func (c *ClaudeCodeAgent) InstallHooks(localDev bool, force bool) (int, error) {
 		rawPermissions = make(map[string]json.RawMessage)
 	}
 
-	// Parse only the hook types we need to modify
+	// Parse only the hook types we need to modify.
+	// Track which types parsed successfully — unparseable types are left untouched.
 	var sessionStart, sessionEnd, stop, userPromptSubmit, preToolUse, postToolUse []ClaudeHookMatcher
-	parseHookType(rawHooks, "SessionStart", &sessionStart)
-	parseHookType(rawHooks, "SessionEnd", &sessionEnd)
-	parseHookType(rawHooks, "Stop", &stop)
-	parseHookType(rawHooks, "UserPromptSubmit", &userPromptSubmit)
-	parseHookType(rawHooks, "PreToolUse", &preToolUse)
-	parseHookType(rawHooks, "PostToolUse", &postToolUse)
+	parsedSessionStart := parseHookType(rawHooks, "SessionStart", &sessionStart)
+	parsedSessionEnd := parseHookType(rawHooks, "SessionEnd", &sessionEnd)
+	parsedStop := parseHookType(rawHooks, "Stop", &stop)
+	parsedUserPromptSubmit := parseHookType(rawHooks, "UserPromptSubmit", &userPromptSubmit)
+	parsedPreToolUse := parseHookType(rawHooks, "PreToolUse", &preToolUse)
+	parsedPostToolUse := parseHookType(rawHooks, "PostToolUse", &postToolUse)
 
 	// If force is true, remove all existing Entire hooks first
 	if force {
@@ -203,12 +204,12 @@ func (c *ClaudeCodeAgent) InstallHooks(localDev bool, force bool) (int, error) {
 	}
 
 	// Marshal modified hook types back to rawHooks
-	marshalHookType(rawHooks, "SessionStart", sessionStart)
-	marshalHookType(rawHooks, "SessionEnd", sessionEnd)
-	marshalHookType(rawHooks, "Stop", stop)
-	marshalHookType(rawHooks, "UserPromptSubmit", userPromptSubmit)
-	marshalHookType(rawHooks, "PreToolUse", preToolUse)
-	marshalHookType(rawHooks, "PostToolUse", postToolUse)
+	marshalHookType(rawHooks, "SessionStart", sessionStart, parsedSessionStart)
+	marshalHookType(rawHooks, "SessionEnd", sessionEnd, parsedSessionEnd)
+	marshalHookType(rawHooks, "Stop", stop, parsedStop)
+	marshalHookType(rawHooks, "UserPromptSubmit", userPromptSubmit, parsedUserPromptSubmit)
+	marshalHookType(rawHooks, "PreToolUse", preToolUse, parsedPreToolUse)
+	marshalHookType(rawHooks, "PostToolUse", postToolUse, parsedPostToolUse)
 
 	// Marshal hooks and update raw settings
 	hooksJSON, err := json.Marshal(rawHooks)
@@ -242,17 +243,25 @@ func (c *ClaudeCodeAgent) InstallHooks(localDev bool, force bool) (int, error) {
 }
 
 // parseHookType parses a specific hook type from rawHooks into the target slice.
-// Silently ignores parse errors (leaves target unchanged).
-func parseHookType(rawHooks map[string]json.RawMessage, hookType string, target *[]ClaudeHookMatcher) {
+// Returns true if the hook type was successfully parsed (or didn't exist).
+// Returns false if parsing failed — caller should NOT marshal this type back,
+// to avoid replacing the original (unparseable) data with an empty array.
+func parseHookType(rawHooks map[string]json.RawMessage, hookType string, target *[]ClaudeHookMatcher) bool {
 	if data, ok := rawHooks[hookType]; ok {
-		//nolint:errcheck,gosec // Intentionally ignoring parse errors - leave target as nil/empty
-		json.Unmarshal(data, target)
+		if err := json.Unmarshal(data, target); err != nil {
+			return false
+		}
 	}
+	return true
 }
 
 // marshalHookType marshals a hook type back to rawHooks.
+// If parsed is false, the original data couldn't be parsed and is left untouched.
 // If the slice is empty, removes the key from rawHooks.
-func marshalHookType(rawHooks map[string]json.RawMessage, hookType string, matchers []ClaudeHookMatcher) {
+func marshalHookType(rawHooks map[string]json.RawMessage, hookType string, matchers []ClaudeHookMatcher, parsed bool) {
+	if !parsed {
+		return // Don't overwrite unparseable data
+	}
 	if len(matchers) == 0 {
 		delete(rawHooks, hookType)
 		return
@@ -293,14 +302,15 @@ func (c *ClaudeCodeAgent) UninstallHooks() error {
 		rawHooks = make(map[string]json.RawMessage)
 	}
 
-	// Parse only the hook types we need to modify
+	// Parse only the hook types we need to modify.
+	// Track which types parsed successfully — unparseable types are left untouched.
 	var sessionStart, sessionEnd, stop, userPromptSubmit, preToolUse, postToolUse []ClaudeHookMatcher
-	parseHookType(rawHooks, "SessionStart", &sessionStart)
-	parseHookType(rawHooks, "SessionEnd", &sessionEnd)
-	parseHookType(rawHooks, "Stop", &stop)
-	parseHookType(rawHooks, "UserPromptSubmit", &userPromptSubmit)
-	parseHookType(rawHooks, "PreToolUse", &preToolUse)
-	parseHookType(rawHooks, "PostToolUse", &postToolUse)
+	parsedSessionStart := parseHookType(rawHooks, "SessionStart", &sessionStart)
+	parsedSessionEnd := parseHookType(rawHooks, "SessionEnd", &sessionEnd)
+	parsedStop := parseHookType(rawHooks, "Stop", &stop)
+	parsedUserPromptSubmit := parseHookType(rawHooks, "UserPromptSubmit", &userPromptSubmit)
+	parsedPreToolUse := parseHookType(rawHooks, "PreToolUse", &preToolUse)
+	parsedPostToolUse := parseHookType(rawHooks, "PostToolUse", &postToolUse)
 
 	// Remove Entire hooks from all hook types
 	sessionStart = removeEntireHooks(sessionStart)
@@ -311,12 +321,12 @@ func (c *ClaudeCodeAgent) UninstallHooks() error {
 	postToolUse = removeEntireHooksFromMatchers(postToolUse)
 
 	// Marshal modified hook types back to rawHooks
-	marshalHookType(rawHooks, "SessionStart", sessionStart)
-	marshalHookType(rawHooks, "SessionEnd", sessionEnd)
-	marshalHookType(rawHooks, "Stop", stop)
-	marshalHookType(rawHooks, "UserPromptSubmit", userPromptSubmit)
-	marshalHookType(rawHooks, "PreToolUse", preToolUse)
-	marshalHookType(rawHooks, "PostToolUse", postToolUse)
+	marshalHookType(rawHooks, "SessionStart", sessionStart, parsedSessionStart)
+	marshalHookType(rawHooks, "SessionEnd", sessionEnd, parsedSessionEnd)
+	marshalHookType(rawHooks, "Stop", stop, parsedStop)
+	marshalHookType(rawHooks, "UserPromptSubmit", userPromptSubmit, parsedUserPromptSubmit)
+	marshalHookType(rawHooks, "PreToolUse", preToolUse, parsedPreToolUse)
+	marshalHookType(rawHooks, "PostToolUse", postToolUse, parsedPostToolUse)
 
 	// Also remove the metadata deny rule from permissions
 	var rawPermissions map[string]json.RawMessage

cmd/entire/cli/agent/claudecode/prompter.go

@@ -0,0 +1,89 @@
+package claudecode
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/entireio/cli/cmd/entire/cli/agent"
+)
+
+// Compile-time assertion that ClaudeCodeAgent implements agent.Prompter.
+var _ agent.Prompter = (*ClaudeCodeAgent)(nil)
+
+// CLICommand returns the CLI executable name for Claude Code.
+func (c *ClaudeCodeAgent) CLICommand() string {
+	return "claude"
+}
+
+// Prompt sends a prompt to the Claude CLI and returns the text response.
+func (c *ClaudeCodeAgent) Prompt(ctx context.Context, prompt string, opts agent.PromptOptions) (*agent.PromptResult, error) {
+	args := []string{"--print", "--setting-sources", ""}
+
+	outputFormat := opts.OutputFormat
+	if outputFormat == "" {
+		outputFormat = "json"
+	}
+	args = append(args, "--output-format", outputFormat)
+
+	if opts.Model != "" {
+		args = append(args, "--model", opts.Model)
+	}
+	if opts.AllowedTools != "" {
+		args = append(args, "--allowedTools", opts.AllowedTools)
+	}
+	if opts.PermissionMode != "" {
+		args = append(args, "--permission-mode", opts.PermissionMode)
+	}
+
+	runner := c.CommandRunner
+	if runner == nil {
+		runner = exec.CommandContext
+	}
+
+	cmd := runner(ctx, c.CLICommand(), args...)
+
+	// Working directory
+	if opts.WorkDir != "" {
+		cmd.Dir = opts.WorkDir
+	} else {
+		cmd.Dir = os.TempDir()
+	}
+
+	// Environment isolation
+	isolate := true
+	if opts.IsolateFromGit != nil {
+		isolate = *opts.IsolateFromGit
+	}
+	if isolate {
+		cmd.Env = agent.StripGitEnv(os.Environ())
+	} else {
+		cmd.Env = os.Environ()
+	}
+	cmd.Env = append(cmd.Env, opts.ExtraEnv...)
+
+	cmd.Stdin = strings.NewReader(prompt)
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		return nil, fmt.Errorf("claude prompt failed: %w", agent.FormatExecError(err, "claude", stderr.String()))
+	}
+
+	// Parse response based on output format
+	if outputFormat == "json" {
+		var cliResp agent.CLIResponse
+		if err := json.Unmarshal(stdout.Bytes(), &cliResp); err != nil {
+			return nil, fmt.Errorf("failed to parse claude CLI response: %w", err)
+		}
+		return &agent.PromptResult{Text: cliResp.Result}, nil
+	}
+
+	return &agent.PromptResult{Text: stdout.String()}, nil
+}