magus-cli 0.0.0-placeholder → 7.1.0

package/src/__tests__/plugin-releases.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+import {
+	MAX_RELEASES,
+	normalizeReleases,
+} from "../services/plugin-releases.js";
+import type { PluginRelease } from "../types/index.js";
+
+/** Narrow to a populated result, failing the test rather than the assertion's type. */
+function expectEntries(input: unknown): PluginRelease[] {
+	const out = normalizeReleases(input);
+	if (!out) throw new Error("expected releases, got undefined");
+	return out;
+}
+
+describe("normalizeReleases", () => {
+	test("passes through a well-formed entry", () => {
+		expect(
+			normalizeReleases([
+				{
+					version: "3.3.0",
+					date: "2026-07-29",
+					kinds: ["Changed", "Fixed"],
+					summary: "Model resolution is now live",
+				},
+			]),
+		).toEqual([
+			{
+				version: "3.3.0",
+				date: "2026-07-29",
+				kinds: ["Changed", "Fixed"],
+				summary: "Model resolution is now live",
+			},
+		]);
+	});
+
+	test("omits optional fields rather than emitting undefined", () => {
+		const [entry] = expectEntries([
+			{ version: "1.0.0", summary: "First release" },
+		]);
+		expect(entry).toEqual({ version: "1.0.0", summary: "First release" });
+		expect("date" in entry).toBe(false);
+		expect("kinds" in entry).toBe(false);
+	});
+
+	test("returns undefined for anything that is not an array", () => {
+		for (const input of [undefined, null, "3.3.0", 7, {}, true]) {
+			expect(normalizeReleases(input)).toBeUndefined();
+		}
+	});
+
+	// The manifest is fetched over the network, so no field's type can be assumed.
+	test("drops entries missing or mistyping the required fields", () => {
+		expect(
+			normalizeReleases([
+				{ version: "1.0.0", summary: "kept" },
+				{ version: "1.0.1" }, // no summary
+				{ summary: "no version" },
+				{ version: 2, summary: "version is a number" },
+				{ version: "1.0.2", summary: 42 },
+				{ version: "  ", summary: "blank version" },
+				{ version: "1.0.3", summary: "   " },
+				null,
+				"not an object",
+			]),
+		).toEqual([{ version: "1.0.0", summary: "kept" }]);
+	});
+
+	test("returns undefined when every entry is unusable", () => {
+		expect(normalizeReleases([{ nope: true }, null])).toBeUndefined();
+		expect(normalizeReleases([])).toBeUndefined();
+	});
+
+	test("caps the list so one manifest cannot flood the panel", () => {
+		const many = Array.from({ length: 500 }, (_, i) => ({
+			version: `1.0.${i}`,
+			summary: `entry ${i}`,
+		}));
+		const out = expectEntries(many);
+		expect(out).toHaveLength(MAX_RELEASES);
+		// Newest-first ordering is preserved — the cap takes the head, not the tail.
+		expect(out[0].version).toBe("1.0.0");
+	});
+
+	test("keeps only string members of kinds", () => {
+		const [entry] = expectEntries([
+			{ version: "1.0.0", summary: "x", kinds: ["Added", 3, null, "Fixed"] },
+		]);
+		expect(entry.kinds).toEqual(["Added", "Fixed"]);
+	});
+
+	test("trims surrounding whitespace", () => {
+		expect(
+			normalizeReleases([
+				{ version: " 1.0.0 ", date: " 2026-07-29 ", summary: "  padded  " },
+			]),
+		).toEqual([{ version: "1.0.0", date: "2026-07-29", summary: "padded" }]);
+	});
+});

package/src/__tests__/plugin-requires.test.ts

