diffstalker 0.2.0 → 0.2.2

package/dist/FollowMode.js

@@ -0,0 +1,85 @@
+import { FilePathWatcher } from './core/FilePathWatcher.js';
+/**
+ * Manages the file-watching follow mode.
+ * Watches a target file for repository path changes and file navigation.
+ */
+export class FollowMode {
+    targetFile;
+    getCurrentRepoPath;
+    callbacks;
+    watcher = null;
+    _watcherState = { enabled: false };
+    constructor(targetFile, getCurrentRepoPath, callbacks) {
+        this.targetFile = targetFile;
+        this.getCurrentRepoPath = getCurrentRepoPath;
+        this.callbacks = callbacks;
+    }
+    get watcherState() {
+        return this._watcherState;
+    }
+    get isEnabled() {
+        return this.watcher !== null;
+    }
+    /**
+     * Start watching the target file.
+     */
+    start() {
+        this.watcher = new FilePathWatcher(this.targetFile);
+        this.watcher.on('path-change', (state) => {
+            if (state.path && state.path !== this.getCurrentRepoPath()) {
+                this._watcherState = {
+                    enabled: true,
+                    sourceFile: state.sourceFile ?? this.targetFile,
+                    rawContent: state.rawContent ?? undefined,
+                    lastUpdate: state.lastUpdate ?? undefined,
+                };
+                this.callbacks.onRepoChange(state.path, this._watcherState);
+            }
+            // Navigate to the followed file if it's within the repo
+            if (state.rawContent) {
+                this.callbacks.onFileNavigate(state.rawContent);
+            }
+        });
+        this._watcherState = {
+            enabled: true,
+            sourceFile: this.targetFile,
+        };
+        this.watcher.start();
+        // Switch to the repo described in the target file
+        const initialState = this.watcher.state;
+        if (initialState.path && initialState.path !== this.getCurrentRepoPath()) {
+            this._watcherState = {
+                enabled: true,
+                sourceFile: initialState.sourceFile ?? this.targetFile,
+                rawContent: initialState.rawContent ?? undefined,
+                lastUpdate: initialState.lastUpdate ?? undefined,
+            };
+            this.callbacks.onRepoChange(initialState.path, this._watcherState);
+        }
+        else if (initialState.rawContent) {
+            this._watcherState.rawContent = initialState.rawContent;
+            this.callbacks.onFileNavigate(initialState.rawContent);
+        }
+    }
+    /**
+     * Toggle follow mode on/off.
+     */
+    toggle() {
+        if (this.watcher) {
+            this.stop();
+        }
+        else {
+            this.start();
+        }
+    }
+    /**
+     * Stop watching.
+     */
+    stop() {
+        if (this.watcher) {
+            this.watcher.stop();
+            this.watcher = null;
+            this._watcherState = { enabled: false };
+        }
+    }
+}

package/dist/KeyBindings.js

