@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,83 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import type { Command } from "commander";
+import { outputJson, printSuccess } from "../output.ts";
+import {
+	CONFIG_FILE,
+	DEFAULT_MAX_PLAN_DEPTH,
+	ISSUES_FILE,
+	PLANS_FILE,
+	SPROUT_DIR_NAME,
+	TEMPLATES_FILE,
+} from "../types.ts";
+
+const MERGE_UNION_LINES = [
+	".sprout/issues.jsonl merge=union",
+	".sprout/templates.jsonl merge=union",
+	".sprout/plans.jsonl merge=union",
+];
+
+function ensureGitattributes(cwd: string): void {
+	const gitattrsPath = join(cwd, ".gitattributes");
+	if (existsSync(gitattrsPath)) {
+		const existing = readFileSync(gitattrsPath, "utf8");
+		const missing = MERGE_UNION_LINES.filter((line) => !existing.includes(line));
+		if (missing.length === 0) return;
+		const sep = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+		writeFileSync(gitattrsPath, `${existing}${sep}${missing.join("\n")}\n`);
+	} else {
+		writeFileSync(gitattrsPath, `${MERGE_UNION_LINES.join("\n")}\n`);
+	}
+}
+
+export async function run(args: string[]): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const cwd = process.cwd();
+	const sproutDir = join(cwd, SPROUT_DIR_NAME);
+
+	if (existsSync(join(sproutDir, CONFIG_FILE))) {
+		// Re-run still backfills any missing merge=union lines per-file.
+		ensureGitattributes(cwd);
+		if (jsonMode) {
+			await outputJson({ success: true, command: "init", dir: sproutDir });
+		} else {
+			printSuccess(`Already initialized: ${sproutDir}`);
+		}
+		return;
+	}
+
+	mkdirSync(sproutDir, { recursive: true });
+
+	// config.yaml — derive project name from directory
+	const projectName = basename(cwd);
+	writeFileSync(
+		join(sproutDir, CONFIG_FILE),
+		`project: "${projectName}"\nversion: "1"\nmax_plan_depth: ${DEFAULT_MAX_PLAN_DEPTH}\n`,
+	);
+
+	// empty JSONL files
+	writeFileSync(join(sproutDir, ISSUES_FILE), "");
+	writeFileSync(join(sproutDir, TEMPLATES_FILE), "");
+	writeFileSync(join(sproutDir, PLANS_FILE), "");
+
+	// .gitignore inside .sprout/
+	writeFileSync(join(sproutDir, ".gitignore"), "*.lock\n");
+
+	ensureGitattributes(cwd);
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "init", dir: sproutDir });
+	} else {
+		printSuccess(`Initialized .sprout/ in ${cwd}`);
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("init")
+		.description("Initialize .sprout/ in current directory")
+		.option("--json", "Output as JSON")
+		.action(async (opts: { json?: boolean }) => {
+			await run(opts.json ? ["--json"] : []);
+		});
+}

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

