@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,221 @@
+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 } 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[]): {
+	flags: Record<string, string | boolean>;
+	positionals: string[];
+} {
+	const flags: Record<string, string | boolean> = {};
+	const positionals: 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 {
+			positionals.push(arg);
+			i++;
+		}
+	}
+	return { flags, positionals };
+}
+
+function matchesQuery(issue: Issue, needle: string): boolean {
+	const title = issue.title.toLowerCase();
+	if (title.includes(needle)) return true;
+	const desc = issue.description?.toLowerCase() ?? "";
+	return desc.includes(needle);
+}
+
+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: "search", error: fmt.error });
+		} else {
+			console.error(fmt.error);
+		}
+		process.exitCode = 1;
+		return;
+	}
+	const { flags, positionals } = parseArgs(args);
+
+	const query = positionals[0];
+	if (!query) {
+		const msg = "Usage: sr search <query> [filters]";
+		if (jsonMode) {
+			await outputJson({ success: false, command: "search", error: msg });
+		} else {
+			console.error(msg);
+		}
+		process.exitCode = 1;
+		return;
+	}
+	const needle = query.toLowerCase();
+
+	const statusFilter = typeof flags.status === "string" ? flags.status : undefined;
+	let limit: number;
+	try {
+		limit = parseLimitFlag(flags.limit);
+	} catch (e) {
+		const msg = (e as Error).message;
+		if (jsonMode) {
+			await outputJson({ success: false, command: "search", 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);
+	}
+
+	issues = issues.filter((i) => matchesQuery(i, needle));
+	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: "search", 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: "search",
+				query,
+				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 match "${query}".`);
+				return;
+			}
+			for (const issue of issues)
+				console.log(stripAnsi(formatIssueOneLine(issue, closedBlockerIds)));
+			console.log(`\n${issues.length} match(es)`);
+			return;
+		default:
+			if (issues.length === 0) {
+				console.log(`No issues match "${query}".`);
+				return;
+			}
+			for (const issue of issues) printIssueOneLine(issue, closedBlockerIds);
+			console.log(`\n${issues.length} match(es)`);
+			return;
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("search")
+		.description("Full-text search title + description")
+		.argument("<query>", "Case-insensitive substring to match")
+		.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("--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 (
+				query: string,
+				opts: {
+					status?: string;
+					type?: string;
+					assignee?: string;
+					label?: string;
+					labelAny?: string;
+					unlabeled?: boolean;
+					priority?: string;
+					priorityMax?: string;
+					limit?: string;
+					sort?: string;
+					format?: string;
+					json?: boolean;
+				},
+			) => {
+				const args: string[] = [query];
+				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.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/show.ts

@@ -0,0 +1,277 @@
+import type { Command } from "commander";
+import { findSproutDir } from "../config.ts";
+import { resolveFormat, stripAnsi, VALID_FORMATS } from "../format.ts";
+import {
+	accent,
+	brand,
+	formatIssueFull,
+	formatIssueOneLineCompact,
+	muted,
+	outputJson,
+	printIssueFull,
+} from "../output.ts";
+import { loadPlanContext, planForIssue, summarisePlanChildren } from "../plan-context.ts";
+import { readIssues } from "../store.ts";
+import type { Issue } from "../types.ts";
+import { runShow as runPlanShow } from "./plan-show.ts";
+
+const HUMAN_DIVIDER = "─".repeat(60);
+
+function collectPositional(args: string[]): string[] {
+	const ids: string[] = [];
+	let i = 0;
+	while (i < args.length) {
+		const arg = args[i];
+		if (arg === undefined) {
+			i++;
+			continue;
+		}
+		if (arg === "--format") {
+			i += 2;
+			continue;
+		}
+		if (arg.startsWith("--")) {
+			i++;
+			continue;
+		}
+		ids.push(arg);
+		i++;
+	}
+	return ids;
+}
+
+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: "show", error: fmt.error });
+		} else {
+			console.error(fmt.error);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	const ids = collectPositional(args);
+	if (ids.length === 0) throw new Error("Usage: sr show <id> [ids...]");
+
+	const dir = sproutDir ?? (await findSproutDir());
+	const issues = await readIssues(dir);
+
+	if (ids.length === 1) {
+		const id = ids[0];
+		if (id === undefined) throw new Error("Usage: sr show <id> [ids...]");
+		await renderSingle(id, issues, dir, fmt.mode);
+		return;
+	}
+
+	await renderMultiple(ids, issues, dir, fmt.mode);
+}
+
+async function renderSingle(
+	id: string,
+	issues: Issue[],
+	dir: string,
+	mode: ReturnType<typeof resolveFormat>["mode"],
+): Promise<void> {
+	const issue = issues.find((i) => i.id === id);
+	if (!issue) {
+		if (id.startsWith("pl-")) {
+			if (mode !== "markdown" && mode !== "json") {
+				const errMsg = `sr show ${id}: --format ${mode} is not supported for plan ids; pass --json or use 'sr plan show ${id}'`;
+				console.error(errMsg);
+				process.exitCode = 1;
+				return;
+			}
+			await runPlanShow(id, mode === "json");
+			return;
+		}
+		throw new Error(`Issue not found: ${id}`);
+	}
+
+	const planCtx = await loadPlanContext(dir);
+	const plan = planForIssue(planCtx, issue);
+	const planChildren = plan ? summarisePlanChildren(plan, issues) : undefined;
+
+	switch (mode) {
+		case "json": {
+			const out: Record<string, unknown> = { success: true, command: "show", issue };
+			if (plan) {
+				out.plan = {
+					id: plan.id,
+					status: plan.status,
+					revision: plan.revision,
+					template: plan.template,
+					children: plan.children,
+				};
+				out.plan_children = planChildren;
+			}
+			await outputJson(out);
+			return;
+		}
+		case "ids":
+			console.log(issue.id);
+			return;
+		case "compact": {
+			const closedBlockerIds = new Set(
+				issues.filter((i) => i.status === "closed").map((i) => i.id),
+			);
+			console.log(formatIssueOneLineCompact(issue, closedBlockerIds));
+			return;
+		}
+		case "plain":
+			console.log(stripAnsi(formatIssueFull(issue) + renderPlanBlock(plan, planChildren)));
+			return;
+		default:
+			printIssueFull(issue);
+			if (plan) process.stdout.write(renderPlanBlock(plan, planChildren));
+			return;
+	}
+}
+
+interface MultiResult {
+	id: string;
+	issue?: Issue;
+	error?: string;
+}
+
+async function renderMultiple(
+	ids: string[],
+	issues: Issue[],
+	dir: string,
+	mode: ReturnType<typeof resolveFormat>["mode"],
+): Promise<void> {
+	const results: MultiResult[] = ids.map((id) => {
+		const issue = issues.find((i) => i.id === id);
+		if (issue) return { id, issue };
+		if (id.startsWith("pl-")) {
+			return {
+				id,
+				error: `Plan id ${id} not supported in multi-id 'sr show'; run 'sr plan show ${id}' instead`,
+			};
+		}
+		return { id, error: `Issue not found: ${id}` };
+	});
+
+	const found = results.filter((r): r is MultiResult & { issue: Issue } => r.issue !== undefined);
+	const errors = results.filter((r): r is MultiResult & { error: string } => r.error !== undefined);
+	const anyMissing = errors.length > 0;
+
+	switch (mode) {
+		case "json": {
+			const planCtx = await loadPlanContext(dir);
+			const items = found.map((r) => {
+				const plan = planForIssue(planCtx, r.issue);
+				const planChildren = plan ? summarisePlanChildren(plan, issues) : undefined;
+				const item: Record<string, unknown> = { issue: r.issue };
+				if (plan) {
+					item.plan = {
+						id: plan.id,
+						status: plan.status,
+						revision: plan.revision,
+						template: plan.template,
+						children: plan.children,
+					};
+					item.plan_children = planChildren;
+				}
+				return item;
+			});
+			const out: Record<string, unknown> = {
+				success: !anyMissing,
+				command: "show",
+				issues: items.map((i) => i.issue),
+				results: items,
+			};
+			if (errors.length > 0) {
+				out.errors = errors.map((e) => ({ id: e.id, error: e.error }));
+			}
+			await outputJson(out);
+			if (anyMissing) process.exitCode = 1;
+			return;
+		}
+		case "ids": {
+			for (const r of found) console.log(r.issue.id);
+			for (const e of errors) console.error(`✗ ${e.id}: ${e.error}`);
+			if (anyMissing) process.exitCode = 1;
+			return;
+		}
+		case "compact": {
+			const closedBlockerIds = new Set(
+				issues.filter((i) => i.status === "closed").map((i) => i.id),
+			);
+			for (const r of found) {
+				console.log(formatIssueOneLineCompact(r.issue, closedBlockerIds));
+			}
+			for (const e of errors) console.error(`✗ ${e.id}: ${e.error}`);
+			if (anyMissing) process.exitCode = 1;
+			return;
+		}
+		case "plain": {
+			const planCtx = await loadPlanContext(dir);
+			const blocks = found.map((r) => {
+				const plan = planForIssue(planCtx, r.issue);
+				const planChildren = plan ? summarisePlanChildren(plan, issues) : undefined;
+				return stripAnsi(formatIssueFull(r.issue) + renderPlanBlock(plan, planChildren));
+			});
+			console.log(blocks.join("\n\n"));
+			for (const e of errors) console.error(`✗ ${e.id}: ${e.error}`);
+			if (anyMissing) process.exitCode = 1;
+			return;
+		}
+		default: {
+			const planCtx = await loadPlanContext(dir);
+			let first = true;
+			for (const r of found) {
+				if (!first) {
+					process.stdout.write(`\n${muted(HUMAN_DIVIDER)}\n\n`);
+				}
+				first = false;
+				printIssueFull(r.issue);
+				const plan = planForIssue(planCtx, r.issue);
+				if (plan) {
+					const planChildren = summarisePlanChildren(plan, issues);
+					process.stdout.write(renderPlanBlock(plan, planChildren));
+				}
+			}
+			for (const e of errors) console.error(`✗ ${e.id}: ${e.error}`);
+			if (anyMissing) process.exitCode = 1;
+			return;
+		}
+	}
+}
+
+function renderPlanBlock(
+	plan: ReturnType<typeof planForIssue>,
+	children: ReturnType<typeof summarisePlanChildren> | undefined,
+): string {
+	if (!plan) return "";
+	const lines: string[] = [
+		"",
+		`${brand("Plan:")} ${accent(plan.id)}  ${muted(`[${plan.status}]`)}`,
+	];
+	if (plan.status === "draft") {
+		lines.push(`${accent("plan in draft — run sr plan submit")}`);
+	} else if (children && children.length > 0) {
+		lines.push(`${muted(`Plan steps (${children.length}):`)}`);
+		for (const c of children) {
+			const tag = c.adopted ? ` ${muted("(adopted)")}` : "";
+			lines.push(`  ${accent(c.id)}  ${muted(`[${c.status}]`)}  ${c.title}${tag}`);
+		}
+	}
+	return `\n${lines.join("\n")}\n`;
+}
+
+export function register(program: Command): void {
+	program
+		.command("show <id> [ids...]")
+		.description("Show one or more issues")
+		.option("--format <mode>", `Output format (${VALID_FORMATS.join("|")})`)
+		.option("--json", "Output as JSON (alias for --format json)")
+		.action(async (id: string, ids: string[], opts: { format?: string; json?: boolean }) => {
+			const args: string[] = [id, ...ids];
+			if (opts.format) args.push("--format", opts.format);
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+}

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

@@ -0,0 +1,146 @@
+import chalk from "chalk";
+import type { Command } from "commander";
+import { findSproutDir } from "../config.ts";
+import { resolveFormat, stripAnsi, VALID_FORMATS } from "../format.ts";
+import { muted, outputJson } from "../output.ts";
+import { readIssues } from "../store.ts";
+import type { Issue } from "../types.ts";
+import { PRIORITY_LABELS } from "../types.ts";
+
+interface StatsData {
+	total: number;
+	open: number;
+	inProgress: number;
+	closed: number;
+	blocked: number;
+	byType: Record<string, number>;
+	byPriority: Record<number, number>;
+	byLabel: Record<string, number>;
+}
+
+function formatStatsMarkdown(s: StatsData): string {
+	const lines: string[] = [];
+	lines.push(`${chalk.bold("Project Statistics")}`);
+	lines.push(`  ${muted("Total:")}       ${s.total}`);
+	lines.push(`  ${muted("Open:")}        ${s.open}`);
+	lines.push(`  ${muted("In progress:")} ${s.inProgress}`);
+	lines.push(`  ${muted("Closed:")}      ${s.closed}`);
+	lines.push(`  ${muted("Blocked:")}     ${s.blocked}`);
+	lines.push(`\n${chalk.bold("By Type")}`);
+	for (const [type, count] of Object.entries(s.byType)) {
+		lines.push(`  ${muted(type.padEnd(10))} ${count}`);
+	}
+	if (Object.keys(s.byPriority).length > 0) {
+		lines.push(`\n${chalk.bold("By Priority")}`);
+		for (const [p, count] of Object.entries(s.byPriority)) {
+			const label = PRIORITY_LABELS[Number(p)] ?? String(p);
+			lines.push(`  ${muted(`P${p} ${label.padEnd(10)}`)} ${count}`);
+		}
+	}
+	if (Object.keys(s.byLabel).length > 0) {
+		lines.push(`\n${chalk.bold("By Label")}`);
+		for (const [label, count] of Object.entries(s.byLabel).sort((a, b) => b[1] - a[1])) {
+			lines.push(`  ${muted(label.padEnd(15))} ${count}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+function formatStatsCompact(s: StatsData): string {
+	const lines: string[] = [];
+	lines.push(
+		`total=${s.total} open=${s.open} in_progress=${s.inProgress} closed=${s.closed} blocked=${s.blocked}`,
+	);
+	const types = Object.entries(s.byType)
+		.map(([t, c]) => `${t}=${c}`)
+		.join(" ");
+	if (types) lines.push(`by_type: ${types}`);
+	const prios = Object.entries(s.byPriority)
+		.map(([p, c]) => `P${p}=${c}`)
+		.join(" ");
+	if (prios) lines.push(`by_priority: ${prios}`);
+	const labels = Object.entries(s.byLabel)
+		.sort((a, b) => b[1] - a[1])
+		.map(([l, c]) => `${l}=${c}`)
+		.join(" ");
+	if (labels) lines.push(`by_label: ${labels}`);
+	return lines.join("\n");
+}
+
+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: "stats", error: fmt.error });
+		} else {
+			console.error(fmt.error);
+		}
+		process.exitCode = 1;
+		return;
+	}
+	const dir = sproutDir ?? (await findSproutDir());
+	const issues = await readIssues(dir);
+
+	const total = issues.length;
+	const open = issues.filter((i: Issue) => i.status === "open").length;
+	const inProgress = issues.filter((i: Issue) => i.status === "in_progress").length;
+	const closed = issues.filter((i: Issue) => i.status === "closed").length;
+
+	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;
+		return (i.blockedBy ?? []).some((bid) => !closedIds.has(bid));
+	}).length;
+
+	const byType: Record<string, number> = {};
+	for (const issue of issues) {
+		byType[issue.type] = (byType[issue.type] ?? 0) + 1;
+	}
+
+	const byPriority: Record<number, number> = {};
+	for (const issue of issues) {
+		byPriority[issue.priority] = (byPriority[issue.priority] ?? 0) + 1;
+	}
+
+	const byLabel: Record<string, number> = {};
+	for (const issue of issues) {
+		for (const label of issue.labels ?? []) {
+			byLabel[label] = (byLabel[label] ?? 0) + 1;
+		}
+	}
+
+	const data: StatsData = { total, open, inProgress, closed, blocked, byType, byPriority, byLabel };
+
+	switch (fmt.mode) {
+		case "json":
+			await outputJson({ success: true, command: "stats", stats: data });
+			return;
+		case "ids":
+			// Stats has no IDs to emit.
+			return;
+		case "compact":
+			console.log(formatStatsCompact(data));
+			return;
+		case "plain":
+			console.log(stripAnsi(formatStatsMarkdown(data)));
+			return;
+		default:
+			console.log(formatStatsMarkdown(data));
+			return;
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("stats")
+		.description("Project statistics")
+		.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);
+		});
+}