@sideboard-ai/core 0.1.67 → 0.1.68

package/dist/mcp/run-stdio.cjs

@@ -1649,7 +1649,7 @@ async function git(args, cwd, opts) {
       prefix.push("-c", `${key}=${value}`);
     }
   }
-  return run("git", [...prefix, ...args], {
+  return run("git", ["--no-pager", ...prefix, ...args], {
     cwd,
     reject: opts?.reject,
     timeoutMs: opts?.timeoutMs,
@@ -2124,7 +2124,7 @@ async function originGhRepoEnv(cwd) {
   const slug = await resolveGithubRepoSlug(cwd);
   return slug ? { GH_REPO: slug } : {};
 }
-async function resolveDefaultBranch(repoPath) {
+async function resolveDefaultBranch(repoPath, opts) {
   const viaOrigin = await git(
     ["symbolic-ref", "refs/remotes/origin/HEAD"],
     repoPath,
@@ -2133,22 +2133,24 @@ async function resolveDefaultBranch(repoPath) {
   if (viaOrigin.exitCode === 0 && viaOrigin.stdout.trim()) {
     return viaOrigin.stdout.trim().replace(/^refs\/remotes\/origin\//, "");
   }
-  const slug = await resolveGithubRepoSlug(repoPath);
-  const viaGh = await gh(
-    [
-      "repo",
-      "view",
-      ...slug ? ["--repo", slug] : [],
-      "--json",
-      "defaultBranchRef",
-      "--jq",
-      ".defaultBranchRef.name"
-    ],
-    repoPath,
-    { reject: false }
-  );
-  if (viaGh.exitCode === 0 && viaGh.stdout.trim()) {
-    return viaGh.stdout.trim();
+  if (opts?.network !== false) {
+    const slug = await resolveGithubRepoSlug(repoPath);
+    const viaGh = await gh(
+      [
+        "repo",
+        "view",
+        ...slug ? ["--repo", slug] : [],
+        "--json",
+        "defaultBranchRef",
+        "--jq",
+        ".defaultBranchRef.name"
+      ],
+      repoPath,
+      { reject: false, timeoutMs: 8e3 }
+    );
+    if (viaGh.exitCode === 0 && viaGh.stdout.trim()) {
+      return viaGh.stdout.trim();
+    }
   }
   for (const candidate of ["main", "master"]) {
     const check = await git(
@@ -2800,11 +2802,11 @@ async function listWorktrees(repoPath) {
   return entries;
 }
 async function isDirty(worktreePath) {
-  const { stdout } = await git(["status", "--porcelain", "-uall"], worktreePath);
+  const { stdout } = await git(["status", "--porcelain"], worktreePath);
   for (const line of stdout.split("\n")) {
     if (!line.trim()) continue;
     const rel = porcelainStatusPath(line);
-    if (!rel || isSideboardScratchPath(rel)) continue;
+    if (!rel || isSideboardScratchPath(rel) || rel === ".sideboard") continue;
     return true;
   }
   return false;
@@ -9744,24 +9746,25 @@ function capPatch(patch, maxHunk) {
 
 \u2026 truncated (${patch.length - maxHunk} more chars)`;
 }
+var mergeBaseCache = /* @__PURE__ */ new Map();
+var MERGE_BASE_TTL_MS = 45e3;
 async function resolveMergeBase(worktreePath, base, repoPath) {
   const baseRef = await resolveDiffBaseRef(worktreePath, base, repoPath);
+  const cacheKey = `${worktreePath}\0${baseRef}`;
+  const hit = mergeBaseCache.get(cacheKey);
+  if (hit && Date.now() - hit.at < MERGE_BASE_TTL_MS) return hit.value;
   const { stdout } = await git(["merge-base", baseRef, "HEAD"], worktreePath, {
     reject: false
   });
-  const mb = stdout.trim();
-  return mb || baseRef;
+  const mb = stdout.trim() || baseRef;
+  mergeBaseCache.set(cacheKey, { at: Date.now(), value: mb });
+  return mb;
 }
 async function countUnpushedCommits(worktreePath) {
   const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath, {
     reject: false
   });
   const branch = head.stdout.trim();
-  if (branch && branch !== "HEAD") {
-    await git(["fetch", "origin", branch, "--quiet"], worktreePath, {
-      reject: false
-    });
-  }
   const upstream = await git(
     ["rev-list", "--count", "@{upstream}..HEAD"],
     worktreePath,
@@ -9794,11 +9797,37 @@ function splitCombinedDiff(stdout) {
   }
   return map;
 }
+function syntheticAddPatch(path, content, maxHunk) {
+  const lines = content.split("\n");
+  const body = lines.map((l) => `+${l}`).join("\n");
+  const header = `diff --git a/${path} b/${path}
+new file mode 100644
+--- /dev/null
++++ b/${path}
+@@ -0,0 +1,${lines.length} @@
+`;
+  return {
+    path,
+    status: "A",
+    patch: capPatch(`${header}${body}`, maxHunk),
+    additions: lines.length,
+    deletions: 0
+  };
+}
 async function untrackedPatch(worktreePath, path, maxHunk) {
+  const abs = (0, import_node_path20.join)(worktreePath, path);
+  try {
+    const st = (0, import_node_fs25.statSync)(abs);
+    if (st.isFile() && st.size > maxHunk) {
+      const buf = (0, import_node_fs25.readFileSync)(abs).subarray(0, maxHunk);
+      return syntheticAddPatch(path, buf.toString("utf8"), maxHunk);
+    }
+  } catch {
+  }
   const { stdout: patch } = await git(
-    ["diff", "--no-index", "--", "/dev/null", path],
+    ["diff", "--no-ext-diff", "--no-color", "--no-index", "--", "/dev/null", path],
     worktreePath,
-    { reject: false }
+    { reject: false, timeoutMs: 4e3 }
   );
   const normalized = patch.replace(/^diff --git a\/.+? b\/.+?$/m, `diff --git a/${path} b/${path}`).replace(/^--- .*$/m, "--- /dev/null").replace(/^\+\+\+ .*$/m, `+++ b/${path}`);
   const addLines = normalized.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
@@ -9810,22 +9839,97 @@ async function untrackedPatch(worktreePath, path, maxHunk) {
     deletions: 0
   };
 }
-async function listUntrackedPaths(worktreePath) {
-  const { stdout } = await git(
-    ["ls-files", "-z", "--others", "--exclude-standard"],
-    worktreePath,
-    { reject: false }
-  );
+async function listUntrackedPaths(worktreePath, path) {
+  const args = ["ls-files", "-z", "--others", "--exclude-standard"];
+  if (path) args.push("--", path);
+  const { stdout } = await git(args, worktreePath, { reject: false });
   return stdout.split("\0").filter(Boolean).filter((p) => !isSideboardScratchPath(p));
 }
-async function listUntrackedFiles(worktreePath, maxHunk) {
-  const paths = await listUntrackedPaths(worktreePath);
-  if (paths.length === 0) return [];
-  return Promise.all(paths.map((path) => untrackedPatch(worktreePath, path, maxHunk)));
+async function listUntrackedFiles(worktreePath, maxHunk, paths) {
+  const list = paths ?? await listUntrackedPaths(worktreePath);
+  if (list.length === 0) return [];
+  return Promise.all(list.map((path) => untrackedPatch(worktreePath, path, maxHunk)));
+}
+function untrackedStubs(paths) {
+  return paths.map((path) => ({
+    path,
+    status: "A",
+    patch: "",
+    additions: 0,
+    deletions: 0
+  }));
+}
+function pathspec(path) {
+  return path ? ["--", path] : [];
+}
+function gitDiff(args, cwd, opts) {
+  return git(["diff", "--no-ext-diff", "--no-color", ...args], cwd, {
+    reject: false,
+    timeoutMs: opts?.timeoutMs
+  });
+}
+function fileFromPatch(path, patch, maxHunk) {
+  let status = "M";
+  if (/^new file mode /m.test(patch) || /^--- \/dev\/null/m.test(patch)) {
+    status = "A";
+  } else if (/^deleted file mode /m.test(patch) || /^\+\+\+ \/dev\/null/m.test(patch)) {
+    status = "D";
+  } else if (/^rename from /m.test(patch)) {
+    status = "R";
+  }
+  const additions = patch.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).length;
+  const deletions = patch.split("\n").filter((l) => l.startsWith("-") && !l.startsWith("---")).length;
+  return {
+    path,
+    status,
+    patch: capPatch(patch, maxHunk),
+    additions,
+    deletions
+  };
+}
+async function gitDiffParts(worktreePath, diffArgs, includePatches, path) {
+  const extra = pathspec(path);
+  if (includePatches) {
+    const diff = await gitDiff([...diffArgs, ...extra], worktreePath, {
+      timeoutMs: 4e3
+    });
+    return { nameStatus: "", numstat: "", combinedDiff: diff.stdout };
+  }
+  const [ns, num2] = await Promise.all([
+    gitDiff(["--name-status", ...diffArgs, ...extra], worktreePath),
+    gitDiff(["--numstat", ...diffArgs, ...extra], worktreePath)
+  ]);
+  return {
+    nameStatus: ns.stdout,
+    numstat: num2.stdout,
+    combinedDiff: ""
+  };
+}
+function formatStat(files) {
+  if (files.length === 0) return "(no changes)";
+  const additions = files.reduce((n2, f) => n2 + (f.additions ?? 0), 0);
+  const deletions = files.reduce((n2, f) => n2 + (f.deletions ?? 0), 0);
+  const n = files.length;
+  return `${n} file${n === 1 ? "" : "s"} changed, ${additions} insertions(+), ${deletions} deletions(-)`;
+}
+function emptyScopeStats() {
+  const z2 = emptyStat();
+  return {
+    commits: z2,
+    uncommitted: z2,
+    staged: z2,
+    unstaged: z2,
+    last_turn: z2
+  };
 }
 function filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk) {
-  const counts = parseNumstat(numstat);
   const patches = splitCombinedDiff(combinedDiff);
+  if (!nameStatus.trim() && patches.size > 0) {
+    return [...patches.entries()].map(
+      ([path, patch]) => fileFromPatch(path, patch, maxHunk)
+    );
+  }
+  const counts = parseNumstat(numstat);
   const files = [];
   for (const { status, path } of parseNameStatus(nameStatus)) {
     const n = counts.get(path);
@@ -9847,11 +9951,11 @@ async function computeScopeStats(worktreePath, mergeBase, lastTurnBase, untracke
     { stdout: unstagedNum },
     lastTurnNum
   ] = await Promise.all([
-    mergeBase ? git(["diff", "--numstat", mergeBase], worktreePath, { reject: false }) : Promise.resolve({ stdout: "" }),
-    git(["diff", "--numstat", "HEAD"], worktreePath, { reject: false }),
-    git(["diff", "--numstat", "--cached"], worktreePath, { reject: false }),
-    git(["diff", "--numstat"], worktreePath, { reject: false }),
-    lastTurnBase ? git(["diff", "--numstat", lastTurnBase], worktreePath, { reject: false }) : Promise.resolve({ stdout: "" })
+    mergeBase ? gitDiff(["--numstat", mergeBase], worktreePath) : Promise.resolve({ stdout: "" }),
+    gitDiff(["--numstat", "HEAD"], worktreePath),
+    gitDiff(["--numstat", "--cached"], worktreePath),
+    gitDiff(["--numstat"], worktreePath),
+    lastTurnBase ? gitDiff(["--numstat", lastTurnBase], worktreePath) : Promise.resolve({ stdout: "" })
   ]);
   return {
     commits: mergeBase ? statFromNumstat(commitsNum, untrackedCount) : emptyStat(),
@@ -9870,7 +9974,7 @@ async function listBranchCommits(worktreePath, repoPath, opts) {
   if (head.exitCode !== 0) return [];
   let base = opts?.base;
   try {
-    base = base ?? await resolveDefaultBranch(repoPath);
+    base = base ?? await resolveDefaultBranch(repoPath, { network: false });
   } catch {
     base = "HEAD";
   }
@@ -9900,7 +10004,121 @@ async function listBranchCommits(worktreePath, repoPath, opts) {
   }
   return commits;
 }
+var SHA_RE = /^[0-9a-f]{7,40}$/i;
+function emptyPathDiff(scope, base, hasLastTurnBase, commitSha = null) {
+  return {
+    scope,
+    commitSha: scope === "commits" ? commitSha : null,
+    base,
+    files: [],
+    stat: formatStat([]),
+    dirty: false,
+    unpushed: 0,
+    hasLastTurnBase,
+    commits: [],
+    scopeStats: emptyScopeStats()
+  };
+}
+async function getPathDiff(worktreePath, repoPath, opts) {
+  const { path, scope, commitSha, lastTurnBase, hasLastTurnBase, includePatches, maxHunk } = opts;
+  if (scope === "last_turn" && !lastTurnBase) {
+    return emptyPathDiff(scope, "last turn", false);
+  }
+  let diffArgs;
+  let labelBase;
+  if (scope === "staged") {
+    diffArgs = ["--cached"];
+    labelBase = "staged";
+  } else if (scope === "unstaged") {
+    diffArgs = [];
+    labelBase = "unstaged";
+  } else if (scope === "uncommitted") {
+    diffArgs = ["HEAD"];
+    labelBase = "HEAD";
+  } else if (scope === "last_turn") {
+    diffArgs = [lastTurnBase];
+    labelBase = "last turn";
+  } else if (scope === "commits" && commitSha) {
+    diffArgs = [`${commitSha}^!`];
+    labelBase = commitSha.slice(0, 7);
+  } else if (scope === "commits" && opts.base && SHA_RE.test(opts.base)) {
+    diffArgs = [opts.base];
+    labelBase = opts.base.slice(0, 7);
+  } else if (scope === "commits") {
+    let base = opts.base;
+    try {
+      base = base ?? await resolveDefaultBranch(repoPath, { network: false });
+    } catch {
+      base = "HEAD";
+    }
+    const mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
+    diffArgs = [mergeBase];
+    labelBase = mergeBase;
+  } else {
+    diffArgs = ["HEAD"];
+    labelBase = "HEAD";
+  }
+  const diff = await gitDiff(
+    includePatches ? [...diffArgs, "--", path] : ["--name-status", ...diffArgs, "--", path],
+    worktreePath,
+    { timeoutMs: 4e3 }
+  );
+  const filesMap = /* @__PURE__ */ new Map();
+  if (includePatches) {
+    const parsed = filesFromDiff("", "", diff.stdout, maxHunk);
+    for (const file of parsed) filesMap.set(file.path, file);
+    if (diff.stdout.trim() && !filesMap.has(path)) {
+      filesMap.set(path, fileFromPatch(path, diff.stdout, maxHunk));
+    }
+  } else {
+    for (const file of filesFromDiff(diff.stdout, "", "", maxHunk)) {
+      filesMap.set(file.path, file);
+    }
+  }
+  if (filesMap.size === 0) {
+    const maybe = await listUntrackedPaths(worktreePath, path);
+    if (maybe.length > 0) {
+      const extra = includePatches ? await listUntrackedFiles(worktreePath, maxHunk, maybe) : untrackedStubs(maybe);
+      for (const file of extra) filesMap.set(file.path, file);
+    }
+  }
+  const files = [...filesMap.values()].sort((a, b) => a.path.localeCompare(b.path));
+  return {
+    scope,
+    commitSha: scope === "commits" ? commitSha : null,
+    base: labelBase,
+    files,
+    stat: formatStat(files),
+    dirty: files.length > 0,
+    unpushed: 0,
+    hasLastTurnBase,
+    commits: [],
+    scopeStats: emptyScopeStats(),
+    mergeBase: SHA_RE.test(diffArgs[0] ?? "") ? diffArgs[0] : null
+  };
+}
 async function getDiff(worktreePath, repoPath, opts) {
+  const maxHunk = opts?.maxHunkChars ?? 8e3;
+  const scope = opts?.scope ?? "commits";
+  const lastTurnBase = opts?.lastTurnBase?.trim() || null;
+  const hasLastTurnBase = Boolean(lastTurnBase);
+  const commitSha = opts?.commitSha?.trim() || null;
+  const includePatches = opts?.includePatches ?? true;
+  const pathFilter = opts?.path?.trim() || null;
+  const fileOnly = Boolean(pathFilter);
+  const includeMeta = (opts?.includeMeta ?? true) && !fileOnly;
+  if (fileOnly && pathFilter && !includeMeta) {
+    return getPathDiff(worktreePath, repoPath, {
+      path: pathFilter,
+      scope,
+      commitSha,
+      lastTurnBase,
+      hasLastTurnBase,
+      base: opts?.base,
+      includePatches,
+      maxHunk
+    });
+  }
   const status = await inspectGitWorktree(worktreePath);
   if (status === "missing_worktree") {
     throw new Error("Worktree not found");
@@ -9908,18 +10126,19 @@ async function getDiff(worktreePath, repoPath, opts) {
   if (status === "not_git") {
     throw new Error("Not a Git repository");
   }
-  const maxHunk = opts?.maxHunkChars ?? 8e3;
-  const scope = opts?.scope ?? "commits";
-  const lastTurnBase = opts?.lastTurnBase?.trim() || null;
-  const hasLastTurnBase = Boolean(lastTurnBase);
-  const commitSha = opts?.commitSha?.trim() || null;
-  const head = await git(["rev-parse", "--verify", "HEAD"], worktreePath, {
+  const wantUntracked = opts?.includeUntracked !== void 0 ? opts.includeUntracked : !fileOnly && (scope === "commits" && !commitSha || scope === "uncommitted" || scope === "unstaged" || scope === "last_turn");
+  const needsMergeBase = scope === "commits" && !commitSha || includeMeta;
+  const headP = git(["rev-parse", "--verify", "HEAD"], worktreePath, {
     reject: false
   });
+  const untrackedP = wantUntracked ? listUntrackedPaths(worktreePath, pathFilter) : Promise.resolve([]);
+  const head = await headP;
   const hasHead = head.exitCode === 0;
-  const untrackedPaths = await listUntrackedPaths(worktreePath);
   if (!hasHead) {
-    const files2 = scope === "staged" ? [] : (await listUntrackedFiles(worktreePath, maxHunk)).sort(
+    const untrackedPaths2 = await untrackedP;
+    const files2 = scope === "staged" ? [] : includePatches ? (await listUntrackedFiles(worktreePath, maxHunk, untrackedPaths2)).sort(
+      (a, b) => a.path.localeCompare(b.path)
+    ) : untrackedStubs(untrackedPaths2).sort(
       (a, b) => a.path.localeCompare(b.path)
     );
     const untrackedStat = {
@@ -9933,7 +10152,7 @@ async function getDiff(worktreePath, repoPath, opts) {
       commitSha: null,
       base: "(no commits)",
       files: files2,
-      stat: files2.length ? files2.map((f) => ` ${f.path} | untracked`).join("\n") : "(no changes)",
+      stat: formatStat(files2),
       dirty: files2.length > 0,
       unpushed: 0,
       hasLastTurnBase,
@@ -9947,137 +10166,122 @@ async function getDiff(worktreePath, repoPath, opts) {
       }
     };
   }
-  let base = opts?.base;
-  try {
-    base = base ?? await resolveDefaultBranch(repoPath);
-  } catch {
-    base = "HEAD";
+  let mergeBase = "HEAD";
+  let baseLabel = "HEAD";
+  if (needsMergeBase) {
+    let base = opts?.base;
+    try {
+      base = base ?? await resolveDefaultBranch(repoPath, { network: false });
+    } catch {
+      base = "HEAD";
+    }
+    mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
+    baseLabel = await resolveDiffBaseRef(worktreePath, base, repoPath);
   }
-  base = await resolveDiffBaseRef(worktreePath, base, repoPath);
-  if (base.startsWith("origin/")) {
-    const short = base.slice("origin/".length);
-    await git(["fetch", "origin", short, "--quiet"], worktreePath, {
-      reject: false
-    });
-    base = await resolveDiffBaseRef(worktreePath, short, repoPath);
+  const includeUntracked = wantUntracked;
+  const metaPromise = includeMeta ? Promise.all([
+    computeScopeStats(
+      worktreePath,
+      mergeBase,
+      lastTurnBase,
+      // Cheap: don't wait on the untracked walk just to pad the badge.
+      0
+    ),
+    listBranchCommits(worktreePath, repoPath, { base: baseLabel }),
+    isDirty(worktreePath),
+    countUnpushedCommits(worktreePath)
+  ]).then(([scopeStats, commits, dirty, unpushed]) => ({
+    scopeStats,
+    commits,
+    dirty,
+    unpushed
+  })) : Promise.resolve({
+    scopeStats: emptyScopeStats(),
+    commits: [],
+    dirty: false,
+    unpushed: 0
+  });
+  if (scope === "last_turn" && !lastTurnBase) {
+    const meta2 = await metaPromise;
+    return {
+      scope,
+      commitSha: null,
+      base: "last turn",
+      files: [],
+      stat: "(no last agent turn)",
+      dirty: meta2.dirty,
+      unpushed: meta2.unpushed,
+      hasLastTurnBase: false,
+      commits: meta2.commits,
+      scopeStats: meta2.scopeStats
+    };
   }
-  const mergeBase = await resolveMergeBase(worktreePath, base, repoPath);
-  const scopeStats = await computeScopeStats(
-    worktreePath,
-    mergeBase,
-    lastTurnBase,
-    untrackedPaths.length
-  );
-  const includeUntracked = scope === "commits" && !commitSha || scope === "uncommitted" || scope === "unstaged" || scope === "last_turn";
-  let nameStatus = "";
-  let numstat = "";
-  let combinedDiff = "";
-  let labelBase = base;
+  let diffArgs;
+  let labelBase = baseLabel;
   if (scope === "staged") {
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", "--cached"], worktreePath, { reject: false }),
-      git(["diff", "--numstat", "--cached"], worktreePath, { reject: false }),
-      git(["diff", "--cached"], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = ["--cached"];
     labelBase = "staged";
   } else if (scope === "unstaged") {
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status"], worktreePath, { reject: false }),
-      git(["diff", "--numstat"], worktreePath, { reject: false }),
-      git(["diff"], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = [];
     labelBase = "unstaged";
   } else if (scope === "uncommitted") {
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", "HEAD"], worktreePath, { reject: false }),
-      git(["diff", "--numstat", "HEAD"], worktreePath, { reject: false }),
-      git(["diff", "HEAD"], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = ["HEAD"];
     labelBase = "HEAD";
   } else if (scope === "last_turn") {
-    if (!lastTurnBase) {
-      const commits2 = await listBranchCommits(worktreePath, repoPath, { base });
-      return {
-        scope,
-        commitSha: null,
-        base: "last turn",
-        files: [],
-        stat: "(no last agent turn)",
-        dirty: await isDirty(worktreePath),
-        unpushed: await countUnpushedCommits(worktreePath),
-        hasLastTurnBase: false,
-        commits: commits2,
-        scopeStats
-      };
-    }
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", lastTurnBase], worktreePath, { reject: false }),
-      git(["diff", "--numstat", lastTurnBase], worktreePath, { reject: false }),
-      git(["diff", lastTurnBase], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = [lastTurnBase];
     labelBase = "last turn";
   } else if (scope === "commits" && commitSha) {
-    const range = `${commitSha}^!`;
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", range], worktreePath, { reject: false }),
-      git(["diff", "--numstat", range], worktreePath, { reject: false }),
-      git(["diff", range], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
+    diffArgs = [`${commitSha}^!`];
     labelBase = commitSha.slice(0, 7);
   } else {
-    const [ns, num2, diff] = await Promise.all([
-      git(["diff", "--name-status", mergeBase], worktreePath, { reject: false }),
-      git(["diff", "--numstat", mergeBase], worktreePath, { reject: false }),
-      git(["diff", mergeBase], worktreePath, { reject: false })
-    ]);
-    nameStatus = ns.stdout;
-    numstat = num2.stdout;
-    combinedDiff = diff.stdout;
-    labelBase = base;
+    diffArgs = [mergeBase];
+    labelBase = baseLabel;
   }
-  const commits = await listBranchCommits(worktreePath, repoPath, { base });
+  const partsPromise = gitDiffParts(
+    worktreePath,
+    diffArgs,
+    includePatches,
+    pathFilter
+  );
+  const [parts, meta, untrackedPaths] = await Promise.all([
+    partsPromise,
+    metaPromise,
+    untrackedP
+  ]);
   const filesMap = /* @__PURE__ */ new Map();
-  for (const file of filesFromDiff(nameStatus, numstat, combinedDiff, maxHunk)) {
+  for (const file of filesFromDiff(
+    parts.nameStatus,
+    parts.numstat,
+    parts.combinedDiff,
+    maxHunk
+  )) {
     filesMap.set(file.path, file);
   }
   if (includeUntracked) {
-    const untrackedFiles = await listUntrackedFiles(worktreePath, maxHunk);
-    for (const file of untrackedFiles) {
+    const extra = includePatches ? await listUntrackedFiles(worktreePath, maxHunk, untrackedPaths) : untrackedStubs(untrackedPaths);
+    for (const file of extra) {
       if (!filesMap.has(file.path)) filesMap.set(file.path, file);
     }
+  } else if (fileOnly && pathFilter && !filesMap.has(pathFilter)) {
+    const maybe = await listUntrackedPaths(worktreePath, pathFilter);
+    if (maybe.length > 0) {
+      const extra = includePatches ? await listUntrackedFiles(worktreePath, maxHunk, maybe) : untrackedStubs(maybe);
+      for (const file of extra) filesMap.set(file.path, file);
+    }
   }
   const files = [...filesMap.values()].sort((a, b) => a.path.localeCompare(b.path));
-  const { stdout: statOut } = await git(
-    scope === "staged" ? ["diff", "--stat", "--cached"] : scope === "unstaged" ? ["diff", "--stat"] : scope === "uncommitted" ? ["diff", "--stat", "HEAD"] : scope === "last_turn" && lastTurnBase ? ["diff", "--stat", lastTurnBase] : scope === "commits" && commitSha ? ["diff", "--stat", `${commitSha}^!`] : ["diff", "--stat", mergeBase],
-    worktreePath,
-    { reject: false }
-  );
   return {
     scope,
     commitSha: scope === "commits" ? commitSha : null,
     base: labelBase,
     files,
-    stat: statOut.trim() || (files.length ? `${files.length} file(s)` : "(no changes)"),
-    dirty: await isDirty(worktreePath),
-    unpushed: await countUnpushedCommits(worktreePath),
+    stat: formatStat(files),
+    dirty: fileOnly || !includeMeta ? files.length > 0 : meta.dirty,
+    unpushed: meta.unpushed,
     hasLastTurnBase,
-    commits,
-    scopeStats
+    commits: meta.commits,
+    scopeStats: meta.scopeStats,
+    mergeBase: needsMergeBase ? mergeBase : null
   };
 }
 async function listWorktreeFiles(worktreePath, opts) {
@@ -12031,6 +12235,11 @@ var Orchestrator = class {
     return getDiff(thread.worktreePath, thread.repoPath, {
       scope: opts?.scope,
       commitSha: opts?.commitSha,
+      base: opts?.base,
+      includePatches: opts?.includePatches,
+      includeMeta: opts?.includeMeta,
+      includeUntracked: opts?.includeUntracked,
+      path: opts?.path,
       lastTurnBase: this.turnBaselines.get(thread.id) ?? null
     });
   }