magus-cli 0.0.0-placeholder → 7.0.0

package/src/__tests__/component-badge.test.ts

@@ -0,0 +1,98 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import {
+	COMPONENT_BADGE,
+	CONTRAST_REFERENCE_KEYS,
+	componentBadge,
+	resetThemeMode,
+	setThemeMode,
+} from "../ui/theme-mode.js";
+
+afterEach(() => {
+	resetThemeMode();
+});
+
+/** WCAG relative luminance of a #rrggbb string. */
+function luminance(hex: string): number {
+	const channel = (v: number) => {
+		const c = v / 255;
+		return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+	};
+	const n = Number.parseInt(hex.slice(1), 16);
+	return (
+		0.2126 * channel((n >> 16) & 0xff) +
+		0.7152 * channel((n >> 8) & 0xff) +
+		0.0722 * channel(n & 0xff)
+	);
+}
+
+function contrast(a: string, b: string): number {
+	const [hi, lo] = [luminance(a), luminance(b)].sort((x, y) => y - x);
+	return (hi + 0.05) / (lo + 0.05);
+}
+
+const KINDS = ["skill", "command", "agent", "mcp"] as const;
+
+describe("componentBadge", () => {
+	it("serves the dark pair before any resolution", () => {
+		// There is no unknown: dark is the stated default, so a chip is always a
+		// pair, never null, and the caller has no bare-glyph branch to keep.
+		for (const kind of KINDS) {
+			expect(componentBadge(kind)).toEqual(COMPONENT_BADGE[kind].dark);
+		}
+	});
+
+	it("serves the light pair on a light terminal", () => {
+		setThemeMode("light");
+
+		expect(componentBadge("skill")).toEqual(COMPONENT_BADGE.skill.light);
+		expect(componentBadge("mcp")).toEqual(COMPONENT_BADGE.mcp.light);
+	});
+
+	it("serves the dark pair on a dark terminal", () => {
+		setThemeMode("dark");
+
+		expect(componentBadge("skill")).toEqual(COMPONENT_BADGE.skill.dark);
+		expect(componentBadge("mcp")).toEqual(COMPONENT_BADGE.mcp.dark);
+	});
+
+	it("keeps every glyph legible on its own chip", () => {
+		// 3:1 is the floor the rest of the palette is measured to. A chip whose
+		// glyph disappears into its wash is worse than no chip at all.
+		for (const kind of KINDS) {
+			for (const mode of ["light", "dark"] as const) {
+				const { bg, fg } = COMPONENT_BADGE[kind][mode];
+				expect(contrast(bg, fg)).toBeGreaterThanOrEqual(3);
+			}
+		}
+	});
+
+	it("keeps every chip quiet against the page it is drawn on", () => {
+		// The wash must read as a tint of the page, not as a block on it. Above
+		// ~1.6 it stops being a chip and starts being a highlight bar.
+		for (const kind of KINDS) {
+			for (const mode of ["light", "dark"] as const) {
+				const { bg } = COMPONENT_BADGE[kind][mode];
+				const page = CONTRAST_REFERENCE_KEYS[mode];
+				expect(contrast(bg, page)).toBeLessThan(1.6);
+			}
+		}
+	});
+
+	it("mirrors the reference pages theme.ts measures accents against", async () => {
+		// The duplicate exists so this module stays free of the renderer import.
+		// If theme.ts ever restates its backgrounds, the chips must move with it.
+		const { CONTRAST_REFERENCE } = await import("../ui/theme.js");
+
+		expect(CONTRAST_REFERENCE_KEYS.light).toBe(CONTRAST_REFERENCE.light);
+		expect(CONTRAST_REFERENCE_KEYS.dark).toBe(CONTRAST_REFERENCE.dark);
+	});
+
+	it("gives each kind a distinguishable hue", () => {
+		// Single-character colour carries no readable hue *shift*, only a readable
+		// hue *difference* — the same reason the scope squares are far apart.
+		for (const mode of ["light", "dark"] as const) {
+			const fills = KINDS.map((k) => COMPONENT_BADGE[k][mode].bg);
+			expect(new Set(fills).size).toBe(KINDS.length);
+		}
+	});
+});

