diffstalker 0.2.3 → 0.2.4

package/dist/core/GitStateManager.js

@@ -1,786 +1,43 @@
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import { execFileSync } from 'node:child_process';
-import { watch } from 'chokidar';
-import { EventEmitter } from 'node:events';
-import ignore from 'ignore';
+/**
+ * GitStateManager coordinator.
+ * Wires sub-managers together; callers access sub-managers directly.
+ */
 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, 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';
+import { WorkingTreeManager } from './WorkingTreeManager.js';
+import { HistoryManager } from './HistoryManager.js';
+import { CompareManager } from './CompareManager.js';
+import { RemoteOperationManager } from './RemoteOperationManager.js';
 /**
- * GitStateManager manages git state independent of React.
- * It owns the operation queue, file watchers, and emits events on state changes.
+ * Coordinates WorkingTreeManager, HistoryManager,
+ * CompareManager, and RemoteOperationManager.
+ * Sub-managers are public readonly — callers use them directly.
  */
-export class GitStateManager extends EventEmitter {
+export class GitStateManager {
+    workingTree;
+    history;
+    compare;
+    remote;
     repoPath;
-    queue;
-    gitWatcher = null;
-    workingDirWatcher = null;
-    ignorers = new Map();
-    diffDebounceTimer = null;
-    // Current state
-    _state = {
-        status: null,
-        diff: null,
-        combinedFileDiffs: null,
-        selectedFile: null,
-        isLoading: false,
-        error: null,
-        hunkCounts: null,
-        stashList: [],
-    };
-    _compareState = {
-        compareDiff: null,
-        compareBaseBranch: null,
-        compareLoading: false,
-        compareError: null,
-    };
-    _historyState = {
-        commits: [],
-        selectedCommit: null,
-        commitDiff: null,
-        isLoading: false,
-    };
-    _compareSelectionState = {
-        type: null,
-        index: 0,
-        diff: null,
-    };
-    _remoteState = {
-        operation: null,
-        inProgress: false,
-        error: null,
-        lastResult: null,
-    };
     constructor(repoPath) {
-        super();
         this.repoPath = repoPath;
-        this.queue = getQueueForRepo(repoPath);
-    }
-    get state() {
-        return this._state;
-    }
-    get compareState() {
-        return this._compareState;
-    }
-    get historyState() {
-        return this._historyState;
-    }
-    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);
-    }
-    updateCompareState(partial) {
-        this._compareState = { ...this._compareState, ...partial };
-        this.emit('compare-state-change', this._compareState);
-    }
-    updateHistoryState(partial) {
-        this._historyState = { ...this._historyState, ...partial };
-        this.emit('history-state-change', this._historyState);
-    }
-    updateCompareSelectionState(partial) {
-        this._compareSelectionState = { ...this._compareSelectionState, ...partial };
-        this.emit('compare-selection-change', this._compareSelectionState);
-    }
-    /**
-     * Load gitignore patterns from all .gitignore files and .git/info/exclude.
-     * Returns a Map of directory → Ignore instance, where each instance handles
-     * patterns relative to its own directory (matching how git scopes .gitignore files).
-     */
-    loadGitignores() {
-        const ignorers = new Map();
-        // Root ignorer: .git dir + root .gitignore + .git/info/exclude
-        const rootIg = ignore();
-        rootIg.add('.git');
-        const rootGitignorePath = path.join(this.repoPath, '.gitignore');
-        if (fs.existsSync(rootGitignorePath)) {
-            rootIg.add(fs.readFileSync(rootGitignorePath, 'utf-8'));
-        }
-        const excludePath = path.join(this.repoPath, '.git', 'info', 'exclude');
-        if (fs.existsSync(excludePath)) {
-            rootIg.add(fs.readFileSync(excludePath, 'utf-8'));
-        }
-        ignorers.set('', rootIg);
-        // Find all nested .gitignore files using git ls-files
-        try {
-            const output = execFileSync('git', ['ls-files', '-z', '--cached', '--others', '**/.gitignore'], { cwd: this.repoPath, encoding: 'utf-8' });
-            for (const entry of output.split('\0')) {
-                if (!entry || entry === '.gitignore')
-                    continue;
-                if (!entry.endsWith('.gitignore'))
-                    continue;
-                const dir = path.dirname(entry);
-                const absPath = path.join(this.repoPath, entry);
-                try {
-                    const content = fs.readFileSync(absPath, 'utf-8');
-                    const ig = ignore();
-                    ig.add(content);
-                    ignorers.set(dir, ig);
-                }
-                catch {
-                    // Skip unreadable files
-                }
-            }
-        }
-        catch {
-            // git ls-files failed — we still have the root ignorer
-        }
-        return ignorers;
-    }
-    /**
-     * Start watching for file changes.
-     */
-    startWatching() {
-        const gitDir = path.join(this.repoPath, '.git');
-        if (!fs.existsSync(gitDir))
-            return;
-        // --- Git internals watcher ---
-        const indexFile = path.join(gitDir, 'index');
-        const headFile = path.join(gitDir, 'HEAD');
-        const refsDir = path.join(gitDir, 'refs');
-        const gitignorePath = path.join(this.repoPath, '.gitignore');
-        // Git uses atomic writes (write to temp, then rename). We use polling
-        // for reliable detection of these atomic operations.
-        this.gitWatcher = watch([indexFile, headFile, refsDir, gitignorePath], {
-            persistent: true,
-            ignoreInitial: true,
-            usePolling: true,
-            interval: 100,
-        });
-        // --- Working directory watcher with gitignore support ---
-        this.ignorers = this.loadGitignores();
-        this.workingDirWatcher = watch(this.repoPath, {
-            persistent: true,
-            ignoreInitial: true,
-            ignored: (filePath) => {
-                const relativePath = path.relative(this.repoPath, filePath);
-                if (!relativePath)
-                    return false;
-                // Walk ancestor directories from root to parent, checking each ignorer
-                const parts = relativePath.split('/');
-                for (let depth = 0; depth < parts.length; depth++) {
-                    const dir = depth === 0 ? '' : parts.slice(0, depth).join('/');
-                    const ig = this.ignorers.get(dir);
-                    if (ig) {
-                        const relToDir = depth === 0 ? relativePath : parts.slice(depth).join('/');
-                        if (ig.ignores(relToDir))
-                            return true;
-                    }
-                }
-                return false;
-            },
-            awaitWriteFinish: {
-                stabilityThreshold: 100,
-                pollInterval: 50,
-            },
+        const queue = getQueueForRepo(repoPath);
+        // Create sub-managers with cross-cutting callbacks
+        this.history = new HistoryManager(repoPath, queue);
+        this.compare = new CompareManager(repoPath, queue);
+        this.workingTree = new WorkingTreeManager(repoPath, queue, async () => {
+            await this.history.refreshIfLoaded();
+            await this.compare.refreshIfLoaded();
         });
-        const scheduleRefresh = () => this.scheduleRefresh();
-        this.gitWatcher.on('change', (filePath) => {
-            // Reload gitignore patterns if .gitignore changed
-            if (filePath === gitignorePath) {
-                this.ignorers = this.loadGitignores();
-            }
-            scheduleRefresh();
-        });
-        this.gitWatcher.on('add', scheduleRefresh);
-        this.gitWatcher.on('unlink', scheduleRefresh);
-        this.gitWatcher.on('error', (err) => {
-            const message = err instanceof Error ? err.message : String(err);
-            this.emit('error', `Git watcher error: ${message}`);
-        });
-        this.workingDirWatcher.on('change', scheduleRefresh);
-        this.workingDirWatcher.on('add', scheduleRefresh);
-        this.workingDirWatcher.on('unlink', scheduleRefresh);
-        this.workingDirWatcher.on('error', (err) => {
-            const message = err instanceof Error ? err.message : String(err);
-            this.emit('error', `Working dir watcher error: ${message}`);
+        this.remote = new RemoteOperationManager(repoPath, queue, {
+            scheduleRefresh: () => this.workingTree.scheduleRefresh(),
+            loadStashList: () => this.workingTree.loadStashList(),
+            resetCompareBaseBranch: () => this.compare.resetBaseBranch(),
         });
     }
-    /**
-     * Stop watching and clean up resources.
-     */
     dispose() {
-        if (this.diffDebounceTimer)
-            clearTimeout(this.diffDebounceTimer);
-        this.gitWatcher?.close();
-        this.workingDirWatcher?.close();
+        this.workingTree.dispose();
         removeQueueForRepo(this.repoPath);
     }
-    /**
-     * Schedule a refresh (coalesced if one is already pending).
-     * Also refreshes history and compare data if they were previously loaded.
-     */
-    scheduleRefresh() {
-        this.queue.scheduleRefresh(async () => {
-            await this.doRefresh();
-            // Also refresh history if it was loaded (has commits)
-            if (this._historyState.commits.length > 0) {
-                await this.doLoadHistory();
-            }
-            // Also refresh compare if it was loaded (has a base branch set)
-            if (this._compareState.compareBaseBranch) {
-                await this.doRefreshCompareDiff(false);
-            }
-        });
-    }
-    /**
-     * Schedule a lightweight status-only refresh (no diff fetching).
-     * Used after stage/unstage where the diff view updates on file selection.
-     */
-    scheduleStatusRefresh() {
-        this.queue.scheduleRefresh(async () => {
-            const newStatus = await getStatus(this.repoPath);
-            if (!newStatus.isRepo) {
-                this.updateState({
-                    status: newStatus,
-                    diff: null,
-                    isLoading: false,
-                    error: 'Not a git repository',
-                });
-                return;
-            }
-            this.updateState({ status: newStatus, isLoading: false });
-        });
-    }
-    /**
-     * Immediately refresh git state.
-     */
-    async refresh() {
-        await this.queue.enqueue(() => this.doRefresh());
-    }
-    async doRefresh() {
-        this.updateState({ isLoading: true, error: null });
-        try {
-            const newStatus = await getStatus(this.repoPath);
-            if (!newStatus.isRepo) {
-                this.updateState({
-                    status: newStatus,
-                    diff: null,
-                    isLoading: false,
-                    error: 'Not a git repository',
-                });
-                return;
-            }
-            // Fetch unstaged and staged diffs in parallel
-            const [allUnstagedDiff, allStagedDiff] = await Promise.all([
-                getDiff(this.repoPath, undefined, false),
-                getDiff(this.repoPath, undefined, true),
-            ]);
-            // Count hunks per file for the file list display
-            const hunkCounts = {
-                unstaged: countHunksPerFile(allUnstagedDiff.raw),
-                staged: countHunksPerFile(allStagedDiff.raw),
-            };
-            // Determine display diff based on selected file
-            const { displayDiff, combinedFileDiffs } = await this.resolveFileDiffs(newStatus, allUnstagedDiff);
-            // Batch status + diffs into a single update to avoid flicker
-            this.updateState({
-                status: newStatus,
-                diff: displayDiff,
-                combinedFileDiffs,
-                hunkCounts,
-                isLoading: false,
-            });
-        }
-        catch (err) {
-            this.updateState({
-                isLoading: false,
-                error: err instanceof Error ? err.message : 'Unknown error',
-            });
-        }
-    }
-    /**
-     * Resolve display diff and combined diffs for the currently selected file.
-     */
-    async resolveFileDiffs(newStatus, fallbackDiff) {
-        const currentSelectedFile = this._state.selectedFile;
-        if (!currentSelectedFile) {
-            return { displayDiff: fallbackDiff, combinedFileDiffs: null };
-        }
-        // Match by path + staged, falling back to path-only (handles staging state changes)
-        const currentFile = newStatus.files.find((f) => f.path === currentSelectedFile.path && f.staged === currentSelectedFile.staged) ?? newStatus.files.find((f) => f.path === currentSelectedFile.path);
-        if (!currentFile) {
-            this.updateState({ selectedFile: null });
-            return { displayDiff: fallbackDiff, combinedFileDiffs: null };
-        }
-        if (currentFile.status === 'untracked') {
-            const displayDiff = await getDiffForUntracked(this.repoPath, currentFile.path);
-            return {
-                displayDiff,
-                combinedFileDiffs: { unstaged: displayDiff, staged: { raw: '', lines: [] } },
-            };
-        }
-        const [unstagedFileDiff, stagedFileDiff] = await Promise.all([
-            getDiff(this.repoPath, currentFile.path, false),
-            getDiff(this.repoPath, currentFile.path, true),
-        ]);
-        const displayDiff = currentFile.staged ? stagedFileDiff : unstagedFileDiff;
-        return {
-            displayDiff,
-            combinedFileDiffs: { unstaged: unstagedFileDiff, staged: stagedFileDiff },
-        };
-    }
-    /**
-     * Select a file and update the diff display.
-     * The selection highlight updates immediately; the diff fetch is debounced
-     * so rapid arrow-key presses only spawn one git process for the final file.
-     */
-    selectFile(file) {
-        this.updateState({ selectedFile: file });
-        if (!this._state.status?.isRepo)
-            return;
-        if (this.diffDebounceTimer) {
-            // Already cooling down — reset the timer and fetch when it expires
-            clearTimeout(this.diffDebounceTimer);
-            this.diffDebounceTimer = setTimeout(() => {
-                this.diffDebounceTimer = null;
-                this.fetchDiffForSelection();
-            }, 20);
-        }
-        else {
-            // First call — fetch immediately, then start cooldown
-            this.fetchDiffForSelection();
-            this.diffDebounceTimer = setTimeout(() => {
-                this.diffDebounceTimer = null;
-            }, 20);
-        }
-    }
-    fetchDiffForSelection() {
-        const file = this._state.selectedFile;
-        this.queue
-            .enqueue(async () => {
-            if (file !== this._state.selectedFile)
-                return;
-            await this.doFetchDiffForFile(file);
-        })
-            .catch((err) => {
-            this.updateState({
-                error: `Failed to load diff: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        });
-    }
-    async doFetchDiffForFile(file) {
-        if (!file) {
-            const allDiff = await getStagedDiff(this.repoPath);
-            if (this._state.selectedFile === null) {
-                this.updateState({ diff: allDiff, combinedFileDiffs: null });
-            }
-            return;
-        }
-        if (file.status === 'untracked') {
-            const fileDiff = await getDiffForUntracked(this.repoPath, file.path);
-            if (file === this._state.selectedFile) {
-                this.updateState({
-                    diff: fileDiff,
-                    combinedFileDiffs: { unstaged: fileDiff, staged: { raw: '', lines: [] } },
-                });
-            }
-            return;
-        }
-        const [unstagedDiff, stagedDiff] = await Promise.all([
-            getDiff(this.repoPath, file.path, false),
-            getDiff(this.repoPath, file.path, true),
-        ]);
-        if (file === this._state.selectedFile) {
-            const displayDiff = file.staged ? stagedDiff : unstagedDiff;
-            this.updateState({
-                diff: displayDiff,
-                combinedFileDiffs: { unstaged: unstagedDiff, staged: stagedDiff },
-            });
-        }
-    }
-    /**
-     * Stage a file.
-     */
-    async stage(file) {
-        try {
-            await this.queue.enqueueMutation(() => stageFile(this.repoPath, file.path));
-            this.scheduleStatusRefresh();
-        }
-        catch (err) {
-            await this.refresh();
-            this.updateState({
-                error: `Failed to stage ${file.path}: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * Unstage a file.
-     */
-    async unstage(file) {
-        try {
-            await this.queue.enqueueMutation(() => unstageFile(this.repoPath, file.path));
-            this.scheduleStatusRefresh();
-        }
-        catch (err) {
-            await this.refresh();
-            this.updateState({
-                error: `Failed to unstage ${file.path}: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * Stage a single hunk via patch.
-     */
-    async stageHunk(patch) {
-        try {
-            await this.queue.enqueueMutation(async () => gitStageHunk(this.repoPath, patch));
-            this.scheduleRefresh();
-        }
-        catch (err) {
-            await this.refresh();
-            this.updateState({
-                error: `Failed to stage hunk: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * Unstage a single hunk via patch.
-     */
-    async unstageHunk(patch) {
-        try {
-            await this.queue.enqueueMutation(async () => gitUnstageHunk(this.repoPath, patch));
-            this.scheduleRefresh();
-        }
-        catch (err) {
-            await this.refresh();
-            this.updateState({
-                error: `Failed to unstage hunk: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * Discard changes to a file.
-     */
-    async discard(file) {
-        if (file.staged || file.status === 'untracked')
-            return;
-        try {
-            await this.queue.enqueueMutation(() => gitDiscardChanges(this.repoPath, file.path));
-            await this.refresh();
-        }
-        catch (err) {
-            this.updateState({
-                error: `Failed to discard ${file.path}: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * Stage all files.
-     */
-    async stageAll() {
-        try {
-            await this.queue.enqueueMutation(() => gitStageAll(this.repoPath));
-            await this.refresh();
-        }
-        catch (err) {
-            this.updateState({
-                error: `Failed to stage all: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * Unstage all files.
-     */
-    async unstageAll() {
-        try {
-            await this.queue.enqueueMutation(() => gitUnstageAll(this.repoPath));
-            await this.refresh();
-        }
-        catch (err) {
-            this.updateState({
-                error: `Failed to unstage all: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * Create a commit.
-     */
-    async commit(message, amend = false) {
-        try {
-            await this.queue.enqueue(() => gitCommit(this.repoPath, message, amend));
-            await this.refresh();
-        }
-        catch (err) {
-            this.updateState({
-                error: `Failed to commit: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    // 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.
-     */
-    async getHeadCommitMessage() {
-        return this.queue.enqueue(() => getHeadMessage(this.repoPath));
-    }
-    /**
-     * 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)}`,
-            });
-        }
-    }
-    /**
-     * Internal: refresh compare diff (called within queue).
-     */
-    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 getCandidateBaseBranches(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);
-    }
-    /**
-     * Load commit history for the history view.
-     */
-    async loadHistory(count = 100) {
-        this.updateHistoryState({ isLoading: true });
-        try {
-            await this.queue.enqueue(() => this.doLoadHistory(count));
-        }
-        catch (err) {
-            this.updateHistoryState({ isLoading: false });
-            this.updateState({
-                error: `Failed to load history: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * Internal: load commit history (called within queue).
-     */
-    async doLoadHistory(count = 100) {
-        const commits = await getCommitHistory(this.repoPath, count);
-        this.updateHistoryState({ commits, isLoading: false });
-    }
-    /**
-     * Select a commit in history view and load its diff.
-     */
-    async selectHistoryCommit(commit) {
-        this.updateHistoryState({ selectedCommit: commit, commitDiff: null });
-        if (!commit)
-            return;
-        try {
-            await this.queue.enqueue(async () => {
-                const diff = await getCommitDiff(this.repoPath, commit.hash);
-                this.updateHistoryState({ commitDiff: diff });
-            });
-        }
-        catch (err) {
-            this.updateState({
-                error: `Failed to load commit diff: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * 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 });
-        try {
-            await this.queue.enqueue(async () => {
-                const diff = await getCommitDiff(this.repoPath, commit.hash);
-                this.updateCompareSelectionState({ diff });
-            });
-        }
-        catch (err) {
-            this.updateState({
-                error: `Failed to load commit diff: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    }
-    /**
-     * 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 });
-    }
 }
 // Registry of managers per repo path
 const managerRegistry = new Map();