@monotykamary/localterm-server 1.26.0 → 1.27.0

package/dist/git-diff.js

@@ -1,7 +1,8 @@
 import { execFile } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { GH_COMMAND_TIMEOUT_MS, GIT_BINARY_SNIFF_BYTES, GIT_COMMAND_TIMEOUT_MS, GIT_EMPTY_TREE_HASH, GIT_MAX_BRANCHES, GIT_MAX_OUTPUT_BYTES, GIT_MAX_PATCH_BYTES_PER_FILE, GIT_MAX_TOTAL_PATCH_BYTES, GIT_MAX_UNTRACKED_FILES, GIT_MAX_UNTRACKED_FILE_BYTES, } from "./constants.js";
+import { openRepository } from "es-git";
+import { GH_COMMAND_TIMEOUT_MS, GIT_BINARY_SNIFF_BYTES, GIT_COMMAND_TIMEOUT_MS, GIT_MAX_BRANCHES, GIT_MAX_OUTPUT_BYTES, GIT_MAX_PATCH_BYTES_PER_FILE, GIT_MAX_TOTAL_PATCH_BYTES, GIT_MAX_UNTRACKED_FILE_BYTES, GIT_MAX_UNTRACKED_FILES, } from "./constants.js";
 const WORKING_OPTIONS = { mode: "working" };
 const EMPTY_SUMMARY = {
     isRepo: false,
@@ -11,6 +12,13 @@ const EMPTY_SUMMARY = {
     binaries: 0,
     branch: null,
 };
+const GIT_EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+const collectIterator = (iterable) => {
+    const result = [];
+    for (const item of iterable)
+        result.push(item);
+    return result;
+};
 const runGit = (cwd, args) => new Promise((resolve, reject) => {
     execFile("git", ["--no-optional-locks", "-C", cwd, ...args], {
         timeout: GIT_COMMAND_TIMEOUT_MS,
@@ -24,269 +32,288 @@ const runGit = (cwd, args) => new Promise((resolve, reject) => {
         resolve(stdout);
     });
 });
-const isGitRepo = async (cwd) => {
-    try {
-        const stdout = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
-        return stdout.trim() === "true";
-    }
-    catch {
-        // Not a repo, git not installed, or the command timed out — all of these
-        // degrade to "nothing to diff" rather than an error the client must handle.
-        return false;
-    }
-};
-// Diff base for the working tree. HEAD when at least one commit exists;
-// otherwise git's well-known empty tree, so staged files in a brand-new
-// repository still show up.
-const resolveDiffBase = async (cwd) => {
-    try {
-        await runGit(cwd, ["rev-parse", "--verify", "--quiet", "HEAD"]);
-        return "HEAD";
-    }
-    catch {
-        return GIT_EMPTY_TREE_HASH;
-    }
-};
-// Run `gh` for PR discovery. Best-effort: gh may be absent, unauthenticated, or
-// slow on the network, so every failure (including a non-zero exit when the
-// branch has no PR) collapses to null and the caller falls back to local git.
 const runGh = (cwd, args) => new Promise((resolve) => {
     execFile("gh", args, { cwd, timeout: GH_COMMAND_TIMEOUT_MS, maxBuffer: GIT_MAX_OUTPUT_BYTES, encoding: "utf8" }, (error, stdout) => resolve(error ? null : stdout));
 });
-// True when `ref` names a commit in this repo. `^{commit}` forces peeling so a
-// tag or tree can't masquerade as a valid diff base.
-const refExists = async (cwd, ref) => {
-    try {
-        await runGit(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
-        return true;
-    }
-    catch {
-        return false;
+const deltaTypeToStatus = (delta) => {
+    switch (delta) {
+        case "Added":
+            return "added";
+        case "Deleted":
+            return "deleted";
+        case "Renamed":
+            return "renamed";
+        case "Copied":
+            return "added";
+        case "Untracked":
+            return "untracked";
+        case "Modified":
+        case "Typechange":
+        default:
+            return "modified";
     }
 };
-// First existing ref among the candidates, tried in order. Used to map a bare
-// branch name (e.g. a PR's baseRefName "main") onto a ref that actually exists,
-// preferring the remote-tracking copy over a possibly-stale local branch.
-const firstExistingRef = async (cwd, candidates) => {
-    for (const candidate of candidates) {
-        if (candidate && (await refExists(cwd, candidate)))
-            return candidate;
-    }
-    return null;
-};
-// Discover the PR for the current branch via gh. Returns null whenever gh is
-// unavailable or there is no PR — never throws.
-// gh reports PR state in upper case (OPEN/CLOSED/MERGED); map to our enum.
-const normalizePrState = (raw) => raw === "MERGED" ? "merged" : raw === "CLOSED" ? "closed" : "open";
-// Parse `gh pr list --json …` output (an array) into our PR shape.
-const parsePrList = (stdout) => {
-    if (!stdout)
-        return [];
+const openRepo = async (cwd) => {
     try {
-        const parsed = JSON.parse(stdout);
-        if (!Array.isArray(parsed))
-            return [];
-        const prs = [];
-        for (const item of parsed) {
-            if (typeof item?.number !== "number" || !item.baseRefName)
-                continue;
-            prs.push({
-                number: item.number,
-                title: typeof item.title === "string" ? item.title : "",
-                baseRefName: item.baseRefName,
-                url: typeof item.url === "string" && item.url.length > 0 ? item.url : null,
-                state: normalizePrState(item.state),
-                headOwner: typeof item.headRepositoryOwner?.login === "string"
-                    ? item.headRepositoryOwner.login
-                    : null,
-            });
-        }
-        return prs;
+        const repo = await openRepository(cwd);
+        return { cwd, repo };
     }
     catch {
-        return [];
+        return null;
     }
 };
-// Parse the repo's GitHub remotes from `git remote -v` — preserving order
-// (origin first) and de-duplicating the fetch/push pair per remote.
-const parseGithubRemotes = async (cwd) => {
+const getCurrentBranch = (r) => {
     try {
-        const stdout = await runGit(cwd, ["remote", "-v"]);
-        const seen = new Set();
-        const remotes = [];
-        for (const line of stdout.split("\n")) {
-            // <name>\t<url> (fetch|push); url is SSH (git@github.com:owner/repo.git)
-            // or HTTPS (https://github.com/owner/repo).
-            const match = /^(\S+)\s+\S*github\.com[/:]([^\s/]+)\/([^\s]+?)(?:\.git)?(?:\s|$)/.exec(line);
-            if (!match)
-                continue;
-            const [, name, owner, repo] = match;
-            const slug = `${owner}/${repo}`;
-            const key = `${name} ${slug}`;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            remotes.push({ name, slug, owner });
-        }
-        return remotes;
+        const head = r.repo.head();
+        const shorthand = head.shorthand();
+        return shorthand && shorthand !== "HEAD" ? shorthand : null;
     }
     catch {
-        return [];
+        return null;
     }
 };
-// GitHub "owner/repo" slugs parsed from the repo's remotes (origin first).
-export const listGithubRemoteSlugs = async (cwd) => {
-    const slugs = [];
-    for (const remote of await parseGithubRemotes(cwd)) {
-        if (!slugs.includes(remote.slug))
-            slugs.push(remote.slug);
+const resolveDiffBaseRef = (r) => {
+    try {
+        r.repo.head();
+        return "HEAD";
     }
-    return slugs;
-};
-const PR_LIST_FIELDS = "number,title,baseRefName,url,state,headRepositoryOwner";
-// Discover the PR for the current branch via gh. Returns null whenever gh is
-// unavailable or there is no PR — never throws.
-//
-// `gh pr list --head <branch>` matches by branch NAME across every fork, so on a
-// common name like "main" it returns strangers' PRs. We therefore keep only PRs
-// whose head repository is OUR repo (the `origin` remote's owner) — the branch
-// in our own fork. We query every GitHub remote (a fork's PR targets the
-// upstream) in parallel, using `--state all` so merged/closed PRs count too. An
-// open PR wins; otherwise the most recent merged/closed one.
-const detectPr = async (cwd) => {
-    const currentBranch = await getCurrentBranch(cwd);
-    if (!currentBranch)
-        return null;
-    const remotes = await parseGithubRemotes(cwd);
-    if (remotes.length === 0)
-        return null;
-    // The head repo of our PR is the fork we push to — `origin` (or, lacking one,
-    // the first remote). Only PRs whose head is owned by it are ours.
-    const ownRemote = remotes.find((remote) => remote.name === "origin") ?? remotes[0];
-    const ownOwner = ownRemote.owner.toLowerCase();
-    const slugs = [...new Set(remotes.map((remote) => remote.slug))];
-    // gh process spawn + network dominate, so query every candidate repo in
-    // parallel — collapses N sequential round-trips into one.
-    const results = await Promise.all(slugs.map((slug) => runGh(cwd, [
-        "pr",
-        "list",
-        "--repo",
-        slug,
-        "--head",
-        currentBranch,
-        "--state",
-        "all",
-        "--json",
-        PR_LIST_FIELDS,
-        "--limit",
-        "30",
-    ]).then(parsePrList)));
-    const seen = new Set();
-    let fallback = null;
-    for (const prs of results) {
-        for (const pr of prs) {
-            // Only PRs whose head is our own fork's copy of this branch.
-            if (!pr.headOwner || pr.headOwner.toLowerCase() !== ownOwner)
-                continue;
-            const key = pr.url ?? `#${pr.number}`;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            if (pr.state === "open")
-                return toBranchPr(pr);
-            fallback ??= pr;
-        }
+    catch {
+        return GIT_EMPTY_TREE_HASH;
     }
-    return fallback ? toBranchPr(fallback) : null;
 };
-// Drop the internal headOwner before returning the public PR shape.
-const toBranchPr = ({ number, title, baseRefName, url, state }) => ({
-    number,
-    title,
-    baseRefName,
-    url,
-    state,
-});
-// Pick the base branch to compare against when the client hasn't chosen one,
-// using LOCAL git only (no gh) so the branch diff loads as fast as the working
-// diff. Order of preference: the repo's default branch (origin/HEAD), then a
-// conventional main/master/develop. The current branch is never its own base.
-// Returns a concrete, existing ref plus how it was found. PR detection is kept
-// off this path on purpose — the PR's base is almost always the default branch,
-// and a non-default PR base can be chosen from the picker.
-const resolveDefaultBase = async (cwd, currentBranch) => {
-    // origin/HEAD -> refs/remotes/origin/main (the remote's default branch).
+const resolveDefaultBase = (r) => {
+    const currentBranch = getCurrentBranch(r);
     try {
-        const stdout = await runGit(cwd, [
-            "symbolic-ref",
-            "--quiet",
-            "--short",
-            "refs/remotes/origin/HEAD",
-        ]);
-        const ref = stdout.trim();
-        if (ref && ref !== currentBranch && (await refExists(cwd, ref))) {
-            return { ref, source: "remoteHead" };
+        const remoteHead = r.repo.getReference("refs/remotes/origin/HEAD");
+        const symTarget = remoteHead.symbolicTarget();
+        if (symTarget) {
+            const shortName = symTarget.replace("refs/remotes/", "");
+            if (shortName !== currentBranch) {
+                try {
+                    r.repo.revparseSingle(shortName);
+                    return { ref: shortName, source: "remoteHead" };
+                }
+                catch {
+                    // stale origin/HEAD
+                }
+            }
         }
     }
     catch {
-        // No origin/HEAD configured — fall through to the conventional names.
+        // No origin/HEAD configured
     }
     for (const name of ["main", "master", "develop"]) {
         if (name === currentBranch)
             continue;
-        const ref = await firstExistingRef(cwd, [`origin/${name}`, name]);
-        if (ref)
-            return { ref, source: "fallback" };
+        for (const candidate of [`origin/${name}`, name]) {
+            try {
+                r.repo.revparseSingle(candidate);
+                return { ref: candidate, source: "fallback" };
+            }
+            catch {
+                continue;
+            }
+        }
     }
     return null;
 };
-// Resolve the actual `git diff` base for the requested mode. "working" diffs
-// against HEAD (or the empty tree). "branch" diffs the working tree against the
-// MERGE BASE of the chosen base ref and HEAD, so changes the base branch made
-// after we forked don't show up — the same set GitHub shows for a PR, plus any
-// uncommitted/untracked work on top. Returns null when a branch base can't be
-// resolved, signalling the caller to report an empty diff.
-const resolveEffectiveBase = async (cwd, options) => {
+const resolveEffectiveBaseRef = (r, options) => {
     if (options.mode !== "branch")
-        return resolveDiffBase(cwd);
+        return resolveDiffBaseRef(r);
     let baseRef = options.base?.trim() || null;
     if (baseRef) {
-        if (!(await refExists(cwd, baseRef)))
+        try {
+            r.repo.revparseSingle(baseRef);
+        }
+        catch {
             baseRef = null;
+        }
     }
     if (!baseRef) {
-        const currentBranch = await getCurrentBranch(cwd);
-        const resolved = await resolveDefaultBase(cwd, currentBranch);
+        const resolved = resolveDefaultBase(r);
         baseRef = resolved?.ref ?? null;
     }
     if (!baseRef)
         return null;
     try {
-        const mergeBase = (await runGit(cwd, ["merge-base", baseRef, "HEAD"])).trim();
+        const baseOid = r.repo.revparseSingle(baseRef);
+        const headOid = r.repo.revparseSingle("HEAD");
+        const mergeBase = r.repo.getMergeBase(baseOid, headOid);
         if (mergeBase)
             return mergeBase;
     }
     catch {
-        // Unrelated histories or detached/no HEAD — diff against the ref directly.
+        // Unrelated histories
     }
-    return baseRef;
-};
-// Short current-branch name, or null when detached (rev-parse returns "HEAD").
-const getCurrentBranch = async (cwd) => {
     try {
-        const name = (await runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
-        return name && name !== "HEAD" ? name : null;
+        return r.repo.revparseSingle(baseRef);
     }
     catch {
         return null;
     }
 };
-/**
- * Parse `git diff --numstat -z` output. Entries are NUL-separated:
- *   `<added>\t<deleted>\t<path>` for ordinary changes, and
- *   `<added>\t<deleted>\t` followed by two extra NUL-separated tokens
- *   (old path, new path) for renames/copies. Binary files report `-` counts.
- */
+const countLines = (text) => {
+    if (text.length === 0)
+        return 0;
+    let count = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (text.charCodeAt(index) === 10)
+            count += 1;
+    }
+    if (!text.endsWith("\n"))
+        count += 1;
+    return count;
+};
+const collectUntrackedFiles = (r) => {
+    const files = [];
+    const statuses = r.repo.statuses();
+    const entries = collectIterator(statuses.iter());
+    for (const entry of entries) {
+        const s = entry.status();
+        if (!s.wtNew || s.ignored)
+            continue;
+        if (files.length >= GIT_MAX_UNTRACKED_FILES)
+            break;
+        const filePath = entry.path();
+        const absolutePath = path.join(r.cwd, filePath);
+        try {
+            const stat = fs.statSync(absolutePath);
+            if (!stat.isFile())
+                continue;
+            const bytesToRead = Math.min(stat.size, GIT_MAX_UNTRACKED_FILE_BYTES);
+            const buffer = Buffer.alloc(bytesToRead);
+            const handle = fs.openSync(absolutePath, "r");
+            fs.readSync(handle, buffer, 0, bytesToRead, 0);
+            fs.closeSync(handle);
+            const sniffEnd = Math.min(buffer.length, GIT_BINARY_SNIFF_BYTES);
+            const binary = buffer.subarray(0, sniffEnd).includes(0);
+            const truncated = stat.size > GIT_MAX_UNTRACKED_FILE_BYTES;
+            const content = binary ? null : truncated ? null : buffer.toString("utf8");
+            const lines = binary ? 0 : content ? countLines(content) : 0;
+            files.push({ path: filePath, binary, lines, content, truncated });
+        }
+        catch {
+            continue;
+        }
+    }
+    return files;
+};
+export const splitPatchByFile = (raw) => raw.split(/^(?=diff --git )/m).filter((chunk) => chunk.startsWith("diff --git "));
+export const buildUntrackedPatch = (content) => {
+    if (content.length === 0)
+        return "";
+    const hasTrailingNewline = content.endsWith("\n");
+    const lines = content.split("\n");
+    if (hasTrailingNewline)
+        lines.pop();
+    const body = lines.map((line) => `+${line}`).join("\n");
+    const noNewlineMarker = hasTrailingNewline ? "" : "\n\";
+    return `@@ -0,0 +1,${lines.length} @@\n${body}${noNewlineMarker}\n`;
+};
+const computeTrackedDeltas = async (r, baseRef) => {
+    let baseTree;
+    try {
+        baseTree = r.repo.getTree(baseRef);
+    }
+    catch {
+        try {
+            const baseOid = r.repo.revparseSingle(baseRef);
+            const obj = r.repo.findObject(baseOid);
+            if (!obj)
+                return [];
+            if (obj.type() === "Tree") {
+                baseTree = obj;
+            }
+            else {
+                const commit = r.repo.getCommit(baseOid);
+                baseTree = commit.tree();
+            }
+        }
+        catch {
+            return [];
+        }
+    }
+    let diff;
+    try {
+        diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
+    }
+    catch {
+        return [];
+    }
+    try {
+        diff.findSimilar({ renames: true });
+    }
+    catch {
+        // Rename detection failed
+    }
+    const stats = diff.stats();
+    const totalInsertions = Number(stats.insertions);
+    const totalDeletions = Number(stats.deletions);
+    const deltas = collectIterator(diff.deltas());
+    const trackedDeltas = [];
+    for (const delta of deltas) {
+        const status = deltaTypeToStatus(delta.status());
+        if (status === "untracked")
+            continue;
+        trackedDeltas.push({
+            path: delta.newFile().path(),
+            oldPath: status === "renamed" ? delta.oldFile().path() : null,
+            status,
+            additions: 0,
+            deletions: 0,
+            binary: delta.newFile().isBinary(),
+        });
+    }
+    // Redistribute the stats diff-wide totals across deltas using git diff --numstat.
+    // es-git's DiffStats gives aggregate insertions/deletions but not per-file.
+    // We fall back to `git diff --numstat -z` for per-file counts — one subprocess
+    // instead of the previous six, and only for the stat-heavy code paths.
+    if (trackedDeltas.length > 0) {
+        try {
+            const numstatRaw = await runGit(r.cwd, [
+                "diff",
+                baseRef,
+                "-M",
+                "--no-ext-diff",
+                "--no-textconv",
+                "--numstat",
+                "-z",
+            ]);
+            const entries = parseNumstatZ(numstatRaw);
+            const numstatByPath = new Map(entries.map((e) => [e.path, e]));
+            for (const d of trackedDeltas) {
+                const entry = numstatByPath.get(d.path);
+                if (entry && !d.binary) {
+                    d.additions = entry.additions;
+                    d.deletions = entry.deletions;
+                }
+            }
+        }
+        catch {
+            // Fallback: split aggregate stats across files
+            const nonBinary = trackedDeltas.filter((d) => !d.binary);
+            if (nonBinary.length === 1) {
+                nonBinary[0].additions = totalInsertions;
+                nonBinary[0].deletions = totalDeletions;
+            }
+            else if (nonBinary.length > 0) {
+                const perFileAdd = Math.floor(totalInsertions / nonBinary.length);
+                let extraAdd = totalInsertions - perFileAdd * nonBinary.length;
+                const perFileDel = Math.floor(totalDeletions / nonBinary.length);
+                let extraDel = totalDeletions - perFileDel * nonBinary.length;
+                for (const d of nonBinary) {
+                    d.additions = perFileAdd + (extraAdd > 0 ? 1 : 0);
+                    d.deletions = perFileDel + (extraDel > 0 ? 1 : 0);
+                    if (extraAdd > 0)
+                        extraAdd--;
+                    if (extraDel > 0)
+                        extraDel--;
+                }
+            }
+        }
+    }
+    return trackedDeltas;
+};
 export const parseNumstatZ = (raw) => {
     const tokens = raw.split("\0");
     const entries = [];
@@ -313,10 +340,6 @@ export const parseNumstatZ = (raw) => {
     }
     return entries;
 };
-/**
- * Parse `git diff --name-status -z` output into a path -> status map.
- * Tokens alternate `<status>` then path (or old path, new path for R/C).
- */
 export const parseNameStatusZ = (raw) => {
     const tokens = raw.split("\0");
     const statuses = new Map();
@@ -346,179 +369,77 @@ export const parseNameStatusZ = (raw) => {
     }
     return statuses;
 };
-// Split `git diff --patch` output into one chunk per file. Chunk order matches
-// the numstat/name-status order for the same diff arguments.
-export const splitPatchByFile = (raw) => raw.split(/^(?=diff --git )/m).filter((chunk) => chunk.startsWith("diff --git "));
-const countLines = (text) => {
-    if (text.length === 0)
-        return 0;
-    let count = 0;
-    for (let index = 0; index < text.length; index += 1) {
-        if (text.charCodeAt(index) === 10)
-            count += 1;
-    }
-    if (!text.endsWith("\n"))
-        count += 1;
-    return count;
-};
-const readUntrackedFile = async (filePath) => {
-    let handle = null;
-    try {
-        handle = await fs.promises.open(filePath, "r");
-        const stat = await handle.stat();
-        if (!stat.isFile())
-            return null;
-        const bytesToRead = Math.min(stat.size, GIT_MAX_UNTRACKED_FILE_BYTES);
-        const buffer = Buffer.alloc(bytesToRead);
-        await handle.read(buffer, 0, bytesToRead, 0);
-        const sniffEnd = Math.min(buffer.length, GIT_BINARY_SNIFF_BYTES);
-        if (buffer.subarray(0, sniffEnd).includes(0)) {
-            return { binary: true, lines: 0, truncated: false, content: null };
-        }
-        const truncated = stat.size > GIT_MAX_UNTRACKED_FILE_BYTES;
-        const text = buffer.toString("utf8");
-        return { binary: false, lines: countLines(text), truncated, content: truncated ? null : text };
-    }
-    catch {
-        // Vanished, unreadable, or special file — skip it.
-        return null;
-    }
-    finally {
-        await handle?.close();
-    }
-};
-// Untracked-file line counts are recomputed on every summary poll; cache them
-// by size+mtime so steady-state polls only stat each file. Bounded to avoid
-// growing forever across many repos/sessions.
-const UNTRACKED_CACHE_MAX_ENTRIES = 4096;
-const untrackedStatsCache = new Map();
-const getUntrackedStats = async (filePath) => {
-    let cacheKey = null;
-    try {
-        const stat = await fs.promises.lstat(filePath);
-        if (!stat.isFile())
-            return null;
-        cacheKey = `${stat.size}:${stat.mtimeMs}`;
-        const cached = untrackedStatsCache.get(filePath);
-        if (cached && cached.key === cacheKey) {
-            return { lines: cached.lines, binary: cached.binary };
-        }
-    }
-    catch {
-        return null;
-    }
-    const read = await readUntrackedFile(filePath);
-    if (!read)
-        return null;
-    if (untrackedStatsCache.size >= UNTRACKED_CACHE_MAX_ENTRIES)
-        untrackedStatsCache.clear();
-    untrackedStatsCache.set(filePath, { key: cacheKey, lines: read.lines, binary: read.binary });
-    return { lines: read.lines, binary: read.binary };
-};
-const listUntrackedPaths = async (cwd) => {
-    const stdout = await runGit(cwd, ["ls-files", "--others", "--exclude-standard", "-z"]);
-    return stdout.split("\0").filter((entry) => entry.length > 0);
-};
 export const getGitDiffSummary = async (cwd, options = WORKING_OPTIONS) => {
-    if (!(await isGitRepo(cwd)))
+    const r = await openRepo(cwd);
+    if (!r)
         return EMPTY_SUMMARY;
     try {
-        const base = await resolveEffectiveBase(cwd, options);
-        if (base === null)
+        const baseRef = resolveEffectiveBaseRef(r, options);
+        if (baseRef === null)
             return { ...EMPTY_SUMMARY, isRepo: true };
-        const [numstatRaw, untrackedPaths, branch] = await Promise.all([
-            runGit(cwd, ["diff", base, "-M", "--no-ext-diff", "--no-textconv", "--numstat", "-z"]),
-            listUntrackedPaths(cwd),
-            getCurrentBranch(cwd),
-        ]);
-        const tracked = parseNumstatZ(numstatRaw);
-        let additions = 0;
-        let deletions = 0;
+        const branch = getCurrentBranch(r);
+        let baseTree;
+        try {
+            baseTree = r.repo.getTree(baseRef);
+        }
+        catch {
+            try {
+                const baseOid = r.repo.revparseSingle(baseRef);
+                const obj = r.repo.findObject(baseOid);
+                if (!obj)
+                    return { ...EMPTY_SUMMARY, isRepo: true };
+                if (obj.type() === "Tree") {
+                    baseTree = obj;
+                }
+                else {
+                    const commit = r.repo.getCommit(baseOid);
+                    baseTree = commit.tree();
+                }
+            }
+            catch {
+                return { ...EMPTY_SUMMARY, isRepo: true };
+            }
+        }
+        let diff;
+        try {
+            diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
+        }
+        catch {
+            return { ...EMPTY_SUMMARY, isRepo: true };
+        }
+        try {
+            diff.findSimilar({ renames: true });
+        }
+        catch {
+            // Rename detection failed
+        }
+        const stats = diff.stats();
+        let additions = Number(stats.insertions);
+        let deletions = Number(stats.deletions);
         let binaries = 0;
-        for (const entry of tracked) {
-            additions += entry.additions;
-            deletions += entry.deletions;
-            if (entry.binary)
-                binaries += 1;
-        }
-        for (const relativePath of untrackedPaths.slice(0, GIT_MAX_UNTRACKED_FILES)) {
-            const stats = await getUntrackedStats(path.join(cwd, relativePath));
-            if (!stats)
-                continue;
-            if (stats.binary)
-                binaries += 1;
-            else
-                additions += stats.lines;
+        let fileCount = Number(stats.filesChanged);
+        const diffDeltas = collectIterator(diff.deltas());
+        for (const delta of diffDeltas) {
+            if (deltaTypeToStatus(delta.status()) !== "untracked" && delta.newFile().isBinary()) {
+                binaries++;
+            }
         }
-        return {
-            isRepo: true,
-            files: tracked.length + untrackedPaths.length,
-            additions,
-            deletions,
-            binaries,
-            branch,
-        };
+        const untracked = collectUntrackedFiles(r);
+        for (const file of untracked) {
+            fileCount++;
+            if (file.binary) {
+                binaries++;
+            }
+            else {
+                additions += file.lines;
+            }
+        }
+        return { isRepo: true, files: fileCount, additions, deletions, binaries, branch };
     }
     catch {
-        // Transient git failure (lock contention, timeout) — report a quiet repo
-        // rather than erroring the poll; the next poll will catch up.
         return { ...EMPTY_SUMMARY, isRepo: true };
     }
 };
-// Synthesize a single-hunk unified diff for an untracked (new) file so the
-// client renders it exactly like a tracked added file.
-export const buildUntrackedPatch = (content) => {
-    if (content.length === 0)
-        return "";
-    const hasTrailingNewline = content.endsWith("\n");
-    const lines = content.split("\n");
-    if (hasTrailingNewline)
-        lines.pop();
-    const body = lines.map((line) => `+${line}`).join("\n");
-    const noNewlineMarker = hasTrailingNewline ? "" : "\n\";
-    return `@@ -0,0 +1,${lines.length} @@\n${body}${noNewlineMarker}\n`;
-};
-const buildUntrackedDiffFile = async (cwd, relativePath) => {
-    const read = await readUntrackedFile(path.join(cwd, relativePath));
-    if (!read)
-        return null;
-    if (read.binary) {
-        return {
-            path: relativePath,
-            oldPath: null,
-            status: "untracked",
-            additions: 0,
-            deletions: 0,
-            binary: true,
-            patch: null,
-            patchOmitted: false,
-        };
-    }
-    return {
-        path: relativePath,
-        oldPath: null,
-        status: "untracked",
-        additions: read.lines,
-        deletions: 0,
-        binary: false,
-        patch: read.truncated || read.content === null ? null : buildUntrackedPatch(read.content),
-        patchOmitted: read.truncated,
-    };
-};
-// Collect per-file metadata (counts, rename old paths, status letters) without
-// generating any patch text. Shared by the bulk diff, the file-list endpoint,
-// and the per-file patch fetch. Rejects propagate to the caller's try/catch.
-const collectTrackedMeta = async (cwd, base) => {
-    const [numstatRaw, nameStatusRaw] = await Promise.all([
-        runGit(cwd, ["diff", base, "-M", "--no-ext-diff", "--no-textconv", "--numstat", "-z"]),
-        runGit(cwd, ["diff", base, "-M", "--no-ext-diff", "--no-textconv", "--name-status", "-z"]),
-    ]);
-    return { tracked: parseNumstatZ(numstatRaw), statuses: parseNameStatusZ(nameStatusRaw) };
-};
-const resolveFileStatus = (entry, statuses) => statuses.get(entry.path) ?? (entry.oldPath ? "renamed" : "modified");
-// Select the patch chunk whose new-side path matches the requested file. Our
-// per-file diff normally yields exactly one chunk; an odd worktree state can
-// split it, and we'd rather show nothing than attach the wrong file's patch.
 const pickPatchChunk = (chunks, newPath) => {
     if (chunks.length === 0)
         return null;
@@ -527,26 +448,19 @@ const pickPatchChunk = (chunks, newPath) => {
     return (chunks.find((chunk) => chunk.includes(`\n+++ b/${newPath}\n`) || chunk.includes(`\nrename to ${newPath}\n`)) ?? null);
 };
 export const getGitDiff = async (cwd, options = WORKING_OPTIONS) => {
-    if (!(await isGitRepo(cwd)))
+    const r = await openRepo(cwd);
+    if (!r)
         return { isRepo: false, files: [] };
-    const base = await resolveEffectiveBase(cwd, options);
-    if (base === null)
-        return { isRepo: true, files: [] };
-    let tracked = [];
-    let statuses = new Map();
-    try {
-        ({ tracked, statuses } = await collectTrackedMeta(cwd, base));
-    }
-    catch {
+    const baseRef = resolveEffectiveBaseRef(r, options);
+    if (baseRef === null)
         return { isRepo: true, files: [] };
-    }
-    // The patch run can exceed maxBuffer or time out on huge diffs; degrade to
-    // stats-only entries instead of failing the whole response.
+    const trackedDeltas = await computeTrackedDeltas(r, baseRef);
+    // Patch text via subprocess — es-git's print() doesn't emit +/- line markers.
     let patchChunks = null;
     try {
         const patchRaw = await runGit(cwd, [
             "diff",
-            base,
+            baseRef,
             "-M",
             "--no-ext-diff",
             "--no-textconv",
@@ -554,17 +468,14 @@ export const getGitDiff = async (cwd, options = WORKING_OPTIONS) => {
             "--patch",
         ]);
         const chunks = splitPatchByFile(patchRaw);
-        // Chunks pair with numstat entries by index; if the counts diverge
-        // (unexpected git output) don't risk attaching the wrong patch to a file.
-        if (chunks.length === tracked.length)
+        if (chunks.length === trackedDeltas.length)
             patchChunks = chunks;
     }
     catch {
         patchChunks = null;
     }
     let totalPatchBytes = 0;
-    const files = tracked.map((entry, index) => {
-        const status = resolveFileStatus(entry, statuses);
+    const files = trackedDeltas.map((entry, index) => {
         let patch = null;
         let patchOmitted = false;
         if (entry.binary) {
@@ -587,7 +498,7 @@ export const getGitDiff = async (cwd, options = WORKING_OPTIONS) => {
         return {
             path: entry.path,
             oldPath: entry.oldPath,
-            status,
+            status: entry.status,
             additions: entry.additions,
             deletions: entry.deletions,
             binary: entry.binary,
@@ -595,109 +506,86 @@ export const getGitDiff = async (cwd, options = WORKING_OPTIONS) => {
             patchOmitted,
         };
     });
-    let untrackedPaths = [];
-    try {
-        untrackedPaths = await listUntrackedPaths(cwd);
-    }
-    catch {
-        untrackedPaths = [];
-    }
-    for (const relativePath of untrackedPaths.slice(0, GIT_MAX_UNTRACKED_FILES)) {
-        const file = await buildUntrackedDiffFile(cwd, relativePath);
-        if (!file)
-            continue;
-        if (file.patch !== null) {
-            if (file.patch.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
-                totalPatchBytes + file.patch.length > GIT_MAX_TOTAL_PATCH_BYTES) {
-                file.patch = null;
-                file.patchOmitted = true;
+    const untracked = collectUntrackedFiles(r);
+    for (const file of untracked) {
+        const patch = file.binary
+            ? null
+            : file.truncated || file.content === null
+                ? null
+                : buildUntrackedPatch(file.content);
+        const entry = {
+            path: file.path,
+            oldPath: null,
+            status: "untracked",
+            additions: file.binary ? 0 : file.lines,
+            deletions: 0,
+            binary: file.binary,
+            patch,
+            patchOmitted: file.truncated,
+        };
+        if (entry.patch !== null) {
+            if (entry.patch.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
+                totalPatchBytes + entry.patch.length > GIT_MAX_TOTAL_PATCH_BYTES) {
+                entry.patch = null;
+                entry.patchOmitted = true;
             }
             else {
-                totalPatchBytes += file.patch.length;
+                totalPatchBytes += entry.patch.length;
             }
         }
-        files.push(file);
+        files.push(entry);
     }
     return { isRepo: true, files };
 };
-// File list for the diff viewer: per-file metadata only, no patch bodies. Cheap
-// (numstat + name-status + stat-only untracked) and small, so the viewer can
-// render its sidebar and totals the instant it opens. Patches load on demand via
-// getGitDiffFilePatch.
 export const getGitDiffFiles = async (cwd, options = WORKING_OPTIONS) => {
-    if (!(await isGitRepo(cwd)))
+    const r = await openRepo(cwd);
+    if (!r)
         return { isRepo: false, files: [] };
-    const base = await resolveEffectiveBase(cwd, options);
-    if (base === null)
-        return { isRepo: true, files: [] };
-    let tracked = [];
-    let statuses = new Map();
-    try {
-        ({ tracked, statuses } = await collectTrackedMeta(cwd, base));
-    }
-    catch {
+    const baseRef = resolveEffectiveBaseRef(r, options);
+    if (baseRef === null)
         return { isRepo: true, files: [] };
-    }
-    const files = tracked.map((entry) => ({
+    const trackedDeltas = await computeTrackedDeltas(r, baseRef);
+    const files = trackedDeltas.map((entry) => ({
         path: entry.path,
         oldPath: entry.oldPath,
-        status: resolveFileStatus(entry, statuses),
+        status: entry.status,
         additions: entry.additions,
         deletions: entry.deletions,
         binary: entry.binary,
     }));
-    let untrackedPaths = [];
-    try {
-        untrackedPaths = await listUntrackedPaths(cwd);
-    }
-    catch {
-        untrackedPaths = [];
-    }
-    for (const relativePath of untrackedPaths.slice(0, GIT_MAX_UNTRACKED_FILES)) {
-        const stats = await getUntrackedStats(path.join(cwd, relativePath));
-        if (!stats)
-            continue;
+    const untracked = collectUntrackedFiles(r);
+    for (const file of untracked) {
         files.push({
-            path: relativePath,
+            path: file.path,
             oldPath: null,
             status: "untracked",
-            additions: stats.binary ? 0 : stats.lines,
+            additions: file.binary ? 0 : file.lines,
             deletions: 0,
-            binary: stats.binary,
+            binary: file.binary,
         });
     }
     return { isRepo: true, files };
 };
-// Unified diff for a SINGLE file, fetched on demand. Unlike getGitDiff this is
-// NOT subject to the whole-response cap (GIT_MAX_TOTAL_PATCH_BYTES) — only the
-// per-file cap applies — so a file the bulk endpoint dropped because the response
-// total was exhausted still loads when opened individually.
 export const getGitDiffFilePatch = async (cwd, requestedPath, options = WORKING_OPTIONS) => {
     const empty = { patch: null, patchOmitted: false, binary: false };
-    if (!(await isGitRepo(cwd)))
+    const r = await openRepo(cwd);
+    if (!r)
         return empty;
-    const base = await resolveEffectiveBase(cwd, options);
-    if (base === null)
+    const baseRef = resolveEffectiveBaseRef(r, options);
+    if (baseRef === null)
         return empty;
-    let tracked = [];
-    try {
-        ({ tracked } = await collectTrackedMeta(cwd, base));
-    }
-    catch {
-        return empty;
-    }
-    const entry = tracked.find((candidate) => candidate.path === requestedPath);
+    // Check if tracked
+    const trackedDeltas = await computeTrackedDeltas(r, baseRef);
+    const entry = trackedDeltas.find((d) => d.path === requestedPath);
     if (entry) {
         if (entry.binary)
             return { patch: null, patchOmitted: false, binary: true };
-        // A rename must diff BOTH endpoints so `-M` pairs them into one chunk;
-        // diffing only the new path would report it as an addition.
+        // A rename must diff BOTH endpoints so -M pairs them into one chunk.
         const pathspecs = entry.oldPath ? [entry.oldPath, entry.path] : [entry.path];
-        let raw;
         try {
-            raw = await runGit(cwd, [
+            const raw = await runGit(r.cwd, [
                 "diff",
-                base,
+                baseRef,
                 "-M",
                 "--no-ext-diff",
                 "--no-textconv",
@@ -706,73 +594,175 @@ export const getGitDiffFilePatch = async (cwd, requestedPath, options = WORKING_
                 "--",
                 ...pathspecs,
             ]);
+            const chunk = pickPatchChunk(splitPatchByFile(raw), entry.path);
+            if (chunk === null)
+                return empty;
+            if (chunk.length > GIT_MAX_PATCH_BYTES_PER_FILE) {
+                return { patch: null, patchOmitted: true, binary: false };
+            }
+            return { patch: chunk, patchOmitted: false, binary: false };
         }
         catch {
-            // Timed out or exceeded maxBuffer on a single pathological file.
             return { patch: null, patchOmitted: true, binary: false };
         }
-        const chunk = pickPatchChunk(splitPatchByFile(raw), entry.path);
-        if (chunk === null)
+    }
+    // Not tracked — check if it's an untracked file
+    const absolutePath = path.join(cwd, requestedPath);
+    try {
+        const stat = fs.statSync(absolutePath);
+        if (!stat.isFile())
             return empty;
-        if (chunk.length > GIT_MAX_PATCH_BYTES_PER_FILE) {
+        const bytesToRead = Math.min(stat.size, GIT_MAX_UNTRACKED_FILE_BYTES);
+        const buffer = Buffer.alloc(bytesToRead);
+        const handle = fs.openSync(absolutePath, "r");
+        fs.readSync(handle, buffer, 0, bytesToRead, 0);
+        fs.closeSync(handle);
+        const sniffEnd = Math.min(buffer.length, GIT_BINARY_SNIFF_BYTES);
+        if (buffer.subarray(0, sniffEnd).includes(0)) {
+            return { patch: null, patchOmitted: false, binary: true };
+        }
+        const truncated = stat.size > GIT_MAX_UNTRACKED_FILE_BYTES;
+        const content = truncated ? null : buffer.toString("utf8");
+        const patch = truncated || content === null ? null : buildUntrackedPatch(content);
+        if (patch !== null && patch.length > GIT_MAX_PATCH_BYTES_PER_FILE) {
             return { patch: null, patchOmitted: true, binary: false };
         }
-        return { patch: chunk, patchOmitted: false, binary: false };
-    }
-    // Not tracked: it may be an untracked file (synthesize a patch like getGitDiff
-    // does), otherwise it was committed/reverted since the file list was fetched.
-    let untrackedPaths = [];
-    try {
-        untrackedPaths = await listUntrackedPaths(cwd);
+        return { patch, patchOmitted: truncated, binary: false };
     }
     catch {
         return empty;
     }
-    if (!untrackedPaths.includes(requestedPath))
-        return empty;
-    const file = await buildUntrackedDiffFile(cwd, requestedPath);
-    if (!file)
-        return empty;
-    if (file.patch !== null && file.patch.length > GIT_MAX_PATCH_BYTES_PER_FILE) {
-        return { patch: null, patchOmitted: true, binary: file.binary };
+};
+const normalizePrState = (raw) => raw === "MERGED" ? "merged" : raw === "CLOSED" ? "closed" : "open";
+const parsePrList = (stdout) => {
+    if (!stdout)
+        return [];
+    try {
+        const parsed = JSON.parse(stdout);
+        if (!Array.isArray(parsed))
+            return [];
+        const prs = [];
+        for (const item of parsed) {
+            if (typeof item?.number !== "number" || !item.baseRefName)
+                continue;
+            prs.push({
+                number: item.number,
+                title: typeof item.title === "string" ? item.title : "",
+                baseRefName: item.baseRefName,
+                url: typeof item.url === "string" && item.url.length > 0 ? item.url : null,
+                state: normalizePrState(item.state),
+                headOwner: typeof item.headRepositoryOwner?.login === "string"
+                    ? item.headRepositoryOwner.login
+                    : null,
+            });
+        }
+        return prs;
+    }
+    catch {
+        return [];
     }
-    return { patch: file.patch, patchOmitted: file.patchOmitted, binary: file.binary };
 };
-// Candidate base branches for the picker: local heads + remote-tracking
-// branches, newest-committed-first so the most relevant refs surface at the top.
-// The synthetic `*/HEAD` symref entries are dropped (they're aliases, not
-// branches). Bounded by GIT_MAX_BRANCHES.
-const listBranches = async (cwd) => {
+const PR_LIST_FIELDS = "number,title,baseRefName,url,state,headRepositoryOwner";
+const parseGithubRemotes = (r) => {
+    const seen = new Set();
+    const remotes = [];
     try {
-        const stdout = await runGit(cwd, [
-            "for-each-ref",
-            "--sort=-committerdate",
-            "--format=%(refname:short)",
-            "refs/heads",
-            "refs/remotes",
-        ]);
-        const seen = new Set();
-        const branches = [];
-        for (const line of stdout.split("\n")) {
-            const ref = line.trim();
-            if (!ref || ref.endsWith("/HEAD") || seen.has(ref))
+        for (const remoteName of r.repo.remoteNames()) {
+            try {
+                const remote = r.repo.getRemote(remoteName);
+                const url = remote.url();
+                const match = /github\.com[/:]([^\s/]+)\/([^\s]+?)(?:\.git)?$/i.exec(url);
+                if (!match)
+                    continue;
+                const [, owner, repoName] = match;
+                const slug = `${owner}/${repoName}`;
+                const key = `${remoteName} ${slug}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                remotes.push({ name: remoteName, slug, owner });
+            }
+            catch {
                 continue;
-            seen.add(ref);
-            branches.push(ref);
-            if (branches.length >= GIT_MAX_BRANCHES)
-                break;
+            }
         }
-        return branches;
     }
     catch {
+        // No remotes
+    }
+    return remotes;
+};
+const detectPr = async (cwd, r) => {
+    const currentBranch = getCurrentBranch(r);
+    if (!currentBranch)
+        return null;
+    const remotes = parseGithubRemotes(r);
+    if (remotes.length === 0)
+        return null;
+    const ownRemote = remotes.find((remote) => remote.name === "origin") ?? remotes[0];
+    const ownOwner = ownRemote.owner.toLowerCase();
+    const slugs = [...new Set(remotes.map((remote) => remote.slug))];
+    const results = await Promise.all(slugs.map((slug) => runGh(cwd, [
+        "pr",
+        "list",
+        "--repo",
+        slug,
+        "--head",
+        currentBranch,
+        "--state",
+        "all",
+        "--json",
+        PR_LIST_FIELDS,
+        "--limit",
+        "30",
+    ]).then(parsePrList)));
+    const seen = new Set();
+    let fallback = null;
+    for (const prs of results) {
+        for (const pr of prs) {
+            if (!pr.headOwner || pr.headOwner.toLowerCase() !== ownOwner)
+                continue;
+            const key = pr.url ?? `#${pr.number}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            if (pr.state === "open") {
+                return {
+                    number: pr.number,
+                    title: pr.title,
+                    baseRefName: pr.baseRefName,
+                    url: pr.url,
+                    state: pr.state,
+                };
+            }
+            fallback ??= pr;
+        }
+    }
+    return fallback
+        ? {
+            number: fallback.number,
+            title: fallback.title,
+            baseRefName: fallback.baseRefName,
+            url: fallback.url,
+            state: fallback.state,
+        }
+        : null;
+};
+export const listGithubRemoteSlugs = async (cwd) => {
+    const r = await openRepo(cwd);
+    if (!r)
         return [];
+    const remotes = parseGithubRemotes(r);
+    const slugs = [];
+    for (const remote of remotes) {
+        if (!slugs.includes(remote.slug))
+            slugs.push(remote.slug);
     }
+    return slugs;
 };
-// Everything the base-branch picker needs, gathered in one request so the client
-// never polls: the candidate refs, a preselected default (with provenance), the
-// current branch, and the PR the branch maps to (via gh, best-effort).
 export const getGitBranchInfo = async (cwd) => {
-    if (!(await isGitRepo(cwd))) {
+    const r = await openRepo(cwd);
+    if (!r) {
         return {
             isRepo: false,
             currentBranch: null,
@@ -782,18 +772,36 @@ export const getGitBranchInfo = async (cwd) => {
             pr: null,
         };
     }
-    const [currentBranch, branches, pr] = await Promise.all([
-        getCurrentBranch(cwd),
-        listBranches(cwd),
-        detectPr(cwd),
-    ]);
-    const defaultBase = await resolveDefaultBase(cwd, currentBranch);
+    const currentBranch = getCurrentBranch(r);
+    const pr = await detectPr(cwd, r);
+    const defaultBase = resolveDefaultBase(r);
+    const branchEntries = collectIterator(r.repo.branches());
+    const branchData = [];
+    for (const b of branchEntries) {
+        if (b.name.endsWith("/HEAD"))
+            continue;
+        try {
+            const refName = b.type === "Remote" ? `refs/remotes/${b.name}` : `refs/heads/${b.name}`;
+            const ref = r.repo.getReference(refName);
+            const target = ref.target();
+            if (!target)
+                continue;
+            const commit = r.repo.getCommit(target);
+            branchData.push({ name: b.name, time: commit.time().getTime() });
+        }
+        catch {
+            branchData.push({ name: b.name, time: 0 });
+        }
+        if (branchData.length >= GIT_MAX_BRANCHES)
+            break;
+    }
+    branchData.sort((a, b) => b.time - a.time);
     return {
         isRepo: true,
         currentBranch,
         defaultBase: defaultBase?.ref ?? null,
         defaultBaseSource: defaultBase?.source ?? null,
-        branches,
+        branches: branchData.map((b) => b.name),
         pr,
     };
 };