magus-cli 0.0.0-placeholder → 7.0.0

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

@@ -0,0 +1,177 @@
+import { describe, expect, test } from "bun:test";
+import {
+	buildAdoptedProfile,
+	findMachineSpecificPaths,
+} from "../services/profile-adopt.js";
+
+const NOW = "2026-08-27T00:00:00.000Z";
+
+describe("buildAdoptedProfile", () => {
+	test("adopts enabled plugins as 'latest', never as the installed version", () => {
+		// Pinning whatever a machine drifted to would turn one developer's
+		// accident into the team's contract.
+		const entry = buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true, "mnemex@magus": true },
+			settings: {},
+			mcpServers: {},
+			now: NOW,
+		});
+		expect(entry.plugins).toEqual({
+			"dev@magus": "latest",
+			"mnemex@magus": "latest",
+		});
+	});
+
+	test("skips disabled plugins", () => {
+		const entry = buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true, "designer@magus": false },
+			settings: {},
+			mcpServers: {},
+			now: NOW,
+		});
+		expect(Object.keys(entry.plugins ?? {})).toEqual(["dev@magus"]);
+	});
+
+	test("skips an id with no marketplace — it cannot be reinstalled elsewhere", () => {
+		const entry = buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true, "some-local-thing": true },
+			settings: {},
+			mcpServers: {},
+			now: NOW,
+		});
+		expect(Object.keys(entry.plugins ?? {})).toEqual(["dev@magus"]);
+	});
+
+	test("derives the marketplace each plugin id names", () => {
+		const entry = buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true },
+			settings: {},
+			mcpServers: {},
+			now: NOW,
+		});
+		expect(entry.marketplaces?.magus).toEqual({
+			source: "github",
+			repo: "MadAppGang/magus",
+		});
+	});
+
+	test("drops enabledPlugins from settings — the plugins map expresses it", () => {
+		// Carrying both would let them disagree; materialization regenerates
+		// enabledPlugins from the plugins map.
+		const entry = buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true },
+			settings: {
+				enabledPlugins: { "dev@magus": true },
+				enableAllProjectMcpServers: true,
+			},
+			mcpServers: {},
+			now: NOW,
+		});
+		expect(entry.settings).toEqual({ enableAllProjectMcpServers: true });
+	});
+
+	test("carries MCP servers over verbatim", () => {
+		const servers = {
+			"chrome-devtools": { command: "npx", args: ["-y", "x"] },
+		};
+		const entry = buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true },
+			settings: {},
+			mcpServers: servers,
+			now: NOW,
+		});
+		expect(entry.mcpServers).toEqual(servers);
+	});
+
+	test("omits empty settings and mcpServers rather than writing empty objects", () => {
+		const entry = buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true },
+			settings: {},
+			mcpServers: {},
+			now: NOW,
+		});
+		expect(entry.settings).toBeUndefined();
+		expect(entry.mcpServers).toBeUndefined();
+	});
+
+	test("strips installedPluginVersions — that is machine state, not a contract", () => {
+		// Committing it publishes one developer's install state as the team's
+		// contract, and it is stale the moment anyone updates.
+		const entry = buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true },
+			settings: {
+				installedPluginVersions: { "dev@magus": "4.6.1" },
+				enableAllProjectMcpServers: true,
+			},
+			mcpServers: {},
+			now: NOW,
+		});
+		expect(entry.settings).toEqual({ enableAllProjectMcpServers: true });
+	});
+
+	test("omits settings entirely when only machine keys were present", () => {
+		const entry = buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true },
+			settings: {
+				enabledPlugins: { "dev@magus": true },
+				installedPluginVersions: { "dev@magus": "4.6.1" },
+			},
+			mcpServers: {},
+			now: NOW,
+		});
+		expect(entry.settings).toBeUndefined();
+	});
+
+	test("does not mutate the caller's settings object", () => {
+		const settings = {
+			installedPluginVersions: { "dev@magus": "4.6.1" },
+			other: 1,
+		};
+		buildAdoptedProfile({
+			enabledPlugins: { "dev@magus": true },
+			settings,
+			mcpServers: {},
+			now: NOW,
+		});
+		expect(settings.installedPluginVersions).toEqual({ "dev@magus": "4.6.1" });
+	});
+
+	test("is deterministic when the clock is injected", () => {
+		const input = {
+			enabledPlugins: { "dev@magus": true },
+			settings: {},
+			mcpServers: {},
+			now: NOW,
+		};
+		expect(buildAdoptedProfile(input)).toEqual(buildAdoptedProfile(input));
+		expect(buildAdoptedProfile(input).createdAt).toBe(NOW);
+	});
+});
+
+describe("findMachineSpecificPaths", () => {
+	const HOME = "/Users/someone";
+
+	test("flags a home-directory path nested in an array", () => {
+		// Not stripped — an additionalDirectories list is often genuinely wanted —
+		// but surfaced, because it will not resolve on a teammate's machine.
+		expect(
+			findMachineSpecificPaths(
+				{ permissions: { additionalDirectories: ["../sibling", `${HOME}/x`] } },
+				HOME,
+			),
+		).toEqual([`permissions.additionalDirectories[1] = ${HOME}/x`]);
+	});
+
+	test("relative paths are not flagged", () => {
+		expect(
+			findMachineSpecificPaths(
+				{ permissions: { additionalDirectories: ["../magus", "./local"] } },
+				HOME,
+			),
+		).toEqual([]);
+	});
+
+	test("returns nothing rather than guessing when HOME is unset", () => {
+		expect(findMachineSpecificPaths({ a: `${HOME}/x` }, "")).toEqual([]);
+	});
+});

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

