magus-cli 7.7.0 → 7.8.0

package/src/services/profile-startup.ts

@@ -69,11 +69,7 @@ import {
 	findEnclosingManifest,
 	readManifest,
 } from "./manifest.js";
-import {
-	type ActivationResult,
-	type ProfileChoice,
-	activationNotes,
-} from "./profile-activate.js";
+import type { ActivationResult, ProfileChoice } from "./profile-activate.js";
 import { freeProfileId } from "./profile-adopt.js";
 import {
 	activeProfile,
@@ -311,36 +307,29 @@ export async function oldFormatNeed(
 	};
 }
 
-/** What the TUI shows at startup, beyond the question (if any). */
+/** The TUI's startup: the question (if any), and what the gate refused. */
 export interface ProfileStartup {
 	need: ProfileStartupNeed;
 	/**
-	 * One line per thing the gate did: absorbed edits, regeneration, repairs.
-	 * Not what an activation reported — see `activations`.
-	 */
-	notices: string[];
-	/**
-	 * One line per thing the gate REFUSED — the lines the CLI stops on. Kept
-	 * apart from `notices` because a refusal can leave detection reading `ok`:
-	 * an old layout whose settings file does not parse is not converted, yet
-	 * still names its profile, so only this says the update did not happen.
+	 * One line per thing the gate REFUSED — the lines the CLI stops on. A
+	 * refusal can leave detection reading `ok`: an old layout whose settings
+	 * file does not parse is not converted, yet still names its profile, so only
+	 * this says the update did not happen.
 	 */
 	problems: string[];
 	/**
-	 * The activations the gate ran (a re-render, a format update). Handed over
-	 * as results rather than lines because the CLI's lines are the wrong words
-	 * for the TUI: they name plugin.json and backups, and they say "will not
-	 * load" in a line nothing marks as a warning. The TUI words them itself, in
-	 * user terms and with a tone (`activationWarnings` in the startup hook).
+	 * Every activation the gate ran — a re-render after profiles.json changed,
+	 * an older format converted — so the TUI can say what one of them could
+	 * not do. Absent is none.
 	 */
-	activations: ActivationResult[];
+	activations?: ActivationResult[];
 }
 
 /**
  * The TUI's startup: the same gate every CLI command runs, then detection.
  *
- * A failure in the gate never blocks the TUI — its message becomes a notice
- * and detection still runs, so the user is asked whatever is left to ask.
+ * A failure in the gate never blocks the TUI — its message is kept in
+ * `problems` and detection still runs, so the user is asked whatever is left.
  */
 export async function prepareProfileStartup(
 	projectPath: string,
@@ -354,21 +343,13 @@ export async function prepareProfileStartup(
 	if (!opts.convert) {
 		const format = await oldFormatNeed(projectPath);
 		if (format !== null) {
-			return { need: format, notices: [], problems: [], activations: [] };
+			return { need: format, problems: [] };
 		}
 	}
-	const notices: string[] = [];
 	const problems: string[] = [];
 	const activations: ActivationResult[] = [];
 	try {
 		const prep = await prepareProfileState(projectPath);
-		// The gate's lines, less the ones its activations contributed: those
-		// reach the TUI as `activations`, and passing both would say the same
-		// thing twice — once in the CLI's words, as if it were a success.
-		const fromActivations = new Set(
-			prep.activations.flatMap((a) => activationNotes(a, { tracked: false })),
-		);
-		notices.push(...prep.lines.filter((line) => !fromActivations.has(line)));
 		problems.push(...prep.problems);
 		activations.push(...prep.activations);
 	} catch (error) {
@@ -378,19 +359,18 @@ export async function prepareProfileStartup(
 	}
 	return {
 		need: await detectProfileStartupNeed(projectPath),
-		notices,
 		problems,
-		activations,
+		...(activations.length > 0 ? { activations } : {}),
 	};
 }
 
 /**
- * What the TUI shows once "Update it now" has run: another question, a notice
- * line, or an error modal.
+ * What the TUI does once "Update it now" has run: ask another question, carry
+ * on, or show an error modal.
  */
 export type FormatUpdateOutcome =
 	| { kind: "ask"; need: ProfileStartupNeed }
-	| { kind: "updated"; notice: string }
+	| { kind: "updated" }
 	| { kind: "failed"; title: string; message: string };
 
 /**
@@ -410,12 +390,7 @@ export function formatUpdateOutcome(
 		};
 	}
 	if (!needsNothing(result.need)) return { kind: "ask", need: result.need };
-	// One line, not the gate's notices: those are the conversion's working log
-	// (edits carried over, the old format's backup), and the result the user
-	// cares about is only that the update is done. What the conversion's
-	// activation warns about is NOT dropped: the caller words it from
-	// `result.activations`, as it does for any activation.
-	return { kind: "updated", notice: "Profile format updated" };
+	return { kind: "updated" };
 }
 
 // ─── What to offer, as data both surfaces render ─────────────────────────────

package/src/services/profile-state.ts

@@ -26,8 +26,9 @@
  */
 
 import path from "node:path";
-import type { ProfileManifest } from "../types/index.js";
-import { readManifest, writeManifest } from "./manifest.js";
+import type { ProfileManifest, ProfileManifestEntry } from "../types/index.js";
+import { selectProfileId } from "./active-closure.js";
+import { readManifest, updateProfileEntry, writeManifest } from "./manifest.js";
 import {
 	type ReconcileResult,
 	absorbOlderLayout,
@@ -47,6 +48,7 @@ import {
 	type ActiveMarker,
 	LIVE_FILE_KEYS,
 	MACHINE_LOCAL_SETTINGS_KEYS,
+	activeProfile,
 	folderHash,
 	hasCurrentMarker,
 	hasOlderLayout,
@@ -68,6 +70,7 @@ import {
 	inspectManagedSkills,
 	skillFolder,
 } from "./profile-skills.js";
+import { resolveExtends } from "./resolver.js";
 import type { SettingsParseError } from "./settings-file.js";
 
 export type ActiveProfileCheck =
@@ -652,3 +655,70 @@ export async function withCliBookkeeping<T>(
 		for (const line of reconciled.lines) opts.report?.(line);
 	}
 }
+
+/** Whether a profile entry, `extends` included, turns the plugin on. */
+function profileLists(
+	entry: ProfileManifestEntry | undefined,
+	pluginId: string,
+): boolean {
+	if (!entry) return false;
+	const value = resolveExtends(entry).plugins?.[pluginId];
+	return value !== undefined && value !== false;
+}
+
+/**
+ * Stop a profile listing `pluginId`, so its next activation does not turn the
+ * plugin back on. Answers whether the profile no longer lists it — read back
+ * from profiles.json after the write, never assumed.
+ *
+ * For a deprecated plugin `magus update` removes. The uninstall that runs first
+ * deletes the plugin from this project's settings (measured, Claude Code
+ * 2.1.284), and `reconcileActiveProfile` would absorb that into the ACTIVE
+ * profile at the next entry point — but only there, and only for the active
+ * one. The Plugins screen's `a` runs no reconcile afterwards, so the screen kept
+ * the plugin declared and planned the same removal again; `magus update <name>`
+ * plans a profile that is not active, whose live files nothing absorbs from;
+ * and a profile declaring a plugin that is installed nowhere has no settings
+ * change to absorb at all. So the entry is edited here, directly, through
+ * {@link updateProfileEntry} — the editor `magus models use` writes through.
+ * The reconcile that follows (`withCliBookkeeping`, or the next entry point)
+ * finds profiles.json and the live files agreeing, and regenerates from it.
+ *
+ * `profile` undefined means the active one, chosen as the Plugins screen and
+ * `magus update` choose it; null means no profile, which lists nothing.
+ *
+ * Deletes the entry's own pin. When `extends` supplies the plugin, the pin
+ * becomes `false`, which is how an entry turns an inherited plugin off.
+ * Throws `SettingsParseError` when profiles.json exists and does not parse.
+ */
+export async function removePluginFromProfile(
+	projectPath: string,
+	pluginId: string,
+	profile?: string | null,
+): Promise<boolean> {
+	const manifest = await readManifest(projectPath);
+	const id =
+		profile === undefined
+			? selectProfileId(
+					Object.keys(manifest.profiles),
+					undefined,
+					await activeProfile(projectPath),
+				)
+			: profile;
+	if (!id || !profileLists(manifest.profiles[id], pluginId)) return true;
+
+	await updateProfileEntry(projectPath, id, (entry) => {
+		const plugins = { ...(entry.plugins ?? {}) };
+		delete plugins[pluginId];
+		if (profileLists({ ...entry, plugins }, pluginId))
+			plugins[pluginId] = false;
+		if (Object.keys(plugins).length > 0) entry.plugins = plugins;
+		// biome-ignore lint/performance/noDelete: absent, not undefined, in profiles.json
+		else delete entry.plugins;
+	});
+
+	return !profileLists(
+		(await readManifest(projectPath)).profiles[id],
+		pluginId,
+	);
+}

package/src/services/resolver.ts

@@ -60,6 +60,7 @@ export async function resolveDependencies(
 	read: PluginDependencyReader,
 ): Promise<DependencyReport> {
 	const derived: string[] = [];
+	const requiredBy: Record<string, string> = {};
 	const unreadable: string[] = [];
 	const blocked: DependencyReport["blocked"] = [];
 	const queue = [...enabled];
@@ -75,13 +76,105 @@ export async function resolveDependencies(
 				blocked.push({ plugin: id, dependency });
 				continue;
 			}
+			// Every edge, including to a plugin the profile names itself: "still
+			// required" is a fact about the plugin that needs it, not about how
+			// the profile came to enable it. Recording only derived ones let a
+			// no-longer-published dependency the profile ALSO listed be planned
+			// for removal from under the plugin that needs it.
+			if (dependency !== id && !Object.hasOwn(requiredBy, dependency)) {
+				requiredBy[dependency] = id;
+			}
 			if (seen.has(dependency)) continue;
 			seen.add(dependency);
 			derived.push(dependency);
 			queue.push(dependency);
 		}
 	}
-	return { derived: derived.sort(), unreadable: unreadable.sort(), blocked };
+	return {
+		derived: derived.sort(),
+		requiredBy,
+		unreadable: unreadable.sort(),
+		blocked,
+	};
+}
+
+/**
+ * Which plugin requires each plugin, for the planner's STILL-REQUIRED rule:
+ * the profile's edges (`DependencyReport.requiredBy`) and, beside them, the
+ * edges every INSTALLED plugin's own plugin.json declares.
+ *
+ * The profile alone is not enough. A plugin installed at USER scope, or in a
+ * project with no profile at all, is planned too — and without its edges a
+ * dependency it needs that stopped being published was planned for removal
+ * from under it. One plugin.json read per installed plugin, the same read the
+ * profile's resolve makes. The profile's answer wins where both name one.
+ *
+ * ONE function for `magus update` and the Plugins screen, so the two plan the
+ * same removals.
+ */
+export async function requiredByHere(
+	profileRequiredBy: Readonly<Record<string, string>> | undefined,
+	installedIds: readonly string[],
+	projectPath?: string,
+	read: PluginDependencyReader = readPluginDependencies,
+): Promise<Record<string, string>> {
+	const all = await requirersHere(
+		profileRequiredBy,
+		installedIds,
+		projectPath,
+		read,
+	);
+	const first: Record<string, string> = {};
+	for (const [dependency, requirers] of Object.entries(all)) {
+		const [requirer] = requirers;
+		if (requirer) first[dependency] = requirer;
+	}
+	return first;
+}
+
+/**
+ * {@link requiredByHere} with EVERY requirer of each plugin, not only the
+ * first — what the planner needs to remove deprecated plugins that require
+ * one another together, while keeping one that anything staying still needs.
+ * The profile's requirer comes first; the installed plugins' follow, sorted.
+ *
+ * This is what `magus update` and the Plugins screen plan with.
+ */
+export async function requirersHere(
+	profileRequiredBy: Readonly<Record<string, string>> | undefined,
+	installedIds: readonly string[],
+	projectPath?: string,
+	read: PluginDependencyReader = readPluginDependencies,
+): Promise<Record<string, string[]>> {
+	const declared = await Promise.all(
+		[...installedIds].sort().map(async (id) => {
+			try {
+				return [id, await read(id, projectPath)] as const;
+			} catch {
+				return [id, null] as const;
+			}
+		}),
+	);
+	const edges: Record<string, string[]> = {};
+	const add = (dependency: string, requirer: string, front = false) => {
+		if (dependency === requirer) return;
+		const list = (
+			Object.hasOwn(edges, dependency) ? (edges[dependency] as string[]) : []
+		).filter((r) => !front || r !== requirer);
+		if (list.includes(requirer)) return;
+		if (front) list.unshift(requirer);
+		else list.push(requirer);
+		edges[dependency] = list;
+	};
+	for (const [id, dependencies] of declared) {
+		for (const dependency of dependencies ?? []) add(dependency, id);
+	}
+	for (const [dependency, requirer] of Object.entries(
+		profileRequiredBy ?? {},
+	)) {
+		add(dependency, requirer, true);
+	}
+	return edges;
 }
 
 function hasDependencies(report: DependencyReport): boolean {
@@ -444,6 +537,7 @@ function mergeDependencyReports(
 	);
 	return {
 		derived: [...new Set([...a.derived, ...b.derived])].sort(),
+		requiredBy: { ...b.requiredBy, ...a.requiredBy },
 		unreadable: [...new Set([...a.unreadable, ...b.unreadable])].sort(),
 		blocked: [...blocked.values()],
 	};