@tanagram/cli 0.1.4 → 0.1.6

package/checker/llm_integration.go

@@ -81,7 +81,7 @@ func checkFileWithLLM(ctx context.Context, file string, changes []git.ChangedLin
 			File:       file,
 			LineNumber: firstLine.LineNumber,
 			PolicyName: policy.Name,
-			Message:    fmt.Sprintf("%s\n\nLLM Analysis: %s", policy.Message, check.Reason),
+			Message:    check.Reason,
 			Code:       formatChangesForDisplay(changes),
 		})
 	}
@@ -100,20 +100,10 @@ func formatChangesForLLM(changes []git.ChangedLine) string {
 
 // formatChangesForDisplay creates a compact display of changed lines
 func formatChangesForDisplay(changes []git.ChangedLine) string {
-	if len(changes) == 1 {
+	// Just return the first line's content, trimmed
+	// Line numbers will be shown in the formatted output
+	if len(changes) > 0 {
 		return strings.TrimSpace(changes[0].Content)
 	}
-
-	var builder strings.Builder
-	for i, change := range changes {
-		if i > 0 {
-			builder.WriteString("\n")
-		}
-		builder.WriteString(fmt.Sprintf("L%d: %s", change.LineNumber, strings.TrimSpace(change.Content)))
-		if i >= 2 { // Limit to first 3 lines
-			builder.WriteString("\n...")
-			break
-		}
-	}
-	return builder.String()
+	return ""
 }

package/checker/matcher.go

@@ -3,6 +3,7 @@ package checker
 import (
 	"context"
 	"fmt"
+	"sort"
 	"strings"
 
 	"github.com/tanagram/cli/git"
@@ -44,12 +45,46 @@ func FormatViolations(result *CheckResult) string {
 		return "✓ No policy violations found"
 	}
 
+	// ANSI color codes
+	const (
+		colorReset = "\033[0m"
+		colorGray  = "\033[90m"
+	)
+
+	// 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 output strings.Builder
 	output.WriteString(fmt.Sprintf("✗ Found %d policy violation(s):\n\n", len(result.Violations)))
 
-	for _, v := range result.Violations {
-		output.WriteString(fmt.Sprintf("%s:%d - [%s] %s\n", v.File, v.LineNumber, v.PolicyName, v.Message))
-		output.WriteString(fmt.Sprintf("  > %s\n\n", v.Code))
+	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
+		})
+
+		output.WriteString(fmt.Sprintf("- %s\n\n", file))
+
+		for _, v := range violations {
+			// Print the code line in gray
+			output.WriteString(fmt.Sprintf("  %s%d: %s%s\n", colorGray, v.LineNumber, v.Code, colorReset))
+
+			// Print the violation message indented with arrow
+			output.WriteString(fmt.Sprintf("      ^ %s\n", v.Message))
+		}
+		output.WriteString("\n")
 	}
 
 	return output.String()

package/commands/run.go

@@ -5,11 +5,13 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sync"
 	"time"
 
 	"github.com/tanagram/cli/checker"
 	"github.com/tanagram/cli/extractor"
 	"github.com/tanagram/cli/git"
+	"github.com/tanagram/cli/parser"
 	"github.com/tanagram/cli/storage"
 )
 
