@astrofoundry/pi-astro 0.5.0 → 0.6.0

package/extensions/multi-edit/types.ts

@@ -0,0 +1,53 @@
+export interface EditItem {
+	path: string;
+	oldText: string;
+	newText: string;
+}
+
+export interface EditResult {
+	path: string;
+	success: boolean;
+	message: string;
+	diff?: string;
+	firstChangedLine?: number;
+}
+
+/**
+ * A single edit window inside an Update File operation.
+ *
+ * `oldBlock` is the exact literal substring to find in the target file;
+ * `newBlock` is what it should be replaced with. Both are raw strings (not
+ * arrays of lines) so the applier can work directly via `indexOf` without
+ * reconstructing line arrays.
+ *
+ * `contextPrefix` is an optional anchor from a "@@ foo" hunk header. When set,
+ * the applier must find `contextPrefix` before searching for `oldBlock`, so
+ * the same oldBlock can appear multiple times in the file and be disambiguated
+ * by the anchor.
+ */
+export interface Hunk {
+	contextPrefix?: string;
+	oldBlock: string;
+	newBlock: string;
+}
+
+export type PatchOperation =
+	| { kind: "add"; path: string; contents: string }
+	| { kind: "delete"; path: string }
+	| { kind: "update"; path: string; hunks: Hunk[] };
+
+export interface PatchOpResult {
+	path: string;
+	message: string;
+	diff?: string;
+	firstChangedLine?: number;
+}
+
+export interface Workspace {
+	readText: (absolutePath: string) => Promise<string>;
+	writeText: (absolutePath: string, content: string) => Promise<void>;
+	deleteFile: (absolutePath: string) => Promise<void>;
+	exists: (absolutePath: string) => Promise<boolean>;
+	/** Check that the file is writable. Rejects if not. Virtual implementations may still touch the real FS so preflights fail fast on read-only files. */
+	checkWriteAccess: (absolutePath: string) => Promise<void>;
+}

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

