@tanagram/cli 0.4.19 → 0.4.20

package/commands/run.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/getsentry/sentry-go"
 	"github.com/tanagram/cli/checker"
 	"github.com/tanagram/cli/config"
 	"github.com/tanagram/cli/extractor"
@@ -37,16 +38,132 @@ func spinner(stop chan bool, message string) {
 	}
 }
 
+// syncPolicies extracts policies from changed files using the LLM
+func syncPolicies(ctx context.Context, filesToSync []string, gitRoot string, cache *storage.Cache) error {
+	syncSpan := sentry.StartSpan(ctx, "commands.auto_sync_policies")
+	defer syncSpan.Finish()
+	syncSpan.SetData("files_to_sync", len(filesToSync))
+
+	apiKey, err := config.GetAPIKey()
+	if err != nil {
+		return err
+	}
+
+	slog.Info("Syncing policies with LLM", "files_to_process", len(filesToSync))
+
+	syncStart := time.Now()
+
+	type syncResult struct {
+		file     string
+		relPath  string
+		policies []parser.Policy
+		err      error
+	}
+
+	results := make(chan syncResult, len(filesToSync))
+	var wg sync.WaitGroup
+
+	stop := make(chan bool)
+	var completed int
+	var mu sync.Mutex
+	go func() {
+		for {
+			select {
+			case <-stop:
+				slog.Info("spinner stopped")
+				return
+			default:
+				mu.Lock()
+				c := completed
+				mu.Unlock()
+				slog.Info("Processing files", "completed", c, "total", len(filesToSync))
+				time.Sleep(100 * time.Millisecond)
+			}
+		}
+	}()
+
+	for _, file := range filesToSync {
+		wg.Add(1)
+		go func(file string) {
+			defer wg.Done()
+			relPath, _ := filepath.Rel(gitRoot, file)
+			policies, err := extractor.ExtractPoliciesFromFile(ctx, file, apiKey)
+			results <- syncResult{file, relPath, policies, err}
+		}(file)
+	}
+
+	go func() {
+		wg.Wait()
+		close(results)
+	}()
+
+	totalPolicies := 0
+	for result := range results {
+		if result.err != nil {
+			stop <- true
+			close(stop)
+			time.Sleep(50 * time.Millisecond)
+			mu.Lock()
+			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)
+		}
+
+		if err := cache.UpdateFile(result.file, result.policies); err != nil {
+			stop <- true
+			close(stop)
+			time.Sleep(50 * time.Millisecond)
+			return fmt.Errorf("failed to update cache for %s: %w", result.file, err)
+		}
+
+		totalPolicies += len(result.policies)
+
+		mu.Lock()
+		completed++
+		slog.Info("Processed file", "file", result.relPath, "policies", len(result.policies))
+		mu.Unlock()
+	}
+
+	stop <- true
+	close(stop)
+	time.Sleep(50 * time.Millisecond)
+
+	if err := cache.Save(); err != nil {
+		return fmt.Errorf("failed to save cache: %w", err)
+	}
+
+	syncDuration := time.Since(syncStart)
+	slog.Info("Sync complete", "policies_synced", totalPolicies, "files_synced", len(filesToSync))
+
+	metrics.Track("cli.sync.complete", map[string]interface{}{
+		"files_synced":     len(filesToSync),
+		"policies_synced":  totalPolicies,
+		"duration_seconds": syncDuration.Seconds(),
+	})
+
+	return nil
+}
+
 // Run executes the main policy check with auto-sync
