diffstalker 0.2.0 → 0.2.2

package/dist/core/GitStateManager.js

@@ -1,11 +1,12 @@
 import * as path from 'node:path';
 import * as fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { watch } from 'chokidar';
 import { EventEmitter } from 'node:events';
 import ignore from 'ignore';
 import { getQueueForRepo, removeQueueForRepo } from './GitOperationQueue.js';
-import { getStatus, stageFile, unstageFile, stageAll as gitStageAll, unstageAll as gitUnstageAll, discardChanges as gitDiscardChanges, commit as gitCommit, getHeadMessage, getCommitHistory, } from '../git/status.js';
-import { getDiff, getDiffForUntracked, getStagedDiff, getDefaultBaseBranch, getCandidateBaseBranches, getDiffBetweenRefs, getCompareDiffWithUncommitted, getCommitDiff, } from '../git/diff.js';
+import { getStatus, stageFile, unstageFile, stageAll as gitStageAll, unstageAll as gitUnstageAll, discardChanges as gitDiscardChanges, commit as gitCommit, getHeadMessage, getCommitHistory, stageHunk as gitStageHunk, unstageHunk as gitUnstageHunk, } from '../git/status.js';
+import { getDiff, getDiffForUntracked, getStagedDiff, getDefaultBaseBranch, getCandidateBaseBranches, getDiffBetweenRefs, getCompareDiffWithUncommitted, getCommitDiff, countHunksPerFile, } from '../git/diff.js';
 import { getCachedBaseBranch, setCachedBaseBranch } from '../utils/baseBranchCache.js';
 /**
  * GitStateManager manages git state independent of React.
@@ -16,15 +17,17 @@ export class GitStateManager extends EventEmitter {
     queue;
     gitWatcher = null;
     workingDirWatcher = null;
-    ignorer = null;
+    ignorers = new Map();
+    diffDebounceTimer = null;
     // Current state
     _state = {
         status: null,
         diff: null,
-        stagedDiff: '',
+        combinedFileDiffs: null,
         selectedFile: null,
         isLoading: false,
         error: null,
+        hunkCounts: null,
     };
     _compareState = {
         compareDiff: null,
@@ -77,24 +80,49 @@ export class GitStateManager extends EventEmitter {
         this.emit('compare-selection-change', this._compareSelectionState);
     }
     /**
-     * Load gitignore patterns from .gitignore and .git/info/exclude.
-     * Returns an Ignore instance that can test paths.
+     * Load gitignore patterns from all .gitignore files and .git/info/exclude.
+     * Returns a Map of directory → Ignore instance, where each instance handles
+     * patterns relative to its own directory (matching how git scopes .gitignore files).
      */
