@astrofoundry/pi-astro 0.5.0 → 0.6.0

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

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { generateDiffString } from "./diff.ts";
+
+describe("generateDiffString", () => {
+    it("returns empty diff + undefined firstChangedLine for identical content", () => {
+        const { diff, firstChangedLine } = generateDiffString("a\nb\nc\n", "a\nb\nc\n");
+        expect(diff).toBe("");
+        expect(firstChangedLine).toBeUndefined();
+    });
+
+    it("marks added line with + and correct new-file line number", () => {
+        const { diff, firstChangedLine } = generateDiffString("a\nb\n", "a\nb\nc\n");
+        expect(diff).toContain("+");
+        expect(diff).toContain("c");
+        expect(firstChangedLine).toBe(3);
+    });
+
+    it("marks removed line with - and correct old-file line number", () => {
+        const { diff, firstChangedLine } = generateDiffString("a\nb\nc\n", "a\nc\n");
+        expect(diff).toContain("-");
+        expect(diff).toContain("b");
+        expect(firstChangedLine).toBe(2);
+    });
+
+    it("pads line numbers to the widest count across both files", () => {
+        const old10 = Array.from({ length: 10 }, (_, i) => `l${i}`).join("\n") + "\n";
+        const new10 = old10.replace("l5", "lX");
+        const { diff } = generateDiffString(old10, new10);
+        // line numbers 1..10 → width 2; "1 " (single char) would indicate no padding
+        expect(diff).toMatch(/\s\s\d /);
+    });
+
+    it("collapses long unchanged runs between changes with a ... marker", () => {
+        const oldContent = ["A", ...Array.from({ length: 20 }, (_, i) => `x${i}`), "B"].join("\n") + "\n";
+        const newContent = oldContent.replace("A", "A2");
+        const { diff } = generateDiffString(oldContent, newContent);
+        expect(diff).toContain("...");
+    });
+
+    it("returns undefined firstChangedLine when contents match", () => {
+        const { firstChangedLine } = generateDiffString("x", "x");
+        expect(firstChangedLine).toBeUndefined();
+    });
+
+    it("handles mixed add+remove with both line numbers reported", () => {
+        const { diff, firstChangedLine } = generateDiffString("a\nb\nc\n", "a\nB\nc\n");
+        expect(diff).toContain("-");
+        expect(diff).toContain("+");
+        expect(firstChangedLine).toBe(2);
+    });
+
+    it("respects custom context-line window", () => {
+        const oldContent = Array.from({ length: 20 }, (_, i) => `line${i}`).join("\n") + "\n";
+        const newContent = oldContent.replace("line10", "lineTEN");
+        const { diff: diffWide } = generateDiffString(oldContent, newContent, 10);
+        const { diff: diffNarrow } = generateDiffString(oldContent, newContent, 1);
+        expect(diffWide.length).toBeGreaterThan(diffNarrow.length);
+    });
+
+    it("does not emit dead context when no changes exist before or after a run", () => {
+        // All identical -> no changes, no context should be emitted
+        const { diff } = generateDiffString("a\nb\n", "a\nb\n");
+        expect(diff).toBe("");
+    });
+});

package/extensions/multi-edit/diff.ts

