magus-cli 7.4.0 → 7.5.0

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();
-	});
-});

package/src/services/profile-materializer.ts

@@ -1,133 +0,0 @@
-/**
- * Materialize a resolved profile into `.claude/_profiles/<name>/`.
- *
- * Writes the shared config the symlink manager later points at:
- *   _profiles/<name>/settings.json  — enabledPlugins + the profile's settings
- *   _profiles/<name>/mcp.json       — the profile's MCP servers
- *   _profiles/<name>/models.json    — per-subagent model routing, when the
- *                                     profile declares any; REMOVED when it
- *                                     does not
- *   _profiles/<name>/skills/        — created empty; skills install into it
- *                                     (through the activated symlink)
- *
- * This is pure output derived from a ResolvedClosure — it performs no installs
- * and touches no global state, so it is fully testable with a temp dir.
- */
-
-import path from "node:path";
-import fs from "fs-extra";
-import type { ResolvedClosure } from "../types/index.js";
-import { profileDir } from "./symlink-manager.js";
-
-/**
- * Build the settings.json contents for a profile: every resolved plugin
- * enabled, merged with the profile's declared settings. The profile's settings
- * win over the derived enabledPlugins only if it explicitly sets that key
- * (it normally won't).
- *
- * `allPluginIds` is the manifest-wide union of plugins across every profile.
- * Plugins in the union that this profile does NOT want are written as an
- * explicit `false`, which is what makes `profile switch` exclusive rather than
- * additive. Claude Code resolves enabledPlugins **per plugin id**, walking from
- * the highest-precedence scope down and taking the first scope that mentions
- * the id — an id a scope omits falls through to the next one. Since
- * `magus install` installs the union at user scope, every non-member would
- * otherwise inherit that user-scope `true` and stay enabled while a profile
- * that excludes it is active. Omitting the union (the default) preserves the
- * old additive behavior for callers that have no cross-profile view.
- */
-export function buildProfileSettings(
-	closure: ResolvedClosure,
-	allPluginIds: readonly string[] = [],
-): Record<string, unknown> {
-	const enabledPlugins: Record<string, boolean> = {};
-	for (const pluginId of allPluginIds) {
-		enabledPlugins[pluginId] = false;
-	}
-	for (const pluginId of Object.keys(closure.plugins)) {
-		enabledPlugins[pluginId] = true;
-	}
-	return { enabledPlugins, ...closure.settings };
-}
-
-/** Build the .mcp.json contents for a profile. */
-export function buildProfileMcp(closure: ResolvedClosure): {
-	mcpServers: Record<string, unknown>;
-} {
-	return { mcpServers: { ...closure.mcpServers } };
-}
-
-/**
- * Seed a profile's skills/ dir from the project's pre-existing `.claude/skills/`.
- *
- * Activating a profile replaces `.claude/skills` with a symlink into the profile
- * dir, and replacing means `fs.remove` first. A project that committed its own
- * skills before adopting profiles would lose them at that moment. So the first
- * time a profile's skills/ dir is created, any real (non-symlink) project skills
- * are copied in — every profile inherits what the project already had, and the
- * link swap destroys nothing.
- *
- * Only runs when the profile's skills/ dir does not exist yet, so it never
- * fights a later `skills-manager` install or re-adds a skill the user removed.
- */
-async function seedSkillsFromProject(
-	skillsDir: string,
-	projectPath?: string,
-): Promise<void> {
-	if (await fs.pathExists(skillsDir)) return;
-
-	const projectSkills = path.join(
-		projectPath ?? process.cwd(),
-		".claude",
-		"skills",
-	);
-	try {
-		// lstat, not pathExists: an existing profile symlink is not a source.
-		const stat = await fs.lstat(projectSkills);
-		if (!stat.isDirectory() || stat.isSymbolicLink()) return;
-		if ((await fs.readdir(projectSkills)).length === 0) return;
-		await fs.copy(projectSkills, skillsDir, { dereference: true });
-	} catch {
-		// No project skills dir (or unreadable) — nothing to carry over.
-	}
-}
-
-/**
- * Write `_profiles/<name>/` from a resolved closure. Idempotent: overwrites
- * settings.json / mcp.json and ensures skills/ exists. Returns the dir path.
- */
-export async function materializeProfile(
-	name: string,
-	closure: ResolvedClosure,
-	projectPath?: string,
-	allPluginIds: readonly string[] = [],
-): Promise<string> {
-	const dir = profileDir(name, projectPath);
-	await fs.ensureDir(dir);
-	await fs.writeJson(
-		path.join(dir, "settings.json"),
-		buildProfileSettings(closure, allPluginIds),
-		{ spaces: 2 },
-	);
-	await fs.writeJson(path.join(dir, "mcp.json"), buildProfileMcp(closure), {
-		spaces: 2,
-	});
-
-	// models.json is the one artifact that is REMOVED when the closure lacks it.
-	// Every other file here is unconditional, so "overwrite" 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 this
-	// one would still be there (and still linked).
-	const modelsPath = path.join(dir, "models.json");
-	if (closure.models) {
-		await fs.writeJson(modelsPath, closure.models, { spaces: 2 });
-	} else {
-		await fs.remove(modelsPath);
-	}
-
-	const skillsDir = path.join(dir, "skills");
-	await seedSkillsFromProject(skillsDir, projectPath);
-	await fs.ensureDir(skillsDir);
-	return dir;
-}