package/src/__tests__/component-icons.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from "bun:test";
+import { COMPONENT_ICON } from "../ui/renderers/pluginRenderers.js";
+
+/**
+ * Every component badge is exactly one terminal cell wide.
+ *
+ * This is the constraint that rules out the icons the ecosystem actually uses:
+ * Cursor's skill badge defaults to a lightning bolt and the community VS Code
+ * Skills sidebar uses a sparkle, but `⚡` (U+26A1) and `✨` (U+2728) are both
+ * East-Asian-Width Wide — two cells — and a two-cell badge shifts every name on
+ * the row out of alignment with the plugin names above it.
+ *
+ * Unicode has no `east_asian_width` in the JS standard library, so the wide
+ * ranges are spelled out. They cover the emoji and CJK blocks a plausible icon
+ * would come from; anything outside them is single-width in practice.
+ */
+const WIDE_RANGES: ReadonlyArray<readonly [number, number]> = [
+	[0x1100, 0x115f], // Hangul Jamo
+	[0x2329, 0x232a], // angle brackets
+	[0x2e80, 0x303e], // CJK radicals, Kangxi
+	[0x3041, 0x33ff], // Hiragana through CJK compatibility
+	[0x3400, 0x4dbf], // CJK Extension A
+	[0x4e00, 0x9fff], // CJK Unified Ideographs
+	[0xa000, 0xa4cf], // Yi
+	[0xac00, 0xd7a3], // Hangul syllables
+	[0xf900, 0xfaff], // CJK compatibility ideographs
+	[0xfe30, 0xfe6f], // CJK compatibility forms
+	[0xff00, 0xff60], // fullwidth forms
+	[0xffe0, 0xffe6], // fullwidth signs
+	[0x1f300, 0x1f64f], // misc symbols and pictographs, emoticons
+	[0x1f900, 0x1f9ff], // supplemental symbols and pictographs
+	[0x20000, 0x3fffd], // CJK Extension B and beyond
+	// Individually Wide despite sitting among narrow neighbours. These are the
+	// ones that actually bite: ⚡ and ✨ are exactly the icons a future editor
+	// would reach for.
+	[0x231a, 0x231b], // watch, hourglass
+	[0x23e9, 0x23ec],
+	[0x25fd, 0x25fe],
+	[0x2614, 0x2615],
+	[0x26a1, 0x26a1], // ⚡ HIGH VOLTAGE SIGN
+	[0x2728, 0x2728], // ✨ SPARKLES
+	[0x274c, 0x274c],
+	[0x2b1b, 0x2b1c],
+	[0x2b50, 0x2b50],
+];
+
+function isWide(ch: string): boolean {
+	const cp = ch.codePointAt(0) ?? 0;
+	return WIDE_RANGES.some(([lo, hi]) => cp >= lo && cp <= hi);
+}
+
+describe("component icons", () => {
+	it("covers every component kind", () => {
+		expect(Object.keys(COMPONENT_ICON).sort()).toEqual([
+			"agent",
+			"command",
+			"mcp",
+			"skill",
+		]);
+	});
+
+	it("uses exactly one code point per icon", () => {
+		for (const [kind, icon] of Object.entries(COMPONENT_ICON)) {
+			expect([...icon], `${kind} must be a single code point`).toHaveLength(1);
+		}
+	});
+
+	it("never uses a double-width glyph", () => {
+		for (const [kind, icon] of Object.entries(COMPONENT_ICON)) {
+			expect(isWide(icon), `${kind} icon ${icon} is double-width`).toBe(false);
+		}
+	});
+
+	it("rejects the two emoji a future editor would reach for", () => {
+		// Negative control: the guard above only means something if it fires.
+		expect(isWide("⚡")).toBe(true);
+		expect(isWide("✨")).toBe(true);
+		expect(isWide("📁")).toBe(true);
+	});
+
+	it("gives each kind a distinct glyph", () => {
+		const icons = Object.values(COMPONENT_ICON);
+		expect(new Set(icons).size).toBe(icons.length);
+	});
+
+	it("does not reuse a glyph this screen already means something by", () => {
+		// ★ is "★ Official" on a marketplace row, ● is "● Installed", ■ is a scope
+		// segment, and ▼ / ▶ are the expand arrows. Reusing one would make a badge
+		// read as a status.
+		for (const taken of ["★", "●", "■", "▼", "▶", "○", "✓", "⚠"]) {
+			expect(Object.values(COMPONENT_ICON)).not.toContain(taken);
+		}
+	});
+});

