magus-cli 7.3.0 → 7.4.0

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

@@ -0,0 +1,280 @@
+/**
+ * magus talks to npm by its PACKAGE name, never by its COMMAND name.
+ *
+ * The npm package is `package.json` `name` (`magus-cli`). The command users
+ * type is `magus`. The bare npm name belongs to an unrelated 2015 package
+ * whose latest release is 0.0.2, and npm never transfers names, so the split
+ * is permanent. Addressing npm by the command name made the update banner go
+ * silent and pointed the CLI Tools row at the wrong package.
+ *
+ * This file uses only exports that existed before the fix, so on the old tree
+ * it fails by VALUE (wrong URL, wrong packageName, wrong argv), not merely at
+ * import. Written black-box from the API contract.
+ *
+ * No network: every checkForUpdates call runs against a stubbed fetch, always
+ * with force = true, because the result is cached for the session.
+ */
+
+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 {
+	cliToolInstall,
+	cliToolUninstall,
+	cliToolUpdate,
+} from "../services/cli-tool-commands.js";
+import { cliToolToBin } from "../services/resolver.js";
+import { specForCatalogTool } from "../services/tool-probe.js";
+import {
+	checkForUpdates,
+	formatUpdateMessage,
+	getCurrentVersion,
+} from "../services/version-check.js";
+
+// Read at test time: the single source of truth the requirements name.
+const PKG = JSON.parse(
+	readFileSync(join(import.meta.dir, "..", "..", "package.json"), "utf8"),
+) as { name: string; version: string; bin: Record<string, string> };
+
+/** The command users type. Also, unluckily, an unrelated npm package. */
+const COMMAND = "magus";
+/** The npm package, as the contract states it. */
+const PACKAGE = "magus-cli";
+const REGISTRY = "https://registry.npmjs.org";
+
+function magusEntry() {
+	const entry = cliTools.find((t) => t.name === COMMAND);
+	if (!entry) throw new Error("cliTools has no entry named magus");
+	return entry;
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" },
+	});
+}
+
+function urlOf(input: unknown): string {
+	return input instanceof Request ? input.url : String(input);
+}
+
+describe("checkForUpdates asks npm about the package, not the command", () => {
+	const realFetch = globalThis.fetch;
+	let urls: string[];
+
+	beforeEach(() => {
+		urls = [];
+	});
+
+	afterEach(() => {
+		globalThis.fetch = realFetch;
+	});
+
+	function stubFetch(answer: (url: string) => Response | Promise<Response>) {
+		globalThis.fetch = (async (input: unknown) => {
+			const url = urlOf(input);
+			urls.push(url);
+			return answer(url);
+		}) as typeof fetch;
+	}
+
+	test("fetches the registry `latest` document of package.json `name`, once", async () => {
+		stubFetch(() => jsonResponse({ version: "999.0.0" }));
+
+		await checkForUpdates(true);
+
+		expect(urls).toHaveLength(1);
+		expect(urls[0]).toBe(`${REGISTRY}/${PKG.name}/latest`);
+		expect(urls[0]).toBe(`${REGISTRY}/${PACKAGE}/latest`);
+		// The first path segment is the package, never the command.
+		const segment = new URL(urls[0]!).pathname.split("/")[1];
+		expect(segment).toBe(PKG.name);
+		expect(segment).not.toBe(COMMAND);
+	});
+
+	test("with the registry as observed (bare name at 0.0.2, package ahead), an update is reported", async () => {
+		// A registry that answers per package, the way npm does: the unrelated
+		// package sits at 0.0.2, the real one is ahead of the running version.
+		const registry: Record<string, string> = {
+			magus: "0.0.2",
+			[PKG.name]: "999.0.0",
+		};
+		stubFetch((url) => {
+			const name = new URL(url).pathname.split("/")[1] ?? "";
+			const version = registry[name];
+			return version
+				? jsonResponse({ version })
+				: jsonResponse({ error: "Not found" }, 404);
+		});
+
+		const r = await checkForUpdates(true);
+
+		expect(r.currentVersion).toBe(PKG.version);
+		expect(r.latestVersion).toBe("999.0.0");
+		expect(r.updateAvailable).toBe(true);
+	});
+
+	test("a major release above the running version is a major update", async () => {
+		stubFetch(() => jsonResponse({ version: "999.0.0" }));
+
+		const r = await checkForUpdates(true);
+
+		expect(r.updateAvailable).toBe(true);
+		expect(r.updateType).toBe("major");
+		expect(r.latestVersion).toBe("999.0.0");
+	});
+
+	test("the unrelated package's 0.0.2 is not an update", async () => {
+		stubFetch(() => jsonResponse({ version: "0.0.2" }));
+
+		const r = await checkForUpdates(true);
+
+		expect(r.updateAvailable).toBe(false);
+	});
+
+	test("a non-ok registry response reports no update and keeps the running version", async () => {
+		stubFetch(() => jsonResponse({ error: "boom" }, 500));
+
+		const r = await checkForUpdates(true);
+
+		expect(r.latestVersion).toBe(r.currentVersion);
+		expect(r.updateAvailable).toBe(false);
+	});
+
+	test("a failed fetch reports no update and keeps the running version", async () => {
+		stubFetch(() => {
+			throw new Error("network down");
+		});
+
+		const r = await checkForUpdates(true);
+
+		expect(r.latestVersion).toBe(r.currentVersion);
+		expect(r.updateAvailable).toBe(false);
+	});
+
+	test("the running version is package.json `version`", () => {
+		expect(getCurrentVersion()).toBe(PKG.version);
+	});
+});
+
+describe("formatUpdateMessage", () => {
+	// Kept as a guard on the hint text; not V1 evidence (amendment L5).
+	test("names `magus upgrade` as the way to update", () => {
+		expect(
+			formatUpdateMessage({
+				currentVersion: "1.0.0",
+				latestVersion: "1.2.0",
+				updateAvailable: true,
+				updateType: "minor",
+			} as any),
+		).toBe("Update available: v1.0.0 → v1.2.0 (minor). Run: magus upgrade");
+	});
+
+	test("is empty when no update is available", () => {
+		expect(
+			formatUpdateMessage({
+				currentVersion: "1.0.0",
+				latestVersion: "1.0.0",
+				updateAvailable: false,
+			} as any),
+		).toBe("");
+	});
+});
+
+describe("the CLI Tools entry for magus", () => {
+	test("targets the npm package and keeps the command", () => {
+		const entry = magusEntry();
+
+		expect(entry.packageName).toBe(PKG.name);
+		expect(entry.packageName).toBe(PACKAGE);
+		// R6: everything that names the command is unchanged.
+		expect(entry.name).toBe(COMMAND);
+		expect(entry.displayName).toBe(COMMAND);
+		expect(entry.checkCommand).toBe("magus --version");
+		expect(entry.packageManager).toBe("bun");
+	});
+
+	test("install targets the package", () => {
+		expect(cliToolInstall(magusEntry())).toEqual({
+			cmd: "bun",
+			args: ["install", "-g", PACKAGE],
+		});
+	});
+
+	test("update targets `<package>@latest` with bun and with npm", () => {
+		const entry = magusEntry();
+		expect(cliToolUpdate(entry, "bun")).toEqual({
+			cmd: "bun",
+			args: ["install", "-g", `${PACKAGE}@latest`],
+		});
+		expect(cliToolUpdate(entry, "npm")).toEqual({
+			cmd: "npm",
+			args: ["install", "-g", `${PACKAGE}@latest`],
+		});
+	});
+
+	test("uninstall targets the package with bun and with npm", () => {
+		const entry = magusEntry();
+		expect(cliToolUninstall(entry, "bun")).toEqual({
+			cmd: "bun",
+			args: ["remove", "-g", PACKAGE],
+		});
+		expect(cliToolUninstall(entry, "npm")).toEqual({
+			cmd: "npm",
+			args: ["uninstall", "-g", PACKAGE],
+		});
+	});
+
+	test("no derived command addresses the bare command name on npm", () => {
+		const entry = magusEntry();
+		const commands = [
+			cliToolInstall(entry),
+			cliToolUpdate(entry, "bun"),
+			cliToolUpdate(entry, "npm"),
+			cliToolUninstall(entry, "bun"),
+			cliToolUninstall(entry, "npm"),
+		];
+		for (const c of commands) {
+			expect(c).not.toBeNull();
+			const args = c!.args as string[];
+			const target = args[args.indexOf("-g") + 1] ?? "";
+			// `<package>` or `<package>@<tag>`, never the command name.
+			expect(target.split("@")[0]).toBe(PKG.name);
+			expect(args).not.toContain(COMMAND);
+		}
+	});
+});
+
+describe("pins and probes resolve to the package", () => {
+	test("a pinned version installs `<package>@<version>` and checks the command", () => {
+		expect(cliToolToBin(COMMAND, PKG.version)).toMatchObject({
+			name: COMMAND,
+			via: "bun",
+			package: PACKAGE,
+			check: "magus --version",
+			version: PKG.version,
+		});
+	});
+
+	test("`latest` carries no version", () => {
+		const bin = cliToolToBin(COMMAND, "latest");
+		expect(bin).toMatchObject({
+			name: COMMAND,
+			via: "bun",
+			package: PACKAGE,
+			check: "magus --version",
+		});
+		expect(bin.version).toBeUndefined();
+	});
+
+	test("the catalogue spec (the dist-tags probe input) names the package", () => {
+		expect(specForCatalogTool(magusEntry(), null, undefined)).toMatchObject({
+			name: COMMAND,
+			via: "bun",
+			package: PACKAGE,
+			check: "magus --version",
+		});
+	});
+});

