magus-cli 7.5.0 → 7.5.1

package/src/cli/doctor.ts

@@ -46,16 +46,17 @@ import {
 	type RepoRootCache,
 	pickLoadedEntry,
 } from "../services/plugin-resolution.js";
-import {
-	trackedGeneratedFiles,
-	untrackCommand,
-} from "../services/profile-activate.js";
+import { trackedGeneratedFiles } from "../services/profile-activate.js";
 import {
 	LIVE_FILE_KEYS,
 	liveKind,
 	livePath,
 	readActiveMarker,
 } from "../services/profile-live.js";
+import {
+	describeDependencies,
+	renderProfile,
+} from "../services/profile-render.js";
 import { inspectManagedSkills } from "../services/profile-skills.js";
 import {
 	type ActiveProfileCheck,
@@ -66,6 +67,10 @@ import {
 	switchHint,
 } from "../services/profile-state.js";
 import { resolveAllProfiles } from "../services/resolver.js";
+import {
+	GitCheckError,
+	untrackCommand,
+} from "../services/tracked-live-files.js";
 import type {
 	ClaudeSettings,
 	InstalledPluginsRegistry,
@@ -529,13 +534,41 @@ export async function reportProfileState(
 		} else if (check.state === "active") {
 			console.log(`✓ Active profile "${check.profile}" is in place.`);
 		}
+		// Plugin dependencies: a dependency the profile turns off stops a plugin
+		// loading; a plugin.json that cannot be read leaves its dependencies
+		// unknown, and they were not enabled.
+		const manifest = await readManifest(projectPath);
+		const { dependencies } = manifest.profiles[check.profile]
+			? await renderProfile(manifest, check.profile, projectPath)
+			: { dependencies: undefined };
+		for (const line of describeDependencies(
+			dependencies && { ...dependencies, unreadable: [] },
+			check.profile,
+		)) {
+			console.log(`✗ ${line}`);
+			unfixable++;
+		}
+		for (const line of describeDependencies(
+			dependencies && { ...dependencies, blocked: [] },
+			check.profile,
+		)) {
+			console.log(`⚠ ${line}`);
+		}
 	}
 
 	// A .gitignore entry does not untrack a file committed before it. Report
 	// only: magus never runs git rm.
-	for (const tracked of await trackedGeneratedFiles(projectPath)) {
+	let tracked: string[] = [];
+	try {
+		tracked = await trackedGeneratedFiles(projectPath);
+	} catch (error) {
+		if (!(error instanceof GitCheckError)) throw error;
+		console.log(`✗ ${error.message}`);
+		unfixable++;
+	}
+	for (const rel of tracked) {
 		console.log(
-			`✗ ${tracked} is generated from profiles.json but tracked by git. Fix: \`${untrackCommand(tracked)}\`, then commit.`,
+			`✗ ${rel} is generated from profiles.json but tracked by git. Fix: \`${untrackCommand(rel)}\`, then commit.`,
 		);
 		unfixable++;
 	}

package/src/cli/install.ts

@@ -27,6 +27,10 @@ import {
 } from "../services/install-plan.js";
 import { readManifest, validateManifest } from "../services/manifest.js";
 import { registerClosureMarketplaces } from "../services/marketplace-sync.js";
+import {
+	clearMarketplaceCache,
+	readInstalledVersionForScope,
+} from "../services/plugin-manager.js";
 import { reportDisplaced } from "../services/profile-activate.js";
 import { activeProfile } from "../services/profile-live.js";
 import {
@@ -40,6 +44,7 @@ import {
 	binInstallCommand,
 	detectToolchains,
 } from "../services/toolchain.js";
+import { bringLoadForward } from "../services/update-engine.js";
 import type { ResolvedBin, ResolvedClosure } from "../types/index.js";
 import { formatCommand, resolveExecutable } from "../utils/command-utils.js";
 import { runCommand, runShellScript } from "../utils/run.js";
@@ -155,6 +160,41 @@ async function installPlugins(closure: ResolvedClosure): Promise<void> {
 	}
 }
 
+/**
+ * After the installs: every plugin must LOAD the version installed here, not
+ * an older one from a registry row this repository's other checkouts left
+ * first in line. Where it does not, the same stale-load repair `magus update`
+ * chains is run, and reported either way.
+ */
+async function bringLoadsForward(
+	pluginIds: readonly string[],
+	projectPath: string,
+): Promise<void> {
+	for (const pluginId of pluginIds) {
+		const here = await readInstalledVersionForScope(
+			pluginId,
+			"project",
+			projectPath,
+		);
+		if (!here) continue;
+		const forward = await bringLoadForward(pluginId, here, projectPath);
+		if (!forward) continue;
+		if (forward.ok) {
+			console.log(
+				`✓ ${pluginId}: Claude Code now loads v${here} here (${forward.rewritten} older record${
+					forward.rewritten === 1 ? "" : "s"
+				} moved forward)`,
+			);
+		} else {
+			console.warn(
+				`⚠ ${pluginId}: installed v${here}, but Claude Code still loads v${
+					forward.loaded ?? "an older version"
+				} here — ${forward.error ?? "the older records could not be moved forward"}`,
+			);
+		}
+	}
+}
+
 async function installBins(bins: ResolvedBin[]): Promise<void> {
 	for (const bin of bins) {
 		if (await resolveExecutable(bin.name)) {
@@ -261,10 +301,13 @@ export async function runInstallCommand(
 		return 1;
 	}
 
-	// Closure: a single profile, or the union of all.
-	const closure = flags.profile
-		? await resolveProfile(manifest, flags.profile)
-		: await resolveAllProfiles(manifest);
+	// Closure: a single profile, or the union of all — with every plugin the
+	// enabled ones depend on.
+	const resolveClosure = () =>
+		flags.profile
+			? resolveProfile(manifest, flags.profile)
+			: resolveAllProfiles(manifest);
+	let closure = await resolveClosure();
 
 	if (flags.check) {
 		return runCheck(closure, manifest.strictVersions === true);
@@ -295,6 +338,25 @@ export async function runInstallCommand(
 
 	await ensureToolchains(closure, flags.yes);
 	await registerClosureMarketplaces(closure.marketplaces);
+	// A marketplace added just now carries the plugin.json files that name
+	// each plugin's dependencies; resolve again so those are installed too.
+	clearMarketplaceCache();
+	const before = new Set(Object.keys(closure.plugins));
+	closure = await resolveClosure();
+	const found = Object.keys(closure.plugins).filter((id) => !before.has(id));
+	if (found.length > 0) {
+		console.log(
+			`Also installing what those plugins depend on: ${found.join(", ")}`,
+		);
+	}
+	const unreadable = closure.dependencies?.unreadable ?? [];
+	if (unreadable.length > 0) {
+		console.warn(
+			`⚠ Could not read the plugin.json of ${unreadable.join(", ")} — whatever ${
+				unreadable.length === 1 ? "it depends" : "they depend"
+			} on is not installed by this run`,
+		);
+	}
 
 	const current = await activeProfile(projectPath);
 	const activeId =
@@ -326,8 +388,10 @@ export async function runInstallCommand(
 	// meantime is kept, only the install's own records are discarded, and a
 	// Ctrl-C leaves the flag for the next command to do the same.
 	await withCliBookkeeping(projectPath, () => installPlugins(closure), {
+		installable: Object.keys(closure.plugins),
 		report: (line) => console.log(noteLine(line)),
 	});
+	await bringLoadsForward(Object.keys(closure.plugins), projectPath);
 	await installBins(closure.bins);
 
 	if (activeId) {

package/src/cli/router.ts

@@ -8,6 +8,7 @@
 
 import type { ThemeMode } from "@opentui/core";
 import { SettingsParseError } from "../services/settings-file.js";
+import { LiveFileRefusal } from "../services/tracked-live-files.js";
 import { checkForUpdates } from "../services/version-check.js";
 import { type ThemeEnv, parseThemeWord } from "../ui/theme-resolve.js";
 import { profileGate, reportUnparseable } from "./bootstrap.js";
@@ -223,6 +224,12 @@ export async function route(
 			reportUnparseable(error);
 			return HANDLED(1);
 		}
+		// A live file git tracks (or git could not say): nothing was written,
+		// and the message says what to do. A refusal, not a crash.
+		if (error instanceof LiveFileRefusal) {
+			console.error(error.message);
+			return HANDLED(1);
+		}
 		throw error;
 	}
 }

package/src/cli/update.ts

@@ -607,6 +607,9 @@ export async function runUpdateCommand(
 		projectPath,
 		() => applyPlan(plan, projectPath, { report: skills.report }),
 		{
+			// Only the active profile's plugins are this run's to install, so
+			// only their records are the CLI's.
+			installable: Object.keys(closure.plugins),
 			beforeReconcile: () =>
 				recordRefetchedSkills(projectPath, skills.fetched()),
 			report: (line) => reconciledLines.push(line),

package/src/services/claude-cli.ts

@@ -10,6 +10,7 @@
  */
 
 import { execFile } from "node:child_process";
+import path from "node:path";
 import { promisify } from "node:util";
 import { defaultMarketplaces } from "../data/marketplaces.js";
 import { which } from "../utils/command-utils.js";
@@ -19,6 +20,7 @@ import {
 	removeLocalInstalledPluginVersion,
 } from "./claude-settings.js";
 import { removeInstalledPluginVersion } from "./plugin-manager.js";
+import { refuseTrackedLiveFiles } from "./tracked-live-files.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -138,6 +140,23 @@ async function execPluginCommand(
 	}
 }
 
+/**
+ * Every `claude plugin … --scope project` command writes the project's
+ * `.claude/settings.json` (its enabledPlugins entry). In a project with
+ * profiles that file is generated; where git tracks it, refuse — before the
+ * CLI runs — rather than let the CLI write it (see `tracked-live-files.ts`).
+ * The CLI works on the current directory.
+ */
+async function refuseProjectSettingsWrite(
+	scope: PluginScope,
+	projectPath: string = process.cwd(),
+): Promise<void> {
+	if (scope !== "project") return;
+	await refuseTrackedLiveFiles(projectPath, [
+		path.join(".claude", "settings.json"),
+	]);
+}
+
 /**
  * Install a plugin using claude CLI
  * Handles enabling + version tracking + cache copy in one shot.
@@ -154,6 +173,7 @@ export async function installPlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope);
 	// 60s, matching update and repair. Before the install/update split this path
 	// ran through `updatePlugin`'s 60s budget; leaving it on the 30s default
 	// would have quietly halved the time a fresh install — the SLOWEST of the
@@ -172,6 +192,7 @@ export async function uninstallPlugin(
 	scope: PluginScope = "user",
 	projectPath?: string,
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope, projectPath);
 	try {
 		await execClaude(["plugin", "uninstall", pluginId, "--scope", scope]);
 	} catch {
@@ -224,6 +245,7 @@ export async function enablePlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope);
 	await execClaude(["plugin", "enable", pluginId, "--scope", scope]);
 }
 
@@ -234,6 +256,7 @@ export async function disablePlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope);
 	await execClaude(["plugin", "disable", pluginId, "--scope", scope]);
 }
 
@@ -276,6 +299,7 @@ export async function updatePlugin(
 	pluginId: string,
 	scope: PluginScope = "user",
 ): Promise<void> {
+	await refuseProjectSettingsWrite(scope);
 	await execPluginCommand("update", pluginId, scope, 60000);
 }
 

package/src/services/claude-settings.ts

@@ -37,6 +37,7 @@ import {
 	writableList,
 	writableMap,
 } from "./settings-file.js";
+import { refuseTrackedLiveFiles } from "./tracked-live-files.js";
 
 /**
  * What every reader below throws for a file that exists but does not parse.
@@ -148,6 +149,11 @@ export async function writeSettings(
 	settings: ClaudeSettings,
 	projectPath?: string,
 ): Promise<void> {
+	// In a project with profiles this file is generated: never written where
+	// git tracks it (see `tracked-live-files.ts`).
+	await refuseTrackedLiveFiles(projectPath ?? process.cwd(), [
+		getSettingsPath(projectPath),
+	]);
 	await refuseUnwritableFile(getSettingsPath(projectPath));
 	const claudeDir = await ensureClaudeDir(projectPath);
 	const settingsPath = path.join(claudeDir, SETTINGS_FILE);
@@ -191,6 +197,7 @@ export async function writeMcpConfig(
 	projectPath?: string,
 ): Promise<void> {
 	const mcpPath = getMcpConfigPath(projectPath);
+	await refuseTrackedLiveFiles(projectPath ?? process.cwd(), [mcpPath]);
 	await refuseUnwritableFile(mcpPath);
 	await fs.writeJson(mcpPath, config, { spaces: 2 });
 }
@@ -2143,6 +2150,26 @@ export async function repairAllStaleLoads(
 	return out;
 }
 
+/**
+ * The version Claude Code's loader resolves for `pluginId` in `projectPath`:
+ * the first relevant registry row whose installPath exists (`pickLoadedEntry`).
+ * Null when no row resolves, or the registry cannot be read.
+ */
+export async function loadedVersionHere(
+	pluginId: string,
+	projectPath: string,
+	root: string = pluginsDir(),
+): Promise<string | null> {
+	try {
+		const registry = await readInstalledPluginsRegistry(root);
+		const rows = registry.plugins?.[pluginId];
+		if (!Array.isArray(rows) || rows.length === 0) return null;
+		return pickLoadedEntry(rows, projectPath)?.version ?? null;
+	} catch {
+		return null;
+	}
+}
+
 /**
  * What one {@link repairStaleLoad} attempt did, and whether it worked.
  *

package/src/services/git-worktree.ts

@@ -24,36 +24,67 @@
  */
 
 import { spawn } from "node:child_process";
+import { lstat } from "node:fs/promises";
 import path from "node:path";
 
 function git(
 	cwd: string,
 	args: string[],
-): Promise<{ code: number; out: string }> {
+): Promise<{ code: number; out: string; err: string }> {
 	return new Promise((resolve) => {
 		const child = spawn("git", args, {
 			cwd,
-			stdio: ["ignore", "pipe", "ignore"],
+			stdio: ["ignore", "pipe", "pipe"],
 		});
 		let out = "";
+		let err = "";
 		child.stdout.on("data", (d) => {
 			out += String(d);
 		});
+		child.stderr.on("data", (d) => {
+			err += String(d);
+		});
+		const settle = (code: number, text: string, why: string) => {
+			clearTimeout(timer);
+			resolve({ code, out: text, err: why });
+		};
 		// Never let a wedged git block the UI.
 		const timer = setTimeout(() => {
 			child.kill();
-			resolve({ code: -1, out: "" });
+			settle(-1, "", `git ${args[0]} did not answer within 5 seconds`);
 		}, 5000);
 		timer.unref?.();
-		const settle = (code: number, text: string) => {
-			clearTimeout(timer);
-			resolve({ code, out: text });
-		};
-		child.on("error", () => settle(-1, ""));
-		child.on("close", (code) => settle(code ?? -1, out.trim()));
+		child.on("error", (error) =>
+			settle(-1, "", `could not run git: ${error.message}`),
+		);
+		child.on("close", (code) => settle(code ?? -1, out.trim(), err.trim()));
 	});
 }
 
+/**
+ * git was asked about a work tree and gave no answer: it timed out, is not
+ * installed, or refused the repository. `detail` is git's own message.
+ */
+export class GitQueryError extends Error {
+	constructor(readonly detail: string) {
+		super(detail);
+		this.name = "GitQueryError";
+	}
+}
+
+/** Is `dir`, or a directory above it, a git work tree (holds a `.git`)? */
+async function insideWorkTree(dir: string): Promise<boolean> {
+	for (let at = path.resolve(dir); ; at = path.dirname(at)) {
+		try {
+			await lstat(path.join(at, ".git"));
+			return true;
+		} catch {
+			// Not here; try the parent.
+		}
+		if (path.dirname(at) === at) return false;
+	}
+}
+
 /**
  * Session cache. Keyed by resolved project path — the repository layout cannot
  * change under a running magus in any way worth tracking, and the resolution
@@ -65,6 +96,58 @@ export function clearWorktreeCache(): void {
 	cache.clear();
 }
 
+/**
+ * The paths (relative to `projectPath`) that git tracks. A path in `files` is
+ * tracked when git has exactly that entry — a symlink is an entry too; a path
+ * in `dirs` when git tracks any file under it. Empty outside a work tree.
+ *
+ * Throws {@link GitQueryError} when there IS a `.git` at or above
+ * `projectPath` and git still fails — a timeout, git missing, or git refusing
+ * the repository (`detected dubious ownership`, exit 128). "Nothing is
+ * tracked" is not an answer git gave there, and a caller that believed it
+ * would write a tracked file.
+ *
+ * The distinction matters for `.claude/skills`: as a directory of committed
+ * custom skills it has tracked files under it, which says nothing about
+ * whether the path ITSELF (an older layout's symlink) was committed.
+ */
+export async function trackedByGit(
+	projectPath: string,
+	files: readonly string[],
+	dirs: readonly string[] = [],
+): Promise<Set<string>> {
+	const out = new Set<string>();
+	const relPaths = [...files, ...dirs];
+	if (relPaths.length === 0) return out;
+	// One call for every path: this runs on every magus command that touches
+	// profile state, and a spawn per path adds up. `ls-files` prints each
+	// tracked FILE matching the pathspecs, so a directory shows as its files.
+	const {
+		code,
+		out: listed,
+		err,
+	} = await git(projectPath, ["ls-files", "-z", "--", ...relPaths]);
+	if (code !== 0) {
+		if (!(await insideWorkTree(projectPath))) return out; // Nothing to track.
+		throw new GitQueryError(err || `git ls-files exited with code ${code}`);
+	}
+	const entries = new Set(listed.split("\0").filter(Boolean));
+	const norm = (rel: string) => rel.split(path.sep).join("/");
+	for (const rel of files) {
+		if (entries.has(norm(rel))) out.add(rel);
+	}
+	for (const rel of dirs) {
+		const prefix = `${norm(rel)}/`;
+		for (const entry of entries) {
+			if (entry.startsWith(prefix)) {
+				out.add(rel);
+				break;
+			}
+		}
+	}
+	return out;
+}
+
 /**
  * Is `relPath` (relative to `projectPath`) tracked by git? For a directory,
  * true when any file under it is tracked.