magus-cli 7.10.3 → 7.10.5

package/src/__tests__/blind/c19-probe-owner-version-shadow.test.ts

@@ -4,6 +4,22 @@
  * (uv's receipt), and reports a newer copy hidden later on PATH.
  *
  * Written from the spec only, through a scripted fake `ToolProbeIO`.
+ *
+ * Merged with the tool-rows design (docs/plans/2026-10-08-magus-update-tool-rows.md,
+ * decision 7). Kept as written: the uv receipt cases (A1–A5) and the guards.
+ * Changed, because they contradict that design's rules:
+ *  - An `external` row carries no note, so the owner sentences (A6, B7–B10,
+ *    C11–C12) now expect none. They were read off Cellar, Caskroom and cargo
+ *    paths, which the design forbids. A pinned tool no installer has (B10) is
+ *    `external`, not `unknown`.
+ *  - zsh's version comes from magus's own version command (`zsh --version`,
+ *    bare name), not from running a file chosen by a path test, so C's fake
+ *    world answers that command.
+ *  - A copy later on PATH is counted (`otherCopies`), never described: its
+ *    owner and version were read off its path, and the warning named a PATH
+ *    folder with nothing for the user to run. So D expects a count, and an
+ *    older copy (D14) counts too — telling older from newer would need that
+ *    same guess.
  */
 import { describe, expect, test } from "bun:test";
 import {
@@ -208,11 +224,11 @@ describe("C19 A: uv's own installer is a driven owner", () => {
 		expect(f.upgradeCommand).toBeUndefined();
 		const s = classifyTool(spec, f);
 		expect(s.state).toBe("external");
-		expect(s.note).toBe("installed by ruff's own installer");
+		expect(s.note).toBeUndefined();
 	});
 });
 
