@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,166 @@
+import { join } from "node:path";
+import type { Command } from "commander";
+import { c, errorOut, fmt, humanOut, jsonOut } from "../output.ts";
+import { dedupById, dedupByIdLast, readJsonl } from "../store.ts";
+import type { Prompt, Schema } from "../types.ts";
+import { ExitError } from "../types.ts";
+import { validatePrompt } from "../validate.ts";
+
+export default async function validate(args: string[], json: boolean): Promise<void> {
+	const cwd = process.cwd();
+	const promptsPath = join(cwd, ".trellis", "prompts.jsonl");
+	const schemasPath = join(cwd, ".trellis", "schemas.jsonl");
+
+	const allMode = args.includes("--all");
+
+	const allPromptRecords = await readJsonl<Prompt>(promptsPath);
+	const allSchemaRecords = await readJsonl<Schema>(schemasPath);
+	const currentPrompts = dedupById(allPromptRecords);
+	const currentSchemas = dedupByIdLast(allSchemaRecords);
+
+	if (args.includes("--help") || args.includes("-h")) {
+		humanOut(`Usage: tl validate <name> [options]
+       tl validate --all
+
+Options:
+  --all     Validate all prompts with schemas
+  --json    Output as JSON`);
+		return;
+	}
+
+	if (allMode) {
+		const promptsWithSchema = currentPrompts.filter((p) => p.schema && p.status !== "archived");
+		const results = [];
+		let allValid = true;
+
+		for (const prompt of promptsWithSchema) {
+			const schemaRecord = currentSchemas.find((s) => s.name === prompt.schema);
+			if (!schemaRecord) {
+				results.push({
+					name: prompt.name,
+					valid: false,
+					errors: [{ section: "", rule: "", message: `Schema '${prompt.schema}' not found` }],
+					warnings: [],
+				});
+				allValid = false;
+				continue;
+			}
+
+			const result = validatePrompt(prompt, schemaRecord, currentPrompts);
+			results.push({ name: prompt.name, ...result });
+			if (!result.valid) allValid = false;
+		}
+
+		if (json) {
+			jsonOut({ success: allValid, command: "validate", results, count: results.length });
+		} else {
+			for (const r of results) {
+				const icon = r.valid ? c.green("✓") : c.red("✗");
+				humanOut(`${icon} ${r.name}`);
+				for (const err of r.errors) {
+					humanOut(`    ${c.red("error")}: [${err.section}] ${err.message}`);
+				}
+				for (const w of r.warnings) {
+					humanOut(`    ${c.yellow("warn")}: ${w}`);
+				}
+			}
+			if (results.length === 0) {
+				humanOut(c.dim("No prompts with schemas to validate."));
+			}
+		}
+
+		if (!allValid) throw new ExitError(1);
+		return;
+	}
+
+	// Single prompt validation
+	const name = args.filter((a) => !a.startsWith("--"))[0];
+	if (!name) {
+		if (json) {
+			jsonOut({ success: false, command: "validate", error: "Prompt name or --all required" });
+		} else {
+			errorOut("Usage: tl validate <name> or tl validate --all");
+		}
+		throw new ExitError(1);
+	}
+
+	const prompt = currentPrompts.find((p) => p.name === name);
+	if (!prompt) {
+		if (json) {
+			jsonOut({ success: false, command: "validate", error: `Prompt '${name}' not found` });
+		} else {
+			errorOut(`Prompt '${name}' not found`);
+		}
+		throw new ExitError(1);
+	}
+
+	if (!prompt.schema) {
+		if (json) {
+			jsonOut({
+				success: false,
+				command: "validate",
+				error: `Prompt '${name}' has no schema assigned`,
+			});
+		} else {
+			errorOut(`Prompt '${name}' has no schema assigned`);
+		}
+		throw new ExitError(1);
+	}
+
+	const schemaRecord = currentSchemas.find((s) => s.name === prompt.schema);
+	if (!schemaRecord) {
+		if (json) {
+			jsonOut({
+				success: false,
+				command: "validate",
+				error: `Schema '${prompt.schema}' not found`,
+			});
+		} else {
+			errorOut(`Schema '${prompt.schema}' not found`);
+		}
+		throw new ExitError(1);
+	}
+
+	const result = validatePrompt(prompt, schemaRecord, currentPrompts);
+
+	if (json) {
+		jsonOut({
+			success: result.valid,
+			command: "validate",
+			name,
+			valid: result.valid,
+			errors: result.errors,
+			warnings: result.warnings,
+		});
+	} else {
+		if (result.valid) {
+			humanOut(fmt.success(`${name} is valid`));
+			if (result.warnings.length > 0) {
+				for (const w of result.warnings) {
+					humanOut(fmt.warning(w));
+				}
+			}
+		} else {
+			humanOut(fmt.error(`${name} is invalid`));
+			for (const err of result.errors) {
+				humanOut(`  ${c.red("error")}: [${err.section}] ${err.message}`);
+			}
+		}
+	}
+
+	if (!result.valid) throw new ExitError(1);
+}
+
+export function registerValidateCommand(program: Command): void {
+	program
+		.command("validate [name]")
+		.description("Validate a prompt against its schema")
+		.option("--all", "Validate all prompts with schemas")
+		.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");
+			await validate(args, json);
+		});
+}

