magus-cli 7.5.3 → 7.6.0

package/src/__tests__/mate-availability.test.ts

@@ -23,7 +23,6 @@ const plugin = (overrides: Partial<PluginInfo> = {}): PluginInfo => ({
 	description: "",
 	marketplace: "magus",
 	marketplaceDisplay: "Magus",
-	enabled: true,
 	...overrides,
 });
 
@@ -43,9 +42,9 @@ describe("areMatesAvailable", () => {
 	test("true when it is installed at ANY scope", async () => {
 		// Any scope, because a mate is served by whatever Claude Code has loaded when the
 		// agent spawns — the union of the three. A user-scope install serves a project that
-		// enables nothing of its own.
+		// installs nothing of its own.
 		for (const scope of ["userScope", "projectScope", "localScope"] as const) {
-			const one = plugin({ [scope]: { enabled: true, version: "1.0.0" } });
+			const one = plugin({ [scope]: { installed: true, version: "1.0.0" } });
 			expect({
 				scope,
 				available: await areMatesAvailable(undefined, lister([one])),
@@ -54,27 +53,26 @@ describe("areMatesAvailable", () => {
 	});
 
 	/**
-	 * The enabled-but-not-installed state is NOT installed.
+	 * Files missing does not serve a mate.
 	 *
-	 * `enabledPlugins` is a flag only magus and the user maintain; the version comes from
-	 * the registry, which is what Claude Code actually loaded. Flag set with no version is the
-	 * broken state the plugin list already renders as "not installed" — and a mate row drawn
-	 * on the strength of it would promise routing through a plugin that never loaded.
+	 * Installed with no version is the broken state the plugin list renders as "files
+	 * missing": Claude Code wants to load the plugin and has nothing to load — and a mate row
+	 * drawn on the strength of it would promise routing through a plugin that never loaded.
 	 */
-	test("false when it is enabled but never actually installed", async () => {
-		const flagged = plugin({ userScope: { enabled: true } });
+	test("false when it is installed but its files are missing", async () => {
+		const flagged = plugin({ userScope: { installed: true } });
 		expect(await areMatesAvailable(undefined, lister([flagged]))).toBe(false);
 	});
 
-	test("false when it is installed but disabled", async () => {
+	test("false when only a registry row exists and it is not installed", async () => {
 		const off = plugin({
-			userScope: { enabled: false, version: "1.0.0" },
+			userScope: { installed: false, version: "1.0.0" },
 		});
 		expect(await areMatesAvailable(undefined, lister([off]))).toBe(false);
 	});
 
 	test('a version of "0.0.0" still counts — that is how some plugins record themselves', async () => {
-		const zero = plugin({ userScope: { enabled: true, version: "0.0.0" } });
+		const zero = plugin({ userScope: { installed: true, version: "0.0.0" } });
 		expect(await areMatesAvailable(undefined, lister([zero]))).toBe(true);
 	});
 

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

@@ -200,7 +200,6 @@ function makePlugin(overrides: Partial<PluginInfo> = {}): PluginInfo {
 		description: "Matt Pocock's agent skills",
 		marketplace: "mattpocock",
 		marketplaceDisplay: "Matt Pocock",
-		enabled: false,
 		source: "./",
 		...overrides,
 	};

package/src/__tests__/plugin-detail-scopes.test.tsx

@@ -0,0 +1,270 @@
+/**
+ * Spec 7.5.4 v3 — REQ-4: at each scope a plugin is installed or not, and the list row
+ * and the detail pane say the same thing.
+ *
+ * Written blind: from the spec and the exported signatures and interfaces only. Both
+ * surfaces are rendered into a character frame and read the way a user reads them.
+ *
+ * The item's `status` is `null` throughout: `PluginUpdateItem` is not part of the
+ * contract this test was given, and the spec derives every scope's display from its
+ * `ScopeStatus` alone.
+ */
+import { describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import { type ReactNode, act } from "react";
+import type { PluginInfo, ScopeStatus } from "../services/plugin-manager.js";
+import type { PluginPluginItem } from "../ui/adapters/pluginsAdapter.js";
+import {
+	renderPluginDetail,
+	renderPluginRow,
+} from "../ui/renderers/pluginRenderers.js";
+
+/** Newer than any scope's version, so an "update available" claim would be plausible. */
+const CATALOG_VERSION = "0.9.0";
+
+interface Scopes {
+	user?: ScopeStatus;
+	project?: ScopeStatus;
+	local?: ScopeStatus;
+}
+
+const SCOPE_NAMES = ["User", "Project", "Local"] as const;
+type ScopeName = (typeof SCOPE_NAMES)[number];
+const CHIP: Record<ScopeName, string> = { User: "u", Project: "p", Local: "l" };
+
+function pluginItem(scopes: Scopes): PluginPluginItem {
+	// The version that loads here: undefined unless some scope has a real install.
+	const loaded = [scopes.user, scopes.project, scopes.local].find(
+		(s) => s?.installed === true && s.version !== undefined,
+	);
+	const plugin: PluginInfo = {
+		id: "scopeprobe@magus",
+		name: "scopeprobe",
+		version: CATALOG_VERSION,
+		description: "Probe plugin for scope rendering.",
+		marketplace: "magus",
+		marketplaceDisplay: "Magus",
+		installedVersion: loaded?.version,
+		userScope: scopes.user,
+		projectScope: scopes.project,
+		localScope: scopes.local,
+	};
+	return {
+		id: `plugin:${plugin.id}`,
+		kind: "plugin",
+		label: plugin.name,
+		plugin,
+		isExpandable: false,
+		isExpanded: false,
+		status: null,
+	};
+}
+
+async function frameOf(
+	node: ReactNode,
+	width: number,
+	height: number,
+): Promise<string[]> {
+	const { captureCharFrame, renderOnce, renderer } = await testRender(
+		<box flexDirection="column">{node}</box>,
+		{ width, height },
+	);
+	await act(async () => {
+		await renderOnce();
+		await renderOnce();
+	});
+	const lines = captureCharFrame().split("\n");
+	await act(async () => renderer.destroy());
+	return lines;
+}
+
+function detailFrame(item: PluginPluginItem): Promise<string[]> {
+	return frameOf(renderPluginDetail(item, new Set<string>()), 120, 80);
+}
+
+function rowFrame(
+	item: PluginPluginItem,
+	isSelected: boolean,
+): Promise<string[]> {
+	return frameOf(renderPluginRow(item, 0, isSelected), 120, 3);
+}
+
+/** The `User` / `Project` / `Local` line under `Scopes:`. */
+function scopeLine(frame: string[], name: ScopeName): string {
+	const header = frame.findIndex((l) => l.includes("Scopes:"));
+	if (header === -1) {
+		throw new Error(
+			`no "Scopes:" section in the detail pane:\n${frame.join("\n")}`,
+		);
+	}
+	const pattern = new RegExp(`\\b${name}\\b`);
+	const line = frame.slice(header + 1).find((l) => pattern.test(l));
+	if (line === undefined) {
+		throw new Error(`no ${name} line under "Scopes:":\n${frame.join("\n")}`);
+	}
+	return line;
+}
+
+function dotOf(line: string): string | undefined {
+	return /[●○]/.exec(line)?.[0];
+}
+
+const V = "0.8.1";
+
+// ---------------------------------------------------------------------------
+// Detail pane, one scope at a time (REQ-4a..d on the Project line)
+// ---------------------------------------------------------------------------
+
+describe("REQ-4 the detail pane's Project line", () => {
+	test("REQ-4a installed with a version: ● and v0.8.1, not files missing", async () => {
+		const frame = await detailFrame(
+			pluginItem({ project: { installed: true, version: V } }),
+		);
+
+		const line = scopeLine(frame, "Project");
+		expect(dotOf(line)).toBe("●");
+		expect(line).toContain(`v${V}`);
+		expect(line).not.toContain("files missing");
+	});
+
+	test("REQ-4b not installed but a version recorded: ○, no 0.8.1, and never the word installed", async () => {
+		const frame = await detailFrame(
+			pluginItem({ project: { installed: false, version: V } }),
+		);
+
+		const line = scopeLine(frame, "Project");
+		expect(dotOf(line)).toBe("○");
+		expect(line).not.toContain(V);
+		expect(line).not.toMatch(/\binstalled\b/i);
+	});
+
+	test("REQ-4c installed with no version: ● and files missing", async () => {
+		const frame = await detailFrame(
+			pluginItem({ project: { installed: true } }),
+		);
+
+		const line = scopeLine(frame, "Project");
+		expect(dotOf(line)).toBe("●");
+		expect(line).toContain("files missing");
+	});
+
+	test("REQ-4d { installed: false } with no version: ○ and none of version, files missing, installed", async () => {
+		const frame = await detailFrame(
+			pluginItem({ project: { installed: false } }),
+		);
+
+		const line = scopeLine(frame, "Project");
+		expect(dotOf(line)).toBe("○");
+		expect(line).not.toContain(V);
+		expect(line).not.toContain("files missing");
+		expect(line).not.toMatch(/\binstalled\b/i);
+	});
+
+	test("REQ-4d an undefined scope: ○ and none of version, files missing, installed", async () => {
+		const frame = await detailFrame(pluginItem({}));
+
+		const line = scopeLine(frame, "Project");
+		expect(dotOf(line)).toBe("○");
+		expect(line).not.toContain(V);
+		expect(line).not.toContain("files missing");
+		expect(line).not.toMatch(/\binstalled\b/i);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// Structure and vocabulary of every scope line (REQ-4 layout, REQ-4e)
+// ---------------------------------------------------------------------------
+
+const STATES: Array<[label: string, status: ScopeStatus | undefined]> = [
+	["installed with version", { installed: true, version: V }],
+	["not installed, version recorded", { installed: false, version: V }],
+	["installed, no version", { installed: true }],
+	["not installed, no version", { installed: false }],
+	["undefined", undefined],
+];
+
+describe("REQ-4 every scope line is chip, dot, name — and never says enabled", () => {
+	for (const [label, status] of STATES) {
+		test(`REQ-4 / REQ-4e scope lines for "${label}" at every scope`, async () => {
+			for (const scope of SCOPE_NAMES) {
+				const scopes: Scopes = {};
+				if (scope === "User") scopes.user = status;
+				if (scope === "Project") scopes.project = status;
+				if (scope === "Local") scopes.local = status;
+
+				const frame = await detailFrame(pluginItem(scopes));
+
+				for (const name of SCOPE_NAMES) {
+					const line = scopeLine(frame, name);
+					const layout = new RegExp(
+						`(?:^|[^A-Za-z0-9])${CHIP[name]}[^A-Za-z0-9●○]*[●○]\\s*${name}\\b`,
+					);
+					expect({ scope, name, line, layout: layout.test(line) }).toEqual({
+						scope,
+						name,
+						line,
+						layout: true,
+					});
+					expect({ scope, name, line, enabled: /enabled/i.test(line) }).toEqual(
+						{ scope, name, line, enabled: false },
+					);
+				}
+			}
+		});
+	}
+});
+
+// ---------------------------------------------------------------------------
+// The list row agrees with the detail pane (REQ-4f)
+// ---------------------------------------------------------------------------
+
+describe("REQ-4f the list row's squares equal the detail pane's dots", () => {
+	const combos: Array<[boolean, boolean, boolean]> = [];
+	for (const u of [false, true]) {
+		for (const p of [false, true]) {
+			for (const l of [false, true]) combos.push([u, p, l]);
+		}
+	}
+
+	for (const isSelected of [false, true]) {
+		for (const [u, p, l] of combos) {
+			const name = `user=${u} project=${p} local=${l}`;
+			test(`REQ-4f ${name}, isSelected=${isSelected}`, async () => {
+				const item = pluginItem({
+					user: { installed: u, version: V },
+					project: { installed: p, version: V },
+					local: { installed: l, version: V },
+				});
+				const expectedSquares = [u, p, l].map((on) => (on ? "■" : "□"));
+				const expectedDots = [u, p, l].map((on) => (on ? "●" : "○"));
+
+				const row = await rowFrame(item, isSelected);
+				const detail = await detailFrame(item);
+
+				const squares = row.join("\n").match(/[■□]/g) ?? [];
+				const dots = SCOPE_NAMES.map((scope) =>
+					dotOf(scopeLine(detail, scope)),
+				);
+				expect(squares).toEqual(expectedSquares);
+				expect(dots).toEqual(expectedDots);
+				expect(squares.map((s) => (s === "■" ? "●" : "○"))).toEqual(dots);
+			});
+		}
+	}
+});
+
+// ---------------------------------------------------------------------------
+// No phantom version claim (REQ-4g)
+// ---------------------------------------------------------------------------
+
+describe("REQ-4g a recorded-but-not-installed version is not presented as installed", () => {
+	test("REQ-4g projectScope { installed: false, version: 0.8.1 } alone: no UPDATE AVAILABLE, no 0.8.1 installed", async () => {
+		const item = pluginItem({ project: { installed: false, version: V } });
+		expect(item.plugin.installedVersion).toBeUndefined();
+
+		const frame = (await detailFrame(item)).join("\n");
+
+		expect(frame).not.toMatch(/update available/i);
+		expect(frame).not.toContain(`${V} installed`);
+	});
+});

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

@@ -47,7 +47,6 @@ function info(over: Partial<PluginInfo> & { id: string }): PluginInfo {
 		description: "",
 		marketplace,
 		marketplaceDisplay: "",
-		enabled: true,
 		author: { name: "Anthropic" },
 		...over,
 	} as PluginInfo;
@@ -58,7 +57,7 @@ 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" },
+	projectScope: { installed: true, version: "3ea32df27be7" },
 });
 
 /** A registry "0.0.0" — the value the old row hid every status behind. */
@@ -66,7 +65,7 @@ const ZERO = info({
 	id: "zero-version@claude-plugins-official",
 	version: null,
 	installedVersion: "0.0.0",
-	projectScope: { enabled: true, version: "0.0.0" },
+	projectScope: { installed: true, version: "0.0.0" },
 });
 
 /** Other listed ids, so each marketplace demonstrably was read. */
@@ -147,7 +146,7 @@ describe("pluginRowText — orphans say what the CLI says (F9)", () => {
 			version: "1.8.0",
 			installedVersion: "1.8.0",
 			isOrphaned: true,
-			projectScope: { enabled: true, version: "1.8.0" },
+			projectScope: { installed: true, version: "1.8.0" },
 		});
 		const row = rows([seo]).get(seo.id) as PluginPluginItem;
 		expect(cliNote([seo], seo.id)).toBe(
@@ -165,7 +164,7 @@ describe("pluginRowText — orphans say what the CLI says (F9)", () => {
 			version: "2.0.0",
 			installedVersion: "2.0.0",
 			isOrphaned: true,
-			projectScope: { enabled: true, version: "2.0.0" },
+			projectScope: { installed: true, version: "2.0.0" },
 		});
 		const row = rows([gone]).get(gone.id) as PluginPluginItem;
 		expect(pluginRowText(row).text).toBe(
@@ -181,7 +180,7 @@ describe("pluginRowText — orphans say what the CLI says (F9)", () => {
 			id: "seo@magus",
 			installedVersion: "1.8.0",
 			isOrphaned: true,
-			projectScope: { enabled: true, version: "1.8.0" },
+			projectScope: { installed: true, version: "1.8.0" },
 		});
 		const { text } = pluginRowText(rows([seo]).get(seo.id) as PluginPluginItem);
 		expect(text).not.toContain("deprecated");
@@ -195,7 +194,7 @@ describe("pluginRowText — history badges combine with the state", () => {
 			id: "terminal@magus",
 			version: "3.3.1",
 			installedVersion: "3.0.1",
-			projectScope: { enabled: true, version: "3.0.1" },
+			projectScope: { installed: true, version: "3.0.1" },
 			author: { name: "MadAppGang" },
 			...over,
 		});
@@ -220,7 +219,7 @@ describe("pluginRowText — history badges combine with the state", () => {
 			recentlyInstalled: true,
 			version: "0.0.0",
 			installedVersion: "0.0.0",
-			projectScope: { enabled: true, version: "0.0.0" },
+			projectScope: { installed: true, version: "0.0.0" },
 		});
 		const row = rows([p]).get(p.id) as PluginPluginItem;
 		expect(pluginRowText(row).text).toBe(" new");
@@ -263,7 +262,7 @@ describe("pluginRowText — rows with no state claim none", () => {
 	});
 });
 
-describe("pluginStatusText — absent is not enabled-not-installed (LOW 6)", () => {
+describe("pluginStatusText — absent is not files-missing (LOW 6)", () => {
 	const status = (over: Partial<PluginUpdateItem>): PluginUpdateItem => ({
 		pluginId: "x@magus",
 		pinned: "latest",
@@ -285,32 +284,30 @@ describe("pluginStatusText — absent is not enabled-not-installed (LOW 6)", ()
 		});
 	});
 
-	test("enabled-not-installed shows its note and never claims a declaration", () => {
+	test("files-missing 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",
+				reason: "files-missing",
+				note: "files missing",
 			}),
 		);
 		expect(got).toEqual({
-			suffix: " not installed (enabled in settings, but no files on disk)",
+			suffix: " files missing",
 			tone: "danger",
 		});
 		expect(got.suffix).not.toContain("profile");
 	});
 
-	test("an undeclared enabled-but-not-installed ROW gets the enabled text", () => {
+	test("an undeclared files-missing ROW gets the files-missing text", () => {
 		const broken = info({
 			id: "kanban@magus",
 			version: "1.6.2",
 			author: { name: "MadAppGang" },
-			localScope: { enabled: true },
+			localScope: { installed: 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)",
-		);
+		expect(row.status?.reason).toBe("files-missing");
+		expect(pluginRowText(row).text).toBe(" files missing");
 	});
 
 	test("null status says nothing", () => {
@@ -357,7 +354,7 @@ describe("pluginRowText — a broken plugin says so, and names the key", () => {
 		version: "0.5.0",
 		installedVersion: "0.5.0",
 		loadedVersion: "0.3.0",
-		projectScope: { enabled: true, version: "0.5.0" },
+		projectScope: { installed: true, version: "0.5.0" },
 		author: { name: "MadAppGang" },
 	});
 
@@ -399,7 +396,7 @@ describe("pluginRowText — a broken plugin says so, and names the key", () => {
 			version: "0.5.0",
 			installedVersion: "0.5.0",
 			loadedVersion: "0.5.0",
-			projectScope: { enabled: true, version: "0.5.0" },
+			projectScope: { installed: true, version: "0.5.0" },
 			author: { name: "MadAppGang" },
 		});
 		const row = rows([healthy]).get("madbench@magus");

package/src/__tests__/profile-command.test.ts

@@ -136,7 +136,7 @@ describe("profile switch", () => {
 		expect((await fs.readJson(live)).enabledPlugins["terminal@magus"]).toBe(
 			true,
 		);
-		expect(logs.some((l) => l.includes("kept at"))).toBe(false);
+		expect(logs.some((l) => l.includes("Backed up"))).toBe(false);
 		expect(await fs.pathExists(join(dir, ".claude", ".magus-backups"))).toBe(
 			false,
 		);
@@ -147,7 +147,7 @@ describe("profile switch", () => {
 		await switchProfile("frontend", dir);
 		await switchProfile("backend", dir);
 		await switchProfile("frontend", dir);
-		expect(logs.some((l) => l.includes("kept at"))).toBe(false);
+		expect(logs.some((l) => l.includes("Backed up"))).toBe(false);
 		expect(await fs.pathExists(join(dir, ".claude", ".magus-backups"))).toBe(
 			false,
 		);

package/src/__tests__/profile-migration-offer.test.ts

@@ -6,10 +6,11 @@
  * update` carry on with a profile "for this run only" — resolving against a
  * manifest the project was not running. Two worlds live at once.
  *
- * The interactive path mounts a real OpenTUI renderer and cannot run here; what
- * IS testable is every path that must refuse, which is the behaviour that
- * changed. `selectDialog` returns null without a TTY, so a non-TTY run takes
- * the refusal branch by construction — which is also what CI does.
+ * The interactive path reads a numbered answer from a terminal and cannot run
+ * here; what IS testable is every path that must refuse, which is the
+ * behaviour that changed. Without a TTY the gate refuses before it asks, so a
+ * non-TTY run takes the refusal branch by construction — which is also what
+ * CI does.
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";