@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,81 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import type { Command } from "commander";
+import { saveConfig } from "../config.ts";
+import { errorOut, humanOut, jsonOut } from "../output.ts";
+import { ExitError } from "../types.ts";
+
+export default async function init(_args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+	const trellisDir = join(cwd, ".trellis");
+
+	if (_args.includes("--help") || _args.includes("-h")) {
+		humanOut(`Usage: tl init
+
+Initializes .trellis/ in the current directory with config and empty JSONL stores.`);
+		return;
+	}
+
+	if (existsSync(trellisDir)) {
+		if (json) {
+			jsonOut({ success: false, command: "init", error: ".trellis/ already exists" });
+		} else {
+			errorOut(".trellis/ already exists");
+		}
+		throw new ExitError(1);
+	}
+
+	mkdirSync(trellisDir, { recursive: true });
+
+	// Write default config
+	await saveConfig(cwd, {
+		project: "trellis",
+		version: "1",
+		targets: {
+			default: { dir: "agents", default: true },
+		},
+	});
+
+	// Write .gitignore for .trellis/
+	await Bun.write(join(trellisDir, ".gitignore"), "*.lock\n");
+
+	// Create empty JSONL files
+	await Bun.write(join(trellisDir, "prompts.jsonl"), "");
+	await Bun.write(join(trellisDir, "schemas.jsonl"), "");
+
+	// Append .gitattributes to project root
+	const gitattrsPath = join(cwd, ".gitattributes");
+	const gitattrsEntry = ".trellis/prompts.jsonl merge=union\n.trellis/schemas.jsonl merge=union\n";
+
+	let existing = "";
+	try {
+		existing = await Bun.file(gitattrsPath).text();
+	} catch {
+		existing = "";
+	}
+
+	if (!existing.includes(".trellis/prompts.jsonl")) {
+		await Bun.write(gitattrsPath, existing + gitattrsEntry);
+	}
+
+	if (json) {
+		jsonOut({ success: true, command: "init", dir: trellisDir });
+	} else {
+		humanOut(`Initialized .trellis/ in ${cwd}`);
+		humanOut("  config.yaml: project=trellis, targets: default → agents/");
+		humanOut("  prompts.jsonl created");
+		humanOut("  schemas.jsonl created");
+		humanOut("  .gitattributes updated with merge=union");
+	}
+}
+
+export function registerInitCommand(program: Command): void {
+	program
+		.command("init")
+		.description("Initialize .trellis/ in current directory")
+		.action(async () => {
+			const json: boolean = program.opts().json ?? false;
+			const args = json ? ["--json"] : [];
+			await init(args, json);
+		});
+}

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

