@os-eco/seeds-cli 0.2.0

package/src/commands/tpl.test.ts

@@ -0,0 +1,330 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+let tmpDir: string;
+
+const CLI = join(import.meta.dir, "../../src/index.ts");
+
+async function run(
+	args: string[],
+	cwd: string,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const proc = Bun.spawn(["bun", "run", CLI, ...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+	const exitCode = await proc.exited;
+	return { stdout, stderr, exitCode };
+}
+
+async function runJson<T = unknown>(args: string[], cwd: string): Promise<T> {
+	const { stdout } = await run([...args, "--json"], cwd);
+	return JSON.parse(stdout) as T;
+}
+
+beforeEach(async () => {
+	tmpDir = await mkdtemp(join(tmpdir(), "seeds-tpl-test-"));
+	await run(["init"], tmpDir);
+});
+
+afterEach(async () => {
+	await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("sd tpl create", () => {
+	test("creates a template with --name", async () => {
+		const result = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "scout-build-review"],
+			tmpDir,
+		);
+		expect(result.success).toBe(true);
+		expect(result.id).toMatch(/^tpl-[0-9a-f]{4}$/);
+	});
+
+	test("requires --name", async () => {
+		const { exitCode } = await run(["tpl", "create"], tmpDir);
+		expect(exitCode).not.toBe(0);
+	});
+});
+
+describe("sd tpl step add", () => {
+	test("adds a step to a template", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "my-template"],
+			tmpDir,
+		);
+		const result = await runJson<{ success: boolean }>(
+			["tpl", "step", "add", create.id, "--title", "Step 1"],
+			tmpDir,
+		);
+		expect(result.success).toBe(true);
+	});
+
+	test("added step appears in tpl show", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "my-template"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "Scout: {prefix}"], tmpDir);
+		await run(["tpl", "step", "add", create.id, "--title", "Build: {prefix}"], tmpDir);
+
+		const show = await runJson<{
+			success: boolean;
+			template: { steps: Array<{ title: string }> };
+		}>(["tpl", "show", create.id], tmpDir);
+
+		expect(show.template.steps).toHaveLength(2);
+		expect(show.template.steps[0]?.title).toBe("Scout: {prefix}");
+		expect(show.template.steps[1]?.title).toBe("Build: {prefix}");
+	});
+
+	test("accepts --type and --priority for step", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "typed-template"],
+			tmpDir,
+		);
+		await run(
+			["tpl", "step", "add", create.id, "--title", "Bug step", "--type", "bug", "--priority", "1"],
+			tmpDir,
+		);
+		const show = await runJson<{
+			success: boolean;
+			template: { steps: Array<{ title: string; type?: string; priority?: number }> };
+		}>(["tpl", "show", create.id], tmpDir);
+
+		const step = show.template.steps[0];
+		expect(step?.type).toBe("bug");
+		expect(step?.priority).toBe(1);
+	});
+
+	test("step defaults to type=task priority=2", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "default-template"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "Default step"], tmpDir);
+		const show = await runJson<{
+			success: boolean;
+			template: { steps: Array<{ title: string; type?: string; priority?: number }> };
+		}>(["tpl", "show", create.id], tmpDir);
+
+		const step = show.template.steps[0];
+		expect(step?.type ?? "task").toBe("task");
+		expect(step?.priority ?? 2).toBe(2);
+	});
+});
+
+describe("sd tpl list", () => {
+	test("lists all templates", async () => {
+		await run(["tpl", "create", "--name", "template-1"], tmpDir);
+		await run(["tpl", "create", "--name", "template-2"], tmpDir);
+
+		const result = await runJson<{ success: boolean; templates: unknown[]; count: number }>(
+			["tpl", "list"],
+			tmpDir,
+		);
+		expect(result.success).toBe(true);
+		expect(result.count).toBe(2);
+		expect(result.templates).toHaveLength(2);
+	});
+
+	test("returns empty list when no templates", async () => {
+		const result = await runJson<{ success: boolean; templates: unknown[]; count: number }>(
+			["tpl", "list"],
+			tmpDir,
+		);
+		expect(result.success).toBe(true);
+		expect(result.count).toBe(0);
+	});
+});
+
+describe("sd tpl show", () => {
+	test("shows template with its steps", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "show-test"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "Step A"], tmpDir);
+
+		const show = await runJson<{
+			success: boolean;
+			template: { id: string; name: string; steps: unknown[] };
+		}>(["tpl", "show", create.id], tmpDir);
+
+		expect(show.success).toBe(true);
+		expect(show.template.id).toBe(create.id);
+		expect(show.template.name).toBe("show-test");
+		expect(show.template.steps).toHaveLength(1);
+	});
+
+	test("fails for unknown template id", async () => {
+		const result = await runJson<{ success: boolean; error: string }>(
+			["tpl", "show", "tpl-ffff"],
+			tmpDir,
+		);
+		expect(result.success).toBe(false);
+		expect(result.error).toBeTruthy();
+	});
+});
+
+describe("sd tpl pour", () => {
+	test("pours template into issues", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "scout-build"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "Scout: {prefix}"], tmpDir);
+		await run(["tpl", "step", "add", create.id, "--title", "Build: {prefix}"], tmpDir);
+
+		const result = await runJson<{ success: boolean; ids: string[] }>(
+			["tpl", "pour", create.id, "--prefix", "auth"],
+			tmpDir,
+		);
+		expect(result.success).toBe(true);
+		expect(result.ids).toHaveLength(2);
+	});
+
+	test("created issues have interpolated titles", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "single-step"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "Build: {prefix}"], tmpDir);
+
+		const pour = await runJson<{ success: boolean; ids: string[] }>(
+			["tpl", "pour", create.id, "--prefix", "oauth"],
+			tmpDir,
+		);
+
+		const show = await runJson<{ success: boolean; issue: { title: string } }>(
+			["show", pour.ids[0] ?? ""],
+			tmpDir,
+		);
+		expect(show.issue.title).toBe("Build: oauth");
+	});
+
+	test("step N+1 is blocked by step N (convoy dependency chain)", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "convoy"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "Step 1"], tmpDir);
+		await run(["tpl", "step", "add", create.id, "--title", "Step 2"], tmpDir);
+		await run(["tpl", "step", "add", create.id, "--title", "Step 3"], tmpDir);
+
+		const pour = await runJson<{ success: boolean; ids: string[] }>(
+			["tpl", "pour", create.id, "--prefix", "test"],
+			tmpDir,
+		);
+
+		// Step 2 blocked by Step 1
+		const s2 = await runJson<{ success: boolean; issue: { blockedBy?: string[] } }>(
+			["show", pour.ids[1] ?? ""],
+			tmpDir,
+		);
+		expect(s2.issue.blockedBy).toContain(pour.ids[0]);
+
+		// Step 3 blocked by Step 2
+		const s3 = await runJson<{ success: boolean; issue: { blockedBy?: string[] } }>(
+			["show", pour.ids[2] ?? ""],
+			tmpDir,
+		);
+		expect(s3.issue.blockedBy).toContain(pour.ids[1]);
+	});
+
+	test("first step is ready (not blocked)", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "convoy-ready"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "First step"], tmpDir);
+		await run(["tpl", "step", "add", create.id, "--title", "Second step"], tmpDir);
+
+		const pour = await runJson<{ success: boolean; ids: string[] }>(
+			["tpl", "pour", create.id, "--prefix", "x"],
+			tmpDir,
+		);
+
+		const ready = await runJson<{ success: boolean; issues: Array<{ id: string }> }>(
+			["ready"],
+			tmpDir,
+		);
+		const ids = ready.issues.map((i) => i.id);
+		expect(ids).toContain(pour.ids[0] ?? "");
+		expect(ids).not.toContain(pour.ids[1] ?? "");
+	});
+
+	test("requires --prefix", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "prefix-required"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "Step"], tmpDir);
+
+		const { exitCode } = await run(["tpl", "pour", create.id], tmpDir);
+		expect(exitCode).not.toBe(0);
+	});
+});
+
+describe("sd tpl status", () => {
+	test("returns convoy completion status", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "status-test"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "Step 1"], tmpDir);
+		await run(["tpl", "step", "add", create.id, "--title", "Step 2"], tmpDir);
+
+		const pour = await runJson<{ success: boolean; ids: string[] }>(
+			["tpl", "pour", create.id, "--prefix", "feature"],
+			tmpDir,
+		);
+
+		const status = await runJson<{
+			success: boolean;
+			status: {
+				templateId: string;
+				total: number;
+				completed: number;
+				inProgress: number;
+				issues: string[];
+			};
+		}>(["tpl", "status", create.id], tmpDir);
+
+		expect(status.success).toBe(true);
+		expect(status.status.templateId).toBe(create.id);
+		expect(status.status.total).toBe(2);
+		expect(status.status.completed).toBe(0);
+		expect(status.status.issues).toHaveLength(2);
+	});
+
+	test("tracks completion after closing convoy issues", async () => {
+		const create = await runJson<{ success: boolean; id: string }>(
+			["tpl", "create", "--name", "track-completion"],
+			tmpDir,
+		);
+		await run(["tpl", "step", "add", create.id, "--title", "Step 1"], tmpDir);
+		await run(["tpl", "step", "add", create.id, "--title", "Step 2"], tmpDir);
+
+		const pour = await runJson<{ success: boolean; ids: string[] }>(
+			["tpl", "pour", create.id, "--prefix", "work"],
+			tmpDir,
+		);
+
+		// Close first step
+		await run(["close", pour.ids[0] ?? ""], tmpDir);
+
+		const status = await runJson<{
+			success: boolean;
+			status: { completed: number; total: number };
+		}>(["tpl", "status", create.id], tmpDir);
+
+		expect(status.status.completed).toBe(1);
+		expect(status.status.total).toBe(2);
+	});
+});

