diffstalker 0.2.1 → 0.2.3

package/dist/ipc/CommandClient.js

@@ -17,15 +17,14 @@ export class CommandClient {
         return new Promise((resolve, reject) => {
             const socket = net.createConnection(this.socketPath);
             let buffer = '';
-            let timeoutId;
-            const cleanup = () => {
-                clearTimeout(timeoutId);
-                socket.destroy();
-            };
-            timeoutId = setTimeout(() => {
+            const timeoutId = setTimeout(() => {
                 cleanup();
                 reject(new Error(`Command timed out after ${this.timeout}ms`));
             }, this.timeout);
+            function cleanup() {
+                clearTimeout(timeoutId);
+                socket.destroy();
+            }
             socket.on('connect', () => {
                 socket.write(JSON.stringify(command) + '\n');
             });
@@ -38,7 +37,7 @@ export class CommandClient {
                     try {
                         resolve(JSON.parse(json));
                     }
-                    catch (err) {
+                    catch {
                         reject(new Error(`Invalid JSON response: ${json}`));
                     }
                 }

package/dist/state/UIState.js

@@ -13,11 +13,13 @@ const DEFAULT_STATE = {
     compareSelectedIndex: 0,
     includeUncommitted: false,
     explorerSelectedIndex: 0,
+    selectedHunkIndex: 0,
     wrapMode: false,
     autoTabEnabled: false,
     mouseEnabled: true,
     hideHiddenFiles: true,
     hideGitignored: true,
+    flatViewMode: false,
     splitRatio: 0.4,
     activeModal: null,
     pendingDiscard: null,
@@ -110,6 +112,22 @@ export class UIState extends EventEmitter {
     setExplorerSelectedIndex(index) {
         this.update({ explorerSelectedIndex: Math.max(0, index) });
     }
+    // Hunk selection
+    setSelectedHunkIndex(index) {
+        this.update({ selectedHunkIndex: Math.max(0, index) });
+    }
+    /**
+     * Silently clamp selectedHunkIndex to valid range without emitting events.
+     * Called during render to sync state with actual hunk count.
+     */
+    clampSelectedHunkIndex(hunkCount) {
+        if (hunkCount <= 0) {
+            this._state.selectedHunkIndex = 0;
+        }
+        else if (this._state.selectedHunkIndex >= hunkCount) {
+            this._state.selectedHunkIndex = hunkCount - 1;
+        }
+    }
     // Display toggles
     toggleWrapMode() {
         this.update({ wrapMode: !this._state.wrapMode, diffScrollOffset: 0 });
@@ -126,6 +144,9 @@ export class UIState extends EventEmitter {
     toggleHideGitignored() {
         this.update({ hideGitignored: !this._state.hideGitignored });
     }
+    toggleFlatViewMode() {
+        this.update({ flatViewMode: !this._state.flatViewMode, fileListScrollOffset: 0 });
+    }
     // Split ratio
     adjustSplitRatio(delta) {
         const newRatio = Math.min(0.85, Math.max(0.15, this._state.splitRatio + delta));
@@ -189,6 +210,7 @@ export class UIState extends EventEmitter {
             explorerSelectedIndex: 0,
             explorerScrollOffset: 0,
             explorerFileScrollOffset: 0,
+            selectedHunkIndex: 0,
         };
         this.emit('change', this._state);
     }

package/dist/types/remote.js

@@ -0,0 +1,5 @@
+/**
+ * Shared type for remote operation state (push/fetch/pull).
+ * Lives in types/ so both ui/ and core/ can import it.
+ */
+export {};

package/dist/ui/PaneRenderers.js

@@ -1,14 +1,15 @@
 import { formatFileList } from './widgets/FileList.js';
+import { formatFlatFileList } from './widgets/FlatFileList.js';
 import { formatHistoryView } from './widgets/HistoryView.js';
 import { formatCompareListView } from './widgets/CompareListView.js';
 import { formatExplorerView } from './widgets/ExplorerView.js';
-import { formatDiff, formatHistoryDiff } from './widgets/DiffView.js';
-import { formatCommitPanel } from './widgets/CommitPanel.js';
+import { formatDiff, formatCombinedDiff, formatHistoryDiff } from './widgets/DiffView.js';
+import { formatCommitPanel, getCommitPanelTotalRows } from './widgets/CommitPanel.js';
 import { formatExplorerContent } from './widgets/ExplorerContent.js';
 /**
  * Render the top pane content for the current tab.
  */
-export function renderTopPane(state, files, historyCommits, compareDiff, compareSelection, explorerState, width, topPaneHeight) {
+export function renderTopPane(state, files, historyCommits, compareDiff, compareSelection, explorerState, width, topPaneHeight, hunkCounts, flatFiles) {
     if (state.bottomTab === 'history') {
         return formatHistoryView(historyCommits, state.historySelectedIndex, state.currentPane === 'history', width, state.historyScrollOffset, topPaneHeight);
     }
@@ -21,36 +22,65 @@ export function renderTopPane(state, files, historyCommits, compareDiff, compare
         const displayRows = explorerState?.displayRows ?? [];
         return formatExplorerView(displayRows, state.explorerSelectedIndex, state.currentPane === 'explorer', width, state.explorerScrollOffset, topPaneHeight, explorerState?.isLoading ?? false, explorerState?.error ?? null);
     }
-    // Default: diff tab file list
-    return formatFileList(files, state.selectedIndex, state.currentPane === 'files', width, state.fileListScrollOffset, topPaneHeight);
+    // Default: diff/commit tab file list
+    if (state.flatViewMode && flatFiles) {
+        return formatFlatFileList(flatFiles, state.selectedIndex, state.currentPane === 'files', width, state.fileListScrollOffset, topPaneHeight);
+    }
+    return formatFileList(files, state.selectedIndex, state.currentPane === 'files', width, state.fileListScrollOffset, topPaneHeight, hunkCounts);
 }
 /**
  * Render the bottom pane content for the current tab.
  */
-export function renderBottomPane(state, diff, historyState, compareSelectionState, explorerSelectedFile, commitFlowState, stagedCount, currentTheme, width, bottomPaneHeight) {
+export function renderBottomPane(state, diff, historyState, compareSelectionState, explorerSelectedFile, commitFlowState, stagedCount, currentTheme, width, bottomPaneHeight, selectedHunkIndex, isFileStaged, combinedFileDiffs, branch, remoteState, stashList, headCommit) {
     if (state.bottomTab === 'commit') {
-        const content = formatCommitPanel(commitFlowState, stagedCount, width);
-        return { content, totalRows: 0 };
+        const panelOpts = {
+            state: commitFlowState,
+            stagedCount,
+            width,
+            branch,
+            remoteState,
+            stashList,
+            headCommit,
+        };
+        const totalRows = getCommitPanelTotalRows(panelOpts);
+        const content = formatCommitPanel(commitFlowState, stagedCount, width, branch, remoteState, stashList, headCommit, state.diffScrollOffset, bottomPaneHeight);
+        return { content, totalRows, hunkCount: 0, hunkBoundaries: [] };
     }
     if (state.bottomTab === 'history') {
         const selectedCommit = historyState?.selectedCommit ?? null;
         const commitDiff = historyState?.commitDiff ?? null;
         const { content, totalRows } = formatHistoryDiff(selectedCommit, commitDiff, width, state.diffScrollOffset, bottomPaneHeight, currentTheme, state.wrapMode);
-        return { content, totalRows };
+        return { content, totalRows, hunkCount: 0, hunkBoundaries: [] };
     }
     if (state.bottomTab === 'compare') {
         const compareDiff = compareSelectionState?.diff ?? null;
         if (compareDiff) {
             const { content, totalRows } = formatDiff(compareDiff, width, state.diffScrollOffset, bottomPaneHeight, currentTheme, state.wrapMode);
-            return { content, totalRows };
+            return { content, totalRows, hunkCount: 0, hunkBoundaries: [] };
         }
-        return { content: '{gray-fg}Select a commit or file to view diff{/gray-fg}', totalRows: 0 };
+        return {
+            content: '{gray-fg}Select a commit or file to view diff{/gray-fg}',
+            totalRows: 0,
+            hunkCount: 0,
+            hunkBoundaries: [],
+        };
     }
     if (state.bottomTab === 'explorer') {
         const content = formatExplorerContent(explorerSelectedFile?.path ?? null, explorerSelectedFile?.content ?? null, width, state.explorerFileScrollOffset, bottomPaneHeight, explorerSelectedFile?.truncated ?? false, state.wrapMode);
-        return { content, totalRows: 0 };
+        return { content, totalRows: 0, hunkCount: 0, hunkBoundaries: [] };
+    }
+    // Flat mode: show combined unstaged+staged diff with section headers
+    if (state.flatViewMode && combinedFileDiffs) {
+        const result = formatCombinedDiff(combinedFileDiffs.unstaged, combinedFileDiffs.staged, width, state.diffScrollOffset, bottomPaneHeight, currentTheme, state.wrapMode, selectedHunkIndex);
+        return {
+            content: result.content,
+            totalRows: result.totalRows,
+            hunkCount: result.hunkCount,
+            hunkBoundaries: result.hunkBoundaries,
+            hunkMapping: result.hunkMapping,
+        };
     }
-    // Default: diff tab
-    const { content, totalRows } = formatDiff(diff, width, state.diffScrollOffset, bottomPaneHeight, currentTheme, state.wrapMode);
-    return { content, totalRows };
+    // Default: diff tab — pass selectedHunkIndex for hunk gutter
+    const { content, totalRows, hunkCount, hunkBoundaries } = formatDiff(diff, width, state.diffScrollOffset, bottomPaneHeight, currentTheme, state.wrapMode, selectedHunkIndex, isFileStaged);
+    return { content, totalRows, hunkCount, hunkBoundaries };
 }

package/dist/ui/modals/BranchPicker.js

@@ -0,0 +1,157 @@
+import blessed from 'neo-blessed';
+/**
+ * BranchPicker modal for switching or creating branches.
+ * Text input at top for filtering; branch list below.
+ * If typed name matches no existing branch, shows "Create: <name>" as first option.
+ */
+export class BranchPicker {
+    box;
+    textbox;
+    screen;
+    branches;
+    filteredBranches = [];
+    selectedIndex = 0;
+    query = '';
+    showCreate = false;
+    onSwitch;
+    onCreate;
+    onCancel;
+    constructor(screen, branches, onSwitch, onCreate, onCancel) {
+        this.screen = screen;
+        this.branches = branches;
+        this.onSwitch = onSwitch;
+        this.onCreate = onCreate;
+        this.onCancel = onCancel;
+        this.filteredBranches = branches;
+        const width = Math.min(60, screen.width - 6);
+        const maxVisible = Math.min(branches.length + 1, 15);
+        const height = maxVisible + 7;
+        this.box = blessed.box({
+            parent: screen,
+            top: 'center',
+            left: 'center',
+            width,
+            height,
+            border: {
+                type: 'line',
+            },
+            style: {
+                border: {
+                    fg: 'cyan',
+                },
+            },
+            tags: true,
+            keys: false,
+        });
+        this.textbox = blessed.textarea({
+            parent: this.box,
+            top: 1,
+            left: 1,
+            width: width - 4,
+            height: 1,
+            inputOnFocus: true,
+            style: {
+                fg: 'white',
+                bg: 'default',
+            },
+        });
+        this.setupKeyHandlers();
+        this.render();
+    }
+    setupKeyHandlers() {
+        this.textbox.key(['escape'], () => {
+            this.close();
+            this.onCancel();
+        });
+        this.textbox.key(['enter'], () => {
+            if (this.showCreate && this.selectedIndex === 0) {
+                this.close();
+                this.onCreate(this.query.trim());
+            }
+            else {
+                const adjustedIndex = this.showCreate ? this.selectedIndex - 1 : this.selectedIndex;
+                const branch = this.filteredBranches[adjustedIndex];
+                if (branch && !branch.current) {
+                    this.close();
+                    this.onSwitch(branch.name);
+                }
+            }
+        });
+        this.textbox.key(['C-j', 'down'], () => {
+            const maxIndex = this.filteredBranches.length + (this.showCreate ? 1 : 0) - 1;
+            this.selectedIndex = Math.min(maxIndex, this.selectedIndex + 1);
+            this.render();
+        });
+        this.textbox.key(['C-k', 'up'], () => {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.render();
+        });
+        this.textbox.on('keypress', () => {
+            setImmediate(() => {
+                const newQuery = this.textbox.getValue() || '';
+                if (newQuery !== this.query) {
+                    this.query = newQuery;
+                    this.selectedIndex = 0;
+                    this.updateFilter();
+                    this.render();
+                }
+            });
+        });
+    }
+    updateFilter() {
+        const q = this.query.trim().toLowerCase();
+        if (!q) {
+            this.filteredBranches = this.branches;
+            this.showCreate = false;
+        }
+        else {
+            this.filteredBranches = this.branches.filter((b) => b.name.toLowerCase().includes(q));
+            // Show create option if no exact match
+            this.showCreate = !this.branches.some((b) => b.name === q);
+        }
+    }
+    render() {
+        const lines = [];
+        lines.push('{bold}{cyan-fg}Switch / Create Branch{/cyan-fg}{/bold}');
+        lines.push(''); // Space for input
+        lines.push('');
+        if (this.showCreate) {
+            const isSelected = this.selectedIndex === 0;
+            if (isSelected) {
+                lines.push(`{green-fg}{bold}> Create: ${this.query.trim()}{/bold}{/green-fg}`);
+            }
+            else {
+                lines.push(`  {green-fg}Create: ${this.query.trim()}{/green-fg}`);
+            }
+        }
+        for (let i = 0; i < this.filteredBranches.length; i++) {
+            const branch = this.filteredBranches[i];
+            const listIndex = this.showCreate ? i + 1 : i;
+            const isSelected = listIndex === this.selectedIndex;
+            let line = isSelected ? '{cyan-fg}{bold}> ' : '  ';
+            if (branch.current) {
+                line += '* ';
+            }
+            line += branch.name;
+            if (isSelected)
+                line += '{/bold}{/cyan-fg}';
+            if (branch.current)
+                line += ' {gray-fg}(current){/gray-fg}';
+            lines.push(line);
+        }
+        if (this.filteredBranches.length === 0 && !this.showCreate) {
+            lines.push('{gray-fg}No matching branches{/gray-fg}');
+        }
+        lines.push('');
+        lines.push('{gray-fg}Enter: select | Esc: cancel | Ctrl+j/k: navigate{/gray-fg}');
+        this.box.setContent(lines.join('\n'));
+        this.screen.render();
+    }
+    close() {
+        this.textbox.destroy();
+        this.box.destroy();
+    }
+    focus() {
+        this.textbox.focus();
+    }
+}

package/dist/ui/modals/CommitActionConfirm.js

@@ -0,0 +1,66 @@
+import blessed from 'neo-blessed';
+/**
+ * CommitActionConfirm modal for confirming cherry-pick or revert.
+ */
+export class CommitActionConfirm {
+    box;
+    screen;
+    onConfirm;
+    onCancel;
+    constructor(screen, verb, commit, onConfirm, onCancel) {
+        this.screen = screen;
+        this.onConfirm = onConfirm;
+        this.onCancel = onCancel;
+        const width = Math.min(60, screen.width - 6);
+        const height = 8;
+        this.box = blessed.box({
+            parent: screen,
+            top: 'center',
+            left: 'center',
+            width,
+            height,
+            border: {
+                type: 'line',
+            },
+            style: {
+                border: {
+                    fg: 'yellow',
+                },
+            },
+            tags: true,
+            keys: true,
+        });
+        this.setupKeyHandlers();
+        this.renderContent(verb, commit, width);
+    }
+    setupKeyHandlers() {
+        this.box.key(['y', 'Y'], () => {
+            this.close();
+            this.onConfirm();
+        });
+        this.box.key(['n', 'N', 'escape', 'q'], () => {
+            this.close();
+            this.onCancel();
+        });
+    }
+    renderContent(verb, commit, width) {
+        const lines = [];
+        const innerWidth = width - 6;
+        lines.push(`{bold}{yellow-fg}     ${verb} commit?{/yellow-fg}{/bold}`);
+        lines.push('');
+        const msg = commit.message.length > innerWidth
+            ? commit.message.slice(0, innerWidth - 3) + '\u2026'
+            : commit.message;
+        lines.push(`{yellow-fg}${commit.shortHash}{/yellow-fg} ${msg}`);
+        lines.push('');
+        lines.push('{gray-fg}Press {/gray-fg}{green-fg}y{/green-fg}{gray-fg} to confirm, {/gray-fg}{red-fg}n{/red-fg}{gray-fg} or Esc to cancel{/gray-fg}');
+        this.box.setContent(lines.join('\n'));
+        this.screen.render();
+    }
+    close() {
+        this.box.destroy();
+    }
+    focus() {
+        this.box.focus();
+    }
+}

package/dist/ui/modals/FileFinder.js

@@ -1,56 +1,20 @@
 import blessed from 'neo-blessed';
+import { Fzf } from 'fzf';
 const MAX_RESULTS = 15;
+const DEBOUNCE_MS = 15;
 /**
- * Simple fuzzy match scoring.
- * Returns -1 if no match, otherwise a score (higher is better).
+ * Highlight matched characters in a display path.
+ * The positions set refers to indices in the original full path,
+ * so we need an offset when the display path is truncated.
  */
-function fuzzyScore(query, target) {
-    const lowerQuery = query.toLowerCase();
-    const lowerTarget = target.toLowerCase();
-    // Must contain all query characters in order
-    let queryIndex = 0;
-    let score = 0;
-    let lastMatchIndex = -1;
-    for (let i = 0; i < lowerTarget.length && queryIndex < lowerQuery.length; i++) {
-        if (lowerTarget[i] === lowerQuery[queryIndex]) {
-            // Bonus for consecutive matches
-            if (lastMatchIndex === i - 1) {
-                score += 10;
-            }
-            // Bonus for matching at start of word
-            if (i === 0 || lowerTarget[i - 1] === '/' || lowerTarget[i - 1] === '.') {
-                score += 5;
-            }
-            score += 1;
-            lastMatchIndex = i;
-            queryIndex++;
-        }
-    }
-    // All query characters must match
-    if (queryIndex < lowerQuery.length) {
-        return -1;
-    }
-    // Bonus for shorter paths (more specific)
-    score += Math.max(0, 50 - target.length);
-    return score;
-}
-/**
- * Highlight matched characters in path.
- */
-function highlightMatch(query, path) {
-    if (!query)
-        return path;
-    const lowerQuery = query.toLowerCase();
-    const lowerPath = path.toLowerCase();
+function highlightMatch(displayPath, positions, offset) {
     let result = '';
-    let queryIndex = 0;
-    for (let i = 0; i < path.length; i++) {
-        if (queryIndex < lowerQuery.length && lowerPath[i] === lowerQuery[queryIndex]) {
-            result += `{yellow-fg}${path[i]}{/yellow-fg}`;
-            queryIndex++;
+    for (let i = 0; i < displayPath.length; i++) {
+        if (positions.has(i + offset)) {
+            result += `{yellow-fg}${displayPath[i]}{/yellow-fg}`;
         }
         else {
-            result += path[i];
+            result += displayPath[i];
         }
     }
     return result;
@@ -68,11 +32,14 @@ export class FileFinder {
     query = '';
     onSelect;
     onCancel;
+    debounceTimer = null;
+    fzf;
     constructor(screen, allPaths, onSelect, onCancel) {
         this.screen = screen;
         this.allPaths = allPaths;
         this.onSelect = onSelect;
         this.onCancel = onCancel;
+        this.fzf = new Fzf(allPaths, { limit: MAX_RESULTS, casing: 'smart-case' });
         // Create modal box
         const width = Math.min(80, screen.width - 10);
         const height = MAX_RESULTS + 6; // results + input + header + borders + padding
@@ -108,9 +75,9 @@ export class FileFinder {
         });
         // Setup key handlers
         this.setupKeyHandlers();
-        // Initial render with all files
+        // Initial render with first N files
         this.updateResults();
-        this.render();
+        this.renderContent();
     }
     setupKeyHandlers() {
         // Handle escape to cancel
@@ -129,57 +96,53 @@ export class FileFinder {
         // Handle up/down for navigation (Ctrl+j/k since j/k are for typing)
         this.textbox.key(['C-j', 'down'], () => {
             this.selectedIndex = Math.min(this.results.length - 1, this.selectedIndex + 1);
-            this.render();
+            this.renderContent();
         });
         this.textbox.key(['C-k', 'up'], () => {
             this.selectedIndex = Math.max(0, this.selectedIndex - 1);
-            this.render();
+            this.renderContent();
         });
         // Handle tab for next result
         this.textbox.key(['tab'], () => {
             this.selectedIndex = (this.selectedIndex + 1) % Math.max(1, this.results.length);
-            this.render();
+            this.renderContent();
         });
         // Handle shift-tab for previous result
         this.textbox.key(['S-tab'], () => {
             this.selectedIndex =
                 (this.selectedIndex - 1 + this.results.length) % Math.max(1, this.results.length);
-            this.render();
+            this.renderContent();
         });
-        // Update results on keypress
+        // Update results on keypress with debounce
         this.textbox.on('keypress', () => {
-            // Defer to next tick to get updated value
-            setImmediate(() => {
+            if (this.debounceTimer)
+                clearTimeout(this.debounceTimer);
+            this.debounceTimer = setTimeout(() => {
                 const newQuery = this.textbox.getValue() || '';
                 if (newQuery !== this.query) {
                     this.query = newQuery;
                     this.selectedIndex = 0;
                     this.updateResults();
-                    this.render();
+                    this.renderContent();
                 }
-            });
+            }, DEBOUNCE_MS);
         });
     }
     updateResults() {
         if (!this.query) {
-            // Show first N files when no query
-            this.results = this.allPaths.slice(0, MAX_RESULTS).map((path) => ({ path, score: 0 }));
+            this.results = this.allPaths
+                .slice(0, MAX_RESULTS)
+                .map((p) => ({ path: p, positions: new Set(), score: 0 }));
             return;
         }
-        // Fuzzy match all paths
-        const scored = [];
-        for (const path of this.allPaths) {
-            const score = fuzzyScore(this.query, path);
-            if (score >= 0) {
-                scored.push({ path, score });
-            }
-        }
-        // Sort by score (descending)
-        scored.sort((a, b) => b.score - a.score);
-        // Take top results
-        this.results = scored.slice(0, MAX_RESULTS);
+        const entries = this.fzf.find(this.query);
+        this.results = entries.map((entry) => ({
+            path: entry.item,
+            score: entry.score,
+            positions: entry.positions,
+        }));
     }
-    render() {
+    renderContent() {
         const lines = [];
         const width = this.box.width - 4;
         // Header
@@ -195,13 +158,18 @@ export class FileFinder {
                 const result = this.results[i];
                 const isSelected = i === this.selectedIndex;
                 // Truncate path if needed
-                let displayPath = result.path;
+                const fullPath = result.path;
                 const maxLen = width - 4;
+                let displayPath = fullPath;
+                let offset = 0;
                 if (displayPath.length > maxLen) {
-                    displayPath = '…' + displayPath.slice(-(maxLen - 1));
+                    offset = displayPath.length - (maxLen - 1);
+                    displayPath = '…' + displayPath.slice(offset);
+                    // Account for the '…' prefix: display index 0 is '…', actual content starts at 1
+                    offset = offset - 1;
                 }
                 // Highlight matched characters
-                const highlighted = highlightMatch(this.query, displayPath);
+                const highlighted = highlightMatch(displayPath, result.positions, offset);
                 if (isSelected) {
                     lines.push(`{cyan-fg}{bold}> ${highlighted}{/bold}{/cyan-fg}`);
                 }
@@ -220,6 +188,8 @@ export class FileFinder {
         this.screen.render();
     }
     close() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
         this.textbox.destroy();
         this.box.destroy();
     }