claudeup 5.0.1 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "5.0.1",
+  "version": "6.0.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "claudeup-darwin-arm64": "5.0.1",
-    "claudeup-darwin-x64": "5.0.1",
-    "claudeup-linux-x64": "5.0.1"
+    "claudeup-darwin-arm64": "6.0.0",
+    "claudeup-darwin-x64": "6.0.0",
+    "claudeup-linux-x64": "6.0.0"
   }
 }

package/src/__tests__/cli-ansi.test.ts

@@ -0,0 +1,297 @@
+/**
+ * Tests for the CLI's colour layer.
+ *
+ * Two things are worth locking here, and neither is "does it look nice":
+ *
+ *  1. **Width arithmetic**, because the live region's cursor-up repaint is built
+ *     on it. A padding or truncation function that counts escape bytes as cells
+ *     makes every animated frame drift down the screen, and the symptom looks
+ *     like a rendering bug rather than an off-by-N in `width`.
+ *  2. **Colour capability**, because getting the precedence wrong ships escape
+ *     sequences into a log file. `NO_COLOR` must win.
+ *
+ * The gradient assertions check that a ramp really is a ramp — the failure mode
+ * the skill warns about is a "gradient" that paints one flat colour, which no
+ * character-level assertion can see.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+	badge,
+	blend1D,
+	blendStops,
+	colorEnabled,
+	darken,
+	elapsed,
+	fg,
+	inkOn,
+	lighten,
+	meter,
+	mix,
+	padEnd,
+	padStart,
+	setColorEnabled,
+	spinner,
+	stackedBar,
+	stripAnsi,
+	truncate,
+	width,
+} from "../cli/ansi.js";
+
+afterEach(() => setColorEnabled(null));
+
+describe("colour capability", () => {
+	const env = { ...process.env };
+	// `delete` is the only way to make an env var absent: assigning undefined
+	// stores the literal string "undefined", and these tests turn on the
+	// difference between unset and set-to-something.
+	const unset = (key: string) => delete process.env[key];
+	afterEach(() => {
+		for (const key of ["NO_COLOR", "FORCE_COLOR", "TERM"] as const) {
+			const original = env[key];
+			if (original === undefined) unset(key);
+			else process.env[key] = original;
+		}
+	});
+
+	test("NO_COLOR beats FORCE_COLOR", () => {
+		// A user who exported NO_COLOR in their shell profile must not get colour
+		// back merely because the CI they are in sets FORCE_COLOR.
+		process.env.NO_COLOR = "1";
+		process.env.FORCE_COLOR = "1";
+		expect(colorEnabled()).toBe(false);
+	});
+
+	test("an empty NO_COLOR is not set, per the spec", () => {
+		process.env.NO_COLOR = "";
+		process.env.FORCE_COLOR = "1";
+		expect(colorEnabled()).toBe(true);
+	});
+
+	test("FORCE_COLOR=0 disables even on a TTY", () => {
+		unset("NO_COLOR");
+		process.env.FORCE_COLOR = "0";
+		expect(colorEnabled()).toBe(false);
+	});
+
+	test("with colour off, every styling call is the identity", () => {
+		setColorEnabled(false);
+		expect(fg("#ff0000", "hi")).toBe("hi");
+		expect(badge("UPDATE", "#ff0000")).toBe(" UPDATE ");
+		expect(stripAnsi(meter(50, 10))).toHaveLength(10);
+	});
+});
+
+describe("colour maths", () => {
+	test("blend1D includes both endpoints", () => {
+		const out = blend1D(5, "#000000", "#ffffff");
+		expect(out).toHaveLength(5);
+		expect(out[0]).toBe("#000000");
+		expect(out[4]).toBe("#ffffff");
+	});
+
+	test("blend1D(1) takes the from end rather than dividing by zero", () => {
+		expect(blend1D(1, "#123456", "#ffffff")).toEqual(["#123456"]);
+	});
+
+	test("degenerate step counts give an empty ramp, never a throw", () => {
+		expect(blend1D(0, "#000", "#fff")).toEqual([]);
+		expect(blend1D(-3, "#000", "#fff")).toEqual([]);
+		expect(blend1D(2.5, "#000", "#fff")).toEqual([]);
+		expect(blendStops(4)).toEqual([]);
+	});
+
+	test("blendStops passes through its midtone stop", () => {
+		// The midtone is the whole reason blendStops exists: a two-stop blend
+		// between distant hues desaturates through the middle, so the control
+		// point has to survive into the output.
+		const out = blendStops(5, "#ff0000", "#00ff00", "#0000ff");
+		expect(out[2]).toBe("#00ff00");
+	});
+
+	test("mix clamps t rather than extrapolating past an endpoint", () => {
+		expect(mix("#000000", "#ffffff", -1)).toBe("#000000");
+		expect(mix("#000000", "#ffffff", 2)).toBe("#ffffff");
+	});
+
+	test("short hex expands, and junk resolves to black instead of NaN", () => {
+		expect(mix("#f00", "#f00", 0)).toBe("#ff0000");
+		expect(mix("not-a-colour", "not-a-colour", 0)).toBe("#000000");
+	});
+
+	test("darken and lighten move toward black and white", () => {
+		expect(darken("#808080", 1)).toBe("#000000");
+		expect(lighten("#808080", 1)).toBe("#ffffff");
+		expect(darken("#808080", 0)).toBe("#808080");
+	});
+
+	test("ink flips to dark on a bright fill", () => {
+		expect(inkOn("#FFE066")).toBe("#101014");
+		expect(inkOn("#15803D")).toBe("#FFFFFF");
+	});
+});
+
+describe("width, padding and truncation", () => {
+	test("escape sequences cost no cells", () => {
+		expect(width(fg("#ff0000", "abc"))).toBe(3);
+	});
+
+	test("padding measures visible cells, not string length", () => {
+		setColorEnabled(true);
+		const painted = fg("#ff0000", "ab");
+		expect(width(padEnd(painted, 6))).toBe(6);
+		expect(width(padStart(painted, 6))).toBe(6);
+		expect(padStart("7", 3)).toBe("  7");
+	});
+
+	test("padding never truncates something already too wide", () => {
+		expect(padEnd("abcdef", 3)).toBe("abcdef");
+	});
+
+	test("truncate clips to visible cells and keeps the colour intact", () => {
+		setColorEnabled(true);
+		const clipped = truncate(fg("#ff0000", "abcdefgh"), 4);
+		expect(width(clipped)).toBe(4);
+		expect(stripAnsi(clipped)).toBe("abcd");
+		// The reset must survive, or the clip bleeds its colour into the next line.
+		expect(clipped).toContain("\x1b[0m");
+	});
+
+	test("truncate is a no-op when it already fits", () => {
+		expect(truncate("abc", 10)).toBe("abc");
+		expect(truncate("abc", 0)).toBe("");
+	});
+
+	test("a double-width glyph costs two cells", () => {
+		expect(width("漢字")).toBe(4);
+		expect(width(truncate("漢字", 3))).toBe(2);
+	});
+
+	test("emoji that render wide are counted wide", () => {
+		// Under-counting is the dangerous direction: a line measured narrower
+		// than it renders reaches the last column, wraps, and the live region's
+		// cursor-up erase — which counted it as one row — smears the block.
+		// These three blocks were all counted as width 1 before.
+		expect(width("🚀")).toBe(2); // U+1F680 transport
+		expect(width("✅")).toBe(2); // U+2705 dingbat
+		expect(width("🇺🇸")).toBe(4); // regional indicator pair
+	});
+
+	test("a zero-width joiner costs nothing", () => {
+		// Without this a three-person family measures as three separate wide
+		// glyphs (6 cells) rather than the one grapheme it renders as.
+		expect(width("‍")).toBe(0);
+		expect(width("👨‍👩‍👧")).toBe(6);
+	});
+
+	test("ambiguous-width glyphs the report actually uses stay narrow", () => {
+		// The arrows and box glyphs in the plan rows are EAW-Ambiguous. Widening
+		// them would misalign the common case, which is the one that matters.
+		for (const ch of ["↑", "→", "█", "░", "·", "✓", "⚠", "◆", "⟳"])
+			expect(width(ch)).toBe(1);
+	});
+});
+
+describe("widgets", () => {
+	test("a meter is exactly `cells` wide at every fill level", () => {
+		for (const pct of [0, 1, 37, 50, 99, 100]) {
+			expect(width(meter(pct, 20))).toBe(20);
+		}
+	});
+
+	test("a meter takes 0..100, and clamps rather than overflowing", () => {
+		expect(stripAnsi(meter(0, 10))).toBe("░".repeat(10));
+		expect(stripAnsi(meter(100, 10))).toBe("█".repeat(10));
+		expect(stripAnsi(meter(-50, 10))).toBe("░".repeat(10));
+		expect(stripAnsi(meter(400, 10))).toBe("█".repeat(10));
+		// The classic mistake: passing a 0..1 ratio. It reads as 1%, i.e. empty —
+		// which is exactly why this asserts the 0..100 contract explicitly.
+		expect(stripAnsi(meter(1, 100))).toBe(`${"█"}${"░".repeat(99)}`);
+	});
+
+	test("NaN does not silently paint a full bar", () => {
+		expect(stripAnsi(meter(Number.NaN, 10))).toBe("░".repeat(10));
+	});
+
+	test("a full meter really is a gradient, not one flat colour", () => {
+		// The failure this catches: a "gradient" that emits the same escape
+		// sequence for every cell. Character assertions cannot see it.
+		setColorEnabled(true);
+		const painted = meter(100, 24);
+		// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC is the thing being matched.
+		const distinct = new Set(painted.match(/\x1b\[38;2;[0-9;]+m/g) ?? []);
+		expect(distinct.size).toBeGreaterThanOrEqual(12);
+	});
+
+	test("a stacked bar is exactly `cells` wide however the counts split", () => {
+		for (const segs of [
+			[{ value: 1, color: "#f00" }],
+			[
+				{ value: 9, color: "#f00" },
+				{ value: 1, color: "#0f0" },
+			],
+			[
+				{ value: 1, color: "#f00" },
+				{ value: 1, color: "#0f0" },
+				{ value: 1, color: "#00f" },
+				{ value: 97, color: "#ff0" },
+			],
+		]) {
+			expect(width(stackedBar(24, segs))).toBe(24);
+		}
+	});
+
+	test("a tiny segment still gets a cell rather than vanishing", () => {
+		setColorEnabled(true);
+		const bar = stackedBar(20, [
+			{ value: 999, color: "#ff0000" },
+			{ value: 1, color: "#00ff00" },
+		]);
+		expect(bar).toContain("38;2;0;255;0m");
+	});
+
+	test("an all-zero distribution renders an empty track, not nothing", () => {
+		expect(width(stackedBar(12, [{ value: 0, color: "#f00" }]))).toBe(12);
+		expect(stackedBar(0, [{ value: 3, color: "#f00" }])).toBe("");
+	});
+
+	test("more segments than cells still yields exactly `cells`", () => {
+		// The width guarantee outranks "every segment gets a cell". The earlier
+		// shrink loop gave up once every segment was down to one and returned a
+		// row WIDER than asked for — 5 cells for cells=3 — silently breaking the
+		// alignment every caller depends on.
+		setColorEnabled(false);
+		const many = Array.from({ length: 5 }, (_, i) => ({
+			value: i + 1,
+			color: "#ff0000",
+		}));
+		expect(width(stackedBar(3, many))).toBe(3);
+		expect(width(stackedBar(1, many))).toBe(1);
+	});
+
+	test("when segments are dropped, the largest survive", () => {
+		setColorEnabled(true);
+		const bar = stackedBar(2, [
+			{ value: 1, color: "#010101" },
+			{ value: 500, color: "#00ff00" },
+			{ value: 400, color: "#0000ff" },
+		]);
+		expect(width(bar)).toBe(2);
+		expect(bar).toContain("38;2;0;255;0m");
+		expect(bar).toContain("38;2;0;0;255m");
+		expect(bar).not.toContain("38;2;1;1;1m");
+	});
+
+	test("the spinner cycles and never indexes out of bounds", () => {
+		expect(spinner(0)).toBe(spinner(10));
+		expect(spinner(-1)).toBeTruthy();
+		expect(width(spinner(7))).toBe(1);
+	});
+
+	test("elapsed picks a unit per magnitude", () => {
+		expect(elapsed(340)).toBe("340ms");
+		expect(elapsed(1400)).toBe("1.4s");
+		expect(elapsed(124_000)).toBe("2m04s");
+		expect(elapsed(-1)).toBe("--");
+	});
+});

package/src/__tests__/cli-apply-seams.test.ts

@@ -0,0 +1,233 @@
+/**
+ * Tests for the three progress seams the animated report depends on.
+ *
+ * All three shipped untested: `ApplyReporter`, `checkBinaries`'s `onProbe`, and
+ * the coupling between the apply meter's denominator and the items the apply
+ * loop actually touches. A review found that last one hand-duplicated
+ * `applyPlugins`'s skip conditions and replicated only one of the two, so a
+ * plan containing an actionable plugin with no scopes would leave the bar stuck
+ * short of full at the end of a successful run. It was unreachable then and
+ * nothing pinned it, which is the definition of a latent bug.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import {
+	type ApplyReporter,
+	type PluginApplyDeps,
+	applyPlugins,
+	parseArgs,
+	pluginNeedsWork,
+} from "../cli/update.js";
+import { checkBinaries } from "../services/doctor-bins.js";
+import type { PluginScope } from "../services/claude-cli.js";
+import type { PluginUpdateItem } from "../services/update-plan.js";
+import type { ResolvedBin } from "../types/index.js";
+
+const PROJECT = "/tmp/project";
+
+function item(over: Partial<PluginUpdateItem> = {}): PluginUpdateItem {
+	return {
+		pluginId: "dev@magus",
+		pinned: "latest",
+		installed: "1.0.0",
+		available: "2.0.0",
+		target: "2.0.0",
+		action: "update",
+		scopes: ["project"],
+		...over,
+	};
+}
+
+function deps(): PluginApplyDeps {
+	return {
+		update: mock(async () => {}),
+		repair: mock(async () => {}),
+		readInstalled: mock(async () => "2.0.0"),
+		saveInstalled: mock(async () => {}),
+	};
+}
+
+/** Records the reporter callbacks in the order they fire. */
+function recorder() {
+	const events: string[] = [];
+	const reporter: ApplyReporter = {
+		begin: (name) => events.push(`begin:${name}`),
+		finish: (ok, name) => events.push(`${ok ? "ok" : "fail"}:${name}`),
+		detach: async (work) => {
+			events.push("detach:start");
+			try {
+				return await work();
+			} finally {
+				events.push("detach:end");
+			}
+		},
+	};
+	return { reporter, events };
+}
+
+describe("ApplyReporter", () => {
+	test("begin fires before the work and finish after it", async () => {
+		const { reporter, events } = recorder();
+		await applyPlugins([item()], PROJECT, deps(), reporter);
+		expect(events).toEqual(["begin:dev@magus", "ok:dev@magus"]);
+	});
+
+	test("a failure is reported through finish, not thrown", async () => {
+		const { reporter, events } = recorder();
+		const d = deps();
+		d.update = mock(async () => {
+			throw new Error("network down");
+		});
+		const result = await applyPlugins([item()], PROJECT, d, reporter);
+		expect(events).toEqual(["begin:dev@magus", "fail:dev@magus"]);
+		expect(result.failed).toEqual(["dev@magus"]);
+	});
+
+	test("a skipped item produces no events at all", async () => {
+		// The meter counts begin/finish pairs. An item that emits `begin` and
+		// never finishes would hang the bar; one that emits neither is correct.
+		const { reporter, events } = recorder();
+		await applyPlugins(
+			[
+				item({ action: "current" }),
+				item({ action: "unknown" }),
+				item({ action: "update", scopes: [] }),
+			],
+			PROJECT,
+			deps(),
+			reporter,
+		);
+		expect(events).toEqual([]);
+	});
+});
+
+describe("the apply meter's denominator", () => {
+	test("pluginNeedsWork agrees with what applyPlugins actually runs", async () => {
+		// The property that matters: for ANY plan, the number of items the
+		// predicate selects equals the number the loop reports. Drift between
+		// them is what leaves the bar short of full.
+		const plan = [
+			item({ pluginId: "a", action: "current" }),
+			item({ pluginId: "b", action: "unknown" }),
+			item({ pluginId: "c", action: "update", scopes: ["project"] }),
+			item({ pluginId: "d", action: "update", scopes: [] }),
+			item({ pluginId: "e", action: "install", scopes: [] }),
+			item({ pluginId: "f", action: "repair", scopes: ["user", "project"] }),
+		];
+
+		const { reporter, events } = recorder();
+		await applyPlugins(plan, PROJECT, deps(), reporter);
+
+		const predicted = plan.filter(pluginNeedsWork).map((p) => p.pluginId);
+		const actual = events
+			.filter((e) => e.startsWith("begin:"))
+			.map((e) => e.slice("begin:".length));
+
+		expect(actual).toEqual(predicted);
+		// And specifically: an install with no scopes IS work (it goes in at
+		// project scope), while an update with no scopes is not.
+		expect(predicted).toEqual(["c", "e", "f"]);
+	});
+
+	test("an item touching two scopes still counts once", async () => {
+		const { reporter, events } = recorder();
+		await applyPlugins(
+			[item({ scopes: ["user", "project"] })],
+			PROJECT,
+			deps(),
+			reporter,
+		);
+		expect(events.filter((e) => e.startsWith("begin:"))).toHaveLength(1);
+	});
+});
+
+describe("flags", () => {
+	test("`--dry-run` and `--check` are distinct modes", () => {
+		// Both print and write nothing, but they answer different questions and
+		// exit differently: --check is the CI gate (exit 1 when behind), while
+		// --dry-run is a preview and always exits 0.
+		expect(parseArgs(["--dry-run"])).toMatchObject({
+			dryRun: true,
+			check: false,
+		});
+		expect(parseArgs(["--check"])).toMatchObject({
+			dryRun: false,
+			check: true,
+		});
+	});
+
+	test("`--yes` and `-y` are accepted and ignored, not treated as a profile", () => {
+		// The confirmation they skipped no longer exists. An old script or a
+		// habit must still run and still do the right thing — and crucially the
+		// flag must not be mistaken for a profile name, which would send the run
+		// at a profile called "-y" and fail.
+		for (const flag of ["--yes", "-y"]) {
+			expect(parseArgs([flag]).profile).toBeUndefined();
+			expect(parseArgs(["lean", flag]).profile).toBe("lean");
+		}
+	});
+
+	test("a profile name is picked out from among flags in any order", () => {
+		expect(parseArgs(["--check", "lean"]).profile).toBe("lean");
+		expect(parseArgs(["lean", "--dry-run"]).profile).toBe("lean");
+		expect(parseArgs([]).profile).toBeUndefined();
+	});
+});
+
+describe("checkBinaries onProbe", () => {
+	const bins: ResolvedBin[] = [
+		{ name: "tmux", via: "brew", sources: [] } as unknown as ResolvedBin,
+		{ name: "tmux-mcp", via: "bun", sources: [] } as unknown as ResolvedBin,
+		{ name: "jq", via: "brew", sources: [] } as unknown as ResolvedBin,
+	];
+
+	test("fires once per binary, before its probe, with a stable total", async () => {
+		// Before the probe matters: the point is to name the binary the command
+		// is currently blocked on, not the one it just finished.
+		const seen: Array<[string, number, number]> = [];
+		const order: string[] = [];
+		await checkBinaries(
+			bins,
+			async (name) => {
+				order.push(`probe:${name}`);
+				return true;
+			},
+			(name, index, total) => {
+				order.push(`announce:${name}`);
+				seen.push([name, index, total]);
+			},
+		);
+
+		expect(seen).toEqual([
+			["tmux", 0, 3],
+			["tmux-mcp", 1, 3],
+			["jq", 2, 3],
+		]);
+		expect(order.slice(0, 2)).toEqual(["announce:tmux", "probe:tmux"]);
+	});
+
+	test("the index is 0-based, so done/total needs index+1", async () => {
+		// A meter fed the raw index reads 0/3 while the first probe runs, which
+		// is correct — it has finished none of them.
+		const first: number[] = [];
+		await checkBinaries(bins, async () => true, (_n, index) =>
+			first.push(index),
+		);
+		expect(first[0]).toBe(0);
+		expect(first.at(-1)).toBe(bins.length - 1);
+	});
+
+	test("no callback means no behaviour change", async () => {
+		const results = await checkBinaries(bins, async () => false);
+		expect(results.map((r) => r.present)).toEqual([false, false, false]);
+	});
+
+	test("an empty bin list announces nothing", async () => {
+		const seen: string[] = [];
+		const results = await checkBinaries([], async () => true, (n) =>
+			seen.push(n),
+		);
+		expect(results).toEqual([]);
+		expect(seen).toEqual([]);
+	});
+});