@@ -0,0 +1,228 @@
+import { SPLIT_RATIO_STEP } from './ui/Layout.js';
+import { getFileAtIndex } from './ui/widgets/FileList.js';
+import { getFlatFileAtIndex } from './utils/flatFileList.js';
+/**
+ * Register all keyboard bindings on the blessed screen.
+ */
+export function setupKeyBindings(screen, actions, ctx) {
+    // Quit
+    screen.key(['q', 'C-c'], () => {
+        actions.exit();
+    });
+    // Navigation (skip if modal is open)
+    screen.key(['j', 'down'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        actions.navigateDown();
+    });
+    screen.key(['k', 'up'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        actions.navigateUp();
+    });
+    // Tab switching (skip if modal is open)
+    const tabs = [
+        ['1', 'diff'],
+        ['2', 'commit'],
+        ['3', 'history'],
+        ['4', 'compare'],
+        ['5', 'explorer'],
+    ];
+    for (const [key, tab] of tabs) {
+        screen.key([key], () => {
+            if (ctx.hasActiveModal())
+                return;
+            ctx.uiState.setTab(tab);
+        });
+    }
+    // Pane toggle (skip if modal is open)
+    screen.key(['tab'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        ctx.uiState.togglePane();
+    });
+    // Staging operations (skip if modal is open)
+    // Context-aware: hunk staging when diff pane is focused on diff tab
+    screen.key(['s'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        if (ctx.getBottomTab() === 'diff' && ctx.getCurrentPane() === 'diff') {
+            actions.toggleCurrentHunk();
+        }
+        else {
+            actions.stageSelected();
+        }
+    });
+    screen.key(['S-u'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        actions.unstageSelected();
+    });
+    screen.key(['S-a'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        actions.stageAll();
+    });
+    screen.key(['S-z'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        actions.unstageAll();
+    });
+    // Select/toggle (skip if modal is open)
+    screen.key(['enter', 'space'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        if (ctx.getBottomTab() === 'explorer' && ctx.getCurrentPane() === 'explorer') {
+            actions.enterExplorerDirectory();
+        }
+        else {
+            actions.toggleSelected();
+        }
+    });
+    // Explorer: go up directory (skip if modal is open)
+    screen.key(['backspace'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        if (ctx.getBottomTab() === 'explorer' && ctx.getCurrentPane() === 'explorer') {
+            actions.goExplorerUp();
+        }
+    });
+    // Explorer: toggle show only changes filter
+    screen.key(['g'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        if (ctx.getBottomTab() === 'explorer') {
+            ctx.getExplorerManager()?.toggleShowOnlyChanges();
+        }
+    });
+    // Explorer: open file finder
+    screen.key(['/'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        if (ctx.getBottomTab() === 'explorer') {
+            actions.openFileFinder();
+        }
+    });
+    // Ctrl+P: open file finder from any tab
+    screen.key(['C-p'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        actions.openFileFinder();
+    });
+    // Commit (skip if modal is open)
+    screen.key(['c'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        ctx.uiState.setTab('commit');
+    });
+    // Commit panel specific keys (only when on commit tab)
+    screen.key(['i'], () => {
+        if (ctx.getBottomTab() === 'commit' && !ctx.isCommitInputFocused()) {
+            actions.focusCommitInput();
+        }
+    });
+    screen.key(['a'], () => {
+        if (ctx.getBottomTab() === 'commit' && !ctx.isCommitInputFocused()) {
+            ctx.commitFlowState.toggleAmend();
+            actions.render();
+        }
+        else {
+            ctx.uiState.toggleAutoTab();
+        }
+    });
+    screen.key(['escape'], () => {
+        if (ctx.getBottomTab() === 'commit') {
+            if (ctx.isCommitInputFocused()) {
+                actions.unfocusCommitInput();
+            }
+            else {
+                ctx.uiState.setTab('diff');
+            }
+        }
+    });
+    // Refresh
+    screen.key(['r'], () => actions.refresh());
+    // Display toggles
+    screen.key(['w'], () => ctx.uiState.toggleWrapMode());
+    screen.key(['m'], () => actions.toggleMouseMode());
+    screen.key(['S-t'], () => ctx.uiState.toggleAutoTab());
+    // Split ratio adjustments
+    screen.key(['-', '_', '['], () => {
+        ctx.uiState.adjustSplitRatio(-SPLIT_RATIO_STEP);
+        ctx.layout.setSplitRatio(ctx.uiState.state.splitRatio);
+        actions.render();
+    });
+    screen.key(['=', '+', ']'], () => {
+        ctx.uiState.adjustSplitRatio(SPLIT_RATIO_STEP);
+        ctx.layout.setSplitRatio(ctx.uiState.state.splitRatio);
+        actions.render();
+    });
+    // Theme picker
+    screen.key(['t'], () => ctx.uiState.openModal('theme'));
+    // Hotkeys modal
+    screen.key(['?'], () => ctx.uiState.toggleModal('hotkeys'));
+    // Follow toggle
+    screen.key(['f'], () => actions.toggleFollow());
+    // Compare view: base branch picker
+    screen.key(['b'], () => {
+        if (ctx.getBottomTab() === 'compare') {
+            ctx.uiState.openModal('baseBranch');
+        }
+    });
+    // u: toggle uncommitted in compare view
+    screen.key(['u'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        if (ctx.getBottomTab() === 'compare') {
+            ctx.uiState.toggleIncludeUncommitted();
+            const includeUncommitted = ctx.uiState.state.includeUncommitted;
+            ctx.getGitManager()?.refreshCompareDiff(includeUncommitted);
+        }
+    });
+    // Toggle flat file view (diff/commit tab only)
+    screen.key(['h'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        const tab = ctx.getBottomTab();
+        if (tab === 'diff' || tab === 'commit') {
+            ctx.uiState.toggleFlatViewMode();
+        }
+    });
+    // Discard changes (with confirmation)
+    screen.key(['d'], () => {
+        if (ctx.getBottomTab() === 'diff') {
+            if (ctx.uiState.state.flatViewMode) {
+                const flatEntry = getFlatFileAtIndex(ctx.getCachedFlatFiles(), ctx.getSelectedIndex());
+                if (flatEntry?.unstagedEntry) {
+                    const file = flatEntry.unstagedEntry;
+                    if (file.status !== 'untracked') {
+                        actions.showDiscardConfirm(file);
+                    }
+                }
+            }
+            else {
+                const files = ctx.getStatusFiles();
+                const selectedFile = getFileAtIndex(files, ctx.getSelectedIndex());
+                // Only allow discard for unstaged modified files
+                if (selectedFile && !selectedFile.staged && selectedFile.status !== 'untracked') {
+                    actions.showDiscardConfirm(selectedFile);
+                }
+            }
+        }
+    });
+    // Hunk navigation (only when diff pane focused on diff tab)
+    screen.key(['n'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        if (ctx.getBottomTab() === 'diff' && ctx.getCurrentPane() === 'diff') {
+            actions.navigateNextHunk();
+        }
+    });
+    screen.key(['S-n'], () => {
+        if (ctx.hasActiveModal())
+            return;
+        if (ctx.getBottomTab() === 'diff' && ctx.getCurrentPane() === 'diff') {
+            actions.navigatePrevHunk();
+        }
+    });
+}

