@monotykamary/localterm-server 2.0.4 → 2.1.0

package/dist/git-diff.js

@@ -2,12 +2,10 @@ import fs from "node:fs";
 import fsPromises from "node:fs/promises";
 import path from "node:path";
 import { Octokit } from "@octokit/rest";
-import { openRepository } from "es-git";
-import { computePatchFromContents } from "./utils/compute-patch.js";
-import { memoBy } from "./utils/memo-by.js";
-import { reconcileFileStats } from "./utils/reconcile-file-stats.js";
+import { runGit } from "./utils/run-git.js";
 import { resolveGithubToken } from "./utils/resolve-github-token.js";
-import { GIT_BINARY_SNIFF_BYTES, GIT_MAX_BRANCHES, GIT_MAX_PATCH_BYTES_PER_FILE, GIT_MAX_TOTAL_PATCH_BYTES, GIT_MAX_UNTRACKED_FILE_BYTES, GIT_MAX_UNTRACKED_FILES, } from "./constants.js";
+import { memoBy } from "./utils/memo-by.js";
+import { GIT_BINARY_SNIFF_BYTES, GIT_CACHE_TTL_MS, GIT_EMPTY_TREE_HASH, GIT_MAX_BRANCHES, 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,
@@ -17,130 +15,103 @@ const EMPTY_SUMMARY = {
     binaries: 0,
     branch: null,
 };
-const GIT_EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
-const ZERO_OID = "0000000000000000000000000000000000000000";
-const collectIterator = (iterable) => {
-    const result = [];
-    for (const item of iterable)
-        result.push(item);
-    return result;
-};
-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";
-    }
-};
-const openRepo = async (cwd) => {
-    try {
-        const repo = await openRepository(cwd);
-        return { cwd, repo };
-    }
-    catch {
+// Nested so a cwd can hold more than one comparison (the working-tree summary
+// is pushed on git-dirty while the viewer may be open in branch mode).
+const diffCacheByCwd = new Map();
+const comparisonKey = (mode, base) => `${mode}:${base ?? ""}`;
+const readDiffCache = (cwd, mode, base) => {
+    const byComparison = diffCacheByCwd.get(cwd);
+    if (!byComparison)
+        return null;
+    const entry = byComparison.get(comparisonKey(mode, base));
+    if (!entry)
+        return null;
+    if (Date.now() - entry.builtAt > GIT_CACHE_TTL_MS) {
+        byComparison.delete(comparisonKey(mode, base));
+        if (byComparison.size === 0)
+            diffCacheByCwd.delete(cwd);
         return null;
     }
+    return entry;
 };
-const getCurrentBranch = (r) => {
-    try {
-        const head = r.repo.head();
-        const shorthand = head.shorthand();
-        return shorthand && shorthand !== "HEAD" ? shorthand : null;
+const writeDiffCache = (cwd, mode, base, cache) => {
+    let byComparison = diffCacheByCwd.get(cwd);
+    if (!byComparison) {
+        byComparison = new Map();
+        diffCacheByCwd.set(cwd, byComparison);
     }
-    catch {
+    byComparison.set(comparisonKey(mode, base), cache);
+};
+export const invalidateGitDiffCache = (cwd) => {
+    diffCacheByCwd.delete(cwd);
+};
+const runGitText = async (cwd, args) => {
+    const result = await runGit(cwd, args);
+    return result.stdout.toString("utf8");
+};
+// `git diff` flags shared by every diff invocation so numstat, name-status and
+// patch all walk the same diff queue (same rename detection, same file order).
+const DIFF_RENAME_FLAG = "--find-renames";
+const isGitRepo = async (cwd) => {
+    const result = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    return result.exitCode === 0;
+};
+const getCurrentBranch = async (cwd) => {
+    const result = await runGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (result.exitCode !== 0)
         return null;
-    }
+    const name = result.stdout.toString("utf8").trim();
+    return name === "HEAD" ? null : name;
 };
-const resolveDiffBaseRef = (r) => {
-    try {
-        r.repo.head();
-        return "HEAD";
-    }
-    catch {
-        return GIT_EMPTY_TREE_HASH;
-    }
+// working mode compares against HEAD (or the empty tree when the branch is
+// unborn). branch mode compares against the merge-base of HEAD and the base
+// ref, so only changes since the branches diverged are shown.
+const resolveDiffBaseRef = async (cwd) => {
+    const result = await runGit(cwd, ["rev-parse", "--verify", "-q", "HEAD"]);
+    return result.exitCode === 0 ? "HEAD" : GIT_EMPTY_TREE_HASH;
 };
-const resolveDefaultBase = (r) => {
-    const currentBranch = getCurrentBranch(r);
-    try {
-        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
-                }
+const verifyRef = async (cwd, ref) => {
+    const result = await runGit(cwd, ["rev-parse", "--verify", "-q", ref]);
+    return result.exitCode === 0;
+};
+const resolveDefaultBase = async (cwd) => {
+    const currentBranch = await getCurrentBranch(cwd);
+    const symbolic = await runGit(cwd, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"]);
+    if (symbolic.exitCode === 0) {
+        const target = symbolic.stdout.toString("utf8").trim();
+        if (target.startsWith("refs/remotes/")) {
+            const shortName = target.slice("refs/remotes/".length);
+            if (shortName !== currentBranch && (await verifyRef(cwd, shortName))) {
+                return { ref: shortName, source: "remoteHead" };
             }
         }
     }
-    catch {
-        // No origin/HEAD configured
-    }
     for (const name of ["main", "master", "develop"]) {
         if (name === currentBranch)
             continue;
         for (const candidate of [`origin/${name}`, name]) {
-            try {
-                r.repo.revparseSingle(candidate);
+            if (await verifyRef(cwd, candidate))
                 return { ref: candidate, source: "fallback" };
-            }
-            catch {
-                continue;
-            }
         }
     }
     return null;
 };
-const resolveEffectiveBaseRef = (r, options) => {
+const resolveEffectiveBaseRef = async (cwd, options) => {
     if (options.mode !== "branch")
-        return resolveDiffBaseRef(r);
+        return resolveDiffBaseRef(cwd);
     let baseRef = options.base?.trim() || null;
-    if (baseRef) {
-        try {
-            r.repo.revparseSingle(baseRef);
-        }
-        catch {
-            baseRef = null;
-        }
-    }
-    if (!baseRef) {
-        const resolved = resolveDefaultBase(r);
-        baseRef = resolved?.ref ?? null;
-    }
+    if (baseRef && !(await verifyRef(cwd, baseRef)))
+        baseRef = null;
+    if (!baseRef)
+        baseRef = (await resolveDefaultBase(cwd))?.ref ?? null;
     if (!baseRef)
         return null;
-    try {
-        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
-    }
-    try {
-        return r.repo.revparseSingle(baseRef);
-    }
-    catch {
+    const mergeBase = await runGit(cwd, ["merge-base", baseRef, "HEAD"]);
+    if (mergeBase.exitCode === 0)
+        return mergeBase.stdout.toString("utf8").trim();
+    if (!(await verifyRef(cwd, baseRef)))
         return null;
-    }
+    return runGitText(cwd, ["rev-parse", "--verify", baseRef]);
 };
 const countLines = (text) => {
     if (text.length === 0)
@@ -154,42 +125,45 @@ const countLines = (text) => {
         count += 1;
     return count;
 };
-const collectUntrackedFiles = async (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);
+const readUntrackedFile = async (cwd, filePath) => {
+    const absolutePath = path.join(cwd, filePath);
+    try {
+        const stat = await fsPromises.stat(absolutePath);
+        if (!stat.isFile())
+            return null;
+        const bytesToRead = Math.min(stat.size, GIT_MAX_UNTRACKED_FILE_BYTES);
+        const buffer = Buffer.alloc(bytesToRead);
+        const handle = await fsPromises.open(absolutePath, "r");
         try {
-            const stat = await fsPromises.stat(absolutePath);
-            if (!stat.isFile())
-                continue;
-            const bytesToRead = Math.min(stat.size, GIT_MAX_UNTRACKED_FILE_BYTES);
-            const buffer = Buffer.alloc(bytesToRead);
-            const handle = await fsPromises.open(absolutePath, "r");
-            try {
-                const { buffer: readBuffer } = await handle.read(buffer, 0, bytesToRead, 0);
-                const sniffEnd = Math.min(readBuffer.length, GIT_BINARY_SNIFF_BYTES);
-                const binary = readBuffer.subarray(0, sniffEnd).includes(0);
-                const truncated = stat.size > GIT_MAX_UNTRACKED_FILE_BYTES;
-                const content = binary ? null : truncated ? null : readBuffer.toString("utf8");
-                const lines = binary ? 0 : content ? countLines(content) : 0;
-                files.push({ path: filePath, binary, lines, content, truncated });
-            }
-            finally {
-                await handle.close();
-            }
+            const { buffer: readBuffer } = await handle.read(buffer, 0, bytesToRead, 0);
+            const sniffEnd = Math.min(readBuffer.length, GIT_BINARY_SNIFF_BYTES);
+            const binary = readBuffer.subarray(0, sniffEnd).includes(0);
+            const truncated = stat.size > GIT_MAX_UNTRACKED_FILE_BYTES;
+            const content = binary ? null : truncated ? null : readBuffer.toString("utf8");
+            const lines = binary ? 0 : content ? countLines(content) : 0;
+            return { path: filePath, binary, lines, content, truncated };
         }
-        catch {
-            continue;
+        finally {
+            await handle.close();
         }
     }
+    catch {
+        return null;
+    }
+};
+const collectUntrackedFiles = async (cwd) => {
+    const result = await runGit(cwd, ["ls-files", "--others", "--exclude-standard", "-z"]);
+    if (result.exitCode !== 0)
+        return [];
+    const paths = result.stdout.toString("utf8").split("\0").filter(Boolean);
+    const files = [];
+    for (const filePath of paths) {
+        if (files.length >= GIT_MAX_UNTRACKED_FILES)
+            break;
+        const file = await readUntrackedFile(cwd, filePath);
+        if (file)
+            files.push(file);
+    }
     return files;
 };
 export const buildUntrackedPatch = (content) => {
@@ -203,161 +177,7 @@ export const buildUntrackedPatch = (content) => {
     const noNewlineMarker = hasTrailingNewline ? "" : "\n\";
     return `@@ -0,0 +1,${lines.length} @@\n${body}${noNewlineMarker}\n`;
 };
-const readBlobContent = (r, oid) => {
-    if (oid === ZERO_OID)
-        return null;
-    try {
-        const obj = r.repo.findObject(oid);
-        if (!obj)
-            return null;
-        const blob = obj.peelToBlob();
-        return Buffer.from(blob.content()).toString("utf8");
-    }
-    catch {
-        return null;
-    }
-};
-const readWorkingTreeFile = (r, filePath, maxBytes = GIT_MAX_UNTRACKED_FILE_BYTES) => {
-    const absolutePath = path.join(r.cwd, filePath);
-    try {
-        const stat = fs.statSync(absolutePath);
-        if (!stat.isFile())
-            return null;
-        const bytesToRead = Math.min(stat.size, maxBytes);
-        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 null;
-        if (stat.size > maxBytes)
-            return null;
-        return buffer.toString("utf8");
-    }
-    catch {
-        return null;
-    }
-};
-const collectDeltaMeta = (r, diff, isWorkingTree) => {
-    const stats = diff.stats();
-    const totalInsertions = Number(stats.insertions);
-    const totalDeletions = Number(stats.deletions);
-    const deltas = collectIterator(diff.deltas());
-    const result = [];
-    for (const delta of deltas) {
-        const status = deltaTypeToStatus(delta.status());
-        if (status === "untracked")
-            continue;
-        const newFile = delta.newFile();
-        const oldFile = delta.oldFile();
-        const isBinary = newFile.isBinary();
-        result.push({
-            path: newFile.path(),
-            oldPath: status === "renamed" ? oldFile.path() : null,
-            status,
-            additions: 0,
-            deletions: 0,
-            binary: isBinary,
-            oldId: oldFile.id(),
-            newId: newFile.id(),
-            isWorkingTree,
-        });
-    }
-    // Compute per-file additions/deletions from patch text.
-    // es-git's DiffStats only gives aggregate totals; we generate
-    // patches per-delta and count +/- lines from the structured diff.
-    const nonBinary = result.filter((d) => !d.binary);
-    if (nonBinary.length === 0)
-        return result;
-    if (nonBinary.length === 1) {
-        nonBinary[0].additions = totalInsertions;
-        nonBinary[0].deletions = totalDeletions;
-        return result;
-    }
-    // Compute per-file stats from patch text. Each delta gets its own
-    // patch generated from old vs new content, giving exact counts.
-    for (const d of result) {
-        if (d.binary)
-            continue;
-        try {
-            const oldContent = d.oldId === ZERO_OID || d.oldId === ""
-                ? d.status === "added"
-                    ? null
-                    : readBlobContent(r, d.oldId)
-                : readBlobContent(r, d.oldId);
-            const newContent = d.isWorkingTree
-                ? readWorkingTreeFile(r, d.path, GIT_MAX_TOTAL_PATCH_BYTES)
-                : d.newId === ZERO_OID || d.newId === ""
-                    ? d.status === "deleted"
-                        ? null
-                        : readBlobContent(r, d.newId)
-                    : readBlobContent(r, d.newId);
-            const aPath = d.oldPath ?? d.path;
-            const patchResult = computePatchFromContents(oldContent, newContent, aPath, d.path, null, null, d.oldId === ZERO_OID ? null : d.oldId, d.newId === ZERO_OID ? null : d.newId, d.status === "renamed");
-            d.additions = patchResult.additions;
-            d.deletions = patchResult.deletions;
-        }
-        catch {
-            // Fallback: proportional split of aggregate totals
-            const perFileAdd = Math.floor(totalInsertions / nonBinary.length);
-            d.additions = perFileAdd;
-            d.deletions = Math.floor(totalDeletions / nonBinary.length);
-        }
-    }
-    // Verify totals match and redistribute remainder if needed
-    reconcileFileStats(result, totalInsertions, totalDeletions);
-    return result;
-};
-const buildBaseTree = (r, baseRef) => {
-    try {
-        return r.repo.getTree(baseRef);
-    }
-    catch {
-        try {
-            const baseOid = r.repo.revparseSingle(baseRef);
-            const obj = r.repo.findObject(baseOid);
-            if (!obj)
-                return null;
-            if (obj.type() === "Tree") {
-                return obj;
-            }
-            const commit = r.repo.getCommit(baseOid);
-            return commit.tree();
-        }
-        catch {
-            return null;
-        }
-    }
-};
 export const splitPatchByFile = (raw) => raw.split(/^(?=diff --git )/m).filter((chunk) => chunk.startsWith("diff --git "));
-const computeTrackedDeltas = async (r, baseRef) => {
-    const baseTree = buildBaseTree(r, baseRef);
-    if (!baseTree)
-        return [];
-    let diff;
-    try {
-        diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
-    }
-    catch {
-        return [];
-    }
-    try {
-        diff.findSimilar({ renames: true });
-    }
-    catch {
-        // Rename detection failed
-    }
-    const deltaMeta = collectDeltaMeta(r, diff, true);
-    return deltaMeta.map((d) => ({
-        path: d.path,
-        oldPath: d.oldPath,
-        status: d.status,
-        additions: d.additions,
-        deletions: d.deletions,
-        binary: d.binary,
-    }));
-};
 export const parseNumstatZ = (raw) => {
     const tokens = raw.split("\0");
     const entries = [];
@@ -413,242 +233,236 @@ export const parseNameStatusZ = (raw) => {
     }
     return statuses;
 };
-export const getGitDiffSummary = async (cwd, options = WORKING_OPTIONS) => {
-    const r = await openRepo(cwd);
-    if (!r)
-        return EMPTY_SUMMARY;
-    try {
-        const baseRef = resolveEffectiveBaseRef(r, options);
-        if (baseRef === null)
-            return { ...EMPTY_SUMMARY, isRepo: true };
-        const branch = getCurrentBranch(r);
-        const baseTree = buildBaseTree(r, baseRef);
-        if (!baseTree)
-            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;
-        let fileCount = Number(stats.filesChanged);
-        const diffDeltas = collectIterator(diff.deltas());
-        for (const delta of diffDeltas) {
-            if (deltaTypeToStatus(delta.status()) !== "untracked" && delta.newFile().isBinary()) {
-                binaries++;
-            }
-        }
-        const untracked = await 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 {
-        return { ...EMPTY_SUMMARY, isRepo: true };
-    }
-};
-const buildFilePatch = (r, delta) => {
-    if (delta.binary)
+// One full diff pass for `(cwd)` against `baseRef`. Three parallel `git diff`
+// invocations (numstat for counts+binary, name-status for the status letter +
+// rename old path, patch for the body) walk the same sorted diff queue, so
+// numstat[i]/name-status.key(patch-path)/patch[i] all describe the same file
+// positionally. Untracked files are folded in from `ls-files` with synthesized
+// patches (git's own diff never lists untracked files).
+const buildDiffCache = async (cwd, baseRef) => {
+    const [numstatRes, nameStatusRes, patchRes] = await Promise.all([
+        runGit(cwd, ["diff", DIFF_RENAME_FLAG, "--numstat", "-z", baseRef]),
+        runGit(cwd, ["diff", DIFF_RENAME_FLAG, "--name-status", "-z", baseRef]),
+        runGit(cwd, ["diff", DIFF_RENAME_FLAG, "--patch", baseRef]),
+    ]);
+    if (numstatRes.exitCode !== 0 || patchRes.exitCode !== 0)
         return null;
-    const oldContent = delta.status === "added"
-        ? null
-        : delta.isWorkingTree
-            ? readBlobContent(r, delta.oldId)
-            : readBlobContent(r, delta.oldId);
-    const newContent = delta.status === "deleted"
-        ? null
-        : delta.isWorkingTree
-            ? readWorkingTreeFile(r, delta.path, GIT_MAX_TOTAL_PATCH_BYTES)
-            : delta.newId === ZERO_OID
-                ? readWorkingTreeFile(r, delta.path, GIT_MAX_TOTAL_PATCH_BYTES)
-                : readBlobContent(r, delta.newId);
-    const aPath = delta.oldPath ?? delta.path;
-    const result = computePatchFromContents(oldContent, newContent, aPath, delta.path, null, null, delta.oldId === ZERO_OID ? null : delta.oldId, delta.newId === ZERO_OID ? null : delta.newId, delta.status === "renamed");
-    return result.patchText || null;
-};
-export const getGitDiff = async (cwd, options = WORKING_OPTIONS) => {
-    const r = await openRepo(cwd);
-    if (!r)
-        return { isRepo: false, files: [] };
-    const baseRef = resolveEffectiveBaseRef(r, options);
-    if (baseRef === null)
-        return { isRepo: true, files: [] };
-    const baseTree = buildBaseTree(r, baseRef);
-    if (!baseTree)
-        return { isRepo: true, files: [] };
-    let diff;
-    try {
-        diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
-    }
-    catch {
-        return { isRepo: true, files: [] };
-    }
-    try {
-        diff.findSimilar({ renames: true });
-    }
-    catch {
-        // Rename detection failed
-    }
-    const deltaMeta = collectDeltaMeta(r, diff, true);
+    const numstat = parseNumstatZ(numstatRes.stdout.toString("utf8"));
+    const statuses = parseNameStatusZ(nameStatusRes.stdout.toString("utf8"));
+    const patches = splitPatchByFile(patchRes.stdout.toString("utf8"));
+    // numstat and --patch share the diff queue's order; if they ever disagree
+    // (a git version quirk on some edge diff) we can't trust positional pairing,
+    // so degrade: stats stay correct, patches read as omitted.
+    const patchesAligned = patches.length === numstat.length;
+    const untracked = await collectUntrackedFiles(cwd);
+    const fileMeta = [];
+    const filePatchByPath = new Map();
+    const fileBinaryByPath = new Map();
+    const filePatchOmittedByPath = new Map();
     let totalPatchBytes = 0;
-    const files = deltaMeta.map((entry) => {
-        let patch = null;
+    let additions = 0;
+    let deletions = 0;
+    let binaries = 0;
+    for (let index = 0; index < numstat.length; index += 1) {
+        const entry = numstat[index];
+        const status = statuses.get(entry.path) ?? "modified";
+        const oldPath = status === "renamed" ? entry.oldPath : null;
+        let patchText = null;
         let patchOmitted = false;
         if (entry.binary) {
-            patch = null;
+            binaries += 1;
         }
         else {
-            try {
-                patch = buildFilePatch(r, entry);
-            }
-            catch {
+            const rawPatch = patchesAligned ? (patches[index] ?? null) : null;
+            if (rawPatch === null ||
+                rawPatch.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
+                totalPatchBytes + rawPatch.length > GIT_MAX_TOTAL_PATCH_BYTES) {
                 patchOmitted = true;
             }
-            if (patch !== null) {
-                if (patch.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
-                    totalPatchBytes + patch.length > GIT_MAX_TOTAL_PATCH_BYTES) {
-                    patch = null;
-                    patchOmitted = true;
-                }
-                else {
-                    totalPatchBytes += patch.length;
-                }
-            }
-            else if (!patchOmitted) {
-                patchOmitted = true;
+            else {
+                patchText = rawPatch;
+                totalPatchBytes += rawPatch.length;
             }
+            additions += entry.additions;
+            deletions += entry.deletions;
         }
-        return {
+        fileMeta.push({
             path: entry.path,
-            oldPath: entry.oldPath,
-            status: entry.status,
+            oldPath,
+            status,
             additions: entry.additions,
             deletions: entry.deletions,
             binary: entry.binary,
-            patch,
-            patchOmitted,
-        };
-    });
-    const untracked = await collectUntrackedFiles(r);
+        });
+        filePatchByPath.set(entry.path, patchText);
+        fileBinaryByPath.set(entry.path, entry.binary);
+        filePatchOmittedByPath.set(entry.path, patchOmitted);
+    }
     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;
+        let patchOmitted = file.truncated;
+        if (patch !== null) {
+            if (patch.length > GIT_MAX_PATCH_BYTES_PER_FILE ||
+                totalPatchBytes + patch.length > GIT_MAX_TOTAL_PATCH_BYTES) {
+                patchOmitted = true;
             }
             else {
-                totalPatchBytes += entry.patch.length;
+                totalPatchBytes += patch.length;
             }
         }
-        files.push(entry);
-    }
-    return { isRepo: true, files };
-};
-export const getGitDiffFiles = async (cwd, options = WORKING_OPTIONS) => {
-    const r = await openRepo(cwd);
-    if (!r)
-        return { isRepo: false, files: [] };
-    const baseRef = resolveEffectiveBaseRef(r, options);
-    if (baseRef === null)
-        return { isRepo: true, files: [] };
-    const trackedDeltas = await computeTrackedDeltas(r, baseRef);
-    const files = trackedDeltas.map((entry) => ({
-        path: entry.path,
-        oldPath: entry.oldPath,
-        status: entry.status,
-        additions: entry.additions,
-        deletions: entry.deletions,
-        binary: entry.binary,
-    }));
-    const untracked = await collectUntrackedFiles(r);
-    for (const file of untracked) {
-        files.push({
+        const fileAdditions = file.binary ? 0 : file.lines;
+        if (file.binary)
+            binaries += 1;
+        additions += fileAdditions;
+        fileMeta.push({
             path: file.path,
             oldPath: null,
             status: "untracked",
-            additions: file.binary ? 0 : file.lines,
+            additions: fileAdditions,
             deletions: 0,
             binary: file.binary,
         });
+        filePatchByPath.set(file.path, patchOmitted ? null : patch);
+        fileBinaryByPath.set(file.path, file.binary);
+        filePatchOmittedByPath.set(file.path, patchOmitted);
     }
-    return { isRepo: true, files };
+    const summary = {
+        isRepo: true,
+        files: fileMeta.length,
+        additions,
+        deletions,
+        binaries,
+        branch: await getCurrentBranch(cwd),
+    };
+    return {
+        summary,
+        fileMeta,
+        filePatchByPath,
+        fileBinaryByPath,
+        filePatchOmittedByPath,
+        builtAt: Date.now(),
+    };
 };
-export const getGitDiffFilePatch = async (cwd, requestedPath, options = WORKING_OPTIONS) => {
-    const empty = { patch: null, patchOmitted: false, binary: false };
-    const r = await openRepo(cwd);
-    if (!r)
-        return empty;
-    const baseRef = resolveEffectiveBaseRef(r, options);
+const ensureDiffCache = async (cwd, options) => {
+    // Read the cache before resolving the base ref — that resolution does git work
+    // (rev-parse + merge-base) on every call, so for the per-file patch endpoint
+    // (where the cache is warm on nearly every request) checking first keeps it a
+    // pure map lookup with no subprocess.
+    const cached = readDiffCache(cwd, options.mode, options.base ?? null);
+    if (cached)
+        return cached;
+    const baseRef = await resolveEffectiveBaseRef(cwd, options);
     if (baseRef === null)
-        return empty;
-    const baseTree = buildBaseTree(r, baseRef);
-    if (!baseTree)
-        return empty;
-    let diff;
+        return null;
+    const cache = await buildDiffCache(cwd, baseRef);
+    if (cache)
+        writeDiffCache(cwd, options.mode, options.base ?? null, cache);
+    return cache;
+};
+export const getGitDiffSummary = async (cwd, options = WORKING_OPTIONS) => {
+    const cached = readDiffCache(cwd, options.mode, options.base ?? null);
+    if (cached)
+        return cached.summary;
+    if (!(await isGitRepo(cwd)))
+        return EMPTY_SUMMARY;
     try {
-        diff = r.repo.diffTreeToWorkdirWithIndex(baseTree);
+        const baseRef = await resolveEffectiveBaseRef(cwd, options);
+        if (baseRef === null)
+            return { ...EMPTY_SUMMARY, isRepo: true };
+        const branch = await getCurrentBranch(cwd);
+        // Summary is pushed on every git-dirty signal, so it stays on the cheap
+        // numstat-only path (no patch) unless a cache is already warm.
+        const numstatRes = await runGit(cwd, ["diff", DIFF_RENAME_FLAG, "--numstat", "-z", baseRef]);
+        if (numstatRes.exitCode !== 0)
+            return { ...EMPTY_SUMMARY, isRepo: true };
+        let additions = 0;
+        let deletions = 0;
+        let binaries = 0;
+        let fileCount = 0;
+        for (const entry of parseNumstatZ(numstatRes.stdout.toString("utf8"))) {
+            fileCount += 1;
+            if (entry.binary) {
+                binaries += 1;
+                continue;
+            }
+            additions += entry.additions;
+            deletions += entry.deletions;
+        }
+        const untracked = await collectUntrackedFiles(cwd);
+        for (const file of untracked) {
+            fileCount += 1;
+            if (file.binary) {
+                binaries += 1;
+            }
+            else {
+                additions += file.lines;
+            }
+        }
+        return { isRepo: true, files: fileCount, additions, deletions, binaries, branch };
     }
     catch {
-        return empty;
-    }
-    try {
-        diff.findSimilar({ renames: true });
+        return { ...EMPTY_SUMMARY, isRepo: true };
     }
-    catch {
-        // Rename detection failed
+};
+export const getGitDiff = async (cwd, options = WORKING_OPTIONS) => {
+    const cached = readDiffCache(cwd, options.mode, options.base ?? null);
+    if (cached) {
+        return { isRepo: true, files: mapCacheFiles(cached) };
     }
-    const deltaMeta = collectDeltaMeta(r, diff, true);
-    const entry = deltaMeta.find((d) => d.path === requestedPath);
-    if (entry) {
-        if (entry.binary)
-            return { patch: null, patchOmitted: false, binary: true };
-        try {
-            const patch = buildFilePatch(r, entry);
-            if (patch === null)
-                return empty;
-            if (patch.length > GIT_MAX_PATCH_BYTES_PER_FILE) {
-                return { patch: null, patchOmitted: true, binary: false };
-            }
-            return { patch, patchOmitted: false, binary: false };
-        }
-        catch {
-            return { patch: null, patchOmitted: true, binary: false };
-        }
+    if (!(await isGitRepo(cwd)))
+        return { isRepo: false, files: [] };
+    const cache = await ensureDiffCache(cwd, options);
+    if (!cache)
+        return { isRepo: true, files: [] };
+    return { isRepo: true, files: mapCacheFiles(cache) };
+};
+const mapCacheFiles = (cache) => cache.fileMeta.map((meta) => ({
+    path: meta.path,
+    oldPath: meta.oldPath,
+    status: meta.status,
+    additions: meta.additions,
+    deletions: meta.deletions,
+    binary: meta.binary,
+    patch: cache.filePatchByPath.get(meta.path) ?? null,
+    patchOmitted: cache.filePatchOmittedByPath.get(meta.path) ?? false,
+}));
+export const getGitDiffFiles = async (cwd, options = WORKING_OPTIONS) => {
+    const cached = readDiffCache(cwd, options.mode, options.base ?? null);
+    if (cached)
+        return { isRepo: true, files: cached.fileMeta };
+    if (!(await isGitRepo(cwd)))
+        return { isRepo: false, files: [] };
+    const cache = await ensureDiffCache(cwd, options);
+    if (!cache)
+        return { isRepo: true, files: [] };
+    return { isRepo: true, files: cache.fileMeta };
+};
+export const getGitDiffFilePatch = async (cwd, requestedPath, options = WORKING_OPTIONS) => {
+    const empty = { patch: null, patchOmitted: false, binary: false };
+    const cache = await ensureDiffCache(cwd, options);
+    if (!cache)
+        return empty;
+    // O(1) lookup: the full diff pass that the per-file patch needs was already
+    // computed once for this (cwd, mode, base) and cached. This was the O(N²)
+    // regression — each per-file request re-ran the whole-tree diff + a jsdiff
+    // for every file. Now it's a map lookup.
+    if (cache.filePatchByPath.has(requestedPath)) {
+        return {
+            patch: cache.filePatchByPath.get(requestedPath) ?? null,
+            patchOmitted: cache.filePatchOmittedByPath.get(requestedPath) ?? false,
+            binary: cache.fileBinaryByPath.get(requestedPath) ?? false,
+        };
     }
+    // An untracked path the cache didn't cover (created between the cache build
+    // and this request) falls back to synthesizing from the working tree.
+    return getGitDiffFilePatchFromWorkingTree(cwd, requestedPath);
+};
+const getGitDiffFilePatchFromWorkingTree = async (cwd, requestedPath) => {
+    const empty = { patch: null, patchOmitted: false, binary: false };
     const absolutePath = path.join(cwd, requestedPath);
     try {
         const stat = fs.statSync(absolutePath);
@@ -715,34 +529,33 @@ let activePrFetcher = defaultPrFetcher;
 export const setPrFetcher = (fetcher) => {
     activePrFetcher = fetcher;
 };
-const parseGithubRemotes = (r) => {
+const parseGithubRemotes = async (cwd) => {
+    const result = await runGit(cwd, ["remote", "-v"]);
+    if (result.exitCode !== 0)
+        return [];
     const raw = [];
-    try {
-        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;
-                raw.push({ name: remoteName, slug: `${owner}/${repoName}`, owner });
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    catch {
-        // No remotes
+    const seen = new Set();
+    for (const line of result.stdout.toString("utf8").split("\n")) {
+        const match = /^(\S+)\t(.+?)\s+\(fetch\)$/.exec(line);
+        if (!match)
+            continue;
+        const [, name, url] = match;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        const urlMatch = /github\.com[/:]([^\s/]+)\/([^\s]+?)(?:\.git)?$/i.exec(url);
+        if (!urlMatch)
+            continue;
+        const [, owner, repoName] = urlMatch;
+        raw.push({ name, slug: `${owner}/${repoName}`, owner });
     }
     return memoBy(raw, (remote) => `${remote.name} ${remote.slug}`);
 };
-const detectPr = async (r) => {
-    const currentBranch = getCurrentBranch(r);
+const detectPr = async (cwd) => {
+    const currentBranch = await getCurrentBranch(cwd);
     if (!currentBranch)
         return null;
-    const remotes = parseGithubRemotes(r);
+    const remotes = await parseGithubRemotes(cwd);
     if (remotes.length === 0)
         return null;
     const ownRemote = remotes.find((remote) => remote.name === "origin") ?? remotes[0];
@@ -771,16 +584,32 @@ const detectPr = async (r) => {
         }
         : null;
 };
-export const listGithubRemoteSlugs = async (cwd) => {
-    const r = await openRepo(cwd);
-    if (!r)
+const listBranchesByRecency = async (cwd) => {
+    const result = await runGit(cwd, [
+        "for-each-ref",
+        "--format=%(refname:short)",
+        "--sort=-committerdate",
+        "refs/heads",
+        "refs/remotes",
+    ]);
+    if (result.exitCode !== 0)
         return [];
-    const remotes = parseGithubRemotes(r);
+    const names = [];
+    for (const name of result.stdout.toString("utf8").split("\n")) {
+        if (!name || name.endsWith("/HEAD"))
+            continue;
+        names.push(name);
+        if (names.length >= GIT_MAX_BRANCHES)
+            break;
+    }
+    return names;
+};
+export const listGithubRemoteSlugs = async (cwd) => {
+    const remotes = await parseGithubRemotes(cwd);
     return memoBy(remotes, (remote) => remote.slug).map((remote) => remote.slug);
 };
 export const getGitBranchInfo = async (cwd) => {
-    const r = await openRepo(cwd);
-    if (!r) {
+    if (!(await isGitRepo(cwd))) {
         return {
             isRepo: false,
             currentBranch: null,
@@ -790,50 +619,23 @@ export const getGitBranchInfo = async (cwd) => {
             pr: null,
         };
     }
-    // Pure-local: branch refs + default base only. The PR lease is resolved
-    // separately by getGitBranchPr so the toolbar paints without waiting on the
-    // GitHub REST API.
-    const currentBranch = getCurrentBranch(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);
+    const [currentBranch, defaultBase, branches] = await Promise.all([
+        getCurrentBranch(cwd),
+        resolveDefaultBase(cwd),
+        listBranchesByRecency(cwd),
+    ]);
     return {
         isRepo: true,
         currentBranch,
         defaultBase: defaultBase?.ref ?? null,
         defaultBaseSource: defaultBase?.source ?? null,
-        branches: branchData.map((b) => b.name),
+        branches,
         pr: null,
     };
 };
-// Resolves the PR the current branch maps to via the GitHub REST API. Bounded by
-// Octokit's own timeout and a try/catch in the default fetcher (returns []), so
-// it degrades to null on a missing token, network failure, or no PR. Served from
-// /api/git/branches/pr so the fast branch lease (/api/git/branches) never waits
-// on the network.
 export const getGitBranchPr = async (cwd) => {
-    const r = await openRepo(cwd);
-    if (!r)
+    if (!(await isGitRepo(cwd)))
         return null;
-    return detectPr(r);
+    return detectPr(cwd);
 };
 //# sourceMappingURL=git-diff.js.map