@hienlh/ppm 0.20.9 → 0.21.0

package/packages/ext-git-graph/src/extension.ts

@@ -10,7 +10,7 @@ import type { VscodeApi } from "./git-exec.ts";
 import {
   assertSafeFilePaths, assertValidHash, assertValidRef, assertValidRemote, spawnGit,
 } from "./git-exec.ts";
-import { authHeaders, getBaseUrl, initPpmApi, resolveProjectName } from "./ppm-api.ts";
+import { authHeaders, getBaseUrl, initPpmApi, resolveFileTab } from "./ppm-api.ts";
 import { registerBlameView } from "./blame-view.ts";
 import { registerFileHistoryView } from "./file-history-view.ts";
 import { registerCompareView } from "./compare-view.ts";
@@ -117,10 +117,9 @@ function openGitGraph(
         case "openDiff": {
           assertSafeFilePaths([msg.filePath], pp);
           const fileName = msg.filePath.split(/[\\/]/).pop() || msg.filePath;
-          const projectName = await resolveProjectName(pp);
-          await vscode.window.openTab("git-diff", `${fileName} (${msg.hash.substring(0, 7)})`, projectName, {
-            projectName,
-            filePath: msg.filePath,
+          const target = await resolveFileTab(pp, msg.filePath);
+          await vscode.window.openTab("git-diff", `${fileName} (${msg.hash.substring(0, 7)})`, target.projectName, {
+            ...target,
             ...(msg.parentHash ? { ref1: msg.parentHash } : {}),
             ...(msg.hash !== "uncommitted" && msg.hash !== "staged" ? { ref2: msg.hash } : {}),
           });
@@ -198,11 +197,8 @@ function openGitGraph(
           break;
         case "openFile": {
           assertSafeFilePaths([msg.filePath], pp);
-          const projectName = await resolveProjectName(pp);
-          await vscode.window.openTab("editor", msg.filePath, projectName, {
-            projectName,
-            filePath: msg.filePath,
-          });
+          const target = await resolveFileTab(pp, msg.filePath);
+          await vscode.window.openTab("editor", msg.filePath, target.projectName, target);
           break;
         }
         case "requestWorktrees":
@@ -348,12 +344,9 @@ function openGitGraph(
           break;
         case "openConflictFile": {
           assertSafeFilePaths([msg.filePath], pp);
-          const projectName = await resolveProjectName(pp);
+          const target = await resolveFileTab(pp, msg.filePath);
           // Opens as conflict-editor tab (Phase 4 will wire this properly)
-          await vscode.window.openTab("conflict-editor", `Conflict: ${msg.filePath.split(/[\\/]/).pop()}`, projectName, {
-            projectName,
-            filePath: msg.filePath,
-          });
+          await vscode.window.openTab("conflict-editor", `Conflict: ${msg.filePath.split(/[\\/]/).pop()}`, target.projectName, target);
           break;
         }
         case "openSourceControl": {
@@ -402,6 +395,41 @@ async function handleRepoInfo(
   });
 }
 
+/**
+ * Which commit-window requests a panel still wants the answers to.
+ *
+ * Scrolling fires one `requestCommits` per page and each one spawns two git
+ * processes — the log and the lines-changed pass — with nothing stopping the
+ * previous pair. Pages are additive, so a late *append* is still wanted; what
+ * is not is anything from before the list was last thrown away. Switching
+ * branch or refreshing sends `skip: 0`, which replaces the list, and an
+ * in-flight page-two append landing after that appends the old branch's
+ * commits to the new branch's first page.
+ *
+ * So responses are dropped by generation rather than cancelled — there is no
+ * abort to reach for through the extension spawn API — and the second pass is
+ * skipped outright when it is already stale, which is also what keeps the
+ * process count down while somebody scrolls.
+ */
+export interface CommitRequestState {
+  latest: number;
+  lastReset: number;
+}
+
+/** Record a new request and return its generation. */
+export function beginCommitRequest(state: CommitRequestState, skip: number): number {
+  state.latest += 1;
+  if (skip === 0) state.lastReset = state.latest;
+  return state.latest;
+}
+
+/** True when the list this request was answering has since been replaced. */
+export function isStaleCommitRequest(state: CommitRequestState, generation: number): boolean {
+  return generation < state.lastReset;
+}
+
+const commitRequests = new WeakMap<object, CommitRequestState>();
+
 async function handleRequestCommits(
   vscode: VscodeApi,
   panel: ReturnType<VscodeApi["window"]["createWebviewPanel"]>,
@@ -413,25 +441,22 @@ async function handleRequestCommits(
 ): Promise<void> {
   const { parseGitLog } = await import("./git-log-parser.ts");
   const settings = context ? getSettings(context) : DEFAULT_SETTINGS;
-  const orderFlag = settings.commitOrdering === "date" ? "--date-order"
-    : settings.commitOrdering === "author-date" ? "--author-date-order"
-    : "--topo-order";
-  const args = [
-    "log",
-    `--format=%H%n%P%n%an%n%ae%n%at%n%cn%n%ce%n%ct%n%D%n%s%n<END_COMMIT>`,
-    orderFlag,
-    `-n`, String(maxCommits),
-  ];
-  if (settings.firstParentOnly) args.push("--first-parent");
-  if (skip > 0) args.push(`--skip=${skip}`);
-  if (branch && branch !== "all") {
-    args.push(branch);
-  } else {
-    // Exclude stash refs — stashes are loaded separately via handleStashes
-    args.push("--exclude=refs/stash", "--all");
+  const window = { maxCommits, skip, branch, firstParentOnly: settings.firstParentOnly,
+    ordering: settings.commitOrdering };
+
+  let requests = commitRequests.get(panel);
+  if (!requests) {
+    requests = { latest: 0, lastReset: 0 };
+    commitRequests.set(panel, requests);
   }
+  const generation = beginCommitRequest(requests, skip);
 
-  const result = await spawnGit(vscode, args, projectPath);
+  const result = await spawnGit(
+    vscode,
+    logArgs(window, `--format=%H%n%P%n%an%n%ae%n%at%n%cn%n%ce%n%ct%n%D%n%s%n<END_COMMIT>`),
+    projectPath,
+  );
+  if (isStaleCommitRequest(requests, generation)) return;
   const commits = parseGitLog(result.stdout);
 
   await panel.webview.postMessage({
@@ -439,14 +464,66 @@ async function handleRequestCommits(
     data: commits,
     append: skip > 0,
   });
+
+  // Lines changed, in a second pass. Asking the first log for --shortstat makes
+  // git diff every commit in the window, and that cost would land before the
+  // graph could be drawn at all; this way the numbers fill into their column a
+  // moment after the rows are already on screen.
+  try {
+    const { parseShortstat } = await import("./shortstat-parser.ts");
+    const stats = await spawnGit(vscode, logArgs(window, "--format=%H", "--shortstat"), projectPath);
+    if (isStaleCommitRequest(requests, generation)) return;
+    await panel.webview.postMessage({
+      command: "loadCommitStats",
+      data: parseShortstat(stats.stdout),
+    });
+  } catch {
+    // A column of numbers is not worth an error banner over the graph.
+  }
+}
+
+export interface LogWindow {
+  maxCommits: number;
+  skip: number;
+  branch?: string;
+  firstParentOnly?: boolean;
+  ordering?: string;
+}
+
+/**
+ * The commit window, as git arguments.
+ *
+ * Shared so the stats pass sees exactly the same commits as the graph: the two
+ * are joined by hash, so a different window would silently leave rows blank.
+ * Exported for its own test — the branch in it comes from a webview.
+ */
+export function logArgs(window: LogWindow, ...format: string[]): string[] {
+  const orderFlag = window.ordering === "date" ? "--date-order"
+    : window.ordering === "author-date" ? "--author-date-order"
+    : "--topo-order";
+  const args = ["log", ...format, orderFlag, "-n", String(window.maxCommits)];
+  if (window.firstParentOnly) args.push("--first-parent");
+  if (window.skip > 0) args.push(`--skip=${window.skip}`);
+  if (window.branch && window.branch !== "all") {
+    // The branch came from a webview. git happens to reject a dash-leading
+    // refname on its own, but that is a coincidence rather than a design, and
+    // this window is now spawned twice per request — once for the graph and
+    // once for the stats — so the value reaches git on two paths.
+    args.push(assertValidRef(window.branch, "branch"));
+  } else {
+    // Exclude stash refs — stashes are loaded separately via handleStashes
+    args.push("--exclude=refs/stash", "--all");
+  }
+  return args;
 }
 
 async function handleCommitDetails(
   vscode: VscodeApi,
   panel: ReturnType<VscodeApi["window"]["createWebviewPanel"]>,
   projectPath: string,
-  hash: string,
+  rawHash: string,
 ): Promise<void> {
+  const hash = assertValidHash(rawHash);
   const result = await spawnGit(vscode, [
     "show", "--numstat", "--format=%H%n%P%n%an%n%ae%n%at%n%cn%n%ce%n%ct%n%B%n<END_MSG>", hash,
   ], projectPath);
@@ -749,7 +826,32 @@ function parseStashes(stdout: string): import("./types.ts").Stash[] {
   });
 }
 
-function parseCommitDetail(stdout: string): import("./types.ts").CommitDetail {
+/**
+ * Files listed for one commit. The uncommitted-status handler two functions
+ * away already caps at the same number; this one capped at nothing, and a
+ * commit touching ten thousand files became ten thousand objects across
+ * `postMessage` and ten thousand rows in one `innerHTML`. A repository you
+ * clone can ship that commit.
+ *
+ * The cap has to be *said*, not just applied: a truncated list rendered as
+ * "500 files changed" is a wrong number presented as a fact, which is worse
+ * than a slow panel. `filesOmitted` carries what was dropped, the way the
+ * message cap appends its own `[… N more characters]`.
+ */
+export const MAX_DETAIL_FILES = 500;
+
+/**
+ * Characters of commit message the panel will render.
+ *
+ * `%B` is whatever the author wrote and is not bounded by anything — and the
+ * message then goes through the issue-link matcher, whose span-overlap check is
+ * quadratic in the number of matches. `\b[0-9a-f]{7,40}\b` matches once per
+ * hex-looking word, so a body of them is ~n² comparisons. 100 KB is longer than
+ * any message anyone reads and short enough that the worst case stays cheap.
+ */
+const MAX_MESSAGE_CHARS = 100_000;
+
+export function parseCommitDetail(stdout: string): import("./types.ts").CommitDetail {
   const [headerBlock, rest] = stdout.split("<END_MSG>");
   const lines = headerBlock.trim().split("\n");
   const hash = lines[0];
@@ -760,14 +862,24 @@ function parseCommitDetail(stdout: string): import("./types.ts").CommitDetail {
   const committer = lines[5];
   const committerEmail = lines[6];
   const commitDate = parseInt(lines[7], 10);
-  const message = lines.slice(8).join("\n").trim();
+  const full = lines.slice(8).join("\n").trim();
+  const message = full.length > MAX_MESSAGE_CHARS
+    ? `${full.slice(0, MAX_MESSAGE_CHARS)}\n\n[… ${full.length - MAX_MESSAGE_CHARS} more characters]`
+    : full;
 
   // Parse --numstat output for file changes (format: "adds\tdels\tpath")
   const fileChanges: import("./types.ts").FileChange[] = [];
+  let filesOmitted = 0;
   if (rest) {
     for (const line of rest.trim().split("\n").filter(Boolean)) {
       const numstatMatch = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
       if (numstatMatch) {
+        // Past the cap the rest of the walk is only counting, so that the panel
+        // can say how many files it is not showing.
+        if (fileChanges.length >= MAX_DETAIL_FILES) {
+          filesOmitted++;
+          continue;
+        }
         const additions = numstatMatch[1] === "-" ? 0 : parseInt(numstatMatch[1], 10);
         const deletions = numstatMatch[2] === "-" ? 0 : parseInt(numstatMatch[2], 10);
         let filePath = numstatMatch[3];
@@ -794,7 +906,7 @@ function parseCommitDetail(stdout: string): import("./types.ts").CommitDetail {
     }
   }
 
-  return { hash, parents, author, authorEmail, authorDate, committer, committerEmail, commitDate, message, fileChanges };
+  return { hash, parents, author, authorEmail, authorDate, committer, committerEmail, commitDate, message, fileChanges, filesOmitted };
 }
 
 function buildGitActionArgs(action: string, args: Record<string, unknown>): string[] {

package/packages/ext-git-graph/src/file-history-view.ts

@@ -12,7 +12,7 @@ import { assertSafeFilePaths, assertValidHash, assertValidLineNumber, spawnGit }
 import { openPanel } from "./panel-registry.ts";
 import { registerViewCommand } from "./register-view-command.ts";
 import { navigateToPanel, takePendingTarget } from "./panel-nav.ts";
-import { resolveProjectName } from "./ppm-api.ts";
+import { resolveFileTab } from "./ppm-api.ts";
 import { FILE_HISTORY_FORMAT, buildLineRangeArg, parseFileHistory } from "./file-history-parser.ts";
 import { FILE_PICKER_CSS, FILE_PICKER_HTML, FILE_PICKER_JS, shellHtml } from "./webview-shell.ts";
 
@@ -99,11 +99,10 @@ export function openFileHistoryView(
             assertSafeFilePaths([filePath], projectPath);
             const hash = assertValidHash(msg.hash);
             const fileName = filePath.split(/[\\/]/).pop() || filePath;
-            const projectName = await resolveProjectName(projectPath);
+            const target = await resolveFileTab(projectPath, filePath);
             const parent = await spawnGit(vscode, ["rev-parse", `${hash}^`], projectPath);
-            await vscode.window.openTab("git-diff", `${fileName} (${hash.slice(0, 7)})`, projectName, {
-              projectName,
-              filePath,
+            await vscode.window.openTab("git-diff", `${fileName} (${hash.slice(0, 7)})`, target.projectName, {
+              ...target,
               ...(parent.exitCode === 0 ? { ref1: parent.stdout.trim() } : {}),
               ref2: hash,
             });

package/packages/ext-git-graph/src/log-args.test.ts

@@ -0,0 +1,57 @@
+/**
+ * `git-exec.ts` opens with the rule this file enforces: every git argument that
+ * originates in a webview passes through one of its `assert*` guards before it
+ * reaches `spawn`. The branch in a commit window did not — and since the stats
+ * pass was split out, that window is built twice per request, so the value
+ * reached git on two paths instead of one.
+ *
+ * git does reject a dash-leading refname by itself, so nothing was exploitable.
+ * The guard is what makes that a property of this code rather than a property
+ * of whichever git happens to be installed.
+ */
+import { describe, it, expect } from "bun:test";
+import { logArgs } from "./extension.ts";
+
+describe("logArgs", () => {
+  it("puts a real branch at the end of the arguments", () => {
+    const args = logArgs({ maxCommits: 50, skip: 0, branch: "feature/x" }, "--format=%H");
+
+    expect(args).toEqual(["log", "--format=%H", "--topo-order", "-n", "50", "feature/x"]);
+  });
+
+  it("asks for every ref but the stashes when no branch is named", () => {
+    for (const window of [{ maxCommits: 10, skip: 0 }, { maxCommits: 10, skip: 0, branch: "all" }]) {
+      expect(logArgs(window, "--format=%H")).toEqual([
+        "log", "--format=%H", "--topo-order", "-n", "10", "--exclude=refs/stash", "--all",
+      ]);
+    }
+  });
+
+  it("carries the window's paging and ordering", () => {
+    expect(logArgs({ maxCommits: 20, skip: 40, ordering: "date", firstParentOnly: true }, "--format=%H"))
+      .toEqual([
+        "log", "--format=%H", "--date-order", "-n", "20", "--first-parent", "--skip=40",
+        "--exclude=refs/stash", "--all",
+      ]);
+    expect(logArgs({ maxCommits: 20, skip: 0, ordering: "author-date" }, "--format=%H"))
+      .toContain("--author-date-order");
+  });
+
+  it("refuses a branch git would read as an option", () => {
+    expect(() => logArgs({ maxCommits: 10, skip: 0, branch: "--upload-pack=sh" }, "--format=%H"))
+      .toThrow(/Invalid git ref/);
+  });
+
+  it("refuses a branch that is really a range", () => {
+    // `a..b` is two commits, not one ref: it would silently change which
+    // commits the graph and the stats pass are asking about.
+    expect(() => logArgs({ maxCommits: 10, skip: 0, branch: "main..evil" }, "--format=%H"))
+      .toThrow(/Invalid git ref/);
+  });
+
+  it("refuses a branch with a control character or a revision operator in it", () => {
+    for (const branch of ["main\u0000", "main^{tree}", "main:path", "ma in\n--all"]) {
+      expect(() => logArgs({ maxCommits: 10, skip: 0, branch }, "--format=%H")).toThrow(/Invalid git ref/);
+    }
+  });
+});

package/packages/ext-git-graph/src/ppm-api.ts

@@ -2,6 +2,7 @@
  * Thin client for the PPM HTTP API, used to map a project path to the project
  * name that `window.openTab` needs. Initialised once from `activate`.
  */
+import { pickProject, toProjectRelative, type ProjectRef } from "./project-scope.ts";
 let baseUrl = "";
 let authToken = "";
 
@@ -33,16 +34,48 @@ export async function resolveProjectPath(): Promise<string | null> {
   return null;
 }
 
-/** Resolve project name from path via PPM API */
-export async function resolveProjectName(projectPath: string): Promise<string> {
+/**
+ * Resolve the registered project owning `dirPath` via the PPM API.
+ *
+ * `dirPath` is the panel's git root, which for a container workspace is a
+ * *subfolder* of the project — so an exact match is not enough. The basename
+ * fallback is kept for the case where the API cannot be reached at all, but it
+ * is a guess: it names no registered project, so anything built from it will
+ * 404.
+ */
+export async function resolveProject(dirPath: string): Promise<ProjectRef> {
   try {
     const res = await fetch(`${baseUrl}/api/projects`, authHeaders());
-    const json = await res.json() as { ok: boolean; data?: { name: string; path: string }[] };
+    const json = await res.json() as { ok: boolean; data?: ProjectRef[] };
     if (json.ok && json.data) {
-      const match = json.data.find((p) => p.path === projectPath);
-      if (match) return match.name;
+      const match = pickProject(json.data, dirPath);
+      if (match) return match;
     }
   } catch {}
   // Fallback to directory name
-  return projectPath.split(/[\\/]/).filter(Boolean).pop() || "project";
+  return { name: dirPath.split(/[\\/]/).filter(Boolean).pop() || "project", path: dirPath };
+}
+
+/** Resolve project name from path via PPM API */
+export async function resolveProjectName(dirPath: string): Promise<string> {
+  return (await resolveProject(dirPath)).name;
+}
+
+/**
+ * What a tab needs to open a file git named: the project it belongs to, and the
+ * path expressed relative to *that* rather than to the repository git ran in.
+ *
+ * Both come from one lookup on purpose — the name and the rebasing depend on
+ * the same answer, and resolving them separately is how one of them gets
+ * forgotten.
+ */
+export async function resolveFileTab(
+  gitRoot: string,
+  filePath: string,
+): Promise<{ projectName: string; filePath: string }> {
+  const project = await resolveProject(gitRoot);
+  return {
+    projectName: project.name,
+    filePath: toProjectRelative(project.path, gitRoot, filePath),
+  };
 }

package/packages/ext-git-graph/src/project-scope.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+import { pickProject, toProjectRelative } from "./project-scope.ts";
+
+const projects = [
+  { name: "workspace", path: "/home/me/work" },
+  { name: "inner", path: "/home/me/work/inner" },
+  { name: "other", path: "/home/me/other" },
+];
+
+describe("pickProject", () => {
+  test("matches a project by its own path", () => {
+    expect(pickProject(projects, "/home/me/other")?.name).toBe("other");
+  });
+
+  test("finds the project containing a repository one level down", () => {
+    // The whole point: a panel is opened on the repository, and the project it
+    // belongs to is what every API route and tab is keyed by.
+    expect(pickProject(projects, "/home/me/work/service-a")?.name).toBe("workspace");
+  });
+
+  test("prefers the innermost project when they nest", () => {
+    expect(pickProject(projects, "/home/me/work/inner/pkg")?.name).toBe("inner");
+  });
+
+  test("does not match a sibling that merely shares a prefix", () => {
+    expect(pickProject(projects, "/home/me/work-evil/repo")).toBeNull();
+  });
+
+  test("ignores a trailing separator on either side", () => {
+    expect(pickProject([{ name: "w", path: "/home/me/work/" }], "/home/me/work")?.name).toBe("w");
+  });
+
+  test("treats a Windows path the same as a POSIX one", () => {
+    const win = [{ name: "w", path: "C:\\Users\\me\\work" }];
+    expect(pickProject(win, "C:\\Users\\me\\work\\service-a")?.name).toBe("w");
+  });
+
+  test("answers null when nothing owns the path", () => {
+    expect(pickProject(projects, "/tmp/elsewhere")).toBeNull();
+  });
+});
+
+describe("toProjectRelative", () => {
+  test("is the identity when the repository is the project", () => {
+    // Every ordinary project takes this path, so it must not be able to change.
+    expect(toProjectRelative("/home/me/work", "/home/me/work", "src/index.ts")).toBe("src/index.ts");
+  });
+
+  test("prefixes the repository's own directory when it is nested", () => {
+    expect(toProjectRelative("/home/me/work", "/home/me/work/service-a", "src/index.ts")).toBe(
+      "service-a/src/index.ts",
+    );
+  });
+
+  test("keeps a repository two levels down whole", () => {
+    expect(toProjectRelative("/home/me/work", "/home/me/work/apps/api", "main.go")).toBe(
+      "apps/api/main.go",
+    );
+  });
+
+  test("strips a leading ./ and normalises separators", () => {
+    expect(toProjectRelative("/home/me/work", "/home/me/work/svc", "./src\\a.ts")).toBe(
+      "svc/src/a.ts",
+    );
+  });
+
+  test("leaves the path alone when the repository is not inside the project", () => {
+    // A worktree opened from outside the project: there is no prefix that would
+    // make the path meaningful, and inventing one would name a file that is not
+    // there.
+    expect(toProjectRelative("/home/me/work", "/tmp/wt", "src/index.ts")).toBe("src/index.ts");
+  });
+
+  test("answers the repository directory itself for an empty path", () => {
+    expect(toProjectRelative("/home/me/work", "/home/me/work/svc", "")).toBe("svc");
+  });
+});

package/packages/ext-git-graph/src/project-scope.ts

@@ -0,0 +1,69 @@
+/**
+ * Which PPM project a panel's git root belongs to, and how to address a file
+ * inside it.
+ *
+ * A panel is opened on the *repository*. For nearly every project that is the
+ * project folder itself, but a workspace folder can be a container whose
+ * children are the repositories — so the path a panel was handed is often a
+ * subfolder of the project. Two things follow, and both are silent failures
+ * otherwise:
+ *
+ * - The project name is not the basename of that path. It is the name of the
+ *   registered project *containing* it, because that is what `/api/projects/:name`
+ *   and `window.openTab` are keyed by; the basename fallback would build URLs
+ *   for a project that does not exist and 404.
+ * - A file path git reported is relative to the repository, while a tab's
+ *   `filePath` is relative to the project. Opening a diff without rebasing it
+ *   lands one or more directories too high and shows an empty buffer for a file
+ *   that plainly exists.
+ *
+ * Pure on purpose: the fetch-backed wrappers live in `ppm-api.ts`.
+ */
+
+export interface ProjectRef {
+  name: string;
+  path: string;
+}
+
+/** Trailing separators off, backslashes to forward slashes. */
+function normalizeDir(path: string): string {
+  return path.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+
+/**
+ * The registered project that owns `dirPath`, or null when none does.
+ *
+ * Longest match wins: a project nested inside another one is the more specific
+ * answer, and taking the first hit would attribute its repositories to the
+ * outer project.
+ */
+export function pickProject(projects: ProjectRef[], dirPath: string): ProjectRef | null {
+  const target = normalizeDir(dirPath);
+  let best: ProjectRef | null = null;
+  let bestLength = -1;
+  for (const project of projects) {
+    const root = normalizeDir(project.path);
+    if (target !== root && !target.startsWith(`${root}/`)) continue;
+    if (root.length > bestLength) {
+      best = project;
+      bestLength = root.length;
+    }
+  }
+  return best;
+}
+
+/**
+ * A repository-relative file path, expressed relative to the project root.
+ *
+ * The identity when the repository *is* the project — which is the case worth
+ * protecting, since it is every ordinary project.
+ */
+export function toProjectRelative(projectPath: string, gitRoot: string, filePath: string): string {
+  const root = normalizeDir(projectPath);
+  const repo = normalizeDir(gitRoot);
+  const file = filePath.replace(/\\/g, "/").replace(/^\.?\//, "");
+  if (repo === root) return file;
+  if (!repo.startsWith(`${root}/`)) return file;
+  const prefix = repo.slice(root.length + 1);
+  return file ? `${prefix}/${file}` : prefix;
+}

package/packages/ext-git-graph/src/shortstat-parser.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from "bun:test";
+import { parseShortstat } from "./shortstat-parser.ts";
+
+const A = "a".repeat(40);
+const B = "b".repeat(40);
+const C = "c".repeat(40);
+
+describe("parseShortstat", () => {
+  it("reads insertions and deletions", () => {
+    const out = parseShortstat(`${A}\n 3 files changed, 12 insertions(+), 4 deletions(-)\n`);
+    expect(out[A]).toEqual({ files: 3, insertions: 12, deletions: 4 });
+  });
+
+  it("handles a commit that only adds, and one that only deletes", () => {
+    const out = parseShortstat(
+      `${A}\n 1 file changed, 2 insertions(+)\n\n${B}\n 1 file changed, 7 deletions(-)\n`,
+    );
+    expect(out[A]).toEqual({ files: 1, insertions: 2, deletions: 0 });
+    expect(out[B]).toEqual({ files: 1, insertions: 0, deletions: 7 });
+  });
+
+  it("leaves a merge commit out rather than giving it zeroes", () => {
+    // git prints no diffstat for a merge by default. Absent and 0/0 are
+    // different things: one is "not computed", the other is "changed nothing".
+    const out = parseShortstat(`${A}\n\n${B}\n 2 files changed, 1 insertion(+)\n`);
+    expect(out[A]).toBeUndefined();
+    expect(out[B]).toEqual({ files: 2, insertions: 1, deletions: 0 });
+  });
+
+  it("keeps each stat with the hash printed before it", () => {
+    const out = parseShortstat(
+      `${A}\n 1 file changed, 1 insertion(+)\n\n${B}\n 2 files changed, 2 insertions(+)\n\n${C}\n 3 files changed, 3 deletions(-)\n`,
+    );
+    expect(out[A]!.insertions).toBe(1);
+    expect(out[B]!.insertions).toBe(2);
+    expect(out[C]!.deletions).toBe(3);
+  });
+
+  it("ignores a stat line with no hash before it", () => {
+    const out = parseShortstat(" 9 files changed, 9 insertions(+)\n");
+    expect(Object.keys(out)).toEqual([]);
+  });
+
+  it("ignores anything that is not a full hash", () => {
+    // A short hash in a commit message must not be mistaken for a record start.
+    const out = parseShortstat(`8abb115\n 1 file changed, 1 insertion(+)\n`);
+    expect(Object.keys(out)).toEqual([]);
+  });
+
+  it("is empty for empty output", () => {
+    expect(parseShortstat("")).toEqual({});
+  });
+});

package/packages/ext-git-graph/src/shortstat-parser.ts

@@ -0,0 +1,45 @@
+/**
+ * `git log --format=%H --shortstat` into a hash → lines-changed map.
+ *
+ * A second pass rather than `--shortstat` on the main log: adding it there costs
+ * git a diff per commit (~100ms for 300 commits on a 2k-commit repository, and
+ * far more on a large one) and that cost would land *before* the graph could be
+ * drawn at all. This runs after the commits have already been sent, so the
+ * numbers fill in a moment later and nothing waits for them.
+ *
+ * A merge commit produces no diffstat at all, which is git's default and not an
+ * error — it is simply absent from the map, and the column stays blank for it.
+ */
+
+export interface CommitStat {
+  files: number;
+  insertions: number;
+  deletions: number;
+}
+
+/** " 3 files changed, 12 insertions(+), 4 deletions(-)" — any of the three clauses may be missing. */
+const SHORTSTAT = /^\s*(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?/;
+const FULL_HASH = /^[0-9a-f]{40}$/;
+
+export function parseShortstat(stdout: string): Record<string, CommitStat> {
+  const stats: Record<string, CommitStat> = {};
+  let hash: string | null = null;
+
+  for (const line of stdout.split("\n")) {
+    if (FULL_HASH.test(line.trim())) {
+      hash = line.trim();
+      continue;
+    }
+    const match = SHORTSTAT.exec(line);
+    // The stat follows the hash it belongs to, so a stat with no hash before it
+    // is not ours — better to drop it than to attach it to the wrong commit.
+    if (!match || !hash) continue;
+    stats[hash] = {
+      files: Number(match[1]),
+      insertions: match[2] ? Number(match[2]) : 0,
+      deletions: match[3] ? Number(match[3]) : 0,
+    };
+    hash = null;
+  }
+  return stats;
+}

package/packages/ext-git-graph/src/types.ts

@@ -67,6 +67,8 @@ export interface CommitDetail {
   message: string;
   parents: string[];
   fileChanges: FileChange[];
+  /** Files the `MAX_DETAIL_FILES` cap dropped, so the panel can say it capped. */
+  filesOmitted: number;
 }
 
 export interface FileChange {