package/dist/MouseHandlers.js

@@ -0,0 +1,192 @@
+import { getFileListTotalRows, getFileIndexFromRow } from './ui/widgets/FileList.js';
+import { getFlatFileListTotalRows } from './ui/widgets/FlatFileList.js';
+import { getCompareListTotalRows, getCompareSelectionFromRow, } from './ui/widgets/CompareListView.js';
+import { getExplorerTotalRows } from './ui/widgets/ExplorerView.js';
+import { getExplorerContentTotalRows } from './ui/widgets/ExplorerContent.js';
+const SCROLL_AMOUNT = 3;
+/**
+ * Register all mouse event handlers on the layout.
+ */
+export function setupMouseHandlers(layout, actions, ctx) {
+    // Mouse wheel on top pane
+    layout.topPane.on('wheeldown', () => {
+        handleTopPaneScroll(SCROLL_AMOUNT, layout, ctx);
+    });
+    layout.topPane.on('wheelup', () => {
+        handleTopPaneScroll(-SCROLL_AMOUNT, layout, ctx);
+    });
+    // Mouse wheel on bottom pane
+    layout.bottomPane.on('wheeldown', () => {
+        handleBottomPaneScroll(SCROLL_AMOUNT, layout, ctx);
+    });
+    layout.bottomPane.on('wheelup', () => {
+        handleBottomPaneScroll(-SCROLL_AMOUNT, layout, ctx);
+    });
+    // Click on top pane to select item
+    layout.topPane.on('click', (mouse) => {
+        const clickedRow = layout.screenYToTopPaneRow(mouse.y);
+        if (clickedRow >= 0) {
+            handleTopPaneClick(clickedRow, mouse.x, actions, ctx);
+        }
+    });
+    // Click on bottom pane to select hunk (diff tab)
+    layout.bottomPane.on('click', (mouse) => {
+        const clickedRow = layout.screenYToBottomPaneRow(mouse.y);
+        if (clickedRow >= 0) {
+            actions.selectHunkAtRow(clickedRow);
+        }
+    });
+    // Click on footer for tabs and toggles
+    layout.footerBox.on('click', (mouse) => {
+        handleFooterClick(mouse.x, actions, ctx);
+    });
+}
+function handleFileListClick(row, x, actions, ctx) {
+    const state = ctx.uiState.state;
+    if (state.flatViewMode) {
+        // Flat mode: row 0 is header, files start at row 1
+        const absoluteRow = row + state.fileListScrollOffset;
+        const fileIndex = absoluteRow - 1; // subtract header row
+        const flatFiles = ctx.getCachedFlatFiles();
+        if (fileIndex < 0 || fileIndex >= flatFiles.length)
+            return;
+        if (x !== undefined && x >= 2 && x <= 4) {
+            actions.toggleFileByIndex(fileIndex);
+        }
+        else {
+            ctx.uiState.setSelectedIndex(fileIndex);
+            actions.selectFileByIndex(fileIndex);
+        }
+    }
+    else {
+        const files = ctx.getStatusFiles();
+        const fileIndex = getFileIndexFromRow(row + state.fileListScrollOffset, files);
+        if (fileIndex === null || fileIndex < 0)
+            return;
+        if (x !== undefined && x >= 2 && x <= 4) {
+            actions.toggleFileByIndex(fileIndex);
+        }
+        else {
+            ctx.uiState.setSelectedIndex(fileIndex);
+            actions.selectFileByIndex(fileIndex);
+        }
+    }
+}
+function handleTopPaneClick(row, x, actions, ctx) {
+    const state = ctx.uiState.state;
+    if (state.bottomTab === 'history') {
+        const index = state.historyScrollOffset + row;
+        ctx.uiState.setHistorySelectedIndex(index);
+        actions.selectHistoryCommitByIndex(index);
+    }
+    else if (state.bottomTab === 'compare') {
+        const commits = ctx.getCompareCommits();
+        const files = ctx.getCompareFiles();
+        const selection = getCompareSelectionFromRow(state.compareScrollOffset + row, commits, files);
+        if (selection) {
+            actions.selectCompareItem(selection);
+        }
+    }
+    else if (state.bottomTab === 'explorer') {
+        const index = state.explorerScrollOffset + row;
+        const explorerManager = ctx.getExplorerManager();
+        const isAlreadySelected = explorerManager?.state.selectedIndex === index;
+        const displayRow = explorerManager?.state.displayRows[index];
+        if (isAlreadySelected && displayRow?.node.isDirectory) {
+            actions.enterExplorerDirectory();
+        }
+        else {
+            explorerManager?.selectIndex(index);
+            ctx.uiState.setExplorerSelectedIndex(index);
+        }
+    }
+    else {
+        handleFileListClick(row, x, actions, ctx);
+    }
+}
+function handleFooterClick(x, actions, ctx) {
+    const width = ctx.getScreenWidth();
+    // Tabs are right-aligned
+    const tabPositions = [
+        { tab: 'explorer', width: 11 },
+        { tab: 'compare', width: 10 },
+        { tab: 'history', width: 10 },
+        { tab: 'commit', width: 9 },
+        { tab: 'diff', width: 7 },
+    ];
+    let rightEdge = width;
+    for (const { tab, width: tabWidth } of tabPositions) {
+        const leftEdge = rightEdge - tabWidth - 1;
+        if (x >= leftEdge && x < rightEdge) {
+            ctx.uiState.setTab(tab);
+            return;
+        }
+        rightEdge = leftEdge;
+    }
+    // Left side toggles (approximate positions)
+    if (x >= 2 && x <= 9) {
+        actions.toggleMouseMode();
+    }
+    else if (x >= 11 && x <= 16) {
+        ctx.uiState.toggleAutoTab();
+    }
+    else if (x >= 18 && x <= 23) {
+        ctx.uiState.toggleWrapMode();
+    }
+    else if (x >= 25 && x <= 32) {
+        actions.toggleFollow();
+    }
+    else if (x >= 34 && x <= 43 && ctx.uiState.state.bottomTab === 'explorer') {
+        ctx.getExplorerManager()?.toggleShowOnlyChanges();
+    }
+    else if (x === 0) {
+        ctx.uiState.openModal('hotkeys');
+    }
+}
+function handleTopPaneScroll(delta, layout, ctx) {
+    const state = ctx.uiState.state;
+    const visibleHeight = layout.dimensions.topPaneHeight;
+    if (state.bottomTab === 'history') {
+        const totalRows = ctx.getHistoryCommitCount();
+        const maxOffset = Math.max(0, totalRows - visibleHeight);
+        const newOffset = Math.min(maxOffset, Math.max(0, state.historyScrollOffset + delta));
+        ctx.uiState.setHistoryScrollOffset(newOffset);
+    }
+    else if (state.bottomTab === 'compare') {
+        const totalRows = getCompareListTotalRows(ctx.getCompareCommits(), ctx.getCompareFiles());
+        const maxOffset = Math.max(0, totalRows - visibleHeight);
+        const newOffset = Math.min(maxOffset, Math.max(0, state.compareScrollOffset + delta));
+        ctx.uiState.setCompareScrollOffset(newOffset);
+    }
+    else if (state.bottomTab === 'explorer') {
+        const totalRows = getExplorerTotalRows(ctx.getExplorerManager()?.state.displayRows ?? []);
+        const maxOffset = Math.max(0, totalRows - visibleHeight);
+        const newOffset = Math.min(maxOffset, Math.max(0, state.explorerScrollOffset + delta));
+        ctx.uiState.setExplorerScrollOffset(newOffset);
+    }
+    else {
+        const totalRows = state.flatViewMode
+            ? getFlatFileListTotalRows(ctx.getCachedFlatFiles())
+            : getFileListTotalRows(ctx.getStatusFiles());
+        const maxOffset = Math.max(0, totalRows - visibleHeight);
+        const newOffset = Math.min(maxOffset, Math.max(0, state.fileListScrollOffset + delta));
+        ctx.uiState.setFileListScrollOffset(newOffset);
+    }
+}
+function handleBottomPaneScroll(delta, layout, ctx) {
+    const state = ctx.uiState.state;
+    const visibleHeight = layout.dimensions.bottomPaneHeight;
+    const width = ctx.getScreenWidth();
+    if (state.bottomTab === 'explorer') {
+        const selectedFile = ctx.getExplorerManager()?.state.selectedFile;
+        const totalRows = getExplorerContentTotalRows(selectedFile?.content ?? null, selectedFile?.path ?? null, selectedFile?.truncated ?? false, width, state.wrapMode);
+        const maxOffset = Math.max(0, totalRows - visibleHeight);
+        const newOffset = Math.min(maxOffset, Math.max(0, state.explorerFileScrollOffset + delta));
+        ctx.uiState.setExplorerFileScrollOffset(newOffset);
+    }
+    else {
+        const maxOffset = Math.max(0, ctx.getBottomPaneTotalRows() - visibleHeight);
+        const newOffset = Math.min(maxOffset, Math.max(0, state.diffScrollOffset + delta));
+        ctx.uiState.setDiffScrollOffset(newOffset);
+    }
+}