diffstalker 0.2.0 → 0.2.1

package/dist/core/GitStateManager.js

@@ -1,5 +1,6 @@
 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';
@@ -16,12 +17,12 @@ 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: '',
         selectedFile: null,
         isLoading: false,
         error: null,
@@ -77,24 +78,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
+                }
+            }
         }
-        return ig;
+        catch {
+            // git ls-files failed — we still have the root ignorer
+        }
+        return ignorers;
     }
     /**
      * Start watching for file changes.
@@ -117,19 +143,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 +173,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 +195,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,17 +251,15 @@ 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),
-                getDiff(this.repoPath, undefined, false),
-            ]);
+            // Emit status immediately so the file list updates after a single git spawn
+            this.updateState({ status: newStatus });
+            // Fetch unstaged diff (updates diff view once complete)
+            const allUnstagedDiff = await getDiff(this.repoPath, undefined, false);
             // Determine display diff based on selected file
             let displayDiff;
             const currentSelectedFile = this._state.selectedFile;
@@ -211,26 +274,16 @@ export class GitStateManager extends EventEmitter {
                     }
                 }
                 else {
-                    // File no longer exists - clear selection
-                    displayDiff = allUnstagedDiff.raw ? allUnstagedDiff : allStagedDiff;
+                    // File no longer exists - clear selection, show unstaged diff
+                    displayDiff = allUnstagedDiff;
                     this.updateState({ selectedFile: null });
                 }
             }
             else {
-                if (allUnstagedDiff.raw) {
-                    displayDiff = allUnstagedDiff;
-                }
-                else if (allStagedDiff.raw) {
-                    displayDiff = allStagedDiff;
-                }
-                else {
-                    displayDiff = { raw: '', lines: [] };
-                }
+                displayDiff = allUnstagedDiff;
             }
             this.updateState({
-                status: newStatus,
                 diff: displayDiff,
-                stagedDiff: allStagedDiff.raw,
                 isLoading: false,
             });
         }
@@ -243,12 +296,36 @@ export class GitStateManager extends EventEmitter {
     }
     /**
      * 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 (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 () => {
+            // Selection changed while queued — skip stale fetch
+            if (file !== this._state.selectedFile)
+                return;
             if (file) {
                 let fileDiff;
                 if (file.status === 'untracked') {
@@ -257,31 +334,30 @@ export class GitStateManager extends EventEmitter {
                 else {
                     fileDiff = await getDiff(this.repoPath, file.path, file.staged);
                 }
-                this.updateState({ diff: fileDiff });
+                if (file === this._state.selectedFile) {
+                    this.updateState({ diff: fileDiff });
+                }
             }
             else {
                 const allDiff = await getStagedDiff(this.repoPath);
-                this.updateState({ diff: allDiff });
+                if (this._state.selectedFile === null) {
+                    this.updateState({ diff: allDiff });
+                }
             }
+        })
+            .catch((err) => {
+            this.updateState({
+                error: `Failed to load diff: ${err instanceof Error ? err.message : String(err)}`,
+            });
         });
     }
     /**
-     * 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,22 +367,12 @@ 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) {
-            this.updateState({
-                status: {
-                    ...currentStatus,
-                    files: currentStatus.files.map((f) => f.path === file.path && f.staged ? { ...f, staged: false } : f),
-                },
-            });
-        }
         try {
             await this.queue.enqueueMutation(() => unstageFile(this.repoPath, file.path));
-            this.scheduleRefresh();
+            this.scheduleStatusRefresh();
         }
         catch (err) {
             await this.refresh();
@@ -385,27 +451,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 +460,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 +505,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 +514,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.
      */

package/dist/git/diff.js

@@ -302,6 +302,8 @@ export async function getDiffBetweenRefs(repoPath, baseRef) {
         date: new Date(entry.date),
         refs: entry.refs || '',
     }));
+    // Sort files alphabetically by path
+    fileDiffs.sort((a, b) => a.path.localeCompare(b.path));
     return {
         baseBranch: baseRef,
         stats: {
@@ -457,6 +459,8 @@ export async function getCompareDiffWithUncommitted(repoPath, baseRef) {
         totalAdditions += file.additions;
         totalDeletions += file.deletions;
     }
+    // Sort files alphabetically by path
+    mergedFiles.sort((a, b) => a.path.localeCompare(b.path));
     return {
         baseBranch: committedDiff.baseBranch,
         stats: {