@ag-eco/agentplate-cli 0.13.0

package/src/tools/trellis/commands/render.ts

@@ -0,0 +1,122 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { c, errorOut, humanOut, jsonOut } from "../output.ts";
+import { resolvePrompt } from "../render.ts";
+import { dedupById, readJsonl } from "../store.ts";
+import type { Prompt } from "../types.ts";
+import { ExitError } from "../types.ts";
+
+export default async function renderCmd(args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+	const promptsPath = join(cwd, ".trellis", "prompts.jsonl");
+
+	if (args.includes("--help") || args.includes("-h")) {
+		humanOut(`Usage: tl render <name>[@version] [options]
+
+Options:
+  --format md|json    Output format (default: md)
+  --json              Output as JSON`);
+		return;
+	}
+
+	const nameArg = args.filter((a) => !a.startsWith("--"))[0];
+	if (!nameArg) {
+		if (json) {
+			jsonOut({ success: false, command: "render", error: "Prompt name required" });
+		} else {
+			errorOut("Usage: tl render <name>[@version] [--format md|json]");
+		}
+		throw new ExitError(1);
+	}
+
+	// Parse name@version
+	let name = nameArg;
+	let version: number | undefined;
+	const atIdx = nameArg.lastIndexOf("@");
+	if (atIdx !== -1) {
+		name = nameArg.slice(0, atIdx);
+		version = Number.parseInt(nameArg.slice(atIdx + 1), 10);
+	}
+
+	// Parse format
+	let format = "md";
+	const fmtIdx = args.indexOf("--format");
+	if (fmtIdx !== -1 && args[fmtIdx + 1]) {
+		format = args[fmtIdx + 1] ?? "md";
+	}
+
+	const allRecords = await readJsonl<Prompt>(promptsPath);
+	const current = dedupById(allRecords);
+
+	try {
+		const result = resolvePrompt(name, current, version);
+
+		if (json) {
+			const envelope: Record<string, unknown> = {
+				success: true,
+				command: "render",
+				name,
+				version: result.version,
+				sections: result.sections,
+				resolvedFrom: result.resolvedFrom,
+				frontmatter: result.frontmatter,
+			};
+			if (result.loam !== undefined) envelope.loam = result.loam;
+			jsonOut(envelope);
+		} else if (format === "json") {
+			const payload: Record<string, unknown> = {
+				name,
+				version: result.version,
+				sections: result.sections,
+				resolvedFrom: result.resolvedFrom,
+				frontmatter: result.frontmatter,
+			};
+			if (result.loam !== undefined) payload.loam = result.loam;
+			jsonOut(payload);
+		} else {
+			// Markdown format
+			humanOut(c.bold(`# ${name}`) + c.dim(` (v${result.version})`));
+			humanOut(c.dim(`Resolved from: ${result.resolvedFrom.join(" → ")}`));
+			humanOut("");
+
+			if (Object.keys(result.frontmatter).length > 0) {
+				humanOut("---");
+				for (const [key, value] of Object.entries(result.frontmatter)) {
+					humanOut(`${key}: ${typeof value === "object" ? JSON.stringify(value) : value}`);
+				}
+				humanOut("---");
+				humanOut("");
+			}
+
+			for (const section of result.sections) {
+				humanOut(`## ${section.name}`);
+				humanOut("");
+				humanOut(section.body);
+				humanOut("");
+			}
+		}
+	} catch (err: unknown) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (json) {
+			jsonOut({ success: false, command: "render", error: msg });
+		} else {
+			errorOut(`Error: ${msg}`);
+		}
+		throw new ExitError(1);
+	}
+}
+
+export function registerRenderCommand(program: Command): void {
+	program
+		.command("render")
+		.description("Render full prompt (resolve inheritance)")
+		.argument("<name>", "Prompt name (name[@version])")
+		.option("--format <format>", "Output format: md or json (default: md)")
+		.action(async (name: string, options: { format?: string }) => {
+			const json: boolean = program.opts().json ?? false;
+			const args = [name];
+			if (options.format) args.push("--format", options.format);
+			if (json) args.push("--json");
+			await renderCmd(args, json);
+		});
+}

package/src/tools/trellis/commands/schema.ts