@@ -0,0 +1,178 @@
+import { Command } from "commander";
+import { findSproutDir } from "../config.ts";
+import { accent, muted, outputJson, printSuccess } from "../output.ts";
+import { issuesPath, readIssues, withLock, writeIssues } from "../store.ts";
+
+// Exported so plan submit/adopt paths can reuse the same normalization
+// (lowercase, trim, drop empties) when applying step.labels to spawned/
+// adopted children (sprout-745e / sprout-bac9 under pl-e5a8).
+export function normalizeLabels(raw: string[]): string[] {
+	return raw.map((l) => l.trim().toLowerCase()).filter(Boolean);
+}
+
+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 label <add|remove|list|list-all>");
+
+	const dir = sproutDir ?? (await findSproutDir());
+
+	if (subcmd === "list-all") {
+		const issues = await readIssues(dir);
+		const counts: Record<string, number> = {};
+		for (const issue of issues) {
+			for (const label of issue.labels ?? []) {
+				counts[label] = (counts[label] ?? 0) + 1;
+			}
+		}
+		const labels = Object.keys(counts).sort();
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "label list-all", labels, counts });
+		} else {
+			if (labels.length === 0) {
+				console.log("No labels found.");
+				return;
+			}
+			for (const label of labels) {
+				console.log(`  ${accent(label.padEnd(20))} ${muted(String(counts[label]))}`);
+			}
+			console.log(`\n${labels.length} label(s)`);
+		}
+		return;
+	}
+
+	if (subcmd === "list") {
+		const issueId = positional[1];
+		if (!issueId) throw new Error("Usage: sr label 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 labels = issue.labels ?? [];
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "label list", issueId, labels });
+		} else {
+			if (labels.length === 0) {
+				console.log(`${accent.bold(issueId)} has no labels.`);
+			} else {
+				console.log(`${accent.bold(issueId)} ${muted("labels:")}`);
+				for (const label of labels) {
+					console.log(`  ${accent(label)}`);
+				}
+			}
+		}
+		return;
+	}
+
+	if (subcmd === "add") {
+		const issueId = positional[1];
+		const rawLabels = positional.slice(2);
+		if (!issueId || rawLabels.length === 0) {
+			throw new Error("Usage: sr label add <issue> <label> [<label2> ...]");
+		}
+		const newLabels = normalizeLabels(rawLabels);
+		if (newLabels.length === 0) throw new Error("No valid labels provided");
+
+		await withLock(issuesPath(dir), async () => {
+			const issues = await readIssues(dir);
+			const idx = issues.findIndex((i) => i.id === issueId);
+			const issue = issues[idx];
+			if (!issue) throw new Error(`Issue not found: ${issueId}`);
+
+			const merged = Array.from(new Set([...(issue.labels ?? []), ...newLabels]));
+			issues[idx] = { ...issue, labels: merged, updatedAt: new Date().toISOString() };
+			await writeIssues(dir, issues);
+		});
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "label add", issueId, labels: newLabels });
+		} else {
+			printSuccess(
+				`Added label(s) ${newLabels.map((l) => accent(l)).join(", ")} to ${accent(issueId)}`,
+			);
+		}
+		return;
+	}
+
+	if (subcmd === "remove") {
+		const issueId = positional[1];
+		const rawLabels = positional.slice(2);
+		if (!issueId || rawLabels.length === 0) {
+			throw new Error("Usage: sr label remove <issue> <label> [<label2> ...]");
+		}
+		const removeSet = new Set(normalizeLabels(rawLabels));
+
+		await withLock(issuesPath(dir), async () => {
+			const issues = await readIssues(dir);
+			const idx = issues.findIndex((i) => i.id === issueId);
+			const issue = issues[idx];
+			if (!issue) throw new Error(`Issue not found: ${issueId}`);
+
+			const remaining = (issue.labels ?? []).filter((l) => !removeSet.has(l));
+			const updated: typeof issue = { ...issue, updatedAt: new Date().toISOString() };
+			if (remaining.length > 0) updated.labels = remaining;
+			else updated.labels = undefined;
+			issues[idx] = updated;
+			await writeIssues(dir, issues);
+		});
+
+		if (jsonMode) {
+			await outputJson({ success: true, command: "label remove", issueId, labels: [...removeSet] });
+		} else {
+			printSuccess(`Removed label(s) from ${accent(issueId)}`);
+		}
+		return;
+	}
+
+	throw new Error(`Unknown label subcommand: ${subcmd}. Use add, remove, list, or list-all.`);
+}
+
+export function register(program: Command): void {
+	const label = new Command("label").description("Manage issue labels");
+
+	label
+		.command("add <issue> <labels...>")
+		.description("Add labels to an issue")
+		.option("--json", "Output as JSON")
+		.action(async (issue: string, labels: string[], opts: { json?: boolean }) => {
+			const args: string[] = ["add", issue, ...labels];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	label
+		.command("remove <issue> <labels...>")
+		.description("Remove labels from an issue")
+		.option("--json", "Output as JSON")
+		.action(async (issue: string, labels: string[], opts: { json?: boolean }) => {
+			const args: string[] = ["remove", issue, ...labels];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	label
+		.command("list <issue>")
+		.description("List labels on 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);
+		});
+
+	label
+		.command("list-all")
+		.description("List all labels used in the project")
+		.option("--json", "Output as JSON")
+		.action(async (opts: { json?: boolean }) => {
+			const args: string[] = ["list-all"];
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+
+	program.addCommand(label);
+}

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

@@ -0,0 +1,210 @@
+import type { Command } from "commander";
+import { findSproutDir } from "../config.ts";
+import { applyIssueFilters, filterOptionsFromFlags, parseLimitFlag } from "../filter.ts";
+import { resolveFormat, stripAnsi, VALID_FORMATS } from "../format.ts";
+import {
+	formatIssueOneLine,
+	formatIssueOneLineCompact,
+	outputJson,
+	printIssueOneLine,
+} from "../output.ts";
+import {
+	issueJsonWithPlan,
+	loadPlanContext,
+	planForIssue,
+	planLineSuffix,
+} from "../plan-context.ts";
+import { isSortMode, sortIssues, VALID_SORT_MODES } from "../sort.ts";
+import { readIssues } from "../store.ts";
+import type { Issue } 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;
+}
+
+export async function run(args: string[], sproutDir?: string): Promise<void> {
+	const fmt = resolveFormat(args);
+	const jsonMode = fmt.mode === "json";
+	if (fmt.error) {
+		if (jsonMode) {
+			await outputJson({ success: false, command: "list", error: fmt.error });
+		} else {
+			console.error(fmt.error);
+		}
+		process.exitCode = 1;
+		return;
+	}
+	const flags = parseArgs(args);
+
+	const statusFilter = typeof flags.status === "string" ? flags.status : undefined;
+	const showAll = flags.all === true;
+	let limit: number;
+	try {
+		limit = parseLimitFlag(flags.limit);
+	} catch (e) {
+		const msg = (e as Error).message;
+		if (jsonMode) {
+			await outputJson({ success: false, command: "list", error: msg });
+		} else {
+			console.error(msg);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	const dir = sproutDir ?? (await findSproutDir());
+	const allIssues = await readIssues(dir);
+	const closedBlockerIds = new Set(
+		allIssues.filter((i: Issue) => i.status === "closed").map((i) => i.id),
+	);
+	let issues = allIssues;
+	const planCtx = await loadPlanContext(dir);
+
+	if (statusFilter) {
+		issues = issues.filter((i: Issue) => i.status === statusFilter);
+	} else if (!showAll) {
+		issues = issues.filter((i: Issue) => i.status !== "closed");
+	}
+	issues = applyIssueFilters(issues, filterOptionsFromFlags(flags));
+
+	const sortFlag = typeof flags.sort === "string" ? flags.sort : "priority";
+	if (!isSortMode(sortFlag)) {
+		const msg = `Invalid --sort value: ${sortFlag}. Valid: ${VALID_SORT_MODES.join("|")}`;
+		if (jsonMode) {
+			await outputJson({ success: false, command: "list", error: msg });
+		} else {
+			console.error(msg);
+		}
+		process.exitCode = 1;
+		return;
+	}
+	issues = sortIssues(issues, sortFlag);
+
+	issues = issues.slice(0, limit);
+
+	switch (fmt.mode) {
+		case "json": {
+			const issuesWithPlan = issues.map((i) => issueJsonWithPlan(i, planForIssue(planCtx, i)));
+			await outputJson({
+				success: true,
+				command: "list",
+				issues: issuesWithPlan,
+				count: issues.length,
+			});
+			return;
+		}
+		case "ids":
+			for (const issue of issues) console.log(issue.id);
+			return;
+		case "compact":
+			for (const issue of issues) console.log(formatIssueOneLineCompact(issue, closedBlockerIds));
+			return;
+		case "plain":
+			if (issues.length === 0) {
+				console.log("No issues found.");
+				return;
+			}
+			for (const issue of issues) {
+				const plan = planForIssue(planCtx, issue);
+				console.log(stripAnsi(formatIssueOneLine(issue, closedBlockerIds) + planLineSuffix(plan)));
+			}
+			console.log(`\n${issues.length} issue(s)`);
+			return;
+		default:
+			if (issues.length === 0) {
+				console.log("No issues found.");
+				return;
+			}
+			for (const issue of issues) {
+				const plan = planForIssue(planCtx, issue);
+				const suffix = planLineSuffix(plan);
+				if (suffix) {
+					process.stdout.write(`${formatIssueOneLine(issue, closedBlockerIds)}${suffix}\n`);
+				} else {
+					printIssueOneLine(issue, closedBlockerIds);
+				}
+			}
+			console.log(`\n${issues.length} issue(s)`);
+			return;
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("list")
+		.description("List issues with filters")
+		.option("--status <status>", "Filter by status (open|in_progress|closed)")
+		.option("--type <type>", "Filter by type (task|bug|feature|epic)")
+		.option("--assignee <name>", "Filter by assignee")
+		.option("--all", "Include closed issues (default: only open/in_progress)")
+		.option("--label <labels>", "Filter: must have ALL labels (comma-separated, AND)")
+		.option("--label-any <labels>", "Filter: must have any label (comma-separated, OR)")
+		.option("--unlabeled", "Filter: issues with no labels")
+		.option("--priority <levels>", "Filter by priority (comma-separated, e.g. 0,1 or P0,P1)")
+		.option("--priority-max <n>", "Filter to priority <= n (e.g. --priority-max 1 = P0+P1)")
+		.option("--limit <n>", "Max issues to show", "50")
+		.option("--sort <mode>", "Sort order (priority|created|updated|id)", "priority")
+		.option("--format <mode>", `Output format (${VALID_FORMATS.join("|")})`)
+		.option("--json", "Output as JSON (alias for --format json)")
+		.action(
+			async (opts: {
+				status?: string;
+				type?: string;
+				assignee?: string;
+				label?: string;
+				labelAny?: string;
+				unlabeled?: boolean;
+				priority?: string;
+				priorityMax?: string;
+				all?: boolean;
+				limit?: string;
+				sort?: string;
+				format?: string;
+				json?: boolean;
+			}) => {
+				const args: string[] = [];
+				if (opts.status) args.push("--status", opts.status);
+				if (opts.type) args.push("--type", opts.type);
+				if (opts.assignee) args.push("--assignee", opts.assignee);
+				if (opts.label) args.push("--label", opts.label);
+				if (opts.labelAny) args.push("--label-any", opts.labelAny);
+				if (opts.unlabeled) args.push("--unlabeled");
+				if (opts.priority) args.push("--priority", opts.priority);
+				if (opts.priorityMax) args.push("--priority-max", opts.priorityMax);
+				if (opts.all) args.push("--all");
+				if (opts.limit) args.push("--limit", opts.limit);
+				if (opts.sort) args.push("--sort", opts.sort);
+				if (opts.format) args.push("--format", opts.format);
+				if (opts.json) args.push("--json");
+				await run(args);
+			},
+		);
+}

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

@@ -0,0 +1,133 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { Command } from "commander";
+import { findSproutDir, projectRootFromSproutDir } from "../config.ts";
+import { outputJson } from "../output.ts";
+import { issuesPath, readIssues, withLock, writeIssues } from "../store.ts";
+import type { Issue } from "../types.ts";
+
+interface BeadsIssue {
+	id?: string;
+	title?: string;
+	status?: string;
+	issue_type?: string;
+	type?: string;
+	priority?: number;
+	owner?: string;
+	assignee?: string;
+	description?: string;
+	close_reason?: string;
+	closeReason?: string;
+	blocks?: string[];
+	blocked_by?: string[];
+	blockedBy?: string[];
+	created_at?: string;
+	createdAt?: string;
+	updated_at?: string;
+	updatedAt?: string;
+	closed_at?: string;
+	closedAt?: string;
+}
+
+function mapStatus(s: string | undefined): Issue["status"] {
+	if (s === "in_progress" || s === "in-progress") return "in_progress";
+	if (s === "closed" || s === "done" || s === "complete") return "closed";
+	return "open";
+}
+
+function mapType(t: string | undefined): Issue["type"] {
+	if (t === "bug") return "bug";
+	if (t === "feature") return "feature";
+	if (t === "epic") return "epic";
+	return "task";
+}
+
+function mapBeadsIssue(b: BeadsIssue): Issue | null {
+	if (!b.id || !b.title) return null;
+	const now = new Date().toISOString();
+	const issue: Issue = {
+		id: b.id,
+		title: b.title,
+		status: mapStatus(b.status),
+		type: mapType(b.issue_type ?? b.type),
+		priority: b.priority ?? 2,
+		createdAt: b.created_at ?? b.createdAt ?? now,
+		updatedAt: b.updated_at ?? b.updatedAt ?? now,
+	};
+	const assignee = b.owner ?? b.assignee;
+	if (assignee) issue.assignee = assignee;
+	if (b.description) issue.description = b.description;
+	const closeReason = b.close_reason ?? b.closeReason;
+	if (closeReason) issue.closeReason = closeReason;
+	const blockedBy = b.blocked_by ?? b.blockedBy;
+	if (blockedBy?.length) issue.blockedBy = blockedBy;
+	if (b.blocks?.length) issue.blocks = b.blocks;
+	const closedAt = b.closed_at ?? b.closedAt;
+	if (closedAt) issue.closedAt = closedAt;
+	return issue;
+}
+
+export async function run(args: string[], sproutDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const dir = sproutDir ?? (await findSproutDir());
+	const projectRoot = projectRootFromSproutDir(dir);
+
+	const beadsPath = join(projectRoot, ".beads", "issues.jsonl");
+	if (!existsSync(beadsPath)) {
+		throw new Error(`Beads issues not found at: ${beadsPath}`);
+	}
+
+	const file = Bun.file(beadsPath);
+	const content = await file.text();
+	const lines = content.split("\n").filter((l) => l.trim());
+
+	const beadsIssues: BeadsIssue[] = [];
+	for (const line of lines) {
+		try {
+			beadsIssues.push(JSON.parse(line) as BeadsIssue);
+		} catch {
+			// skip malformed lines
+		}
+	}
+
+	const mapped: Issue[] = [];
+	const skipped: string[] = [];
+	for (const b of beadsIssues) {
+		const issue = mapBeadsIssue(b);
+		if (issue) mapped.push(issue);
+		else skipped.push(b.id ?? "(unknown)");
+	}
+
+	let written = 0;
+	await withLock(issuesPath(dir), async () => {
+		const existing = await readIssues(dir);
+		const existingIds = new Set(existing.map((i) => i.id));
+		const newIssues = mapped.filter((i) => !existingIds.has(i.id));
+		await writeIssues(dir, [...existing, ...newIssues]);
+		written = newIssues.length;
+	});
+
+	if (jsonMode) {
+		await outputJson({
+			success: true,
+			command: "migrate-from-beads",
+			written,
+			skipped: skipped.length,
+		});
+	} else {
+		console.log(`Migrated ${written} issues from beads.`);
+		if (skipped.length > 0) {
+			console.log(`Skipped ${skipped.length} malformed issues.`);
+		}
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("migrate-from-beads")
+		.description("Migrate issues from beads issue tracker")
+		.option("--json", "Output as JSON")
+		.action(async (opts: { json?: boolean }) => {
+			await run(opts.json ? ["--json"] : []);
+		});
+}