diffstalker 0.2.2 → 0.2.3

package/dist/App.js

@@ -15,6 +15,10 @@ import { HotkeysModal } from './ui/modals/HotkeysModal.js';
 import { BaseBranchPicker } from './ui/modals/BaseBranchPicker.js';
 import { DiscardConfirm } from './ui/modals/DiscardConfirm.js';
 import { FileFinder } from './ui/modals/FileFinder.js';
+import { StashListModal } from './ui/modals/StashListModal.js';
+import { BranchPicker } from './ui/modals/BranchPicker.js';
+import { SoftResetConfirm } from './ui/modals/SoftResetConfirm.js';
+import { CommitActionConfirm } from './ui/modals/CommitActionConfirm.js';
 import { CommitFlowState } from './state/CommitFlowState.js';
 import { UIState } from './state/UIState.js';
 import { getManagerForRepo, removeManagerForRepo, } from './core/GitStateManager.js';
@@ -43,6 +47,8 @@ export class App {
     commitTextarea = null;
     // Active modals
     activeModal = null;
+    // Auto-clear timer for remote operation status
+    remoteClearTimer = null;
     // Cached total rows and hunk info for scroll bounds (single source of truth from render)
     bottomPaneTotalRows = 0;
     bottomPaneHunkCount = 0;
@@ -170,11 +176,22 @@ export class App {
             toggleCurrentHunk: () => this.toggleCurrentHunk(),
             navigateNextHunk: () => this.navigateNextHunk(),
             navigatePrevHunk: () => this.navigatePrevHunk(),
+            push: () => this.gitManager?.push(),
+            fetchRemote: () => this.gitManager?.fetchRemote(),
+            pullRebase: () => this.gitManager?.pullRebase(),
+            stash: () => this.gitManager?.stash(),
+            stashPop: () => this.gitManager?.stashPop(),
+            openStashListModal: () => this.openStashListModal(),
+            openBranchPicker: () => this.openBranchPicker(),
+            showSoftResetConfirm: () => this.showSoftResetConfirm(),
+            cherryPickSelected: () => this.cherryPickSelected(),
+            revertSelected: () => this.revertSelected(),
         }, {
             hasActiveModal: () => this.activeModal !== null,
             getBottomTab: () => this.uiState.state.bottomTab,
             getCurrentPane: () => this.uiState.state.currentPane,
             isCommitInputFocused: () => this.commitFlowState.state.inputFocused,
+            isRemoteInProgress: () => this.gitManager?.remoteState.inProgress ?? false,
             getStatusFiles: () => this.gitManager?.state.status?.files ?? [],
             getSelectedIndex: () => this.uiState.state.selectedIndex,
             uiState: this.uiState,
@@ -195,6 +212,11 @@ export class App {
             toggleMouseMode: () => this.toggleMouseMode(),
             toggleFollow: () => this.toggleFollow(),
             selectHunkAtRow: (row) => this.selectHunkAtRow(row),
+            focusCommitInput: () => this.focusCommitInput(),
+            toggleAmend: () => {
+                this.commitFlowState.toggleAmend();
+                this.render();
+            },
             render: () => this.render(),
         }, {
             uiState: this.uiState,
@@ -265,6 +287,13 @@ export class App {
                     this.explorerManager?.loadDirectory('');
                 }
             }
+            else if (tab === 'commit') {
+                this.gitManager?.loadStashList();
+                // Also load history if needed for HEAD commit display
+                if (!this.gitManager?.historyState.commits.length) {
+                    this.gitManager?.loadHistory();
+                }
+            }
         });
         // Handle modal opening/closing
         this.uiState.on('modal-change', (modal) => {
@@ -370,6 +399,22 @@ export class App {
         this.gitManager.on('compare-selection-change', () => {
             this.render();
         });
+        this.gitManager.on('remote-state-change', (remoteState) => {
+            // Auto-clear success after 3s, error after 5s
+            if (this.remoteClearTimer)
+                clearTimeout(this.remoteClearTimer);
+            if (remoteState.lastResult && !remoteState.inProgress) {
+                this.remoteClearTimer = setTimeout(() => {
+                    this.gitManager?.clearRemoteState();
+                }, 3000);
+            }
+            else if (remoteState.error) {
+                this.remoteClearTimer = setTimeout(() => {
+                    this.gitManager?.clearRemoteState();
+                }, 5000);
+            }
+            this.render();
+        });
         // Start watching and do initial refresh
         this.gitManager.startWatching();
         this.gitManager.refresh();
@@ -439,6 +484,8 @@ export class App {
         });
         // Load root directory
         this.explorerManager.loadDirectory('');
+        // Pre-load file paths for file finder (runs in background)
+        this.explorerManager.loadFilePaths();
         // Update git status after tree is loaded
         this.updateExplorerGitStatus();
     }
@@ -985,7 +1032,12 @@ export class App {
         }
     }
     async openFileFinder() {
-        const allPaths = (await this.explorerManager?.getAllFilePaths()) ?? [];
+        let allPaths = this.explorerManager?.getCachedFilePaths() ?? [];
+        if (allPaths.length === 0) {
+            // First open or cache not yet loaded — wait for it
+            await this.explorerManager?.loadFilePaths();
+            allPaths = this.explorerManager?.getCachedFilePaths() ?? [];
+        }
         if (allPaths.length === 0)
             return;
         this.activeModal = new FileFinder(this.screen, allPaths, async (selectedPath) => {
@@ -1017,6 +1069,66 @@ export class App {
         });
         this.activeModal.focus();
     }
+    openStashListModal() {
+        const entries = this.gitManager?.state.stashList ?? [];
+        this.activeModal = new StashListModal(this.screen, entries, (index) => {
+            this.activeModal = null;
+            this.gitManager?.stashPop(index);
+        }, () => {
+            this.activeModal = null;
+        });
+        this.activeModal.focus();
+    }
+    openBranchPicker() {
+        this.gitManager?.getLocalBranches().then((branches) => {
+            this.activeModal = new BranchPicker(this.screen, branches, (name) => {
+                this.activeModal = null;
+                this.gitManager?.switchBranch(name);
+            }, (name) => {
+                this.activeModal = null;
+                this.gitManager?.createBranch(name);
+            }, () => {
+                this.activeModal = null;
+            });
+            this.activeModal.focus();
+        });
+    }
+    showSoftResetConfirm() {
+        const headCommit = this.gitManager?.historyState.commits[0];
+        if (!headCommit)
+            return;
+        this.activeModal = new SoftResetConfirm(this.screen, headCommit, () => {
+            this.activeModal = null;
+            this.gitManager?.softReset();
+        }, () => {
+            this.activeModal = null;
+        });
+        this.activeModal.focus();
+    }
+    cherryPickSelected() {
+        const commit = this.gitManager?.historyState.selectedCommit;
+        if (!commit)
+            return;
+        this.activeModal = new CommitActionConfirm(this.screen, 'Cherry-pick', commit, () => {
+            this.activeModal = null;
+            this.gitManager?.cherryPick(commit.hash);
+        }, () => {
+            this.activeModal = null;
+        });
+        this.activeModal.focus();
+    }
+    revertSelected() {
+        const commit = this.gitManager?.historyState.selectedCommit;
+        if (!commit)
+            return;
+        this.activeModal = new CommitActionConfirm(this.screen, 'Revert', commit, () => {
+            this.activeModal = null;
+            this.gitManager?.revertCommit(commit.hash);
+        }, () => {
+            this.activeModal = null;
+        });
+        this.activeModal.focus();
+    }
     async commit(message) {
         await this.gitManager?.commit(message);
     }
@@ -1083,7 +1195,7 @@ export class App {
     updateHeader() {
         const gitState = this.gitManager?.state;
         const width = this.screen.width || 80;
-        const content = formatHeader(this.repoPath, gitState?.status?.branch ?? null, gitState?.isLoading ?? false, gitState?.error ?? null, width);
+        const content = formatHeader(this.repoPath, gitState?.status?.branch ?? null, gitState?.isLoading ?? false, gitState?.error ?? null, width, this.gitManager?.remoteState ?? null);
         this.layout.headerBox.setContent(content);
     }
     updateTopPane() {
@@ -1108,7 +1220,7 @@ export class App {
         const diffPaneFocused = state.bottomTab === 'diff' && state.currentPane === 'diff';
         const hunkIndex = diffPaneFocused ? state.selectedHunkIndex : undefined;
         const isFileStaged = diffPaneFocused ? this.gitManager?.state.selectedFile?.staged : undefined;
-        const { content, totalRows, hunkCount, hunkBoundaries, hunkMapping } = renderBottomPane(state, this.gitManager?.state.diff ?? null, this.gitManager?.historyState, this.gitManager?.compareSelectionState, this.explorerManager?.state?.selectedFile ?? null, this.commitFlowState.state, stagedCount, this.currentTheme, width, this.layout.dimensions.bottomPaneHeight, hunkIndex, isFileStaged, state.flatViewMode ? this.gitManager?.state.combinedFileDiffs : undefined);
+        const { content, totalRows, hunkCount, hunkBoundaries, hunkMapping } = renderBottomPane(state, this.gitManager?.state.diff ?? null, this.gitManager?.historyState, this.gitManager?.compareSelectionState, this.explorerManager?.state?.selectedFile ?? null, this.commitFlowState.state, stagedCount, this.currentTheme, width, this.layout.dimensions.bottomPaneHeight, hunkIndex, isFileStaged, state.flatViewMode ? this.gitManager?.state.combinedFileDiffs : undefined, this.gitManager?.state.status?.branch ?? null, this.gitManager?.remoteState ?? null, this.gitManager?.state.stashList, this.gitManager?.historyState.commits[0] ?? null);
         this.bottomPaneTotalRows = totalRows;
         this.bottomPaneHunkCount = hunkCount;
         this.bottomPaneHunkBoundaries = hunkBoundaries;
@@ -1149,6 +1261,9 @@ export class App {
         if (this.commandServer) {
             this.commandServer.stop();
         }
+        if (this.remoteClearTimer) {
+            clearTimeout(this.remoteClearTimer);
+        }
         // Destroy screen (this will clean up terminal)
         this.screen.destroy();
     }

package/dist/KeyBindings.js

@@ -130,6 +130,29 @@ export function setupKeyBindings(screen, actions, ctx) {
             ctx.uiState.toggleAutoTab();
         }
     });
+    // Ctrl+a: toggle amend on commit tab (works even when input is focused)
+    screen.key(['C-a'], () => {
+        if (ctx.getBottomTab() === 'commit') {
+            ctx.commitFlowState.toggleAmend();
+            actions.render();
+        }
+    });
+    // Remote operations (global, any tab)
+    screen.key(['S-p'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused() || ctx.isRemoteInProgress())
+            return;
+        actions.push();
+    });
+    screen.key(['S-f'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused() || ctx.isRemoteInProgress())
+            return;
+        actions.fetchRemote();
+    });
+    screen.key(['S-r'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused() || ctx.isRemoteInProgress())
+            return;
+        actions.pullRebase();
+    });
     screen.key(['escape'], () => {
         if (ctx.getBottomTab() === 'commit') {
             if (ctx.isCommitInputFocused()) {
@@ -163,11 +186,16 @@ export function setupKeyBindings(screen, actions, ctx) {
     screen.key(['?'], () => ctx.uiState.toggleModal('hotkeys'));
     // Follow toggle
     screen.key(['f'], () => actions.toggleFollow());
-    // Compare view: base branch picker
+    // Compare view: base branch picker / Commit tab: branch picker
     screen.key(['b'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused())
+            return;
         if (ctx.getBottomTab() === 'compare') {
             ctx.uiState.openModal('baseBranch');
         }
+        else if (ctx.getBottomTab() === 'commit') {
+            actions.openBranchPicker();
+        }
     });
     // u: toggle uncommitted in compare view
     screen.key(['u'], () => {
@@ -225,4 +253,50 @@ export function setupKeyBindings(screen, actions, ctx) {
             actions.navigatePrevHunk();
         }
     });
+    // Stash: save (global)
+    screen.key(['S-s'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused() || ctx.isRemoteInProgress())
+            return;
+        actions.stash();
+    });
+    // Stash: pop (commit tab only)
+    screen.key(['o'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused())
+            return;
+        if (ctx.getBottomTab() === 'commit') {
+            actions.stashPop();
+        }
+    });
+    // Stash: list modal (commit tab only)
+    screen.key(['l'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused())
+            return;
+        if (ctx.getBottomTab() === 'commit') {
+            actions.openStashListModal();
+        }
+    });
+    // Soft reset HEAD~1 (commit tab only)
+    screen.key(['S-x'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused() || ctx.isRemoteInProgress())
+            return;
+        if (ctx.getBottomTab() === 'commit') {
+            actions.showSoftResetConfirm();
+        }
+    });
+    // Cherry-pick selected commit (history tab only)
+    screen.key(['p'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused())
+            return;
+        if (ctx.getBottomTab() === 'history') {
+            actions.cherryPickSelected();
+        }
+    });
+    // Revert selected commit (history tab only)
+    screen.key(['v'], () => {
+        if (ctx.hasActiveModal() || ctx.isCommitInputFocused())
+            return;
+        if (ctx.getBottomTab() === 'history') {
+            actions.revertSelected();
+        }
+    });
 }

