magus-cli 7.4.1 → 7.5.0

package/README.md

@@ -43,7 +43,6 @@ install [profile]           Install a profile's plugins, binaries, skills and
                             it. No argument = every profile.
   --check                   Report drift only, write nothing (CI gate)
   --yes, -y                 Skip the confirmation prompt
-  --force                   Discard unsynced local edits instead of refusing
 update [profile]            Bring the ACTIVE profile up to date: install what it
                             declares but this machine lacks, and advance every
                             "latest" pin to the newest published version.
@@ -52,10 +51,10 @@ update [profile]            Bring the ACTIVE profile up to date: install what it
   --yes, -y                 Skip the confirmation prompt
 profile list                Show every profile; ● marks the active one
 profile show <name>         Print a profile's fully resolved closure
-profile switch <name>       Repoint the active profile — offline, no reinstall
+profile switch <name>       Make <name> active: render its settings.json,
+                            .mcp.json and models.json, install its skills
 profile init                Write .claude/profiles.json from this project's setup
-profile sync                Promote local edits back into .claude/profiles.json
-doctor [--fix]              Check binary deps, profile symlinks, conventions
+doctor [--fix]              Check binary deps, the active profile, conventions
 
 claude [args...]            Check for plugin updates (1h cache), then run claude
   --force, -f               Force the update check
@@ -248,13 +247,15 @@ written. `force-for-plugin` is never set either — that would override your own
 
 | Path | Owner | What magus does |
 |---|---|---|
-| `.claude/profiles.json` | you, committed | reads it; `profile sync` writes to it |
-| `.claude/_profiles/<name>/` | magus, gitignored | generated build output |
-| `.claude/settings.json` | Claude Code | in profile mode, a symlink into `_profiles/` |
+| `.claude/profiles.json` | you, committed | the one source of truth; records every change to the live config |
+| `.claude/profiles/active.json` | magus, gitignored | which profile is active, and what magus last wrote |
+| `.claude/settings.json` | magus + Claude Code, gitignored | in profile mode, rendered from the active profile; Claude Code's edits are recorded back into it |
+| `.claude/models.json` | magus, gitignored | in profile mode, rendered from the active profile's routing |
+| `.claude/skills/<name>/` | magus or you | a skill the active profile lists is installed and gitignored by magus; any other folder is yours and is never touched |
 | `.claude/settings.local.json` | you, gitignored | env values collected during install |
 | `.claude/style.json` | you, committed | the project's declared style — written on apply |
 | `.claude/output-styles/composed*.md` | magus, committed | the generated style Claude Code reads |
-| `.mcp.json` | Claude Code | in profile mode, a symlink into `_profiles/` |
+| `.mcp.json` | magus + Claude Code, gitignored | in profile mode, rendered from the active profile; Claude Code's edits are recorded back into it |
 | `~/.claude/plugins/*` | Claude Code | never written directly — always via the `claude` CLI |
 
 magus never hand-edits Claude Code's own registries

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.4.1",
+  "version": "7.5.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.4.1",
-    "magus-cli-darwin-x64": "7.4.1",
-    "magus-cli-linux-x64": "7.4.1"
+    "magus-cli-darwin-arm64": "7.5.0",
+    "magus-cli-darwin-x64": "7.5.0",
+    "magus-cli-linux-x64": "7.5.0"
   }
 }

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

@@ -7,11 +7,12 @@ import { runInstallCommand } from "../cli/install.js";
 
 // Integration coverage for runInstallCommand's VALIDATION wiring — the paths
 // that return before the closure is resolved. We deliberately don't exercise
-// --check / the drift guard here: those resolve the closure, which reaches
+// --check or the install itself here: those resolve the closure, which reaches
 // claude-settings/plugin-manager — modules other test files replace globally
 // via bun's mock.module (not restorable across files in bun 1.3.10). The
