diffstalker 0.1.6 → 0.2.0

package/dist/config.js

@@ -1,2 +1,83 @@
-import*as t from"node:fs";import*as n from"node:path";import*as s from"node:os";const a={targetFile:n.join(s.homedir(),".cache","diffstalker","target"),watcherEnabled:!1,debug:!1,theme:"dark"},r=n.join(s.homedir(),".config","diffstalker","config.json");export const VALID_THEMES=["dark","light","dark-colorblind","light-colorblind","dark-ansi","light-ansi"];export function isValidTheme(i){return typeof i=="string"&&VALID_THEMES.includes(i)}export function loadConfig(){const i={...a};if(process.env.DIFFSTALKER_PAGER&&(i.pager=process.env.DIFFSTALKER_PAGER),t.existsSync(r))try{const e=JSON.parse(t.readFileSync(r,"utf-8"));e.pager&&(i.pager=e.pager),e.targetFile&&(i.targetFile=e.targetFile),isValidTheme(e.theme)&&(i.theme=e.theme),typeof e.splitRatio=="number"&&e.splitRatio>=.15&&e.splitRatio<=.85&&(i.splitRatio=e.splitRatio)}catch{}return i}export function saveConfig(i){const e=n.dirname(r);t.existsSync(e)||t.mkdirSync(e,{recursive:!0});let o={};if(t.existsSync(r))try{o=JSON.parse(t.readFileSync(r,"utf-8"))}catch{}Object.assign(o,i),t.writeFileSync(r,JSON.stringify(o,null,2)+`
-`)}export function ensureTargetDir(i){const e=n.dirname(i);t.existsSync(e)||t.mkdirSync(e,{recursive:!0})}export function abbreviateHomePath(i){const e=s.homedir();return i.startsWith(e)?"~"+i.slice(e.length):i}
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const defaultConfig = {
+    targetFile: path.join(os.homedir(), '.cache', 'diffstalker', 'target'),
+    watcherEnabled: false, // Watcher is opt-in via --follow
+    debug: false,
+    theme: 'dark',
+};
+const CONFIG_PATH = path.join(os.homedir(), '.config', 'diffstalker', 'config.json');
+export const VALID_THEMES = [
+    'dark',
+    'light',
+    'dark-colorblind',
+    'light-colorblind',
+    'dark-ansi',
+    'light-ansi',
+];
+export function isValidTheme(theme) {
+    return typeof theme === 'string' && VALID_THEMES.includes(theme);
+}
+export function loadConfig() {
+    const config = { ...defaultConfig };
+    // Override from environment
+    if (process.env.DIFFSTALKER_PAGER) {
+        config.pager = process.env.DIFFSTALKER_PAGER;
+    }
+    // Try to load from config file
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            const fileConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+            if (fileConfig.pager)
+                config.pager = fileConfig.pager;
+            if (fileConfig.targetFile)
+                config.targetFile = fileConfig.targetFile;
+            if (isValidTheme(fileConfig.theme))
+                config.theme = fileConfig.theme;
+            if (typeof fileConfig.splitRatio === 'number' &&
+                fileConfig.splitRatio >= 0.15 &&
+                fileConfig.splitRatio <= 0.85) {
+                config.splitRatio = fileConfig.splitRatio;
+            }
+        }
+        catch {
+            // Ignore config file errors
+        }
+    }
+    return config;
+}
+export function saveConfig(updates) {
+    // Ensure config directory exists
+    const configDir = path.dirname(CONFIG_PATH);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    // Load existing config or start fresh
+    let fileConfig = {};
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            fileConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+        }
+        catch {
+            // Start fresh if file is corrupted
+        }
+    }
+    // Apply updates
+    Object.assign(fileConfig, updates);
+    // Write back
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(fileConfig, null, 2) + '\n');
+}
+export function ensureTargetDir(targetFile) {
+    const dir = path.dirname(targetFile);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+export function abbreviateHomePath(fullPath) {
+    const home = os.homedir();
+    if (fullPath.startsWith(home)) {
+        return '~' + fullPath.slice(home.length);
+    }
+    return fullPath;
+}

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/GitOperationQueue.js

@@ -1 +1,109 @@
-export class GitOperationQueue{queue=[];isProcessing=!1;pendingMutations=0;refreshScheduled=!1;enqueue(e){return new Promise((s,r)=>{this.queue.push({execute:e,resolve:s,reject:r}),this.processNext()})}enqueueMutation(e){return this.pendingMutations++,this.enqueue(e).finally(()=>{this.pendingMutations--})}hasPendingMutations(){return this.pendingMutations>0}scheduleRefresh(e){this.pendingMutations>0||this.refreshScheduled||(this.refreshScheduled=!0,this.enqueue(async()=>{this.refreshScheduled=!1,await e()}).catch(()=>{this.refreshScheduled=!1}))}isBusy(){return this.isProcessing||this.queue.length>0}async processNext(){if(this.isProcessing||this.queue.length===0)return;this.isProcessing=!0;const e=this.queue.shift();try{const s=await e.execute();e.resolve(s)}catch(s){e.reject(s instanceof Error?s:new Error(String(s)))}finally{this.isProcessing=!1,this.processNext()}}}const i=new Map;export function getQueueForRepo(t){let e=i.get(t);return e||(e=new GitOperationQueue,i.set(t,e)),e}export function removeQueueForRepo(t){i.delete(t)}
+/**
+ * GitOperationQueue - Serializes git operations to prevent index.lock conflicts.
+ *
+ * All git operations must go through this queue to ensure they execute
+ * sequentially, preventing concurrent access to the git index.
+ */
+export class GitOperationQueue {
+    queue = [];
+    isProcessing = false;
+    pendingMutations = 0; // Track pending stage/unstage operations
+    refreshScheduled = false; // Avoid duplicate refresh enqueues
+    /**
+     * Enqueue a git operation to be executed sequentially.
+     * Returns a promise that resolves when the operation completes.
+     */
+    enqueue(operation) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                execute: operation,
+                resolve: resolve,
+                reject,
+            });
+            this.processNext();
+        });
+    }
+    /**
+     * Enqueue a mutation operation (stage/unstage) that should block refreshes.
+     * Refreshes are suppressed while any mutations are pending.
+     */
+    enqueueMutation(operation) {
+        this.pendingMutations++;
+        return this.enqueue(operation).finally(() => {
+            this.pendingMutations--;
+        });
+    }
+    /**
+     * Check if there are pending mutation operations.
+     */
+    hasPendingMutations() {
+        return this.pendingMutations > 0;
+    }
+    /**
+     * Schedule a refresh operation.
+     * Skips if there are pending mutations (the last mutation will trigger refresh).
+     * Skips if a refresh is already scheduled/queued.
+     */
+    scheduleRefresh(callback) {
+        // If there are pending mutations, skip - the last mutation will trigger refresh
+        if (this.pendingMutations > 0) {
+            return;
+        }
+        // If a refresh is already scheduled, skip
+        if (this.refreshScheduled) {
+            return;
+        }
+        this.refreshScheduled = true;
+        this.enqueue(async () => {
+            this.refreshScheduled = false;
+            await callback();
+        }).catch(() => {
+            this.refreshScheduled = false;
+        });
+    }
+    /**
+     * Check if the queue is currently processing or has pending operations.
+     */
+    isBusy() {
+        return this.isProcessing || this.queue.length > 0;
+    }
+    async processNext() {
+        if (this.isProcessing || this.queue.length === 0) {
+            return;
+        }
+        this.isProcessing = true;
+        const operation = this.queue.shift();
+        try {
+            const result = await operation.execute();
+            operation.resolve(result);
+        }
+        catch (error) {
+            operation.reject(error instanceof Error ? error : new Error(String(error)));
+        }
+        finally {
+            this.isProcessing = false;
+            // Process next operation if any
+            this.processNext();
+        }
+    }
+}
+// Global registry of queues per repo path to ensure single queue per repo
+const queueRegistry = new Map();
+/**
+ * Get the operation queue for a specific repository.
+ * Creates a new queue if one doesn't exist for this path.
+ */
+export function getQueueForRepo(repoPath) {
+    let queue = queueRegistry.get(repoPath);
+    if (!queue) {
+        queue = new GitOperationQueue();
+        queueRegistry.set(repoPath, queue);
+    }
+    return queue;
+}
+/**
+ * Remove a queue from the registry (for cleanup).
+ */
+export function removeQueueForRepo(repoPath) {
+    queueRegistry.delete(repoPath);
+}