magus-cli 7.4.1 → 7.5.0

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

@@ -1,238 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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);
-	});
-});

package/src/__tests__/symlink-manager.test.ts

@@ -1,180 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { lstat, mkdtemp, readlink, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import fs from "fs-extra";
-import {
-	activateProfile,
-	activeProfile,
-	profileDir,
-} from "../services/symlink-manager.js";
-
-/** Materialize a fake profile dir with the given files. */
-async function materialize(
-	project: string,
-	name: string,
-	files: {
-		settings?: object;
-		mcp?: object;
-		skills?: boolean;
-		models?: object;
-	},
-) {
-	const dir = profileDir(name, project);
-	await fs.ensureDir(dir);
-	if (files.settings)
-		await fs.writeJson(join(dir, "settings.json"), files.settings);
-	if (files.mcp) await fs.writeJson(join(dir, "mcp.json"), files.mcp);
-	if (files.skills) await fs.ensureDir(join(dir, "skills"));
-	if (files.models) await fs.writeJson(join(dir, "models.json"), files.models);
-}
-
-describe("symlink-manager", () => {
-	let project: string;
-	beforeEach(async () => {
-		project = await mkdtemp(join(tmpdir(), "symlink-"));
-	});
-	afterEach(async () => {
-		await rm(project, { recursive: true, force: true });
-	});
-
-	test("activateProfile links settings.json, .mcp.json, and skills/", async () => {
-		await materialize(project, "frontend", {
-			settings: { enabledPlugins: { "dev@magus": true } },
-			mcp: { mcpServers: {} },
-			skills: true,
-		});
-		await activateProfile("frontend", project);
-
-		// settings.json is a symlink into the profile dir
-		expect(
-			(await lstat(join(project, ".claude", "settings.json"))).isSymbolicLink(),
-		).toBe(true);
-		expect((await lstat(join(project, ".mcp.json"))).isSymbolicLink()).toBe(
-			true,
-		);
-		expect(
-			(await lstat(join(project, ".claude", "skills"))).isSymbolicLink(),
-		).toBe(true);
-
-		// reading through the link returns the profile's content
-		const settings = await fs.readJson(
-			join(project, ".claude", "settings.json"),
-		);
-		expect(settings.enabledPlugins["dev@magus"]).toBe(true);
-	});
-
-	test("writeJson through the settings symlink lands in the profile dir", async () => {
-		await materialize(project, "frontend", { settings: { a: 1 } });
-		await activateProfile("frontend", project);
-		await fs.writeJson(join(project, ".claude", "settings.json"), { a: 2 });
-		// The real file inside the profile dir was updated (symlink preserved).
-		expect(
-			(await lstat(join(project, ".claude", "settings.json"))).isSymbolicLink(),
-		).toBe(true);
-		expect(
-			(await fs.readJson(`${profileDir("frontend", project)}/settings.json`)).a,
-		).toBe(2);
-	});
-
-	test("switching repoints links and activeProfile tracks it", async () => {
-		await materialize(project, "frontend", { settings: { which: "frontend" } });
-		await materialize(project, "backend", { settings: { which: "backend" } });
-
-		await activateProfile("frontend", project);
-		expect(await activeProfile(project)).toBe("frontend");
-		expect(
-			(await fs.readJson(join(project, ".claude", "settings.json"))).which,
-		).toBe("frontend");
-
-		await activateProfile("backend", project);
-		expect(await activeProfile(project)).toBe("backend");
-		expect(
-			(await fs.readJson(join(project, ".claude", "settings.json"))).which,
-		).toBe("backend");
-	});
-
-	test("uses relative (not absolute) symlinks", async () => {
-		await materialize(project, "frontend", { settings: { a: 1 } });
-		await activateProfile("frontend", project);
-		const target = await readlink(join(project, ".claude", "settings.json"));
-		expect(target.startsWith("/")).toBe(false);
-		expect(target).toContain("_profiles");
-	});
-
-	test("a profile without skills/ creates no skills link", async () => {
-		await materialize(project, "frontend", { settings: { a: 1 } });
-		await activateProfile("frontend", project);
-		expect(await fs.pathExists(join(project, ".claude", "skills"))).toBe(false);
-	});
-
-	test("activateProfile throws if the profile isn't materialized", async () => {
-		await expect(activateProfile("ghost", project)).rejects.toThrow(
-			"not materialized",
-		);
-	});
-
-	test("links models.json when the profile has routing", async () => {
-		await materialize(project, "frontend", {
-			settings: { a: 1 },
-			models: { version: 1, preset: "fable-advisor" },
-		});
-		await activateProfile("frontend", project);
-
-		const link = join(project, ".claude", "models.json");
-		expect((await lstat(link)).isSymbolicLink()).toBe(true);
-		expect((await fs.readJson(link)).preset).toBe("fable-advisor");
-	});
-
-	// A dangling .claude/models.json is a repo-wide hazard: `.claude/` is
-	// committed, so it would ship to every teammate and point at a directory
-	// that only exists on the machine that made it.
-	test("a profile without routing gets no models link at all", async () => {
-		await materialize(project, "frontend", { settings: { a: 1 } });
-		await activateProfile("frontend", project);
-
-		const link = join(project, ".claude", "models.json");
-		expect(await fs.pathExists(link)).toBe(false);
-		await expect(lstat(link)).rejects.toThrow();
-	});
-
-	test("switching to a profile without routing removes the previous link", async () => {
-		await materialize(project, "routed", {
-			settings: { which: "routed" },
-			models: { version: 1, preset: "fable-advisor" },
-		});
-		await materialize(project, "plain", { settings: { which: "plain" } });
-
-		await activateProfile("routed", project);
-		expect(
-			(await lstat(join(project, ".claude", "models.json"))).isSymbolicLink(),
-		).toBe(true);
-
-		await activateProfile("plain", project);
-		await expect(
-			lstat(join(project, ".claude", "models.json")),
-		).rejects.toThrow();
-	});
-
-	// Removal is scoped to links INTO _profiles/. A real models.json a project
-	// wrote by hand is not magus's to delete.
-	test("a real models.json file is never clobbered by activation", async () => {
-		await materialize(project, "plain", { settings: { a: 1 } });
-		await fs.outputJson(join(project, ".claude", "models.json"), {
-			version: 1,
-			preset: "hand-written",
-		});
-
-		await activateProfile("plain", project);
-
-		expect(
-			(await fs.readJson(join(project, ".claude", "models.json"))).preset,
-		).toBe("hand-written");
-	});
-
-	test("activeProfile returns null when settings.json is a real file", async () => {
-		await fs.ensureDir(join(project, ".claude"));
-		await fs.writeJson(join(project, ".claude", "settings.json"), { a: 1 });
-		expect(await activeProfile(project)).toBeNull();
-	});
-});