@@ -0,0 +1,110 @@
+import { afterEach, beforeEach, describe, expect, mock, 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 { listProfiles, showProfile, switchProfile } from "../cli/profile.js";
+import { activeProfile } from "../services/symlink-manager.js";
+import type { ProfileManifest } from "../types/index.js";
+
+let logs: string[];
+let errs: string[];
+
+beforeEach(() => {
+	logs = [];
+	errs = [];
+	console.log = mock((...a: unknown[]) => logs.push(a.join(" "))) as any;
+	console.error = mock((...a: unknown[]) => errs.push(a.join(" "))) as any;
+});
+afterEach(() => mock.restore());
+
+async function setupProject(
+	manifest: ProfileManifest,
+	materialize: string[] = [],
+): 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;
+}
+
+const twoProfiles: ProfileManifest = {
+	version: 2,
+	profiles: {
+		frontend: { name: "Frontend", plugins: { "dev@magus": "latest" } },
+		backend: { name: "Backend", plugins: { "dev@magus": "2.9.0" } },
+	},
+};
+
+describe("profile list", () => {
+	let dir: string;
+	afterEach(async () => {
+		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
+		logs = [];
+		const code = await listProfiles(dir);
+		expect(code).toBe(0);
+		const out = logs.join("\n");
+		expect(out).toContain("frontend");
+		expect(out).toContain("Backend");
+		expect(out).toContain("(not installed)"); // backend isn't materialized
+		expect(out).toContain("Active: frontend");
+	});
+});
+
+describe("profile show", () => {
+	let dir: string;
+	afterEach(async () => {
+		if (dir) await rm(dir, { recursive: true, force: true });
+	});
+
+	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");
+	});
+
+	test("unknown profile → exit 1", async () => {
+		dir = await setupProject(twoProfiles);
+		expect(await showProfile("ghost", dir)).toBe(1);
+	});
+});
+
+describe("profile switch", () => {
+	let dir: string;
+	afterEach(async () => {
+		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"]);
+		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/",
+		);
+	});
+
+	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("unknown profile → exit 1", async () => {
+		dir = await setupProject(twoProfiles);
+		expect(await switchProfile("ghost", dir)).toBe(1);
+	});
+});

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

