diffstalker 0.2.2 → 0.2.4

package/dist/NavigationController.js

@@ -0,0 +1,290 @@
+import { getNextCompareSelection, getRowFromCompareSelection, } from './ui/widgets/CompareListView.js';
+import { getRowFromFileIndex } from './ui/widgets/FileList.js';
+import { getCommitAtIndex } from './ui/widgets/HistoryView.js';
+/**
+ * Handles all list and pane navigation: file list, history, compare, explorer, hunks.
+ * Owns the compareSelection state.
+ */
+export class NavigationController {
+    ctx;
+    compareSelection = null;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    scrollActiveDiffPane(delta) {
+        const state = this.ctx.uiState.state;
+        if (state.bottomTab === 'explorer') {
+            const newOffset = Math.max(0, state.explorerFileScrollOffset + delta);
+            this.ctx.uiState.setExplorerFileScrollOffset(newOffset);
+        }
+        else {
+            const newOffset = Math.max(0, state.diffScrollOffset + delta);
+            this.ctx.uiState.setDiffScrollOffset(newOffset);
+        }
+    }
+    navigateFileList(direction) {
+        const state = this.ctx.uiState.state;
+        const files = this.ctx.getGitManager()?.workingTree.state.status?.files ?? [];
+        const maxIndex = this.ctx.getFileListMaxIndex();
+        if (maxIndex < 0)
+            return;
+        const newIndex = direction === -1
+            ? Math.max(0, state.selectedIndex - 1)
+            : Math.min(maxIndex, state.selectedIndex + 1);
+        this.ctx.uiState.setSelectedIndex(newIndex);
+        this.selectFileByIndex(newIndex);
+        const row = state.flatViewMode ? newIndex + 1 : getRowFromFileIndex(newIndex, files);
+        this.scrollToKeepRowVisible(row, direction, state.fileListScrollOffset);
+    }
+    scrollToKeepRowVisible(row, direction, currentOffset) {
+        if (direction === -1 && row < currentOffset) {
+            this.ctx.uiState.setFileListScrollOffset(row);
+        }
+        else if (direction === 1) {
+            const visibleEnd = currentOffset + this.ctx.getTopPaneHeight() - 1;
+            if (row >= visibleEnd) {
+                this.ctx.uiState.setFileListScrollOffset(currentOffset + (row - visibleEnd + 1));
+            }
+        }
+    }
+    navigateActiveList(direction) {
+        const tab = this.ctx.uiState.state.bottomTab;
+        if (tab === 'history') {
+            if (direction === -1)
+                this.navigateHistoryUp();
+            else
+                this.navigateHistoryDown();
+        }
+        else if (tab === 'compare') {
+            if (direction === -1)
+                this.navigateCompareUp();
+            else
+                this.navigateCompareDown();
+        }
+        else if (tab === 'explorer') {
+            if (direction === -1)
+                this.navigateExplorerUp();
+            else
+                this.navigateExplorerDown();
+        }
+        else {
+            this.navigateFileList(direction);
+        }
+    }
+    navigateUp() {
+        const state = this.ctx.uiState.state;
+        const isListPane = state.currentPane !== 'diff';
+        if (isListPane) {
+            this.navigateActiveList(-1);
+        }
+        else {
+            this.scrollActiveDiffPane(-3);
+        }
+    }
+    navigateDown() {
+        const state = this.ctx.uiState.state;
+        const isListPane = state.currentPane !== 'diff';
+        if (isListPane) {
+            this.navigateActiveList(1);
+        }
+        else {
+            this.scrollActiveDiffPane(3);
+        }
+    }
+    navigateHistoryUp() {
+        const state = this.ctx.uiState.state;
+        const newIndex = Math.max(0, state.historySelectedIndex - 1);
+        if (newIndex !== state.historySelectedIndex) {
+            this.ctx.uiState.setHistorySelectedIndex(newIndex);
+            if (newIndex < state.historyScrollOffset) {
+                this.ctx.uiState.setHistoryScrollOffset(newIndex);
+            }
+            this.selectHistoryCommitByIndex(newIndex);
+        }
+    }
+    navigateHistoryDown() {
+        const state = this.ctx.uiState.state;
+        const commits = this.ctx.getGitManager()?.history.historyState.commits ?? [];
+        const newIndex = Math.min(commits.length - 1, state.historySelectedIndex + 1);
+        if (newIndex !== state.historySelectedIndex) {
+            this.ctx.uiState.setHistorySelectedIndex(newIndex);
+            const visibleEnd = state.historyScrollOffset + this.ctx.getTopPaneHeight() - 1;
+            if (newIndex >= visibleEnd) {
+                this.ctx.uiState.setHistoryScrollOffset(state.historyScrollOffset + 1);
+            }
+            this.selectHistoryCommitByIndex(newIndex);
+        }
+    }
+    selectHistoryCommitByIndex(index) {
+        const gm = this.ctx.getGitManager();
+        const commits = gm?.history.historyState.commits ?? [];
+        const commit = getCommitAtIndex(commits, index);
+        if (commit) {
+            this.ctx.uiState.setDiffScrollOffset(0);
+            gm?.history.selectHistoryCommit(commit).catch((err) => {
+                this.ctx.onError(`Failed to load commit diff: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+    }
+    navigateCompareUp() {
+        const compareState = this.ctx.getGitManager()?.compare.compareState;
+        const commits = compareState?.compareDiff?.commits ?? [];
+        const files = compareState?.compareDiff?.files ?? [];
+        if (commits.length === 0 && files.length === 0)
+            return;
+        const next = getNextCompareSelection(this.compareSelection, commits, files, 'up');
+        if (next &&
+            (next.type !== this.compareSelection?.type || next.index !== this.compareSelection?.index)) {
+            this.selectCompareItem(next);
+            const state = this.ctx.uiState.state;
+            const row = getRowFromCompareSelection(next, commits, files);
+            if (row < state.compareScrollOffset) {
+                this.ctx.uiState.setCompareScrollOffset(row);
+            }
+        }
+    }
+    navigateCompareDown() {
+        const compareState = this.ctx.getGitManager()?.compare.compareState;
+        const commits = compareState?.compareDiff?.commits ?? [];
+        const files = compareState?.compareDiff?.files ?? [];
+        if (commits.length === 0 && files.length === 0)
+            return;
+        if (!this.compareSelection) {
+            if (commits.length > 0) {
+                this.selectCompareItem({ type: 'commit', index: 0 });
+            }
+            else if (files.length > 0) {
+                this.selectCompareItem({ type: 'file', index: 0 });
+            }
+            return;
+        }
+        const next = getNextCompareSelection(this.compareSelection, commits, files, 'down');
+        if (next &&
+            (next.type !== this.compareSelection?.type || next.index !== this.compareSelection?.index)) {
+            this.selectCompareItem(next);
+            const state = this.ctx.uiState.state;
+            const row = getRowFromCompareSelection(next, commits, files);
+            const visibleEnd = state.compareScrollOffset + this.ctx.getTopPaneHeight() - 1;
+            if (row >= visibleEnd) {
+                this.ctx.uiState.setCompareScrollOffset(state.compareScrollOffset + (row - visibleEnd + 1));
+            }
+        }
+    }
+    selectCompareItem(selection) {
+        this.compareSelection = selection;
+        this.ctx.uiState.setDiffScrollOffset(0);
+        const gm = this.ctx.getGitManager();
+        if (selection.type === 'commit') {
+            gm?.compare.selectCompareCommit(selection.index).catch((err) => {
+                this.ctx.onError(`Failed to load commit diff: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+        else {
+            gm?.compare.selectCompareFile(selection.index);
+        }
+    }
+    navigateExplorerUp() {
+        const state = this.ctx.uiState.state;
+        const explorer = this.ctx.getExplorerManager();
+        const rows = explorer?.state.displayRows ?? [];
+        if (rows.length === 0)
+            return;
+        const newScrollOffset = explorer?.navigateUp(state.explorerScrollOffset);
+        if (newScrollOffset !== null && newScrollOffset !== undefined) {
+            this.ctx.uiState.setExplorerScrollOffset(newScrollOffset);
+        }
+        this.ctx.uiState.setExplorerSelectedIndex(explorer?.state.selectedIndex ?? 0);
+    }
+    navigateExplorerDown() {
+        const state = this.ctx.uiState.state;
+        const explorer = this.ctx.getExplorerManager();
+        const rows = explorer?.state.displayRows ?? [];
+        if (rows.length === 0)
+            return;
+        const visibleHeight = this.ctx.getTopPaneHeight();
+        const newScrollOffset = explorer?.navigateDown(state.explorerScrollOffset, visibleHeight);
+        if (newScrollOffset !== null && newScrollOffset !== undefined) {
+            this.ctx.uiState.setExplorerScrollOffset(newScrollOffset);
+        }
+        this.ctx.uiState.setExplorerSelectedIndex(explorer?.state.selectedIndex ?? 0);
+    }
+    async enterExplorerDirectory() {
+        const explorer = this.ctx.getExplorerManager();
+        await explorer?.enterDirectory();
+        this.ctx.uiState.setExplorerFileScrollOffset(0);
+        this.ctx.uiState.setExplorerSelectedIndex(explorer?.state.selectedIndex ?? 0);
+    }
+    async goExplorerUp() {
+        const explorer = this.ctx.getExplorerManager();
+        await explorer?.goUp();
+        this.ctx.uiState.setExplorerFileScrollOffset(0);
+        this.ctx.uiState.setExplorerSelectedIndex(explorer?.state.selectedIndex ?? 0);
+    }
+    selectFileByIndex(index) {
+        const file = this.ctx.resolveFileAtIndex(index);
+        if (file) {
+            this.ctx.uiState.setDiffScrollOffset(0);
+            this.ctx.uiState.setSelectedHunkIndex(0);
+            this.ctx.getGitManager()?.workingTree.selectFile(file);
+        }
+    }
+    navigateToFile(absolutePath) {
+        const repoPath = this.ctx.getRepoPath();
+        if (!absolutePath || !repoPath)
+            return;
+        const repoPrefix = repoPath.endsWith('/') ? repoPath : repoPath + '/';
+        if (!absolutePath.startsWith(repoPrefix))
+            return;
+        const relativePath = absolutePath.slice(repoPrefix.length);
+        if (!relativePath)
+            return;
+        const files = this.ctx.getGitManager()?.workingTree.state.status?.files ?? [];
+        const fileIndex = files.findIndex((f) => f.path === relativePath);
+        if (fileIndex >= 0) {
+            this.ctx.uiState.setSelectedIndex(fileIndex);
+            this.selectFileByIndex(fileIndex);
+        }
+    }
+    // Hunk navigation
+    navigateNextHunk() {
+        const current = this.ctx.uiState.state.selectedHunkIndex;
+        const hunkCount = this.ctx.getHunkCount();
+        if (hunkCount > 0 && current < hunkCount - 1) {
+            this.ctx.uiState.setSelectedHunkIndex(current + 1);
+            this.scrollHunkIntoView(current + 1);
+        }
+    }
+    navigatePrevHunk() {
+        const current = this.ctx.uiState.state.selectedHunkIndex;
+        if (current > 0) {
+            this.ctx.uiState.setSelectedHunkIndex(current - 1);
+            this.scrollHunkIntoView(current - 1);
+        }
+    }
+    scrollHunkIntoView(hunkIndex) {
+        const boundary = this.ctx.getHunkBoundaries()[hunkIndex];
+        if (!boundary)
+            return;
+        const scrollOffset = this.ctx.uiState.state.diffScrollOffset;
+        const visibleHeight = this.ctx.getBottomPaneHeight();
+        if (boundary.startRow < scrollOffset || boundary.startRow >= scrollOffset + visibleHeight) {
+            this.ctx.uiState.setDiffScrollOffset(boundary.startRow);
+        }
+    }
+    selectHunkAtRow(visualRow) {
+        if (this.ctx.uiState.state.bottomTab !== 'diff')
+            return;
+        const boundaries = this.ctx.getHunkBoundaries();
+        if (boundaries.length === 0)
+            return;
+        this.ctx.uiState.setPane('diff');
+        const absoluteRow = this.ctx.uiState.state.diffScrollOffset + visualRow;
+        for (let i = 0; i < boundaries.length; i++) {
+            const b = boundaries[i];
+            if (absoluteRow >= b.startRow && absoluteRow < b.endRow) {
+                this.ctx.uiState.setSelectedHunkIndex(i);
+                return;
+            }
+        }
+    }
+}

package/dist/StagingOperations.js

@@ -0,0 +1,199 @@
+import { getFlatFileAtIndex } from './utils/flatFileList.js';
+import { getCategoryForIndex } from './utils/fileCategories.js';
+import { extractHunkPatch } from './git/diff.js';
+/**
+ * Handles all file and hunk staging/unstaging operations.
+ * Owns selection anchoring state used for reconciliation after git state changes.
+ */
+export class StagingOperations {
+    ctx;
+    pendingSelectionAnchor = null;
+    pendingFlatSelectionPath = null;
+    pendingHunkIndex = null;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    consumePendingSelectionAnchor() {
+        const value = this.pendingSelectionAnchor;
+        this.pendingSelectionAnchor = null;
+        return value;
+    }
+    consumePendingFlatSelectionPath() {
+        const value = this.pendingFlatSelectionPath;
+        this.pendingFlatSelectionPath = null;
+        return value;
+    }
+    consumePendingHunkIndex() {
+        const value = this.pendingHunkIndex;
+        this.pendingHunkIndex = null;
+        return value;
+    }
+    async stageSelected() {
+        const gm = this.ctx.getGitManager();
+        const wt = gm?.workingTree;
+        const files = wt?.state.status?.files ?? [];
+        const index = this.ctx.uiState.state.selectedIndex;
+        if (this.ctx.uiState.state.flatViewMode) {
+            const flatEntry = getFlatFileAtIndex(this.ctx.getCachedFlatFiles(), index);
+            if (!flatEntry)
+                return;
+            const file = flatEntry.unstagedEntry;
+            if (file) {
+                this.pendingFlatSelectionPath = flatEntry.path;
+                await wt?.stage(file);
+            }
+        }
+        else {
+            const selectedFile = this.ctx.resolveFileAtIndex(index);
+            if (selectedFile && !selectedFile.staged) {
+                this.pendingSelectionAnchor = getCategoryForIndex(files, index);
+                await wt?.stage(selectedFile);
+            }
+        }
+    }
+    async unstageSelected() {
+        const gm = this.ctx.getGitManager();
+        const wt = gm?.workingTree;
+        const files = wt?.state.status?.files ?? [];
+        const index = this.ctx.uiState.state.selectedIndex;
+        if (this.ctx.uiState.state.flatViewMode) {
+            const flatEntry = getFlatFileAtIndex(this.ctx.getCachedFlatFiles(), index);
+            if (!flatEntry)
+                return;
+            const file = flatEntry.stagedEntry;
+            if (file) {
+                this.pendingFlatSelectionPath = flatEntry.path;
+                await wt?.unstage(file);
+            }
+        }
+        else {
+            const selectedFile = this.ctx.resolveFileAtIndex(index);
+            if (selectedFile?.staged) {
+                this.pendingSelectionAnchor = getCategoryForIndex(files, index);
+                await wt?.unstage(selectedFile);
+            }
+        }
+    }
+    async toggleSelected() {
+        const index = this.ctx.uiState.state.selectedIndex;
+        if (this.ctx.uiState.state.flatViewMode) {
+            const flatEntry = getFlatFileAtIndex(this.ctx.getCachedFlatFiles(), index);
+            if (flatEntry)
+                await this.toggleFlatEntry(flatEntry);
+        }
+        else {
+            const gm = this.ctx.getGitManager();
+            const wt = gm?.workingTree;
+            const files = wt?.state.status?.files ?? [];
+            const selectedFile = this.ctx.resolveFileAtIndex(index);
+            if (selectedFile) {
+                this.pendingSelectionAnchor = getCategoryForIndex(files, index);
+                if (selectedFile.staged) {
+                    await wt?.unstage(selectedFile);
+                }
+                else {
+                    await wt?.stage(selectedFile);
+                }
+            }
+        }
+    }
+    async stageAll() {
+        await this.ctx.getGitManager()?.workingTree.stageAll();
+    }
+    async unstageAll() {
+        await this.ctx.getGitManager()?.workingTree.unstageAll();
+    }
+    async toggleFlatEntry(entry) {
+        const wt = this.ctx.getGitManager()?.workingTree;
+        this.pendingFlatSelectionPath = entry.path;
+        if (entry.stagingState === 'staged') {
+            if (entry.stagedEntry)
+                await wt?.unstage(entry.stagedEntry);
+        }
+        else {
+            if (entry.unstagedEntry)
+                await wt?.stage(entry.unstagedEntry);
+        }
+    }
+    async toggleFileByIndex(index) {
+        if (this.ctx.uiState.state.flatViewMode) {
+            const flatEntry = getFlatFileAtIndex(this.ctx.getCachedFlatFiles(), index);
+            if (flatEntry)
+                await this.toggleFlatEntry(flatEntry);
+        }
+        else {
+            const gm = this.ctx.getGitManager();
+            const wt = gm?.workingTree;
+            const files = wt?.state.status?.files ?? [];
+            const file = this.ctx.resolveFileAtIndex(index);
+            if (file) {
+                this.pendingSelectionAnchor = getCategoryForIndex(files, this.ctx.uiState.state.selectedIndex);
+                if (file.staged) {
+                    await wt?.unstage(file);
+                }
+                else {
+                    await wt?.stage(file);
+                }
+            }
+        }
+    }
+    // Hunk staging
+    async toggleCurrentHunk() {
+        const selectedFile = this.ctx.getGitManager()?.workingTree.state.selectedFile;
+        if (!selectedFile)
+            return;
+        if (selectedFile.status === 'untracked') {
+            // Hunk staging not available for untracked files; stage the whole file
+            // but preserve selection state like a normal hunk toggle would
+            const wt = this.ctx.getGitManager()?.workingTree;
+            const files = wt?.state.status?.files ?? [];
+            this.pendingSelectionAnchor = getCategoryForIndex(files, this.ctx.uiState.state.selectedIndex);
+            this.pendingHunkIndex = this.ctx.uiState.state.selectedHunkIndex;
+            await wt?.stage(selectedFile);
+            return;
+        }
+        if (this.ctx.uiState.state.flatViewMode) {
+            await this.toggleCurrentHunkFlat();
+        }
+        else {
+            await this.toggleCurrentHunkCategorized(selectedFile);
+        }
+    }
+    async toggleCurrentHunkFlat() {
+        const mapping = this.ctx.getCombinedHunkMapping()[this.ctx.uiState.state.selectedHunkIndex];
+        if (!mapping)
+            return;
+        const wt = this.ctx.getGitManager()?.workingTree;
+        const combined = wt?.state.combinedFileDiffs;
+        if (!combined)
+            return;
+        const rawDiff = mapping.source === 'unstaged' ? combined.unstaged.raw : combined.staged.raw;
+        const patch = extractHunkPatch(rawDiff, mapping.hunkIndex);
+        if (!patch)
+            return;
+        this.pendingHunkIndex = this.ctx.uiState.state.selectedHunkIndex;
+        if (mapping.source === 'staged') {
+            await wt?.unstageHunk(patch);
+        }
+        else {
+            await wt?.stageHunk(patch);
+        }
+    }
+    async toggleCurrentHunkCategorized(selectedFile) {
+        const wt = this.ctx.getGitManager()?.workingTree;
+        const rawDiff = wt?.state.diff?.raw;
+        if (!rawDiff)
+            return;
+        const patch = extractHunkPatch(rawDiff, this.ctx.uiState.state.selectedHunkIndex);
+        if (!patch)
+            return;
+        const files = wt?.state.status?.files ?? [];
+        this.pendingSelectionAnchor = getCategoryForIndex(files, this.ctx.uiState.state.selectedIndex);
+        if (selectedFile.staged) {
+            await wt?.unstageHunk(patch);
+        }
+        else {
+            await wt?.stageHunk(patch);
+        }
+    }
+}

package/dist/config.js

@@ -40,6 +40,24 @@ export function loadConfig() {
                 fileConfig.splitRatio <= 0.85) {
                 config.splitRatio = fileConfig.splitRatio;
             }
+            if (typeof fileConfig.autoTabEnabled === 'boolean') {
+                config.autoTabEnabled = fileConfig.autoTabEnabled;
+            }
+            if (typeof fileConfig.wrapMode === 'boolean') {
+                config.wrapMode = fileConfig.wrapMode;
+            }
+            if (typeof fileConfig.mouseEnabled === 'boolean') {
+                config.mouseEnabled = fileConfig.mouseEnabled;
+            }
+            if (Array.isArray(fileConfig.recentRepos) &&
+                fileConfig.recentRepos.every((r) => typeof r === 'string')) {
+                config.recentRepos = fileConfig.recentRepos;
+            }
+            if (typeof fileConfig.maxRecentRepos === 'number' &&
+                fileConfig.maxRecentRepos >= 1 &&
+                fileConfig.maxRecentRepos <= 50) {
+                config.maxRecentRepos = fileConfig.maxRecentRepos;
+            }
         }
         catch {
             // Ignore config file errors
@@ -81,3 +99,24 @@ export function abbreviateHomePath(fullPath) {
     }
     return fullPath;
 }
+function normalizeRepoPath(p) {
+    return p.length > 1 && p.endsWith('/') ? p.slice(0, -1) : p;
+}
+export function addRecentRepo(repoPath, maxRecentRepos = 10) {
+    const normalized = normalizeRepoPath(repoPath);
+    let existing = [];
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            const fileConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+            if (Array.isArray(fileConfig.recentRepos))
+                existing = fileConfig.recentRepos;
+        }
+        catch {
+            // start fresh
+        }
+    }
+    const filtered = existing.filter((r) => normalizeRepoPath(r) !== normalized);
+    saveConfig({
+        recentRepos: [normalized, ...filtered.map(normalizeRepoPath)].slice(0, maxRecentRepos),
+    });
+}

package/dist/core/CompareManager.js

@@ -0,0 +1,134 @@
+import { EventEmitter } from 'node:events';
+import { getDiffBetweenRefs, getCompareDiffWithUncommitted, getDefaultBaseBranch, getCandidateBaseBranches as gitGetCandidateBaseBranches, getCommitDiff, } from '../git/diff.js';
+import { getCachedBaseBranch, setCachedBaseBranch } from '../utils/baseBranchCache.js';
+/**
+ * Manages branch comparison state: base branch, diff, and selection.
+ */
+export class CompareManager extends EventEmitter {
+    repoPath;
+    queue;
+    _compareState = {
+        compareDiff: null,
+        compareBaseBranch: null,
+        compareLoading: false,
+        compareError: null,
+    };
+    _compareSelectionState = {
+        type: null,
+        index: 0,
+        diff: null,
+    };
+    constructor(repoPath, queue) {
+        super();
+        this.repoPath = repoPath;
+        this.queue = queue;
+    }
+    get compareState() {
+        return this._compareState;
+    }
+    get compareSelectionState() {
+        return this._compareSelectionState;
+    }
+    updateCompareState(partial) {
+        this._compareState = { ...this._compareState, ...partial };
+        this.emit('compare-state-change', this._compareState);
+    }
+    updateCompareSelectionState(partial) {
+        this._compareSelectionState = { ...this._compareSelectionState, ...partial };
+        this.emit('compare-selection-change', this._compareSelectionState);
+    }
+    /**
+     * Refresh compare diff if it was previously loaded (has a base branch set).
+     * Called by the cascade refresh after file changes.
+     */
+    async refreshIfLoaded() {
+        if (this._compareState.compareBaseBranch) {
+            await this.doRefreshCompareDiff(false);
+        }
+    }
+    /**
+     * Reset the base branch (e.g. after switching branches).
+     */
+    resetBaseBranch() {
+        this.updateCompareState({ compareBaseBranch: null });
+    }
+    /**
+     * Refresh compare diff.
+     */
+    async refreshCompareDiff(includeUncommitted = false) {
+        this.updateCompareState({ compareLoading: true, compareError: null });
+        try {
+            await this.queue.enqueue(() => this.doRefreshCompareDiff(includeUncommitted));
+        }
+        catch (err) {
+            this.updateCompareState({
+                compareLoading: false,
+                compareError: `Failed to load compare diff: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    async doRefreshCompareDiff(includeUncommitted) {
+        let base = this._compareState.compareBaseBranch;
+        if (!base) {
+            // Try cached value first, then fall back to default detection
+            base = getCachedBaseBranch(this.repoPath) ?? (await getDefaultBaseBranch(this.repoPath));
+            this.updateCompareState({ compareBaseBranch: base });
+        }
+        if (base) {
+            const diff = includeUncommitted
+                ? await getCompareDiffWithUncommitted(this.repoPath, base)
+                : await getDiffBetweenRefs(this.repoPath, base);
+            this.updateCompareState({ compareDiff: diff, compareLoading: false });
+        }
+        else {
+            this.updateCompareState({
+                compareDiff: null,
+                compareLoading: false,
+                compareError: 'No base branch found',
+            });
+        }
+    }
+    /**
+     * Get candidate base branches for branch comparison.
+     */
+    async getCandidateBaseBranches() {
+        return gitGetCandidateBaseBranches(this.repoPath);
+    }
+    /**
+     * Set the base branch for branch comparison and refresh.
+     * Also saves the selection to the cache for future sessions.
+     */
+    async setCompareBaseBranch(branch, includeUncommitted = false) {
+        this.updateCompareState({ compareBaseBranch: branch });
+        setCachedBaseBranch(this.repoPath, branch);
+        await this.refreshCompareDiff(includeUncommitted);
+    }
+    /**
+     * Select a commit in compare view and load its diff.
+     */
+    async selectCompareCommit(index) {
+        const compareDiff = this._compareState.compareDiff;
+        if (!compareDiff || index < 0 || index >= compareDiff.commits.length) {
+            this.updateCompareSelectionState({ type: null, index: 0, diff: null });
+            return;
+        }
+        const commit = compareDiff.commits[index];
+        this.updateCompareSelectionState({ type: 'commit', index, diff: null });
+        await this.queue.enqueue(async () => {
+            const diff = await getCommitDiff(this.repoPath, commit.hash);
+            this.updateCompareSelectionState({ diff });
+        });
+    }
+    /**
+     * Select a file in compare view and show its diff.
+     */
+    selectCompareFile(index) {
+        const compareDiff = this._compareState.compareDiff;
+        if (!compareDiff || index < 0 || index >= compareDiff.files.length) {
+            this.updateCompareSelectionState({ type: null, index: 0, diff: null });
+            return;
+        }
+        const file = compareDiff.files[index];
+        this.updateCompareSelectionState({ type: 'file', index, diff: file.diff });
+    }
+}