@astrofoundry/pi-astro 0.5.1 → 0.6.0

package/extensions/grimoire/index.test.ts

@@ -0,0 +1,244 @@
+import { EventEmitter } from "node:events";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock node:child_process BEFORE importing the module under test.
+vi.mock("node:child_process", () => {
+    const mod = {
+        execFileSync: vi.fn(),
+        spawn: vi.fn(),
+    };
+    return mod;
+});
+
+type SpawnFactory = () => { proc: EventEmitter & { stdout: EventEmitter; stderr: EventEmitter; kill: (sig: string) => void }; emitClose: (code: number) => void; emitError: (err: Error) => void; emitData: (where: "stdout" | "stderr", chunk: string) => void };
+
+function makeFakeProc(): ReturnType<SpawnFactory> {
+    const proc = Object.assign(new EventEmitter(), {
+        stdout: new EventEmitter(),
+        stderr: new EventEmitter(),
+        kill: vi.fn(),
+    });
+    return {
+        proc,
+        emitClose: (code: number) => proc.emit("close", code),
+        emitError: (err: Error) => proc.emit("error", err),
+        emitData: (where, chunk) => proc[where].emit("data", Buffer.from(chunk)),
+    };
+}
+
+interface CapturedTool {
+    name: string;
+    description: string;
+    promptGuidelines?: string[];
+    execute: (id: string, input: { query: string; source?: string; top?: number }, signal?: AbortSignal, onUpdate?: unknown, ctx?: unknown) => Promise<unknown>;
+}
+
+interface CapturedPi {
+    registerTool: (tool: CapturedTool) => void;
+    tools: CapturedTool[];
+}
+
+function makePi(): CapturedPi {
+    const tools: CapturedTool[] = [];
+    return {
+        tools,
+        registerTool: (tool) => {
+            tools.push(tool);
+        },
+    };
+}
+
+function makeCtx(): { ui: { notify: ReturnType<typeof vi.fn> }; notifications: Array<[string, string | undefined]> } {
+    const notifications: Array<[string, string | undefined]> = [];
+    return {
+        notifications,
+        ui: {
+            notify: vi.fn((msg: string, type?: string) => {
+                notifications.push([msg, type]);
+            }),
+        },
+    };
+}
+
+describe("grimoire extension", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("loads --help into promptGuidelines when grimoire is available", async () => {
+        const { execFileSync } = await import("node:child_process");
+        vi.mocked(execFileSync).mockReturnValue("FAKE HELP OUTPUT" as unknown as ReturnType<typeof execFileSync>);
+
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+
+        const tool = pi.tools[0];
+        expect(tool.name).toBe("grimoire");
+        expect(tool.promptGuidelines?.some((g) => g.includes("FAKE HELP OUTPUT"))).toBe(true);
+    });
+
+    it("falls back to 'not available' promptGuidelines when grimoire CLI is missing", async () => {
+        const { execFileSync } = await import("node:child_process");
+        vi.mocked(execFileSync).mockImplementation(() => {
+            throw new Error("ENOENT");
+        });
+
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+
+        expect(pi.tools[0].promptGuidelines?.[0]).toMatch(/NOT available/i);
+    });
+
+    it("execute throws when CLI was not available at load time", async () => {
+        const { execFileSync } = await import("node:child_process");
+        vi.mocked(execFileSync).mockImplementation(() => {
+            throw new Error("ENOENT");
+        });
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        await expect(
+            pi.tools[0].execute("t1", { query: "x" }, undefined, undefined, ctx),
+        ).rejects.toThrow(/not installed/i);
+        expect(ctx.notifications.some((n) => n[1] === "error")).toBe(true);
+    });
+
+    it("execute returns stdout when grimoire exits 0 with results", async () => {
+        const { execFileSync, spawn } = await import("node:child_process");
+        vi.mocked(execFileSync).mockReturnValue("help" as unknown as ReturnType<typeof execFileSync>);
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        const promise = pi.tools[0].execute("t1", { query: "react hooks" }, undefined, undefined, ctx);
+        fake.emitData("stdout", "result line 1\nresult line 2\n");
+        fake.emitClose(0);
+        const result = (await promise) as { content: Array<{ text: string }> };
+        expect(result.content[0].text).toContain("result line 1");
+    });
+
+    it("execute with source + top passes them through as CLI args", async () => {
+        const { execFileSync, spawn } = await import("node:child_process");
+        vi.mocked(execFileSync).mockReturnValue("help" as unknown as ReturnType<typeof execFileSync>);
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        const promise = pi.tools[0].execute("t", { query: "q", source: "react", top: 3 }, undefined, undefined, ctx);
+        fake.emitData("stdout", "out");
+        fake.emitClose(0);
+        await promise;
+        const callArgs = vi.mocked(spawn).mock.calls[0][1] as string[];
+        expect(callArgs).toContain("--source");
+        expect(callArgs).toContain("react");
+        expect(callArgs).toContain("--top");
+        expect(callArgs).toContain("3");
+    });
+
+    it("execute notifies warning and returns soft result on no-results", async () => {
+        const { execFileSync, spawn } = await import("node:child_process");
+        vi.mocked(execFileSync).mockReturnValue("help" as unknown as ReturnType<typeof execFileSync>);
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        const promise = pi.tools[0].execute("t", { query: "zzz" }, undefined, undefined, ctx);
+        fake.emitData("stdout", "No results found.\n");
+        fake.emitClose(0);
+        const result = (await promise) as { content: Array<{ text: string }> };
+        expect(result.content[0].text).toMatch(/No results found/);
+        expect(ctx.notifications.some((n) => n[1] === "warning")).toBe(true);
+    });
+
+    it("execute also treats empty stdout as no-results and suggests widening scope when source given", async () => {
+        const { execFileSync, spawn } = await import("node:child_process");
+        vi.mocked(execFileSync).mockReturnValue("help" as unknown as ReturnType<typeof execFileSync>);
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        const promise = pi.tools[0].execute("t", { query: "zzz", source: "react" }, undefined, undefined, ctx);
+        fake.emitData("stdout", "");
+        fake.emitClose(0);
+        const result = (await promise) as { content: Array<{ text: string }> };
+        expect(result.content[0].text).toMatch(/widening scope/);
+    });
+
+    it("execute rejects on non-zero exit code", async () => {
+        const { execFileSync, spawn } = await import("node:child_process");
+        vi.mocked(execFileSync).mockReturnValue("help" as unknown as ReturnType<typeof execFileSync>);
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        const promise = pi.tools[0].execute("t", { query: "q" }, undefined, undefined, ctx);
+        fake.emitData("stderr", "bad source");
+        fake.emitClose(1);
+        await expect(promise).rejects.toThrow(/exited with code 1/);
+    });
+
+    it("execute rejects on ENOENT at spawn time with install guidance + notify", async () => {
+        const { execFileSync, spawn } = await import("node:child_process");
+        vi.mocked(execFileSync).mockReturnValue("help" as unknown as ReturnType<typeof execFileSync>);
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        const promise = pi.tools[0].execute("t", { query: "q" }, undefined, undefined, ctx);
+        const err = Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+        fake.emitError(err);
+        await expect(promise).rejects.toThrow(/not installed/i);
+        expect(ctx.notifications.some((n) => n[1] === "error")).toBe(true);
+    });
+
+    it("execute rejects on non-ENOENT spawn error", async () => {
+        const { execFileSync, spawn } = await import("node:child_process");
+        vi.mocked(execFileSync).mockReturnValue("help" as unknown as ReturnType<typeof execFileSync>);
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        const promise = pi.tools[0].execute("t", { query: "q" }, undefined, undefined, ctx);
+        fake.emitError(new Error("mystery"));
+        await expect(promise).rejects.toThrow(/failed to run/i);
+    });
+
+    it("execute kills process on abort signal", async () => {
+        const { execFileSync, spawn } = await import("node:child_process");
+        vi.mocked(execFileSync).mockReturnValue("help" as unknown as ReturnType<typeof execFileSync>);
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const ctx = makeCtx();
+        const ac = new AbortController();
+        const promise = pi.tools[0].execute("t", { query: "q" }, ac.signal, undefined, ctx);
+        ac.abort();
+        expect(fake.proc.kill).toHaveBeenCalledWith("SIGTERM");
+        fake.emitClose(0);
+        await expect(promise).resolves.toBeDefined();
+    });
+});

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

