@ag-eco/agentplate-cli 0.13.0

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

@@ -0,0 +1,257 @@
+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";
+import { VALID_STATUSES, 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): number {
+	if (val.toUpperCase().startsWith("P")) return Number.parseInt(val.slice(1), 10);
+	return Number.parseInt(val, 10);
+}
+
+// Accept only a JSON object literal (not array, scalar, or null) — extensions
+// is a Record<string, unknown> by contract. See plan pl-c195 risk #5.
+function parseExtensionsPatch(raw: string): Record<string, unknown> {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		throw new Error(`--extensions must be valid JSON: ${msg}`);
+	}
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+		throw new Error("--extensions must be a JSON object (not array, null, or scalar)");
+	}
+	return parsed as Record<string, unknown>;
+}
+
+export async function run(args: string[], sproutDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const id = args.find((a) => !a.startsWith("--"));
+	if (!id) throw new Error("Usage: sr update <id> [flags]");
+
+	const flags = parseArgs(args);
+
+	const dir = sproutDir ?? (await findSproutDir());
+	let updated: Issue | undefined;
+
+	const statusChanging = typeof flags.status === "string";
+	const inner = async () => {
+		const issues = await readIssues(dir);
+		const idx = issues.findIndex((i) => i.id === id);
+		const issue = issues[idx];
+		if (!issue) throw new Error(`Issue not found: ${id}`);
+		const now = new Date().toISOString();
+		const patch: Partial<Issue> = { updatedAt: now };
+
+		if (typeof flags.status === "string") {
+			const s = flags.status;
+			if (!(VALID_STATUSES as readonly string[]).includes(s)) {
+				throw new Error(`--status must be one of: ${VALID_STATUSES.join(", ")}`);
+			}
+			patch.status = s as Issue["status"];
+			// Reopening (status moving away from "closed"): drop stale close metadata
+			// so `sr show` doesn't display a phantom closedAt/closeReason on an open
+			// issue. JSON.stringify omits keys with `undefined` values, so the spread
+			// `{...issue, ...patch}` followed by writeIssues clears them on disk.
+			if (patch.status !== "closed") {
+				patch.closedAt = undefined;
+				patch.closeReason = undefined;
+			}
+		}
+		if (typeof flags.title === "string") {
+			if (flags.title.trim() === "") {
+				throw new Error("--title must not be empty");
+			}
+			patch.title = flags.title;
+		}
+		if (typeof flags.assignee === "string") patch.assignee = flags.assignee;
+		const desc =
+			typeof flags.description === "string"
+				? flags.description
+				: typeof flags.desc === "string"
+					? flags.desc
+					: flags.body;
+		if (typeof desc === "string") patch.description = desc;
+		if (typeof flags.type === "string") {
+			const t = flags.type;
+			if (!(VALID_TYPES as readonly string[]).includes(t)) {
+				throw new Error(`--type must be one of: ${VALID_TYPES.join(", ")}`);
+			}
+			patch.type = t as Issue["type"];
+		}
+		if (typeof flags.priority === "string") {
+			const p = parsePriority(flags.priority);
+			if (Number.isNaN(p) || p < 0 || p > 4) throw new Error("--priority must be 0-4 or P0-P4");
+			patch.priority = p;
+		}
+
+		const extPatchProvided = typeof flags.extensions === "string";
+		const clearExt = flags["clear-extensions"] === true;
+		if (extPatchProvided && clearExt) {
+			throw new Error("--extensions and --clear-extensions are mutually exclusive");
+		}
+		if (clearExt) {
+			patch.extensions = undefined;
+		} else if (extPatchProvided) {
+			const incoming = parseExtensionsPatch(flags.extensions as string);
+			const merged: Record<string, unknown> = { ...(issue.extensions ?? {}), ...incoming };
+			patch.extensions = Object.keys(merged).length > 0 ? merged : undefined;
+		}
+
+		if (typeof flags["set-labels"] === "string") {
+			const val = flags["set-labels"];
+			if (val === "") {
+				patch.labels = undefined;
+			} else {
+				const parsed = val
+					.split(",")
+					.map((l) => l.trim().toLowerCase())
+					.filter(Boolean);
+				patch.labels = parsed.length > 0 ? parsed : undefined;
+			}
+		}
+		if (typeof flags["add-label"] === "string") {
+			const toAdd = flags["add-label"]
+				.split(",")
+				.map((l) => l.trim().toLowerCase())
+				.filter(Boolean);
+			const base = patch.labels ?? issue.labels ?? [];
+			const merged = Array.from(new Set([...base, ...toAdd]));
+			patch.labels = merged.length > 0 ? merged : undefined;
+		}
+		if (typeof flags["remove-label"] === "string") {
+			const toRemove = new Set(flags["remove-label"].split(",").map((l) => l.trim().toLowerCase()));
+			const base = patch.labels ?? issue.labels ?? [];
+			const remaining = base.filter((l) => !toRemove.has(l));
+			patch.labels = remaining.length > 0 ? remaining : undefined;
+		}
+
+		issues[idx] = { ...issue, ...patch };
+		updated = issues[idx];
+		await writeIssues(dir, issues);
+
+		// Plan lifecycle: if a child seed's status changed, recompute owning plan(s).
+		if (statusChanging && patch.status !== undefined && patch.status !== issue.status) {
+			const plans = await readPlans(dir);
+			const affected = affectedPlanIds(plans, [id]);
+			if (affected.length > 0) {
+				const changedCount = applyPlanTransitions(plans, issues, affected, now);
+				if (changedCount > 0) await writePlans(dir, plans);
+			}
+		}
+	};
+
+	if (statusChanging) {
+		// Lock order matches plan-submit: plans (outer) → issues (inner).
+		await withLock(plansPath(dir), () => withLock(issuesPath(dir), inner));
+	} else {
+		await withLock(issuesPath(dir), inner);
+	}
+
+	if (jsonMode) {
+		await outputJson({ success: true, command: "update", issue: updated });
+	} else {
+		printSuccess(`Updated ${id}`);
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("update <id>")
+		.description("Update issue fields")
+		.option("--status <status>", "New status (open|in_progress|closed)")
+		.option("--title <text>", "New title")
+		.option("--assignee <name>", "New assignee")
+		.option("--description <text>", "New description")
+		.option("--desc <text>", "New description (alias for --description)")
+		.option("--body <text>", "New description (alias for --description)")
+		.option("--type <type>", "New type (task|bug|feature|epic)")
+		.option("--priority <n>", "New priority 0-4 or P0-P4")
+		.option("--add-label <labels>", "Add label(s) (comma-separated)")
+		.option("--remove-label <labels>", "Remove label(s) (comma-separated)")
+		.option("--set-labels <labels>", "Set labels (comma-separated, empty to clear)")
+		.option("--extensions <json>", "Shallow-merge JSON object into Issue.extensions")
+		.option("--clear-extensions", "Remove the extensions field")
+		.option("--json", "Output as JSON")
+		.action(
+			async (
+				id: string,
+				opts: {
+					status?: string;
+					title?: string;
+					assignee?: string;
+					description?: string;
+					desc?: string;
+					body?: string;
+					type?: string;
+					priority?: string;
+					addLabel?: string;
+					removeLabel?: string;
+					setLabels?: string;
+					extensions?: string;
+					clearExtensions?: boolean;
+					json?: boolean;
+				},
+			) => {
+				const args: string[] = [id];
+				if (opts.status) args.push("--status", opts.status);
+				if (opts.title !== undefined) args.push("--title", opts.title);
+				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);
+				if (opts.type) args.push("--type", opts.type);
+				if (opts.priority) args.push("--priority", opts.priority);
+				if (opts.addLabel) args.push("--add-label", opts.addLabel);
+				if (opts.removeLabel) args.push("--remove-label", opts.removeLabel);
+				if (opts.setLabels !== undefined) args.push("--set-labels", opts.setLabels);
+				if (opts.extensions !== undefined) args.push("--extensions", opts.extensions);
+				if (opts.clearExtensions) args.push("--clear-extensions");
+				if (opts.json) args.push("--json");
+				await run(args);
+			},
+		);
+}

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