-// --check and drift LOGIC is covered by pure-function tests instead
-// (install-plan.test.ts computeVersionDrift, profile-sync.test.ts computeSync).
+// --check logic is covered by install-plan.test.ts (computeVersionDrift); the
+// re-render over the Claude CLI's own settings.json writes by
+// profile-absorb.test.ts (regenerateLiveFiles).
 //
 // runInstallCommand takes an explicit projectPath so no cwd juggling is needed.
 // Console is captured via explicit save/restore.

package/src/__tests__/models-cli.test.ts

@@ -14,6 +14,7 @@ import fs from "fs-extra";
 import { runModelsCommand } from "../cli/models.js";
 import { presetNames } from "../data/models-presets.js";
 import { writeManifest } from "../services/manifest.js";
+import { activateProfile } from "../services/profile-activate.js";
 
 let logs: string[];
 let errs: string[];
@@ -56,13 +57,9 @@ afterEach(async () => {
  * under test rather than on how the runner was launched.
  */
 async function seedProfile(name = "team"): Promise<void> {
-	await writeManifest({ version: 2, profiles: { [name]: { name } } }, project);
-	const dir = join(project, ".claude", "_profiles", name);
-	await fs.outputJson(join(dir, "settings.json"), {});
-	await fs.symlink(
-		join("_profiles", name, "settings.json"),
-		join(project, ".claude", "settings.json"),
-	);
+	const manifest = { version: 2 as const, profiles: { [name]: { name } } };
+	await writeManifest(manifest, project);
+	await activateProfile(manifest, name, project, { onDisplace: () => {} });
 }
 
 describe("models use", () => {

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

@@ -23,6 +23,8 @@ import {
 	readModelsStatus,
 	resolveFullModelId,
 } from "../services/models-manager.js";
+import { activateProfile } from "../services/profile-activate.js";
+import { liveHash, readActiveMarker } from "../services/profile-live.js";
 import type { ProfileManifest } from "../types/index.js";
 
 let project: string;
@@ -55,22 +57,16 @@ function manifestWith(profile: string, extra = {}): ProfileManifest {
 
 /**
  * Stage a project that already has a profile ACTIVE, the way `magus install`
- * leaves one: a materialized dir and `.claude/settings.json` symlinked into it.
- * Built by hand rather than by running install, which needs the claude CLI.
+ * leaves one: the live files rendered from the manifest and recorded in the
+ * marker. Built without running install, which needs the claude CLI.
  */
 async function stageActiveProfile(
 	name: string,
 	entry: Record<string, unknown> = {},
-	settings: Record<string, unknown> = {},
 ): Promise<void> {
-	await writeManifest(manifestWith(name, entry), project);
-	const dir = join(project, ".claude", "_profiles", name);
-	await fs.outputJson(join(dir, "settings.json"), settings, { spaces: 2 });
-	await fs.ensureDir(join(project, ".claude"));
-	await fs.symlink(
-		join("_profiles", name, "settings.json"),
-		join(project, ".claude", "settings.json"),
-	);
+	const manifest = manifestWith(name, entry);
+	await writeManifest(manifest, project);
+	await activateProfile(manifest, name, project, { onDisplace: () => {} });
 }
 
 async function readSettings(): Promise<Record<string, unknown>> {
@@ -131,34 +127,55 @@ describe("applyModelPreset", () => {
 		expect(again.hook).toBe("already");
 	});
 
-	// The symlink is how the active profile is wired. `updateSettingsFile` writes
-	// through it on purpose; a remove-then-create would silently detach the
-	// project from its profile and leave the next read looking at a fresh file.
-	test("keeps the profile symlink and updates profiles.json under it", async () => {
+	// settings.json and models.json are real files rendered from the manifest
+	// (Claude Code refuses to write through a symlink), recorded in the marker.
+	test("renders settings.json and models.json from the profile as real files", async () => {
 		await stageActiveProfile("team", { plugins: { "dev@magus": "latest" } });
 
 		await applyModelPreset({ projectPath: project, preset: PRESET });
 
-		const link = join(project, ".claude", "settings.json");
-		expect((await fs.lstat(link)).isSymbolicLink()).toBe(true);
-		expect(await fs.readlink(link)).toBe(
-			join("_profiles", "team", "settings.json"),
-		);
-
-		// The write landed in the profile's copy, and re-materializing did not
-		// cost the profile the plugins its manifest entry declares.
-		const inProfile = await fs.readJson(
-			join(project, ".claude", "_profiles", "team", "settings.json"),
+		const live = join(project, ".claude", "settings.json");
+		expect((await fs.lstat(live)).isFile()).toBe(true);
+		const settings = await readSettings();
+		expect(settings.model).toBe("opus");
+		// Rendering from the manifest kept the plugins the entry declares.
+		expect(
+			(settings.enabledPlugins as Record<string, boolean>)["dev@magus"],
+		).toBe(true);
+		const marker = await readActiveMarker(project);
+		expect(marker?.files.settings).toBe(
+			(await liveHash("settings", project)) ?? "",
 		);
-		expect(inProfile.model).toBe("opus");
-		expect(inProfile.enabledPlugins["dev@magus"]).toBe(true);
-
-		// And .claude/models.json is a link into the same profile dir, not a copy.
-		const modelsLink = join(project, ".claude", "models.json");
-		expect((await fs.lstat(modelsLink)).isSymbolicLink()).toBe(true);
-		expect(await fs.readlink(modelsLink)).toBe(
-			join("_profiles", "team", "models.json"),
+		expect(marker?.files.models).toBe(
+			(await liveHash("models", project)) ?? "",
 		);
+
+		const modelsFile = join(project, ".claude", "models.json");
+		expect((await fs.lstat(modelsFile)).isSymbolicLink()).toBe(false);
+		expect((await fs.readJson(modelsFile)).preset).toBe(PRESET);
+		expect(
+			await fs.pathExists(join(project, ".claude", "profiles", "team")),
+		).toBe(false);
+	});
+
+	test("a Claude Code edit to settings.json is absorbed into the profile, then the keys are added", async () => {
+		await stageActiveProfile("team");
+		// Claude Code wrote a permission; that is a change to the active profile.
+		await fs.writeJson(join(project, ".claude", "settings.json"), {
+			enabledPlugins: {},
+			permissions: { allow: ["Bash(ls)"] },
+		});
+
+		await applyModelPreset({ projectPath: project, preset: PRESET });
+
+		const settings = await readSettings();
+		expect(settings.model).toBe("opus");
+		expect(settings.permissions).toEqual({ allow: ["Bash(ls)"] });
+		const manifest = await fs.readJson(getManifestPath(project));
+		expect(manifest.profiles.team.settings.permissions).toEqual({
+			allow: ["Bash(ls)"],
+		});
+		expect(manifest.profiles.team.settings.model).toBe("opus");
 	});
 
 	test("without a profile it writes a plain models.json and records nothing", async () => {
@@ -212,20 +229,15 @@ describe("applyModelPreset", () => {
 });
 
 describe("clearModels", () => {
-	test("removes the config, the link, and the manifest entry", async () => {
+	test("removes the config file and the manifest entry", async () => {
 		await stageActiveProfile("team");
 		await applyModelPreset({ projectPath: project, preset: PRESET });
 
 		await clearModels(project);
 
 		expect(await fs.pathExists(configPath(project))).toBe(false);
-		// lstat, not pathExists: a DANGLING symlink is the failure this guards.
 		await expect(fs.lstat(configPath(project))).rejects.toThrow();
-		expect(
-			await fs.pathExists(
-				join(project, ".claude", "_profiles", "team", "models.json"),
-			),
-		).toBe(false);
+		expect((await readActiveMarker(project))?.files.models).toBeUndefined();
 
 		const manifest = await fs.readJson(getManifestPath(project));
 		expect(manifest.profiles.team.models).toBeUndefined();