magus-cli 0.0.0-placeholder → 7.1.0

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

@@ -0,0 +1,101 @@
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import { parseKeypress } from "@opentui/core";
+import fs from "fs-extra";
+
+/**
+ * A shifted key never arrives as an uppercase `name`.
+ *
+ * OpenTUI reports Shift+U as `{name: "u", shift: true, sequence: "U"}`, so
+ * `event.name === "U"` is unreachable. That is not merely dead code: in
+ * PluginsScreen the dead branch sat BELOW `event.name === "u"`, so pressing
+ * Shift+U — advertised in the footer as "update" — fell through to the plain "u"
+ * branch and installed the plugin at user scope instead. Reported from the real
+ * UI: "U instead of update install user scope".
+ *
+ * The same shape was in McpRegistryScreen (`"R"` for refresh), where nothing
+ * shadowed it, so refresh silently did nothing at all.
+ */
+
+const UI_DIR = path.join(import.meta.dir, "..", "ui");
+
+async function uiSourceFiles(dir: string): Promise<string[]> {
+	const out: string[] = [];
+	for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) out.push(...(await uiSourceFiles(full)));
+		else if (/\.tsx?$/.test(entry.name)) out.push(full);
+	}
+	return out;
+}
+
+const isComment = (line: string) => {
+	const t = line.trim();
+	return t.startsWith("//") || t.startsWith("*") || t.startsWith("/*");
+};
+
+describe("shifted keys parse to a lowercase name plus a flag", () => {
+	// Pin the platform behaviour the rule depends on. If OpenTUI ever changed
+	// this, the guard below would be enforcing a rule that no longer holds.
+	test("Shift+letter keeps the unshifted name and sets shift", () => {
+		for (const [raw, name] of [
+			["U", "u"],
+			["A", "a"],
+			["R", "r"],
+		] as const) {
+			const k = parseKeypress(raw);
+			expect({ raw, name: k?.name, shift: k?.shift }).toEqual({
+				raw,
+				name,
+				shift: true,
+			});
+		}
+	});
+
+	test("an unshifted letter reports shift false", () => {
+		const k = parseKeypress("u");
+		expect({ name: k?.name, shift: k?.shift }).toEqual({
+			name: "u",
+			shift: false,
+		});
+	});
+});
+
+describe("no binding compares name to an uppercase letter", () => {
+	test("uppercase name comparisons are absent from the UI", async () => {
+		const files = await uiSourceFiles(UI_DIR);
+		expect(files.length).toBeGreaterThan(10); // guard: the walk found real files
+
+		const offenders: string[] = [];
+		for (const file of files) {
+			const text = await fs.readFile(file, "utf8");
+			text.split("\n").forEach((line, i) => {
+				if (isComment(line)) return;
+				if (/\bname\s*===\s*"[A-Z]"/.test(line)) {
+					offenders.push(
+						`${path.relative(UI_DIR, file)}:${i + 1}  ${line.trim()}`,
+					);
+				}
+			});
+		}
+		expect(offenders).toEqual([]);
+	});
+
+	test("an uppercase binding is reachable only via the shift flag", async () => {
+		// 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",
+		);
+		const update = src.indexOf('event.name === "u" && event.shift');
+		const userScope = src.indexOf(
+			'event.name === "u") handleScopeToggle("user")',
+		);
+		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);
+	});
+});

