@tanagram/cli 0.4.3 → 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/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)
+			}
+		})
+	}
+}

package/main.go

@@ -1,12 +1,15 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 
 	"github.com/tanagram/cli/commands"
 	"github.com/tanagram/cli/metrics"
 	"github.com/tanagram/cli/tui"
+	"github.com/tanagram/cli/utils"
 )
 
 // Version is set in install.js via `-X` ldflags
@@ -37,6 +40,29 @@ func main() {
 		"subcommand": subcommand,
 	})
 
+	// THIS IS A HUGE HACK
+	// Cursor runs its hooks in the ~/.cursor directory as cwd
+	// Claude runs its hooks directly as a subprocess, with your terminal directory as cwd
+	// We have existing code that depends on cwd being the workspace root
+	// So we detect if we're running through Cursor (`GetParentProcess` does some magic here)
+	// and set cwd based on the workspace_root that Cursor gives us.
+	// TODO: handle 0 or multiple workspace_roots
+	if utils.GetParentProcess() == "cursor" {
+		input, err := io.ReadAll(os.Stdin)
+		if err == nil {
+			var payload struct {
+				WorkspaceRoots []string `json:"workspace_roots"`
+			}
+			if err := json.Unmarshal(input, &payload); err != nil {
+				fmt.Fprintf(os.Stderr, "Error parsing input: %v\n", err)
+			} else if len(payload.WorkspaceRoots) > 0 {
+				os.Chdir(payload.WorkspaceRoots[0])
+			} else {
+				fmt.Fprintf(os.Stderr, "No workspace roots found\n")
+			}
+		}
+	}
+
 	var err error
 	switch subcommand {
 	case "run":

package/package.json

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

package/utils/process.go

@@ -2,6 +2,7 @@ package utils
 
 import (
 	"os"
+	"strings"
 	"sync"
 
 	"github.com/shirou/gopsutil/v3/process"
@@ -17,20 +18,30 @@ var (
 func GetParentProcess() string {
 	parentProcessOnce.Do(func() {
 		parentProcessName = "unknown"
-		
+
 		parentPID := int32(os.Getppid())
 		parent, err := process.NewProcess(parentPID)
 		if err != nil {
 			return
 		}
-		
+
 		name, err := parent.Name()
 		if err != nil {
 			return
 		}
-		
+
+		// Cursor runs hooks via `node` or `zsh` (I've seen both) in ~/.cursor
+		// Handle this case and make life easier for users of this function.
+		if name == "node" || name == "zsh" {
+			cwd, err := parent.Cwd()
+			if err == nil && strings.Contains(cwd, ".cursor") {
+				parentProcessName = "cursor"
+				return
+			}
+		}
+
 		parentProcessName = name
 	})
-	
+
 	return parentProcessName
 }