@tanagram/cli 0.4.2 → 0.4.3

package/commands/config.go

@@ -8,34 +8,11 @@ import (
 	"strings"
 )
 
-// ConfigClaude sets up the Claude Code hook in ~/.claude/settings.json
-func ConfigClaude() error {
-	// Get the Claude settings file path
-	home, err := os.UserHomeDir()
+// ConfigClaude sets up the Claude Code hook in the specified settings file
+func ConfigClaude(settingsPath string) error {
+	settings, err := loadConfig(settingsPath)
 	if err != nil {
-		return fmt.Errorf("failed to get home directory: %w", err)
-	}
-
-	settingsPath := filepath.Join(home, ".claude", "settings.json")
-
-	// Read existing settings or create new structure
-	var settings map[string]interface{}
-
-	// Check if file exists
-	if _, err := os.Stat(settingsPath); os.IsNotExist(err) {
-		// File doesn't exist, create new settings
-		settings = make(map[string]interface{})
-	} else {
-		// File exists, read it
-		data, err := os.ReadFile(settingsPath)
-		if err != nil {
-			return fmt.Errorf("failed to read Claude settings: %w", err)
-		}
-
-		// Parse JSON
-		if err := json.Unmarshal(data, &settings); err != nil {
-			return fmt.Errorf("failed to parse Claude settings (invalid JSON): %w", err)
-		}
+		return fmt.Errorf("failed to load Claude settings: %w", err)
 	}
 
 	// Check if hooks already exist
@@ -102,6 +79,7 @@ func ConfigClaude() error {
 					}
 				}
 			}
+
 		}
 	}
 
@@ -138,20 +116,8 @@ func ConfigClaude() error {
 		hooks["PostToolUse"] = postToolUse
 	}
 
