@ag-eco/agentplate-cli 0.13.0

package/src/commands/ecosystem.test.ts

@@ -0,0 +1,226 @@
+/**
+ * Tests for the ap ecosystem command.
+ *
+ * Structural tests for CLI registration, plus a smoke test that runs the
+ * actual command and verifies the JSON output shape. The smoke test hits
+ * real CLIs and the npm registry, so it requires network access.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	createEcosystemCommand,
+	executeEcosystem,
+	formatDoctorLine,
+	printHumanOutput,
+	type ToolResult,
+} from "./ecosystem.ts";
+
+describe("createEcosystemCommand — CLI structure", () => {
+	test("command has correct name", () => {
+		const cmd = createEcosystemCommand();
+		expect(cmd.name()).toBe("ecosystem");
+	});
+
+	test("description mentions ag-eco", () => {
+		const cmd = createEcosystemCommand();
+		expect(cmd.description().toLowerCase()).toContain("ag-eco");
+	});
+
+	test("has --json option", () => {
+		const cmd = createEcosystemCommand();
+		const optionNames = cmd.options.map((o) => o.long);
+		expect(optionNames).toContain("--json");
+	});
+
+	test("returns a Command instance", () => {
+		const cmd = createEcosystemCommand();
+		expect(typeof cmd.parse).toBe("function");
+	});
+});
+
+describe("executeEcosystem — JSON output shape", () => {
+	test("--json produces valid JSON with expected structure", async () => {
+		// Capture stdout
+		const chunks: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = (chunk: string | Uint8Array) => {
+			chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+			return true;
+		};
+
+		try {
+			await executeEcosystem({ json: true });
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+
+		const output = chunks.join("");
+		const parsed = JSON.parse(output.trim());
+
+		// Envelope
+		expect(parsed.success).toBe(true);
+		expect(parsed.command).toBe("ecosystem");
+
+		// Tools array
+		expect(Array.isArray(parsed.tools)).toBe(true);
+		expect(parsed.tools.length).toBeGreaterThan(0);
+
+		// Each tool has required fields
+		for (const tool of parsed.tools) {
+			expect(typeof tool.name).toBe("string");
+			expect(typeof tool.cli).toBe("string");
+			expect(typeof tool.npm).toBe("string");
+			expect(typeof tool.installed).toBe("boolean");
+		}
+
+		// Summary
+		expect(typeof parsed.summary).toBe("object");
+		expect(typeof parsed.summary.total).toBe("number");
+		expect(typeof parsed.summary.installed).toBe("number");
+		expect(typeof parsed.summary.missing).toBe("number");
+		expect(typeof parsed.summary.outdated).toBe("number");
+		expect(parsed.summary.total).toBe(parsed.tools.length);
+	}, 30_000); // Network calls may be slow
+
+	test("includes agentplate in tool list", async () => {
+		const chunks: string[] = [];
+		const originalWrite = process.stdout.write;
+		process.stdout.write = (chunk: string | Uint8Array) => {
+			chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+			return true;
+		};
+
+		try {
+			await executeEcosystem({ json: true });
+		} finally {
+			process.stdout.write = originalWrite;
+		}
+
+		const parsed = JSON.parse(chunks.join("").trim());
+		const agentplate = parsed.tools.find((t: { name: string }) => t.name === "agentplate");
+		expect(agentplate).toBeDefined();
+		// In CI, `ap` may not be globally installed — only assert version when installed
+		if (agentplate.installed) {
+			expect(agentplate.version).toBeDefined();
+		}
+	}, 30_000);
+});
+
+describe("formatDoctorLine", () => {
+	test("pass-only shows green passed count", () => {
+		const result = formatDoctorLine({ pass: 5, warn: 0, fail: 0 });
+		expect(result).toContain("5 passed");
+		expect(result).not.toContain("warn");
+		expect(result).not.toContain("fail");
+	});
+
+	test("warn and fail without pass", () => {
+		const result = formatDoctorLine({ pass: 0, warn: 2, fail: 3 });
+		expect(result).toContain("2 warn");
+		expect(result).toContain("3 fail");
+		expect(result).not.toContain("passed");
+	});
+
+	test("all three counts present", () => {
+		const result = formatDoctorLine({ pass: 10, warn: 1, fail: 2 });
+		expect(result).toContain("10 passed");
+		expect(result).toContain("1 warn");
+		expect(result).toContain("2 fail");
+	});
+
+	test("all-zero returns 'no checks'", () => {
+		const result = formatDoctorLine({ pass: 0, warn: 0, fail: 0 });
+		expect(result).toBe("no checks");
+	});
+});
+
+// getInstalledVersion tests moved to src/utils/version.test.ts
+
+describe("printHumanOutput", () => {
+	function capturePrintOutput(results: ToolResult[]): string {
+		const chunks: string[] = [];
+		const original = process.stdout.write;
+		process.stdout.write = (chunk: string | Uint8Array) => {
+			chunks.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+			return true;
+		};
+		try {
+			printHumanOutput(results);
+		} finally {
+			process.stdout.write = original;
+		}
+		return chunks.join("");
+	}
+
+	test("shows installed tool with version", () => {
+		const results: ToolResult[] = [
+			{
+				name: "test-tool",
+				cli: "tt",
+				npm: "@test/tool",
+				installed: true,
+				version: "1.2.3",
+				latest: "1.2.3",
+				upToDate: true,
+			},
+		];
+		const output = capturePrintOutput(results);
+		expect(output).toContain("test-tool");
+		expect(output).toContain("1.2.3");
+		expect(output).toContain("up to date");
+		expect(output).toContain("1/1 installed");
+	});
+
+	test("shows not-installed tool with install hint", () => {
+		const results: ToolResult[] = [
+			{
+				name: "missing-tool",
+				cli: "mt",
+				npm: "@test/missing",
+				installed: false,
+			},
+		];
+		const output = capturePrintOutput(results);
+		expect(output).toContain("missing-tool");
+		expect(output).toContain("not installed");
+		expect(output).toContain("npm i -g @test/missing");
+		expect(output).toContain("1 missing");
+	});
+
+	test("shows outdated tool with latest version", () => {
+		const results: ToolResult[] = [
+			{
+				name: "old-tool",
+				cli: "ot",
+				npm: "@test/old",
+				installed: true,
+				version: "1.0.0",
+				latest: "2.0.0",
+				upToDate: false,
+			},
+		];
+		const output = capturePrintOutput(results);
+		expect(output).toContain("old-tool");
+		expect(output).toContain("1.0.0");
+		expect(output).toContain("outdated");
+		expect(output).toContain("2.0.0");
+		expect(output).toContain("1 outdated");
+	});
+
+	test("shows latestError gracefully", () => {
+		const results: ToolResult[] = [
+			{
+				name: "err-tool",
+				cli: "et",
+				npm: "@test/err",
+				installed: true,
+				version: "1.0.0",
+				latestError: "network timeout",
+			},
+		];
+		const output = capturePrintOutput(results);
+		expect(output).toContain("err-tool");
+		expect(output).toContain("1.0.0");
+		expect(output).toContain("version check failed");
+	});
+});

package/src/commands/ecosystem.ts

@@ -0,0 +1,248 @@
+/**
+ * CLI command: ap ecosystem
+ *
+ * Shows a summary dashboard of all installed ag-eco tools: version, update
+ * status (latest vs outdated), and doctor health (agentplate only).
+ */
+
+import { Command } from "commander";
+import { jsonError, jsonOutput } from "../json.ts";
+import { accent, brand, color, muted } from "../logging/color.ts";
+import { thickSeparator } from "../logging/theme.ts";
+import { fetchLatestVersion, getInstalledVersion } from "../utils/version.ts";
+
+// loam/sprout/trellis are bundled into @ag-eco/agentplate-cli — their bins
+// (lm/sr/tl) ship from this single package, so they share its npm name/version.
+const TOOLS = [
+	{ name: "agentplate", cli: "ap", npm: "@ag-eco/agentplate-cli" },
+	{ name: "loam", cli: "lm", npm: "@ag-eco/agentplate-cli" },
+	{ name: "sprout", cli: "sr", npm: "@ag-eco/agentplate-cli" },
+	{ name: "trellis", cli: "tl", npm: "@ag-eco/agentplate-cli" },
+] as const;
+
+export interface EcosystemOptions {
+	json?: boolean;
+}
+
+export interface DoctorSummary {
+	pass: number;
+	warn: number;
+	fail: number;
+}
+
+export interface ToolResult {
+	name: string;
+	cli: string;
+	npm: string;
+	installed: boolean;
+	version?: string;
+	latest?: string;
+	upToDate?: boolean;
+	doctorSummary?: DoctorSummary;
+	latestError?: string;
+}
+
+async function getDoctorSummary(): Promise<DoctorSummary | undefined> {
+	try {
+		const proc = Bun.spawn(["ap", "doctor", "--json"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		await proc.exited;
+		const stdout = await new Response(proc.stdout).text();
+		const trimmed = stdout.trim();
+		if (trimmed) {
+			const data = JSON.parse(trimmed) as {
+				summary?: { pass?: number; warn?: number; fail?: number };
+			};
+			if (data.summary) {
+				return {
+					pass: data.summary.pass ?? 0,
+					warn: data.summary.warn ?? 0,
+					fail: data.summary.fail ?? 0,
+				};
+			}
+		}
+	} catch {
+		// Doctor failed — report nothing
+	}
+	return undefined;
+}
+
+async function checkTool(tool: { name: string; cli: string; npm: string }): Promise<ToolResult> {
+	const version = await getInstalledVersion(tool.cli);
+
+	if (version === null) {
+		return { name: tool.name, cli: tool.cli, npm: tool.npm, installed: false };
+	}
+
+	let latest: string | undefined;
+	let latestError: string | undefined;
+	let doctorSummary: DoctorSummary | undefined;
+
+	const latestPromise = fetchLatestVersion(tool.npm)
+		.then((v) => {
+			latest = v;
+		})
+		.catch((err) => {
+			latestError = err instanceof Error ? err.message : String(err);
+		});
+
+	const doctorPromise =
+		tool.name === "agentplate"
+			? getDoctorSummary().then((d) => {
+					doctorSummary = d;
+				})
+			: Promise.resolve();
+
+	await Promise.all([latestPromise, doctorPromise]);
+
+	const upToDate = latest !== undefined ? version === latest : undefined;
+
+	return {
+		name: tool.name,
+		cli: tool.cli,
+		npm: tool.npm,
+		installed: true,
+		version,
+		latest,
+		upToDate,
+		doctorSummary,
+		latestError,
+	};
+}
+
+/** @internal Exported for testing. */
+export function formatDoctorLine(summary: DoctorSummary): string {
+	const parts: string[] = [];
+	if (summary.pass > 0) parts.push(color.green(`${summary.pass} passed`));
+	if (summary.warn > 0) parts.push(color.yellow(`${summary.warn} warn`));
+	if (summary.fail > 0) parts.push(color.red(`${summary.fail} fail`));
+	return parts.length > 0 ? parts.join(", ") : "no checks";
+}
+
+/** @internal Exported for testing. */
+export function printHumanOutput(results: ToolResult[]): void {
+	process.stdout.write(`${brand.bold("ag-eco Ecosystem")}\n`);
+	process.stdout.write(`${thickSeparator()}\n`);
+	process.stdout.write("\n");
+
+	for (const tool of results) {
+		if (!tool.installed) {
+			process.stdout.write(
+				`  ${color.red("x")} ${accent(tool.name)} ${muted(`(${tool.cli})`)}  ${color.red("not installed")}\n`,
+			);
+			process.stdout.write(`    ${muted(`npm i -g ${tool.npm}`)}\n`);
+			process.stdout.write("\n");
+			continue;
+		}
+
+		// Determine status icon
+		let icon: string;
+		if (tool.latestError !== undefined || tool.upToDate === undefined) {
+			icon = muted("-");
+		} else if (tool.upToDate) {
+			icon = color.green("-");
+		} else {
+			icon = color.yellow("!");
+		}
+
+		process.stdout.write(`  ${icon} ${accent(tool.name)} ${muted(`(${tool.cli})`)}\n`);
+
+		// Version line
+		let versionLine = `Version: ${tool.version}`;
+		if (tool.latestError !== undefined) {
+			versionLine += ` ${muted("(version check failed)")}`;
+		} else if (tool.upToDate === true) {
+			versionLine += ` ${color.green("(up to date)")}`;
+		} else if (tool.upToDate === false) {
+			versionLine += ` ${color.yellow(`(outdated, latest: ${tool.latest})`)}`;
+		}
+		process.stdout.write(`    ${versionLine}\n`);
+
+		// Doctor summary (agentplate only)
+		if (tool.doctorSummary !== undefined) {
+			process.stdout.write(`    Doctor:  ${formatDoctorLine(tool.doctorSummary)}\n`);
+		}
+
+		process.stdout.write("\n");
+	}
+
+	const installed = results.filter((t) => t.installed).length;
+	const missing = results.filter((t) => !t.installed).length;
+	const outdated = results.filter(
+		(t) => t.installed && t.upToDate === false && t.latestError === undefined,
+	).length;
+
+	let summary = `Summary: ${installed}/${results.length} installed`;
+	if (missing > 0) summary += `, ${missing} missing`;
+	if (outdated > 0) summary += `, ${outdated} outdated`;
+	process.stdout.write(`${summary}\n`);
+}
+
+export async function executeEcosystem(opts: EcosystemOptions): Promise<void> {
+	const json = opts.json ?? false;
+
+	let results: ToolResult[];
+	try {
+		results = await Promise.all(TOOLS.map((tool) => checkTool(tool)));
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (json) {
+			jsonError("ecosystem", msg);
+		} else {
+			process.stderr.write(`Error: ${msg}\n`);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	if (json) {
+		const installed = results.filter((t) => t.installed).length;
+		const missing = results.filter((t) => !t.installed).length;
+		const outdated = results.filter(
+			(t) => t.installed && t.upToDate === false && t.latestError === undefined,
+		).length;
+
+		jsonOutput("ecosystem", {
+			tools: results.map((t) => {
+				const entry: Record<string, unknown> = {
+					name: t.name,
+					cli: t.cli,
+					npm: t.npm,
+					installed: t.installed,
+				};
+				if (t.installed) {
+					entry.version = t.version;
+					entry.latest = t.latest;
+					entry.upToDate = t.upToDate;
+					if (t.doctorSummary !== undefined) {
+						entry.doctorSummary = t.doctorSummary;
+					}
+					if (t.latestError !== undefined) {
+						entry.latestError = t.latestError;
+					}
+				}
+				return entry;
+			}),
+			summary: {
+				total: results.length,
+				installed,
+				missing,
+				outdated,
+			},
+		});
+		return;
+	}
+
+	printHumanOutput(results);
+}
+
+export function createEcosystemCommand(): Command {
+	return new Command("ecosystem")
+		.description("Show a summary dashboard of all installed ag-eco tools")
+		.option("--json", "Output as JSON")
+		.action(async (opts: EcosystemOptions) => {
+			await executeEcosystem(opts);
+		});
+}