@@ -0,0 +1,187 @@
+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";
+import fs from "fs-extra";
+import {
+	parsePluginRequires,
+	readPluginRequires,
+} from "../services/plugin-requires.js";
+
+describe("parsePluginRequires", () => {
+	test("parses a valid requires.bin and fills defaults", () => {
+		const requires = parsePluginRequires({
+			name: "terminal",
+			requires: {
+				bin: [
+					{ name: "tmux", via: "brew", formula: "tmux", check: "tmux -V" },
+					{ name: "tmux-mcp", via: "bun", package: "tmux-mcp" },
+				],
+			},
+		});
+		expect(requires.bin).toHaveLength(2);
+		const tmux = requires.bin!.find((b) => b.name === "tmux")!;
+		expect(tmux.via).toBe("brew");
+		expect(tmux.check).toBe("tmux -V");
+		const mcp = requires.bin!.find((b) => b.name === "tmux-mcp")!;
+		// check defaulted from the name
+		expect(mcp.check).toBe("tmux-mcp --version");
+	});
+
+	test("drops entries with no name or an unknown installer", () => {
+		const requires = parsePluginRequires({
+			requires: {
+				bin: [
+					{ via: "bun" }, // no name
+					{ name: "x", via: "cargo" }, // unknown installer
+					{ name: "ok", via: "npm" },
+				],
+			},
+		});
+		expect(requires.bin).toHaveLength(1);
+		expect(requires.bin![0]!.name).toBe("ok");
+	});
+
+	test("no requires / non-array bin → empty object", () => {
+		expect(parsePluginRequires({ name: "x" })).toEqual({});
+		expect(parsePluginRequires({ requires: {} })).toEqual({});
+		expect(parsePluginRequires({ requires: { bin: "nope" } })).toEqual({});
+		expect(parsePluginRequires(null)).toEqual({});
+	});
+});
+
+describe("parsePluginRequires — setup block (the established convention)", () => {
+	test("terminal's setup: go module + required system tool", () => {
+		// The real plugins/terminal/plugin.json shape.
+		const r = parsePluginRequires({
+			name: "terminal",
+			setup: {
+				go: ["github.com/MadAppGang/tmux-mcp@latest"],
+				required: ["tmux"],
+			},
+		});
+		const mcp = r.bin!.find((b) => b.name === "tmux-mcp")!;
+		expect(mcp.via).toBe("go");
+		expect(mcp.module).toBe("github.com/MadAppGang/tmux-mcp");
+		expect(mcp.version).toBe("latest");
+		const tmux = r.bin!.find((b) => b.name === "tmux")!;
+		expect(tmux.via).toBe("brew");
+		expect(tmux.formula).toBe("tmux");
+	});
+
+	// Negative control for the /vN fix: basename(base) yields "v2" here, so
+	// without the go-module helper this test FAILS on `name`.
+	test("terminal's v2 pin: /v2 is the module's major version, not the binary", () => {
+		const r = parsePluginRequires({
+			name: "terminal",
+			setup: { go: ["github.com/MadAppGang/tmux-mcp/v2@v2.0.0"] },
+		});
+		expect(r.bin).toEqual([
+			{
+				name: "tmux-mcp",
+				via: "go",
+				module: "github.com/MadAppGang/tmux-mcp/v2",
+				version: "v2.0.0",
+				check: "tmux-mcp --version",
+			},
+		]);
+	});
+
+	// One manifest per spec: entries are keyed by binary name, so a v1 and a v2
+	// pin of the same module in ONE setup would (correctly) collapse to one.
+	test.each([
+		[
+			"github.com/MadAppGang/tmux-mcp@v1.7.1",
+			{
+				name: "tmux-mcp",
+				module: "github.com/MadAppGang/tmux-mcp",
+				version: "v1.7.1",
+			},
+		],
+		[
+			"github.com/MadAppGang/tmux-mcp/v2",
+			{
+				name: "tmux-mcp",
+				module: "github.com/MadAppGang/tmux-mcp/v2",
+				version: undefined,
+			},
+		],
+		[
+			"github.com/x/v2tool@v1.0.0",
+			{ name: "v2tool", module: "github.com/x/v2tool", version: "v1.0.0" },
+		],
+	])("go spec %s → name/module/version", (spec, expected) => {
+		const r = parsePluginRequires({ setup: { go: [spec] } });
+		expect(
+			r.bin!.map((b) => ({
+				name: b.name,
+				module: b.module,
+				version: b.version,
+			})),
+		).toEqual([expected]);
+	});
+
+	test("browser-use's setup: pip packages", () => {
+		const r = parsePluginRequires({
+			name: "browser-use",
+			setup: { pip: ["browser-use", "mcp"] },
+		});
+		expect(r.bin!.map((b) => b.name).sort()).toEqual(["browser-use", "mcp"]);
+		expect(r.bin!.every((b) => b.via === "pip")).toBe(true);
+	});
+
+	test("bun/npm specs split name@version", () => {
+		const r = parsePluginRequires({
+			setup: { bun: ["claudish@1.2.0"], npm: ["@scope/tool@3.0.0"] },
+		});
+		const claudish = r.bin!.find((b) => b.name === "claudish")!;
+		expect(claudish.version).toBe("1.2.0");
+		const scoped = r.bin!.find((b) => b.name === "tool")!;
+		expect(scoped.package).toBe("@scope/tool");
+		expect(scoped.version).toBe("3.0.0");
+	});
+
+	test("explicit requires.bin overrides a setup entry of the same name", () => {
+		const r = parsePluginRequires({
+			setup: { required: ["tmux"] }, // → brew
+			requires: {
+				bin: [{ name: "tmux", via: "go", module: "example.com/tmux" }],
+			},
+		});
+		const tmux = r.bin!.find((b) => b.name === "tmux")!;
+		expect(tmux.via).toBe("go"); // requires.bin won
+	});
+});
+
+describe("readPluginRequires", () => {
+	let dir: string;
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "plugreq-"));
+	});
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	test("reads plugin.json at the plugin root", async () => {
+		await fs.writeJson(join(dir, "plugin.json"), {
+			name: "p",
+			requires: { bin: [{ name: "tmux", via: "brew" }] },
+		});
+		const r = await readPluginRequires(dir);
+		expect(r.bin?.[0]?.name).toBe("tmux");
+	});
+
+	test("falls back to .claude-plugin/plugin.json", async () => {
+		await fs.ensureDir(join(dir, ".claude-plugin"));
+		await fs.writeJson(join(dir, ".claude-plugin", "plugin.json"), {
+			name: "p",
+			requires: { bin: [{ name: "mnemex", via: "bun" }] },
+		});
+		const r = await readPluginRequires(dir);
+		expect(r.bin?.[0]?.name).toBe("mnemex");
+	});
+
+	test("missing manifest → empty", async () => {
+		expect(await readPluginRequires(dir)).toEqual({});
+	});
+});

