@ag-eco/agentplate-cli 0.13.0

package/src/tools/sprout/yaml.ts

@@ -0,0 +1,387 @@
+// Minimal YAML parser/emitter for sprout config.yaml.
+//
+// Supports the subset needed for `plan_templates:` (PLAN_SPEC.md:36-78):
+//   - Block-style nested mappings (indent-driven, any indent step).
+//   - Block-style sequences (`- item`, `- key: value` for object items).
+//   - Inline flow mappings (`{ k: v, k2: v2 }`) and sequences (`[a, b, c]`).
+//   - Single- and double-quoted scalars; bare scalars typed as bool / int /
+//     float / null / string.
+//   - `# comment` to end-of-line, ignored both whole-line and trailing.
+//
+// Not supported: anchors/aliases, block scalars (| / >), tags, multi-document
+// streams, complex keys. None of those appear in sprout config files.
+//
+// Kept in-tree per CLAUDE.md "minimal runtime dependencies". If this file grows
+// past ~250 LOC the js-yaml route is the right call.
+
+export type YamlValue = string | number | boolean | null | YamlValue[] | { [k: string]: YamlValue };
+
+export function parseYaml(content: string): Record<string, YamlValue> {
+	const lines = tokenize(content);
+	if (lines.length === 0) return {};
+	const top = lines[0];
+	if (!top) return {};
+	if (top.text.startsWith("-")) {
+		throw new Error("Top-level YAML sequences are not supported by this parser");
+	}
+	const { value } = parseMapping(lines, 0, top.indent);
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return {};
+	return value as Record<string, YamlValue>;
+}
+
+export function stringifyYaml(data: Record<string, YamlValue>): string {
+	return emitMap(data, 0);
+}
+
+interface TokLine {
+	indent: number;
+	text: string;
+}
+
+function tokenize(input: string): TokLine[] {
+	const out: TokLine[] = [];
+	for (const raw of input.split("\n")) {
+		const stripped = stripComment(raw);
+		const indent = leadingSpaces(stripped);
+		const text = stripped.slice(indent).trimEnd();
+		if (text === "") continue;
+		out.push({ indent, text });
+	}
+	return out;
+}
+
+function leadingSpaces(s: string): number {
+	let i = 0;
+	while (i < s.length && s[i] === " ") i++;
+	return i;
+}
+
+function stripComment(line: string): string {
+	let inSingle = false;
+	let inDouble = false;
+	for (let i = 0; i < line.length; i++) {
+		const c = line[i];
+		if (!inDouble && c === "'") inSingle = !inSingle;
+		else if (!inSingle && c === '"') inDouble = !inDouble;
+		else if (!inSingle && !inDouble && c === "#") {
+			// Treat `#` as a comment only if preceded by whitespace or at line start.
+			if (i === 0 || line[i - 1] === " " || line[i - 1] === "\t") return line.slice(0, i);
+		}
+	}
+	return line;
+}
+
+function parseBlock(
+	lines: TokLine[],
+	start: number,
+	indent: number,
+): { value: YamlValue; end: number } {
+	const first = lines[start];
+	if (!first || first.indent < indent) return { value: null, end: start };
+	if (first.text.startsWith("- ") || first.text === "-") {
+		return parseSequence(lines, start, first.indent);
+	}
+	return parseMapping(lines, start, first.indent);
+}
+
+function parseMapping(
+	lines: TokLine[],
+	start: number,
+	indent: number,
+): { value: Record<string, YamlValue>; end: number } {
+	const obj: Record<string, YamlValue> = {};
+	let i = start;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (!line || line.indent < indent) break;
+		if (line.indent > indent) break;
+		if (line.text.startsWith("-")) break;
+		const entry = parseMapEntry(lines, i, indent);
+		obj[entry.key] = entry.value;
+		i = entry.end;
+	}
+	return { value: obj, end: i };
+}
+
+function parseMapEntry(
+	lines: TokLine[],
+	idx: number,
+	indent: number,
+): { key: string; value: YamlValue; end: number } {
+	const line = lines[idx];
+	if (!line) throw new Error(`parseMapEntry: no line at ${idx}`);
+	const colonIdx = findKeyColon(line.text);
+	if (colonIdx === -1) throw new Error(`Expected 'key: value' (got: ${line.text})`);
+	const key = unquote(line.text.slice(0, colonIdx).trim());
+	const valuePart = line.text.slice(colonIdx + 1).trim();
+
+	if (valuePart === "") {
+		const next = lines[idx + 1];
+		if (!next || next.indent < indent) {
+			return { key, value: null, end: idx + 1 };
+		}
+		// A sibling mapping key at the same indent is NOT this key's value; only
+		// a same-indent sequence (`- ...`) is, since YAML allows sequences to
+		// share their parent's indent.
+		if (next.indent === indent && !next.text.startsWith("-")) {
+			return { key, value: null, end: idx + 1 };
+		}
+		const sub = parseBlock(lines, idx + 1, next.indent);
+		return { key, value: sub.value, end: sub.end };
+	}
+	return { key, value: parseScalarOrFlow(valuePart), end: idx + 1 };
+}
+
+function parseSequence(
+	lines: TokLine[],
+	start: number,
+	indent: number,
+): { value: YamlValue[]; end: number } {
+	const arr: YamlValue[] = [];
+	let i = start;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (!line || line.indent !== indent || !line.text.startsWith("-")) break;
+		const rest = line.text === "-" ? "" : line.text.slice(2).trimStart();
+		if (rest === "") {
+			const next = lines[i + 1];
+			if (next && next.indent > indent) {
+				const sub = parseBlock(lines, i + 1, next.indent);
+				arr.push(sub.value);
+				i = sub.end;
+			} else {
+				arr.push(null);
+				i++;
+			}
+			continue;
+		}
+		const inlineColon = findKeyColon(rest);
+		const startsWithFlow = rest.startsWith("{") || rest.startsWith("[");
+		const startsWithQuote = rest.startsWith('"') || rest.startsWith("'");
+		if (inlineColon !== -1 && !startsWithFlow && !startsWithQuote) {
+			// "- key: value" — start of a block-mapping item. The map's logical
+			// indent is the column where `key` begins (line indent + 2 for "- ").
+			const itemIndent = indent + 2;
+			const k = unquote(rest.slice(0, inlineColon).trim());
+			const v = rest.slice(inlineColon + 1).trim();
+			const obj: Record<string, YamlValue> = {};
+			if (v === "") {
+				const next = lines[i + 1];
+				if (next && next.indent > itemIndent) {
+					const sub = parseBlock(lines, i + 1, next.indent);
+					obj[k] = sub.value;
+					i = sub.end;
+				} else {
+					obj[k] = null;
+					i++;
+				}
+			} else {
+				obj[k] = parseScalarOrFlow(v);
+				i++;
+			}
+			while (i < lines.length) {
+				const more = lines[i];
+				if (!more || more.indent !== itemIndent || more.text.startsWith("-")) break;
+				const entry = parseMapEntry(lines, i, itemIndent);
+				obj[entry.key] = entry.value;
+				i = entry.end;
+			}
+			arr.push(obj);
+			continue;
+		}
+		arr.push(parseScalarOrFlow(rest));
+		i++;
+	}
+	return { value: arr, end: i };
+}
+
+function findKeyColon(text: string): number {
+	let inSingle = false;
+	let inDouble = false;
+	let depth = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (!inDouble && c === "'") inSingle = !inSingle;
+		else if (!inSingle && c === '"') inDouble = !inDouble;
+		else if (!inSingle && !inDouble && (c === "{" || c === "[")) depth++;
+		else if (!inSingle && !inDouble && (c === "}" || c === "]")) depth--;
+		else if (!inSingle && !inDouble && depth === 0 && c === ":") {
+			const next = text[i + 1];
+			if (next === undefined || next === " " || next === "\t") return i;
+		}
+	}
+	return -1;
+}
+
+function unquote(s: string): string {
+	if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+		try {
+			return JSON.parse(s) as string;
+		} catch {
+			return s.slice(1, -1);
+		}
+	}
+	if (s.length >= 2 && s.startsWith("'") && s.endsWith("'")) {
+		return s.slice(1, -1).replace(/''/g, "'");
+	}
+	return s;
+}
+
+export function parseScalarOrFlow(s: string): YamlValue {
+	if (s.startsWith("[")) return parseFlowSeq(s);
+	if (s.startsWith("{")) return parseFlowMap(s);
+	if (s.startsWith('"') || s.startsWith("'")) return unquote(s);
+	if (s === "true") return true;
+	if (s === "false") return false;
+	if (s === "null" || s === "~" || s === "") return null;
+	if (/^-?\d+$/.test(s)) return Number(s);
+	if (/^-?\d+\.\d+$/.test(s)) return Number(s);
+	return s;
+}
+
+function parseFlowSeq(s: string): YamlValue[] {
+	if (!s.endsWith("]")) throw new Error(`Unclosed flow sequence: ${s}`);
+	const inner = s.slice(1, -1).trim();
+	if (inner === "") return [];
+	return splitFlow(inner).map((p) => parseScalarOrFlow(p.trim()));
+}
+
+function parseFlowMap(s: string): Record<string, YamlValue> {
+	if (!s.endsWith("}")) throw new Error(`Unclosed flow mapping: ${s}`);
+	const inner = s.slice(1, -1).trim();
+	const out: Record<string, YamlValue> = {};
+	if (inner === "") return out;
+	for (const part of splitFlow(inner)) {
+		const t = part.trim();
+		const colonIdx = findKeyColon(t);
+		if (colonIdx === -1) throw new Error(`Flow map entry missing ':': ${t}`);
+		const k = unquote(t.slice(0, colonIdx).trim());
+		const v = t.slice(colonIdx + 1).trim();
+		out[k] = parseScalarOrFlow(v);
+	}
+	return out;
+}
+
+function splitFlow(s: string): string[] {
+	const parts: string[] = [];
+	let depth = 0;
+	let inSingle = false;
+	let inDouble = false;
+	let start = 0;
+	for (let i = 0; i < s.length; i++) {
+		const c = s[i];
+		if (!inDouble && c === "'") inSingle = !inSingle;
+		else if (!inSingle && c === '"') inDouble = !inDouble;
+		else if (!inSingle && !inDouble && (c === "[" || c === "{")) depth++;
+		else if (!inSingle && !inDouble && (c === "]" || c === "}")) depth--;
+		else if (!inSingle && !inDouble && depth === 0 && c === ",") {
+			parts.push(s.slice(start, i));
+			start = i + 1;
+		}
+	}
+	if (start <= s.length) parts.push(s.slice(start));
+	return parts;
+}
+
+function emitMap(obj: Record<string, YamlValue>, indent: number): string {
+	const lines: string[] = [];
+	const pad = " ".repeat(indent);
+	for (const [k, v] of Object.entries(obj)) {
+		const key = needsQuotedKey(k) ? `"${k}"` : k;
+		if (v === null || v === undefined) {
+			lines.push(`${pad}${key}:`);
+		} else if (typeof v === "string") {
+			lines.push(`${pad}${key}: ${formatScalar(v)}`);
+		} else if (typeof v === "number" || typeof v === "boolean") {
+			lines.push(`${pad}${key}: ${v}`);
+		} else if (Array.isArray(v)) {
+			if (v.length === 0) {
+				lines.push(`${pad}${key}: []`);
+			} else {
+				lines.push(`${pad}${key}:`);
+				lines.push(emitSeq(v, indent));
+			}
+		} else if (typeof v === "object") {
+			if (Object.keys(v).length === 0) {
+				lines.push(`${pad}${key}: {}`);
+			} else {
+				lines.push(`${pad}${key}:`);
+				lines.push(emitMap(v as Record<string, YamlValue>, indent + 2));
+			}
+		}
+	}
+	const out = lines.join("\n");
+	return indent === 0 ? `${out}\n` : out;
+}
+
+function emitSeq(arr: YamlValue[], indent: number): string {
+	const pad = " ".repeat(indent);
+	const lines: string[] = [];
+	for (const v of arr) {
+		if (v === null || v === undefined) {
+			lines.push(`${pad}-`);
+		} else if (typeof v === "string") {
+			lines.push(`${pad}- ${formatScalar(v)}`);
+		} else if (typeof v === "number" || typeof v === "boolean") {
+			lines.push(`${pad}- ${v}`);
+		} else if (Array.isArray(v)) {
+			if (v.length === 0) {
+				lines.push(`${pad}- []`);
+			} else {
+				lines.push(`${pad}-`);
+				lines.push(emitSeq(v, indent + 2));
+			}
+		} else if (typeof v === "object") {
+			const entries = Object.entries(v);
+			if (entries.length === 0) {
+				lines.push(`${pad}- {}`);
+				continue;
+			}
+			const first = entries[0];
+			if (!first) continue;
+			const [fk, fv] = first;
+			const rest = entries.slice(1);
+			const fkKey = needsQuotedKey(fk) ? `"${fk}"` : fk;
+			if (
+				fv !== null &&
+				typeof fv !== "object" &&
+				rest.every(([, rv]) => rv !== null && typeof rv !== "object")
+			) {
+				// Inline first key on the dash line, then the rest indented.
+				lines.push(`${pad}- ${fkKey}: ${formatScalarValue(fv)}`);
+				if (rest.length > 0) {
+					const sub = emitMap(Object.fromEntries(rest), indent + 2);
+					lines.push(sub);
+				}
+			} else {
+				lines.push(`${pad}-`);
+				lines.push(emitMap(v as Record<string, YamlValue>, indent + 2));
+			}
+		}
+	}
+	return lines.join("\n");
+}
+
+function formatScalar(s: string): string {
+	if (needsQuotedScalar(s)) return JSON.stringify(s);
+	return s;
+}
+
+function formatScalarValue(v: YamlValue): string {
+	if (typeof v === "string") return formatScalar(v);
+	if (v === null || v === undefined) return "null";
+	return String(v);
+}
+
+function needsQuotedScalar(s: string): boolean {
+	if (s === "") return true;
+	if (s === "true" || s === "false" || s === "null" || s === "~") return true;
+	if (/^-?\d+(\.\d+)?$/.test(s)) return true;
+	if (/[:#"'[\]{}\n,&*!|>%@`]/.test(s)) return true;
+	if (s !== s.trim()) return true;
+	return false;
+}
+
+function needsQuotedKey(k: string): boolean {
+	return /[\s:#"'[\]{},&*!|>%@`]/.test(k) || k === "";
+}

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

@@ -0,0 +1,87 @@
+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 archive(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 archive <name> [options]
+
+Options:
+  --json    Output as JSON`);
+		return;
+	}
+
+	const name = args.filter((a) => !a.startsWith("--"))[0];
+	if (!name) {
+		if (json) {
+			jsonOut({ success: false, command: "archive", error: "Prompt name required" });
+		} else {
+			errorOut("Usage: tl archive <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: "archive", error: `Prompt '${name}' not found` });
+			} else {
+				errorOut(`Prompt '${name}' not found`);
+			}
+			throw new ExitError(1);
+		}
+
+		if (prompt.status === "archived") {
+			if (json) {
+				jsonOut({
+					success: false,
+					command: "archive",
+					error: `Prompt '${name}' is already archived`,
+				});
+			} else {
+				errorOut(`Prompt '${name}' is already archived`);
+			}
+			throw new ExitError(1);
+		}
+
+		const updated: Prompt = {
+			...prompt,
+			status: "archived",
+			version: prompt.version + 1,
+			updatedAt: new Date().toISOString(),
+		};
+
+		await appendJsonl(promptsPath, updated);
+
+		if (json) {
+			jsonOut({ success: true, command: "archive", id: updated.id, name: updated.name });
+		} else {
+			humanOut(`${fmt.success("Archived prompt")} ${c.bold(name)}`);
+		}
+	} finally {
+		releaseLock(promptsPath);
+	}
+}
+
+export function registerArchiveCommand(program: Command): void {
+	program
+		.command("archive")
+		.description("Archive a prompt")
+		.argument("<name>", "Prompt name")
+		.action(async (name: string) => {
+			const json: boolean = program.opts().json ?? false;
+			const args = [name, ...(json ? ["--json"] : [])];
+			await archive(args, json);
+		});
+}