magus-cli 7.7.0 → 7.9.0

package/src/__tests__/blind-780-deprecated.test.ts

@@ -0,0 +1,631 @@
+/**
+ * magus 7.8.0 QA spec, section D — deprecated plugins.
+ *
+ * Written blind: from the spec and the exported signatures of
+ * services/update-plan.ts, services/update-engine.ts,
+ * ui/renderers/pluginStatusText.ts and cli/update-view.ts. No function body
+ * was read.
+ *
+ * Coverage map (requirement → describe block):
+ *   D1 unlisted by a READ marketplace → remove/deprecated   → "D1"
+ *   D2 remove scopes = installed scopes ([] if declared only) → "D2"
+ *   D3 unread marketplace → unknown/marketplace-unread      → "D3"
+ *   D4 pluginNeedsWork is true for remove                   → "D4"
+ *   D5 apply: uninstall each scope, drop from profile, verify → "D5"
+ *   D6 Plugins row text                                     → "D6"
+ *   D7 CLI view Deprecated group                            → "D7"
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { setColorEnabled, stripAnsi } from "../cli/ansi.js";
+import { planReport } from "../cli/update-view.js";
+import type { PluginScope } from "../services/claude-cli.js";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import {
+	type ApplyReporter,
+	type PluginApplyDeps,
+	type PluginRemoveDeps,
+	applyPlugins,
+	planWorkItems,
+	pluginName,
+	pluginNeedsWork,
+} from "../services/update-engine.js";
+import {
+	type PluginUpdateItem,
+	type UpdatePlan,
+	classifyPlugin,
+	indexCatalog,
+	planHasWork,
+	planIsBehind,
+	planPluginUpdates,
+} from "../services/update-plan.js";
+import { pluginStatusText } from "../ui/renderers/pluginStatusText.js";
+
+const PROJECT = "/tmp/blind-780-project";
+const SCOPES: PluginScope[] = ["user", "project", "local"];
+
+afterEach(() => setColorEnabled(null));
+
+// ---------------------------------------------------------------------------
+// Builders
+// ---------------------------------------------------------------------------
+
+function info(over: Partial<PluginInfo> & { id: string }): PluginInfo {
+	return {
+		name: over.id.split("@")[0] as string,
+		version: null,
+		description: "",
+		marketplace: over.id.split("@")[1] ?? "magus",
+		marketplaceDisplay: "",
+		...over,
+	};
+}
+
+/** A plugin the marketplace publishes — which is what makes "magus" a READ marketplace. */
+const LISTED = info({
+	id: "alive@magus",
+	version: "1.0.0",
+	projectScope: { installed: true, version: "1.0.0" },
+});
+
+/** Installed here, but its marketplace (which we read) does not list it. */
+function orphan(id: string, scopes: Partial<Record<PluginScope, string>>) {
+	return info({
+		id,
+		version: scopes.project ?? scopes.user ?? scopes.local ?? null,
+		isOrphaned: true,
+		userScope: scopes.user
+			? { installed: true, version: scopes.user }
+			: undefined,
+		projectScope: scopes.project
+			? { installed: true, version: scopes.project }
+			: undefined,
+		localScope: scopes.local
+			? { installed: true, version: scopes.local }
+			: undefined,
+	});
+}
+
+function itemFor(
+	items: PluginUpdateItem[],
+	pluginId: string,
+): PluginUpdateItem {
+	const found = items.find((i) => i.pluginId === pluginId);
+	if (!found) throw new Error(`${pluginId} not planned`);
+	return found;
+}
+
+function removeItem(over: Partial<PluginUpdateItem> = {}): PluginUpdateItem {
+	return {
+		pluginId: "old@magus",
+		pinned: "latest",
+		installed: "0.9.0",
+		loaded: "0.9.0",
+		available: null,
+		target: null,
+		action: "remove",
+		reason: "deprecated",
+		scopes: ["project"],
+		beforeVersions: { project: "0.9.0" },
+		...over,
+	};
+}
+
+/**
+ * A machine: which scopes each plugin is installed at, and which plugins the
+ * profile lists. The remove deps act on it; the other deps must not be called.
+ */
+function machine(
+	installed: Record<string, PluginScope[]>,
+	profile: string[],
+	behaviour: {
+		uninstallThrows?: boolean;
+		uninstallIsNoop?: boolean;
+		dropReturns?: boolean;
+	} = {},
+) {
+	const state = {
+		installed: new Map(
+			Object.entries(installed).map(([k, v]) => [k, new Set(v)]),
+		),
+		profile: new Set(profile),
+		uninstalls: [] as Array<{ id: string; scope: PluginScope }>,
+		drops: [] as Array<{ id: string; profile: string | null | undefined }>,
+		otherCalls: [] as string[],
+	};
+	const remove: PluginRemoveDeps = {
+		uninstall: async (id, scope) => {
+			state.uninstalls.push({ id, scope });
+			if (behaviour.uninstallThrows) throw new Error("uninstall exploded");
+			if (!behaviour.uninstallIsNoop) state.installed.get(id)?.delete(scope);
+		},
+		isInstalled: async (id, scope) =>
+			state.installed.get(id)?.has(scope) ?? false,
+		dropFromProfile: async (id, _project, profile) => {
+			state.drops.push({ id, profile });
+			if (behaviour.dropReturns === false) return false;
+			state.profile.delete(id);
+			return !state.profile.has(id);
+		},
+	};
+	const unexpected = (name: string) => async () => {
+		state.otherCalls.push(name);
+		throw new Error(`${name} must not be called for a remove`);
+	};
+	const deps: PluginApplyDeps = {
+		install: unexpected("install"),
+		update: unexpected("update"),
+		repair: unexpected("repair"),
+		readInstalled: async () => null,
+		saveInstalled: unexpected("saveInstalled"),
+		repairStaleLoad: unexpected("repairStaleLoad"),
+		remove,
+	};
+	return { deps, state };
+}
+
+function recordingReporter() {
+	const finished: Array<{ ok: boolean; name: string; detail: string }> = [];
+	const reporter: ApplyReporter = {
+		begin: () => {},
+		finish: (ok, name, detail) => finished.push({ ok, name, detail }),
+		detach: (work) => work(),
+	};
+	return { reporter, finished };
+}
+
+// ---------------------------------------------------------------------------
+// D1 / D2 / D3 — the planner
+// ---------------------------------------------------------------------------
+
+describe("D1 a plugin its READ marketplace does not list is deprecated", () => {
+	test("D1 installed at project scope, unlisted → remove / deprecated", () => {
+		const items = planPluginUpdates({}, [
+			LISTED,
+			orphan("old@magus", { project: "0.9.0" }),
+		]);
+
+		const old = itemFor(items, "old@magus");
+		expect({ action: old.action, reason: old.reason }).toEqual({
+			action: "remove",
+			reason: "deprecated",
+		});
+	});
+
+	test("D1 declared by the profile only, installed nowhere, unlisted → remove / deprecated", () => {
+		const items = planPluginUpdates({ "gone@magus": "latest" }, [LISTED]);
+
+		const gone = itemFor(items, "gone@magus");
+		expect({ action: gone.action, reason: gone.reason }).toEqual({
+			action: "remove",
+			reason: "deprecated",
+		});
+	});
+
+	test("D1 declared by the profile under an exact pin and unlisted → still deprecated", () => {
+		const items = planPluginUpdates({ "gone@magus": "1.2.3" }, [LISTED]);
+
+		expect(itemFor(items, "gone@magus").reason).toBe("deprecated");
+	});
+
+	test("D1 declared AND installed, unlisted → remove / deprecated", () => {
+		const items = planPluginUpdates({ "old@magus": "latest" }, [
+			LISTED,
+			orphan("old@magus", { user: "0.9.0" }),
+		]);
+
+		expect(itemFor(items, "old@magus").action).toBe("remove");
+	});
+
+	test("D1 the same through classifyPlugin over indexCatalog", () => {
+		const index = indexCatalog([
+			LISTED,
+			orphan("old@magus", { local: "0.9.0" }),
+		]);
+
+		const old = classifyPlugin("old@magus", "latest", index);
+
+		expect({ action: old.action, reason: old.reason }).toEqual({
+			action: "remove",
+			reason: "deprecated",
+		});
+	});
+
+	test("D1 the listed plugin beside it is not deprecated", () => {
+		const items = planPluginUpdates({}, [
+			LISTED,
+			orphan("old@magus", { project: "0.9.0" }),
+		]);
+
+		expect(itemFor(items, "alive@magus").action).not.toBe("remove");
+	});
+});
+
+describe("D2 scopes of a remove item", () => {
+	test("D2 one installed scope → exactly that scope", () => {
+		const items = planPluginUpdates({}, [
+			LISTED,
+			orphan("old@magus", { project: "0.9.0" }),
+		]);
+
+		expect(itemFor(items, "old@magus").scopes).toEqual(["project"]);
+	});
+
+	test("D2 installed at user and local → both, and nothing else", () => {
+		const items = planPluginUpdates({}, [
+			LISTED,
+			orphan("old@magus", { user: "0.9.0", local: "0.8.0" }),
+		]);
+
+		expect([...itemFor(items, "old@magus").scopes].sort()).toEqual([
+			"local",
+			"user",
+		]);
+	});
+
+	test("D2 installed at all three scopes → all three", () => {
+		const items = planPluginUpdates({}, [
+			LISTED,
+			orphan("old@magus", { user: "0.9.0", project: "0.9.0", local: "0.9.0" }),
+		]);
+
+		expect([...itemFor(items, "old@magus").scopes].sort()).toEqual([
+			"local",
+			"project",
+			"user",
+		]);
+	});
+
+	test("D2 declared only → scopes is empty", () => {
+		const items = planPluginUpdates({ "gone@magus": "latest" }, [LISTED]);
+
+		expect(itemFor(items, "gone@magus").scopes).toEqual([]);
+	});
+});
+
+describe("D3 a plugin whose marketplace was NOT read", () => {
+	test("D3 installed, its marketplace contributes no listed id → unknown / marketplace-unread", () => {
+		const items = planPluginUpdates({}, [
+			LISTED,
+			orphan("thing@unread-market", { project: "1.0.0" }),
+		]);
+
+		const thing = itemFor(items, "thing@unread-market");
+		expect({ action: thing.action, reason: thing.reason }).toEqual({
+			action: "unknown",
+			reason: "marketplace-unread",
+		});
+	});
+
+	test("D3 declared by the profile and installed, marketplace unread → unknown, not remove", () => {
+		const items = planPluginUpdates({ "thing@unread-market": "latest" }, [
+			LISTED,
+			orphan("thing@unread-market", { user: "1.0.0" }),
+		]);
+
+		const thing = itemFor(items, "thing@unread-market");
+		expect({ action: thing.action, reason: thing.reason }).toEqual({
+			action: "unknown",
+			reason: "marketplace-unread",
+		});
+	});
+
+	test("D3 declared only, marketplace unread → never planned as a removal", () => {
+		const items = planPluginUpdates({ "thing@unread-market": "latest" }, [
+			LISTED,
+		]);
+
+		const thing = itemFor(items, "thing@unread-market");
+		expect(thing.action).not.toBe("remove");
+		expect(thing.reason).not.toBe("deprecated");
+	});
+
+	test("D3 a marketplace whose only entries are orphans counts as unread", () => {
+		const items = planPluginUpdates({}, [
+			orphan("a@ghost-market", { project: "1.0.0" }),
+			orphan("b@ghost-market", { project: "1.0.0" }),
+		]);
+
+		for (const id of ["a@ghost-market", "b@ghost-market"]) {
+			expect(itemFor(items, id).action).toBe("unknown");
+		}
+	});
+});
+
+// ---------------------------------------------------------------------------
+// D4 — pluginNeedsWork
+// ---------------------------------------------------------------------------
+
+describe("D4 pluginNeedsWork", () => {
+	test("D4 true for a remove item installed at a scope", () => {
+		expect(pluginNeedsWork(removeItem())).toBe(true);
+	});
+
+	test("D4 true for a remove item with no scopes (declared only)", () => {
+		expect(pluginNeedsWork(removeItem({ scopes: [], installed: null }))).toBe(
+			true,
+		);
+	});
+
+	test("D4 true for the remove items the planner produces", () => {
+		const items = planPluginUpdates({ "gone@magus": "latest" }, [
+			LISTED,
+			orphan("old@magus", { project: "0.9.0" }),
+		]);
+
+		expect(pluginNeedsWork(itemFor(items, "old@magus"))).toBe(true);
+		expect(pluginNeedsWork(itemFor(items, "gone@magus"))).toBe(true);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// D5 — applying a remove
+// ---------------------------------------------------------------------------
+
+describe("D5 applying a remove item", () => {
+	test("D5 uninstalls at every scope, drops it from the profile, counts it removed", async () => {
+		const m = machine({ "old@magus": ["user", "project"] }, ["old@magus"]);
+
+		const result = await applyPlugins(
+			[removeItem({ scopes: ["user", "project"] })],
+			PROJECT,
+			m.deps,
+		);
+
+		expect(m.state.uninstalls.map((u) => `${u.id}:${u.scope}`).sort()).toEqual([
+			"old@magus:project",
+			"old@magus:user",
+		]);
+		expect(m.state.drops.map((d) => d.id)).toEqual(["old@magus"]);
+		expect(result.removed.map(pluginName)).toEqual(["old"]);
+		expect(result.failed).toEqual([]);
+		expect(m.state.otherCalls).toEqual([]);
+	});
+
+	test("D5 afterwards it is installed nowhere and the profile no longer lists it", async () => {
+		const m = machine({ "old@magus": ["local"] }, ["old@magus", "keep@magus"]);
+
+		await applyPlugins([removeItem({ scopes: ["local"] })], PROJECT, m.deps);
+
+		expect(
+			SCOPES.filter((s) => m.state.installed.get("old@magus")?.has(s)),
+		).toEqual([]);
+		expect([...m.state.profile]).toEqual(["keep@magus"]);
+	});
+
+	test("D5 declared only (no scopes): no uninstall, profile edited, counted removed", async () => {
+		const m = machine({}, ["gone@magus"]);
+
+		const result = await applyPlugins(
+			[
+				removeItem({
+					pluginId: "gone@magus",
+					scopes: [],
+					installed: null,
+					loaded: null,
+					beforeVersions: {},
+				}),
+			],
+			PROJECT,
+			m.deps,
+		);
+
+		expect(m.state.uninstalls).toEqual([]);
+		expect(m.state.drops.map((d) => d.id)).toEqual(["gone@magus"]);
+		expect(result.removed.map(pluginName)).toEqual(["gone"]);
+		expect(result.failed).toEqual([]);
+	});
+
+	test("D5 the uninstall throws → failed, not removed", async () => {
+		const m = machine({ "old@magus": ["project"] }, ["old@magus"], {
+			uninstallThrows: true,
+		});
+
+		const result = await applyPlugins([removeItem()], PROJECT, m.deps);
+
+		expect(result.removed).toEqual([]);
+		expect(result.failed.map(pluginName)).toEqual(["old"]);
+	});
+
+	test("D5 the uninstall returns but it is still installed → failed, not removed", async () => {
+		const m = machine({ "old@magus": ["project"] }, ["old@magus"], {
+			uninstallIsNoop: true,
+		});
+
+		const result = await applyPlugins([removeItem()], PROJECT, m.deps);
+
+		expect(result.removed).toEqual([]);
+		expect(result.failed.map(pluginName)).toEqual(["old"]);
+	});
+
+	test("D5 the profile still lists it afterwards → failed, not removed", async () => {
+		const m = machine({ "old@magus": ["project"] }, ["old@magus"], {
+			dropReturns: false,
+		});
+
+		const result = await applyPlugins([removeItem()], PROJECT, m.deps);
+
+		expect(result.removed).toEqual([]);
+		expect(result.failed.map(pluginName)).toEqual(["old"]);
+	});
+
+	test("D5 still installed at a scope the item did not name → failed (installed nowhere is the bar)", async () => {
+		const m = machine({ "old@magus": ["project", "user"] }, ["old@magus"]);
+
+		const result = await applyPlugins(
+			[removeItem({ scopes: ["project"] })],
+			PROJECT,
+			m.deps,
+		);
+
+		expect(result.removed).toEqual([]);
+		expect(result.failed.map(pluginName)).toEqual(["old"]);
+	});
+
+	test("D5 a remove item applied with no remove deps fails rather than claiming a removal", async () => {
+		const m = machine({ "old@magus": ["project"] }, ["old@magus"]);
+		const { remove: _ignored, ...withoutRemove } = m.deps;
+
+		const result = await applyPlugins([removeItem()], PROJECT, withoutRemove);
+
+		expect(result.removed).toEqual([]);
+		expect(result.failed.map(pluginName)).toEqual(["old"]);
+	});
+
+	test("D5 the reporter hears a failure for a failed removal and a success for a removal", async () => {
+		const m = machine({ "old@magus": ["project"], "dead@magus": ["user"] }, [
+			"old@magus",
+			"dead@magus",
+		]);
+		const failing = machine({ "dead@magus": ["user"] }, ["dead@magus"], {
+			uninstallThrows: true,
+		});
+		const ok = recordingReporter();
+		const bad = recordingReporter();
+
+		await applyPlugins([removeItem()], PROJECT, m.deps, ok.reporter);
+		await applyPlugins(
+			[removeItem({ pluginId: "dead@magus", scopes: ["user"] })],
+			PROJECT,
+			failing.deps,
+			bad.reporter,
+		);
+
+		expect(ok.finished.map((f) => f.ok)).toEqual([true]);
+		expect(bad.finished.map((f) => f.ok)).toEqual([false]);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// D6 — the Plugins row text
+// ---------------------------------------------------------------------------
+
+describe("D6 Plugins row text", () => {
+	test("D6 a remove item reads ' deprecated — press a to remove' in the danger tone", () => {
+		expect(pluginStatusText(removeItem())).toEqual({
+			suffix: " deprecated — press a to remove",
+			tone: "danger",
+		});
+	});
+
+	test("D6 the same for a declared-only remove item", () => {
+		expect(
+			pluginStatusText(removeItem({ scopes: [], installed: null })),
+		).toEqual({ suffix: " deprecated — press a to remove", tone: "danger" });
+	});
+
+	test("D6 the planner's own remove item renders the same text", () => {
+		const items = planPluginUpdates({}, [
+			LISTED,
+			orphan("old@magus", { project: "0.9.0" }),
+		]);
+
+		expect(pluginStatusText(itemFor(items, "old@magus"))).toEqual({
+			suffix: " deprecated — press a to remove",
+			tone: "danger",
+		});
+	});
+
+	test("D6 never contains 'marketplace', even when the item's note does", () => {
+		const text = pluginStatusText(
+			removeItem({ note: "no longer listed by its marketplace" }),
+		);
+
+		expect(text.suffix.toLowerCase()).not.toContain("marketplace");
+	});
+});
+
+// ---------------------------------------------------------------------------
+// D7 — the CLI view
+// ---------------------------------------------------------------------------
+
+function planWith(plugins: PluginUpdateItem[]): UpdatePlan {
+	return {
+		profileId: "blind",
+		plugins,
+		bins: [],
+		skills: [],
+		binSpecs: new Map(),
+	};
+}
+
+const CURRENT: PluginUpdateItem = {
+	pluginId: "alive@magus",
+	pinned: "latest",
+	installed: "1.0.0",
+	loaded: "1.0.0",
+	available: "1.0.0",
+	target: null,
+	action: "current",
+	reason: "up-to-date",
+	scopes: ["project"],
+	beforeVersions: { project: "1.0.0" },
+};
+
+describe("D7 CLI view", () => {
+	test("D7 remove items are listed under a 'Deprecated' group with a DEPRECATED chip", () => {
+		setColorEnabled(false);
+
+		const lines = planReport(planWith([CURRENT, removeItem()])).map((l) =>
+			stripAnsi(l),
+		);
+
+		const heading = lines.findIndex((l) => /^\s*Deprecated\b/.test(l));
+		const row = lines.findIndex((l) => l.includes("old@magus"));
+		expect(heading).toBeGreaterThanOrEqual(0);
+		expect(row).toBeGreaterThan(heading);
+		expect(lines[row]).toContain("DEPRECATED");
+		const nextHeading = lines.findIndex(
+			(l, i) => i > heading && /^\s{0,2}[A-Z][a-z]+\s+\d+\s*$/.test(l),
+		);
+		if (nextHeading !== -1) expect(row).toBeLessThan(nextHeading);
+	});
+
+	test("D7 the Deprecated group counts its items", () => {
+		setColorEnabled(false);
+
+		const lines = planReport(
+			planWith([
+				CURRENT,
+				removeItem(),
+				removeItem({ pluginId: "gone@magus", scopes: [], installed: null }),
+			]),
+		).map((l) => stripAnsi(l));
+
+		expect(lines.some((l) => /^\s*Deprecated\s+2\s*$/.test(l))).toBe(true);
+		expect(lines.filter((l) => l.includes("DEPRECATED"))).toHaveLength(2);
+	});
+
+	test("D7 the current plugin is not under the Deprecated group", () => {
+		setColorEnabled(false);
+
+		const lines = planReport(planWith([CURRENT, removeItem()])).map((l) =>
+			stripAnsi(l),
+		);
+
+		const aliveRow = lines.find((l) => l.includes("alive@magus")) ?? "";
+		expect(aliveRow).not.toContain("DEPRECATED");
+	});
+
+	test("D7 remove items count as items to apply", () => {
+		const plan = planWith([
+			CURRENT,
+			removeItem(),
+			removeItem({ pluginId: "gone@magus", scopes: [], installed: null }),
+		]);
+
+		const work = planWorkItems(plan);
+
+		expect(work).toHaveLength(2);
+		expect(work.map(pluginName).sort()).toEqual(["gone", "old"]);
+		expect(planHasWork(plan)).toBe(true);
+		expect(planIsBehind(plan)).toBe(true);
+	});
+
+	test("D7 a plan of current plugins only has nothing to apply (control)", () => {
+		const plan = planWith([CURRENT]);
+
+		expect(planWorkItems(plan)).toEqual([]);
+		expect(planHasWork(plan)).toBe(false);
+	});
+});