@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,112 @@
+import type { Command } from "commander";
+import { c, errorOut, fmt, humanOut, jsonOut } from "../output.ts";
+import { ExitError } from "../types.ts";
+
+export default async function sync(args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+
+	if (args.includes("--help") || args.includes("-h")) {
+		humanOut(`Usage: tl sync [options]
+
+Options:
+  --status    Check sync status without committing
+  --json      Output as JSON`);
+		return;
+	}
+
+	const statusOnly = args.includes("--status");
+
+	// Check git status of .trellis/
+	const statusResult = Bun.spawnSync(["git", "status", "--porcelain", ".trellis/"], { cwd });
+
+	if (statusResult.exitCode !== 0) {
+		const stderr = statusResult.stderr.toString();
+		if (json) {
+			jsonOut({ success: false, command: "sync", error: stderr });
+		} else {
+			errorOut(`git error: ${stderr}`);
+		}
+		throw new ExitError(1);
+	}
+
+	const statusOutput = statusResult.stdout.toString().trim();
+	const changedFiles = statusOutput
+		? statusOutput.split("\n").map((line) => line.trim().split(" ").pop() ?? "")
+		: [];
+
+	if (statusOnly) {
+		if (json) {
+			jsonOut({
+				success: true,
+				command: "sync",
+				uncommitted: changedFiles.length > 0,
+				files: changedFiles,
+			});
+		} else {
+			if (changedFiles.length === 0) {
+				humanOut(fmt.success(".trellis/ is clean (no uncommitted changes)"));
+			} else {
+				humanOut(fmt.warning(`${changedFiles.length} uncommitted file(s)`));
+				for (const f of changedFiles) {
+					humanOut(`  ${f}`);
+				}
+			}
+		}
+		return;
+	}
+
+	if (changedFiles.length === 0) {
+		if (json) {
+			jsonOut({ success: true, command: "sync", committed: false, message: "Nothing to commit" });
+		} else {
+			humanOut(c.dim("Nothing to commit in .trellis/"));
+		}
+		return;
+	}
+
+	// Stage .trellis/ changes
+	const addResult = Bun.spawnSync(["git", "add", ".trellis/"], { cwd });
+	if (addResult.exitCode !== 0) {
+		const err = addResult.stderr.toString();
+		if (json) {
+			jsonOut({ success: false, command: "sync", error: err });
+		} else {
+			errorOut(`git add failed: ${err}`);
+		}
+		throw new ExitError(1);
+	}
+
+	// Commit
+	const msg = `trellis: sync ${new Date().toISOString().slice(0, 10)}`;
+	const commitResult = Bun.spawnSync(["git", "commit", "-m", msg], { cwd });
+
+	if (commitResult.exitCode !== 0) {
+		const err = commitResult.stderr.toString();
+		if (json) {
+			jsonOut({ success: false, command: "sync", error: err });
+		} else {
+			errorOut(`git commit failed: ${err}`);
+		}
+		throw new ExitError(1);
+	}
+
+	if (json) {
+		jsonOut({ success: true, command: "sync", committed: true, files: changedFiles, message: msg });
+	} else {
+		humanOut(fmt.success(`Committed ${changedFiles.length} file(s): ${msg}`));
+	}
+}
+
+export function registerSyncCommand(program: Command): void {
+	program
+		.command("sync")
+		.description("Stage and commit .trellis/ changes")
+		.option("--status", "Check sync status without committing")
+		.action(async (options: { status?: boolean }) => {
+			const json: boolean = program.opts().json ?? false;
+			const args: string[] = [];
+			if (options.status) args.push("--status");
+			if (json) args.push("--json");
+			await sync(args, json);
+		});
+}

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

