magus-cli 7.4.1 → 7.5.1

package/src/__tests__/profile-manifest-write.test.ts

@@ -0,0 +1,231 @@
+/**
+ * B2 — writing `.claude/profiles.json` changes only the values that changed.
+ *
+ * The file is committed and reviewed. A single absorbed plugin used to
+ * re-serialise the whole thing: every inline array expanded, keys reordered,
+ * `"strictVersions": false` dropped — a 63-line diff on magus-src.
+ */
+
+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 { readManifest, writeManifest } from "../services/manifest.js";
+import { reconcileActiveProfile } from "../services/profile-absorb.js";
+import { activateProfile } from "../services/profile-activate.js";
+import { renameProfile, saveProfile } from "../services/profiles.js";
+
+/** A committed-style manifest: inline arrays, a key with a default value. */
+const COMMITTED = `{
+  "version": 2,
+  "strictVersions": false,
+  "profiles": {
+    "team": {
+      "name": "Team",
+      "marketplaces": {
+        "magus": { "source": "github", "repo": "MadAppGang/magus" }
+      },
+      "plugins": {
+        "dev@magus": "latest",
+        "terminal@magus": "latest"
+      },
+      "mcpServers": {
+        "chrome": { "command": "npx", "args": ["-y", "chrome-devtools-mcp"] }
+      },
+      "env": {
+        "required": ["OPENROUTER_API_KEY"]
+      }
+    },
+    "other": {
+      "name": "Other",
+      "plugins": { "designer@magus": "latest" }
+    }
+  }
+}
+`;
+
+let project: string;
+let log: ReturnType<typeof spyOn>;
+const manifestPath = () => join(project, ".claude", "profiles.json");
+
+/** Lines in `after` not matched by an LCS against `before`, plus the reverse. */
+function changedLines(before: string, after: string): number {
+	const a = before.split("\n");
+	const b = after.split("\n");
+	const dp: number[][] = Array.from({ length: a.length + 1 }, () =>
+		new Array<number>(b.length + 1).fill(0),
+	);
+	for (let i = a.length - 1; i >= 0; i--) {
+		for (let j = b.length - 1; j >= 0; j--) {
+			dp[i]![j] =
+				a[i] === b[j]
+					? (dp[i + 1]![j + 1] as number) + 1
+					: Math.max(dp[i + 1]![j] as number, dp[i]![j + 1] as number);
+		}
+	}
+	const common = dp[0]![0] as number;
+	return a.length - common + (b.length - common);
+}
+
+beforeEach(async () => {
+	project = await mkdtemp(join(tmpdir(), "manifest-write-"));
+	await fs.outputFile(manifestPath(), COMMITTED);
+	log = spyOn(console, "log").mockImplementation(() => {});
+});
+afterEach(async () => {
+	log.mockRestore();
+	await rm(project, { recursive: true, force: true });
+});
+
+describe("writeManifest edits, it does not re-serialise", () => {
+	test("adding a plugin changes exactly the plugin lines", async () => {
+		const m = await readManifest(project);
+		(m.profiles.team?.plugins as Record<string, string>)["code-search@magus"] =
+			"latest";
+		await writeManifest(m, project);
+
+		expect(await fs.readFile(manifestPath(), "utf8")).toBe(
+			COMMITTED.replace(
+				'"terminal@magus": "latest"\n',
+				'"terminal@magus": "latest",\n        "code-search@magus": "latest"\n',
+			),
+		);
+	});
+
+	test("removing a key removes that line only; strictVersions: false stays", async () => {
+		const m = await readManifest(project);
+		// biome-ignore lint/performance/noDelete: an absent key is the case under test
+		delete (m.profiles.team?.plugins as Record<string, string>)[
+			"terminal@magus"
+		];
+		await writeManifest(m, project);
+
+		const after = await fs.readFile(manifestPath(), "utf8");
+		expect(after).toBe(
+			COMMITTED.replace(
+				'"dev@magus": "latest",\n        "terminal@magus": "latest"\n',
+				'"dev@magus": "latest"\n',
+			),
+		);
+		expect(after).toContain('"strictVersions": false');
+		expect(after).toContain('"args": ["-y", "chrome-devtools-mcp"]');
+	});
+
+	test("a write that changes nothing — even reordered keys — leaves every byte", async () => {
+		const m = await readManifest(project);
+		const team = m.profiles.team as unknown as Record<string, unknown>;
+		const reordered: Record<string, unknown> = {};
+		for (const key of Object.keys(team).reverse()) reordered[key] = team[key];
+		m.profiles.team = reordered as never;
+		await writeManifest(m, project);
+		expect(await fs.readFile(manifestPath(), "utf8")).toBe(COMMITTED);
+	});
+
+	test("a new file is written as 2-space JSON with a trailing newline", async () => {
+		await fs.remove(manifestPath());
+		const m = { version: 2 as const, profiles: { a: { name: "A" } } };
+		await writeManifest(m, project);
+		expect(await fs.readFile(manifestPath(), "utf8")).toBe(
+			`${JSON.stringify(m, null, 2)}\n`,
+		);
+	});
+
+	test("an inline object gains a key on its own line; a changed inline array stays inline", async () => {
+		const m = await readManifest(project);
+		(m.profiles.other?.plugins as Record<string, string>)["code-search@magus"] =
+			"latest";
+		(m.profiles.team?.env as { required: string[] }).required.push(
+			"GEMINI_KEY",
+		);
+		await writeManifest(m, project);
+
+		expect(await fs.readFile(manifestPath(), "utf8")).toBe(
+			COMMITTED.replace(
+				'"plugins": { "designer@magus": "latest" }',
+				'"plugins": { "designer@magus": "latest", "code-search@magus": "latest" }',
+			).replace(
+				'"required": ["OPENROUTER_API_KEY"]',
+				'"required": ["OPENROUTER_API_KEY", "GEMINI_KEY"]',
+			),
+		);
+	});
+
+	test("removing the first key, or the only one, keeps the rest of the layout", async () => {
+		const m = await readManifest(project);
+		// biome-ignore lint/performance/noDelete: an absent key is the case under test
+		delete (m.profiles.team?.plugins as Record<string, string>)["dev@magus"];
+		m.profiles.team!.mcpServers = {};
+		await writeManifest(m, project);
+
+		expect(await fs.readFile(manifestPath(), "utf8")).toBe(
+			COMMITTED.replace(
+				'"dev@magus": "latest",\n        "terminal@magus"',
+				'"terminal@magus"',
+			).replace(
+				'"mcpServers": {\n        "chrome": { "command": "npx", "args": ["-y", "chrome-devtools-mcp"] }\n      }',
+				'"mcpServers": {}',
+			),
+		);
+	});
+
+	test("a v1 file is recorded as v2 and nothing else moves", async () => {
+		const v1 = COMMITTED.replace('"version": 2', '"version": 1');
+		await fs.outputFile(manifestPath(), v1);
+		const m = await readManifest(project);
+		await writeManifest(m, project);
+		expect(await fs.readFile(manifestPath(), "utf8")).toBe(COMMITTED);
+	});
+
+	test("the TUI's profiles writer (project scope) changes only the renamed profile's values", async () => {
+		await renameProfile("other", "Other Renamed", "project", project);
+		const after = await fs.readFile(manifestPath(), "utf8");
+		const stamp = /"updatedAt": "([^"]+)"/.exec(after)?.[1];
+		expect(stamp).toBeString();
+		expect(after).toBe(
+			COMMITTED.replace(
+				'"name": "Other",\n      "plugins": { "designer@magus": "latest" }\n',
+				`"name": "Other Renamed",\n      "plugins": { "designer@magus": "latest" },\n      "updatedAt": "${stamp}"\n`,
+			),
+		);
+	});
+
+	test("the TUI's profiles writer adds a profile without touching the others", async () => {
+		await saveProfile("New", { "dev@magus": true }, "project", project);
+		const after = await fs.readFile(manifestPath(), "utf8");
+		const [head] = after.split('    "new": {');
+		expect(head).toBe(
+			COMMITTED.slice(0, COMMITTED.lastIndexOf("    }\n  }\n}")).concat(
+				"    },\n",
+			),
+		);
+		const saved = JSON.parse(after).profiles.new;
+		expect(saved.name).toBe("New");
+		expect(saved.plugins).toEqual({ "dev@magus": true });
+		expect(after).toContain(
+			'    "new": {\n      "name": "New",\n      "plugins": {\n        "dev@magus": true\n      },',
+		);
+	});
+});
+
+describe("absorption writes a minimal diff", () => {
+	test("a plugin Claude Code installed is a ≤3-line diff, with no updatedAt", async () => {
+		await activateProfile(await readManifest(project), "team", project, {
+			onDisplace: () => {},
+		});
+		const committed = await fs.readFile(manifestPath(), "utf8");
+		expect(committed).toBe(COMMITTED);
+		const live = join(project, ".claude", "settings.json");
+		const settings = await fs.readJson(live);
+		settings.enabledPlugins["code-search@magus"] = true;
+		await fs.writeFile(live, JSON.stringify(settings));
+
+		const result = await reconcileActiveProfile(project);
+
+		expect(result.lines).toEqual(['Added code-search@magus to profile "team"']);
+		const after = await fs.readFile(manifestPath(), "utf8");
+		expect(changedLines(committed, after)).toBeLessThanOrEqual(3);
+		expect(after).not.toContain("updatedAt");
+		expect(after).toContain('"strictVersions": false');
+	});
+});

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

