@ag-eco/agentplate-cli 0.13.0

package/src/tools/sprout/commands/config.ts

@@ -0,0 +1,238 @@
+// `sr config` — schema-driven read/write surface for `.sprout/config.yaml`.
+//
+// Designed as warren V2's wire contract (warren ROADMAP R-10):
+//   - `sr config schema --json` emits the JSON Schema (warren auto-renders a form)
+//   - `sr config show [--path <p>]` reads the current value
+//   - `sr config set <path> <value>` validates + writes atomically (YAML-parsed)
+//   - `sr config unset <path>` removes a value
+//
+// Writes hold the config.yaml advisory lock; mutations validate the entire
+// post-write file against configSchema() before persisting, so a partial set
+// that would leave the file inconsistent is rejected.
+
+import { randomBytes } from "node:crypto";
+import { renameSync } from "node:fs";
+import { join } from "node:path";
+import { Command } from "commander";
+import { findSproutDir } from "../config.ts";
+import { configSchema } from "../config-schema.ts";
+import { accent, muted, outputJson, printSuccess } from "../output.ts";
+import { withLock } from "../store.ts";
+import { CONFIG_FILE } from "../types.ts";
+import { compileSchema } from "../validation.ts";
+import { parseScalarOrFlow, parseYaml, stringifyYaml, type YamlValue } from "../yaml.ts";
+
+function configPath(sproutDir: string): string {
+	return join(sproutDir, CONFIG_FILE);
+}
+
+function pathParts(path: string): string[] {
+	const parts = path.split(".").filter((p) => p.length > 0);
+	if (parts.length === 0) throw new Error("Config path must be non-empty");
+	return parts;
+}
+
+function describeType(v: unknown): string {
+	if (v === null) return "null";
+	if (Array.isArray(v)) return "array";
+	return typeof v;
+}
+
+function getAtPath(data: YamlValue, parts: string[]): YamlValue | undefined {
+	let cur: YamlValue = data;
+	for (const p of parts) {
+		if (cur === null || typeof cur !== "object" || Array.isArray(cur)) return undefined;
+		cur = (cur as Record<string, YamlValue>)[p] as YamlValue;
+		if (cur === undefined) return undefined;
+	}
+	return cur;
+}
+
+function setAtPath(data: Record<string, YamlValue>, parts: string[], value: YamlValue): void {
+	let cur: Record<string, YamlValue> = data;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const p = parts[i];
+		if (p === undefined) continue;
+		const nxt = cur[p];
+		if (nxt === undefined || nxt === null) {
+			const empty: Record<string, YamlValue> = {};
+			cur[p] = empty;
+			cur = empty;
+		} else if (typeof nxt === "object" && !Array.isArray(nxt)) {
+			cur = nxt as Record<string, YamlValue>;
+		} else {
+			const soFar = parts.slice(0, i + 1).join(".");
+			throw new Error(`Cannot set: '${soFar}' is not an object (got: ${describeType(nxt)})`);
+		}
+	}
+	const last = parts[parts.length - 1];
+	if (last !== undefined) cur[last] = value;
+}
+
+function unsetAtPath(data: Record<string, YamlValue>, parts: string[]): boolean {
+	let cur: Record<string, YamlValue> = data;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const p = parts[i];
+		if (p === undefined) continue;
+		const nxt = cur[p];
+		if (nxt === null || typeof nxt !== "object" || Array.isArray(nxt)) return false;
+		cur = nxt as Record<string, YamlValue>;
+	}
+	const last = parts[parts.length - 1];
+	if (last === undefined) return false;
+	if (!(last in cur)) return false;
+	delete cur[last];
+	return true;
+}
+
+function validateConfig(data: unknown): void {
+	// Strip the meta-schema URI: configSchema() advertises draft 2020-12 for
+	// downstream consumers (warren's UI), but our shared compileSchema runs
+	// AJV in default (draft-07) mode and rejects unknown $schema URIs.
+	const { $schema: _meta, ...schema } = configSchema();
+	const validator = compileSchema(schema);
+	const result = validator(data);
+	if (!result.valid) {
+		const lines = result.diff.errors.map((e) => `  ${e.path || "(root)"}: ${e.fix}`);
+		throw new Error(`Config validation failed:\n${lines.join("\n")}`);
+	}
+}
+
+async function readRawConfig(sproutDir: string): Promise<Record<string, YamlValue>> {
+	const file = Bun.file(configPath(sproutDir));
+	if (!(await file.exists())) {
+		throw new Error(`Config not found at ${configPath(sproutDir)}`);
+	}
+	const content = await file.text();
+	return parseYaml(content);
+}
+
+async function writeRawConfig(sproutDir: string, data: Record<string, YamlValue>): Promise<void> {
+	const path = configPath(sproutDir);
+	const tmpPath = `${path}.tmp.${randomBytes(4).toString("hex")}`;
+	await Bun.write(tmpPath, stringifyYaml(data));
+	renameSync(tmpPath, path);
+}
+
+function displayValue(v: YamlValue): string {
+	if (typeof v === "string") return v;
+	return JSON.stringify(v);
+}
+
+async function runSchema(jsonMode: boolean): Promise<void> {
+	const schema = configSchema();
+	if (jsonMode) {
+		await Bun.write(Bun.stdout, `${JSON.stringify(schema)}\n`);
+		return;
+	}
+	await Bun.write(Bun.stdout, `${JSON.stringify(schema, null, 2)}\n`);
+}
+
+async function runShow(pathArg: string | undefined, jsonMode: boolean): Promise<void> {
+	const dir = await findSproutDir();
+	const raw = await readRawConfig(dir);
+
+	if (pathArg) {
+		const parts = pathParts(pathArg);
+		const value = getAtPath(raw, parts);
+		if (value === undefined) {
+			throw new Error(`Path not found: ${pathArg}`);
+		}
+		if (jsonMode) {
+			await outputJson({ success: true, command: "config show", path: pathArg, value });
+		} else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			process.stdout.write(stringifyYaml(value as Record<string, YamlValue>));
+		} else if (typeof value === "string") {
+			console.log(value);
+		} else {
+			await Bun.write(Bun.stdout, `${JSON.stringify(value)}\n`);
+		}
+		return;
+	}
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "config show", config: raw });
+	} else {
+		process.stdout.write(stringifyYaml(raw));
+	}
+}
+
+async function runSet(pathArg: string, valueArg: string, jsonMode: boolean): Promise<void> {
+	const dir = await findSproutDir();
+	const parts = pathParts(pathArg);
+	const value = parseScalarOrFlow(valueArg);
+
+	await withLock(configPath(dir), async () => {
+		const raw = await readRawConfig(dir);
+		setAtPath(raw, parts, value);
+		validateConfig(raw);
+		await writeRawConfig(dir, raw);
+	});
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "config set", path: pathArg, value });
+	} else {
+		printSuccess(`Set ${accent(pathArg)} ${muted("=")} ${displayValue(value)}`);
+	}
+}
+
+async function runUnset(pathArg: string, jsonMode: boolean): Promise<void> {
+	const dir = await findSproutDir();
+	const parts = pathParts(pathArg);
+
+	let removed = false;
+	await withLock(configPath(dir), async () => {
+		const raw = await readRawConfig(dir);
+		removed = unsetAtPath(raw, parts);
+		if (!removed) return;
+		validateConfig(raw);
+		await writeRawConfig(dir, raw);
+	});
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "config unset", path: pathArg, removed });
+	} else if (removed) {
+		printSuccess(`Unset ${accent(pathArg)}`);
+	} else {
+		console.log(muted(`No such path: ${pathArg}`));
+	}
+}
+
+export function register(program: Command): void {
+	const config = new Command("config").description("Read, write, and inspect .sprout/config.yaml");
+
+	config
+		.command("schema")
+		.description("Emit the JSON Schema for .sprout/config.yaml")
+		.option("--json", "Compact single-line JSON (default is pretty-printed)")
+		.action(async (opts: { json?: boolean }) => {
+			await runSchema(opts.json === true);
+		});
+
+	config
+		.command("show")
+		.description("Print the current config (or a value at --path)")
+		.option("--path <path>", "Dot-path to read (e.g. plan_templates.feature.sections.context)")
+		.option("--json", "Output as JSON")
+		.action(async (opts: { path?: string; json?: boolean }) => {
+			await runShow(opts.path, opts.json === true);
+		});
+
+	config
+		.command("set <path> <value>")
+		.description("Set a config value at <path>; <value> is YAML-parsed")
+		.option("--json", "Output as JSON")
+		.action(async (path: string, value: string, opts: { json?: boolean }) => {
+			await runSet(path, value, opts.json === true);
+		});
+
+	config
+		.command("unset <path>")
+		.description("Remove the config value at <path>")
+		.option("--json", "Output as JSON")
+		.action(async (path: string, opts: { json?: boolean }) => {
+			await runUnset(path, opts.json === true);
+		});
+
+	program.addCommand(config);
+}

