@tanagram/cli 0.4.11 → 0.4.14

package/commands/config_test.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 )
 
@@ -31,12 +32,12 @@ func TestConfigClaude(t *testing.T) {
 		}
 
 		settings := readSettings(t, settingsPath)
-		pre, post := checkHooks(settings)
-		if !pre {
-			t.Error("PreToolUse hook not created")
+		sessionStart, stop := checkHooks(settings)
+		if !sessionStart {
+			t.Error("SessionStart hook not created")
 		}
-		if !post {
-			t.Error("PostToolUse hook not created")
+		if !stop {
+			t.Error("Stop hook not created")
 		}
 	})
 
@@ -47,22 +48,22 @@ func TestConfigClaude(t *testing.T) {
 		}
 
 		settings := readSettings(t, settingsPath)
-		pre, post := checkHooks(settings)
-		if !pre || !post {
+		sessionStart, stop := checkHooks(settings)
+		if !sessionStart || !stop {
 			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{})
+		sessionStartHooks := hooks["SessionStart"].([]interface{})
+		stopHooks := hooks["Stop"].([]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(sessionStartHooks) != 1 {
+			t.Errorf("Expected 1 SessionStart hook, got %d", len(sessionStartHooks))
 		}
-		if len(postToolUse) != 1 {
-			t.Errorf("Expected 1 PostToolUse hook, got %d", len(postToolUse))
+		if len(stopHooks) != 1 {
+			t.Errorf("Expected 1 Stop hook, got %d", len(stopHooks))
 		}
 	})
 
@@ -70,9 +71,9 @@ func TestConfigClaude(t *testing.T) {
 		// Reset with a file that has other hooks
 		otherHook := map[string]interface{}{
 			"hooks": map[string]interface{}{
-				"PreToolUse": []interface{}{
+				"SessionStart": []interface{}{
 					map[string]interface{}{
-						"matcher": "Read",
+						"matcher": "startup|clear",
 						"hooks": []interface{}{
 							map[string]interface{}{"command": "echo existing"},
 						},
@@ -100,19 +101,19 @@ func TestConfigClaude(t *testing.T) {
 		}
 
 		settings := readSettings(t, settingsPath)
-		pre, post := checkHooks(settings)
-		if !pre || !post {
+		sessionStart, stop := checkHooks(settings)
+		if !sessionStart || !stop {
 			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{})
+		sessionStartHooks := hooks["SessionStart"].([]interface{})
 
 		foundExisting := false
-		for _, h := range preToolUse {
+		for _, h := range sessionStartHooks {
 			hMap := h.(map[string]interface{})
-			if hMap["matcher"] == "Read" {
+			if hMap["matcher"] == "startup|clear" {
 				// Check for the specific command to be sure it's the right one
 				if commands, ok := hMap["hooks"].([]interface{}); ok {
 					for _, cmd := range commands {
@@ -133,6 +134,85 @@ func TestConfigClaude(t *testing.T) {
 			t.Error("Existing hook was lost")
 		}
 	})
+
+	t.Run("Preserve existing absolute path hooks", func(t *testing.T) {
+		// Reset with a file that has absolute path hooks
+		absHook := map[string]interface{}{
+			"hooks": map[string]interface{}{
+				"SessionStart": []interface{}{
+					map[string]interface{}{
+						"matcher": "startup|clear",
+						"hooks": []interface{}{
+							map[string]interface{}{"command": "/absolute/path/to/tanagram snapshot"},
+						},
+					},
+				},
+				"Stop": []interface{}{
+					map[string]interface{}{
+						"hooks": []interface{}{
+							map[string]interface{}{
+								"type":    "command",
+								"command": "/absolute/path/to/tanagram",
+							},
+						},
+					},
+				},
+			},
+		}
+
+		// 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 absHook to settingsPath
+		data, _ := json.Marshal(absHook)
+		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)
+
+		// Check duplication
+		hooks := settings["hooks"].(map[string]interface{})
+		sessionStartHooks := hooks["SessionStart"].([]interface{})
+		stopHooks := hooks["Stop"].([]interface{})
+
+		// We expect exactly 1 hook since we started with 1 and it should match
+		if len(sessionStartHooks) != 1 {
+			t.Errorf("Expected 1 SessionStart hook, got %d", len(sessionStartHooks))
+		}
+		if len(stopHooks) != 1 {
+			t.Errorf("Expected 1 Stop hook, got %d", len(stopHooks))
+		}
+
+		// Check content
+		h := sessionStartHooks[0].(map[string]interface{})
+		innerHooks := h["hooks"].([]interface{})
+		cmdMap := innerHooks[0].(map[string]interface{})
+		cmd := cmdMap["command"].(string)
+
+		if cmd != "/absolute/path/to/tanagram snapshot" {
+			t.Errorf("Expected command to be preserved as '/absolute/path/to/tanagram snapshot', got '%s'", cmd)
+		}
+
+		// Check post content
+		hPost := stopHooks[0].(map[string]interface{})
+		innerHooksPost := hPost["hooks"].([]interface{})
+		cmdMapPost := innerHooksPost[0].(map[string]interface{})
+		cmdPost := cmdMapPost["command"].(string)
+
+		if cmdPost != "/absolute/path/to/tanagram" {
+			t.Errorf("Expected command to be preserved as '/absolute/path/to/tanagram', got '%s'", cmdPost)
+		}
+	})
 }
 
 func TestConfigCursor(t *testing.T) {
@@ -243,6 +323,69 @@ func TestConfigCursor(t *testing.T) {
 			t.Error("Existing hook was lost")
 		}
 	})
+
+	t.Run("Preserve existing absolute path hooks", func(t *testing.T) {
+		// Reset with a file that has absolute path hooks
+		absHook := map[string]interface{}{
+			"hooks": map[string]interface{}{
+				"beforeSubmitPrompt": []interface{}{
+					map[string]interface{}{"command": "/absolute/path/to/tanagram snapshot"},
+				},
+				"stop": []interface{}{
+					map[string]interface{}{"command": "/absolute/path/to/tanagram"},
+				},
+			},
+		}
+
+		// 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 absHook to hooksPath
+		data, _ := json.Marshal(absHook)
+		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)
+
+		// Check duplication
+		hooks := settings["hooks"].(map[string]interface{})
+		beforeSubmitHooks := hooks["beforeSubmitPrompt"].([]interface{})
+		stopHooks := hooks["stop"].([]interface{})
+
+		// We expect exactly 1 hook since we started with 1 and it should match
+		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))
+		}
+
+		// Check content
+		h := beforeSubmitHooks[0].(map[string]interface{})
+		cmd, _ := h["command"].(string)
+
+		if cmd != "/absolute/path/to/tanagram snapshot" {
+			t.Errorf("Expected command to be preserved as '/absolute/path/to/tanagram snapshot', got '%s'", cmd)
+		}
+
+		// Check stop content
+		hStop := stopHooks[0].(map[string]interface{})
+		cmdStop, _ := hStop["command"].(string)
+
+		if cmdStop != "/absolute/path/to/tanagram" {
+			t.Errorf("Expected command to be preserved as '/absolute/path/to/tanagram', got '%s'", cmdStop)
+		}
+	})
 }
 
 func TestEnsureHooksConfigured(t *testing.T) {
@@ -277,12 +420,12 @@ func TestEnsureHooksConfigured(t *testing.T) {
 		// 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")
+		sessionStart, stop := checkHooks(claudeSettings)
+		if !sessionStart {
+			t.Error("SessionStart hook not created")
 		}
-		if !post {
-			t.Error("PostToolUse hook not created")
+		if !stop {
+			t.Error("Stop hook not created")
 		}
 
 		// Check Cursor hooks
@@ -316,16 +459,16 @@ func checkHooks(settings map[string]interface{}) (bool, bool) {
 		return false, false
 	}
 
-	preExists := false
-	if preToolUse, ok := hooks["PreToolUse"].([]interface{}); ok {
-		for _, h := range preToolUse {
+	sessionStartExists := false
+	if sessionStart, ok := hooks["SessionStart"].([]interface{}); ok {
+		for _, h := range sessionStart {
 			if hMap, ok := h.(map[string]interface{}); ok {
-				if hMap["matcher"] == "Edit|Write" {
+				if hMap["matcher"] == "startup|clear" {
 					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
+								if cmd, ok := ihMap["command"].(string); ok && strings.HasSuffix(cmd, "tanagram snapshot") {
+									sessionStartExists = true
 								}
 							}
 						}
@@ -335,17 +478,15 @@ func checkHooks(settings map[string]interface{}) (bool, bool) {
 		}
 	}
 
-	postExists := false
-	if postToolUse, ok := hooks["PostToolUse"].([]interface{}); ok {
-		for _, h := range postToolUse {
+	stopExists := false
+	if stopHooks, ok := hooks["Stop"].([]interface{}); ok {
+		for _, h := range stopHooks {
 			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
-								}
+				if innerHooks, ok := hMap["hooks"].([]interface{}); ok {
+					for _, ih := range innerHooks {
+						if ihMap, ok := ih.(map[string]interface{}); ok {
+							if cmd, ok := ihMap["command"].(string); ok && strings.HasSuffix(cmd, "tanagram") {
+								stopExists = true
 							}
 						}
 					}
@@ -354,7 +495,7 @@ func checkHooks(settings map[string]interface{}) (bool, bool) {
 		}
 	}
 
-	return preExists, postExists
+	return sessionStartExists, stopExists
 }
 
 func checkCursorHooks(settings map[string]interface{}) (bool, bool) {
@@ -367,7 +508,7 @@ func checkCursorHooks(settings map[string]interface{}) (bool, bool) {
 	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" {
+				if cmd, ok := hMap["command"].(string); ok && strings.HasSuffix(cmd, "tanagram snapshot") {
 					beforeSubmitExists = true
 				}
 			}
@@ -378,7 +519,7 @@ func checkCursorHooks(settings map[string]interface{}) (bool, bool) {
 	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" {
+				if cmd, ok := hMap["command"].(string); ok && strings.HasSuffix(cmd, "tanagram") {
 					stopExists = true
 				}
 			}

package/commands/login.go

@@ -19,7 +19,7 @@ import (
 // getWebAppURL returns the web app URL based on environment
 func getWebAppURL() string {
 	// Check environment variable first
-	if url := os.Getenv("TANAGRAM_WEB_URL"); url != "" {
+	if url := os.Getenv("TANAGRAM_WEB_HOSTNAME"); url != "" {
 		return url
 	}
 
@@ -79,7 +79,7 @@ func Login() error {
 
 		// Send success message to browser
 		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprintf(w, `
+		fmt.Fprint(w, `
 			<!DOCTYPE html>
 			<html lang="en">
 			<head>

package/commands/run.go

@@ -3,6 +3,7 @@ package commands
 import (
 	"context"
 	"fmt"
+	"log/slog"
 	"os"
 	"path/filepath"
 	"sync"
@@ -26,10 +27,10 @@ func spinner(stop chan bool, message string) {
 	for {
 		select {
 		case <-stop:
-			fmt.Fprint(os.Stderr, "\r")
+			slog.Info("\r")
 			return
 		default:
-			fmt.Fprintf(os.Stderr, "\r%s %s", chars[i%len(chars)], message)
+			slog.Info("spinner", "char", chars[i%len(chars)], "message", message)
 			i++
 			time.Sleep(100 * time.Millisecond)
 		}
@@ -80,7 +81,7 @@ func Run() error {
 			return err
 		}
 
-		fmt.Fprintf(os.Stderr, "\nSyncing policies with LLM (processing %d changed file(s) in parallel)...\n", len(filesToSync))
+		slog.Info("Syncing policies with LLM", "files_to_process", len(filesToSync))
 
 		syncStart := time.Now()
 		ctx := context.Background()
@@ -102,19 +103,16 @@ func Run() error {
 		var completed int
 		var mu sync.Mutex
 		go func() {
-			chars := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-			i := 0
 			for {
 				select {
 				case <-stop:
-					fmt.Fprint(os.Stderr, "\r")
+					slog.Info("spinner stopped")
 					return
 				default:
 					mu.Lock()
 					c := completed
 					mu.Unlock()
-					fmt.Fprintf(os.Stderr, "\r%s Processing files... (%d/%d completed)", chars[i%len(chars)], c, len(filesToSync))
-					i++
+					slog.Info("Processing files", "completed", c, "total", len(filesToSync))
 					time.Sleep(100 * time.Millisecond)
 				}
 			}
@@ -145,7 +143,7 @@ func Run() error {
 				close(stop)
 				time.Sleep(50 * time.Millisecond)
 				mu.Lock()
-				fmt.Fprintf(os.Stderr, "\r\033[K✗ Failed to process %s\n", result.relPath)
+				slog.Error("Failed to process file", "file", result.relPath)
 				mu.Unlock()
 				return fmt.Errorf("failed to extract policies from %s: %w", result.file, result.err)
 			}
@@ -162,7 +160,7 @@ func Run() error {
 			// Atomic update of counter and output (prevents race with spinner)
 			mu.Lock()
 			completed++
-			fmt.Fprintf(os.Stderr, "\r\033[K✓ %s - %d policies\n", result.relPath, len(result.policies))
+			slog.Info("Processed file", "file", result.relPath, "policies", len(result.policies))
 			mu.Unlock()
 		}
 
@@ -176,7 +174,7 @@ func Run() error {
 		}
 
 		syncDuration := time.Since(syncStart)
-		fmt.Fprintf(os.Stderr, "\n✓ Synced %d policies from %d changed file(s)\n", totalPolicies, len(filesToSync))
+		slog.Info("Sync complete", "policies_synced", totalPolicies, "files_synced", len(filesToSync))
 
 		// Track sync metrics
 		metrics.Track("cli.sync.complete", map[string]interface{}{
@@ -202,10 +200,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.Fprintf(os.Stderr, "Warning: Failed to load cloud policies: %v\n", err)
+			slog.Warn("Failed to load cloud policies", "error", err)
 			cloudPolicies = []parser.Policy{}
 		} else if len(cloudPolicies) > 0 {
-			fmt.Fprintf(os.Stderr, "Loaded %d cloud policies for %s/%s\n", len(cloudPolicies), repoInfo.Owner, repoInfo.Name)
+			slog.Info("Loaded cloud policies", "count", len(cloudPolicies), "owner", repoInfo.Owner, "repo", repoInfo.Name)
 		}
 	}
 	// If repo detection failed, silently continue with local-only policies
@@ -214,7 +212,7 @@ func Run() error {
 	policies := storage.MergePolicies(localPolicies, cloudPolicies)
 
 	if len(policies) == 0 {
-		fmt.Fprintln(os.Stderr, "No enforceable policies found")
+		slog.Info("No enforceable policies found")
 		return nil
 	}
 
@@ -223,9 +221,9 @@ func Run() error {
 	totalMerged := len(policies)
 
 	if totalCloud > 0 {
-		fmt.Fprintf(os.Stderr, "Total policies: %d (%d local, %d cloud, %d after merge)\n", totalMerged, totalLocal, totalCloud, totalMerged)
+		slog.Info("Total policies", "total", totalMerged, "local", totalLocal, "cloud", totalCloud, "after_merge", totalMerged)
 	} else {
-		fmt.Fprintf(os.Stderr, "Loaded %d local policies\n", totalLocal)
+		slog.Info("Loaded local policies", "count", totalLocal)
 	}
 
 	// Check if a snapshot exists (from PreToolUse hook)
@@ -233,7 +231,7 @@ func Run() error {
 	useSnapshot := false
 
 	if snapshot.Exists(gitRoot) {
-		fmt.Fprintln(os.Stderr, "Snapshot detected - checking only Claude's changes...")
+		slog.Info("Snapshot detected - checking only Claude's changes")
 
 		// Load snapshot
 		snap, err := snapshot.Load(gitRoot)
@@ -265,13 +263,13 @@ func Run() error {
 
 		// Delete snapshot after using it
 		if err := snapshot.Delete(gitRoot); err != nil {
-			fmt.Fprintf(os.Stderr, "Warning: failed to delete snapshot: %v\n", err)
+			slog.Warn("Failed to delete snapshot", "error", err)
 		}
 
 		useSnapshot = true
 	} else {
 		// No snapshot - fall back to checking all git changes
-		fmt.Fprintln(os.Stderr, "Checking all changes (unstaged + staged)...")
+		slog.Info("Checking all changes (unstaged + staged)")
 		diffResult, err := gitpkg.GetAllChanges()
 		if err != nil {
 			return fmt.Errorf("error getting git diff: %w", err)
@@ -282,14 +280,14 @@ func Run() error {
 
 	if len(changesToCheck) == 0 {
 		if useSnapshot {
-			fmt.Fprintln(os.Stderr, "No changes detected since snapshot")
+			fmt.Fprint(os.Stdout, "No changes detected since snapshot\n")
 		} else {
-			fmt.Fprintln(os.Stderr, "No changes to check")
+			fmt.Fprint(os.Stdout, "No changes to check\n")
 		}
 		return nil
 	}
 
-	fmt.Fprintf(os.Stderr, "Scanning %d changed lines...\n\n", len(changesToCheck))
+	slog.Info("Scanning changed lines", "count", len(changesToCheck))
 
 	// Get API key once upfront before checking
 	apiKey, err := config.GetAPIKey()
@@ -337,6 +335,6 @@ func Run() error {
 	}
 
 	// No violations found - output success message
-	fmt.Fprintln(os.Stderr, "✓ No policy violations found")
+	fmt.Fprint(os.Stdout, "No policy violations found")
 	return nil
 }

package/commands/snapshot_test.go

@@ -10,11 +10,11 @@ import (
 func TestSnapshot_Cursor(t *testing.T) {
 	// Save original functions
 	origFindGitRoot := findGitRoot
-	origCreateSnapshot := createSnapshot
+	origCreateSnapshot := createOptimized
 	origGetParentProcess := getParentProcess
 	defer func() {
 		findGitRoot = origFindGitRoot
-		createSnapshot = origCreateSnapshot
+		createOptimized = origCreateSnapshot
 		getParentProcess = origGetParentProcess
 	}()
 
@@ -22,7 +22,7 @@ func TestSnapshot_Cursor(t *testing.T) {
 	findGitRoot = func() (string, error) {
 		return "/tmp/mock-git-root", nil
 	}
-	createSnapshot = func(root string) error {
+	createOptimized = func(root string, files []string) error {
 		return nil
 	}
 

package/go.mod

@@ -43,6 +43,7 @@ require (
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	github.com/zalando/go-keyring v0.2.6 // indirect
-	golang.org/x/sys v0.36.0 // indirect
+	golang.org/x/sys v0.38.0 // indirect
+	golang.org/x/term v0.37.0 // indirect
 	golang.org/x/text v0.27.0 // indirect
 )

package/go.sum

@@ -97,6 +97,10 @@ golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
 golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.37.0 h1:8EGAD0qCmHYZg6J17DvsMy9/wJ7/D/4pV/wfnld5lTU=
+golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254=
 golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
 golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=