pi-usereq 0.48.0 → 0.50.0

package/pi.dev-src/pi-mono/coding-agent/test/extensions-discovery.test.ts

@@ -1,463 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { discoverAndLoadExtensions } from "../src/core/extensions/loader.js";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-describe("extensions discovery", () => {
-	let tempDir: string;
-	let extensionsDir: string;
-
-	beforeEach(() => {
-		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-ext-test-"));
-		extensionsDir = path.join(tempDir, "extensions");
-		fs.mkdirSync(extensionsDir);
-	});
-
-	afterEach(() => {
-		fs.rmSync(tempDir, { recursive: true, force: true });
-	});
-
-	const extensionCode = `
-		export default function(pi) {
-			pi.registerCommand("test", { handler: async () => {} });
-		}
-	`;
-
-	const extensionCodeWithTool = (toolName: string) => `
-		import { Type } from "typebox";
-		export default function(pi) {
-			pi.registerTool({
-				name: "${toolName}",
-				label: "${toolName}",
-				description: "Test tool",
-				parameters: Type.Object({}),
-				execute: async () => ({ content: [{ type: "text", text: "ok" }] }),
-			});
-		}
-	`;
-
-	it("discovers direct .ts files in extensions/", async () => {
-		fs.writeFileSync(path.join(extensionsDir, "foo.ts"), extensionCode);
-		fs.writeFileSync(path.join(extensionsDir, "bar.ts"), extensionCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(2);
-		expect(result.extensions.map((e) => path.basename(e.path)).sort()).toEqual(["bar.ts", "foo.ts"]);
-	});
-
-	it("discovers direct .js files in extensions/", async () => {
-		fs.writeFileSync(path.join(extensionsDir, "foo.js"), extensionCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(path.basename(result.extensions[0].path)).toBe("foo.js");
-	});
-
-	it("discovers subdirectory with index.ts", async () => {
-		const subdir = path.join(extensionsDir, "my-extension");
-		fs.mkdirSync(subdir);
-		fs.writeFileSync(path.join(subdir, "index.ts"), extensionCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].path).toContain("my-extension");
-		expect(result.extensions[0].path).toContain("index.ts");
-	});
-
-	it("discovers subdirectory with index.js", async () => {
-		const subdir = path.join(extensionsDir, "my-extension");
-		fs.mkdirSync(subdir);
-		fs.writeFileSync(path.join(subdir, "index.js"), extensionCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].path).toContain("index.js");
-	});
-
-	it("prefers index.ts over index.js", async () => {
-		const subdir = path.join(extensionsDir, "my-extension");
-		fs.mkdirSync(subdir);
-		fs.writeFileSync(path.join(subdir, "index.ts"), extensionCode);
-		fs.writeFileSync(path.join(subdir, "index.js"), extensionCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].path).toContain("index.ts");
-	});
-
-	it("discovers subdirectory with package.json pi field", async () => {
-		const subdir = path.join(extensionsDir, "my-package");
-		const srcDir = path.join(subdir, "src");
-		fs.mkdirSync(subdir);
-		fs.mkdirSync(srcDir);
-		fs.writeFileSync(path.join(srcDir, "main.ts"), extensionCode);
-		fs.writeFileSync(
-			path.join(subdir, "package.json"),
-			JSON.stringify({
-				name: "my-package",
-				pi: {
-					extensions: ["./src/main.ts"],
-				},
-			}),
-		);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].path).toContain("src");
-		expect(result.extensions[0].path).toContain("main.ts");
-	});
-
-	it("package.json can declare multiple extensions", async () => {
-		const subdir = path.join(extensionsDir, "my-package");
-		fs.mkdirSync(subdir);
-		fs.writeFileSync(path.join(subdir, "ext1.ts"), extensionCode);
-		fs.writeFileSync(path.join(subdir, "ext2.ts"), extensionCode);
-		fs.writeFileSync(
-			path.join(subdir, "package.json"),
-			JSON.stringify({
-				name: "my-package",
-				pi: {
-					extensions: ["./ext1.ts", "./ext2.ts"],
-				},
-			}),
-		);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(2);
-	});
-
-	it("package.json with pi field takes precedence over index.ts", async () => {
-		const subdir = path.join(extensionsDir, "my-package");
-		fs.mkdirSync(subdir);
-		fs.writeFileSync(path.join(subdir, "index.ts"), extensionCodeWithTool("from-index"));
-		fs.writeFileSync(path.join(subdir, "custom.ts"), extensionCodeWithTool("from-custom"));
-		fs.writeFileSync(
-			path.join(subdir, "package.json"),
-			JSON.stringify({
-				name: "my-package",
-				pi: {
-					extensions: ["./custom.ts"],
-				},
-			}),
-		);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].path).toContain("custom.ts");
-		// Verify the right tool was registered
-		expect(result.extensions[0].tools.has("from-custom")).toBe(true);
-		expect(result.extensions[0].tools.has("from-index")).toBe(false);
-	});
-
-	it("ignores package.json without pi field, falls back to index.ts", async () => {
-		const subdir = path.join(extensionsDir, "my-package");
-		fs.mkdirSync(subdir);
-		fs.writeFileSync(path.join(subdir, "index.ts"), extensionCode);
-		fs.writeFileSync(
-			path.join(subdir, "package.json"),
-			JSON.stringify({
-				name: "my-package",
-				version: "1.0.0",
-			}),
-		);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].path).toContain("index.ts");
-	});
-
-	it("ignores subdirectory without index or package.json", async () => {
-		const subdir = path.join(extensionsDir, "not-an-extension");
-		fs.mkdirSync(subdir);
-		fs.writeFileSync(path.join(subdir, "helper.ts"), extensionCode);
-		fs.writeFileSync(path.join(subdir, "utils.ts"), extensionCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(0);
-	});
-
-	it("does not recurse beyond one level", async () => {
-		const subdir = path.join(extensionsDir, "container");
-		const nested = path.join(subdir, "nested");
-		fs.mkdirSync(subdir);
-		fs.mkdirSync(nested);
-		fs.writeFileSync(path.join(nested, "index.ts"), extensionCode);
-		// No index.ts or package.json in container/
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(0);
-	});
-
-	it("handles mixed direct files and subdirectories", async () => {
-		// Direct file
-		fs.writeFileSync(path.join(extensionsDir, "direct.ts"), extensionCode);
-
-		// Subdirectory with index
-		const subdir1 = path.join(extensionsDir, "with-index");
-		fs.mkdirSync(subdir1);
-		fs.writeFileSync(path.join(subdir1, "index.ts"), extensionCode);
-
-		// Subdirectory with package.json
-		const subdir2 = path.join(extensionsDir, "with-manifest");
-		fs.mkdirSync(subdir2);
-		fs.writeFileSync(path.join(subdir2, "entry.ts"), extensionCode);
-		fs.writeFileSync(path.join(subdir2, "package.json"), JSON.stringify({ pi: { extensions: ["./entry.ts"] } }));
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(3);
-	});
-
-	it("skips non-existent paths declared in package.json", async () => {
-		const subdir = path.join(extensionsDir, "my-package");
-		fs.mkdirSync(subdir);
-		fs.writeFileSync(path.join(subdir, "exists.ts"), extensionCode);
-		fs.writeFileSync(
-			path.join(subdir, "package.json"),
-			JSON.stringify({
-				pi: {
-					extensions: ["./exists.ts", "./missing.ts"],
-				},
-			}),
-		);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].path).toContain("exists.ts");
-	});
-
-	it("loads extensions and registers commands", async () => {
-		fs.writeFileSync(path.join(extensionsDir, "with-command.ts"), extensionCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].commands.has("test")).toBe(true);
-	});
-
-	it("loads extensions and registers tools", async () => {
-		fs.writeFileSync(path.join(extensionsDir, "with-tool.ts"), extensionCodeWithTool("my-tool"));
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].tools.has("my-tool")).toBe(true);
-	});
-
-	it("reports errors for invalid extension code", async () => {
-		fs.writeFileSync(path.join(extensionsDir, "invalid.ts"), "this is not valid typescript export");
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(1);
-		expect(result.errors[0].path).toContain("invalid.ts");
-		expect(result.extensions).toHaveLength(0);
-	});
-
-	it("handles explicitly configured paths", async () => {
-		const customPath = path.join(tempDir, "custom-location", "my-ext.ts");
-		fs.mkdirSync(path.dirname(customPath), { recursive: true });
-		fs.writeFileSync(customPath, extensionCode);
-
-		const result = await discoverAndLoadExtensions([customPath], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].path).toContain("my-ext.ts");
-	});
-
-	it("resolves dependencies from extension's own node_modules", async () => {
-		// Load extension that has its own package.json and node_modules with 'ms' package
-		const extPath = path.resolve(__dirname, "../examples/extensions/with-deps");
-
-		const result = await discoverAndLoadExtensions([extPath], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].path).toContain("with-deps");
-		// The extension registers a 'parse_duration' tool
-		expect(result.extensions[0].tools.has("parse_duration")).toBe(true);
-	});
-
-	it("registers message renderers", async () => {
-		const extCode = `
-			export default function(pi) {
-				pi.registerMessageRenderer("my-custom-type", (message, options, theme) => {
-					return null; // Use default rendering
-				});
-			}
-		`;
-		fs.writeFileSync(path.join(extensionsDir, "with-renderer.ts"), extCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].messageRenderers.has("my-custom-type")).toBe(true);
-	});
-
-	it("reports error when extension throws during initialization", async () => {
-		const extCode = `
-			export default function(pi) {
-				throw new Error("Initialization failed!");
-			}
-		`;
-		fs.writeFileSync(path.join(extensionsDir, "throws.ts"), extCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(1);
-		expect(result.errors[0].error).toContain("Initialization failed!");
-		expect(result.extensions).toHaveLength(0);
-	});
-
-	it("reports error when extension has no default export", async () => {
-		const extCode = `
-			export function notDefault(pi) {
-				pi.registerCommand("test", { handler: async () => {} });
-			}
-		`;
-		fs.writeFileSync(path.join(extensionsDir, "no-default.ts"), extCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(1);
-		expect(result.errors[0].error).toContain("does not export a valid factory function");
-		expect(result.extensions).toHaveLength(0);
-	});
-
-	it("allows multiple extensions to register different tools", async () => {
-		fs.writeFileSync(path.join(extensionsDir, "tool-a.ts"), extensionCodeWithTool("tool-a"));
-		fs.writeFileSync(path.join(extensionsDir, "tool-b.ts"), extensionCodeWithTool("tool-b"));
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(2);
-
-		const allTools = new Set<string>();
-		for (const ext of result.extensions) {
-			for (const name of ext.tools.keys()) {
-				allTools.add(name);
-			}
-		}
-		expect(allTools.has("tool-a")).toBe(true);
-		expect(allTools.has("tool-b")).toBe(true);
-	});
-
-	it("loads extension with event handlers", async () => {
-		const extCode = `
-			export default function(pi) {
-				pi.on("agent_start", async () => {});
-				pi.on("tool_call", async (event) => undefined);
-				pi.on("agent_end", async () => {});
-			}
-		`;
-		fs.writeFileSync(path.join(extensionsDir, "with-handlers.ts"), extCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].handlers.has("agent_start")).toBe(true);
-		expect(result.extensions[0].handlers.has("tool_call")).toBe(true);
-		expect(result.extensions[0].handlers.has("agent_end")).toBe(true);
-	});
-
-	it("loads extension with shortcuts", async () => {
-		const extCode = `
-			export default function(pi) {
-				pi.registerShortcut("ctrl+t", {
-					description: "Test shortcut",
-					handler: async (ctx) => {},
-				});
-			}
-		`;
-		fs.writeFileSync(path.join(extensionsDir, "with-shortcut.ts"), extCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].shortcuts.has("ctrl+t")).toBe(true);
-	});
-
-	it("loads extension with flags", async () => {
-		const extCode = `
-			export default function(pi) {
-				pi.registerFlag("my-flag", {
-					description: "My custom flag",
-					handler: async (value) => {},
-				});
-			}
-		`;
-		fs.writeFileSync(path.join(extensionsDir, "with-flag.ts"), extCode);
-
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].flags.has("my-flag")).toBe(true);
-	});
-
-	it("loadExtensions only loads explicit paths without discovery", async () => {
-		// Create discoverable extensions (would be found by discoverAndLoadExtensions)
-		fs.writeFileSync(path.join(extensionsDir, "discovered.ts"), extensionCodeWithTool("discovered"));
-
-		// Create explicit extension outside discovery path
-		const explicitPath = path.join(tempDir, "explicit.ts");
-		fs.writeFileSync(explicitPath, extensionCodeWithTool("explicit"));
-
-		// Use loadExtensions directly to skip discovery
-		const { loadExtensions } = await import("../src/core/extensions/loader.js");
-		const result = await loadExtensions([explicitPath], tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(1);
-		expect(result.extensions[0].tools.has("explicit")).toBe(true);
-		expect(result.extensions[0].tools.has("discovered")).toBe(false);
-	});
-
-	it("loadExtensions with no paths loads nothing", async () => {
-		// Create discoverable extensions (would be found by discoverAndLoadExtensions)
-		fs.writeFileSync(path.join(extensionsDir, "discovered.ts"), extensionCode);
-
-		// Use loadExtensions directly with empty paths
-		const { loadExtensions } = await import("../src/core/extensions/loader.js");
-		const result = await loadExtensions([], tempDir);
-
-		expect(result.errors).toHaveLength(0);
-		expect(result.extensions).toHaveLength(0);
-	});
-});

