claudeup 6.5.0 → 6.6.0

package/src/ui/screens/PluginsScreen.tsx

@@ -4,6 +4,7 @@ import {
 	defaultMarketplaces,
 	getAllMarketplaces,
 } from "../../data/marketplaces.js";
+import { loadActiveClosure } from "../../services/active-closure.js";
 import {
 	type PluginScope,
 	addMarketplace as cliAddMarketplace,
@@ -37,11 +38,6 @@ import {
 	getPluginSetupFromSource,
 	installPluginDeps,
 } from "../../services/plugin-setup.js";
-import {
-	type VersionMismatchInfo,
-	checkPluginVersionMismatches,
-	checkSinglePluginMismatch,
-} from "../../services/plugin-version-check.js";
 import { saveProfile } from "../../services/profiles.js";
 import {
 	fetchPluginContents,
@@ -57,7 +53,15 @@ import {
 	pluginNeedsWork,
 	updatePluginInScope,
 } from "../../services/update-engine.js";
-import { planPluginUpdates } from "../../services/update-plan.js";
+// The ONE plugin classifier, shared with `claudeup update`. Every state this
+// screen shows or acts on — row text, detail panel, header counts, U / a, the
+// scope picker — reads the same map it builds.
+import {
+	type PluginUpdateItem,
+	classifyPluginRows,
+	countPluginStates,
+	scopeIsBehind,
+} from "../../services/update-plan.js";
 import {
 	diffVersions,
 	loadSeenVersions,
@@ -70,13 +74,13 @@ import {
 	type PluginComponentItem,
 	type PluginPluginItem,
 	buildPluginBrowserItems,
+	noMoveReasons,
 	pluginContentsRepo,
 } from "../adapters/pluginsAdapter.js";
 import { EmptyFilterState } from "../components/EmptyFilterState.js";
 import { ScrollableList } from "../components/ScrollableList.js";
 import { ScreenLayout } from "../components/layout/index.js";
 import { useKeyboard } from "../hooks/useKeyboard.js";
-import { useMismatchModal } from "../hooks/useMismatchModal.js";
 import {
 	renderPluginDetail,
 	renderPluginRow,
@@ -101,7 +105,6 @@ export function PluginsScreen() {
 	const modal = useModal();
 	const progress = useProgress();
 	const dimensions = useDimensions();
-	const mismatchModal = useMismatchModal();
 
 	const isSearchActive =
 		state.isSearching &&
@@ -122,13 +125,32 @@ export function PluginsScreen() {
 	/** Re-render tick so the retry countdown in the notice actually counts down. */
 	const [nowTick, setNowTick] = useState(() => Date.now());
 
+	/**
+	 * The active profile's pins — the same values `claudeup update` plans with.
+	 *
+	 * `undefined` until the first fetch answers; `null` when no profile could be
+	 * resolved (no manifest, an invalid one, or several with none active). In
+	 * that case every row is judged against "latest" and the notice says so.
+	 */
+	const [pins, setPins] = useState<
+		Readonly<Record<string, string>> | null | undefined
+	>(undefined);
+
 	// Fetch data (always fetches all scopes)
 	const fetchData = useCallback(async () => {
 		dispatch({ type: "PLUGINS_DATA_LOADING" });
 		try {
 			const localMarketplaces = await getLocalMarketplacesInfo();
 			const allMarketplaces = getAllMarketplaces(localMarketplaces);
-			const pluginData = await getAvailablePlugins(state.projectPath);
+			// Read-only, never throws. `resolveBins: false`: this screen needs only
+			// the plugin pins, not every declared plugin's binary requirements.
+			const [pluginData, active] = await Promise.all([
+				getAvailablePlugins(state.projectPath),
+				loadActiveClosure(state.projectPath || process.cwd(), {
+					resolveBins: false,
+				}),
+			]);
+			setPins(active?.closure.plugins ?? null);
 
 			// Which catalogs answered, and which only appeared to. Read straight
 			// after the fetch, while the record still describes this attempt.
@@ -147,7 +169,7 @@ export function PluginsScreen() {
 			);
 
 			// Surface version changes made outside claudeup (Claude Code's own
-			// plugin update, the prerunner, a manual CLI call). Diffing against
+			// plugin update, a manual CLI call). Diffing against
 			// what we last rendered catches all of them; logging only what
 			// claudeup did would miss every one.
 			const current: Record<string, string> = {};
@@ -234,6 +256,18 @@ export function PluginsScreen() {
 	const isReloading =
 		pluginsState.plugins.status === "loading" && shownPlugins !== undefined;
 
+	/**
+	 * One status per plugin that has a pin, computed ONCE per data/pins change.
+	 * The rows, the detail panel, the header counts, U / a and the scope picker
+	 * all read this map, so none of them can disagree with another — or with
+	 * `claudeup update`, which runs the same classifier over the same pins.
+	 */
+	const statuses = useMemo(
+		(): Map<string, PluginUpdateItem> =>
+			shownPlugins ? classifyPluginRows(shownPlugins, pins ?? {}) : new Map(),
+		[shownPlugins, pins],
+	);
+
 	// Build list items (categories + plugins)
 	const allItems = useMemo((): PluginBrowserItem[] => {
 		if (!shownMarketplaces || !shownPlugins) return [];
@@ -243,6 +277,7 @@ export function PluginsScreen() {
 			collapsedMarketplaces: pluginsState.collapsedMarketplaces,
 			expandedPlugins: pluginsState.expandedPlugins,
 			pluginContents: pluginsState.pluginContents,
+			statuses,
 		});
 	}, [
 		shownMarketplaces,
@@ -250,6 +285,7 @@ export function PluginsScreen() {
 		pluginsState.collapsedMarketplaces,
 		pluginsState.expandedPlugins,
 		pluginsState.pluginContents,
+		statuses,
 	]);
 
 	// Filter items by search query
@@ -517,32 +553,11 @@ export function PluginsScreen() {
 		else if (event.name === "l") handleScopeToggle("local");
 		else if (event.name === "d") handleRemoveDeprecated();
 		else if (event.name === "a") handleUpdateAll();
-		else if (event.name === "m") handleCheckMismatches();
 		else if (event.name === "s") handleSaveAsProfile();
 	});
 
 	// ── Helpers ───────────────────────────────────────────────────────────────
 
-	/**
-	 * Check for version mismatch after a plugin update and show the
-	 * interactive mismatch modal with a "Fix all projects" button.
-	 *
-	 * The [0] index bug in Claude Code means the update may not actually
-	 * take effect if another project's entry is at index 0. The shared
-	 * useMismatchModal hook provides the same fix flow available at startup.
-	 */
-	const warnIfVersionMismatch = async (pluginId: string): Promise<void> => {
-		try {
-			const projectPath = state.projectPath || process.cwd();
-			const mismatch = await checkSinglePluginMismatch(pluginId, projectPath);
-			if (mismatch) {
-				mismatchModal.show([mismatch]);
-			}
-		} catch {
-			// Non-fatal: mismatch check is best-effort
-		}
-	};
-
 	// ── Action handlers ────────────────────────────────────────────────────────
 
 	const handleRefresh = async () => {
@@ -851,24 +866,24 @@ export function PluginsScreen() {
 			}
 		} else if (item.kind === "plugin") {
 			const plugin = item.plugin;
-			const latestVersion = plugin.version || "0.0.0";
+			const status = statuses.get(plugin.id);
 
+			// The label's arrow and what the key then does are ONE rule —
+			// `scopeIsBehind` — so the picker can never show no arrow and then
+			// update, or show an arrow and then uninstall.
 			const buildScopeLabel = (
 				name: string,
+				scopeKey: PluginScope,
 				scope: ScopeStatus | undefined,
 				desc: string,
 			) => {
 				const installed = isInstalledInScope(scope);
 				const ver = scope?.version;
-				const hasUpdate =
-					ver &&
-					latestVersion &&
-					ver !== latestVersion &&
-					latestVersion !== "0.0.0";
 				let label = installed ? `● ${name}` : `○ ${name}`;
 				label += ` (${desc})`;
 				if (ver) label += ` v${ver}`;
-				if (hasUpdate) label += ` → v${latestVersion}`;
+				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.
@@ -878,15 +893,25 @@ export function PluginsScreen() {
 
 			const scopeOptions = [
 				{
-					label: buildScopeLabel("User", plugin.userScope, "global"),
+					label: buildScopeLabel("User", "user", plugin.userScope, "global"),
 					value: "user",
 				},
 				{
-					label: buildScopeLabel("Project", plugin.projectScope, "team"),
+					label: buildScopeLabel(
+						"Project",
+						"project",
+						plugin.projectScope,
+						"team",
+					),
 					value: "project",
 				},
 				{
-					label: buildScopeLabel("Local", plugin.localScope, "private"),
+					label: buildScopeLabel(
+						"Local",
+						"local",
+						plugin.localScope,
+						"private",
+					),
 					value: "local",
 				},
 			];
@@ -912,8 +937,12 @@ export function PluginsScreen() {
 						: "Local";
 
 			// Decided from the registry-backed version, not the `enabledPlugins`
-			// flag alone — see resolveScopeAction.
-			const action = resolveScopeAction(selectedScope, latestVersion);
+			// flag alone — see resolveScopeAction. Update-versus-uninstall is the
+			// same `scopeIsBehind` the label above used.
+			const action = resolveScopeAction(
+				selectedScope,
+				scopeIsBehind(status, scopeValue as PluginScope),
+			);
 
 			try {
 				const scope = scopeValue as PluginScope;
@@ -928,7 +957,7 @@ export function PluginsScreen() {
 					);
 					// Scope is the user's explicit choice here, so this does NOT go
 					// through applyPlugins (which advances every scope behind). It
-					// still records the version READ BACK, not `latestVersion`.
+					// still records the version READ BACK, not the catalog version.
 					await updatePluginInScope(
 						plugin.id,
 						scope,
@@ -939,7 +968,7 @@ export function PluginsScreen() {
 						`Installing ${plugin.name} to ${scopeLabel}…\nclaude plugin install ${plugin.id} --scope ${scope}`,
 					);
 					// Same read-back as the update branch above. A fresh install is
-					// no more able to guarantee it got `latestVersion` than an
+					// no more able to guarantee it got the catalog version than an
 					// update is — the marketplace serves whatever it publishes at
 					// the moment of the call — so recording the version we asked
 					// for made `install --check` compare that number against a copy
@@ -956,9 +985,6 @@ export function PluginsScreen() {
 				if (action !== "install") {
 					modal.hideModal();
 				}
-				if (action === "update") {
-					await warnIfVersionMismatch(plugin.id);
-				}
 				fetchData();
 			} catch (error) {
 				modal.hideModal();
@@ -970,7 +996,9 @@ export function PluginsScreen() {
 	const handleUpdate = async () => {
 		const item = selectableItems[pluginsState.selectedIndex];
 		if (!item || item.kind !== "plugin") return;
-		if (!item.plugin.hasUpdate && !item.plugin.contentStale) return;
+		// The row said "update" or "stale — reinstall"; nothing else is work.
+		const status = statuses.get(item.plugin.id);
+		if (status?.action !== "update" && status?.action !== "repair") return;
 
 		const plugin = item.plugin;
 		const scope: PluginScope =
@@ -979,28 +1007,26 @@ export function PluginsScreen() {
 		// No version bump to install over — the files changed underneath an
 		// unchanged version, and `plugin install` no-ops on "already installed".
 		// Only uninstall+install re-copies. See claude-cli.ts repairPlugin.
-		const repairing = !plugin.hasUpdate && plugin.contentStale;
+		const repairing = status.action === "repair";
 
 		modal.loading(
 			repairing
 				? `Repairing ${plugin.name}…\nclaude plugin uninstall ${plugin.id} --scope ${scope} && claude plugin install ${plugin.id} --scope ${scope}`
 				: `Updating ${plugin.name}…\nclaude plugin install ${plugin.id} --scope ${scope}`,
 		);
+		const reasons = noMoveReasons();
 		try {
 			// One plugin, but the SAME engine — so a single update records the
 			// version that landed and touches every scope that is behind, exactly
-			// as `claudeup update` does. `repairing` is not re-derived here: the
-			// planner already encodes it as the `repair` action.
-			const catalog = new Map(
-				pluginsState.plugins.status === "success"
-					? pluginsState.plugins.data.map((p) => [p.id, p] as const)
-					: [[plugin.id, plugin] as const],
-			);
-			const items = planPluginUpdates({ [plugin.id]: "latest" }, catalog);
+			// as `claudeup update` does. The plan item IS the row's status: the
+			// classifier's answer for this plugin under its real pin (the
+			// profile's, or "latest" for an undeclared install — see pinForRow),
+			// so what runs is exactly what the row claimed.
 			const result = await applyPlugins(
-				items,
+				[status],
 				state.projectPath || process.cwd(),
 				REAL_PLUGIN_DEPS,
+				reasons.reporter,
 			);
 			modal.hideModal();
 			if (result.failed.length > 0) {
@@ -1011,7 +1037,16 @@ export function PluginsScreen() {
 				);
 				return;
 			}
-			await warnIfVersionMismatch(plugin.id);
+			// Ran, exited 0, moved nothing — and the row will not have moved
+			// either. Saying nothing here is what made "press U, press U,
+			// forever": the CLI names the cause, so the screen does too.
+			if (result.unchanged.length > 0) {
+				await modal.message(
+					"No change",
+					reasons.lines(result.unchanged),
+					"info",
+				);
+			}
 			fetchData();
 		} catch (error) {
 			modal.hideModal();
@@ -1034,29 +1069,26 @@ export function PluginsScreen() {
 	const handleUpdateAll = async () => {
 		if (pluginsState.plugins.status !== "success") return;
 
-		// Content-stale plugins are included: they need repairing, and excluding
-		// them meant "update all" left the machine with silently outdated files.
-		const updatable = pluginsState.plugins.data.filter(
-			(p) => p.hasUpdate || p.contentStale,
-		);
-		if (updatable.length === 0) return;
+		// Exactly the rows that say "update" or "stale — reinstall", 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.
+		const items = [...statuses.values()]
+			.filter((s) => s.action === "update" || s.action === "repair")
+			.sort((a, b) => a.pluginId.localeCompare(b.pluginId));
+		if (items.length === 0) return;
 
 		const projectPath = state.projectPath || process.cwd();
-		// The screen's own list IS the catalog the planner needs.
-		const catalog = new Map(pluginsState.plugins.data.map((p) => [p.id, p]));
-		const items = planPluginUpdates(
-			Object.fromEntries(updatable.map((p) => [p.id, "latest"])),
-			catalog,
-		);
 		const total = items.filter(pluginNeedsWork).length;
 
 		let done = 0;
+		const reasons = noMoveReasons();
 		const reporter: ApplyReporter = {
 			begin: (name) => {
 				done++;
 				modal.loading(`Updating ${name} (${done}/${total})…`);
 			},
-			finish: () => {},
+			finish: reasons.reporter.finish,
 			detach: (work) => work(),
 		};
 
@@ -1067,10 +1099,6 @@ export function PluginsScreen() {
 				REAL_PLUGIN_DEPS,
 				reporter,
 			);
-			const updatedPluginIds = items
-				.filter(pluginNeedsWork)
-				.map((i) => i.pluginId)
-				.filter((id) => !result.failed.includes(id));
 			modal.hideModal();
 			if (result.failed.length > 0) {
 				await modal.message(
@@ -1079,18 +1107,12 @@ export function PluginsScreen() {
 					"error",
 				);
 			}
-			// Batch mismatch checks into a single modal
-			const allMismatches: VersionMismatchInfo[] = [];
-			for (const pluginId of updatedPluginIds) {
-				try {
-					const m = await checkSinglePluginMismatch(pluginId, projectPath);
-					if (m) allMismatches.push(m);
-				} catch {
-					// best-effort
-				}
-			}
-			if (allMismatches.length > 0) {
-				mismatchModal.show(allMismatches);
+			if (result.unchanged.length > 0) {
+				await modal.message(
+					"No change",
+					reasons.lines(result.unchanged),
+					"info",
+				);
 			}
 			fetchData();
 		} catch (error) {
@@ -1099,39 +1121,11 @@ export function PluginsScreen() {
 		}
 	};
 
-	/**
-	 * Manual on-demand check for plugin version mismatches across projects.
-	 * Bound to the `m` keybind. Shows a success message if everything is
-	 * aligned, or the interactive fix modal if any mismatches are found.
-	 */
-	const handleCheckMismatches = async () => {
-		try {
-			const projectPath = state.projectPath || process.cwd();
-			const mismatches = await checkPluginVersionMismatches(projectPath);
-			if (mismatches.length === 0) {
-				await modal.message(
-					"No Mismatches",
-					"All enabled plugins in this project will load their expected versions. No action needed.",
-					"success",
-				);
-				return;
-			}
-			mismatchModal.show(mismatches);
-		} catch (error) {
-			await modal.message(
-				"Error",
-				`Failed to check mismatches: ${error}`,
-				"error",
-			);
-		}
-	};
-
 	const handleScopeToggle = async (scope: "user" | "project" | "local") => {
 		const item = selectableItems[pluginsState.selectedIndex];
 		if (!item || item.kind !== "plugin") return;
 
 		const plugin = item.plugin;
-		const latestVersion = plugin.version || "0.0.0";
 		const scopeLabel =
 			scope === "user" ? "User" : scope === "project" ? "Project" : "Local";
 
@@ -1145,8 +1139,13 @@ export function PluginsScreen() {
 		// 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.
-		const action = resolveScopeAction(scopeData, latestVersion);
+		// 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.
+		const action = resolveScopeAction(
+			scopeData,
+			scopeIsBehind(statuses.get(plugin.id), scope),
+		);
 
 		try {
 			if (action === "uninstall") {
@@ -1181,9 +1180,6 @@ export function PluginsScreen() {
 			if (action !== "install") {
 				modal.hideModal();
 			}
-			if (action === "update") {
-				await warnIfVersionMismatch(plugin.id);
-			}
 			fetchData();
 		} catch (error) {
 			modal.hideModal();
@@ -1369,33 +1365,53 @@ export function PluginsScreen() {
 				{ keys: ["u", "/", "p", "/", "l"], label: "toggle" },
 				{ keys: ["U"], label: "update" },
 				{ keys: ["a"], label: "all" },
-				{ keys: ["m"], label: "mismatches" },
 				{ keys: ["s"], label: "profile" },
 				{ keys: ["/"], label: "search" },
 			];
 
 	const scopeLabel = pluginsState.scope === "global" ? "Global" : "Project";
 	const plugins: PluginInfo[] = shownPlugins ?? [];
-	const installedCount = plugins.filter((p) => p.enabled).length;
-	const updateCount = plugins.filter(
-		(p) =>
-			(p.hasUpdate || p.contentStale) &&
-			(p.userScope?.enabled ||
-				p.projectScope?.enabled ||
-				p.localScope?.enabled),
-	).length;
-	const subtitle = `${scopeLabel} │ ${installedCount} installed${updateCount > 0 ? ` │ ${updateCount} updates` : ""}`;
-	const searchPlaceholder = `${scopeLabel} │ ${installedCount} installed${updateCount > 0 ? ` │ ${updateCount} ⬆` : ""} │ / to search`;
-
+	// "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);
+	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.
+	const counts = countPluginStates(statuses.values());
+	const updateCount = counts.update + counts.repair;
+	// Cannot tell whether it is current. Counted and shown separately: folding
+	// it into `updateCount` would overstate, and folding it into silence is the
+	// "cannot tell rendered as fine" bug.
+	const unknownCount = counts.unknown;
+	const installCount = counts.install;
+	const subtitle = `${scopeLabel} │ ${installedCount} installed${updateCount > 0 ? ` │ ${updateCount} updates` : ""}${installCount > 0 ? ` │ ${installCount} to install` : ""}${unknownCount > 0 ? ` │ ${unknownCount} unverified` : ""}`;
+	const searchPlaceholder = `${scopeLabel} │ ${installedCount} installed${updateCount > 0 ? ` │ ${updateCount} ⬆` : ""}${installCount > 0 ? ` │ ${installCount} +` : ""}${unknownCount > 0 ? ` │ ${unknownCount} ?` : ""} │ / to search`;
+
+	const catalogNotice = buildCatalogNotice({
+		failures: catalogFailures,
+		unverifiedPlugins: [...statuses.values()].filter(
+			(s) => s.reason === "catalog-unverified",
+		).length,
+		width: dimensions.terminalWidth,
+		now: nowTick,
+	});
+	// Without a resolved profile, exact pins are unknown here and every row is
+	// judged against "latest". Saying so is what keeps a row that disagrees with
+	// `claudeup update <profile>` from reading as a contradiction.
 	const notice = isReloading ? (
 		<text fg={theme.colors.muted}>⟳ Refreshing catalogs from GitHub…</text>
 	) : (
-		buildCatalogNotice({
-			failures: catalogFailures,
-			unverifiedPlugins: plugins.filter((p) => p.updateCheckFailed).length,
-			width: dimensions.terminalWidth,
-			now: nowTick,
-		})
+		(catalogNotice ??
+		(pins === null ? (
+			<text fg={theme.colors.muted}>
+				profile not resolved — states judged against latest
+			</text>
+		) : null))
 	);
 
 	return (

package/src/ui/state/types.ts

@@ -1,6 +1,5 @@
 import type { ModelsConfig, ModelsStatus } from "../../services/models-core.js";
 import type { PluginInfo } from "../../services/plugin-manager.js";
-import type { VersionMismatchInfo } from "../../services/plugin-version-check.js";
 import type {
 	PluginComponent,
 	PluginSkillDetail,
@@ -113,12 +112,6 @@ export type ModalState =
 	| {
 			type: "loading";
 			message: string;
-	  }
-	| {
-			type: "version-mismatch";
-			mismatches: VersionMismatchInfo[];
-			onFix: () => void;
-			onDismiss: () => void;
 	  };
 
 // ============================================================================