pi-ui-extend 0.1.1

package/external/pi-tools-suite/src/model-tools/apply-patch.ts

@@ -0,0 +1,590 @@
+import { spawn } from "node:child_process";
+import { mkdir, mkdtemp, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { withFileMutationQueue } from "@mariozechner/pi-coding-agent";
+import { isPathInside } from "./path-utils";
+
+export interface ApplyPatchResult {
+  changedFiles: string[];
+  summary: string;
+}
+
+type HunkLine = {
+  kind: "context" | "remove" | "add";
+  text: string;
+};
+
+type Hunk = {
+  header?: string;
+  lines: HunkLine[];
+  endOfFile: boolean;
+};
+
+type PatchOperation =
+  | { kind: "add"; path: string; lines: string[] }
+  | { kind: "delete"; path: string }
+  | { kind: "update"; path: string; moveTo?: string; hunks: Hunk[] };
+
+interface PlannedWrite {
+  kind: "write";
+  changeKind: "A" | "M";
+  path: string;
+  absolutePath: string;
+  content: string;
+}
+
+interface PlannedDelete {
+  kind: "delete";
+  changeKind: "D";
+  path: string;
+  absolutePath: string;
+  summarize: boolean;
+}
+
+type PlannedChange = PlannedWrite | PlannedDelete;
+type Match = { kind: "found"; index: number } | { kind: "missing" };
+
+const BEGIN = "*** Begin Patch";
+const END = "*** End Patch";
+const ADD = "*** Add File: ";
+const DELETE = "*** Delete File: ";
+const UPDATE = "*** Update File: ";
+const MOVE = "*** Move to: ";
+const EOF_MARKER = "*** End of File";
+
+type UnifiedChangeKind = "A" | "M" | "D";
+type UnifiedChange = { path: string; changeKind: UnifiedChangeKind };
+
+function normalizedPatchLines(input: string): string[] {
+  const normalized = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+  return normalized ? normalized.split("\n") : [];
+}
+
+function strictPatchBodyLines(lines: string[]): string[] {
+  const first = lines[0]?.trim();
+  const last = lines.at(-1)?.trim();
+  if (first !== BEGIN) throw new Error("Invalid patch: The first line of the patch must be '*** Begin Patch'");
+  if (last !== END) throw new Error("Invalid patch: The last line of the patch must be '*** End Patch'");
+  return lines.slice(1, -1);
+}
+
+function patchBodyLines(input: string): string[] {
+  const originalLines = normalizedPatchLines(input);
+  try {
+    return strictPatchBodyLines(originalLines);
+  } catch (originalError) {
+    const first = originalLines[0];
+    const last = originalLines.at(-1);
+    const isHeredoc = first === "<<EOF" || first === "<<'EOF'" || first === '<<"EOF"';
+    if (isHeredoc && last?.endsWith("EOF") && originalLines.length >= 4) {
+      return strictPatchBodyLines(originalLines.slice(1, -1));
+    }
+    throw originalError;
+  }
+}
+
+function looksLikeBeginPatch(input: string): boolean {
+  const first = normalizedPatchLines(input)[0]?.trim();
+  return first === BEGIN || first === "<<EOF" || first === "<<'EOF'" || first === '<<"EOF"';
+}
+
+function stripDiffPathPrefix(pathText: string): string {
+  if (pathText === "/dev/null") return "";
+  if ((pathText.startsWith("a/") || pathText.startsWith("b/")) && pathText.length > 2) return pathText.slice(2);
+  return pathText;
+}
+
+function unifiedHeaderPath(line: string, marker: "--- " | "+++ "): string {
+  let pathText = line.slice(marker.length).trim();
+  if (pathText === "/dev/null") return "";
+  const tabIndex = pathText.indexOf("\t");
+  if (tabIndex !== -1) pathText = pathText.slice(0, tabIndex);
+  return stripDiffPathPrefix(pathText);
+}
+
+function extractUnifiedChanges(input: string): UnifiedChange[] {
+  const changes = new Map<string, UnifiedChange>();
+  let oldPath = "";
+
+  for (const line of input.split(/\r?\n/)) {
+    if (line.startsWith("--- ")) {
+      oldPath = unifiedHeaderPath(line, "--- ");
+      continue;
+    }
+    if (!line.startsWith("+++ ")) continue;
+
+    const newPath = unifiedHeaderPath(line, "+++ ");
+    const path = newPath || oldPath;
+    if (!path) continue;
+    const changeKind: UnifiedChangeKind = oldPath ? (newPath ? "M" : "D") : "A";
+    changes.set(path, { path, changeKind });
+    oldPath = "";
+  }
+
+  return [...changes.values()];
+}
+
+function validateUnifiedPatchPaths(cwd: string, changes: UnifiedChange[]): void {
+  const workspace = resolve(cwd);
+  for (const change of changes) {
+    const absolutePath = resolvePatchPath(cwd, change.path);
+    if (!isPathInside(workspace, absolutePath)) throw new Error(`Patch path escapes workspace: ${change.path}`);
+  }
+}
+
+function readPath(line: string, marker: string, lineNumber: number): string {
+  const path = line.slice(marker.length).trim();
+  if (!path) throw new Error(`Invalid patch line ${lineNumber}: missing path`);
+  return path;
+}
+
+function isFileOp(line: string): boolean {
+  const trimmed = line.trim();
+  return trimmed.startsWith(ADD) || trimmed.startsWith(DELETE) || trimmed.startsWith(UPDATE) || trimmed === END;
+}
+
+function parseUpdateChunk(
+  lines: string[],
+  startIndex: number,
+  lineNumber: number,
+  allowMissingContext: boolean,
+): { hunk: Hunk; consumed: number } {
+  if (startIndex >= lines.length) throw new Error(`Invalid update hunk line ${lineNumber}: update hunk does not contain any lines`);
+
+  let header: string | undefined;
+  let index = startIndex;
+  if (lines[index] === "@@") {
+    index++;
+  } else if (lines[index]?.startsWith("@@ ")) {
+    header = (lines[index] ?? "").slice(3);
+    index++;
+  } else if (!allowMissingContext) {
+    throw new Error(`Invalid update hunk line ${lineNumber}: expected @@ header`);
+  }
+
+  if (index >= lines.length) {
+    throw new Error(`Invalid update hunk line ${lineNumber + 1}: update hunk does not contain any lines`);
+  }
+
+  const hunkLines: HunkLine[] = [];
+  let endOfFile = false;
+  let parsedLines = 0;
+
+  for (; index < lines.length; index++) {
+    const current = lines[index] ?? "";
+    if (current === EOF_MARKER) {
+      if (parsedLines === 0) {
+        throw new Error(`Invalid update hunk line ${lineNumber + 1}: update hunk does not contain any lines`);
+      }
+      endOfFile = true;
+      parsedLines++;
+      index++;
+      break;
+    }
+
+    const prefix = current[0];
+    if (prefix === undefined) {
+      hunkLines.push({ kind: "context", text: "" });
+    } else if (prefix === " ") {
+      hunkLines.push({ kind: "context", text: current.slice(1) });
+    } else if (prefix === "-") {
+      hunkLines.push({ kind: "remove", text: current.slice(1) });
+    } else if (prefix === "+") {
+      hunkLines.push({ kind: "add", text: current.slice(1) });
+    } else {
+      if (parsedLines === 0) {
+        throw new Error(`Invalid update hunk line ${lineNumber + 1}: expected space, -, or + prefix`);
+      }
+      break;
+    }
+    parsedLines++;
+  }
+
+  return { hunk: { header, lines: hunkLines, endOfFile }, consumed: index - startIndex };
+}
+
+export function parseApplyPatch(input: string): PatchOperation[] {
+  const lines = patchBodyLines(input);
+  const operations: PatchOperation[] = [];
+  let index = 0;
+
+  while (index < lines.length) {
+    const line = lines[index]?.trim() ?? "";
+    const lineNumber = index + 2;
+
+    if (line.startsWith(ADD)) {
+      const path = readPath(line, ADD, lineNumber);
+      index++;
+      const content: string[] = [];
+      while (index < lines.length) {
+        const contentLine = lines[index] ?? "";
+        if (!contentLine.startsWith("+")) break;
+        content.push(contentLine.slice(1));
+        index++;
+      }
+      operations.push({ kind: "add", path, lines: content });
+      continue;
+    }
+
+    if (line.startsWith(DELETE)) {
+      operations.push({ kind: "delete", path: readPath(line, DELETE, lineNumber) });
+      index++;
+      continue;
+    }
+
+    if (line.startsWith(UPDATE)) {
+      const path = readPath(line, UPDATE, lineNumber);
+      index++;
+      let moveTo: string | undefined;
+      if ((lines[index] ?? "").trim().startsWith(MOVE)) {
+        moveTo = readPath((lines[index] ?? "").trim(), MOVE, index + 2);
+        index++;
+      }
+
+      const hunks: Hunk[] = [];
+      while (index < lines.length) {
+        const current = lines[index] ?? "";
+        if (current.trim() === "") {
+          index++;
+          continue;
+        }
+        if (isFileOp(current) || current.startsWith("*")) break;
+
+        const parsed = parseUpdateChunk(lines, index, index + 2, hunks.length === 0);
+        hunks.push(parsed.hunk);
+        index += parsed.consumed;
+      }
+
+      if (hunks.length === 0) {
+        throw new Error(`Invalid update for ${path}: update must include hunks`);
+      }
+      operations.push({ kind: "update", path, moveTo, hunks });
+      continue;
+    }
+
+    throw new Error(`Invalid patch line ${lineNumber}: expected file operation header`);
+  }
+
+  return operations;
+}
+
+function resolvePatchPath(cwd: string, patchPath: string): string {
+	return resolve(cwd, patchPath);
+}
+
+function isEnoent(error: unknown): boolean {
+  return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+
+function assertNotAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) throw new Error("Operation aborted");
+}
+
+function splitContent(content: string): string[] {
+  const lines = content.split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+}
+
+function joinContent(lines: string[]): string {
+  const next = [...lines];
+  if (next.at(-1) !== "") next.push("");
+  return next.join("\n");
+}
+
+function hunkOldLines(hunk: Hunk): string[] {
+  return hunk.lines.filter((line) => line.kind !== "add").map((line) => line.text);
+}
+
+function hunkNewLines(hunk: Hunk): string[] {
+  return hunk.lines.filter((line) => line.kind !== "remove").map((line) => line.text);
+}
+
+function matchesAt(lines: string[], pattern: string[], index: number): boolean {
+  if (index + pattern.length > lines.length) return false;
+  for (let offset = 0; offset < pattern.length; offset++) {
+    if (lines[index + offset] !== pattern[offset]) return false;
+  }
+  return true;
+}
+
+function findHeaderStart(path: string, lines: string[], header: string | undefined, startAt: number): number {
+  if (!header) return startAt;
+  const match = findMatch(lines, [header], startAt, false);
+  if (match.kind === "missing") throw new Error(`Failed to find context '${header}' in ${path}`);
+  return match.index + 1;
+}
+
+function normalizeUnicodePunctuation(value: string): string {
+  return value
+    .trim()
+    .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+    .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+    .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+    .replace(/[\u00A0\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000]/g, " ");
+}
+
+function findMatch(lines: string[], pattern: string[], startAt: number, endOfFile: boolean): Match {
+  if (pattern.length === 0) return { kind: "found", index: startAt };
+  if (pattern.length > lines.length) return { kind: "missing" };
+
+  const searchStart = endOfFile && lines.length >= pattern.length ? lines.length - pattern.length : startAt;
+  const normalizers = [(value: string) => value, (value: string) => value.trimEnd(), (value: string) => value.trim(), normalizeUnicodePunctuation];
+  for (const normalize of normalizers) {
+    const normalizedLines = lines.map(normalize);
+    const normalizedPattern = pattern.map(normalize);
+    for (let index = searchStart; index <= lines.length - pattern.length; index++) {
+      if (matchesAt(normalizedLines, normalizedPattern, index)) return { kind: "found", index };
+    }
+  }
+  return { kind: "missing" };
+}
+
+function applyUpdateHunks(path: string, content: string, hunks: Hunk[]): string {
+  const originalLines = splitContent(content);
+  const replacements: Array<{ start: number; oldLength: number; newLines: string[] }> = [];
+  let lineIndex = 0;
+
+  for (const hunk of hunks) {
+    lineIndex = findHeaderStart(path, originalLines, hunk.header, lineIndex);
+    let oldLines = hunkOldLines(hunk);
+    let newLines = hunkNewLines(hunk);
+
+    if (oldLines.length === 0) {
+      replacements.push({ start: originalLines.length, oldLength: 0, newLines });
+      continue;
+    }
+
+    let match = findMatch(originalLines, oldLines, lineIndex, hunk.endOfFile);
+    if (match.kind === "missing" && oldLines.at(-1) === "") {
+      oldLines = oldLines.slice(0, -1);
+      if (newLines.at(-1) === "") newLines = newLines.slice(0, -1);
+      match = findMatch(originalLines, oldLines, lineIndex, hunk.endOfFile);
+    }
+
+    if (match.kind === "missing") {
+      throw new Error(`Failed to find expected lines in ${path}:\n${hunkOldLines(hunk).join("\n")}`);
+    }
+
+    replacements.push({ start: match.index, oldLength: oldLines.length, newLines });
+    lineIndex = match.index + oldLines.length;
+  }
+
+  const lines = [...originalLines];
+  replacements.sort((left, right) => left.start - right.start);
+  for (const replacement of replacements.reverse()) {
+    lines.splice(replacement.start, replacement.oldLength, ...replacement.newLines);
+  }
+  return joinContent(lines);
+}
+
+async function assertDeletableFile(absolutePath: string, patchPath: string): Promise<void> {
+  let metadata: Awaited<ReturnType<typeof stat>>;
+  try {
+    metadata = await stat(absolutePath);
+  } catch (error) {
+    if (isEnoent(error)) throw new Error(`Cannot delete missing file: ${patchPath}`);
+    throw error;
+  }
+  if (metadata.isDirectory()) throw new Error(`Cannot delete directory: ${patchPath}`);
+}
+
+async function readUpdateFile(absolutePath: string, patchPath: string): Promise<string> {
+  try {
+    return await readFile(absolutePath, "utf8");
+  } catch (error) {
+    if (isEnoent(error)) throw new Error(`Cannot update missing file: ${patchPath}`);
+    throw error;
+  }
+}
+
+async function realpathIfExists(path: string): Promise<string | undefined> {
+  try {
+    return await realpath(path);
+  } catch (error) {
+    if (isEnoent(error)) return undefined;
+    throw error;
+  }
+}
+
+async function planChanges(cwd: string, operations: PatchOperation[], signal?: AbortSignal): Promise<PlannedChange[]> {
+  if (operations.length === 0) throw new Error("No files were modified.");
+
+  const changes: PlannedChange[] = [];
+  const pendingContent = new Map<string, string | null>();
+  for (const operation of operations) {
+    assertNotAborted(signal);
+    const absolutePath = resolvePatchPath(cwd, operation.path);
+
+    if (operation.kind === "add") {
+      const content = operation.lines.length === 0 ? "" : `${operation.lines.join("\n")}\n`;
+      pendingContent.set(absolutePath, content);
+      changes.push({
+        kind: "write",
+        changeKind: "A",
+        path: operation.path,
+        absolutePath,
+        content,
+      });
+      continue;
+    }
+
+    if (operation.kind === "delete") {
+      if (pendingContent.get(absolutePath) === null) throw new Error(`Cannot delete missing file: ${operation.path}`);
+      if (!pendingContent.has(absolutePath)) await assertDeletableFile(absolutePath, operation.path);
+      pendingContent.set(absolutePath, null);
+      changes.push({ kind: "delete", changeKind: "D", path: operation.path, absolutePath, summarize: true });
+      continue;
+    }
+
+    const pending = pendingContent.get(absolutePath);
+    if (pending === null) throw new Error(`Cannot update missing file: ${operation.path}`);
+    const current = pending ?? (await readUpdateFile(absolutePath, operation.path));
+    assertNotAborted(signal);
+    const targetPath = operation.moveTo ?? operation.path;
+    const targetAbsolutePath = resolvePatchPath(cwd, targetPath);
+    if (operation.moveTo && targetAbsolutePath === absolutePath) {
+      throw new Error(`Cannot move file to itself: ${operation.path}`);
+    }
+    const content = applyUpdateHunks(operation.path, current, operation.hunks);
+    pendingContent.set(targetAbsolutePath, content);
+    changes.push({
+      kind: "write",
+      changeKind: "M",
+      path: targetPath,
+      absolutePath: targetAbsolutePath,
+      content,
+    });
+    if (operation.moveTo) {
+      if (!pendingContent.has(absolutePath)) await assertDeletableFile(absolutePath, operation.path);
+      pendingContent.set(absolutePath, null);
+      changes.push({ kind: "delete", changeKind: "D", path: operation.path, absolutePath, summarize: false });
+    }
+  }
+  return changes;
+}
+
+async function writeChange(change: PlannedWrite, signal?: AbortSignal): Promise<void> {
+  assertNotAborted(signal);
+  await mkdir(dirname(change.absolutePath), { recursive: true });
+  await writeFile(change.absolutePath, change.content, { encoding: "utf8" });
+}
+
+async function withMutationQueues(paths: string[], fn: () => Promise<void>): Promise<void> {
+  const [first, ...rest] = [...new Set(paths)].sort();
+  if (!first) return fn();
+  return withFileMutationQueue(first, () => withMutationQueues(rest, fn));
+}
+
+async function operationPaths(cwd: string, operations: PatchOperation[]): Promise<string[]> {
+  const paths: string[] = [];
+  for (const operation of operations) {
+    const absolutePath = resolvePatchPath(cwd, operation.path);
+    const realPath = await realpathIfExists(absolutePath);
+    paths.push(realPath ?? absolutePath);
+    if (operation.kind === "update" && operation.moveTo) {
+      const targetAbsolutePath = resolvePatchPath(cwd, operation.moveTo);
+      const targetRealPath = await realpathIfExists(targetAbsolutePath);
+      paths.push(targetRealPath ?? targetAbsolutePath);
+    }
+  }
+  return paths;
+}
+
+function summarizedChanges(changes: PlannedChange[]): PlannedChange[] {
+  return changes.filter((change) => change.kind === "write" || change.summarize);
+}
+
+function summaryForChanges(changes: PlannedChange[]): string {
+  const lines = ["Success. Updated the following files:"];
+  const visible = summarizedChanges(changes);
+  for (const changeKind of ["A", "M", "D"] as const) {
+    for (const change of visible) {
+      if (change.changeKind === changeKind) lines.push(`${change.changeKind} ${change.path}`);
+    }
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+function summaryForUnifiedChanges(changes: UnifiedChange[]): string {
+  const lines = ["Success. Updated the following files:"];
+  for (const changeKind of ["A", "M", "D"] as const) {
+    for (const change of changes) {
+      if (change.changeKind === changeKind) lines.push(`${change.changeKind} ${change.path}`);
+    }
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+function runGitApply(cwd: string, patchFile: string, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn("git", ["apply", "--no-index", "--whitespace=nowarn", "--recount", patchFile], { cwd, signal });
+    let stderr = "";
+    let settled = false;
+
+    const fail = (error: Error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+    const succeed = () => {
+      if (settled) return;
+      settled = true;
+      resolvePromise();
+    };
+
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => { stderr += String(chunk); });
+    child.on("error", (error) => {
+      if (signal?.aborted) fail(new Error("Operation aborted"));
+      else fail(error);
+    });
+    child.on("close", (code, signalName) => {
+      if (code === 0) {
+        succeed();
+        return;
+      }
+      const suffix = signalName ? ` (signal ${signalName})` : code === null ? "" : ` (exit ${code})`;
+      fail(new Error(stderr.trim() || `git apply failed${suffix}`));
+    });
+  });
+}
+
+async function applyUnifiedPatch(cwd: string, input: string, signal?: AbortSignal): Promise<ApplyPatchResult> {
+  assertNotAborted(signal);
+  const changes = extractUnifiedChanges(input);
+  if (changes.length === 0) throw new Error("Invalid unified diff: no changed files found");
+  validateUnifiedPatchPaths(cwd, changes);
+
+  const tempDir = await mkdtemp(join(tmpdir(), "pi-apply-patch-"));
+  const patchFile = join(tempDir, "patch.diff");
+  try {
+    await writeFile(patchFile, input, "utf8");
+    await runGitApply(cwd, patchFile, signal);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
+  }
+
+  return { changedFiles: changes.map((change) => change.path), summary: summaryForUnifiedChanges(changes) };
+}
+
+export async function applyPatch(cwd: string, input: string, signal?: AbortSignal): Promise<ApplyPatchResult> {
+  if (!looksLikeBeginPatch(input)) return applyUnifiedPatch(cwd, input, signal);
+
+  const operations = parseApplyPatch(input);
+  const paths = await operationPaths(cwd, operations);
+  let changes: PlannedChange[] = [];
+
+  await withMutationQueues(paths, async () => {
+    changes = await planChanges(cwd, operations, signal);
+    for (const change of changes) {
+      assertNotAborted(signal);
+      if (change.kind === "delete") await rm(change.absolutePath, { force: false });
+      else await writeChange(change, signal);
+    }
+  });
+
+  const changedFiles = [...new Set(summarizedChanges(changes).map((change) => change.path))];
+  return { changedFiles, summary: summaryForChanges(changes) };
+}