package/src/tools/sprout/commands/create.ts

@@ -0,0 +1,164 @@
+import { type Command, Option } from "commander";
+import { findSproutDir, readConfig } from "../config.ts";
+import { generateId } from "../id.ts";
+import { outputJson, printSuccess } from "../output.ts";
+import { appendIssue, issuesPath, readIssues, withLock } from "../store.ts";
+import type { Issue } from "../types.ts";
+import { VALID_TYPES } from "../types.ts";
+
+function parseArgs(args: string[]) {
+	const flags: Record<string, string | boolean> = {};
+	let i = 0;
+	while (i < args.length) {
+		const arg = args[i];
+		if (!arg) {
+			i++;
+			continue;
+		}
+		if (arg.startsWith("--")) {
+			const key = arg.slice(2);
+			const eqIdx = key.indexOf("=");
+			if (eqIdx !== -1) {
+				flags[key.slice(0, eqIdx)] = key.slice(eqIdx + 1);
+				i++;
+			} else {
+				const next = args[i + 1];
+				if (next !== undefined && !next.startsWith("--")) {
+					flags[key] = next;
+					i += 2;
+				} else {
+					flags[key] = true;
+					i++;
+				}
+			}
+		} else {
+			i++;
+		}
+	}
+	return flags;
+}
+
+function parsePriority(val: string | boolean | undefined, defaultVal = 2): number {
+	if (val === undefined || val === true) return defaultVal;
+	const s = String(val);
+	if (s.toUpperCase().startsWith("P")) return Number.parseInt(s.slice(1), 10);
+	return Number.parseInt(s, 10);
+}
+
+export async function run(args: string[], sproutDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const flags = parseArgs(args);
+	const title = flags.title;
+	if (!title || typeof title !== "string" || !title.trim()) {
+		throw new Error("--title is required");
+	}
+
+	const typeVal = flags.type ?? "task";
+	if (typeof typeVal !== "string" || !(VALID_TYPES as readonly string[]).includes(typeVal)) {
+		throw new Error(`--type must be one of: ${VALID_TYPES.join(", ")}`);
+	}
+	const issueType = typeVal as Issue["type"];
+
+	const priority = parsePriority(flags.priority);
+	if (Number.isNaN(priority) || priority < 0 || priority > 4) {
+		throw new Error("--priority must be 0-4 or P0-P4");
+	}
+
+	// --label is a hidden alias for --labels; --labels wins when both are supplied.
+	const labelsRaw =
+		typeof flags.labels === "string"
+			? flags.labels
+			: typeof flags.label === "string"
+				? flags.label
+				: undefined;
+	const labels = labelsRaw
+		? labelsRaw
+				.split(",")
+				.map((l) => l.trim().toLowerCase())
+				.filter(Boolean)
+		: undefined;
+
+	const assignee = typeof flags.assignee === "string" ? flags.assignee : undefined;
+	const description =
+		typeof flags.description === "string"
+			? flags.description
+			: typeof flags.desc === "string"
+				? flags.desc
+				: typeof flags.body === "string"
+					? flags.body
+					: undefined;
+
+	const dir = sproutDir ?? (await findSproutDir());
+	const config = await readConfig(dir);
+
+	let createdId = "";
+	await withLock(issuesPath(dir), async () => {
+		const existing = await readIssues(dir);
+		const existingIds = new Set(existing.map((i) => i.id));
+		const id = generateId(config.project, existingIds);
+		const now = new Date().toISOString();
+		const issue: Issue = {
+			id,
+			title: title.trim(),
+			status: "open",
+			type: issueType,
+			priority,
+			createdAt: now,
+			updatedAt: now,
+			...(assignee ? { assignee } : {}),
+			...(description ? { description } : {}),
+			...(labels && labels.length > 0 ? { labels } : {}),
+		};
+		await appendIssue(dir, issue);
+		createdId = id;
+	});
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "create", id: createdId });
+	} else {
+		printSuccess(`Created ${createdId}`);
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("create")
+		.description("Create a new issue")
+		.requiredOption("--title <text>", "Issue title")
+		.option("--type <type>", "Issue type (task|bug|feature|epic)", "task")
+		.option("--priority <n>", "Priority 0-4 or P0-P4", "2")
+		.option("--assignee <name>", "Assignee name")
+		.option("--description <text>", "Issue description")
+		.option("--desc <text>", "Issue description (alias for --description)")
+		.option("--body <text>", "Issue description (alias for --description)")
+		.option("--labels <labels>", "Comma-separated labels")
+		.addOption(new Option("--label <labels>", "Comma-separated labels (alias)").hideHelp())
+		.option("--json", "Output as JSON")
+		.action(
+			async (opts: {
+				title: string;
+				type?: string;
+				priority?: string;
+				assignee?: string;
+				description?: string;
+				desc?: string;
+				body?: string;
+				labels?: string;
+				label?: string;
+				json?: boolean;
+			}) => {
+				const args: string[] = ["--title", opts.title];
+				if (opts.type) args.push("--type", opts.type);
+				if (opts.priority) args.push("--priority", opts.priority);
+				if (opts.assignee) args.push("--assignee", opts.assignee);
+				if (opts.description) args.push("--description", opts.description);
+				if (opts.desc) args.push("--desc", opts.desc);
+				if (opts.body) args.push("--body", opts.body);
+				// --labels wins over --label alias when both are supplied.
+				if (opts.labels) args.push("--labels", opts.labels);
+				else if (opts.label) args.push("--labels", opts.label);
+				if (opts.json) args.push("--json");
+				await run(args);
+			},
+		);
+}

