@astrofoundry/pi-astro 0.5.1 → 0.6.0

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

@@ -0,0 +1,170 @@
+import { 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 extensionDefault from "./index.ts";
+
+interface ToolDef {
+    name: string;
+    execute: (
+        id: string,
+        params: Record<string, unknown>,
+        signal: AbortSignal | undefined,
+        onUpdate: unknown,
+        ctx: { cwd: string; events?: { emit: (...a: unknown[]) => void } },
+    ) => Promise<{ content: Array<{ text: string }>; details: { diff?: string; firstChangedLine?: number } }>;
+}
+
+function makePi(): { tools: ToolDef[]; registerTool: (t: ToolDef) => void; events: { emit: () => void } } {
+    const tools: ToolDef[] = [];
+    return {
+        tools,
+        registerTool: (t) => tools.push(t),
+        events: { emit: () => {} },
+    };
+}
+
+function makeCtx(cwd: string): { cwd: string; events: { emit: () => void } } {
+    return { cwd, events: { emit: () => {} } };
+}
+
+describe("multi-edit extension (edit tool)", () => {
+    let root: string;
+    const pi = makePi();
+
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "medit-idx-"));
+        // Extension registers once — only call default on first iteration.
+        if (pi.tools.length === 0) {
+            extensionDefault(pi as unknown as Parameters<typeof extensionDefault>[0]);
+        }
+    });
+
+    afterEach(() => {
+        rmSync(root, { recursive: true, force: true });
+    });
+
+    it("registers a tool named 'edit'", () => {
+        expect(pi.tools[0].name).toBe("edit");
+    });
+
+    it("single edit via top-level path/oldText/newText", async () => {
+        const f = join(root, "a.ts");
+        writeFileSync(f, "hi\n", "utf-8");
+        const res = await pi.tools[0].execute(
+            "t",
+            { path: f, oldText: "hi", newText: "HI" },
+            undefined,
+            undefined,
+            makeCtx(root),
+        );
+        expect(res.content[0].text).toMatch(/.+/);
+        expect(readFileSync(f, "utf-8")).toContain("HI");
+    });
+
+    it("multi edit array applies to one file", async () => {
+        const f = join(root, "b.ts");
+        writeFileSync(f, "a\nb\n", "utf-8");
+        await pi.tools[0].execute(
+            "t",
+            {
+                multi: [
+                    { path: f, oldText: "a", newText: "A" },
+                    { path: f, oldText: "b", newText: "B" },
+                ],
+            },
+            undefined,
+            undefined,
+            makeCtx(root),
+        );
+        expect(readFileSync(f, "utf-8")).toBe("A\nB\n");
+    });
+
+    it("multi inherits top-level path when item omits it", async () => {
+        const f = join(root, "c.ts");
+        writeFileSync(f, "1\n2\n", "utf-8");
+        await pi.tools[0].execute(
+            "t",
+            {
+                path: f,
+                multi: [
+                    { oldText: "1", newText: "ONE" },
+                    { oldText: "2", newText: "TWO" },
+                ],
+            },
+            undefined,
+            undefined,
+            makeCtx(root),
+        );
+        expect(readFileSync(f, "utf-8")).toBe("ONE\nTWO\n");
+    });
+
+    it("patch mode creates a new file", async () => {
+        const patch = "*** Begin Patch\n*** Add File: new.ts\n+fresh\n*** End Patch";
+        await pi.tools[0].execute(
+            "t",
+            { patch },
+            undefined,
+            undefined,
+            makeCtx(root),
+        );
+        expect(readFileSync(join(root, "new.ts"), "utf-8")).toBe("fresh\n");
+    });
+
+    it("patch + classic params together is an error", async () => {
+        await expect(
+            pi.tools[0].execute(
+                "t",
+                { patch: "*** Begin Patch\n*** End Patch", path: "x" },
+                undefined,
+                undefined,
+                makeCtx(root),
+            ),
+        ).rejects.toThrow(/mutually exclusive/);
+    });
+
+    it("incomplete top-level (path + oldText without newText) is an error", async () => {
+        await expect(
+            pi.tools[0].execute(
+                "t",
+                { path: "x", oldText: "y" },
+                undefined,
+                undefined,
+                makeCtx(root),
+            ),
+        ).rejects.toThrow(/Incomplete top-level/);
+    });
+
+    it("no params at all is an error", async () => {
+        await expect(
+            pi.tools[0].execute("t", {}, undefined, undefined, makeCtx(root)),
+        ).rejects.toThrow(/No edits provided/);
+    });
+
+    it("multi item missing path and no top-level path is an error", async () => {
+        await expect(
+            pi.tools[0].execute(
+                "t",
+                { multi: [{ oldText: "x", newText: "y" }] },
+                undefined,
+                undefined,
+                makeCtx(root),
+            ),
+        ).rejects.toThrow(/missing a path/);
+    });
+
+    it("preflight error prevents real writes", async () => {
+        const f = join(root, "d.ts");
+        writeFileSync(f, "actual", "utf-8");
+        await expect(
+            pi.tools[0].execute(
+                "t",
+                { path: f, oldText: "missing-text", newText: "x" },
+                undefined,
+                undefined,
+                makeCtx(root),
+            ),
+        ).rejects.toThrow(/Preflight failed/);
+        expect(readFileSync(f, "utf-8")).toBe("actual");
+    });
+});