-func Run() error {
+func Run(ctx context.Context) error {
+	span := sentry.StartSpan(ctx, "command.run")
+	defer span.Finish()
+	ctx = span.Context()
+
+	utils.AddBreadcrumb("run", "Starting policy check", sentry.LevelInfo, nil)
+
 	// Find git root
+	findGitRootSpan := sentry.StartSpan(ctx, "storage.find_git_root")
 	gitRoot, err := storage.FindGitRoot()
+	findGitRootSpan.Finish()
 	if err != nil {
 		return err
 	}
 
 	// Find all instruction files
+	findFilesSpan := sentry.StartSpan(ctx, "commands.find_instruction_files")
 	instructionFiles, err := FindInstructionFiles(gitRoot)
+	findFilesSpan.Finish()
 	if err != nil {
 		return err
 	}
@@ -56,7 +173,9 @@ func Run() error {
 	}
 
 	// Load cache
+	loadCacheSpan := sentry.StartSpan(ctx, "storage.load_cache")
 	cache, err := storage.LoadCache(gitRoot)
+	loadCacheSpan.Finish()
 	if err != nil {
 		return fmt.Errorf("failed to load cache: %w", err)
 	}
@@ -75,122 +194,21 @@ func Run() error {
 
 	// Auto-sync only the files that changed
 	if len(filesToSync) > 0 {
-		// Get API key once upfront before parallel processing
-		apiKey, err := config.GetAPIKey()
-		if err != nil {
+		if err := syncPolicies(ctx, filesToSync, gitRoot, cache); err != nil {
 			return err
 		}
-
-		slog.Info("Syncing policies with LLM", "files_to_process", len(filesToSync))
-
-		syncStart := time.Now()
-		ctx := context.Background()
-
-		// Result type for collecting sync results
-		type syncResult struct {
-			file     string
-			relPath  string
-			policies []parser.Policy
-			err      error
-		}
-
-		// Channel to collect results
-		results := make(chan syncResult, len(filesToSync))
-		var wg sync.WaitGroup
-
-		// Start spinner
-		stop := make(chan bool)
-		var completed int
-		var mu sync.Mutex
-		go func() {
-			for {
-				select {
-				case <-stop:
-					slog.Info("spinner stopped")
-					return
-				default:
-					mu.Lock()
-					c := completed
-					mu.Unlock()
-					slog.Info("Processing files", "completed", c, "total", len(filesToSync))
-					time.Sleep(100 * time.Millisecond)
-				}
-			}
-		}()
-
-		// Launch goroutines only for changed files
-		for _, file := range filesToSync {
-			wg.Add(1)
-			go func(file string) {
-				defer wg.Done()
-				relPath, _ := filepath.Rel(gitRoot, file)
-				policies, err := extractor.ExtractPoliciesFromFile(ctx, file, apiKey)
-				results <- syncResult{file, relPath, policies, err}
-			}(file)
-		}
-
-		// Close results channel when all goroutines complete
-		go func() {
-			wg.Wait()
-			close(results)
-		}()
-
-		// Collect results
-		totalPolicies := 0
-		for result := range results {
-			if result.err != nil {
-				stop <- true
-				close(stop)
-				time.Sleep(50 * time.Millisecond)
-				mu.Lock()
-				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)
-			}
-
-			if err := cache.UpdateFile(result.file, result.policies); err != nil {
-				stop <- true
-				close(stop)
-				time.Sleep(50 * time.Millisecond)
-				return fmt.Errorf("failed to update cache for %s: %w", result.file, err)
-			}
-
-			totalPolicies += len(result.policies)
-
-			// Atomic update of counter and output (prevents race with spinner)
-			mu.Lock()
-			completed++
-			slog.Info("Processed file", "file", result.relPath, "policies", len(result.policies))
-			mu.Unlock()
-		}
-
-		// Stop spinner
-		stop <- true
-		close(stop)
-		time.Sleep(50 * time.Millisecond)
-
-		if err := cache.Save(); err != nil {
-			return fmt.Errorf("failed to save cache: %w", err)
-		}
-
-		syncDuration := time.Since(syncStart)
-		slog.Info("Sync complete", "policies_synced", totalPolicies, "files_synced", len(filesToSync))
-
-		// Track sync metrics
-		metrics.Track("cli.sync.complete", map[string]interface{}{
-			"files_synced":     len(filesToSync),
-			"policies_synced":  totalPolicies,
-			"duration_seconds": syncDuration.Seconds(),
-		})
 	}
 
 	// Load local policies from cache
+	loadPoliciesSpan := sentry.StartSpan(ctx, "cache.get_all_policies")
 	localPolicies, err := cache.GetAllPolicies()
+	loadPoliciesSpan.Finish()
 	if err != nil {
 		return fmt.Errorf("failed to load policies from cache: %w", err)
 	}
 
 	// Try to load cloud policies for current repo
+	cloudPoliciesSpan := sentry.StartSpan(ctx, "storage.load_cloud_policies")
 	cloudPolicies := []parser.Policy{}
 	cloudStorage := storage.NewCloudPolicyStorage(gitRoot)
 
@@ -206,6 +224,7 @@ func Run() error {
 			slog.Info("Loaded cloud policies", "count", len(cloudPolicies), "owner", repoInfo.Owner, "repo", repoInfo.Name)
 		}
 	}
+	cloudPoliciesSpan.Finish()
 	// If repo detection failed, silently continue with local-only policies
 
 	// Merge local and cloud policies (cloud takes precedence)
@@ -227,55 +246,9 @@ func Run() error {
 	}
 
 	// Check if a snapshot exists (from PreToolUse hook)
-	var changesToCheck []gitpkg.ChangedLine
-	useSnapshot := false
-
-	if snapshot.Exists(gitRoot) {
-		slog.Info("Snapshot detected - checking only Claude's changes")
-
-		// Load snapshot
-		snap, err := snapshot.Load(gitRoot)
-		if err != nil {
-			return fmt.Errorf("failed to load snapshot: %w", err)
-		}
-
-		// Compare current state to snapshot
-		compareResult, err := snapshot.Compare(gitRoot, snap)
-		if err != nil {
-			return fmt.Errorf("failed to compare to snapshot: %w", err)
-		}
-
-		// Get changed lines
-		snapshotChanges, err := snapshot.GetChangedLinesForChecker(gitRoot, snap, compareResult)
-		if err != nil {
-			return fmt.Errorf("failed to get changed lines from snapshot: %w", err)
-		}
-
-		// Convert snapshot.ChangedLine to git.ChangedLine
-		for _, sc := range snapshotChanges {
-			changesToCheck = append(changesToCheck, gitpkg.ChangedLine{
-				File:       sc.File,
-				LineNumber: sc.LineNumber,
-				Content:    sc.Content,
-				ChangeType: sc.ChangeType,
-			})
-		}
-
-		// Delete snapshot after using it
-		if err := snapshot.Delete(gitRoot); err != nil {
-			slog.Warn("Failed to delete snapshot", "error", err)
-		}
-
-		useSnapshot = true
-	} else {
-		// No snapshot - fall back to checking all git changes
-		slog.Info("Checking all changes (unstaged + staged)")
-		diffResult, err := gitpkg.GetAllChanges()
-		if err != nil {
-			return fmt.Errorf("error getting git diff: %w", err)
-		}
-
-		changesToCheck = diffResult.Changes
+	changesToCheck, useSnapshot, err := getChangesToCheck(ctx, gitRoot)
+	if err != nil {
+		return err
 	}
 
 	if len(changesToCheck) == 0 {
@@ -287,6 +260,11 @@ func Run() error {
 		return nil
 	}
 
+	utils.AddBreadcrumb("run", "Scanning changes", sentry.LevelInfo, map[string]interface{}{
+		"changes_count": len(changesToCheck),
+		"use_snapshot":  useSnapshot,
+	})
+
 	slog.Info("Scanning changed lines", "count", len(changesToCheck))
 
 	// Get API key once upfront before checking
@@ -296,10 +274,13 @@ func Run() error {
 	}
 
 	// Check changes against policies (both regex and LLM-based)
-	ctx := context.Background()
+	checkSpan := sentry.StartSpan(ctx, "checker.check_changes")
+	checkSpan.SetData("changes_count", len(changesToCheck))
+	checkSpan.SetData("policies_count", len(policies))
 	checkStart := time.Now()
 	result := checker.CheckChanges(ctx, changesToCheck, policies, apiKey)
 	checkDuration := time.Since(checkStart)
+	checkSpan.Finish()
 
 	// Track policy check results (similar to policy.execute.result in github-app)
 	metrics.Track("cli.policy.check.result", map[string]interface{}{
@@ -311,6 +292,11 @@ func Run() error {
 		"used_snapshot":    useSnapshot,
 	})
 
+	utils.AddBreadcrumb("run", "Policy check complete", sentry.LevelInfo, map[string]interface{}{
+		"violations_found": len(result.Violations),
+		"duration_seconds": checkDuration.Seconds(),
+	})
+
 	// Handle results based on whether violations were found
 	if len(result.Violations) > 0 {
 		// Determine parent process to decide output format
@@ -321,6 +307,10 @@ func Run() error {
 			claudeInstructions := checker.FormatClaudeInstructions(result)
 			fmt.Fprint(os.Stderr, claudeInstructions)
 
+			// Finish span and flush Sentry before exit (os.Exit bypasses deferred functions)
+			span.Finish()
+			sentry.Flush(2 * time.Second)
+
 			// Exit with code 2 to trigger Claude Code hook behavior
 			os.Exit(2)
 		} else if parentProcess == "cursor" {
@@ -338,3 +328,51 @@ func Run() error {
 	fmt.Fprint(os.Stdout, "No policy violations found")
 	return nil
 }
+
+func getChangesToCheck(ctx context.Context, gitRoot string) ([]gitpkg.ChangedLine, bool, error) {
+	span := sentry.StartSpan(ctx, "commands.get_changes_to_check")
+	defer span.Finish()
+
+	if snapshot.Exists(gitRoot) {
+		slog.Info("Snapshot detected - checking only Claude's changes")
+
+		snap, err := snapshot.Load(gitRoot)
+		if err != nil {
+			return nil, false, fmt.Errorf("failed to load snapshot: %w", err)
+		}
+
+		compareResult, err := snapshot.Compare(gitRoot, snap)
+		if err != nil {
+			return nil, false, fmt.Errorf("failed to compare to snapshot: %w", err)
+		}
+
+		snapshotChanges, err := snapshot.GetChangedLinesForChecker(gitRoot, snap, compareResult)
+		if err != nil {
+			return nil, false, fmt.Errorf("failed to get changed lines from snapshot: %w", err)
+		}
+
+		var changes []gitpkg.ChangedLine
+		for _, sc := range snapshotChanges {
+			changes = append(changes, gitpkg.ChangedLine{
+				File:       sc.File,
+				LineNumber: sc.LineNumber,
+				Content:    sc.Content,
+				ChangeType: sc.ChangeType,
+			})
+		}
+
+		if err := snapshot.Delete(gitRoot); err != nil {
+			slog.Warn("Failed to delete snapshot", "error", err)
+		}
+
+		return changes, true, nil
+	}
+
+	slog.Info("Checking all changes (unstaged + staged)")
+	diffResult, err := gitpkg.GetAllChanges()
+	if err != nil {
+		return nil, false, fmt.Errorf("error getting git diff: %w", err)
+	}
+
+	return diffResult.Changes, false, nil
+}

package/commands/snapshot.go

@@ -1,10 +1,12 @@
 package commands
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"os"
 
+	"github.com/getsentry/sentry-go"
 	"github.com/tanagram/cli/snapshot"
 	"github.com/tanagram/cli/storage"
 	"github.com/tanagram/cli/utils"
@@ -18,9 +20,14 @@ var (
 )
 
 // Snapshot creates a snapshot of the current working directory state
-func Snapshot() error {
+func Snapshot(ctx context.Context) error {
+	span := sentry.StartSpan(ctx, "command.snapshot")
+	defer span.Finish()
+
 	// Find git root
+	findGitRootSpan := sentry.StartSpan(span.Context(), "storage.find_git_root")
 	gitRoot, err := findGitRoot()
+	findGitRootSpan.Finish()
 	if err != nil {
 		return err
 	}
@@ -46,9 +53,12 @@ func Snapshot() error {
 	}
 
 	// Create snapshot
+	createSnapshotSpan := sentry.StartSpan(span.Context(), "snapshot.create_optimized")
 	if err := createOptimized(gitRoot, targetFiles); err != nil {
+		createSnapshotSpan.Finish()
 		return fmt.Errorf("failed to create snapshot: %w", err)
 	}
+	createSnapshotSpan.Finish()
 
 	parentProcess := getParentProcess()
 	if parentProcess == "Cursor" || parentProcess == "cursor" {

package/commands/snapshot_test.go

@@ -2,6 +2,7 @@ package commands
 
 import (
 	"bytes"
+	"context"
 	"io"
 	"os"
 	"testing"
@@ -65,7 +66,7 @@ func TestSnapshot_Cursor(t *testing.T) {
 			r, w, _ := os.Pipe()
 			os.Stdout = w
 
-			err := Snapshot()
+			err := Snapshot(context.Background())
 
 			// Restore stdout
 			w.Close()

package/commands/sync.go

@@ -8,15 +8,23 @@ import (
 	"sync"
 	"time"
 
+	"github.com/getsentry/sentry-go"
 	"github.com/tanagram/cli/api"
 	"github.com/tanagram/cli/config"
 	"github.com/tanagram/cli/extractor"
 	"github.com/tanagram/cli/parser"
 	"github.com/tanagram/cli/storage"
+	"github.com/tanagram/cli/utils"
 )
 
 // Sync manually syncs all instruction files to the cache
-func Sync() error {
+func Sync(ctx context.Context) error {
+	span := sentry.StartSpan(ctx, "command.sync")
+	defer span.Finish()
+	ctx = span.Context()
+
+	utils.AddBreadcrumb("sync", "Starting policy sync", sentry.LevelInfo, nil)
+
 	// Get API key first before doing any work
 	apiKey, err := getAPIKey()
 	if err != nil {
@@ -24,13 +32,21 @@ func Sync() error {
 	}
 
 	// Find git root
+	findGitRootSpan := sentry.StartSpan(ctx, "storage.find_git_root")
 	gitRoot, err := storage.FindGitRoot()
+	findGitRootSpan.Finish()
 	if err != nil {
 		return err
 	}
 
+	utils.AddBreadcrumb("sync", "Found git root", sentry.LevelInfo, map[string]interface{}{
+		"git_root": gitRoot,
+	})
+
 	// Find all instruction files
+	findFilesSpan := sentry.StartSpan(ctx, "commands.find_instruction_files")
 	instructionFiles, err := FindInstructionFiles(gitRoot)
+	findFilesSpan.Finish()
 	if err != nil {
 		return err
 	}
@@ -42,7 +58,9 @@ func Sync() error {
 	fmt.Printf("Found %d instruction file(s)\n", len(instructionFiles))
 
 	// Load or create cache
+	loadCacheSpan := sentry.StartSpan(ctx, "storage.load_cache")
 	cache, err := storage.LoadCache(gitRoot)
+	loadCacheSpan.Finish()
 	if err != nil {
 		return fmt.Errorf("failed to load cache: %w", err)
 	}
@@ -74,9 +92,40 @@ func Sync() error {
 	}
 
 	// Parse and sync only changed files using LLM in parallel
-	fmt.Printf("\nSyncing policies with LLM (processing %d changed file(s) in parallel)...\n", len(filesToSync))
+	totalPolicies, err := extractPoliciesParallel(ctx, filesToSync, gitRoot, apiKey, cache)
+	if err != nil {
+		return err
+	}
+
+	// Save cache
+	if err := cache.Save(); err != nil {
+		return fmt.Errorf("failed to save cache: %w", err)
+	}
+
+	utils.AddBreadcrumb("sync", "Local sync complete", sentry.LevelInfo, map[string]interface{}{
+		"policies_synced": totalPolicies,
+		"files_synced":    len(filesToSync),
+	})
+
+	fmt.Printf("\n✓ Synced %d policies from %d changed file(s)\n", totalPolicies, len(filesToSync))
+
+	// Also sync cloud policies if user is authenticated
+	if err := syncCloudPolicies(gitRoot); err != nil {
+		// Don't fail the whole sync if cloud sync fails - just warn
+		fmt.Printf("\nWarning: Could not sync cloud policies: %v\n", err)
+		fmt.Println("(Run 'tanagram login' to sync policies from cloud)")
+	}
+
+	return nil
+}
+
+// extractPoliciesParallel extracts policies from files in parallel using the LLM
+func extractPoliciesParallel(ctx context.Context, filesToSync []string, gitRoot, apiKey string, cache *storage.Cache) (int, error) {
+	span := sentry.StartSpan(ctx, "extractor.extract_policies_parallel")
+	defer span.Finish()
+	span.SetData("files_to_sync", len(filesToSync))
 
-	ctx := context.Background()
+	fmt.Printf("\nSyncing policies with LLM (processing %d changed file(s) in parallel)...\n", len(filesToSync))
 
 	// Result type for collecting sync results
 	type syncResult struct {
@@ -130,24 +179,27 @@ func Sync() error {
 		close(results)
 	}()
 
+	// stopSpinner stops the spinner goroutine safely
+	stopSpinner := func() {
+		stop <- true
+		close(stop)
+		time.Sleep(50 * time.Millisecond)
+	}
+
 	// Collect results
 	totalPolicies := 0
 	for result := range results {
 		if result.err != nil {
-			stop <- true
-			close(stop)
-			time.Sleep(50 * time.Millisecond)
+			stopSpinner()
 			mu.Lock()
 			fmt.Printf("\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)
+			return 0, fmt.Errorf("failed to extract policies from %s: %w", result.file, result.err)
 		}
 
 		if err := cache.UpdateFile(result.file, result.policies); err != nil {
-			stop <- true
-			close(stop)
-			time.Sleep(50 * time.Millisecond)
-			return fmt.Errorf("failed to update cache for %s: %w", result.file, err)
+			stopSpinner()
+			return 0, fmt.Errorf("failed to update cache for %s: %w", result.file, err)
 		}
 
 		totalPolicies += len(result.policies)
@@ -160,25 +212,9 @@ func Sync() error {
 	}
 
 	// Stop spinner
-	stop <- true
-	close(stop)
-	time.Sleep(50 * time.Millisecond)
+	stopSpinner()
 
-	// Save cache
-	if err := cache.Save(); err != nil {
-		return fmt.Errorf("failed to save cache: %w", err)
-	}
-
-	fmt.Printf("\n✓ Synced %d policies from %d changed file(s)\n", totalPolicies, len(filesToSync))
-
-	// Also sync cloud policies if user is authenticated
-	if err := syncCloudPolicies(gitRoot); err != nil {
-		// Don't fail the whole sync if cloud sync fails - just warn
-		fmt.Printf("\nWarning: Could not sync cloud policies: %v\n", err)
-		fmt.Println("(Run 'tanagram login' to sync policies from cloud)")
-	}
-
-	return nil
+	return totalPolicies, nil
 }
 
 // FindInstructionFiles searches for instruction files in the git repository