diffstalker 0.1.7 → 0.2.1

package/dist/core/FilePathWatcher.js

@@ -0,0 +1,133 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { watch } from 'chokidar';
+import { EventEmitter } from 'node:events';
+import { ensureTargetDir } from '../config.js';
+import { expandPath, getLastNonEmptyLine } from '../utils/pathUtils.js';
+/**
+ * FilePathWatcher watches a target file and emits events when the path it contains changes.
+ * It supports append-only files by reading only the last non-empty line.
+ */
+export class FilePathWatcher extends EventEmitter {
+    targetFile;
+    debug;
+    watcher = null;
+    debounceTimer = null;
+    lastReadPath = null;
+    _state = {
+        path: null,
+        lastUpdate: null,
+        rawContent: null,
+        sourceFile: null,
+    };
+    constructor(targetFile, debug = false) {
+        super();
+        this.targetFile = targetFile;
+        this.debug = debug;
+        this._state.sourceFile = targetFile;
+    }
+    get state() {
+        return this._state;
+    }
+    updateState(partial) {
+        this._state = { ...this._state, ...partial };
+        this.emit('path-change', this._state);
+    }
+    processContent(content) {
+        if (!content)
+            return null;
+        const expanded = expandPath(content);
+        return path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
+    }
+    readTargetDebounced() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.readTarget();
+        }, 100);
+    }
+    readTarget() {
+        try {
+            const raw = fs.readFileSync(this.targetFile, 'utf-8');
+            const content = getLastNonEmptyLine(raw);
+            if (content && content !== this.lastReadPath) {
+                const resolved = this.processContent(content);
+                const now = new Date();
+                if (this.debug && resolved) {
+                    process.stderr.write(`[diffstalker ${now.toISOString()}] Path change detected\n`);
+                    process.stderr.write(`  Source file: ${this.targetFile}\n`);
+                    process.stderr.write(`  Raw content: "${content}"\n`);
+                    process.stderr.write(`  Previous:    "${this.lastReadPath ?? '(none)'}"\n`);
+                    process.stderr.write(`  Resolved:    "${resolved}"\n`);
+                }
+                this.lastReadPath = resolved;
+                this.updateState({
+                    path: resolved,
+                    lastUpdate: now,
+                    rawContent: content,
+                });
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    /**
+     * Start watching the target file.
+     */
+    start() {
+        // Ensure the directory exists
+        ensureTargetDir(this.targetFile);
+        // Create the file if it doesn't exist
+        if (!fs.existsSync(this.targetFile)) {
+            fs.writeFileSync(this.targetFile, '');
+        }
+        // Read initial value immediately (no debounce for first read)
+        try {
+            const raw = fs.readFileSync(this.targetFile, 'utf-8');
+            const content = getLastNonEmptyLine(raw);
+            if (content) {
+                const resolved = this.processContent(content);
+                const now = new Date();
+                if (this.debug && resolved) {
+                    process.stderr.write(`[diffstalker ${now.toISOString()}] Initial path read\n`);
+                    process.stderr.write(`  Source file: ${this.targetFile}\n`);
+                    process.stderr.write(`  Raw content: "${content}"\n`);
+                    process.stderr.write(`  Resolved:    "${resolved}"\n`);
+                }
+                this.lastReadPath = resolved;
+                this._state = {
+                    path: resolved,
+                    lastUpdate: now,
+                    rawContent: content,
+                    sourceFile: this.targetFile,
+                };
+                // Don't emit on initial read - caller should check state after start()
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+        // Watch for changes
+        this.watcher = watch(this.targetFile, {
+            persistent: true,
+            ignoreInitial: true,
+        });
+        this.watcher.on('change', () => this.readTargetDebounced());
+        this.watcher.on('add', () => this.readTargetDebounced());
+    }
+    /**
+     * Stop watching and clean up resources.
+     */
+    stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+}

package/dist/core/GitStateManager.js

@@ -1,9 +1,11 @@
 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, } from '../git/status.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 { getCachedBaseBranch, setCachedBaseBranch } from '../utils/baseBranchCache.js';
 /**
@@ -15,11 +17,12 @@ export class GitStateManager extends EventEmitter {
     queue;
     gitWatcher = null;
     workingDirWatcher = null;
+    ignorers = new Map();
+    diffDebounceTimer = null;
     // Current state
     _state = {
         status: null,
         diff: null,
-        stagedDiff: '',
         selectedFile: null,
         isLoading: false,
         error: null,
@@ -31,8 +34,10 @@ export class GitStateManager extends EventEmitter {
         compareError: null,
     };
     _historyState = {
+        commits: [],
         selectedCommit: null,
         commitDiff: null,
+        isLoading: false,
     };
     _compareSelectionState = {
         type: null,
@@ -72,6 +77,51 @@ export class GitStateManager extends EventEmitter {
         this._compareSelectionState = { ...this._compareSelectionState, ...partial };
         this.emit('compare-selection-change', this._compareSelectionState);
     }
+    /**
+     * 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).
+     */
+    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'));
+        }
+        const excludePath = path.join(this.repoPath, '.git', 'info', 'exclude');
+        if (fs.existsSync(excludePath)) {
+            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 ignorers;
+    }
     /**
      * Start watching for file changes.
      */
@@ -79,55 +129,113 @@ export class GitStateManager extends EventEmitter {
         const gitDir = path.join(this.repoPath, '.git');
         if (!fs.existsSync(gitDir))
             return;
+        // --- Git internals watcher ---
         const indexFile = path.join(gitDir, 'index');
         const headFile = path.join(gitDir, 'HEAD');
         const refsDir = path.join(gitDir, 'refs');
-        this.gitWatcher = watch([indexFile, headFile, refsDir], {
+        const gitignorePath = path.join(this.repoPath, '.gitignore');
+        // Git uses atomic writes (write to temp, then rename). We use polling
+        // for reliable detection of these atomic operations.
+        this.gitWatcher = watch([indexFile, headFile, refsDir, gitignorePath], {
             persistent: true,
             ignoreInitial: true,
-            awaitWriteFinish: {
-                stabilityThreshold: 100,
-                pollInterval: 50,
-            },
+            usePolling: true,
+            interval: 100,
         });
+        // --- Working directory watcher with gitignore support ---
+        this.ignorers = this.loadGitignores();
         this.workingDirWatcher = watch(this.repoPath, {
             persistent: true,
             ignoreInitial: true,
-            ignored: [
-                '**/node_modules/**',
-                '**/.git/**',
-                '**/dist/**',
-                '**/build/**',
-                '**/*.log',
-                '**/.DS_Store',
-            ],
+            ignored: (filePath) => {
+                const relativePath = path.relative(this.repoPath, filePath);
+                if (!relativePath)
+                    return 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,
                 pollInterval: 50,
             },
-            depth: 10,
         });
         const scheduleRefresh = () => this.scheduleRefresh();
-        this.gitWatcher.on('change', scheduleRefresh);
+        this.gitWatcher.on('change', (filePath) => {
+            // Reload gitignore patterns if .gitignore changed
+            if (filePath === gitignorePath) {
+                this.ignorers = this.loadGitignores();
+            }
+            scheduleRefresh();
+        });
         this.gitWatcher.on('add', scheduleRefresh);
         this.gitWatcher.on('unlink', scheduleRefresh);
+        this.gitWatcher.on('error', (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            this.emit('error', `Git watcher error: ${message}`);
+        });
         this.workingDirWatcher.on('change', scheduleRefresh);
         this.workingDirWatcher.on('add', scheduleRefresh);
         this.workingDirWatcher.on('unlink', scheduleRefresh);
+        this.workingDirWatcher.on('error', (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            this.emit('error', `Working dir watcher error: ${message}`);
+        });
     }
     /**
      * 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.
@@ -143,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;
@@ -168,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,
             });
         }
@@ -200,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') {
@@ -214,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();
@@ -248,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();
@@ -342,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({
@@ -371,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.
      */
@@ -386,6 +499,28 @@ export class GitStateManager extends EventEmitter {
         setCachedBaseBranch(this.repoPath, branch);
         await this.refreshCompareDiff(includeUncommitted);
     }
+    /**
+     * Load commit history for the history view.
+     */
+    async loadHistory(count = 100) {
+        this.updateHistoryState({ isLoading: true });
+        try {
+            await this.queue.enqueue(() => this.doLoadHistory(count));
+        }
+        catch (err) {
+            this.updateHistoryState({ isLoading: false });
+            this.updateState({
+                error: `Failed to load history: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    /**
+     * 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: {

package/dist/git/ignoreUtils.js

@@ -0,0 +1,30 @@
+import { simpleGit } from 'simple-git';
+/**
+ * Check which files from a list are ignored by git.
+ * Uses `git check-ignore` to determine ignored files.
+ */
+export async function getIgnoredFiles(repoPath, files) {
+    if (files.length === 0)
+        return new Set();
+    const git = simpleGit(repoPath);
+    const ignoredFiles = new Set();
+    const batchSize = 100;
+    for (let i = 0; i < files.length; i += batchSize) {
+        const batch = files.slice(i, i + batchSize);
+        try {
+            const result = await git.raw(['check-ignore', ...batch]);
+            const ignored = result
+                .trim()
+                .split('\n')
+                .filter((f) => f.length > 0);
+            for (const f of ignored) {
+                ignoredFiles.add(f);
+            }
+        }
+        catch {
+            // check-ignore exits with code 1 if no files are ignored, which throws
+            // Just continue to next batch
+        }
+    }
+    return ignoredFiles;
+}