magus-cli 7.6.0 → 7.8.0

package/src/__tests__/blind-780-plugin-resolution.test.ts

@@ -0,0 +1,431 @@
+/**
+ * magus 7.8.0 QA spec, section R — which installed copy Claude Code loads.
+ *
+ * Written blind: from the spec and the exported signatures of
+ * services/plugin-resolution.ts only. No function body was read.
+ *
+ * Coverage map (requirement → describe block):
+ *   R1 user / managed rows always relevant          → "R1"
+ *   R2 project row at exactly cwd is relevant       → "R2"
+ *   R3 project row with no projectPath never counts → "R3"
+ *   R4 same-repository rows count, others do not    → "R4"
+ *   R5 cwd in no repository: other folders never    → "R5"
+ *   R6 pickLoadedEntry selection rules              → "R6"
+ *   R7 end to end, outside git                      → "R7"
+ *
+ * Real git repositories in the OS temp dir, because "same repository" is a
+ * question git answers — a hand-written `.git` would confirm whatever parse it
+ * was written from.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import {
+	isRelevantInstallation,
+	pickLoadedEntry,
+	repoRootForPath,
+} from "../services/plugin-resolution.js";
+import type { InstalledPluginEntry } from "../types/index.js";
+
+const GIT_CFG = [
+	"-c",
+	"user.name=blind",
+	"-c",
+	"user.email=blind@example.com",
+	"-c",
+	"commit.gpgsign=false",
+	"-c",
+	"init.defaultBranch=main",
+];
+
+const git = (cwd: string, ...args: string[]) =>
+	execFileSync("git", [...GIT_CFG, ...args], { cwd, encoding: "utf8" }).trim();
+
+let base: string;
+/** Repository under test. */
+let repo: string;
+/** A folder inside it. */
+let repoSub: string;
+/** A live linked worktree of `repo`. */
+let sibling: string;
+/** A linked worktree of `repo`, OUTSIDE its tree, created and then deleted. */
+let deletedWorktree: string;
+/** A linked worktree of `repo`, INSIDE its tree (Claude Code's own layout), deleted. */
+let deletedNested: string;
+/** A different repository. */
+let otherRepo: string;
+/** Folders in no repository. */
+let plainA: string;
+let plainB: string;
+/** A path in no repository that does not exist. */
+let plainMissing: string;
+/** Install directories that exist on disk. */
+let cacheDir: Record<string, string>;
+/** An install directory that does not exist. */
+let missingCache: string;
+
+function row(
+	over: Partial<InstalledPluginEntry> & { version: string },
+): InstalledPluginEntry {
+	return {
+		scope: "project",
+		installPath: cacheDir?.[over.version] ?? `/nonexistent/${over.version}`,
+		installedAt: "2026-01-01T00:00:00.000Z",
+		lastUpdated: "2026-01-01T00:00:00.000Z",
+		...over,
+	};
+}
+
+function relevant(entry: InstalledPluginEntry, cwd: string): boolean {
+	return isRelevantInstallation(entry, cwd, repoRootForPath(cwd));
+}
+
+beforeAll(async () => {
+	base = await fs.realpath(
+		await fs.mkdtemp(path.join(os.tmpdir(), "blind-780-resolution-")),
+	);
+	repo = path.join(base, "repo");
+	repoSub = path.join(repo, "packages", "tool");
+	sibling = path.join(base, "repo-sibling");
+	deletedWorktree = path.join(base, "repo-gone");
+	deletedNested = path.join(repo, ".claude", "worktrees", "gone-nested");
+	otherRepo = path.join(base, "other");
+	plainA = path.join(base, "plain-a");
+	plainB = path.join(base, "plain-b");
+	plainMissing = path.join(base, "plain-missing");
+	missingCache = path.join(base, "cache", "does-not-exist");
+
+	await fs.ensureDir(repoSub);
+	await fs.writeFile(path.join(repoSub, "x.txt"), "x\n");
+	git(repo, "init", "-q");
+	git(repo, "add", "-A");
+	git(repo, "commit", "-qm", "init");
+	git(repo, "worktree", "add", "-q", "-b", "sib", sibling);
+	git(repo, "worktree", "add", "-q", "-b", "gone", deletedWorktree);
+	await fs.remove(deletedWorktree);
+	git(repo, "worktree", "add", "-q", "-b", "gone-nested", deletedNested);
+	await fs.remove(deletedNested);
+
+	await fs.ensureDir(otherRepo);
+	await fs.writeFile(path.join(otherRepo, "y.txt"), "y\n");
+	git(otherRepo, "init", "-q");
+	git(otherRepo, "add", "-A");
+	git(otherRepo, "commit", "-qm", "init");
+
+	await fs.ensureDir(plainA);
+	await fs.ensureDir(plainB);
+
+	cacheDir = {};
+	for (const v of ["0.0.0", "1.0.0", "2.0.0", "3.0.0"]) {
+		const dir = path.join(base, "cache", v);
+		await fs.ensureDir(dir);
+		cacheDir[v] = dir;
+	}
+});
+
+afterAll(async () => {
+	await fs.remove(base);
+});
+
+describe("preconditions of the temp layout", () => {
+	test("the plain folders are in no git repository, the repo folders are", () => {
+		expect(repoRootForPath(plainA)).toBeNull();
+		expect(repoRootForPath(plainB)).toBeNull();
+		expect(repoRootForPath(plainMissing)).toBeNull();
+		expect(repoRootForPath(repo)).not.toBeNull();
+		expect(repoRootForPath(otherRepo)).not.toBeNull();
+		expect(fs.existsSync(deletedWorktree)).toBe(false);
+		expect(fs.existsSync(deletedNested)).toBe(false);
+	});
+});
+
+describe("R1 machine-wide rows", () => {
+	test("R1 a USER row with no projectPath is relevant inside a repository", () => {
+		expect(relevant(row({ scope: "user", version: "1.0.0" }), repo)).toBe(true);
+	});
+
+	test("R1 a USER row is relevant in a folder outside git", () => {
+		expect(relevant(row({ scope: "user", version: "1.0.0" }), plainA)).toBe(
+			true,
+		);
+	});
+
+	test("R1 a USER row carrying another folder's projectPath is still relevant", () => {
+		const entry = row({ scope: "user", version: "1.0.0", projectPath: plainB });
+
+		expect(relevant(entry, plainA)).toBe(true);
+		expect(relevant(entry, repo)).toBe(true);
+	});
+
+	test("R1 a managed row is relevant inside and outside a repository", () => {
+		const managed = {
+			...row({ version: "1.0.0" }),
+			scope: "managed",
+		} as unknown as InstalledPluginEntry;
+
+		expect(relevant(managed, repo)).toBe(true);
+		expect(relevant(managed, plainA)).toBe(true);
+	});
+});
+
+describe("R2 the project row for exactly this folder", () => {
+	test("R2 relevant when cwd is a repository root", () => {
+		expect(relevant(row({ version: "1.0.0", projectPath: repo }), repo)).toBe(
+			true,
+		);
+	});
+
+	test("R2 relevant when cwd is a folder outside git", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: plainA }), plainA),
+		).toBe(true);
+	});
+
+	test("R2 relevant when cwd is a folder outside git that does not exist", () => {
+		expect(
+			relevant(
+				row({ version: "1.0.0", projectPath: plainMissing }),
+				plainMissing,
+			),
+		).toBe(true);
+	});
+});
+
+describe("R3 a project row with no projectPath", () => {
+	test("R3 is not relevant inside a repository", () => {
+		expect(relevant(row({ version: "1.0.0" }), repo)).toBe(false);
+	});
+
+	test("R3 is not relevant outside git", () => {
+		expect(relevant(row({ version: "1.0.0" }), plainA)).toBe(false);
+	});
+});
+
+describe("R4 cwd inside a git repository", () => {
+	test("R4 a row from a subfolder of the same repository is relevant", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: repoSub }), repo),
+		).toBe(true);
+	});
+
+	test("R4 a row from the repository root is relevant in a subfolder", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: repo }), repoSub),
+		).toBe(true);
+	});
+
+	test("R4 a row from a sibling worktree is relevant", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: sibling }), repo),
+		).toBe(true);
+	});
+
+	test("R4 a row from the main tree is relevant when cwd is the sibling worktree", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: repo }), sibling),
+		).toBe(true);
+	});
+
+	test("R4 a row from a deleted worktree nested in the repository is relevant", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: deletedNested }), repo),
+		).toBe(true);
+	});
+
+	// Spec correction after the blind run: Claude Code's root lookup is a path
+	// walk to the nearest `.git` (2.1.284 `Zt`), so a deleted worktree that sat
+	// OUTSIDE the repository's folder has no ancestor carrying one and resolves to
+	// no repository. The loader does not count it, and neither may magus.
+	test("R4 a row from a deleted worktree outside the repository's tree is NOT relevant", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: deletedWorktree }), repo),
+		).toBe(false);
+	});
+
+	test("R4 a row from another repository is not relevant", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: otherRepo }), repo),
+		).toBe(false);
+	});
+
+	test("R4 a row from a folder outside git is not relevant", () => {
+		expect(relevant(row({ version: "1.0.0", projectPath: plainA }), repo)).toBe(
+			false,
+		);
+	});
+
+	test("R4 a local-scope row from a sibling worktree is relevant", () => {
+		expect(
+			relevant(
+				row({ scope: "local", version: "1.0.0", projectPath: sibling }),
+				repo,
+			),
+		).toBe(true);
+	});
+});
+
+describe("R5 cwd in no git repository", () => {
+	test("R5 a row from another existing folder outside git is not relevant", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: plainB }), plainA),
+		).toBe(false);
+	});
+
+	test("R5 a row from a missing folder outside git is not relevant", () => {
+		expect(
+			relevant(row({ version: "1.0.0", projectPath: plainMissing }), plainA),
+		).toBe(false);
+	});
+
+	test("R5 a row from a folder inside a repository is not relevant", () => {
+		expect(relevant(row({ version: "1.0.0", projectPath: repo }), plainA)).toBe(
+			false,
+		);
+	});
+
+	test("R5 a local-scope row from another folder outside git is not relevant", () => {
+		expect(
+			relevant(
+				row({ scope: "local", version: "1.0.0", projectPath: plainB }),
+				plainA,
+			),
+		).toBe(false);
+	});
+
+	test("R5 holds when a cache is passed and reused across calls", () => {
+		const cache = new Map<string, string | null>();
+		const root = repoRootForPath(plainA, cache);
+
+		const results = [plainB, plainMissing, repo].map((p) =>
+			isRelevantInstallation(
+				row({ version: "1.0.0", projectPath: p }),
+				plainA,
+				root,
+				cache,
+			),
+		);
+
+		expect(results).toEqual([false, false, false]);
+	});
+});
+
+describe("R6 pickLoadedEntry", () => {
+	test("R6 returns undefined for undefined or empty input", () => {
+		expect(pickLoadedEntry(undefined, repo)).toBeUndefined();
+		expect(pickLoadedEntry([], repo)).toBeUndefined();
+	});
+
+	test("R6 returns undefined when no entry is relevant", () => {
+		const entries = [
+			row({ version: "1.0.0", projectPath: otherRepo }),
+			row({ version: "2.0.0", projectPath: plainA }),
+			row({ version: "3.0.0" }),
+		];
+
+		expect(pickLoadedEntry(entries, repo)).toBeUndefined();
+	});
+
+	test("R6 exactly one relevant entry wins even though its installPath is missing", () => {
+		const only = row({
+			version: "9.9.9",
+			projectPath: repo,
+			installPath: missingCache,
+		});
+		const entries = [
+			row({ version: "1.0.0", projectPath: otherRepo }),
+			only,
+			row({ version: "2.0.0", projectPath: plainA }),
+		];
+
+		expect(pickLoadedEntry(entries, repo)).toBe(only);
+	});
+
+	test("R6 several relevant: the first in array order whose installPath exists", () => {
+		const entries = [
+			row({ version: "0.0.0", projectPath: otherRepo }),
+			row({
+				version: "9.9.9",
+				projectPath: sibling,
+				installPath: missingCache,
+			}),
+			row({ version: "1.0.0", projectPath: deletedNested }),
+			row({ version: "3.0.0", projectPath: repo }),
+		];
+
+		expect(pickLoadedEntry(entries, repo)?.version).toBe("1.0.0");
+	});
+
+	test("R6 array order beats version order and scope", () => {
+		const entries = [
+			row({ version: "1.0.0", projectPath: sibling }),
+			row({ scope: "user", version: "3.0.0" }),
+			row({ version: "2.0.0", projectPath: repo }),
+		];
+
+		expect(pickLoadedEntry(entries, repo)?.version).toBe("1.0.0");
+	});
+
+	test("R6 none exists: the first relevant entry that has an installPath", () => {
+		const entries = [
+			row({ version: "0.0.0", projectPath: otherRepo }),
+			row({ version: "5.0.0", projectPath: sibling, installPath: "" }),
+			row({
+				version: "6.0.0",
+				projectPath: repo,
+				installPath: path.join(missingCache, "a"),
+			}),
+			row({
+				version: "7.0.0",
+				projectPath: repoSub,
+				installPath: path.join(missingCache, "b"),
+			}),
+		];
+
+		expect(pickLoadedEntry(entries, repo)?.version).toBe("6.0.0");
+	});
+});
+
+describe("R7 end to end, cwd outside git", () => {
+	test("R7 own project row first: v2 loads, never the earlier foreign v0", () => {
+		const entries = [
+			row({ version: "0.0.0", projectPath: plainB }),
+			row({ version: "2.0.0", projectPath: plainA }),
+			row({ scope: "user", version: "1.0.0" }),
+		];
+
+		expect(pickLoadedEntry(entries, plainA)?.version).toBe("2.0.0");
+	});
+
+	test("R7 USER row first: v1 loads, never the earlier foreign v0", () => {
+		const entries = [
+			row({ version: "0.0.0", projectPath: plainB }),
+			row({ scope: "user", version: "1.0.0" }),
+			row({ version: "2.0.0", projectPath: plainA }),
+		];
+
+		expect(pickLoadedEntry(entries, plainA)?.version).toBe("1.0.0");
+	});
+
+	test("R7 the first relevant row missing on disk: the next existing one loads", () => {
+		const entries = [
+			row({ version: "0.0.0", projectPath: plainB }),
+			row({ scope: "user", version: "1.0.0", installPath: missingCache }),
+			row({ version: "2.0.0", projectPath: plainA }),
+		];
+
+		expect(pickLoadedEntry(entries, plainA)?.version).toBe("2.0.0");
+	});
+
+	test("R7 a foreign row from a missing outside-git folder is ignored too", () => {
+		const entries = [
+			row({ version: "0.0.0", projectPath: plainMissing }),
+			row({ scope: "user", version: "1.0.0" }),
+			row({ version: "2.0.0", projectPath: plainA }),
+		];
+
+		expect(pickLoadedEntry(entries, plainA)?.version).toBe("1.0.0");
+	});
+});