@@ -0,0 +1,238 @@
+import { afterEach, beforeEach, describe, expect, 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 type { ModelsConfig } from "../services/models-core.js";
+import {
+	buildProfileMcp,
+	buildProfileSettings,
+	materializeProfile,
+} from "../services/profile-materializer.js";
+import { profileDir } from "../services/symlink-manager.js";
+import type { 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);
+	});
+
+	// Regression: `install` enables the manifest-wide union at USER scope, and
+	// Claude Code resolves enabledPlugins per plugin id — an id the project
+	// scope omits falls through to the user scope's `true`. A profile that
+	// merely omits another profile's plugins therefore never disables them, so
+	// `profile switch` silently becomes 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("no union given -> no false entries (unchanged legacy shape)", () => {
+		const s = buildProfileSettings(
+			closure({ plugins: { "dev@magus": "latest" } }),
+		);
+		expect(s.enabledPlugins).toEqual({ "dev@magus": true });
+	});
+});
+
+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("materializeProfile", () => {
+	let project: string;
+	beforeEach(async () => {
+		project = await mkdtemp(join(tmpdir(), "materialize-"));
+	});
+	afterEach(async () => {
+		await rm(project, { recursive: true, force: true });
+	});
+
+	test("writes settings.json, mcp.json, and an empty skills/ dir", async () => {
+		const dir = await materializeProfile(
+			"frontend",
+			closure({
+				plugins: { "dev@magus": "latest" },
+				mcpServers: { x: { command: "y" } },
+			}),
+			project,
+		);
+		expect(dir).toBe(profileDir("frontend", project));
+		expect(
+			(await fs.readJson(join(dir, "settings.json"))).enabledPlugins[
+				"dev@magus"
+			],
+		).toBe(true);
+		expect(
+			(await fs.readJson(join(dir, "mcp.json"))).mcpServers.x.command,
+		).toBe("y");
+		expect(await fs.pathExists(join(dir, "skills"))).toBe(true);
+	});
+
+	test("is idempotent (re-materialize overwrites cleanly)", async () => {
+		await materializeProfile(
+			"p",
+			closure({ plugins: { "a@m": "latest" } }),
+			project,
+		);
+		const dir = await materializeProfile(
+			"p",
+			closure({ plugins: { "b@m": "latest" } }),
+			project,
+		);
+		const settings = await fs.readJson(join(dir, "settings.json"));
+		expect(settings.enabledPlugins).toEqual({ "b@m": true });
+	});
+
+	// Regression: activating a profile replaces .claude/skills with a symlink,
+	// and replacing means fs.remove first. A repo that committed its own project
+	// skills before adopting profiles would lose them at that moment.
+	test("seeds skills/ from the project's pre-existing .claude/skills", async () => {
+		const src = join(project, ".claude", "skills", "systematic-debugging");
+		await fs.outputFile(join(src, "SKILL.md"), "# committed project skill\n");
+
+		const dir = await materializeProfile("p", closure(), project);
+
+		expect(
+			await fs.readFile(
+				join(dir, "skills", "systematic-debugging", "SKILL.md"),
+				"utf8",
+			),
+		).toContain("committed project skill");
+	});
+
+	test("does not re-seed skills/ once the profile dir exists", async () => {
+		await fs.outputFile(
+			join(project, ".claude", "skills", "gone", "SKILL.md"),
+			"# removed later\n",
+		);
+		const dir = await materializeProfile("p", closure(), project);
+		await fs.remove(join(dir, "skills", "gone"));
+
+		await materializeProfile("p", closure(), project);
+
+		expect(await fs.pathExists(join(dir, "skills", "gone"))).toBe(false);
+	});
+
+	test("still creates an empty skills/ when the project has none", async () => {
+		const dir = await materializeProfile("p", closure(), project);
+		expect(await fs.pathExists(join(dir, "skills"))).toBe(true);
+		expect(await fs.readdir(join(dir, "skills"))).toEqual([]);
+	});
+
+	test("writes models.json when the closure carries routing", async () => {
+		const dir = await materializeProfile(
+			"p",
+			closure({ models: ROUTING }),
+			project,
+		);
+		expect(await fs.readJson(join(dir, "models.json"))).toEqual(ROUTING);
+	});
+
+	// The one artifact materialization DELETES. Every other file here is
+	// unconditional, so overwriting is enough; routing is optional, and a
+	// profile that dropped it would otherwise keep routing from a file nothing
+	// writes any more — `magus models off` could not turn routing off,
+	// because the hook walks up to the nearest models.json and finds this one.
+	test("deletes a stale models.json when the closure has no routing", async () => {
+		const dir = await materializeProfile(
+			"p",
+			closure({ models: ROUTING }),
+			project,
+		);
+		expect(await fs.pathExists(join(dir, "models.json"))).toBe(true);
+
+		await materializeProfile("p", closure(), project);
+
+		expect(await fs.pathExists(join(dir, "models.json"))).toBe(false);
+	});
+
+	test("a profile that never had routing gets no models.json", async () => {
+		const dir = await materializeProfile("p", closure(), project);
+		expect(await fs.pathExists(join(dir, "models.json"))).toBe(false);
+	});
+
+	test("two profiles from one union each disable the other's plugins", async () => {
+		const union = ["designer@magus", "terminal@magus"];
+		const fe = await materializeProfile(
+			"frontend",
+			closure({ plugins: { "designer@magus": "latest" } }),
+			project,
+			union,
+		);
+		const be = await materializeProfile(
+			"backend",
+			closure({ plugins: { "terminal@magus": "latest" } }),
+			project,
+			union,
+		);
+		expect(
+			(await fs.readJson(join(fe, "settings.json"))).enabledPlugins,
+		).toEqual({
+			"designer@magus": true,
+			"terminal@magus": false,
+		});
+		expect(
+			(await fs.readJson(join(be, "settings.json"))).enabledPlugins,
+		).toEqual({
+			"designer@magus": false,
+			"terminal@magus": true,
+		});
+	});
+});

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

