magus-cli 7.5.0 → 7.5.2

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-skills.test.ts

@@ -398,6 +398,105 @@ describe("older layout: committed custom skills the seeding displaced come back"
 		).toBe(true);
 	});
 
+	test("review 3b: a committed skill the profile ALSO lists stays the team's copy — never magus-installed", async () => {
+		expect(git(project, "init", "-q").status).toBe(0);
+		const committed = "---\nname: claudish-usage\n---\n# the team's skill\n";
+		await fs.outputFile(join(skill("claudish-usage"), "SKILL.md"), committed);
+		expect(git(project, "add", ".claude/skills").status).toBe(0);
+		expect(git(project, "commit", "-q", "-m", "skills").status).toBe(0);
+		// 7.4.1: the profile lists that same skill, and the layout linked it.
+		const listed: ProfileManifest = manifest();
+		(listed.profiles.team as { skills: ProfileSkillRef[] }).skills = [
+			ALPHA,
+			{
+				name: "claudish-usage",
+				repo: "acme/skills",
+				path: "skills/claudish-usage",
+			},
+		];
+		const old = join(project, ".claude", "_profiles", "team");
+		await fs.move(skillsRoot(project), join(old, "skills"));
+		await fs.outputFile(join(old, "skills", "alpha", "SKILL.md"), "# alpha\n");
+		await fs.symlink("_profiles/team/skills", skillsRoot(project));
+		await fs.outputJson(join(old, "settings.json"), { enabledPlugins: {} });
+		await fs.symlink(
+			"_profiles/team/settings.json",
+			join(project, ".claude", "settings.json"),
+		);
+		await writeManifest(listed, project);
+
+		const prep = await prepareProfileState(project, {
+			installSkill: fakeInstall,
+		});
+
+		expect(prep.problems).toEqual([]);
+		expect(prep.lines.join("\n")).not.toContain("git rm");
+		expect(prep.lines).toContain(
+			"Skill .claude/skills/claudish-usage is committed to git — the team's copy is used; magus does not install or manage it",
+		);
+		expect(
+			Object.keys((await readActiveMarker(project))?.skills ?? {}),
+		).toEqual(["alpha"]);
+		expect(
+			await fs.readFile(join(skill("claudish-usage"), "SKILL.md"), "utf8"),
+		).toBe(committed);
+		expect(await gitignoreLines()).not.toContain(
+			".claude/skills/claudish-usage/",
+		);
+		expect(
+			git(
+				project,
+				"status",
+				"--porcelain",
+				"--",
+				".claude/skills/claudish-usage",
+			).stdout,
+		).toBe("");
+		// The next command neither refuses nor reconverts.
+		const again = await prepareProfileState(project, {
+			installSkill: fakeInstall,
+		});
+		expect(again.problems).toEqual([]);
+	});
+
+	test("review 3b: a magus-installed folder someone committed is refused before the reconcile writes anything", async () => {
+		await start();
+		expect(git(project, "init", "-q").status).toBe(0);
+		expect(git(project, "add", "-f", ".claude/skills/alpha").status).toBe(0);
+		expect(git(project, "commit", "-q", "-m", "oops").status).toBe(0);
+		// A teammate drops alpha from the profile: the next reconcile would
+		// remove the folder, after recording the change in the marker.
+		const pulled = manifest();
+		(pulled.profiles.team as { skills: ProfileSkillRef[] }).skills = [];
+		await writeManifest(pulled, project);
+		const marker = await fs.readFile(
+			join(project, ".claude", "profiles", "active.json"),
+			"utf8",
+		);
+		const manifestBytes = await fs.readFile(
+			join(project, ".claude", "profiles.json"),
+			"utf8",
+		);
+
+		const prep = await prepareProfileState(project, {
+			installSkill: fakeInstall,
+		});
+
+		expect(prep.problems[0]).toContain(
+			"git rm --cached -r .claude/skills/alpha",
+		);
+		expect(await fs.pathExists(skill("alpha"))).toBe(true);
+		expect(
+			await fs.readFile(
+				join(project, ".claude", "profiles", "active.json"),
+				"utf8",
+			),
+		).toBe(marker);
+		expect(
+			await fs.readFile(join(project, ".claude", "profiles.json"), "utf8"),
+		).toBe(manifestBytes);
+	});
+
 	test("an existing folder is never overwritten; a differing copy is reported with both paths", async () => {
 		await fs.outputFile(join(skill("shared"), "SKILL.md"), "# mine\n");
 		const old = join(project, ".claude", "_profiles", "other", "skills");