-    loadGitignore() {
-        const ig = ignore();
-        // Always ignore .git directory (has its own dedicated watcher)
-        ig.add('.git');
-        // Load .gitignore if it exists
-        const gitignorePath = path.join(this.repoPath, '.gitignore');
-        if (fs.existsSync(gitignorePath)) {
-            ig.add(fs.readFileSync(gitignorePath, 'utf-8'));
+    loadGitignores() {
+        const ignorers = new Map();
+        // Root ignorer: .git dir + root .gitignore + .git/info/exclude
+        const rootIg = ignore();
+        rootIg.add('.git');
+        const rootGitignorePath = path.join(this.repoPath, '.gitignore');
+        if (fs.existsSync(rootGitignorePath)) {
+            rootIg.add(fs.readFileSync(rootGitignorePath, 'utf-8'));
         }
-        // Load .git/info/exclude if it exists (repo-specific ignores)
         const excludePath = path.join(this.repoPath, '.git', 'info', 'exclude');
         if (fs.existsSync(excludePath)) {
-            ig.add(fs.readFileSync(excludePath, 'utf-8'));
+            rootIg.add(fs.readFileSync(excludePath, 'utf-8'));
+        }
+        ignorers.set('', rootIg);
+        // Find all nested .gitignore files using git ls-files
+        try {
+            const output = execFileSync('git', ['ls-files', '-z', '--cached', '--others', '**/.gitignore'], { cwd: this.repoPath, encoding: 'utf-8' });
+            for (const entry of output.split('\0')) {
+                if (!entry || entry === '.gitignore')
+                    continue;
+                if (!entry.endsWith('.gitignore'))
+                    continue;
+                const dir = path.dirname(entry);
+                const absPath = path.join(this.repoPath, entry);
+                try {
+                    const content = fs.readFileSync(absPath, 'utf-8');
+                    const ig = ignore();
+                    ig.add(content);
+                    ignorers.set(dir, ig);
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+        }
+        catch {
+            // git ls-files failed — we still have the root ignorer
         }
-        return ig;
+        return ignorers;
     }
     /**
      * Start watching for file changes.
@@ -117,19 +145,26 @@ export class GitStateManager extends EventEmitter {
             interval: 100,
         });
         // --- Working directory watcher with gitignore support ---
-        this.ignorer = this.loadGitignore();
+        this.ignorers = this.loadGitignores();
         this.workingDirWatcher = watch(this.repoPath, {
             persistent: true,
             ignoreInitial: true,
             ignored: (filePath) => {
-                // Get path relative to repo root
                 const relativePath = path.relative(this.repoPath, filePath);
-                // Don't ignore the repo root itself
                 if (!relativePath)
                     return false;
-                // Check against gitignore patterns
-                // When this returns true for a directory, chokidar won't recurse into it
-                return this.ignorer?.ignores(relativePath) ?? false;
+                // Walk ancestor directories from root to parent, checking each ignorer
+                const parts = relativePath.split('/');
+                for (let depth = 0; depth < parts.length; depth++) {
+                    const dir = depth === 0 ? '' : parts.slice(0, depth).join('/');
+                    const ig = this.ignorers.get(dir);
+                    if (ig) {
+                        const relToDir = depth === 0 ? relativePath : parts.slice(depth).join('/');
+                        if (ig.ignores(relToDir))
+                            return true;
+                    }
+                }
+                return false;
             },
             awaitWriteFinish: {
                 stabilityThreshold: 100,
@@ -140,7 +175,7 @@ export class GitStateManager extends EventEmitter {
         this.gitWatcher.on('change', (filePath) => {
             // Reload gitignore patterns if .gitignore changed
             if (filePath === gitignorePath) {
-                this.ignorer = this.loadGitignore();
+                this.ignorers = this.loadGitignores();
             }
             scheduleRefresh();
         });
@@ -162,15 +197,47 @@ export class GitStateManager extends EventEmitter {
      * Stop watching and clean up resources.
      */
     dispose() {
+        if (this.diffDebounceTimer)
+            clearTimeout(this.diffDebounceTimer);
         this.gitWatcher?.close();
         this.workingDirWatcher?.close();
         removeQueueForRepo(this.repoPath);
     }
     /**
      * Schedule a refresh (coalesced if one is already pending).
+     * Also refreshes history and compare data if they were previously loaded.
      */
     scheduleRefresh() {
-        this.queue.scheduleRefresh(() => this.doRefresh());
+        this.queue.scheduleRefresh(async () => {
+            await this.doRefresh();
+            // Also refresh history if it was loaded (has commits)
+            if (this._historyState.commits.length > 0) {
+                await this.doLoadHistory();
+            }
+            // Also refresh compare if it was loaded (has a base branch set)
+            if (this._compareState.compareBaseBranch) {
+                await this.doRefreshCompareDiff(false);
+            }
+        });
+    }
+    /**
+     * Schedule a lightweight status-only refresh (no diff fetching).
+     * Used after stage/unstage where the diff view updates on file selection.
+     */
+    scheduleStatusRefresh() {
+        this.queue.scheduleRefresh(async () => {
+            const newStatus = await getStatus(this.repoPath);
+            if (!newStatus.isRepo) {
+                this.updateState({
+                    status: newStatus,
+                    diff: null,
+                    isLoading: false,
+                    error: 'Not a git repository',
+                });
+                return;
+            }
+            this.updateState({ status: newStatus, isLoading: false });
+        });
     }
     /**
      * Immediately refresh git state.
@@ -186,51 +253,29 @@ export class GitStateManager extends EventEmitter {
                 this.updateState({
                     status: newStatus,
                     diff: null,
-                    stagedDiff: '',
                     isLoading: false,
                     error: 'Not a git repository',
                 });
                 return;
             }
-            // Fetch all diffs atomically
-            const [allStagedDiff, allUnstagedDiff] = await Promise.all([
-                getStagedDiff(this.repoPath),
+            // Fetch unstaged and staged diffs in parallel
+            const [allUnstagedDiff, allStagedDiff] = await Promise.all([
                 getDiff(this.repoPath, undefined, false),
+                getDiff(this.repoPath, undefined, true),
             ]);
+            // Count hunks per file for the file list display
+            const hunkCounts = {
+                unstaged: countHunksPerFile(allUnstagedDiff.raw),
+                staged: countHunksPerFile(allStagedDiff.raw),
+            };
             // Determine display diff based on selected file
-            let displayDiff;
-            const currentSelectedFile = this._state.selectedFile;
-            if (currentSelectedFile) {
-                const currentFile = newStatus.files.find((f) => f.path === currentSelectedFile.path && f.staged === currentSelectedFile.staged);
-                if (currentFile) {
-                    if (currentFile.status === 'untracked') {
-                        displayDiff = await getDiffForUntracked(this.repoPath, currentFile.path);
-                    }
-                    else {
-                        displayDiff = await getDiff(this.repoPath, currentFile.path, currentFile.staged);
-                    }
-                }
-                else {
-                    // File no longer exists - clear selection
-                    displayDiff = allUnstagedDiff.raw ? allUnstagedDiff : allStagedDiff;
-                    this.updateState({ selectedFile: null });
-                }
-            }
-            else {
-                if (allUnstagedDiff.raw) {
-                    displayDiff = allUnstagedDiff;
-                }
-                else if (allStagedDiff.raw) {
-                    displayDiff = allStagedDiff;
-                }
-                else {
-                    displayDiff = { raw: '', lines: [] };
-                }
-            }
+            const { displayDiff, combinedFileDiffs } = await this.resolveFileDiffs(newStatus, allUnstagedDiff);
+            // Batch status + diffs into a single update to avoid flicker
             this.updateState({
                 status: newStatus,
                 diff: displayDiff,
-                stagedDiff: allStagedDiff.raw,
+                combinedFileDiffs,
+                hunkCounts,
                 isLoading: false,
             });
         }
@@ -241,47 +286,113 @@ export class GitStateManager extends EventEmitter {
             });
         }
     }
+    /**
+     * Resolve display diff and combined diffs for the currently selected file.
+     */
+    async resolveFileDiffs(newStatus, fallbackDiff) {
+        const currentSelectedFile = this._state.selectedFile;
+        if (!currentSelectedFile) {
+            return { displayDiff: fallbackDiff, combinedFileDiffs: null };
+        }
+        // Match by path + staged, falling back to path-only (handles staging state changes)
+        const currentFile = newStatus.files.find((f) => f.path === currentSelectedFile.path && f.staged === currentSelectedFile.staged) ?? newStatus.files.find((f) => f.path === currentSelectedFile.path);
+        if (!currentFile) {
+            this.updateState({ selectedFile: null });
+            return { displayDiff: fallbackDiff, combinedFileDiffs: null };
+        }
+        if (currentFile.status === 'untracked') {
+            const displayDiff = await getDiffForUntracked(this.repoPath, currentFile.path);
+            return {
+                displayDiff,
+                combinedFileDiffs: { unstaged: displayDiff, staged: { raw: '', lines: [] } },
+            };
+        }
+        const [unstagedFileDiff, stagedFileDiff] = await Promise.all([
+            getDiff(this.repoPath, currentFile.path, false),
+            getDiff(this.repoPath, currentFile.path, true),
+        ]);
+        const displayDiff = currentFile.staged ? stagedFileDiff : unstagedFileDiff;
+        return {
+            displayDiff,
+            combinedFileDiffs: { unstaged: unstagedFileDiff, staged: stagedFileDiff },
+        };
+    }
     /**
      * Select a file and update the diff display.
+     * The selection highlight updates immediately; the diff fetch is debounced
+     * so rapid arrow-key presses only spawn one git process for the final file.
      */
-    async selectFile(file) {
+    selectFile(file) {
         this.updateState({ selectedFile: file });
         if (!this._state.status?.isRepo)
             return;
-        await this.queue.enqueue(async () => {
-            if (file) {
-                let fileDiff;
-                if (file.status === 'untracked') {
-                    fileDiff = await getDiffForUntracked(this.repoPath, file.path);
-                }
-                else {
-                    fileDiff = await getDiff(this.repoPath, file.path, file.staged);
-                }
-                this.updateState({ diff: fileDiff });
+        if (this.diffDebounceTimer) {
+            // Already cooling down — reset the timer and fetch when it expires
+            clearTimeout(this.diffDebounceTimer);
+            this.diffDebounceTimer = setTimeout(() => {
+                this.diffDebounceTimer = null;
+                this.fetchDiffForSelection();
+            }, 20);
+        }
+        else {
+            // First call — fetch immediately, then start cooldown
+            this.fetchDiffForSelection();
+            this.diffDebounceTimer = setTimeout(() => {
+                this.diffDebounceTimer = null;
+            }, 20);
+        }
+    }
+    fetchDiffForSelection() {
+        const file = this._state.selectedFile;
+        this.queue
+            .enqueue(async () => {
+            if (file !== this._state.selectedFile)
+                return;
+            await this.doFetchDiffForFile(file);
+        })
+            .catch((err) => {
+            this.updateState({
+                error: `Failed to load diff: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        });
+    }
+    async doFetchDiffForFile(file) {
+        if (!file) {
+            const allDiff = await getStagedDiff(this.repoPath);
+            if (this._state.selectedFile === null) {
+                this.updateState({ diff: allDiff, combinedFileDiffs: null });
             }
-            else {
-                const allDiff = await getStagedDiff(this.repoPath);
-                this.updateState({ diff: allDiff });
+            return;
+        }
+        if (file.status === 'untracked') {
+            const fileDiff = await getDiffForUntracked(this.repoPath, file.path);
+            if (file === this._state.selectedFile) {
+                this.updateState({
+                    diff: fileDiff,
+                    combinedFileDiffs: { unstaged: fileDiff, staged: { raw: '', lines: [] } },
+                });
             }
-        });
+            return;
+        }
+        const [unstagedDiff, stagedDiff] = await Promise.all([
+            getDiff(this.repoPath, file.path, false),
+            getDiff(this.repoPath, file.path, true),
+        ]);
+        if (file === this._state.selectedFile) {
+            const displayDiff = file.staged ? stagedDiff : unstagedDiff;
+            this.updateState({
+                diff: displayDiff,
+                combinedFileDiffs: { unstaged: unstagedDiff, staged: stagedDiff },
+            });
+        }
     }
     /**
-     * Stage a file with optimistic update.
+     * Stage a file.
      */
     async stage(file) {
-        // Optimistic update
-        const currentStatus = this._state.status;
-        if (currentStatus) {
-            this.updateState({
-                status: {
-                    ...currentStatus,
-                    files: currentStatus.files.map((f) => f.path === file.path && !f.staged ? { ...f, staged: true } : f),
-                },
-            });
-        }
         try {
             await this.queue.enqueueMutation(() => stageFile(this.repoPath, file.path));
-            this.scheduleRefresh();
+            this.scheduleStatusRefresh();
         }
         catch (err) {
             await this.refresh();
@@ -291,27 +402,47 @@ export class GitStateManager extends EventEmitter {
         }
     }
     /**
-     * Unstage a file with optimistic update.
+     * Unstage a file.
      */
     async unstage(file) {
-        // Optimistic update
-        const currentStatus = this._state.status;
-        if (currentStatus) {
+        try {
+            await this.queue.enqueueMutation(() => unstageFile(this.repoPath, file.path));
+            this.scheduleStatusRefresh();
+        }
+        catch (err) {
+            await this.refresh();
             this.updateState({
-                status: {
-                    ...currentStatus,
-                    files: currentStatus.files.map((f) => f.path === file.path && f.staged ? { ...f, staged: false } : f),
-                },
+                error: `Failed to unstage ${file.path}: ${err instanceof Error ? err.message : String(err)}`,
             });
         }
+    }
+    /**
+     * Stage a single hunk via patch.
+     */
+    async stageHunk(patch) {
         try {
-            await this.queue.enqueueMutation(() => unstageFile(this.repoPath, file.path));
+            await this.queue.enqueueMutation(async () => gitStageHunk(this.repoPath, patch));
             this.scheduleRefresh();
         }
         catch (err) {
             await this.refresh();
             this.updateState({
-                error: `Failed to unstage ${file.path}: ${err instanceof Error ? err.message : String(err)}`,
+                error: `Failed to stage hunk: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    /**
+     * Unstage a single hunk via patch.
+     */
+    async unstageHunk(patch) {
+        try {
+            await this.queue.enqueueMutation(async () => gitUnstageHunk(this.repoPath, patch));
+            this.scheduleRefresh();
+        }
+        catch (err) {
+            await this.refresh();
+            this.updateState({
+                error: `Failed to unstage hunk: ${err instanceof Error ? err.message : String(err)}`,
             });
         }
     }
@@ -385,27 +516,7 @@ export class GitStateManager extends EventEmitter {
     async refreshCompareDiff(includeUncommitted = false) {
         this.updateCompareState({ compareLoading: true, compareError: null });
         try {
-            await this.queue.enqueue(async () => {
-                let base = this._compareState.compareBaseBranch;
-                if (!base) {
-                    // Try cached value first, then fall back to default detection
-                    base = getCachedBaseBranch(this.repoPath) ?? (await getDefaultBaseBranch(this.repoPath));
-                    this.updateCompareState({ compareBaseBranch: base });
-                }
-                if (base) {
-                    const diff = includeUncommitted
-                        ? await getCompareDiffWithUncommitted(this.repoPath, base)
-                        : await getDiffBetweenRefs(this.repoPath, base);
-                    this.updateCompareState({ compareDiff: diff, compareLoading: false });
-                }
-                else {
-                    this.updateCompareState({
-                        compareDiff: null,
-                        compareLoading: false,
-                        compareError: 'No base branch found',
-                    });
-                }
-            });
+            await this.queue.enqueue(() => this.doRefreshCompareDiff(includeUncommitted));
         }
         catch (err) {
             this.updateCompareState({
@@ -414,6 +525,30 @@ export class GitStateManager extends EventEmitter {
             });
         }
     }
+    /**
+     * Internal: refresh compare diff (called within queue).
+     */
+    async doRefreshCompareDiff(includeUncommitted) {
+        let base = this._compareState.compareBaseBranch;
+        if (!base) {
+            // Try cached value first, then fall back to default detection
+            base = getCachedBaseBranch(this.repoPath) ?? (await getDefaultBaseBranch(this.repoPath));
+            this.updateCompareState({ compareBaseBranch: base });
+        }
+        if (base) {
+            const diff = includeUncommitted
+                ? await getCompareDiffWithUncommitted(this.repoPath, base)
+                : await getDiffBetweenRefs(this.repoPath, base);
+            this.updateCompareState({ compareDiff: diff, compareLoading: false });
+        }
+        else {
+            this.updateCompareState({
+                compareDiff: null,
+                compareLoading: false,
+                compareError: 'No base branch found',
+            });
+        }
+    }
     /**
      * Get candidate base branches for branch comparison.
      */
@@ -435,8 +570,7 @@ export class GitStateManager extends EventEmitter {
     async loadHistory(count = 100) {
         this.updateHistoryState({ isLoading: true });
         try {
-            const commits = await this.queue.enqueue(() => getCommitHistory(this.repoPath, count));
-            this.updateHistoryState({ commits, isLoading: false });
+            await this.queue.enqueue(() => this.doLoadHistory(count));
         }
         catch (err) {
             this.updateHistoryState({ isLoading: false });
@@ -445,6 +579,13 @@ export class GitStateManager extends EventEmitter {
             });
         }
     }
+    /**
+     * Internal: load commit history (called within queue).
+     */
+    async doLoadHistory(count = 100) {
+        const commits = await getCommitHistory(this.repoPath, count);
+        this.updateHistoryState({ commits, isLoading: false });
+    }
     /**
      * Select a commit in history view and load its diff.
      */