magus-cli 7.4.0 → 7.5.0

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

@@ -1,49 +1,165 @@
 /**
- * Migration = adopt AND activate, without destroying what it replaces.
+ * Activation writes the live config directly, and backs up only a genuine
+ * pre-magus hand-written file at first adoption.
  *
- * REGRESSION: adopting a project wrote `.claude/profiles.json` and stopped, so
- * `activeProfile()` still returned null and every later run asked which profile
- * to use. The manifest changed; nothing the user could feel did. Fixed in
- * /dev:fix session dev-fix-20260918-migration.
+ * REGRESSION (dev-fix-20260918-migration): adopting a project wrote
+ * `.claude/profiles.json` and stopped, so `activeProfile()` still returned null
+ * and every later run asked which profile to use.
  *
- * The second half is the reason activation was left out in the first place:
- * activating replaces four real paths with symlinks, and the replacement used
- * `fs.remove` with no backup. A migration that loses a hand-written
- * `.claude/settings.json` is worse than one that does nothing.
+ * REGRESSION (this change): once a project was magus-managed, a Claude Code
+ * edit to `.claude/settings.json` was moved into `.magus-backups/` on the next
+ * switch, silently disabling the plugin it had just installed. A managed
+ * project's live files are the active profile's — they are absorbed, never
+ * backed up.
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { lstat, mkdtemp, rm } from "node:fs/promises";
+import { lstat, mkdtemp, readdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
-import { materializeAndActivate } from "../services/profile-activate.js";
+import { writeManifest } from "../services/manifest.js";
+import { activateProfile } from "../services/profile-activate.js";
 import { adoptCurrentProject } from "../services/profile-adopt.js";
 import {
-	activateProfile,
+	activeMarkerPath,
 	activeProfile,
 	backupRoot,
-	profileDir,
 	profilesRoot,
-} from "../services/symlink-manager.js";
+	readActiveMarker,
+} from "../services/profile-live.js";
 import type { ProfileManifest } from "../types/index.js";
 
-/** Materialize a fake profile dir, as `magus install` would have. */
-async function materialize(
-	project: string,
-	name: string,
-	settings: object,
-): Promise<void> {
-	const dir = profileDir(name, project);
-	await fs.ensureDir(dir);
-	await fs.writeJson(join(dir, "settings.json"), settings);
-	await fs.writeJson(join(dir, "mcp.json"), { mcpServers: {} });
+const MANIFEST: ProfileManifest = {
+	version: 2,
+	profiles: {
+		team: {
+			name: "Team",
+			plugins: { "dev@magus": "latest" },
+			mcpServers: { srv: { command: "srv" } },
+		},
+		other: { name: "Other", plugins: { "terminal@magus": "latest" } },
+	},
+};
+
+async function setup(project: string, manifest = MANIFEST): Promise<void> {
+	await writeManifest(manifest, project);
 }
 
-describe("activation never deletes a real file", () => {
+describe("activation writes the live config directly", () => {
 	let project: string;
 	beforeEach(async () => {
-		project = await mkdtemp(join(tmpdir(), "migrate-"));
+		project = await mkdtemp(join(tmpdir(), "activate-"));
+		await setup(project);
+	});
+	afterEach(async () => {
+		await rm(project, { recursive: true, force: true });
+	});
+
+	test("settings.json and .mcp.json are real files rendered from the manifest", async () => {
+		await activateProfile(MANIFEST, "team", project);
+
+		const settingsPath = join(project, ".claude", "settings.json");
+		const mcpPath = join(project, ".mcp.json");
+		expect((await lstat(settingsPath)).isFile()).toBe(true);
+		expect((await lstat(mcpPath)).isFile()).toBe(true);
+		expect(await fs.readJson(settingsPath)).toEqual({
+			enabledPlugins: { "dev@magus": true, "terminal@magus": false },
+		});
+		expect(await fs.readJson(mcpPath)).toEqual({
+			mcpServers: { srv: { command: "srv" } },
+		});
+	});
+
+	test("no per-profile directory and no copies: .claude/profiles/ holds only the marker", async () => {
+		await activateProfile(MANIFEST, "team", project);
+
+		expect(await readdir(profilesRoot(project))).toEqual(["active.json"]);
+		expect(await fs.pathExists(join(profilesRoot(project), "team"))).toBe(
+			false,
+		);
+		expect(
+			await fs.pathExists(join(profilesRoot(project), "team", "settings.json")),
+		).toBe(false);
+	});
+
+	test("nothing generated is a symlink", async () => {
+		await activateProfile(
+			{
+				...MANIFEST,
+				profiles: {
+					...MANIFEST.profiles,
+					team: {
+						...(MANIFEST.profiles.team as never),
+						models: {
+							version: 1,
+							preset: "t",
+							main: { model: "opus", effort: "medium" },
+							grades: {
+								smart: { model: "opus", effort: "high" },
+								normal: { model: "opus", effort: "medium" },
+								cheap: { model: "sonnet", effort: "low" },
+							},
+							agents: {},
+							fallback: "normal",
+						},
+					},
+				},
+			},
+			"team",
+			project,
+		);
+		for (const rel of [
+			".claude/settings.json",
+			".mcp.json",
+			".claude/models.json",
+		]) {
+			expect((await lstat(join(project, rel))).isSymbolicLink()).toBe(false);
+		}
+	});
+
+	test("the marker records the profile, the definition, and each file's hash", async () => {
+		await activateProfile(MANIFEST, "team", project);
+		const marker = await readActiveMarker(project);
+		expect(marker?.profile).toBe("team");
+		expect(marker?.definition).toMatch(/^[0-9a-f]{64}$/);
+		expect(marker?.base).toEqual(MANIFEST.profiles.team as never);
+		expect(Object.keys(marker?.files ?? {}).sort()).toEqual([
+			"mcp",
+			"settings",
+		]);
+		expect(activeMarkerPath(project)).toBe(
+			join(project, ".claude", "profiles", "active.json"),
+		);
+	});
+
+	test("switching between profiles backs up nothing", async () => {
+		await activateProfile(MANIFEST, "team", project);
+		const second = await activateProfile(MANIFEST, "other", project);
+
+		expect(second.displaced).toEqual([]);
+		expect(await fs.pathExists(backupRoot(project))).toBe(false);
+	});
+
+	test("switching over a live file Claude Code edited backs up nothing", async () => {
+		await activateProfile(MANIFEST, "team", project);
+		const settingsPath = join(project, ".claude", "settings.json");
+		const live = await fs.readJson(settingsPath);
+		live.enabledPlugins["code-search@magus"] = true;
+		await fs.writeJson(settingsPath, live);
+
+		const second = await activateProfile(MANIFEST, "other", project);
+
+		expect(second.displaced).toEqual([]);
+		expect(await fs.pathExists(backupRoot(project))).toBe(false);
+	});
+});
+
+describe("first adoption keeps a hand-written file", () => {
+	let project: string;
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "adopt-"));
+		await setup(project);
 	});
 	afterEach(async () => {
 		await rm(project, { recursive: true, force: true });
@@ -52,14 +168,11 @@ describe("activation never deletes a real file", () => {
 	test("a hand-written settings.json is moved aside, not destroyed", async () => {
 		const settingsPath = join(project, ".claude", "settings.json");
 		await fs.outputJson(settingsPath, { hand: "written", keep: "me" });
-		await materialize(project, "team", { enabledPlugins: {} });
 
-		const backups = await activateProfile("team", project);
+		const { displaced } = await activateProfile(MANIFEST, "team", project);
 
-		// The link is live...
-		expect((await lstat(settingsPath)).isSymbolicLink()).toBe(true);
-		// ...and the file it displaced is still readable somewhere.
-		const saved = backups.find((b) => b.link === settingsPath);
+		expect((await lstat(settingsPath)).isFile()).toBe(true);
+		const saved = displaced.find((b) => b.link === settingsPath);
 		expect(saved).toBeDefined();
 		expect(await fs.readJson(saved?.savedTo ?? "")).toEqual({
 			hand: "written",
@@ -67,81 +180,50 @@ describe("activation never deletes a real file", () => {
 		});
 	});
 
-	test("switching between profiles reports no backups", async () => {
-		await materialize(project, "a", { enabledPlugins: {} });
-		await materialize(project, "b", { enabledPlugins: {} });
-
-		await activateProfile("a", project);
-		// Everything at the link paths is now a symlink magus itself wrote.
-		// Backing those up on every switch would fill the repo with copies of
-		// generated state that the manifest can regenerate at any time.
-		const second = await activateProfile("b", project);
-
-		expect(second).toEqual([]);
-	});
-
-	test("a symlink magus does not own is preserved too", async () => {
-		// Someone pointed .mcp.json at a shared config outside the project. It is
-		// not generated state, so it gets the same protection a real file gets.
+	test("a symlink magus does not own is preserved, its target untouched", async () => {
 		const outside = join(project, "shared-mcp.json");
 		await fs.writeJson(outside, { mcpServers: { shared: {} } });
 		await fs.symlink(outside, join(project, ".mcp.json"));
-		await materialize(project, "team", { enabledPlugins: {} });
 
-		const backups = await activateProfile("team", project);
+		const { displaced } = await activateProfile(MANIFEST, "team", project);
 
-		expect(backups.map((b) => b.link)).toContain(join(project, ".mcp.json"));
-		// The target was never touched — only the link moved.
+		expect(displaced.map((b) => b.link)).toContain(join(project, ".mcp.json"));
 		expect(await fs.readJson(outside)).toEqual({ mcpServers: { shared: {} } });
 	});
 
 	test("a RELATIVE user symlink still resolves from the backup", async () => {
-		// A symlink's target resolves against the directory the link sits in, so
-		// moving the link into a backup two levels deeper silently repoints it.
-		// Preserving a link that no longer resolves preserves nothing.
 		await fs.writeJson(join(project, "shared-mcp.json"), { mcpServers: {} });
 		await fs.symlink("shared-mcp.json", join(project, ".mcp.json"));
-		await materialize(project, "team", { enabledPlugins: {} });
 
-		const backups = await activateProfile("team", project);
-		const saved = backups.find((b) => b.link === join(project, ".mcp.json"));
+		const { displaced } = await activateProfile(MANIFEST, "team", project);
+		const saved = displaced.find((b) => b.link === join(project, ".mcp.json"));
 
 		expect(saved).toBeDefined();
-		// readJson follows the link: if it were still relative this would throw.
 		expect(await fs.readJson(saved?.savedTo ?? "")).toEqual({ mcpServers: {} });
 	});
 
-	test("backups live OUTSIDE the regenerable _profiles/ tree", async () => {
-		// `_profiles/` is generated and documented as safe to delete. A backup kept
-		// there is the only copy of a hand-written file, stored in the one
-		// directory everybody is told they can remove.
+	test("backups live OUTSIDE the regenerable .claude/profiles/ tree", async () => {
 		await fs.outputJson(join(project, ".claude", "settings.json"), { a: 1 });
-		await materialize(project, "team", { enabledPlugins: {} });
 
-		const backups = await activateProfile("team", project);
-		const saved = backups[0]?.savedTo ?? "";
+		const { displaced } = await activateProfile(MANIFEST, "team", project);
+		const saved = displaced[0]?.savedTo ?? "";
 
 		expect(saved.startsWith(profilesRoot(project))).toBe(false);
 		expect(saved.startsWith(backupRoot(project))).toBe(true);
-
 		await fs.remove(profilesRoot(project));
 		expect(await fs.readJson(saved)).toEqual({ a: 1 });
 	});
 
-	test("every displaced artifact is announced as it moves", async () => {
-		// The returned array is lost if a later link throws, and `magus install`
-		// and `profile switch` discard it outright. The callback is what makes the
-		// move visible at the moment it happens.
+	test("every displaced file is announced as it moves", async () => {
 		await fs.outputJson(join(project, ".claude", "settings.json"), { a: 1 });
 		await fs.writeJson(join(project, ".mcp.json"), { mcpServers: {} });
-		await materialize(project, "team", { enabledPlugins: {} });
 
 		const announced: string[] = [];
-		const returned = await activateProfile("team", project, (d) =>
-			announced.push(d.link),
-		);
+		const { displaced } = await activateProfile(MANIFEST, "team", project, {
+			onDisplace: (d) => announced.push(d.link),
+		});
 
-		expect(announced.sort()).toEqual(returned.map((d) => d.link).sort());
+		expect(announced.sort()).toEqual(displaced.map((d) => d.link).sort());
 		expect(announced).toHaveLength(2);
 	});
 });
@@ -155,20 +237,24 @@ describe("migration leaves the project ON the profile it created", () => {
 		await rm(project, { recursive: true, force: true });
 	});
 
-	test("after adopting, activeProfile() names the adopted profile", async () => {
-		await fs.outputJson(join(project, ".claude", "settings.json"), {
-			enabledPlugins: { "dev@magus": true, "code-search@magus": true },
-		});
-
+	async function adoptAndActivate(existing?: ProfileManifest) {
 		const result = await adoptCurrentProject(
 			project,
 			undefined,
-			undefined,
+			existing,
 			"default",
 		);
-		await materializeAndActivate(result.manifest, "default", project);
+		await writeManifest(result.manifest, project);
+		await activateProfile(result.manifest, "default", project, {
+			onDisplace: () => {},
+		});
+	}
 
-		// The whole point: the question "which profile?" now has an answer.
+	test("after adopting, activeProfile() names the adopted profile", async () => {
+		await fs.outputJson(join(project, ".claude", "settings.json"), {
+			enabledPlugins: { "dev@magus": true, "code-search@magus": true },
+		});
+		await adoptAndActivate();
 		expect(await activeProfile(project)).toBe("default");
 	});
 
@@ -177,16 +263,8 @@ describe("migration leaves the project ON the profile it created", () => {
 			enabledPlugins: { "dev@magus": true, "code-search@magus": true },
 			someOtherSetting: 42,
 		});
+		await adoptAndActivate();
 
-		const result = await adoptCurrentProject(
-			project,
-			undefined,
-			undefined,
-			"default",
-		);
-		await materializeAndActivate(result.manifest, "default", project);
-
-		// Read through the live symlink — this is what Claude Code will load.
 		const live = await fs.readJson(join(project, ".claude", "settings.json"));
 		expect(live.enabledPlugins).toEqual({
 			"dev@magus": true,
@@ -199,44 +277,95 @@ describe("migration leaves the project ON the profile it created", () => {
 		await fs.outputJson(join(project, ".claude", "settings.json"), {
 			enabledPlugins: { "dev@magus": true },
 		});
-		const existing: ProfileManifest = {
+		await adoptAndActivate({
 			version: 2,
 			profiles: {
 				lean: { name: "Lean", plugins: { "terminal@magus": "latest" } },
 			},
-		};
-
-		const result = await adoptCurrentProject(
-			project,
-			undefined,
-			existing,
-			"default",
-		);
-		await materializeAndActivate(result.manifest, "default", project);
+		});
 
 		const live = await fs.readJson(join(project, ".claude", "settings.json"));
-		// `terminal@magus` belongs to another profile, so this one must say so
-		// explicitly — an omitted id falls through to user scope and stays on.
 		expect(live.enabledPlugins["terminal@magus"]).toBe(false);
 		expect(live.enabledPlugins["dev@magus"]).toBe(true);
 	});
 
-	test("the generated dir and the symlinks are gitignored", async () => {
+	test("the marker dir and live config are gitignored; .claude/skills is not", async () => {
 		await fs.outputJson(join(project, ".claude", "settings.json"), {
 			enabledPlugins: { "dev@magus": true },
 		});
-		const result = await adoptCurrentProject(
-			project,
-			undefined,
-			undefined,
-			"default",
+		await adoptAndActivate();
+
+		const lines = (await fs.readFile(join(project, ".gitignore"), "utf8"))
+			.split("\n")
+			.map((l) => l.trim());
+		expect(lines).toContain(".claude/profiles/");
+		expect(lines).toContain(".claude/settings.json");
+		expect(lines).toContain(".mcp.json");
+		// Custom skills in .claude/skills are committed; a blanket ignore hid them.
+		expect(lines).not.toContain(".claude/skills");
+		expect(lines).not.toContain(".claude/_profiles/");
+	});
+
+	test("a user's own .claude/skills/ line outside magus's block survives activation and switching", async () => {
+		await fs.writeFile(
+			join(project, ".gitignore"),
+			"node_modules\n# my skills are local\n.claude/skills/\n.claude/skills\n",
+		);
+		await fs.outputJson(join(project, ".claude", "settings.json"), {
+			enabledPlugins: { "dev@magus": true },
+		});
+		await adoptAndActivate();
+
+		const lines = (await fs.readFile(join(project, ".gitignore"), "utf8"))
+			.split("\n")
+			.map((l) => l.trim());
+		expect(lines).toContain("node_modules");
+		expect(lines).toContain(".claude/skills/");
+		expect(lines).toContain(".claude/skills");
+		expect(lines).toContain(".claude/profiles/");
+	});
+
+	test("converting a 7.4.1 layout removes the blanket skills line from magus's block only", async () => {
+		// magus 7.4.1 wrote this block; the user's own line sits elsewhere.
+		await fs.writeFile(
+			join(project, ".gitignore"),
+			[
+				"node_modules",
+				".claude/skills/",
+				"",
+				"# magus: generated profile build output + active-profile config",
+				".claude/_profiles/",
+				".claude/.magus-backups/",
+				".claude/settings.json",
+				".claude/skills",
+				".claude/models.json",
+				".mcp.json",
+				"",
+			].join("\n"),
+		);
+		await writeManifest(MANIFEST, project);
+		const old = join(project, ".claude", "_profiles", "team");
+		await fs.outputJson(join(old, "settings.json"), { enabledPlugins: {} });
+		await fs.ensureDir(join(old, "skills"));
+		await fs.symlink(
+			"_profiles/team/settings.json",
+			join(project, ".claude", "settings.json"),
+		);
+		await fs.symlink(
+			"_profiles/team/skills",
+			join(project, ".claude", "skills"),
 		);
-		await materializeAndActivate(result.manifest, "default", project);
 
-		const gitignore = await fs.readFile(join(project, ".gitignore"), "utf8");
-		// `.claude/` is committed, so a symlink into generated state that lands in
-		// git breaks every teammate who does not have that profile materialized.
-		expect(gitignore).toContain(".claude/_profiles/");
-		expect(gitignore).toContain(".claude/settings.json");
+		await activateProfile(MANIFEST, "team", project, { onDisplace: () => {} });
+
+		const text = await fs.readFile(join(project, ".gitignore"), "utf8");
+		const lines = text.split("\n").map((l) => l.trim());
+		// The user's line, outside the block: kept.
+		expect(lines.slice(0, 2)).toEqual(["node_modules", ".claude/skills/"]);
+		// magus's obsolete lines, inside its block: gone.
+		expect(lines).not.toContain(".claude/skills");
+		expect(lines).not.toContain(".claude/_profiles/");
+		expect(lines).toContain(".claude/settings.json");
+		expect(lines).toContain(".claude/profiles/");
 	});
 });

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

@@ -0,0 +1,141 @@
+import { describe, expect, test } from "bun:test";
+import type { ModelsConfig } from "../services/models-core.js";
+import {
+	buildProfileMcp,
+	buildProfileSettings,
+	renderProfile,
+} from "../services/profile-render.js";
+import type { ProfileManifest, ResolvedClosure } from "../types/index.js";
+
+const ROUTING: ModelsConfig = {
+	version: 1,
+	preset: "test",
+	main: { model: "opus", effort: "medium" },
+	grades: {
+		smart: { model: "fable", effort: "xhigh" },
+		normal: { model: "opus", effort: "medium" },
+		cheap: { model: "sonnet", effort: "low" },
+	},
+	agents: { "dev:architect": "smart" },
+	fallback: "normal",
+};
+
+function closure(overrides: Partial<ResolvedClosure> = {}): ResolvedClosure {
+	return {
+		marketplaces: {},
+		plugins: {},
+		mcpServers: {},
+		bins: [],
+		skills: [],
+		settings: {},
+		env: { required: [], optional: [] },
+		...overrides,
+	};
+}
+
+describe("buildProfileSettings", () => {
+	test("enables every resolved plugin and merges declared settings", () => {
+		const s = buildProfileSettings(
+			closure({
+				plugins: { "dev@magus": "2.9.0", "terminal@magus": "latest" },
+				settings: { enableAllProjectMcpServers: true },
+			}),
+		);
+		expect(s.enabledPlugins).toEqual({
+			"dev@magus": true,
+			"terminal@magus": true,
+		});
+		expect(s.enableAllProjectMcpServers).toBe(true);
+	});
+
+	// Claude Code resolves enabledPlugins per plugin id — an id the project
+	// scope omits falls through to user scope. A profile that merely omits
+	// another profile's plugins would never disable them, so `profile switch`
+	// would be additive instead of exclusive.
+	test("explicitly disables union plugins the profile excludes", () => {
+		const s = buildProfileSettings(
+			closure({ plugins: { "designer@magus": "latest" } }),
+			["designer@magus", "terminal@magus", "madbench@magus"],
+		);
+		expect(s.enabledPlugins).toEqual({
+			"designer@magus": true,
+			"terminal@magus": false,
+			"madbench@magus": false,
+		});
+	});
+
+	test("a profile's own plugin wins over its union entry", () => {
+		const s = buildProfileSettings(
+			closure({ plugins: { "terminal@magus": "4.1.4" } }),
+			["terminal@magus"],
+		);
+		expect(s.enabledPlugins).toEqual({ "terminal@magus": true });
+	});
+
+	test("a plugin the profile declares false is rendered false", () => {
+		const s = buildProfileSettings(
+			closure({
+				plugins: { "dev@magus": "latest" },
+				disabledPlugins: ["noisy@elsewhere"],
+			}),
+		);
+		expect(s.enabledPlugins).toEqual({
+			"dev@magus": true,
+			"noisy@elsewhere": false,
+		});
+	});
+});
+
+describe("buildProfileMcp", () => {
+	test("wraps the closure's mcpServers", () => {
+		const m = buildProfileMcp(
+			closure({ mcpServers: { "chrome-devtools": { command: "npx" } } }),
+		);
+		expect(m.mcpServers["chrome-devtools"]).toEqual({ command: "npx" });
+	});
+});
+
+describe("renderProfile", () => {
+	const manifest: ProfileManifest = {
+		version: 2,
+		profiles: {
+			frontend: {
+				name: "Frontend",
+				plugins: { "designer@magus": "latest", "off@elsewhere": false },
+				mcpServers: { x: { command: "y" } },
+				settings: { outputStyle: "composed-frontend" },
+				models: ROUTING,
+			},
+			backend: { name: "Backend", plugins: { "terminal@magus": "latest" } },
+		},
+	};
+
+	test("renders settings, mcp and models in memory from the entry", async () => {
+		const r = await renderProfile(manifest, "frontend");
+		expect(r.settings).toEqual({
+			enabledPlugins: {
+				"designer@magus": true,
+				"terminal@magus": false,
+				"off@elsewhere": false,
+			},
+			outputStyle: "composed-frontend",
+		});
+		expect(r.mcp).toEqual({ mcpServers: { x: { command: "y" } } });
+		expect(r.models).toEqual(ROUTING as unknown as Record<string, unknown>);
+		expect(r.entry).toBe(manifest.profiles.frontend as never);
+	});
+
+	test("a profile without routing renders no models.json", async () => {
+		const r = await renderProfile(manifest, "backend");
+		expect(r.models).toBeNull();
+		expect(r.settings.enabledPlugins).toEqual({
+			"designer@magus": false,
+			"terminal@magus": true,
+		});
+		expect(r.mcp).toEqual({ mcpServers: {} });
+	});
+
+	test("an unknown profile throws", async () => {
+		await expect(renderProfile(manifest, "nope")).rejects.toThrow(/nope/);
+	});
+});