package/src/commands/tpl.ts

@@ -0,0 +1,279 @@
+import { findSeedsDir, readConfig } from "../config.ts";
+import { generateId } from "../id.ts";
+import { c, outputJson, printIssueOneLine, printSuccess } from "../output.ts";
+import {
+	appendIssue,
+	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[], seedsDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const { flags, positional } = parseArgs(args);
+	const subcmd = positional[0];
+
+	if (!subcmd) throw new Error("Usage: sd tpl <create|step|list|show|pour|status>");
+
+	const dir = seedsDir ?? (await findSeedsDir());
+
+	// sd tpl create --name "..."
+	if (subcmd === "create") {
+		const name = flags.name;
+		if (!name || typeof name !== "string") throw new Error("--name is required");
+
+		let createdId: string;
+		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) {
+			outputJson({ success: true, command: "tpl create", id: createdId! });
+		} else {
+			printSuccess(`Created template ${createdId!}: ${name}`);
+		}
+		return;
+	}
+
+	// sd tpl step add <template-id> --title "..." [--type task] [--priority 2]
+	if (subcmd === "step") {
+		const stepSubcmd = positional[1];
+		if (stepSubcmd !== "add") throw new Error("Usage: sd 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);
+			if (idx === -1) throw new Error(`Template not found: ${templateId}`);
+			const tpl = templates[idx]!;
+			const step: TemplateStep = { title, type: typeVal, priority };
+			templates[idx] = { ...tpl, steps: [...tpl.steps, step] };
+			stepCount = templates[idx]?.steps.length;
+			await writeTemplates(dir, templates);
+		});
+
+		if (jsonMode) {
+			outputJson({ success: true, command: "tpl step add", id: templateId, stepCount });
+		} else {
+			printSuccess(`Added step ${stepCount} to ${templateId}: "${title}"`);
+		}
+		return;
+	}
+
+	// sd tpl list
+	if (subcmd === "list") {
+		const templates = await readTemplates(dir);
+		if (jsonMode) {
+			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(
+					`${c.bold}${tpl.id}${c.reset}  ${tpl.name}  ${c.gray}(${tpl.steps.length} steps)${c.reset}`,
+				);
+			}
+		}
+		return;
+	}
+
+	// sd tpl show <id>
+	if (subcmd === "show") {
+		const templateId = positional[1];
+		if (!templateId) throw new Error("Usage: sd 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) {
+			outputJson({ success: true, command: "tpl show", template: tpl });
+		} else {
+			console.log(`${c.bold}${tpl.id}${c.reset}  ${tpl.name}`);
+			console.log(`Steps (${tpl.steps.length}):`);
+			tpl.steps.forEach((step, i) => {
+				console.log(
+					`  ${i + 1}. ${step.title}  ${c.gray}[${step.type ?? "task"} P${step.priority ?? 2}]${c.reset}`,
+				);
+			});
+		}
+		return;
+	}
+
+	// sd tpl pour <id> --prefix "..."
+	if (subcmd === "pour") {
+		const templateId = positional[1];
+		if (!templateId) throw new Error("Usage: sd 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]!;
+				curr.blockedBy = [prev.id];
+				prev.blocks = [curr.id];
+			}
+
+			// Append all new issues
+			const allIssues = [...existing, ...newIssues];
+			await writeIssues(dir, allIssues);
+		});
+
+		if (jsonMode) {
+			outputJson({ success: true, command: "tpl pour", ids: createdIds });
+		} else {
+			printSuccess(`Poured template ${templateId} — created ${createdIds.length} issues`);
+			for (const id of createdIds) console.log(`  ${id}`);
+		}
+		return;
+	}
+
+	// sd tpl status <id>
+	if (subcmd === "status") {
+		const templateId = positional[1];
+		if (!templateId) throw new Error("Usage: sd tpl status <id>");
+
+		const issues = await readIssues(dir);
+		const convoyIssues = issues.filter((i: Issue) => i.convoy === templateId);
+
+		if (convoyIssues.length === 0) {
+			if (jsonMode) {
+				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) {
+			outputJson({ success: true, command: "tpl status", status });
+		} else {
+			console.log(`${c.bold}Convoy: ${templateId}${c.reset}`);
+			console.log(`  Total:       ${status.total}`);
+			console.log(`  Completed:   ${completed}`);
+			console.log(`  In progress: ${inProgress}`);
+			console.log(`  Blocked:     ${blocked}`);
+			console.log("  Issues:");
+			for (const issue of convoyIssues) {
+				process.stdout.write("    ");
+				printIssueOneLine(issue);
+			}
+		}
+		return;
+	}
+
+	throw new Error(
+		`Unknown tpl subcommand: ${subcmd}. Use create, step, list, show, pour, or status.`,
+	);
+}