package/pi.dev-src/pi-mono/coding-agent/test/extensions-input-event.test.ts

@@ -1,112 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { AuthStorage } from "../src/core/auth-storage.js";
-import { discoverAndLoadExtensions } from "../src/core/extensions/loader.js";
-import { ExtensionRunner } from "../src/core/extensions/runner.js";
-import { ModelRegistry } from "../src/core/model-registry.js";
-import { SessionManager } from "../src/core/session-manager.js";
-
-describe("Input Event", () => {
-	let tempDir: string;
-	let extensionsDir: string;
-
-	beforeEach(() => {
-		tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-input-test-"));
-		extensionsDir = path.join(tempDir, "extensions");
-		fs.mkdirSync(extensionsDir);
-		// Clean globalThis test vars
-		delete (globalThis as any).testVar;
-	});
-
-	afterEach(() => fs.rmSync(tempDir, { recursive: true, force: true }));
-
-	async function createRunner(...extensions: string[]) {
-		// Clear and recreate extensions dir for clean state
-		fs.rmSync(extensionsDir, { recursive: true, force: true });
-		fs.mkdirSync(extensionsDir);
-		for (let i = 0; i < extensions.length; i++) fs.writeFileSync(path.join(extensionsDir, `e${i}.ts`), extensions[i]);
-		const result = await discoverAndLoadExtensions([], tempDir, tempDir);
-		const sm = SessionManager.inMemory();
-		const mr = ModelRegistry.create(AuthStorage.create(path.join(tempDir, "auth.json")));
-		return new ExtensionRunner(result.extensions, result.runtime, tempDir, sm, mr);
-	}
-
-	it("returns continue when no handlers, undefined return, or explicit continue", async () => {
-		// No handlers
-		expect((await (await createRunner()).emitInput("x", undefined, "interactive")).action).toBe("continue");
-		// Returns undefined
-		let r = await createRunner(`export default p => p.on("input", async () => {});`);
-		expect((await r.emitInput("x", undefined, "interactive")).action).toBe("continue");
-		// Returns explicit continue
-		r = await createRunner(`export default p => p.on("input", async () => ({ action: "continue" }));`);
-		expect((await r.emitInput("x", undefined, "interactive")).action).toBe("continue");
-	});
-
-	it("transforms text and preserves images when omitted", async () => {
-		const r = await createRunner(
-			`export default p => p.on("input", async e => ({ action: "transform", text: "T:" + e.text }));`,
-		);
-		const imgs = [{ type: "image" as const, data: "orig", mimeType: "image/png" }];
-		const result = await r.emitInput("hi", imgs, "interactive");
-		expect(result).toEqual({ action: "transform", text: "T:hi", images: imgs });
-	});
-
-	it("transforms and replaces images when provided", async () => {
-		const r = await createRunner(
-			`export default p => p.on("input", async () => ({ action: "transform", text: "X", images: [{ type: "image", data: "new", mimeType: "image/jpeg" }] }));`,
-		);
-		const result = await r.emitInput("hi", [{ type: "image", data: "orig", mimeType: "image/png" }], "interactive");
-		expect(result).toEqual({
-			action: "transform",
-			text: "X",
-			images: [{ type: "image", data: "new", mimeType: "image/jpeg" }],
-		});
-	});
-
-	it("chains transforms across multiple handlers", async () => {
-		const r = await createRunner(
-			`export default p => p.on("input", async e => ({ action: "transform", text: e.text + "[1]" }));`,
-			`export default p => p.on("input", async e => ({ action: "transform", text: e.text + "[2]" }));`,
-		);
-		const result = await r.emitInput("X", undefined, "interactive");
-		expect(result).toEqual({ action: "transform", text: "X[1][2]", images: undefined });
-	});
-
-	it("short-circuits on handled and skips subsequent handlers", async () => {
-		(globalThis as any).testVar = false;
-		const r = await createRunner(
-			`export default p => p.on("input", async () => ({ action: "handled" }));`,
-			`export default p => p.on("input", async () => { globalThis.testVar = true; });`,
-		);
-		expect(await r.emitInput("X", undefined, "interactive")).toEqual({ action: "handled" });
-		expect((globalThis as any).testVar).toBe(false);
-	});
-
-	it("passes source correctly for all source types", async () => {
-		const r = await createRunner(
-			`export default p => p.on("input", async e => { globalThis.testVar = e.source; return { action: "continue" }; });`,
-		);
-		for (const source of ["interactive", "rpc", "extension"] as const) {
-			await r.emitInput("x", undefined, source);
-			expect((globalThis as any).testVar).toBe(source);
-		}
-	});
-
-	it("catches handler errors and continues", async () => {
-		const r = await createRunner(`export default p => p.on("input", async () => { throw new Error("boom"); });`);
-		const errs: string[] = [];
-		r.onError((e) => errs.push(e.error));
-		const result = await r.emitInput("x", undefined, "interactive");
-		expect(result.action).toBe("continue");
-		expect(errs).toContain("boom");
-	});
-
-	it("hasHandlers returns correct value", async () => {
-		let r = await createRunner();
-		expect(r.hasHandlers("input")).toBe(false);
-		r = await createRunner(`export default p => p.on("input", async () => {});`);
-		expect(r.hasHandlers("input")).toBe(true);
-	});
-});