diffstalker 0.1.6 → 0.2.0

package/dist/core/GitStateManager.js

@@ -1 +1,525 @@
-import*as h from"node:path";import*as m from"node:fs";import{watch as l}from"chokidar";import{EventEmitter as g}from"node:events";import{getQueueForRepo as S,removeQueueForRepo as y}from"./GitOperationQueue.js";import{getStatus as w,stageFile as D,unstageFile as C,stageAll as _,unstageAll as F,discardChanges as q,commit as P,getHeadMessage as B}from"../git/status.js";import{getDiff as c,getDiffForUntracked as p,getStagedDiff as f,getDefaultBaseBranch as E,getCandidateBaseBranches as R,getDiffBetweenRefs as W,getCompareDiffWithUncommitted as k,getCommitDiff as d}from"../git/diff.js";import{getCachedBaseBranch as $,setCachedBaseBranch as M}from"../utils/baseBranchCache.js";export class GitStateManager extends g{repoPath;queue;gitWatcher=null;workingDirWatcher=null;_state={status:null,diff:null,stagedDiff:"",selectedFile:null,isLoading:!1,error:null};_compareState={compareDiff:null,compareBaseBranch:null,compareLoading:!1,compareError:null};_historyState={selectedCommit:null,commitDiff:null};_compareSelectionState={type:null,index:0,diff:null};constructor(t){super(),this.repoPath=t,this.queue=S(t)}get state(){return this._state}get compareState(){return this._compareState}get historyState(){return this._historyState}get compareSelectionState(){return this._compareSelectionState}updateState(t){this._state={...this._state,...t},this.emit("state-change",this._state)}updateCompareState(t){this._compareState={...this._compareState,...t},this.emit("compare-state-change",this._compareState)}updateHistoryState(t){this._historyState={...this._historyState,...t},this.emit("history-state-change",this._historyState)}updateCompareSelectionState(t){this._compareSelectionState={...this._compareSelectionState,...t},this.emit("compare-selection-change",this._compareSelectionState)}startWatching(){const t=h.join(this.repoPath,".git");if(!m.existsSync(t))return;const e=h.join(t,"index"),a=h.join(t,"HEAD"),s=h.join(t,"refs");this.gitWatcher=l([e,a,s],{persistent:!0,ignoreInitial:!0,awaitWriteFinish:{stabilityThreshold:100,pollInterval:50}}),this.workingDirWatcher=l(this.repoPath,{persistent:!0,ignoreInitial:!0,ignored:["**/node_modules/**","**/.git/**","**/dist/**","**/build/**","**/*.log","**/.DS_Store"],awaitWriteFinish:{stabilityThreshold:100,pollInterval:50},depth:10});const i=()=>this.scheduleRefresh();this.gitWatcher.on("change",i),this.gitWatcher.on("add",i),this.gitWatcher.on("unlink",i),this.workingDirWatcher.on("change",i),this.workingDirWatcher.on("add",i),this.workingDirWatcher.on("unlink",i)}dispose(){this.gitWatcher?.close(),this.workingDirWatcher?.close(),y(this.repoPath)}scheduleRefresh(){this.queue.scheduleRefresh(()=>this.doRefresh())}async refresh(){await this.queue.enqueue(()=>this.doRefresh())}async doRefresh(){this.updateState({isLoading:!0,error:null});try{const t=await w(this.repoPath);if(!t.isRepo){this.updateState({status:t,diff:null,stagedDiff:"",isLoading:!1,error:"Not a git repository"});return}const[e,a]=await Promise.all([f(this.repoPath),c(this.repoPath,void 0,!1)]);let s;const i=this._state.selectedFile;if(i){const o=t.files.find(u=>u.path===i.path&&u.staged===i.staged);o?o.status==="untracked"?s=await p(this.repoPath,o.path):s=await c(this.repoPath,o.path,o.staged):(s=a.raw?a:e,this.updateState({selectedFile:null}))}else a.raw?s=a:e.raw?s=e:s={raw:"",lines:[]};this.updateState({status:t,diff:s,stagedDiff:e.raw,isLoading:!1})}catch(t){this.updateState({isLoading:!1,error:t instanceof Error?t.message:"Unknown error"})}}async selectFile(t){this.updateState({selectedFile:t}),this._state.status?.isRepo&&await this.queue.enqueue(async()=>{if(t){let e;t.status==="untracked"?e=await p(this.repoPath,t.path):e=await c(this.repoPath,t.path,t.staged),this.updateState({diff:e})}else{const e=await f(this.repoPath);this.updateState({diff:e})}})}async stage(t){const e=this._state.status;e&&this.updateState({status:{...e,files:e.files.map(a=>a.path===t.path&&!a.staged?{...a,staged:!0}:a)}});try{await this.queue.enqueueMutation(()=>D(this.repoPath,t.path)),this.scheduleRefresh()}catch(a){await this.refresh(),this.updateState({error:`Failed to stage ${t.path}: ${a instanceof Error?a.message:String(a)}`})}}async unstage(t){const e=this._state.status;e&&this.updateState({status:{...e,files:e.files.map(a=>a.path===t.path&&a.staged?{...a,staged:!1}:a)}});try{await this.queue.enqueueMutation(()=>C(this.repoPath,t.path)),this.scheduleRefresh()}catch(a){await this.refresh(),this.updateState({error:`Failed to unstage ${t.path}: ${a instanceof Error?a.message:String(a)}`})}}async discard(t){if(!(t.staged||t.status==="untracked"))try{await this.queue.enqueueMutation(()=>q(this.repoPath,t.path)),await this.refresh()}catch(e){this.updateState({error:`Failed to discard ${t.path}: ${e instanceof Error?e.message:String(e)}`})}}async stageAll(){try{await this.queue.enqueueMutation(()=>_(this.repoPath)),await this.refresh()}catch(t){this.updateState({error:`Failed to stage all: ${t instanceof Error?t.message:String(t)}`})}}async unstageAll(){try{await this.queue.enqueueMutation(()=>F(this.repoPath)),await this.refresh()}catch(t){this.updateState({error:`Failed to unstage all: ${t instanceof Error?t.message:String(t)}`})}}async commit(t,e=!1){try{await this.queue.enqueue(()=>P(this.repoPath,t,e)),await this.refresh()}catch(a){this.updateState({error:`Failed to commit: ${a instanceof Error?a.message:String(a)}`})}}async getHeadCommitMessage(){return this.queue.enqueue(()=>B(this.repoPath))}async refreshCompareDiff(t=!1){this.updateCompareState({compareLoading:!0,compareError:null});try{await this.queue.enqueue(async()=>{let e=this._compareState.compareBaseBranch;if(e||(e=$(this.repoPath)??await E(this.repoPath),this.updateCompareState({compareBaseBranch:e})),e){const a=t?await k(this.repoPath,e):await W(this.repoPath,e);this.updateCompareState({compareDiff:a,compareLoading:!1})}else this.updateCompareState({compareDiff:null,compareLoading:!1,compareError:"No base branch found"})})}catch(e){this.updateCompareState({compareLoading:!1,compareError:`Failed to load compare diff: ${e instanceof Error?e.message:String(e)}`})}}async getCandidateBaseBranches(){return R(this.repoPath)}async setCompareBaseBranch(t,e=!1){this.updateCompareState({compareBaseBranch:t}),M(this.repoPath,t),await this.refreshCompareDiff(e)}async selectHistoryCommit(t){if(this.updateHistoryState({selectedCommit:t,commitDiff:null}),!!t)try{await this.queue.enqueue(async()=>{const e=await d(this.repoPath,t.hash);this.updateHistoryState({commitDiff:e})})}catch(e){this.updateState({error:`Failed to load commit diff: ${e instanceof Error?e.message:String(e)}`})}}async selectCompareCommit(t){const e=this._compareState.compareDiff;if(!e||t<0||t>=e.commits.length){this.updateCompareSelectionState({type:null,index:0,diff:null});return}const a=e.commits[t];this.updateCompareSelectionState({type:"commit",index:t,diff:null});try{await this.queue.enqueue(async()=>{const s=await d(this.repoPath,a.hash);this.updateCompareSelectionState({diff:s})})}catch(s){this.updateState({error:`Failed to load commit diff: ${s instanceof Error?s.message:String(s)}`})}}selectCompareFile(t){const e=this._compareState.compareDiff;if(!e||t<0||t>=e.files.length){this.updateCompareSelectionState({type:null,index:0,diff:null});return}const a=e.files[t];this.updateCompareSelectionState({type:"file",index:t,diff:a.diff})}}const n=new Map;export function getManagerForRepo(r){let t=n.get(r);return t||(t=new GitStateManager(r),n.set(r,t)),t}export function removeManagerForRepo(r){const t=n.get(r);t&&(t.dispose(),n.delete(r))}
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+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, } from '../git/status.js';
+import { getDiff, getDiffForUntracked, getStagedDiff, getDefaultBaseBranch, getCandidateBaseBranches, getDiffBetweenRefs, getCompareDiffWithUncommitted, getCommitDiff, } from '../git/diff.js';
+import { getCachedBaseBranch, setCachedBaseBranch } from '../utils/baseBranchCache.js';
+/**
+ * GitStateManager manages git state independent of React.
+ * It owns the operation queue, file watchers, and emits events on state changes.
+ */
+export class GitStateManager extends EventEmitter {
+    repoPath;
+    queue;
+    gitWatcher = null;
+    workingDirWatcher = null;
+    ignorer = null;
+    // Current state
+    _state = {
+        status: null,
+        diff: null,
+        stagedDiff: '',
+        selectedFile: null,
+        isLoading: false,
+        error: null,
+    };
+    _compareState = {
+        compareDiff: null,
+        compareBaseBranch: null,
+        compareLoading: false,
+        compareError: null,
+    };
+    _historyState = {
+        commits: [],
+        selectedCommit: null,
+        commitDiff: null,
+        isLoading: false,
+    };
+    _compareSelectionState = {
+        type: null,
+        index: 0,
+        diff: 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;
+    }
+    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 .gitignore and .git/info/exclude.
+     * Returns an Ignore instance that can test paths.
+     */
+    loadGitignore() {
+        const ig = ignore();
+        // Always ignore .git directory (has its own dedicated watcher)
+        ig.add('.git');
+        // Load .gitignore if it exists
+        const gitignorePath = path.join(this.repoPath, '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+            ig.add(fs.readFileSync(gitignorePath, 'utf-8'));
+        }
+        // Load .git/info/exclude if it exists (repo-specific ignores)
+        const excludePath = path.join(this.repoPath, '.git', 'info', 'exclude');
+        if (fs.existsSync(excludePath)) {
+            ig.add(fs.readFileSync(excludePath, 'utf-8'));
+        }
+        return ig;
+    }
+    /**
+     * 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.ignorer = this.loadGitignore();
+        this.workingDirWatcher = watch(this.repoPath, {
+            persistent: true,
+            ignoreInitial: true,
+            ignored: (filePath) => {
+                // Get path relative to repo root
+                const relativePath = path.relative(this.repoPath, filePath);
+                // Don't ignore the repo root itself
+                if (!relativePath)
+                    return false;
+                // Check against gitignore patterns
+                // When this returns true for a directory, chokidar won't recurse into it
+                return this.ignorer?.ignores(relativePath) ?? false;
+            },
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50,
+            },
+        });
+        const scheduleRefresh = () => this.scheduleRefresh();
+        this.gitWatcher.on('change', (filePath) => {
+            // Reload gitignore patterns if .gitignore changed
+            if (filePath === gitignorePath) {
+                this.ignorer = this.loadGitignore();
+            }
+            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}`);
+        });
+    }
+    /**
+     * Stop watching and clean up resources.
+     */
+    dispose() {
+        this.gitWatcher?.close();
+        this.workingDirWatcher?.close();
+        removeQueueForRepo(this.repoPath);
+    }
+    /**
+     * Schedule a refresh (coalesced if one is already pending).
+     */
+    scheduleRefresh() {
+        this.queue.scheduleRefresh(() => this.doRefresh());
+    }
+    /**
+     * 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,
+                    stagedDiff: '',
+                    isLoading: false,
+                    error: 'Not a git repository',
+                });
+                return;
+            }
+            // Fetch all diffs atomically
+            const [allStagedDiff, allUnstagedDiff] = await Promise.all([
+                getStagedDiff(this.repoPath),
+                getDiff(this.repoPath, undefined, false),
+            ]);
+            // Determine display diff based on selected file
+            let displayDiff;
+            const currentSelectedFile = this._state.selectedFile;
+            if (currentSelectedFile) {
+                const currentFile = newStatus.files.find((f) => f.path === currentSelectedFile.path && f.staged === currentSelectedFile.staged);
+                if (currentFile) {
+                    if (currentFile.status === 'untracked') {
+                        displayDiff = await getDiffForUntracked(this.repoPath, currentFile.path);
+                    }
+                    else {
+                        displayDiff = await getDiff(this.repoPath, currentFile.path, currentFile.staged);
+                    }
+                }
+                else {
+                    // File no longer exists - clear selection
+                    displayDiff = allUnstagedDiff.raw ? allUnstagedDiff : allStagedDiff;
+                    this.updateState({ selectedFile: null });
+                }
+            }
+            else {
+                if (allUnstagedDiff.raw) {
+                    displayDiff = allUnstagedDiff;
+                }
+                else if (allStagedDiff.raw) {
+                    displayDiff = allStagedDiff;
+                }
+                else {
+                    displayDiff = { raw: '', lines: [] };
+                }
+            }
+            this.updateState({
+                status: newStatus,
+                diff: displayDiff,
+                stagedDiff: allStagedDiff.raw,
+                isLoading: false,
+            });
+        }
+        catch (err) {
+            this.updateState({
+                isLoading: false,
+                error: err instanceof Error ? err.message : 'Unknown error',
+            });
+        }
+    }
+    /**
+     * Select a file and update the diff display.
+     */
+    async selectFile(file) {
+        this.updateState({ selectedFile: file });
+        if (!this._state.status?.isRepo)
+            return;
+        await this.queue.enqueue(async () => {
+            if (file) {
+                let fileDiff;
+                if (file.status === 'untracked') {
+                    fileDiff = await getDiffForUntracked(this.repoPath, file.path);
+                }
+                else {
+                    fileDiff = await getDiff(this.repoPath, file.path, file.staged);
+                }
+                this.updateState({ diff: fileDiff });
+            }
+            else {
+                const allDiff = await getStagedDiff(this.repoPath);
+                this.updateState({ diff: allDiff });
+            }
+        });
+    }
+    /**
+     * Stage a file with optimistic update.
+     */
+    async stage(file) {
+        // Optimistic update
+        const currentStatus = this._state.status;
+        if (currentStatus) {
+            this.updateState({
+                status: {
+                    ...currentStatus,
+                    files: currentStatus.files.map((f) => f.path === file.path && !f.staged ? { ...f, staged: true } : f),
+                },
+            });
+        }
+        try {
+            await this.queue.enqueueMutation(() => stageFile(this.repoPath, file.path));
+            this.scheduleRefresh();
+        }
+        catch (err) {
+            await this.refresh();
+            this.updateState({
+                error: `Failed to stage ${file.path}: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    /**
+     * Unstage a file with optimistic update.
+     */
+    async unstage(file) {
+        // Optimistic update
+        const currentStatus = this._state.status;
+        if (currentStatus) {
+            this.updateState({
+                status: {
+                    ...currentStatus,
+                    files: currentStatus.files.map((f) => f.path === file.path && f.staged ? { ...f, staged: false } : f),
+                },
+            });
+        }
+        try {
+            await this.queue.enqueueMutation(() => unstageFile(this.repoPath, file.path));
+            this.scheduleRefresh();
+        }
+        catch (err) {
+            await this.refresh();
+            this.updateState({
+                error: `Failed to unstage ${file.path}: ${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)}`,
+            });
+        }
+    }
+    /**
+     * 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(async () => {
+                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',
+                    });
+                }
+            });
+        }
+        catch (err) {
+            this.updateCompareState({
+                compareLoading: false,
+                compareError: `Failed to load compare diff: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    /**
+     * 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 {
+            const commits = await this.queue.enqueue(() => getCommitHistory(this.repoPath, count));
+            this.updateHistoryState({ commits, isLoading: false });
+        }
+        catch (err) {
+            this.updateHistoryState({ isLoading: false });
+            this.updateState({
+                error: `Failed to load history: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    /**
+     * 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();
+/**
+ * Get the state manager for a specific repository.
+ */
+export function getManagerForRepo(repoPath) {
+    let manager = managerRegistry.get(repoPath);
+    if (!manager) {
+        manager = new GitStateManager(repoPath);
+        managerRegistry.set(repoPath, manager);
+    }
+    return manager;
+}
+/**
+ * Remove a manager from the registry.
+ */
+export function removeManagerForRepo(repoPath) {
+    const manager = managerRegistry.get(repoPath);
+    if (manager) {
+        manager.dispose();
+        managerRegistry.delete(repoPath);
+    }
+}