@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,64 @@
+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";
+
+export async function run(args: string[], sproutDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+
+	// Parse --by <blocker-id>
+	const byIdx = args.indexOf("--by");
+	const blockerId = byIdx !== -1 ? args[byIdx + 1] : undefined;
+
+	// Collect positional args (skip flags and their values)
+	const skipNext = new Set<number>();
+	if (byIdx !== -1) skipNext.add(byIdx + 1);
+	const positional = args.filter((a, i) => !a.startsWith("--") && !skipNext.has(i));
+
+	const issueId = positional[0];
+	if (!issueId) throw new Error("Usage: sr block <id> --by <blocker-id>");
+	if (!blockerId) throw new Error("Usage: sr block <id> --by <blocker-id>");
+	if (issueId === blockerId) throw new Error(`Cannot block an issue by itself: ${issueId}`);
+
+	const dir = sproutDir ?? (await findSproutDir());
+
+	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 blockerIdx = issues.findIndex((i) => i.id === blockerId);
+		const blocker = issues[blockerIdx];
+		if (!blocker) throw new Error(`Issue not found: ${blockerId}`);
+
+		const blockedBy = Array.from(new Set([...(issue.blockedBy ?? []), blockerId]));
+		const blocks = Array.from(new Set([...(blocker.blocks ?? []), issueId]));
+
+		issues[issueIdx] = { ...issue, blockedBy, updatedAt: new Date().toISOString() };
+		issues[blockerIdx] = { ...blocker, blocks, updatedAt: new Date().toISOString() };
+
+		await writeIssues(dir, issues);
+	});
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "block", issueId, blockerId });
+	} else {
+		console.log(`${accent(issueId)} ${muted("is now blocked by")} ${accent(blockerId)}`);
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("block")
+		.description("Add a blocker to an issue")
+		.argument("<id>", "Issue ID to block")
+		.option("--by <blocker-id>", "Issue that blocks this issue")
+		.option("--json", "Output as JSON")
+		.action(async (id: string, opts: { by?: string; json?: boolean }) => {
+			const args: string[] = [id];
+			if (opts.by) args.push("--by", opts.by);
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+}

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

@@ -0,0 +1,86 @@
+import type { Command } from "commander";
+import { findSproutDir } from "../config.ts";
+import { resolveFormat, stripAnsi, VALID_FORMATS } from "../format.ts";
+import {
+	formatIssueOneLine,
+	formatIssueOneLineCompact,
+	outputJson,
+	printIssueOneLine,
+} from "../output.ts";
+import { issueJsonWithPlan, loadPlanContext, planForIssue } from "../plan-context.ts";
+import { readIssues } from "../store.ts";
+import type { Issue } from "../types.ts";
+
+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: "blocked", error: fmt.error });
+		} else {
+			console.error(fmt.error);
+		}
+		process.exitCode = 1;
+		return;
+	}
+	const dir = sproutDir ?? (await findSproutDir());
+	const issues = await readIssues(dir);
+	const planCtx = await loadPlanContext(dir);
+
+	const closedIds = new Set(issues.filter((i: Issue) => i.status === "closed").map((i) => i.id));
+
+	const blocked = issues.filter((i: Issue) => {
+		if (i.status === "closed") return false;
+		const blockers = i.blockedBy ?? [];
+		return blockers.some((bid) => !closedIds.has(bid));
+	});
+
+	switch (fmt.mode) {
+		case "json": {
+			const issuesWithPlan = blocked.map((i) => issueJsonWithPlan(i, planForIssue(planCtx, i)));
+			await outputJson({
+				success: true,
+				command: "blocked",
+				issues: issuesWithPlan,
+				count: blocked.length,
+			});
+			return;
+		}
+		case "ids":
+			for (const issue of blocked) console.log(issue.id);
+			return;
+		case "compact":
+			for (const issue of blocked) console.log(formatIssueOneLineCompact(issue, closedIds));
+			return;
+		case "plain":
+			if (blocked.length === 0) {
+				console.log("No blocked issues.");
+				return;
+			}
+			for (const issue of blocked) console.log(stripAnsi(formatIssueOneLine(issue, closedIds)));
+			console.log(`\n${blocked.length} blocked issue(s)`);
+			return;
+		default:
+			if (blocked.length === 0) {
+				console.log("No blocked issues.");
+				return;
+			}
+			for (const issue of blocked) printIssueOneLine(issue, closedIds);
+			console.log(`\n${blocked.length} blocked issue(s)`);
+			return;
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("blocked")
+		.description("Show all blocked issues")
+		.option("--format <mode>", `Output format (${VALID_FORMATS.join("|")})`)
+		.option("--json", "Output as JSON (alias for --format json)")
+		.action(async (opts: { format?: string; json?: boolean }) => {
+			const args: string[] = [];
+			if (opts.format) args.push("--format", opts.format);
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+}

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

@@ -0,0 +1,129 @@
+import type { Command } from "commander";
+import { findSproutDir } from "../config.ts";
+import { outputJson, printSuccess } from "../output.ts";
+import { affectedPlanIds, applyPlanTransitions } from "../plan-lifecycle.ts";
+import {
+	issuesPath,
+	plansPath,
+	readIssues,
+	readPlans,
+	withLock,
+	writeIssues,
+	writePlans,
+} from "../store.ts";
+import type { Issue } 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);
+
+	if (positional.length === 0) throw new Error("Usage: sr close <id> [ids...] [--reason text]");
+
+	const reason = typeof flags.reason === "string" ? flags.reason : undefined;
+	const ids = positional;
+
+	const dir = sproutDir ?? (await findSproutDir());
+	const closed: string[] = [];
+
+	// Lock order matches plan-submit: plans (outer) → issues (inner) so plan
+	// lifecycle transitions stay atomic with the close write.
+	await withLock(plansPath(dir), () =>
+		withLock(issuesPath(dir), async () => {
+			const issues = await readIssues(dir);
+			const now = new Date().toISOString();
+
+			for (const id of ids) {
+				const idx = issues.findIndex((i) => i.id === id);
+				const issue = issues[idx];
+				if (!issue) throw new Error(`Issue not found: ${id}`);
+				const updated: Issue = {
+					...issue,
+					status: "closed",
+					closedAt: now,
+					updatedAt: now,
+					...(reason ? { closeReason: reason } : {}),
+				};
+				issues[idx] = updated;
+				closed.push(id);
+
+				// Clean up blockedBy on issues this one blocks
+				const blockedIssueIds = issue.blocks ?? [];
+				for (const blockedId of blockedIssueIds) {
+					const blockedIdx = issues.findIndex((i) => i.id === blockedId);
+					const blockedIssue = issues[blockedIdx];
+					if (!blockedIssue) continue;
+					const remaining = (blockedIssue.blockedBy ?? []).filter((bid) => bid !== id);
+					issues[blockedIdx] = {
+						...blockedIssue,
+						blockedBy: remaining.length > 0 ? remaining : undefined,
+						updatedAt: now,
+					};
+				}
+			}
+			await writeIssues(dir, issues);
+
+			const plans = await readPlans(dir);
+			const affected = affectedPlanIds(plans, ids);
+			if (affected.length > 0) {
+				const changedCount = applyPlanTransitions(plans, issues, affected, now);
+				if (changedCount > 0) await writePlans(dir, plans);
+			}
+		}),
+	);
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "close", closed });
+	} else {
+		for (const id of closed) {
+			printSuccess(`Closed ${id}${reason ? ` — ${reason}` : ""}`);
+		}
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("close <id> [ids...]")
+		.description("Close one or more issues")
+		.option("--reason <text>", "Close reason")
+		.option("--json", "Output as JSON")
+		.action(async (id: string, ids: string[], opts: { reason?: string; json?: boolean }) => {
+			const args: string[] = [id, ...ids];
+			if (opts.reason) args.push("--reason", opts.reason);
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+}

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

@@ -0,0 +1,198 @@
+import type { Command } from "commander";
+
+const SUPPORTED_SHELLS = ["bash", "zsh", "fish"] as const;
+type Shell = (typeof SUPPORTED_SHELLS)[number];
+
+interface CmdInfo {
+	name: string;
+	description: string;
+	options: { flags: string; description: string }[];
+	subcommands: { name: string; description: string }[];
+}
+
+function collectCommands(program: Command): CmdInfo[] {
+	const result: CmdInfo[] = [];
+	for (const cmd of program.commands) {
+		const info: CmdInfo = {
+			name: cmd.name(),
+			description: cmd.description(),
+			options: cmd.options.map((o) => ({
+				flags: o.long ?? o.short ?? o.flags,
+				description: o.description,
+			})),
+			subcommands: [],
+		};
+		for (const sub of cmd.commands) {
+			info.subcommands.push({
+				name: sub.name(),
+				description: sub.description(),
+			});
+		}
+		result.push(info);
+	}
+	return result;
+}
+
+function generateBash(program: Command): string {
+	const cmds = collectCommands(program);
+	const cmdNames = cmds.map((c) => c.name).join(" ");
+
+	const subcaseBranches: string[] = [];
+	for (const cmd of cmds) {
+		if (cmd.subcommands.length > 0) {
+			const subNames = cmd.subcommands.map((s) => s.name).join(" ");
+			subcaseBranches.push(
+				`        ${cmd.name})\n            COMPREPLY=( $(compgen -W "${subNames}" -- "$cur") )\n            return 0\n            ;;`,
+			);
+		}
+		if (cmd.options.length > 0) {
+			const optFlags = cmd.options.map((o) => o.flags).join(" ");
+			subcaseBranches.push(
+				`        ${cmd.name})\n            COMPREPLY=( $(compgen -W "${optFlags}" -- "$cur") )\n            return 0\n            ;;`,
+			);
+		}
+	}
+
+	const caseBlock =
+		subcaseBranches.length > 0
+			? `    case "\${COMP_WORDS[1]}" in\n${subcaseBranches.join("\n")}\n    esac`
+			: "";
+
+	return `# bash completion for sr
+_sr_completions() {
+    local cur prev
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+    if [[ \${COMP_CWORD} -eq 1 ]]; then
+        COMPREPLY=( $(compgen -W "${cmdNames}" -- "$cur") )
+        return 0
+    fi
+
+${caseBlock}
+}
+
+complete -F _sr_completions sr
+`;
+}
+
+function generateZsh(program: Command): string {
+	const cmds = collectCommands(program);
+
+	const cmdDescLines = cmds.map(
+		(c) => `        '${c.name}:${c.description.replace(/'/g, "'\\''")}'`,
+	);
+
+	const subcmdFunctions: string[] = [];
+	for (const cmd of cmds) {
+		const parts: string[] = [];
+		for (const o of cmd.options) {
+			parts.push(
+				`        '${o.flags}[${o.description.replace(/'/g, "'\\''").replace(/\[/g, "\\[").replace(/\]/g, "\\]")}]'`,
+			);
+		}
+		if (cmd.subcommands.length > 0) {
+			const subDescs = cmd.subcommands.map(
+				(s) => `            '${s.name}:${s.description.replace(/'/g, "'\\''")}'`,
+			);
+			parts.push(`        '1:subcommand:(('\n${subDescs.join("\n")}\n        ))'`);
+		}
+		if (parts.length > 0) {
+			subcmdFunctions.push(
+				`    ${cmd.name})\n        _arguments -s \\\n${parts.join(" \\\n")}\n        ;;`,
+			);
+		}
+	}
+
+	const subcmdCase =
+		subcmdFunctions.length > 0
+			? `    case "$words[1]" in\n${subcmdFunctions.join("\n")}\n    esac`
+			: "";
+
+	return `#compdef sr
+
+_sd() {
+    local -a commands
+    commands=(
+${cmdDescLines.join("\n")}
+    )
+
+    _arguments -s \\
+        '1:command:_describe "command" commands' \\
+        '*::arg:->args'
+
+    case "$state" in
+    args)
+${subcmdCase}
+        ;;
+    esac
+}
+
+_sd "$@"
+`;
+}
+
+function generateFish(program: Command): string {
+	const cmds = collectCommands(program);
+	const lines: string[] = ["# fish completions for sr"];
+
+	// Disable file completions for sr
+	lines.push("complete -c sr -f");
+	lines.push("");
+
+	// Top-level commands
+	const cmdNames = cmds.map((c) => c.name);
+	const noSubcmdCond = cmdNames.map((n) => `__fish_seen_subcommand_from ${n}`).join("; or ");
+
+	for (const cmd of cmds) {
+		lines.push(
+			`complete -c sr -n "not ${noSubcmdCond}" -a ${cmd.name} -d '${cmd.description.replace(/'/g, "\\'")}'`,
+		);
+	}
+
+	lines.push("");
+
+	// Subcommands and options
+	for (const cmd of cmds) {
+		for (const sub of cmd.subcommands) {
+			lines.push(
+				`complete -c sr -n "__fish_seen_subcommand_from ${cmd.name}" -a ${sub.name} -d '${sub.description.replace(/'/g, "\\'")}'`,
+			);
+		}
+		for (const o of cmd.options) {
+			const flag = o.flags.replace(/^--?/, "");
+			const longFlag = o.flags.startsWith("--") ? `-l ${flag}` : `-s ${flag}`;
+			lines.push(
+				`complete -c sr -n "__fish_seen_subcommand_from ${cmd.name}" ${longFlag} -d '${o.description.replace(/'/g, "\\'")}'`,
+			);
+		}
+	}
+
+	lines.push("");
+	return lines.join("\n");
+}
+
+export function register(program: Command): void {
+	program
+		.command("completions")
+		.argument("<shell>", `Shell type (${SUPPORTED_SHELLS.join(", ")})`)
+		.description("Output shell completion script")
+		.action((shell: string) => {
+			if (!SUPPORTED_SHELLS.includes(shell as Shell)) {
+				console.error(`Unknown shell: ${shell}. Supported: ${SUPPORTED_SHELLS.join(", ")}`);
+				process.exitCode = 1;
+				return;
+			}
+			switch (shell as Shell) {
+				case "bash":
+					console.log(generateBash(program));
+					break;
+				case "zsh":
+					console.log(generateZsh(program));
+					break;
+				case "fish":
+					console.log(generateFish(program));
+					break;
+			}
+		});
+}