magus-cli 7.4.1 → 7.5.0

package/src/data/gitignore-defaults.ts

@@ -12,9 +12,9 @@ export const BUILTIN_DEFAULTS: GitignoreManifest = {
 		".claude/scheduled_tasks.lock",
 		".claude/cache/",
 		".claude/.statusline-worktree-*",
-		// Generated, per-developer profile build output (like node_modules).
-		".claude/_profiles/",
-		// Generated from profiles.json (a symlink into _profiles/ when a profile
+		// The per-developer active-profile marker.
+		".claude/profiles/",
+		// Generated from profiles.json (rendered from the active profile when one
 		// is active). The routing itself IS committed — in profiles.json, under
 		// the profile that declares it.
 		".claude/models.json",

package/src/services/active-closure.ts

@@ -6,7 +6,7 @@
  * pick the profile in different ways — the CLI inline, the TUI not at all (it
  * judged everything against "latest") — so an exact pin could never agree.
  * Both now choose through {@link selectProfileId} over the same manifest and
- * the same active-profile symlink.
+ * the same active-profile marker.
  *
  * Read-only. Unlike the CLI's `ensureManifest`, nothing here bootstraps a
  * manifest: a screen opening must never author a file a team commits.
@@ -20,14 +20,14 @@ import type {
 	ResolvedClosure,
 } from "../types/index.js";
 import { readManifest, validateManifest } from "./manifest.js";
+import { activeProfile } from "./profile-live.js";
 import { resolveProfile } from "./resolver.js";
-import { activeProfile } from "./symlink-manager.js";
 
 /**
  * The profile to use: the explicit one, else the active one, else the only one.
  *
  * Each candidate counts only if the manifest defines it. A stale active-profile
- * symlink naming a profile that was since removed would otherwise be chosen and
+ * marker naming a profile that was since removed would otherwise be chosen and
  * then fail to resolve, even when the manifest has exactly one profile and the
  * answer is unambiguous.
  */

package/src/services/conventions-manager.ts

@@ -258,6 +258,94 @@ export async function removeGitignoreEntries(
 	});
 }
 
