@tanagram/cli 0.4.2 → 0.4.4

package/checker/matcher.go

@@ -2,7 +2,9 @@ package checker
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"os"
 	"sort"
 	"strings"
 
@@ -138,3 +140,65 @@ func FormatClaudeInstructions(result *CheckResult) string {
 
 	return output.String()
 }
+
+// FormatCursorInstructions formats violations as a JSON response for Cursor
+// structured as {"followup_message": "<text>"}
+func FormatCursorInstructions(result *CheckResult) string {
+	if len(result.Violations) == 0 {
+		return ""
+	}
+
+	// Group violations by file
+	violationsByFile := make(map[string][]Violation)
+	for _, v := range result.Violations {
+		violationsByFile[v.File] = append(violationsByFile[v.File], v)
+	}
+
+	// Sort files for consistent output
+	files := make([]string, 0, len(violationsByFile))
+	for file := range violationsByFile {
+		files = append(files, file)
+	}
+	sort.Strings(files)
+
+	var message strings.Builder
+	message.WriteString("POLICY VIOLATIONS DETECTED - PLEASE FIX\n\n")
+	message.WriteString(fmt.Sprintf("Found %d policy violation(s) that need to be fixed:\n\n", len(result.Violations)))
+
+	for _, file := range files {
+		violations := violationsByFile[file]
+
+		// Sort violations by line number
+		sort.Slice(violations, func(i, j int) bool {
+			return violations[i].LineNumber < violations[j].LineNumber
+		})
+
+		message.WriteString(fmt.Sprintf("File: %s\n", file))
+
+		for _, v := range violations {
+			message.WriteString(fmt.Sprintf("\n  Line %d:\n", v.LineNumber))
+			message.WriteString(fmt.Sprintf("    Code: %s\n", v.Code))
+			message.WriteString(fmt.Sprintf("    Policy: %s\n", v.PolicyName))
+			message.WriteString(fmt.Sprintf("    Issue: %s\n", v.Message))
+			message.WriteString(fmt.Sprintf("    Action: Review and fix this code to comply with the policy.\n"))
+		}
+		message.WriteString("\n")
+	}
+
+	message.WriteString("Please fix all violations listed above and ensure the code complies with all policies.\n")
+
+	// Wrap in JSON structure
+	response := struct {
+		FollowupMessage string `json:"followup_message"`
+	}{
+		FollowupMessage: message.String(),
+	}
+
+	bytes, err := json.MarshalIndent(response, "", "  ")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error formatting violations: %v\n", err)
+		return "{}"
+	}
+
+	return string(bytes)
+}

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
+}