@@ -69,38 +71,93 @@ func Run() error {
 
 	// Auto-sync if any files changed
 	if needsSync {
-		fmt.Printf("\nSyncing policies with LLM...\n")
+		fmt.Printf("\nSyncing policies with LLM (processing %d files in parallel)...\n", len(instructionFiles))
 
-		totalPolicies := 0
 		ctx := context.Background()
 
-		for i, file := range instructionFiles {
-			relPath, _ := filepath.Rel(gitRoot, file)
-
-			// Start spinner
-			stop := make(chan bool)
-			go spinner(stop, fmt.Sprintf("Processing %s (%d/%d)", relPath, i+1, len(instructionFiles)))
+		// Result type for collecting sync results
+		type syncResult struct {
+			file     string
+			relPath  string
+			policies []parser.Policy
+			err      error
+		}
 
-			policies, err := extractor.ExtractPoliciesFromFile(ctx, file)
+		// Channel to collect results
+		results := make(chan syncResult, len(instructionFiles))
+		var wg sync.WaitGroup
+
+		// Start spinner
+		stop := make(chan bool)
+		var completed int
+		var mu sync.Mutex
+		go func() {
+			chars := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+			i := 0
+			for {
+				select {
+				case <-stop:
+					fmt.Print("\r")
+					return
+				default:
+					mu.Lock()
+					c := completed
+					mu.Unlock()
+					fmt.Printf("\r%s Processing files... (%d/%d completed)", chars[i%len(chars)], c, len(instructionFiles))
+					i++
+					time.Sleep(100 * time.Millisecond)
+				}
+			}
+		}()
+
+		// Launch goroutines for each file
+		for _, file := range instructionFiles {
+			wg.Add(1)
+			go func(file string) {
+				defer wg.Done()
+				relPath, _ := filepath.Rel(gitRoot, file)
+				policies, err := extractor.ExtractPoliciesFromFile(ctx, file)
+				results <- syncResult{file, relPath, policies, err}
+			}(file)
+		}
 
-			// Stop spinner
-			stop <- true
-			close(stop)
-			time.Sleep(50 * time.Millisecond)
+		// Close results channel when all goroutines complete
+		go func() {
+			wg.Wait()
+			close(results)
+		}()
 
-			if err != nil {
-				fmt.Printf("\r✗ Failed to process %s\n", relPath)
-				return fmt.Errorf("failed to extract policies from %s: %w", file, err)
+		// Collect results
+		totalPolicies := 0
+		for result := range results {
+			mu.Lock()
+			completed++
+			mu.Unlock()
+
+			if result.err != nil {
+				stop <- true
+				close(stop)
+				time.Sleep(50 * time.Millisecond)
+				fmt.Printf("\r✗ Failed to process %s\n", result.relPath)
+				return fmt.Errorf("failed to extract policies from %s: %w", result.file, result.err)
 			}
 
-			if err := cache.UpdateFile(file, policies); err != nil {
-				return fmt.Errorf("failed to update cache for %s: %w", file, 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)
 			}
 
-			fmt.Printf("\r✓ %s - %d policies\n", relPath, len(policies))
-			totalPolicies += len(policies)
+			totalPolicies += len(result.policies)
+			fmt.Printf("\r✓ %s - %d policies\n", result.relPath, len(result.policies))
 		}
 
+		// 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)
 		}

package/commands/sync.go

@@ -5,9 +5,11 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sync"
 	"time"
 
 	"github.com/tanagram/cli/extractor"
+	"github.com/tanagram/cli/parser"
 	"github.com/tanagram/cli/storage"
 )
 
@@ -37,39 +39,94 @@ func Sync() error {
 		return fmt.Errorf("failed to load cache: %w", err)
 	}
 
-	// Parse and sync each file using LLM
-	fmt.Printf("\nSyncing policies with LLM...\n")
+	// Parse and sync each file using LLM in parallel
+	fmt.Printf("\nSyncing policies with LLM (processing %d files in parallel)...\n", len(instructionFiles))
 
-	totalPolicies := 0
 	ctx := context.Background()
 
-	for i, file := range instructionFiles {
-		relPath, _ := filepath.Rel(gitRoot, file)
-
-		// Start spinner
-		stop := make(chan bool)
-		go spinner(stop, fmt.Sprintf("Processing %s (%d/%d)", relPath, i+1, len(instructionFiles)))
+	// Result type for collecting sync results
+	type syncResult struct {
+		file     string
+		relPath  string
+		policies []parser.Policy
+		err      error
+	}
 
-		policies, err := extractor.ExtractPoliciesFromFile(ctx, file)
+	// Channel to collect results
+	results := make(chan syncResult, len(instructionFiles))
+	var wg sync.WaitGroup
+
+	// Start spinner
+	stop := make(chan bool)
+	var completed int
+	var mu sync.Mutex
+	go func() {
+		chars := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+		i := 0
+		for {
+			select {
+			case <-stop:
+				fmt.Print("\r")
+				return
+			default:
+				mu.Lock()
+				c := completed
+				mu.Unlock()
+				fmt.Printf("\r%s Processing files... (%d/%d completed)", chars[i%len(chars)], c, len(instructionFiles))
+				i++
+				time.Sleep(100 * time.Millisecond)
+			}
+		}
+	}()
+
+	// Launch goroutines for each file
+	for _, file := range instructionFiles {
+		wg.Add(1)
+		go func(file string) {
+			defer wg.Done()
+			relPath, _ := filepath.Rel(gitRoot, file)
+			policies, err := extractor.ExtractPoliciesFromFile(ctx, file)
+			results <- syncResult{file, relPath, policies, err}
+		}(file)
+	}
 
-		// Stop spinner
-		stop <- true
-		close(stop)
-		time.Sleep(50 * time.Millisecond)
+	// Close results channel when all goroutines complete
+	go func() {
+		wg.Wait()
+		close(results)
+	}()
 
-		if err != nil {
-			fmt.Printf("\r✗ Failed to process %s\n", relPath)
-			return fmt.Errorf("failed to extract policies from %s: %w", file, err)
+	// Collect results
+	totalPolicies := 0
+	for result := range results {
+		mu.Lock()
+		completed++
+		mu.Unlock()
+
+		if result.err != nil {
+			stop <- true
+			close(stop)
+			time.Sleep(50 * time.Millisecond)
+			fmt.Printf("\r✗ Failed to process %s\n", result.relPath)
+			return fmt.Errorf("failed to extract policies from %s: %w", result.file, result.err)
 		}
 
-		if err := cache.UpdateFile(file, policies); err != nil {
-			return fmt.Errorf("failed to update cache for %s: %w", file, 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)
 		}
 
-		fmt.Printf("\r✓ %s - %d policies\n", relPath, len(policies))
-		totalPolicies += len(policies)
+		totalPolicies += len(result.policies)
+		fmt.Printf("\r✓ %s - %d policies\n", result.relPath, len(result.policies))
 	}
 
+	// Stop spinner
+	stop <- true
+	close(stop)
+	time.Sleep(50 * time.Millisecond)
+
 	// Save cache
 	if err := cache.Save(); err != nil {
 		return fmt.Errorf("failed to save cache: %w", err)

package/package.json

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