magus-cli 7.5.2 → 7.5.4

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";

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

@@ -17,6 +17,7 @@ import {
 	activationNotes,
 	recordRefetchedSkills,
 	trackFetchedSkills,
+	trackedGeneratedNotices,
 	updatableSkills,
 } from "../services/profile-activate.js";
 import {
@@ -360,7 +361,7 @@ describe("older layout: committed custom skills the seeding displaced come back"
 		});
 
 		expect(prep.lines).toContain(
-			'Converted profile "team" from the older layout to real files',
+			'Updated profile "team" to the current profile format',
 		);
 		expect(
 			git(
@@ -459,42 +460,36 @@ describe("older layout: committed custom skills the seeding displaced come back"
 		expect(again.problems).toEqual([]);
 	});
 
-	test("review 3b: a magus-installed folder someone committed is refused before the reconcile writes anything", async () => {
+	test("B7 review: a magus-installed folder someone committed is handed back to the team — kept, never warned about", async () => {
 		await start();
 		expect(git(project, "init", "-q").status).toBe(0);
 		expect(git(project, "add", "-f", ".claude/skills/alpha").status).toBe(0);
 		expect(git(project, "commit", "-q", "-m", "oops").status).toBe(0);
-		// A teammate drops alpha from the profile: the next reconcile would
-		// remove the folder, after recording the change in the marker.
+		expect(await trackedGeneratedNotices(project)).toEqual([]);
+		// A teammate drops alpha from the profile. Were it still magus's, the
+		// reconcile would delete the team's committed folder.
 		const pulled = manifest();
 		(pulled.profiles.team as { skills: ProfileSkillRef[] }).skills = [];
 		await writeManifest(pulled, project);
-		const marker = await fs.readFile(
-			join(project, ".claude", "profiles", "active.json"),
-			"utf8",
-		);
-		const manifestBytes = await fs.readFile(
-			join(project, ".claude", "profiles.json"),
-			"utf8",
-		);
 
 		const prep = await prepareProfileState(project, {
 			installSkill: fakeInstall,
 		});
 
-		expect(prep.problems[0]).toContain(
-			"git rm --cached -r .claude/skills/alpha",
+		expect(prep.problems).toEqual([]);
+		expect(prep.lines).toContain(
+			"Skill alpha is committed by the team — magus no longer manages it",
 		);
 		expect(await fs.pathExists(skill("alpha"))).toBe(true);
+		expect((await readActiveMarker(project))?.skills).toEqual({});
 		expect(
-			await fs.readFile(
-				join(project, ".claude", "profiles", "active.json"),
-				"utf8",
-			),
-		).toBe(marker);
-		expect(
-			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
-		).toBe(manifestBytes);
+			git(project, "status", "--porcelain", "--", ".claude/skills").stdout,
+		).toBe("");
+		// Said once: the marker no longer records it.
+		const again = await prepareProfileState(project, {
+			installSkill: fakeInstall,
+		});
+		expect(again.lines.join("\n")).not.toContain("committed by the team");
 	});
 
 	test("an existing folder is never overwritten; a differing copy is reported with both paths", async () => {