@ag-eco/agentplate-cli 0.13.0

package/src/trellis/client.test.ts

@@ -0,0 +1,107 @@
+/**
+ * Tests for the Trellis CLI client.
+ *
+ * Uses real `tl` CLI calls against the actual .trellis/ directory.
+ * We do not mock the CLI — the project root has real prompts to test against.
+ * Tests are skipped if the `tl` CLI is not installed (e.g. in CI).
+ */
+
+import { describe, expect, test } from "bun:test";
+import { AgentError } from "../errors.ts";
+import { createTrellisClient } from "./client.ts";
+
+// Check if trellis CLI is available
+let hasTrellis = false;
+try {
+	const proc = Bun.spawn(["which", "tl"], { stdout: "pipe", stderr: "pipe" });
+	const exitCode = await proc.exited;
+	hasTrellis = exitCode === 0;
+} catch {
+	hasTrellis = false;
+}
+
+// The worktree root has its own .trellis/ symlinked/shared from the canonical root.
+// Use process.cwd() which is set to the worktree root in bun test.
+const cwd = process.cwd();
+const client = createTrellisClient(cwd);
+
+describe("TrellisClient.list()", () => {
+	test.skipIf(!hasTrellis)("returns prompts array with at least one entry", async () => {
+		const result = await client.list();
+		expect(result.success).toBe(true);
+		expect(Array.isArray(result.prompts)).toBe(true);
+		expect(result.prompts.length).toBeGreaterThan(0);
+		const first = result.prompts[0];
+		expect(first).toBeDefined();
+		expect(typeof first?.name).toBe("string");
+		expect(typeof first?.version).toBe("number");
+		expect(Array.isArray(first?.sections)).toBe(true);
+	});
+});
+
+describe("TrellisClient.render()", () => {
+	test.skipIf(!hasTrellis)(
+		"returns TrellisRenderResult with name, version, sections for 'builder' prompt",
+		async () => {
+			const result = await client.render("builder");
+			expect(result.success).toBe(true);
+			expect(result.name).toBe("builder");
+			expect(typeof result.version).toBe("number");
+			expect(result.version).toBeGreaterThan(0);
+			expect(Array.isArray(result.sections)).toBe(true);
+			expect(result.sections.length).toBeGreaterThan(0);
+			const section = result.sections[0];
+			expect(section).toBeDefined();
+			expect(typeof section?.name).toBe("string");
+			expect(typeof section?.body).toBe("string");
+		},
+	);
+
+	test.skipIf(!hasTrellis)("throws AgentError on non-existent prompt", async () => {
+		await expect(client.render("nonexistent-prompt-xyz-404")).rejects.toThrow(AgentError);
+	});
+});
+
+describe("TrellisClient.show()", () => {
+	test.skipIf(!hasTrellis)("returns prompt object for 'builder'", async () => {
+		const result = await client.show("builder");
+		expect(result.success).toBe(true);
+		expect(result.prompt).toBeDefined();
+		expect(result.prompt.name).toBe("builder");
+		expect(typeof result.prompt.version).toBe("number");
+		expect(typeof result.prompt.id).toBe("string");
+		expect(Array.isArray(result.prompt.sections)).toBe(true);
+	});
+
+	test.skipIf(!hasTrellis)("throws AgentError on non-existent prompt", async () => {
+		await expect(client.show("nonexistent-prompt-xyz-404")).rejects.toThrow(AgentError);
+	});
+});
+
+describe("TrellisClient.validate()", () => {
+	test.skipIf(!hasTrellis)("returns {success, errors} for a named prompt", async () => {
+		const result = await client.validate("scout");
+		expect(typeof result.success).toBe("boolean");
+		expect(Array.isArray(result.errors)).toBe(true);
+		if (result.success) {
+			expect(result.errors.length).toBe(0);
+		}
+	});
+
+	test.skipIf(!hasTrellis)("returns success=false with errors for an invalid prompt", async () => {
+		// 'builder' is known to fail schema validation (missing test gate)
+		const result = await client.validate("builder");
+		expect(typeof result.success).toBe("boolean");
+		expect(Array.isArray(result.errors)).toBe(true);
+		// Either valid or invalid — just verify structure is correct
+		if (!result.success) {
+			expect(result.errors.length).toBeGreaterThan(0);
+		}
+	});
+
+	test.skipIf(!hasTrellis)("validate --all returns result with success boolean", async () => {
+		const result = await client.validate(undefined, { all: true });
+		expect(typeof result.success).toBe("boolean");
+		expect(Array.isArray(result.errors)).toBe(true);
+	});
+});

package/src/trellis/client.ts

