gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/src/resources/skills/create-gsd-extension/templates/templates.test.ts

@@ -3,56 +3,102 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { join, dirname, relative } from "node:path";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import ts from "typescript";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const skillRoot = join(__dirname, "..");
-
-function walk(dir: string): string[] {
-	const out: string[] = [];
-	for (const entry of readdirSync(dir)) {
-		const full = join(dir, entry);
-		if (statSync(full).isDirectory()) {
-			out.push(...walk(full));
-		} else {
-			out.push(full);
-		}
+
+const extensionApiStubs = `
+declare module "@gsd/pi-coding-agent" {
+	export interface ExtensionContext {
+		hasUI: boolean;
+		sessionManager: { getBranch(): Array<{ type: string; message: { role?: string; toolName?: string; details?: unknown } }> };
+		ui: { notify(message: string, level: string): void; custom<T>(view: unknown): Promise<T> };
+	}
+	export interface ExtensionAPI {
+		on(event: string, handler: (event: unknown, ctx: ExtensionContext) => unknown): void;
+		registerTool(tool: Record<string, unknown>): void;
+		registerCommand(name: string, command: {
+			description: string;
+			handler: (args: string, ctx: ExtensionContext) => unknown;
+		}): void;
 	}
-	return out;
+}
+
+declare module "@sinclair/typebox" {
+	export const Type: {
+		Object(shape: Record<string, unknown>): unknown;
+		Optional(schema: unknown): unknown;
+		String(options?: Record<string, unknown>): unknown;
+		Number(options?: Record<string, unknown>): unknown;
+	};
+}
+
+declare module "@gsd/pi-ai" {
+	export function StringEnum<T extends readonly string[]>(values: T): unknown;
+}
+
+declare module "@gsd/pi-tui" {
+	export class Text {
+		constructor(text: string, x: number, y: number);
+	}
+	export function truncateToWidth(text: string, width: number): string;
+	export function matchesKey(data: string, key: string): boolean;
+	export const Key: { escape: string };
+}
+`;
+
+function renderTemplate(template: string): string {
+	return template
+		.replaceAll("{{EXTENSION_NAME}}", "Sample Extension")
+		.replaceAll("{{DESCRIPTION}}", "Sample extension")
+		.replaceAll("{{CAPABILITIES_LIST}}", "- sample")
+		.replaceAll("{{tool_name}}", "sample_tool")
+		.replaceAll("{{Tool Label}}", "Sample Tool")
+		.replaceAll("{{Tool description for LLM}}", "Sample tool description")
+		.replaceAll("{{command_name}}", "sample")
+		.replaceAll("{{Command description}}", "Sample command")
+		.replaceAll("{{ItemType}}", "SampleItem")
+		.replaceAll("{{ToolDetails}}", "SampleToolDetails")
+		.replaceAll("{{Description for LLM}}", "Sample stateful tool description")
+		.replaceAll("{{items}}", "items")
+		.replaceAll("{{Items}}", "Items");
 }
 
 describe("extension templates use @gsd/* imports", () => {
 	const templates = ["extension-skeleton.ts", "stateful-tool-skeleton.ts"];
 
 	for (const template of templates) {
-		it(`${template} uses @gsd/pi-coding-agent (not @mariozechner)`, () => {
-			const content = readFileSync(join(__dirname, template), "utf-8");
-			assert.ok(content.includes("@gsd/pi-coding-agent"), `Expected @gsd/pi-coding-agent import in ${template}`);
-			assert.ok(!content.includes("@mariozechner/"), `Found stale @mariozechner/ import in ${template}`);
-		});
-	}
+		it(`${template} renders as a compilable extension module`, () => {
+			const dir = mkdtempSync(join(tmpdir(), "create-gsd-extension-template-"));
+			try {
+				const stubsPath = join(dir, "extension-api-stubs.d.ts");
+				const renderedPath = join(dir, template);
+				writeFileSync(stubsPath, extensionApiStubs, "utf-8");
+				const rendered = renderTemplate(readFileSync(join(__dirname, template), "utf-8"));
+				writeFileSync(renderedPath, rendered, "utf-8");
 
-	it("extension-skeleton.ts uses @gsd/pi-ai for StringEnum", () => {
-		const content = readFileSync(join(__dirname, "extension-skeleton.ts"), "utf-8");
-		assert.ok(content.includes("@gsd/pi-ai"), "Expected @gsd/pi-ai import");
-	});
-
-	it("stateful-tool-skeleton.ts uses @gsd/pi-tui", () => {
-		const content = readFileSync(join(__dirname, "stateful-tool-skeleton.ts"), "utf-8");
-		assert.ok(content.includes("@gsd/pi-tui"), "Expected @gsd/pi-tui import");
-	});
-
-	it("no @mariozechner/ references anywhere in create-gsd-extension/", () => {
-		const offenders: string[] = [];
-		for (const file of walk(skillRoot)) {
-			if (file.endsWith("templates.test.ts")) continue;
-			const content = readFileSync(file, "utf-8");
-			if (content.includes("@mariozechner/")) {
-				offenders.push(relative(skillRoot, file));
+				const program = ts.createProgram([stubsPath, renderedPath], {
+					allowJs: false,
+					esModuleInterop: true,
+					module: ts.ModuleKind.NodeNext,
+					moduleResolution: ts.ModuleResolutionKind.NodeNext,
+					noEmit: true,
+					skipLibCheck: true,
+					strict: false,
+					target: ts.ScriptTarget.ES2022,
+				});
+				const diagnostics = ts.getPreEmitDiagnostics(program).filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+				assert.deepEqual(
+					diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")),
+					[],
+				);
+			} finally {
+				rmSync(dir, { recursive: true, force: true });
 			}
-		}
-		assert.deepEqual(offenders, [], `Stale @mariozechner/ references found in: ${offenders.join(", ")}`);
-	});
+		});
+	}
 });