magus-cli 0.0.0-placeholder → 7.0.0

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

@@ -0,0 +1,239 @@
+/**
+ * The CLI-tools catalogue can no longer emit a bare `pip`, or shell syntax.
+ *
+ * Two defects lived in this screen, and both were data problems dressed as code
+ * problems:
+ *
+ *  1. **Bare `pip`.** `getUpdateCommand`'s `pip` and `default` arms returned the
+ *     catalogue's `installCommand` verbatim, and `getUninstallCommand` emitted
+ *     `pip uninstall -y`. `pip` is frequently a zsh alias rather than an
+ *     executable, and a machine that manages Python tools with uv or pipx may
+ *     have no `pip` at all. `services/toolchain.ts` already knew how to answer
+ *     "how does Python work here"; this screen was not asking it.
+ *  2. **Shell syntax in data.** `aider`'s entry was
+ *     `pip install aider-install && aider-install` — a `&&` chain in a catalogue
+ *     field that got handed to `/bin/bash`.
+ *
+ * Both are now unrepresentable: the field is gone and the command is derived.
+ * These tests assert that over the whole catalogue rather than over an example,
+ * so a new entry cannot reintroduce either.
+ *
+ * Pure — no React, no network, no PATH dependency. Every Python installer is
+ * pinned explicitly, per the convention `toolchain.test.ts` established: the
+ * production default is resolved from PATH, so an unpinned assertion would
+ * encode whatever happens to be installed on the machine running the suite.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { cliTools } from "../data/cli-tools.js";
+import {
+	type InstallMethod,
+	cliToolInstall,
+	cliToolUninstall,
+	cliToolUpdate,
+} from "../services/cli-tool-commands.js";
+import { versionFromPypiJson } from "../services/tool-probe.js";
+import {
+	PYTHON_CLI_INSTALLERS,
+	type PythonCliInstaller,
+	resolvePythonCliInstaller,
+} from "../services/toolchain.js";
+import { type Command, formatCommand } from "../utils/command-utils.js";
+
+const byProbe = (probe: string): PythonCliInstaller => {
+	const found = PYTHON_CLI_INSTALLERS.find((i) => i.probe === probe);
+	if (!found) throw new Error(`no python installer with probe ${probe}`);
+	return found;
+};
+const PYTHON_PROBES = PYTHON_CLI_INSTALLERS.map((i) => i.probe);
+
+/** 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("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.
+		expect(cliTools.length).toBeGreaterThan(5);
+		for (const tool of cliTools) {
+			expect(typeof tool.packageName).toBe("string");
+			expect(tool.packageName.length).toBeGreaterThan(0);
+			expect(["bun", "npm", "pip", "brew", "go"]).toContain(
+				tool.packageManager,
+			);
+		}
+	});
+});
+
+describe("no builder ever emits a bare `pip`", () => {
+	test("install: cmd is the resolver's probe, never `pip`", () => {
+		for (const tool of cliTools) {
+			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);
+			}
+		}
+	});
+
+	test("update and uninstall: cmd is never `pip`, for any method", () => {
+		for (const tool of cliTools) {
+			for (const method of RESOLVED_METHODS) {
+				for (const cmd of [
+					cliToolUpdate(tool, method),
+					cliToolUninstall(tool, method),
+				]) {
+					if (!cmd) continue;
+					expect(cmd.cmd).not.toBe("pip");
+				}
+			}
+		}
+	});
+
+	test("each pinned Python installer drives all three of its own commands", () => {
+		// Pinned explicitly so this holds on a runner with no uv. The `pip`
+		// method must route to the SAME executable for install, update and
+		// uninstall — installing with uv and uninstalling with python3 would look
+		// like it worked and leave the tool on disk.
+		for (const probe of PYTHON_PROBES) {
+			const python = byProbe(probe);
+			expect(python.install("x").cmd).toBe(probe);
+			expect(python.upgrade("x").cmd).toBe(probe);
+			expect(python.uninstall("x").cmd).toBe(probe);
+		}
+	});
+});
+
+describe("no builder can emit shell syntax", () => {
+	test("no argv element of any command contains &&, | or ;", () => {
+		// The catalogue's only `&&` chain was aider's installCommand. With the
+		// field gone there is nowhere left for shell syntax to enter, and this
+		// asserts that over every entry and every method rather than over that
+		// one case.
+		const all: Command[] = [];
+		for (const tool of cliTools) {
+			all.push(cliToolInstall(tool));
+			for (const method of [
+				...RESOLVED_METHODS,
+				"pnpm" as const,
+				"yarn" as const,
+			]) {
+				const u = cliToolUpdate(tool, method);
+				const r = cliToolUninstall(tool, method);
+				if (u) all.push(u);
+				if (r) all.push(r);
+			}
+		}
+		expect(all.length).toBeGreaterThan(0);
+
+		for (const cmd of all) {
+			for (const token of [cmd.cmd, ...cmd.args]) {
+				expect(token).not.toContain("&&");
+				expect(token).not.toContain("|");
+				expect(token).not.toContain(";");
+			}
+		}
+	});
+});
+
+describe("the detected method is followed, not the catalogue's", () => {
+	test("pnpm and yarn keep their own shapes", () => {
+		// A tool the catalogue calls npm can still have been installed with
+		// pnpm. Updating it as npm would install a second copy beside the first,
+		// which is the conflict this screen exists to report.
+		const tool = cliTools.find((t) => t.packageManager === "npm")!;
+		expect(cliToolUpdate(tool, "pnpm")).toEqual({
+			cmd: "pnpm",
+			args: ["install", "-g", tool.packageName],
+		});
+		expect(cliToolUpdate(tool, "yarn")).toEqual({
+			cmd: "yarn",
+			args: ["global", "add", tool.packageName],
+		});
+		expect(cliToolUninstall(tool, "pnpm")).toEqual({
+			cmd: "pnpm",
+			args: ["remove", "-g", tool.packageName],
+		});
+		expect(cliToolUninstall(tool, "yarn")).toEqual({
+			cmd: "yarn",
+			args: ["global", "remove", tool.packageName],
+		});
+	});
+
+	test("`unknown` returns null rather than guessing", () => {
+		// Preserves the observable behaviour: handleInstall reads
+		// `installed && updateCommand ? updateCommand : install…`, so null falls
+		// back to a plain install — which is what the old `default:` arm did by
+		// returning `tool.installCommand`.
+		const tool = cliTools[0]!;
+		expect(cliToolUpdate(tool, "unknown")).toBeNull();
+		expect(cliToolUninstall(tool, "unknown")).toBeNull();
+	});
+
+	test("brew and go arms are pinned, since no catalogue entry exercises them", () => {
+		// Every entry today is bun/npm/pip, so these two ship untouched by real
+		// data. `go` has no uninstaller — `go install` writes a binary and
+		// records nothing — so null is correct rather than an invented `rm`.
+		const tool = cliTools[0]!;
+		expect(cliToolUpdate(tool, "brew", "some-formula")).toEqual({
+			cmd: "brew",
+			args: ["upgrade", "some-formula"],
+		});
+		expect(cliToolUninstall(tool, "brew", "some-formula")).toEqual({
+			cmd: "brew",
+			args: ["uninstall", "some-formula"],
+		});
+	});
+});
+
+describe("derived commands still read as they did", () => {
+	test("claude renders exactly the literal the catalogue used to carry", () => {
+		// The entry whose command SHOULD not change. Its old
+		// `installCommand: "npm install -g @anthropic-ai/claude-code"` is now
+		// derived from packageManager + packageName, and must render identically.
+		const claude = cliTools.find((t) => t.name === "claude")!;
+		expect(formatCommand(cliToolInstall(claude))).toBe(
+			"npm install -g @anthropic-ai/claude-code",
+		);
+	});
+
+	test("aider now installs the package its own fields already named", () => {
+		// The one deliberate behaviour change. The old command installed
+		// `aider-install`, a bootstrapper whose version nothing here ever read,
+		// while `packageName`, `checkCommand` and the PyPI query all said
+		// `aider-chat`. The installCommand was the field that was out of step.
+		const aider = cliTools.find((t) => t.name === "aider")!;
+		expect(aider.packageName).toBe("aider-chat");
+		expect(cliToolInstall(aider).args).toContain("aider-chat");
+		expect(formatCommand(cliToolInstall(aider))).not.toContain("aider-install");
+	});
+});
+
+describe("versionFromPypiJson", () => {
+	// The shape of a real https://pypi.org/pypi/<pkg>/json body, trimmed to the
+	// two fields that matter. Captured rather than mocked so the parser is
+	// tested against what the endpoint actually returns.
+	const body = {
+		info: { name: "aider-chat", version: "0.86.1" },
+		releases: {},
+	};
+
+	test("reads info.version", () => {
+		expect(versionFromPypiJson(body)).toBe("0.86.1");
+	});
+
+	test("anything unexpected yields undefined, never a throw", () => {
+		// A version check is advisory: it must degrade to "no update badge",
+		// never take the screen down. PyPI returning an error object, a 404 body,
+		// or nothing at all all land here.
+		expect(versionFromPypiJson({})).toBeUndefined();
+		expect(versionFromPypiJson({ info: {} })).toBeUndefined();
+		expect(versionFromPypiJson({ info: { version: 42 } })).toBeUndefined();
+		expect(versionFromPypiJson(null)).toBeUndefined();
+		expect(versionFromPypiJson("not json at all")).toBeUndefined();
+	});
+});

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

@@ -0,0 +1,294 @@
+/**
+ * The TUI CLI Tools row is built from the shared probe facts and the shared
+ * classifier — the row can no longer disagree with `magus update`.
+ *
+ * Pure: `buildToolRow` over `specForCatalogTool`, with facts supplied the way
+ * `probeTools` would report them. No React, no IO.
+ */
+
+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,
+	classifyTool,
+	specForCatalogTool,
+} from "../services/tool-probe.js";
+import { binCommandFor } from "../services/update-engine.js";
+import { planBinUpdates } from "../services/update-plan.js";
+import type { ResolvedBin } from "../types/index.js";
+import {
+	buildToolRow,
+	cliToolStatusText,
+	countToolRows,
+} from "../ui/adapters/cliToolsAdapter.js";
+
+const catalogue = (name: string) => {
+	const tool = cliTools.find((t) => t.name === name);
+	if (!tool) throw new Error(`no catalogue tool ${name}`);
+	return tool;
+};
+
+function facts(name: string, over: Partial<ToolFacts> = {}): ToolFacts {
+	return {
+		name,
+		present: true,
+		resolvedPath: `/x/${name}`,
+		installed: "1.0.0",
+		latest: null,
+		behind: null,
+		managed: true,
+		sources: [],
+		...over,
+	};
+}
+
+describe("buildToolRow — which installer a catalogue row is judged through", () => {
+	test("catalogue says npm, detected bun: the spec is bun and the state is bun's", () => {
+		// codex and opencode on the reporter's machine: catalogued as npm,
+		// installed by bun into ~/.bun/install/global.
+		const codex = catalogue("codex");
+		expect(codex.packageManager).toBe("npm");
+		const install = { primary: "bun" as const, all: ["bun" as const] };
+		const spec = specForCatalogTool(codex, null, install);
+		expect(spec.via).toBe("bun");
+
+		const row = buildToolRow(
+			codex,
+			spec,
+			facts("codex", { installed: "0.153.2", latest: "0.154.0" }),
+			install,
+		);
+		expect(row.status).toMatchObject({
+			state: "upgrade",
+			target: "0.154.0",
+		});
+		// Enter names the same installer the row was probed through.
+		expect(row.updateCommand).toEqual({
+			cmd: "bun",
+			args: ["install", "-g", "@openai/codex@latest"],
+		});
+	});
+
+	test("declared by the closure with via npm: the closure wins, and the row equals the CLI plan", () => {
+		const codex = catalogue("codex");
+		const declared: ResolvedBin = {
+			name: "codex",
+			via: "npm",
+			package: "@openai/codex",
+			sources: ["profile:default.cliTools"],
+		};
+		const install = { primary: "bun" as const, all: ["bun" as const] };
+		const spec = specForCatalogTool(codex, [declared], install);
+		expect(spec).toBe(declared);
+
+		// Through npm, the bun-installed file is not npm's: not-managed.
+		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");
+	});
+
+	test("pinned and behind: the row's key installs the PIN, exactly what the CLI runs", () => {
+		// The defect this pins: the row read `→ v0.150.0` (the pin) while its
+		// key ran `npm install -g @openai/codex@latest`, which installs past the
+		// pin and leaves the tool `unknown / ahead-of-pin` for good.
+		const codex = catalogue("codex");
+		const declared: ResolvedBin = {
+			name: "codex",
+			via: "npm",
+			package: "@openai/codex",
+			version: "0.150.0",
+			sources: ["profile:default.cliTools"],
+		};
+		// Detected as bun — the installer the OLD command builder followed.
+		const install = { primary: "bun" as const, all: ["bun" as const] };
+		const spec = specForCatalogTool(codex, [declared], install);
+		const f = facts("codex", { installed: "0.149.0", managed: true });
+
+		const row = buildToolRow(codex, spec, f, install);
+		expect(row.status).toMatchObject({
+			state: "upgrade",
+			reason: "behind-pin",
+			target: "0.150.0",
+		});
+		expect(row.updateCommand).toEqual({
+			cmd: "npm",
+			args: ["install", "-g", "@openai/codex@0.150.0"],
+		});
+		// And it is the same command `magus update` would run for this row.
+		const [item] = planBinUpdates([declared], [f]);
+		expect(row.updateCommand).toEqual(binCommandFor(item!, declared)!);
+	});
+
+	test("declared and absent: Enter installs at the pin, not the catalogue's @latest", () => {
+		const codex = catalogue("codex");
+		const declared: ResolvedBin = {
+			name: "codex",
+			via: "npm",
+			package: "@openai/codex",
+			version: "0.150.0",
+			sources: ["profile:default.cliTools"],
+		};
+		const row = buildToolRow(
+			codex,
+			specForCatalogTool(codex, [declared], undefined),
+			facts("codex", { present: false, installed: null }),
+		);
+		expect(row.status?.state).toBe("install");
+		expect(row.updateCommand).toBeUndefined();
+		expect(row.installCommand).toEqual({
+			cmd: "npm",
+			args: ["install", "-g", "@openai/codex@0.150.0"],
+		});
+	});
+
+	test("declared, unpinned and behind: the closure's package, at latest", () => {
+		const codex = catalogue("codex");
+		const declared: ResolvedBin = {
+			name: "codex",
+			via: "npm",
+			package: "@openai/codex",
+			sources: ["plugin:dev@magus"],
+		};
+		const install = { primary: "bun" as const, all: ["bun" as const] };
+		const row = buildToolRow(
+			codex,
+			specForCatalogTool(codex, [declared], install),
+			facts("codex", { installed: "0.153.2", latest: "0.154.0" }),
+			install,
+		);
+		expect(row.status?.state).toBe("upgrade");
+		// npm, the PROFILE's installer — not bun, the detected one — because the
+		// row's state was judged through npm too.
+		expect(row.updateCommand).toEqual({
+			cmd: "npm",
+			args: ["install", "-g", "@openai/codex@latest"],
+		});
+	});
+
+	test("undeclared: the screen's own rule survives — how it IS installed", () => {
+		const codex = catalogue("codex");
+		const install = { primary: "bun" as const, all: ["bun" as const] };
+		const row = buildToolRow(
+			codex,
+			specForCatalogTool(codex, null, install),
+			facts("codex", { installed: "0.153.2", latest: "0.154.0" }),
+			install,
+		);
+		expect(row.updateCommand).toEqual({
+			cmd: "bun",
+			args: ["install", "-g", "@openai/codex@latest"],
+		});
+		expect(row.installCommand).toEqual(cliToolInstall(codex));
+	});
+
+	test("detected pnpm → the catalogue's via, and a not-managed row naming the real path", () => {
+		const opencode = catalogue("opencode");
+		const install = { primary: "pnpm" as const, all: ["pnpm" as const] };
+		const spec = specForCatalogTool(opencode, null, install);
+		expect(spec.via).toBe(opencode.packageManager);
+
+		const f = facts("opencode", {
+			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?.reason).toBe("not-managed");
+		expect(row.status?.note).toContain("/Users/j/.local/share/pnpm/");
+		// Enter still follows how it IS installed (pnpm).
+		expect(row.updateCommand?.cmd).toBe("pnpm");
+	});
+
+	test("no facts yet → checking, no status, no command", () => {
+		const tool = catalogue("claudish");
+		const row = buildToolRow(
+			tool,
+			specForCatalogTool(tool, null, undefined),
+			undefined,
+		);
+		expect(row).toMatchObject({ checking: true, status: null });
+		expect(row.updateCommand).toBeUndefined();
+		expect(cliToolStatusText(row).suffix).toBe(" ...");
+	});
+
+	test("absent → install, with no update command", () => {
+		const tool = catalogue("cline");
+		const spec = specForCatalogTool(tool, null, undefined);
+		const row = buildToolRow(
+			tool,
+			spec,
+			facts("cline", { present: false, installed: null }),
+			{ primary: "unknown", all: [] },
+		);
+		expect(row.status?.state).toBe("install");
+		expect(row.updateCommand).toBeUndefined();
+	});
+});
+
+describe("cliToolStatusText — the row's words", () => {
+	test("unknown renders as ? <note>, the note verbatim", () => {
+		const tool = catalogue("crush");
+		const spec = specForCatalogTool(tool, null, {
+			primary: "npm",
+			all: ["npm"],
+		});
+		const f = facts("crush", { managed: false, owner: "npm (root /l)" });
+		const row = buildToolRow(tool, spec, f);
+		const text = cliToolStatusText(row);
+		expect(text.tone).toBe("warning");
+		expect(text.suffix).toBe(` ? ${classifyTool(spec, f).note}`);
+	});
+
+	test("upgrade names the target once, with one v", () => {
+		const tool = catalogue("mnemex");
+		const spec = specForCatalogTool(tool, null, {
+			primary: "bun",
+			all: ["bun"],
+		});
+		const row = buildToolRow(tool, spec, facts("mnemex", { latest: "v1.2.0" }));
+		expect(cliToolStatusText(row).suffix).toBe(" → v1.2.0");
+	});
+
+	test("current and install say nothing extra", () => {
+		const tool = catalogue("mnemex");
+		const spec = specForCatalogTool(tool, null, undefined);
+		expect(
+			cliToolStatusText(
+				buildToolRow(tool, spec, facts("mnemex", { behind: false })),
+			).suffix,
+		).toBe("");
+	});
+});
+
+describe("countToolRows — header counts from states", () => {
+	test("installed, updates and unverified", () => {
+		const tool = catalogue("mnemex");
+		const spec = specForCatalogTool(tool, null, undefined);
+		const rows = [
+			buildToolRow(tool, spec, facts("mnemex", { behind: false })),
+			buildToolRow(tool, spec, facts("mnemex", { behind: true })),
+			buildToolRow(tool, spec, facts("mnemex", { managed: false })),
+			buildToolRow(tool, spec, facts("mnemex", { present: false })),
+			buildToolRow(tool, spec, undefined),
+		];
+		expect(countToolRows(rows)).toEqual({
+			installed: 3,
+			updates: 1,
+			unverified: 1,
+		});
+	});
+});