@@ -0,0 +1,353 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { generateId } from "../id.ts";
+import { c, errorOut, fmt, humanOut, jsonOut } from "../output.ts";
+import { acquireLock, appendJsonl, dedupByIdLast, readJsonl, releaseLock } from "../store.ts";
+import type { Schema, ValidationRule } from "../types.ts";
+import { ExitError } from "../types.ts";
+
+export default async function schema(args: string[], json: boolean): Promise<void> {
+	if (args.includes("--help") || args.includes("-h")) {
+		humanOut(`Usage: tl schema <subcommand> [options]
+
+Subcommands:
+  create --name <name> --required <sections> [--optional <sections>]
+  show <name>
+  list
+  rule add <schema> --section <name> --pattern <regex> --message <text>
+
+Options:
+  --json    Output as JSON`);
+		return;
+	}
+
+	const subcommand = args[0];
+
+	switch (subcommand) {
+		case "create":
+			await schemaCreate(args.slice(1), json);
+			break;
+		case "show":
+			await schemaShow(args.slice(1), json);
+			break;
+		case "list":
+			await schemaList(args.slice(1), json);
+			break;
+		case "rule":
+			if (args[1] === "add") {
+				await schemaRuleAdd(args.slice(2), json);
+			} else {
+				errorOut(`Unknown schema rule subcommand: ${args[1]}`);
+				throw new ExitError(1);
+			}
+			break;
+		default:
+			if (json) {
+				jsonOut({ success: false, command: "schema", error: `Unknown subcommand: ${subcommand}` });
+			} else {
+				errorOut(
+					`Unknown schema subcommand: ${subcommand}\nUsage: tl schema create|show|list|rule`,
+				);
+			}
+			throw new ExitError(1);
+	}
+}
+
+async function schemaCreate(args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+	const schemasPath = join(cwd, ".trellis", "schemas.jsonl");
+
+	let name = "";
+	const requiredSections: string[] = [];
+	const optionalSections: string[] = [];
+
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "--name" && args[i + 1]) {
+			name = args[++i] ?? "";
+		} else if (args[i] === "--required" && args[i + 1]) {
+			const parsed = (args[++i] ?? "")
+				.split(",")
+				.map((s) => s.trim())
+				.filter(Boolean);
+			requiredSections.push(...parsed);
+		} else if (args[i] === "--optional" && args[i + 1]) {
+			const parsed = (args[++i] ?? "")
+				.split(",")
+				.map((s) => s.trim())
+				.filter(Boolean);
+			optionalSections.push(...parsed);
+		}
+	}
+
+	if (!name) {
+		if (json) {
+			jsonOut({ success: false, command: "schema create", error: "--name is required" });
+		} else {
+			errorOut("--name is required");
+		}
+		throw new ExitError(1);
+	}
+
+	await acquireLock(schemasPath);
+	try {
+		const allRecords = await readJsonl<Schema>(schemasPath);
+		const current = dedupByIdLast(allRecords);
+
+		if (current.find((s) => s.name === name)) {
+			if (json) {
+				jsonOut({
+					success: false,
+					command: "schema create",
+					error: `Schema '${name}' already exists`,
+				});
+			} else {
+				errorOut(`Schema '${name}' already exists`);
+			}
+			throw new ExitError(1);
+		}
+
+		const id = generateId(
+			"schema",
+			current.map((s) => s.id),
+		);
+		const now = new Date().toISOString();
+
+		const schemaRecord: Schema = {
+			id,
+			name,
+			requiredSections,
+			optionalSections: optionalSections.length > 0 ? optionalSections : undefined,
+			createdAt: now,
+			updatedAt: now,
+		};
+
+		await appendJsonl(schemasPath, schemaRecord);
+
+		if (json) {
+			jsonOut({ success: true, command: "schema create", id, name });
+		} else {
+			humanOut(`${fmt.success("Created schema")} ${c.bold(name)} ${fmt.id(id)}`);
+		}
+	} finally {
+		releaseLock(schemasPath);
+	}
+}
+
+async function schemaShow(args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+	const schemasPath = join(cwd, ".trellis", "schemas.jsonl");
+
+	const name = args.filter((a) => !a.startsWith("--"))[0];
+	if (!name) {
+		if (json) {
+			jsonOut({ success: false, command: "schema show", error: "Schema name required" });
+		} else {
+			errorOut("Usage: tl schema show <name>");
+		}
+		throw new ExitError(1);
+	}
+
+	const allRecords = await readJsonl<Schema>(schemasPath);
+	const current = dedupByIdLast(allRecords);
+	const schemaRecord = current.find((s) => s.name === name);
+
+	if (!schemaRecord) {
+		if (json) {
+			jsonOut({ success: false, command: "schema show", error: `Schema '${name}' not found` });
+		} else {
+			errorOut(`Schema '${name}' not found`);
+		}
+		throw new ExitError(1);
+	}
+
+	if (json) {
+		jsonOut({ success: true, command: "schema show", schema: schemaRecord });
+	} else {
+		humanOut(`${c.bold(schemaRecord.name)} (${schemaRecord.id})`);
+		humanOut(`Required: ${schemaRecord.requiredSections.join(", ") || c.dim("(none)")}`);
+		if (schemaRecord.optionalSections?.length) {
+			humanOut(`Optional: ${schemaRecord.optionalSections.join(", ")}`);
+		}
+		if (schemaRecord.rules?.length) {
+			humanOut("\nRules:");
+			for (const rule of schemaRecord.rules) {
+				humanOut(`  ${c.cyan(rule.section)}: /${rule.pattern}/ → "${rule.message}"`);
+			}
+		}
+	}
+}
+
+async function schemaList(_args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+	const schemasPath = join(cwd, ".trellis", "schemas.jsonl");
+
+	const allRecords = await readJsonl<Schema>(schemasPath);
+	const schemas = dedupByIdLast(allRecords);
+
+	if (json) {
+		jsonOut({ success: true, command: "schema list", schemas, count: schemas.length });
+	} else {
+		if (schemas.length === 0) {
+			humanOut("No schemas found.");
+			return;
+		}
+		for (const s of schemas) {
+			const required = s.requiredSections.join(", ") || c.dim("(none)");
+			humanOut(`${c.bold(s.name)}  required: ${required}  ${c.dim(s.id)}`);
+		}
+	}
+}
+
+async function schemaRuleAdd(args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+	const schemasPath = join(cwd, ".trellis", "schemas.jsonl");
+
+	const schemaName = args.filter((a) => !a.startsWith("--"))[0];
+	if (!schemaName) {
+		if (json) {
+			jsonOut({ success: false, command: "schema rule add", error: "Schema name required" });
+		} else {
+			errorOut(
+				"Usage: tl schema rule add <schema-name> --section <name> --pattern <regex> --message <text>",
+			);
+		}
+		throw new ExitError(1);
+	}
+
+	let section = "";
+	let pattern = "";
+	let message = "";
+
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "--section" && args[i + 1]) {
+			section = args[++i] ?? "";
+		} else if (args[i] === "--pattern" && args[i + 1]) {
+			pattern = args[++i] ?? "";
+		} else if (args[i] === "--message" && args[i + 1]) {
+			message = args[++i] ?? "";
+		}
+	}
+
+	if (!section || !pattern || !message) {
+		if (json) {
+			jsonOut({
+				success: false,
+				command: "schema rule add",
+				error: "--section, --pattern, and --message are required",
+			});
+		} else {
+			errorOut("--section, --pattern, and --message are required");
+		}
+		throw new ExitError(1);
+	}
+
+	await acquireLock(schemasPath);
+	try {
+		const allRecords = await readJsonl<Schema>(schemasPath);
+		const current = dedupByIdLast(allRecords);
+
+		const schemaRecord = current.find((s) => s.name === schemaName);
+		if (!schemaRecord) {
+			if (json) {
+				jsonOut({
+					success: false,
+					command: "schema rule add",
+					error: `Schema '${schemaName}' not found`,
+				});
+			} else {
+				errorOut(`Schema '${schemaName}' not found`);
+			}
+			throw new ExitError(1);
+		}
+
+		const rule: ValidationRule = { section, pattern, message };
+		const updated: Schema = {
+			...schemaRecord,
+			rules: [...(schemaRecord.rules ?? []), rule],
+			updatedAt: new Date().toISOString(),
+		};
+
+		// Append updated schema (dedup on read handles version management for schemas)
+		await appendJsonl(schemasPath, updated);
+
+		if (json) {
+			jsonOut({ success: true, command: "schema rule add", schema: schemaName, rule });
+		} else {
+			humanOut(fmt.success(`Added rule to ${c.bold(schemaName)}: /${pattern}/ on "${section}"`));
+		}
+	} finally {
+		releaseLock(schemasPath);
+	}
+}
+
+export function registerSchemaCommand(program: Command): void {
+	const schemaCmd = program
+		.command("schema")
+		.description("Schema management (create, show, list, rule add)");
+
+	schemaCmd
+		.command("create")
+		.description("Create a validation schema")
+		.requiredOption("--name <name>", "Schema name")
+		.option(
+			"--required <sections>",
+			"Required sections (comma-separated, repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.option(
+			"--optional <sections>",
+			"Optional sections (comma-separated, repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.action(async (opts: Record<string, unknown>) => {
+			const json: boolean = program.opts().json ?? false;
+			const args: string[] = ["--name", opts.name as string];
+			for (const r of opts.required as string[]) args.push("--required", r);
+			for (const o of opts.optional as string[]) args.push("--optional", o);
+			await schemaCreate(args, json);
+		});
+
+	schemaCmd
+		.command("show")
+		.description("Show schema details")
+		.argument("<name>", "Schema name")
+		.action(async (name: string) => {
+			const json: boolean = program.opts().json ?? false;
+			await schemaShow([name], json);
+		});
+
+	schemaCmd
+		.command("list")
+		.description("List all schemas")
+		.action(async () => {
+			const json: boolean = program.opts().json ?? false;
+			await schemaList([], json);
+		});
+
+	const ruleCmd = schemaCmd.command("rule").description("Schema rule management");
+
+	ruleCmd
+		.command("add")
+		.description("Add a validation rule to a schema")
+		.argument("<schema>", "Schema name")
+		.requiredOption("--section <name>", "Section to validate")
+		.requiredOption("--pattern <regex>", "Regex pattern that must match")
+		.requiredOption("--message <text>", "Error message if validation fails")
+		.action(async (schemaName: string, opts: Record<string, unknown>) => {
+			const json: boolean = program.opts().json ?? false;
+			await schemaRuleAdd(
+				[
+					schemaName,
+					"--section",
+					opts.section as string,
+					"--pattern",
+					opts.pattern as string,
+					"--message",
+					opts.message as string,
+				],
+				json,
+			);
+		});
+}

