magus-cli 7.7.0 → 7.9.0

package/src/__tests__/cli-apply-seams.test.ts

@@ -1,8 +1,7 @@
 /**
- * Tests for the three progress seams the animated report depends on.
+ * Tests for the progress seams the animated report depends on.
  *
- * All three shipped untested: `ApplyReporter`, `checkBinaries`'s `onProbe`, and
- * the coupling between the apply meter's denominator and the items the apply
+ * Both shipped untested: `ApplyReporter`, and the coupling between the apply meter's denominator and the items the apply
  * loop actually touches. A review found that last one hand-duplicated
  * `applyPlugins`'s skip conditions and replicated only one of the two, so a
  * plan containing an actionable plugin with no scopes would leave the bar stuck
@@ -13,7 +12,6 @@
 import { describe, expect, mock, test } from "bun:test";
 import { parseArgs } from "../cli/update.js";
 import type { PluginScope } from "../services/claude-cli.js";
-import { checkBinaries } from "../services/doctor-bins.js";
 import {
 	type ApplyReporter,
 	type PluginApplyDeps,
@@ -22,7 +20,6 @@ import {
 	pluginNeedsWork,
 } from "../services/update-engine.js";
 import type { PluginUpdateItem } from "../services/update-plan.js";
-import type { ResolvedBin } from "../types/index.js";
 
 const PROJECT = "/tmp/project";
 
@@ -224,65 +221,3 @@ describe("installPluginInScope — the scope-targeted path", () => {
 		expect(saved).toEqual([]);
 	});
 });
-
-describe("checkBinaries onProbe", () => {
-	const bins: ResolvedBin[] = [
-		{ name: "tmux", via: "brew", sources: [] } as unknown as ResolvedBin,
-		{ name: "tmux-mcp", via: "bun", sources: [] } as unknown as ResolvedBin,
-		{ name: "jq", via: "brew", sources: [] } as unknown as ResolvedBin,
-	];
-
-	test("fires once per binary, before its probe, with a stable total", async () => {
-		// Before the probe matters: the point is to name the binary the command
-		// is currently blocked on, not the one it just finished.
-		const seen: Array<[string, number, number]> = [];
-		const order: string[] = [];
-		await checkBinaries(
-			bins,
-			async (name) => {
-				order.push(`probe:${name}`);
-				return true;
-			},
-			(name, index, total) => {
-				order.push(`announce:${name}`);
-				seen.push([name, index, total]);
-			},
-		);
-
-		expect(seen).toEqual([
-			["tmux", 0, 3],
-			["tmux-mcp", 1, 3],
-			["jq", 2, 3],
-		]);
-		expect(order.slice(0, 2)).toEqual(["announce:tmux", "probe:tmux"]);
-	});
-
-	test("the index is 0-based, so done/total needs index+1", async () => {
-		// A meter fed the raw index reads 0/3 while the first probe runs, which
-		// is correct — it has finished none of them.
-		const first: number[] = [];
-		await checkBinaries(
-			bins,
-			async () => true,
-			(_n, index) => first.push(index),
-		);
-		expect(first[0]).toBe(0);
-		expect(first.at(-1)).toBe(bins.length - 1);
-	});
-
-	test("no callback means no behaviour change", async () => {
-		const results = await checkBinaries(bins, async () => false);
-		expect(results.map((r) => r.present)).toEqual([false, false, false]);
-	});
-
-	test("an empty bin list announces nothing", async () => {
-		const seen: string[] = [];
-		const results = await checkBinaries(
-			[],
-			async () => true,
-			(n) => seen.push(n),
-		);
-		expect(results).toEqual([]);
-		expect(seen).toEqual([]);
-	});
-});

package/src/__tests__/cli-tool-commands.test.ts

@@ -25,12 +25,18 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { cliTools } from "../data/cli-tools.js";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { cliTools as catalogue, isOwnedEntry } from "../data/cli-tools.js";
 import {
 	type InstallMethod,
 	cliToolInstall,
 	cliToolUninstall,
 	cliToolUpdate,
+	isPluginManagedItem,
+	ownedCliTool,
+	resolveCatalogue,
+	unownedCatalogue,
 } from "../services/cli-tool-commands.js";
 import { versionFromPypiJson } from "../services/tool-probe.js";
 import {
@@ -38,6 +44,7 @@ import {
 	type PythonCliInstaller,
 	resolvePythonCliInstaller,
 } from "../services/toolchain.js";
+import { parseRequires } from "../shared/plugin/hooks/lib/requires-probe.js";
 import { type Command, formatCommand } from "../utils/command-utils.js";
 
 const byProbe = (probe: string): PythonCliInstaller => {
@@ -47,10 +54,129 @@ const byProbe = (probe: string): PythonCliInstaller => {
 };
 const PYTHON_PROBES = PYTHON_CLI_INSTALLERS.map((i) => i.probe);
 
+/** The catalogue entries that carry their own installer (no plugin owns them). */
+const cliTools = unownedCatalogue().map((c) => c.tool);
+
+/** Every requirement the repo's plugins declare, by name → the plugins declaring it. */
+function declaredRequirements(): Map<string, string[]> {
+	const pluginsDir = join(import.meta.dir, "..", "..", "..", "..", "plugins");
+	const out = new Map<string, string[]>();
+	for (const plugin of readdirSync(pluginsDir)) {
+		let manifest: unknown;
+		try {
+			manifest = JSON.parse(
+				readFileSync(
+					join(pluginsDir, plugin, ".claude-plugin", "plugin.json"),
+					"utf8",
+				),
+			);
+		} catch {
+			continue;
+		}
+		const parsed = parseRequires(manifest);
+		if (!parsed.ok) continue;
+		for (const r of parsed.requirements) {
+			out.set(r.name, [...(out.get(r.name) ?? []), plugin]);
+		}
+	}
+	return out;
+}
+
 /** The methods the resolver models, i.e. the ones that reach toolchain.ts. */
 const RESOLVED_METHODS: InstallMethod[] = ["npm", "bun", "brew", "pip"];
 
 describe("the catalogue is well-formed", () => {
+	test("no catalogue entry restates a requirement a plugin declares", () => {
+		// A tool a plugin declares is owned by that plugin: the catalogue keeps its
+		// display fields and `ownedBy`, and its check and installer come from the
+		// declaration. A second copy here is what drifted before.
+		const declared = declaredRequirements();
+		expect(declared.size).toBeGreaterThan(0);
+		for (const entry of catalogue) {
+			if (isOwnedEntry(entry)) {
+				const [plugin] = entry.ownedBy.split("@");
+				expect(declared.get(entry.name) ?? []).toContain(plugin);
+				expect("packageName" in entry).toBe(false);
+				expect("checkCommand" in entry).toBe(false);
+			} else {
+				expect(declared.has(entry.name)).toBe(false);
+			}
+		}
+		expect(catalogue.some(isOwnedEntry)).toBe(true);
+	});
+
+	test("an owned row takes its check and installer from the plugin's declaration", async () => {
+		const owned = await resolveCatalogue(
+			"/nonexistent",
+			async (pluginId, name) =>
+				pluginId === "claudish@magus"
+					? {
+							name,
+							check: [name, "--version"],
+							install: [{ via: "bun", package: name }],
+							chosen: { via: "bun", package: name },
+						}
+					: null,
+		);
+		const claudish = owned.find(
+			(c) => !isPluginManagedItem(c) && c.tool.name === "claudish",
+		);
+		expect(
+			claudish && !isPluginManagedItem(claudish) && claudish.tool,
+		).toMatchObject({
+			checkCommand: "claudish --version",
+			packageManager: "bun",
+			packageName: "claudish",
+		});
+		expect(claudish?.owned?.sources).toEqual(["plugin:claudish@magus"]);
+		// An owned entry whose declaration cannot be read here is left out.
+		const names = owned.map((c) =>
+			isPluginManagedItem(c) ? c.entry.name : c.tool.name,
+		);
+		expect(names).not.toContain("mnemex");
+		// One whose chosen install is not version-managed cannot be a row.
+		const entry = catalogue.find((e) => e.name === "claudish");
+		expect(
+			entry &&
+				ownedCliTool(entry, {
+					name: "claudish",
+					check: ["claudish"],
+					install: [],
+					chosen: { via: "apt", packages: ["claudish"] },
+				}),
+		).toBeNull();
+	});
+
+	test("an owned tool its plugin installs from a release is a plugin-managed row, in catalogue order", async () => {
+		const release = {
+			via: "release" as const,
+			repo: "MadAppGang/claudish",
+			tag: "v10.3.0",
+			asset: "claudish-{os}-{arch}",
+			binary: "claudish",
+			sha256: { linux_amd64: "a".repeat(64) },
+		};
+		const items = await resolveCatalogue("/nonexistent", async (_id, name) => ({
+			name,
+			check: [name, "--version"],
+			install: [release],
+			chosen: release,
+		}));
+		const names = items.map((c) =>
+			isPluginManagedItem(c) ? c.entry.name : c.tool.name,
+		);
+		// Nothing dropped: the catalogue, in its own order.
+		expect(names).toEqual(catalogue.map((e) => e.name));
+		const managed = items.filter(isPluginManagedItem);
+		expect(managed.map((m) => [m.entry.name, m.entry.ownedBy])).toEqual(
+			catalogue.filter(isOwnedEntry).map((e) => [e.name, e.ownedBy]),
+		);
+		for (const m of managed) {
+			expect(m.owned.chosen).toEqual(release);
+			expect(m.owned.sources).toEqual([`plugin:${m.entry.ownedBy}`]);
+		}
+	});
+
 	test("it has entries, and each names a package manager and a package", () => {
 		// Guard: every assertion below iterates the catalogue, so an empty or
 		// malformed one would make them all pass vacuously.
@@ -71,11 +197,10 @@ describe("no builder ever emits a bare `pip`", () => {
 			const cmd = cliToolInstall(tool);
 			expect(cmd.cmd).not.toBe("pip");
 			if (tool.packageManager === "pip") {
-				// Whatever the machine running this resolved to, it must be one of
-				// the three modelled installers — and `cmd` must BE that probe,
-				// since that is the executable the syscall looks up.
-				expect(PYTHON_PROBES).toContain(cmd.cmd);
-				expect(cmd.cmd).toBe(resolvePythonCliInstaller().probe);
+				// requires-probe renders the profile-only pip kind as a uv tool
+				// install: the package gets its own env, immune to PEP 668.
+				expect(cmd.cmd).toBe("uv");
+				expect(cmd.args.slice(0, 2)).toEqual(["tool", "install"]);
 			}
 		}
 	});

package/src/__tests__/cli-tools-adapter.test.ts

@@ -7,7 +7,6 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { cliTools } from "../data/cli-tools.js";
 import { cliToolInstall } from "../services/cli-tool-commands.js";
 import {
 	type ToolFacts,
@@ -18,13 +17,17 @@ import { binCommandFor } from "../services/update-engine.js";
 import { planBinUpdates } from "../services/update-plan.js";
 import type { ResolvedBin } from "../types/index.js";
 import {
+	type PluginManagedRow,
 	buildToolRow,
 	cliToolStatusText,
 	countToolRows,
+	isPluginManagedRow,
+	rowName,
 } from "../ui/adapters/cliToolsAdapter.js";
+import { testCatalogue } from "./fixtures/bins.js";
 
 const catalogue = (name: string) => {
-	const tool = cliTools.find((t) => t.name === name);
+	const tool = testCatalogue().find((t) => t.name === name);
 	if (!tool) throw new Error(`no catalogue tool ${name}`);
 	return tool;
 };
@@ -294,4 +297,51 @@ describe("countToolRows — header counts from states", () => {
 			unverified: 1,
 		});
 	});
+
+	test("a plugin-managed row counts from its probe answer, and never as an update", () => {
+		const managed = (
+			presence: PluginManagedRow["presence"],
+		): PluginManagedRow => ({
+			managedBy: "claudish@magus",
+			entry: {
+				name: "claudish",
+				displayName: "Claudish",
+				description: "",
+				website: "",
+				category: "ai-coding",
+				ownedBy: "claudish@magus",
+			},
+			owned: {
+				name: "claudish",
+				check: ["claudish", "--version"],
+				install: [],
+				chosen: null,
+				sources: ["plugin:claudish@magus"],
+			},
+			presence,
+			installText: "",
+		});
+		const rows = [
+			managed({ name: "claudish", status: "present" }),
+			managed({ name: "claudish", status: "off-path", prefix: "~/.local/bin" }),
+			managed({ name: "claudish", status: "missing" }),
+			managed({ name: "claudish", status: "unknown", reason: "slow" }),
+			managed(null),
+		];
+		expect(countToolRows(rows)).toEqual({
+			installed: 2,
+			updates: 0,
+			unverified: 1,
+		});
+		expect(rows.every(isPluginManagedRow)).toBe(true);
+		expect(rowName(rows[0] as PluginManagedRow)).toBe("claudish");
+		const tool = catalogue("mnemex");
+		const tracked = buildToolRow(
+			tool,
+			specForCatalogTool(tool, null, undefined),
+			undefined,
+		);
+		expect(isPluginManagedRow(tracked)).toBe(false);
+		expect(rowName(tracked)).toBe("mnemex");
+	});
 });