package/src/tools/trellis/config-schema.ts

@@ -0,0 +1,81 @@
+// JSON Schema for `.trellis/config.yaml`. Wire-format contract for warren V2's
+// schema-driven config UI (warren ROADMAP R-10): warren reads this schema,
+// renders a form, and writes back via `tl config set <path> <value>`. Locked
+// with a golden test (config-schema.test.ts) so any shape change is intentional.
+//
+// Describes the **canonical** shape produced by loadConfig in src/config.ts:
+// `project`, `version`, and a `targets` map of named EmitTargets. The loader
+// transparently migrates legacy `emitDir`/`emitDirByTag` configs to this shape
+// on read; the first `tl config set` rewrites the file in the canonical form.
+// Legacy fields are intentionally absent so warren's UI does not surface
+// deprecated knobs.
+
+type JSONSchema = Record<string, unknown>;
+
+export function configSchema(): JSONSchema {
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: "https://github.com/jayminwest/trellis/config.schema.json",
+		title: "Trellis project config",
+		description:
+			"Schema for .trellis/config.yaml. Consumed by warren's schema-driven UI; emit via `tl config schema`.",
+		type: "object",
+		required: ["project", "version"],
+		additionalProperties: false,
+		properties: {
+			project: {
+				type: "string",
+				minLength: 1,
+				title: "Project name",
+				description: "Human-readable project identifier surfaced in `tl list` and warren.",
+			},
+			version: {
+				type: "string",
+				title: "Config schema version",
+				description: "Internal version tag for the config layout. Bumped when the schema breaks.",
+				default: "1",
+			},
+			targets: {
+				type: "object",
+				title: "Emit targets",
+				description:
+					"Map of target name → emit target. `tl emit` resolves a prompt to a target by matching tags, falling back to the target marked `default: true`.",
+				additionalProperties: { $ref: "#/$defs/EmitTarget" },
+				examples: [
+					{
+						default: { dir: "agents", default: true },
+						docs: { dir: "docs/prompts", tags: ["doc"] },
+					},
+				],
+			},
+		},
+		$defs: {
+			EmitTarget: {
+				type: "object",
+				required: ["dir"],
+				additionalProperties: false,
+				properties: {
+					dir: {
+						type: "string",
+						minLength: 1,
+						title: "Directory",
+						description:
+							"Output directory (relative to the repo root) where prompts emitted to this target are written.",
+					},
+					default: {
+						type: "boolean",
+						title: "Default target",
+						description:
+							"When true, prompts with no matching tag-based target are emitted here. At most one target should set this.",
+					},
+					tags: {
+						type: "array",
+						items: { type: "string", minLength: 1 },
+						title: "Tags",
+						description: "Prompts whose `tags` include any of these are routed to this target.",
+					},
+				},
+			},
+		},
+	};
+}

