claudeup 4.42.1 → 5.0.1

package/src/__tests__/update-plan.test.ts

@@ -0,0 +1,631 @@
+import { describe, expect, test } from "bun:test";
+import type { BinCheckResult } from "../services/doctor-bins.js";
+import type { PluginInfo } from "../services/plugin-manager.js";
+import {
+	type UpdatePlan,
+	planBinUpdates,
+	planHasWork,
+	planIsBehind,
+	planPluginUpdates,
+	planSkillUpdates,
+	scopesNeeding,
+	summarizePlan,
+} from "../services/update-plan.js";
+import type { ResolvedBin } from "../types/index.js";
+
+/** A PluginInfo with only the fields the planner reads. */
+function info(overrides: Partial<PluginInfo> & { id: string }): PluginInfo {
+	return {
+		name: overrides.id.split("@")[0]!,
+		version: null,
+		description: "",
+		marketplace: overrides.id.split("@")[1] ?? "magus",
+		marketplaceDisplay: "",
+		enabled: true,
+		...overrides,
+	} as PluginInfo;
+}
+
+function catalog(...infos: PluginInfo[]): Map<string, PluginInfo> {
+	return new Map(infos.map((i) => [i.id, i]));
+}
+
+function plan(overrides: Partial<UpdatePlan> = {}): UpdatePlan {
+	return {
+		profileId: "test",
+		plugins: [],
+		bins: [],
+		skills: [],
+		binSpecs: new Map(),
+		...overrides,
+	};
+}
+
+describe("planPluginUpdates — the profile declares it, the machine lacks it", () => {
+	test("a plugin absent from every scope is an install", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(info({ id: "dev@magus", version: "4.7.0" })),
+		);
+		expect(item).toMatchObject({
+			action: "install",
+			installed: null,
+			target: "4.7.0",
+			scopes: [],
+		});
+	});
+
+	test("a plugin missing from the catalog entirely is still an install", () => {
+		// The marketplace may not be registered yet — install registers it.
+		const [item] = planPluginUpdates({ "new@magus": "latest" }, catalog());
+		expect(item).toMatchObject({ action: "install", available: null });
+	});
+
+	test("an exact pin that is not installed installs that exact version", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(info({ id: "dev@magus", version: "4.7.0" })),
+		);
+		expect(item.target).toBe("4.6.1");
+	});
+});
+
+describe("planPluginUpdates — advancing a 'latest' pin", () => {
+	test("a newer catalog version is an update, targeting it", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "4.7.0",
+					projectScope: { enabled: true, version: "4.6.1" },
+				}),
+			),
+		);
+		expect(item).toMatchObject({
+			action: "update",
+			installed: "4.6.1",
+			target: "4.7.0",
+			scopes: ["project"],
+		});
+	});
+
+	test("the same version is current, with no scopes to touch", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "4.7.0",
+					projectScope: { enabled: true, version: "4.7.0" },
+				}),
+			),
+		);
+		expect(item).toMatchObject({ action: "current", scopes: [] });
+	});
+
+	test("an older catalog version does not downgrade a 'latest' pin", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "4.5.0",
+					projectScope: { enabled: true, version: "4.7.0" },
+				}),
+			),
+		);
+		expect(item.action).toBe("current");
+	});
+});
+
+describe("planPluginUpdates — a failed check is never 'up to date'", () => {
+	test("updateCheckFailed yields 'unknown', not 'current'", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(
+				info({
+					id: "dev@magus",
+					// The stale local clone reports the same version we have installed:
+					// without the flag this is indistinguishable from a clean check.
+					version: "4.6.1",
+					projectScope: { enabled: true, version: "4.6.1" },
+					updateCheckFailed: true,
+					updateCheckFailure: {
+						marketplace: "magus",
+						kind: "rate-limit",
+						detail: "GitHub rate limit",
+					},
+				}),
+			),
+		);
+		expect(item.action).toBe("unknown");
+		expect(item.note).toBe("GitHub rate limit");
+		expect(item.target).toBeNull();
+	});
+
+	test("an unknown plugin keeps --check failing", () => {
+		const p = plan({
+			plugins: planPluginUpdates(
+				{ "dev@magus": "latest" },
+				catalog(
+					info({
+						id: "dev@magus",
+						version: "4.6.1",
+						projectScope: { enabled: true, version: "4.6.1" },
+						updateCheckFailed: true,
+					}),
+				),
+			),
+		});
+		expect(planHasWork(p)).toBe(true);
+	});
+});
+
+describe("planPluginUpdates — content drift", () => {
+	test("same version, changed files is a repair across every installed scope", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "4.6.1",
+					contentStale: true,
+					userScope: { enabled: true, version: "4.6.1" },
+					projectScope: { enabled: true, version: "4.6.1" },
+				}),
+			),
+		);
+		expect(item.action).toBe("repair");
+		expect(item.scopes).toEqual(["user", "project"]);
+	});
+});
+
+describe("planPluginUpdates — an exact pin plans against what is deliverable", () => {
+	// This is dependency management, not a package manager: `claude plugin
+	// install` takes no version, so the only installable version is whatever the
+	// marketplace publishes now. A pin naming anything else cannot be satisfied,
+	// and planning toward it anyway never converges.
+
+	test("targets the marketplace version, not the unreachable pin", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "9.9.9",
+					projectScope: { enabled: true, version: "4.0.0" },
+				}),
+			),
+		);
+		expect(item).toMatchObject({ action: "update", target: "9.9.9" });
+	});
+
+	test("an unreachable pin is NOTED, never silently abandoned", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "9.9.9",
+					projectScope: { enabled: true, version: "9.9.9" },
+				}),
+			),
+		);
+		expect(item.note).toBe(
+			"manifest pins 4.6.1; the marketplace offers only 9.9.9",
+		);
+	});
+
+	test("already on the only installable version is CURRENT — no churn", () => {
+		// The bug this guards: planning 9.9.9 → 4.6.1 forever. Install returns
+		// 9.9.9, the next run replans the identical move, and --check fails in
+		// between every time.
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "9.9.9",
+					projectScope: { enabled: true, version: "9.9.9" },
+				}),
+			),
+		);
+		expect(item.action).toBe("current");
+		expect(item.scopes).toEqual([]);
+	});
+
+	test("an unsatisfiable pin does not fail --check forever", () => {
+		const p = plan({
+			plugins: planPluginUpdates(
+				{ "dev@magus": "4.6.1" },
+				catalog(
+					info({
+						id: "dev@magus",
+						version: "9.9.9",
+						projectScope: { enabled: true, version: "9.9.9" },
+					}),
+				),
+			),
+		});
+		expect(planIsBehind(p)).toBe(false);
+	});
+
+	test("a pin the marketplace DOES offer is honoured exactly", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "4.6.1",
+					projectScope: { enabled: true, version: "4.0.0" },
+				}),
+			),
+		);
+		expect(item).toMatchObject({ action: "update", target: "4.6.1" });
+		expect(item.note).toBeUndefined();
+	});
+
+	test("falls back to the pin when the catalog offers nothing", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: null,
+					projectScope: { enabled: true, version: "4.0.0" },
+				}),
+			),
+		);
+		expect(item.target).toBe("4.6.1");
+	});
+});
+
+describe("per-scope decisions — a stale scope is never masked", () => {
+	test("project behind while user is current is an UPDATE, not 'current'", async () => {
+		// `installed` is the highest version across scopes. Deciding from it hid
+		// exactly this: project scope — the one that actually loads for the repo —
+		// sits behind while user scope drags the comparison up to "current".
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "4.7.0",
+					userScope: { enabled: true, version: "4.7.0" },
+					projectScope: { enabled: true, version: "4.6.1" },
+				}),
+			),
+		);
+		expect(item.action).toBe("update");
+		expect(item.scopes).toEqual(["project"]);
+	});
+
+	test("the same masking under an EXACT pin is also caught", () => {
+		// The marketplace offers the pinned version here, so the target IS the pin
+		// and only the behind scope should move. (When the marketplace offers
+		// something else, every scope moves to that instead — see the
+		// "deliverable" suite.)
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "4.6.1",
+					userScope: { enabled: true, version: "4.6.1" },
+					projectScope: { enabled: true, version: "4.0.0" },
+				}),
+			),
+		);
+		expect(item.action).toBe("update");
+		expect(item.scopes).toEqual(["project"]);
+	});
+
+	test("an unreachable pin moves EVERY scope to the installable version", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "9.9.9",
+					userScope: { enabled: true, version: "4.6.1" },
+					projectScope: { enabled: true, version: "4.0.0" },
+				}),
+			),
+		);
+		expect(item.target).toBe("9.9.9");
+		expect(item.scopes).toEqual(["user", "project"]);
+	});
+
+	test("all scopes at the target is genuinely current", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "4.7.0",
+					userScope: { enabled: true, version: "4.7.0" },
+					projectScope: { enabled: true, version: "4.7.0" },
+				}),
+			),
+		);
+		expect(item.action).toBe("current");
+	});
+
+	test("an installed plugin no marketplace offers is 'unknown', not 'current'", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: null,
+					projectScope: { enabled: true, version: "4.6.1" },
+				}),
+			),
+		);
+		expect(item.action).toBe("unknown");
+		expect(item.note).toContain("not offered");
+	});
+});
+
+describe("planIsBehind — the --check gate", () => {
+	const skillRef = {
+		name: "release",
+		repo: "MadAppGang/magus",
+		path: "skills/release",
+	};
+
+	test("an already-installed skill does NOT fail the gate", () => {
+		// A skill ref carries no content hash, so it is re-fetched every run.
+		// Counting that as drift made --check exit 1 forever for any profile
+		// declaring a single skill — a gate that can never pass is no gate.
+		const p = plan({
+			skills: planSkillUpdates([skillRef], new Set(["release"])),
+		});
+		expect(planHasWork(p)).toBe(true);
+		expect(planIsBehind(p)).toBe(false);
+	});
+
+	test("a MISSING skill does fail the gate", () => {
+		const p = plan({ skills: planSkillUpdates([skillRef], new Set()) });
+		expect(planIsBehind(p)).toBe(true);
+	});
+
+	test("a present unpinned binary does NOT fail the gate", () => {
+		// There is no version probe for a binary, only present/absent. "Upgrade"
+		// is best-effort advancement, not evidence anything is behind.
+		const p = plan({
+			bins: planBinUpdates(
+				[{ name: "tmux-mcp", via: "bun", sources: [] }],
+				[{ name: "tmux-mcp", present: true, installCommand: "", sources: [] }],
+			),
+		});
+		expect(planHasWork(p)).toBe(true);
+		expect(planIsBehind(p)).toBe(false);
+	});
+
+	test("a MISSING binary does fail the gate", () => {
+		const p = plan({
+			bins: planBinUpdates(
+				[{ name: "tmux-mcp", via: "bun", sources: [] }],
+				[{ name: "tmux-mcp", present: false, installCommand: "", sources: [] }],
+			),
+		});
+		expect(planIsBehind(p)).toBe(true);
+	});
+
+	test("an unverifiable plugin still fails the gate", () => {
+		const p = plan({
+			plugins: planPluginUpdates(
+				{ "dev@magus": "latest" },
+				catalog(
+					info({
+						id: "dev@magus",
+						version: "4.6.1",
+						projectScope: { enabled: true, version: "4.6.1" },
+						updateCheckFailed: true,
+					}),
+				),
+			),
+		});
+		expect(planIsBehind(p)).toBe(true);
+	});
+
+	test("a fully current profile with skills and bins passes the gate", () => {
+		const p = plan({
+			plugins: planPluginUpdates(
+				{ "dev@magus": "latest" },
+				catalog(
+					info({
+						id: "dev@magus",
+						version: "4.7.0",
+						projectScope: { enabled: true, version: "4.7.0" },
+					}),
+				),
+			),
+			bins: planBinUpdates(
+				[{ name: "tmux-mcp", via: "bun", version: "1.0.0", sources: [] }],
+				[{ name: "tmux-mcp", present: true, installCommand: "", sources: [] }],
+			),
+			skills: planSkillUpdates([skillRef], new Set(["release"])),
+		});
+		expect(planIsBehind(p)).toBe(false);
+	});
+});
+
+describe("nothing ever plans a downgrade", () => {
+	// `claude plugin install` installs the newest published version and takes no
+	// version argument, so a downgrade is not a move this tool can perform.
+	// Planning one produces a step that runs, reports success, lands on the same
+	// version as before, and is replanned identically on the next run.
+
+	test("a scope AHEAD of the marketplace is left alone under an exact pin", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "9.9.9",
+					projectScope: { enabled: true, version: "10.0.0" },
+				}),
+			),
+		);
+		expect(item.action).toBe("current");
+		expect(item.scopes).toEqual([]);
+	});
+
+	test("an older pin with no catalog entry does not drag an install backwards", () => {
+		// available === null, so the pin is the only target on offer — and it is
+		// BELOW what is installed. Moving to it is neither possible nor wanted.
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "4.6.1" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: null,
+					projectScope: { enabled: true, version: "5.0.0" },
+				}),
+			),
+		);
+		expect(item.action).toBe("current");
+		expect(item.scopes).toEqual([]);
+	});
+
+	test("only the behind scope moves when one is ahead and one behind", () => {
+		const [item] = planPluginUpdates(
+			{ "dev@magus": "latest" },
+			catalog(
+				info({
+					id: "dev@magus",
+					version: "9.9.9",
+					userScope: { enabled: true, version: "10.0.0" },
+					projectScope: { enabled: true, version: "4.0.0" },
+				}),
+			),
+		);
+		expect(item.scopes).toEqual(["project"]);
+	});
+
+	test("scopesNeeding never returns a scope ahead of the target", () => {
+		const i = info({
+			id: "dev@magus",
+			userScope: { enabled: true, version: "10.0.0" },
+			projectScope: { enabled: true, version: "9.9.9" },
+			localScope: { enabled: true, version: "1.0.0" },
+		});
+		expect(scopesNeeding(i, "9.9.9")).toEqual(["local"]);
+	});
+});
+
+describe("scopesNeeding", () => {
+	test("returns every outdated scope, not just user", () => {
+		// The prerunner's original bug: it fixed 'user' and left the project row
+		// behind, so the same drift reappeared on every run.
+		const i = info({
+			id: "dev@magus",
+			userScope: { enabled: true, version: "4.6.1" },
+			projectScope: { enabled: true, version: "4.6.1" },
+			localScope: { enabled: true, version: "4.7.0" },
+		});
+		expect(scopesNeeding(i, "4.7.0")).toEqual(["user", "project"]);
+	});
+
+	test("a scope already on the target is left alone", () => {
+		const i = info({
+			id: "dev@magus",
+			projectScope: { enabled: true, version: "4.7.0" },
+		});
+		expect(scopesNeeding(i, "4.7.0")).toEqual([]);
+	});
+});
+
+describe("planBinUpdates", () => {
+	const bin = (over: Partial<ResolvedBin>): ResolvedBin => ({
+		name: "tmux-mcp",
+		via: "bun",
+		sources: ["profile:test.cliTools"],
+		...over,
+	});
+	const check = (name: string, present: boolean): BinCheckResult => ({
+		name,
+		present,
+		installCommand: "",
+		sources: [],
+	});
+
+	test("a missing binary is an install", () => {
+		const [item] = planBinUpdates([bin({})], [check("tmux-mcp", false)]);
+		expect(item.action).toBe("install");
+	});
+
+	test("present and unpinned is an upgrade — that is what 'update' means", () => {
+		const [item] = planBinUpdates([bin({})], [check("tmux-mcp", true)]);
+		expect(item.action).toBe("upgrade");
+	});
+
+	test("present and pinned is left alone — there is nothing to advance to", () => {
+		const [item] = planBinUpdates(
+			[bin({ version: "1.2.3" })],
+			[check("tmux-mcp", true)],
+		);
+		expect(item).toMatchObject({ action: "current", version: "1.2.3" });
+	});
+});
+
+describe("planSkillUpdates", () => {
+	const ref = {
+		name: "release",
+		repo: "MadAppGang/magus",
+		path: "skills/release",
+	};
+
+	test("an uninstalled skill is an install", () => {
+		expect(planSkillUpdates([ref], new Set())[0]!.action).toBe("install");
+	});
+
+	test("an installed skill is refreshed, since refs carry no content hash", () => {
+		expect(planSkillUpdates([ref], new Set(["release"]))[0]!.action).toBe(
+			"refresh",
+		);
+	});
+});
+
+describe("planHasWork / summarizePlan", () => {
+	test("an all-current plan has no work", () => {
+		const p = plan({
+			plugins: planPluginUpdates(
+				{ "dev@magus": "latest" },
+				catalog(
+					info({
+						id: "dev@magus",
+						version: "4.7.0",
+						projectScope: { enabled: true, version: "4.7.0" },
+					}),
+				),
+			),
+		});
+		expect(planHasWork(p)).toBe(false);
+		expect(summarizePlan(p).current).toBe(1);
+	});
+
+	test("counts split installs from updates across plugins and bins", () => {
+		const p = plan({
+			plugins: planPluginUpdates(
+				{ "a@magus": "latest", "b@magus": "latest" },
+				catalog(
+					info({ id: "a@magus", version: "1.0.0" }),
+					info({
+						id: "b@magus",
+						version: "2.0.0",
+						projectScope: { enabled: true, version: "1.0.0" },
+					}),
+				),
+			),
+			bins: planBinUpdates(
+				[{ name: "tmux-mcp", via: "bun", sources: [] }],
+				[{ name: "tmux-mcp", present: true, installCommand: "", sources: [] }],
+			),
+		});
+		expect(summarizePlan(p)).toMatchObject({ installed: 1, updated: 2 });
+	});
+});