package/src/__tests__/useGitignoreModal.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "bun:test";
+import { buildGitignoreModal } from "../ui/hooks/useGitignoreModal";
+
+describe("buildGitignoreModal", () => {
+	it("builds a select modal with three options", () => {
+		let dismissed = false;
+		let fixed = false;
+		let opened = false;
+		const modal = buildGitignoreModal({
+			violationCount: 5,
+			safeCount: 3,
+			onFixSafe: () => {
+				fixed = true;
+			},
+			onOpenTab: () => {
+				opened = true;
+			},
+			onDismiss: () => {
+				dismissed = true;
+			},
+		});
+		expect(modal.type).toBe("select");
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.options.length).toBe(3);
+		expect(modal.options[0].value).toBe("fix-safe");
+		expect(modal.options[1].value).toBe("open-tab");
+		expect(modal.options[2].value).toBe("dismiss");
+		expect(modal.options[0].label).toContain("3");
+
+		modal.onSelect("fix-safe");
+		expect(fixed).toBe(true);
+
+		modal.onSelect("open-tab");
+		expect(opened).toBe(true);
+
+		modal.onSelect("dismiss");
+		expect(dismissed).toBe(true);
+	});
+
+	it("shows no missing entries label when safeCount is 0", () => {
+		const modal = buildGitignoreModal({
+			violationCount: 2,
+			safeCount: 0,
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.options[0].label).toContain("no missing .gitignore");
+	});
+
+	it("includes violation count in the message", () => {
+		const modal = buildGitignoreModal({
+			violationCount: 7,
+			safeCount: 2,
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		expect(modal.message).toContain("7");
+	});
+
+	it("calls onCancel as dismiss", () => {
+		let dismissed = false;
+		const modal = buildGitignoreModal({
+			violationCount: 1,
+			safeCount: 0,
+			onFixSafe: () => {},
+			onOpenTab: () => {},
+			onDismiss: () => {
+				dismissed = true;
+			},
+		});
+		if (modal.type !== "select") throw new Error("type guard");
+		modal.onCancel();
+		expect(dismissed).toBe(true);
+	});
+});

package/src/__tests__/version-check-refresh.test.ts

@@ -0,0 +1,45 @@
+/**
+ * Guards the update-check refresh fix. checkForUpdates caches within a session
+ * (so we don't hammer the registry), but `force` bypasses that cache so a
+ * release landing mid-session is actually seen — the 4.25-vs-4.26 banner
+ * staleness. (The fetch itself also sets `cache: "no-store"` so a CDN-stale
+ * response can't mask a fresh release.)
+ */
+import { afterEach, describe, expect, it } from "bun:test";
+import { checkForUpdates } from "../services/version-check.js";
+
+describe("checkForUpdates — session cache vs forced re-check", () => {
+	const realFetch = globalThis.fetch;
+	afterEach(() => {
+		globalThis.fetch = realFetch;
+	});
+
+	it("serves the session cache by default and re-fetches only when forced", async () => {
+		let calls = 0;
+		let latest = "9.9.9";
+		globalThis.fetch = (async () => {
+			calls++;
+			return new Response(JSON.stringify({ version: latest }), {
+				status: 200,
+				headers: { "content-type": "application/json" },
+			});
+		}) as typeof fetch;
+
+		// Force the first call so the test is independent of any cache another
+		// test in the same process may have primed.
+		const first = await checkForUpdates(true);
+		expect(calls).toBe(1);
+		expect(first.latestVersion).toBe("9.9.9");
+
+		// Default call is served from the session cache — no new fetch.
+		const cached = await checkForUpdates();
+		expect(calls).toBe(1);
+		expect(cached.latestVersion).toBe("9.9.9");
+
+		// A release lands; a forced re-check bypasses the cache and sees it.
+		latest = "9.9.10";
+		const forced = await checkForUpdates(true);
+		expect(calls).toBe(2);
+		expect(forced.latestVersion).toBe("9.9.10");
+	});
+});

package/src/__tests__/version-snapshot.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, test } from "bun:test";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	UNKNOWN_VERSION,
+	diffVersions,
+	isKnownVersion,
+	loadSeenVersions,
+	saveSeenVersions,
+} from "../services/version-snapshot.js";
+
+/**
+ * Plugins get updated by things magus does not control — Claude Code's own
+ * `plugin update` writes installed_plugins.json without touching magus's
+ * bookkeeping. Diffing what we last rendered against reality catches every
+ * source; logging only magus's own actions catches none of them.
+ */
+
+describe("isKnownVersion", () => {
+	test('"0.0.0" is not a usable version', () => {
+		// Claude Code records this for a plugin whose version it cannot determine.
+		expect(isKnownVersion(UNKNOWN_VERSION)).toBe(false);
+		expect(isKnownVersion(undefined)).toBe(false);
+		expect(isKnownVersion("")).toBe(false);
+		expect(isKnownVersion("1.0.0")).toBe(true);
+	});
+});
+
+describe("diffVersions — first run", () => {
+	test("no baseline reports nothing at all", () => {
+		// Without this, the first launch would flag every installed plugin as new,
+		// which is both wrong and the fastest way to train someone to ignore badges.
+		expect(
+			diffVersions(null, { "dev@magus": "2.12.1", "a@mp": UNKNOWN_VERSION }),
+		).toEqual([]);
+	});
+
+	test("an empty baseline is NOT the same as no baseline", () => {
+		// A real snapshot that happens to be empty means we have looked before and
+		// saw nothing, so anything present now is genuinely new.
+		const changes = diffVersions({}, { "dev@magus": "2.12.1" });
+		expect(changes).toEqual([
+			{ pluginId: "dev@magus", kind: "installed", to: "2.12.1" },
+		]);
+	});
+});
+
+describe("diffVersions — installs", () => {
+	test("a plugin absent from the baseline is reported as installed, not updated", () => {
+		const changes = diffVersions(
+			{ "other@mp": "1.0.0" },
+			{ "new@mp": "3.1.0" },
+		);
+		expect(changes).toEqual([
+			{ pluginId: "new@mp", kind: "installed", to: "3.1.0" },
+		]);
+	});
+
+	test("an install with an unknown version is still reported", () => {
+		// The version is unusable but the install is real — the UI shows "new"
+		// with no version rather than suppressing the plugin entirely.
+		const changes = diffVersions({}, { "a@mp": UNKNOWN_VERSION });
+		expect(changes).toEqual([
+			{ pluginId: "a@mp", kind: "installed", to: UNKNOWN_VERSION },
+		]);
+	});
+});
+
+describe("diffVersions — updates", () => {
+	test("reports a genuine version transition", () => {
+		expect(
+			diffVersions({ "dev@magus": "2.12.0" }, { "dev@magus": "2.12.1" }),
+		).toEqual([
+			{ pluginId: "dev@magus", kind: "updated", from: "2.12.0", to: "2.12.1" },
+		]);
+	});
+
+	test("unchanged versions report nothing", () => {
+		expect(
+			diffVersions({ "dev@magus": "2.12.1" }, { "dev@magus": "2.12.1" }),
+		).toEqual([]);
+	});
+
+	test("learning a previously unknown version is not an update", () => {
+		// This is exactly what v4.22.0's registry overlay caused: versions that
+		// could not be resolved suddenly could be. Reporting it would announce
+		// magus's own bugfix as if the user's plugins had changed.
+		expect(
+			diffVersions({ "a@mp": UNKNOWN_VERSION }, { "a@mp": "5.3.0" }),
+		).toEqual([]);
+	});
+
+	test("losing a known version is not an update either", () => {
+		expect(
+			diffVersions({ "a@mp": "5.3.0" }, { "a@mp": UNKNOWN_VERSION }),
+		).toEqual([]);
+	});
+
+	test("a downgrade IS reported", () => {
+		// Rolling back is a real change, arguably the most important to surface.
+		expect(diffVersions({ "a@mp": "2.0.0" }, { "a@mp": "1.0.0" })).toEqual([
+			{ pluginId: "a@mp", kind: "updated", from: "2.0.0", to: "1.0.0" },
+		]);
+	});
+});
+
+describe("diffVersions — removals and mixed sets", () => {
+	test("a removed plugin is not reported", () => {
+		expect(diffVersions({ "gone@mp": "1.0.0" }, {})).toEqual([]);
+	});
+
+	test("classifies each plugin independently in one pass", () => {
+		const changes = diffVersions(
+			{ same: "1.0.0", moved: "2.0.0", learned: UNKNOWN_VERSION },
+			{ same: "1.0.0", moved: "2.1.0", learned: "9.0.0", fresh: "0.1.0" },
+		);
+		expect(changes).toEqual([
+			{ pluginId: "moved", kind: "updated", from: "2.0.0", to: "2.1.0" },
+			{ pluginId: "fresh", kind: "installed", to: "0.1.0" },
+		]);
+	});
+});
+
+describe("per-project baselines", () => {
+	/**
+	 * The baseline used to be one flat map for the whole machine, but the
+	 * versions written into it are resolved per project. Two projects
+	 * legitimately on different versions overwrote each other's baseline, so
+	 * every differing plugin was reported as "updated" on the next render — a
+	 * change that never happened.
+	 *
+	 * CLAUDE_CONFIG_DIR, not HOME: os.homedir() reads the passwd database on
+	 * macOS and ignores $HOME, so a HOME-only override writes to the operator's
+	 * real ~/.claude. That is not hypothetical — it happened while writing these.
+	 */
+	const withSandbox = async (fn: () => Promise<void>): Promise<void> => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "vsnap-"));
+		const prev = process.env.CLAUDE_CONFIG_DIR;
+		process.env.CLAUDE_CONFIG_DIR = dir;
+		try {
+			await fn();
+		} finally {
+			// biome-ignore lint/performance/noDelete: assigning undefined to process.env stores the string "undefined"; only delete unsets the variable
+			if (prev === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+			else process.env.CLAUDE_CONFIG_DIR = prev;
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	};
+
+	test("a project with no baseline of its own reports nothing", async () => {
+		await withSandbox(async () => {
+			await saveSeenVersions("/proj/a", { "setup@magus": "2.2.0" });
+			const baseline = await loadSeenVersions("/proj/b");
+			expect(baseline).toBeNull();
+			expect(diffVersions(baseline, { "setup@magus": "2.5.0" })).toEqual([]);
+		});
+	});
+
+	test("saving one project preserves the others", async () => {
+		await withSandbox(async () => {
+			await saveSeenVersions("/proj/a", { "designer@magus": "2.0.0" });
+			await saveSeenVersions("/proj/b", { "designer@magus": "2.0.1" });
+			expect(await loadSeenVersions("/proj/a")).toEqual({
+				"designer@magus": "2.0.0",
+			});
+			expect(await loadSeenVersions("/proj/b")).toEqual({
+				"designer@magus": "2.0.1",
+			});
+		});
+	});
+
+	test("a real update inside one project is still reported", async () => {
+		await withSandbox(async () => {
+			await saveSeenVersions("/proj/a", { "dev@magus": "3.0.0" });
+			const previous = await loadSeenVersions("/proj/a");
+			expect(diffVersions(previous, { "dev@magus": "3.0.1" })).toEqual([
+				{ pluginId: "dev@magus", kind: "updated", from: "3.0.0", to: "3.0.1" },
+			]);
+		});
+	});
+
+	test("a pre-migration flat baseline is adopted once, then replaced", async () => {
+		await withSandbox(async () => {
+			const file = path.join(
+				process.env.CLAUDE_CONFIG_DIR as string,
+				"magus-version-snapshot.json",
+			);
+			await fs.writeFile(
+				file,
+				JSON.stringify({
+					seen: { "dev@magus": "3.0.0" },
+					seededAt: "2026-07-29T00:00:00.000Z",
+					updatedAt: "2026-07-29T00:00:00.000Z",
+				}),
+			);
+
+			// Legacy shape carries no project, so it stands in for whoever asks first
+			// rather than being thrown away.
+			expect(await loadSeenVersions("/proj/a")).toEqual({
+				"dev@magus": "3.0.0",
+			});
+
+			await saveSeenVersions("/proj/a", { "dev@magus": "3.0.1" });
+			// Once per-project entries exist, the flat map is no longer consulted.
+			expect(await loadSeenVersions("/proj/b")).toBeNull();
+			expect(await loadSeenVersions("/proj/a")).toEqual({
+				"dev@magus": "3.0.1",
+			});
+		});
+	});
+});