@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,134 @@
+import type { Command } from "commander";
+import { findSproutDir, isInsideWorktree, projectRootFromSproutDir } from "../config.ts";
+import { outputJson, printWarning } from "../output.ts";
+import { SPROUT_DIR_NAME } from "../types.ts";
+
+function spawnSync(
+	cmd: string[],
+	cwd: string,
+): { stdout: string; stderr: string; exitCode: number } {
+	const result = Bun.spawnSync(cmd, { cwd, stdout: "pipe", stderr: "pipe" });
+	const stdout = new TextDecoder().decode(result.stdout);
+	const stderr = new TextDecoder().decode(result.stderr);
+	return { stdout, stderr, exitCode: result.exitCode ?? 0 };
+}
+
+export async function run(args: string[], sproutDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const statusOnly = args.includes("--status");
+	const dryRun = args.includes("--dry-run");
+
+	const dir = sproutDir ?? (await findSproutDir());
+	const projectRoot = projectRootFromSproutDir(dir);
+
+	// Worktree guard: skip commit when running from a worktree
+	if (!sproutDir && isInsideWorktree(process.cwd())) {
+		const msg = "Inside a git worktree — skipping commit. Issues are stored in the main repo.";
+		if (jsonMode) {
+			await outputJson({
+				success: true,
+				command: "sync",
+				committed: false,
+				worktree: true,
+				message: msg,
+			});
+		} else {
+			printWarning(msg);
+		}
+		return;
+	}
+
+	const statusResult = spawnSync(
+		["git", "-C", projectRoot, "status", "--porcelain", `${SPROUT_DIR_NAME}/`],
+		projectRoot,
+	);
+
+	const changed = statusResult.stdout.trim();
+
+	if (statusOnly) {
+		if (jsonMode) {
+			await outputJson({ success: true, command: "sync", hasChanges: !!changed, changes: changed });
+		} else {
+			if (changed) {
+				console.log("Uncommitted .sprout/ changes:");
+				console.log(changed);
+			} else {
+				console.log("No uncommitted .sprout/ changes.");
+			}
+		}
+		return;
+	}
+
+	if (!changed) {
+		if (jsonMode) {
+			await outputJson({
+				success: true,
+				command: "sync",
+				committed: false,
+				message: "Nothing to commit",
+			});
+		} else {
+			console.log("No changes to commit.");
+		}
+		return;
+	}
+
+	if (dryRun) {
+		const date = new Date().toISOString().slice(0, 10);
+		const msg = `sprout: sync ${date}`;
+		if (jsonMode) {
+			await outputJson({
+				success: true,
+				command: "sync",
+				dryRun: true,
+				wouldCommit: true,
+				message: msg,
+				changes: changed,
+			});
+		} else {
+			console.log("Dry run — would commit:");
+			console.log(changed);
+			console.log(`Commit message: ${msg}`);
+		}
+		return;
+	}
+
+	// Stage
+	const addResult = spawnSync(
+		["git", "-C", projectRoot, "add", `${SPROUT_DIR_NAME}/`],
+		projectRoot,
+	);
+	if (addResult.exitCode !== 0) {
+		throw new Error(`git add failed: ${addResult.stderr}`);
+	}
+
+	// Commit
+	const date = new Date().toISOString().slice(0, 10);
+	const msg = `sprout: sync ${date}`;
+	const commitResult = spawnSync(["git", "-C", projectRoot, "commit", "-m", msg], projectRoot);
+	if (commitResult.exitCode !== 0) {
+		throw new Error(`git commit failed: ${commitResult.stderr}`);
+	}
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "sync", committed: true, message: msg });
+	} else {
+		console.log(`Committed: ${msg}`);
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("sync")
+		.description("Stage and commit .sprout/ changes")
+		.option("--status", "Check status without committing")
+		.option("--dry-run", "Show what would be committed without committing")
+		.option("--json", "Output as JSON")
+		.action(async (opts: { status?: boolean; dryRun?: boolean; json?: boolean }) => {
+			const args: string[] = [];
+			if (opts.status) args.push("--status");
+			if (opts.dryRun) args.push("--dry-run");
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+}

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

@@ -0,0 +1,364 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { findSproutDir, readConfig } from "../config.ts";
+import { generateId } from "../id.ts";
+import { accent, muted, outputJson, printIssueOneLine, printSuccess } from "../output.ts";
+import {
+	appendTemplate,
+	issuesPath,
+	readIssues,
+	readTemplates,
+	templatesPath,
+	withLock,
+	writeIssues,
+	writeTemplates,
+} from "../store.ts";
+import type { Issue, Template, TemplateStep } from "../types.ts";
+import { VALID_TYPES } from "../types.ts";
+
+function parseArgs(args: string[]) {
+	const flags: Record<string, string | boolean> = {};
+	const positional: string[] = [];
+	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 {
+			positional.push(arg);
+			i++;
+		}
+	}
+	return { flags, positional };
+}
+
+export async function run(args: string[], sproutDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const { flags, positional } = parseArgs(args);
+	const subcmd = positional[0];
+
+	if (!subcmd) throw new Error("Usage: sr tpl <create|step|list|show|pour|status>");
+
+	const dir = sproutDir ?? (await findSproutDir());
+
+	// sr tpl create --name "..."
+	if (subcmd === "create") {
+		const name = flags.name;
+		if (!name || typeof name !== "string") throw new Error("--name is required");
+
+		let createdId = "";
+		await withLock(templatesPath(dir), async () => {
+			const existing = await readTemplates(dir);
+			const existingIds = new Set(existing.map((t) => t.id));
+			const id = generateId("tpl", existingIds);
+			const template: Template = { id, name, steps: [] };
+			await appendTemplate(dir, template);
+			createdId = id;
+		});
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "tpl create", id: createdId });
+		} else {
+			printSuccess(`Created template ${createdId}: ${name}`);
+		}
+		return;
+	}
+
+	// sr tpl step add <template-id> --title "..." [--type task] [--priority 2]
+	if (subcmd === "step") {
+		const stepSubcmd = positional[1];
+		if (stepSubcmd !== "add") throw new Error("Usage: sr tpl step add <id> --title ...");
+		const templateId = positional[2];
+		if (!templateId) throw new Error("Template ID is required");
+		const title = flags.title;
+		if (!title || typeof title !== "string") throw new Error("--title is required");
+
+		const typeVal = typeof flags.type === "string" ? flags.type : "task";
+		if (!(VALID_TYPES as readonly string[]).includes(typeVal)) {
+			throw new Error(`--type must be one of: ${VALID_TYPES.join(", ")}`);
+		}
+		const priorityStr = typeof flags.priority === "string" ? flags.priority : "2";
+		const priority = Number.parseInt(priorityStr, 10);
+
+		let stepCount = 0;
+		await withLock(templatesPath(dir), async () => {
+			const templates = await readTemplates(dir);
+			const idx = templates.findIndex((t) => t.id === templateId);
+			const tpl = templates[idx];
+			if (!tpl) throw new Error(`Template not found: ${templateId}`);
+			const step: TemplateStep = { title, type: typeVal, priority };
+			const updated: Template = { ...tpl, steps: [...tpl.steps, step] };
+			templates[idx] = updated;
+			stepCount = updated.steps.length;
+			await writeTemplates(dir, templates);
+		});
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "tpl step add", id: templateId, stepCount });
+		} else {
+			printSuccess(`Added step ${stepCount} to ${templateId}: "${title}"`);
+		}
+		return;
+	}
+
+	// sr tpl list
+	if (subcmd === "list") {
+		const templates = await readTemplates(dir);
+		if (jsonMode) {
+			await outputJson({ success: true, command: "tpl list", templates, count: templates.length });
+		} else {
+			if (templates.length === 0) {
+				console.log("No templates.");
+				return;
+			}
+			for (const tpl of templates) {
+				console.log(`${accent.bold(tpl.id)}  ${tpl.name}  ${muted(`(${tpl.steps.length} steps)`)}`);
+			}
+		}
+		return;
+	}
+
+	// sr tpl show <id>
+	if (subcmd === "show") {
+		const templateId = positional[1];
+		if (!templateId) throw new Error("Usage: sr tpl show <id>");
+		const templates = await readTemplates(dir);
+		const tpl = templates.find((t) => t.id === templateId);
+		if (!tpl) throw new Error(`Template not found: ${templateId}`);
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "tpl show", template: tpl });
+		} else {
+			console.log(`${accent.bold(tpl.id)}  ${tpl.name}`);
+			console.log(muted(`Steps (${tpl.steps.length}):`));
+			tpl.steps.forEach((step, i) => {
+				console.log(
+					`  ${i + 1}. ${step.title}  ${muted(`[${step.type ?? "task"} P${step.priority ?? 2}]`)}`,
+				);
+			});
+		}
+		return;
+	}
+
+	// sr tpl pour <id> --prefix "..."
+	if (subcmd === "pour") {
+		const templateId = positional[1];
+		if (!templateId) throw new Error("Usage: sr tpl pour <id> --prefix ...");
+		if (typeof flags.prefix !== "string") throw new Error("--prefix is required");
+		const prefix = flags.prefix;
+
+		const templates = await readTemplates(dir);
+		const tpl = templates.find((t) => t.id === templateId);
+		if (!tpl) throw new Error(`Template not found: ${templateId}`);
+		if (tpl.steps.length === 0) throw new Error(`Template ${templateId} has no steps`);
+
+		const config = await readConfig(dir);
+		const createdIds: string[] = [];
+
+		await withLock(issuesPath(dir), async () => {
+			const existing = await readIssues(dir);
+			const existingIds = new Set(existing.map((i) => i.id));
+			const now = new Date().toISOString();
+
+			// Create all issues first (collect IDs)
+			const newIssues: Issue[] = [];
+			for (const step of tpl.steps) {
+				const id = generateId(
+					config.project,
+					new Set([...existingIds, ...newIssues.map((i) => i.id)]),
+				);
+				const title = step.title.replace(/\{prefix\}/g, prefix);
+				const issue: Issue = {
+					id,
+					title,
+					status: "open",
+					type: (step.type ?? "task") as Issue["type"],
+					priority: step.priority ?? 2,
+					createdAt: now,
+					updatedAt: now,
+					convoy: templateId,
+				};
+				newIssues.push(issue);
+				createdIds.push(id);
+			}
+
+			// Wire dependencies: step[i+1] blocked by step[i]
+			for (let i = 1; i < newIssues.length; i++) {
+				const prev = newIssues[i - 1];
+				const curr = newIssues[i];
+				if (!prev || !curr) continue;
+				curr.blockedBy = [prev.id];
+				prev.blocks = [curr.id];
+			}
+
+			// Append all new issues
+			const allIssues = [...existing, ...newIssues];
+			await writeIssues(dir, allIssues);
+		});
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "tpl pour", ids: createdIds });
+		} else {
+			printSuccess(`Poured template ${accent(templateId)} — created ${createdIds.length} issues`);
+			for (const id of createdIds) console.log(`  ${accent(id)}`);
+		}
+		return;
+	}
+
+	// sr tpl status <id>
+	if (subcmd === "status") {
+		const templateId = positional[1];
+		if (!templateId) throw new Error("Usage: sr tpl status <id>");
+
+		const issues = await readIssues(dir);
+		const convoyIssues = issues.filter((i: Issue) => i.convoy === templateId);
+
+		if (convoyIssues.length === 0) {
+			if (jsonMode) {
+				await outputJson({
+					success: true,
+					command: "tpl status",
+					templateId,
+					total: 0,
+					issues: [],
+				});
+			} else {
+				console.log(`No issues found for convoy ${templateId}`);
+			}
+			return;
+		}
+
+		const closedIds = new Set(issues.filter((i: Issue) => i.status === "closed").map((i) => i.id));
+		const completed = convoyIssues.filter((i) => i.status === "closed").length;
+		const inProgress = convoyIssues.filter((i) => i.status === "in_progress").length;
+		const blocked = convoyIssues.filter((i) => {
+			if (i.status === "closed") return false;
+			return (i.blockedBy ?? []).some((bid) => !closedIds.has(bid));
+		}).length;
+
+		const status = {
+			templateId,
+			total: convoyIssues.length,
+			completed,
+			inProgress,
+			blocked,
+			issues: convoyIssues.map((i) => i.id),
+		};
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "tpl status", status });
+		} else {
+			console.log(`${chalk.bold("Convoy:")} ${accent(templateId)}`);
+			console.log(`  ${muted("Total:")}       ${status.total}`);
+			console.log(`  ${muted("Completed:")}   ${completed}`);
+			console.log(`  ${muted("In progress:")} ${inProgress}`);
+			console.log(`  ${muted("Blocked:")}     ${blocked}`);
+			console.log(muted("  Issues:"));
+			for (const issue of convoyIssues) {
+				process.stdout.write("    ");
+				printIssueOneLine(issue, closedIds);
+			}
+		}
+		return;
+	}
+
+	throw new Error(
+		`Unknown tpl subcommand: ${subcmd}. Use create, step, list, show, pour, or status.`,
+	);
+}
+
+export function register(program: Command): void {
+	const tpl = new Command("tpl").description("Manage issue templates (molecules)");
+
+	tpl
+		.command("create")
+		.description("Create a new template")
+		.requiredOption("--name <text>", "Template name")
+		.option("--json", "Output as JSON")
+		.action(async (opts: { name: string; json?: boolean }) => {
+			const args: string[] = ["create", "--name", opts.name];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	const step = new Command("step").description("Manage template steps");
+	step
+		.command("add <id>")
+		.description("Add a step to a template")
+		.requiredOption("--title <text>", "Step title")
+		.option("--type <type>", "Step type (task|bug|feature|epic)", "task")
+		.option("--priority <n>", "Step priority 0-4", "2")
+		.option("--json", "Output as JSON")
+		.action(
+			async (
+				id: string,
+				opts: { title: string; type?: string; priority?: string; json?: boolean },
+			) => {
+				const args: string[] = ["step", "add", id, "--title", opts.title];
+				if (opts.type) args.push("--type", opts.type);
+				if (opts.priority) args.push("--priority", opts.priority);
+				if (opts.json) args.push("--json");
+				await run(args);
+			},
+		);
+	tpl.addCommand(step);
+
+	tpl
+		.command("list")
+		.description("List all templates")
+		.option("--json", "Output as JSON")
+		.action(async (opts: { json?: boolean }) => {
+			await run(opts.json ? ["list", "--json"] : ["list"]);
+		});
+
+	tpl
+		.command("show <id>")
+		.description("Show template with steps")
+		.option("--json", "Output as JSON")
+		.action(async (id: string, opts: { json?: boolean }) => {
+			const args: string[] = ["show", id];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	tpl
+		.command("pour <id>")
+		.description("Instantiate template into issues")
+		.requiredOption("--prefix <text>", "Prefix for issue titles")
+		.option("--json", "Output as JSON")
+		.action(async (id: string, opts: { prefix: string; json?: boolean }) => {
+			const args: string[] = ["pour", id, "--prefix", opts.prefix];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	tpl
+		.command("status <id>")
+		.description("Show convoy status for a template")
+		.option("--json", "Output as JSON")
+		.action(async (id: string, opts: { json?: boolean }) => {
+			const args: string[] = ["status", id];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	program.addCommand(tpl);
+}

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

@@ -0,0 +1,115 @@
+import type { Command } from "commander";
+import { findSproutDir } from "../config.ts";
+import { accent, muted, outputJson } 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 allFlag = args.includes("--all");
+
+	// Parse --from <blocker-id>
+	const fromIdx = args.indexOf("--from");
+	const blockerId = fromIdx !== -1 ? args[fromIdx + 1] : undefined;
+
+	// Collect positional args (skip flags and their values)
+	const skipNext = new Set<number>();
+	if (fromIdx !== -1) skipNext.add(fromIdx + 1);
+	const positional = args.filter((a, i) => !a.startsWith("--") && !skipNext.has(i));
+
+	const issueId = positional[0];
+	if (!issueId) throw new Error("Usage: sr unblock <id> [--from <blocker-id> | --all]");
+	if (!allFlag && fromIdx === -1) {
+		throw new Error("Usage: sr unblock <id> [--from <blocker-id> | --all]");
+	}
+	if (fromIdx !== -1 && !blockerId) {
+		throw new Error("--from requires a blocker ID");
+	}
+
+	const dir = sproutDir ?? (await findSproutDir());
+	let removed: string[] = [];
+
+	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 currentBlockers = issue.blockedBy ?? [];
+
+		if (allFlag) {
+			const closedIds = new Set(issues.filter((i) => i.status === "closed").map((i) => i.id));
+			removed = currentBlockers.filter((bid) => closedIds.has(bid));
+			const remaining = currentBlockers.filter((bid) => !closedIds.has(bid));
+
+			const updatedIssue: Issue = { ...issue, updatedAt: new Date().toISOString() };
+			if (remaining.length > 0) updatedIssue.blockedBy = remaining;
+			else updatedIssue.blockedBy = undefined;
+			issues[issueIdx] = updatedIssue;
+
+			for (const bid of removed) {
+				const bidIdx = issues.findIndex((i) => i.id === bid);
+				const blocker = issues[bidIdx];
+				if (!blocker) continue;
+				const newBlocks = (blocker.blocks ?? []).filter((id) => id !== issueId);
+				const updatedBlocker: Issue = { ...blocker, updatedAt: new Date().toISOString() };
+				if (newBlocks.length > 0) updatedBlocker.blocks = newBlocks;
+				else updatedBlocker.blocks = undefined;
+				issues[bidIdx] = updatedBlocker;
+			}
+		} else {
+			if (!blockerId) throw new Error("--from requires a blocker ID");
+			if (!currentBlockers.includes(blockerId)) {
+				throw new Error(`${issueId} is not blocked by ${blockerId}`);
+			}
+			removed = [blockerId];
+			const remaining = currentBlockers.filter((bid) => bid !== blockerId);
+
+			const updatedIssue: Issue = { ...issue, updatedAt: new Date().toISOString() };
+			if (remaining.length > 0) updatedIssue.blockedBy = remaining;
+			else updatedIssue.blockedBy = undefined;
+			issues[issueIdx] = updatedIssue;
+
+			const bidIdx = issues.findIndex((i) => i.id === blockerId);
+			const blocker = issues[bidIdx];
+			if (blocker) {
+				const newBlocks = (blocker.blocks ?? []).filter((id) => id !== issueId);
+				const updatedBlocker: Issue = { ...blocker, updatedAt: new Date().toISOString() };
+				if (newBlocks.length > 0) updatedBlocker.blocks = newBlocks;
+				else updatedBlocker.blocks = undefined;
+				issues[bidIdx] = updatedBlocker;
+			}
+		}
+
+		await writeIssues(dir, issues);
+	});
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "unblock", issueId, removed });
+	} else {
+		if (removed.length === 0) {
+			console.log(`${muted("No closed blockers to remove from")} ${accent(issueId)}.`);
+		} else {
+			for (const bid of removed) {
+				console.log(`${accent(issueId)} ${muted("unblocked from")} ${accent(bid)}`);
+			}
+		}
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("unblock")
+		.description("Remove blockers from an issue")
+		.argument("<id>", "Issue ID to unblock")
+		.option("--from <blocker-id>", "Remove a specific blocker")
+		.option("--all", "Remove all closed blockers")
+		.option("--json", "Output as JSON")
+		.action(async (id: string, opts: { from?: string; all?: boolean; json?: boolean }) => {
+			const args: string[] = [id];
+			if (opts.from) args.push("--from", opts.from);
+			if (opts.all) args.push("--all");
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+}