magus-cli 7.5.3 → 7.5.4

package/src/ui/renderers/pluginRenderers.tsx

@@ -2,8 +2,11 @@ import type React from "react";
 import { getMarketplaceVersion } from "../../services/marketplace-fetcher.js";
 import {
 	compareVersions,
-	isEnabledButNotInstalled,
+	hasMissingFiles,
+	isInstalledAnywhere,
 	isInstalledInScope,
+	scopeFilesMissing,
+	versionInScope,
 } from "../../services/plugin-manager.js";
 import type { ScopeStatus } from "../../services/plugin-manager.js";
 import type { PluginComponentKind } from "../../services/skills-manager.js";
@@ -195,9 +198,12 @@ function pluginRow(
 	isSelected: boolean,
 ): React.ReactNode {
 	const { plugin } = item;
-	const hasUser = !!plugin.userScope?.enabled;
-	const hasProject = !!plugin.projectScope?.enabled;
-	const hasLocal = !!plugin.localScope?.enabled;
+	// The squares and the name colour read the one installed-at-scope test, the
+	// same one the detail panel's dots read, so the row and the panel beside it
+	// cannot show two different states.
+	const hasUser = isInstalledInScope(plugin.userScope);
+	const hasProject = isInstalledInScope(plugin.projectScope);
+	const hasLocal = isInstalledInScope(plugin.localScope);
 	const hasAnyScope = hasUser || hasProject || hasLocal;
 
 	// Everything after the name — version, history badge, status — comes from
@@ -257,24 +263,13 @@ function pluginRow(
 		);
 	}
 
