@tanagram/cli 0.1.33 → 0.2.1

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

@@ -4,6 +4,7 @@ const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const pkg = require('./package.json');
 
 const GO_VERSION = '1.21.0';
 const GO_CACHE_DIR = path.join(os.homedir(), '.tanagram', `go-${GO_VERSION}`);
@@ -80,7 +81,8 @@ function buildBinary(goCommand) {
   console.log('🔧 Building Tanagram CLI...');
 
   try {
-    execSync(`"${goCommand}" build -o "${binaryPath}" .`, {
+    const ldflags = `-X 'main.Version=${pkg.version}'`;
+    execSync(`"${goCommand}" build -ldflags "${ldflags}" -o "${binaryPath}" .`, {
       cwd: __dirname,
       stdio: 'inherit',
       env: {

package/main.go

@@ -9,7 +9,11 @@ import (
 	"github.com/tanagram/cli/tui"
 )
 
+// Version is set in install.js via `-X` ldflags
+var Version = "dev"
+
 func main() {
+	metrics.SetVersion(Version)
 	metrics.Init()
 
 	exitCode := 0
@@ -40,6 +44,11 @@ func main() {
 			"command": "run",
 		})
 		err = commands.Run()
+	case "snapshot":
+		metrics.Track("cli.command.execute", map[string]interface{}{
+			"command": "snapshot",
+		})
+		err = commands.Snapshot()
 	case "sync":
 		metrics.Track("cli.command.execute", map[string]interface{}{
 			"command": "sync",
@@ -109,6 +118,9 @@ func main() {
 			return
 		}
 		return
+	case "version", "-v", "--version":
+		fmt.Println(Version)
+		return
 	case "help", "-h", "--help":
 		printHelp()
 		return
@@ -138,19 +150,23 @@ 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
   config list    Show hook installation status
+  version        Show the CLI version
   help           Show this help message
 
 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
+  tanagram version       # Show the version
 
 INSTRUCTION FILES:
   Tanagram looks for instruction files in your git repository:
@@ -158,6 +174,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

@@ -14,8 +14,14 @@ var (
 	// Injected at build time via -ldflags
 	posthogWriteKey = "phc_sMsUvf0nK50rZdztSlX9rDJqIreLcXj4dyGS0tORQpQ"
 	posthogHost     = "https://us.i.posthog.com"
+	version         = "dev"
 )
 
+// SetVersion sets the CLI version
+func SetVersion(v string) {
+	version = v
+}
+
 // Init initializes the PostHog client
 // Similar to PosthogService.py and webui/app/lib/posthog.ts
 func Init() {
@@ -117,6 +123,5 @@ func getDeploymentEnv() string {
 
 // getVersion returns the CLI version
 func getVersion() string {
-	// TODO: embed version at build time with -ldflags
-	return "0.1.14"
+	return version
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanagram/cli",
-  "version": "0.1.33",
+  "version": "0.2.1",
   "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)
+	}
+}