diffstalker 0.1.7 → 0.2.0

package/dist/core/ExplorerStateManager.js

@@ -0,0 +1,266 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { getIgnoredFiles } from '../git/ignoreUtils.js';
+const MAX_FILE_SIZE = 1024 * 1024; // 1MB
+const WARN_FILE_SIZE = 100 * 1024; // 100KB
+/**
+ * Check if content appears to be binary.
+ */
+function isBinaryContent(buffer) {
+    // Check first 8KB for null bytes (common in binary files)
+    const checkLength = Math.min(buffer.length, 8192);
+    for (let i = 0; i < checkLength; i++) {
+        if (buffer[i] === 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * ExplorerStateManager manages file explorer state independent of React.
+ * It handles directory loading, file selection, and navigation.
+ */
+export class ExplorerStateManager extends EventEmitter {
+    repoPath;
+    options;
+    _state = {
+        currentPath: '',
+        items: [],
+        selectedIndex: 0,
+        selectedFile: null,
+        isLoading: false,
+        error: null,
+    };
+    constructor(repoPath, options) {
+        super();
+        this.repoPath = repoPath;
+        this.options = options;
+    }
+    get state() {
+        return this._state;
+    }
+    updateState(partial) {
+        this._state = { ...this._state, ...partial };
+        this.emit('state-change', this._state);
+    }
+    /**
+     * Set filtering options and reload directory.
+     */
+    async setOptions(options) {
+        this.options = { ...this.options, ...options };
+        await this.loadDirectory(this._state.currentPath);
+    }
+    /**
+     * Load a directory's contents.
+     */
+    async loadDirectory(relativePath) {
+        this.updateState({ isLoading: true, error: null, currentPath: relativePath });
+        try {
+            const fullPath = path.join(this.repoPath, relativePath);
+            const entries = await fs.promises.readdir(fullPath, { withFileTypes: true });
+            // Build list of paths for gitignore check
+            const pathsToCheck = entries.map((e) => relativePath ? path.join(relativePath, e.name) : e.name);
+            // Get ignored files (only if we need to filter them)
+            const ignoredFiles = this.options.hideGitignored
+                ? await getIgnoredFiles(this.repoPath, pathsToCheck)
+                : new Set();
+            // Filter and map entries
+            const explorerItems = entries
+                .filter((entry) => {
+                // Filter dot-prefixed hidden files
+                if (this.options.hideHidden && entry.name.startsWith('.')) {
+                    return false;
+                }
+                // Filter gitignored files
+                if (this.options.hideGitignored) {
+                    const entryPath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+                    if (ignoredFiles.has(entryPath)) {
+                        return false;
+                    }
+                }
+                return true;
+            })
+                .map((entry) => ({
+                name: entry.name,
+                path: relativePath ? path.join(relativePath, entry.name) : entry.name,
+                isDirectory: entry.isDirectory(),
+            }));
+            // Sort: directories first (alphabetical), then files (alphabetical)
+            explorerItems.sort((a, b) => {
+                if (a.isDirectory && !b.isDirectory)
+                    return -1;
+                if (!a.isDirectory && b.isDirectory)
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+            // Add ".." at the beginning if not at root
+            if (relativePath) {
+                explorerItems.unshift({
+                    name: '..',
+                    path: path.dirname(relativePath) || '',
+                    isDirectory: true,
+                });
+            }
+            this.updateState({
+                items: explorerItems,
+                selectedIndex: 0,
+                selectedFile: null,
+                isLoading: false,
+            });
+        }
+        catch (err) {
+            this.updateState({
+                error: err instanceof Error ? err.message : 'Failed to read directory',
+                items: [],
+                isLoading: false,
+            });
+        }
+    }
+    /**
+     * Load a file's contents.
+     */
+    async loadFile(itemPath) {
+        try {
+            const fullPath = path.join(this.repoPath, itemPath);
+            const stats = await fs.promises.stat(fullPath);
+            // Check file size
+            if (stats.size > MAX_FILE_SIZE) {
+                this.updateState({
+                    selectedFile: {
+                        path: itemPath,
+                        content: `File too large to display (${(stats.size / 1024 / 1024).toFixed(2)} MB).\nMaximum size: 1 MB`,
+                        truncated: true,
+                    },
+                });
+                return;
+            }
+            const buffer = await fs.promises.readFile(fullPath);
+            // Check if binary
+            if (isBinaryContent(buffer)) {
+                this.updateState({
+                    selectedFile: {
+                        path: itemPath,
+                        content: 'Binary file - cannot display',
+                    },
+                });
+                return;
+            }
+            let content = buffer.toString('utf-8');
+            let truncated = false;
+            // Warn about large files
+            if (stats.size > WARN_FILE_SIZE) {
+                const warning = `⚠ Large file (${(stats.size / 1024).toFixed(1)} KB)\n\n`;
+                content = warning + content;
+            }
+            // Truncate if needed
+            const maxLines = 5000;
+            const lines = content.split('\n');
+            if (lines.length > maxLines) {
+                content =
+                    lines.slice(0, maxLines).join('\n') +
+                        `\n\n... (truncated, ${lines.length - maxLines} more lines)`;
+                truncated = true;
+            }
+            this.updateState({
+                selectedFile: {
+                    path: itemPath,
+                    content,
+                    truncated,
+                },
+            });
+        }
+        catch (err) {
+            this.updateState({
+                selectedFile: {
+                    path: itemPath,
+                    content: err instanceof Error ? `Error: ${err.message}` : 'Failed to read file',
+                },
+            });
+        }
+    }
+    /**
+     * Select an item by index.
+     */
+    async selectIndex(index) {
+        if (index < 0 || index >= this._state.items.length)
+            return;
+        const selected = this._state.items[index];
+        this.updateState({ selectedIndex: index });
+        if (selected && !selected.isDirectory) {
+            await this.loadFile(selected.path);
+        }
+        else {
+            this.updateState({ selectedFile: null });
+        }
+    }
+    /**
+     * Navigate to previous item.
+     * Returns the new scroll offset if scrolling is needed, or null if not.
+     */
+    navigateUp(currentScrollOffset) {
+        const newIndex = Math.max(0, this._state.selectedIndex - 1);
+        if (newIndex === this._state.selectedIndex)
+            return null;
+        // Don't await - fire and forget for responsiveness
+        this.selectIndex(newIndex);
+        // Return new scroll offset if we need to scroll up
+        if (newIndex < currentScrollOffset) {
+            return newIndex;
+        }
+        return null;
+    }
+    /**
+     * Navigate to next item.
+     * Returns the new scroll offset if scrolling is needed, or null if not.
+     */
+    navigateDown(currentScrollOffset, visibleHeight) {
+        const newIndex = Math.min(this._state.items.length - 1, this._state.selectedIndex + 1);
+        if (newIndex === this._state.selectedIndex)
+            return null;
+        // Don't await - fire and forget for responsiveness
+        this.selectIndex(newIndex);
+        // Calculate visible area accounting for scroll indicators
+        const needsScrolling = this._state.items.length > visibleHeight;
+        const availableHeight = needsScrolling ? visibleHeight - 2 : visibleHeight;
+        const visibleEnd = currentScrollOffset + availableHeight;
+        if (newIndex >= visibleEnd) {
+            return currentScrollOffset + 1;
+        }
+        return null;
+    }
+    /**
+     * Enter the selected directory or go to parent if ".." is selected.
+     */
+    async enterDirectory() {
+        const selected = this._state.items[this._state.selectedIndex];
+        if (!selected)
+            return;
+        if (selected.isDirectory) {
+            if (selected.name === '..') {
+                const parent = path.dirname(this._state.currentPath);
+                // path.dirname returns "." for top-level paths, normalize to ""
+                await this.loadDirectory(parent === '.' ? '' : parent);
+            }
+            else {
+                await this.loadDirectory(selected.path);
+            }
+        }
+        // If it's a file, do nothing (file content is already shown)
+    }
+    /**
+     * Go to parent directory (backspace navigation).
+     */
+    async goUp() {
+        if (this._state.currentPath) {
+            const parent = path.dirname(this._state.currentPath);
+            // path.dirname returns "." for top-level paths, normalize to ""
+            await this.loadDirectory(parent === '.' ? '' : parent);
+        }
+    }
+    /**
+     * Clean up resources.
+     */
+    dispose() {
+        this.removeAllListeners();
+    }
+}

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

@@ -2,8 +2,9 @@ import * as path from 'node:path';
 import * as fs from 'node:fs';
 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,6 +16,7 @@ export class GitStateManager extends EventEmitter {
     queue;
     gitWatcher = null;
     workingDirWatcher = null;
+    ignorer = null;
     // Current state
     _state = {
         status: null,
@@ -31,8 +33,10 @@ export class GitStateManager extends EventEmitter {
         compareError: null,
     };
     _historyState = {
+        commits: [],
         selectedCommit: null,
         commitDiff: null,
+        isLoading: false,
     };
     _compareSelectionState = {
         type: null,
@@ -72,6 +76,26 @@ export class GitStateManager extends EventEmitter {
         this._compareSelectionState = { ...this._compareSelectionState, ...partial };
         this.emit('compare-selection-change', this._compareSelectionState);
     }
+    /**
+     * Load gitignore patterns from .gitignore and .git/info/exclude.
+     * Returns an Ignore instance that can test paths.
+     */
+    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'));
+        }
+        // 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'));
+        }
+        return ig;
+    }
     /**
      * Start watching for file changes.
      */
@@ -79,41 +103,60 @@ 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.ignorer = this.loadGitignore();
         this.workingDirWatcher = watch(this.repoPath, {
             persistent: true,
             ignoreInitial: true,
-            ignored: [
-                '**/node_modules/**',
-                '**/.git/**',
-                '**/dist/**',
-                '**/build/**',
-                '**/*.log',
-                '**/.DS_Store',
-            ],
+            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;
+            },
             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.ignorer = this.loadGitignore();
+            }
+            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.
@@ -386,6 +429,22 @@ 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 {
+            const commits = await this.queue.enqueue(() => getCommitHistory(this.repoPath, count));
+            this.updateHistoryState({ commits, isLoading: false });
+        }
+        catch (err) {
+            this.updateHistoryState({ isLoading: false });
+            this.updateState({
+                error: `Failed to load history: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
     /**
      * Select a commit in history view and load its diff.
      */

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;
+}

package/dist/git/status.js

@@ -1,6 +1,7 @@
 import { simpleGit } from 'simple-git';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { getIgnoredFiles } from './ignoreUtils.js';
 // Parse git diff --numstat output into a map of path -> stats
 export function parseNumstat(output) {
     const stats = new Map();
@@ -29,39 +30,6 @@ async function countFileLines(repoPath, filePath) {
         return 0;
     }
 }
-// Check which files from a list are ignored by git
-async function getIgnoredFiles(git, files) {
-    if (files.length === 0)
-        return new Set();
-    try {
-        // git check-ignore returns the list of ignored files (one per line)
-        // Pass files as arguments (limit batch size to avoid command line length issues)
-        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;
-    }
-    catch {
-        // If check-ignore fails entirely, return empty set
-        return new Set();
-    }
-}
 export function parseStatusCode(code) {
     switch (code) {
         case 'M':
@@ -145,7 +113,7 @@ export async function getStatus(repoPath) {
         // Collect untracked files to check if they're ignored
         const untrackedPaths = status.files.filter((f) => f.working_dir === '?').map((f) => f.path);
         // Get the set of ignored files
-        const ignoredFiles = await getIgnoredFiles(git, untrackedPaths);
+        const ignoredFiles = await getIgnoredFiles(repoPath, untrackedPaths);
         for (const file of status.files) {
             // Skip ignored files (marked with '!' in either column, or detected by check-ignore)
             if (file.index === '!' || file.working_dir === '!' || ignoredFiles.has(file.path)) {