@tanagram/cli 0.4.13 → 0.4.14

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/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=

package/main.go

@@ -2,19 +2,30 @@ package main
 
 import (
 	"encoding/json"
+	"flag"
 	"fmt"
 	"io"
+	"log/slog"
 	"os"
+	"path/filepath"
+	"strings"
 
 	"github.com/tanagram/cli/commands"
 	"github.com/tanagram/cli/metrics"
 	"github.com/tanagram/cli/tui"
 	"github.com/tanagram/cli/utils"
+	"golang.org/x/term"
 )
 
 // Version is set in install.js via `-X` ldflags
 var Version = "dev"
 
+var (
+	flagLogLevel  = flag.String("log-level", "info", "log level: debug, info, warn, error")
+	flagLogFormat = flag.String("log-format", "text", "log format: text or json")
+	flagLogFile   = flag.String("log-file", "", "log output file path (defaults to stderr if not specified)")
+)
+
 func main() {
 	metrics.SetVersion(Version)
 	metrics.Init()
@@ -30,16 +41,50 @@ func main() {
 		os.Exit(exitCode)
 	}()
 
+	flag.Parse()
+
 	// Get subcommand (default to "run" if none provided)
 	subcommand := "run"
-	if len(os.Args) > 1 {
-		subcommand = os.Args[1]
+	args := flag.Args()
+	if len(args) > 0 {
+		subcommand = args[0]
 	}
 
 	metrics.Track("cli.start", map[string]interface{}{
 		"subcommand": subcommand,
 	})
 
+	var logOutput io.Writer = os.Stderr
+	if utils.GetParentProcess() == "claude" {
+		// We use "exit-code 2" behavior for claude: https://code.claude.com/docs/en/hooks#simple:-exit-code
+		// Claude expects communication (i.e. `stop` hook output) to come on `stderr`,
+		// Which means we want to send log output (i.e. not output-to-Claude) to `stdout`.
+		logOutput = os.Stdout
+	}
+	if *flagLogFile != "" {
+		logPath, logErr := createLogFile(*flagLogFile)
+		if logErr != nil {
+			slog.Error("Error setting up logging", "error", logErr)
+			exitCode = 1
+			return
+		}
+		logFile, logErr := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+		if logErr != nil {
+			slog.Error("Error opening log file", "error", logErr)
+			exitCode = 1
+			return
+		}
+		defer logFile.Close()
+		logOutput = logFile
+	}
+	isTTY := term.IsTerminal(int(os.Stdout.Fd()))
+	logger := newLogger(*flagLogLevel, *flagLogFormat, logOutput, isTTY)
+	slog.SetDefault(logger)
+
+	slog.Info("Running CLI with args",
+		"args", os.Args[1:],
+	)
+
 	// 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
@@ -54,11 +99,11 @@ func main() {
 				WorkspaceRoots []string `json:"workspace_roots"`
 			}
 			if err := json.Unmarshal(input, &payload); err != nil {
-				fmt.Fprintf(os.Stderr, "Error parsing input: %v\n", err)
+				slog.Error("Error parsing input", "error", err)
 			} else if len(payload.WorkspaceRoots) > 0 {
 				os.Chdir(payload.WorkspaceRoots[0])
 			} else {
-				fmt.Fprintf(os.Stderr, "No workspace roots found\n")
+				slog.Warn("No workspace roots found")
 			}
 		}
 	}
@@ -71,7 +116,7 @@ func main() {
 		})
 		// Auto-setup hooks on first run
 		if err := commands.EnsureHooksConfigured(); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error("Failed to configure hooks", "error", err)
 			exitCode = 1
 			return
 		}
@@ -87,7 +132,7 @@ func main() {
 		})
 		// Auto-setup hooks on first run
 		if err := commands.EnsureHooksConfigured(); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error("Failed to configure hooks", "error", err)
 			exitCode = 1
 			return
 		}
@@ -98,7 +143,7 @@ func main() {
 		})
 		// Auto-setup hooks on first run
 		if err := commands.EnsureHooksConfigured(); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error("Failed to configure hooks", "error", err)
 			exitCode = 1
 			return
 		}
@@ -152,7 +197,7 @@ func main() {
 		})
 		choice, err := tui.RunWelcomeScreen()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error("Welcome screen failed", "error", err)
 			exitCode = 1
 			return
 		}
@@ -183,7 +228,7 @@ func main() {
 		})
 		err := tui.RunPuzzleEditor()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			slog.Error("Puzzle editor failed", "error", err)
 			exitCode = 1
 			return
 		}
@@ -206,7 +251,7 @@ func main() {
 			"command": subcommand,
 			"error":   err.Error(),
 		})
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		slog.Error("Command failed", "command", subcommand, "error", err)
 		exitCode = 1
 		return
 	}
@@ -266,3 +311,58 @@ HOOK WORKFLOW:
 `
 	fmt.Print(help)
 }
+
+func newLogger(levelStr, format string, output io.Writer, isTTY bool) *slog.Logger {
+	var lvl slog.Level
+	switch strings.ToLower(levelStr) {
+	case "debug":
+		lvl = slog.LevelDebug
+	case "info":
+		lvl = slog.LevelInfo
+	case "warn", "warning":
+		lvl = slog.LevelWarn
+	case "error":
+		lvl = slog.LevelError
+	default:
+		lvl = slog.LevelInfo
+	}
+
+	opts := &slog.HandlerOptions{
+		Level: lvl,
+	}
+
+	var h slog.Handler
+	switch strings.ToLower(format) {
+	case "json":
+		h = slog.NewJSONHandler(output, opts)
+	default:
+		if isTTY {
+			opts.ReplaceAttr = func(groups []string, a slog.Attr) slog.Attr {
+				if a.Key == slog.TimeKey || a.Key == slog.LevelKey {
+					return slog.Attr{}
+				}
+				return a
+			}
+		}
+		h = slog.NewTextHandler(output, opts)
+	}
+
+	return slog.New(h)
+}
+
+func createLogFile(logFilePath string) (string, error) {
+	logPath := logFilePath
+	if strings.HasPrefix(logPath, "~/") {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", fmt.Errorf("getting home directory: %w", err)
+		}
+		logPath = filepath.Join(home, logPath[2:])
+	}
+
+	if err := os.MkdirAll(filepath.Dir(logPath), 0755); err != nil {
+		return "", fmt.Errorf("creating log directory: %w", err)
+	}
+
+	return logPath, nil
+}

package/package.json

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

package/utils/process.go

@@ -30,9 +30,10 @@ func GetParentProcess() string {
 			return
 		}
 
-		// Cursor runs hooks via `node` or `zsh` (I've seen both) in ~/.cursor
+		// Cursor runs hooks via `node` or a shell (I've seen both) in ~/.cursor
 		// Handle this case and make life easier for users of this function.
-		if name == "node" || name == "zsh" {
+		// `pwsh` is powershell: https://chatgpt.com/share/6927b015-2738-8000-ab6d-792e05c9401b
+		if name == "node" || name == "zsh" || name == "bash" || name == "fish" || name == "sh" || strings.Contains(name, "pwsh") {
 			cwd, err := parent.Cwd()
 			if err == nil && strings.Contains(cwd, ".cursor") {
 				parentProcessName = "cursor"