package/src/__tests__/content-drift.test.ts

@@ -0,0 +1,353 @@
+/**
+ * Content drift: a plugin whose files changed without its version changing.
+ *
+ * Hermetic — builds a real git marketplace under a temp CLAUDE_CONFIG_DIR.
+ * Real git is used deliberately: the detection IS a git question, and mocking
+ * it would only test the mock.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+	clearContentDriftCache,
+	hasContentDrift,
+	repoHeadSha,
+} from "../services/content-drift.js";
+import {
+	type PluginInfo,
+	contentDriftCandidate,
+} from "../services/plugin-manager.js";
+
+let configDir: string;
+let prevConfigDir: string | undefined;
+let repo: string;
+
+// commit.gpgsign=false isolates the developer's git config. With signing on
+// (1Password's SSH signer, for instance) every commit here calls that signer,
+// and because this helper ignores the exit status a failure is silent: no
+// commit is created, so drift is never detected and the assertions fail with a
+// bare `false` that points nowhere near the real cause. CI has no signing
+// config, so this only ever broke locally.
+const git = (args: string[]) =>
+	spawnSync("git", ["-c", "commit.gpgsign=false", ...args], {
+		cwd: repo,
+		encoding: "utf-8",
+	});
+
+const head = () => git(["rev-parse", "HEAD"]).stdout.trim();
+
+/** Rewrite a plugin's manifest version, mimicking a release. */
+const setVersion = (plugin: string, version: string) =>
+	fs.writeFile(
+		path.join(repo, "plugins", plugin, "plugin.json"),
+		JSON.stringify({ name: plugin, version }, null, 2),
+	);
+
+beforeEach(async () => {
+	prevConfigDir = process.env.CLAUDE_CONFIG_DIR;
+	configDir = await fs.mkdtemp(path.join(os.tmpdir(), "drift-"));
+	process.env.CLAUDE_CONFIG_DIR = configDir;
+	clearContentDriftCache();
+
+	repo = path.join(configDir, "plugins", "marketplaces", "probemp");
+	await fs.mkdir(path.join(repo, "plugins", "alpha", "skills"), {
+		recursive: true,
+	});
+	await fs.mkdir(path.join(repo, "plugins", "beta"), { recursive: true });
+	await fs.writeFile(
+		path.join(repo, "plugins", "alpha", "skills", "s.md"),
+		"v1",
+	);
+	await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v1");
+	await setVersion("alpha", "1.0.0");
+	await setVersion("beta", "1.0.0");
+
+	git(["init", "-q", "-b", "main"]);
+	git(["config", "user.email", "probe@example.invalid"]);
+	git(["config", "user.name", "probe"]);
+	git(["add", "-A"]);
+	git(["commit", "-q", "-m", "release 1.0.0"]);
+});
+
+afterEach(async () => {
+	// biome-ignore lint/performance/noDelete: assigning undefined to process.env stores the string "undefined"; only delete unsets the variable
+	if (prevConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+	else process.env.CLAUDE_CONFIG_DIR = prevConfigDir;
+	await fs.rm(configDir, { recursive: true, force: true });
+});
+
+describe("hasContentDrift", () => {
+	test("no drift when the plugin's files are untouched", async () => {
+		const sha = head();
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: sha,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(false);
+	});
+
+	test("drift when the plugin's files change under an unchanged version", async () => {
+		const sha = head();
+		// Republish: same version, different content — what publish-dist.sh does.
+		await fs.writeFile(
+			path.join(repo, "plugins", "alpha", "skills", "s.md"),
+			"v2 — different content, same version",
+		);
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "republish 1.0.0"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: sha,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(true);
+	});
+
+	test("a change to ANOTHER plugin does not flag this one", async () => {
+		// The reason this compares the plugin subtree and not the marketplace
+		// HEAD: any commit to any plugin would otherwise flag every plugin.
+		const sha = head();
+		await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v2");
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "unrelated change"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: sha,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(false);
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "beta",
+				installedSha: sha,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(true);
+	});
+
+	test("deleting a skill counts as drift", async () => {
+		// The live case: dev@magus 3.0.1 lost tui-progress/SKILL.md while still
+		// declaring 3.0.1, so the version compare reported "up to date".
+		const sha = head();
+		await fs.rm(path.join(repo, "plugins", "alpha", "skills", "s.md"));
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "drop a skill"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: sha,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(true);
+	});
+
+	test("stays silent when it cannot answer honestly", async () => {
+		// No recorded sha, unknown sha (force-push/shallow clone), and unknown
+		// marketplace must all report false rather than nag for a reinstall.
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: undefined,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(false);
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: "0".repeat(40),
+				installedVersion: "1.0.0",
+			}),
+		).toBe(false);
+		expect(
+			await hasContentDrift({
+				marketplace: "does-not-exist",
+				pluginName: "alpha",
+				installedSha: head(),
+				installedVersion: "1.0.0",
+			}),
+		).toBe(false);
+	});
+
+	// REGRESSION: every installed plugin rendered "stale — reinstall" because
+	// updateInstalledPluginsRegistry bumped `version` while carrying the
+	// pre-update `gitCommitSha` forward. The sha then named a commit several
+	// releases old, so the subtree diff was non-empty for essentially every
+	// plugin. Fixed in /dev:fix session dev-fix-20260822-125510-03db093b.
+	test("a sha recorded against a DIFFERENT version cannot answer the question", async () => {
+		const oldSha = head();
+
+		// Ship 2.0.0 — the plugin genuinely changed, as a release does.
+		await fs.writeFile(
+			path.join(repo, "plugins", "alpha", "skills", "s.md"),
+			"v2 content",
+		);
+		await setVersion("alpha", "2.0.0");
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "release 2.0.0"]);
+
+		// 2.0.0 is installed, but the registry still carries the 1.0.0 sha.
+		// The subtree diff between them is non-empty, and says nothing about
+		// whether the installed 2.0.0 files match the marketplace's 2.0.0.
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: oldSha,
+				installedVersion: "2.0.0",
+			}),
+		).toBe(false);
+	});
+
+	test("a manifest that cannot be read at that sha reports no drift", async () => {
+		// Provenance unverifiable — the module's policy is silence, not a nag.
+		await fs.rm(path.join(repo, "plugins", "beta", "plugin.json"));
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "beta loses its manifest"]);
+		const sha = head();
+
+		await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v2");
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "beta content changes"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "beta",
+				installedSha: sha,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(false);
+	});
+
+	test("reads a manifest at .claude-plugin/plugin.json too", async () => {
+		// magus lays plugins out as plugins/<name>/plugin.json, but Claude Code's
+		// documented location is .claude-plugin/plugin.json. Both must resolve or
+		// the guard silences drift detection for half the ecosystem.
+		await fs.mkdir(path.join(repo, "plugins", "beta", ".claude-plugin"), {
+			recursive: true,
+		});
+		await fs.rm(path.join(repo, "plugins", "beta", "plugin.json"));
+		await fs.writeFile(
+			path.join(repo, "plugins", "beta", ".claude-plugin", "plugin.json"),
+			JSON.stringify({ name: "beta", version: "1.0.0" }),
+		);
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "beta uses .claude-plugin"]);
+		const sha = head();
+
+		await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v2");
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "republish 1.0.0"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "beta",
+				installedSha: sha,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(true);
+	});
+});
+
+describe("repoHeadSha", () => {
+	// The other half of the same bug: nothing in magus ever recorded a fresh
+	// sha, so the registry could only ever go stale. This is what
+	// updateInstalledPluginsRegistry now calls to stamp real provenance onto the
+	// files it just copied out of the marketplace clone.
+	test("resolves HEAD from a path inside the repo", async () => {
+		const sha = head();
+		expect(await repoHeadSha(path.join(repo, "plugins", "alpha"))).toBe(sha);
+		expect(await repoHeadSha(repo)).toBe(sha);
+	});
+
+	test("returns undefined for a directory that is not in a git repo", async () => {
+		// Directory-type marketplaces have no commit to name. Recording a sha
+		// from some unrelated clone would assert a provenance that is false.
+		const plain = await fs.mkdtemp(path.join(os.tmpdir(), "nogit-"));
+		try {
+			expect(await repoHeadSha(plain)).toBeUndefined();
+		} finally {
+			await fs.rm(plain, { recursive: true, force: true });
+		}
+	});
+
+	test("returns undefined for a path that does not exist", async () => {
+		expect(
+			await repoHeadSha(path.join(configDir, "no", "such", "dir")),
+		).toBeUndefined();
+	});
+});
+
+describe("contentDriftCandidate — which plugins are even asked", () => {
+	const info = (over: Partial<PluginInfo> = {}): PluginInfo => ({
+		id: "dev@magus",
+		name: "dev",
+		version: "3.0.0",
+		description: "",
+		marketplace: "magus",
+		marketplaceDisplay: "magus",
+		enabled: true,
+		installedVersion: "3.0.0",
+		...over,
+	});
+
+	test("same version, provably: asked", () => {
+		expect(contentDriftCandidate(info())).toBe(true);
+		// The comparator, not string equality: "3.0" IS 3.0.0.
+		expect(contentDriftCandidate(info({ installedVersion: "3.0" }))).toBe(true);
+	});
+
+	test("the pre-classifier `hasUpdate` no longer decides", () => {
+		// It was the gate's first clause. It could only ever be true for a pair
+		// the version compare already rejects, and reading it here made the
+		// input the shared classifier consumes depend on the rule it replaced.
+		// A stale flag must not suppress the question.
+		expect(contentDriftCandidate(info({ hasUpdate: true }))).toBe(true);
+	});
+
+	test("behind the catalog: NOT asked — that is an update, not drift", () => {
+		// hasContentDrift diffs the installed commit against the clone HEAD, so
+		// a plugin that is merely behind always "differs". Calling that drift
+		// would make it a repair, and a repair reinstalls whatever the clone
+		// holds — past a pin.
+		expect(contentDriftCandidate(info({ installedVersion: "2.9.0" }))).toBe(
+			false,
+		);
+		expect(
+			contentDriftCandidate(
+				info({ hasUpdate: false, installedVersion: "2.9.0" }),
+			),
+		).toBe(false);
+	});
+
+	test("unorderable, not installed, no catalog version, orphaned: not asked", () => {
+		expect(
+			contentDriftCandidate(
+				info({ version: "517b2fcd1b60", installedVersion: "b819188d2eea" }),
+			),
+		).toBe(false);
+		expect(contentDriftCandidate(info({ installedVersion: undefined }))).toBe(
+			false,
+		);
+		expect(contentDriftCandidate(info({ version: null }))).toBe(false);
+		expect(contentDriftCandidate(info({ isOrphaned: true }))).toBe(false);
+	});
+});