@@ -0,0 +1,103 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { c, humanOut, jsonOut } from "../output.ts";
+import { dedupById, readJsonl } from "../store.ts";
+import type { Prompt } from "../types.ts";
+
+export default async function list(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 list [options]
+
+Options:
+  --tag <tag>     Filter by tag
+  --status <s>    Filter by status (draft|active|archived)
+  --mixin <name>  Filter by mixin
+  --json          Output as JSON`);
+		return;
+	}
+
+	// Parse filters
+	let filterTag: string | undefined;
+	let filterStatus: string | undefined;
+	let filterExtends: string | undefined;
+	let filterMixin: string | undefined;
+
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "--tag" && args[i + 1]) {
+			filterTag = args[++i];
+		} else if (args[i] === "--status" && args[i + 1]) {
+			filterStatus = args[++i];
+		} else if (args[i] === "--extends" && args[i + 1]) {
+			filterExtends = args[++i];
+		} else if (args[i] === "--mixin" && args[i + 1]) {
+			filterMixin = args[++i];
+		}
+	}
+
+	const allRecords = await readJsonl<Prompt>(promptsPath);
+	let prompts = dedupById(allRecords);
+
+	// Default: exclude archived unless explicitly requested
+	if (!filterStatus) {
+		prompts = prompts.filter((p) => p.status !== "archived");
+	} else {
+		prompts = prompts.filter((p) => p.status === filterStatus);
+	}
+
+	if (filterTag) {
+		prompts = prompts.filter((p) => p.tags?.includes(filterTag as string));
+	}
+
+	if (filterExtends) {
+		prompts = prompts.filter((p) => p.extends === filterExtends);
+	}
+
+	if (filterMixin) {
+		prompts = prompts.filter((p) => p.mixins?.includes(filterMixin as string));
+	}
+
+	if (json) {
+		jsonOut({ success: true, command: "list", prompts, count: prompts.length });
+	} else {
+		if (prompts.length === 0) {
+			humanOut("No prompts found.");
+			return;
+		}
+
+		for (const p of prompts) {
+			const tags = p.tags?.length ? c.dim(` [${p.tags.join(", ")}]`) : "";
+			const ext = p.extends ? c.dim(` → ${p.extends}`) : "";
+			const mix = p.mixins?.length ? c.dim(` + ${p.mixins.join(", ")}`) : "";
+			const pin = p.pinned !== undefined ? c.yellow(` (pinned @${p.pinned})`) : "";
+			humanOut(
+				`${c.bold(p.name)}${ext}${mix}${tags}${pin}  ${c.dim(`v${p.version} · ${p.status} · ${p.id}`)}`,
+			);
+		}
+		humanOut(c.dim(`\n${prompts.length} prompt${prompts.length === 1 ? "" : "s"}`));
+	}
+}
+
+export function registerListCommand(program: Command): void {
+	program
+		.command("list")
+		.description("List prompts")
+		.option("--tag <tag>", "Filter by tag")
+		.option("--status <status>", "Filter by status (draft|active|archived)")
+		.option("--extends <name>", "Filter by parent prompt")
+		.option("--mixin <name>", "Filter by mixin")
+		.action(
+			async (options: { tag?: string; status?: string; extends?: string; mixin?: string }) => {
+				const json: boolean = program.opts().json ?? false;
+				const args: string[] = [];
+				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);
+				if (json) args.push("--json");
+				await list(args, json);
+			},
+		);
+}

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

@@ -0,0 +1,156 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { Command } from "commander";
+import { detectStatus, replaceMarkerSection, VERSION_MARKER, wrapInMarkers } from "../markers.ts";
+import { humanOut, isQuiet, jsonOut } from "../output.ts";
+
+const CANDIDATE_FILES = ["CLAUDE.md", ".claude/CLAUDE.md", "AGENTS.md"] as const;
+
+function onboardSnippet(): string {
+	return `## Prompt Management (Trellis)
+${VERSION_MARKER}
+
+This project uses [Trellis](https://github.com/jayminwest/trellis) for git-native prompt management.
+
+**At the start of every session**, run:
+\`\`\`
+tl prime
+\`\`\`
+
+This injects prompt workflow context: commands, conventions, and common workflows.
+
+**Quick reference:**
+- \`tl list\` — List all prompts
+- \`tl render <name>\` — View rendered prompt (resolves inheritance)
+- \`tl emit --all\` — Render prompts to files
+- \`tl update <name>\` — Update a prompt (creates new version)
+- \`tl sync\` — Stage and commit .trellis/ changes
+
+**Do not manually edit emitted files.** Use \`tl update\` to modify prompts, then \`tl emit\` to regenerate.
+
+**Loam metadata:** Prompts can declare expertise dependencies via \`loam.prime.domains\`, \`loam.prime.files\`, \`loam.budget\`, \`loam.on_empty\`, plus a top-level \`extends_loam\` flag (override-by-default; merge with parent when \`true\`). Trellis never shells out to \`ml\` — \`tl render --json\` surfaces the resolved declaration in a top-level \`loam\` field for consumers to act on. See SPEC.md "Loam Metadata".`;
+}
+
+function findTargetFile(projectRoot: string): string | null {
+	for (const candidate of CANDIDATE_FILES) {
+		const fullPath = join(projectRoot, candidate);
+		if (existsSync(fullPath)) {
+			return fullPath;
+		}
+	}
+	return null;
+}
+
+export default async function onboard(args: string[], json: boolean): Promise<void> {
+	if (args.includes("--help") || args.includes("-h")) {
+		humanOut(`Usage: tl onboard [options]
+
+Adds a trellis section to CLAUDE.md (or creates it) so AI agents discover prompt workflows.
+
+Options:
+  --check     Report status without writing (missing, current, outdated)
+  --stdout    Print snippet to stdout without writing to file
+  --json      Output as JSON`);
+		return;
+	}
+
+	const stdoutMode = args.includes("--stdout");
+	const checkMode = args.includes("--check");
+	const cwd = process.cwd();
+
+	const targetPath = findTargetFile(cwd);
+	const snippet = onboardSnippet();
+
+	// --check mode: report status only
+	if (checkMode) {
+		if (!targetPath) {
+			if (json) {
+				jsonOut({ success: true, command: "onboard", status: "missing", file: null });
+			} else {
+				humanOut("Status: missing (no CLAUDE.md found)");
+			}
+			return;
+		}
+		const content = await Bun.file(targetPath).text();
+		const status = detectStatus(content);
+		if (json) {
+			jsonOut({ success: true, command: "onboard", status, file: targetPath });
+		} else {
+			humanOut(`Status: ${status} (${targetPath})`);
+		}
+		return;
+	}
+
+	// --stdout mode: print what would be written
+	if (stdoutMode) {
+		if (!isQuiet()) {
+			process.stdout.write(wrapInMarkers(snippet));
+			process.stdout.write("\n");
+		}
+		return;
+	}
+
+	// Default mode: write to file
+	const filePath = targetPath ?? join(cwd, "CLAUDE.md");
+	const fileExists = existsSync(filePath);
+	const wrappedSnippet = wrapInMarkers(snippet);
+
+	if (!fileExists) {
+		await Bun.write(filePath, `${wrappedSnippet}\n`);
+		if (json) {
+			jsonOut({ success: true, command: "onboard", action: "created", file: filePath });
+		} else {
+			humanOut(`Created ${filePath} with trellis section`);
+		}
+		return;
+	}
+
+	const content = await Bun.file(filePath).text();
+	const status = detectStatus(content);
+
+	if (status === "current") {
+		if (json) {
+			jsonOut({ success: true, command: "onboard", action: "unchanged", file: filePath });
+		} else {
+			humanOut("Trellis section is already up to date");
+		}
+		return;
+	}
+
+	if (status === "outdated") {
+		const updated = replaceMarkerSection(content, snippet);
+		if (updated) {
+			await Bun.write(filePath, updated);
+			if (json) {
+				jsonOut({ success: true, command: "onboard", action: "updated", file: filePath });
+			} else {
+				humanOut(`Updated trellis section in ${filePath}`);
+			}
+		}
+		return;
+	}
+
+	// status === "missing": append
+	const separator = content.endsWith("\n") ? "\n" : "\n\n";
+	await Bun.write(filePath, `${content}${separator}${wrappedSnippet}\n`);
+	if (json) {
+		jsonOut({ success: true, command: "onboard", action: "appended", file: filePath });
+	} else {
+		humanOut(`Added trellis section to ${filePath}`);
+	}
+}
+
+export function registerOnboardCommand(program: Command): void {
+	program
+		.command("onboard")
+		.description("Add trellis section to CLAUDE.md for AI agent discovery")
+		.option("--check", "Report status without writing (missing, current, outdated)")
+		.option("--stdout", "Print snippet to stdout without writing to file")
+		.action(async (opts: Record<string, unknown>) => {
+			const json: boolean = program.opts().json ?? false;
+			const args: string[] = [];
+			if (opts.check) args.push("--check");
+			if (opts.stdout) args.push("--stdout");
+			await onboard(args, json);
+		});
+}

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

@@ -0,0 +1,172 @@
+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 pin(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 pin <name>@<version> [options]
+
+Options:
+  --json    Output as JSON`);
+		return;
+	}
+
+	const nameArg = args.filter((a) => !a.startsWith("--"))[0];
+	if (!nameArg) {
+		if (json) {
+			jsonOut({ success: false, command: "pin", error: "Usage: tl pin <name>@<version>" });
+		} else {
+			errorOut("Usage: tl pin <name>@<version>");
+		}
+		throw new ExitError(1);
+	}
+
+	// Parse name@version
+	const atIdx = nameArg.lastIndexOf("@");
+	if (atIdx === -1) {
+		if (json) {
+			jsonOut({ success: false, command: "pin", error: "Usage: tl pin <name>@<version>" });
+		} else {
+			errorOut("Usage: tl pin <name>@<version>");
+		}
+		throw new ExitError(1);
+	}
+
+	const name = nameArg.slice(0, atIdx);
+	const version = Number.parseInt(nameArg.slice(atIdx + 1), 10);
+
+	if (Number.isNaN(version)) {
+		errorOut("Version must be an integer");
+		throw new ExitError(1);
+	}
+
+	await acquireLock(promptsPath);
+	try {
+		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: "pin", error: `Prompt '${name}' not found` });
+			} else {
+				errorOut(`Prompt '${name}' not found`);
+			}
+			throw new ExitError(1);
+		}
+
+		// Verify the target version exists
+		const targetVersion = allRecords.find((p) => p.id === prompt.id && p.version === version);
+		if (!targetVersion) {
+			if (json) {
+				jsonOut({
+					success: false,
+					command: "pin",
+					error: `Version ${version} of '${name}' not found`,
+				});
+			} else {
+				errorOut(`Version ${version} of '${name}' not found`);
+			}
+			throw new ExitError(1);
+		}
+
+		const updated: Prompt = {
+			...prompt,
+			pinned: version,
+			version: prompt.version + 1,
+			updatedAt: new Date().toISOString(),
+		};
+
+		await appendJsonl(promptsPath, updated);
+
+		if (json) {
+			jsonOut({ success: true, command: "pin", name, pinned: version });
+		} else {
+			humanOut(`${fmt.success("Pinned")} ${c.bold(name)} to v${version}`);
+		}
+	} finally {
+		releaseLock(promptsPath);
+	}
+}
+
+export async function defaultUnpin(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 unpin <name> [options]
+
+Options:
+  --json    Output as JSON`);
+		return;
+	}
+
+	const name = args.filter((a) => !a.startsWith("--"))[0];
+	if (!name) {
+		if (json) {
+			jsonOut({ success: false, command: "unpin", error: "Prompt name required" });
+		} else {
+			errorOut("Usage: tl unpin <name>");
+		}
+		throw new ExitError(1);
+	}
+
+	await acquireLock(promptsPath);
+	try {
+		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: "unpin", error: `Prompt '${name}' not found` });
+			} else {
+				errorOut(`Prompt '${name}' not found`);
+			}
+			throw new ExitError(1);
+		}
+
+		const updated: Prompt = {
+			...prompt,
+			version: prompt.version + 1,
+			updatedAt: new Date().toISOString(),
+		};
+		updated.pinned = undefined;
+
+		await appendJsonl(promptsPath, updated);
+
+		if (json) {
+			jsonOut({ success: true, command: "unpin", name });
+		} else {
+			humanOut(`${fmt.success("Unpinned")} ${c.bold(name)}`);
+		}
+	} finally {
+		releaseLock(promptsPath);
+	}
+}
+
+export function registerPinCommand(program: Command): void {
+	program
+		.command("pin")
+		.description("Pin prompt to a specific version")
+		.argument("<name@version>", "Prompt name and version (e.g. my-prompt@2)")
+		.action(async (nameAtVersion: string) => {
+			const json: boolean = program.opts().json ?? false;
+			await pin([nameAtVersion], json);
+		});
+
+	program
+		.command("unpin")
+		.description("Remove version pin from a prompt")
+		.argument("<name>", "Prompt name")
+		.action(async (name: string) => {
+			const json: boolean = program.opts().json ?? false;
+			await defaultUnpin([name], json);
+		});
+}

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

