@astrofoundry/pi-astro 0.5.0 → 0.6.0

package/extensions/multi-edit/patch.test.ts

@@ -0,0 +1,242 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { applyPatchOperations, parsePatch } from "./patch.ts";
+import { createRealWorkspace, createVirtualWorkspace } from "./workspace.ts";
+
+const piStub = {
+    events: { emit: () => {} },
+} as unknown as Parameters<typeof createRealWorkspace>[0];
+
+describe("parsePatch", () => {
+    it("throws on empty patch", () => {
+        expect(() => parsePatch("")).toThrow(/empty or invalid/i);
+        expect(() => parsePatch("   ")).toThrow(/empty or invalid/i);
+    });
+
+    it("throws when missing Begin directive", () => {
+        expect(() => parsePatch("*** End Patch")).toThrow(/first line/i);
+    });
+
+    it("throws when missing End directive", () => {
+        expect(() => parsePatch("*** Begin Patch")).toThrow(/last line/i);
+    });
+
+    it("parses Add File with + lines", () => {
+        const ops = parsePatch(
+            "*** Begin Patch\n*** Add File: new.ts\n+export const x = 1;\n+export const y = 2;\n*** End Patch",
+        );
+        expect(ops).toHaveLength(1);
+        expect(ops[0]).toMatchObject({ kind: "add", path: "new.ts" });
+        expect((ops[0] as { kind: "add"; contents: string }).contents).toBe("export const x = 1;\nexport const y = 2;\n");
+    });
+
+    it("parses empty Add File to empty contents", () => {
+        const ops = parsePatch("*** Begin Patch\n*** Add File: empty.ts\n*** End Patch");
+        expect((ops[0] as { kind: "add"; contents: string }).contents).toBe("");
+    });
+
+    it("rejects Add File line without + prefix", () => {
+        expect(() =>
+            parsePatch("*** Begin Patch\n*** Add File: bad.ts\nno-plus-prefix\n*** End Patch"),
+        ).toThrow(/must start with '\+'/);
+    });
+
+    it("parses Delete File", () => {
+        const ops = parsePatch("*** Begin Patch\n*** Delete File: gone.ts\n*** End Patch");
+        expect(ops[0]).toEqual({ kind: "delete", path: "gone.ts" });
+    });
+
+    it("parses Update File with a hunk", () => {
+        const ops = parsePatch(
+            "*** Begin Patch\n*** Update File: x.ts\n@@\n-old\n+new\n*** End Patch",
+        );
+        expect(ops[0]).toMatchObject({ kind: "update", path: "x.ts" });
+        const hunks = (ops[0] as { kind: "update"; hunks: Array<{ oldBlock: string; newBlock: string }> }).hunks;
+        expect(hunks).toHaveLength(1);
+        expect(hunks[0].oldBlock).toBe("old");
+        expect(hunks[0].newBlock).toBe("new");
+    });
+
+    it("rejects Update File with *** Move to:", () => {
+        expect(() =>
+            parsePatch("*** Begin Patch\n*** Update File: x.ts\n*** Move to: y.ts\n*** End Patch"),
+        ).toThrow(/Move operations/i);
+    });
+
+    it("rejects Update File without any hunk", () => {
+        expect(() =>
+            parsePatch("*** Begin Patch\n*** Update File: x.ts\n*** End Patch"),
+        ).toThrow(/empty/);
+    });
+
+    it("rejects hunk without @@ header", () => {
+        expect(() =>
+            parsePatch("*** Begin Patch\n*** Update File: x.ts\n-old\n+new\n*** End Patch"),
+        ).toThrow(/@@/);
+    });
+
+    it("parses hunk with @@ context prefix after header", () => {
+        const ops = parsePatch(
+            "*** Begin Patch\n*** Update File: x.ts\n@@ function foo() {\n-old\n+new\n*** End Patch",
+        );
+        const hunk = (ops[0] as { hunks: Array<{ contextPrefix?: string }> }).hunks[0];
+        expect(hunk.contextPrefix).toBe("function foo() {");
+    });
+
+    it("parses context lines (starting with space) inside a hunk", () => {
+        const ops = parsePatch(
+            "*** Begin Patch\n*** Update File: x.ts\n@@\n context\n-old\n+new\n*** End Patch",
+        );
+        const hunk = (ops[0] as { hunks: Array<{ oldBlock: string; newBlock: string }> }).hunks[0];
+        expect(hunk.oldBlock).toContain("context");
+        expect(hunk.newBlock).toContain("context");
+    });
+
+    it("handles CRLF patches by normalizing to LF", () => {
+        const patch = "*** Begin Patch\r\n*** Delete File: a.ts\r\n*** End Patch";
+        expect(parsePatch(patch)).toEqual([{ kind: "delete", path: "a.ts" }]);
+    });
+
+    it("rejects unknown directive", () => {
+        expect(() =>
+            parsePatch("*** Begin Patch\n*** Frobnicate: x.ts\n*** End Patch"),
+        ).toThrow(/valid hunk header/);
+    });
+
+    it("skips blank lines between operations", () => {
+        const ops = parsePatch(
+            "*** Begin Patch\n\n*** Delete File: a.ts\n\n*** Delete File: b.ts\n*** End Patch",
+        );
+        expect(ops).toHaveLength(2);
+    });
+});
+
+describe("applyPatchOperations", () => {
+    let root: string;
+
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "patch-apply-"));
+    });
+
+    afterEach(() => {
+        rmSync(root, { recursive: true, force: true });
+    });
+
+    it("applies Add File on virtual workspace", async () => {
+        const ws = createVirtualWorkspace(root);
+        const ops = parsePatch("*** Begin Patch\n*** Add File: new.ts\n+hello\n*** End Patch");
+        const results = await applyPatchOperations(ops, ws, root, undefined, { collectDiff: false });
+        expect(results[0].message).toMatch(/Added|Created/i);
+        expect(await ws.readText(join(root, "new.ts"))).toBe("hello\n");
+    });
+
+    it("applies Delete File on virtual workspace", async () => {
+        const file = join(root, "gone.ts");
+        writeFileSync(file, "x", "utf-8");
+        const ws = createVirtualWorkspace(root);
+        const ops = parsePatch("*** Begin Patch\n*** Delete File: gone.ts\n*** End Patch");
+        const results = await applyPatchOperations(ops, ws, root, undefined, { collectDiff: false });
+        expect(results[0].message).toMatch(/Deleted|Removed/i);
+        expect(await ws.exists(file)).toBe(false);
+    });
+
+    it("applies Update File hunk on real workspace and writes disk", async () => {
+        const file = join(root, "x.ts");
+        writeFileSync(file, "alpha\nold\nbeta\n", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        const ops = parsePatch(
+            "*** Begin Patch\n*** Update File: x.ts\n@@\n-old\n+new\n*** End Patch",
+        );
+        const results = await applyPatchOperations(ops, ws, root, undefined, { collectDiff: true });
+        expect(results[0].message).toMatch(/Updated|Modified/i);
+        expect(readFileSync(file, "utf-8")).toContain("new");
+    });
+
+    it("rejects Update when file doesn't exist", async () => {
+        const ws = createVirtualWorkspace(root);
+        const ops = parsePatch(
+            "*** Begin Patch\n*** Update File: missing.ts\n@@\n-old\n+new\n*** End Patch",
+        );
+        await expect(
+            applyPatchOperations(ops, ws, root, undefined, { collectDiff: false }),
+        ).rejects.toThrow();
+    });
+
+    it("rejects Delete when file doesn't exist", async () => {
+        const ws = createVirtualWorkspace(root);
+        const ops = parsePatch("*** Begin Patch\n*** Delete File: nope.ts\n*** End Patch");
+        await expect(
+            applyPatchOperations(ops, ws, root, undefined, { collectDiff: false }),
+        ).rejects.toThrow();
+    });
+
+    it("honors abort signal mid-batch", async () => {
+        const ws = createVirtualWorkspace(root);
+        const file = join(root, "a.ts");
+        writeFileSync(file, "x", "utf-8");
+        const ops = parsePatch("*** Begin Patch\n*** Delete File: a.ts\n*** End Patch");
+        const ac = new AbortController();
+        ac.abort();
+        await expect(
+            applyPatchOperations(ops, ws, root, ac.signal, { collectDiff: false }),
+        ).rejects.toThrow();
+    });
+
+    it("finds hunk using contextPrefix to disambiguate", async () => {
+        const file = join(root, "x.ts");
+        writeFileSync(file, "dup\nfunction A() {\ndup\n}\nfunction B() {\ndup\n}\n", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        // Update only under function B
+        const ops = parsePatch(
+            "*** Begin Patch\n*** Update File: x.ts\n@@ function B() {\n-dup\n+changed\n*** End Patch",
+        );
+        await applyPatchOperations(ops, ws, root, undefined, { collectDiff: false });
+        const content = readFileSync(file, "utf-8");
+        // Only the one under B should change.
+        expect(content.split("changed")).toHaveLength(2);
+    });
+
+    it("rejects hunk whose oldBlock is not found in the file", async () => {
+        const file = join(root, "x.ts");
+        writeFileSync(file, "completely unrelated\n", "utf-8");
+        const ws = createVirtualWorkspace(root);
+        const ops = parsePatch(
+            "*** Begin Patch\n*** Update File: x.ts\n@@\n-missing-text\n+replacement\n*** End Patch",
+        );
+        await expect(
+            applyPatchOperations(ops, ws, root, undefined, { collectDiff: false }),
+        ).rejects.toThrow();
+    });
+
+    it("handles Add that overwrites existing file", async () => {
+        const file = join(root, "exists.ts");
+        writeFileSync(file, "old content\n", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        const ops = parsePatch("*** Begin Patch\n*** Add File: exists.ts\n+fresh\n*** End Patch");
+        await applyPatchOperations(ops, ws, root, undefined, { collectDiff: false });
+        expect(readFileSync(file, "utf-8")).toBe("fresh\n");
+    });
+
+    it("resolves relative paths against cwd", async () => {
+        const sub = join(root, "sub");
+        mkdirSync(sub);
+        const ws = createVirtualWorkspace(root);
+        const ops = parsePatch("*** Begin Patch\n*** Add File: sub/new.ts\n+hi\n*** End Patch");
+        await applyPatchOperations(ops, ws, root, undefined, { collectDiff: false });
+        expect(await ws.exists(join(root, "sub", "new.ts"))).toBe(true);
+    });
+
+    it("produces a diff when collectDiff is true", async () => {
+        const file = join(root, "x.ts");
+        writeFileSync(file, "old\n", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        const ops = parsePatch(
+            "*** Begin Patch\n*** Update File: x.ts\n@@\n-old\n+new\n*** End Patch",
+        );
+        const results = await applyPatchOperations(ops, ws, root, undefined, { collectDiff: true });
+        expect(results[0].diff).toBeDefined();
+        expect(results[0].firstChangedLine).toBeDefined();
+    });
+});

package/extensions/multi-edit/patch.ts

@@ -0,0 +1,463 @@
+/**
+ * Codex-style apply_patch engine.
+ *
+ * Accepts payloads bracketed by `*** Begin Patch` / `*** End Patch` and
+ * supports three operations: Add File, Delete File, Update File.
+ *
+ * Design — this is a recursive-descent parser over a line cursor. Each
+ * grammar rule owns a small function; there is no shared mutable index
+ * bookkeeping or nested-loop state machine. Hunks are stored as raw
+ * `oldBlock`/`newBlock` strings so the applier can run `indexOf` directly
+ * instead of reconstructing line arrays on each apply.
+ *
+ * Compatibility notes (vs the original Codex apply_patch format):
+ * - Hunks MUST start with a "@@" header. Missing headers are rejected.
+ * - Only exact-match hunk anchoring — no 4-pass fuzzy `seekSequence`.
+ * - `*** End of File` sentinel hunks are not recognized.
+ * - `*** Move to:` is rejected.
+ */
+
+import { isAbsolute, resolve as resolvePath } from "path";
+
+import { generateDiffString } from "./diff.ts";
+import type {
+  Hunk,
+  PatchOperation,
+  PatchOpResult,
+  Workspace,
+} from "./types.ts";
+
+// ---------------------------------------------------------------------------
+// Line cursor
+// ---------------------------------------------------------------------------
+
+class LineCursor {
+  private pos = 0;
+  constructor(private readonly lines: readonly string[]) {}
+
+  peek(): string | undefined {
+    return this.lines[this.pos];
+  }
+
+  next(): string | undefined {
+    return this.lines[this.pos++];
+  }
+
+  hasMore(): boolean {
+    return this.pos < this.lines.length;
+  }
+
+  /** Consume lines while the predicate holds. Returns the number consumed. */
+  skipWhile(pred: (line: string) => boolean): number {
+    let count = 0;
+    while (this.hasMore() && pred(this.peek()!)) {
+      this.pos++;
+      count++;
+    }
+    return count;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+
+const DIRECTIVE_BEGIN = "*** Begin Patch";
+const DIRECTIVE_END = "*** End Patch";
+const DIRECTIVE_ADD = "*** Add File: ";
+const DIRECTIVE_DELETE = "*** Delete File: ";
+const DIRECTIVE_UPDATE = "*** Update File: ";
+const DIRECTIVE_MOVE = "*** Move to: ";
+
+const isBlank = (line: string): boolean => line.trim() === "";
+const isDirective = (line: string): boolean =>
+  line.trimEnd().startsWith("*** ");
+
+export function parsePatch(patchText: string): PatchOperation[] {
+  const normalized = patchText.replace(/\r\n/g, "\n").trim();
+  if (normalized.length === 0) {
+    throw new Error("Patch is empty or invalid");
+  }
+
+  const lines = normalized.split("\n");
+  if (lines[0].trim() !== DIRECTIVE_BEGIN) {
+    throw new Error(`The first line of the patch must be '${DIRECTIVE_BEGIN}'`);
+  }
+  if (lines[lines.length - 1].trim() !== DIRECTIVE_END) {
+    throw new Error(`The last line of the patch must be '${DIRECTIVE_END}'`);
+  }
+
+  // Cursor over the interior (strip Begin and End sentinels).
+  const cursor = new LineCursor(lines.slice(1, -1));
+  const operations: PatchOperation[] = [];
+
+  while (cursor.hasMore()) {
+    cursor.skipWhile(isBlank);
+    if (!cursor.hasMore()) break;
+
+    const header = cursor.next()!.trimEnd();
+
+    if (header.startsWith(DIRECTIVE_ADD)) {
+      operations.push(parseAddFile(header.slice(DIRECTIVE_ADD.length), cursor));
+      continue;
+    }
+    if (header.startsWith(DIRECTIVE_DELETE)) {
+      operations.push({
+        kind: "delete",
+        path: header.slice(DIRECTIVE_DELETE.length),
+      });
+      continue;
+    }
+    if (header.startsWith(DIRECTIVE_UPDATE)) {
+      operations.push(
+        parseUpdateFile(header.slice(DIRECTIVE_UPDATE.length), cursor),
+      );
+      continue;
+    }
+
+    throw new Error(
+      `'${header}' is not a valid hunk header. Valid headers: '${DIRECTIVE_ADD.trim()}', '${DIRECTIVE_DELETE.trim()}', '${DIRECTIVE_UPDATE.trim()}'`,
+    );
+  }
+
+  return operations;
+}
+
+function parseAddFile(path: string, cursor: LineCursor): PatchOperation {
+  const bodyLines: string[] = [];
+
+  while (cursor.hasMore()) {
+    const line = cursor.peek()!;
+    if (isDirective(line)) break;
+    cursor.next();
+    if (!line.startsWith("+")) {
+      throw new Error(
+        `Invalid add-file line '${line}'. Add-file lines must start with '+'`,
+      );
+    }
+    bodyLines.push(line.slice(1));
+  }
+
+  const contents = bodyLines.length > 0 ? `${bodyLines.join("\n")}\n` : "";
+  return { kind: "add", path, contents };
+}
+
+function parseUpdateFile(path: string, cursor: LineCursor): PatchOperation {
+  // Move-to is explicitly rejected — we only support in-place updates.
+  const lookahead = cursor.peek();
+  if (
+    lookahead !== undefined &&
+    lookahead.trimEnd().startsWith(DIRECTIVE_MOVE)
+  ) {
+    throw new Error("Patch move operations (*** Move to:) are not supported.");
+  }
+
+  const hunks: Hunk[] = [];
+
+  while (cursor.hasMore()) {
+    cursor.skipWhile(isBlank);
+    if (!cursor.hasMore()) break;
+
+    const line = cursor.peek()!;
+    if (isDirective(line)) break;
+
+    hunks.push(parseHunk(path, cursor));
+  }
+
+  if (hunks.length === 0) {
+    throw new Error(`Update file hunk for path '${path}' is empty`);
+  }
+
+  return { kind: "update", path, hunks };
+}
+
+function parseHunk(path: string, cursor: LineCursor): Hunk {
+  const header = cursor.next();
+  if (header === undefined) {
+    throw new Error(`Expected @@ hunk header in '${path}', got end of patch`);
+  }
+
+  const trimmed = header.trimEnd();
+  let contextPrefix: string | undefined;
+  if (trimmed === "@@") {
+    contextPrefix = undefined;
+  } else if (trimmed.startsWith("@@ ")) {
+    contextPrefix = trimmed.slice(3);
+  } else {
+    throw new Error(
+      `Expected update hunk to start with @@ context marker, got: '${header}'`,
+    );
+  }
+
+  const oldLines: string[] = [];
+  const newLines: string[] = [];
+
+  while (cursor.hasMore()) {
+    const raw = cursor.peek()!;
+    const trimEnd = raw.trimEnd();
+
+    // Any directive or next hunk header ends the current hunk.
+    if (trimEnd.startsWith("@@") || isDirective(raw)) break;
+
+    cursor.next();
+
+    if (raw.length === 0) {
+      // Blank line inside a hunk is treated as an unchanged empty line.
+      oldLines.push("");
+      newLines.push("");
+      continue;
+    }
+
+    const marker = raw[0];
+    const body = raw.slice(1);
+
+    if (marker === " ") {
+      oldLines.push(body);
+      newLines.push(body);
+    } else if (marker === "-") {
+      oldLines.push(body);
+    } else if (marker === "+") {
+      newLines.push(body);
+    } else {
+      throw new Error(
+        `Unexpected line found in update hunk for '${path}': '${raw}'. Every line should start with ' ', '+', or '-'.`,
+      );
+    }
+  }
+
+  if (oldLines.length === 0 && newLines.length === 0) {
+    throw new Error(`Update hunk for '${path}' does not contain any lines`);
+  }
+
+  return {
+    contextPrefix,
+    oldBlock: oldLines.join("\n"),
+    newBlock: newLines.join("\n"),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Applier
+// ---------------------------------------------------------------------------
+
+/**
+ * Apply a list of hunks to a file's content. Operates directly on the raw
+ * string via `indexOf` — no intermediate line-array reconstruction. A search
+ * cursor advances after each hunk so repeated `oldBlock` strings are matched
+ * in top-to-bottom order.
+ */
+/**
+ * Find `needle` in `haystack` starting from `offset`. Tries exact match
+ * first; if that fails, retries with per-line trimEnd on both sides.
+ * Returns `{ pos, matchLength }` referencing the *original* haystack, or
+ * undefined when no match is found in either pass.
+ */
+function findBlock(
+  haystack: string,
+  needle: string,
+  offset: number,
+): { pos: number; matchLength: number } | undefined {
+  const exact = haystack.indexOf(needle, offset);
+  if (exact !== -1) return { pos: exact, matchLength: needle.length };
+
+  // trimEnd pass: strip trailing whitespace per line on both sides.
+  const trimLine = (s: string) =>
+    s
+      .split("\n")
+      .map((l) => l.trimEnd())
+      .join("\n");
+
+  const normNeedle = trimLine(needle);
+  const normHaystack = trimLine(haystack);
+  if (normNeedle === needle && normHaystack === haystack) return undefined;
+
+  const normPos = normHaystack.indexOf(normNeedle, offset);
+  if (normPos === -1) return undefined;
+
+  // Map normalised position back to original haystack. Because trimEnd only
+  // removes characters (never adds), character positions can only shift
+  // right. Walk original lines to find the real byte offset for the matched
+  // line index.
+  const normPrefix = normHaystack.slice(0, normPos);
+  const startLineIdx = normPrefix.split("\n").length - 1;
+
+  const origLines = haystack.split("\n");
+  let realPos = 0;
+  for (let i = 0; i < startLineIdx; i++) realPos += origLines[i].length + 1;
+
+  // Compute the real length: count original bytes for the matched lines.
+  const matchedLineCount = normNeedle.split("\n").length;
+  let realEnd = realPos;
+  for (let i = startLineIdx; i < startLineIdx + matchedLineCount; i++) {
+    realEnd += origLines[i].length + 1;
+  }
+  realEnd--; // exclude trailing \n after last line
+
+  // If the needle ended with \n, include it.
+  if (needle.endsWith("\n") && realEnd + 1 <= haystack.length) realEnd++;
+
+  return { pos: realPos, matchLength: realEnd - realPos };
+}
+
+function applyHunks(filePath: string, content: string, hunks: Hunk[]): string {
+  let result = content;
+  let cursor = 0;
+
+  for (const hunk of hunks) {
+    let searchFrom = cursor;
+
+    if (hunk.contextPrefix !== undefined) {
+      const ctxMatch = findBlock(result, hunk.contextPrefix, searchFrom);
+      if (ctxMatch === undefined) {
+        throw new Error(
+          `Failed to find context '${hunk.contextPrefix}' in ${filePath}`,
+        );
+      }
+      searchFrom = ctxMatch.pos + ctxMatch.matchLength;
+    }
+
+    if (hunk.oldBlock === "") {
+      // Pure insertion: append newBlock at the anchor (or end-of-file).
+      const insertAt =
+        hunk.contextPrefix !== undefined ? searchFrom : result.length;
+      const needsNewline = insertAt > 0 && result[insertAt - 1] !== "\n";
+      const prefix = needsNewline ? "\n" : "";
+      result =
+        result.slice(0, insertAt) +
+        prefix +
+        hunk.newBlock +
+        result.slice(insertAt);
+      cursor = insertAt + prefix.length + hunk.newBlock.length;
+      continue;
+    }
+
+    const match = findBlock(result, hunk.oldBlock, searchFrom);
+    if (match === undefined) {
+      throw new Error(
+        `Failed to find expected lines in ${filePath}:\n${hunk.oldBlock}`,
+      );
+    }
+
+    result =
+      result.slice(0, match.pos) +
+      hunk.newBlock +
+      result.slice(match.pos + match.matchLength);
+    cursor = match.pos + hunk.newBlock.length;
+  }
+
+  // Preserve the "file ends with newline" invariant upstream relies on.
+  if (!result.endsWith("\n")) {
+    result = `${result}\n`;
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Orchestration
+// ---------------------------------------------------------------------------
+
+function resolvePatchPath(cwd: string, filePath: string): string {
+  const trimmed = filePath.trim();
+  if (!trimmed) {
+    throw new Error("Patch path cannot be empty");
+  }
+  return isAbsolute(trimmed) ? resolvePath(trimmed) : resolvePath(cwd, trimmed);
+}
+
+function ensureTrailingNewline(content: string): string {
+  return content.endsWith("\n") ? content : `${content}\n`;
+}
+
+export async function applyPatchOperations(
+  ops: PatchOperation[],
+  workspace: Workspace,
+  cwd: string,
+  signal?: AbortSignal,
+  options?: { collectDiff?: boolean },
+): Promise<PatchOpResult[]> {
+  const results: PatchOpResult[] = [];
+  const collectDiff = options?.collectDiff ?? false;
+
+  for (const op of ops) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+
+    switch (op.kind) {
+      case "add": {
+        const abs = resolvePatchPath(cwd, op.path);
+        const oldText =
+          collectDiff && (await workspace.exists(abs))
+            ? await workspace.readText(abs)
+            : "";
+        const newText = ensureTrailingNewline(op.contents);
+        await workspace.writeText(abs, newText);
+        results.push(
+          buildOpResult(
+            op.path,
+            `Added file ${op.path}.`,
+            oldText,
+            newText,
+            collectDiff,
+          ),
+        );
+        break;
+      }
+
+      case "delete": {
+        const abs = resolvePatchPath(cwd, op.path);
+        if (!(await workspace.exists(abs))) {
+          throw new Error(`Failed to delete ${op.path}: file does not exist`);
+        }
+        const oldText = collectDiff ? await workspace.readText(abs) : "";
+        await workspace.deleteFile(abs);
+        results.push(
+          buildOpResult(
+            op.path,
+            `Deleted file ${op.path}.`,
+            oldText,
+            "",
+            collectDiff,
+          ),
+        );
+        break;
+      }
+
+      case "update": {
+        const abs = resolvePatchPath(cwd, op.path);
+        const sourceText = await workspace.readText(abs);
+        const updated = applyHunks(op.path, sourceText, op.hunks);
+        await workspace.writeText(abs, updated);
+        results.push(
+          buildOpResult(
+            op.path,
+            `Updated ${op.path}.`,
+            sourceText,
+            updated,
+            collectDiff,
+          ),
+        );
+        break;
+      }
+    }
+  }
+
+  return results;
+}
+
+function buildOpResult(
+  path: string,
+  message: string,
+  oldText: string,
+  newText: string,
+  collectDiff: boolean,
+): PatchOpResult {
+  const result: PatchOpResult = { path, message };
+  if (collectDiff) {
+    const { diff, firstChangedLine } = generateDiffString(oldText, newText);
+    result.diff = diff;
+    result.firstChangedLine = firstChangedLine;
+  }
+  return result;
+}