@@ -0,0 +1,274 @@
+import { chmodSync, 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 { applyClassicEdits, findActualString, formatResults } from "./classic.ts";
+import { createRealWorkspace, createVirtualWorkspace } from "./workspace.ts";
+
+const piStub = { events: { emit: () => {} } } as unknown as Parameters<typeof createRealWorkspace>[0];
+
+describe("findActualString", () => {
+    it("returns exact match when content contains oldText", () => {
+        const r = findActualString("hello world", "world", 0);
+        expect(r).toEqual({ pos: 6, actualOldText: "world" });
+    });
+
+    it("returns undefined when no match possible", () => {
+        expect(findActualString("abc", "xyz", 0)).toBeUndefined();
+    });
+
+    it("honors offset — match before offset is skipped", () => {
+        const r = findActualString("foo foo", "foo", 1);
+        expect(r?.pos).toBe(4);
+    });
+
+    it("falls back to curly-quote normalization (straight query, curly content)", () => {
+        const content = "const x = “hello”;"; // curly double quotes in content
+        const r = findActualString(content, 'const x = "hello";', 0);
+        expect(r).toBeDefined();
+        expect(r?.pos).toBe(0);
+    });
+
+    it("falls back to trimEnd per-line tolerance", () => {
+        const content = "line one   \nline two   \n";
+        const r = findActualString(content, "line one\nline two", 0);
+        expect(r).toBeDefined();
+    });
+});
+
+describe("applyClassicEdits", () => {
+    let root: string;
+
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "classic-"));
+    });
+
+    afterEach(() => {
+        rmSync(root, { recursive: true, force: true });
+    });
+
+    it("applies a single edit on a real file", async () => {
+        const file = join(root, "a.ts");
+        writeFileSync(file, "before\n", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        const res = await applyClassicEdits(
+            [{ path: file, oldText: "before", newText: "after" }],
+            ws,
+            root,
+            undefined,
+            { collectDiff: true },
+        );
+        expect(res[0].success).toBe(true);
+        expect(readFileSync(file, "utf-8")).toBe("after\n");
+    });
+
+    it("applies multiple edits in same file, top-to-bottom regardless of input order", async () => {
+        const file = join(root, "b.ts");
+        writeFileSync(file, "alpha\nbravo\ncharlie\n", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        // provide them in REVERSE order
+        await applyClassicEdits(
+            [
+                { path: file, oldText: "charlie", newText: "CHARLIE" },
+                { path: file, oldText: "alpha", newText: "ALPHA" },
+            ],
+            ws,
+            root,
+            undefined,
+            { collectDiff: false },
+        );
+        expect(readFileSync(file, "utf-8")).toBe("ALPHA\nbravo\nCHARLIE\n");
+    });
+
+    it("throws when oldText not found (single edit)", async () => {
+        const file = join(root, "c.ts");
+        writeFileSync(file, "x", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        await expect(
+            applyClassicEdits(
+                [{ path: file, oldText: "NOPE", newText: "N" }],
+                ws,
+                root,
+                undefined,
+                { collectDiff: false },
+            ),
+        ).rejects.toThrow();
+    });
+
+    it("throws when file missing", async () => {
+        const ws = createRealWorkspace(piStub);
+        await expect(
+            applyClassicEdits(
+                [{ path: join(root, "missing.ts"), oldText: "x", newText: "y" }],
+                ws,
+                root,
+                undefined,
+                { collectDiff: false },
+            ),
+        ).rejects.toThrow();
+    });
+
+    it("preflight on virtual workspace does NOT touch real files", async () => {
+        const file = join(root, "d.ts");
+        writeFileSync(file, "x", "utf-8");
+        const vws = createVirtualWorkspace(root);
+        await applyClassicEdits(
+            [{ path: file, oldText: "x", newText: "y" }],
+            vws,
+            root,
+            undefined,
+            { collectDiff: false },
+        );
+        expect(readFileSync(file, "utf-8")).toBe("x"); // unchanged on disk
+    });
+
+    it("rejects when the same oldText runs out of occurrences for duplicate edits", async () => {
+        const file = join(root, "e.ts");
+        writeFileSync(file, "one\n", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        await expect(
+            applyClassicEdits(
+                [
+                    { path: file, oldText: "one", newText: "two" },
+                    { path: file, oldText: "one", newText: "three" }, // second occurrence doesn't exist
+                ],
+                ws,
+                root,
+                undefined,
+                { collectDiff: false },
+            ),
+        ).rejects.toThrow();
+    });
+
+    it("continueOnError applies successful edits even when siblings fail", async () => {
+        const f1 = join(root, "f1.ts");
+        const f2 = join(root, "f2.ts");
+        writeFileSync(f1, "X", "utf-8");
+        writeFileSync(f2, "Y", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        const res = await applyClassicEdits(
+            [
+                { path: f1, oldText: "X", newText: "Xnew" },
+                { path: f2, oldText: "NOPE", newText: "N" }, // will fail
+            ],
+            ws,
+            root,
+            undefined,
+            { collectDiff: false, continueOnError: true },
+        );
+        expect(res[0].success).toBe(true);
+        expect(res[1].success).toBe(false);
+        expect(readFileSync(f1, "utf-8")).toBe("Xnew");
+    });
+
+    it("rollbackOnError restores already-written files when later file errors", async () => {
+        const f1 = join(root, "g1.ts");
+        writeFileSync(f1, "original", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        // Simulate: f1 succeeds (writes "new"), then f2 edit can't match -> rollback f1
+        await expect(
+            applyClassicEdits(
+                [
+                    { path: f1, oldText: "original", newText: "modified" },
+                    { path: join(root, "missing.ts"), oldText: "x", newText: "y" },
+                ],
+                ws,
+                root,
+                undefined,
+                { collectDiff: false, rollbackOnError: true },
+            ),
+        ).rejects.toThrow();
+        expect(readFileSync(f1, "utf-8")).toBe("original");
+    });
+
+    it("signal abort stops mid-batch", async () => {
+        const f1 = join(root, "h.ts");
+        writeFileSync(f1, "x", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        const ac = new AbortController();
+        ac.abort();
+        await expect(
+            applyClassicEdits(
+                [{ path: f1, oldText: "x", newText: "y" }],
+                ws,
+                root,
+                ac.signal,
+                { collectDiff: false },
+            ),
+        ).rejects.toThrow();
+    });
+
+    it("normalizes curly quotes from model input", async () => {
+        const file = join(root, "i.ts");
+        writeFileSync(file, 'const s = "hello";\n', "utf-8");
+        const ws = createRealWorkspace(piStub);
+        const res = await applyClassicEdits(
+            [{ path: file, oldText: "const s = “hello”;", newText: 'const s = "HI";' }],
+            ws,
+            root,
+            undefined,
+            { collectDiff: false },
+        );
+        expect(res[0].success).toBe(true);
+    });
+
+    it("no-op edit where newText equals oldText is treated as success", async () => {
+        const file = join(root, "j.ts");
+        writeFileSync(file, "same", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        const res = await applyClassicEdits(
+            [{ path: file, oldText: "same", newText: "same" }],
+            ws,
+            root,
+            undefined,
+            { collectDiff: true },
+        );
+        expect(res[0].success).toBe(true);
+    });
+
+    it("resolves relative paths against cwd", async () => {
+        const file = join(root, "sub.ts");
+        writeFileSync(file, "x", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        const res = await applyClassicEdits(
+            [{ path: "sub.ts", oldText: "x", newText: "y" }],
+            ws,
+            root,
+            undefined,
+            { collectDiff: false },
+        );
+        expect(res[0].success).toBe(true);
+        expect(readFileSync(file, "utf-8")).toBe("y");
+    });
+
+    it("preflight catches read-only file before real write", async () => {
+        const file = join(root, "ro.ts");
+        writeFileSync(file, "x", "utf-8");
+        chmodSync(file, 0o444);
+        const vws = createVirtualWorkspace(root);
+        await expect(
+            applyClassicEdits(
+                [{ path: file, oldText: "x", newText: "y" }],
+                vws,
+                root,
+                undefined,
+                { collectDiff: false },
+            ),
+        ).rejects.toThrow();
+        chmodSync(file, 0o644);
+    });
+});
+
+describe("formatResults", () => {
+    it("joins result messages", () => {
+        const out = formatResults(
+            [
+                { path: "a", success: true, message: "ok a" },
+                { path: "b", success: false, message: "fail b" },
+            ],
+            2,
+        );
+        expect(out).toContain("ok a");
+        expect(out).toContain("fail b");
+    });
+});