@dotobokuri/fleet-console 1.23.0 → 1.25.0

package/dist/fleet-plugins/diff/routes.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from 'child_process';
 import 'fs';
-import path3 from 'path';
+import path2 from 'path';
 import fs from 'fs/promises';
 
 // sdk/plugin/node.ts
@@ -100,17 +100,22 @@ function runGit(args, opts) {
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function literalPathspec(relativePath) {
+  return `:(literal)${relativePath}`;
+}
 function normalizeNumstatPath(p) {
   const match = /^(.*?)\{[^}]* => ([^}]*)\}(.*)$/.exec(p);
-  if (!match) return p;
-  return (match[1] ?? "") + (match[2] ?? "") + (match[3] ?? "");
+  if (match) return (match[1] ?? "") + (match[2] ?? "") + (match[3] ?? "");
+  const plainRename = /^.+ => (.+)$/.exec(p);
+  return plainRename?.[1] ?? p;
 }
 function parseDiffFileList(nameStatusOutput, numstatOutput) {
   const numstatMap = /* @__PURE__ */ new Map();
   for (const line of numstatOutput.split("\n")) {
     const parts = line.split("	");
     if (parts.length < 3) continue;
-    const [adds, dels, filePath] = parts;
+    const [adds, dels] = parts;
+    const filePath = parts.length > 3 ? parts[parts.length - 1] : parts[2];
     if (!filePath) continue;
     numstatMap.set(normalizeNumstatPath(filePath), {
       additions: parseInt(adds ?? "0", 10) || 0,
@@ -123,16 +128,17 @@ function parseDiffFileList(nameStatusOutput, numstatOutput) {
     const [rawStatus, ...pathParts] = line.split("	");
     if (!rawStatus || pathParts.length === 0) continue;
     const statusChar = rawStatus.charAt(0).toUpperCase();
-    if (statusChar !== "M" && statusChar !== "A" && statusChar !== "D" && statusChar !== "R") continue;
+    if (statusChar !== "M" && statusChar !== "A" && statusChar !== "D" && statusChar !== "R" && statusChar !== "T") continue;
+    const oldPath = statusChar === "R" ? pathParts[0] : void 0;
     const filePath = statusChar === "R" ? pathParts[1] ?? pathParts[0] ?? "" : pathParts[0] ?? "";
     if (!filePath) continue;
     const nums = numstatMap.get(filePath) ?? { additions: 0, deletions: 0 };
-    files.push({ path: filePath, status: statusChar, ...nums });
+    files.push({ path: filePath, ...oldPath ? { oldPath } : {}, status: statusChar, ...nums });
   }
   return files;
 }
 async function fetchUntrackedFiles(cwd) {
-  const result = await runGit(["ls-files", "--others", "--exclude-standard"], { cwd });
+  const result = await runGit(["ls-files", "--others", "--exclude-standard", "--", "."], { cwd });
   return result.stdout.split("\n").filter((p) => p.trim()).map((p) => ({
     path: p,
     status: "U",
@@ -140,6 +146,9 @@ async function fetchUntrackedFiles(cwd) {
     deletions: 0
   }));
 }
+async function ensureGitRepository(cwd) {
+  await runGit(["rev-parse", "--is-inside-work-tree"], { cwd });
+}
 function isNoHeadError(error) {
   if (!(error instanceof GitExecutorError)) return false;
   if (error.code !== "non_zero_exit") return false;
@@ -147,9 +156,9 @@ function isNoHeadError(error) {
 }
 async function resolveGitCwd(theaterPath, rawSubPath) {
   if (rawSubPath === "") return { gitCwd: theaterPath };
-  const resolvedSub = path3.resolve(theaterPath, rawSubPath);
-  if (!resolvedSub.startsWith(theaterPath + path3.sep) && resolvedSub !== theaterPath) return null;
-  if (path3.normalize(rawSubPath).startsWith("..")) return null;
+  const resolvedSub = path2.resolve(theaterPath, rawSubPath);
+  if (!resolvedSub.startsWith(theaterPath + path2.sep) && resolvedSub !== theaterPath) return null;
+  if (path2.normalize(rawSubPath).startsWith("..")) return null;
   let realTheater;
   let realSub;
   try {
@@ -160,7 +169,7 @@ async function resolveGitCwd(theaterPath, rawSubPath) {
   } catch {
     return null;
   }
-  const norm = realTheater.endsWith(path3.sep) ? realTheater : realTheater + path3.sep;
+  const norm = realTheater.endsWith(path2.sep) ? realTheater : realTheater + path2.sep;
   if (realSub !== realTheater && !realSub.startsWith(norm)) return null;
   return { gitCwd: resolvedSub };
 }
@@ -196,20 +205,21 @@ async function handleDiffChanged(req, res, ctx) {
   }
   const { gitCwd } = cwdResult;
   try {
+    await ensureGitRepository(gitCwd);
     let files;
     let truncated = false;
     try {
       const [nameStatusResult, numstatResult] = await Promise.all([
-        runGit(["diff", "HEAD", "--name-status", "--diff-filter=MADR"], { cwd: gitCwd }),
-        runGit(["diff", "HEAD", "--numstat", "--diff-filter=MADR"], { cwd: gitCwd })
+        runGit(["diff", "HEAD", "--relative", "--name-status", "--diff-filter=MADRT", "--", "."], { cwd: gitCwd }),
+        runGit(["diff", "HEAD", "--relative", "--numstat", "--diff-filter=MADRT", "--", "."], { cwd: gitCwd })
       ]);
       files = parseDiffFileList(nameStatusResult.stdout, numstatResult.stdout);
       truncated = nameStatusResult.truncated || numstatResult.truncated;
     } catch (err) {
       if (!isNoHeadError(err)) throw err;
       const [nsResult, nsNumstat] = await Promise.all([
-        runGit(["diff", "--cached", "--name-status", "--diff-filter=MADR"], { cwd: gitCwd }),
-        runGit(["diff", "--cached", "--numstat", "--diff-filter=MADR"], { cwd: gitCwd })
+        runGit(["diff", "--cached", "--relative", "--name-status", "--diff-filter=MADRT", "--", "."], { cwd: gitCwd }),
+        runGit(["diff", "--cached", "--relative", "--numstat", "--diff-filter=MADRT", "--", "."], { cwd: gitCwd })
       ]);
       files = parseDiffFileList(nsResult.stdout, nsNumstat.stdout);
       truncated = nsResult.truncated || nsNumstat.truncated;
@@ -269,12 +279,12 @@ async function handleDiffFile(req, res, ctx) {
   }
   const { gitCwd } = cwdResult;
   const rawFilePath = body.filePath;
-  const resolvedFilePath = path3.resolve(gitCwd, rawFilePath);
-  if (!resolvedFilePath.startsWith(gitCwd + path3.sep) && resolvedFilePath !== gitCwd) {
+  const resolvedFilePath = path2.resolve(gitCwd, rawFilePath);
+  if (!resolvedFilePath.startsWith(gitCwd + path2.sep) && resolvedFilePath !== gitCwd) {
     ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
   }
-  const relativePath = path3.normalize(rawFilePath);
+  const relativePath = path2.normalize(rawFilePath);
   if (relativePath.startsWith("..")) {
     ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
@@ -292,12 +302,12 @@ async function handleDiffFile(req, res, ctx) {
         ctx.host.http.writeJson(res, 404, { error: "file_not_found" });
         return;
       }
-      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path3.sep)) {
+      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path2.sep)) {
         ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
         return;
       }
       const result2 = await runGit(
-        ["diff", "--no-index", "--unified=3", "--", "/dev/null", relativePath],
+        ["diff", "--no-index", "--relative", "--unified=3", "--", "/dev/null", relativePath],
         { cwd: gitCwd, allowExitCodes: [1] }
       );
       ctx.host.http.writeJson(res, 200, { content: result2.stdout, truncated: result2.truncated });
@@ -308,7 +318,7 @@ async function handleDiffFile(req, res, ctx) {
         fs.realpath(gitCwd),
         fs.realpath(resolvedFilePath)
       ]);
-      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path3.sep)) {
+      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path2.sep)) {
         ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
         return;
       }
@@ -316,10 +326,10 @@ async function handleDiffFile(req, res, ctx) {
     }
     let result;
     try {
-      result = await runGit(["diff", "HEAD", "--unified=3", "--", relativePath], { cwd: gitCwd });
+      result = await runGit(["diff", "HEAD", "--relative", "--unified=3", "--", literalPathspec(relativePath)], { cwd: gitCwd });
     } catch (err) {
       if (!isNoHeadError(err)) throw err;
-      result = await runGit(["diff", "--cached", "--unified=3", "--", relativePath], { cwd: gitCwd });
+      result = await runGit(["diff", "--cached", "--relative", "--unified=3", "--", literalPathspec(relativePath)], { cwd: gitCwd });
     }
     ctx.host.http.writeJson(res, 200, { content: result.stdout, truncated: result.truncated });
   } catch (error) {
@@ -340,6 +350,22 @@ var REF_RE = /^[0-9a-f]{7,40}$/i;
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function parseCommitMeta(output) {
+  const fields = output.split("\0");
+  if (fields.length < 6) return null;
+  const [authorName, authorEmail, rawAuthorAt, subject, rawParents, ...bodyParts] = fields;
+  if (authorName === void 0 || authorEmail === void 0 || rawAuthorAt === void 0 || subject === void 0 || rawParents === void 0) return null;
+  const authorAt = Number.parseInt(rawAuthorAt, 10);
+  if (!Number.isFinite(authorAt)) return null;
+  return {
+    authorName,
+    authorEmail,
+    authorAt,
+    subject,
+    body: bodyParts.join("\0").trimEnd(),
+    parents: rawParents.split(" ").filter(Boolean).map((full) => ({ full, short: full.slice(0, 9) }))
+  };
+}
 async function handleDiffCommit(req, res, ctx) {
   if (req.method !== "POST") {
     ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
@@ -377,8 +403,21 @@ async function handleDiffCommit(req, res, ctx) {
   }
   const { gitCwd } = cwdResult;
   try {
-    const result = await runGit(["show", ref, "--unified=3", "--format="], { cwd: gitCwd });
-    ctx.host.http.writeJson(res, 200, { content: result.stdout, ...result.truncated ? { truncated: true } : {} });
+    const [metaResult, nameStatusResult, numstatResult] = await Promise.all([
+      runGit(["show", "-s", "--format=%an%x00%ae%x00%at%x00%s%x00%P%x00%b", ref], { cwd: gitCwd }),
+      runGit(["show", "--first-parent", "--format=", "--relative", "--name-status", "--diff-filter=MADRT", ref, "--", "."], { cwd: gitCwd }),
+      runGit(["show", "--first-parent", "--format=", "--relative", "--numstat", "--diff-filter=MADRT", ref, "--", "."], { cwd: gitCwd })
+    ]);
+    const meta = parseCommitMeta(metaResult.stdout);
+    if (!meta) {
+      ctx.host.http.writeJson(res, 500, { error: "git_failed" });
+      return;
+    }
+    ctx.host.http.writeJson(res, 200, {
+      meta,
+      files: parseDiffFileList(nameStatusResult.stdout, numstatResult.stdout),
+      ...metaResult.truncated || nameStatusResult.truncated || numstatResult.truncated ? { truncated: true } : {}
+    });
   } catch (error) {
     if (error instanceof GitExecutorError) {
       if (error.code === "no_git_repo" || error.code === "git_unavailable") {
@@ -391,51 +430,19 @@ async function handleDiffCommit(req, res, ctx) {
     throw error;
   }
 }
-
-// ../fleet-plugins/diff/server/log.ts
 function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function parseLogOutput(stdout) {
-  if (!stdout.trim()) return [];
-  const commits = [];
-  for (const chunk of stdout.split("")) {
-    const trimmed = chunk.trimStart();
-    if (!trimmed) continue;
-    const lines = trimmed.split("\n");
-    const firstLine = lines[0] ?? "";
-    const fields = firstLine.split("\0");
-    const fullHash = fields[0] ?? "";
-    const shortHash = fields[1] ?? "";
-    const subject = fields[2] ?? "";
-    const authorName = fields[3] ?? "";
-    const relTime = fields[4] ?? "";
-    const refsRaw = fields[5] ?? "";
-    const parentsRaw = fields[6] ?? "";
-    if (!fullHash) continue;
-    const refs = refsRaw.split(",").map((r) => r.trim()).filter(Boolean);
-    const parents = parentsRaw.split(" ").map((p) => p.trim()).filter(Boolean);
-    let additions = 0;
-    let deletions = 0;
-    for (const line of lines.slice(1)) {
-      if (!line.trim()) continue;
-      const parts = line.split("	");
-      if (parts.length < 2) continue;
-      const a = parseInt(parts[0] ?? "0", 10);
-      const d = parseInt(parts[1] ?? "0", 10);
-      if (!isNaN(a)) additions += a;
-      if (!isNaN(d)) deletions += d;
-    }
-    commits.push({ shortHash, fullHash, subject, authorName, relTime, refs, parents, additions, deletions });
-  }
-  return commits;
+function resolveLiteralFilePath(gitCwd, rawPath) {
+  const relativePath = path2.normalize(rawPath);
+  const resolved = path2.resolve(gitCwd, relativePath);
+  if (relativePath === ".." || relativePath.startsWith(".." + path2.sep) || !resolved.startsWith(gitCwd + path2.sep)) return null;
+  return relativePath;
 }
-function isNoHeadError2(error) {
-  if (!(error instanceof GitExecutorError)) return false;
-  if (error.code !== "non_zero_exit") return false;
-  return error.stderr.includes("unknown revision") || error.stderr.includes("bad revision");
+function literalPathspec2(relativePath) {
+  return `:(literal)${relativePath}`;
 }
-async function handleDiffLog(req, res, ctx) {
+async function handleDiffCommitFile(req, res, ctx) {
   if (req.method !== "POST") {
     ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
     return;
@@ -445,186 +452,163 @@ async function handleDiffLog(req, res, ctx) {
     return;
   }
   const body = await ctx.host.http.readJsonBody(req);
-  if (!isPlainObject3(body)) {
+  if (!isPlainObject3(body) || typeof body.theaterId !== "string" || typeof body.ref !== "string" || typeof body.filePath !== "string") {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
-  const theaterId = body.theaterId;
-  if (typeof theaterId !== "string") {
-    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+  if (!REF_RE.test(body.ref)) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_ref" });
     return;
   }
-  const theaterPath = ctx.host.paths.resolveTheaterPath(theaterId);
+  if (!body.filePath) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_file_path" });
+    return;
+  }
+  if (body.oldPath !== void 0 && (typeof body.oldPath !== "string" || !body.oldPath)) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_file_path" });
+    return;
+  }
+  const theaterPath = ctx.host.paths.resolveTheaterPath(body.theaterId);
   if (!theaterPath) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
-  const rawSubPath = typeof body.subPath === "string" ? body.subPath : "";
-  const cwdResult = await resolveGitCwd(theaterPath, rawSubPath);
+  const cwdResult = await resolveGitCwd(theaterPath, typeof body.subPath === "string" ? body.subPath : "");
   if (!cwdResult) {
     ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
   }
-  const { gitCwd } = cwdResult;
+  const relativePath = resolveLiteralFilePath(cwdResult.gitCwd, body.filePath);
+  const oldPath = typeof body.oldPath === "string" ? resolveLiteralFilePath(cwdResult.gitCwd, body.oldPath) : void 0;
+  if (!relativePath || body.oldPath !== void 0 && !oldPath) {
+    ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
+    return;
+  }
   try {
-    const result = await runGit(
-      ["log", "-n", "50", "--numstat", "--pretty=format:%x1e%H%x00%h%x00%s%x00%an%x00%ar%x00%D%x00%P"],
-      { cwd: gitCwd }
-    );
-    const commits = parseLogOutput(result.stdout);
-    ctx.host.http.writeJson(res, 200, { commits, ...result.truncated ? { truncated: true } : {} });
+    const result = await runGit(oldPath ? ["show", "--first-parent", body.ref, "-M", "--format=", "--unified=3", "--", literalPathspec2(oldPath), literalPathspec2(relativePath)] : ["show", "--first-parent", body.ref, "--format=", "--unified=3", "--", literalPathspec2(relativePath)], { cwd: cwdResult.gitCwd });
+    ctx.host.http.writeJson(res, 200, { content: result.stdout, ...result.truncated ? { truncated: true } : {} });
   } catch (error) {
     if (error instanceof GitExecutorError) {
-      if (error.code === "no_git_repo") {
-        ctx.host.http.writeJson(res, 200, { commits: [] });
-        return;
-      }
-      if (error.code === "git_unavailable") {
+      if (error.code === "no_git_repo" || error.code === "git_unavailable") {
         ctx.host.http.writeJson(res, 422, { error: error.code });
         return;
       }
-      if (isNoHeadError2(error)) {
-        ctx.host.http.writeJson(res, 200, { commits: [] });
-        return;
-      }
       ctx.host.http.writeJson(res, 500, { error: "git_failed" });
       return;
     }
     throw error;
   }
 }
-var REPOS_CAP = 200;
-var HARD_CAP_DEPTH = 8;
-var DEFAULT_DEPTH = 3;
+var WORKTREE_SHA_RE = /^[0-9a-f]{40}$/;
 function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function resolveRepoBranch(repoDir) {
-  try {
-    const result = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: repoDir });
-    const branch = result.stdout.trim();
-    if (branch === "HEAD") {
-      const sha = await runGit(["rev-parse", "--short", "HEAD"], { cwd: repoDir });
-      return sha.stdout.trim() || "HEAD";
-    }
-    return branch || "HEAD";
-  } catch {
-    return "unknown";
+function parseLogOutput(stdout) {
+  if (!stdout.trim()) return [];
+  const commits = [];
+  for (const chunk of stdout.split("")) {
+    const trimmed = chunk.trimStart();
+    if (!trimmed) continue;
+    const lines = trimmed.split("\n");
+    const firstLine = lines[0] ?? "";
+    const fields = firstLine.split("\0");
+    const fullHash = fields[0] ?? "";
+    const shortHash = fields[1] ?? "";
+    const subject = fields[2] ?? "";
+    const authorName = fields[3] ?? "";
+    const relTime = fields[4] ?? "";
+    const authorAt = Number.parseInt(fields[5] ?? "0", 10);
+    const refsRaw = fields[6] ?? "";
+    const parentsRaw = fields[7] ?? "";
+    if (!fullHash) continue;
+    const refs = refsRaw.split(",").map((r) => r.trim()).filter(Boolean);
+    const parents = parentsRaw.split(" ").map((p) => p.trim()).filter(Boolean);
+    commits.push({
+      shortHash,
+      fullHash,
+      subject,
+      authorName,
+      relTime,
+      authorAt: Number.isFinite(authorAt) ? authorAt : 0,
+      refs,
+      parents,
+      onHead: true
+    });
   }
+  return commits;
 }
-async function detectWorktreeParent(dir, gitFileContent) {
-  const match = gitFileContent.trim().match(/^gitdir:\s*(.+)$/m);
-  if (!match) return null;
-  const rawPointer = match[1].trim();
-  const resolvedGitdir = path3.normalize(
-    path3.isAbsolute(rawPointer) ? rawPointer : path3.resolve(dir, rawPointer)
-  );
-  if (resolvedGitdir.includes(`${path3.sep}modules${path3.sep}`)) {
-    return null;
-  }
-  const worktreesSegment = `${path3.sep}.git${path3.sep}worktrees${path3.sep}`;
-  const wtIdx = resolvedGitdir.indexOf(worktreesSegment);
-  if (wtIdx === -1) {
-    return null;
+async function parseWorktreePorcelain(stdout, currentWorktreePath) {
+  const worktrees = [];
+  let worktreePath = null;
+  let sha = "";
+  let branch = null;
+  let prunable = false;
+  const pushCurrent = () => {
+    if (!worktreePath || !sha || prunable || /^0+$/.test(sha)) return;
+    worktrees.push({
+      sha,
+      branch,
+      worktreePath
+    });
+  };
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      pushCurrent();
+      worktreePath = line.slice(9);
+      sha = "";
+      branch = null;
+      prunable = false;
+    } else if (line.startsWith("HEAD ")) {
+      sha = line.slice(5);
+    } else if (line.startsWith("branch ")) {
+      const ref = line.slice(7);
+      branch = ref.startsWith("refs/heads/") ? ref.slice(11) : ref;
+    } else if (line === "prunable" || line.startsWith("prunable ")) {
+      prunable = true;
+    }
   }
-  const parentAbsRaw = resolvedGitdir.slice(0, wtIdx);
-  let parentAbs;
+  pushCurrent();
+  const normalizedCurrentWorktreePath = await normalizeWorktreePath(currentWorktreePath);
+  return Promise.all(worktrees.map(async ({ worktreePath: worktreePath2, ...checkout }) => ({
+    ...checkout,
+    isCurrent: normalizedCurrentWorktreePath !== "" && await normalizeWorktreePath(worktreePath2) === normalizedCurrentWorktreePath
+  })));
+}
+function annotateHeadReachability(commits, revListStdout) {
+  const reachable = new Set(revListStdout.split("\n").map((line) => line.trim()).filter(Boolean));
+  if (reachable.size === 0) return commits;
+  return commits.map((commit) => ({ ...commit, onHead: reachable.has(commit.fullHash) }));
+}
+function isNoHeadError2(error) {
+  if (!(error instanceof GitExecutorError)) return false;
+  if (error.code !== "non_zero_exit") return false;
+  return error.stderr.includes("unknown revision") || error.stderr.includes("bad revision") || error.stderr.includes("does not have any commits");
+}
+async function normalizeWorktreePath(worktreePath) {
+  if (!worktreePath) return "";
   try {
-    parentAbs = await fs.realpath(parentAbsRaw);
+    return await fs.realpath(worktreePath);
   } catch {
-    parentAbs = path3.normalize(parentAbsRaw);
+    return worktreePath;
   }
-  return { isWorktree: true, parentAbs };
 }
-async function scanRepos(theaterPath, realTheaterPath, dir, currentDepth, maxDepth, repos, cap = REPOS_CAP) {
-  if (repos.length >= cap) return true;
-  const gitPath = path3.join(dir, ".git");
+async function readHeadRevList(gitCwd) {
   try {
-    const gitStat = await fs.stat(gitPath);
-    const relPath = path3.relative(theaterPath, dir);
-    const name = relPath === "" ? path3.basename(theaterPath) : path3.basename(dir);
-    const branch = await resolveRepoBranch(dir);
-    if (gitStat.isFile()) {
-      const content = await fs.readFile(gitPath, "utf8");
-      const worktreeResult = await detectWorktreeParent(dir, content);
-      if (worktreeResult) {
-        repos.push({ relPath, name, branch, isWorktree: true, _wtParentAbs: worktreeResult.parentAbs });
-      } else {
-        repos.push({ relPath, name, branch });
-      }
-    } else {
-      repos.push({ relPath, name, branch });
-    }
-    if (repos.length >= cap) return true;
-  } catch {
+    return (await runGit(["rev-list", "-n", "1000", "HEAD"], { cwd: gitCwd })).stdout;
+  } catch (error) {
+    if (error instanceof GitExecutorError) return "";
+    throw error;
   }
-  if (currentDepth >= maxDepth) return false;
-  let dirHandle = null;
+}
+async function readCurrentWorktreePath(gitCwd) {
   try {
-    dirHandle = await fs.opendir(dir);
-    try {
-      let dirent = await dirHandle.read();
-      while (dirent !== null) {
-        if (repos.length >= cap) return true;
-        if (dirent.isDirectory()) {
-          const childName = dirent.name;
-          if (childName === "node_modules" || childName === ".git") {
-            dirent = await dirHandle.read();
-            continue;
-          }
-          const childPath = path3.join(dir, childName);
-          let realChildPath;
-          try {
-            realChildPath = await fs.realpath(childPath);
-          } catch {
-            dirent = await dirHandle.read();
-            continue;
-          }
-          const normalizedReal = realTheaterPath.endsWith(path3.sep) ? realTheaterPath : realTheaterPath + path3.sep;
-          if (realChildPath !== realTheaterPath && !realChildPath.startsWith(normalizedReal)) {
-            dirent = await dirHandle.read();
-            continue;
-          }
-          const truncated = await scanRepos(theaterPath, realTheaterPath, childPath, currentDepth + 1, maxDepth, repos, cap);
-          if (truncated) return true;
-        }
-        dirent = await dirHandle.read();
-      }
-      return false;
-    } finally {
-      await dirHandle.close();
-    }
-  } catch {
-    if (dirHandle) {
-      try {
-        await dirHandle.close();
-      } catch {
-      }
-    }
-    return false;
+    return (await runGit(["rev-parse", "--show-toplevel"], { cwd: gitCwd })).stdout.trim();
+  } catch (error) {
+    if (error instanceof GitExecutorError) return "";
+    throw error;
   }
 }
-function resolveWorktreeParents(raw, realTheaterPath) {
-  const absToRelPath = /* @__PURE__ */ new Map();
-  for (const entry of raw) {
-    const absDir = path3.normalize(
-      entry.relPath === "" ? realTheaterPath : path3.join(realTheaterPath, entry.relPath)
-    );
-    absToRelPath.set(absDir, entry.relPath);
-  }
-  return raw.map((entry) => {
-    const { _wtParentAbs, ...rest } = entry;
-    if (_wtParentAbs && entry.isWorktree) {
-      const normalizedParent = path3.normalize(_wtParentAbs);
-      const parentRelPath = absToRelPath.get(normalizedParent);
-      if (parentRelPath !== void 0) {
-        return { ...rest, worktreeOf: parentRelPath };
-      }
-    }
-    return rest;
-  });
-}
-async function handleDiffRepos(req, res, ctx) {
+async function handleDiffLog(req, res, ctx) {
   if (req.method !== "POST") {
     ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
     return;
@@ -648,35 +632,54 @@ async function handleDiffRepos(req, res, ctx) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
-  const rawDepth = body.maxDepth;
-  const maxDepth = typeof rawDepth === "number" && Number.isFinite(rawDepth) && rawDepth >= 1 ? Math.min(HARD_CAP_DEPTH, Math.floor(rawDepth)) : DEFAULT_DEPTH;
-  let realTheaterPath;
-  try {
-    realTheaterPath = await fs.realpath(theaterPath);
-  } catch {
-    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+  const rawSubPath = typeof body.subPath === "string" ? body.subPath : "";
+  const cwdResult = await resolveGitCwd(theaterPath, rawSubPath);
+  if (!cwdResult) {
+    ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
   }
-  const raw = [];
-  const truncated = await scanRepos(theaterPath, realTheaterPath, theaterPath, 0, maxDepth, raw);
-  const resolved = resolveWorktreeParents(raw, realTheaterPath);
-  resolved.sort((a, b) => {
-    if (a.relPath === "") return -1;
-    if (b.relPath === "") return 1;
-    return a.relPath.localeCompare(b.relPath);
-  });
-  const result = { repos: resolved, ...truncated ? { truncated: true } : {} };
-  ctx.host.http.writeJson(res, 200, result);
+  const { gitCwd } = cwdResult;
+  try {
+    const [worktrees, currentWorktreePath, headRevList] = await Promise.all([
+      runGit(["worktree", "list", "--porcelain"], { cwd: gitCwd }),
+      readCurrentWorktreePath(gitCwd),
+      readHeadRevList(gitCwd)
+    ]);
+    const checkouts = await parseWorktreePorcelain(worktrees.stdout, currentWorktreePath);
+    const worktreeRevs = [...new Set(checkouts.map((checkout) => checkout.sha))].filter((sha) => WORKTREE_SHA_RE.test(sha) && !/^0+$/.test(sha));
+    const headRevs = headRevList ? ["HEAD"] : [];
+    const result = await runGit(
+      // --all은 refs/stash·refs/notes까지 그래프에 유입시키므로 브랜치/태그/원격 + 현재 HEAD + 워크트리 HEAD로 한정한다
+      ["log", "--branches", "--tags", "--remotes", "--date-order", "-n", "200", "--relative", "--decorate=full", "--pretty=format:%x1e%H%x00%h%x00%s%x00%an%x00%ar%x00%at%x00%D%x00%P", ...headRevs, ...worktreeRevs, "--", "."],
+      { cwd: gitCwd }
+    );
+    const commits = annotateHeadReachability(parseLogOutput(result.stdout), headRevList);
+    ctx.host.http.writeJson(res, 200, { commits, checkouts, ...result.truncated ? { truncated: true } : {} });
+  } catch (error) {
+    if (error instanceof GitExecutorError) {
+      if (error.code === "no_git_repo") {
+        ctx.host.http.writeJson(res, 200, { commits: [], checkouts: [] });
+        return;
+      }
+      if (error.code === "git_unavailable") {
+        ctx.host.http.writeJson(res, 422, { error: error.code });
+        return;
+      }
+      if (isNoHeadError2(error)) {
+        ctx.host.http.writeJson(res, 200, { commits: [], checkouts: [] });
+        return;
+      }
+      ctx.host.http.writeJson(res, 500, { error: "git_failed" });
+      return;
+    }
+    throw error;
+  }
 }
 
 // ../fleet-plugins/diff/routes.ts
 var routes_default = definePlugin({
   id: "diff",
   register(ctx) {
-    registerRouter(ctx, "repos", async ({ req, res }) => {
-      await handleDiffRepos(req, res, ctx);
-      return true;
-    });
     registerRouter(ctx, "changed", async ({ req, res }) => {
       await handleDiffChanged(req, res, ctx);
       return true;
@@ -693,6 +696,10 @@ var routes_default = definePlugin({
       await handleDiffCommit(req, res, ctx);
       return true;
     });
+    registerRouter(ctx, "commit-file", async ({ req, res }) => {
+      await handleDiffCommitFile(req, res, ctx);
+      return true;
+    });
   }
 });