@tanagram/cli 0.1.32 → 0.2.0

package/commands/config.go

@@ -45,30 +45,58 @@ func ConfigClaude() error {
 		settings["hooks"] = hooks
 	}
 
+	// Check if PreToolUse exists
+	preToolUse, preToolUseExist := hooks["PreToolUse"].([]interface{})
+	if !preToolUseExist {
+		preToolUse = []interface{}{}
+	}
+
 	// Check if PostToolUse exists
 	postToolUse, postToolUseExist := hooks["PostToolUse"].([]interface{})
 	if !postToolUseExist {
 		postToolUse = []interface{}{}
 	}
 
-	// Check if tanagram hook already exists
-	tanaramExists := false
+	// Check if tanagram hooks already exist
+	preHookExists := false
+	postHookExists := false
+
+	for _, hook := range preToolUse {
+		hookMap, ok := hook.(map[string]interface{})
+		if !ok {
+			continue
+		}
+
+		if matcher, ok := hookMap["matcher"].(string); ok && matcher == "Edit|Write" {
+			innerHooks, ok := hookMap["hooks"].([]interface{})
+			if ok {
+				for _, innerHook := range innerHooks {
+					innerHookMap, ok := innerHook.(map[string]interface{})
+					if ok {
+						if cmd, ok := innerHookMap["command"].(string); ok && cmd == "tanagram snapshot" {
+							preHookExists = true
+							break
+						}
+					}
+				}
+			}
+		}
+	}
+
 	for _, hook := range postToolUse {
 		hookMap, ok := hook.(map[string]interface{})
 		if !ok {
 			continue
 		}
 
-		// Check if this is the Edit|Write matcher
 		if matcher, ok := hookMap["matcher"].(string); ok && matcher == "Edit|Write" {
-			// Check if tanagram is in the hooks array
 			innerHooks, ok := hookMap["hooks"].([]interface{})
 			if ok {
 				for _, innerHook := range innerHooks {
 					innerHookMap, ok := innerHook.(map[string]interface{})
 					if ok {
 						if cmd, ok := innerHookMap["command"].(string); ok && cmd == "tanagram" {
-							tanaramExists = true
+							postHookExists = true
 							break
 						}
 					}
@@ -77,24 +105,38 @@ func ConfigClaude() error {
 		}
 	}
 
-	if tanaramExists {
-		fmt.Println("✓ Tanagram hook is already configured in ~/.claude/settings.json")
+	if preHookExists && postHookExists {
+		fmt.Println("✓ Tanagram hooks are already configured in ~/.claude/settings.json")
 		return nil
 	}
 
-	// Add tanagram hook
-	tanaramHook := map[string]interface{}{
-		"matcher": "Edit|Write",
-		"hooks": []interface{}{
-			map[string]interface{}{
-				"type":    "command",
-				"command": "tanagram",
+	if !preHookExists {
+		preHook := map[string]interface{}{
+			"matcher": "Edit|Write",
+			"hooks": []interface{}{
+				map[string]interface{}{
+					"type":    "command",
+					"command": "tanagram snapshot",
+				},
 			},
-		},
+		}
+		preToolUse = append(preToolUse, preHook)
+		hooks["PreToolUse"] = preToolUse
 	}
 
-	postToolUse = append(postToolUse, tanaramHook)
-	hooks["PostToolUse"] = postToolUse
+	if !postHookExists {
+		postHook := map[string]interface{}{
+			"matcher": "Edit|Write",
+			"hooks": []interface{}{
+				map[string]interface{}{
+					"type":    "command",
+					"command": "tanagram",
+				},
+			},
+		}
+		postToolUse = append(postToolUse, postHook)
+		hooks["PostToolUse"] = postToolUse
+	}
 
 	// Ensure .claude directory exists
 	claudeDir := filepath.Join(home, ".claude")
@@ -112,9 +154,12 @@ func ConfigClaude() error {
 		return fmt.Errorf("failed to write settings: %w", err)
 	}
 
-	fmt.Println("✓ Tanagram hook added to ~/.claude/settings.json")
-	fmt.Println("\nClaude Code will now automatically run Tanagram after Edit/Write operations.")
-	fmt.Println("Any policy violations will be sent to Claude for automatic fixing.")
+	fmt.Println("✓ Tanagram hooks added to ~/.claude/settings.json")
+	fmt.Println("\nClaude Code will now:")
+	fmt.Println("  - Snapshot file state before each Edit/Write (PreToolUse)")
+	fmt.Println("  - Check only Claude's changes after Edit/Write (PostToolUse)")
+	fmt.Println("  - Send policy violations to Claude for automatic fixing")
+	fmt.Println("\nThis prevents false positives from user-written code!")
 
 	return nil
 }
@@ -148,95 +193,120 @@ func ConfigList() error {
 
 // HookStatus represents the status of a hook configuration
 type HookStatus struct {
-	FileExists  bool
-	HookExists  bool
-	IsUpToDate  bool
-	Command     string
-	Error       error
+	FileExists     bool
+	PreHookExists  bool
+	PostHookExists bool
+	IsUpToDate     bool
+	PreCommand     string
+	PostCommand    string
+	Error          error
 }
 
 // checkHookStatus checks the status of Tanagram hook in a settings file
 func checkHookStatus(settingsPath string) HookStatus {
 	status := HookStatus{
-		FileExists:  false,
-		HookExists:  false,
-		IsUpToDate:  false,
-		Command:     "",
-		Error:       nil,
+		FileExists:     false,
+		PreHookExists:  false,
+		PostHookExists: false,
+		IsUpToDate:     false,
+		PreCommand:     "",
+		PostCommand:    "",
+		Error:          nil,
 	}
 
-	// Check if file exists
 	if _, err := os.Stat(settingsPath); os.IsNotExist(err) {
 		return status
 	}
 
 	status.FileExists = true
 
-	// Read file
 	data, err := os.ReadFile(settingsPath)
 	if err != nil {
 		status.Error = err
 		return status
 	}
 
-	// Parse JSON
 	var settings map[string]interface{}
 	if err := json.Unmarshal(data, &settings); err != nil {
 		status.Error = fmt.Errorf("invalid JSON: %w", err)
 		return status
 	}
 
-	// Check for hooks
 	hooks, ok := settings["hooks"].(map[string]interface{})
 	if !ok {
 		return status
 	}
 
-	postToolUse, ok := hooks["PostToolUse"].([]interface{})
-	if !ok {
-		return status
-	}
+	if preToolUse, ok := hooks["PreToolUse"].([]interface{}); ok {
+		for _, hook := range preToolUse {
+			hookMap, ok := hook.(map[string]interface{})
+			if !ok {
+				continue
+			}
 
-	// Look for tanagram hook
-	for _, hook := range postToolUse {
-		hookMap, ok := hook.(map[string]interface{})
-		if !ok {
-			continue
-		}
+			matcher, ok := hookMap["matcher"].(string)
+			if !ok || matcher != "Edit|Write" {
+				continue
+			}
 
-		// Check if this is the Edit|Write matcher
-		matcher, ok := hookMap["matcher"].(string)
-		if !ok {
-			continue
-		}
+			innerHooks, ok := hookMap["hooks"].([]interface{})
+			if !ok {
+				continue
+			}
 
-		// Check if tanagram is in the hooks array
-		innerHooks, ok := hookMap["hooks"].([]interface{})
-		if !ok {
-			continue
+			for _, innerHook := range innerHooks {
+				innerHookMap, ok := innerHook.(map[string]interface{})
+				if !ok {
+					continue
+				}
+
+				cmd, cmdOk := innerHookMap["command"].(string)
+				if cmdOk && strings.Contains(cmd, "tanagram snapshot") {
+					status.PreHookExists = true
+					status.PreCommand = cmd
+				}
+			}
 		}
+	}
+
+	if postToolUse, ok := hooks["PostToolUse"].([]interface{}); ok {
+		for _, hook := range postToolUse {
+			hookMap, ok := hook.(map[string]interface{})
+			if !ok {
+				continue
+			}
+
+			matcher, ok := hookMap["matcher"].(string)
+			if !ok || matcher != "Edit|Write" {
+				continue
+			}
 
-		for _, innerHook := range innerHooks {
-			innerHookMap, ok := innerHook.(map[string]interface{})
+			innerHooks, ok := hookMap["hooks"].([]interface{})
 			if !ok {
 				continue
 			}
 
-			cmd, cmdOk := innerHookMap["command"].(string)
-			hookType, typeOk := innerHookMap["type"].(string)
+			for _, innerHook := range innerHooks {
+				innerHookMap, ok := innerHook.(map[string]interface{})
+				if !ok {
+					continue
+				}
 
-			if cmdOk && strings.Contains(cmd, "tanagram") {
-				status.HookExists = true
-				status.Command = cmd
+				cmd, cmdOk := innerHookMap["command"].(string)
+				hookType, typeOk := innerHookMap["type"].(string)
 
-				// Check if it's up to date (should be "tanagram" and type "command" and matcher "Edit|Write")
-				if cmd == "tanagram" && typeOk && hookType == "command" && matcher == "Edit|Write" {
-					status.IsUpToDate = true
+				if cmdOk && cmd == "tanagram" && typeOk && hookType == "command" {
+					status.PostHookExists = true
+					status.PostCommand = cmd
 				}
 			}
 		}
 	}
 
+	if status.PreHookExists && status.PostHookExists {
+		status.IsUpToDate = true
+	}
+
 	return status
 }
 
@@ -253,7 +323,7 @@ func printHookStatus(status HookStatus, path string) {
 		return
 	}
 
-	if !status.HookExists {
+	if !status.PreHookExists && !status.PostHookExists {
 		fmt.Printf("  ○ Not configured\n")
 		fmt.Printf("  → Run: tanagram config claude\n")
 		return
@@ -261,12 +331,21 @@ func printHookStatus(status HookStatus, path string) {
 
 	if status.IsUpToDate {
 		fmt.Printf("  ✓ Configured and up to date\n")
-		fmt.Printf("  Command: %s\n", status.Command)
+		fmt.Printf("  PreToolUse: %s\n", status.PreCommand)
+		fmt.Printf("  PostToolUse: %s\n", status.PostCommand)
 		fmt.Printf("  Location: %s\n", path)
 	} else {
-		fmt.Printf("  ⚠ Configured but outdated\n")
-		fmt.Printf("  Current: %s\n", status.Command)
-		fmt.Printf("  Expected: tanagram\n")
+		fmt.Printf("  ⚠ Configured but incomplete\n")
+		if status.PreHookExists {
+			fmt.Printf("  ✓ PreToolUse: %s\n", status.PreCommand)
+		} else {
+			fmt.Printf("  ✗ PreToolUse: missing\n")
+		}
+		if status.PostHookExists {
+			fmt.Printf("  ✓ PostToolUse: %s\n", status.PostCommand)
+		} else {
+			fmt.Printf("  ✗ PostToolUse: missing\n")
+		}
 		fmt.Printf("  → Run: tanagram config claude\n")
 	}
 }

package/commands/run.go

@@ -14,6 +14,7 @@ import (
 	"github.com/tanagram/cli/git"
 	"github.com/tanagram/cli/metrics"
 	"github.com/tanagram/cli/parser"
+	"github.com/tanagram/cli/snapshot"
 	"github.com/tanagram/cli/storage"
 )
 
@@ -197,19 +198,68 @@ func Run() error {
 
 	fmt.Printf("Loaded %d policies\n", len(policies))
 
-	// Get all changes (unstaged + staged)
-	fmt.Println("Checking all changes (unstaged + staged)...")
-	diffResult, err := git.GetAllChanges()
-	if err != nil {
-		return fmt.Errorf("error getting git diff: %w", err)
+	// Check if a snapshot exists (from PreToolUse hook)
+	var changesToCheck []git.ChangedLine
+	useSnapshot := false
+
+	if snapshot.Exists(gitRoot) {
+		fmt.Println("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, git.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 {
+			fmt.Fprintf(os.Stderr, "Warning: failed to delete snapshot: %v\n", err)
+		}
+
+		useSnapshot = true
+	} else {
+		// No snapshot - fall back to checking all git changes
+		fmt.Println("Checking all changes (unstaged + staged)...")
+		diffResult, err := git.GetAllChanges()
+		if err != nil {
+			return fmt.Errorf("error getting git diff: %w", err)
+		}
+
+		changesToCheck = diffResult.Changes
 	}
 
-	if len(diffResult.Changes) == 0 {
-		fmt.Println("No changes to check")
+	if len(changesToCheck) == 0 {
+		if useSnapshot {
+			fmt.Println("No changes detected since snapshot")
+		} else {
+			fmt.Println("No changes to check")
+		}
 		return nil
 	}
 
-	fmt.Printf("Scanning %d changed lines...\n\n", len(diffResult.Changes))
+	fmt.Printf("Scanning %d changed lines...\n\n", len(changesToCheck))
 
 	// Get API key once upfront before checking
 	apiKey, err := config.GetAPIKey()
@@ -220,16 +270,17 @@ func Run() error {
 	// Check changes against policies (both regex and LLM-based)
 	ctx := context.Background()
 	checkStart := time.Now()
-	result := checker.CheckChanges(ctx, diffResult.Changes, policies, apiKey)
+	result := checker.CheckChanges(ctx, changesToCheck, policies, apiKey)
 	checkDuration := time.Since(checkStart)
 
 	// Track policy check results (similar to policy.execute.result in github-app)
 	metrics.Track("cli.policy.check.result", map[string]interface{}{
 		"policies_checked":   len(policies),
-		"changes_checked":    len(diffResult.Changes),
+		"changes_checked":    len(changesToCheck),
 		"violations_found":   len(result.Violations),
 		"has_violations":     len(result.Violations) > 0,
 		"duration_seconds":   checkDuration.Seconds(),
+		"used_snapshot":      useSnapshot,
 	})
 
 	// Handle results based on whether violations were found

package/commands/snapshot.go

@@ -0,0 +1,25 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/tanagram/cli/snapshot"
+	"github.com/tanagram/cli/storage"
+)
+
+// Snapshot creates a snapshot of the current working directory state
+func Snapshot() error {
+	// Find git root
+	gitRoot, err := storage.FindGitRoot()
+	if err != nil {
+		return err
+	}
+
+	// Create snapshot
+	if err := snapshot.Create(gitRoot); err != nil {
+		return fmt.Errorf("failed to create snapshot: %w", err)
+	}
+
+	// Silent success - no output for hooks
+	return nil
+}

package/install.js

@@ -79,15 +79,8 @@ function buildBinary(goCommand) {
 
   console.log('🔧 Building Tanagram CLI...');
 
-  // Build ldflags to inject PostHog key at build time
-  let ldflags = '';
-  if (process.env.POSTHOG_WRITE_KEY) {
-    ldflags = `-ldflags="-X 'github.com/tanagram/cli/metrics.posthogWriteKey=${process.env.POSTHOG_WRITE_KEY}'"`;
-    console.log('  📊 Injecting PostHog metrics key...');
-  }
-
   try {
-    execSync(`"${goCommand}" build ${ldflags} -o "${binaryPath}" .`, {
+    execSync(`"${goCommand}" build -o "${binaryPath}" .`, {
       cwd: __dirname,
       stdio: 'inherit',
       env: {

package/main.go

@@ -10,9 +10,18 @@ import (
 )
 
 func main() {
-	// Initialize metrics (similar to PosthogService initialization)
 	metrics.Init()
-	defer metrics.Close()
+
+	exitCode := 0
+	defer func() {
+		metrics.Track("cli.exit", map[string]interface{}{
+			"exit_code": exitCode,
+		})
+		metrics.Close()
+		// os.Exit immediately exits without calling other `defer`s, so we need to group these two statements
+		// and call them in the right order.
+		os.Exit(exitCode)
+	}()
 
 	// Get subcommand (default to "run" if none provided)
 	subcommand := "run"
@@ -20,20 +29,29 @@ func main() {
 		subcommand = os.Args[1]
 	}
 
+	metrics.Track("cli.start", map[string]interface{}{
+		"subcommand": subcommand,
+	})
+
 	var err error
 	switch subcommand {
 	case "run":
-		metrics.Track("command.execute", map[string]interface{}{
+		metrics.Track("cli.command.execute", map[string]interface{}{
 			"command": "run",
 		})
 		err = commands.Run()
+	case "snapshot":
+		metrics.Track("cli.command.execute", map[string]interface{}{
+			"command": "snapshot",
+		})
+		err = commands.Snapshot()
 	case "sync":
-		metrics.Track("command.execute", map[string]interface{}{
+		metrics.Track("cli.command.execute", map[string]interface{}{
 			"command": "sync",
 		})
 		err = commands.Sync()
 	case "list":
-		metrics.Track("command.execute", map[string]interface{}{
+		metrics.Track("cli.command.execute", map[string]interface{}{
 			"command": "list",
 		})
 		err = commands.List()
@@ -44,32 +62,35 @@ func main() {
 			fmt.Fprintf(os.Stderr, "\nAvailable subcommands:\n")
 			fmt.Fprintf(os.Stderr, "  claude    Setup Claude Code hook\n")
 			fmt.Fprintf(os.Stderr, "  list      Show hook installation status\n")
-			os.Exit(1)
+			exitCode = 1
+			return
 		}
 		subCmd := os.Args[2]
 		switch subCmd {
 		case "claude":
-			metrics.Track("command.execute", map[string]interface{}{
+			metrics.Track("cli.command.execute", map[string]interface{}{
 				"command": "config.claude",
 			})
 			err = commands.ConfigClaude()
 		case "list":
-			metrics.Track("command.execute", map[string]interface{}{
+			metrics.Track("cli.command.execute", map[string]interface{}{
 				"command": "config.list",
 			})
 			err = commands.ConfigList()
 		default:
 			fmt.Fprintf(os.Stderr, "Unknown config subcommand: %s\n", subCmd)
-			os.Exit(1)
+			exitCode = 1
+			return
 		}
 	case "welcome":
-		metrics.Track("command.execute", map[string]interface{}{
+		metrics.Track("cli.command.execute", map[string]interface{}{
 			"command": "welcome",
 		})
 		choice, err := tui.RunWelcomeScreen()
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			os.Exit(1)
+			exitCode = 1
+			return
 		}
 		switch choice {
 		case tui.ChoiceImportPolicies:
@@ -83,13 +104,14 @@ func main() {
 		}
 		return
 	case "puzzle":
-		metrics.Track("command.execute", map[string]interface{}{
+		metrics.Track("cli.command.execute", map[string]interface{}{
 			"command": "puzzle",
 		})
 		err := tui.RunPuzzleEditor()
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			os.Exit(1)
+			exitCode = 1
+			return
 		}
 		return
 	case "help", "-h", "--help":
@@ -98,16 +120,18 @@ func main() {
 	default:
 		fmt.Fprintf(os.Stderr, "Unknown command: %s\n\n", subcommand)
 		printHelp()
-		os.Exit(1)
+		exitCode = 1
+		return
 	}
 
 	if err != nil {
-		metrics.Track("command.error", map[string]interface{}{
+		metrics.Track("cli.command.error", map[string]interface{}{
 			"command": subcommand,
 			"error":   err.Error(),
 		})
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
+		exitCode = 1
+		return
 	}
 }
 
@@ -119,6 +143,7 @@ USAGE:
 
 COMMANDS:
   run            Check git changes against policies (default)
+  snapshot       Create a snapshot of current file state (used by PreToolUse hook)
   sync           Manually sync instruction files to cache
   list           Show all cached policies
   config claude  Setup Claude Code hook automatically
@@ -128,9 +153,10 @@ COMMANDS:
 EXAMPLES:
   tanagram               # Check changes (auto-syncs if files changed)
   tanagram run           # Same as above
+  tanagram snapshot      # Create snapshot before making changes
   tanagram sync          # Manually sync policies
   tanagram list          # View all cached policies
-  tanagram config claude # Setup Claude Code hook in ~/.claude/settings.json
+  tanagram config claude # Setup Claude Code hooks in ~/.claude/settings.json
   tanagram config list   # Show where hooks are installed
 
 INSTRUCTION FILES:
@@ -139,6 +165,13 @@ INSTRUCTION FILES:
   - Cursor rules: .cursor/rules/*.mdc
 
   Policies are cached and automatically resynced when files change.
+
+HOOK WORKFLOW:
+  When configured with 'tanagram config claude', two hooks are installed:
+  1. PreToolUse (Edit|Write): Creates snapshot before Claude makes changes
+  2. PostToolUse (Edit|Write): Checks only Claude's changes against policies
+
+  This prevents false positives from user-written code!
 `
 	fmt.Print(help)
 }

package/metrics/metrics.go

@@ -12,7 +12,7 @@ var (
 	client posthog.Client
 
 	// Injected at build time via -ldflags
-	posthogWriteKey = ""
+	posthogWriteKey = "phc_sMsUvf0nK50rZdztSlX9rDJqIreLcXj4dyGS0tORQpQ"
 	posthogHost     = "https://us.i.posthog.com"
 )
 
@@ -76,10 +76,16 @@ func Track(event string, properties map[string]interface{}) {
 	properties["arch"] = runtime.GOARCH
 	properties["cli_version"] = getVersion()
 
+	// Build properties - include all custom properties from the caller
+	props := posthog.NewProperties()
+	for key, value := range properties {
+		props.Set(key, value)
+	}
+
 	err := client.Enqueue(posthog.Capture{
 		DistinctId: getDistinctId(),
 		Event:      event,
-		Properties: properties,
+		Properties: props,
 		Timestamp:  time.Now(),
 	})
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanagram/cli",
-  "version": "0.1.32",
+  "version": "0.2.0",
   "description": "Tanagram - Catch sloppy code before it ships",
   "main": "index.js",
   "bin": {
@@ -42,6 +42,7 @@
     "llm/",
     "metrics/",
     "parser/",
+    "snapshot/",
     "storage/",
     "tui/",
     "main.go",

package/snapshot/snapshot.go

@@ -0,0 +1,418 @@
+package snapshot
+
+import (
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/tanagram/cli/storage"
+)
+
+// FileState represents the state of a single file
+type FileState struct {
+	Path         string    `json:"path"`
+	Hash         string    `json:"hash"`
+	Size         int64     `json:"size"`
+	ModifiedTime time.Time `json:"modified_time"`
+}
+
+// Snapshot represents a snapshot of the working directory
+type Snapshot struct {
+	Timestamp time.Time              `json:"timestamp"`
+	Files     map[string]*FileState  `json:"files"`
+}
+
+// SnapshotPath returns the path to the snapshot file
+func SnapshotPath(gitRoot string) string {
+	return filepath.Join(gitRoot, ".tanagram", "snapshot.json")
+}
+
+// Create creates a new snapshot of all tracked and modified files
+func Create(gitRoot string) error {
+	snapshot := &Snapshot{
+		Timestamp: time.Now(),
+		Files:     make(map[string]*FileState),
+	}
+
+	// Walk the git repository
+	err := filepath.Walk(gitRoot, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip .git directory and .tanagram directory
+		if info.IsDir() {
+			if info.Name() == ".git" || info.Name() == ".tanagram" || info.Name() == "node_modules" {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Get relative path
+		relPath, err := filepath.Rel(gitRoot, path)
+		if err != nil {
+			return err
+		}
+
+		// Calculate file hash
+		hash, err := hashFile(path)
+		if err != nil {
+			// Skip files we can't read (permissions, etc)
+			return nil
+		}
+
+		snapshot.Files[relPath] = &FileState{
+			Path:         relPath,
+			Hash:         hash,
+			Size:         info.Size(),
+			ModifiedTime: info.ModTime(),
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return fmt.Errorf("failed to walk directory: %w", err)
+	}
+
+	// Save snapshot
+	return Save(gitRoot, snapshot)
+}
+
+// Load loads an existing snapshot
+func Load(gitRoot string) (*Snapshot, error) {
+	path := SnapshotPath(gitRoot)
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil // No snapshot exists
+		}
+		return nil, fmt.Errorf("failed to read snapshot: %w", err)
+	}
+
+	var snapshot Snapshot
+	if err := json.Unmarshal(data, &snapshot); err != nil {
+		return nil, fmt.Errorf("failed to parse snapshot: %w", err)
+	}
+
+	return &snapshot, nil
+}
+
+// Save saves a snapshot to disk
+func Save(gitRoot string, snapshot *Snapshot) error {
+	path := SnapshotPath(gitRoot)
+
+	// Ensure .tanagram directory exists
+	tanagramDir := filepath.Join(gitRoot, ".tanagram")
+	if err := os.MkdirAll(tanagramDir, 0755); err != nil {
+		return fmt.Errorf("failed to create .tanagram directory: %w", err)
+	}
+
+	// Marshal snapshot
+	data, err := json.MarshalIndent(snapshot, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal snapshot: %w", err)
+	}
+
+	// Write to file
+	if err := os.WriteFile(path, data, 0644); err != nil {
+		return fmt.Errorf("failed to write snapshot: %w", err)
+	}
+
+	return nil
+}
+
+// Delete removes the snapshot file
+func Delete(gitRoot string) error {
+	path := SnapshotPath(gitRoot)
+	if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to delete snapshot: %w", err)
+	}
+	return nil
+}
+
+// CompareResult represents the result of comparing two snapshots
+type CompareResult struct {
+	ModifiedFiles []string
+	DeletedFiles  []string
+	NewFiles      []string
+}
+
+// Compare compares the current working directory to a snapshot
+func Compare(gitRoot string, snapshot *Snapshot) (*CompareResult, error) {
+	result := &CompareResult{
+		ModifiedFiles: []string{},
+		DeletedFiles:  []string{},
+		NewFiles:      []string{},
+	}
+
+	// Get current file states
+	currentFiles := make(map[string]*FileState)
+	err := filepath.Walk(gitRoot, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip directories
+		if info.IsDir() {
+			if info.Name() == ".git" || info.Name() == ".tanagram" || info.Name() == "node_modules" {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Get relative path
+		relPath, err := filepath.Rel(gitRoot, path)
+		if err != nil {
+			return err
+		}
+
+		// Calculate file hash
+		hash, err := hashFile(path)
+		if err != nil {
+			return nil
+		}
+
+		currentFiles[relPath] = &FileState{
+			Path:         relPath,
+			Hash:         hash,
+			Size:         info.Size(),
+			ModifiedTime: info.ModTime(),
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to walk directory: %w", err)
+	}
+
+	// Find modified and new files
+	for path, currentState := range currentFiles {
+		if snapshotState, exists := snapshot.Files[path]; exists {
+			// File existed in snapshot - check if modified
+			if currentState.Hash != snapshotState.Hash {
+				result.ModifiedFiles = append(result.ModifiedFiles, path)
+			}
+		} else {
+			// File is new
+			result.NewFiles = append(result.NewFiles, path)
+		}
+	}
+
+	// Find deleted files
+	for path := range snapshot.Files {
+		if _, exists := currentFiles[path]; !exists {
+			result.DeletedFiles = append(result.DeletedFiles, path)
+		}
+	}
+
+	return result, nil
+}
+
+// GetChangedFileContents reads the contents of files that changed
+func GetChangedFileContents(gitRoot string, compareResult *CompareResult) (map[string]string, error) {
+	contents := make(map[string]string)
+
+	// Read contents of modified and new files
+	allChangedFiles := append(compareResult.ModifiedFiles, compareResult.NewFiles...)
+
+	for _, relPath := range allChangedFiles {
+		fullPath := filepath.Join(gitRoot, relPath)
+
+		// Skip binary files and very large files
+		info, err := os.Stat(fullPath)
+		if err != nil {
+			continue
+		}
+
+		// Skip files larger than 1MB
+		if info.Size() > 1024*1024 {
+			continue
+		}
+
+		data, err := os.ReadFile(fullPath)
+		if err != nil {
+			continue
+		}
+
+		// Check if file is likely text
+		if isText(data) {
+			contents[relPath] = string(data)
+		}
+	}
+
+	return contents, nil
+}
+
+// hashFile calculates the MD5 hash of a file
+func hashFile(path string) (string, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	hash := md5.New()
+	if _, err := io.Copy(hash, file); err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("%x", hash.Sum(nil)), nil
+}
+
+// isText checks if data is likely text (not binary)
+func isText(data []byte) bool {
+	if len(data) == 0 {
+		return true
+	}
+
+	// Check first 512 bytes for null bytes
+	checkLen := len(data)
+	if checkLen > 512 {
+		checkLen = 512
+	}
+
+	for i := 0; i < checkLen; i++ {
+		if data[i] == 0 {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Exists checks if a snapshot exists
+func Exists(gitRoot string) bool {
+	_, err := os.Stat(SnapshotPath(gitRoot))
+	return err == nil
+}
+
+// Note: We use a simple approach here - for modified files, we include ALL lines
+// A more sophisticated approach would do line-by-line diffing to find exact changes
+// But this works well enough for our use case since we only check files that changed
+
+// GetChangedLinesForChecker extracts line-level changes and returns them in a format
+// compatible with what the checker expects (same as git diff output)
+type ChangedLine struct {
+	File       string
+	LineNumber int
+	Content    string
+	ChangeType string // "+" for added/modified
+}
+
+func GetChangedLinesForChecker(gitRoot string, snapshot *Snapshot, compareResult *CompareResult) ([]ChangedLine, error) {
+	var changes []ChangedLine
+
+	// For each modified file, include all non-empty lines
+	// (we can't easily determine which specific lines changed without doing a full diff)
+	for _, relPath := range compareResult.ModifiedFiles {
+		fullPath := filepath.Join(gitRoot, relPath)
+
+		// Read new content
+		newData, err := os.ReadFile(fullPath)
+		if err != nil {
+			continue
+		}
+
+		// Skip binary files
+		if !isText(newData) {
+			continue
+		}
+
+		newLines := strings.Split(string(newData), "\n")
+
+		// Include all non-empty lines from modified files
+		for i, line := range newLines {
+			if strings.TrimSpace(line) != "" {
+				changes = append(changes, ChangedLine{
+					File:       relPath,
+					LineNumber: i + 1,
+					Content:    line,
+					ChangeType: "+",
+				})
+			}
+		}
+	}
+
+	// For new files, all lines are "added"
+	for _, relPath := range compareResult.NewFiles {
+		fullPath := filepath.Join(gitRoot, relPath)
+
+		data, err := os.ReadFile(fullPath)
+		if err != nil {
+			continue
+		}
+
+		if !isText(data) {
+			continue
+		}
+
+		lines := strings.Split(string(data), "\n")
+		for i, line := range lines {
+			if strings.TrimSpace(line) != "" {
+				changes = append(changes, ChangedLine{
+					File:       relPath,
+					LineNumber: i + 1,
+					Content:    line,
+					ChangeType: "+",
+				})
+			}
+		}
+	}
+
+	return changes, nil
+}
+
+// init adds .tanagram to .gitignore if not already present
+func EnsureGitIgnore(gitRoot string) error {
+	gitignorePath := filepath.Join(gitRoot, ".gitignore")
+
+	// Read existing .gitignore
+	var existingContent string
+	data, err := os.ReadFile(gitignorePath)
+	if err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to read .gitignore: %w", err)
+	}
+	if err == nil {
+		existingContent = string(data)
+	}
+
+	// Check if .tanagram is already in .gitignore
+	if strings.Contains(existingContent, ".tanagram") {
+		return nil
+	}
+
+	// Append .tanagram to .gitignore
+	f, err := os.OpenFile(gitignorePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf("failed to open .gitignore: %w", err)
+	}
+	defer f.Close()
+
+	if existingContent != "" && !strings.HasSuffix(existingContent, "\n") {
+		if _, err := f.WriteString("\n"); err != nil {
+			return err
+		}
+	}
+
+	if _, err := f.WriteString(".tanagram/\n"); err != nil {
+		return fmt.Errorf("failed to write to .gitignore: %w", err)
+	}
+
+	return nil
+}
+
+func init() {
+	// Try to add .tanagram to .gitignore when package is loaded
+	gitRoot, err := storage.FindGitRoot()
+	if err == nil {
+		_ = EnsureGitIgnore(gitRoot)
+	}
+}