package/src/tools/trellis/config.ts

@@ -0,0 +1,108 @@
+import { join } from "node:path";
+import type { Config, EmitTarget } from "./types.ts";
+import { parseYaml, serializeYaml, type YamlMap } from "./yaml.ts";
+
+export async function loadConfig(dir: string): Promise<Config> {
+	const configPath = join(dir, ".trellis", "config.yaml");
+
+	try {
+		const text = await Bun.file(configPath).text();
+		const parsed = parseYaml(text);
+
+		const project = typeof parsed.project === "string" ? parsed.project : "trellis";
+		const version = typeof parsed.version === "string" ? parsed.version : "1";
+
+		const config: Config = { project, version };
+
+		// New format: targets
+		if (typeof parsed.targets === "object" && !Array.isArray(parsed.targets)) {
+			config.targets = {};
+			for (const [name, targetValue] of Object.entries(parsed.targets as Record<string, unknown>)) {
+				if (
+					typeof targetValue === "object" &&
+					targetValue !== null &&
+					!Array.isArray(targetValue)
+				) {
+					const tv = targetValue as Record<string, unknown>;
+					const target: EmitTarget = { dir: typeof tv.dir === "string" ? tv.dir : name };
+					if (tv.default === "true" || tv.default === true) target.default = true;
+					if (Array.isArray(tv.tags)) {
+						target.tags = tv.tags.filter((t): t is string => typeof t === "string");
+					}
+					config.targets[name] = target;
+				}
+			}
+		}
+		// Legacy format: emitDir / emitDirByTag → convert to targets
+		else {
+			const emitDir = typeof parsed.emitDir === "string" ? parsed.emitDir || undefined : undefined;
+			const rawByTag = parsed.emitDirByTag;
+
+			if (
+				emitDir ||
+				(typeof rawByTag === "object" && rawByTag !== null && !Array.isArray(rawByTag))
+			) {
+				config.targets = {};
+				const defaultDir = emitDir || "agents";
+				config.targets.default = { dir: defaultDir, default: true };
+
+				if (typeof rawByTag === "object" && rawByTag !== null && !Array.isArray(rawByTag)) {
+					// Invert tag→dir map to dir→tags, creating named targets
+					const dirToTags: Record<string, string[]> = {};
+					for (const [tag, tdir] of Object.entries(rawByTag as Record<string, string>)) {
+						const existing = dirToTags[tdir];
+						if (existing) {
+							existing.push(tag);
+						} else {
+							dirToTags[tdir] = [tag];
+						}
+					}
+					for (const [tdir, tags] of Object.entries(dirToTags)) {
+						if (tdir === defaultDir) {
+							// Merge tags into the default target
+							config.targets.default.tags = tags;
+						} else {
+							// Generate a name from the directory path
+							const name =
+								tdir
+									.replace(/[^a-zA-Z0-9]/g, "-")
+									.replace(/^-+|-+$/g, "")
+									.replace(/-+/g, "-") || "target";
+							config.targets[name] = { dir: tdir, tags };
+						}
+					}
+				}
+			}
+		}
+
+		return config;
+	} catch {
+		// Return defaults if config doesn't exist
+		return {
+			project: "trellis",
+			version: "1",
+		};
+	}
+}
+
+export async function saveConfig(dir: string, config: Config): Promise<void> {
+	const configPath = join(dir, ".trellis", "config.yaml");
+
+	const obj: YamlMap = {
+		project: config.project,
+		version: config.version,
+	};
+
+	if (config.targets && Object.keys(config.targets).length > 0) {
+		const targetsMap: YamlMap = {};
+		for (const [name, target] of Object.entries(config.targets)) {
+			const targetMap: YamlMap = { dir: target.dir };
+			if (target.default) targetMap.default = "true";
+			if (target.tags && target.tags.length > 0) targetMap.tags = target.tags;
+			targetsMap[name] = targetMap;
+		}
+		obj.targets = targetsMap;
+	}
+
+	await Bun.write(configPath, serializeYaml(obj));
+}