@@ -0,0 +1,193 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { isQuiet, jsonOut } from "../output.ts";
+
+const PRIME_FILE = "PRIME.md";
+
+function defaultPrimeContent(compact: boolean): string {
+	if (compact) {
+		return compactContent();
+	}
+	return fullContent();
+}
+
+function compactContent(): string {
+	return `# Trellis Quick Reference
+
+\`\`\`
+tl list                   # List all prompts
+tl show <name>            # View prompt record
+tl render <name>          # Render prompt (resolve inheritance)
+tl emit <name>            # Render and write to file
+tl emit --all             # Emit all active prompts
+tl create --name "..."    # Create a new prompt
+tl update <name>          # Update prompt (new version)
+tl import <path>          # Import existing .md as prompt
+tl sync                   # Stage + commit .trellis/
+\`\`\`
+
+**Do not manually edit emitted files.** Use \`tl update\` to modify prompts.
+`;
+}
+
+function fullContent(): string {
+	return `# Trellis Workflow Context
+
+> **Context Recovery**: Run \`tl prime\` after compaction, clear, or new session
+
+## Core Rules
+- **Storage**: Prompts live in \`.trellis/prompts.jsonl\` — never edit this file by hand
+- **Emit files are generated**: Do NOT manually edit files in the emit directory; use \`tl update\` instead
+- **Composition**: Prompts are composed via sections and inheritance, not duplicated
+- **Git-native**: JSONL storage is diffable/mergeable; \`merge=union\` gitattribute handles branch merges
+
+## Essential Commands
+
+### Viewing Prompts
+- \`tl list\` — List all prompts (name, version, status, tags)
+- \`tl show <name>\` — Show full prompt record (sections, metadata)
+- \`tl show <name>@<v>\` — Show specific version
+- \`tl render <name>\` — Render full prompt (resolves inheritance chain)
+- \`tl tree <name>\` — Show inheritance tree
+- \`tl history <name>\` — Show version timeline
+- \`tl diff <name> <v1> <v2>\` — Section-aware diff between versions
+
+### Creating & Updating
+- \`tl create --name "..." --section "role:You are..." --tag agent\` — Create prompt
+- \`tl update <name> --section "role:Updated content"\` — Update (creates new version)
+- \`tl import <path>\` — Import existing .md file as a prompt
+- \`tl archive <name>\` — Archive a prompt
+
+### Emitting
+- \`tl emit <name>\` — Render and write prompt to a file
+- \`tl emit --all\` — Emit all active prompts
+- \`tl emit --check\` — Check if emitted files are up to date
+
+### Schemas & Validation
+- \`tl schema create --name "..." --required "role,task"\` — Create validation schema
+- \`tl validate <name>\` — Validate prompt against its schema
+- \`tl validate --all\` — Validate all prompts with schemas
+
+### Versioning
+- \`tl pin <name>@<version>\` — Pin prompt to a specific version
+- \`tl unpin <name>\` — Remove version pin
+
+### Sync
+- \`tl sync\` — Stage and commit .trellis/ changes
+
+## Loam Metadata
+
+Prompts can declare loam (expertise) dependencies inline. Trellis stores the declaration as metadata and surfaces it in the render envelope — **trellis never shells out to \`ml\`**. Consumers (warren, overstory) read the resolved \`loam\` field and run \`ml prime\` themselves.
+
+Schema fields on a prompt record:
+- \`loam.prime.domains[]\` — domain names to prime
+- \`loam.prime.files[]\` — file globs that scope priming
+- \`loam.budget\` — non-negative number, consumer-defined units
+- \`loam.on_empty\` — \`"skip"\` | \`"warn"\` | \`"error"\`
+- \`extends_loam\` — boolean (default false): when true, child merges with parent's loam (union domains/files, last-wins budget/on_empty); when false, child wholesale overrides
+
+\`tl render <name> --json\` includes a top-level \`loam\` field whenever any role in the chain declared one. The field is **omitted entirely** (not null, not {}) when no role declared loam — absent vs. empty is semantically distinct.
+
+\`tl doctor\` runs an optional \`loam-domains\` check that warns on domains not declared in \`.loam/loam.config.yaml\`. The check is a typo guard, not a hard gate.
+
+See SPEC.md "Loam Metadata" for full semantics.
+
+## Common Workflows
+
+**Viewing what's available:**
+\`\`\`bash
+tl list                               # See all prompts
+tl render <name>                      # See full rendered output
+tl tree <name>                        # Understand inheritance
+\`\`\`
+
+**Creating a new prompt:**
+\`\`\`bash
+tl create --name "agent-v1" --section "role:You are a helpful assistant" --tag agent
+tl emit agent-v1                      # Write to agents/agent-v1.md
+tl sync                               # Commit changes
+\`\`\`
+
+**Updating an existing prompt:**
+\`\`\`bash
+tl show <name>                        # Review current state
+tl update <name> --section "role:Updated instructions"
+tl emit <name>                        # Re-emit with changes
+tl sync                               # Commit changes
+\`\`\`
+
+**Importing from an existing file:**
+\`\`\`bash
+tl import path/to/prompt.md           # Import as trellis prompt
+tl emit <name>                        # Verify emit output
+\`\`\`
+`;
+}
+
+export default async function prime(args: string[], json: boolean): Promise<void> {
+	if (args.includes("--help") || args.includes("-h")) {
+		if (!isQuiet()) {
+			process.stdout.write(`Usage: tl prime [options]
+
+Outputs trellis workflow context for AI agent sessions.
+
+Options:
+  --compact   Output minimal quick-reference
+  --export    Output default template (ignores custom PRIME.md)
+  --json      Output as JSON
+`);
+		}
+		return;
+	}
+
+	const compact = args.includes("--compact");
+	const exportMode = args.includes("--export");
+
+	// --export always outputs the default template
+	if (exportMode) {
+		const content = defaultPrimeContent(false);
+		if (json) {
+			jsonOut({ success: true, command: "prime", content });
+		} else if (!isQuiet()) {
+			process.stdout.write(content);
+		}
+		return;
+	}
+
+	// Try to find .trellis dir for custom PRIME.md
+	let content: string | null = null;
+	try {
+		const trellisDir = join(process.cwd(), ".trellis");
+		const customFile = Bun.file(join(trellisDir, PRIME_FILE));
+		if (await customFile.exists()) {
+			content = await customFile.text();
+		}
+	} catch {
+		// No .trellis dir — that's fine, use default
+	}
+
+	if (!content) {
+		content = defaultPrimeContent(compact);
+	}
+
+	if (json) {
+		jsonOut({ success: true, command: "prime", content });
+	} else if (!isQuiet()) {
+		process.stdout.write(content);
+	}
+}
+
+export function registerPrimeCommand(program: Command): void {
+	program
+		.command("prime")
+		.description("Output workflow context for AI agents")
+		.option("--compact", "Output minimal quick-reference")
+		.option("--export", "Output default template (ignores custom PRIME.md)")
+		.action(async (opts: Record<string, unknown>) => {
+			const json: boolean = program.opts().json ?? false;
+			const args: string[] = [];
+			if (opts.compact) args.push("--compact");
+			if (opts.export) args.push("--export");
+			await prime(args, json);
+		});
+}