@@ -0,0 +1,154 @@
+import { afterEach, beforeEach, describe, expect, 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 { computeSync, syncProfile } from "../services/profile-sync.js";
+import { profileDir } from "../services/symlink-manager.js";
+import type { ProfileManifestEntry } from "../types/index.js";
+
+describe("computeSync (pure)", () => {
+	const entry: ProfileManifestEntry = {
+		name: "Frontend",
+		plugins: { "dev@magus": "2.9.0", "terminal@magus": "latest" },
+		settings: { effortLevel: "high" },
+	};
+
+	test("adds a newly-enabled plugin, preserving existing pins", () => {
+		const { entry: next, changes } = computeSync(
+			entry,
+			{
+				enabledPlugins: {
+					"dev@magus": true,
+					"terminal@magus": true,
+					"designer@magus": true,
+				},
+				effortLevel: "high",
+			},
+			{ mcpServers: {} },
+		);
+		// existing pin preserved (not downgraded to latest)
+		expect(next.plugins!["dev@magus"]).toBe("2.9.0");
+		// new plugin added as latest
+		expect(next.plugins!["designer@magus"]).toBe("latest");
+		expect(changes).toContainEqual({
+			kind: "plugin-added",
+			detail: "designer@magus",
+		});
+	});
+
+	test("removes a plugin that was disabled", () => {
+		const { entry: next, changes } = computeSync(
+			entry,
+			{ enabledPlugins: { "dev@magus": true }, effortLevel: "high" },
+			{ mcpServers: {} },
+		);
+		expect(next.plugins!["terminal@magus"]).toBeUndefined();
+		expect(changes).toContainEqual({
+			kind: "plugin-removed",
+			detail: "terminal@magus",
+		});
+	});
+
+	test("captures a settings change and an mcp change", () => {
+		const { entry: next, changes } = computeSync(
+			entry,
+			{
+				enabledPlugins: { "dev@magus": true, "terminal@magus": true },
+				effortLevel: "max",
+			},
+			{ mcpServers: { "chrome-devtools": { command: "npx" } } },
+		);
+		expect(next.settings!.effortLevel).toBe("max");
+		expect(next.mcpServers!["chrome-devtools"]).toEqual({ command: "npx" });
+		expect(changes.some((c) => c.kind === "settings-changed")).toBe(true);
+		expect(changes.some((c) => c.kind === "mcp-changed")).toBe(true);
+	});
+
+	test("no changes when the materialized state matches the manifest", () => {
+		const { changes } = computeSync(
+			entry,
+			{
+				enabledPlugins: { "dev@magus": true, "terminal@magus": true },
+				effortLevel: "high",
+			},
+			{ mcpServers: {} },
+		);
+		expect(changes).toEqual([]);
+	});
+
+	test("refreshes updatedAt to the injected timestamp when changed", () => {
+		const withStamp: ProfileManifestEntry = { ...entry, updatedAt: "OLD" };
+		const { entry: changed } = computeSync(
+			withStamp,
+			{
+				enabledPlugins: {
+					"dev@magus": true,
+					"terminal@magus": true,
+					"new@magus": true,
+				},
+				effortLevel: "high",
+			},
+			{ mcpServers: {} },
+			"2026-07-27T00:00:00.000Z",
+		);
+		expect(changed.updatedAt).toBe("2026-07-27T00:00:00.000Z");
+
+		// Unchanged sync leaves updatedAt alone.
+		const { entry: same } = computeSync(
+			withStamp,
+			{
+				enabledPlugins: { "dev@magus": true, "terminal@magus": true },
+				effortLevel: "high",
+			},
+			{ mcpServers: {} },
+			"2026-07-27T00:00:00.000Z",
+		);
+		expect(same.updatedAt).toBe("OLD");
+	});
+});
+
+describe("syncProfile (io)", () => {
+	let dir: string;
+	beforeEach(async () => {
+		dir = await mkdtemp(join(tmpdir(), "sync-"));
+		await fs.ensureDir(join(dir, ".claude"));
+		await fs.writeJson(join(dir, ".claude", "profiles.json"), {
+			version: 2,
+			profiles: {
+				frontend: { name: "Frontend", plugins: { "dev@magus": "2.9.0" } },
+			},
+		});
+	});
+	afterEach(async () => {
+		await rm(dir, { recursive: true, force: true });
+	});
+
+	test("promotes an edit in the materialized dir into the manifest file", async () => {
+		// A teammate enabled a new plugin directly in the active profile's settings.
+		const pd = profileDir("frontend", dir);
+		await fs.ensureDir(pd);
+		await fs.writeJson(join(pd, "settings.json"), {
+			enabledPlugins: { "dev@magus": true, "designer@magus": true },
+		});
+		await fs.writeJson(join(pd, "mcp.json"), { mcpServers: {} });
+
+		const { changes, wrote } = await syncProfile("frontend", dir);
+		expect(wrote).toBe(true);
+		expect(changes.some((c) => c.detail === "designer@magus")).toBe(true);
+
+		const manifest = await fs.readJson(join(dir, ".claude", "profiles.json"));
+		expect(manifest.profiles.frontend.plugins["designer@magus"]).toBe("latest");
+		expect(manifest.profiles.frontend.plugins["dev@magus"]).toBe("2.9.0"); // pin kept
+	});
+
+	test("no-op when nothing drifted", async () => {
+		const pd = profileDir("frontend", dir);
+		await fs.ensureDir(pd);
+		await fs.writeJson(join(pd, "settings.json"), {
+			enabledPlugins: { "dev@magus": true },
+		});
+		const { wrote } = await syncProfile("frontend", dir);
+		expect(wrote).toBe(false);
+	});
+});