package/src/tools/sprout/commands/dep.ts

@@ -0,0 +1,148 @@
+import { Command } from "commander";
+import { findSproutDir } from "../config.ts";
+import { accent, muted, outputJson, printIssueOneLine } from "../output.ts";
+import { issuesPath, readIssues, withLock, writeIssues } from "../store.ts";
+import type { Issue } from "../types.ts";
+
+export async function run(args: string[], sproutDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const positional = args.filter((a) => !a.startsWith("--"));
+
+	const subcmd = positional[0];
+	if (!subcmd) throw new Error("Usage: sr dep <add|remove|list> <issue> [depends-on]");
+
+	const dir = sproutDir ?? (await findSproutDir());
+
+	if (subcmd === "list") {
+		const issueId = positional[1];
+		if (!issueId) throw new Error("Usage: sr dep list <issue>");
+		const issues = await readIssues(dir);
+		const issue = issues.find((i) => i.id === issueId);
+		if (!issue) throw new Error(`Issue not found: ${issueId}`);
+
+		const blockedBy = issue.blockedBy ?? [];
+		const blocks = issue.blocks ?? [];
+		const closedBlockerIds = new Set(issues.filter((i) => i.status === "closed").map((i) => i.id));
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "dep list", issueId, blockedBy, blocks });
+		} else {
+			console.log(`${accent.bold(issueId)} ${muted("dependencies:")}`);
+			if (blockedBy.length > 0) {
+				console.log(muted("  Blocked by:"));
+				for (const bid of blockedBy) {
+					const b = issues.find((i) => i.id === bid);
+					if (b) {
+						process.stdout.write("    ");
+						printIssueOneLine(b, closedBlockerIds);
+					} else {
+						console.log(`    ${accent(bid)} ${muted("(not found)")}`);
+					}
+				}
+			}
+			if (blocks.length > 0) {
+				console.log(muted("  Blocks:"));
+				for (const bid of blocks) {
+					const b = issues.find((i) => i.id === bid);
+					if (b) {
+						process.stdout.write("    ");
+						printIssueOneLine(b, closedBlockerIds);
+					} else {
+						console.log(`    ${accent(bid)} ${muted("(not found)")}`);
+					}
+				}
+			}
+			if (blockedBy.length === 0 && blocks.length === 0) {
+				console.log(muted("  No dependencies."));
+			}
+		}
+		return;
+	}
+
+	if (subcmd === "add" || subcmd === "remove") {
+		const issueId = positional[1];
+		const dependsOnId = positional[2];
+		if (!issueId || !dependsOnId) {
+			throw new Error(`Usage: sr dep ${subcmd} <issue> <depends-on>`);
+		}
+		if (subcmd === "add" && issueId === dependsOnId) {
+			throw new Error(`Cannot add a self-dependency: ${issueId}`);
+		}
+
+		await withLock(issuesPath(dir), async () => {
+			const issues = await readIssues(dir);
+			const issueIdx = issues.findIndex((i) => i.id === issueId);
+			const issue = issues[issueIdx];
+			if (!issue) throw new Error(`Issue not found: ${issueId}`);
+
+			const depIdx = issues.findIndex((i) => i.id === dependsOnId);
+			const dep = issues[depIdx];
+			if (!dep) throw new Error(`Issue not found: ${dependsOnId}`);
+
+			if (subcmd === "add") {
+				const blockedBy = Array.from(new Set([...(issue.blockedBy ?? []), dependsOnId]));
+				const depBlocks = Array.from(new Set([...(dep.blocks ?? []), issueId]));
+				issues[issueIdx] = { ...issue, blockedBy, updatedAt: new Date().toISOString() };
+				issues[depIdx] = { ...dep, blocks: depBlocks, updatedAt: new Date().toISOString() };
+			} else {
+				const blockedBy = (issue.blockedBy ?? []).filter((id: string) => id !== dependsOnId);
+				const depBlocks = (dep.blocks ?? []).filter((id: string) => id !== issueId);
+				const updatedIssue: Issue = { ...issue, updatedAt: new Date().toISOString() };
+				if (blockedBy.length > 0) updatedIssue.blockedBy = blockedBy;
+				else updatedIssue.blockedBy = undefined;
+				const updatedDep: Issue = { ...dep, updatedAt: new Date().toISOString() };
+				if (depBlocks.length > 0) updatedDep.blocks = depBlocks;
+				else updatedDep.blocks = undefined;
+				issues[issueIdx] = updatedIssue;
+				issues[depIdx] = updatedDep;
+			}
+			await writeIssues(dir, issues);
+		});
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: `dep ${subcmd}`, issueId, dependsOnId });
+		} else {
+			const verb = subcmd === "add" ? "Added" : "Removed";
+			console.log(`${verb} dependency: ${accent(issueId)} ${muted("→")} ${accent(dependsOnId)}`);
+		}
+		return;
+	}
+
+	throw new Error(`Unknown dep subcommand: ${subcmd}. Use add, remove, or list.`);
+}
+
+export function register(program: Command): void {
+	const dep = new Command("dep").description("Manage issue dependencies");
+
+	dep
+		.command("add <issue> <depends-on>")
+		.description("Add a dependency (issue depends on depends-on)")
+		.option("--json", "Output as JSON")
+		.action(async (issue: string, dependsOn: string, opts: { json?: boolean }) => {
+			const args: string[] = ["add", issue, dependsOn];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	dep
+		.command("remove <issue> <depends-on>")
+		.description("Remove a dependency")
+		.option("--json", "Output as JSON")
+		.action(async (issue: string, dependsOn: string, opts: { json?: boolean }) => {
+			const args: string[] = ["remove", issue, dependsOn];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	dep
+		.command("list <issue>")
+		.description("Show dependencies for an issue")
+		.option("--json", "Output as JSON")
+		.action(async (issue: string, opts: { json?: boolean }) => {
+			const args: string[] = ["list", issue];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	program.addCommand(dep);
+}