magus-cli 7.6.0 → 7.8.0

package/src/services/profile-absorb.ts

@@ -59,6 +59,7 @@ import { readManifest, writeManifest } from "./manifest.js";
 import { validateModelsConfig } from "./models-core.js";
 import {
 	type ActivateOptions,
+	type ActivationResult,
 	activateProfile,
 	activationNotes,
 	releasedCommittedSkillNote,
@@ -588,6 +589,12 @@ export interface ReconcileResult {
 	conflicts: string[];
 	/** Everything worth printing, in order. */
 	lines: string[];
+	/**
+	 * The re-render, when profiles.json changed and the live config was
+	 * generated again. `lines` already carries its CLI wording; this is for a
+	 * surface that words it differently (the TUI's notices).
+	 */
+	activation: ActivationResult | null;
 }
 
 function emptyResult(profile: string | null): ReconcileResult {
@@ -600,6 +607,7 @@ function emptyResult(profile: string | null): ReconcileResult {
 		unreadable: [],
 		conflicts: [],
 		lines: [],
+		activation: null,
 	};
 }
 
@@ -1529,6 +1537,7 @@ export async function reconcileActiveProfile(
 			// command that ran it reports that once, itself, and repeating it here
 			// printed the same warning three times in one `magus update`.
 			notes.push(...activationNotes(activation, { tracked: false }));
+			result.activation = activation;
 		} catch (error) {
 			result.problems.push(
 				error instanceof Error ? error.message : String(error),

package/src/services/profile-activate.ts

@@ -209,7 +209,7 @@ export function releasedCommittedSkillNote(folder: string): string {
 
 /**
  * Lines describing what activation did beyond the switch itself, phrased for
- * both the terminal and the TUI's outcome modal.
+ * the terminal.
  *
  * `tracked: false` leaves the tracked-path notices out, for the CLI, which
  * prints them itself as a warning with the fix beneath it

package/src/services/profile-startup.ts

@@ -69,7 +69,7 @@ import {
 	findEnclosingManifest,
 	readManifest,
 } from "./manifest.js";
-import type { ProfileChoice } from "./profile-activate.js";
+import type { ActivationResult, ProfileChoice } from "./profile-activate.js";
 import { freeProfileId } from "./profile-adopt.js";
 import {
 	activeProfile,
@@ -307,25 +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. */
-	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[];
+	/**
+	 * 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[];
 }
 
 /**
  * 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,
@@ -338,14 +342,16 @@ export async function prepareProfileStartup(
 ): Promise<ProfileStartup> {
 	if (!opts.convert) {
 		const format = await oldFormatNeed(projectPath);
-		if (format !== null) return { need: format, notices: [], problems: [] };
+		if (format !== null) {
+			return { need: format, problems: [] };
+		}
 	}
-	const notices: string[] = [];
 	const problems: string[] = [];
+	const activations: ActivationResult[] = [];
 	try {
 		const prep = await prepareProfileState(projectPath);
-		notices.push(...prep.lines);
 		problems.push(...prep.problems);
+		activations.push(...prep.activations);
 	} catch (error) {
 		if (!(error instanceof SettingsParseError)) {
 			problems.push(error instanceof Error ? error.message : String(error));
@@ -353,15 +359,18 @@ export async function prepareProfileStartup(
 	}
 	return {
 		need: await detectProfileStartupNeed(projectPath),
-		notices,
 		problems,
+		...(activations.length > 0 ? { activations } : {}),
 	};
 }
 
-/** What the TUI shows once "Update it now" has run. */
+/**
+ * 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"; title: string; message: string }
+	| { kind: "updated" }
 	| { kind: "failed"; title: string; message: string };
 
 /**
@@ -381,14 +390,7 @@ export function formatUpdateOutcome(
 		};
 	}
 	if (!needsNothing(result.need)) return { kind: "ask", need: result.need };
-	return {
-		kind: "updated",
-		title: "Profile format updated",
-		message:
-			result.notices.length > 0
-				? result.notices.join("\n")
-				: "This project now uses the current profile format.",
-	};
+	return { kind: "updated" };
 }
 
 // ─── What to offer, as data both surfaces render ─────────────────────────────
@@ -426,9 +428,10 @@ export const UPDATE_FORMAT_VALUE = "update-format";
  * Neither mentions the backup, deliberately. A sentence promising "nothing is
  * deleted — the old files are moved to a backup" raises a question the reader
  * did not have (which files? what was at risk?) and implies data loss, when what
- * changes is settings. Where the displaced files went belongs in the outcome
- * modal AFTER the switch, where it is something to act on rather than a worry to
- * plant beforehand.
+ * changes is settings. The TUI does not name the backup afterwards either: the
+ * backup is magus's own storage, and the user acts on nothing there. Only a
+ * failed activation lists what was moved, because then it is something to act
+ * on (see `describeFailure` in ui/hooks/useProfileStartupModal.ts).
  *
  * No file paths in these strings, deliberately. The TUI modal soft-wraps its
  * message at whatever width the terminal gives it, and OpenTUI treats `.` as a

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 =
@@ -299,6 +302,12 @@ export interface ProfileStatePrep {
 	problems: string[];
 	/** The files behind `problems` that could not be parsed. */
 	unreadable: SettingsParseError[];
+	/**
+	 * Every activation the gate ran, in order: a re-render after profiles.json
+	 * changed, an older layout converted. `lines` already carries them in the
+	 * CLI's words; the TUI words them itself from these.
+	 */
+	activations: ActivationResult[];
 }
 
 /**
@@ -319,11 +328,13 @@ export async function prepareProfileState(
 		lines: [],
 		problems: [],
 		unreadable: [],
+		activations: [],
 	};
 	const take = (r: ReconcileResult) => {
 		out.lines.push(...r.lines.filter((l) => !r.problems.includes(l)));
 		out.problems.push(...r.problems);
 		out.unreadable.push(...r.unreadable);
+		if (r.activation) out.activations.push(r.activation);
 	};
 
 	if (check.state === "active" && check.restored) {
@@ -358,6 +369,7 @@ export async function prepareProfileState(
 			}
 			// Tracked files are the command's to report, once (see profile-absorb).
 			out.lines.push(...activationNotes(result, { tracked: false }));
+			out.activations.push(result);
 		}
 		out.check = { state: "active", profile, restored: false };
 	}
@@ -643,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()],
 	};