magus-cli 7.4.1 → 7.5.1

package/src/__tests__/profile-command.test.ts

@@ -3,8 +3,14 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
-import { listProfiles, showProfile, switchProfile } from "../cli/profile.js";
-import { activeProfile } from "../services/symlink-manager.js";
+import {
+	listProfiles,
+	runProfileCommand,
+	showProfile,
+	switchProfile,
+} from "../cli/profile.js";
+import { readManifest } from "../services/manifest.js";
+import { activeProfile, writeActiveMarker } from "../services/profile-live.js";
 import type { ProfileManifest } from "../types/index.js";
 
 let logs: string[];
@@ -18,19 +24,10 @@ beforeEach(() => {
 });
 afterEach(() => mock.restore());
 
-async function setupProject(
-	manifest: ProfileManifest,
-	materialize: string[] = [],
-): Promise<string> {
+async function setupProject(manifest: ProfileManifest): Promise<string> {
 	const dir = await mkdtemp(join(tmpdir(), "profcmd-"));
 	await fs.ensureDir(join(dir, ".claude"));
 	await fs.writeJson(join(dir, ".claude", "profiles.json"), manifest);
-	for (const name of materialize) {
-		const pd = join(dir, ".claude", "_profiles", name);
-		await fs.ensureDir(pd);
-		await fs.writeJson(join(pd, "settings.json"), { which: name });
-		await fs.writeJson(join(pd, "mcp.json"), { mcpServers: {} });
-	}
 	return dir;
 }
 
@@ -38,7 +35,7 @@ const twoProfiles: ProfileManifest = {
 	version: 2,
 	profiles: {
 		frontend: { name: "Frontend", plugins: { "dev@magus": "latest" } },
-		backend: { name: "Backend", plugins: { "dev@magus": "2.9.0" } },
+		backend: { name: "Backend", plugins: { "terminal@magus": "2.9.0" } },
 	},
 };
 
@@ -48,18 +45,41 @@ describe("profile list", () => {
 		if (dir) await rm(dir, { recursive: true, force: true });
 	});
 
-	test("lists profiles, marks (not installed) and the active one", async () => {
-		dir = await setupProject(twoProfiles, ["frontend"]);
-		await switchProfile("frontend", dir); // activate
+	test("lists profiles and marks the active one", async () => {
+		dir = await setupProject(twoProfiles);
+		await switchProfile("frontend", dir);
 		logs = [];
-		const code = await listProfiles(dir);
-		expect(code).toBe(0);
+		expect(await listProfiles(dir)).toBe(0);
 		const out = logs.join("\n");
-		expect(out).toContain("frontend");
+		expect(out).toContain("● frontend");
 		expect(out).toContain("Backend");
-		expect(out).toContain("(not installed)"); // backend isn't materialized
 		expect(out).toContain("Active: frontend");
 	});
+
+	test("a recorded profile the manifest no longer defines is named, with the fix", async () => {
+		dir = await setupProject(twoProfiles);
+		await writeActiveMarker(
+			{ version: 1, profile: "gone", files: {}, skills: {} },
+			dir,
+		);
+		expect(await listProfiles(dir)).toBe(0);
+		// No default and two profiles: `<name>`, with the choices spelled out.
+		expect(logs.join("\n")).toContain(
+			'recorded as "gone", which is not defined above. Run: `magus profile switch <name>` (profiles: frontend, backend)',
+		);
+	});
+
+	test("the fix names the declared default, never a real name in angle brackets", async () => {
+		dir = await setupProject({ ...twoProfiles, default: "backend" });
+		await writeActiveMarker(
+			{ version: 1, profile: "gone", files: {}, skills: {} },
+			dir,
+		);
+		expect(await listProfiles(dir)).toBe(0);
+		const out = logs.join("\n");
+		expect(out).toContain("Run: `magus profile switch backend`");
+		expect(out).not.toContain("<backend>");
+	});
 });
 
 describe("profile show", () => {
@@ -70,9 +90,8 @@ describe("profile show", () => {
 
 	test("prints a resolved closure summary", async () => {
 		dir = await setupProject(twoProfiles);
-		const code = await showProfile("backend", dir);
-		expect(code).toBe(0);
-		expect(logs.join("\n")).toContain("dev@magus@2.9.0");
+		expect(await showProfile("backend", dir)).toBe(0);
+		expect(logs.join("\n")).toContain("terminal@magus@2.9.0");
 	});
 
 	test("unknown profile → exit 1", async () => {
@@ -87,20 +106,51 @@ describe("profile switch", () => {
 		if (dir) await rm(dir, { recursive: true, force: true });
 	});
 
-	test("switches when materialized and records the active profile", async () => {
-		dir = await setupProject(twoProfiles, ["frontend", "backend"]);
+	test("switches and records the active profile", async () => {
+		dir = await setupProject(twoProfiles);
 		expect(await switchProfile("backend", dir)).toBe(0);
 		expect(await activeProfile(dir)).toBe("backend");
-		// gitignore got the _profiles entry
-		expect(await fs.readFile(join(dir, ".gitignore"), "utf8")).toContain(
-			".claude/_profiles/",
+		const gitignore = await fs.readFile(join(dir, ".gitignore"), "utf8");
+		expect(gitignore).toContain(".claude/profiles/");
+		expect(gitignore).not.toContain(".claude/_profiles/");
+	});
+
+	test("Claude Code's edits go into the profile being left; nothing is backed up", async () => {
+		dir = await setupProject(twoProfiles);
+		expect(await switchProfile("frontend", dir)).toBe(0);
+		const live = join(dir, ".claude", "settings.json");
+		const settings = await fs.readJson(live);
+		settings.enabledPlugins["code-search@magus"] = true;
+		await fs.writeFile(live, JSON.stringify(settings));
+
+		logs = [];
+		expect(await switchProfile("backend", dir)).toBe(0);
+
+		expect(logs.join("\n")).toContain(
+			'Added code-search@magus to profile "frontend"',
+		);
+		const manifest = await readManifest(dir);
+		expect(manifest.profiles.frontend?.plugins?.["code-search@magus"]).toBe(
+			"latest",
+		);
+		expect((await fs.readJson(live)).enabledPlugins["terminal@magus"]).toBe(
+			true,
+		);
+		expect(logs.some((l) => l.includes("kept at"))).toBe(false);
+		expect(await fs.pathExists(join(dir, ".claude", ".magus-backups"))).toBe(
+			false,
 		);
 	});
 
-	test("refuses to switch to a profile that isn't installed", async () => {
-		dir = await setupProject(twoProfiles, ["frontend"]);
-		expect(await switchProfile("backend", dir)).toBe(1);
-		expect(errs.join("\n")).toContain("magus install backend");
+	test("switching back and forth backs nothing up", async () => {
+		dir = await setupProject(twoProfiles);
+		await switchProfile("frontend", dir);
+		await switchProfile("backend", dir);
+		await switchProfile("frontend", dir);
+		expect(logs.some((l) => l.includes("kept at"))).toBe(false);
+		expect(await fs.pathExists(join(dir, ".claude", ".magus-backups"))).toBe(
+			false,
+		);
 	});
 
 	test("unknown profile → exit 1", async () => {
@@ -108,3 +158,11 @@ describe("profile switch", () => {
 		expect(await switchProfile("ghost", dir)).toBe(1);
 	});
 });
+
+describe("profile sync is gone", () => {
+	test("is an unknown subcommand", async () => {
+		expect(await runProfileCommand(["sync"])).toBe(1);
+		expect(errs.join("\n")).toContain('Unknown profile command "sync"');
+		expect(errs.join("\n")).not.toContain("| sync");
+	});
+});

package/src/__tests__/profile-dependencies.test.ts

@@ -0,0 +1,442 @@
+/**
+ * B6 — a profile enables what its plugins depend on.
+ *
+ * Claude Code will not load a plugin whose dependency is disabled. Every
+ * profile renders the plugins it does not want as `false` so switching is
+ * exclusive — and on magus-src that switched `claudish@magus` off under the
+ * `lean` profile, whose dev@magus depends on it: the loader logged
+ * `Dependency "claudish@magus" is disabled` and dev never loaded.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fs from "fs-extra";
+import { reportProfileState } from "../cli/doctor.js";
+import { readManifest, writeManifest } from "../services/manifest.js";
+import {
+	type PluginDependencyReader,
+	setPluginDependencyReader,
+} from "../services/plugin-dependencies.js";
+import {
+	type PluginManifestSources,
+	parsePluginDependencies,
+	readPluginManifest,
+	resolvePluginDependencies,
+} from "../services/plugin-requires.js";
+import { reconcileActiveProfile } from "../services/profile-absorb.js";
+import {
+	activateProfile,
+	activationNotes,
+} from "../services/profile-activate.js";
+import { renderProfile } from "../services/profile-render.js";
+import { resolveAllProfiles, resolveProfile } from "../services/resolver.js";
+import type { ProfileManifest } from "../types/index.js";
+import { NO_DEPENDENCIES } from "./support/preload.js";
+
+/** What dev@magus and multimodel@magus declare in the real marketplace. */
+const DECLARED: Record<string, string[] | null> = {
+	"dev@magus": ["claudish@magus", "mnemex@magus", "multimodel@magus"],
+	"multimodel@magus": ["claudish@magus"],
+};
+
+/** magus-src's shape: `lean` has dev without two of its dependencies. */
+function leanShaped(): ProfileManifest {
+	return {
+		version: 2,
+		profiles: {
+			maintainer: {
+				name: "Maintainer",
+				plugins: {
+					"dev@magus": "latest",
+					"claudish@magus": "latest",
+					"multimodel@magus": "latest",
+					"mnemex@magus": "latest",
+					"terminal@magus": "latest",
+				},
+			},
+			lean: {
+				name: "Lean",
+				plugins: { "dev@magus": "latest", "mnemex@magus": "latest" },
+			},
+		},
+	};
+}
+
+function reader(
+	declared: Record<string, string[] | null>,
+): PluginDependencyReader {
+	return async (id) => (id in declared ? (declared[id] ?? null) : []);
+}
+
+let project: string;
+let log: ReturnType<typeof spyOn>;
+const settingsPath = () => join(project, ".claude", "settings.json");
+const manifestPath = () => join(project, ".claude", "profiles.json");
+const enabled = async () =>
+	(await fs.readJson(settingsPath())).enabledPlugins as Record<string, boolean>;
+const printed = () => log.mock.calls.map((c) => String(c[0])).join("\n");
+
+beforeEach(async () => {
+	project = await mkdtemp(join(tmpdir(), "deps-"));
+	log = spyOn(console, "log").mockImplementation(() => {});
+	setPluginDependencyReader(reader(DECLARED));
+});
+afterEach(async () => {
+	setPluginDependencyReader(NO_DEPENDENCIES);
+	log.mockRestore();
+	await rm(project, { recursive: true, force: true });
+});
+
+async function start(manifest: ProfileManifest, profile: string) {
+	await writeManifest(manifest, project);
+	return activateProfile(manifest, profile, project, { onDisplace: () => {} });
+}
+
+describe("the render enables what the profile's plugins depend on", () => {
+	test("B6: lean enables claudish and multimodel for dev@magus, though maintainer lists them", async () => {
+		await start(leanShaped(), "lean");
+
+		expect(await enabled()).toEqual({
+			"dev@magus": true,
+			"mnemex@magus": true,
+			"claudish@magus": true,
+			"multimodel@magus": true,
+			"terminal@magus": false,
+		});
+	});
+
+	test("B6: dependencies are followed transitively, each in its dependent's marketplace", async () => {
+		// Real plugin.json files, read by the real parser.
+		const plugins = join(project, "plugins");
+		const write = (name: string, dependencies: unknown[]) =>
+			fs.outputJson(join(plugins, name, ".claude-plugin", "plugin.json"), {
+				name,
+				dependencies,
+			});
+		await write("app", [{ name: "lib", version: "^1.0" }]);
+		await write("lib", ["core"]);
+		await write("core", [{ name: "shared", marketplace: "other" }]);
+		setPluginDependencyReader(async (id) => {
+			const manifest = await readPluginManifest(
+				join(plugins, id.slice(0, id.lastIndexOf("@"))),
+			);
+			return manifest === null ? [] : parsePluginDependencies(manifest, id);
+		});
+		const manifest: ProfileManifest = {
+			version: 2,
+			profiles: { only: { name: "Only", plugins: { "app@mkt": "latest" } } },
+		};
+
+		const closure = await resolveProfile(manifest, "only");
+		expect(closure.plugins).toEqual({
+			"app@mkt": "latest",
+			"lib@mkt": "latest",
+			"core@mkt": "latest",
+			"shared@other": "latest",
+		});
+		expect(closure.dependencies?.derived).toEqual([
+			"core@mkt",
+			"lib@mkt",
+			"shared@other",
+		]);
+		await start(manifest, "only");
+		expect(await enabled()).toEqual({
+			"app@mkt": true,
+			"lib@mkt": true,
+			"core@mkt": true,
+			"shared@other": true,
+		});
+	});
+
+	test("B6: a dependency the profile itself turns off stays off, and the note names both plugins", async () => {
+		const manifest = leanShaped();
+		(manifest.profiles.lean?.plugins as Record<string, string | boolean>)[
+			"claudish@magus"
+		] = false;
+
+		const result = await start(manifest, "lean");
+
+		expect((await enabled())["claudish@magus"]).toBe(false);
+		expect((await enabled())["multimodel@magus"]).toBe(true);
+		const notes = activationNotes(result);
+		expect(notes).toContain(
+			'dev@magus will not load: it depends on claudish@magus, which profile "lean" turns off — remove "claudish@magus": false from the profile to let it load',
+		);
+		expect(notes).toContain(
+			'multimodel@magus will not load: it depends on claudish@magus, which profile "lean" turns off — remove "claudish@magus": false from the profile to let it load',
+		);
+		// doctor counts it: the plugin will not load.
+		const { unfixable } = await reportProfileState(project, false);
+		expect(unfixable).toBe(2);
+		expect(printed()).toContain("✗ dev@magus will not load");
+	});
+
+	test("B6: a plugin.json that cannot be read is reported, not guessed, and activation proceeds", async () => {
+		setPluginDependencyReader(reader({ ...DECLARED, "dev@magus": null }));
+
+		const result = await start(leanShaped(), "lean");
+
+		expect((await enabled())["dev@magus"]).toBe(true);
+		expect((await enabled())["claudish@magus"]).toBe(false);
+		expect(activationNotes(result)).toContain(
+			"Could not read the plugin.json of dev@magus on this machine, so nothing it depends on was enabled — run `magus install` to fetch it",
+		);
+		// doctor reports it, and does not count it as a failure.
+		const { unfixable } = await reportProfileState(project, false);
+		expect(unfixable).toBe(0);
+		expect(printed()).toContain(
+			"⚠ Could not read the plugin.json of dev@magus",
+		);
+	});
+
+	test("B6: `magus install` and `magus update` resolve the dependencies as part of the closure", async () => {
+		const lean = await resolveProfile(leanShaped(), "lean");
+		expect(lean.plugins).toEqual({
+			"dev@magus": "latest",
+			"mnemex@magus": "latest",
+			"claudish@magus": "latest",
+			"multimodel@magus": "latest",
+		});
+		const all = await resolveAllProfiles({
+			version: 2,
+			profiles: { lean: leanShaped().profiles.lean as never },
+		});
+		expect(Object.keys(all.plugins).sort()).toEqual([
+			"claudish@magus",
+			"dev@magus",
+			"mnemex@magus",
+			"multimodel@magus",
+		]);
+	});
+});
+
+describe("dependencies are derived, never recorded", () => {
+	test("B6: an edit elsewhere in settings.json records the edit and no dependency", async () => {
+		await start(leanShaped(), "lean");
+		const committed = await fs.readFile(manifestPath(), "utf8");
+		const live = await fs.readJson(settingsPath());
+		live.permissions = { allow: ["Bash(ls)"] };
+		await fs.writeJson(settingsPath(), live);
+
+		const result = await reconcileActiveProfile(project);
+
+		expect(result.lines).toEqual(['Updated settings of profile "lean"']);
+		const lean = (await readManifest(project)).profiles.lean;
+		expect(lean?.plugins).toEqual({
+			"dev@magus": "latest",
+			"mnemex@magus": "latest",
+		});
+		expect(lean?.settings).toEqual({ permissions: { allow: ["Bash(ls)"] } });
+		// The only change to the file is lean's new settings.
+		const after = await fs.readFile(manifestPath(), "utf8");
+		expect(after.split("claudish").length).toBe(
+			committed.split("claudish").length,
+		);
+		expect(after.split("multimodel").length).toBe(
+			committed.split("multimodel").length,
+		);
+	});
+
+	test("review LOW 1: Claude Code disabling a dependency another profile uses is the user's `false`, and it stays", async () => {
+		await start(leanShaped(), "lean");
+		expect((await enabled())["claudish@magus"]).toBe(true);
+		// Claude Code turns claudish off; maintainer uses claudish too.
+		const live = await fs.readJson(settingsPath());
+		live.enabledPlugins["claudish@magus"] = false;
+		await fs.writeJson(settingsPath(), live);
+
+		const result = await reconcileActiveProfile(project);
+
+		expect(result.lines).toContain('Disabled claudish@magus in profile "lean"');
+		expect((await readManifest(project)).profiles.lean?.plugins).toEqual({
+			"dev@magus": "latest",
+			"mnemex@magus": "latest",
+			"claudish@magus": false,
+		});
+		expect((await enabled())["claudish@magus"]).toBe(false);
+		// What will not load is reported from here on.
+		const { dependencies } = await renderProfile(
+			await readManifest(project),
+			"lean",
+		);
+		expect(dependencies?.blocked).toContainEqual({
+			plugin: "dev@magus",
+			dependency: "claudish@magus",
+		});
+		// A later regeneration (a teammate's change to maintainer) keeps it off.
+		const pulled = await readManifest(project);
+		(pulled.profiles.maintainer?.plugins as Record<string, string>)[
+			"designer@magus"
+		] = "latest";
+		await writeManifest(pulled, project);
+		const next = await reconcileActiveProfile(project);
+		expect(next.lines.join("\n")).toContain("regenerated");
+		expect((await enabled())["claudish@magus"]).toBe(false);
+		expect(
+			(await readManifest(project)).profiles.lean?.plugins?.["claudish@magus"],
+		).toBe(false);
+	});
+
+	test("B6: the `false` an older render wrote for a dependency is not taken as a disable", async () => {
+		// What 7.5.0 left: lean rendered with claudish and multimodel `false`,
+		// then an unrelated edit, so the file is absorbed.
+		setPluginDependencyReader(NO_DEPENDENCIES);
+		await start(leanShaped(), "lean");
+		expect((await enabled())["claudish@magus"]).toBe(false);
+		const live = await fs.readJson(settingsPath());
+		live.permissions = { allow: ["Bash(ls)"] };
+		await fs.writeJson(settingsPath(), live);
+		setPluginDependencyReader(reader(DECLARED));
+
+		const result = await reconcileActiveProfile(project);
+
+		expect(result.lines).toContain('Updated settings of profile "lean"');
+		expect((await readManifest(project)).profiles.lean?.plugins).toEqual({
+			"dev@magus": "latest",
+			"mnemex@magus": "latest",
+		});
+		expect((await enabled())["claudish@magus"]).toBe(true);
+		expect((await enabled())["multimodel@magus"]).toBe(true);
+	});
+
+	test("B6: a plugin.json that starts declaring a dependency regenerates the live config", async () => {
+		setPluginDependencyReader(NO_DEPENDENCIES);
+		await start(leanShaped(), "lean");
+		const before = (await renderProfile(leanShaped(), "lean")).definition;
+		setPluginDependencyReader(reader(DECLARED));
+		expect((await renderProfile(leanShaped(), "lean")).definition).not.toBe(
+			before,
+		);
+
+		const result = await reconcileActiveProfile(project);
+
+		expect(result.lines.join("\n")).toContain("regenerated");
+		expect((await enabled())["claudish@magus"]).toBe(true);
+		expect((await readManifest(project)).profiles.lean?.plugins).toEqual({
+			"dev@magus": "latest",
+			"mnemex@magus": "latest",
+		});
+	});
+});
+
+describe("reading dependencies from plugin.json", () => {
+	test("every form Claude Code accepts, resolved in the dependent's marketplace", () => {
+		expect(
+			parsePluginDependencies(
+				{
+					dependencies: [
+						{ name: "claudish", version: "^2.0" },
+						"mnemex",
+						"other@elsewhere",
+						{ name: "x", marketplace: "mp" },
+						{ version: "^1.0" },
+						42,
+					],
+				},
+				"dev@magus",
+			),
+		).toEqual(["claudish@magus", "mnemex@magus", "other@elsewhere", "x@mp"]);
+		expect(parsePluginDependencies({ name: "none" }, "dev@magus")).toEqual([]);
+	});
+
+	test("a plugin.json that does not parse reads as unreadable, not as no dependencies", async () => {
+		const dir = join(project, "broken");
+		await fs.outputFile(join(dir, ".claude-plugin", "plugin.json"), "{ nope");
+		await fs.outputJson(join(dir, "plugin.json"), { dependencies: ["x"] });
+		expect(await readPluginManifest(dir)).toBeNull();
+		expect(await readPluginManifest(join(project, "absent"))).toBeNull();
+	});
+});
+
+describe("the real reader: the installed copy Claude Code loads decides", () => {
+	/**
+	 * Fixture machine state, all under the test's temp dir: a plugins root with
+	 * a registry and an installed app@fixture 1.0.0, and a marketplace clone
+	 * whose app is 2.0.0. The preload's reader is bypassed — this runs
+	 * `resolvePluginDependencies` itself against these directories.
+	 */
+	async function machine(): Promise<{
+		here: string;
+		sources: PluginManifestSources;
+	}> {
+		const here = await fs.realpath(project);
+		const root = join(here, "plugins-root");
+		const installed = join(root, "cache", "fixture", "app", "1.0.0");
+		const clone = join(here, "marketplace-clone");
+		await fs.outputJson(join(installed, ".claude-plugin", "plugin.json"), {
+			name: "app",
+			version: "1.0.0",
+			dependencies: [{ name: "lib", version: "^1.0" }],
+		});
+		// The marketplace's newer app dropped the dependency.
+		await fs.outputJson(join(clone, "app", ".claude-plugin", "plugin.json"), {
+			name: "app",
+			version: "2.0.0",
+		});
+		await fs.outputJson(join(clone, "lib", ".claude-plugin", "plugin.json"), {
+			name: "lib",
+		});
+		await fs.outputJson(join(root, "installed_plugins.json"), {
+			version: 2,
+			plugins: {
+				"app@fixture": [
+					{
+						scope: "project",
+						projectPath: here,
+						installPath: installed,
+						version: "1.0.0",
+						installedAt: "2026-01-01T00:00:00.000Z",
+						lastUpdated: "2026-01-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+		return {
+			here,
+			sources: {
+				root,
+				clone: async (id) => join(clone, id.slice(0, id.lastIndexOf("@"))),
+			},
+		};
+	}
+
+	test("review LOW 2: a dependency the installed version declares stays enabled when the clone's newer version dropped it", async () => {
+		const { here, sources } = await machine();
+		expect(
+			await resolvePluginDependencies("app@fixture", here, sources),
+		).toEqual(["lib@fixture"]);
+		// Not installed: the clone answers.
+		expect(
+			await resolvePluginDependencies("lib@fixture", here, sources),
+		).toEqual([]);
+
+		setPluginDependencyReader((id, at) =>
+			resolvePluginDependencies(id, at, sources),
+		);
+		const manifest: ProfileManifest = {
+			version: 2,
+			profiles: {
+				only: { name: "Only", plugins: { "app@fixture": "latest" } },
+			},
+		};
+		await writeManifest(manifest, here);
+		await activateProfile(manifest, "only", here, { onDisplace: () => {} });
+
+		expect(await enabled()).toEqual({
+			"app@fixture": true,
+			"lib@fixture": true,
+		});
+	});
+
+	test('review LOW 2: nothing installed and no clone is unreadable, not "no dependencies"', async () => {
+		const { here, sources } = await machine();
+		expect(
+			await resolvePluginDependencies("ghost@fixture", here, {
+				...sources,
+				clone: async () => null,
+			}),
+		).toBeNull();
+	});
+});