@tanagram/cli 0.4.9 → 0.4.11

package/commands/snapshot.go

@@ -1,7 +1,9 @@
 package commands
 
 import (
+	"encoding/json"
 	"fmt"
+	"os"
 
 	"github.com/tanagram/cli/snapshot"
 	"github.com/tanagram/cli/storage"
@@ -11,7 +13,7 @@ import (
 // Extracted variables so that tests can override these
 var (
 	findGitRoot      = storage.FindGitRoot
-	createSnapshot   = snapshot.Create
+	createOptimized  = snapshot.CreateOptimized
 	getParentProcess = utils.GetParentProcess
 )
 
@@ -23,8 +25,28 @@ func Snapshot() error {
 		return err
 	}
 
+	var targetFiles []string
+
+	// Check if there is input on stdin (e.g. from Claude Code hook)
+	stat, err := os.Stdin.Stat()
+	if err == nil && (stat.Mode()&os.ModeCharDevice) == 0 && stat.Size() > 0 {
+		var input struct {
+			ToolInput struct {
+				FilePath string `json:"file_path"`
+			} `json:"tool_input"`
+		}
+
+		decoder := json.NewDecoder(os.Stdin)
+		// Ignore errors decoding, just proceed with empty target if fails
+		if err := decoder.Decode(&input); err == nil {
+			if input.ToolInput.FilePath != "" {
+				targetFiles = []string{input.ToolInput.FilePath}
+			}
+		}
+	}
+
 	// Create snapshot
-	if err := createSnapshot(gitRoot); err != nil {
+	if err := createOptimized(gitRoot, targetFiles); err != nil {
 		return fmt.Errorf("failed to create snapshot: %w", err)
 	}
 

package/git/diff.go

@@ -66,6 +66,40 @@ func GetAllChanges() (*DiffResult, error) {
 	return result, nil
 }
 
+// DiffFiles compares two files using git diff --no-index
+func DiffFiles(oldFile, newFile, displayPath string) (*DiffResult, error) {
+	cmd := exec.Command("git", "diff", "--no-index", "--unified=0", oldFile, newFile)
+	output, err := cmd.Output()
+	
+	// git diff --no-index returns exit code 1 if there are differences
+	// It returns 0 if identical
+	if err != nil {
+		if exitError, ok := err.(*exec.ExitError); ok {
+			if exitError.ExitCode() != 1 {
+				// Anything other than 0 or 1 is an actual error
+				return nil, fmt.Errorf("failed to run git diff: %w", err)
+			}
+			// Exit code 1 means differences found, proceed to parse
+		} else {
+			return nil, fmt.Errorf("failed to run git diff: %w", err)
+		}
+	}
+
+	// Parse the diff output
+	result, err := parseDiff(string(output))
+	if err != nil {
+		return nil, err
+	}
+
+	// Fix up the file paths in the result to match the displayPath
+	// git diff --no-index outputs temp file paths like "b/tmp/..."
+	for i := range result.Changes {
+		result.Changes[i].File = displayPath
+	}
+
+	return result, nil
+}
+
 // parseDiff parses unified diff format and extracts changed lines
 func parseDiff(diffText string) (*DiffResult, error) {
 	result := &DiffResult{

package/package.json

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

package/snapshot/snapshot.go

@@ -1,15 +1,18 @@
 package snapshot
 
 import (
+	"bytes"
 	"crypto/md5"
 	"encoding/json"
 	"fmt"
 	"io"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"time"
 
+	"github.com/tanagram/cli/git"
 	"github.com/tanagram/cli/storage"
 )
 
@@ -19,12 +22,14 @@ type FileState struct {
 	Hash         string    `json:"hash"`
 	Size         int64     `json:"size"`
 	ModifiedTime time.Time `json:"modified_time"`
+	Content      string    `json:"content,omitempty"`
 }
 
 // Snapshot represents a snapshot of the working directory
 type Snapshot struct {
-	Timestamp time.Time             `json:"timestamp"`
-	Files     map[string]*FileState `json:"files"`
+	Timestamp  time.Time             `json:"timestamp"`
+	HeadCommit string                `json:"head_commit,omitempty"`
+	Files      map[string]*FileState `json:"files"`
 }
 
 // SnapshotPath returns the path to the snapshot file
@@ -32,7 +37,36 @@ func SnapshotPath(gitRoot string) string {
 	return filepath.Join(gitRoot, ".tanagram", "snapshot.json")
 }
 
+// runGit executes a git command in the given directory
+func runGit(dir string, args ...string) (string, error) {
+	cmd := exec.Command("git", args...)
+	cmd.Dir = dir
+	out, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	return string(bytes.TrimSpace(out)), nil
+}
+
+// getHashAtCommit returns the MD5 hash of a file at a specific commit
+func getHashAtCommit(gitRoot, commit, path string) (string, error) {
+	// git show commit:path
+	cmd := exec.Command("git", "show", fmt.Sprintf("%s:%s", commit, path))
+	cmd.Dir = gitRoot
+
+	// We need to hash the output
+	h := md5.New()
+	cmd.Stdout = h
+
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("%x", h.Sum(nil)), nil
+}
+
 // Create creates a new snapshot of all tracked and modified files
+// This is kept for backward compatibility or fallback
 func Create(gitRoot string) error {
 	snapshot := &Snapshot{
 		Timestamp: time.Now(),
@@ -84,6 +118,87 @@ func Create(gitRoot string) error {
 	return Save(gitRoot, snapshot)
 }
 
+// CreateOptimized creates a snapshot using git status/target files
+func CreateOptimized(gitRoot string, targetFiles []string) error {
+	// Get current HEAD
+	headCommit, err := runGit(gitRoot, "rev-parse", "HEAD")
+	if err != nil {
+		// Fallback to full create if no git/head
+		return Create(gitRoot)
+	}
+
+	snapshot := &Snapshot{
+		Timestamp:  time.Now(),
+		HeadCommit: headCommit,
+		Files:      make(map[string]*FileState),
+	}
+
+	// Use a map to deduplicate files
+	filesToSnapshot := make(map[string]bool)
+
+	// 1. Add target files (if provided)
+	for _, f := range targetFiles {
+		filesToSnapshot[f] = true
+	}
+
+	// 2. Add all currently dirty files (modified/staged/untracked)
+	// This ensures that if the user has uncommitted changes, we record them
+	// so that we don't falsely attribute them to the agent later.
+	out, err := runGit(gitRoot, "status", "--porcelain")
+	if err == nil {
+		lines := strings.Split(out, "\n")
+		for _, line := range lines {
+			if len(line) < 4 {
+				continue
+			}
+			// Format: XY PATH or XY PATH -> NEWPATH
+			content := line[3:]
+			if idx := strings.Index(content, " -> "); idx != -1 {
+				// Rename, take the new path
+				content = content[idx+4:]
+			}
+			path := strings.Trim(content, "\"")
+			filesToSnapshot[path] = true
+		}
+	}
+
+	for relPath := range filesToSnapshot {
+		fullPath := filepath.Join(gitRoot, relPath)
+
+		// Skip if not exist (deleted)
+		info, err := os.Stat(fullPath)
+		if err != nil {
+			continue
+		}
+
+		// Skip directories
+		if info.IsDir() {
+			continue
+		}
+
+		hash, err := hashFile(fullPath)
+		if err != nil {
+			continue
+		}
+
+		// Read content
+		contentBytes, err := os.ReadFile(fullPath)
+		if err != nil {
+			continue
+		}
+
+		snapshot.Files[relPath] = &FileState{
+			Path:         relPath,
+			Hash:         hash,
+			Size:         info.Size(),
+			ModifiedTime: info.ModTime(),
+			Content:      string(contentBytes),
+		}
+	}
+
+	return Save(gitRoot, snapshot)
+}
+
 // Load loads an existing snapshot
 func Load(gitRoot string) (*Snapshot, error) {
 	path := SnapshotPath(gitRoot)
@@ -146,6 +261,80 @@ type CompareResult struct {
 
 // Compare compares the current working directory to a snapshot
 func Compare(gitRoot string, snapshot *Snapshot) (*CompareResult, error) {
+	if snapshot.HeadCommit == "" {
+		return compareLegacy(gitRoot, snapshot)
+	}
+
+	result := &CompareResult{
+		ModifiedFiles: []string{},
+		DeletedFiles:  []string{},
+		NewFiles:      []string{},
+	}
+
+	candidates := make(map[string]bool)
+
+	// 1. Files in snapshot
+	for f := range snapshot.Files {
+		candidates[f] = true
+	}
+
+	// 2. Files changed relative to HeadCommit
+	// git diff --name-only HeadCommit
+	out, err := runGit(gitRoot, "diff", "--name-only", snapshot.HeadCommit)
+	if err == nil {
+		for _, f := range strings.Split(out, "\n") {
+			if f != "" {
+				candidates[f] = true
+			}
+		}
+	}
+
+	// 3. Untracked files
+	// git ls-files --others --exclude-standard
+	out, err = runGit(gitRoot, "ls-files", "--others", "--exclude-standard")
+	if err == nil {
+		for _, f := range strings.Split(out, "\n") {
+			if f != "" {
+				candidates[f] = true
+			}
+		}
+	}
+
+	for path := range candidates {
+		// Determine Current Hash
+		var currentHash string
+		fullPath := filepath.Join(gitRoot, path)
+		info, err := os.Stat(fullPath)
+		if err == nil && !info.IsDir() {
+			currentHash, _ = hashFile(fullPath)
+		}
+
+		// Determine Snapshot Hash
+		var snapshotHash string
+		if state, ok := snapshot.Files[path]; ok {
+			snapshotHash = state.Hash
+		} else {
+			// Not in snapshot, assume equal to HeadCommit
+			// If file didn't exist in HeadCommit, getHashAtCommit returns err/empty
+			snapshotHash, _ = getHashAtCommit(gitRoot, snapshot.HeadCommit, path)
+		}
+
+		if currentHash == "" && snapshotHash == "" {
+			continue
+		}
+		if currentHash == "" {
+			result.DeletedFiles = append(result.DeletedFiles, path)
+		} else if snapshotHash == "" {
+			result.NewFiles = append(result.NewFiles, path)
+		} else if currentHash != snapshotHash {
+			result.ModifiedFiles = append(result.ModifiedFiles, path)
+		}
+	}
+
+	return result, nil
+}
+
+func compareLegacy(gitRoot string, snapshot *Snapshot) (*CompareResult, error) {
 	result := &CompareResult{
 		ModifiedFiles: []string{},
 		DeletedFiles:  []string{},
@@ -310,31 +499,113 @@ type ChangedLine struct {
 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 modified files, we diff against the snapshot version
 	for _, relPath := range compareResult.ModifiedFiles {
 		fullPath := filepath.Join(gitRoot, relPath)
 
-		// Read new content
+		// Get New Content (Current)
 		newData, err := os.ReadFile(fullPath)
 		if err != nil {
 			continue
 		}
-
-		// Skip binary files
 		if !isText(newData) {
 			continue
 		}
 
-		newLines := strings.Split(string(newData), "\n")
+		// Get Old Content (Snapshot)
+		var oldData []byte
+		
+		if fileState, ok := snapshot.Files[relPath]; ok && fileState.Content != "" {
+			// Was dirty -> use stored content
+			oldData = []byte(fileState.Content)
+		} else {
+			// Was clean -> use git show
+			// If it wasn't in snapshot.Files but is in ModifiedFiles, it must have been clean at HEAD
+			// and now is modified.
+			// Note: If snapshot.Files has it but Content is empty, that means it was clean but we stored it?
+			// No, CreateOptimized only stores Content for dirty files.
+			// But wait, CreateOptimized only adds files to snapshot.Files if they are dirty or targetted.
+			// If a file is NOT in snapshot.Files, it is assumed clean at HeadCommit.
+			
+			// However, compareResult.ModifiedFiles includes files that:
+			// 1. Were in snapshot (hash changed)
+			// 2. Were NOT in snapshot (current hash != HEAD hash)
+			
+			// Case 1: In snapshot
+			if fileState, ok := snapshot.Files[relPath]; ok {
+				if fileState.Content != "" {
+					oldData = []byte(fileState.Content)
+				} else {
+					// It was in snapshot but no content? This happens if it was > 1MB
+					// or if we used the legacy Create method which doesn't store content.
+					// In that case we fall back to reading from HEAD (imperfect but best effort)
+					// OR we just treat all lines as changed (current behavior) if we can't get old content.
+					
+					// Try to get from HEAD just in case it matches
+					hash, _ := getHashAtCommit(gitRoot, snapshot.HeadCommit, relPath)
+					if hash == fileState.Hash {
+						// It matches HEAD, so we can get content from HEAD
+						out, err := runGit(gitRoot, "show", fmt.Sprintf("%s:%s", snapshot.HeadCommit, relPath))
+						if err == nil {
+							oldData = []byte(out)
+						}
+					}
+				}
+			} else {
+				// Case 2: Not in snapshot (was clean at HEAD)
+				out, err := runGit(gitRoot, "show", fmt.Sprintf("%s:%s", snapshot.HeadCommit, relPath))
+				if err == nil {
+					oldData = []byte(out)
+				}
+			}
+		}
 
-		// Include all non-empty lines from modified files
-		for i, line := range newLines {
-			if strings.TrimSpace(line) != "" {
+		// If we couldn't get old data, fallback to treating all lines as new (safest)
+		if len(oldData) == 0 {
+			newLines := strings.Split(string(newData), "\n")
+			for i, line := range newLines {
+				if strings.TrimSpace(line) != "" {
+					changes = append(changes, ChangedLine{
+						File:       relPath,
+						LineNumber: i + 1,
+						Content:    line,
+						ChangeType: "+",
+					})
+				}
+			}
+			continue
+		}
+
+		// Do the diff
+		// Write to temp files
+		tmpOld, err := os.CreateTemp("", "tanagram-old-*")
+		if err != nil {
+			continue
+		}
+		defer os.Remove(tmpOld.Name())
+		tmpOld.Write(oldData)
+		tmpOld.Close()
+
+		tmpNew, err := os.CreateTemp("", "tanagram-new-*")
+		if err != nil {
+			continue
+		}
+		defer os.Remove(tmpNew.Name())
+		tmpNew.Write(newData)
+		tmpNew.Close()
+
+		diffResult, err := git.DiffFiles(tmpOld.Name(), tmpNew.Name(), relPath)
+		if err != nil {
+			continue
+		}
+
+		// Convert git.ChangedLine to snapshot.ChangedLine
+		for _, c := range diffResult.Changes {
+			if c.ChangeType == "+" {
 				changes = append(changes, ChangedLine{
 					File:       relPath,
-					LineNumber: i + 1,
-					Content:    line,
+					LineNumber: c.LineNumber,
+					Content:    c.Content,
 					ChangeType: "+",
 				})
 			}