byterover-cli 2.6.0 → 3.0.1

package/dist/server/infra/git/isomorphic-git-service.js

@@ -0,0 +1,983 @@
+import * as git from 'isomorphic-git';
+import fs from 'node:fs';
+import { join } from 'node:path';
+import { GitAuthError, GitError } from '../../core/domain/errors/git-error.js';
+import { gitHttpWrapper as http } from './git-http-wrapper.js';
+/** Max commit depth for ahead/behind calculation. Counts beyond this are truncated. */
+const MAX_AHEAD_BEHIND_DEPTH = 500;
+export class IsomorphicGitService {
+    authStateStore;
+    constructor(authStateStore) {
+        this.authStateStore = authStateStore;
+    }
+    static isConflictError(error) {
+        return error.name === 'MergeConflictError' && 'data' in error;
+    }
+    static isMergeConflictData(data) {
+        if (typeof data !== 'object' || data === null)
+            return false;
+        return 'filepaths' in data && Array.isArray(data.filepaths);
+    }
+    async abortMerge(params) {
+        const dir = this.requireDirectory(params);
+        const mergeHeadPath = join(dir, '.git', 'MERGE_HEAD');
+        const mergeMsgPath = join(dir, '.git', 'MERGE_MSG');
+        // Identify files introduced by the merge source (in MERGE_HEAD tree but not in HEAD tree).
+        // These files appeared on disk during merge and must be removed on abort.
+        // We compare tree contents (not statusMatrix) because merge-introduced files and
+        // pre-existing untracked files both show as [0,2,0] in the status matrix.
+        // Get current branch BEFORE checkout to avoid detached HEAD
+        const branch = await this.getCurrentBranch(params);
+        let mergeIntroducedFiles = [];
+        const mergeHeadOid = await fs.promises
+            .readFile(mergeHeadPath, 'utf8')
+            .then((s) => s.trim())
+            .catch(() => null);
+        if (mergeHeadOid) {
+            const headFiles = new Set(await git.listFiles({ dir, fs, ref: branch ?? 'HEAD' }));
+            const mergeFiles = await git.listFiles({ dir, fs, ref: mergeHeadOid });
+            mergeIntroducedFiles = mergeFiles.filter((f) => !headFiles.has(f));
+        }
+        await git.checkout({ dir, force: true, fs, ref: branch ?? 'HEAD' });
+        // Clean up files that the merge brought in (exist in MERGE_HEAD but not in HEAD)
+        for (const filepath of mergeIntroducedFiles) {
+            // eslint-disable-next-line no-await-in-loop
+            await fs.promises.unlink(join(dir, filepath)).catch(() => { });
+        }
+        await fs.promises.unlink(mergeHeadPath).catch(() => { });
+        await fs.promises.unlink(mergeMsgPath).catch(() => { });
+    }
+    async add(params) {
+        const dir = this.requireDirectory(params);
+        // Identify deleted files (exist in HEAD + index but not on disk: [1,0,1])
+        // git.add() silently ignores missing files; git.remove() is required to stage deletions
+        const matrix = await git.statusMatrix({ dir, fs });
+        // Covers [1,0,1] (unstaged deletion) and [1,0,2] (post-merge-conflict absent file).
+        // stage !== 0 excludes [1,0,0] which is already staged as deletion — no git.remove() needed.
+        const deletedInIndex = new Set(matrix
+            .filter(([, head, workdir, stage]) => head === 1 && workdir === 0 && stage !== 0)
+            .map(([filepath]) => String(filepath)));
+        // Files not present on disk at all (workdir=0): covers both [1,0,1] (unstaged deletion)
+        // and [1,0,0] (already staged deletion). git.add() on these exact paths throws; skip toAdd.
+        const notOnDisk = new Set(matrix.filter((row) => row[2] === 0).map((row) => String(row[0])));
+        const toRemove = [];
+        const toAdd = [];
+        for (const rp of params.filePaths) {
+            const matchesDelete = (filepath) => {
+                if (rp === '.')
+                    return true;
+                if (filepath === rp)
+                    return true;
+                const prefix = rp.endsWith('/') ? rp : `${rp}/`;
+                return filepath.startsWith(prefix);
+            };
+            for (const deleted of deletedInIndex) {
+                if (matchesDelete(deleted))
+                    toRemove.push(deleted);
+            }
+            // Don't call git.add() for exact paths not on disk — git.remove() handles [1,0,1] above,
+            // and [1,0,0] (already staged deletion) needs no further action.
+            // git.add('.') and directory patterns are fine (silently skip missing files).
+            if (!notOnDisk.has(rp)) {
+                toAdd.push(rp);
+            }
+        }
+        const results = await Promise.allSettled([
+            ...toRemove.map((filepath) => git.remove({ dir, filepath, fs })),
+            ...toAdd.map((filepath) => git.add({ dir, filepath, fs })),
+        ]);
+        const allPaths = [...toRemove, ...toAdd];
+        const failed = results
+            .map((r, i) => ({ path: allPaths[i], result: r }))
+            .filter((x) => x.result.status === 'rejected');
+        if (failed.length > 0) {
+            const paths = failed.map((f) => f.path).join(', ');
+            throw new GitError(`Failed to stage: ${paths}`);
+        }
+    }
+    async addRemote(params) {
+        const dir = this.requireDirectory(params);
+        await git.addRemote({ dir, fs, remote: params.remote, url: params.url });
+    }
+    async checkout(params) {
+        const dir = this.requireDirectory(params);
+        // Snapshot tracked files in current branch BEFORE checkout.
+        // isomorphic-git's checkout only restores target files but does NOT remove
+        // files that are tracked in the source branch but absent in the target.
+        // Native git removes them, so we do it manually after checkout.
+        const sourceBranch = await this.getCurrentBranch(params);
+        const sourceFiles = sourceBranch ? new Set(await git.listFiles({ dir, fs, ref: sourceBranch })) : new Set();
+        // isomorphic-git's checkout detects unstaged conflicts (CheckoutConflictError)
+        // but silently overwrites staged changes — a data-loss bug. Guard staged
+        // conflicts here to match native git behavior.
+        if (!params.force && sourceBranch) {
+            await this.guardStagedConflicts(dir, sourceBranch, params.ref);
+        }
+        try {
+            await git.checkout({ dir, force: params.force, fs, ref: params.ref });
+        }
+        catch (error) {
+            if (error instanceof git.Errors.CheckoutConflictError) {
+                throw new GitError('Your local changes to the following files would be overwritten by checkout. ' +
+                    'Commit your changes or stash them before you switch branches.');
+            }
+            throw error;
+        }
+        // Remove files tracked in source but not in target (matches native git behavior).
+        // Untracked files are not in either set, so they are preserved.
+        if (sourceFiles.size > 0) {
+            const targetFiles = new Set(await git.listFiles({ dir, fs, ref: params.ref }));
+            for (const filepath of sourceFiles) {
+                if (!targetFiles.has(filepath)) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await fs.promises.unlink(join(dir, filepath)).catch(() => { });
+                }
+            }
+        }
+    }
+    async clone(params) {
+        const dir = this.requireDirectory(params);
+        const token = this.requireToken();
+        await git.clone({
+            dir,
+            fs,
+            headers: this.buildBasicAuthHeaders(token.userId, token.sessionKey),
+            http,
+            onAuth: this.getOnAuth(),
+            onAuthFailure: this.getOnAuthFailure(),
+            onProgress: params.onProgress,
+            url: params.url,
+        });
+    }
+    async commit(params) {
+        const dir = this.requireDirectory(params);
+        const author = params.author ?? this.getAuthor();
+        // If MERGE_HEAD exists, create a proper merge commit with two parents
+        const mergeHeadPath = join(dir, '.git', 'MERGE_HEAD');
+        const mergeMsgPath = join(dir, '.git', 'MERGE_MSG');
+        const mergeHeadContent = await fs.promises.readFile(mergeHeadPath, 'utf8').catch(() => null);
+        const mergeHead = mergeHeadContent?.trim() ?? null;
+        let parent;
+        if (mergeHead) {
+            const headSha = await git.resolveRef({ dir, fs, ref: 'HEAD' });
+            parent = [headSha, mergeHead];
+        }
+        let sha;
+        try {
+            sha = await git.commit({ author, dir, fs, message: params.message, ...(parent ? { parent } : {}) });
+        }
+        catch (error) {
+            if (error instanceof git.Errors.UnmergedPathsError) {
+                const paths = error.data.filepaths.join(', ');
+                throw new GitError(`Unmerged files must be resolved before committing: ${paths}`);
+            }
+            throw error;
+        }
+        const { commit: commitObj } = await git.readCommit({ dir, fs, oid: sha });
+        // Clean up MERGE_HEAD and MERGE_MSG (isomorphic-git does not remove them automatically)
+        await fs.promises.unlink(mergeHeadPath).catch(() => { });
+        await fs.promises.unlink(mergeMsgPath).catch(() => { });
+        return {
+            author,
+            message: params.message,
+            sha,
+            timestamp: new Date(commitObj.author.timestamp * 1000),
+        };
+    }
+    async createBranch(params) {
+        const dir = this.requireDirectory(params);
+        await git.branch({ checkout: params.checkout, dir, fs, ref: params.branch });
+    }
+    async deleteBranch(params) {
+        const dir = this.requireDirectory(params);
+        await git.deleteBranch({ dir, fs, ref: params.branch });
+    }
+    async fetch(params) {
+        const dir = this.requireDirectory(params);
+        const token = this.requireToken();
+        await git.fetch({
+            dir,
+            fs,
+            headers: this.buildBasicAuthHeaders(token.userId, token.sessionKey),
+            http,
+            onAuth: this.getOnAuth(),
+            onAuthFailure: this.getOnAuthFailure(),
+            ref: params.ref,
+            remote: params.remote ?? 'origin',
+        });
+    }
+    async getAheadBehind(params) {
+        const dir = this.requireDirectory(params);
+        const localSha = await git.resolveRef({ dir, fs, ref: params.localRef }).catch(() => null);
+        const remoteSha = await git.resolveRef({ dir, fs, ref: params.remoteRef }).catch(() => null);
+        if (!localSha || !remoteSha)
+            return { ahead: 0, behind: 0 };
+        if (localSha === remoteSha)
+            return { ahead: 0, behind: 0 };
+        const [localLog, remoteLog] = await Promise.all([
+            git.log({ depth: MAX_AHEAD_BEHIND_DEPTH, dir, fs, ref: params.localRef }).catch(() => []),
+            git.log({ depth: MAX_AHEAD_BEHIND_DEPTH, dir, fs, ref: params.remoteRef }).catch(() => []),
+        ]);
+        const localShas = new Set(localLog.map((c) => c.oid));
+        const remoteShas = new Set(remoteLog.map((c) => c.oid));
+        const ahead = localLog.filter((c) => !remoteShas.has(c.oid)).length;
+        const behind = remoteLog.filter((c) => !localShas.has(c.oid)).length;
+        return { ahead, behind };
+    }
+    async getConflicts(params) {
+        const dir = this.requireDirectory(params);
+        // Only report conflicts when a merge is actually in progress
+        const mergeInProgress = await fs.promises
+            .access(join(dir, '.git', 'MERGE_HEAD'))
+            .then(() => true)
+            .catch(() => false);
+        if (!mergeInProgress)
+            return [];
+        const matrix = await git.statusMatrix({ dir, fs });
+        const conflicts = [];
+        await Promise.all(matrix.map(async ([filepath, head, workdir, stage]) => {
+            const path = String(filepath);
+            // deleted_modified: file was in HEAD but gone from workdir
+            if (head === 1 && workdir === 0) {
+                conflicts.push({ path, type: 'deleted_modified' });
+                return;
+            }
+            // deleted_modified (isomorphic-git variant): file in HEAD, on disk unchanged,
+            // but index differs from both (stage=3). This happens when the other branch
+            // deletes a file that we modified — isomorphic-git keeps our version on disk.
+            if (head === 1 && workdir === 1 && stage === 3) {
+                conflicts.push({ path, type: 'deleted_modified' });
+                return;
+            }
+            // both_added or both_modified: look for conflict markers in file content
+            if (workdir === 2) {
+                try {
+                    const content = await fs.promises.readFile(join(dir, path), 'utf8');
+                    if (content.includes('<<<<<<<')) {
+                        const type = head === 0 ? 'both_added' : 'both_modified';
+                        conflicts.push({ path, type });
+                    }
+                }
+                catch {
+                    // skip binary or unreadable files
+                }
+            }
+        }));
+        return conflicts.sort((a, b) => a.path.localeCompare(b.path));
+    }
+    async getCurrentBranch(params) {
+        const dir = this.requireDirectory(params);
+        const branch = await git.currentBranch({ dir, fs });
+        return branch ?? undefined;
+    }
+    async getFilesWithConflictMarkers(params) {
+        const dir = this.requireDirectory(params);
+        const matrix = await git.statusMatrix({ dir, fs });
+        const conflicted = [];
+        await Promise.all(matrix.map(async ([filepath, , workdir]) => {
+            const path = String(filepath);
+            // Only check files that exist in the working directory
+            if (workdir === 0)
+                return;
+            try {
+                const content = await fs.promises.readFile(join(dir, path), 'utf8');
+                if (content.includes('<<<<<<<') && content.includes('=======') && content.includes('>>>>>>>')) {
+                    conflicted.push(path);
+                }
+            }
+            catch {
+                // skip binary or unreadable files
+            }
+        }));
+        return conflicted.sort();
+    }
+    async getRemoteUrl(params) {
+        const dir = this.requireDirectory(params);
+        const result = await git.getConfig({ dir, fs, path: `remote.${params.remote}.url` });
+        return result === undefined || result === null ? undefined : String(result);
+    }
+    async getTrackingBranch(params) {
+        const dir = this.requireDirectory(params);
+        const remote = await git.getConfig({ dir, fs, path: `branch.${params.branch}.remote` });
+        if (remote === undefined || remote === null)
+            return undefined;
+        const merge = await git.getConfig({ dir, fs, path: `branch.${params.branch}.merge` });
+        if (merge === undefined || merge === null)
+            return undefined;
+        // merge is stored as refs/heads/<branch> — extract the branch name
+        const mergeStr = String(merge);
+        const remoteBranch = mergeStr.startsWith('refs/heads/') ? mergeStr.slice('refs/heads/'.length) : mergeStr;
+        return { remote: String(remote), remoteBranch };
+    }
+    async init(params) {
+        const dir = this.requireDirectory(params);
+        await git.init({ defaultBranch: params.defaultBranch ?? 'main', dir, fs });
+    }
+    async isAncestor(params) {
+        const dir = this.requireDirectory(params);
+        const commitOid = await git.resolveRef({ dir, fs, ref: params.commit });
+        const ancestorOid = await git.resolveRef({ dir, fs, ref: params.ancestor });
+        if (commitOid === ancestorOid)
+            return true;
+        return git.isDescendent({ ancestor: ancestorOid, depth: -1, dir, fs, oid: commitOid });
+    }
+    async isEmptyRepository(params) {
+        const dir = this.requireDirectory(params);
+        const commits = await this.log({ depth: 1, directory: dir });
+        if (commits.length > 0)
+            return false;
+        const remotes = await this.listRemotes({ directory: dir });
+        if (remotes.length > 0)
+            return false;
+        const branches = await git.listBranches({ dir, fs });
+        if (branches.length > 0)
+            return false;
+        const tags = await git.listTags({ dir, fs });
+        if (tags.length > 0)
+            return false;
+        const { isClean } = await this.status({ directory: dir });
+        return isClean;
+    }
+    async isInitialized(params) {
+        const dir = this.requireDirectory(params);
+        return fs.promises
+            .access(join(dir, '.git'))
+            .then(() => true)
+            .catch(() => false);
+    }
+    async listBranches(params) {
+        const dir = this.requireDirectory(params);
+        const current = await this.getCurrentBranch(params);
+        const branches = await git.listBranches({ dir, fs });
+        const result = branches.map((name) => ({ isCurrent: name === current, isRemote: false, name }));
+        if (params.remote) {
+            try {
+                const remoteBranches = await git.listBranches({ dir, fs, remote: params.remote });
+                for (const name of remoteBranches) {
+                    if (name === 'HEAD')
+                        continue;
+                    result.push({ isCurrent: false, isRemote: true, name: `${params.remote}/${name}` });
+                }
+            }
+            catch {
+                // No remote configured or no refs fetched yet — return local-only.
+                // Mirrors `git branch -a`: never auto-fetches, reads cached refs only.
+            }
+        }
+        return result;
+    }
+    async listRemotes(params) {
+        const dir = this.requireDirectory(params);
+        const remotes = await git.listRemotes({ dir, fs });
+        return remotes.map((r) => ({ remote: r.remote, url: r.url }));
+    }
+    async log(params) {
+        const dir = this.requireDirectory(params);
+        try {
+            const commits = await git.log({ depth: params.depth, dir, fs, ref: params.ref });
+            return commits.map((c) => ({
+                author: { email: c.commit.author.email, name: c.commit.author.name },
+                message: c.commit.message.trim(),
+                sha: c.oid,
+                timestamp: new Date(c.commit.author.timestamp * 1000),
+            }));
+        }
+        catch (error) {
+            // No commits yet — HEAD ref does not exist
+            if (error instanceof git.Errors.NotFoundError)
+                return [];
+            throw error;
+        }
+    }
+    async merge(params) {
+        const dir = this.requireDirectory(params);
+        const mergeHeadPath = join(dir, '.git', 'MERGE_HEAD');
+        const mergeMsgPath = join(dir, '.git', 'MERGE_MSG');
+        const author = params.author ?? this.getAuthor();
+        const message = params.message ?? `Merge branch '${params.branch}'`;
+        const currentBranch = await git.currentBranch({ dir, fs });
+        const localSha = currentBranch
+            ? await git.resolveRef({ dir, fs, ref: `refs/heads/${currentBranch}` }).catch(() => null)
+            : null;
+        try {
+            const mergeResult = await git.merge({
+                abortOnConflict: false,
+                author,
+                committer: author,
+                dir,
+                fs,
+                message,
+                theirs: params.branch,
+            });
+            if (mergeResult.alreadyMerged) {
+                return { alreadyUpToDate: true, success: true };
+            }
+            // isomorphic-git merge only updates refs — checkout to apply changes to working tree
+            if (currentBranch) {
+                await git.checkout({ dir, fs, ref: currentBranch });
+            }
+            return { success: true };
+        }
+        catch (error) {
+            if (error instanceof git.Errors.CheckoutConflictError) {
+                // Undo the merge commit — restore HEAD to pre-merge state so repo is left clean
+                if (localSha && currentBranch) {
+                    await git.writeRef({ dir, force: true, fs, ref: `refs/heads/${currentBranch}`, value: localSha });
+                }
+                throw new GitError('Local changes would be overwritten by merge. Commit or discard your changes first.');
+            }
+            if (error instanceof git.Errors.MergeConflictError) {
+                // isomorphic-git does not write MERGE_HEAD/MERGE_MSG — write them so
+                // getConflicts() and --continue work post-restart
+                const theirsOid = await git.resolveRef({ dir, fs, ref: params.branch });
+                await fs.promises.writeFile(mergeHeadPath, `${theirsOid}\n`);
+                await fs.promises.writeFile(mergeMsgPath, `${message}\n`);
+                // isomorphic-git uses the branch name as marker label (<<<<<<< main);
+                // native git uses HEAD — rewrite markers to match git convention
+                if (currentBranch) {
+                    await this.rewriteConflictMarkers(dir, currentBranch, this.conflictsFromError(error));
+                }
+                return { conflicts: this.conflictsFromError(error), success: false };
+            }
+            if (error instanceof git.Errors.MergeNotSupportedError) {
+                if (!params.allowUnrelatedHistories) {
+                    throw new GitError('Refusing to merge unrelated histories. Use --allow-unrelated-histories to force.');
+                }
+                const oursRef = (await git.currentBranch({ dir, fs })) ?? 'HEAD';
+                return this.mergeUnrelatedHistories({ author, dir, message, oursRef, theirsRef: params.branch });
+            }
+            throw error;
+        }
+    }
+    async pull(params) {
+        const dir = this.requireDirectory(params);
+        const token = this.requireToken();
+        const remote = params.remote ?? 'origin';
+        // Guard: if MERGE_HEAD exists, a previous merge is unresolved — refuse to pull
+        const hasPendingMerge = await fs.promises
+            .readFile(join(dir, '.git', 'MERGE_HEAD'), 'utf8')
+            .then(() => true)
+            .catch(() => false);
+        if (hasPendingMerge) {
+            throw new GitError('You have unresolved merge conflicts. Resolve them, stage the files, and commit before pulling again.');
+        }
+        // Fetch from remote
+        await git.fetch({
+            dir,
+            fs,
+            headers: this.buildBasicAuthHeaders(token.userId, token.sessionKey),
+            http,
+            onAuth: this.getOnAuth(),
+            onAuthFailure: this.getOnAuthFailure(),
+            remote,
+            ...(params.branch ? { remoteRef: params.branch } : {}),
+        });
+        // Determine which remote-tracking branch to merge
+        const localBranch = params.branch ?? (await this.getCurrentBranch(params));
+        if (!localBranch)
+            throw new GitError('Cannot determine branch for pull');
+        // After fetch, check if already up to date
+        const localSha = await git.resolveRef({ dir, fs, ref: `refs/heads/${localBranch}` }).catch(() => null);
+        const remoteSha = await git.resolveRef({ dir, fs, ref: `refs/remotes/${remote}/${localBranch}` }).catch(() => null);
+        if (localSha && remoteSha && localSha === remoteSha) {
+            return { alreadyUpToDate: true, success: true };
+        }
+        // Empty local repo — fast-forward HEAD to remote tip (like native git pull on empty repo)
+        if (!localSha && remoteSha) {
+            await git.writeRef({ dir, force: true, fs, ref: `refs/heads/${localBranch}`, value: remoteSha });
+            await git.checkout({ dir, fs, ref: localBranch });
+            return { alreadyUpToDate: false, success: true };
+        }
+        // Step 2: working tree safety check (isomorphic-git does not do this automatically)
+        // Abort if any dirty local file would be overwritten by the incoming changes
+        if (localSha && remoteSha) {
+            const matrix = await git.statusMatrix({ dir, fs });
+            const dirtyFiles = matrix.filter((row) => row[2] !== 1 || row[3] !== 1).map((row) => String(row[0]));
+            const localRef = localSha;
+            const remoteRef = remoteSha;
+            const wouldBeOverwritten = await Promise.all(dirtyFiles.map(async (filepath) => {
+                const [localFileOid, remoteFileOid] = await Promise.all([
+                    git
+                        .readBlob({ dir, filepath, fs, oid: localRef })
+                        .then((r) => r.oid)
+                        .catch(() => null),
+                    git
+                        .readBlob({ dir, filepath, fs, oid: remoteRef })
+                        .then((r) => r.oid)
+                        .catch(() => null),
+                ]);
+                return localFileOid !== remoteFileOid;
+            }));
+            if (wouldBeOverwritten.some(Boolean)) {
+                throw new GitError('Local changes would be overwritten by pull. Commit or discard your changes first.');
+            }
+        }
+        const author = params.author ?? this.getAuthor();
+        try {
+            const mergeResult = await git.merge({
+                abortOnConflict: false,
+                author,
+                committer: author,
+                dir,
+                fs,
+                theirs: `${remote}/${localBranch}`,
+            });
+            // isomorphic-git merge only updates refs/commits — checkout to apply file changes to workdir.
+            await git.checkout({ dir, fs, ref: localBranch });
+            return { alreadyUpToDate: mergeResult.alreadyMerged, success: true };
+        }
+        catch (error) {
+            if (error instanceof git.Errors.MergeConflictError) {
+                // isomorphic-git does not write MERGE_HEAD/MERGE_MSG — write them so
+                // getConflicts() and --continue work post-restart
+                const theirsOid = await git.resolveRef({ dir, fs, ref: `refs/remotes/${remote}/${localBranch}` });
+                await fs.promises.writeFile(join(dir, '.git', 'MERGE_HEAD'), `${theirsOid}\n`);
+                await fs.promises.writeFile(join(dir, '.git', 'MERGE_MSG'), `Merge remote-tracking branch '${remote}/${localBranch}'\n`);
+                // Rewrite conflict markers: isomorphic-git uses branch name, git uses HEAD
+                await this.rewriteConflictMarkers(dir, localBranch, this.conflictsFromError(error));
+                return { conflicts: this.conflictsFromError(error), success: false };
+            }
+            if (error instanceof git.Errors.MergeNotSupportedError) {
+                if (!params.allowUnrelatedHistories) {
+                    throw new GitError('Refusing to merge unrelated histories. Use --allow-unrelated-histories to force.');
+                }
+                const result = await this.mergeUnrelatedHistories({
+                    author,
+                    dir,
+                    message: `Merge remote-tracking branch '${remote}/${localBranch}'`,
+                    oursRef: localBranch,
+                    theirsRef: `${remote}/${localBranch}`,
+                });
+                if (result.success) {
+                    await git.checkout({ dir, fs, ref: localBranch });
+                }
+                return result;
+            }
+            if (error instanceof git.Errors.CheckoutConflictError) {
+                // Undo the merge commit — restore HEAD to pre-merge state so repo is left clean
+                if (localSha) {
+                    await git.writeRef({ dir, force: true, fs, ref: `refs/heads/${localBranch}`, value: localSha });
+                }
+                throw new GitError('Local changes would be overwritten by pull. Commit or discard your changes first.');
+            }
+            throw error;
+        }
+    }
+    async push(params) {
+        const dir = this.requireDirectory(params);
+        const token = this.requireToken();
+        try {
+            const branch = params.branch ?? (await git.currentBranch({ dir, fs })) ?? 'main';
+            const remote = params.remote ?? 'origin';
+            const localSha = await git.resolveRef({ dir, fs, ref: `refs/heads/${branch}` }).catch(() => null);
+            const remoteSha = await git.resolveRef({ dir, fs, ref: `refs/remotes/${remote}/${branch}` }).catch(() => null);
+            if (localSha && remoteSha && localSha === remoteSha) {
+                return { alreadyUpToDate: true, success: true };
+            }
+            await git.push({
+                dir,
+                fs,
+                headers: this.buildBasicAuthHeaders(token.userId, token.sessionKey),
+                http,
+                onAuth: this.getOnAuth(),
+                onAuthFailure: this.getOnAuthFailure(),
+                ref: branch,
+                remote,
+            });
+            return { alreadyUpToDate: false, success: true };
+        }
+        catch (error) {
+            if (error instanceof git.Errors.PushRejectedError) {
+                return { message: error.message, reason: 'non_fast_forward', success: false };
+            }
+            throw error;
+        }
+    }
+    async removeRemote(params) {
+        const dir = this.requireDirectory(params);
+        await git.deleteRemote({ dir, fs, remote: params.remote });
+    }
+    async reset(params) {
+        const dir = this.requireDirectory(params);
+        const mode = params.mode ?? 'mixed';
+        const ref = params.ref ?? 'HEAD';
+        // Case 1: Path-scoped unstage — always mixed, ignores mode/ref
+        if (params.filePaths && params.filePaths.length > 0) {
+            return this.resetUnstage(dir, params.filePaths);
+        }
+        // Case 2: Whole-tree unstage (mixed mode, ref=HEAD, no filePaths)
+        if (mode === 'mixed' && ref === 'HEAD') {
+            return this.resetUnstage(dir);
+        }
+        // Cases 3-5: Reset to a specific ref (soft/mixed/hard)
+        // Empty repo (no commits) — HEAD doesn't exist. Git treats this as a silent no-op.
+        const headExists = await git.resolveRef({ dir, fs, ref: 'HEAD' }).then(() => true, () => false);
+        if (!headExists) {
+            return { filesChanged: 0, headSha: '' };
+        }
+        const targetSha = await this.resolveRefExpression(dir, ref);
+        const branch = await this.getCurrentBranch(params);
+        if (!branch) {
+            throw new GitError('Cannot reset in detached HEAD state.');
+        }
+        const previousSha = await git.resolveRef({ dir, fs, ref: 'HEAD' });
+        if (mode === 'soft') {
+            await git.writeRef({ dir, force: true, fs, ref: `refs/heads/${branch}`, value: targetSha });
+            return { filesChanged: 0, headSha: targetSha };
+        }
+        if (mode === 'hard') {
+            // Snapshot files in current HEAD to detect orphans after reset
+            const currentFiles = new Set(await git.listFiles({ dir, fs, ref: previousSha }));
+            const targetFiles = new Set(await git.listFiles({ dir, fs, ref: targetSha }));
+            // Move branch pointer
+            await git.writeRef({ dir, force: true, fs, ref: `refs/heads/${branch}`, value: targetSha });
+            // Restore working tree + index
+            await git.checkout({ dir, force: true, fs, ref: branch });
+            // Delete orphaned files (tracked in old HEAD but not in target)
+            for (const filepath of currentFiles) {
+                if (!targetFiles.has(filepath)) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await fs.promises.unlink(join(dir, filepath)).catch(() => { });
+                }
+            }
+            // Clean up merge state if present
+            await fs.promises.unlink(join(dir, '.git', 'MERGE_HEAD')).catch(() => { });
+            await fs.promises.unlink(join(dir, '.git', 'MERGE_MSG')).catch(() => { });
+            const filesChanged = [...currentFiles].filter((f) => !targetFiles.has(f)).length +
+                [...targetFiles].filter((f) => !currentFiles.has(f)).length;
+            return { filesChanged, headSha: targetSha };
+        }
+        // mode === 'mixed' with ref !== HEAD
+        // Move branch pointer, then reset index to match new HEAD (working tree untouched)
+        await git.writeRef({ dir, force: true, fs, ref: `refs/heads/${branch}`, value: targetSha });
+        // Reset every file in the index to match the target
+        const targetFiles = await git.listFiles({ dir, fs, ref: targetSha });
+        const matrix = await git.statusMatrix({ dir, fs });
+        const allPaths = new Set([...matrix.map((row) => String(row[0])), ...targetFiles]);
+        await Promise.all([...allPaths].map((filepath) => git.resetIndex({ dir, filepath, fs, ref: targetSha })));
+        return { filesChanged: allPaths.size, headSha: targetSha };
+    }
+    async setTrackingBranch(params) {
+        const dir = this.requireDirectory(params);
+        await git.setConfig({ dir, fs, path: `branch.${params.branch}.remote`, value: params.remote });
+        await git.setConfig({ dir, fs, path: `branch.${params.branch}.merge`, value: `refs/heads/${params.remoteBranch}` });
+    }
+    async status(params) {
+        const dir = this.requireDirectory(params);
+        const matrix = await git.statusMatrix({ dir, fs });
+        const files = this.parseMatrix(matrix);
+        return { files, isClean: files.length === 0 };
+    }
+    buildBasicAuthHeaders(userId, sessionKey) {
+        const credentials = Buffer.from(`${userId}:${sessionKey}`).toString('base64');
+        return { Authorization: `Basic ${credentials}` };
+    }
+    conflictsFromError(error) {
+        if (!IsomorphicGitService.isConflictError(error))
+            return [];
+        const conflictData = error.data;
+        if (!IsomorphicGitService.isMergeConflictData(conflictData))
+            return [];
+        const deletedPaths = new Set([...(conflictData.deleteByTheirs ?? []), ...(conflictData.deleteByUs ?? [])]);
+        const bothModifiedPaths = new Set(conflictData.bothModified ?? []);
+        return conflictData.filepaths
+            .map((path) => ({
+            path,
+            type: deletedPaths.has(path)
+                ? 'deleted_modified'
+                : bothModifiedPaths.has(path)
+                    ? 'both_modified'
+                    : 'both_added',
+        }))
+            .sort((a, b) => a.path.localeCompare(b.path));
+    }
+    getAuthor() {
+        const token = this.authStateStore.getToken();
+        if (!token)
+            throw new GitAuthError();
+        return {
+            email: token.userEmail,
+            name: token.userName ?? token.userEmail,
+        };
+    }
+    getOnAuth() {
+        return () => {
+            const token = this.authStateStore.getToken();
+            if (!token)
+                throw new GitAuthError();
+            return {
+                password: token.sessionKey,
+                username: token.userId,
+            };
+        };
+    }
+    getOnAuthFailure() {
+        return () => {
+            throw new GitAuthError('Authentication failed. Try /login again.');
+        };
+    }
+    /**
+     * Guard against staged changes that would be overwritten by checkout.
+     * isomorphic-git's checkout only detects unstaged conflicts — it silently
+     * overwrites staged changes, causing data loss. This method fills that gap
+     * to match native git behavior.
+     */
+    async guardStagedConflicts(dir, sourceBranch, targetRef) {
+        const matrix = await git.statusMatrix({ dir, fs });
+        // Staged files: index (col 3) differs from HEAD (col 1)
+        // [1,_,2] modified+staged, [1,_,0] deleted+staged, [0,_,2] new+staged
+        const stagedFiles = matrix.filter(([, head, , stage]) => stage !== head).map(([filepath]) => String(filepath));
+        if (stagedFiles.length === 0)
+            return;
+        const sourceOid = await git.resolveRef({ dir, fs, ref: sourceBranch });
+        const targetOid = await git.resolveRef({ dir, fs, ref: targetRef });
+        const conflicting = [];
+        /* eslint-disable no-await-in-loop -- sequential file I/O is intentional here */
+        for (const filepath of stagedFiles) {
+            const sourceBlobOid = await this.readBlobOid(dir, sourceOid, filepath);
+            const targetBlobOid = await this.readBlobOid(dir, targetOid, filepath);
+            if (sourceBlobOid !== targetBlobOid) {
+                conflicting.push(filepath);
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        if (conflicting.length > 0) {
+            throw new GitError('Your local changes to the following files would be overwritten by checkout:\n' +
+                conflicting.map((f) => `\t${f}`).join('\n') +
+                '\nPlease commit your changes or stash them before you switch branches.');
+        }
+    }
+    /**
+     * Manual merge for unrelated histories (no common ancestor).
+     * isomorphic-git throws MergeNotSupportedError because it can't handle
+     * base=null at the root tree level. We bypass by combining both trees directly.
+     */
+    async mergeUnrelatedHistories(params) {
+        const { author, dir, message, oursRef, theirsRef } = params;
+        const mergeHeadPath = join(dir, '.git', 'MERGE_HEAD');
+        const mergeMsgPath = join(dir, '.git', 'MERGE_MSG');
+        const oursSha = await git.resolveRef({ dir, fs, ref: oursRef });
+        const theirsSha = await git.resolveRef({ dir, fs, ref: theirsRef });
+        // List all files from both sides
+        const oursFiles = await git.listFiles({ dir, fs, ref: oursSha });
+        const theirsFiles = await git.listFiles({ dir, fs, ref: theirsSha });
+        const theirsSet = new Set(theirsFiles);
+        // Detect conflicts: same filepath on both sides with different content
+        const conflicts = [];
+        /* eslint-disable no-await-in-loop -- sequential file I/O is intentional here */
+        for (const filepath of oursFiles) {
+            if (!theirsSet.has(filepath))
+                continue;
+            const oursBlob = await git.readBlob({ dir, filepath, fs, oid: oursSha });
+            const theirsBlob = await git.readBlob({ dir, filepath, fs, oid: theirsSha });
+            if (oursBlob.oid !== theirsBlob.oid) {
+                conflicts.push({ path: filepath, type: 'both_added' });
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        if (conflicts.length > 0) {
+            // Write MERGE_HEAD/MERGE_MSG so --continue works
+            await fs.promises.writeFile(mergeHeadPath, `${theirsSha}\n`);
+            await fs.promises.writeFile(mergeMsgPath, `${message}\n`);
+            // Write conflict markers to working tree for each conflicted file
+            /* eslint-disable no-await-in-loop -- sequential per-file conflict marker writes */
+            for (const conflict of conflicts) {
+                const oursBlob = await git.readBlob({ dir, filepath: conflict.path, fs, oid: oursSha });
+                const theirsBlob = await git.readBlob({ dir, filepath: conflict.path, fs, oid: theirsSha });
+                const oursContent = Buffer.from(oursBlob.blob).toString('utf8');
+                const theirsContent = Buffer.from(theirsBlob.blob).toString('utf8');
+                const conflictContent = `<<<<<<< HEAD\n` +
+                    oursContent +
+                    (oursContent.endsWith('\n') ? '' : '\n') +
+                    `=======\n` +
+                    theirsContent +
+                    (theirsContent.endsWith('\n') ? '' : '\n') +
+                    `>>>>>>> ${theirsRef}\n`;
+                await fs.promises.writeFile(join(dir, conflict.path), conflictContent);
+            }
+            /* eslint-enable no-await-in-loop */
+            return { conflicts, success: false };
+        }
+        // No conflicts — write all remote files to working tree and stage them
+        const oursSet = new Set(oursFiles);
+        /* eslint-disable no-await-in-loop -- sequential file writes + git add */
+        for (const filepath of theirsFiles) {
+            if (oursSet.has(filepath))
+                continue; // same content, already present
+            const blob = await git.readBlob({ dir, filepath, fs, oid: theirsSha });
+            const filePath = join(dir, filepath);
+            const fileDir = join(filePath, '..');
+            await fs.promises.mkdir(fileDir, { recursive: true });
+            await fs.promises.writeFile(filePath, Buffer.from(blob.blob));
+            await git.add({ dir, filepath, fs });
+        }
+        /* eslint-enable no-await-in-loop */
+        // Create merge commit with both parents
+        await git.commit({
+            author,
+            committer: author,
+            dir,
+            fs,
+            message,
+            parent: [oursSha, theirsSha],
+        });
+        return { success: true };
+    }
+    // eslint-disable-next-line complexity
+    parseMatrix(matrix) {
+        const files = [];
+        for (const [filepath, head, workdir, stage] of matrix) {
+            const path = String(filepath);
+            if (head === 1 && workdir === 0 && stage === 0) {
+                files.push({ path, staged: true, status: 'deleted' }); // [1,0,0] staged deletion (git rm)
+            }
+            else if (head === 1 && workdir === 0 && stage === 1) {
+                files.push({ path, staged: false, status: 'deleted' }); // [1,0,1] unstaged deletion (rm without git rm)
+            }
+            else if (head === 1 && workdir === 0 && stage === 2) {
+                files.push({ path, staged: false, status: 'deleted' }); // [1,0,2] absent from disk, index differs from HEAD (e.g. post-merge-conflict)
+            }
+            else if (head === 1 && workdir === 0 && stage === 3) {
+                // [1,0,3] staged modification then deleted from disk → show both staged mod and unstaged deletion
+                files.push({ path, staged: true, status: 'modified' }, { path, staged: false, status: 'deleted' });
+            }
+            else if (head === 1 && workdir === 1 && stage === 0) {
+                files.push({ path, staged: true, status: 'deleted' }, { path, staged: false, status: 'untracked' }); // [1,1,0] git rm --cached: staged deletion + file still in workdir → untracked
+            }
+            else if (head === 1 && workdir === 2 && stage === 1) {
+                files.push({ path, staged: false, status: 'modified' }); // [1,2,1] unstaged modification
+            }
+            else if (head === 1 && workdir === 2 && stage === 2) {
+                files.push({ path, staged: true, status: 'modified' }); // [1,2,2] staged modification
+            }
+            else if (head === 1 && workdir === 2 && stage === 3) {
+                files.push({ path, staged: true, status: 'modified' }, { path, staged: false, status: 'modified' }); // [1,2,3] partially staged modification
+            }
+            else if (head === 0 && workdir === 2 && stage === 0) {
+                files.push({ path, staged: false, status: 'untracked' }); // [0,2,0] untracked new file
+            }
+            else if (head === 0 && workdir === 2 && stage === 2) {
+                files.push({ path, staged: true, status: 'added' }); // [0,2,2] staged new file
+            }
+            else if (head === 0 && workdir === 2 && stage === 3) {
+                files.push({ path, staged: true, status: 'added' }, { path, staged: false, status: 'modified' }); // [0,2,3] partially staged new file
+            }
+            // [1,1,1] unmodified → skip
+        }
+        return files;
+    }
+    async readBlobOid(dir, commitOid, filepath) {
+        try {
+            const result = await git.readBlob({ dir, filepath, fs, oid: commitOid });
+            return result.oid;
+        }
+        catch {
+            return null;
+        }
+    }
+    requireDirectory(params) {
+        // Guard against empty string — undefined/null are caught by TypeScript at compile time
+        if (!params.directory)
+            throw new GitError('directory is required for git operations');
+        return params.directory;
+    }
+    requireToken() {
+        const token = this.authStateStore.getToken();
+        if (!token)
+            throw new GitAuthError();
+        return token;
+    }
+    /**
+     * Unstage files by resetting their index entries to match HEAD.
+     * When filePaths is omitted, unstages all staged files.
+     */
+    async resetUnstage(dir, filePaths) {
+        const headSha = await git.resolveRef({ dir, fs, ref: 'HEAD' }).catch(() => null);
+        const matrix = await git.statusMatrix({ dir, fs });
+        // Identify staged rows — any file where the index differs from HEAD
+        const stagedRows = matrix.filter(([, head, , stage]) => {
+            if (head === 1 && stage === 0)
+                return true; // staged deletion or git rm --cached ([1,0,0] and [1,1,0])
+            if (head === 0 && stage === 2)
+                return true; // staged new file ([0,2,2])
+            if (head === 1 && stage === 2)
+                return true; // staged modification ([1,2,2])
+            if (stage === 3)
+                return true; // partially staged ([*,*,3])
+            return false;
+        });
+        const toUnstage = filePaths && filePaths.length > 0
+            ? stagedRows
+                .filter(([filepath]) => {
+                const path = String(filepath);
+                return filePaths.some((fp) => {
+                    if (path === fp)
+                        return true;
+                    const prefix = fp.endsWith('/') ? fp : `${fp}/`;
+                    return path.startsWith(prefix);
+                });
+            })
+                .map(([filepath]) => String(filepath))
+            : stagedRows.map(([filepath]) => String(filepath));
+        // Validate that every requested path is known to the repository
+        if (filePaths && filePaths.length > 0) {
+            const allKnownPaths = new Set(matrix.map(([filepath]) => String(filepath)));
+            for (const fp of filePaths) {
+                const isKnown = fp.endsWith('/') ? [...allKnownPaths].some((p) => p.startsWith(fp)) : allKnownPaths.has(fp);
+                if (!isKnown) {
+                    throw new GitError(`pathspec '${fp}' did not match any file(s) known to git`);
+                }
+            }
+        }
+        await Promise.all(headSha
+            ? toUnstage.map((filepath) => git.resetIndex({ dir, filepath, fs, ref: 'HEAD' }))
+            : toUnstage.map((filepath) => git.remove({ dir, filepath, fs })));
+        return { filesChanged: toUnstage.length, headSha: headSha ?? '' };
+    }
+    /**
+     * Resolves a ref expression that may include ~N ancestry syntax (e.g. HEAD~2).
+     * Falls back to git.resolveRef for plain refs.
+     */
+    async resolveRefExpression(dir, ref) {
+        const tildeMatch = /^(.+)~(\d+)$/.exec(ref);
+        if (!tildeMatch) {
+            return git.resolveRef({ dir, fs, ref });
+        }
+        const baseRef = tildeMatch[1];
+        const count = Number.parseInt(tildeMatch[2], 10);
+        if (count === 0) {
+            return git.resolveRef({ dir, fs, ref: baseRef });
+        }
+        let oid = await git.resolveRef({ dir, fs, ref: baseRef });
+        for (let i = 0; i < count; i++) {
+            // eslint-disable-next-line no-await-in-loop
+            const commit = await git.readCommit({ dir, fs, oid });
+            if (commit.commit.parent.length === 0) {
+                throw new GitError(`Cannot resolve '${ref}': not enough ancestors.`);
+            }
+            oid = commit.commit.parent[0];
+        }
+        return oid;
+    }
+    /**
+     * Fixes conflict markers written by isomorphic-git to match native git:
+     * 1. Replaces `<<<<<<< <branchName>` with `<<<<<<< HEAD`
+     * 2. Ensures `\n` before `=======` and `>>>>>>>` (isomorphic-git omits it when content has no trailing newline)
+     */
+    async rewriteConflictMarkers(dir, branchName, conflicts) {
+        const marker = `<<<<<<< ${branchName}`;
+        await Promise.all(conflicts
+            .filter((c) => c.type !== 'deleted_modified')
+            .map(async (c) => {
+            const filePath = join(dir, c.path);
+            let content = await fs.promises.readFile(filePath, 'utf8').catch(() => null);
+            if (!content)
+                return;
+            content = content.replaceAll(marker, '<<<<<<< HEAD');
+            // isomorphic-git omits \n before ======= and >>>>>>> when file content has no trailing newline
+            content = content.replaceAll(/([^\n])=======/g, '$1\n=======');
+            content = content.replaceAll(/([^\n])>>>>>>>/g, '$1\n>>>>>>>');
+            await fs.promises.writeFile(filePath, content);
+        }));
+    }
+}