@@ -0,0 +1,179 @@
+/**
+ * Trellis CLI client.
+ *
+ * Wraps the `tl` command-line tool for prompt management operations.
+ * All methods use Bun.spawn to invoke the CLI directly.
+ */
+
+import { AgentError } from "../errors.ts";
+import type {
+	TrellisListResult,
+	TrellisRenderResult,
+	TrellisShowResult,
+	TrellisValidateResult,
+} from "../types.ts";
+
+export interface TrellisClient {
+	/** Render a prompt, resolving inheritance. */
+	render(name: string, options?: { format?: "md" | "json" }): Promise<TrellisRenderResult>;
+
+	/** Validate a prompt (or all prompts) against its schema. */
+	validate(name?: string, options?: { all?: boolean }): Promise<TrellisValidateResult>;
+
+	/** List all prompts. */
+	list(options?: {
+		tag?: string;
+		status?: string;
+		extends?: string;
+		mixin?: string;
+	}): Promise<TrellisListResult>;
+
+	/** Show a prompt record. */
+	show(name: string): Promise<TrellisShowResult>;
+}
+
+/**
+ * Run a shell command and capture its output.
+ */
+async function runCommand(
+	cmd: string[],
+	cwd: string,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const proc = Bun.spawn(cmd, {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+	const exitCode = await proc.exited;
+	return { stdout, stderr, exitCode };
+}
+
+/**
+ * Create a TrellisClient bound to the given working directory.
+ *
+ * @param cwd - Working directory where tl commands should run
+ * @returns A TrellisClient instance wrapping the tl CLI
+ */
+export function createTrellisClient(cwd: string): TrellisClient {
+	async function runTrellis(
+		args: string[],
+		context: string,
+	): Promise<{ stdout: string; stderr: string }> {
+		const { stdout, stderr, exitCode } = await runCommand(["tl", ...args], cwd);
+		if (exitCode !== 0) {
+			throw new AgentError(`trellis ${context} failed (exit ${exitCode}): ${stderr.trim()}`);
+		}
+		return { stdout, stderr };
+	}
+
+	return {
+		async render(name, _options) {
+			// Always use --json for structured output; format param reserved for future use
+			const { stdout } = await runTrellis(["render", name, "--json"], `render ${name}`);
+			const trimmed = stdout.trim();
+			try {
+				const raw = JSON.parse(trimmed) as {
+					success: boolean;
+					name: string;
+					version: number;
+					sections: Array<{ name: string; body: string }>;
+				};
+				return {
+					success: raw.success,
+					name: raw.name,
+					version: raw.version,
+					sections: raw.sections,
+				};
+			} catch {
+				throw new AgentError(
+					`Failed to parse JSON from tl render ${name}: ${trimmed.slice(0, 200)}`,
+				);
+			}
+		},
+
+		async validate(name, options) {
+			const args = ["validate"];
+			if (options?.all) {
+				args.push("--all");
+			} else if (name) {
+				args.push(name);
+			}
+			// tl validate does not support --json; parse exit code and stdout/stderr
+			const { stdout, stderr, exitCode } = await runCommand(["tl", ...args], cwd);
+			const output = (stdout + stderr).trim();
+			const errors: string[] = [];
+			if (exitCode !== 0) {
+				// Extract error lines from output (lines containing "error:")
+				for (const line of output.split("\n")) {
+					const trimmedLine = line.trim();
+					if (trimmedLine.includes("error:")) {
+						errors.push(trimmedLine);
+					}
+				}
+				if (errors.length === 0 && output) {
+					errors.push(output);
+				}
+			}
+			return { success: exitCode === 0, errors };
+		},
+
+		async list(options) {
+			const args = ["list", "--json"];
+			if (options?.tag) {
+				args.push("--tag", options.tag);
+			}
+			if (options?.status) {
+				args.push("--status", options.status);
+			}
+			if (options?.extends) {
+				args.push("--extends", options.extends);
+			}
+			if (options?.mixin) {
+				args.push("--mixin", options.mixin);
+			}
+			const { stdout } = await runTrellis(args, "list");
+			const trimmed = stdout.trim();
+			try {
+				const raw = JSON.parse(trimmed) as {
+					success: boolean;
+					prompts: Array<{
+						id: string;
+						name: string;
+						version: number;
+						sections: Array<{ name: string; body: string }>;
+					}>;
+				};
+				return {
+					success: raw.success,
+					prompts: raw.prompts,
+				};
+			} catch {
+				throw new AgentError(`Failed to parse JSON from tl list: ${trimmed.slice(0, 200)}`);
+			}
+		},
+
+		async show(name) {
+			const { stdout } = await runTrellis(["show", name, "--json"], `show ${name}`);
+			const trimmed = stdout.trim();
+			try {
+				const raw = JSON.parse(trimmed) as {
+					success: boolean;
+					prompt: {
+						id: string;
+						name: string;
+						version: number;
+						sections: Array<{ name: string; body: string }>;
+					};
+				};
+				return {
+					success: raw.success,
+					prompt: raw.prompt,
+				};
+			} catch {
+				throw new AgentError(`Failed to parse JSON from tl show ${name}: ${trimmed.slice(0, 200)}`);
+			}
+		},
+	};
+}