-	// Ensure .claude directory exists
-	claudeDir := filepath.Join(home, ".claude")
-	if err := os.MkdirAll(claudeDir, 0755); err != nil {
-		return fmt.Errorf("failed to create .claude directory: %w", err)
-	}
-
-	// Write updated settings back to file
-	data, err := json.MarshalIndent(settings, "", "  ")
-	if err != nil {
-		return fmt.Errorf("failed to marshal settings: %w", err)
-	}
-
-	if err := os.WriteFile(settingsPath, data, 0644); err != nil {
-		return fmt.Errorf("failed to write settings: %w", err)
+	if err := saveConfig(settingsPath, settings); err != nil {
+		return fmt.Errorf("failed to save settings: %w", err)
 	}
 
 	fmt.Println("✓ Tanagram hooks added to ~/.claude/settings.json")
@@ -164,35 +130,140 @@ func ConfigClaude() error {
 	return nil
 }
 
-// ConfigList shows where Tanagram hooks are installed
-func ConfigList() error {
-	home, err := os.UserHomeDir()
+// ConfigCursor sets up the Cursor hook in the specified settings file
+func ConfigCursor(hooksPath string) error {
+
+	hooksConfig, err := loadConfig(hooksPath)
 	if err != nil {
-		return fmt.Errorf("failed to get home directory: %w", err)
+		return fmt.Errorf("failed to load Cursor hooks: %w", err)
+	}
+
+	// Ensure version field exists
+	if _, ok := hooksConfig["version"]; !ok {
+		hooksConfig["version"] = 1
+	}
+
+	// Check if hooks object exists
+	hooks, hooksExist := hooksConfig["hooks"].(map[string]interface{})
+	if !hooksExist {
+		hooks = make(map[string]interface{})
+		hooksConfig["hooks"] = hooks
+	}
+
+	// Check if beforeSubmitPrompt exists
+	beforeSubmitPrompt, beforeSubmitExists := hooks["beforeSubmitPrompt"].([]interface{})
+	if !beforeSubmitExists {
+		beforeSubmitPrompt = []interface{}{}
 	}
 
+	// Check if stop exists
+	stopHooks, stopExists := hooks["stop"].([]interface{})
+	if !stopExists {
+		stopHooks = []interface{}{}
+	}
+
+	// Check if tanagram hooks already exist
+	beforeSubmitHookExists := false
+	stopHookExists := false
+
+	for _, hook := range beforeSubmitPrompt {
+		hookMap, ok := hook.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		if cmd, ok := hookMap["command"].(string); ok && cmd == "tanagram snapshot" {
+			beforeSubmitHookExists = true
+			break
+		}
+	}
+
+	for _, hook := range stopHooks {
+		hookMap, ok := hook.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		if cmd, ok := hookMap["command"].(string); ok && cmd == "tanagram" {
+			stopHookExists = true
+			break
+		}
+	}
+
+	if beforeSubmitHookExists && stopHookExists {
+		fmt.Println("✓ Tanagram hooks are already configured in ~/.cursor/hooks.json")
+		return nil
+	}
+
+	if !beforeSubmitHookExists {
+		beforeSubmitHook := map[string]interface{}{
+			"command": "tanagram snapshot",
+		}
+		beforeSubmitPrompt = append(beforeSubmitPrompt, beforeSubmitHook)
+		hooks["beforeSubmitPrompt"] = beforeSubmitPrompt
+	}
+
+	if !stopHookExists {
+		stopHook := map[string]interface{}{
+			"command": "tanagram",
+		}
+		stopHooks = append(stopHooks, stopHook)
+		hooks["stop"] = stopHooks
+	}
+
+	if err := saveConfig(hooksPath, hooksConfig); err != nil {
+		return fmt.Errorf("failed to save hooks: %w", err)
+	}
+
+	fmt.Println("✓ Tanagram hooks added to ~/.cursor/hooks.json")
+	fmt.Println("\nCursor will now:")
+	fmt.Println("  - Snapshot file state before each prompt (beforeSubmitPrompt)")
+	fmt.Println("  - Check only Cursor's changes after agent completes (stop)")
+	fmt.Println("  - Send policy violations to Cursor for automatic fixing")
+	fmt.Println("\nThis prevents false positives from user-written code!")
+
+	return nil
+}
+
+// ConfigList shows where Tanagram hooks are installed
+func ConfigList() error {
 	// Check user settings (~/.claude/settings.json)
-	userSettingsPath := filepath.Join(home, ".claude", "settings.json")
-	userStatus := checkHookStatus(userSettingsPath)
+	userSettingsPath, err := GetHomeConfigPath(".claude", "settings.json")
+	if err != nil {
+		return err
+	}
+	userStatus := checkClaudeHookStatus(userSettingsPath)
 
 	// Check project settings (./.claude/settings.json)
 	projectSettingsPath := ".claude/settings.json"
-	projectStatus := checkHookStatus(projectSettingsPath)
+	projectStatus := checkClaudeHookStatus(projectSettingsPath)
+
+	// Check Cursor hooks (~/.cursor/hooks.json)
+	cursorHooksPath, err := GetHomeConfigPath(".cursor", "hooks.json")
+	if err != nil {
+		return err
+	}
+	cursorStatus := checkCursorHookStatus(cursorHooksPath)
 
 	// Print results
 	fmt.Println("Claude Code Hook Status:")
 
 	fmt.Printf("User Settings (~/.claude/settings.json):\n")
-	printHookStatus(userStatus, userSettingsPath)
+	printClaudeHookStatus(userStatus, userSettingsPath)
 
 	fmt.Printf("\nProject Settings (./.claude/settings.json):\n")
-	printHookStatus(projectStatus, projectSettingsPath)
+	printClaudeHookStatus(projectStatus, projectSettingsPath)
+
+	fmt.Println("\nCursor Hook Status:")
+
+	fmt.Printf("User Settings (~/.cursor/hooks.json):\n")
+	printCursorHookStatus(cursorStatus, cursorHooksPath)
 
 	return nil
 }
 
-// HookStatus represents the status of a hook configuration
-type HookStatus struct {
+// ClaudeHookStatus represents the status of a hook configuration
+type ClaudeHookStatus struct {
 	FileExists     bool
 	PreHookExists  bool
 	PostHookExists bool
@@ -202,9 +273,20 @@ type HookStatus struct {
 	Error          error
 }
 
-// checkHookStatus checks the status of Tanagram hook in a settings file
-func checkHookStatus(settingsPath string) HookStatus {
-	status := HookStatus{
+// CursorHookStatus represents the status of a Cursor hook configuration
+type CursorHookStatus struct {
+	FileExists          bool
+	BeforeSubmitExists  bool
+	StopExists          bool
+	IsUpToDate          bool
+	BeforeSubmitCommand string
+	StopCommand         string
+	Error               error
+}
+
+// checkClaudeHookStatus checks the status of Tanagram hook in a settings file
+func checkClaudeHookStatus(settingsPath string) ClaudeHookStatus {
+	status := ClaudeHookStatus{
 		FileExists:     false,
 		PreHookExists:  false,
 		PostHookExists: false,
@@ -220,18 +302,12 @@ func checkHookStatus(settingsPath string) HookStatus {
 
 	status.FileExists = true
 
-	data, err := os.ReadFile(settingsPath)
+	settings, err := loadConfig(settingsPath)
 	if err != nil {
 		status.Error = err
 		return status
 	}
 
-	var settings map[string]interface{}
-	if err := json.Unmarshal(data, &settings); err != nil {
-		status.Error = fmt.Errorf("invalid JSON: %w", err)
-		return status
-	}
-
 	hooks, ok := settings["hooks"].(map[string]interface{})
 	if !ok {
 		return status
@@ -310,8 +386,74 @@ func checkHookStatus(settingsPath string) HookStatus {
 	return status
 }
 
-// printHookStatus prints the status of a hook in a human-readable format
-func printHookStatus(status HookStatus, path string) {
+// checkCursorHookStatus checks the status of Tanagram hooks in a Cursor hooks.json file
+func checkCursorHookStatus(hooksPath string) CursorHookStatus {
+	status := CursorHookStatus{
+		FileExists:          false,
+		BeforeSubmitExists:  false,
+		StopExists:          false,
+		IsUpToDate:          false,
+		BeforeSubmitCommand: "",
+		StopCommand:         "",
+		Error:               nil,
+	}
+
+	if _, err := os.Stat(hooksPath); os.IsNotExist(err) {
+		return status
+	}
+
+	status.FileExists = true
+
+	hooksConfig, err := loadConfig(hooksPath)
+	if err != nil {
+		status.Error = err
+		return status
+	}
+
+	hooks, ok := hooksConfig["hooks"].(map[string]interface{})
+	if !ok {
+		return status
+	}
+
+	if beforeSubmitPrompt, ok := hooks["beforeSubmitPrompt"].([]interface{}); ok {
+		for _, hook := range beforeSubmitPrompt {
+			hookMap, ok := hook.(map[string]interface{})
+			if !ok {
+				continue
+			}
+
+			cmd, cmdOk := hookMap["command"].(string)
+			if cmdOk && cmd == "tanagram snapshot" {
+				status.BeforeSubmitExists = true
+				status.BeforeSubmitCommand = cmd
+			}
+		}
+	}
+
+	if stopHooks, ok := hooks["stop"].([]interface{}); ok {
+		for _, hook := range stopHooks {
+			hookMap, ok := hook.(map[string]interface{})
+			if !ok {
+				continue
+			}
+
+			cmd, cmdOk := hookMap["command"].(string)
+			if cmdOk && cmd == "tanagram" {
+				status.StopExists = true
+				status.StopCommand = cmd
+			}
+		}
+	}
+
+	if status.BeforeSubmitExists && status.StopExists {
+		status.IsUpToDate = true
+	}
+
+	return status
+}
+
+// printClaudeHookStatus prints the status of a hook in a human-readable format
+func printClaudeHookStatus(status ClaudeHookStatus, path string) {
 	if status.Error != nil {
 		fmt.Printf("  ✗ Error: %v\n", status.Error)
 		return
@@ -350,18 +492,57 @@ func printHookStatus(status HookStatus, path string) {
 	}
 }
 
-// EnsureClaudeConfigured checks if Claude Code hooks are configured,
+// printCursorHookStatus prints the status of a Cursor hook in a human-readable format
+func printCursorHookStatus(status CursorHookStatus, path string) {
+	if status.Error != nil {
+		fmt.Printf("  ✗ Error: %v\n", status.Error)
+		return
+	}
+
+	if !status.FileExists {
+		fmt.Printf("  ○ Not configured (file does not exist)\n")
+		fmt.Printf("  → Run: tanagram config cursor\n")
+		return
+	}
+
+	if !status.BeforeSubmitExists && !status.StopExists {
+		fmt.Printf("  ○ Not configured\n")
+		fmt.Printf("  → Run: tanagram config cursor\n")
+		return
+	}
+
+	if status.IsUpToDate {
+		fmt.Printf("  ✓ Configured and up to date\n")
+		fmt.Printf("  beforeSubmitPrompt: %s\n", status.BeforeSubmitCommand)
+		fmt.Printf("  stop: %s\n", status.StopCommand)
+		fmt.Printf("  Location: %s\n", path)
+	} else {
+		fmt.Printf("  ⚠ Configured but incomplete\n")
+		if status.BeforeSubmitExists {
+			fmt.Printf("  ✓ beforeSubmitPrompt: %s\n", status.BeforeSubmitCommand)
+		} else {
+			fmt.Printf("  ✗ beforeSubmitPrompt: missing\n")
+		}
+		if status.StopExists {
+			fmt.Printf("  ✓ stop: %s\n", status.StopCommand)
+		} else {
+			fmt.Printf("  ✗ stop: missing\n")
+		}
+		fmt.Printf("  → Run: tanagram config cursor\n")
+	}
+}
+
+// ensureClaudeConfigured checks if Claude Code hooks are configured,
 // and automatically sets them up if not. This is called on first run
 // of commands that need Claude Code integration.
-func EnsureClaudeConfigured() error {
-	home, err := os.UserHomeDir()
+func ensureClaudeConfigured() error {
+	settingsPath, err := GetHomeConfigPath(".claude", "settings.json")
 	if err != nil {
 		// Silently skip if we can't get home dir - not critical
 		return nil
 	}
 
-	settingsPath := filepath.Join(home, ".claude", "settings.json")
-	status := checkHookStatus(settingsPath)
+	status := checkClaudeHookStatus(settingsPath)
 
 	// If hooks are already configured, we're done
 	if status.IsUpToDate {
@@ -371,7 +552,7 @@ func EnsureClaudeConfigured() error {
 	// If file doesn't exist or hooks aren't configured, set them up
 	if !status.FileExists || !status.PreHookExists || !status.PostHookExists {
 		fmt.Println("Setting up Claude Code integration...")
-		if err := ConfigClaude(); err != nil {
+		if err := ConfigClaude(settingsPath); err != nil {
 			// Don't fail the command if hook setup fails - just warn
 			fmt.Fprintf(os.Stderr, "Warning: Failed to setup Claude Code hooks: %v\n", err)
 			fmt.Fprintf(os.Stderr, "You can manually setup hooks later with: tanagram config claude\n\n")
@@ -382,3 +563,95 @@ func EnsureClaudeConfigured() error {
 
 	return nil
 }
+
+// ensureCursorConfigured checks if Cursor hooks are configured,
+// and automatically sets them up if not. This is called on first run
+// of commands that need Cursor integration.
+func ensureCursorConfigured() error {
+	hooksPath, err := GetHomeConfigPath(".cursor", "hooks.json")
+	if err != nil {
+		// Silently skip if we can't get home dir - not critical
+		return nil
+	}
+
+	status := checkCursorHookStatus(hooksPath)
+
+	// If hooks are already configured, we're done
+	if status.IsUpToDate {
+		return nil
+	}
+
+	// If file doesn't exist or hooks aren't configured, set them up
+	if !status.FileExists || !status.BeforeSubmitExists || !status.StopExists {
+		fmt.Println("Setting up Cursor integration...")
+		if err := ConfigCursor(hooksPath); err != nil {
+			// Don't fail the command if hook setup fails - just warn
+			fmt.Fprintf(os.Stderr, "Warning: Failed to setup Cursor hooks: %v\n", err)
+			fmt.Fprintf(os.Stderr, "You can manually setup hooks later with: tanagram config cursor\n\n")
+			return nil
+		}
+		fmt.Println() // Add blank line after setup message
+	}
+
+	return nil
+}
+
+// EnsureHooksConfigured ensures that both Claude Code and Cursor hooks are configured.
+// This is a convenience function for commands that need both integrations.
+func EnsureHooksConfigured() error {
+	if err := ensureClaudeConfigured(); err != nil {
+		return err
+	}
+	if err := ensureCursorConfigured(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Helpers
+
+func GetHomeConfigPath(parts ...string) (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("failed to get home directory: %w", err)
+	}
+	// Prepend home to parts
+	allParts := append([]string{home}, parts...)
+	return filepath.Join(allParts...), nil
+}
+
+func loadConfig(path string) (map[string]interface{}, error) {
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return make(map[string]interface{}), nil
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read config: %w", err)
+	}
+
+	var config map[string]interface{}
+	if err := json.Unmarshal(data, &config); err != nil {
+		return nil, fmt.Errorf("failed to parse config (invalid JSON): %w", err)
+	}
+
+	return config, nil
+}
+
+func saveConfig(path string, config map[string]interface{}) error {
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+
+	data, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal config: %w", err)
+	}
+
+	if err := os.WriteFile(path, data, 0644); err != nil {
+		return fmt.Errorf("failed to write config: %w", err)
+	}
+
+	return nil
+}

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/main.go

@@ -43,8 +43,8 @@ func main() {
 		metrics.Track("cli.command.execute", map[string]interface{}{
 			"command": "run",
 		})
-		// Auto-setup Claude Code hooks on first run
-		if err := commands.EnsureClaudeConfigured(); err != nil {
+		// Auto-setup hooks on first run
+		if err := commands.EnsureHooksConfigured(); err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 			exitCode = 1
 			return
@@ -59,8 +59,8 @@ func main() {
 		metrics.Track("cli.command.execute", map[string]interface{}{
 			"command": "sync",
 		})
-		// Auto-setup Claude Code hooks on first run
-		if err := commands.EnsureClaudeConfigured(); err != nil {
+		// Auto-setup hooks on first run
+		if err := commands.EnsureHooksConfigured(); err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 			exitCode = 1
 			return
@@ -70,8 +70,8 @@ func main() {
 		metrics.Track("cli.command.execute", map[string]interface{}{
 			"command": "list",
 		})
-		// Auto-setup Claude Code hooks on first run
-		if err := commands.EnsureClaudeConfigured(); err != nil {
+		// Auto-setup hooks on first run
+		if err := commands.EnsureHooksConfigured(); err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 			exitCode = 1
 			return
@@ -83,6 +83,7 @@ func main() {
 			fmt.Fprintf(os.Stderr, "Usage: tanagram config <subcommand>\n")
 			fmt.Fprintf(os.Stderr, "\nAvailable subcommands:\n")
 			fmt.Fprintf(os.Stderr, "  claude    Setup Claude Code hook\n")
+			fmt.Fprintf(os.Stderr, "  cursor    Setup Cursor hook\n")
 			fmt.Fprintf(os.Stderr, "  list      Show hook installation status\n")
 			exitCode = 1
 			return
@@ -93,7 +94,22 @@ func main() {
 			metrics.Track("cli.command.execute", map[string]interface{}{
 				"command": "config.claude",
 			})
-			err = commands.ConfigClaude()
+			settingsPath, pathErr := commands.GetHomeConfigPath(".claude", "settings.json")
+			if pathErr != nil {
+				err = pathErr
+				break
+			}
+			err = commands.ConfigClaude(settingsPath)
+		case "cursor":
+			metrics.Track("cli.command.execute", map[string]interface{}{
+				"command": "config.cursor",
+			})
+			hooksPath, pathErr := commands.GetHomeConfigPath(".cursor", "hooks.json")
+			if pathErr != nil {
+				err = pathErr
+				break
+			}
+			err = commands.ConfigCursor(hooksPath)
 		case "list":
 			metrics.Track("cli.command.execute", map[string]interface{}{
 				"command": "config.list",
@@ -184,6 +200,7 @@ COMMANDS:
   sync           Manually sync instruction files to cache
   list           Show all cached policies
   config claude  Setup Claude Code hook automatically
+  config cursor  Setup Cursor hook automatically
   config list    Show hook installation status
   version        Show the CLI version
   help           Show this help message
@@ -197,6 +214,7 @@ EXAMPLES:
   tanagram sync          # Manually sync local instruction files
   tanagram list          # View all cached policies
   tanagram config claude # Setup Claude Code hooks in ~/.claude/settings.json
+  tanagram config cursor # Setup Cursor hooks in ~/.cursor/hooks.json
   tanagram config list   # Show where hooks are installed
   tanagram version       # Show the version
 
@@ -208,9 +226,15 @@ INSTRUCTION FILES:
   Policies are cached and automatically resynced when files change.
 
 HOOK WORKFLOW:
-  When configured with 'tanagram config claude', two hooks are installed:
+  When configured with 'tanagram config claude' or 'tanagram config cursor':
+  
+  Claude Code:
   1. PreToolUse (Edit|Write): Creates snapshot before Claude makes changes
   2. PostToolUse (Edit|Write): Checks only Claude's changes against policies
+  
+  Cursor:
+  1. beforeSubmitPrompt: Creates snapshot before agent starts working
+  2. stop: Checks only Cursor's changes after agent completes
 
   This prevents false positives from user-written code!
 `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanagram/cli",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Tanagram - Catch sloppy code before it ships",
   "main": "index.js",
   "bin": {