package/src/commands/update.ts

@@ -0,0 +1,97 @@
+import { findSeedsDir } from "../config.ts";
+import { outputJson, printSuccess } from "../output.ts";
+import { issuesPath, readIssues, withLock, writeIssues } 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);
+}
+
+export async function run(args: string[], seedsDir?: string): Promise<void> {
+	const jsonMode = args.includes("--json");
+	const id = args.find((a) => !a.startsWith("--"));
+	if (!id) throw new Error("Usage: sd update <id> [flags]");
+
+	const flags = parseArgs(args);
+
+	const dir = seedsDir ?? (await findSeedsDir());
+	let updated: Issue | undefined;
+
+	await withLock(issuesPath(dir), async () => {
+		const issues = await readIssues(dir);
+		const idx = issues.findIndex((i) => i.id === id);
+		if (idx === -1) throw new Error(`Issue not found: ${id}`);
+
+		const issue = issues[idx]!;
+		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"];
+		}
+		if (typeof flags.title === "string") patch.title = flags.title;
+		if (typeof flags.assignee === "string") patch.assignee = flags.assignee;
+		const desc = typeof flags.description === "string" ? flags.description : flags.desc;
+		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;
+		}
+
+		issues[idx] = { ...issue, ...patch };
+		updated = issues[idx];
+		await writeIssues(dir, issues);
+	});
+
+	if (jsonMode) {
+		outputJson({ success: true, command: "update", issue: updated });
+	} else {
+		printSuccess(`Updated ${id}`);
+	}
+}