package/dist/MouseHandlers.js

@@ -29,11 +29,22 @@ export function setupMouseHandlers(layout, actions, ctx) {
             handleTopPaneClick(clickedRow, mouse.x, actions, ctx);
         }
     });
-    // Click on bottom pane to select hunk (diff tab)
+    // Click on bottom pane
     layout.bottomPane.on('click', (mouse) => {
         const clickedRow = layout.screenYToBottomPaneRow(mouse.y);
         if (clickedRow >= 0) {
-            actions.selectHunkAtRow(clickedRow);
+            if (ctx.uiState.state.bottomTab === 'commit') {
+                // Row 6 (0-indexed) is the amend checkbox row
+                if (clickedRow === 6) {
+                    actions.toggleAmend();
+                }
+                else {
+                    actions.focusCommitInput();
+                }
+            }
+            else {
+                actions.selectHunkAtRow(clickedRow);
+            }
         }
     });
     // Click on footer for tabs and toggles

package/dist/core/ExplorerStateManager.js

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { EventEmitter } from 'node:events';
 import { getIgnoredFiles } from '../git/ignoreUtils.js';
+import { listAllFiles } from '../git/status.js';
 const MAX_FILE_SIZE = 1024 * 1024; // 1MB
 const WARN_FILE_SIZE = 100 * 1024; // 100KB
 /**
@@ -25,6 +26,7 @@ export class ExplorerStateManager extends EventEmitter {
     options;
     expandedPaths = new Set();
     gitStatusMap = { files: new Map(), directories: new Set() };
+    _cachedFilePaths = null;
     _state = {
         currentPath: '',
         tree: null,
@@ -61,9 +63,12 @@ export class ExplorerStateManager extends EventEmitter {
     }
     /**
      * Update git status map and refresh display.
+     * Also invalidates the file path cache so the next file finder open gets fresh data.
      */
     setGitStatus(statusMap) {
         this.gitStatusMap = statusMap;
+        // Invalidate file path cache — reload in background
+        this.loadFilePaths();
         // Refresh display to show updated status
         if (this._state.tree) {
             this.applyGitStatusToTree(this._state.tree);
@@ -538,45 +543,23 @@ export class ExplorerStateManager extends EventEmitter {
         return search(this._state.tree);
     }
     /**
-     * Get all file paths in the repo (for file finder).
-     * Scans the filesystem directly to get all files, not just expanded ones.
+     * Load all file paths using git ls-files (fast, single git command).
+     * Stores result in cache for instant access by FileFinder.
      */
-    async getAllFilePaths() {
-        const paths = [];
-        const scanDir = async (dirPath) => {
-            try {
-                const fullPath = path.join(this.repoPath, dirPath);
-                const entries = await fs.promises.readdir(fullPath, { withFileTypes: true });
-                // Build list of paths for gitignore check
-                const pathsToCheck = entries.map((e) => (dirPath ? path.join(dirPath, e.name) : e.name));
-                // Get ignored files
-                const ignoredFiles = this.options.hideGitignored
-                    ? await getIgnoredFiles(this.repoPath, pathsToCheck)
-                    : new Set();
-                for (const entry of entries) {
-                    // Filter dot-prefixed hidden files
-                    if (this.options.hideHidden && entry.name.startsWith('.')) {
-                        continue;
-                    }
-                    const entryPath = dirPath ? path.join(dirPath, entry.name) : entry.name;
-                    // Filter gitignored files
-                    if (this.options.hideGitignored && ignoredFiles.has(entryPath)) {
-                        continue;
-                    }
-                    if (entry.isDirectory()) {
-                        await scanDir(entryPath);
-                    }
-                    else {
-                        paths.push(entryPath);
-                    }
-                }
-            }
-            catch {
-                // Ignore errors for individual directories
-            }
-        };
-        await scanDir('');
-        return paths;
+    async loadFilePaths() {
+        try {
+            this._cachedFilePaths = await listAllFiles(this.repoPath);
+        }
+        catch {
+            this._cachedFilePaths = [];
+        }
+    }
+    /**
+     * Get cached file paths (for file finder).
+     * Returns empty array if not yet loaded.
+     */
+    getCachedFilePaths() {
+        return this._cachedFilePaths ?? [];
     }
     /**
      * Navigate to a specific file path in the tree.

package/dist/core/GitStateManager.js

@@ -5,7 +5,7 @@ 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, getCommitHistory, stageHunk as gitStageHunk, unstageHunk as gitUnstageHunk, } from '../git/status.js';
+import { getStatus, stageFile, unstageFile, stageAll as gitStageAll, unstageAll as gitUnstageAll, discardChanges as gitDiscardChanges, commit as gitCommit, getHeadMessage, getCommitHistory, stageHunk as gitStageHunk, unstageHunk as gitUnstageHunk, push as gitPush, fetchRemote as gitFetchRemote, pullRebase as gitPullRebase, getStashList as gitGetStashList, stashSave as gitStashSave, stashPop as gitStashPop, getLocalBranches as gitGetLocalBranches, switchBranch as gitSwitchBranch, createBranch as gitCreateBranch, softResetHead as gitSoftResetHead, cherryPick as gitCherryPick, revertCommit as gitRevertCommit, } from '../git/status.js';
 import { getDiff, getDiffForUntracked, getStagedDiff, getDefaultBaseBranch, getCandidateBaseBranches, getDiffBetweenRefs, getCompareDiffWithUncommitted, getCommitDiff, countHunksPerFile, } from '../git/diff.js';
 import { getCachedBaseBranch, setCachedBaseBranch } from '../utils/baseBranchCache.js';
 /**
@@ -28,6 +28,7 @@ export class GitStateManager extends EventEmitter {
         isLoading: false,
         error: null,
         hunkCounts: null,
+        stashList: [],
     };
     _compareState = {
         compareDiff: null,
@@ -46,6 +47,12 @@ export class GitStateManager extends EventEmitter {
         index: 0,
         diff: null,
     };
+    _remoteState = {
+        operation: null,
+        inProgress: false,
+        error: null,
+        lastResult: null,
+    };
     constructor(repoPath) {
         super();
         this.repoPath = repoPath;
@@ -63,6 +70,13 @@ export class GitStateManager extends EventEmitter {
     get compareSelectionState() {
         return this._compareSelectionState;
     }
+    get remoteState() {
+        return this._remoteState;
+    }
+    updateRemoteState(partial) {
+        this._remoteState = { ...this._remoteState, ...partial };
+        this.emit('remote-state-change', this._remoteState);
+    }
     updateState(partial) {
         this._state = { ...this._state, ...partial };
         this.emit('state-change', this._state);
@@ -504,6 +518,133 @@ export class GitStateManager extends EventEmitter {
             });
         }
     }
+    // Remote operations
+    /**
+     * Push to remote.
+     */
+    async push() {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('push', () => gitPush(this.repoPath));
+    }
+    /**
+     * Fetch from remote.
+     */
+    async fetchRemote() {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('fetch', () => gitFetchRemote(this.repoPath));
+    }
+    /**
+     * Pull with rebase from remote.
+     */
+    async pullRebase() {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('pull', () => gitPullRebase(this.repoPath));
+    }
+    async runRemoteOperation(operation, fn) {
+        this.updateRemoteState({ operation, inProgress: true, error: null, lastResult: null });
+        try {
+            const result = await this.queue.enqueue(fn);
+            this.updateRemoteState({ inProgress: false, lastResult: result });
+            // Refresh status to pick up new ahead/behind counts
+            this.scheduleRefresh();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.updateRemoteState({ inProgress: false, error: message });
+        }
+    }
+    // Stash operations
+    /**
+     * Load the stash list.
+     */
+    async loadStashList() {
+        try {
+            const stashList = await this.queue.enqueue(() => gitGetStashList(this.repoPath));
+            this.updateState({ stashList });
+        }
+        catch {
+            // Silently ignore — stash list is non-critical
+        }
+    }
+    /**
+     * Save working changes to stash.
+     */
+    async stash(message) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('stash', () => gitStashSave(this.repoPath, message));
+        await this.loadStashList();
+    }
+    /**
+     * Pop a stash entry.
+     */
+    async stashPop(index = 0) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('stashPop', () => gitStashPop(this.repoPath, index));
+        await this.loadStashList();
+    }
+    // Branch operations
+    /**
+     * Get local branches.
+     */
+    async getLocalBranches() {
+        return this.queue.enqueue(() => gitGetLocalBranches(this.repoPath));
+    }
+    /**
+     * Switch to an existing branch.
+     */
+    async switchBranch(name) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('branchSwitch', () => gitSwitchBranch(this.repoPath, name));
+        // Reset compare base branch since it may not exist on the new branch
+        this.updateCompareState({ compareBaseBranch: null });
+    }
+    /**
+     * Create and switch to a new branch.
+     */
+    async createBranch(name) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('branchCreate', () => gitCreateBranch(this.repoPath, name));
+        this.updateCompareState({ compareBaseBranch: null });
+    }
+    // Undo operations
+    /**
+     * Soft reset HEAD by count commits.
+     */
+    async softReset(count = 1) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('softReset', () => gitSoftResetHead(this.repoPath, count));
+    }
+    // History actions
+    /**
+     * Cherry-pick a commit.
+     */
+    async cherryPick(hash) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('cherryPick', () => gitCherryPick(this.repoPath, hash));
+    }
+    /**
+     * Revert a commit.
+     */
+    async revertCommit(hash) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('revert', () => gitRevertCommit(this.repoPath, hash));
+    }
+    /**
+     * Clear the remote state (e.g. after auto-clear timeout).
+     */
+    clearRemoteState() {
+        this.updateRemoteState({ operation: null, error: null, lastResult: null });
+    }
     /**
      * Get the HEAD commit message.
      */