@@ -1,8 +1,8 @@
 /**
  * The CLI gate: no active profile, no command.
  *
- * This replaces `offerAdoptionOnDrift`, which asked only when the manifest had
- * drifted from `enabledPlugins`, let the user decline, and then let `magus
+ * This replaces the old adoption offer, which asked only when the manifest
+ * disagreed with `enabledPlugins`, let the user decline, and then let `magus
  * update` carry on with a profile "for this run only" — resolving against a
  * manifest the project was not running. Two worlds live at once.
  *
@@ -19,8 +19,8 @@ import { join } from "node:path";
 import fs from "fs-extra";
 import { requireActiveProfile } from "../cli/bootstrap.js";
 import { runUpdateCommand } from "../cli/update.js";
-import { materializeAndActivate } from "../services/profile-activate.js";
-import { activeProfile } from "../services/symlink-manager.js";
+import { activateProfile } from "../services/profile-activate.js";
+import { activeProfile } from "../services/profile-live.js";
 import type { ProfileManifest } from "../types/index.js";
 
 const MANIFEST: ProfileManifest = {
@@ -82,9 +82,9 @@ describe("requireActiveProfile", () => {
 
 		await requireActiveProfile(project, MANIFEST);
 
-		// No profile materialized, no backups taken, settings left exactly as it
+		// No profile activated, no backups taken, settings left exactly as it
 		// was: a refusal is not allowed to half-migrate anything.
-		expect(await fs.pathExists(join(project, ".claude", "_profiles"))).toBe(
+		expect(await fs.pathExists(join(project, ".claude", "profiles"))).toBe(
 			false,
 		);
 		expect(
@@ -112,14 +112,16 @@ describe("requireActiveProfile", () => {
 		expect(
 			await requireActiveProfile(project, MANIFEST, { check: true }),
 		).toBeNull();
-		expect(await fs.pathExists(join(project, ".claude", "_profiles"))).toBe(
+		expect(await fs.pathExists(join(project, ".claude", "profiles"))).toBe(
 			false,
 		);
 	});
 
 	test("passes straight through when a profile IS active", async () => {
 		await fs.outputJson(join(project, ".claude", "profiles.json"), MANIFEST);
-		await materializeAndActivate(MANIFEST, "lean", project, () => {});
+		await activateProfile(MANIFEST, "lean", project, {
+			onDisplace: () => {},
+		});
 		noTTY();
 
 		// No prompt, no refusal: the one state where there is nothing to ask.
@@ -166,7 +168,7 @@ describe("requireActiveProfile", () => {
 	test("--dry-run writes nothing and exits 0", async () => {
 		// `--dry-run` promises to write nothing and exit 0. An earlier version
 		// passed only `check: flags.check`, so a dry run reached `autoActivate`,
-		// wrote symlinks and appended to the TRACKED `.gitignore`. A preview that
+		// wrote config files and appended to the TRACKED `.gitignore`. A preview that
 		// mutates the repo is not a preview. Refusing is the right outcome, and
 		// for a preview it is not a failure — hence 0, where `--check` gives 1.
 		await fs.outputJson(join(project, ".claude", "profiles.json"), {
@@ -189,7 +191,7 @@ describe("requireActiveProfile", () => {
 		}
 
 		expect(await activeProfile(project)).toBeNull();
-		expect(await fs.pathExists(join(project, ".claude", "_profiles"))).toBe(
+		expect(await fs.pathExists(join(project, ".claude", "profiles"))).toBe(
 			false,
 		);
 		expect(await fs.pathExists(join(project, ".gitignore"))).toBe(false);
@@ -199,11 +201,12 @@ describe("requireActiveProfile", () => {
 		// The gate must not consult enabledPlugins. A project running a profile is
 		// usable regardless of what its generated settings currently say.
 		await fs.outputJson(join(project, ".claude", "profiles.json"), MANIFEST);
-		await materializeAndActivate(MANIFEST, "lean", project, () => {});
-		await fs.outputJson(
-			join(project, ".claude", "_profiles", "lean", "settings.json"),
-			{ enabledPlugins: { "something-else@magus": true } },
-		);
+		await activateProfile(MANIFEST, "lean", project, {
+			onDisplace: () => {},
+		});
+		await fs.outputJson(join(project, ".claude", "settings.json"), {
+			enabledPlugins: { "something-else@magus": true },
+		});
 		noTTY();
 
 		expect(await requireActiveProfile(project, MANIFEST)).not.toBeNull();