@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,365 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { Command } from "commander";
+import { loadConfig } from "../config.ts";
+import { renderFrontmatter } from "../frontmatter.ts";
+import { c, errorOut, fmt, humanOut, jsonOut } from "../output.ts";
+import { resolvePrompt } from "../render.ts";
+import { dedupById, readJsonl } from "../store.ts";
+import type { Config, Prompt } from "../types.ts";
+import { ExitError } from "../types.ts";
+
+function formatSections(sections: { name: string; body: string }[]): string {
+	return sections.length === 1
+		? sections.map((s) => s.body).join("")
+		: sections.map((s) => `## ${s.name}\n\n${s.body}`).join("\n\n");
+}
+
+function promptToMarkdown(
+	sections: { name: string; body: string }[],
+	frontmatter: Record<string, unknown>,
+	promptName: string,
+	promptDescription?: string,
+): string {
+	const combined: Record<string, unknown> = { name: promptName };
+	if (promptDescription) combined.description = promptDescription;
+	Object.assign(combined, frontmatter);
+
+	const fmBlock = renderFrontmatter(combined);
+	const sectionsMd = `${formatSections(sections)}\n`;
+	return fmBlock ? `${fmBlock}\n${sectionsMd}` : sectionsMd;
+}
+
+export function toExportName(name: string): string {
+	return name.toUpperCase().replace(/-/g, "_");
+}
+
+export function escapeTemplateLiteral(s: string): string {
+	return s.replace(/\\[`\\$]|`|\$\{|\\/g, (match) => {
+		// Already-escaped sequences: preserve as-is in the template literal
+		if (match === "\\`" || match === "\\\\" || match === "\\$") return match;
+		// Raw characters that need escaping for template literal safety
+		if (match === "`") return "\\`";
+		if (match === "${") return "\\${";
+		// Lone backslash (not followed by `, \, or $)
+		return "\\\\";
+	});
+}
+
+function promptToTypeScript(
+	sections: { name: string; body: string }[],
+	promptName: string,
+	promptDescription?: string,
+): string {
+	const exportName = toExportName(promptName);
+	const body = formatSections(sections);
+	const escaped = escapeTemplateLiteral(body);
+
+	const lines: string[] = [
+		"// Auto-generated by Trellis — do not edit manually",
+		`// Prompt: ${promptName}`,
+	];
+	if (promptDescription) {
+		lines.push(`// ${promptDescription}`);
+	}
+	lines.push("");
+	lines.push(`export const ${exportName} = \`${escaped}\`;`);
+	lines.push("");
+	return lines.join("\n");
+}
+
+function renderPrompt(
+	filename: string,
+	sections: { name: string; body: string }[],
+	frontmatter: Record<string, unknown>,
+	promptName: string,
+	promptDescription?: string,
+): string {
+	if (filename.endsWith(".ts")) {
+		return promptToTypeScript(sections, promptName, promptDescription);
+	}
+	return promptToMarkdown(sections, frontmatter, promptName, promptDescription);
+}
+
+export function resolveEmitDir(prompt: Prompt, config: Config): string {
+	if (prompt.emitDir) return prompt.emitDir;
+	if (config.targets && prompt.tags) {
+		for (const tag of prompt.tags) {
+			for (const target of Object.values(config.targets)) {
+				if (target.tags?.includes(tag)) return target.dir;
+			}
+		}
+	}
+	if (config.targets) {
+		const defaultTarget = Object.values(config.targets).find((t) => t.default);
+		if (defaultTarget) return defaultTarget.dir;
+	}
+	return "agents";
+}
+
+async function emitPrompt(
+	prompt: Prompt,
+	outDir: string,
+	allPrompts: Prompt[],
+	force: boolean,
+): Promise<{ name: string; path: string; version: number; skipped?: boolean }> {
+	const pinnedVersion = prompt.pinned;
+	const result = resolvePrompt(prompt.name, allPrompts, pinnedVersion);
+	const filename = prompt.emitAs ?? `${prompt.name}.md`;
+	const outPath = join(outDir, filename);
+
+	if (!force && existsSync(outPath)) {
+		// Check if up to date
+		const existing = await Bun.file(outPath).text();
+		const content = renderPrompt(
+			filename,
+			result.sections,
+			result.frontmatter,
+			prompt.name,
+			prompt.description,
+		);
+		if (existing === content) {
+			return { name: prompt.name, path: outPath, version: result.version, skipped: true };
+		}
+	}
+
+	mkdirSync(dirname(outPath), { recursive: true });
+	await Bun.write(
+		outPath,
+		renderPrompt(filename, result.sections, result.frontmatter, prompt.name, prompt.description),
+	);
+
+	return { name: prompt.name, path: outPath, version: result.version };
+}
+
+export default async function emit(args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+	const promptsPath = join(cwd, ".trellis", "prompts.jsonl");
+	const config = await loadConfig(cwd);
+
+	if (args.includes("--help") || args.includes("-h")) {
+		humanOut(`Usage: tl emit <name> [options]
+       tl emit --all [options]
+
+Options:
+  --all              Emit all active prompts
+  --check            Check if emitted files are up to date
+  --out <path>       Custom output path (single prompt)
+  --out-dir <path>   Custom output directory (--all mode)
+  --force            Overwrite even if unchanged
+  --dry-run          Show what would be emitted
+  --json             Output as JSON`);
+		return;
+	}
+
+	const force = args.includes("--force");
+	const dryRun = args.includes("--dry-run");
+	const checkMode = args.includes("--check");
+	const allMode = args.includes("--all") || checkMode;
+
+	const allRecords = await readJsonl<Prompt>(promptsPath);
+	const current = dedupById(allRecords);
+
+	// Get output directory override (applies to all prompts when set)
+	let outDir: string | undefined;
+	const outDirIdx = args.indexOf("--out-dir");
+	if (outDirIdx !== -1 && args[outDirIdx + 1]) {
+		outDir = args[outDirIdx + 1];
+	}
+
+	if (allMode) {
+		const activePrompts = current.filter((p) => p.status === "active");
+
+		if (dryRun) {
+			if (json) {
+				jsonOut({
+					success: true,
+					command: "emit",
+					dryRun: true,
+					files: activePrompts.map((p) => ({
+						name: p.name,
+						path: join(outDir ?? resolveEmitDir(p, config), p.emitAs ?? `${p.name}.md`),
+						version: p.version,
+					})),
+				});
+			} else {
+				if (outDir) {
+					humanOut(`Would emit ${activePrompts.length} prompts to ${outDir}/`);
+				} else {
+					humanOut(`Would emit ${activePrompts.length} prompts:`);
+				}
+				for (const p of activePrompts) {
+					const dir = outDir ?? resolveEmitDir(p, config);
+					humanOut(`  ${p.name} → ${join(dir, p.emitAs ?? `${p.name}.md`)}`);
+				}
+			}
+			return;
+		}
+
+		if (checkMode) {
+			const stale: string[] = [];
+			for (const p of activePrompts) {
+				const filename = p.emitAs ?? `${p.name}.md`;
+				const promptOutDir = outDir ?? resolveEmitDir(p, config);
+				const outPath = join(promptOutDir, filename);
+				const result = resolvePrompt(p.name, allRecords, p.pinned);
+				const expected = renderPrompt(
+					filename,
+					result.sections,
+					result.frontmatter,
+					p.name,
+					p.description,
+				);
+
+				let actual = "";
+				try {
+					actual = await Bun.file(outPath).text();
+				} catch {
+					stale.push(p.name);
+					continue;
+				}
+
+				if (actual !== expected) {
+					stale.push(p.name);
+				}
+			}
+
+			if (json) {
+				jsonOut({
+					success: stale.length === 0,
+					command: "emit",
+					check: true,
+					stale,
+					upToDate: stale.length === 0,
+				});
+			} else {
+				if (stale.length === 0) {
+					humanOut(fmt.success("All emitted files are up to date"));
+				} else {
+					humanOut(fmt.error(`${stale.length} stale file(s)`));
+					for (const name of stale) {
+						humanOut(`  - ${name}`);
+					}
+				}
+			}
+
+			if (stale.length > 0) throw new ExitError(1);
+			return;
+		}
+
+		const results = [];
+		for (const p of activePrompts) {
+			const r = await emitPrompt(p, outDir ?? resolveEmitDir(p, config), allRecords, force);
+			results.push(r);
+		}
+
+		if (json) {
+			jsonOut({ success: true, command: "emit", files: results });
+		} else {
+			for (const r of results) {
+				const status = r.skipped ? c.dim("(unchanged)") : c.green("✓");
+				humanOut(`${status} ${r.name} → ${r.path}`);
+			}
+		}
+		return;
+	}
+
+	// Single prompt emit
+	const nameArg = args.filter((a) => !a.startsWith("--"))[0];
+	if (!nameArg) {
+		if (json) {
+			jsonOut({ success: false, command: "emit", error: "Prompt name or --all required" });
+		} else {
+			errorOut("Usage: tl emit <name> [--out <path>] or tl emit --all");
+		}
+		throw new ExitError(1);
+	}
+
+	const prompt = current.find((p) => p.name === nameArg);
+	if (!prompt) {
+		if (json) {
+			jsonOut({ success: false, command: "emit", error: `Prompt '${nameArg}' not found` });
+		} else {
+			errorOut(`Prompt '${nameArg}' not found`);
+		}
+		throw new ExitError(1);
+	}
+
+	// Custom --out path
+	let outPath: string | undefined;
+	const outIdx = args.indexOf("--out");
+	if (outIdx !== -1 && args[outIdx + 1]) {
+		outPath = args[outIdx + 1];
+	}
+
+	const filename = prompt.emitAs ?? `${prompt.name}.md`;
+	const singleOutDir = outDir ?? resolveEmitDir(prompt, config);
+	const resolvedPath = outPath ?? join(singleOutDir, filename);
+
+	if (!force && existsSync(resolvedPath)) {
+		const result = resolvePrompt(prompt.name, allRecords, prompt.pinned);
+		const content = renderPrompt(
+			filename,
+			result.sections,
+			result.frontmatter,
+			prompt.name,
+			prompt.description,
+		);
+		const existing = await Bun.file(resolvedPath).text();
+		if (existing === content) {
+			if (json) {
+				jsonOut({
+					success: true,
+					command: "emit",
+					files: [
+						{ name: prompt.name, path: resolvedPath, version: result.version, skipped: true },
+					],
+				});
+			} else {
+				humanOut(c.dim(`(unchanged) ${prompt.name} → ${resolvedPath}`));
+			}
+			return;
+		}
+	}
+
+	const result = resolvePrompt(prompt.name, allRecords, prompt.pinned);
+	mkdirSync(dirname(resolvedPath), { recursive: true });
+	await Bun.write(
+		resolvedPath,
+		renderPrompt(filename, result.sections, result.frontmatter, prompt.name, prompt.description),
+	);
+
+	if (json) {
+		jsonOut({
+			success: true,
+			command: "emit",
+			files: [{ name: prompt.name, path: resolvedPath, version: result.version }],
+		});
+	} else {
+		humanOut(fmt.success(`${prompt.name} → ${resolvedPath}`));
+	}
+}
+
+export function registerEmitCommand(program: Command): void {
+	program
+		.command("emit [name]")
+		.description("Render and write prompt to a file")
+		.option("--all", "Emit all active prompts")
+		.option("--check", "Check if emitted files are up to date")
+		.option("--out <path>", "Custom output path (single prompt)")
+		.option("--out-dir <path>", "Custom output directory (--all mode)")
+		.option("--force", "Overwrite even if unchanged")
+		.option("--dry-run", "Show what would be emitted")
+		.action(async (name: string | undefined, opts: Record<string, unknown>) => {
+			const json: boolean = program.opts().json ?? false;
+			const args: string[] = [];
+			if (name) args.push(name);
+			if (opts.all) args.push("--all");
+			if (opts.check) args.push("--check");
+			if (opts.out) args.push("--out", opts.out as string);
+			if (opts.outDir) args.push("--out-dir", opts.outDir as string);
+			if (opts.force) args.push("--force");
+			if (opts.dryRun) args.push("--dry-run");
+			await emit(args, json);
+		});
+}

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

@@ -0,0 +1,83 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { c, errorOut, humanOut, icons, 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 history(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 history <name> [options]
+
+Options:
+  --limit <n>    Max versions to show (default: 20)
+  --json         Output as JSON`);
+		return;
+	}
+
+	const name = args.filter((a) => !a.startsWith("--"))[0];
+	if (!name) {
+		if (json) {
+			jsonOut({ success: false, command: "history", error: "Prompt name required" });
+		} else {
+			errorOut("Usage: tl history <name> [--limit <n>]");
+		}
+		throw new ExitError(1);
+	}
+
+	let limit = 20;
+	const limitIdx = args.indexOf("--limit");
+	if (limitIdx !== -1 && args[limitIdx + 1]) {
+		limit = Number.parseInt(args[limitIdx + 1] ?? "20", 10);
+	}
+
+	const allRecords = await readJsonl<Prompt>(promptsPath);
+
+	// Find the ID for this prompt name
+	const current = dedupById(allRecords);
+	const prompt = current.find((p) => p.name === name);
+	if (!prompt) {
+		if (json) {
+			jsonOut({ success: false, command: "history", error: `Prompt '${name}' not found` });
+		} else {
+			errorOut(`Prompt '${name}' not found`);
+		}
+		throw new ExitError(1);
+	}
+
+	const versions = getVersions(allRecords, prompt.id).reverse().slice(0, limit);
+
+	if (json) {
+		jsonOut({ success: true, command: "history", name, versions });
+		return;
+	}
+
+	humanOut(`${c.bold(name)} — version history (${versions.length} versions)`);
+	humanOut("");
+
+	for (const v of versions) {
+		const isCurrent = v.version === prompt.version;
+		const marker = isCurrent ? ` ${icons.active} current` : "";
+		const pinned = v.pinned !== undefined ? c.yellow(` (pinned @${v.pinned})`) : "";
+		humanOut(`  ${c.bold(`v${v.version}`)}${marker}${pinned}  ${c.dim(v.updatedAt)}`);
+		humanOut(`    sections: ${v.sections.map((s) => s.name).join(", ") || c.dim("(none)")}`);
+	}
+}
+
+export function registerHistoryCommand(program: Command): void {
+	program
+		.command("history")
+		.description("Show version timeline for a prompt")
+		.argument("<name>", "Prompt name")
+		.option("--limit <n>", "Max versions to show (default: 20)")
+		.action(async (name: string, options: { limit?: string }) => {
+			const json: boolean = program.opts().json ?? false;
+			const args = [name];
+			if (options.limit) args.push("--limit", options.limit);
+			if (json) args.push("--json");
+			await history(args, json);
+		});
+}

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

@@ -0,0 +1,198 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { loadConfig } from "../config.ts";
+import { extractFrontmatter } from "../frontmatter.ts";
+import { generateId } from "../id.ts";
+import { c, errorOut, fmt, humanOut, jsonOut } from "../output.ts";
+import { acquireLock, appendJsonl, dedupById, readJsonl, releaseLock } from "../store.ts";
+import type { Prompt, Section } from "../types.ts";
+import { ExitError } from "../types.ts";
+
+function splitMarkdown(content: string): Section[] {
+	const sections: Section[] = [];
+	const lines = content.split("\n");
+	let currentName = "intro";
+	let currentLines: string[] = [];
+
+	function flush() {
+		const body = currentLines.join("\n").trim();
+		if (body || currentName !== "intro") {
+			sections.push({ name: currentName, body });
+		}
+		currentLines = [];
+	}
+
+	for (const line of lines) {
+		// Match ## headings
+		const headingMatch = line.match(/^##\s+(.+)$/);
+		if (headingMatch) {
+			flush();
+			const heading = headingMatch[1] ?? "";
+			currentName = heading;
+		} else {
+			currentLines.push(line);
+		}
+	}
+
+	flush();
+
+	return sections.filter((s) => s.body !== "");
+}
+
+export default async function importCmd(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 import <path> --name <name> [options]
+
+Options:
+  --name <name>    Prompt name (required)
+  --no-split       Import as single body section (default: split on ## headings)
+  --tag <tag>      Add tag (repeatable)
+  --json           Output as JSON`);
+		return;
+	}
+
+	const pathArg = args.filter((a) => !a.startsWith("--"))[0];
+	if (!pathArg) {
+		if (json) {
+			jsonOut({ success: false, command: "import", error: "File path required" });
+		} else {
+			errorOut("Usage: tl import <path> --name <name> [--no-split] [--tag <tag>]");
+		}
+		throw new ExitError(1);
+	}
+
+	let name = "";
+	let noSplit = false;
+	const tags: string[] = [];
+
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "--name" && args[i + 1]) {
+			name = args[++i] ?? "";
+		} else if (args[i] === "--no-split") {
+			noSplit = true;
+		} else if (args[i] === "--tag" && args[i + 1]) {
+			tags.push(args[++i] ?? "");
+		}
+	}
+
+	if (!name) {
+		if (json) {
+			jsonOut({ success: false, command: "import", error: "--name is required" });
+		} else {
+			errorOut("--name is required");
+		}
+		throw new ExitError(1);
+	}
+
+	// Read input file
+	let content: string;
+	try {
+		content = await Bun.file(pathArg).text();
+	} catch {
+		if (json) {
+			jsonOut({ success: false, command: "import", error: `Cannot read file: ${pathArg}` });
+		} else {
+			errorOut(`Cannot read file: ${pathArg}`);
+		}
+		throw new ExitError(1);
+	}
+
+	// Extract frontmatter before splitting
+	const { metadata, body } = extractFrontmatter(content);
+
+	const sections: Section[] = noSplit ? [{ name: "body", body: body.trim() }] : splitMarkdown(body);
+
+	const config = await loadConfig(cwd);
+
+	await acquireLock(promptsPath);
+	try {
+		const allRecords = await readJsonl<Prompt>(promptsPath);
+		const current = dedupById(allRecords);
+
+		// Check for name collision
+		if (current.find((p) => p.name === name && p.status !== "archived")) {
+			if (json) {
+				jsonOut({
+					success: false,
+					command: "import",
+					error: `Prompt name '${name}' already exists`,
+				});
+			} else {
+				errorOut(`Prompt name '${name}' already exists`);
+			}
+			throw new ExitError(1);
+		}
+
+		const id = generateId(
+			config.project,
+			current.map((p) => p.id),
+		);
+		const now = new Date().toISOString();
+
+		const prompt: Prompt = {
+			id,
+			name,
+			version: 1,
+			sections,
+			status: "active",
+			createdAt: now,
+			updatedAt: now,
+		};
+
+		if (tags.length > 0) prompt.tags = tags;
+
+		// Map frontmatter description to prompt description
+		if (metadata.description && typeof metadata.description === "string") {
+			prompt.description = metadata.description;
+		}
+
+		// Store remaining frontmatter (excluding name/description which are Prompt fields)
+		const { name: _name, description: _desc, ...restFrontmatter } = metadata;
+		if (Object.keys(restFrontmatter).length > 0) {
+			prompt.frontmatter = restFrontmatter;
+		}
+
+		await appendJsonl(promptsPath, prompt);
+
+		if (json) {
+			jsonOut({
+				success: true,
+				command: "import",
+				id,
+				name,
+				sections: sections.length,
+			});
+		} else {
+			humanOut(
+				`${fmt.success("Imported")} ${c.bold(name)} ${fmt.id(id)} with ${sections.length} section(s)`,
+			);
+		}
+	} finally {
+		releaseLock(promptsPath);
+	}
+}
+
+export function registerImportCommand(program: Command): void {
+	program
+		.command("import")
+		.description("Import an existing .md file as a prompt")
+		.argument("<path>", "Path to the markdown file")
+		.requiredOption("--name <name>", "Prompt name")
+		.option("--no-split", "Import as single body section (default: split on ## headings)")
+		.option(
+			"--tag <tag>",
+			"Add tag (repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.action(async (filePath: string, opts: Record<string, unknown>) => {
+			const json: boolean = program.opts().json ?? false;
+			const args: string[] = [filePath, "--name", opts.name as string];
+			if (!opts.split) args.push("--no-split");
+			for (const tag of opts.tag as string[]) args.push("--tag", tag);
+			await importCmd(args, json);
+		});
+}