magus-cli 7.3.1 → 7.4.1

package/src/__tests__/tabbar-layout.test.ts

@@ -1,71 +1,83 @@
 import { describe, expect, test } from "bun:test";
-import { TABS, barWidth, layoutTabs } from "../ui/components/TabBar.js";
+import {
+	TABS,
+	type TabLayout,
+	barWidth,
+	layoutTabs,
+} from "../ui/components/TabBar.js";
 
 const FULL = TABS.map((t) => `${t.key}:${t.label}`);
 const FULL_WIDTH = barWidth(FULL);
 
-/** The widest the compacted bar ever gets — whichever active label is longest. */
+/** Columns a layout actually paints. */
+const painted = (layout: TabLayout) => barWidth(layout.texts, layout.padded);
+
+/** The widest the key-only bar ever gets — whichever active label is longest. */
 const WIDEST_COMPACT = Math.max(
-	...TABS.map((tab) => barWidth(layoutTabs(TABS, tab.screen, 0))),
+	...TABS.map((tab) => painted(layoutTabs(TABS, tab.screen, 0))),
 );
 
 describe("tab bar layout", () => {
-	test("shows every label when the bar fits", () => {
-		expect(layoutTabs(TABS, "plugins", FULL_WIDTH)).toEqual(FULL);
+	test("shows every label, padded, when the full bar fits", () => {
+		expect(layoutTabs(TABS, "plugins", FULL_WIDTH)).toEqual({
+			texts: FULL,
+			padded: true,
+		});
 	});
 
-	test("drops inactive labels when the bar does not fit", () => {
-		// A 94-column pane leaves ~90 usable, and ten full tabs need ~110 — the
-		// width at which OpenTUI clipped each cell into a meaningless stub.
-		const texts = layoutTabs(TABS, "styles", 90);
-		expect(texts).toContain("9:Styles");
-		expect(texts).toContain("1");
-		expect(texts).not.toContain("1:Plugins");
+	test("drops the padding before it drops any label", () => {
+		// A 94-column pane leaves 90 usable. Ten padded tabs need 110, but the
+		// same ten names unpadded need exactly 90 — so every tab keeps its name.
+		// The old rule jumped straight to bare numbers here.
+		expect(layoutTabs(TABS, "styles", 90)).toEqual({
+			texts: FULL,
+			padded: false,
+		});
 	});
 
-	test("the compact bar actually fits a narrow pane", () => {
-		// The point of compacting is that the result fits. If it did not, the
-		// fallback would just be a differently-truncated mess.
-		expect(barWidth(layoutTabs(TABS, "styles", 90))).toBeLessThanOrEqual(90);
+	test("shortens inactive labels to prefixes before dropping them", () => {
+		const layout = layoutTabs(TABS, "styles", 70);
+		expect(layout.texts).toContain("9:Styles");
+		expect(layout.texts).not.toContain("1");
+		expect(layout.texts.find((t) => t.startsWith("1:"))).toMatch(/^1:Plu/);
+		expect(painted(layout)).toBeLessThanOrEqual(70);
 	});
 
-	test("the full bar no longer fits a standard window, so compacting is the norm", () => {
-		// The tenth tab pushed the full bar past 100 columns. That is not a
-		// regression — it is why the compact form has to stay readable, and why
-		// the test below measures it rather than assuming.
+	test("a 100-column window names every tab", () => {
+		// The tenth tab pushed the padded bar past 100 columns. That no longer
+		// costs the names: at 96 usable columns the unpadded bar fits whole.
 		expect(FULL_WIDTH).toBeGreaterThan(100);
-		expect(layoutTabs(TABS, "models", 100)).not.toEqual(FULL);
+		expect(layoutTabs(TABS, "models", 96).texts).toEqual(FULL);
 	});
 
-	test("the compact bar fits an 80-column terminal, on every tab", () => {
-		// The real question a tenth tab raises. ScreenLayout pads the bar by 1
-		// each side inside a container padded by 1, so an 80-column terminal
-		// leaves 76 — and the widest compact bar is well under it.
+	test("the bar fits an 80-column terminal, on every tab", () => {
+		// ScreenLayout pads the bar by 1 each side inside a container padded by
+		// 1, so an 80-column terminal leaves 76.
 		expect(WIDEST_COMPACT).toBeLessThanOrEqual(76);
 		for (const tab of TABS) {
-			expect(barWidth(layoutTabs(TABS, tab.screen, 76))).toBeLessThanOrEqual(
-				76,
-			);
+			expect(painted(layoutTabs(TABS, tab.screen, 76))).toBeLessThanOrEqual(76);
 		}
 	});
 
 	test("keeps the label of whichever tab is active", () => {
 		for (const tab of TABS) {
-			const texts = layoutTabs(TABS, tab.screen, 40);
+			const { texts } = layoutTabs(TABS, tab.screen, 40);
 			expect(texts).toContain(`${tab.key}:${tab.label}`);
-			// Exactly one tab keeps its label.
+			// At 40 columns only the active tab keeps a label.
 			expect(texts.filter((t) => t.includes(":"))).toHaveLength(1);
 		}
 	});
 
 	test("compacting never changes how many tabs are drawn", () => {
-		expect(layoutTabs(TABS, "plugins", 20)).toHaveLength(TABS.length);
-		expect(layoutTabs(TABS, "plugins", 10_000)).toHaveLength(TABS.length);
+		expect(layoutTabs(TABS, "plugins", 20).texts).toHaveLength(TABS.length);
+		expect(layoutTabs(TABS, "plugins", 10_000).texts).toHaveLength(TABS.length);
 	});
 
 	test("barWidth counts padding and separators", () => {
 		// " a " + "│" + " bb " = 3 + 1 + 4
 		expect(barWidth(["a", "bb"])).toBe(8);
+		// "a" + "│" + "bb" = 1 + 1 + 2
+		expect(barWidth(["a", "bb"], false)).toBe(4);
 		expect(barWidth([])).toBe(0);
 	});
 

package/src/__tests__/theme-adaptive-colors.test.ts

@@ -24,8 +24,10 @@ import { CONTRAST_REFERENCE, brand, theme } from "../ui/theme.js";
  *     can clear a text-grade ratio against that terminal's own background).
  *  2. Every accent clears 3:1 against BOTH reference backgrounds.
  *  3. Ink on our own badges clears 4.5:1 against that badge.
- *  4. The three scope colours are far enough apart in hue to read as squares.
- *  5. No component invents a colour outside the palette.
+ *  4. No component invents a colour outside the palette.
+ *
+ * The scope squares no longer own a hue each (see theme.ts): position names the
+ * scope and shape says the state, so there is no scope palette to measure here.
  */
 
 // ─── Contrast maths (WCAG 2.1 relative luminance) ─────────────────────────────
@@ -48,37 +50,6 @@ function contrastRatio(a: string, b: string): number {
 	return (hi + 0.05) / (lo + 0.05);
 }
 
-/**
- * Perceptual distance (CIE76 ΔE) in L*a*b*.
- *
- * Contrast ratio is the wrong tool for "are these two swatches telling apart":
- * it only compares luminance, and the scope colours are deliberately close in
- * luminance — that is precisely what lets each of them clear 3:1 against both a
- * light and a dark background. Measured, they sit at ratios of 1.00-1.03 to each
- * other while being obviously different colours. ΔE sees the hue difference that
- * a luminance ratio is blind to.
- */
-function deltaE(aHex: string, bHex: string): number {
-	const toLab = (hex: string): [number, number, number] => {
-		const n = hex.replace("#", "");
-		const [r, g, b] = [0, 2, 4].map((i) => {
-			const c = Number.parseInt(n.slice(i, i + 2), 16) / 255;
-			return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
-		});
-		// sRGB -> XYZ (D65), then XYZ -> Lab
-		const x = (r * 0.4124 + g * 0.3576 + b * 0.1805) / 0.95047;
-		const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
-		const z = (r * 0.0193 + g * 0.1192 + b * 0.9505) / 1.08883;
-		const f = (t: number) =>
-			t > 0.008856 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
-		const [fx, fy, fz] = [f(x), f(y), f(z)];
-		return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
-	};
-	const [l1, a1, b1] = toLab(aHex);
-	const [l2, a2, b2] = toLab(bHex);
-	return Math.hypot(l1 - l2, a1 - a2, b1 - b2);
-}
-
 /** WCAG threshold for UI components and large text. 4.5 is unreachable against
  *  both a light and a dark background at once — the luminance bands do not overlap. */
 const UI_CONTRAST = 3;
@@ -129,9 +100,9 @@ describe("accents are legible on light AND dark terminals", () => {
 
 	test("badge ink clears 4.5:1 on every badge colour we paint", () => {
 		const failures: string[] = [];
-		for (const [tone, colors] of Object.entries(theme.category)) {
+		for (const [tone, colors] of Object.entries(theme.badge)) {
 			const r = contrastRatio(brand.ink, colors.bg as string);
-			if (r < INK_CONTRAST) failures.push(`category.${tone} ${r.toFixed(2)}`);
+			if (r < INK_CONTRAST) failures.push(`badge.${tone} ${r.toFixed(2)}`);
 		}
 		for (const key of ["defaultBg", "primaryBg", "dangerBg"] as const) {
 			const r = contrastRatio(brand.ink, theme.hints[key]);
@@ -177,30 +148,6 @@ describe("accents are legible on light AND dark terminals", () => {
 			Object.keys(theme.meta).sort(),
 		);
 	});
-
-	test("the three scope colours are perceptually far apart", () => {
-		// They render as single-character squares, where a subtle shift is not
-		// readable at all. Deferring to ANSI put project and local on slots 2 and 3,
-		// which one real theme drew as two near-identical olives — the reason this
-		// rule exists. ΔE > 25 is comfortably past "different colour" (~2.3 is the
-		// just-noticeable difference); the bar is set high because these are tiny.
-		const scopes = Object.entries(theme.scopes) as [string, string][];
-		const tooClose: string[] = [];
-		for (let i = 0; i < scopes.length; i++) {
-			for (let j = i + 1; j < scopes.length; j++) {
-				const d = deltaE(scopes[i][1], scopes[j][1]);
-				if (d < 25)
-					tooClose.push(`${scopes[i][0]}~${scopes[j][0]} ΔE=${d.toFixed(1)}`);
-			}
-		}
-		expect(tooClose).toEqual([]);
-		expect(new Set(scopes.map(([, hex]) => hex)).size).toBe(scopes.length);
-	});
-
-	test("ΔE agrees that identical colours are identical (guards the metric)", () => {
-		expect(deltaE(brand.success, brand.success)).toBeCloseTo(0, 5);
-		expect(deltaE("#000000", "#FFFFFF")).toBeGreaterThan(90);
-	});
 });
 
 describe("the canvas stays the terminal's", () => {

package/src/__tests__/tool-probe.test.ts

@@ -605,7 +605,7 @@ describe("isInside — containment in the package's OWN directory", () => {
 // ── ownership through the probe, with a fake IO ─────────────────────────────
 
 describe("probeTool — ownership decides managed", () => {
-	test("native claude is NOT npm-owned: not-managed, never an upgrade", async () => {
+	test("native claude is its own installer's: managed, `claude update`, never the npm veto", async () => {
 		const io = fakeIO({
 			onPath: { claude: "/Users/j/.local/bin/claude" },
 			real: {
@@ -616,6 +616,10 @@ describe("probeTool — ownership decides managed", () => {
 				"npm root -g": { stdout: "/Users/j/.local/lib/node_modules\n" },
 				"claude --version": { stdout: "2.1.268 (Claude Code)\n" },
 			},
+			fetch: {
+				"https://registry.npmjs.org/-/package/@anthropic-ai%2Fclaude-code/dist-tags":
+					{ ok: true, body: { latest: "2.1.270" } },
+			},
 		});
 		const s = spec({
 			name: "claude",
@@ -623,16 +627,21 @@ describe("probeTool — ownership decides managed", () => {
 			package: "@anthropic-ai/claude-code",
 			check: "claude --version",
 		});
-		// The read-back path's opt-in. Planning never runs a check command —
-		// see "a check command is never run while planning" below.
 		const f = await probeTool(s, io, { allowCheckCommand: true });
 		expect(f).toMatchObject({
 			present: true,
-			managed: false,
+			managed: true,
 			installed: "2.1.268",
+			latest: "2.1.270",
+			upgradeCommand: { cmd: "claude", args: ["update"] },
 		});
-		expect(classifyTool(s, f).reason).toBe("not-managed");
-		expect(io.fetches).toEqual([]);
+		expect(classifyTool(s, f)).toMatchObject({
+			state: "upgrade",
+			reason: "behind",
+			target: "2.1.270",
+		});
+		// The version is the directory entry's name: nothing ran, npm was not asked.
+		expect(io.calls).toEqual([]);
 	});
 
 	test("bun-owned codex: version from its package.json, latest from dist-tags", async () => {
@@ -732,27 +741,41 @@ describe("probeTool — ownership decides managed", () => {
 		expect(classifyTool(s, await probeTool(s, io)).reason).toBe("held-back");
 	});
 
-	test("crush under nvm while PATH's npm writes elsewhere: not-managed", async () => {
+	test("crush under nvm while PATH's npm writes elsewhere: managed through --prefix", async () => {
+		const prefix = "/Users/j/.nvm/versions/node/v24.14.0";
+		const pkgDir = `${prefix}/lib/node_modules/@charmland/crush`;
 		const io = fakeIO({
-			onPath: { crush: "/Users/j/.nvm/versions/node/v24.14.0/bin/crush" },
-			real: {
-				"/Users/j/.nvm/versions/node/v24.14.0/bin/crush":
-					"/Users/j/.nvm/versions/node/v24.14.0/lib/node_modules/@charmland/crush/run-crush.js",
-			},
+			onPath: { crush: `${prefix}/bin/crush` },
+			real: { [`${prefix}/bin/crush`]: `${pkgDir}/run-crush.js` },
+			files: { [`${pkgDir}/package.json`]: '{"version":"0.7.1"}' },
 			exec: {
 				"npm root -g": { stdout: "/Users/j/.local/lib/node_modules\n" },
 				"crush --version": { stdout: "crush version v0.7.1\n" },
 			},
+			fetch: {
+				"https://registry.npmjs.org/-/package/@charmland%2Fcrush/dist-tags": {
+					ok: true,
+					body: { latest: "0.8.0" },
+				},
+			},
 		});
 		const s = spec({ name: "crush", via: "npm", package: "@charmland/crush" });
-		const status = classifyTool(
-			s,
-			await probeTool(s, io, { allowCheckCommand: true }),
-		);
-		expect(status.reason).toBe("not-managed");
-		expect(status.note).toContain(
-			"npm (root /Users/j/.local/lib/node_modules)",
-		);
+		const f = await probeTool(s, io, { allowCheckCommand: true });
+		expect(f).toMatchObject({
+			managed: true,
+			installed: "0.7.1",
+			latest: "0.8.0",
+			upgradeCommand: {
+				cmd: "npm",
+				args: ["install", "-g", "--prefix", prefix, "@charmland/crush@latest"],
+			},
+		});
+		expect(classifyTool(s, f)).toMatchObject({
+			state: "upgrade",
+			target: "0.8.0",
+		});
+		// Version from the package.json, not by running the tool.
+		expect(io.calls).toEqual(["npm root -g"]);
 	});
 
 	test("go: tmux-mcp pinned v2.0.0 reads build info only — no network", async () => {
@@ -843,10 +866,12 @@ describe("probeTool — ownership decides managed", () => {
 		const [f] = await probeTools([hostile], io);
 		expect(io.calls).toEqual(["npm root -g"]);
 		expect(f?.installed).toBeNull();
-		// Cannot tell ⇒ unknown, so it is reported and never applied.
+		// Cannot tell ⇒ unknown, so it is reported and never applied. The file
+		// is outside npm's tree, so the reason is ownership (R9.9), not the
+		// unread version that follows from it.
 		expect(classifyTool(hostile, f!)).toMatchObject({
 			state: "unknown",
-			reason: "version-unreadable",
+			reason: "not-managed",
 		});
 
 		// Even an honest check command stays unrun while planning.

package/src/__tests__/uppercase-keybindings.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, test } from "bun:test";
 import path from "node:path";
 import { parseKeypress } from "@opentui/core";
 import fs from "fs-extra";
+import type { KeyPress } from "../ui/input/key-dispatch.js";
+import { SCREEN_BINDINGS, matchBinding } from "../ui/keymap.js";
 
 /**
  * A shifted key never arrives as an uppercase `name`.
@@ -81,21 +83,32 @@ describe("no binding compares name to an uppercase letter", () => {
 		expect(offenders).toEqual([]);
 	});
 
-	test("an uppercase binding is reachable only via the shift flag", async () => {
+	test("an uppercase binding is reachable only via the shift flag", () => {
 		// The positive half: Shift+U must actually route to update. Asserting only
 		// the absence of `=== "U"` would also pass if someone deleted the binding.
-		const src = await fs.readFile(
-			path.join(UI_DIR, "screens", "PluginsScreen.tsx"),
-			"utf8",
+		// Keys are matched through the keymap now, so the check is on what a
+		// parsed keypress resolves to — and plain `u` must NOT resolve to update,
+		// which is the original bug the other way round.
+		const press = (raw: string): KeyPress => {
+			const k = parseKeypress(raw);
+			return {
+				name: k?.name ?? "",
+				sequence: k?.sequence ?? "",
+				ctrl: k?.ctrl === true,
+				meta: k?.meta === true,
+				shift: k?.shift === true,
+			};
+		};
+		expect(matchBinding(SCREEN_BINDINGS.plugins, press("U"))?.id).toBe(
+			"update",
 		);
-		const update = src.indexOf('event.name === "u" && event.shift');
-		const userScope = src.indexOf(
-			'event.name === "u") handleScopeToggle("user")',
+		expect(matchBinding(SCREEN_BINDINGS.plugins, press("u"))?.id).toBe("scope");
+		// The registry's refresh, the one that silently did nothing.
+		expect(matchBinding(SCREEN_BINDINGS["mcp-registry"], press("R"))?.id).toBe(
+			"reload",
 		);
-		expect(update).toBeGreaterThan(-1);
-		expect(userScope).toBeGreaterThan(-1);
-		// Order matters: the shifted branch has to be tested first, or the plain
-		// "u" branch swallows it again — which is exactly the original bug.
-		expect(update).toBeLessThan(userScope);
+		expect(
+			matchBinding(SCREEN_BINDINGS["mcp-registry"], press("r"))?.id,
+		).toBeUndefined();
 	});
 });

package/src/cli/ansi.ts

@@ -346,12 +346,12 @@ export function truncate(text: string, n: number): string {
 export const ramps = {
 	/**
 	 * Work in progress to done. Purple is magus's brand, green is "settled",
-	 * and the blue midtone is the chosen control point that stops a two-hue
+	 * and the teal midtone is the chosen control point that stops a two-hue
 	 * blend desaturating into grey at the halfway mark.
 	 */
 	progress: [
 		lighten(brand.accent, 0.15),
-		lighten(brand.link, 0.2),
+		lighten(brand.info, 0.2),
 		lighten(brand.success, 0.25),
 	],
 	/**

package/src/cli/bootstrap.ts

@@ -31,12 +31,28 @@ import {
 	needsNothing,
 	parseProfileChoice,
 } from "../services/profile-startup.js";
+import { SettingsParseError } from "../services/settings-file.js";
 import type { ProfileManifest } from "../types/index.js";
 import { dim } from "./ansi.js";
 import { confirm } from "./prompt.js";
 import { selectDialog } from "./tui-prompt.js";
 import { fail as failLine, note as noteLine } from "./update-view.js";
 
+/**
+ * Report a file that exists and cannot be used — it does not parse, or parses
+ * into the wrong shape — and that magus left it alone.
+ *
+ * One wording for every command that meets one — the message names the file
+ * and says what is wrong with it; the note says what the user has to do, since
+ * magus will not do it for them.
+ */
+export function reportUnparseable(error: SettingsParseError): void {
+	console.error(failLine(error.message));
+	console.error(
+		noteLine("Fix the JSON by hand; magus leaves the file as it is."),
+	);
+}
+
 /**
  * Write the adopted manifest, then put the project ON the profile it describes.
  *
@@ -147,13 +163,22 @@ export interface EnsureManifestOptions {
  * Return the project's manifest, creating one by adoption if it has none.
  *
  * Resolves to null when there is no manifest and none was created — the caller
- * should exit non-zero. Anything it prints has already explained why.
+ * should exit non-zero. Anything it prints has already explained why. A
+ * manifest that exists and does not parse is one of those: it is reported, and
+ * never read as "none" — adoption below would write a new one over it.
  */
 export async function ensureManifest(
 	projectPath: string,
 	opts: EnsureManifestOptions = {},
 ): Promise<ProfileManifest | null> {
-	const manifest = await readManifest(projectPath);
+	let manifest: ProfileManifest;
+	try {
+		manifest = await readManifest(projectPath);
+	} catch (error) {
+		if (!(error instanceof SettingsParseError)) throw error;
+		reportUnparseable(error);
+		return null;
+	}
 	if (Object.keys(manifest.profiles).length > 0) return manifest;
 
 	const result = await adoptCurrentProject(projectPath);
@@ -226,6 +251,12 @@ export async function requireActiveProfile(
 	const need = await detectProfileStartupNeed(projectPath);
 	if (needsNothing(need)) return manifest;
 
+	// Nothing to ask: every option would read or write a file that does not parse.
+	if (need.parseError) {
+		reportUnparseable(need.parseError);
+		return null;
+	}
+
 	// The repo declares which profile it wants and there is nothing of the
 	// user's to replace — a fresh clone. Activate it and carry on, even under
 	// `--check` and with no TTY: this is the committed answer being applied, not