farming-code 2.2.29 → 2.2.32

package/backend/review-diff-service.cjs

@@ -0,0 +1,1267 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var review_diff_service_exports = {};
+__export(review_diff_service_exports, {
+  ReviewDiffService: () => ReviewDiffService,
+  fileFromPatch: () => fileFromPatch,
+  filterWorkingCopyChangeItems: () => filterWorkingCopyChangeItems,
+  gitContextArgs: () => gitContextArgs,
+  gitDiffPathspecArgs: () => gitDiffPathspecArgs,
+  gitRangeReviewId: () => gitRangeReviewId,
+  gitWhitespaceArgs: () => gitWhitespaceArgs,
+  metadataFile: () => metadataFile,
+  normalizeDiffContext: () => normalizeDiffContext,
+  normalizeIgnoreWhitespace: () => normalizeIgnoreWhitespace,
+  normalizeModifiedWithinDays: () => normalizeModifiedWithinDays,
+  normalizeReviewLimit: () => normalizeReviewLimit,
+  normalizeWorkingCopyScope: () => normalizeWorkingCopyScope,
+  parseComparisonBranches: () => parseComparisonBranches,
+  parseComparisonCommits: () => parseComparisonCommits,
+  parseNameStatus: () => parseNameStatus,
+  parseNumstat: () => parseNumstat,
+  parseRawDiffMetadata: () => parseRawDiffMetadata,
+  patchDiffHeader: () => patchDiffHeader,
+  patchMetadata: () => patchMetadata,
+  untrackedHunks: () => untrackedHunks,
+  untrackedPatch: () => untrackedPatch,
+  workingCopyPatchset: () => workingCopyPatchset,
+  workingCopyReviewId: () => workingCopyReviewId
+});
+module.exports = __toCommonJS(review_diff_service_exports);
+var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_workspace_file_service = require("./workspace-file-service.cjs");
+const MAX_REVIEW_FILES = 200;
+const MAX_WORKING_COPY_SCAN_FILES = 2e3;
+const MAX_UNTRACKED_LINES = 500;
+const MAX_REVIEW_CONTEXT_RANGE_LINES = 1e4;
+const DIFF_CONCURRENCY = 4;
+function errorField(error, field) {
+  return error && typeof error === "object" && field in error ? error[field] : void 0;
+}
+function errorString(error, field) {
+  const value = errorField(error, field);
+  return value ? String(value) : "";
+}
+function reviewKind(gitStatus) {
+  if (gitStatus === "added" || gitStatus === "untracked") return "added";
+  if (gitStatus === "copied") return "copied";
+  if (gitStatus === "deleted") return "deleted";
+  if (gitStatus === "renamed") return "renamed";
+  if (gitStatus === "rewritten") return "rewritten";
+  return "modified";
+}
+function reviewStatus(kind) {
+  if (kind === "added") return "A";
+  if (kind === "copied") return "C";
+  if (kind === "deleted") return "D";
+  if (kind === "renamed") return "R";
+  if (kind === "rewritten") return "W";
+  if (kind === "unmodified") return "U";
+  if (kind === "reverted") return "X";
+  return "M";
+}
+function countRows(hunks) {
+  return hunks.reduce((total, hunk) => hunk.rows.reduce((count, row) => ({
+    added: count.added + (row.kind === "added" || row.kind === "changed" ? 1 : 0),
+    removed: count.removed + (row.kind === "deleted" || row.kind === "changed" ? 1 : 0)
+  }), total), { added: 0, removed: 0 });
+}
+function metadataOnlyOption(value) {
+  return value === true || value === "1" || value === "true";
+}
+function normalizeIgnoreWhitespace(value) {
+  if (value === "ALL" || value === "IGNORE_ALL") return "ALL";
+  if (value === "TRAILING" || value === "IGNORE_TRAILING") return "TRAILING";
+  if (value === "LEADING_AND_TRAILING" || value === "IGNORE_LEADING_AND_TRAILING") return "LEADING_AND_TRAILING";
+  return "NONE";
+}
+function normalizeDiffContext(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const context = Number(value);
+  if (!Number.isInteger(context) || context < 0) return void 0;
+  return Math.min(context, 1e4);
+}
+function normalizeReviewLimit(value) {
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit <= 0) return MAX_REVIEW_FILES;
+  return Math.min(MAX_REVIEW_FILES, limit);
+}
+function normalizeContextRangeInteger(value, name, { allowZero = false } = {}) {
+  const number = Number(value);
+  const minimum = allowZero ? 0 : 1;
+  if (!Number.isInteger(number) || number < minimum) {
+    throw new import_workspace_file_service.WorkspaceFileError(`${name} must be an integer greater than or equal to ${minimum}`, 400);
+  }
+  return number;
+}
+function textLines(content) {
+  if (content === void 0 || content === null || content === "") return [];
+  const lines = String(content).split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+}
+function reviewTextFileMeta(name, lines) {
+  return {
+    contentType: "text/plain",
+    lines: lines.length,
+    name
+  };
+}
+function contextRowsFromSources(sources, options = {}) {
+  const oldStart = normalizeContextRangeInteger(options.oldStart, "oldStart");
+  const newStart = normalizeContextRangeInteger(options.newStart, "newStart");
+  const requestedLines = normalizeContextRangeInteger(options.lines, "lines");
+  if (requestedLines > MAX_REVIEW_CONTEXT_RANGE_LINES) {
+    throw new import_workspace_file_service.WorkspaceFileError(`lines must not exceed ${MAX_REVIEW_CONTEXT_RANGE_LINES}`, 400);
+  }
+  const left = sources.leftLines.slice(oldStart - 1, oldStart - 1 + requestedLines);
+  const right = sources.rightLines.slice(newStart - 1, newStart - 1 + requestedLines);
+  if (left.length !== requestedLines || right.length !== requestedLines) {
+    throw new import_workspace_file_service.WorkspaceFileError("review context range is outside the file", 416);
+  }
+  return {
+    leftLines: sources.leftLines.length,
+    rightLines: sources.rightLines.length,
+    rows: Array.from({ length: requestedLines }, (_, index) => ({
+      kind: "context",
+      left: { line: oldStart + index, text: left[index] },
+      right: { line: newStart + index, text: right[index] }
+    }))
+  };
+}
+function normalizeWorkingCopyScope(value) {
+  return value === "tracked" || value === "untracked" ? value : void 0;
+}
+function normalizeModifiedWithinDays(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const days = Number(value);
+  return Number.isInteger(days) && days >= 1 && days <= 3650 ? days : void 0;
+}
+function filterWorkingCopyChangeItems(root, items, options = {}, now = Date.now()) {
+  const scope = normalizeWorkingCopyScope(options.scope);
+  let filtered = items;
+  if (scope === "tracked") {
+    filtered = items.filter((change) => change.gitStatus !== "untracked");
+  } else if (scope === "untracked") {
+    filtered = items.filter((change) => change.gitStatus === "untracked");
+    const modifiedWithinDays = normalizeModifiedWithinDays(options.modifiedWithinDays);
+    if (modifiedWithinDays !== void 0) {
+      const modifiedSince = now - modifiedWithinDays * 24 * 60 * 60 * 1e3;
+      filtered = filtered.filter((change) => {
+        if (!isSafeReviewPath(change.path)) return false;
+        try {
+          return fs.statSync(path.join(root, change.path)).mtimeMs >= modifiedSince;
+        } catch {
+          return false;
+        }
+      });
+    }
+  }
+  return filtered;
+}
+function gitWhitespaceArgs(value) {
+  const normalized = normalizeIgnoreWhitespace(value);
+  if (normalized === "ALL") return ["--ignore-all-space"];
+  if (normalized === "TRAILING") return ["--ignore-space-at-eol"];
+  if (normalized === "LEADING_AND_TRAILING") return ["--ignore-space-change"];
+  return [];
+}
+function gitContextArgs(value) {
+  const context = normalizeDiffContext(value);
+  return context === void 0 ? [] : [`--unified=${context}`];
+}
+function diffContentOptions(options = {}) {
+  const ignoreWhitespace = normalizeIgnoreWhitespace(options.ignoreWhitespace);
+  const context = normalizeDiffContext(options.context);
+  return {
+    ...ignoreWhitespace !== "NONE" ? { ignoreWhitespace } : {},
+    ...context !== void 0 ? { context } : {}
+  };
+}
+function hasOptions(value) {
+  return Object.keys(value).length > 0;
+}
+function reviewFileIdentity(file) {
+  return {
+    added: file.added,
+    binary: file.binary === true,
+    kind: file.kind,
+    newMode: file.newMode || "",
+    newSha: file.newSha || "",
+    oldMode: file.oldMode || "",
+    oldSha: file.oldSha || "",
+    path: file.path,
+    previousPath: file.previousPath || "",
+    removed: file.removed,
+    size: Number.isInteger(file.size) ? file.size : null,
+    sizeDelta: Number.isInteger(file.sizeDelta) ? file.sizeDelta : null,
+    status: file.status || reviewStatus(file.kind)
+  };
+}
+function metadataFile(change, options = {}) {
+  const kind = change.kind || reviewKind(change.gitStatus);
+  return {
+    added: typeof options.added === "number" && Number.isInteger(options.added) && options.added >= 0 ? options.added : 0,
+    ...options.binary === true ? { binary: true } : {},
+    diff: { hunks: [], ...options.truncated === true ? { truncated: true } : {} },
+    diffLoaded: false,
+    ...options.diffTooExpensive === true ? { diffTooExpensive: true } : {},
+    kind,
+    ...typeof options.newMode === "string" ? { newMode: options.newMode } : {},
+    ...typeof options.newSha === "string" ? { newSha: options.newSha } : {},
+    ...typeof options.oldMode === "string" ? { oldMode: options.oldMode } : {},
+    ...typeof options.oldSha === "string" ? { oldSha: options.oldSha } : {},
+    path: change.path,
+    ...change.previousPath ? { previousPath: change.previousPath } : {},
+    removed: typeof options.removed === "number" && Number.isInteger(options.removed) && options.removed >= 0 ? options.removed : 0,
+    ...Number.isInteger(options.size) ? { size: options.size } : {},
+    ...Number.isInteger(options.sizeDelta) ? { sizeDelta: options.sizeDelta } : {},
+    status: change.status || reviewStatus(kind)
+  };
+}
+function assertUniqueReviewPaths(files) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (seen.has(file.path)) throw new import_workspace_file_service.WorkspaceFileError("review snapshot contains duplicate file paths", 500);
+    seen.add(file.path);
+  }
+  return files;
+}
+function untrackedLines(content) {
+  const lines = String(content || "").split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+}
+function untrackedHunks(content) {
+  const lines = untrackedLines(content);
+  const visibleLines = lines.slice(0, MAX_UNTRACKED_LINES);
+  return [{
+    header: `@@ -0,0 +1,${visibleLines.length} @@`,
+    oldStart: 0,
+    oldLines: 0,
+    newStart: 1,
+    newLines: visibleLines.length,
+    rows: visibleLines.map((text, index) => ({ kind: "added", right: { line: index + 1, text } }))
+  }];
+}
+function untrackedPatch(filePath, content) {
+  const lines = untrackedLines(content);
+  const visibleLines = lines.slice(0, MAX_UNTRACKED_LINES);
+  const suffix = visibleLines.length ? `${visibleLines.map((line) => `+${line}`).join("\n")}
+` : "";
+  return [
+    `diff --git a/${filePath} b/${filePath}`,
+    "new file mode 100644",
+    "--- /dev/null",
+    `+++ b/${filePath}`,
+    `@@ -0,0 +1,${visibleLines.length} @@`,
+    suffix
+  ].join("\n");
+}
+function untrackedContentTooLarge(content) {
+  return untrackedLines(content).length > MAX_UNTRACKED_LINES;
+}
+async function mapWithConcurrency(values, mapper) {
+  const result = new Array(values.length);
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(DIFF_CONCURRENCY, values.length) }, async () => {
+    while (next < values.length) {
+      const index = next++;
+      result[index] = await mapper(values[index]);
+    }
+  }));
+  return result;
+}
+function stableHash(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex");
+}
+function reviewRootIdentity(root) {
+  try {
+    return fs.realpathSync.native(root);
+  } catch {
+    return root;
+  }
+}
+function workingCopyReviewId(root, options = {}) {
+  const scope = normalizeWorkingCopyScope(options.scope);
+  if (!scope) return `working-copy-${stableHash(reviewRootIdentity(root)).slice(0, 24)}`;
+  const modifiedWithinDays = scope === "untracked" ? normalizeModifiedWithinDays(options.modifiedWithinDays) : void 0;
+  const identity = [reviewRootIdentity(root), scope, modifiedWithinDays || "all"].join("\n");
+  return `working-copy-${stableHash(identity).slice(0, 24)}`;
+}
+function workingCopyPatchset(files) {
+  return `Working copy ${stableHash(JSON.stringify(files.map(reviewFileIdentity))).slice(0, 12)}`;
+}
+function gitRangeReviewId(root, base, head) {
+  return `git-range-${stableHash(`${reviewRootIdentity(root)}
+${base}
+${head}`).slice(0, 24)}`;
+}
+function parseComparisonCommits(value) {
+  return String(value || "").split("").map((record) => record.trim()).filter(Boolean).map((record) => {
+    const [id = "", parents = "", shortId = "", ...subjectParts] = record.split("");
+    const parent = parents.trim().split(/\s+/).filter(Boolean)[0];
+    const subject = subjectParts.join("").trim();
+    if (!/^[a-f0-9]{40,64}$/i.test(id) || !/^[a-f0-9]{40,64}$/i.test(parent || "")) return null;
+    return {
+      base: parent,
+      head: id,
+      id: `commit:${id}`,
+      label: `${shortId || id.slice(0, 8)} ${subject || "Commit"}`.trim()
+    };
+  }).filter((commit) => commit !== null);
+}
+function parseComparisonBranches(value, currentBranch) {
+  return String(value || "").split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const [name = "", id = ""] = line.split("\0");
+    if (!name || name === currentBranch || name.endsWith("/HEAD") || !/^[a-f0-9]{40,64}$/i.test(id)) return null;
+    return { id, name };
+  }).filter((branch) => branch !== null);
+}
+function isSafeGitRevision(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 200 && !value.startsWith("-") && !/[\\\0\r\n\t ]/.test(value);
+}
+function isReviewHead(value) {
+  return value === "now" || isSafeGitRevision(value);
+}
+function gitRangeRevisionArgs(base, head) {
+  return head === "now" ? [base] : [base, head];
+}
+function isSafeReviewPath(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.includes("\0") && !value.startsWith("/") && !value.startsWith("\\") && value.split(/[\\/]/).every((segment) => segment && segment !== "." && segment !== "..");
+}
+function nulFields(stdout) {
+  const fields = String(stdout || "").split("\0");
+  if (fields.at(-1) === "") fields.pop();
+  return fields;
+}
+function changeFromStatus(status, path2, previousPath) {
+  const filePath = path2 || "";
+  if (status.startsWith("R")) return { kind: "renamed", path: filePath, previousPath, status: "R" };
+  if (status.startsWith("C")) return { kind: "copied", path: filePath, previousPath, status: "C" };
+  if (status === "A") return { kind: "added", path: filePath, status: "A" };
+  if (status === "D") return { kind: "deleted", path: filePath, status: "D" };
+  if (status === "W") return { kind: "rewritten", path: filePath, status: "W" };
+  return { kind: "modified", path: filePath, status: "M" };
+}
+function parseNameStatus(stdout) {
+  if (String(stdout || "").includes("\0")) {
+    const fields = nulFields(stdout);
+    const changes = [];
+    for (let index = 0; index < fields.length; ) {
+      const status = fields[index++] || "";
+      if (status.startsWith("R") || status.startsWith("C")) {
+        const previousPath = fields[index++];
+        const filePath2 = fields[index++];
+        if (filePath2) changes.push(changeFromStatus(status, filePath2, previousPath));
+        continue;
+      }
+      const filePath = fields[index++];
+      if (filePath) changes.push(changeFromStatus(status, filePath));
+    }
+    return changes;
+  }
+  return String(stdout || "").split("\n").filter(Boolean).map((line) => {
+    const fields = line.split("	");
+    const status = fields[0] || "";
+    return changeFromStatus(status, status.startsWith("R") || status.startsWith("C") ? fields[2] : fields[1], fields[1]);
+  }).filter((file) => file.path);
+}
+function normalizedNumstatPath(pathField) {
+  const value = String(pathField || "");
+  const braceRename = value.match(/^(.*)\{.* => (.*)\}(.*)$/);
+  if (braceRename) return `${braceRename[1]}${braceRename[2]}${braceRename[3]}`;
+  return value;
+}
+function numstatPathForChanges(pathField, changes = []) {
+  const value = String(pathField || "");
+  if (!value) return "";
+  if (changes.some((change) => change.path === value)) return value;
+  const bracePath = normalizedNumstatPath(value);
+  const renamed = changes.find((change) => {
+    if (!change.previousPath) return false;
+    if (bracePath && change.path === bracePath) return true;
+    if (value === `${change.previousPath} => ${change.path}`) return true;
+    return false;
+  });
+  if (renamed) return renamed.path;
+  return value;
+}
+function splitNumstatEntry(value) {
+  const text = String(value || "");
+  const first = text.indexOf("	");
+  const second = first === -1 ? -1 : text.indexOf("	", first + 1);
+  if (first === -1 || second === -1) return ["", "", ""];
+  return [text.slice(0, first), text.slice(first + 1, second), text.slice(second + 1)];
+}
+function parseNumstat(stdout, changes = []) {
+  const stats = /* @__PURE__ */ new Map();
+  if (String(stdout || "").includes("\0")) {
+    const fields = nulFields(stdout);
+    for (let index = 0; index < fields.length; ) {
+      const counts = fields[index++] || "";
+      const [addedText, removedText, inlinePath] = splitNumstatEntry(counts);
+      const renameLike = inlinePath === "";
+      const pathField = renameLike ? `${fields[index++] || ""} => ${fields[index++] || ""}` : inlinePath;
+      const added = Number(addedText);
+      const removed = Number(removedText);
+      const path2 = numstatPathForChanges(pathField, changes);
+      if (!path2) continue;
+      stats.set(path2, {
+        added: Number.isInteger(added) && added >= 0 ? added : 0,
+        binary: addedText === "-" || removedText === "-",
+        removed: Number.isInteger(removed) && removed >= 0 ? removed : 0
+      });
+    }
+    return stats;
+  }
+  for (const line of String(stdout || "").split("\n")) {
+    if (!line.trim()) continue;
+    const [addedText, removedText, pathText] = splitNumstatEntry(line);
+    if (!pathText) continue;
+    const added = Number(addedText);
+    const removed = Number(removedText);
+    const path2 = numstatPathForChanges(pathText, changes);
+    if (!path2) continue;
+    stats.set(path2, {
+      added: Number.isInteger(added) && added >= 0 ? added : 0,
+      binary: addedText === "-" || removedText === "-",
+      removed: Number.isInteger(removed) && removed >= 0 ? removed : 0
+    });
+  }
+  return stats;
+}
+function parseRawDiffMetadata(stdout) {
+  const metadata = /* @__PURE__ */ new Map();
+  if (String(stdout || "").includes("\0")) {
+    const fields = nulFields(stdout);
+    for (let index = 0; index < fields.length; ) {
+      const header = fields[index++] || "";
+      const match = header.match(/^:([0-7]{6}) ([0-7]{6}) ([0-9a-f]+) ([0-9a-f]+) ([A-Z][0-9]*)$/i);
+      if (!match) continue;
+      const status = match[5] || "";
+      const oldPath = fields[index++];
+      const filePath = status.startsWith("R") || status.startsWith("C") ? fields[index++] : oldPath;
+      if (!filePath) continue;
+      const fileMetadata = {};
+      if (match[1] !== "000000") fileMetadata.oldMode = match[1];
+      if (match[2] !== "000000") fileMetadata.newMode = match[2];
+      if (!isZeroObjectId(match[3])) fileMetadata.oldSha = match[3];
+      if (!isZeroObjectId(match[4])) fileMetadata.newSha = match[4];
+      metadata.set(filePath, fileMetadata);
+    }
+    return metadata;
+  }
+  for (const line of String(stdout || "").split("\n")) {
+    if (!line.trim()) continue;
+    const fields = line.split("	");
+    const header = fields[0] || "";
+    const match = header.match(/^:([0-7]{6}) ([0-7]{6}) ([0-9a-f]+) ([0-9a-f]+) ([A-Z][0-9]*)$/i);
+    if (!match) continue;
+    const status = match[5] || "";
+    const path2 = status.startsWith("R") || status.startsWith("C") ? fields[2] : fields[1];
+    if (!path2) continue;
+    const fileMetadata = {};
+    if (match[1] !== "000000") fileMetadata.oldMode = match[1];
+    if (match[2] !== "000000") fileMetadata.newMode = match[2];
+    if (!isZeroObjectId(match[3])) fileMetadata.oldSha = match[3];
+    if (!isZeroObjectId(match[4])) fileMetadata.newSha = match[4];
+    metadata.set(path2, fileMetadata);
+  }
+  return metadata;
+}
+function patchDiffHeader(patch) {
+  const lines = String(patch || "").split("\n");
+  const header = [];
+  for (const line of lines) {
+    if (line.startsWith("@@ ")) break;
+    if (!line) continue;
+    header.push(line);
+    if (line === "GIT binary patch") break;
+  }
+  return header;
+}
+function isZeroObjectId(value) {
+  return /^0+$/.test(String(value || ""));
+}
+function patchMetadata(patchOrHeader) {
+  const header = Array.isArray(patchOrHeader) ? patchOrHeader : patchDiffHeader(patchOrHeader);
+  const metadata = {};
+  for (const line of header) {
+    const index = line.match(/^index ([0-9a-f]+)\.\.([0-9a-f]+)(?: ([0-7]{6}))?$/i);
+    if (index) {
+      if (!isZeroObjectId(index[1])) metadata.oldSha = index[1];
+      if (!isZeroObjectId(index[2])) metadata.newSha = index[2];
+      if (index[3]) {
+        metadata.oldMode = metadata.oldMode || index[3];
+        metadata.newMode = metadata.newMode || index[3];
+      }
+      continue;
+    }
+    const newFileMode = line.match(/^new file mode ([0-7]{6})$/);
+    if (newFileMode) {
+      metadata.newMode = newFileMode[1];
+      continue;
+    }
+    const deletedFileMode = line.match(/^deleted file mode ([0-7]{6})$/);
+    if (deletedFileMode) {
+      metadata.oldMode = deletedFileMode[1];
+      continue;
+    }
+    const oldMode = line.match(/^old mode ([0-7]{6})$/);
+    if (oldMode) {
+      metadata.oldMode = oldMode[1];
+      continue;
+    }
+    const newMode = line.match(/^new mode ([0-7]{6})$/);
+    if (newMode) metadata.newMode = newMode[1];
+  }
+  return metadata;
+}
+function fileFromPatch(change, patch) {
+  const hunks = (0, import_workspace_file_service.parseUnifiedDiffRows)(patch);
+  const totals = countRows(hunks);
+  const binary = /(^|\n)(Binary files? |GIT binary patch(?:\n|$))/.test(String(patch || ""));
+  const diffHeader = patchDiffHeader(patch);
+  const metadata = patchMetadata(diffHeader);
+  return {
+    added: totals.added,
+    ...binary ? { binary: true } : {},
+    diff: {
+      ...diffHeader.length ? { diffHeader } : {},
+      hunks
+    },
+    kind: change.kind,
+    ...metadata,
+    path: change.path,
+    ...change.previousPath ? { previousPath: change.previousPath } : {},
+    removed: totals.removed,
+    status: change.status || reviewStatus(change.kind)
+  };
+}
+function fileWithStats(file, stat) {
+  if (!stat) return file;
+  return {
+    ...file,
+    added: stat.added,
+    ...stat.binary === true ? { binary: true } : {},
+    removed: stat.removed
+  };
+}
+function gitDiffPathArgs(change) {
+  return change.previousPath ? [change.previousPath, change.path] : [change.path];
+}
+function gitDiffPathspecArgs(changes = []) {
+  const seen = /* @__PURE__ */ new Set();
+  const paths = [];
+  for (const change of changes) {
+    for (const filePath of gitDiffPathArgs(change)) {
+      if (!filePath || seen.has(filePath)) continue;
+      seen.add(filePath);
+      paths.push(filePath);
+    }
+  }
+  return paths;
+}
+class ReviewDiffService {
+  agentManager;
+  fileService;
+  constructor(agentManager, fileService) {
+    this.agentManager = agentManager;
+    this.fileService = fileService;
+  }
+  resolveWorkspace(agentId, requestedRoot) {
+    if (requestedRoot !== void 0) {
+      if (typeof requestedRoot !== "string" || !requestedRoot.trim() || typeof agentId === "string" && agentId.trim()) {
+        throw new import_workspace_file_service.WorkspaceFileError("exactly one review workspace target is required", 400);
+      }
+      let root2;
+      try {
+        root2 = fs.realpathSync.native(path.resolve(requestedRoot));
+      } catch {
+        throw new import_workspace_file_service.WorkspaceFileError("review workspace does not exist", 404);
+      }
+      if (!fs.statSync(root2).isDirectory()) throw new import_workspace_file_service.WorkspaceFileError("review workspace must be a directory", 400);
+      return root2;
+    }
+    if (typeof agentId !== "string" || !agentId.trim()) {
+      throw new import_workspace_file_service.WorkspaceFileError("review workspace target is required", 400);
+    }
+    const root = this.agentManager?.getAgentWorkspaceRoot?.(agentId);
+    if (!root) throw new import_workspace_file_service.WorkspaceFileError("agent not found", 404);
+    return root;
+  }
+  async git(root, args, options = {}) {
+    try {
+      return await this.fileService.execFile(this.fileService.gitPath, ["-C", root, ...args], {
+        cwd: root,
+        timeout: this.fileService.diffTimeoutMs,
+        maxBuffer: this.fileService.diffMaxBuffer,
+        ...options
+      });
+    } catch (error) {
+      if (errorString(error, "code") === "ETIMEDOUT") {
+        throw new import_workspace_file_service.WorkspaceFileError("git comparison source request timed out", 504);
+      }
+      throw new import_workspace_file_service.WorkspaceFileError(
+        errorString(error, "stderr") || errorString(error, "message") || "git comparison sources could not be loaded",
+        500
+      );
+    }
+  }
+  async getComparisonSources(agentId, options = {}) {
+    const root = this.resolveWorkspace(agentId, options.root);
+    const [{ stdout: headOutput }, { stdout: indexOutput }, branchResult, logResult, statusResult] = await Promise.all([
+      this.git(root, ["rev-parse", "--verify", "HEAD"]),
+      this.git(root, ["write-tree"]),
+      this.git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"]).catch(() => ({ stdout: "" })),
+      this.git(root, ["log", "-n", "12", "--format=%H%x1f%P%x1f%h%x1f%s%x1e", "HEAD"]),
+      Promise.all([
+        this.git(root, ["diff", "--name-only", "-z", "--"]),
+        this.git(root, ["diff", "--cached", "--name-only", "-z", "--"]),
+        this.git(root, ["ls-files", "--others", "--exclude-standard", "-z"])
+      ])
+    ]);
+    const head = String(headOutput || "").trim();
+    const indexTree = String(indexOutput || "").trim();
+    if (!/^[a-f0-9]{40,64}$/i.test(head) || !/^[a-f0-9]{40,64}$/i.test(indexTree)) {
+      throw new import_workspace_file_service.WorkspaceFileError("git comparison sources are invalid", 500);
+    }
+    const currentBranch = String(branchResult.stdout || "").trim();
+    const [unstagedResult, stagedResult, untrackedResult] = statusResult;
+    const refsResult = await this.git(root, [
+      "for-each-ref",
+      "--count=20",
+      "--sort=-committerdate",
+      "--format=%(refname:short)%00%(objectname)",
+      "refs/heads",
+      "refs/remotes"
+    ]);
+    const branchRefs = parseComparisonBranches(refsResult.stdout, currentBranch);
+    const branches = [];
+    for (const branch of branchRefs) {
+      try {
+        const { stdout } = await this.git(root, ["merge-base", "HEAD", branch.id]);
+        const base = String(stdout || "").trim();
+        if (!/^[a-f0-9]{40,64}$/i.test(base) || base === head) continue;
+        branches.push({
+          base,
+          head,
+          id: `branch:${branch.name}`,
+          label: branch.name
+        });
+      } catch {
+      }
+    }
+    return {
+      branches,
+      commits: parseComparisonCommits(logResult.stdout),
+      currentBranch: currentBranch || "Detached HEAD",
+      root,
+      staged: {
+        available: Boolean(String(stagedResult.stdout || "")),
+        base: head,
+        head: indexTree,
+        id: "staged",
+        label: "Staged"
+      },
+      unstaged: {
+        available: Boolean(String(unstagedResult.stdout || "") || String(untrackedResult.stdout || "")),
+        base: indexTree,
+        head: "now",
+        id: "unstaged",
+        label: "Unstaged"
+      }
+    };
+  }
+  async getWorkingCopyChanges(root, options, limit) {
+    const scope = normalizeWorkingCopyScope(options.scope);
+    const scanLimit = scope ? MAX_WORKING_COPY_SCAN_FILES : limit;
+    const changes = await this.fileService.changes(root, { limit: scanLimit });
+    const items = filterWorkingCopyChangeItems(root, assertUniqueReviewPaths(changes.items), options);
+    return {
+      items: items.slice(0, limit),
+      truncated: changes.truncated === true && (scope !== "tracked" || changes.items.at(-1)?.gitStatus !== "untracked") || items.length > limit
+    };
+  }
+  async getGitRangeChanges(root, base, head) {
+    try {
+      const { stdout } = await this.fileService.execFile(this.fileService.gitPath, [
+        "-C",
+        root,
+        "diff",
+        "--name-status",
+        "-z",
+        "--find-renames",
+        ...gitRangeRevisionArgs(base, head),
+        "--"
+      ], { cwd: root, timeout: this.fileService.diffTimeoutMs, maxBuffer: this.fileService.diffMaxBuffer });
+      const changes = parseNameStatus(stdout);
+      if (head !== "now") return changes;
+      const untracked = await this.fileService.execFile(this.fileService.gitPath, [
+        "-C",
+        root,
+        "ls-files",
+        "--others",
+        "--exclude-standard",
+        "-z"
+      ], { cwd: root, timeout: this.fileService.diffTimeoutMs, maxBuffer: this.fileService.diffMaxBuffer });
+      return [...changes, ...nulFields(untracked.stdout).map((path2) => ({ gitStatus: "untracked", kind: "added", path: path2, status: "A" }))];
+    } catch (error) {
+      if (errorString(error, "code") === "ETIMEDOUT") {
+        throw new import_workspace_file_service.WorkspaceFileError("git diff timed out", 504);
+      }
+      throw new import_workspace_file_service.WorkspaceFileError(
+        errorString(error, "stderr") || errorString(error, "message") || "git diff failed",
+        500
+      );
+    }
+  }
+  async getCommitSummary(root, revision) {
+    if (!isSafeGitRevision(revision) || revision === "now") return null;
+    try {
+      const { stdout } = await this.fileService.execFile(this.fileService.gitPath, [
+        "-C",
+        root,
+        "show",
+        "-s",
+        "--format=%H%x1f%an%x1f%ae%x1f%aI%x1f%B",
+        revision
+      ], { cwd: root, timeout: this.fileService.diffTimeoutMs, maxBuffer: this.fileService.diffMaxBuffer });
+      const [id, authorName, authorEmail, authoredAt, ...messageParts] = String(stdout || "").split("");
+      const message = messageParts.join("").trim();
+      if (!/^[a-f0-9]{40,64}$/i.test(id || "") || !message) return null;
+      return { authoredAt: String(authoredAt || "").trim(), authorEmail: String(authorEmail || "").trim(), authorName: String(authorName || "").trim(), id, message };
+    } catch {
+      return null;
+    }
+  }
+  async getComparison(root, base, head) {
+    const [baseCommit, headCommit] = await Promise.all([
+      this.getCommitSummary(root, base),
+      head === "now" ? Promise.resolve(null) : this.getCommitSummary(root, head)
+    ]);
+    if (!baseCommit && !headCommit) return null;
+    return {
+      ...baseCommit ? { base: baseCommit } : {},
+      ...headCommit ? { head: headCommit } : {},
+      workingTree: head === "now"
+    };
+  }
+  async readGitTextFile(root, revision, filePath) {
+    try {
+      const { stdout } = await this.fileService.execFile(this.fileService.gitPath, [
+        "-C",
+        root,
+        "show",
+        `${revision}:${filePath}`
+      ], { cwd: root, encoding: "buffer", timeout: this.fileService.diffTimeoutMs, maxBuffer: this.fileService.diffMaxBuffer });
+      const buffer = Buffer.isBuffer(stdout) ? stdout : Buffer.from(String(stdout || ""));
+      if (buffer.includes(0)) throw new import_workspace_file_service.WorkspaceFileError("binary files do not have expandable text context", 415);
+      return textLines(buffer.toString("utf8"));
+    } catch (error) {
+      if (error instanceof import_workspace_file_service.WorkspaceFileError) throw error;
+      if (errorString(error, "code") === "ETIMEDOUT") {
+        throw new import_workspace_file_service.WorkspaceFileError("git show timed out", 504);
+      }
+      throw new import_workspace_file_service.WorkspaceFileError(
+        errorString(error, "stderr") || errorString(error, "message") || "git file content could not be loaded",
+        500
+      );
+    }
+  }
+  async readWorkingTreeTextFile(root, filePath) {
+    try {
+      const resolved = await this.fileService.resolvePath(root, filePath);
+      const buffer = await fs.promises.readFile(resolved.target);
+      if (buffer.includes(0)) throw new import_workspace_file_service.WorkspaceFileError("binary files do not have expandable text context", 415);
+      return textLines(buffer.toString("utf8"));
+    } catch (error) {
+      if (error instanceof import_workspace_file_service.WorkspaceFileError) throw error;
+      throw new import_workspace_file_service.WorkspaceFileError(
+        errorString(error, "message") || "working tree file content could not be loaded",
+        500
+      );
+    }
+  }
+  async getWorkingCopyTextSources(root, change, source) {
+    const kind = reviewKind(change.gitStatus);
+    const leftLines = kind === "added" ? [] : textLines(source.originalContent);
+    const rightLines = kind === "deleted" ? [] : textLines(source.modifiedContent);
+    return {
+      leftLines,
+      leftName: change.previousPath || change.path,
+      rightLines,
+      rightName: change.path
+    };
+  }
+  async getGitRangeTextSources(root, base, head, change) {
+    const kind = change.kind || reviewKind(change.gitStatus);
+    const leftName = change.previousPath || change.path;
+    const [leftLines, rightLines] = await Promise.all([
+      kind === "added" ? Promise.resolve([]) : this.readGitTextFile(root, base, leftName),
+      kind === "deleted" ? Promise.resolve([]) : head === "now" ? this.readWorkingTreeTextFile(root, change.path) : this.readGitTextFile(root, head, change.path)
+    ]);
+    return { leftLines, leftName, rightLines, rightName: change.path };
+  }
+  async getWorkingCopyFileContext(agentId, filePath, options = {}) {
+    const root = this.resolveWorkspace(agentId, options.root);
+    if (!isSafeReviewPath(filePath)) throw new import_workspace_file_service.WorkspaceFileError("file path is required", 400);
+    const changes = await this.getWorkingCopyChanges(root, options, MAX_REVIEW_FILES);
+    const change = changes.items.find((item) => item.path === filePath);
+    if (!change) throw new import_workspace_file_service.WorkspaceFileError("review file not found", 404);
+    if (change.gitStatus === "untracked") throw new import_workspace_file_service.WorkspaceFileError("untracked files do not have common diff context", 400);
+    const source = await this.fileService.diff(root, change.path);
+    if (source.binary === true) throw new import_workspace_file_service.WorkspaceFileError("binary files do not have expandable text context", 415);
+    return contextRowsFromSources(await this.getWorkingCopyTextSources(root, change, source), options);
+  }
+  async getGitRangeFileContext(agentId, options = {}) {
+    const root = this.resolveWorkspace(agentId, options.root);
+    const base = String(options.base || "").trim();
+    const head = String(options.head || "").trim();
+    const filePath = typeof options.path === "string" ? options.path : "";
+    if (!isSafeGitRevision(base) || !isReviewHead(head)) {
+      throw new import_workspace_file_service.WorkspaceFileError("base and head revisions are required", 400);
+    }
+    if (!isSafeReviewPath(filePath)) throw new import_workspace_file_service.WorkspaceFileError("file path is required", 400);
+    const changes = assertUniqueReviewPaths(await this.getGitRangeChanges(root, base, head));
+    const change = changes.find((item) => item.path === filePath);
+    if (!change) throw new import_workspace_file_service.WorkspaceFileError("review file not found", 404);
+    if (change.gitStatus === "untracked") throw new import_workspace_file_service.WorkspaceFileError("untracked files do not have common diff context", 400);
+    return contextRowsFromSources(await this.getGitRangeTextSources(root, base, head, change), options);
+  }
+  async getGitRangeUntrackedFile(root, change, metadataOnly) {
+    const source = await this.fileService.diff(root, change.path);
+    const hunks = untrackedHunks(source.modifiedContent);
+    const totals = countRows(hunks);
+    const truncated = source.truncated === true || untrackedContentTooLarge(source.modifiedContent);
+    const metadata = patchMetadata(patchDiffHeader(untrackedPatch(change.path, source.modifiedContent)));
+    if (metadataOnly) {
+      return metadataFile(change, {
+        added: totals.added,
+        binary: source.binary === true,
+        diffTooExpensive: truncated,
+        ...metadata,
+        removed: totals.removed,
+        size: source.size,
+        sizeDelta: source.sizeDelta,
+        truncated
+      });
+    }
+    return {
+      added: totals.added,
+      ...source.binary === true ? { binary: true } : {},
+      diff: {
+        diffHeader: patchDiffHeader(untrackedPatch(change.path, source.modifiedContent)),
+        hunks,
+        truncated
+      },
+      ...truncated ? { diffTooExpensive: true } : {},
+      kind: "added",
+      ...metadata,
+      path: change.path,
+      removed: totals.removed,
+      ...Number.isInteger(source.size) ? { size: source.size } : {},
+      ...Number.isInteger(source.sizeDelta) ? { sizeDelta: source.sizeDelta } : {},
+      status: "A"
+    };
+  }
+  async getWorkingCopy(agentId, options = {}) {
+    const root = this.resolveWorkspace(agentId, options.root);
+    const limit = normalizeReviewLimit(options.limit);
+    const metadataOnly = metadataOnlyOption(options.metadataOnly);
+    const contentOptions = diffContentOptions(options);
+    const changes = await this.getWorkingCopyChanges(root, options, limit);
+    const changeItems = changes.items;
+    const files = await mapWithConcurrency(changeItems, async (change) => {
+      const source = await this.fileService.diff(root, change.path);
+      const diffSource = !metadataOnly && hasOptions(contentOptions) ? await this.fileService.diff(root, change.path, contentOptions) : source;
+      const isUntracked = change.gitStatus === "untracked";
+      const metadataHunks = isUntracked ? untrackedHunks(source.modifiedContent) : (0, import_workspace_file_service.parseUnifiedDiffRows)(source.patch);
+      const hunks = isUntracked ? metadataHunks : (0, import_workspace_file_service.parseUnifiedDiffRows)(diffSource.patch);
+      const totals = countRows(metadataHunks);
+      const kind = reviewKind(change.gitStatus);
+      const diffHeader = patchDiffHeader(isUntracked ? untrackedPatch(change.path, source.modifiedContent) : diffSource.patch || source.patch);
+      const metadata = patchMetadata(diffHeader);
+      const untrackedTooLarge = isUntracked && untrackedContentTooLarge(source.modifiedContent);
+      if (metadataOnly) {
+        return metadataFile({ ...change, kind }, {
+          added: totals.added,
+          binary: source.binary === true,
+          diffTooExpensive: source.truncated === true || untrackedTooLarge,
+          ...metadata,
+          removed: totals.removed,
+          size: source.size,
+          sizeDelta: source.sizeDelta,
+          truncated: source.truncated === true || untrackedTooLarge
+        });
+      }
+      return {
+        added: totals.added,
+        ...source.binary === true ? { binary: true } : {},
+        diff: {
+          ...diffHeader.length ? { diffHeader } : {},
+          hunks,
+          truncated: source.truncated === true || diffSource.truncated === true || untrackedTooLarge
+        },
+        ...source.truncated === true || diffSource.truncated === true || untrackedTooLarge ? { diffTooExpensive: true } : {},
+        kind,
+        ...metadata,
+        path: change.path,
+        ...change.previousPath ? { previousPath: change.previousPath } : {},
+        removed: totals.removed,
+        ...Number.isInteger(source.size) ? { size: source.size } : {},
+        ...Number.isInteger(source.sizeDelta) ? { sizeDelta: source.sizeDelta } : {},
+        status: reviewStatus(kind)
+      };
+    });
+    const comparison = await this.getComparison(root, "HEAD", "now");
+    return {
+      basePatchset: "HEAD",
+      ...comparison ? { comparison } : {},
+      files,
+      isGitRepo: true,
+      patchset: workingCopyPatchset(files),
+      reviewId: workingCopyReviewId(root, options),
+      root,
+      source: "working-copy",
+      truncated: changes.truncated
+    };
+  }
+  async getWorkingCopyFile(agentId, filePath, options = {}) {
+    const root = this.resolveWorkspace(agentId, options.root);
+    const contentOptions = diffContentOptions(options);
+    if (!isSafeReviewPath(filePath)) throw new import_workspace_file_service.WorkspaceFileError("file path is required", 400);
+    const changes = await this.getWorkingCopyChanges(root, options, MAX_REVIEW_FILES);
+    const changeItems = changes.items;
+    const change = changeItems.find((item) => item.path === filePath);
+    if (!change) throw new import_workspace_file_service.WorkspaceFileError("review file not found", 404);
+    const source = await this.fileService.diff(root, change.path);
+    const diffSource = hasOptions(contentOptions) ? await this.fileService.diff(root, change.path, contentOptions) : source;
+    const isUntracked = change.gitStatus === "untracked";
+    const metadataHunks = isUntracked ? untrackedHunks(source.modifiedContent) : (0, import_workspace_file_service.parseUnifiedDiffRows)(source.patch);
+    const hunks = isUntracked ? metadataHunks : (0, import_workspace_file_service.parseUnifiedDiffRows)(diffSource.patch);
+    const totals = countRows(metadataHunks);
+    const kind = reviewKind(change.gitStatus);
+    const diffHeader = patchDiffHeader(isUntracked ? untrackedPatch(change.path, source.modifiedContent) : diffSource.patch || source.patch);
+    const metadata = patchMetadata(diffHeader);
+    const untrackedTooLarge = isUntracked && untrackedContentTooLarge(source.modifiedContent);
+    const textSources = options.fileMeta === true && !isUntracked && source.binary !== true && typeof source.originalContent === "string" && typeof source.modifiedContent === "string" ? await this.getWorkingCopyTextSources(root, change, source) : null;
+    return {
+      added: totals.added,
+      ...source.binary === true ? { binary: true } : {},
+      diff: {
+        ...diffHeader.length ? { diffHeader } : {},
+        hunks,
+        ...textSources ? { leftMeta: reviewTextFileMeta(textSources.leftName, textSources.leftLines) } : {},
+        ...textSources ? { rightMeta: reviewTextFileMeta(textSources.rightName, textSources.rightLines) } : {},
+        truncated: source.truncated === true || diffSource.truncated === true || untrackedTooLarge
+      },
+      ...source.truncated === true || diffSource.truncated === true || untrackedTooLarge ? { diffTooExpensive: true } : {},
+      kind,
+      ...metadata,
+      path: change.path,
+      ...change.previousPath ? { previousPath: change.previousPath } : {},
+      removed: totals.removed,
+      ...Number.isInteger(source.size) ? { size: source.size } : {},
+      ...Number.isInteger(source.sizeDelta) ? { sizeDelta: source.sizeDelta } : {},
+      status: reviewStatus(kind)
+    };
+  }
+  async getWorkingCopyPatch(agentId, options = {}) {
+    const root = this.resolveWorkspace(agentId, options.root);
+    const limit = normalizeReviewLimit(options.limit);
+    const contentOptions = diffContentOptions(options);
+    const changes = await this.getWorkingCopyChanges(root, options, limit);
+    const changeItems = changes.items;
+    const patchResults = await mapWithConcurrency(changeItems, async (change) => {
+      const source = await this.fileService.diff(root, change.path, contentOptions);
+      const untrackedTooLarge = change.gitStatus === "untracked" && untrackedContentTooLarge(source.modifiedContent);
+      return {
+        patch: change.gitStatus === "untracked" ? untrackedPatch(change.path, source.modifiedContent) : String(source.patch || ""),
+        truncated: source.truncated === true || untrackedTooLarge
+      };
+    });
+    return {
+      patch: patchResults.map((result) => result.patch).filter(Boolean).join("\n"),
+      truncated: changes.truncated || patchResults.some((result) => result.truncated)
+    };
+  }
+  async getGitRange(agentId, options = {}) {
+    const root = this.resolveWorkspace(agentId, options.root);
+    const base = String(options.base || "").trim();
+    const head = String(options.head || "").trim();
+    if (!isSafeGitRevision(base) || !isReviewHead(head)) {
+      throw new import_workspace_file_service.WorkspaceFileError("base and head revisions are required", 400);
+    }
+    const limit = normalizeReviewLimit(options.limit);
+    const ignoreWhitespace = normalizeIgnoreWhitespace(options.ignoreWhitespace);
+    const context = normalizeDiffContext(options.context);
+    const changes = await this.getGitRangeChanges(root, base, head);
+    const comparisonPromise = this.getComparison(root, base, head);
+    const selected = assertUniqueReviewPaths(changes.slice(0, limit));
+    const lineStats = ignoreWhitespace !== "NONE" && !metadataOnlyOption(options.metadataOnly) ? await this.getGitRangeNumstat(root, base, head, ignoreWhitespace, selected) : null;
+    if (metadataOnlyOption(options.metadataOnly)) {
+      const stats = await this.getGitRangeNumstat(root, base, head, "NONE", selected);
+      const rawMetadata = await this.getGitRangeRawMetadata(root, base, head, selected);
+      const files2 = await mapWithConcurrency(selected, async (change) => {
+        if (change.gitStatus === "untracked") return this.getGitRangeUntrackedFile(root, change, true);
+        return metadataFile(change, {
+          ...stats.get(change.path),
+          ...rawMetadata.get(change.path)
+        });
+      });
+      const comparison2 = await comparisonPromise;
+      return {
+        basePatchset: base,
+        ...comparison2 ? { comparison: comparison2 } : {},
+        files: files2,
+        isGitRepo: true,
+        patchset: head,
+        reviewId: options.reviewId || gitRangeReviewId(root, base, head),
+        root,
+        source: "git-range",
+        truncated: changes.length > limit
+      };
+    }
+    const files = await mapWithConcurrency(selected, async (change) => {
+      if (change.gitStatus === "untracked") return this.getGitRangeUntrackedFile(root, change, false);
+      try {
+        const { stdout } = await this.fileService.execFile(this.fileService.gitPath, [
+          "-C",
+          root,
+          "diff",
+          "--find-renames",
+          ...gitWhitespaceArgs(ignoreWhitespace),
+          ...gitContextArgs(context),
+          ...gitRangeRevisionArgs(base, head),
+          "--",
+          ...gitDiffPathArgs(change)
+        ], { cwd: root, timeout: this.fileService.diffTimeoutMs, maxBuffer: this.fileService.diffMaxBuffer });
+        const file = fileFromPatch(change, stdout);
+        const stat = lineStats?.get(change.path);
+        return fileWithStats(file, stat);
+      } catch (error) {
+        if (errorString(error, "code") === "ETIMEDOUT") {
+          throw new import_workspace_file_service.WorkspaceFileError("git diff timed out", 504);
+        }
+        throw new import_workspace_file_service.WorkspaceFileError(
+          errorString(error, "stderr") || errorString(error, "message") || "git diff failed",
+          500
+        );
+      }
+    });
+    const comparison = await comparisonPromise;
+    return {
+      basePatchset: base,
+      ...comparison ? { comparison } : {},
+      files,
+      isGitRepo: true,
+      patchset: head,
+      reviewId: options.reviewId || gitRangeReviewId(root, base, head),
+      root,
+      source: "git-range",
+      truncated: changes.length > limit
+    };
+  }
+  async getGitRangeFile(agentId, options = {}) {
+    const root = this.resolveWorkspace(agentId, options.root);
+    const base = String(options.base || "").trim();
+    const head = String(options.head || "").trim();
+    const path2 = typeof options.path === "string" ? options.path : "";
+    const ignoreWhitespace = normalizeIgnoreWhitespace(options.ignoreWhitespace);
+    const context = normalizeDiffContext(options.context);
+    if (!isSafeGitRevision(base) || !isReviewHead(head)) {
+      throw new import_workspace_file_service.WorkspaceFileError("base and head revisions are required", 400);
+    }
+    if (!isSafeReviewPath(path2)) throw new import_workspace_file_service.WorkspaceFileError("file path is required", 400);
+    const changes = await this.getGitRangeChanges(root, base, head);
+    const uniqueChanges = assertUniqueReviewPaths(changes);
+    const change = uniqueChanges.find((item) => item.path === path2);
+    if (!change) throw new import_workspace_file_service.WorkspaceFileError("review file not found", 404);
+    if (change.gitStatus === "untracked") return this.getGitRangeUntrackedFile(root, change, false);
+    const stats = ignoreWhitespace !== "NONE" ? await this.getGitRangeNumstat(root, base, head, ignoreWhitespace, [change]) : null;
+    try {
+      const { stdout } = await this.fileService.execFile(this.fileService.gitPath, [
+        "-C",
+        root,
+        "diff",
+        "--find-renames",
+        ...gitWhitespaceArgs(ignoreWhitespace),
+        ...gitContextArgs(context),
+        ...gitRangeRevisionArgs(base, head),
+        "--",
+        ...gitDiffPathArgs(change)
+      ], { cwd: root, timeout: this.fileService.diffTimeoutMs, maxBuffer: this.fileService.diffMaxBuffer });
+      const file = fileFromPatch(change, stdout);
+      if (options.fileMeta === true && file.binary !== true) {
+        const textSources = await this.getGitRangeTextSources(root, base, head, change);
+        file.diff = {
+          ...file.diff,
+          leftMeta: reviewTextFileMeta(textSources.leftName, textSources.leftLines),
+          rightMeta: reviewTextFileMeta(textSources.rightName, textSources.rightLines)
+        };
+      }
+      const stat = stats?.get(change.path);
+      return fileWithStats(file, stat);
+    } catch (error) {
+      if (errorString(error, "code") === "ETIMEDOUT") {
+        throw new import_workspace_file_service.WorkspaceFileError("git diff timed out", 504);
+      }
+      throw new import_workspace_file_service.WorkspaceFileError(
+        errorString(error, "stderr") || errorString(error, "message") || "git diff failed",
+        500
+      );
+    }
+  }
+  async getGitRangePatch(agentId, options = {}) {
+    const root = this.resolveWorkspace(agentId, options.root);
+    const base = String(options.base || "").trim();
+    const head = String(options.head || "").trim();
+    if (!isSafeGitRevision(base) || !isReviewHead(head)) {
+      throw new import_workspace_file_service.WorkspaceFileError("base and head revisions are required", 400);
+    }
+    const limit = normalizeReviewLimit(options.limit);
+    const ignoreWhitespace = normalizeIgnoreWhitespace(options.ignoreWhitespace);
+    const context = normalizeDiffContext(options.context);
+    const changes = await this.getGitRangeChanges(root, base, head);
+    const selected = assertUniqueReviewPaths(changes.slice(0, limit));
+    const patches = await mapWithConcurrency(selected, async (change) => {
+      if (change.gitStatus === "untracked") {
+        const source = await this.fileService.diff(root, change.path);
+        return untrackedPatch(change.path, source.modifiedContent);
+      }
+      try {
+        const { stdout } = await this.fileService.execFile(this.fileService.gitPath, [
+          "-C",
+          root,
+          "diff",
+          "--find-renames",
+          ...gitWhitespaceArgs(ignoreWhitespace),
+          ...gitContextArgs(context),
+          ...gitRangeRevisionArgs(base, head),
+          "--",
+          ...gitDiffPathArgs(change)
+        ], { cwd: root, timeout: this.fileService.diffTimeoutMs, maxBuffer: this.fileService.diffMaxBuffer });
+        return stdout;
+      } catch (error) {
+        if (errorString(error, "code") === "ETIMEDOUT") {
+          throw new import_workspace_file_service.WorkspaceFileError("git diff timed out", 504);
+        }
+        throw new import_workspace_file_service.WorkspaceFileError(
+          errorString(error, "stderr") || errorString(error, "message") || "git diff failed",
+          500
+        );
+      }
+    });
+    return {
+      patch: patches.filter(Boolean).join("\n"),
+      truncated: changes.length > limit
+    };
+  }
+  async getGitRangeNumstat(root, base, head, ignoreWhitespace = "NONE", changes = []) {
+    try {
+      const { stdout } = await this.fileService.execFile(this.fileService.gitPath, [
+        "-C",
+        root,
+        "diff",
+        "--numstat",
+        "-z",
+        "--find-renames",
+        ...gitWhitespaceArgs(ignoreWhitespace),
+        ...gitRangeRevisionArgs(base, head),
+        "--",
+        ...gitDiffPathspecArgs(changes)
+      ], { cwd: root, timeout: this.fileService.diffTimeoutMs, maxBuffer: this.fileService.diffMaxBuffer });
+      return parseNumstat(stdout, changes);
+    } catch (error) {
+      if (errorString(error, "code") === "ETIMEDOUT") {
+        throw new import_workspace_file_service.WorkspaceFileError("git diff timed out", 504);
+      }
+      throw new import_workspace_file_service.WorkspaceFileError(
+        errorString(error, "stderr") || errorString(error, "message") || "git diff failed",
+        500
+      );
+    }
+  }
+  async getGitRangeRawMetadata(root, base, head, changes = []) {
+    try {
+      const { stdout } = await this.fileService.execFile(this.fileService.gitPath, [
+        "-C",
+        root,
+        "diff",
+        "--raw",
+        "-z",
+        "--find-renames",
+        ...gitRangeRevisionArgs(base, head),
+        "--",
+        ...gitDiffPathspecArgs(changes)
+      ], { cwd: root, timeout: this.fileService.diffTimeoutMs, maxBuffer: this.fileService.diffMaxBuffer });
+      return parseRawDiffMetadata(stdout);
+    } catch (error) {
+      if (errorString(error, "code") === "ETIMEDOUT") {
+        throw new import_workspace_file_service.WorkspaceFileError("git diff timed out", 504);
+      }
+      throw new import_workspace_file_service.WorkspaceFileError(
+        errorString(error, "stderr") || errorString(error, "message") || "git diff failed",
+        500
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReviewDiffService,
+  fileFromPatch,
+  filterWorkingCopyChangeItems,
+  gitContextArgs,
+  gitDiffPathspecArgs,
+  gitRangeReviewId,
+  gitWhitespaceArgs,
+  metadataFile,
+  normalizeDiffContext,
+  normalizeIgnoreWhitespace,
+  normalizeModifiedWithinDays,
+  normalizeReviewLimit,
+  normalizeWorkingCopyScope,
+  parseComparisonBranches,
+  parseComparisonCommits,
+  parseNameStatus,
+  parseNumstat,
+  parseRawDiffMetadata,
+  patchDiffHeader,
+  patchMetadata,
+  untrackedHunks,
+  untrackedPatch,
+  workingCopyPatchset,
+  workingCopyReviewId
+});