package/src/services/profile-sync.ts

@@ -1,158 +0,0 @@
-/**
- * `profile sync` — promote edits made to the active profile dir back into the
- * committed manifest.
- *
- * `.claude/_profiles/<name>/` is generated build output, so an edit to the
- * symlinked settings.json / mcp.json would be lost on the next `install`. Sync
- * reverse-materializes those files into `.claude/profiles.json` so the change
- * becomes a reviewable manifest diff instead of silent, throwaway drift.
- */
-
-import path from "node:path";
-import fs from "fs-extra";
-import type {
-	McpServerConfig,
-	ProfileManifest,
-	ProfileManifestEntry,
-} from "../types/index.js";
-import { readManifest, writeManifest } from "./manifest.js";
-import { profileDir } from "./symlink-manager.js";
-
-export interface SyncChange {
-	kind: "plugin-added" | "plugin-removed" | "settings-changed" | "mcp-changed";
-	detail: string;
-}
-
-/**
- * Merge a materialized profile's settings.json + mcp.json back into a manifest
- * entry. Pure: returns the updated entry and the list of changes.
- *
- * - enabledPlugins present but not in the entry -> added as "latest".
- * - entry plugins that are no longer enabled -> removed.
- * - an existing version PIN is preserved (enabled != downgrade-to-latest).
- * - non-enabledPlugins settings keys replace the entry's settings.
- * - mcpServers replace the entry's mcpServers when they differ.
- */
-export function computeSync(
-	entry: ProfileManifestEntry,
-	materializedSettings: Record<string, unknown>,
-	materializedMcp: { mcpServers?: Record<string, McpServerConfig> },
-	now: string = new Date().toISOString(),
-): { entry: ProfileManifestEntry; changes: SyncChange[] } {
-	const changes: SyncChange[] = [];
-	const next: ProfileManifestEntry = { ...entry };
-
-	const enabled = (materializedSettings.enabledPlugins ?? {}) as Record<
-		string,
-		boolean
-	>;
-	const currentPlugins = { ...(entry.plugins ?? {}) };
-
-	// Additions: enabled plugins the manifest doesn't list.
-	for (const [id, on] of Object.entries(enabled)) {
-		if (on && !(id in currentPlugins)) {
-			currentPlugins[id] = "latest";
-			changes.push({ kind: "plugin-added", detail: id });
-		}
-	}
-	// Removals: manifest plugins no longer enabled.
-	for (const id of Object.keys(entry.plugins ?? {})) {
-		if (!enabled[id]) {
-			delete currentPlugins[id];
-			changes.push({ kind: "plugin-removed", detail: id });
-		}
-	}
-	next.plugins = currentPlugins;
-
-	// Settings = everything in the materialized file except enabledPlugins.
-	const { enabledPlugins: _drop, ...settings } = materializedSettings;
-	if (JSON.stringify(settings) !== JSON.stringify(entry.settings ?? {})) {
-		if (Object.keys(settings).length > 0) next.settings = settings;
-		else {
-			// biome-ignore lint/performance/noDelete: the manifest entry is serialised to profiles.json and diffed with JSON.stringify/toStrictEqual; the key must be absent, not undefined
-			delete next.settings;
-		}
-		changes.push({ kind: "settings-changed", detail: "settings updated" });
-	}
-
-	// MCP servers.
-	const mcp = materializedMcp.mcpServers ?? {};
-	if (JSON.stringify(mcp) !== JSON.stringify(entry.mcpServers ?? {})) {
-		if (Object.keys(mcp).length > 0) next.mcpServers = mcp;
-		else {
-			// biome-ignore lint/performance/noDelete: the manifest entry is serialised to profiles.json and diffed with JSON.stringify/toStrictEqual; the key must be absent, not undefined
-			delete next.mcpServers;
-		}
-		changes.push({ kind: "mcp-changed", detail: "mcp servers updated" });
-	}
-
-	// Refresh the timestamp when anything changed. `now` is injectable so
-	// callers/tests control it (and computeSync stays pure).
-	if (changes.length > 0) next.updatedAt = now;
-
-	return { entry: next, changes };
-}
-
-/**
- * Detect drift between a materialized profile and the manifest WITHOUT writing.
- * Returns the changes `sync` would promote (empty = in sync). Returns [] if the
- * profile isn't materialized (nothing to lose).
- */
-export async function detectProfileDrift(
-	name: string,
-	projectPath?: string,
-): Promise<SyncChange[]> {
-	const manifest = await readManifest(projectPath);
-	const entry = manifest.profiles[name];
-	if (!entry) return [];
-
-	const dir = profileDir(name, projectPath);
-	const settingsPath = path.join(dir, "settings.json");
-	if (!(await fs.pathExists(settingsPath))) return [];
-
-	const mcpPath = path.join(dir, "mcp.json");
-	const materializedSettings = await fs.readJson(settingsPath);
-	const materializedMcp = (await fs.pathExists(mcpPath))
-		? await fs.readJson(mcpPath)
-		: { mcpServers: {} };
-
-	return computeSync(entry, materializedSettings, materializedMcp).changes;
-}
-
-/**
- * Read the materialized active profile, merge it into the manifest, and write
- * the manifest back if anything changed. Returns the applied changes.
- */
-export async function syncProfile(
-	name: string,
-	projectPath?: string,
-): Promise<{ changes: SyncChange[]; wrote: boolean }> {
-	const manifest: ProfileManifest = await readManifest(projectPath);
-	const entry = manifest.profiles[name];
-	if (!entry) throw new Error(`Profile "${name}" not found in manifest`);
-
-	const dir = profileDir(name, projectPath);
-	const settingsPath = path.join(dir, "settings.json");
-	const mcpPath = path.join(dir, "mcp.json");
-	if (!(await fs.pathExists(settingsPath))) {
-		throw new Error(
-			`Profile "${name}" isn't materialized (${settingsPath} missing).`,
-		);
-	}
-
-	const materializedSettings = await fs.readJson(settingsPath);
-	const materializedMcp = (await fs.pathExists(mcpPath))
-		? await fs.readJson(mcpPath)
-		: { mcpServers: {} };
-
-	const { entry: nextEntry, changes } = computeSync(
-		entry,
-		materializedSettings,
-		materializedMcp,
-	);
-	if (changes.length === 0) return { changes: [], wrote: false };
-
-	manifest.profiles[name] = nextEntry;
-	await writeManifest(manifest, projectPath);
-	return { changes, wrote: true };
-}