@@ -0,0 +1,123 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { c, errorOut, humanOut, jsonOut } from "../output.ts";
+import { dedupById, readJsonl } from "../store.ts";
+import type { Prompt } from "../types.ts";
+import { ExitError } from "../types.ts";
+
+export default async function tree(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 tree <name> [options]
+
+Options:
+  --json    Output as JSON`);
+		return;
+	}
+
+	const name = args.filter((a) => !a.startsWith("--"))[0];
+	if (!name) {
+		if (json) {
+			jsonOut({ success: false, command: "tree", error: "Prompt name required" });
+		} else {
+			errorOut("Usage: tl tree <name>");
+		}
+		throw new ExitError(1);
+	}
+
+	const allRecords = await readJsonl<Prompt>(promptsPath);
+	const current = dedupById(allRecords);
+
+	const prompt = current.find((p) => p.name === name);
+	if (!prompt) {
+		if (json) {
+			jsonOut({ success: false, command: "tree", error: `Prompt '${name}' not found` });
+		} else {
+			errorOut(`Prompt '${name}' not found`);
+		}
+		throw new ExitError(1);
+	}
+
+	// Build ancestry chain (parents via extends)
+	const ancestors: string[] = [];
+	let cur: Prompt | undefined = prompt;
+	while (cur?.extends) {
+		const parentName: string = cur.extends;
+		if (ancestors.includes(parentName)) break; // cycle guard
+		ancestors.push(parentName);
+		cur = current.find((p) => p.name === parentName);
+	}
+	ancestors.reverse();
+
+	// Collect mixins for the focal prompt
+	const mixins: string[] = prompt.mixins ?? [];
+
+	// Find all descendants (via extends or mixins)
+	function getChildren(pname: string): string[] {
+		return current.filter((p) => p.extends === pname && p.name !== pname).map((p) => p.name);
+	}
+
+	function getMixinUsers(pname: string): string[] {
+		return current.filter((p) => p.mixins?.includes(pname) && p.name !== pname).map((p) => p.name);
+	}
+
+	if (json) {
+		const buildTree = (pname: string): object => ({
+			name: pname,
+			children: getChildren(pname).map(buildTree),
+			mixinUsers: getMixinUsers(pname),
+		});
+
+		jsonOut({
+			success: true,
+			command: "tree",
+			name,
+			ancestors,
+			mixins,
+			tree: buildTree(name),
+		});
+		return;
+	}
+
+	// Render ancestors
+	for (let i = 0; i < ancestors.length; i++) {
+		const indent = "  ".repeat(i);
+		humanOut(`${indent}${c.dim(ancestors[i] ?? "")}`);
+	}
+
+	// Render focal node
+	const focalIndent = "  ".repeat(ancestors.length);
+	const mixinLabel = mixins.length > 0 ? c.dim(` + ${mixins.join(", ")}`) : "";
+	humanOut(`${focalIndent}${c.bold(c.cyan(name))} ${c.dim(`(v${prompt.version})`)}${mixinLabel}`);
+
+	// Render children recursively
+	function renderChildren(pname: string, depth: number) {
+		const children = getChildren(pname);
+		for (const child of children) {
+			const indent = "  ".repeat(depth);
+			const childPrompt = current.find((p) => p.name === child);
+			const ver = childPrompt ? c.dim(` v${childPrompt.version}`) : "";
+			const childMixins = childPrompt?.mixins?.length
+				? c.dim(` + ${childPrompt.mixins.join(", ")}`)
+				: "";
+			humanOut(`${indent}├── ${child}${ver}${childMixins}`);
+			renderChildren(child, depth + 1);
+		}
+	}
+
+	renderChildren(name, ancestors.length + 1);
+}
+
+export function registerTreeCommand(program: Command): void {
+	program
+		.command("tree")
+		.description("Show inheritance tree for a prompt")
+		.argument("<name>", "Prompt name")
+		.action(async (name: string) => {
+			const json: boolean = program.opts().json ?? false;
+			const args = [name, ...(json ? ["--json"] : [])];
+			await tree(args, json);
+		});
+}

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

@@ -0,0 +1,330 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { c, errorOut, fmt, humanOut, jsonOut } from "../output.ts";
+import { acquireLock, appendJsonl, dedupById, readJsonl, releaseLock } from "../store.ts";
+import type { Prompt } from "../types.ts";
+import { ExitError } from "../types.ts";
+
+export default async function update(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 update <name> [options]
+
+Options:
+  --name <name>              Rename prompt
+  --description <text>       Update description
+  --section <name> --body <text>  Update section body
+  --section <name>=<text>         Update section (shorthand)
+  --add-section <name> --body <text>  Add new section with body (repeatable)
+  --add-section <name>=<text>        Add new section (shorthand, repeatable)
+  --remove-section <name>    Remove section (empty body, repeatable)
+  --tag <tag>                Add tag (repeatable)
+  --untag <tag>              Remove tag (repeatable)
+  --schema <name>            Assign schema
+  --extends <name>           Change parent
+  --mixin <name>             Add mixin (repeatable)
+  --remove-mixin <name>      Remove mixin (repeatable)
+  --emit-as <filename>       Custom emit filename
+  --emit-dir <path>          Custom emit directory
+  --fm <key=value>           Set frontmatter field (repeatable)
+  --remove-fm <key>          Remove frontmatter field (repeatable)
+  --status draft|active|archived  Change status
+  --json                     Output as JSON`);
+		return;
+	}
+
+	const nameArg = args.filter((a) => !a.startsWith("--"))[0];
+	if (!nameArg) {
+		if (json) {
+			jsonOut({ success: false, command: "update", error: "Prompt name required" });
+		} else {
+			errorOut("Usage: tl update <name> [options]");
+		}
+		throw new ExitError(1);
+	}
+
+	// Parse flags
+	let sectionName: string | undefined;
+	let sectionBody: string | undefined;
+	const addSections: Array<{ name: string; body: string }> = [];
+	const removeSections: string[] = [];
+	const addTags: string[] = [];
+	const removeTags: string[] = [];
+	let newDescription: string | undefined;
+	let newSchema: string | undefined;
+	let newExtends: string | undefined;
+	const addMixins: string[] = [];
+	const removeMixins: string[] = [];
+	let newEmitAs: string | undefined;
+	let newEmitDir: string | undefined;
+	let newStatus: string | undefined;
+	let newName: string | undefined;
+	const fmUpdates: Record<string, string> = {};
+	const fmRemovals: string[] = [];
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--section" && args[i + 1]) {
+			const next = args[++i] ?? "";
+			const eqIdx = next.indexOf("=");
+			if (eqIdx !== -1) {
+				// --section name=body shorthand
+				sectionName = next.slice(0, eqIdx);
+				sectionBody = next.slice(eqIdx + 1);
+			} else {
+				sectionName = next;
+			}
+		} else if (arg === "--body" && args[i + 1] !== undefined) {
+			// body may be empty string
+			sectionBody = args[++i];
+		} else if (arg === "--add-section" && args[i + 1]) {
+			const next = args[++i] ?? "";
+			const eqIdx = next.indexOf("=");
+			if (eqIdx !== -1) {
+				// --add-section name=body shorthand
+				addSections.push({ name: next.slice(0, eqIdx), body: next.slice(eqIdx + 1) });
+			} else {
+				let body = "";
+				// lookahead for --body
+				if (args[i + 1] === "--body" && args[i + 2] !== undefined) {
+					i++; // skip --body
+					body = args[++i] ?? "";
+				}
+				addSections.push({ name: next, body });
+			}
+		} else if (arg === "--remove-section" && args[i + 1]) {
+			removeSections.push(args[++i] ?? "");
+		} else if (arg === "--tag" && args[i + 1]) {
+			addTags.push(args[++i] ?? "");
+		} else if (arg === "--untag" && args[i + 1]) {
+			removeTags.push(args[++i] ?? "");
+		} else if (arg === "--description" && args[i + 1]) {
+			newDescription = args[++i];
+		} else if (arg === "--schema" && args[i + 1]) {
+			newSchema = args[++i];
+		} else if (arg === "--extends" && args[i + 1]) {
+			newExtends = args[++i];
+		} else if (arg === "--mixin" && args[i + 1]) {
+			addMixins.push(args[++i] ?? "");
+		} else if (arg === "--remove-mixin" && args[i + 1]) {
+			removeMixins.push(args[++i] ?? "");
+		} else if (arg === "--emit-as" && args[i + 1]) {
+			newEmitAs = args[++i];
+		} else if (arg === "--emit-dir" && args[i + 1]) {
+			newEmitDir = args[++i];
+		} else if (arg === "--status" && args[i + 1]) {
+			newStatus = args[++i];
+		} else if (arg === "--name" && args[i + 1]) {
+			newName = args[++i];
+		} else if (arg === "--fm" && args[i + 1]) {
+			const fmArg = args[++i] ?? "";
+			const eqIdx = fmArg.indexOf("=");
+			if (eqIdx !== -1) {
+				fmUpdates[fmArg.slice(0, eqIdx)] = fmArg.slice(eqIdx + 1);
+			}
+		} else if (arg === "--remove-fm" && args[i + 1]) {
+			fmRemovals.push(args[++i] ?? "");
+		}
+	}
+
+	await acquireLock(promptsPath);
+	try {
+		const allRecords = await readJsonl<Prompt>(promptsPath);
+		const current = dedupById(allRecords);
+
+		const prompt = current.find((p) => p.name === nameArg);
+		if (!prompt) {
+			if (json) {
+				jsonOut({ success: false, command: "update", error: `Prompt '${nameArg}' not found` });
+			} else {
+				errorOut(`Prompt '${nameArg}' not found`);
+			}
+			throw new ExitError(1);
+		}
+
+		// Clone and apply mutations
+		const updated: Prompt = {
+			...prompt,
+			sections: [...prompt.sections.map((s) => ({ ...s }))],
+			version: prompt.version + 1,
+			updatedAt: new Date().toISOString(),
+		};
+
+		// Update section body
+		if (sectionName !== undefined && sectionBody !== undefined) {
+			const idx = updated.sections.findIndex((s) => s.name === sectionName);
+			if (idx !== -1) {
+				const existing = updated.sections[idx];
+				if (existing) updated.sections[idx] = { ...existing, body: sectionBody };
+			} else {
+				updated.sections.push({ name: sectionName, body: sectionBody });
+			}
+		}
+
+		// Add new sections
+		for (const { name: addName, body: addBody } of addSections) {
+			const existingIdx = updated.sections.findIndex((s) => s.name === addName);
+			if (existingIdx !== -1) {
+				const existingSec = updated.sections[existingIdx];
+				if (existingSec) updated.sections[existingIdx] = { ...existingSec, body: addBody };
+			} else {
+				updated.sections.push({ name: addName, body: addBody });
+			}
+		}
+
+		// Remove sections
+		for (const removeName of removeSections) {
+			const idx = updated.sections.findIndex((s) => s.name === removeName);
+			if (updated.extends) {
+				// Inheriting prompt: use empty body to suppress inherited section in render
+				if (idx !== -1) {
+					const existing = updated.sections[idx];
+					if (existing) updated.sections[idx] = { ...existing, body: "" };
+				} else {
+					updated.sections.push({ name: removeName, body: "" });
+				}
+			} else {
+				// Non-inheriting prompt: splice section out entirely
+				if (idx !== -1) {
+					updated.sections.splice(idx, 1);
+				}
+			}
+		}
+
+		// Tags
+		const currentTags = new Set(updated.tags ?? []);
+		for (const t of addTags) currentTags.add(t);
+		for (const t of removeTags) currentTags.delete(t);
+		updated.tags = currentTags.size > 0 ? Array.from(currentTags) : undefined;
+
+		// Frontmatter updates
+		const currentFm = { ...(updated.frontmatter ?? {}) };
+		for (const [k, v] of Object.entries(fmUpdates)) currentFm[k] = v;
+		for (const k of fmRemovals) delete currentFm[k];
+		updated.frontmatter = Object.keys(currentFm).length > 0 ? currentFm : undefined;
+
+		// Mixins
+		if (addMixins.length > 0 || removeMixins.length > 0) {
+			const currentMixins = new Set(updated.mixins ?? []);
+			for (const m of addMixins) currentMixins.add(m);
+			for (const m of removeMixins) currentMixins.delete(m);
+			updated.mixins = currentMixins.size > 0 ? Array.from(currentMixins) : undefined;
+		}
+
+		if (newDescription !== undefined) updated.description = newDescription;
+		if (newSchema !== undefined) updated.schema = newSchema;
+		if (newExtends !== undefined) updated.extends = newExtends;
+		if (newEmitAs !== undefined) updated.emitAs = newEmitAs;
+		if (newEmitDir !== undefined) updated.emitDir = newEmitDir;
+		if (newStatus === "draft" || newStatus === "active" || newStatus === "archived") {
+			updated.status = newStatus;
+		}
+		if (newName !== undefined) updated.name = newName;
+
+		await appendJsonl(promptsPath, updated);
+
+		if (json) {
+			jsonOut({
+				success: true,
+				command: "update",
+				id: updated.id,
+				name: updated.name,
+				version: updated.version,
+			});
+		} else {
+			humanOut(`${fmt.success("Updated")} ${c.bold(updated.name)} → v${updated.version}`);
+		}
+	} finally {
+		releaseLock(promptsPath);
+	}
+}
+
+export function registerUpdateCommand(program: Command): void {
+	program
+		.command("update")
+		.description("Update a prompt (creates new version)")
+		.argument("<name>", "Prompt name")
+		.option("--name <name>", "Rename prompt")
+		.option("--description <text>", "Update description")
+		.option("--section <name>", "Section to update (use with --body or name=body shorthand)")
+		.option("--body <text>", "New body for the section specified by --section")
+		.option(
+			"--add-section <name>",
+			"Add a new section (use name=body shorthand, repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.option(
+			"--remove-section <name>",
+			"Remove a section (sets body to empty, repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.option(
+			"--tag <tag>",
+			"Add tag (repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.option(
+			"--untag <tag>",
+			"Remove tag (repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.option("--schema <name>", "Assign schema")
+		.option("--extends <name>", "Change parent prompt")
+		.option(
+			"--mixin <name>",
+			"Add mixin (repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.option(
+			"--remove-mixin <name>",
+			"Remove mixin (repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.option("--emit-as <filename>", "Custom emit filename")
+		.option("--emit-dir <path>", "Custom emit directory")
+		.option("--status <status>", "Change status (draft|active|archived)")
+		.option(
+			"--fm <key=value>",
+			"Set frontmatter field (repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.option(
+			"--remove-fm <key>",
+			"Remove frontmatter field (repeatable)",
+			(v: string, a: string[]) => a.concat([v]),
+			[] as string[],
+		)
+		.action(async (nameArg: string, opts: Record<string, unknown>) => {
+			const json: boolean = program.opts().json ?? false;
+			const args: string[] = [nameArg];
+			if (opts.name) args.push("--name", opts.name as string);
+			if (opts.description) args.push("--description", opts.description as string);
+			if (opts.section) {
+				args.push("--section", opts.section as string);
+				if (opts.body !== undefined) args.push("--body", opts.body as string);
+			}
+			for (const sec of opts.addSection as string[]) args.push("--add-section", sec);
+			for (const sec of opts.removeSection as string[]) args.push("--remove-section", sec);
+			for (const tag of opts.tag as string[]) args.push("--tag", tag);
+			for (const tag of opts.untag as string[]) args.push("--untag", tag);
+			if (opts.schema) args.push("--schema", opts.schema as string);
+			if (opts.extends) args.push("--extends", opts.extends as string);
+			for (const mixin of opts.mixin as string[]) args.push("--mixin", mixin);
+			for (const mixin of opts.removeMixin as string[]) args.push("--remove-mixin", mixin);
+			if (opts.emitAs) args.push("--emit-as", opts.emitAs as string);
+			if (opts.emitDir) args.push("--emit-dir", opts.emitDir as string);
+			if (opts.status) args.push("--status", opts.status as string);
+			for (const fm of opts.fm as string[]) args.push("--fm", fm);
+			for (const key of opts.removeFm as string[]) args.push("--remove-fm", key);
+			await update(args, json);
+		});
+}

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

@@ -0,0 +1,95 @@
+import chalk from "chalk";
+import type { Command } from "commander";
+import { VERSION } from "../../../version.ts";
+import { humanOut, jsonOut } from "../output.ts";
+
+// trellis is bundled in @ag-eco/agentplate-cli; upgrading is `ap upgrade`.
+const PACKAGE_NAME = "@ag-eco/agentplate-cli";
+
+async function getCurrentVersion(): Promise<string> {
+	return VERSION;
+}
+
+async function fetchLatestVersion(): Promise<string> {
+	const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`);
+	if (!res.ok) throw new Error(`Failed to fetch npm registry: ${res.status} ${res.statusText}`);
+	const data = (await res.json()) as { version: string };
+	return data.version;
+}
+
+export async function run(args: string[]): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const checkOnly = args.includes("--check");
+
+	const [current, latest] = await Promise.all([getCurrentVersion(), fetchLatestVersion()]);
+	const upToDate = current === latest;
+
+	if (checkOnly) {
+		if (jsonMode) {
+			jsonOut({ success: true, command: "upgrade", current, latest, upToDate });
+		} else {
+			if (upToDate) {
+				humanOut(`${chalk.green("✔")} Already up to date (${current})`);
+			} else {
+				humanOut(`${chalk.yellow("!")} Update available: ${current} → ${latest}`);
+				process.exitCode = 1;
+			}
+		}
+		return;
+	}
+
+	if (upToDate) {
+		if (jsonMode) {
+			jsonOut({
+				success: true,
+				command: "upgrade",
+				current,
+				latest,
+				upToDate: true,
+				updated: false,
+			});
+		} else {
+			humanOut(`${chalk.green("✔")} Already up to date (${current})`);
+		}
+		return;
+	}
+
+	if (!jsonMode) {
+		humanOut(`Upgrading ${PACKAGE_NAME} from ${current} to ${latest}...`);
+	}
+
+	const result = Bun.spawnSync(["bun", "install", "-g", `${PACKAGE_NAME}@latest`], {
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+
+	if (result.exitCode !== 0) {
+		throw new Error(`bun install failed with exit code ${result.exitCode}`);
+	}
+
+	if (jsonMode) {
+		jsonOut({
+			success: true,
+			command: "upgrade",
+			current,
+			latest,
+			upToDate: false,
+			updated: true,
+		});
+	} else {
+		humanOut(`${chalk.green("✔")} Upgraded to ${latest}`);
+	}
+}
+
+export function registerUpgradeCommand(program: Command): void {
+	program
+		.command("upgrade")
+		.description("Upgrade trellis to the latest version from npm")
+		.option("--check", "Check for updates without installing")
+		.action(async (opts: { check?: boolean }) => {
+			const args: string[] = [];
+			if (opts.check) args.push("--check");
+			if (program.opts().json) args.push("--json");
+			await run(args);
+		});
+}