package/src/tools/trellis/commands/show.ts

@@ -0,0 +1,115 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { c, errorOut, humanOut, jsonOut } from "../output.ts";
+import { dedupById, getVersions, readJsonl } from "../store.ts";
+import type { Prompt } from "../types.ts";
+import { ExitError } from "../types.ts";
+
+export default async function show(args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+	const promptsPath = join(cwd, ".trellis", "prompts.jsonl");
+
+	if (args.includes("--help") || args.includes("-h")) {
+		humanOut(`Usage: tl show <name>[@version] [options]
+
+Options:
+  --json    Output as JSON`);
+		return;
+	}
+
+	// Parse name@version syntax
+	const nameArg = args.filter((a) => !a.startsWith("--"))[0];
+	if (!nameArg) {
+		if (json) {
+			jsonOut({ success: false, command: "show", error: "Prompt name required" });
+		} else {
+			errorOut("Usage: tl show <name>[@version]");
+		}
+		throw new ExitError(1);
+	}
+
+	let name = nameArg;
+	let version: number | undefined;
+
+	const atIdx = nameArg.lastIndexOf("@");
+	if (atIdx !== -1) {
+		name = nameArg.slice(0, atIdx);
+		version = Number.parseInt(nameArg.slice(atIdx + 1), 10);
+		if (Number.isNaN(version)) {
+			errorOut(`Invalid version: ${nameArg.slice(atIdx + 1)}`);
+			throw new ExitError(1);
+		}
+	}
+
+	const allRecords = await readJsonl<Prompt>(promptsPath);
+
+	let prompt: Prompt | undefined;
+	if (version !== undefined) {
+		const _versions = getVersions(allRecords, "");
+		// Find by name + version
+		prompt = allRecords.find((p) => p.name === name && p.version === version);
+		if (!prompt) {
+			// Try to find by looking at all records with that name
+			const withName = allRecords.filter((p) => p.name === name);
+			prompt = withName.find((p) => p.version === version);
+		}
+	} else {
+		const current = dedupById(allRecords);
+		prompt = current.find((p) => p.name === name);
+	}
+
+	if (!prompt) {
+		const versionStr = version !== undefined ? `@${version}` : "";
+		if (json) {
+			jsonOut({
+				success: false,
+				command: "show",
+				error: `Prompt '${name}${versionStr}' not found`,
+			});
+		} else {
+			errorOut(`Prompt '${name}${versionStr}' not found`);
+		}
+		throw new ExitError(1);
+	}
+
+	if (json) {
+		jsonOut({ success: true, command: "show", prompt });
+	} else {
+		humanOut(`${c.bold(prompt.name)} (${prompt.id}) v${prompt.version}`);
+		if (prompt.description) humanOut(c.dim(prompt.description));
+		humanOut(
+			`Status: ${prompt.status}  Created: ${prompt.createdAt}  Updated: ${prompt.updatedAt}`,
+		);
+		if (prompt.extends) humanOut(`Extends: ${prompt.extends}`);
+		if (prompt.mixins?.length) humanOut(`Mixins: ${prompt.mixins.join(", ")}`);
+		if (prompt.tags?.length) humanOut(`Tags: ${prompt.tags.join(", ")}`);
+		if (prompt.schema) humanOut(`Schema: ${prompt.schema}`);
+		if (prompt.pinned !== undefined) humanOut(`Pinned: v${prompt.pinned}`);
+		if (prompt.frontmatter && Object.keys(prompt.frontmatter).length > 0) {
+			humanOut("Frontmatter:");
+			for (const [key, value] of Object.entries(prompt.frontmatter)) {
+				const display = typeof value === "object" ? JSON.stringify(value) : String(value);
+				humanOut(`  ${key}: ${display}`);
+			}
+		}
+		humanOut("");
+
+		for (const section of prompt.sections) {
+			humanOut(`${c.cyan(`## ${section.name}`)}${section.required ? " (required)" : ""}`);
+			humanOut(section.body || c.dim("(empty — removed from render)"));
+			humanOut("");
+		}
+	}
+}
+
+export function registerShowCommand(program: Command): void {
+	program
+		.command("show")
+		.description("Show prompt record")
+		.argument("<name>", "Prompt name (name[@version])")
+		.action(async (name: string) => {
+			const json: boolean = program.opts().json ?? false;
+			const args = [name, ...(json ? ["--json"] : [])];
+			await show(args, json);
+		});
+}

package/src/tools/trellis/commands/stats.ts

@@ -0,0 +1,65 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { c, humanOut, jsonOut } from "../output.ts";
+import { dedupById, dedupByIdLast, readJsonl } from "../store.ts";
+import type { Prompt, Schema } from "../types.ts";
+
+export default async function stats(_args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+
+	if (_args.includes("--help") || _args.includes("-h")) {
+		humanOut(`Usage: tl stats [options]
+
+Options:
+  --json    Output as JSON`);
+		return;
+	}
+
+	const promptsPath = join(cwd, ".trellis", "prompts.jsonl");
+	const schemasPath = join(cwd, ".trellis", "schemas.jsonl");
+
+	const allPromptRecords = await readJsonl<Prompt>(promptsPath);
+	const allSchemaRecords = await readJsonl<Schema>(schemasPath);
+
+	const prompts = dedupById(allPromptRecords);
+	const schemas = dedupByIdLast(allSchemaRecords);
+
+	const active = prompts.filter((p) => p.status === "active").length;
+	const draft = prompts.filter((p) => p.status === "draft").length;
+	const archived = prompts.filter((p) => p.status === "archived").length;
+	const total = prompts.length;
+	const totalVersions = allPromptRecords.length;
+	const withSchema = prompts.filter((p) => p.schema).length;
+	const withParent = prompts.filter((p) => p.extends).length;
+
+	if (json) {
+		jsonOut({
+			success: true,
+			command: "stats",
+			prompts: { total, active, draft, archived, withSchema, withParent, totalVersions },
+			schemas: schemas.length,
+		});
+	} else {
+		humanOut(c.bold("Trellis Stats"));
+		humanOut("");
+		humanOut("Prompts:");
+		humanOut(`  ${c.green(String(active))} active`);
+		humanOut(`  ${c.yellow(String(draft))} draft`);
+		humanOut(`  ${c.dim(String(archived))} archived`);
+		humanOut(`  ${c.dim(`${totalVersions} total versions in JSONL`)}`);
+		humanOut("");
+		humanOut(`  ${withSchema} with schema  |  ${withParent} with parent (inheritance)`);
+		humanOut(`  ${schemas.length} schema(s) defined`);
+	}
+}
+
+export function registerStatsCommand(program: Command): void {
+	program
+		.command("stats")
+		.description("Show prompt statistics")
+		.action(async () => {
+			const json: boolean = program.opts().json ?? false;
+			const args = json ? ["--json"] : [];
+			await stats(args, json);
+		});
+}