package/src/__tests__/plugin-row-text.test.ts

@@ -0,0 +1,345 @@
+import { describe, expect, test } from "bun:test";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import {
+	type PluginUpdateItem,
+	classifyPluginRows,
+	planPluginUpdates,
+} from "../services/update-plan.js";
+import type { Marketplace } from "../types/index.js";
+import {
+	type PluginPluginItem,
+	buildPluginBrowserItems,
+} from "../ui/adapters/pluginsAdapter.js";
+import { pluginRowText } from "../ui/renderers/pluginRowText.js";
+import { pluginStatusText } from "../ui/renderers/pluginStatusText.js";
+
+/**
+ * `pluginRowText` is exactly what a Plugins row prints after the name, in
+ * every branch of `pluginRow` — selected, unselected, orphan. So asserting on
+ * it asserts on the screen.
+ *
+ * Rows here are built the way the screen builds them: `classifyPluginRows` over
+ * the plugin list and the profile's pins, then `buildPluginBrowserItems`. The
+ * note each row must contain is taken from `planPluginUpdates` — the CLI's own
+ * answer — never retyped, so the two front ends are compared, not two copies.
+ */
+
+const OFFICIAL: Marketplace = {
+	name: "claude-plugins-official",
+	displayName: "Anthropic Official",
+	source: { source: "github", repo: "anthropics/claude-plugins-official" },
+	description: "",
+} as Marketplace;
+
+const MAGUS: Marketplace = {
+	name: "magus",
+	displayName: "Magus",
+	source: { source: "github", repo: "MadAppGang/magus" },
+	description: "",
+	owned: true,
+} as Marketplace;
+
+function info(over: Partial<PluginInfo> & { id: string }): PluginInfo {
+	const [name, marketplace] = over.id.split("@");
+	return {
+		name,
+		version: null,
+		description: "",
+		marketplace,
+		marketplaceDisplay: "",
+		enabled: true,
+		author: { name: "Anthropic" },
+		...over,
+	} as PluginInfo;
+}
+
+/** Real: `code-review@claude-plugins-official` in /Users/jack/mag/claudish. */
+const CODE_REVIEW = info({
+	id: "code-review@claude-plugins-official",
+	version: null, // the official catalog publishes no version for it
+	installedVersion: "3ea32df27be7",
+	projectScope: { enabled: true, version: "3ea32df27be7" },
+});
+
+/** A registry "0.0.0" — the value the old row hid every status behind. */
+const ZERO = info({
+	id: "zero-version@claude-plugins-official",
+	version: null,
+	installedVersion: "0.0.0",
+	projectScope: { enabled: true, version: "0.0.0" },
+});
+
+/** Other listed ids, so each marketplace demonstrably was read. */
+const LISTED = [
+	info({ id: "dev@magus", version: "4.7.0", author: { name: "MadAppGang" } }),
+	info({ id: "github@claude-plugins-official", version: null }),
+];
+
+function rows(
+	plugins: PluginInfo[],
+	pins: Record<string, string> = {},
+): Map<string, PluginPluginItem> {
+	const all = [...plugins, ...LISTED];
+	const items = buildPluginBrowserItems({
+		marketplaces: [MAGUS, OFFICIAL],
+		plugins: all,
+		collapsedMarketplaces: new Set(),
+		statuses: classifyPluginRows(all, pins),
+	});
+	return new Map(
+		items
+			.filter((i): i is PluginPluginItem => i.kind === "plugin")
+			.map((i) => [i.plugin.id, i]),
+	);
+}
+
+/** The note `magus update` prints for this plugin under this pin. */
+function cliNote(
+	plugins: PluginInfo[],
+	id: string,
+	pin = "latest",
+): string | undefined {
+	const all = [...plugins, ...LISTED];
+	const [item] = planPluginUpdates(
+		{ [id]: pin },
+		new Map(all.map((p) => [p.id, p])),
+	);
+	return item?.note;
+}
+
+describe("pluginRowText — a status never depends on a displayable version", () => {
+	// A sha install against a catalog that publishes no version is `current`
+	// now — we assume what is installed is the latest rather than warning about
+	// a comparison that can never be made. R2 still holds and is still the point
+	// of this file: whatever the CLI says, the row says, word for word.
+	test("a sha-versioned install says exactly what the CLI says", () => {
+		const row = rows([CODE_REVIEW]).get(CODE_REVIEW.id) as PluginPluginItem;
+		expect(row.status?.action).toBe("current");
+		// No note means no suffix. The row is the version and nothing else.
+		expect(cliNote([CODE_REVIEW], CODE_REVIEW.id)).toBeUndefined();
+		const { text } = pluginRowText(row);
+		expect(text).toBe(" v3ea32df27be7");
+		// The row never invents a vocabulary the CLI does not use.
+		expect(text).not.toContain("not comparable");
+		expect(text).not.toContain("?");
+	});
+
+	test('a "0.0.0" install is never printed as a version', () => {
+		// "0.0.0" means installed with an unknown version — Anthropic's official
+		// plugins record exactly that. It is not a version anyone can act on, so
+		// it is never shown, and no status clause may be gated on showing it.
+		const row = rows([ZERO]).get(ZERO.id) as PluginPluginItem;
+		expect(row.status?.action).toBe("current");
+		const { text } = pluginRowText(row);
+		expect(text).not.toContain("0.0.0");
+		expect(text).toBe(cliNote([ZERO], ZERO.id) ?? "");
+	});
+});
+
+describe("pluginRowText — orphans say what the CLI says (F9)", () => {
+	// The row NEVER guesses where an orphan went. That guess was a bare name
+	// match, and it cannot tell a move from a dual publication: claudish ships
+	// to two marketplaces with both copies installed, and the row announced
+	// "moved → magus" about a plugin that had not moved anywhere.
+	test("an orphan is 'not offered', and never names a destination", () => {
+		const seo = info({
+			id: "seo@magus",
+			version: "1.8.0",
+			installedVersion: "1.8.0",
+			isOrphaned: true,
+			projectScope: { enabled: true, version: "1.8.0" },
+		});
+		const row = rows([seo]).get(seo.id) as PluginPluginItem;
+		expect(cliNote([seo], seo.id)).toBe(
+			"not offered by any configured marketplace",
+		);
+		expect(pluginRowText(row).text).toBe(
+			" v1.8.0 ? not offered by any configured marketplace",
+		);
+		expect(pluginRowText(row).text).not.toMatch(/moved/i);
+	});
+
+	test("an orphan from a marketplace we DID read is 'not offered'", () => {
+		const gone = info({
+			id: "gone@magus",
+			version: "2.0.0",
+			installedVersion: "2.0.0",
+			isOrphaned: true,
+			projectScope: { enabled: true, version: "2.0.0" },
+		});
+		const row = rows([gone]).get(gone.id) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(
+			` v2.0.0 ? ${cliNote([gone], gone.id)}`,
+		);
+		expect(pluginRowText(row).text).toContain(
+			"not offered by any configured marketplace",
+		);
+	});
+
+	test("the old words are gone: no 'deprecated', no 'moved →'", () => {
+		const seo = info({
+			id: "seo@magus",
+			installedVersion: "1.8.0",
+			isOrphaned: true,
+			projectScope: { enabled: true, version: "1.8.0" },
+		});
+		const { text } = pluginRowText(rows([seo]).get(seo.id) as PluginPluginItem);
+		expect(text).not.toContain("deprecated");
+		expect(text).not.toContain("moved →");
+	});
+});
+
+describe("pluginRowText — history badges combine with the state", () => {
+	const updated = (over: Partial<PluginInfo>) =>
+		info({
+			id: "terminal@magus",
+			version: "3.3.1",
+			installedVersion: "3.0.1",
+			projectScope: { enabled: true, version: "3.0.1" },
+			author: { name: "MadAppGang" },
+			...over,
+		});
+
+	test("'updated' and a pending update are both shown", () => {
+		// An external update moved 2.9.0 → 3.0.1 while 3.3.1 is already out.
+		const p = updated({ recentlyUpdatedFrom: "2.9.0" });
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		const { text, segments } = pluginRowText(row);
+		expect(text).toBe(" v2.9.0 → v3.0.1 updated → v3.3.1 available");
+		expect(segments.map((s) => s.tone)).toEqual(["success", "warning"]);
+	});
+
+	test("'new' and a pending update are both shown", () => {
+		const p = updated({ recentlyInstalled: true });
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(" v3.0.1 new → v3.3.1 available");
+	});
+
+	test("'new' with no displayable version still says new", () => {
+		const p = updated({
+			recentlyInstalled: true,
+			version: "0.0.0",
+			installedVersion: "0.0.0",
+			projectScope: { enabled: true, version: "0.0.0" },
+		});
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(" new");
+	});
+
+	test("a current row shows only its version", () => {
+		const p = updated({
+			version: "3.0.1",
+		});
+		const row = rows([p]).get(p.id) as PluginPluginItem;
+		expect(row.status?.action).toBe("current");
+		expect(pluginRowText(row).text).toBe(" v3.0.1");
+	});
+});
+
+describe("pluginRowText — rows with no state claim none", () => {
+	test("an undeclared, uninstalled catalog entry has no status and no text", () => {
+		const browse = info({
+			id: "kanban@magus",
+			version: "1.6.2",
+			author: { name: "MadAppGang" },
+		});
+		const row = rows([browse]).get(browse.id) as PluginPluginItem;
+		expect(row.status).toBeNull();
+		expect(pluginRowText(row).text).toBe("");
+	});
+
+	test("the same entry DECLARED by the profile says the profile wants it", () => {
+		const declared = info({
+			id: "kanban@magus",
+			version: "1.6.2",
+			author: { name: "MadAppGang" },
+		});
+		const row = rows([declared], { "kanban@magus": "latest" }).get(
+			declared.id,
+		) as PluginPluginItem;
+		expect(pluginRowText(row).text).toBe(
+			" not installed — profile declares it",
+		);
+	});
+});
+
+describe("pluginStatusText — absent is not enabled-not-installed (LOW 6)", () => {
+	const status = (over: Partial<PluginUpdateItem>): PluginUpdateItem => ({
+		pluginId: "x@magus",
+		pinned: "latest",
+		installed: null,
+		available: "1.0.0",
+		target: "1.0.0",
+		action: "install",
+		reason: "absent",
+		scopes: [],
+		beforeVersions: {},
+		...over,
+	});
+
+	test("absent — only ever from a profile pin — may say the profile declares it", () => {
+		expect(pluginStatusText(status({}))).toEqual({
+			suffix: " not installed — profile declares it",
+			tone: "warning",
+		});
+	});
+
+	test("enabled-not-installed shows its note and never claims a declaration", () => {
+		const got = pluginStatusText(
+			status({
+				reason: "enabled-not-installed",
+				note: "enabled in settings, but no files on disk",
+			}),
+		);
+		expect(got).toEqual({
+			suffix: " not installed (enabled in settings, but no files on disk)",
+			tone: "danger",
+		});
+		expect(got.suffix).not.toContain("profile");
+	});
+
+	test("an undeclared enabled-but-not-installed ROW gets the enabled text", () => {
+		const broken = info({
+			id: "kanban@magus",
+			version: "1.6.2",
+			author: { name: "MadAppGang" },
+			localScope: { enabled: true },
+		});
+		const row = rows([broken]).get(broken.id) as PluginPluginItem;
+		expect(row.status?.reason).toBe("enabled-not-installed");
+		expect(pluginRowText(row).text).toBe(
+			" not installed (enabled in settings, but no files on disk)",
+		);
+	});
+
+	test("null status says nothing", () => {
+		expect(pluginStatusText(null)).toEqual({ suffix: "", tone: "muted" });
+	});
+
+	test("update with a pin-undeliverable note carries it", () => {
+		expect(
+			pluginStatusText(
+				status({
+					action: "update",
+					reason: "pin-undeliverable",
+					target: "9.9.9",
+					note: "manifest pins 4.6.1; the marketplace offers only 9.9.9",
+				}),
+			).suffix,
+		).toBe(
+			" → v9.9.9 available (manifest pins 4.6.1; the marketplace offers only 9.9.9)",
+		);
+	});
+
+	test("repair carries its note", () => {
+		expect(
+			pluginStatusText(
+				status({
+					action: "repair",
+					reason: "content-stale",
+					note: "files changed without a version bump",
+				}),
+			).suffix,
+		).toBe(" stale — reinstall (files changed without a version bump)");
+	});
+});