magus-cli 7.10.3 → 7.10.4

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

@@ -12,20 +12,20 @@
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
-import { setColorEnabled, stripAnsi, width } from "../cli/ansi.js";
+import { dim, setColorEnabled, stripAnsi, width } from "../cli/ansi.js";
 import {
 	type ApplyState,
 	type Step,
 	applyFrame,
 	applyRow,
 	header,
+	nothingToApplyLines,
 	nothingToApplyNotice,
 	planReport,
 	stepFrame,
 	stepRecord,
 	summaryLine,
 	uncheckedGateNotice,
-	unknownToolsNotice,
 } from "../cli/update-view.js";
 import type { UpdatePlan } from "../services/update-plan.js";
 
@@ -200,11 +200,11 @@ describe("NO_COLOR", () => {
 		// Colour never carries meaning alone: the report has to survive a pipe
 		// and colour blindness. Plugins say their state as a GROUP HEADING and a
 		// glyph; the tool and skill sections still badge each row with its own
-		// action word.
+		// action word. A current tool gets no row; its header count says it.
 		for (const heading of ["Update", "Fix required", "Current"])
 			expect(out).toContain(heading);
-		for (const label of ["CURRENT", "UPGRADE", "INSTALL"])
-			expect(out).toContain(label);
+		for (const label of ["UPGRADE", "INSTALL"]) expect(out).toContain(label);
+		expect(out).toContain("1 current");
 		for (const glyph of ["=", "↑", "+", "?"]) expect(out).toContain(glyph);
 	});
 
@@ -414,58 +414,54 @@ describe("sections", () => {
 		expect(row).toContain("3.7b → 3.7c");
 	});
 
