@ag-eco/agentplate-cli 0.13.0

package/src/commands/update.ts

@@ -0,0 +1,263 @@
+/**
+ * CLI command: ap update [--agents] [--manifest] [--hooks] [--dry-run] [--json]
+ *
+ * Refreshes .agentplate/ managed files from the installed npm package without
+ * requiring a full `ap init`. Distinct from `ap upgrade` (which updates the
+ * npm package itself).
+ *
+ * Managed files refreshed:
+ * - Agent definitions (.agentplate/agent-defs/*.md)
+ * - agent-manifest.json
+ * - hooks.json
+ * - .gitignore
+ * - README.md
+ *
+ * Does NOT touch: config.yaml, config.local.yaml, SQLite databases,
+ * agents/, worktrees/, specs/, logs/, or .claude/settings.local.json.
+ */
+
+import { mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { Command } from "commander";
+import { ValidationError } from "../errors.ts";
+import { jsonOutput } from "../json.ts";
+import { printHint, printSuccess } from "../logging/color.ts";
+import {
+	AGENTPLATE_GITIGNORE,
+	AGENTPLATE_README,
+	buildAgentManifest,
+	buildHooksJson,
+	writeAgentplateGitignore,
+	writeAgentplateReadme,
+} from "./init.ts";
+
+export interface UpdateOptions {
+	agents?: boolean;
+	manifest?: boolean;
+	hooks?: boolean;
+	dryRun?: boolean;
+	json?: boolean;
+}
+
+/** Agent def files to exclude (deprecated). */
+const EXCLUDED_AGENT_DEFS = new Set(["supervisor.md"]);
+
+interface UpdateResult {
+	agentDefs: { updated: string[]; unchanged: string[] };
+	manifest: { updated: boolean };
+	hooks: { updated: boolean };
+	gitignore: { updated: boolean };
+	readme: { updated: boolean };
+}
+
+/**
+ * Entry point for `ap update [flags]`.
+ */
+export async function executeUpdate(opts: UpdateOptions): Promise<void> {
+	const json = opts.json ?? false;
+	const dryRun = opts.dryRun ?? false;
+
+	const projectRoot = process.cwd();
+	const agentplateDir = join(projectRoot, ".agentplate");
+
+	// Verify .agentplate/config.yaml exists (already initialized)
+	const configFile = Bun.file(join(agentplateDir, "config.yaml"));
+	if (!(await configFile.exists())) {
+		throw new ValidationError("Not initialized. Run 'ap init' first to set up .agentplate/.", {
+			field: "config.yaml",
+		});
+	}
+
+	// Determine what to refresh. No flags = refresh all.
+	const hasGranularFlags = opts.agents || opts.manifest || opts.hooks;
+	const doAgents = hasGranularFlags ? (opts.agents ?? false) : true;
+	const doManifest = hasGranularFlags ? (opts.manifest ?? false) : true;
+	const doHooks = hasGranularFlags ? (opts.hooks ?? false) : true;
+	const doGitignore = !hasGranularFlags;
+	const doReadme = !hasGranularFlags;
+
+	const result: UpdateResult = {
+		agentDefs: { updated: [], unchanged: [] },
+		manifest: { updated: false },
+		hooks: { updated: false },
+		gitignore: { updated: false },
+		readme: { updated: false },
+	};
+
+	// 1. Refresh agent definitions
+	if (doAgents) {
+		const sourceDir = join(import.meta.dir, "..", "..", "agents");
+		const targetDir = join(agentplateDir, "agent-defs");
+
+		await mkdir(targetDir, { recursive: true });
+
+		const sourceFiles = await readdir(sourceDir);
+		for (const fileName of sourceFiles) {
+			if (!fileName.endsWith(".md")) continue;
+			if (EXCLUDED_AGENT_DEFS.has(fileName)) continue;
+
+			const sourceContent = await Bun.file(join(sourceDir, fileName)).text();
+			const targetPath = join(targetDir, fileName);
+			const targetFile = Bun.file(targetPath);
+
+			let needsUpdate = true;
+			if (await targetFile.exists()) {
+				const existing = await targetFile.text();
+				if (existing === sourceContent) {
+					needsUpdate = false;
+				}
+			}
+
+			if (needsUpdate) {
+				if (!dryRun) {
+					await Bun.write(targetPath, sourceContent);
+				}
+				result.agentDefs.updated.push(fileName);
+			} else {
+				result.agentDefs.unchanged.push(fileName);
+			}
+		}
+	}
+
+	// 2. Refresh agent-manifest.json
+	if (doManifest) {
+		const manifestPath = join(agentplateDir, "agent-manifest.json");
+		const newContent = `${JSON.stringify(buildAgentManifest(), null, "\t")}\n`;
+		const manifestFile = Bun.file(manifestPath);
+
+		let needsUpdate = true;
+		if (await manifestFile.exists()) {
+			const existing = await manifestFile.text();
+			if (existing === newContent) {
+				needsUpdate = false;
+			}
+		}
+
+		if (needsUpdate) {
+			if (!dryRun) {
+				await Bun.write(manifestPath, newContent);
+			}
+			result.manifest.updated = true;
+		}
+	}
+
+	// 3. Refresh hooks.json
+	if (doHooks) {
+		const hooksPath = join(agentplateDir, "hooks.json");
+		const newContent = buildHooksJson();
+		const hooksFile = Bun.file(hooksPath);
+
+		let needsUpdate = true;
+		if (await hooksFile.exists()) {
+			const existing = await hooksFile.text();
+			if (existing === newContent) {
+				needsUpdate = false;
+			}
+		}
+
+		if (needsUpdate) {
+			if (!dryRun) {
+				await Bun.write(hooksPath, newContent);
+			}
+			result.hooks.updated = true;
+		}
+	}
+
+	// 4. Refresh .gitignore
+	if (doGitignore) {
+		const gitignorePath = join(agentplateDir, ".gitignore");
+		const gitignoreFile = Bun.file(gitignorePath);
+
+		let needsUpdate = true;
+		if (await gitignoreFile.exists()) {
+			const existing = await gitignoreFile.text();
+			if (existing === AGENTPLATE_GITIGNORE) {
+				needsUpdate = false;
+			}
+		}
+
+		if (needsUpdate) {
+			if (!dryRun) {
+				await writeAgentplateGitignore(agentplateDir);
+			}
+			result.gitignore.updated = true;
+		}
+	}
+
+	// 5. Refresh README.md
+	if (doReadme) {
+		const readmePath = join(agentplateDir, "README.md");
+		const readmeFile = Bun.file(readmePath);
+
+		let needsUpdate = true;
+		if (await readmeFile.exists()) {
+			const existing = await readmeFile.text();
+			if (existing === AGENTPLATE_README) {
+				needsUpdate = false;
+			}
+		}
+
+		if (needsUpdate) {
+			if (!dryRun) {
+				await writeAgentplateReadme(agentplateDir);
+			}
+			result.readme.updated = true;
+		}
+	}
+
+	// Output
+	if (json) {
+		jsonOutput("update", { dryRun, ...result });
+		return;
+	}
+
+	const prefix = dryRun ? "Would update" : "Updated";
+	let anyChanged = false;
+
+	if (result.agentDefs.updated.length > 0) {
+		anyChanged = true;
+		for (const f of result.agentDefs.updated) {
+			printSuccess(prefix, `agent-defs/${f}`);
+		}
+	}
+
+	if (result.manifest.updated) {
+		anyChanged = true;
+		printSuccess(prefix, "agent-manifest.json");
+	}
+
+	if (result.hooks.updated) {
+		anyChanged = true;
+		printSuccess(prefix, "hooks.json");
+		if (!dryRun) {
+			printHint("If hooks are deployed, run 'ap hooks install --force' to redeploy");
+		}
+	}
+
+	if (result.gitignore.updated) {
+		anyChanged = true;
+		printSuccess(prefix, ".gitignore");
+	}
+
+	if (result.readme.updated) {
+		anyChanged = true;
+		printSuccess(prefix, "README.md");
+	}
+
+	if (!anyChanged) {
+		printSuccess("Already up to date");
+	}
+}
+
+export function createUpdateCommand(): Command {
+	return new Command("update")
+		.description("Refresh .agentplate/ managed files from the installed package")
+		.option("--agents", "Refresh agent definition files only")
+		.option("--manifest", "Refresh agent-manifest.json only")
+		.option("--hooks", "Refresh hooks.json only")
+		.option("--dry-run", "Show what would change without writing")
+		.option("--json", "Output as JSON")
+		.action(async (opts: UpdateOptions) => {
+			await executeUpdate(opts);
+		});
+}

package/src/commands/upgrade.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Tests for the ap upgrade command.
+ *
+ * Structural tests for CLI registration and option parsing.
+ * Network calls and subprocess execution happen via real implementations;
+ * this file tests command structure and output format rather than side effects.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { createUpgradeCommand } from "./upgrade.ts";
+
+describe("createUpgradeCommand — CLI structure", () => {
+	test("command has correct name", () => {
+		const cmd = createUpgradeCommand();
+		expect(cmd.name()).toBe("upgrade");
+	});
+
+	test("description mentions agentplate", () => {
+		const cmd = createUpgradeCommand();
+		expect(cmd.description().toLowerCase()).toContain("agentplate");
+	});
+
+	test("has --check option", () => {
+		const cmd = createUpgradeCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--check");
+	});
+
+	test("has --json option", () => {
+		const cmd = createUpgradeCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--json");
+	});
+
+	test("has --all option", () => {
+		const cmd = createUpgradeCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--all");
+	});
+
+	test("returns a Command instance", () => {
+		const cmd = createUpgradeCommand();
+		// Commander Command instances have a .parse method
+		expect(typeof cmd.parse).toBe("function");
+	});
+});
+
+// getCurrentVersion and fetchLatestVersion tests moved to src/utils/version.test.ts

package/src/commands/upgrade.ts

@@ -0,0 +1,240 @@
+/**
+ * CLI command: ap upgrade [--check] [--all] [--json]
+ *
+ * Upgrades agentplate (and optionally all ag-eco tools) to their latest npm versions.
+ * --check: Compare current vs latest without installing.
+ * --all:   Upgrade all 4 ecosystem tools (agentplate, loam, sprout, trellis).
+ * --json:  Output result as JSON envelope.
+ */
+
+import { Command } from "commander";
+import { jsonError, jsonOutput } from "../json.ts";
+import { muted, printError, printHint, printSuccess, printWarning } from "../logging/color.ts";
+import { fetchLatestVersion, getCurrentVersion } from "../utils/version.ts";
+
+const AGENTPLATE_PACKAGE = "@ag-eco/agentplate-cli";
+
+// loam/sprout/trellis are now bundled into @ag-eco/agentplate-cli (their bins
+// lm/sr/tl ship from this package), so there is a single package to upgrade.
+const ALL_PACKAGES = ["@ag-eco/agentplate-cli"] as const;
+
+export interface UpgradeOptions {
+	check?: boolean;
+	all?: boolean;
+	json?: boolean;
+}
+
+async function runInstall(packageName: string): Promise<number> {
+	const proc = Bun.spawn(["bun", "install", "-g", `${packageName}@latest`], {
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	return proc.exited;
+}
+
+interface PackageResult {
+	package: string;
+	current: string;
+	latest: string;
+	upToDate: boolean;
+	updated: boolean;
+	error?: string;
+}
+
+async function upgradePackage(packageName: string): Promise<PackageResult> {
+	let latest: string;
+	try {
+		latest = await fetchLatestVersion(packageName);
+	} catch (err) {
+		const error = err instanceof Error ? err.message : String(err);
+		return {
+			package: packageName,
+			current: "unknown",
+			latest: "unknown",
+			upToDate: false,
+			updated: false,
+			error,
+		};
+	}
+
+	const exitCode = await runInstall(packageName);
+	if (exitCode !== 0) {
+		return {
+			package: packageName,
+			current: "unknown",
+			latest,
+			upToDate: false,
+			updated: false,
+			error: `bun install failed with exit code ${exitCode}`,
+		};
+	}
+	return { package: packageName, current: "unknown", latest, upToDate: false, updated: true };
+}
+
+async function executeUpgradeSingle(opts: UpgradeOptions): Promise<void> {
+	const json = opts.json ?? false;
+	const checkOnly = opts.check ?? false;
+
+	let current: string;
+	let latest: string;
+	try {
+		[current, latest] = await Promise.all([
+			getCurrentVersion(),
+			fetchLatestVersion(AGENTPLATE_PACKAGE),
+		]);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (json) {
+			jsonError("upgrade", msg);
+		} else {
+			printError("Failed to check for updates", msg);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	const upToDate = current === latest;
+
+	if (checkOnly) {
+		if (json) {
+			jsonOutput("upgrade", { current, latest, upToDate });
+		} else if (upToDate) {
+			printSuccess("Already up to date", current);
+		} else {
+			printWarning(`Update available: ${current} → ${latest}`);
+			printHint("Run 'ap upgrade' to install the latest version");
+			process.exitCode = 1;
+		}
+		return;
+	}
+
+	if (upToDate) {
+		if (json) {
+			jsonOutput("upgrade", { current, latest, upToDate: true, updated: false });
+		} else {
+			printSuccess("Already up to date", current);
+		}
+		return;
+	}
+
+	if (!json) {
+		process.stdout.write(
+			`${muted(`Upgrading ${AGENTPLATE_PACKAGE} from ${current} to ${latest}...`)}\n`,
+		);
+	}
+
+	const exitCode = await runInstall(AGENTPLATE_PACKAGE);
+
+	if (exitCode !== 0) {
+		if (json) {
+			jsonError("upgrade", `bun install failed with exit code ${exitCode}`);
+		} else {
+			printError("Upgrade failed", `bun install exited with code ${exitCode}`);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	if (json) {
+		jsonOutput("upgrade", { current, latest, upToDate: false, updated: true });
+	} else {
+		printSuccess("Upgraded to", latest);
+	}
+}
+
+async function executeUpgradeAll(opts: UpgradeOptions): Promise<void> {
+	const json = opts.json ?? false;
+	const checkOnly = opts.check ?? false;
+
+	// Fetch all latest versions in parallel
+	const latestResults = await Promise.allSettled(
+		ALL_PACKAGES.map((pkg) => fetchLatestVersion(pkg)),
+	);
+
+	if (checkOnly) {
+		// For --check --all, we just report status without installing
+		const results: Array<{ package: string; latest: string; error?: string }> = [];
+		let anyOutdated = false;
+
+		for (let i = 0; i < ALL_PACKAGES.length; i++) {
+			const pkg = ALL_PACKAGES[i] as string;
+			const result = latestResults[i];
+			if (result === undefined || result.status === "rejected") {
+				const error =
+					result?.status === "rejected"
+						? result.reason instanceof Error
+							? result.reason.message
+							: String(result.reason)
+						: "unknown error";
+				results.push({ package: pkg, latest: "unknown", error });
+				anyOutdated = true;
+			} else {
+				results.push({ package: pkg, latest: result.value });
+				// We can't easily get current versions for all tools without spawning them
+				// so for --all --check we just report latest versions available
+			}
+		}
+
+		if (json) {
+			jsonOutput("upgrade", { packages: results });
+		} else {
+			for (const r of results) {
+				if (r.error) {
+					printError(`${r.package}`, r.error);
+				} else {
+					process.stdout.write(`  ${r.package} → ${r.latest}\n`);
+				}
+			}
+			if (anyOutdated) process.exitCode = 1;
+		}
+		return;
+	}
+
+	// Install all packages
+	if (!json) {
+		process.stdout.write(`${muted("Upgrading all ag-eco tools to latest...")}\n`);
+	}
+
+	const results: PackageResult[] = await Promise.all(
+		ALL_PACKAGES.map((pkg) => upgradePackage(pkg)),
+	);
+
+	const anyError = results.some((r) => r.error !== undefined);
+
+	if (json) {
+		if (anyError) {
+			jsonError("upgrade", `One or more packages failed to upgrade`);
+		} else {
+			jsonOutput("upgrade", { packages: results, updated: true });
+		}
+	} else {
+		for (const r of results) {
+			if (r.error) {
+				printError(`Failed to upgrade ${r.package}`, r.error);
+			} else {
+				printSuccess(`Upgraded ${r.package} to`, r.latest);
+			}
+		}
+	}
+
+	if (anyError) process.exitCode = 1;
+}
+
+export async function executeUpgrade(opts: UpgradeOptions): Promise<void> {
+	if (opts.all) {
+		await executeUpgradeAll(opts);
+	} else {
+		await executeUpgradeSingle(opts);
+	}
+}
+
+export function createUpgradeCommand(): Command {
+	return new Command("upgrade")
+		.description("Upgrade agentplate to the latest version from npm")
+		.option("--check", "Check for updates without installing")
+		.option("--all", "Upgrade all ag-eco ecosystem tools")
+		.option("--json", "Output as JSON")
+		.action(async (opts: UpgradeOptions) => {
+			await executeUpgrade(opts);
+		});
+}