package/src/__tests__/cli-tools-plugin-managed.test.tsx

@@ -0,0 +1,83 @@
+/**
+ * A catalogue tool its plugin installs without a version magus can track
+ * (claudish and mnemex from their releases off Homebrew) is drawn read-only:
+ * the row says which plugin manages it, the detail pane says it cannot be
+ * acted on here, and no Enter action is drawn. Rendered through OpenTUI's
+ * test renderer; no IO.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
+import type { PluginManagedRow } from "../ui/adapters/cliToolsAdapter.js";
+import {
+	renderCliToolDetail,
+	renderCliToolRow,
+} from "../ui/renderers/cliToolRenderers.js";
+
+function row(presence: PluginManagedRow["presence"]): PluginManagedRow {
+	return {
+		managedBy: "claudish@magus",
+		entry: {
+			name: "claudish",
+			displayName: "Claudish",
+			description: "Run Claude Code with any model",
+			website: "https://github.com/MadAppGang/claudish",
+			category: "ai-coding",
+			ownedBy: "claudish@magus",
+		},
+		owned: {
+			name: "claudish",
+			check: ["claudish", "--version"],
+			install: [],
+			chosen: null,
+			sources: ["plugin:claudish@magus"],
+		},
+		presence,
+		installText: "cd $(mktemp -d) && curl -fsSLO https://example/claudish",
+	};
+}
+
+async function frame(node: React.ReactNode, width = 80): Promise<string> {
+	const { captureCharFrame, renderOnce, renderer } = await testRender(
+		<box flexDirection="column">{node}</box>,
+		{ width, height: 20 },
+	);
+	await act(async () => {
+		await renderOnce();
+		await renderOnce();
+	});
+	const out = captureCharFrame();
+	await act(async () => renderer.destroy());
+	return out;
+}
+
+describe("a plugin-managed CLI tool row", () => {
+	test("the row names the plugin that manages it", async () => {
+		const out = await frame(
+			renderCliToolRow(row({ name: "claudish", status: "present" }), 0, false),
+		);
+		expect(out).toContain("● Claudish · managed by claudish@magus");
+	});
+
+	test("missing: the detail says so, shows the plugin's install, and offers no Enter", async () => {
+		const out = await frame(
+			renderCliToolDetail(row({ name: "claudish", status: "missing" }), 70),
+			70,
+		);
+		expect(out).toContain("Status   ○ Not installed");
+		expect(out).toContain("Managed  by claudish@magus");
+		expect(out).toContain("Install  cd $(mktemp -d)");
+		// The note wraps at the pane's width; read it as prose.
+		const prose = out.replace(/\s+/g, " ");
+		expect(prose).toContain(
+			"claudish@magus installs claudish and decides its version; it cannot be installed, updated or removed from here. magus doctor --fix installs it when it is missing.",
+		);
+		expect(out).not.toContain("Enter");
+	});
+
+	test("while it is being checked, the row says so", async () => {
+		const out = await frame(renderCliToolRow(row(null), 0, false));
+		expect(out).toContain("○ Claudish ...");
+	});
+});

package/src/__tests__/cli-update-view.test.ts

@@ -362,7 +362,7 @@ describe("sections", () => {
 				: [];
 		});
 		// This fixture has one of each except Deprecated, whose row would need a
-		// `not-offered` reason. `designer@magus` is unknown with a note, so it is
+		// `remove` action. `designer@magus` is unknown with a note, so it is
 		// Unverified — NOT Current, which would claim a failed check succeeded.
 		expect(headings.map((h) => h.group)).toEqual([
 			"Update",
@@ -390,8 +390,8 @@ describe("sections", () => {
 				installed: null,
 				available: null,
 				target: null,
-				action: "unknown",
-				reason: "not-offered",
+				action: "remove",
+				reason: "deprecated",
 				scopes: [],
 			},
 			...p.plugins,