+/** A `.gitignore` comment that heads a block magus wrote. */
+const MAGUS_BLOCK_HEADER_RE = /^#\s*magus:/;
+
+/**
+ * Edit magus's own block in a `.gitignore`, and nothing else in the file.
+ *
+ * A block is a `# magus: …` comment line and the entry lines under it, up to
+ * the next blank line or comment. Every magus release wrote its profile lines
+ * that way, so that block is the only part of the file magus may take lines
+ * OUT of: the same pattern elsewhere is a person's, and they put it there on
+ * purpose.
+ *
+ * - `add`: entries not already present anywhere in the file are appended to
+ *   the block headed exactly by `header`, which is created at the end of the
+ *   file when there is none.
+ * - `remove`: entries are removed from every `# magus:` block. Lines outside
+ *   the blocks are never touched.
+ *
+ * Under the file lock, written atomically, a no-op when nothing changes.
+ */
+export async function updateManagedGitignoreBlock(
+	gitignorePath: string,
+	header: string,
+	edits: { add?: readonly string[]; remove?: readonly string[] },
+): Promise<{ added: string[]; removed: string[]; modified: boolean }> {
+	const add = (edits.add ?? []).map((e) => e.trim()).filter(Boolean);
+	const remove = new Set(
+		(edits.remove ?? []).map((e) => e.trim()).filter((e) => !add.includes(e)),
+	);
+	if (add.length === 0 && remove.size === 0) {
+		return { added: [], removed: [], modified: false };
+	}
+
+	return withFileLock(gitignorePath, async () => {
+		const content = await readFileOrEmpty(gitignorePath);
+		const lines = content.length > 0 ? content.split("\n") : [];
+		if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+
+		// Pass 1: drop `remove` entries inside magus blocks only.
+		const removed: string[] = [];
+		const kept: string[] = [];
+		let inBlock = false;
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (MAGUS_BLOCK_HEADER_RE.test(trimmed)) {
+				inBlock = true;
+				kept.push(line);
+				continue;
+			}
+			if (trimmed === "" || trimmed.startsWith("#")) inBlock = false;
+			if (inBlock && remove.has(trimmed)) {
+				removed.push(trimmed);
+				continue;
+			}
+			kept.push(line);
+		}
+
+		// Pass 2: add what the file lacks, at the end of the named block.
+		const present = new Set(
+			kept.map((l) => l.trim()).filter((l) => l && !l.startsWith("#")),
+		);
+		const toAdd = add.filter((e) => !present.has(e));
+		let out = kept;
+		if (toAdd.length > 0) {
+			const at = kept.findIndex((l) => l.trim() === header.trim());
+			if (at === -1) {
+				out = [...kept];
+				if (out.length > 0 && out[out.length - 1]?.trim() !== "") out.push("");
+				out.push(header, ...toAdd);
+			} else {
+				let end = at + 1;
+				while (end < kept.length) {
+					const t = kept[end]?.trim() ?? "";
+					if (t === "" || t.startsWith("#")) break;
+					end++;
+				}
+				out = [...kept.slice(0, end), ...toAdd, ...kept.slice(end)];
+			}
+		}
+
+		if (toAdd.length === 0 && removed.length === 0) {
+			return { added: [], removed: [], modified: false };
+		}
+		await atomicWrite(gitignorePath, `${out.join("\n")}\n`);
+		return { added: toAdd, removed, modified: true };
+	});
+}
+
 /**
  * Check which expected entries are missing from a .gitignore file.
  *

package/src/services/git-worktree.ts

@@ -65,6 +65,27 @@ export function clearWorktreeCache(): void {
 	cache.clear();
 }
 
+/**
+ * Is `relPath` (relative to `projectPath`) tracked by git? For a directory,
+ * true when any file under it is tracked.
+ *
+ * `git ls-files --error-unmatch` exits 0 only for a tracked path. Not a
+ * repository, git missing, or git not replying all answer false: a project
+ * outside git has nothing tracked to report.
+ */
+export async function isTrackedByGit(
+	projectPath: string,
+	relPath: string,
+): Promise<boolean> {
+	const { code } = await git(projectPath, [
+		"ls-files",
+		"--error-unmatch",
+		"--",
+		relPath,
+	]);
+	return code === 0;
+}
+
 /**
  * Directories whose registry rows this project may inherit, nearest first.
  *

package/src/services/manifest.ts

@@ -311,11 +311,10 @@ export async function updateProfileEntry(
  * Merge `patch` into `profiles.<profile>.settings`, optionally removing the
  * keys named in `unset`.
  *
- * Why this exists: `.claude/settings.json` is a symlink into the active
- * profile's materialized directory, so a live write lands in the right place —
- * but `materializeProfile` REWRITES that file from the manifest on every
- * `magus install`, so the live write alone silently regresses. The manifest
- * is the durable half of every settings write magus makes.
+ * Why this exists: `.claude/settings.json` is rendered from the active
+ * profile's entry, so a setting magus writes belongs in the entry — the next
+ * render reads it from there. The manifest is the durable half of every
+ * settings write magus makes.
  */
 export async function mergeManifestSettings(
 	projectPath: string,

package/src/services/models-manager.ts

@@ -11,15 +11,13 @@
  *
  * The routing is a PROFILE property, committed in `.claude/profiles.json` under
  * `profiles.<name>.models`. `.claude/models.json` is the generated view of it —
- * a symlink into `_profiles/<active>/models.json` when a profile is active, a
- * plain file when the project has no profiles. The hook reads the generated
- * file (it walks up from the session's cwd looking for exactly that name); a
- * teammate gets the routing by pulling profiles.json and running `magus
- * install`.
+ * a real file rendered from the active profile when there is one, a plain
+ * hand-kept file when the project has no profiles. The hook reads the
+ * generated file (it walks up from the session's cwd looking for exactly that
+ * name); a teammate gets the routing by pulling profiles.json.
  *
- * Writing only the generated file would be silently temporary: `magus
- * install` rewrites `_profiles/<name>/` from the manifest, so the routing would
- * disappear on the next install with nothing to explain why.
+ * Writing only the generated file would be silently temporary: every
+ * activation renders it again from the manifest.
  *
  * ## Why the full model id is resolved live
  *
@@ -61,17 +59,17 @@ import {
 	computeModelsStatus,
 	validateModelsConfig,
 } from "./models-core.js";
-import { materializeProfile } from "./profile-materializer.js";
-import { resolveAllProfiles, resolveProfile } from "./resolver.js";
+import { regenerateLiveFiles } from "./profile-activate.js";
+import { activeProfile } from "./profile-live.js";
+import { prepareProfileWrite } from "./profile-state.js";
 import { readSettingsFile, updateSettingsFile } from "./settings-file.js";
-import { activeProfile, syncProfileLink } from "./symlink-manager.js";
 
 /** `<projectPath>/.claude/models.json` — what the hook looks for. */
 export function configPath(projectPath: string): string {
 	return path.join(projectPath, ".claude", "models.json");
 }
 
-/** `<projectPath>/.claude/settings.json` — a symlink when a profile is active. */
+/** `<projectPath>/.claude/settings.json` — rendered from the profile when one is active. */
 function settingsPathFor(projectPath: string): string {
 	return path.join(projectPath, ".claude", "settings.json");
 }
@@ -368,8 +366,9 @@ export interface ApplyModelPresetResult {
  *
  * Validation comes first: an invalid config makes every subagent spawn fail, so
  * it must never reach disk. After that the order of the numbered steps below is
- * load-bearing — the manifest is written before materialization because
- * materialization regenerates `_profiles/<n>/` FROM the manifest, and the hook
+ * load-bearing — Claude Code's edits are absorbed before the manifest is
+ * written, the manifest is written before the live files because they are
+ * rendered FROM it, and the hook
  * is registered last because a hook pointing at a config that failed to write is
  * worse than no hook at all.
  */
@@ -405,10 +404,14 @@ export async function applyModelPreset(
 	if (Object.keys(manifest.profiles).length === 0 && args.ensureManifest) {
 		manifest = (await args.ensureManifest(projectPath)) ?? manifest;
 	}
+	// 2. The gate: anything Claude Code wrote to the live files goes into the
+	// profile first, so the regeneration below replaces nothing unrecorded —
+	// and a live file that does not parse stops everything, unwritten.
+	await prepareProfileWrite(projectPath);
 	const profile = await activeProfile(projectPath);
 
-	// 2. Record BOTH halves in the manifest: the routing, and the settings it
-	// implies. Without the settings half the next `magus install` rewrites
+	// 3. Record BOTH halves in the manifest: the routing, and the settings it
+	// implies. Without the settings half the next activation renders
 	// settings.json from the manifest and silently reverts the main thread's
 	// model — the routing would keep working and the orchestrator would not.
 	const recordedInManifest = await updateProfileEntry(
@@ -420,38 +423,23 @@ export async function applyModelPreset(
 		},
 	);
 
-	// 3. Regenerate the profile dir from the manifest, then point
-	// .claude/models.json at it. Only the models link is touched: repointing all
-	// four here would replace a project's real .mcp.json with a symlink as a side
-	// effect of choosing a model.
+	// 4. The live files. With a profile active, settings.json and models.json
+	// are rendered from the manifest just written. Without one, models.json is
+	// a plain file and settings.json is edited in place.
 	if (recordedInManifest && profile) {
-		// Re-read: `manifest` above predates the write, so resolving from it would
-		// materialize the OLD entry — which, having no `models`, would delete the
-		// file this call exists to create.
-		const written = await readManifest(projectPath);
-		await materializeProfile(
-			profile,
-			await resolveProfile(written, profile, { binResolver: noBins }),
-			projectPath,
-			await unionPluginIds(projectPath),
-		);
-		await syncProfileLink(profile, "models", projectPath);
+		await regenerateLiveFiles(projectPath);
 	} else {
-		// No profile: models.json is a plain committed-alongside file.
 		await fs.outputFile(
 			configPath(projectPath),
 			`${JSON.stringify(config, null, 2)}\n`,
 		);
+		await updateSettingsFile(settingsPath, (settings) => {
+			for (const [key, value] of Object.entries(patch.set)) {
+				settings[key] = value;
+			}
+		});
 	}
 
-	// 4. The live settings file (a symlink into the profile when one is active,
-	// so this lands in the same place materialization just wrote).
-	await updateSettingsFile(settingsPath, (settings) => {
-		for (const [key, value] of Object.entries(patch.set)) {
-			settings[key] = value;
-		}
-	});
-
 	// 5. Without this, nothing routes.
 	const hook = await registerAgentModelHook();
 
@@ -480,6 +468,8 @@ export async function clearModels(projectPath: string): Promise<void> {
 			)
 		: [];
 
+	// The gate first; a live file that does not parse stops everything.
+	await prepareProfileWrite(projectPath);
 	const profile = await activeProfile(projectPath);
 	const removed = await updateProfileEntry(projectPath, profile, (entry) => {
 		// biome-ignore lint/performance/noDelete: absence is the state, not undefined
@@ -493,21 +483,14 @@ export async function clearModels(projectPath: string): Promise<void> {
 		}
 	});
 
+	// With a profile active, rendering from an entry with no `models` REMOVES
+	// .claude/models.json — that is the whole mechanism by which `off` is off.
 	if (removed && profile) {
-		// Re-materializing with no `models` in the closure DELETES
-		// _profiles/<n>/models.json, and the relink then removes the now-dangling
-		// .claude/models.json. That is the whole mechanism by which `off` is off.
-		const manifest = await readManifest(projectPath);
-		await materializeProfile(
-			profile,
-			await resolveProfile(manifest, profile, { binResolver: noBins }),
-			projectPath,
-			await unionPluginIds(projectPath),
-		);
-		await syncProfileLink(profile, "models", projectPath);
+		await regenerateLiveFiles(projectPath);
+		return;
 	}
-	await fs.remove(configPath(projectPath));
 
+	await fs.remove(configPath(projectPath));
 	const settingsPath = settingsPathFor(projectPath);
 	if (await fs.pathExists(settingsPath)) {
 		await updateSettingsFile(settingsPath, (settings) => {
@@ -543,26 +526,6 @@ function unclaimModelSettings(
 	}
 }
 
-/**
- * Materialization needs no binary requirements — it writes settings, mcp,
- * models and skills, and reads none of `closure.bins`. Skipping the resolver's
- * per-plugin `plugin.json` reads keeps `models use` off the marketplace cache
- * entirely.
- */
-const noBins = async () => [];
-
-/**
- * The manifest-wide union of plugin ids, which `materializeProfile` needs to
- * keep writing the explicit `false` entries that make `profile switch`
- * exclusive. Re-materializing without it would silently make switching additive
- * again — a routing change must not have that side effect.
- */
-async function unionPluginIds(projectPath: string): Promise<string[]> {
-	const manifest = await readManifest(projectPath);
-	const union = await resolveAllProfiles(manifest, { binResolver: noBins });
-	return Object.keys(union.plugins);
-}
-
 // ─── Status ───────────────────────────────────────────────────────────────────
 
 /** What `magus models status` and `magus doctor` report. */
@@ -596,7 +559,7 @@ async function readSettingsFileSafely(
 	}
 }
 
-/** Re-apply the config already on disk. Used by `doctor --fix` to clear drift. */
+/** Re-apply the config already on disk. Used by `doctor --fix` to repair settings the config implies. */
 export async function reapplyModels(
 	projectPath: string,
 ): Promise<ApplyModelPresetResult | null> {