package/src/tools/trellis/frontmatter.ts

@@ -0,0 +1,348 @@
+/**
+ * YAML frontmatter parser and serializer.
+ * Handles arrays, nested objects, booleans, numbers, and quoted strings.
+ * Does NOT handle flow syntax ([a,b], {a:b}), multi-line scalars, anchors, or tags.
+ */
+
+type FmValue = string | number | boolean | FmValue[] | FmObj;
+type FmObj = { [key: string]: FmValue };
+
+// --- Helpers ---
+
+function getIndent(line: string): number {
+	let i = 0;
+	while (i < line.length && line[i] === " ") i++;
+	return i;
+}
+
+function unquoteStr(s: string): string {
+	if (s.startsWith('"') && s.endsWith('"') && s.length >= 2) {
+		return s.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\").replace(/\\n/g, "\n");
+	}
+	if (s.startsWith("'") && s.endsWith("'") && s.length >= 2) {
+		return s.slice(1, -1).replace(/''/g, "'");
+	}
+	return s;
+}
+
+function stripInlineComment(s: string): string {
+	if (s.startsWith('"') || s.startsWith("'")) return s;
+	const idx = s.indexOf(" #");
+	return idx !== -1 ? s.slice(0, idx).trim() : s;
+}
+
+function parseScalar(raw: string): string | number | boolean {
+	raw = stripInlineComment(raw).trim();
+	if (
+		(raw.startsWith('"') && raw.endsWith('"') && raw.length >= 2) ||
+		(raw.startsWith("'") && raw.endsWith("'") && raw.length >= 2)
+	) {
+		return unquoteStr(raw);
+	}
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	if (/^-?\d+(\.\d+)?$/.test(raw)) return Number(raw);
+	return raw;
+}
+
+// --- Parser ---
+
+function parseMappingBlock(
+	lines: string[],
+	start: number,
+	indent: number,
+): { value: FmObj; next: number } {
+	const result: FmObj = {};
+	let i = start;
+
+	while (i < lines.length) {
+		const rawLine = lines[i] ?? "";
+		const trimmed = rawLine.trim();
+
+		if (!trimmed || trimmed.startsWith("#")) {
+			i++;
+			continue;
+		}
+
+		const lineIndent = getIndent(rawLine);
+		if (lineIndent < indent) break;
+		if (lineIndent > indent) {
+			i++;
+			continue;
+		}
+
+		// Sequence item at this indent — we're leaving mapping territory
+		if (trimmed.startsWith("- ") || trimmed === "-") break;
+
+		const colonIdx = trimmed.indexOf(":");
+		if (colonIdx === -1) {
+			i++;
+			continue;
+		}
+
+		const key = trimmed.slice(0, colonIdx).trim();
+		const rest = trimmed.slice(colonIdx + 1).trim();
+		i++;
+
+		if (rest && !rest.startsWith("#")) {
+			result[key] = parseScalar(rest);
+		} else {
+			// Empty value — peek ahead to determine child type
+			let peek = i;
+			while (peek < lines.length && !lines[peek]?.trim()) peek++;
+
+			if (peek >= lines.length) {
+				result[key] = "";
+				continue;
+			}
+
+			const nextLine = lines[peek] ?? "";
+			const nextIndent = getIndent(nextLine);
+			const nextTrimmed = nextLine.trim();
+
+			if (nextIndent <= indent) {
+				result[key] = "";
+			} else if (nextTrimmed.startsWith("- ") || nextTrimmed === "-") {
+				const { value, next } = parseSequenceBlock(lines, i, nextIndent);
+				result[key] = value;
+				i = next;
+			} else {
+				const { value, next } = parseMappingBlock(lines, i, nextIndent);
+				result[key] = value;
+				i = next;
+			}
+		}
+	}
+
+	return { value: result, next: i };
+}
+
+function parseSequenceBlock(
+	lines: string[],
+	start: number,
+	indent: number,
+): { value: FmValue[]; next: number } {
+	const items: FmValue[] = [];
+	let i = start;
+
+	while (i < lines.length) {
+		const rawLine = lines[i] ?? "";
+		const trimmed = rawLine.trim();
+
+		if (!trimmed || trimmed.startsWith("#")) {
+			i++;
+			continue;
+		}
+
+		const lineIndent = getIndent(rawLine);
+		if (lineIndent < indent) break;
+		if (lineIndent > indent) {
+			i++;
+			continue;
+		}
+
+		if (!trimmed.startsWith("- ") && trimmed !== "-") break;
+
+		const itemContent = trimmed.startsWith("- ") ? trimmed.slice(2).trim() : "";
+		i++;
+
+		if (!itemContent) {
+			// Empty item — check for indented mapping children
+			let peek = i;
+			while (peek < lines.length && !lines[peek]?.trim()) peek++;
+			if (peek < lines.length && getIndent(lines[peek] ?? "") > indent) {
+				const childIndent = getIndent(lines[peek] ?? "");
+				const { value, next } = parseMappingBlock(lines, i, childIndent);
+				items.push(value);
+				i = next;
+			} else {
+				items.push("");
+			}
+			continue;
+		}
+
+		const colonIdx = itemContent.indexOf(":");
+		if (colonIdx !== -1 && !itemContent.startsWith('"') && !itemContent.startsWith("'")) {
+			// Mapping item: "- key: value" with optional continuation fields
+			const key = itemContent.slice(0, colonIdx).trim();
+			const valStr = itemContent.slice(colonIdx + 1).trim();
+			const obj: FmObj = { [key]: valStr ? parseScalar(valStr) : "" };
+
+			// Continuation fields at indent + 2 (same as the content after "- ")
+			const contIndent = indent + 2;
+			while (i < lines.length) {
+				const nextRaw = lines[i] ?? "";
+				const nextTrimmed = nextRaw.trim();
+
+				if (!nextTrimmed || nextTrimmed.startsWith("#")) {
+					i++;
+					continue;
+				}
+
+				const nextIndent = getIndent(nextRaw);
+				if (nextIndent !== contIndent) break;
+				if (nextTrimmed.startsWith("- ")) break;
+
+				const fieldColon = nextTrimmed.indexOf(":");
+				if (fieldColon === -1) break;
+
+				const fieldKey = nextTrimmed.slice(0, fieldColon).trim();
+				const fieldRest = nextTrimmed.slice(fieldColon + 1).trim();
+				obj[fieldKey] = fieldRest ? parseScalar(fieldRest) : "";
+				i++;
+			}
+
+			items.push(obj);
+		} else {
+			items.push(parseScalar(itemContent));
+		}
+	}
+
+	return { value: items, next: i };
+}
+
+// --- Serializer ---
+
+function needsQuoting(s: string): boolean {
+	// Ambiguous scalars that would be misinterpreted without quotes
+	if (s === "true" || s === "false" || s === "null" || s === "~") return true;
+	if (/^-?\d+(\.\d+)?$/.test(s)) return true;
+	return (
+		s.includes(":") ||
+		s.includes("#") ||
+		s.includes('"') ||
+		s.includes("'") ||
+		s.includes("\n") ||
+		s.startsWith(" ") ||
+		s.endsWith(" ")
+	);
+}
+
+function maybeQuote(s: string): string {
+	if (needsQuoting(s)) {
+		return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+	}
+	return s;
+}
+
+function serializeScalar(val: unknown): string {
+	if (typeof val === "boolean" || typeof val === "number") return String(val);
+	if (typeof val === "string") return maybeQuote(val);
+	return String(val ?? "");
+}
+
+function serializeValue(key: string, val: unknown, indent: number): string[] {
+	const pad = " ".repeat(indent);
+
+	if (val === null || val === undefined) {
+		return [`${pad}${key}:`];
+	}
+
+	if (typeof val === "boolean" || typeof val === "number") {
+		return [`${pad}${key}: ${val}`];
+	}
+
+	if (typeof val === "string") {
+		return [`${pad}${key}: ${maybeQuote(val)}`];
+	}
+
+	if (Array.isArray(val)) {
+		const lines: string[] = [`${pad}${key}:`];
+		for (const item of val) {
+			if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+				const entries = Object.entries(item as Record<string, unknown>);
+				if (entries.length === 0) {
+					lines.push(`${pad}  -`);
+				} else {
+					for (let j = 0; j < entries.length; j++) {
+						const entry = entries[j];
+						if (!entry) continue;
+						const [k, v] = entry;
+						if (j === 0) {
+							lines.push(`${pad}  - ${k}: ${serializeScalar(v)}`);
+						} else {
+							lines.push(`${pad}    ${k}: ${serializeScalar(v)}`);
+						}
+					}
+				}
+			} else {
+				lines.push(`${pad}  - ${serializeScalar(item)}`);
+			}
+		}
+		return lines;
+	}
+
+	if (typeof val === "object") {
+		const lines: string[] = [`${pad}${key}:`];
+		for (const [childKey, childVal] of Object.entries(val as Record<string, unknown>)) {
+			lines.push(...serializeValue(childKey, childVal, indent + 2));
+		}
+		return lines;
+	}
+
+	return [`${pad}${key}: ${String(val)}`];
+}
+
+// --- Public API ---
+
+/**
+ * Extract YAML frontmatter from markdown content.
+ * Returns parsed metadata + remaining body.
+ */
+export function extractFrontmatter(content: string): {
+	metadata: Record<string, unknown>;
+	body: string;
+} {
+	if (!content.startsWith("---")) {
+		return { metadata: {}, body: content };
+	}
+
+	// The opening --- must be the entire first line
+	const firstNewline = content.indexOf("\n");
+	if (firstNewline === -1) {
+		return { metadata: {}, body: content };
+	}
+	if (content.slice(0, firstNewline).trim() !== "---") {
+		return { metadata: {}, body: content };
+	}
+
+	const afterFirst = content.slice(firstNewline + 1);
+	const lines = afterFirst.split("\n");
+
+	// Find the closing ---
+	let closingIdx = -1;
+	for (let i = 0; i < lines.length; i++) {
+		if ((lines[i] ?? "").trim() === "---") {
+			closingIdx = i;
+			break;
+		}
+	}
+
+	if (closingIdx === -1) {
+		// No closing ---, treat as no frontmatter
+		return { metadata: {}, body: content };
+	}
+
+	const yamlLines = lines.slice(0, closingIdx);
+	const bodyLines = lines.slice(closingIdx + 1);
+	const body = bodyLines.join("\n");
+
+	const { value: metadata } = parseMappingBlock(yamlLines, 0, 0);
+	return { metadata, body };
+}
+
+/**
+ * Serialize a metadata object to a YAML frontmatter block (with --- delimiters).
+ * Returns empty string if metadata is empty.
+ */
+export function renderFrontmatter(metadata: Record<string, unknown>): string {
+	if (Object.keys(metadata).length === 0) return "";
+
+	const lines: string[] = ["---"];
+	for (const [key, val] of Object.entries(metadata)) {
+		lines.push(...serializeValue(key, val, 0));
+	}
+	lines.push("---");
+
+	return `${lines.join("\n")}\n`;
+}