@@ -0,0 +1,143 @@
+/**
+ * Two-pass diff renderer on top of `diff.diffLines`.
+ *
+ * Pass 1 — `expand`: flatten the `diffLines` change parts into a typed
+ * `Entry[]` stream where every entry carries its own 1-indexed old/new line
+ * numbers. No rendering decisions happen here.
+ *
+ * Pass 2 — `render`: walk the entries, buffer each unchanged run, and decide
+ * per run whether to show it whole, collapse it with a `...` marker, or
+ * discard it (when the run sits outside any change's context window).
+ *
+ * Output contract (stable, tested in __tests__/diff.test.ts):
+ * - Added lines:   `+NN text`
+ * - Removed lines: `-NN text`
+ * - Context lines: ` NN text`
+ * - Collapsed run: ` __ ...`   (blank gutter + ellipsis)
+ *
+ * Line numbers are right-padded to the width of the longest 1-indexed line
+ * number across both files so the gutter stays aligned.
+ */
+
+import * as Diff from "diff";
+
+type ContextEntry = { kind: "context"; oldLine: number; newLine: number; text: string };
+type AddedEntry = { kind: "added"; newLine: number; text: string };
+type RemovedEntry = { kind: "removed"; oldLine: number; text: string };
+type Entry = ContextEntry | AddedEntry | RemovedEntry;
+
+/**
+ * Walk `diff.diffLines` parts and yield a flat entry list plus the 1-indexed
+ * new-file line number of the first change. `firstChangedLine` is captured
+ * eagerly during expansion so callers don't have to re-scan the entries.
+ */
+function expand(parts: Diff.Change[]): { entries: Entry[]; firstChangedLine: number | undefined } {
+	const entries: Entry[] = [];
+	let oldNum = 1;
+	let newNum = 1;
+	let firstChangedLine: number | undefined;
+
+	for (const part of parts) {
+		const lines = part.value.split("\n");
+		// `diff.diffLines` always terminates with an empty string from the trailing
+		// newline — drop it so we don't emit a ghost row per part.
+		if (lines.length > 0 && lines[lines.length - 1] === "") {
+			lines.pop();
+		}
+
+		for (const text of lines) {
+			if (part.added) {
+				if (firstChangedLine === undefined) firstChangedLine = newNum;
+				entries.push({ kind: "added", newLine: newNum, text });
+				newNum++;
+			} else if (part.removed) {
+				if (firstChangedLine === undefined) firstChangedLine = newNum;
+				entries.push({ kind: "removed", oldLine: oldNum, text });
+				oldNum++;
+			} else {
+				entries.push({ kind: "context", oldLine: oldNum, newLine: newNum, text });
+				oldNum++;
+				newNum++;
+			}
+		}
+	}
+
+	return { entries, firstChangedLine };
+}
+
+/**
+ * Render an expanded entry stream into gutter-formatted output lines. Context
+ * runs are collapsed when their length exceeds the visible head + tail window.
+ */
+function render(entries: Entry[], contextLines: number, lineNumWidth: number): string[] {
+	const pad = (n: number) => String(n).padStart(lineNumWidth, " ");
+	const blankGutter = " ".repeat(lineNumWidth);
+	const out: string[] = [];
+
+	let i = 0;
+	while (i < entries.length) {
+		const entry = entries[i];
+
+		if (entry.kind === "added") {
+			out.push(`+${pad(entry.newLine)} ${entry.text}`);
+			i++;
+			continue;
+		}
+		if (entry.kind === "removed") {
+			out.push(`-${pad(entry.oldLine)} ${entry.text}`);
+			i++;
+			continue;
+		}
+
+		// entry.kind === "context" — buffer the whole run before deciding.
+		const runStart = i;
+		while (i < entries.length && entries[i].kind === "context") {
+			i++;
+		}
+		const runEnd = i;
+		const runLen = runEnd - runStart;
+
+		const hasChangeBefore = runStart > 0;
+		const hasChangeAfter = runEnd < entries.length;
+
+		// Context that isn't adjacent to any change is dead weight — drop it.
+		if (!hasChangeBefore && !hasChangeAfter) continue;
+
+		const head = hasChangeBefore ? contextLines : 0;
+		const tail = hasChangeAfter ? contextLines : 0;
+
+		const writeAt = (idx: number) => {
+			const e = entries[idx] as ContextEntry;
+			out.push(` ${pad(e.oldLine)} ${e.text}`);
+		};
+
+		if (runLen <= head + tail) {
+			for (let j = runStart; j < runEnd; j++) writeAt(j);
+			continue;
+		}
+
+		for (let j = 0; j < head; j++) writeAt(runStart + j);
+		out.push(` ${blankGutter} ...`);
+		for (let j = tail; j > 0; j--) writeAt(runEnd - j);
+	}
+
+	return out;
+}
+
+export function generateDiffString(
+	oldContent: string,
+	newContent: string,
+	contextLines = 4,
+): { diff: string; firstChangedLine: number | undefined } {
+	const parts = Diff.diffLines(oldContent, newContent);
+	const { entries, firstChangedLine } = expand(parts);
+
+	// Gutter width: pad to the widest 1-indexed line number that can appear.
+	const oldLineCount = oldContent.split("\n").length;
+	const newLineCount = newContent.split("\n").length;
+	const lineNumWidth = String(Math.max(oldLineCount, newLineCount)).length;
+
+	const lines = render(entries, contextLines, lineNumWidth);
+
+	return { diff: lines.join("\n"), firstChangedLine };
+}

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