@tanagram/cli 0.4.2 → 0.4.4

package/commands/config_test.go

@@ -0,0 +1,389 @@
+package commands
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestConfigClaude(t *testing.T) {
+	// Create a temporary directory
+	tempDir, err := os.MkdirTemp("", "tanagram-config-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	settingsPath := filepath.Join(tempDir, ".claude", "settings.json")
+
+	// Redirect stdout to suppress logs
+	oldStdout := os.Stdout
+	_, w, _ := os.Pipe()
+	os.Stdout = w
+	defer func() {
+		os.Stdout = oldStdout
+	}()
+
+	t.Run("Create new config", func(t *testing.T) {
+		if err := ConfigClaude(settingsPath); err != nil {
+			t.Fatalf("ConfigClaude() failed: %v", err)
+		}
+
+		settings := readSettings(t, settingsPath)
+		pre, post := checkHooks(settings)
+		if !pre {
+			t.Error("PreToolUse hook not created")
+		}
+		if !post {
+			t.Error("PostToolUse hook not created")
+		}
+	})
+
+	t.Run("Idempotency", func(t *testing.T) {
+		// Run it again (first time was in "Create new config")
+		if err := ConfigClaude(settingsPath); err != nil {
+			t.Fatalf("ConfigClaude() failed on second run: %v", err)
+		}
+
+		settings := readSettings(t, settingsPath)
+		pre, post := checkHooks(settings)
+		if !pre || !post {
+			t.Error("Hooks missing after second run")
+		}
+
+		// Check that we didn't duplicate them (rudimentary check: count of items)
+		hooks := settings["hooks"].(map[string]interface{})
+		preToolUse := hooks["PreToolUse"].([]interface{})
+		postToolUse := hooks["PostToolUse"].([]interface{})
+
+		// We expect exactly 1 hook in each since we started fresh
+		if len(preToolUse) != 1 {
+			t.Errorf("Expected 1 PreToolUse hook, got %d", len(preToolUse))
+		}
+		if len(postToolUse) != 1 {
+			t.Errorf("Expected 1 PostToolUse hook, got %d", len(postToolUse))
+		}
+	})
+
+	t.Run("Preserve existing hooks", func(t *testing.T) {
+		// Reset with a file that has other hooks
+		otherHook := map[string]interface{}{
+			"hooks": map[string]interface{}{
+				"PreToolUse": []interface{}{
+					map[string]interface{}{
+						"matcher": "Read",
+						"hooks": []interface{}{
+							map[string]interface{}{"command": "echo existing"},
+						},
+					},
+				},
+			},
+		}
+
+		// Clean up previous run
+		os.RemoveAll(filepath.Dir(settingsPath))
+
+		dir := filepath.Dir(settingsPath)
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			t.Fatalf("Failed to create dir: %v", err)
+		}
+
+		// Write otherHook to settingsPath
+		data, _ := json.Marshal(otherHook)
+		if err := os.WriteFile(settingsPath, data, 0644); err != nil {
+			t.Fatalf("Failed to write settings: %v", err)
+		}
+
+		if err := ConfigClaude(settingsPath); err != nil {
+			t.Fatalf("ConfigClaude() failed: %v", err)
+		}
+
+		settings := readSettings(t, settingsPath)
+		pre, post := checkHooks(settings)
+		if !pre || !post {
+			t.Error("Tanagram hooks missing when merging with existing config")
+		}
+
+		// Check if existing hook is still there
+		hooks := settings["hooks"].(map[string]interface{})
+		preToolUse := hooks["PreToolUse"].([]interface{})
+
+		foundExisting := false
+		for _, h := range preToolUse {
+			hMap := h.(map[string]interface{})
+			if hMap["matcher"] == "Read" {
+				// Check for the specific command to be sure it's the right one
+				if commands, ok := hMap["hooks"].([]interface{}); ok {
+					for _, cmd := range commands {
+						if cmdMap, ok := cmd.(map[string]interface{}); ok {
+							if cmdMap["command"] == "echo existing" {
+								foundExisting = true
+								break
+							}
+						}
+					}
+				}
+			}
+			if foundExisting {
+				break
+			}
+		}
+		if !foundExisting {
+			t.Error("Existing hook was lost")
+		}
+	})
+}
+
+func TestConfigCursor(t *testing.T) {
+	// Create a temporary directory
+	tempDir, err := os.MkdirTemp("", "tanagram-cursor-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	hooksPath := filepath.Join(tempDir, ".cursor", "hooks.json")
+
+	// Redirect stdout to suppress logs
+	oldStdout := os.Stdout
+	_, w, _ := os.Pipe()
+	os.Stdout = w
+	defer func() {
+		os.Stdout = oldStdout
+	}()
+
+	t.Run("Create new config", func(t *testing.T) {
+		if err := ConfigCursor(hooksPath); err != nil {
+			t.Fatalf("ConfigCursor() failed: %v", err)
+		}
+
+		settings := readSettings(t, hooksPath)
+		beforeSubmit, stop := checkCursorHooks(settings)
+		if !beforeSubmit {
+			t.Error("beforeSubmitPrompt hook not created")
+		}
+		if !stop {
+			t.Error("stop hook not created")
+		}
+	})
+
+	t.Run("Idempotency", func(t *testing.T) {
+		// Run it again
+		if err := ConfigCursor(hooksPath); err != nil {
+			t.Fatalf("ConfigCursor() failed on second run: %v", err)
+		}
+
+		settings := readSettings(t, hooksPath)
+		beforeSubmit, stop := checkCursorHooks(settings)
+		if !beforeSubmit || !stop {
+			t.Error("Hooks missing after second run")
+		}
+
+		// Check duplicates
+		hooks := settings["hooks"].(map[string]interface{})
+		beforeSubmitHooks := hooks["beforeSubmitPrompt"].([]interface{})
+		stopHooks := hooks["stop"].([]interface{})
+
+		if len(beforeSubmitHooks) != 1 {
+			t.Errorf("Expected 1 beforeSubmitPrompt hook, got %d", len(beforeSubmitHooks))
+		}
+		if len(stopHooks) != 1 {
+			t.Errorf("Expected 1 stop hook, got %d", len(stopHooks))
+		}
+	})
+
+	t.Run("Preserve existing hooks", func(t *testing.T) {
+		// Reset with a file that has other hooks
+		otherHook := map[string]interface{}{
+			"hooks": map[string]interface{}{
+				"beforeSubmitPrompt": []interface{}{
+					map[string]interface{}{"command": "echo existing"},
+				},
+			},
+		}
+
+		// Clean up previous run
+		os.RemoveAll(filepath.Dir(hooksPath))
+
+		dir := filepath.Dir(hooksPath)
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			t.Fatalf("Failed to create dir: %v", err)
+		}
+
+		// Write otherHook to hooksPath
+		data, _ := json.Marshal(otherHook)
+		if err := os.WriteFile(hooksPath, data, 0644); err != nil {
+			t.Fatalf("Failed to write settings: %v", err)
+		}
+
+		if err := ConfigCursor(hooksPath); err != nil {
+			t.Fatalf("ConfigCursor() failed: %v", err)
+		}
+
+		settings := readSettings(t, hooksPath)
+		beforeSubmit, stop := checkCursorHooks(settings)
+		if !beforeSubmit || !stop {
+			t.Error("Tanagram hooks missing when merging with existing config")
+		}
+
+		// Check if existing hook is still there
+		hooks := settings["hooks"].(map[string]interface{})
+		beforeSubmitHooks := hooks["beforeSubmitPrompt"].([]interface{})
+
+		foundExisting := false
+		for _, h := range beforeSubmitHooks {
+			hMap := h.(map[string]interface{})
+			if cmd, ok := hMap["command"].(string); ok && cmd == "echo existing" {
+				foundExisting = true
+				break
+			}
+		}
+		if !foundExisting {
+			t.Error("Existing hook was lost")
+		}
+	})
+}
+
+func TestEnsureHooksConfigured(t *testing.T) {
+	// Create a temporary home directory
+	tempHome, err := os.MkdirTemp("", "tanagram-home-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp home: %v", err)
+	}
+	defer os.RemoveAll(tempHome)
+
+	// Mock HOME environment variable
+	originalHome := os.Getenv("HOME")
+	defer os.Setenv("HOME", originalHome)
+	os.Setenv("HOME", tempHome)
+
+	// Redirect stdout/stderr to suppress logs
+	oldStdout := os.Stdout
+	oldStderr := os.Stderr
+	_, w, _ := os.Pipe()
+	os.Stdout = w
+	os.Stderr = w
+	defer func() {
+		os.Stdout = oldStdout
+		os.Stderr = oldStderr
+	}()
+
+	t.Run("Fresh configuration", func(t *testing.T) {
+		if err := EnsureHooksConfigured(); err != nil {
+			t.Fatalf("EnsureHooksConfigured() failed: %v", err)
+		}
+
+		// Check Claude settings
+		claudeSettingsPath := filepath.Join(tempHome, ".claude", "settings.json")
+		claudeSettings := readSettings(t, claudeSettingsPath)
+		pre, post := checkHooks(claudeSettings)
+		if !pre {
+			t.Error("PreToolUse hook not created")
+		}
+		if !post {
+			t.Error("PostToolUse hook not created")
+		}
+
+		// Check Cursor hooks
+		cursorHooksPath := filepath.Join(tempHome, ".cursor", "hooks.json")
+		cursorSettings := readSettings(t, cursorHooksPath)
+		beforeSubmit, stop := checkCursorHooks(cursorSettings)
+		if !beforeSubmit {
+			t.Error("beforeSubmitPrompt hook not created")
+		}
+		if !stop {
+			t.Error("stop hook not created")
+		}
+	})
+}
+
+func readSettings(t *testing.T, settingsPath string) map[string]interface{} {
+	data, err := os.ReadFile(settingsPath)
+	if err != nil {
+		t.Fatalf("Failed to read settings file: %v", err)
+	}
+	var settings map[string]interface{}
+	if err := json.Unmarshal(data, &settings); err != nil {
+		t.Fatalf("Failed to parse settings JSON: %v", err)
+	}
+	return settings
+}
+
+func checkHooks(settings map[string]interface{}) (bool, bool) {
+	hooks, ok := settings["hooks"].(map[string]interface{})
+	if !ok {
+		return false, false
+	}
+
+	preExists := false
+	if preToolUse, ok := hooks["PreToolUse"].([]interface{}); ok {
+		for _, h := range preToolUse {
+			if hMap, ok := h.(map[string]interface{}); ok {
+				if hMap["matcher"] == "Edit|Write" {
+					if innerHooks, ok := hMap["hooks"].([]interface{}); ok {
+						for _, ih := range innerHooks {
+							if ihMap, ok := ih.(map[string]interface{}); ok {
+								if ihMap["command"] == "tanagram snapshot" {
+									preExists = true
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	postExists := false
+	if postToolUse, ok := hooks["PostToolUse"].([]interface{}); ok {
+		for _, h := range postToolUse {
+			if hMap, ok := h.(map[string]interface{}); ok {
+				if hMap["matcher"] == "Edit|Write" {
+					if innerHooks, ok := hMap["hooks"].([]interface{}); ok {
+						for _, ih := range innerHooks {
+							if ihMap, ok := ih.(map[string]interface{}); ok {
+								if ihMap["command"] == "tanagram" {
+									postExists = true
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return preExists, postExists
+}
+
+func checkCursorHooks(settings map[string]interface{}) (bool, bool) {
+	hooks, ok := settings["hooks"].(map[string]interface{})
+	if !ok {
+		return false, false
+	}
+
+	beforeSubmitExists := false
+	if beforeSubmit, ok := hooks["beforeSubmitPrompt"].([]interface{}); ok {
+		for _, h := range beforeSubmit {
+			if hMap, ok := h.(map[string]interface{}); ok {
+				if cmd, ok := hMap["command"].(string); ok && cmd == "tanagram snapshot" {
+					beforeSubmitExists = true
+				}
+			}
+		}
+	}
+
+	stopExists := false
+	if stop, ok := hooks["stop"].([]interface{}); ok {
+		for _, h := range stop {
+			if hMap, ok := h.(map[string]interface{}); ok {
+				if cmd, ok := hMap["command"].(string); ok && cmd == "tanagram" {
+					stopExists = true
+				}
+			}
+		}
+	}
+
+	return beforeSubmitExists, stopExists
+}

package/commands/run.go

@@ -26,10 +26,10 @@ func spinner(stop chan bool, message string) {
 	for {
 		select {
 		case <-stop:
-			fmt.Print("\r")
+			fmt.Fprint(os.Stderr, "\r")
 			return
 		default:
-			fmt.Printf("\r%s %s", chars[i%len(chars)], message)
+			fmt.Fprintf(os.Stderr, "\r%s %s", chars[i%len(chars)], message)
 			i++
 			time.Sleep(100 * time.Millisecond)
 		}
@@ -80,7 +80,7 @@ func Run() error {
 			return err
 		}
 
-		fmt.Printf("\nSyncing policies with LLM (processing %d changed file(s) in parallel)...\n", len(filesToSync))
+		fmt.Fprintf(os.Stderr, "\nSyncing policies with LLM (processing %d changed file(s) in parallel)...\n", len(filesToSync))
 
 		syncStart := time.Now()
 		ctx := context.Background()
@@ -107,13 +107,13 @@ func Run() error {
 			for {
 				select {
 				case <-stop:
-					fmt.Print("\r")
+					fmt.Fprint(os.Stderr, "\r")
 					return
 				default:
 					mu.Lock()
 					c := completed
 					mu.Unlock()
-					fmt.Printf("\r%s Processing files... (%d/%d completed)", chars[i%len(chars)], c, len(filesToSync))
+					fmt.Fprintf(os.Stderr, "\r%s Processing files... (%d/%d completed)", chars[i%len(chars)], c, len(filesToSync))
 					i++
 					time.Sleep(100 * time.Millisecond)
 				}
@@ -145,7 +145,7 @@ func Run() error {
 				close(stop)
 				time.Sleep(50 * time.Millisecond)
 				mu.Lock()
-				fmt.Printf("\r\033[K✗ Failed to process %s\n", result.relPath)
+				fmt.Fprintf(os.Stderr, "\r\033[K✗ Failed to process %s\n", result.relPath)
 				mu.Unlock()
 				return fmt.Errorf("failed to extract policies from %s: %w", result.file, result.err)
 			}
@@ -162,7 +162,7 @@ func Run() error {
 			// Atomic update of counter and output (prevents race with spinner)
 			mu.Lock()
 			completed++
-			fmt.Printf("\r\033[K✓ %s - %d policies\n", result.relPath, len(result.policies))
+			fmt.Fprintf(os.Stderr, "\r\033[K✓ %s - %d policies\n", result.relPath, len(result.policies))
 			mu.Unlock()
 		}
 
@@ -176,7 +176,7 @@ func Run() error {
 		}
 
 		syncDuration := time.Since(syncStart)
-		fmt.Printf("\n✓ Synced %d policies from %d changed file(s)\n", totalPolicies, len(filesToSync))
+		fmt.Fprintf(os.Stderr, "\n✓ Synced %d policies from %d changed file(s)\n", totalPolicies, len(filesToSync))
 
 		// Track sync metrics
 		metrics.Track("cli.sync.complete", map[string]interface{}{
@@ -202,10 +202,10 @@ func Run() error {
 		cloudPolicies, err = cloudStorage.LoadCloudPoliciesAsParserFormat(repoInfo.Owner, repoInfo.Name)
 		if err != nil {
 			// Cloud policies exist but failed to load - warn but continue
-			fmt.Printf("Warning: Failed to load cloud policies: %v\n", err)
+			fmt.Fprintf(os.Stderr, "Warning: Failed to load cloud policies: %v\n", err)
 			cloudPolicies = []parser.Policy{}
 		} else if len(cloudPolicies) > 0 {
-			fmt.Printf("Loaded %d cloud policies for %s/%s\n", len(cloudPolicies), repoInfo.Owner, repoInfo.Name)
+			fmt.Fprintf(os.Stderr, "Loaded %d cloud policies for %s/%s\n", len(cloudPolicies), repoInfo.Owner, repoInfo.Name)
 		}
 	}
 	// If repo detection failed, silently continue with local-only policies
@@ -214,7 +214,7 @@ func Run() error {
 	policies := storage.MergePolicies(localPolicies, cloudPolicies)
 
 	if len(policies) == 0 {
-		fmt.Println("No enforceable policies found")
+		fmt.Fprintln(os.Stderr, "No enforceable policies found")
 		return nil
 	}
 
@@ -223,9 +223,9 @@ func Run() error {
 	totalMerged := len(policies)
 
 	if totalCloud > 0 {
-		fmt.Printf("Total policies: %d (%d local, %d cloud, %d after merge)\n", totalMerged, totalLocal, totalCloud, totalMerged)
+		fmt.Fprintf(os.Stderr, "Total policies: %d (%d local, %d cloud, %d after merge)\n", totalMerged, totalLocal, totalCloud, totalMerged)
 	} else {
-		fmt.Printf("Loaded %d local policies\n", totalLocal)
+		fmt.Fprintf(os.Stderr, "Loaded %d local policies\n", totalLocal)
 	}
 
 	// Check if a snapshot exists (from PreToolUse hook)
@@ -233,7 +233,7 @@ func Run() error {
 	useSnapshot := false
 
 	if snapshot.Exists(gitRoot) {
-		fmt.Println("Snapshot detected - checking only Claude's changes...")
+		fmt.Fprintln(os.Stderr, "Snapshot detected - checking only Claude's changes...")
 
 		// Load snapshot
 		snap, err := snapshot.Load(gitRoot)
@@ -271,7 +271,7 @@ func Run() error {
 		useSnapshot = true
 	} else {
 		// No snapshot - fall back to checking all git changes
-		fmt.Println("Checking all changes (unstaged + staged)...")
+		fmt.Fprintln(os.Stderr, "Checking all changes (unstaged + staged)...")
 		diffResult, err := gitpkg.GetAllChanges()
 		if err != nil {
 			return fmt.Errorf("error getting git diff: %w", err)
@@ -282,14 +282,14 @@ func Run() error {
 
 	if len(changesToCheck) == 0 {
 		if useSnapshot {
-			fmt.Println("No changes detected since snapshot")
+			fmt.Fprintln(os.Stderr, "No changes detected since snapshot")
 		} else {
-			fmt.Println("No changes to check")
+			fmt.Fprintln(os.Stderr, "No changes to check")
 		}
 		return nil
 	}
 
-	fmt.Printf("Scanning %d changed lines...\n\n", len(changesToCheck))
+	fmt.Fprintf(os.Stderr, "Scanning %d changed lines...\n\n", len(changesToCheck))
 
 	// Get API key once upfront before checking
 	apiKey, err := config.GetAPIKey()
@@ -325,6 +325,10 @@ func Run() error {
 
 			// Exit with code 2 to trigger Claude Code hook behavior
 			os.Exit(2)
+		} else if parentProcess == "cursor" {
+			// Format and output Cursor-friendly instructions to stdout
+			cursorInstructions := checker.FormatCursorInstructions(result)
+			fmt.Fprint(os.Stdout, cursorInstructions)
 		} else {
 			// Format and output violations to stderr
 			violationOutput := checker.FormatViolations(result)
@@ -333,6 +337,6 @@ func Run() error {
 	}
 
 	// No violations found - output success message
-	fmt.Println("✓ No policy violations found")
+	fmt.Fprintln(os.Stderr, "✓ No policy violations found")
 	return nil
 }

package/commands/snapshot.go

@@ -5,21 +5,33 @@ import (
 
 	"github.com/tanagram/cli/snapshot"
 	"github.com/tanagram/cli/storage"
+	"github.com/tanagram/cli/utils"
+)
+
+// Extracted variables so that tests can override these
+var (
+	findGitRoot      = storage.FindGitRoot
+	createSnapshot   = snapshot.Create
+	getParentProcess = utils.GetParentProcess
 )
 
 // Snapshot creates a snapshot of the current working directory state
 func Snapshot() error {
 	// Find git root
-	gitRoot, err := storage.FindGitRoot()
+	gitRoot, err := findGitRoot()
 	if err != nil {
 		return err
 	}
 
 	// Create snapshot
-	if err := snapshot.Create(gitRoot); err != nil {
+	if err := createSnapshot(gitRoot); err != nil {
 		return fmt.Errorf("failed to create snapshot: %w", err)
 	}
 
-	// Silent success - no output for hooks
+	parentProcess := getParentProcess()
+	if parentProcess == "Cursor" || parentProcess == "cursor" {
+		// https://cursor.com/docs/agent/hooks#beforesubmitprompt
+		fmt.Println(`{ "continue": true }`)
+	}
 	return nil
 }

package/commands/snapshot_test.go

@@ -0,0 +1,88 @@
+package commands
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"testing"
+)
+
+func TestSnapshot_Cursor(t *testing.T) {
+	// Save original functions
+	origFindGitRoot := findGitRoot
+	origCreateSnapshot := createSnapshot
+	origGetParentProcess := getParentProcess
+	defer func() {
+		findGitRoot = origFindGitRoot
+		createSnapshot = origCreateSnapshot
+		getParentProcess = origGetParentProcess
+	}()
+
+	// Mock functions
+	findGitRoot = func() (string, error) {
+		return "/tmp/mock-git-root", nil
+	}
+	createSnapshot = func(root string) error {
+		return nil
+	}
+
+	tests := []struct {
+		name           string
+		parentProcess  string
+		expectedOutput string
+	}{
+		{
+			name:           "Cursor process",
+			parentProcess:  "Cursor",
+			expectedOutput: "{ \"continue\": true }\n",
+		},
+		{
+			name:           "cursor process lowercase",
+			parentProcess:  "cursor",
+			expectedOutput: "{ \"continue\": true }\n",
+		},
+		{
+			name:           "Claude",
+			parentProcess:  "claude",
+			expectedOutput: "",
+		},
+		{
+			name:           "Terminal process",
+			parentProcess:  "zsh",
+			expectedOutput: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Set mock
+			getParentProcess = func() string {
+				return tt.parentProcess
+			}
+
+			// Capture stdout
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			err := Snapshot()
+
+			// Restore stdout
+			w.Close()
+			os.Stdout = oldStdout
+
+			// Read captured output
+			var buf bytes.Buffer
+			io.Copy(&buf, r)
+			output := buf.String()
+
+			if err != nil {
+				t.Errorf("Snapshot() returned unexpected error: %v", err)
+			}
+
+			if output != tt.expectedOutput {
+				t.Errorf("Expected output %q, got %q", tt.expectedOutput, output)
+			}
+		})
+	}
+}