-	const installedSomewhere =
-		isInstalledInScope(plugin.userScope) ||
-		isInstalledInScope(plugin.projectScope) ||
-		isInstalledInScope(plugin.localScope);
-
 	return (
 		<text fg={theme.colors.text}>
 			<span> </span>
 			<ScopeSquares user={hasUser} project={hasProject} local={hasLocal} />
 			<span> </span>
 			<span fg={theme.colors.dim}>{arrow}</span>
-			<span
-				fg={
-					hasAnyScope && installedSomewhere
-						? theme.colors.text
-						: theme.colors.muted
-				}
-			>
+			<span fg={hasAnyScope ? theme.colors.text : theme.colors.muted}>
 				{displayName}
 			</span>
 			<RowSegments segments={segments} selected={false} />
@@ -344,14 +339,10 @@ function pluginDetail(
 	fetched?: PluginContentsEntry,
 ): React.ReactNode {
 	const { plugin, status } = item;
-	// "Installed" has to mean the same thing here as in the list row. Reading the
-	// `enabledPlugins` flag alone made this panel print "● Installed" for the
-	// exact plugin the row beside it was labelling "not installed".
-	const isInstalled =
-		isInstalledInScope(plugin.userScope) ||
-		isInstalledInScope(plugin.projectScope) ||
-		isInstalledInScope(plugin.localScope);
-	const brokenInstall = isEnabledButNotInstalled(plugin);
+	// "Installed" means the same thing here as in the list row: the one
+	// installed-at-scope test, at any scope.
+	const isInstalled = isInstalledAnywhere(plugin);
+	const filesMissing = hasMissingFiles(plugin);
 	// The ⬆ marker and the U hint claim that pressing U does something. That is
 	// exactly the classifier's update/repair, and nothing else.
 	const needsWork = status?.action === "update" || status?.action === "repair";
@@ -453,25 +444,25 @@ function pluginDetail(
 			<box marginTop={1}>
 				<text
 					fg={
-						isInstalled
-							? theme.colors.success
-							: brokenInstall
-								? theme.colors.danger
+						filesMissing
+							? theme.colors.danger
+							: isInstalled
+								? theme.colors.success
 								: theme.colors.muted
 					}
 				>
-					{isInstalled
-						? "● Installed"
-						: brokenInstall
-							? "○ Not installed — enabled in settings, no files on disk"
+					{filesMissing
+						? "● Installed — files missing"
+						: isInstalled
+							? "● Installed"
 							: "○ Not installed"}
 				</text>
 			</box>
-			{brokenInstall ? (
+			{filesMissing ? (
 				<box>
 					<text fg={theme.colors.muted}>
 						Claude Code cannot load it in this state. Press the scope key to
-						repair.
+						reinstall.
 					</text>
 				</box>
 			) : null}
@@ -631,10 +622,15 @@ function pluginDetail(
 /**
  * One line of the detail panel's scope breakdown.
  *
- * The filled dot means installed — registry-backed, same as everywhere else.
- * A scope that is enabled with nothing installed is called out explicitly
- * rather than shown as a plain empty dot, because those two states need
- * different actions from the user and used to look identical.
+ * The filled dot means what the list row's square means — installed at this
+ * scope — because both read `isInstalledInScope`. The version shows only where
+ * the plugin is installed: a registry row can be inherited from another
+ * directory of the same repository, and magus run in `tools/magus` once showed
+ * "Project team v0.8.1" for a plugin that directory's settings never turn on and
+ * Claude Code started there never loads.
+ *
+ * Installed with no version is named, in the danger colour, because it needs an
+ * action — the scope key reinstalls — and a plain dot would read as healthy.
  */
 function ScopeLine({
 	keyHint,
@@ -647,18 +643,16 @@ function ScopeLine({
 	qualifier: string;
 	scope?: ScopeStatus;
 }): React.ReactNode {
-	const installed = isInstalledInScope(scope);
+	const version = versionInScope(scope);
 	return (
 		<text fg={theme.colors.text}>
 			<ScopeKeyChip scopeKey={keyHint} />
-			<ScopeDot installed={installed} />
+			<ScopeDot installed={isInstalledInScope(scope)} />
 			<span>{name}</span>
 			<span fg={theme.colors.muted}> {qualifier}</span>
-			{scope?.version ? (
-				<span fg={theme.colors.info}> v{scope.version}</span>
-			) : null}
-			{!installed && scope?.enabled ? (
-				<span fg={theme.colors.danger}> enabled, not installed</span>
+			{version ? <span fg={theme.colors.info}> v{version}</span> : null}
+			{scopeFilesMissing(scope) ? (
+				<span fg={theme.colors.danger}> files missing</span>
 			) : null}
 		</text>
 	);

package/src/ui/renderers/pluginRowText.ts

@@ -38,8 +38,12 @@ export function pluginRowText(item: PluginPluginItem): PluginRowText {
 	// A version is shown only when it carries information. "0.0.0" means
 	// installed with an unknown version (Anthropic's official plugins record
 	// exactly that) — it is never printed, and nothing below depends on it.
-	const installed = status?.installed ?? plugin.installedVersion;
-	const shown = isKnownVersion(installed ?? undefined) ? installed : undefined;
+	//
+	// The classifier's version and nothing else. A fallback to
+	// `plugin.installedVersion` printed a version where the classifier had none —
+	// "v0.8.1 files missing", with 0.8.1 read off a scope not installed here.
+	const installed = status?.installed ?? undefined;
+	const shown = isKnownVersion(installed) ? installed : undefined;
 
 	// "What just changed" and "what state it is in now" are independent facts
 	// and both can be true at once: an external update can move a plugin

package/src/ui/renderers/pluginStatusText.ts

@@ -57,13 +57,14 @@ export function pluginStatusText(
 			return { suffix: " BROKEN — press a to fix", tone: "danger" };
 		case "install":
 			// `absent` only ever comes from a profile pin (see `pinForRow`), so it
-			// may say so. An undeclared row that is merely enabled must not.
+			// may say so. An undeclared row whose files are missing must not.
 			return status.reason === "absent"
 				? { suffix: " not installed — profile declares it", tone: "warning" }
-				: // Enabled with nothing on disk is a broken state; a missing
+				: // Files missing is installed, and broken — never "not installed",
+					// which would contradict the filled square beside it. A missing
 					// declared plugin is routine work. Red against amber is the
 					// distinction that matters.
-					{ suffix: ` not installed${withNote}`, tone: "danger" };
+					{ suffix: ` ${status.note ?? "files missing"}`, tone: "danger" };
 		case "current":
 			return { suffix: withNote, tone: "muted" };
 	}

package/src/ui/screens/PluginsScreen.tsx

@@ -26,9 +26,12 @@ import {
 	getAvailablePlugins,
 	getLocalMarketplacesInfo,
 	getMarketplaceFetchFailures,
+	isInstalledAnywhere,
 	isInstalledInScope,
 	refreshAllMarketplaces,
 	resolveScopeAction,
+	scopeFilesMissing,
+	versionInScope,
 } from "../../services/plugin-manager.js";
 import {
 	getPluginEnvRequirements,
@@ -871,17 +874,16 @@ export function PluginsScreen() {
 				scope: ScopeStatus | undefined,
 				desc: string,
 			) => {
-				const installed = isInstalledInScope(scope);
-				const ver = scope?.version;
-				let label = installed ? `● ${name}` : `○ ${name}`;
+				const ver = versionInScope(scope);
+				let label = isInstalledInScope(scope) ? `● ${name}` : `○ ${name}`;
 				label += ` (${desc})`;
 				if (ver) label += ` v${ver}`;
 				if (scopeIsBehind(status, scopeKey) && status?.target)
 					label += ` → v${status.target}`;
-				// Enabled in settings with nothing installed. Without saying so the
-				// row reads exactly like a scope that was never enabled, and the
-				// user cannot tell that picking it repairs rather than adds.
-				if (!installed && scope?.enabled) label += " — not installed, repairs";
+				// Installed with no version. Without saying so the row reads like a
+				// healthy install, and the user cannot tell that picking it
+				// reinstalls rather than uninstalls.
+				if (scopeFilesMissing(scope)) label += " — files missing, reinstalls";
 				return label;
 			};
 
@@ -930,9 +932,9 @@ export function PluginsScreen() {
 						? "Project"
 						: "Local";
 
-			// Decided from the registry-backed version, not the `enabledPlugins`
-			// flag alone — see resolveScopeAction. Update-versus-uninstall is the
-			// same `scopeIsBehind` the label above used.
+			// Files missing reinstalls rather than uninstalls — see
+			// resolveScopeAction. Update-versus-uninstall is the same
+			// `scopeIsBehind` the label above used.
 			const action = resolveScopeAction(
 				selectedScope,
 				scopeIsBehind(status, scopeValue as PluginScope),
@@ -1060,10 +1062,12 @@ export function PluginsScreen() {
 	};
 
 	/**
-	 * "Update all" — the SAME planner and the SAME apply engine `magus
-	 * update` runs. Only the selection differs, and only because a screen and a
-	 * profile genuinely mean different sets: here it is "everything listed with
-	 * an update", there it is "what the profile declares".
+	 * "Update all" — the SAME plan, the SAME selection and the SAME apply engine
+	 * `magus update` runs: every item of {@link planPluginUpdates} handed to
+	 * `applyPlugins`, which does the work each one needs (advance, repair,
+	 * reinstall missing files) and skips the rest. There used to be a different
+	 * selection here — "rows that say update" against the CLI's "what the profile
+	 * declares" — and the two surfaces disagreed about the same machine.
 	 *
 	 * This used to be a hand-rolled loop, and it had drifted from the CLI in
 	 * three ways that were bugs, not choices — it touched one scope derived from
@@ -1074,20 +1078,11 @@ export function PluginsScreen() {
 	const handleUpdateAll = async () => {
 		if (pluginsState.plugins.status !== "success") return;
 
-		// Exactly the rows that say "update", "stale — reinstall" or "BROKEN — press
-		// a to fix", each planned under its real pin. Content-stale plugins are
-		// included: they need repairing, and excluding them meant "update all" left
-		// the machine with silently outdated files. Broken (`stale-load`) rows are
-		// included because the row itself now names this key — leaving them out
-		// would make that hint a lie. `install` stays out: a plugin nothing has
-		// installed is `s`'s business, per the note above.
+		// Every item that needs work, by the same `pluginNeedsWork` the CLI's
+		// apply uses: updates, content repairs, broken loads, missing files, and a
+		// profile plugin not installed yet — exactly what `magus update` would do.
 		const items = [...statuses.values()]
-			.filter(
-				(s) =>
-					s.action === "update" ||
-					s.action === "repair" ||
-					s.action === "stale-load",
-			)
+			.filter(pluginNeedsWork)
 			.sort((a, b) => a.pluginId.localeCompare(b.pluginId));
 		if (items.length === 0) return;
 
@@ -1155,12 +1150,10 @@ export function PluginsScreen() {
 					? plugin.projectScope
 					: plugin.localScope;
 
-		// This used to key off `scopeData.enabled` alone, so a plugin the list
-		// had just labelled "not installed" answered its own scope key by
-		// uninstalling itself — the `enabledPlugins` flag was set, the registry
-		// entry was missing, and only the flag was consulted. Update-versus-
-		// uninstall is the classifier's `scopeIsBehind`, the same rule the Enter
-		// scope picker labels with.
+		// A scope whose files are missing answers its key with a reinstall. It once
+		// answered with an uninstall, removing the plugin the row was reporting as
+		// broken. Update-versus-uninstall is the classifier's `scopeIsBehind`, the
+		// same rule the Enter scope picker labels with.
 		const action = resolveScopeAction(
 			scopeData,
 			scopeIsBehind(statuses.get(plugin.id), scope),
@@ -1355,14 +1348,8 @@ export function PluginsScreen() {
 
 	const scopeLabel = pluginsState.scope === "global" ? "Global" : "Project";
 	const plugins: PluginInfo[] = shownPlugins ?? [];
-	// "installed" must mean the same thing here as in the rows beside it. This
-	// counted `p.enabled` — the settings flag — so the header read "11 installed"
-	// on a screen whose every row said "not installed". Same predicate as the
-	// row and the detail panel now.
-	const isInstalledAnywhere = (p: PluginInfo) =>
-		isInstalledInScope(p.userScope) ||
-		isInstalledInScope(p.projectScope) ||
-		isInstalledInScope(p.localScope);
+	// "installed" means the same thing here as in the rows beside it: the one
+	// installed-at-scope test the row and the detail panel read.
 	const installedCount = plugins.filter(isInstalledAnywhere).length;
 	// Every state count is the classifier's, over the same map the rows read,
 	// so a header can never count a row the list beside it does not show.

package/src/cli/tui-prompt.tsx

@@ -1,143 +0,0 @@
-/**
- * One OpenTUI dialog, for a command that is otherwise not a TUI.
- *
- * `magus update` prints a report and exits; it is not the interactive app. But
- * a question it must ask deserves the same dialog the TUI asks with, so this
- * mounts the REAL `SelectModal` — the component tab 5 and tab 0 use — for the
- * length of one question, then tears the renderer down and lets the command
- * carry on printing. Nothing here re-draws a list, a border or a highlight: the
- * component and the theme own all of that, and a second implementation is how
- * the two surfaces drift apart.
- *
- * Every import of `@opentui/*` and `ui/` is DYNAMIC. `main.tsx` splits the TUI
- * out precisely so `magus hook …`, which Claude Code runs on every matching
- * tool call, never pays to load the renderer — a static import here would undo
- * that for every command that imports this module's file, whether or not it
- * ever asks a question.
- *
- * `screenMode: "main-screen"` keeps the dialog in the scrollback beside the
- * report. The alternate screen would take the terminal over and then hand back
- * a screen with no trace the question was ever asked.
- */
-
-import type { SelectOption } from "../ui/state/types.js";
-
-export interface SelectDialogInput {
-	title: string;
-	message: string;
-	options: SelectOption[];
-	/** Row to start on. Defaults to the first. */
-	defaultIndex?: number;
-}
-
-/**
- * Ask the user to pick one option. Resolves to the chosen value, or null when
- * they cancel with Esc or Ctrl+C — the caller decides whether that is fatal.
- *
- * Falls back to `null` when stdin or stdout is not a TTY. A renderer needs both:
- * `magus update > file` has a TTY stdin and a pipe for stdout, and mounting
- * there writes escape sequences into the file.
- */
-export async function selectDialog(
-	input: SelectDialogInput,
-): Promise<string | null> {
-	if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
-		return null;
-	}
-
-	const [{ createCliRenderer }, { createRoot }, React, modals, dimensions] =
-		await Promise.all([
-			import("@opentui/core"),
-			import("@opentui/react"),
-			import("react"),
-			import("../ui/components/modals/index.js"),
-			import("../ui/state/DimensionsContext.js"),
-		]);
-
-	const renderer = await createCliRenderer({
-		screenMode: "main-screen",
-		// BOTH, so the renderer registers no handler of its own and teardown
-		// below is the only path. With either left at its default, a Ctrl+C
-		// destroys the renderer underneath this promise and it never settles.
-		exitSignals: [],
-		exitOnCtrlC: false,
-	});
-
-	const root = createRoot(renderer);
-
-	return await new Promise<string | null>((resolve) => {
-		// Clamped, not trusted: a caller computing an index from a list it built
-		// separately could hand over one that is out of range, and a cursor
-		// pointing past the end makes Enter resolve to null.
-		let index = Math.min(
-			Math.max(0, input.defaultIndex ?? 0),
-			Math.max(0, input.options.length - 1),
-		);
-		let done = false;
-
-		const finish = (value: string | null): void => {
-			if (done) return;
-			done = true;
-			renderer.keyInput.off("keypress", onKey);
-			root.unmount();
-			renderer.destroy();
-			resolve(value);
-		};
-
-		function onKey(key: {
-			name?: string;
-			ctrl?: boolean;
-			sequence?: string;
-		}): void {
-			if ((key.ctrl && key.name === "c") || key.name === "escape") {
-				finish(null);
-				return;
-			}
-			if (key.name === "return" || key.name === "enter") {
-				finish(input.options[index]?.value ?? null);
-				return;
-			}
-			if (key.name === "up" || key.name === "k") {
-				index = (index - 1 + input.options.length) % input.options.length;
-				draw();
-				return;
-			}
-			if (key.name === "down" || key.name === "j") {
-				index = (index + 1) % input.options.length;
-				draw();
-				return;
-			}
-			// The numbers stay live: the list is short, and the plain-text prompt
-			// this replaced numbered it, so the habit already exists.
-			const digit = Number(key.sequence);
-			if (
-				Number.isInteger(digit) &&
-				digit >= 1 &&
-				digit <= input.options.length
-			) {
-				index = digit - 1;
-				finish(input.options[index]?.value ?? null);
-			}
-		}
-
-		const draw = (): void => {
-			root.render(
-				React.createElement(
-					dimensions.DimensionsProvider,
-					null,
-					React.createElement(modals.SelectModal, {
-						title: input.title,
-						message: input.message,
-						options: input.options,
-						defaultIndex: index,
-						onSelect: finish,
-						onCancel: () => finish(null),
-					}),
-				),
-			);
-		};
-
-		renderer.keyInput.on("keypress", onKey);
-		draw();
-	});
-}