-	test("an unpinned CURRENT tool shows its version, not 'pinned —' (F8)", () => {
+	test("a CURRENT tool gets no row, and the header counts it", () => {
 		setColorEnabled(false);
-		const p = plan();
-		p.bins = [
-			{
-				name: "tmux",
-				action: "current",
-				reason: "up-to-date",
-				installed: "3.7c",
-				latest: null,
-				target: null,
-				sources: [],
-			},
-		];
-		const row = planReport(p).find(
-			(l) => l.includes("tmux ") && l.includes("CURRENT"),
-		)!;
-		expect(row).toContain("3.7c");
-		expect(row).not.toContain("pinned");
-	});
-
-	test("a pinned current tool still names its pin", () => {
-		setColorEnabled(false);
-		const row = planReport(plan()).find((l) => l.includes("tmux-mcp"))!;
-		expect(row).toContain("pinned v1.7.1");
+		const out = planReport(plan());
+		expect(out.some((l) => l.includes("tmux-mcp"))).toBe(false);
+		const header = out.find((l) => /^\s*CLI\s/.test(l))!;
+		expect(header).toMatch(/CLI\s+2\s/);
+		expect(header).toContain("1 current");
+		expect(header).toContain("1 upgrade");
 	});
 
-	test("an UNKNOWN tool shows its reason and no command", () => {
+	test("an unknown tool with no fix gets no row, is counted 'not checked', and no path is printed", () => {
 		setColorEnabled(false);
 		const p = plan();
 		p.bins = [
 			{
 				name: "crush",
 				action: "unknown",
-				reason: "not-managed",
-				note: "on PATH at /n/crush.js, which npm (root /l) does not own",
+				reason: "owner-unknown",
+				note: "could not tell which installer owns it (npm timed out after 8s)",
 				installed: "0.7.1",
 				latest: null,
 				target: null,
 				sources: [],
 			},
+			{
+				name: "zsh",
+				action: "external",
+				reason: "installed-elsewhere",
+				installed: "5.9",
+				latest: null,
+				target: null,
+				sources: [],
+			},
 		];
 		p.binSpecs = new Map([
 			[
 				"crush",
 				{ name: "crush", via: "npm", package: "@charmland/crush", sources: [] },
 			],
+			["zsh", { name: "zsh", via: "brew", sources: [] }],
 		]);
-		const row = planReport(p).find((l) => l.includes("crush"))!;
-		expect(row).toContain("0.7.1");
-		expect(row).toContain("which npm (root /l) does not own");
-		expect(row).not.toContain("npm install");
+		const out = planReport(p);
+		expect(out.some((l) => l.includes("crush") || l.includes("zsh"))).toBe(
+			false,
+		);
+		const header = out.find((l) => /^\s*CLI\s/.test(l))!;
+		expect(header).toMatch(/CLI\s+2\s+1 not checked · 1 installed elsewhere$/);
+		expect(out.join("\n")).not.toContain("npm install");
 	});
 });
 
@@ -476,18 +472,14 @@ describe("unverified notices", () => {
 	// closing notices must hold for every one of them. They used to say "re-run
 	// once the catalog is reachable", which is false advice for a plugin whose
 	// marketplace publishes no version — the case a real dry run showed five of.
-	const notices = () => [
-		nothingToApplyNotice(5),
-		unknownToolsNotice(1, ["crush"]),
-		uncheckedGateNotice(6),
-	];
+	const notices = () => [nothingToApplyNotice(5), uncheckedGateNotice(6, 0)];
 
 	test("never advise a re-run, never blame the catalog", () => {
 		setColorEnabled(false);
 		for (const line of notices()) {
 			expect(line).not.toMatch(/re-run/i);
 			expect(line).not.toContain("catalog is reachable");
-			expect(line).toContain("Reasons are shown above.");
+			expect(line).toMatch(/[Rr]eason(s are| is) shown above\./);
 		}
 	});
 
@@ -503,22 +495,103 @@ describe("unverified notices", () => {
 		expect(nothing).toContain("They are NOT reported as up to date.");
 	});
 
-	test("the tool notice names the tools it could not check", () => {
-		setColorEnabled(false);
-		expect(unknownToolsNotice(2, ["crush", "tmux"])).toContain(
-			"2 tool(s) could not be checked: crush, tmux — not applied.",
-		);
-	});
-
 	test("the gate notice says the unknowns passed without being verified", () => {
 		// `--check` exits 0 with unknowns present, so this line carries the whole
 		// difference between "nothing is known to be behind" and "all verified".
 		setColorEnabled(false);
-		const line = uncheckedGateNotice(6);
-		expect(line).toContain("6 item(s) could not be checked");
+		const line = uncheckedGateNotice(4, 2);
+		expect(line).toContain("4 plugin(s) and 2 tool(s) could not be checked");
 		expect(line).toContain("they do not fail this gate");
 		expect(line).toContain("They are NOT reported as up to date.");
 		// A warning, not a failure: the gate is about to pass.
 		expect(line.trimStart()).toStartWith("⚠");
 	});
+
+	test("the gate notice points at reasons only where the report shows them", () => {
+		// A plugin's reason is on its row; an unchecked tool has no row, only a
+		// count in the CLI header — so a tools-only notice claims no reasons.
+		setColorEnabled(false);
+		expect(uncheckedGateNotice(1, 0)).toContain(
+			"Each plugin's reason is shown above.",
+		);
+		const tools = uncheckedGateNotice(0, 2);
+		expect(tools).toContain("2 tool(s) could not be checked");
+		expect(tools).not.toContain("shown above");
+		expect(tools).not.toContain("plugin");
+	});
+});
+
+describe("nothing to apply", () => {
+	const lines = (c: {
+		unknownPlugins: number;
+		unknownTools: number;
+		heldBack: number;
+	}) => {
+		setColorEnabled(false);
+		return nothingToApplyLines(c);
+	};
+
+	test("'Everything is up to date' only when nothing is unchecked or held back", () => {
+		expect(lines({ unknownPlugins: 0, unknownTools: 0, heldBack: 0 })).toEqual([
+			"  ✓  Everything is up to date.",
+		]);
+	});
+
+	test("unchecked tools alone: a dim note, never the success line, never a warning", () => {
+		const out = lines({ unknownPlugins: 0, unknownTools: 2, heldBack: 0 });
+		expect(out).toHaveLength(1);
+		expect(out[0]!.trim()).toBe("Nothing to apply. 2 tool(s) not checked.");
+		expect(out.join("\n")).not.toContain("up to date");
+		expect(out.join("\n")).not.toMatch(/[✓⚠]/);
+	});
+
+	test("a held-back tool alone is not 'up to date' either", () => {
+		const out = lines({ unknownPlugins: 0, unknownTools: 0, heldBack: 1 });
+		expect(out.map((l) => l.trim())).toEqual([
+			"Nothing to apply. 1 held back.",
+		]);
+	});
+
+	test("unverified plugins keep their warning; tools add a dim count", () => {
+		const out = lines({ unknownPlugins: 3, unknownTools: 1, heldBack: 1 });
+		expect(out[0]).toBe(nothingToApplyNotice(3));
+		expect(out[1]!.trim()).toBe("1 tool(s) not checked · 1 held back.");
+		expect(out.join("\n")).not.toContain("Everything is up to date");
+	});
+
+	test("the dim note really is dim when colour is on", () => {
+		setColorEnabled(true);
+		const [line] = nothingToApplyLines({
+			unknownPlugins: 0,
+			unknownTools: 1,
+			heldBack: 0,
+		});
+		expect(line).toContain(dim("Nothing to apply. 1 tool(s) not checked."));
+	});
+});
+
+describe("a held-back tool", () => {
+	test("is its own kind: a HELD row with `brew unpin`, counted 'held back'", () => {
+		setColorEnabled(false);
+		const p = plan();
+		p.bins = [
+			{
+				name: "tmux",
+				action: "unknown",
+				reason: "held-back",
+				note: "held by brew pin",
+				installed: "3.7b",
+				latest: "3.7c",
+				target: null,
+				sources: [],
+			},
+		];
+		const out = planReport(p);
+		const header = out.find((l) => /^\s*CLI\s/.test(l))!;
+		expect(header).toMatch(/CLI\s+1\s+1 held back$/);
+		const row = out.find((l) => l.includes("tmux "))!;
+		expect(row).toContain("HELD");
+		expect(row).toContain("brew unpin tmux");
+		expect(row).not.toContain("UNKNOWN");
+	});
 });

package/src/__tests__/fixtures/bins.ts

@@ -14,8 +14,15 @@ import type {
 	SelectedBin,
 } from "../../types/index.js";
 
+/**
+ * A version-managed tool, plus the REQUIREMENT's presence check as one line
+ * (`Requirement.check`, which doctor runs). ManagedTool itself carries no check:
+ * the update probe reads versions only through magus's own table.
+ */
+export type TestTool = ManagedTool & { check?: string };
+
 /** A selected requirement whose one option (and choice) is `t`'s installer. */
-export function selected(t: ManagedTool, root?: string): SelectedBin {
+export function selected(t: TestTool, root?: string): SelectedBin {
 	const option = managedOption(t);
 	return {
 		name: t.name,
@@ -27,7 +34,7 @@ export function selected(t: ManagedTool, root?: string): SelectedBin {
 }
 
 /** {@link selected}, with provenance. */
-export function resolved(t: ManagedTool, sources: string[]): ResolvedBin {
+export function resolved(t: TestTool, sources: string[]): ResolvedBin {
 	return { ...selected(t), sources };
 }
 

package/src/__tests__/npm-package-name.test.ts

@@ -19,6 +19,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { cliTools } from "../data/cli-tools.js";
+import { presenceArgv } from "../data/tool-versions.js";
 import {
 	cliToolInstall,
 	cliToolUninstall,
@@ -192,7 +193,8 @@ describe("the CLI Tools entry for magus", () => {
 		// R6: everything that names the command is unchanged.
 		expect(entry.name).toBe(COMMAND);
 		expect(entry.displayName).toBe(COMMAND);
-		expect(entry.checkCommand).toBe("magus --version");
+		// The version command is magus's one table, keyed by the command.
+		expect(presenceArgv(entry.name)).toEqual(["magus", "--version"]);
 		expect(entry.packageManager).toBe("bun");
 	});
 
@@ -271,7 +273,6 @@ describe("pins and probes resolve to the package", () => {
 			name: COMMAND,
 			via: "bun",
 			package: PACKAGE,
-			check: "magus --version",
 		});
 	});
 });

package/src/__tests__/tool-adopt-brew-owner.test.ts

@@ -0,0 +1,167 @@
+// REGRESSION: brew adopted as owner of a same-version copy PATH does not run — release review of magus 7.10.4
+/**
+ * docs/plans/2026-10-08-magus-update-tool-rows.md, decision 7: when the
+ * declared installer does not have the file PATH runs, magus asks the other
+ * installers it drives. Ownership is the installer's OWN answer about the file
+ * PATH runs. A same-version string in `brew list --versions` is not that
+ * answer: brew's own file list for the formula (`brew list <formula>`, one
+ * absolute path per line) is.
+ *
+ * Blind tests: written from the spec and the exported ToolProbeIO seam only.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	type ExecResult,
+	type ToolFacts,
+	type ToolProbeIO,
+	classifyTool,
+	probeTool,
+} from "../services/tool-probe.js";
+import type { ManagedTool } from "../types/index.js";
+
+type Handler = Partial<ExecResult>;
+
+interface Setup {
+	exec: Record<string, Handler>;
+	onPath: Record<string, string>;
+	real: Record<string, string>;
+	json?: Record<string, unknown>;
+	env: Record<string, string>;
+}
+
+const MISSING: ExecResult = {
+	code: null,
+	stdout: "",
+	stderr: "",
+	timedOut: false,
+	missing: true,
+};
+
+function fakeIO(setup: Setup): ToolProbeIO & { calls: string[] } {
+	const calls: string[] = [];
+	return {
+		calls,
+		exec: async (command) => {
+			const key = [command.cmd, ...command.args].join(" ");
+			calls.push(key);
+			const h = setup.exec[key];
+			if (h === undefined) return MISSING;
+			return {
+				code: 0,
+				stdout: "",
+				stderr: "",
+				timedOut: false,
+				missing: false,
+				...h,
+			};
+		},
+		fetchJson: async () => ({ ok: false, reason: "returned 404" }),
+		readJson: async (file) => setup.json?.[file] ?? null,
+		readText: async () => null,
+		readlink: async () => null,
+		realpath: async (file) => setup.real[file] ?? file,
+		resolveExecutable: async (name) => setup.onPath[name] ?? null,
+		env: setup.env,
+		homedir: "/Users/j",
+	};
+}
+
+const OPTS = { timeoutMs: 500, deadlineMs: 3000 };
+const BUN_HOME = "/Users/j/.bun";
+const ENV = { HOMEBREW_PREFIX: "/opt/homebrew", BUN_INSTALL: BUN_HOME };
+const ON_PATH = "/usr/local/bin/claudish";
+const BREW_FILE = "/opt/homebrew/Cellar/claudish/10.4.1/bin/claudish";
+
+const OUTDATED_BEHIND = JSON.stringify({
+	formulae: [
+		{
+			name: "claudish",
+			installed_versions: ["10.4.1"],
+			current_version: "10.4.2",
+			pinned: false,
+			pinned_version: null,
+		},
+	],
+	casks: [],
+});
+
+/** brew's own file list for the formula: one absolute path per line. */
+const brewFiles = (...extra: string[]): string =>
+	`${[
+		BREW_FILE,
+		"/opt/homebrew/Cellar/claudish/10.4.1/INSTALL_RECEIPT.json",
+		"/opt/homebrew/Cellar/claudish/10.4.1/README.md",
+		...extra,
+	].join("\n")}\n`;
+
+/** A world where bun is declared, bun's tree has no `claudish`, brew has 10.4.1. */
+function world(resolved: string, json?: Record<string, unknown>) {
+	return fakeIO({
+		env: ENV,
+		onPath: { claudish: ON_PATH },
+		real: { [ON_PATH]: resolved },
+		json,
+		exec: {
+			"brew list --versions claudish": { stdout: "claudish 10.4.1\n" },
+			"brew list claudish": { stdout: brewFiles() },
+			"brew outdated --json=v2 claudish": { stdout: OUTDATED_BEHIND },
+			"claudish --version": { stdout: "claudish version 10.4.1\n" },
+		},
+	});
+}
+
+const bunSpec: ManagedTool = { name: "claudish", via: "bun" };
+
+function plansBrewUpgrade(io: { calls: string[] }, f: ToolFacts): boolean {
+	return (
+		f.upgradeCommand?.cmd === "brew" ||
+		(f.managed === true &&
+			(f.sources as string[]).includes("brew") &&
+			io.calls.includes("brew outdated --json=v2 claudish") &&
+			f.behind === true)
+	);
+}
+
+describe("brew is credited only for a file brew itself lists", () => {
+	test("1. same-version twin: PATH runs a copy brew does not list — installed elsewhere, never a brew upgrade", async () => {
+		// Not brew's, not bun's, not under any node_modules prefix.
+		const io = world("/Users/j/tools/claudish-dist/claudish");
+		const f = await probeTool(bunSpec, io, OPTS);
+		const st = classifyTool(bunSpec, f);
+
+		expect(st.state).not.toBe("upgrade");
+		expect(f.upgradeCommand?.cmd).not.toBe("brew");
+		expect(plansBrewUpgrade(io, f)).toBe(false);
+		expect(f.managed).toBe(false);
+		expect(st.state as string).toBe("external");
+		expect(st.reason as string).toBe("installed-elsewhere");
+	});
+
+	test("2. positive control: brew's file list includes the file PATH runs — brew owns it, upgrade through brew", async () => {
+		const io = world(BREW_FILE);
+		const f = await probeTool(bunSpec, io, OPTS);
+		const st = classifyTool(bunSpec, f);
+
+		expect(f.managed).toBe(true);
+		expect(f.installed).toBe("10.4.1");
+		expect(st.state).toBe("upgrade");
+		expect(st.latest).toBe("10.4.2");
+		expect(f.upgradeCommand?.cmd).toBe("brew");
+		expect(f.upgradeCommand?.args).toContain("upgrade");
+	});
+
+	test("3. a file in bun's global tree under another package never falls through to brew adoption", async () => {
+		const pkg = `${BUN_HOME}/install/global/node_modules/other-pkg`;
+		const io = world(`${pkg}/bin/claudish.cjs`, {
+			[`${pkg}/package.json`]: { name: "other-pkg", version: "10.4.1" },
+		});
+		const f = await probeTool(bunSpec, io, OPTS);
+		const st = classifyTool(bunSpec, f);
+
+		expect(f.upgradeCommand?.cmd).not.toBe("brew");
+		expect(plansBrewUpgrade(io, f)).toBe(false);
+		expect(st.state).not.toBe("upgrade");
+		expect(io.calls.filter((c) => c.startsWith("brew upgrade"))).toEqual([]);
+	});
+});