@@ -0,0 +1,91 @@
+import type { Command } from "commander";
+import { brand, outputJson, printSuccess, printWarning } from "../output.ts";
+import { VERSION } from "../version.ts";
+
+const PACKAGE_NAME = "@ag-eco/sprout-cli";
+
+async function fetchLatestVersion(): Promise<string> {
+	const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`);
+	if (!res.ok) throw new Error(`Failed to fetch npm registry: ${res.status} ${res.statusText}`);
+	const data = (await res.json()) as { version: string };
+	return data.version;
+}
+
+export async function run(args: string[]): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const checkOnly = args.includes("--check");
+
+	const current = VERSION;
+	const latest = await fetchLatestVersion();
+	const upToDate = current === latest;
+
+	if (checkOnly) {
+		if (jsonMode) {
+			await outputJson({ success: true, command: "upgrade", current, latest, upToDate });
+		} else {
+			if (upToDate) {
+				printSuccess(`Already up to date (${current})`);
+			} else {
+				printWarning(`Update available: ${current} → ${latest}`);
+				process.exitCode = 1;
+			}
+		}
+		return;
+	}
+
+	if (upToDate) {
+		if (jsonMode) {
+			await outputJson({
+				success: true,
+				command: "upgrade",
+				current,
+				latest,
+				upToDate: true,
+				updated: false,
+			});
+		} else {
+			printSuccess(`Already up to date (${current})`);
+		}
+		return;
+	}
+
+	if (!jsonMode) {
+		console.log(`Upgrading ${brand(PACKAGE_NAME)} from ${current} to ${latest}...`);
+	}
+
+	const result = Bun.spawnSync(["bun", "install", "-g", `${PACKAGE_NAME}@latest`], {
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+
+	if (result.exitCode !== 0) {
+		throw new Error(`bun install failed with exit code ${result.exitCode}`);
+	}
+
+	if (jsonMode) {
+		await outputJson({
+			success: true,
+			command: "upgrade",
+			current,
+			latest,
+			upToDate: false,
+			updated: true,
+		});
+	} else {
+		printSuccess(`Upgraded to ${latest}`);
+	}
+}
+
+export function register(program: Command): void {
+	program
+		.command("upgrade")
+		.description("Upgrade sprout to the latest version from npm")
+		.option("--check", "Check for updates without installing")
+		.option("--json", "Output as JSON")
+		.action(async (opts: { check?: boolean; json?: boolean }) => {
+			const args: string[] = [];
+			if (opts.check) args.push("--check");
+			if (opts.json) args.push("--json");
+			await run(args);
+		});
+}

package/src/tools/sprout/config-schema.ts

@@ -0,0 +1,152 @@
+// JSON Schema for `.sprout/config.yaml`. Wire-format contract for warren V2's
+// schema-driven config UI (warren ROADMAP R-10): warren reads this schema,
+// renders a form, and writes back via `sr config set <path> <value>`. Locked
+// with a golden test (config.test.ts) so any shape change is intentional.
+//
+// Mirrors the ground-truth shape produced by readConfig + loadPlanTemplates in
+// src/config.ts. Built-in plan templates appear in `examples` so warren's UI
+// can offer a "copy a built-in to start" affordance.
+
+import {
+	BUILTIN_BUG_TEMPLATE,
+	BUILTIN_FEATURE_TEMPLATE,
+	BUILTIN_REFACTOR_TEMPLATE,
+} from "./config.ts";
+import { DEFAULT_MAX_PLAN_DEPTH, type PlanTemplate } from "./types.ts";
+
+type JSONSchema = Record<string, unknown>;
+
+function templateExample(t: PlanTemplate): Record<string, unknown> {
+	const out: Record<string, unknown> = { sections: t.sections };
+	if (t.description) out.description = t.description;
+	return out;
+}
+
+export function configSchema(): JSONSchema {
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: "https://github.com/jayminwest/sprout/config.schema.json",
+		title: "Sprout project config",
+		description:
+			"Schema for .sprout/config.yaml. Consumed by warren's schema-driven UI; emit via `sr config schema`.",
+		type: "object",
+		required: ["project", "version"],
+		additionalProperties: false,
+		properties: {
+			project: {
+				type: "string",
+				minLength: 1,
+				title: "Project name",
+				description: "Used as the prefix for issue IDs (e.g. `<project>-a1b2`).",
+			},
+			version: {
+				type: "string",
+				title: "Config schema version",
+				description: "Internal version tag for the config layout. Bumped when the schema breaks.",
+				default: "1",
+			},
+			max_plan_depth: {
+				type: "integer",
+				minimum: 1,
+				title: "Max plan depth",
+				description:
+					"Display-only depth limit for `sr plan show` recursion through nested sub-plans.",
+				default: DEFAULT_MAX_PLAN_DEPTH,
+			},
+			plan_templates: {
+				type: "object",
+				title: "Custom plan templates",
+				description:
+					"Map of template name → template definition. Overrides the built-in `feature`, `bug`, and `refactor` templates when names collide.",
+				additionalProperties: { $ref: "#/$defs/PlanTemplate" },
+				examples: [
+					{
+						feature: templateExample(BUILTIN_FEATURE_TEMPLATE),
+						bug: templateExample(BUILTIN_BUG_TEMPLATE),
+						refactor: templateExample(BUILTIN_REFACTOR_TEMPLATE),
+					},
+				],
+			},
+		},
+		$defs: {
+			PlanTemplate: {
+				type: "object",
+				required: ["sections"],
+				additionalProperties: false,
+				properties: {
+					description: {
+						type: "string",
+						title: "Description",
+						description: "Human-readable summary shown in `sr plan templates`.",
+					},
+					sections: {
+						type: "object",
+						title: "Sections",
+						description:
+							"Map of section name → spec. Each section becomes a field in the plan submission.",
+						additionalProperties: { $ref: "#/$defs/SectionSpec" },
+					},
+				},
+			},
+			SectionSpec: {
+				type: "object",
+				required: ["required", "kind", "prompt"],
+				additionalProperties: false,
+				properties: {
+					required: {
+						type: "boolean",
+						title: "Required",
+						description: "Whether this section must be present in the plan submission.",
+					},
+					kind: {
+						title: "Kind",
+						description:
+							"`text` for free text, `list` for an array, `steps` for an ordered step list, or an object describing nested sub-fields.",
+						oneOf: [
+							{ type: "string", enum: ["text", "list", "steps"] },
+							{
+								type: "object",
+								additionalProperties: { $ref: "#/$defs/SectionSpec" },
+							},
+						],
+					},
+					prompt: {
+						type: "string",
+						title: "Prompt",
+						description: "Question or instruction shown to the LLM when filling this section.",
+					},
+					min_length: {
+						type: "integer",
+						minimum: 0,
+						title: "Minimum length",
+						description: "Minimum character count when `kind` is `text`.",
+					},
+					min: {
+						type: "integer",
+						minimum: 0,
+						title: "Minimum items",
+						description: "Minimum item count when `kind` is `list` or `steps`.",
+					},
+					item: {
+						title: "Item shape",
+						description:
+							"When `kind` is `list`, the per-item shape: `text` for strings or an object spec for structured items.",
+						oneOf: [
+							{ type: "string", const: "text" },
+							{
+								type: "object",
+								additionalProperties: { $ref: "#/$defs/SectionSpec" },
+							},
+						],
+					},
+					loam_source: {
+						type: "string",
+						title: "Loam source",
+						description:
+							"Optional record type (e.g. `failure`, `decision`) seeded into `prior_art` when emitting a plan prompt.",
+					},
+				},
+			},
+		},
+	};
+}