package/extensions/multi-edit/index.ts

@@ -0,0 +1,267 @@
+/**
+ * Multi-Edit Extension — replaces the built-in `edit` tool.
+ *
+ * Supports all original parameters (path, oldText, newText) plus:
+ * - `multi`: array of {path, oldText, newText} edits applied in sequence
+ * - `patch`: Codex-style apply_patch payload
+ *
+ * When both top-level params and `multi` are provided, the top-level edit
+ * is treated as an implicit first item prepended to the multi list.
+ *
+ * A preflight pass is performed before mutating files:
+ * - multi/top-level mode: preflight via virtualized built-in edit tool
+ * - patch mode: preflight by applying patch operations on a virtual filesystem
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+
+import { applyClassicEdits } from "./classic.ts";
+import { applyPatchOperations, parsePatch } from "./patch.ts";
+import type { EditItem } from "./types.ts";
+import { createRealWorkspace, createVirtualWorkspace } from "./workspace.ts";
+
+const editItemSchema = Type.Object({
+  path: Type.Optional(
+    Type.String({
+      description:
+        "Path to the file to edit (relative or absolute). Inherits from top-level path if omitted.",
+    }),
+  ),
+  oldText: Type.String({
+    description: "Exact text to find and replace (must match exactly)",
+  }),
+  newText: Type.String({
+    description: "New text to replace the old text with",
+  }),
+});
+
+const multiEditSchema = Type.Object({
+  path: Type.Optional(
+    Type.String({
+      description: "Path to the file to edit (relative or absolute)",
+    }),
+  ),
+  oldText: Type.Optional(
+    Type.String({
+      description: "Exact text to find and replace (must match exactly)",
+    }),
+  ),
+  newText: Type.Optional(
+    Type.String({ description: "New text to replace the old text with" }),
+  ),
+  multi: Type.Optional(
+    Type.Array(editItemSchema, {
+      description:
+        "Multiple edits to apply in sequence. Each item has path, oldText, and newText.",
+    }),
+  ),
+  patch: Type.Optional(
+    Type.String({
+      description:
+        "Codex-style apply_patch payload (*** Begin Patch ... *** End Patch). Mutually exclusive with path/oldText/newText/multi.",
+    }),
+  ),
+});
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "edit",
+    label: "edit",
+    description:
+      "Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits. Supports a `multi` parameter for batch edits across one or more files, and a `patch` parameter for Codex-style patches.",
+    promptSnippet:
+      "Edit a file by replacing exact text. The oldText must match exactly (including whitespace). Use this for precise, surgical edits.",
+    promptGuidelines: [
+      "Use edit for precise changes (old text must match exactly)",
+      "Use the `multi` parameter to apply multiple edits in a single tool call",
+      "Use the `patch` parameter for Codex-style multi-file / hunk-based edits",
+    ],
+    parameters: multiEditSchema,
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const { path, oldText, newText, multi, patch } = params;
+
+      const hasAnyClassicParam =
+        path !== undefined ||
+        oldText !== undefined ||
+        newText !== undefined ||
+        multi !== undefined;
+      if (patch !== undefined && hasAnyClassicParam) {
+        throw new Error(
+          "The `patch` parameter is mutually exclusive with path/oldText/newText/multi.",
+        );
+      }
+
+      if (patch !== undefined) {
+        const ops = parsePatch(patch);
+
+        // Preflight on virtual filesystem before mutating real files.
+        await applyPatchOperations(
+          ops,
+          createVirtualWorkspace(ctx.cwd),
+          ctx.cwd,
+          signal,
+          { collectDiff: false },
+        );
+
+        // Apply for real.
+        const applied = await applyPatchOperations(
+          ops,
+          createRealWorkspace(pi),
+          ctx.cwd,
+          signal,
+          { collectDiff: true },
+        );
+        const summary = applied
+          .map((r, i) => `${i + 1}. ${r.message}`)
+          .join("\n");
+        const combinedDiff = applied
+          .filter((r) => r.diff)
+          .map((r) => `File: ${r.path}\n${r.diff}`)
+          .join("\n\n");
+        const firstChangedLine = applied.find(
+          (r) => r.firstChangedLine !== undefined,
+        )?.firstChangedLine;
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Applied patch with ${applied.length} operation(s).\n${summary}`,
+            },
+          ],
+          details: {
+            diff: combinedDiff,
+            firstChangedLine,
+          },
+        };
+      }
+
+      // Build classic edit list.
+      const edits: EditItem[] = [];
+      const hasTopLevel =
+        path !== undefined && oldText !== undefined && newText !== undefined;
+
+      if (hasTopLevel) {
+        edits.push({ path: path!, oldText: oldText!, newText: newText! });
+      } else if (
+        path !== undefined ||
+        oldText !== undefined ||
+        newText !== undefined
+      ) {
+        // When multi is present, only a bare top-level `path` (for inheritance) is allowed.
+        // Any other partial combination (e.g. path+oldText, oldText+newText) is an error.
+        const hasOnlyPath =
+          path !== undefined && oldText === undefined && newText === undefined;
+        if (!hasOnlyPath || multi === undefined) {
+          const missing: string[] = [];
+          if (path === undefined) missing.push("path");
+          if (oldText === undefined) missing.push("oldText");
+          if (newText === undefined) missing.push("newText");
+          throw new Error(
+            `Incomplete top-level edit: missing ${missing.join(", ")}. Provide all three (path, oldText, newText) or use only the multi parameter.`,
+          );
+        }
+        // path-only top-level with multi is fine — path is inherited below.
+      }
+
+      if (multi) {
+        for (const item of multi) {
+          edits.push({
+            path: item.path ?? path ?? "",
+            oldText: item.oldText,
+            newText: item.newText,
+          });
+        }
+      }
+
+      if (edits.length === 0) {
+        throw new Error(
+          "No edits provided. Supply path/oldText/newText, a multi array, or a patch.",
+        );
+      }
+
+      // Validate that every edit has a path.
+      for (let i = 0; i < edits.length; i++) {
+        if (!edits[i].path) {
+          throw new Error(
+            `Edit ${i + 1} is missing a path. Provide a path on each multi item or set a top-level path to inherit.`,
+          );
+        }
+      }
+
+      // Preflight pass on virtual workspace before mutating real files.
+      // Uses sequential occurrence matching so same-file edits are resolved
+      // in file order (positional ordering).
+      try {
+        await applyClassicEdits(
+          edits,
+          createVirtualWorkspace(ctx.cwd),
+          ctx.cwd,
+          signal,
+          { collectDiff: false },
+        );
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Preflight failed before mutating files.\n${message}`, {
+          cause: err,
+        });
+      }
+
+      // Apply for real. `continueOnError` lets successful edits land even
+      // when a sibling fails; `rollbackOnError` restores files if an
+      // unexpected error (I/O, abort) breaks the batch mid-write.
+      const isBatch = edits.length > 1;
+      const results = await applyClassicEdits(
+        edits,
+        createRealWorkspace(pi),
+        ctx.cwd,
+        signal,
+        {
+          collectDiff: true,
+          rollbackOnError: true,
+          continueOnError: isBatch,
+        },
+      );
+
+      const succeeded = results.filter((r) => r?.success);
+      const failed = results.filter((r) => r && !r.success);
+
+      if (results.length === 1) {
+        const r = results[0];
+        return {
+          content: [{ type: "text" as const, text: r.message }],
+          details: {
+            diff: r.diff ?? "",
+            firstChangedLine: r.firstChangedLine,
+          },
+        };
+      }
+
+      const combinedDiff = results
+        .filter((r) => r?.diff)
+        .map((r) => r.diff)
+        .join("\n");
+
+      const firstChanged = results.find(
+        (r) => r?.firstChangedLine !== undefined,
+      )?.firstChangedLine;
+      const summary = results
+        .map((r, i) => `${i + 1}. ${r.message}`)
+        .join("\n");
+
+      const statusLine =
+        failed.length > 0
+          ? `Applied ${succeeded.length}/${results.length} edit(s). ${failed.length} failed:\n${summary}`
+          : `Applied ${results.length} edit(s) successfully.\n${summary}`;
+
+      return {
+        content: [{ type: "text" as const, text: statusLine }],
+        details: {
+          diff: combinedDiff,
+          firstChangedLine: firstChanged,
+        },
+      };
+    },
+  });
+}

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();
+    });
+});