@tanagram/cli 0.4.9 → 0.4.10

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/package.json

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

package/snapshot/snapshot.go

@@ -1,11 +1,13 @@
 package snapshot
 
 import (
+	"bytes"
 	"crypto/md5"
 	"encoding/json"
 	"fmt"
 	"io"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"time"
@@ -23,8 +25,9 @@ type FileState struct {
 
 // 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 +35,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 +116,80 @@ 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
+		}
+
+		snapshot.Files[relPath] = &FileState{
+			Path:         relPath,
+			Hash:         hash,
+			Size:         info.Size(),
+			ModifiedTime: info.ModTime(),
+		}
+	}
+
+	return Save(gitRoot, snapshot)
+}
+
 // Load loads an existing snapshot
 func Load(gitRoot string) (*Snapshot, error) {
 	path := SnapshotPath(gitRoot)
@@ -146,6 +252,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{},