magus-cli 7.5.3 → 7.5.4

package/src/services/update-plan.ts

@@ -34,7 +34,11 @@ import type { PluginScope } from "./claude-cli.js";
 import {
 	type PluginInfo,
 	compareVersions,
+	filesMissingScopes,
+	highestInstalledVersion,
+	installedScopeVersions,
 	isBehind,
+	isInstalledAnywhere,
 	isRepairablyBehind,
 } from "./plugin-manager.js";
 import {
@@ -48,7 +52,7 @@ import {
 // ── Plugins ──────────────────────────────────────────────────────────────────
 
 export type PluginUpdateAction =
-	/** Declared by the profile, installed nowhere. */
+	/** Declared by the profile and installed nowhere, or installed with its files missing. */
 	| "install"
 	/** Installed at a version other than the one we should be on. */
 	| "update"
@@ -83,8 +87,8 @@ export type PluginUpdateAction =
 export type PluginReason =
 	/** install: declared by the profile, installed nowhere. */
 	| "absent"
-	/** install: enabled in a settings file, but no registry row in any scope. */
-	| "enabled-not-installed"
+	/** install: installed at a scope, but no version resolves at any installed scope. */
+	| "files-missing"
 	/** unknown: a marketplace we READ does not list it. */
 	| "not-offered"
 	/** unknown: installed, unlisted, and its marketplace contributed no listed ids. */
@@ -127,7 +131,11 @@ export interface PluginUpdateItem {
 	action: PluginUpdateAction;
 	/** Why it is in this state. */
 	reason: PluginReason;
-	/** Scopes holding an install this action must touch. Empty for a fresh install. */
+	/**
+	 * Scopes holding an install this action must touch — for `files-missing`, the
+	 * scopes installed with no version. Empty for an `absent` install, which the
+	 * engine puts at project scope.
+	 */
 	scopes: PluginScope[];
 	/**
 	 * The version installed in each scope BEFORE any work, so an apply can tell
@@ -141,44 +149,12 @@ export interface PluginUpdateItem {
 	note?: string;
 }
 
-/** Scope → installed version, for the three scopes a PluginInfo carries. */
-function scopeVersions(
-	info: PluginInfo | undefined,
-): Array<[PluginScope, string]> {
-	if (!info) return [];
-	const out: Array<[PluginScope, string]> = [];
-	for (const [scope, status] of [
-		["user", info.userScope],
-		["project", info.projectScope],
-		["local", info.localScope],
-	] as const) {
-		if (status?.version) out.push([scope, status.version]);
-	}
-	return out;
-}
-
-/**
- * The highest version installed across scopes, or null.
- *
- * `compareVersions` answers null for an unorderable pair, and null is not
- * `>= 0`, so the reduce keeps the right-hand side when two versions cannot be
- * ranked. "Highest" is not meaningful across commit ids; picking one
- * deterministically is, and every caller only needs *an* installed version.
- */
-function highestInstalled(info: PluginInfo | undefined): string | null {
-	const versions = scopeVersions(info).map(([, v]) => v);
-	if (versions.length === 0) return null;
-	return versions.reduce((a, b) =>
-		(compareVersions(a, b) ?? -1) >= 0 ? a : b,
-	);
-}
-
 /**
  * The highest installed version THE PIN PERMITS — the ceiling a stale-load
  * repair may aim at. Null when no installed version qualifies.
  *
- * Under "latest" that is simply {@link highestInstalled}: nothing caps it, and
- * the newest version on this machine is the one to converge on.
+ * Under "latest" that is simply {@link highestInstalledVersion}: nothing caps
+ * it, and the newest version on this machine is the one to converge on.
  *
  * Under an EXACT pin it is the highest installed version at or below the pin.
  * `installed` reaches across every scope and `scopesNeeding` never downgrades, so
@@ -196,8 +172,8 @@ function highestPermittedInstalled(
 	info: PluginInfo | undefined,
 	pin: string,
 ): string | null {
-	if (pin === "latest") return highestInstalled(info);
-	const permitted = scopeVersions(info)
+	if (pin === "latest") return highestInstalledVersion(info);
+	const permitted = installedScopeVersions(info)
 		.map(([, v]) => v)
 		// pin >= v, i.e. v is at or below the pin. Null (unorderable) fails this.
 		.filter((v) => (compareVersions(pin, v) ?? -1) >= 0);
@@ -238,7 +214,7 @@ export function scopesNeeding(
 	// A raw `compareVersions(...) > 0` reported false for that pair and the
 	// scope was silently left alone. An unknown (null) is still left alone —
 	// moving a scope we cannot rank would be a guess.
-	return scopeVersions(info)
+	return installedScopeVersions(info)
 		.filter(([, version]) => isBehind(target, version) === true)
 		.map(([scope]) => scope);
 }
@@ -255,11 +231,11 @@ function marketplaceSuffix(id: string): string | null {
  * The catalog, indexed for the questions the classifier asks of it.
  *
  * "Listed" is narrower than "present". `getAvailablePlugins` puts ORPHANS —
- * installed or enabled, but published by no marketplace we read — into the same
- * list with `isOrphaned: true`, so a plain `has(id)` is true for a plugin that
- * nothing publishes. Treating an orphan as listed is what let an orphan plan as
- * `current`: its `version` is filled in from its own installed version, so the
- * compare found them equal.
+ * in this project's settings or registry, but published by no marketplace we
+ * read — into the same list with `isOrphaned: true`, so a plain `has(id)` is
+ * true for a plugin that nothing publishes. Treating an orphan as listed is
+ * what let an orphan plan as `current`: its `version` is filled in from its own
+ * installed version, so the compare found them equal.
  */
 export interface CatalogIndex {
 	get(pluginId: string): PluginInfo | undefined;
@@ -306,15 +282,6 @@ export function indexCatalog(
 	};
 }
 
-/** True when a settings file enables the plugin in at least one scope. */
-function enabledAnywhere(info: PluginInfo | undefined): boolean {
-	return (
-		!!info?.userScope?.enabled ||
-		!!info?.projectScope?.enabled ||
-		!!info?.localScope?.enabled
-	);
-}
-
 /**
  * THE plugin classifier. Pure.
  *
@@ -332,7 +299,7 @@ export function classifyPlugin(
 ): PluginUpdateItem {
 	const info = index.get(pluginId);
 	const listed = index.isListed(pluginId);
-	const installed = highestInstalled(info);
+	const installed = highestInstalledVersion(info);
 	// An orphan's `version` is its own installed version (or a stale local
 	// clone's), not something a marketplace we read offers — so it is not
 	// "available" from anywhere.
@@ -344,7 +311,7 @@ export function classifyPlugin(
 		installed,
 		loaded: info?.loadedVersion ?? null,
 		available,
-		beforeVersions: Object.fromEntries(scopeVersions(info)) as Partial<
+		beforeVersions: Object.fromEntries(installedScopeVersions(info)) as Partial<
 			Record<PluginScope, string>
 		>,
 	};
@@ -388,24 +355,29 @@ export function classifyPlugin(
 		};
 	}
 
-	// Not installed anywhere — the "checked but not installed" case.
+	// No installed scope has a version — the "checked but not installed" case.
 	//
-	// Nothing is installed in any scope here, so "enabled somewhere" is exactly
-	// "enabled but not installed". It is tested directly rather than through
-	// `isEnabledButNotInstalled`, which excludes orphans: an orphan that is only
-	// a settings key would otherwise read as `absent`, and the TUI renders
-	// `absent` as "the profile declares it", which an undeclared orphan does not.
+	// So a scope that IS installed here has its files missing. It is tested
+	// directly rather than through `hasMissingFiles`, which excludes orphans: an
+	// orphan that is only a settings key would otherwise read as `absent`, and the
+	// TUI renders `absent` as "the profile declares it", which an undeclared
+	// orphan does not.
+	//
+	// Files missing carries the scopes to reinstall at: exactly the ones installed
+	// with no version. It used to carry none, and the engine read "install" as
+	// "project scope" — so a user-scope plugin with its files missing was
+	// reinstalled at project scope, turning it on in the team's settings.json.
+	// `absent` still carries none: the engine installs it at project scope.
 	if (!installed) {
-		const brokenEnable = enabledAnywhere(info);
+		const missingAt = filesMissingScopes(info);
+		const filesMissing = missingAt.length > 0;
 		return {
 			...base,
 			target: pin === "latest" ? available : pin,
 			action: "install",
-			reason: brokenEnable ? "enabled-not-installed" : "absent",
-			scopes: [],
-			...(brokenEnable
-				? { note: "enabled in settings, but no files on disk" }
-				: {}),
+			reason: filesMissing ? "files-missing" : "absent",
+			scopes: missingAt,
+			...(filesMissing ? { note: "files missing" } : {}),
 		};
 	}
 
@@ -622,7 +594,7 @@ export function classifyPlugin(
 			target: installed,
 			action: "repair",
 			reason: "content-stale",
-			scopes: scopeVersions(info).map(([scope]) => scope),
+			scopes: installedScopeVersions(info).map(([scope]) => scope),
 			note: "files changed without a version bump",
 		};
 	}
@@ -669,17 +641,38 @@ export function classifyPlugin(
 }
 
 /**
- * Decide what to do with every plugin the profile declares.
+ * THE plugin plan — for `magus update` and the Plugins screen alike.
+ *
+ * Every plugin the active profile declares, under its pin, and every plugin
+ * installed in any scope (user, project, local), under "latest" — the rule
+ * {@link pinForRow} states — each classified by {@link classifyPlugin}, sorted.
+ *
+ * ONE list, read by both surfaces: the screen's rows, header counts and
+ * "update all", and the CLI's report and apply. It used to be two — the CLI
+ * planned the profile's plugins only, the screen every installed plugin — so a
+ * USER-scope plugin the screen showed as "update available" was never seen by
+ * `magus update`, which then reported everything up to date. The owner asked
+ * for "absolutely the same code" on both sides; this is it.
  *
  * @param pinned  closure.plugins — pluginId -> exact version | "latest"
- * @param catalog getAvailablePlugins() output, keyed by plugin id
+ * @param catalog getAvailablePlugins() output — keyed by id, or as a list
  */
 export function planPluginUpdates(
-	pinned: Record<string, string>,
-	catalog: Map<string, PluginInfo>,
+	pinned: Readonly<Record<string, string>>,
+	catalog: ReadonlyMap<string, PluginInfo> | readonly PluginInfo[],
 ): PluginUpdateItem[] {
 	const index = indexCatalog(catalog);
-	return Object.entries(pinned)
+	const plugins =
+		catalog instanceof Map
+			? [...catalog.values()]
+			: (catalog as readonly PluginInfo[]);
+	const pins = new Map(Object.entries(pinned));
+	for (const info of plugins) {
+		if (pins.has(info.id)) continue;
+		const pin = pinForRow(info, pinned);
+		if (pin !== null) pins.set(info.id, pin);
+	}
+	return [...pins]
 		.map(([pluginId, pin]) => classifyPlugin(pluginId, pin, index))
 		.sort((a, b) => a.pluginId.localeCompare(b.pluginId));
 }
@@ -689,45 +682,36 @@ export function planPluginUpdates(
  *
  * 1. The active profile's pin, when it declares the plugin — the SAME value
  *    `magus update` plans with, which is what makes the two agree.
- * 2. Otherwise "latest", when the plugin is installed in any scope or enabled
- *    in one — what the TUI's own update actions have always planned with, so
- *    the row and the action agree.
+ * 2. Otherwise "latest", when the plugin is installed in any scope, files
+ *    missing included — what the TUI's own update actions have always planned
+ *    with, so the row and the action agree.
  * 3. Otherwise null: an undeclared catalog entry the user is only browsing. It
  *    gets no status at all. `install` means "the profile wants it", and an
  *    undeclared plugin carries no such claim.
  *
  * A consequence the renderer relies on: reason `absent` can only come from
- * rule 1, because rule 2 never assigns a pin to a row that is neither installed
- * nor enabled.
+ * rule 1, because rule 2 never assigns a pin to a row that is not installed.
  */
 export function pinForRow(
 	info: PluginInfo,
 	pins: Readonly<Record<string, string>>,
 ): string | null {
 	if (Object.hasOwn(pins, info.id)) return pins[info.id] ?? null;
-	if (scopeVersions(info).length > 0 || enabledAnywhere(info)) return "latest";
+	if (isInstalledAnywhere(info)) return "latest";
 	return null;
 }
 
 /**
- * One status per row that has a pin. Rows whose {@link pinForRow} is null are
- * absent from the map.
- *
- * Computed once per data/pins change, and the same map feeds every consumer —
- * so the row, the detail panel, the header and the scope picker cannot disagree.
+ * {@link planPluginUpdates} keyed by plugin id, for the screen's lookups — the
+ * SAME plan `magus update` runs, not a second classification. Computed once
+ * per data/pins change, and the one map feeds the row, the detail panel, the
+ * header and the scope picker, so none of them can disagree.
  */
 export function classifyPluginRows(
 	plugins: readonly PluginInfo[],
 	pins: Readonly<Record<string, string>>,
 ): Map<string, PluginUpdateItem> {
-	const index = indexCatalog(plugins);
-	const out = new Map<string, PluginUpdateItem>();
-	for (const info of plugins) {
-		const pin = pinForRow(info, pins);
-		if (pin === null) continue;
-		out.set(info.id, classifyPlugin(info.id, pin, index));
-	}
-	return out;
+	return new Map(planPluginUpdates(pins, plugins).map((i) => [i.pluginId, i]));
 }
 
 export interface PluginStateCounts {

package/src/ui/App.tsx

@@ -427,8 +427,13 @@ function AppContent({ onExit }: AppContentProps) {
 				// edits into the active profile, regenerate from a changed
 				// profiles.json, restore a lost marker — then the question, if one
 				// is left to ask.
-				const { need, notices } = await prepareProfileStartup(process.cwd());
-				if (notices.length > 0) setProfileNotices(notices);
+				const { need, notices, problems } = await prepareProfileStartup(
+					process.cwd(),
+				);
+				// A refusal never blocks the TUI at startup: it is shown beside what
+				// the gate did, and the user is still asked whatever is left.
+				const shown = [...notices, ...problems];
+				if (shown.length > 0) setProfileNotices(shown);
 				if (!needsNothing(need)) setProfileNeed(need);
 			} catch {
 				// non-fatal: the Profiles tab still works by hand

package/src/ui/adapters/pluginsAdapter.ts

@@ -43,7 +43,7 @@ export interface PluginPluginItem {
 	/**
 	 * The classifier's answer for this plugin — the same item `magus update`
 	 * plans with. Null for a catalog entry the user is only browsing (neither
-	 * declared by the profile, installed, nor enabled): it has no state to claim.
+	 * declared by the profile nor installed): it has no state to claim.
 	 */
 	status: PluginUpdateItem | null;
 }

package/src/ui/components/primitives/ScopeSquares.tsx

@@ -8,23 +8,28 @@ interface ScopeSquaresProps {
 	selected?: boolean;
 }
 
-/** Installed at that scope. */
+/** On at that scope. */
 export const SCOPE_ON = "■";
-/** Not installed at that scope. */
+/** Not on at that scope. */
 export const SCOPE_OFF = "□";
 
 /**
  * Scope bar: three positional squares, user / project / local.
  *
  * POSITION names the scope — the first square is always user, the second
- * project, the third local — and SHAPE says the state: `■` installed, `□` not.
- * That reads with no colour at all, which the bar never used to: every square
+ * project, the third local — and SHAPE says the state: `■` on, `□` not. "On"
+ * is the caller's to decide, and for a plugin and a skill alike it is
+ * installed. For a plugin that is `isInstalledInScope` — the scope's settings
+ * file turns it on, which is what Claude Code loads by — the same function the
+ * detail panel's dot reads, so the two cannot disagree.
+ *
+ * The shape reads with no colour at all, which the bar never used to: every square
  * was the same filled block, lit in a scope hue or unlit in a fill near the
  * page, so on a monochrome terminal, to a colour-blind reader, or on a theme
  * that drew two hues alike, all three states were one shape.
  *
  * Colour now only repeats what the shape says. A filled square wears `success`
- * (installed is what it means, on every screen); a hollow one wears `muted`,
+ * (on is what it means, on every screen); a hollow one wears `muted`,
  * which a thin outline needs to stay visible — the shape, not a pale fill, is
  * what makes it recede. On a selected row the selection owns the colour
  * channel: filled squares take its ink, hollow ones its dim ink.

package/src/ui/hooks/useProfileStartupModal.ts

@@ -25,10 +25,13 @@ import {
 import type { DisplacedArtifact } from "../../services/profile-live.js";
 import {
 	type ProfileStartupNeed,
+	UPDATE_FORMAT_VALUE,
 	buildProfileOptions,
 	defaultOptionIndex,
 	describeNeed,
+	formatUpdateOutcome,
 	parseProfileChoice,
+	prepareProfileStartup,
 	unparseableNeed,
 } from "../../services/profile-startup.js";
 import { applyProfileChoice } from "../../services/profile-state.js";
@@ -39,6 +42,8 @@ import type { ModalState } from "../state/types.js";
 export interface BuildProfileModalArgs {
 	need: ProfileStartupNeed;
 	onChoose: (choice: ProfileChoice) => void;
+	/** "Update it now" on the `old-format` question — not a profile choice. */
+	onUpdateFormat?: () => void;
 	/**
 	 * Leave magus. NOT "dismiss" — there is deliberately no way to carry on
 	 * without a profile, because there is nothing to carry on with.
@@ -49,7 +54,7 @@ export interface BuildProfileModalArgs {
 export function buildProfileStartupModal(
 	args: BuildProfileModalArgs,
 ): ModalState {
-	const { need, onChoose, onQuit } = args;
+	const { need, onChoose, onUpdateFormat, onQuit } = args;
 	const { title, message } = describeNeed(need);
 	return {
 		type: "select",
@@ -60,6 +65,10 @@ export function buildProfileStartupModal(
 		// developer who has local work and therefore still gets asked.
 		defaultIndex: defaultOptionIndex(need),
 		onSelect: (value: string) => {
+			if (value === UPDATE_FORMAT_VALUE && onUpdateFormat) {
+				onUpdateFormat();
+				return;
+			}
 			const choice = parseProfileChoice(value, need);
 			if (choice) onChoose(choice);
 			else onQuit();
@@ -168,8 +177,16 @@ export function useProfileStartupModal(
 
 	const show = useCallback(
 		(need: ProfileStartupNeed) => {
-			/** Apply a choice, reporting the outcome either way. */
-			const apply = (choice: ProfileChoice, automatic: boolean): void => {
+			/**
+			 * Apply a choice, reporting the outcome either way. `current` is the
+			 * question it answers — after "Update it now" that is a NEW question,
+			 * whose manifest is the converted one, not the one magus opened with.
+			 */
+			const apply = (
+				choice: ProfileChoice,
+				automatic: boolean,
+				current: ProfileStartupNeed = need,
+			): void => {
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: {
@@ -191,7 +208,7 @@ export function useProfileStartupModal(
 				// where they left it. `.magus-backups/` is gitignored, so git status
 				// showed the deletion and no sign of the copy.
 				const moved: DisplacedArtifact[] = [];
-				void applyProfileChoice(choice, need.manifest, projectPath, {
+				void applyProfileChoice(choice, current.manifest, projectPath, {
 					onDisplace: (artifact) => moved.push(artifact),
 				})
 					.then((result: ActivationResult) => {
@@ -228,7 +245,7 @@ export function useProfileStartupModal(
 							error instanceof SettingsParseError &&
 							error.path === getManifestPath(projectPath)
 								? unparseableNeed(error)
-								: need;
+								: current;
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
@@ -241,7 +258,7 @@ export function useProfileStartupModal(
 									error,
 									moved,
 									projectPath,
-									need.declaredDefault,
+									current.declaredDefault,
 								),
 								variant: "error",
 								// A failure leaves the project without an active profile, so
@@ -254,12 +271,75 @@ export function useProfileStartupModal(
 					});
 			};
 
+			/**
+			 * "Update it now" on an old profile format: update it — the same gate
+			 * the CLI runs after its own question — then ask whatever is left, or
+			 * say it is done.
+			 */
+			const updateFormat = (): void => {
+				dispatch({
+					type: "SHOW_MODAL",
+					modal: { type: "loading", message: "Updating the profile format…" },
+				});
+				void prepareProfileStartup(projectPath, { convert: true })
+					.then((result) => {
+						const outcome = formatUpdateOutcome(result);
+						if (outcome.kind === "ask") {
+							onActivated?.();
+							ask(outcome.need);
+							return;
+						}
+						if (outcome.kind === "failed") {
+							// Refused, so still the old format: back to the question,
+							// as the CLI stops on the same lines.
+							dispatch({
+								type: "SHOW_MODAL",
+								modal: {
+									type: "message",
+									title: outcome.title,
+									message: outcome.message,
+									variant: "error",
+									onDismiss: () => ask(need),
+								},
+							});
+							return;
+						}
+						onActivated?.();
+						dispatch({
+							type: "SHOW_MODAL",
+							modal: {
+								type: "message",
+								title: outcome.title,
+								message: outcome.message,
+								variant: "success",
+								onDismiss: () => {
+									dispatch({ type: "HIDE_MODAL" });
+									navigateToScreen("profiles");
+								},
+							},
+						});
+					})
+					.catch((error: unknown) => {
+						dispatch({
+							type: "SHOW_MODAL",
+							modal: {
+								type: "message",
+								title: "Could not update the profile format",
+								message: `${error instanceof Error ? error.message : String(error)}\n\nYour profiles are kept. Open magus again to retry.`,
+								variant: "error",
+								onDismiss: () => ask(need),
+							},
+						});
+					});
+			};
+
 			function ask(current: ProfileStartupNeed = need): void {
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: buildProfileStartupModal({
 						need: current,
-						onChoose: (choice) => apply(choice, false),
+						onChoose: (choice) => apply(choice, false, current),
+						onUpdateFormat: updateFormat,
 						onQuit,
 					}),
 				});

package/src/ui/keymap.ts

@@ -156,7 +156,7 @@ const PLUGINS = [
 		"save-profile",
 		["s"],
 		"profile",
-		"Save the enabled plugins as a profile",
+		"Save the installed plugins as a profile",
 		60,
 	),
 	bind(