-describe("C19 B: KEPT notes name who installed it", () => {
+describe("C19 B: a file no driven installer has is installed elsewhere, with no note", () => {
 	const spec = (
 		name: string,
 		extra: Partial<BinRequirement> = {},
@@ -239,7 +255,7 @@ describe("C19 B: KEPT notes name who installed it", () => {
 		const f = await probeTool(sp, fakeIO(world("madbench", file)));
 		const s = classifyTool(sp, f);
 		expect(s.state).toBe("external");
-		expect(s.note).toBe("installed by a Homebrew cask");
+		expect(s.note).toBeUndefined();
 	});
 
 	test("8a. cargo bin under the home directory", async () => {
@@ -247,7 +263,7 @@ describe("C19 B: KEPT notes name who installed it", () => {
 		const f = await probeTool(sp, fakeIO(world("rg", "/home/u/.cargo/bin/rg")));
 		const s = classifyTool(sp, f);
 		expect(s.state).toBe("external");
-		expect(s.note).toBe("installed by cargo");
+		expect(s.note).toBeUndefined();
 	});
 
 	test("8b. cargo bin under CARGO_HOME", async () => {
@@ -258,7 +274,7 @@ describe("C19 B: KEPT notes name who installed it", () => {
 		);
 		const s = classifyTool(sp, f);
 		expect(s.state).toBe("external");
-		expect(s.note).toBe("installed by cargo");
+		expect(s.note).toBeUndefined();
 	});
 
 	test("9. unrecognised place, never says 'outside'", async () => {
@@ -269,18 +285,15 @@ describe("C19 B: KEPT notes name who installed it", () => {
 		);
 		const s = classifyTool(sp, f);
 		expect(s.state).toBe("external");
-		expect(s.note).toBe("installed by an installer magus does not update");
-		expect(s.note ?? "").not.toContain("outside");
+		expect(s.note).toBeUndefined();
 	});
 
 	test("10. pinned spec with a cargo file", async () => {
 		const sp = spec("rg", { version: "1.0.0" });
 		const f = await probeTool(sp, fakeIO(world("rg", "/home/u/.cargo/bin/rg")));
 		const s = classifyTool(sp, f);
-		expect(s.state).toBe("unknown");
-		expect(s.note).toBe(
-			"installed by cargo, so magus cannot move it to the pin 1.0.0",
-		);
+		expect(s.state).toBe("external");
+		expect(s.note).toBeUndefined();
 	});
 });
 
@@ -291,7 +304,7 @@ describe("C19 C: operating-system programs show their version", () => {
 		real: { "/bin/zsh": "/bin/zsh", ...CELLAR },
 		exec: {
 			...BREW_PREFIX_OK,
-			...(zshExec ? { "/bin/zsh --version": zshExec } : {}),
+			...(zshExec ? { "zsh --version": zshExec } : {}),
 		},
 	});
 
@@ -303,7 +316,7 @@ describe("C19 C: operating-system programs show their version", () => {
 		expect(f.installed).toBe("5.9");
 		const s = classifyTool(zsh, f);
 		expect(s.state).toBe("external");
-		expect(s.note).toBe("comes with the operating system");
+		expect(s.note).toBeUndefined();
 	});
 
 	test("12a. --version exits non-zero: still external, installed null", async () => {
@@ -314,7 +327,7 @@ describe("C19 C: operating-system programs show their version", () => {
 		expect(f.installed).toBeNull();
 		const s = classifyTool(zsh, f);
 		expect(s.state).toBe("external");
-		expect(s.note).toBe("comes with the operating system");
+		expect(s.note).toBeUndefined();
 	});
 
 	test("12b. --version missing: still external, installed null", async () => {
@@ -322,11 +335,11 @@ describe("C19 C: operating-system programs show their version", () => {
 		expect(f.installed).toBeNull();
 		const s = classifyTool(zsh, f);
 		expect(s.state).toBe("external");
-		expect(s.note).toBe("comes with the operating system");
+		expect(s.note).toBeUndefined();
 	});
 });
 
-describe("C19 D: a newer copy later on PATH is reported", () => {
+describe("C19 D: another copy later on PATH is counted", () => {
 	const BREW_BIN = "/opt/homebrew/bin/uv";
 	const cellarFile = (v: string) => `/opt/homebrew/Cellar/uv/${v}/bin/uv`;
 	const world = (second: string, secondReal: string): FakeSetup =>
@@ -338,52 +351,42 @@ describe("C19 D: a newer copy later on PATH is reported", () => {
 				env: { HOMEBREW_PREFIX: PREFIX },
 			},
 		});
-	const NOTE =
-		"Homebrew also has 0.13.0, unused: ~/.local/bin comes first on PATH";
 
-	test("13. newer Homebrew copy: pathDir, otherCopies, shadowed", async () => {
+	test("13. a Homebrew copy later on PATH: counted, no path, no warning", async () => {
 		const f = await probeTool(
 			UV,
 			fakeIO(world(BREW_BIN, cellarFile("0.13.0"))),
 		);
-		expect(f.pathDir).toBe("~/.local/bin");
-		expect(f.otherCopies).toEqual([
-			{ owner: "Homebrew", version: "0.13.0", dir: "/opt/homebrew/bin" },
-		]);
-		expect(classifyTool(UV, f).shadowed).toBe(NOTE);
+		expect(f.otherCopies).toBe(1);
+		expect(JSON.stringify(classifyTool(UV, f))).not.toContain("/");
 	});
 
-	test("14. older later copy: listed, not shadowed", async () => {
+	test("14. an older later copy is counted the same: no version is guessed", async () => {
 		const f = await probeTool(
 			UV,
 			fakeIO(world(BREW_BIN, cellarFile("0.10.0"))),
 		);
-		expect(f.otherCopies).toEqual([
-			{ owner: "Homebrew", version: "0.10.0", dir: "/opt/homebrew/bin" },
-		]);
-		expect(classifyTool(UV, f).shadowed).toBeUndefined();
+		expect(f.otherCopies).toBe(1);
 	});
 
 	test("15. a symlink to the running file is not another copy", async () => {
 		const f = await probeTool(UV, fakeIO(world("/usr/local/bin/uv", UV_FILE)));
-		expect(f.otherCopies ?? []).toEqual([]);
-		expect(classifyTool(UV, f).shadowed).toBeUndefined();
+		expect(f.otherCopies).toBeUndefined();
 	});
 
 	test("16. IO without resolveAllExecutables: nothing reported, nothing throws", async () => {
 		const w = world(BREW_BIN, cellarFile("0.13.0"));
 		w.noAll = true;
 		const f = await probeTool(UV, fakeIO(w));
-		expect(f.otherCopies ?? []).toEqual([]);
-		expect(classifyTool(UV, f).shadowed).toBeUndefined();
+		expect(f.otherCopies).toBeUndefined();
 	});
 
-	test("17. shadowed is set on a current row too", async () => {
+	test("17. a current row is counted too", async () => {
 		const w = world(BREW_BIN, cellarFile("0.13.0"));
 		w.fetch = pypi("0.11.15");
 		const f = await probeTool(UV, fakeIO(w));
 		const s = classifyTool(UV, f);
 		expect(s.state).toBe("current");
-		expect(s.shadowed).toBe(NOTE);
+		expect(f.otherCopies).toBe(1);
 	});
 });

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

@@ -93,11 +93,12 @@ describe("the catalogue is well-formed", () => {
 		const declared = declaredRequirements();
 		expect(declared.size).toBeGreaterThan(0);
 		for (const entry of catalogue) {
+			// No entry carries a version command: that is data/tool-versions.ts.
+			expect("checkCommand" in entry).toBe(false);
 			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);
 			}
@@ -124,7 +125,6 @@ describe("the catalogue is well-formed", () => {
 		expect(
 			claudish && !isPluginManagedItem(claudish) && claudish.tool,
 		).toMatchObject({
-			checkCommand: "claudish --version",
 			packageManager: "bun",
 			packageName: "claudish",
 		});

package/src/__tests__/cli-tool-external-row.test.tsx

@@ -0,0 +1,112 @@
+/**
+ * A tool installed another way (`external`), and one held back, on the CLI
+ * Tools screen (docs/plans/2026-10-08-magus-update-tool-rows.md, decisions 5
+ * and 6).
+ *
+ * The screen is an inventory, so the row stays — but it is not a warning and
+ * not "Up to date": no `?`, a muted icon, "installed elsewhere", a detail
+ * status that says the same, and no Enter action. The list icon and the
+ * detail Status line are if-chains the compiler does not check, which is why
+ * each branch is pinned here. 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 { cliTools } from "../data/cli-tools.js";
+import type { CliTool } from "../data/cli-tools.js";
+import type { ToolStatus } from "../services/tool-probe.js";
+import type { CliToolRow } from "../ui/adapters/cliToolsAdapter.js";
+import {
+	renderCliToolDetail,
+	renderCliToolRow,
+} from "../ui/renderers/cliToolRenderers.js";
+
+const TOOL = cliTools.find((t) => t.name === "crush") as CliTool;
+
+function row(status: Pick<ToolStatus, "state" | "reason">): CliToolRow {
+	return {
+		tool: TOOL,
+		spec: { name: TOOL.name, via: "npm", package: TOOL.packageName },
+		checking: false,
+		status: {
+			name: TOOL.name,
+			installed: "0.55.0",
+			latest: null,
+			target: null,
+			...status,
+		},
+		updateCommand: { cmd: "npm", args: ["install", "-g", "x@latest"] },
+		installCommand: { cmd: "npm", args: ["install", "-g", "x"] },
+	};
+}
+
+const EXTERNAL = row({ state: "external", reason: "installed-elsewhere" });
+const CURRENT = row({ state: "current", reason: "up-to-date" });
+
+async function render(node: React.ReactNode, width = 80) {
+	const { captureCharFrame, captureSpans, renderOnce, renderer } =
+		await testRender(<box flexDirection="column">{node}</box>, {
+			width,
+			height: 24,
+		});
+	await act(async () => {
+		await renderOnce();
+		await renderOnce();
+	});
+	const out = { chars: captureCharFrame(), lines: captureSpans().lines };
+	await act(async () => renderer.destroy());
+	return out;
+}
+
+/** The colour of the row's ● icon. */
+async function iconColour(r: CliToolRow): Promise<string> {
+	const { lines } = await render(renderCliToolRow(r, 0, false));
+	for (const line of lines) {
+		const span = line.spans.find((s) => s.text.includes("●"));
+		if (span) return JSON.stringify(span.fg);
+	}
+	throw new Error("no ● icon on the row");
+}
+
+describe("an external CLI tool row", () => {
+	test("the row says installed elsewhere, with no ?", async () => {
+		const { chars } = await render(renderCliToolRow(EXTERNAL, 0, false));
+		expect(chars).toContain("● Crush v0.55.0 installed elsewhere");
+		expect(chars).not.toContain("?");
+	});
+
+	test("its icon is muted, never the success colour of a current tool", async () => {
+		expect(await iconColour(EXTERNAL)).not.toBe(await iconColour(CURRENT));
+	});
+
+	test("the detail Status says Installed elsewhere, never Up to date, and offers no Enter", async () => {
+		const { chars } = await render(renderCliToolDetail(EXTERNAL, 70), 70);
+		expect(chars).toContain("Status   ● Installed elsewhere");
+		expect(chars).not.toContain("Up to date");
+		expect(chars).not.toContain("Enter");
+	});
+
+	test("control: a current tool's detail still says Up to date", async () => {
+		const { chars } = await render(renderCliToolDetail(CURRENT, 70), 70);
+		expect(chars).toContain("Up to date");
+	});
+});
+
+// A held-back tool was checked — brew says it is behind and pinned — so it is
+// "held back" here as in `magus update`: never `?`, never "not checked".
+const HELD = row({ state: "unknown", reason: "held-back" });
+
+describe("a held-back CLI tool row", () => {
+	test("the row says held back, with no ?", async () => {
+		const { chars } = await render(renderCliToolRow(HELD, 0, false));
+		expect(chars).toContain("‖ Crush v0.55.0 held back");
+		expect(chars).not.toContain("?");
+	});
+
+	test("the detail Status says Held back, never not checked", async () => {
+		const { chars } = await render(renderCliToolDetail(HELD, 70), 70);
+		expect(chars).toContain("Status   ‖ Held back");
+		expect(chars).not.toContain("not checked");
+	});
+});

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

@@ -19,6 +19,7 @@ import type { ResolvedBin } from "../types/index.js";
 import {
 	type PluginManagedRow,
 	buildToolRow,
+	cliToolEnterAction,
 	cliToolStatusText,
 	countToolRows,
 	isPluginManagedRow,
@@ -85,22 +86,21 @@ describe("buildToolRow — which installer a catalogue row is judged through", (
 		const spec = specForCatalogTool(codex, [declared], install);
 		expect(spec).toBe(declared);
 
-		// Through npm, the bun-installed file is not npm's: not-managed.
+		// Through npm, the bun-installed file is not npm's: installed elsewhere.
 		const f = facts("codex", {
 			managed: false,
 			resolvedPath:
 				"/Users/j/.bun/install/global/node_modules/@openai/codex/bin/codex.js",
-			owner: "npm (root /Users/j/.local/lib/node_modules)",
 		});
 		const row = buildToolRow(codex, spec, f, install);
 		const [cli] = planBinUpdates([declared], [f]);
 		expect(row.status).toMatchObject({
 			state: cli!.action,
 			reason: cli!.reason,
-			note: cli!.note,
 			target: cli!.target,
 		});
-		expect(row.status?.reason).toBe("not-managed");
+		expect(row.status?.note).toBe(cli!.note);
+		expect(row.status?.reason).toBe("installed-elsewhere");
 	});
 
 	test("pinned and behind: the row's key installs the PIN, exactly what the CLI runs", () => {
@@ -197,7 +197,7 @@ describe("buildToolRow — which installer a catalogue row is judged through", (
 		expect(row.installCommand).toEqual(cliToolInstall(codex));
 	});
 
-	test("detected pnpm → the catalogue's via, and a not-managed row in the user's terms", () => {
+	test("detected pnpm → the catalogue's via, and an installed-elsewhere row with no path", () => {
 		const opencode = catalogue("opencode");
 		const install = { primary: "pnpm" as const, all: ["pnpm" as const] };
 		const spec = specForCatalogTool(opencode, null, install);
@@ -207,17 +207,17 @@ describe("buildToolRow — which installer a catalogue row is judged through", (
 			managed: false,
 			resolvedPath:
 				"/Users/j/.local/share/pnpm/global/5/node_modules/opencode-ai/bin/opencode",
-			owner: "npm (root /Users/j/.local/lib/node_modules)",
 		});
 		const row = buildToolRow(opencode, spec, f, install);
-		expect(row.status?.state).toBe("external");
-		expect(row.status?.reason).toBe("not-managed");
-		// No path and no installer directory: the user acts on neither.
-		expect(row.status?.note).toBe(
-			"installed by an installer magus does not update",
-		);
-		expect(row.status?.note).not.toContain("/");
-		// Enter still follows how it IS installed (pnpm).
+		expect(row.status).toMatchObject({
+			state: "external",
+			reason: "installed-elsewhere",
+		});
+		expect(row.status?.note).toBeUndefined();
+		// Enter offers nothing for a tool installed another way.
+		expect(cliToolEnterAction(row)).toBeNull();
+		// The row still builds its update command for how it IS installed
+		// (pnpm), even though Enter offers nothing for it.
 		expect(row.updateCommand?.cmd).toBe("pnpm");
 	});
 
@@ -254,26 +254,30 @@ describe("cliToolStatusText — the row's words", () => {
 			primary: "npm",
 			all: ["npm"],
 		});
-		const f = facts("crush", { managed: null });
+		const f = facts("crush", {
+			managed: null,
+			failure: "npm timed out after 8s",
+		});
 		const row = buildToolRow(tool, spec, f);
 		const text = cliToolStatusText(row);
 		expect(text.tone).toBe("warning");
-		expect(text.suffix).toBe(" ? owner not known");
+		expect(text.suffix).toBe(" ? owner unknown");
 		// The note is for the detail pane's "Why", not the row.
 		expect(row.status?.note).toBe(classifyTool(spec, f).note);
 		expect(text.suffix).not.toContain("/");
 	});
 
-	test("external renders muted, naming the installer it is outside of", () => {
+	test("external renders muted as `installed elsewhere`, with no ?", () => {
 		const tool = catalogue("crush");
 		const spec = specForCatalogTool(tool, null, {
 			primary: "npm",
 			all: ["npm"],
 		});
 		const row = buildToolRow(tool, spec, facts("crush", { managed: false }));
-		const text = cliToolStatusText(row);
-		expect(text.tone).toBe("muted");
-		expect(text.suffix).toBe(" · outside npm");
+		expect(cliToolStatusText(row)).toEqual({
+			suffix: " installed elsewhere",
+			tone: "muted",
+		});
 	});
 
 	test("upgrade names the target once, with one v", () => {
@@ -305,13 +309,19 @@ describe("countToolRows — header counts from states", () => {
 			buildToolRow(tool, spec, facts("mnemex", { behind: false })),
 			buildToolRow(tool, spec, facts("mnemex", { behind: true })),
 			buildToolRow(tool, spec, facts("mnemex", { managed: null })),
-			// Another installer's: installed, and not "unverified".
+			// Installed elsewhere: installed, but neither an update nor unverified.
 			buildToolRow(tool, spec, facts("mnemex", { managed: false })),
+			// Held back: checked (behind and pinned), so not unverified either.
+			buildToolRow(
+				tool,
+				spec,
+				facts("mnemex", { behind: true, heldBack: "held by brew pin" }),
+			),
 			buildToolRow(tool, spec, facts("mnemex", { present: false })),
 			buildToolRow(tool, spec, undefined),
 		];
 		expect(countToolRows(rows)).toEqual({
-			installed: 4,
+			installed: 5,
 			updates: 1,
 			unverified: 1,
 		});