@@ -0,0 +1,165 @@
+import { mkdtempSync, rmSync, writeFileSync, chmodSync, readFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createRealWorkspace, createVirtualWorkspace } from "./workspace.ts";
+
+describe("createVirtualWorkspace", () => {
+    let root: string;
+
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "virt-ws-"));
+    });
+
+    afterEach(() => {
+        rmSync(root, { recursive: true, force: true });
+    });
+
+    it("reads file content from disk on first access, then from memory", async () => {
+        const file = join(root, "a.txt");
+        writeFileSync(file, "hello", "utf-8");
+        const ws = createVirtualWorkspace(root);
+        expect(await ws.readText(file)).toBe("hello");
+        writeFileSync(file, "mutated on disk", "utf-8"); // underlying change
+        expect(await ws.readText(file)).toBe("hello"); // still cached
+    });
+
+    it("throws when reading a file that does not exist", async () => {
+        const ws = createVirtualWorkspace(root);
+        await expect(ws.readText(join(root, "missing.txt"))).rejects.toThrow(/not found/i);
+    });
+
+    it("writes to the virtual state and later reads return the new content", async () => {
+        const file = join(root, "b.txt");
+        writeFileSync(file, "old", "utf-8");
+        const ws = createVirtualWorkspace(root);
+        await ws.writeText(file, "new");
+        expect(await ws.readText(file)).toBe("new");
+    });
+
+    it("deletes a virtual file and errors on read after delete", async () => {
+        const file = join(root, "c.txt");
+        writeFileSync(file, "x", "utf-8");
+        const ws = createVirtualWorkspace(root);
+        await ws.deleteFile(file);
+        await expect(ws.readText(file)).rejects.toThrow(/not found/i);
+    });
+
+    it("rejects delete on non-existent file", async () => {
+        const ws = createVirtualWorkspace(root);
+        await expect(ws.deleteFile(join(root, "missing.txt"))).rejects.toThrow(/not found/i);
+    });
+
+    it("reports existence correctly", async () => {
+        const file = join(root, "d.txt");
+        writeFileSync(file, "x", "utf-8");
+        const ws = createVirtualWorkspace(root);
+        expect(await ws.exists(file)).toBe(true);
+        expect(await ws.exists(join(root, "missing.txt"))).toBe(false);
+    });
+
+    it("exists returns false after virtual delete", async () => {
+        const file = join(root, "e.txt");
+        writeFileSync(file, "x", "utf-8");
+        const ws = createVirtualWorkspace(root);
+        await ws.deleteFile(file);
+        expect(await ws.exists(file)).toBe(false);
+    });
+
+    it("checkWriteAccess resolves for writable files", async () => {
+        const file = join(root, "w.txt");
+        writeFileSync(file, "x", "utf-8");
+        const ws = createVirtualWorkspace(root);
+        await expect(ws.checkWriteAccess(file)).resolves.toBeUndefined();
+    });
+
+    it("checkWriteAccess rejects for read-only files", async () => {
+        const file = join(root, "ro.txt");
+        writeFileSync(file, "x", "utf-8");
+        chmodSync(file, 0o444);
+        const ws = createVirtualWorkspace(root);
+        await expect(ws.checkWriteAccess(file)).rejects.toThrow();
+        chmodSync(file, 0o644); // restore for rmSync
+    });
+});
+
+describe("createRealWorkspace", () => {
+    let root: string;
+    let events: Array<{ name: string; payload: unknown }>;
+    const piStub = {
+        events: {
+            emit: vi.fn((name: string, payload: unknown) => {
+                events.push({ name, payload });
+            }),
+        },
+    } as unknown as Parameters<typeof createRealWorkspace>[0];
+
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "real-ws-"));
+        events = [];
+        vi.mocked(piStub.events.emit).mockClear();
+    });
+
+    afterEach(() => {
+        rmSync(root, { recursive: true, force: true });
+    });
+
+    it("reads file and caches on subsequent calls", async () => {
+        const file = join(root, "a.txt");
+        writeFileSync(file, "hello", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        expect(await ws.readText(file)).toBe("hello");
+        writeFileSync(file, "changed on disk", "utf-8");
+        expect(await ws.readText(file)).toBe("hello"); // cached
+    });
+
+    it("writes to disk and emits context-guard:file-modified event", async () => {
+        const file = join(root, "b.txt");
+        writeFileSync(file, "old", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        await ws.readText(file); // populate cache
+        await ws.writeText(file, "new");
+        expect(readFileSync(file, "utf-8")).toBe("new");
+        expect(events.some((e) => e.name === "context-guard:file-modified")).toBe(true);
+    });
+
+    it("skips write when new content matches cached content (no-op dedup)", async () => {
+        const file = join(root, "c.txt");
+        writeFileSync(file, "same", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        await ws.readText(file);
+        events.length = 0;
+        await ws.writeText(file, "same");
+        // file on disk untouched, no event emitted
+        expect(events.length).toBe(0);
+    });
+
+    it("deletes a file and emits event", async () => {
+        const file = join(root, "d.txt");
+        writeFileSync(file, "x", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        await ws.deleteFile(file);
+        expect(existsSync(file)).toBe(false);
+        expect(events.some((e) => e.name === "context-guard:file-modified")).toBe(true);
+    });
+
+    it("reports existence for real files", async () => {
+        const file = join(root, "e.txt");
+        writeFileSync(file, "x", "utf-8");
+        const ws = createRealWorkspace(piStub);
+        expect(await ws.exists(file)).toBe(true);
+        expect(await ws.exists(join(root, "missing.txt"))).toBe(false);
+    });
+
+    it("checkWriteAccess resolves for writable + rejects for RO", async () => {
+        const wfile = join(root, "w.txt");
+        const rofile = join(root, "ro.txt");
+        writeFileSync(wfile, "x", "utf-8");
+        writeFileSync(rofile, "x", "utf-8");
+        chmodSync(rofile, 0o444);
+        const ws = createRealWorkspace(piStub);
+        await expect(ws.checkWriteAccess(wfile)).resolves.toBeUndefined();
+        await expect(ws.checkWriteAccess(rofile)).rejects.toThrow();
+        chmodSync(rofile, 0o644);
+    });
+});

package/extensions/multi-edit/workspace.ts

@@ -0,0 +1,85 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { constants } from "fs";
+import { access as fsAccess, readFile as fsReadFile, unlink as fsUnlink, writeFile as fsWriteFile } from "fs/promises";
+
+import type { Workspace } from "./types.ts";
+
+export function createRealWorkspace(pi: ExtensionAPI): Workspace {
+	const readCache = new Map<string, string>();
+	return {
+		readText: async (absolutePath: string) => {
+			if (readCache.has(absolutePath)) return readCache.get(absolutePath)!;
+			const content = await fsReadFile(absolutePath, "utf-8");
+			readCache.set(absolutePath, content);
+			return content;
+		},
+		writeText: async (absolutePath: string, content: string) => {
+			// Skip the write (and the file-modified event) when content is
+			// identical to what we last read. Prevents thrashing downstream
+			// consumers (watchers, context-guard) after no-op dedups.
+			const existing = readCache.get(absolutePath);
+			if (existing === content) return;
+			readCache.delete(absolutePath);
+			await fsWriteFile(absolutePath, content, "utf-8");
+			pi.events.emit("context-guard:file-modified", { path: absolutePath });
+		},
+		deleteFile: async (absolutePath: string) => {
+			readCache.delete(absolutePath);
+			await fsUnlink(absolutePath);
+			pi.events.emit("context-guard:file-modified", { path: absolutePath });
+		},
+		exists: async (absolutePath: string) => {
+			try {
+				await fsAccess(absolutePath, constants.F_OK);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		checkWriteAccess: (absolutePath: string) => fsAccess(absolutePath, constants.R_OK | constants.W_OK),
+	};
+}
+
+export function createVirtualWorkspace(cwd: string): Workspace {
+	const state = new Map<string, string | null>();
+
+	async function ensureLoaded(absolutePath: string): Promise<void> {
+		if (state.has(absolutePath)) return;
+		try {
+			const content = await fsReadFile(absolutePath, "utf-8");
+			state.set(absolutePath, content);
+		} catch {
+			state.set(absolutePath, null);
+		}
+	}
+
+	return {
+		readText: async (absolutePath) => {
+			await ensureLoaded(absolutePath);
+			const content = state.get(absolutePath);
+			if (content === null || content === undefined) {
+				throw new Error(`File not found: ${absolutePath.replace(`${cwd}/`, "")}`);
+			}
+			return content;
+		},
+		writeText: async (absolutePath, content) => {
+			state.set(absolutePath, content);
+		},
+		deleteFile: async (absolutePath) => {
+			await ensureLoaded(absolutePath);
+			if (state.get(absolutePath) === null) {
+				throw new Error(`File not found: ${absolutePath.replace(`${cwd}/`, "")}`);
+			}
+			state.set(absolutePath, null);
+		},
+		exists: async (absolutePath) => {
+			await ensureLoaded(absolutePath);
+			return state.get(absolutePath) !== null;
+		},
+		checkWriteAccess: async (absolutePath: string) => {
+			// Check real-fs write permission during the virtual preflight so
+			// that read-only files fail fast *before* any real file is touched.
+			await fsAccess(absolutePath, constants.W_OK);
+		},
+	};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Personal pi customizations (extensions, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"
@@ -52,7 +52,9 @@
     "@mariozechner/pi-ai": "^0.70.0",
     "@mariozechner/pi-coding-agent": "^0.70.0",
     "@mariozechner/pi-tui": "^0.70.0",
+    "@types/diff": "^8.0.0",
     "@types/node": "^25.6.0",
+    "@vitest/coverage-v8": "^4.1.5",
     "eslint": "^10.2.1",
     "globals": "^17.5.0",
     "typebox": "^1.1.33",
@@ -60,11 +62,15 @@
     "typescript-eslint": "^8.59.0",
     "vitest": "^4.1.5"
   },
+  "dependencies": {
+    "@google/genai": "^1.50.1",
+    "diff": "^9.0.0"
+  },
   "scripts": {
-    "test": "vitest run --passWithNoTests",
+    "test": "vitest run --coverage",
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
-    "check": "tsc --noEmit && eslint . && vitest run --passWithNoTests",
+    "check": "tsc --noEmit && eslint . && vitest run --coverage",
     "release:patch": "v=$(pnpm version patch --no-git-tag-version) && git add -A && git commit -m \"Release $v\" && git tag $v && git push && git push origin $v",
     "release:minor": "v=$(pnpm version minor --no-git-tag-version) && git add -A && git commit -m \"Release $v\" && git tag $v && git push && git push origin $v",
     "release:major": "v=$(pnpm version major --no-git-tag-version) && git add -A && git commit -m \"Release $v\" && git tag $v && git push && git push origin $v"