package/src/__tests__/scope-squares.test.tsx

@@ -1,25 +1,16 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import type React from "react";
 import { ScopeSquares } from "../ui/components/primitives/ScopeSquares.js";
-import {
-	SCOPE_OFF_FILL,
-	resetThemeMode,
-	setThemeMode,
-} from "../ui/theme-mode.js";
-import { CONTRAST_REFERENCE, theme } from "../ui/theme.js";
+import { theme } from "../ui/theme.js";
 
 /**
- * The scope bar is three filled segments; only the fill says lit or unlit.
+ * The scope bar is three positional squares: user, project, local.
  *
- * Its unlit fill was `theme.colors.muted` (#6B7280) — the same mid-dark grey as
- * de-emphasised text. On a light page that is a *dark* block, so an unlit segment
- * carried the same visual weight as a lit one and the bar read as three similar
- * blobs: "non installed state is dark as well - confusing".
- *
- * An unlit segment has to recede toward the page, which is exactly what a fixed
- * colour cannot do — a pale fill that sits quietly on cream is a bright block on
- * near-black. So the fill follows the resolved mode, and these tests pin both
- * that behaviour and the dark default that applies before resolution.
+ * It used to be three FILLED blocks told apart only by fill colour — a scope
+ * hue when lit, a page-relative grey when not — so without colour (a
+ * monochrome terminal, a colour-blind reader, a theme drawing two hues alike)
+ * every state was the same shape. Now position names the scope and SHAPE says
+ * the state: `■` installed, `□` not. Colour only repeats what the shape says.
  */
 
 interface SpanLike {
@@ -35,129 +26,52 @@ const glyphs = (el: React.ReactElement) =>
 	segments(el).map((c) => c.props.children);
 const fills = (el: React.ReactElement) => segments(el).map((c) => c.props.fg);
 
-function relativeLuminance(hex: string): number {
-	const n = hex.replace("#", "");
-	const ch = [0, 2, 4].map((i) => Number.parseInt(n.slice(i, i + 2), 16) / 255);
-	const lin = ch.map((c) =>
-		c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4,
-	);
-	return 0.2126 * lin[0] + 0.7152 * lin[1] + 0.0722 * lin[2];
-}
-
-afterEach(() => resetThemeMode());
-
-describe("every segment is a filled block", () => {
-	test("lit and unlit alike use the filled glyph", () => {
-		setThemeMode("light");
+describe("shape says the state", () => {
+	test("installed is filled, not installed is hollow, by position", () => {
 		const el = ScopeSquares({ user: true, project: false, local: true });
-		expect(glyphs(el)).toEqual(["■", "■", "■"]);
+		expect(glyphs(el)).toEqual(["■", "□", "■"]);
 	});
 
 	test("local is omitted when the caller does not pass it", () => {
-		setThemeMode("light");
 		expect(glyphs(ScopeSquares({ user: true, project: false }))).toEqual([
 			"■",
-			"■",
-		]);
-	});
-});
-
-describe("fill distinguishes lit from unlit", () => {
-	test("each lit segment keeps its own scope hue", () => {
-		setThemeMode("light");
-		const el = ScopeSquares({ user: true, project: true, local: true });
-		expect(fills(el)).toEqual([
-			theme.scopes.user,
-			theme.scopes.project,
-			theme.scopes.local,
+			"□",
 		]);
 	});
 
-	test("unlit segments take the page-relative off fill", () => {
-		setThemeMode("light");
-		const el = ScopeSquares({ user: false, project: false, local: false });
-		expect(new Set(fills(el))).toEqual(new Set([SCOPE_OFF_FILL.light]));
-
-		setThemeMode("dark");
-		const dark = ScopeSquares({ user: false, project: false, local: false });
-		expect(new Set(fills(dark))).toEqual(new Set([SCOPE_OFF_FILL.dark]));
+	test("the two states never share a glyph", () => {
+		const on = glyphs(ScopeSquares({ user: true, project: true, local: true }));
+		const off = glyphs(
+			ScopeSquares({ user: false, project: false, local: false }),
+		);
+		expect(new Set(on)).toEqual(new Set(["■"]));
+		expect(new Set(off)).toEqual(new Set(["□"]));
 	});
+});
 
-	test("a mixed bar shows lit and unlit fills side by side", () => {
-		setThemeMode("light");
+describe("colour repeats the shape", () => {
+	test("a filled square wears success, a hollow one muted", () => {
 		const el = ScopeSquares({ user: false, project: true, local: false });
 		expect(fills(el)).toEqual([
-			SCOPE_OFF_FILL.light,
-			theme.scopes.project,
-			SCOPE_OFF_FILL.light,
+			theme.colors.muted,
+			theme.colors.success,
+			theme.colors.muted,
 		]);
 	});
-
-	test("before resolution the fill is the dark pair", () => {
-		resetThemeMode();
-		const el = ScopeSquares({ user: false, project: false, local: false });
-		expect(new Set(fills(el))).toEqual(new Set([SCOPE_OFF_FILL.dark]));
-	});
-});
-
-describe("the unlit fill recedes toward the page it is on", () => {
-	/**
-	 * How far a fill sits from the page, relative to the NEAREST lit segment.
-	 *
-	 * The naive property — "unlit is closer to the page than a lit colour" — is
-	 * too weak, and measurably so: the old #6B7280 satisfied it on a light page
-	 * (0.766 vs 0.774) while still looking wrong. What made the bar read as three
-	 * similar blobs was that unlit sat **99% as far** from the page as a lit
-	 * segment: essentially the same visual weight. Ratio, not order, is the
-	 * property that captures the defect.
-	 */
-	const pageDistanceRatio = (fill: string, page: string) => {
-		const d = (hex: string) =>
-			Math.abs(relativeLuminance(hex) - relativeLuminance(page));
-		const nearestLit = Math.min(...Object.values(theme.scopes).map(d));
-		return d(fill) / nearestLit;
-	};
-
-	/** Unlit must be at most half as far from the page as the nearest lit segment. */
-	const MAX_RATIO = 0.5;
-
-	test("light page: unlit recedes (measured 0.32)", () => {
-		expect(
-			pageDistanceRatio(SCOPE_OFF_FILL.light, CONTRAST_REFERENCE.light),
-		).toBeLessThan(MAX_RATIO);
-	});
-
-	test("dark page: unlit recedes (measured 0.22)", () => {
-		expect(
-			pageDistanceRatio(SCOPE_OFF_FILL.dark, CONTRAST_REFERENCE.dark),
-		).toBeLessThan(MAX_RATIO);
-	});
-
-	test("the old mid-grey fails the property on BOTH pages", () => {
-		// Pins why the value changed, and guards against anyone reinstating it:
-		// 0.99 on cream and 1.10 on near-black — an unlit segment as heavy as a lit
-		// one, or heavier.
-		expect(
-			pageDistanceRatio("#6B7280", CONTRAST_REFERENCE.light),
-		).toBeGreaterThan(MAX_RATIO);
-		expect(
-			pageDistanceRatio("#6B7280", CONTRAST_REFERENCE.dark),
-		).toBeGreaterThan(MAX_RATIO);
-	});
 });
 
 describe("selected rows", () => {
-	test("unlit segments recede into the selection block, lit take its ink", () => {
-		setThemeMode("light");
+	test("filled squares take the selection ink, hollow ones its dim ink", () => {
 		const el = ScopeSquares({
 			user: true,
 			project: false,
 			local: true,
 			selected: true,
 		});
+		expect(glyphs(el)).toEqual(["■", "□", "■"]);
 		expect(fills(el)).toEqual([
 			theme.selection.fg,
-			theme.selection.bg,
+			theme.selection.dim,
 			theme.selection.fg,
 		]);
 	});