@tanagram/cli 0.4.10 → 0.4.11

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.10",
+  "version": "0.4.11",
   "description": "Tanagram - Catch sloppy code before it ships",
   "main": "index.js",
   "bin": {

package/snapshot/snapshot.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/tanagram/cli/git"
 	"github.com/tanagram/cli/storage"
 )
 
@@ -21,6 +22,7 @@ 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
@@ -179,11 +181,18 @@ func CreateOptimized(gitRoot string, targetFiles []string) error {
 			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),
 		}
 	}
 
@@ -490,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)
+				}
+			}
+		}
+
+		// 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
+		}
 
-		// Include all non-empty lines from modified files
-		for i, line := range newLines {
-			if strings.TrimSpace(line) != "" {
+		// 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: "+",
 				})
 			}