claudeup 6.5.1 → 6.6.0

package/src/services/version-snapshot.ts

@@ -2,7 +2,7 @@
  * version-snapshot.ts — detect plugin changes that happened outside claudeup.
  *
  * Plugins get updated by things claudeup does not control: Claude Code's own
- * `plugin install`/`update`, the `claudeup claude` prerunner, or a direct CLI
+ * `plugin install`/`update`, or a direct CLI
  * call. All of them write `installed_plugins.json`; none of them tell the user
  * anything the next time claudeup opens, so versions move underfoot silently.
  *

package/src/types/bun.d.ts

@@ -7,6 +7,9 @@
  * payload from `Bun.stdin.stream()` because that is the fastest path on the
  * hottest code claudeup has (a PreToolUse hook runs on every Agent call), so
  * the global is declared here rather than the call being rewritten.
+ * `services/tool-probe.ts` reads uv's `uv-receipt.toml` with `Bun.TOML.parse`
+ * (the receipt decides whether uv's silence may be read as "current"); a
+ * missing parser degrades to "cannot tell", so the member is optional.
  *
  * Keep this MINIMAL. Every member added here is a member nobody checks against
  * the real runtime; a full mirror of Bun's API would be a second, worse copy of
@@ -18,4 +21,7 @@ declare namespace Bun {
 	const stdin: {
 		stream(): AsyncIterable<Uint8Array>;
 	};
+	const TOML: {
+		parse(text: string): unknown;
+	};
 }

package/src/ui/App.tsx

@@ -6,17 +6,13 @@ import {
 	migrateMarketplaceRename,
 	recoverMarketplaceSettings,
 } from "../services/claude-settings.js";
-import { checkGitignore } from "../services/gitignore-prerun.js";
+import { checkGitignore } from "../services/gitignore-check.js";
 import {
 	applyAllSafeFixes,
 	loadGitignoreState,
 } from "../services/gitignore-service.js";
 import { repairAllMarketplaces } from "../services/local-marketplace.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
-import {
-	type VersionMismatchInfo,
-	checkPluginVersionMismatches,
-} from "../services/plugin-version-check.js";
 import {
 	type VersionCheckResult,
 	checkForUpdates,
@@ -26,7 +22,6 @@ import { ProgressBar } from "./components/layout/ProgressBar.js";
 import { ModalContainer } from "./components/modals/index.js";
 import { useGitignoreModal } from "./hooks/useGitignoreModal.js";
 import { useKeyboardHandler } from "./hooks/useKeyboardHandler.js";
-import { useMismatchModal } from "./hooks/useMismatchModal.js";
 import {
 	AliasScreen,
 	CliToolsScreen,
@@ -365,10 +360,6 @@ function AppContent({ onExit }: AppContentProps) {
 	const [showDebug, setShowDebug] = useState(false);
 	const [updateInfo, setUpdateInfo] = useState<VersionCheckResult | null>(null);
 	const [recoveryReport, setRecoveryReport] = useState<string | null>(null);
-	const [mismatchData, setMismatchData] = useState<
-		VersionMismatchInfo[] | null
-	>(null);
-	const mismatchModal = useMismatchModal();
 	const [gitignoreData, setGitignoreData] = useState<{
 		violationCount: number;
 		safeCount: number;
@@ -400,15 +391,8 @@ function AppContent({ onExit }: AppContentProps) {
 		return () => clearTimeout(timer);
 	}, [recoveryReport]);
 
-	// Show mismatch modal when data arrives
-	useEffect(() => {
-		if (!mismatchData || mismatchData.length === 0) return;
-		mismatchModal.show(mismatchData);
-		setMismatchData(null);
-	}, [mismatchData, mismatchModal]);
-
 	// Show gitignore modal — wait for the modal slot to be free so we don't
-	// stomp on the mismatch modal that may have just been shown.
+	// stomp on another modal that may have just been shown.
 	useEffect(() => {
 		if (!gitignoreData) return;
 		if (state.modal) return;
@@ -482,15 +466,6 @@ function AppContent({ onExit }: AppContentProps) {
 			})
 			.catch(() => {}); // non-fatal
 
-		// Check for plugin version mismatches (the [0] index bug)
-		checkPluginVersionMismatches(process.cwd())
-			.then((mismatches) => {
-				if (mismatches.length > 0) {
-					setMismatchData(mismatches);
-				}
-			})
-			.catch(() => {}); // non-fatal
-
 		// Check for gitignore manifest violations and surface a popup if any.
 		// Loads twice (once for count, once when user picks "fix safe") because
 		// the second load happens after edits — keeps detection cheap on startup.

package/src/ui/adapters/cliToolsAdapter.ts

@@ -0,0 +1,176 @@
+/**
+ * A CLI Tools row, built from the SAME probe facts and the SAME classifier
+ * `claudeup update` plans with.
+ *
+ * The screen used to carry its own probe — a shell `which`, `npm view` per
+ * tool, and a private comparator that read "1.2.3-beta" as "1.2.3" — so the
+ * row and the CLI could disagree about the same tool. Now the row's state is
+ * `classifyTool(spec, facts)`, and for a tool the active profile declares the
+ * spec IS the profile's (`specForCatalogTool`), so the two cannot differ.
+ *
+ * The same goes for the COMMANDS: a declared tool's row builds them with
+ * `binCommandForState`, the rule `claudeup update`'s apply path uses, so the
+ * row's target and the row's key can never aim at different versions.
+ *
+ * Pure: no IO, no React. The screen gathers facts; this only assembles.
+ */
+
+import type { CliTool } from "../../data/cli-tools.js";
+import {
+	cliToolInstall,
+	cliToolUpdate,
+} from "../../services/cli-tool-commands.js";
+import {
+	type InstallInfo,
+	type ToolFacts,
+	type ToolStatus,
+	classifyTool,
+} from "../../services/tool-probe.js";
+import { binCommandForState } from "../../services/toolchain.js";
+import type { BinRequirement, ResolvedBin } from "../../types/index.js";
+import type { Command } from "../../utils/command-utils.js";
+import type { StatusTone } from "../renderers/pluginStatusText.js";
+
+export interface CliToolRow {
+	tool: CliTool;
+	/** The requirement the tool was probed through (closure → detected → catalogue). */
+	spec: BinRequirement;
+	/** True until facts arrive. */
+	checking: boolean;
+	/** Null while checking. */
+	status: ToolStatus | null;
+	install?: InstallInfo;
+	/**
+	 * What Enter runs for an installed tool. For a tool the active profile
+	 * declares this is the SAME command `claudeup update` would run for the
+	 * same row (pin included); otherwise the DETECTED method's updater, so it
+	 * names the installer the row was probed through.
+	 */
+	updateCommand?: Command;
+	/** What Enter runs for a tool that is not installed. */
+	installCommand: Command;
+}
+
+/**
+ * Did this spec come from the resolver's closure — i.e. does the active profile
+ * declare this tool?
+ *
+ * `ResolvedBin` is `BinRequirement` plus `sources`, and only the resolver adds
+ * them, so the provenance travels with the spec itself rather than being
+ * re-derived here (which would be a second copy of `specForCatalogTool`'s
+ * branch 1, free to disagree with it).
+ */
+function declaredSpec(spec: BinRequirement): ResolvedBin | null {
+	const candidate = spec as ResolvedBin;
+	return Array.isArray(candidate.sources) ? candidate : null;
+}
+
+export function buildToolRow(
+	tool: CliTool,
+	spec: BinRequirement,
+	facts: ToolFacts | undefined,
+	install?: InstallInfo,
+): CliToolRow {
+	const declared = declaredSpec(spec);
+	// A declared tool installs at its pin, the way `claudeup update` does; the
+	// catalogue entry has no pin to honour.
+	const installCommand =
+		(declared && binCommandForState("install", null, declared)) ||
+		cliToolInstall(tool);
+	const base = { tool, spec, installCommand, ...(install ? { install } : {}) };
+	if (!facts) return { ...base, checking: true, status: null };
+	const status = classifyTool(spec, facts);
+	const updateCommand = updateCommandFor(tool, declared, status, install);
+	return {
+		...base,
+		checking: false,
+		status,
+		...(updateCommand ? { updateCommand } : {}),
+	};
+}
+
+/**
+ * The command the row's key runs, from the same rule as the row's state.
+ *
+ * A declared tool goes through `binCommandForState` — the CLI apply path's own
+ * builder over the PROFILE's requirement — so a row whose target is the pin
+ * installs the pin. Building `@latest` here (what this used to do, always) let
+ * the TUI overshoot a pin the CLI hits exactly, and the tool then classified
+ * `unknown / ahead-of-pin` for good: claudeup never downgrades.
+ *
+ * An undeclared catalogue tool keeps the screen's own rule, "follow how it IS
+ * installed": there is no pin to honour, and `pnpm`/`yarn` have no
+ * `BinInstaller` counterpart to hand the shared builder.
+ */
+function updateCommandFor(
+	tool: CliTool,
+	declared: ResolvedBin | null,
+	status: ToolStatus,
+	install: InstallInfo | undefined,
+): Command | undefined {
+	if (!isInstalled(status)) return undefined;
+	if (declared) {
+		return binCommandForState("upgrade", status.target, declared) ?? undefined;
+	}
+	if (!install) return undefined;
+	return cliToolUpdate(tool, install.primary, install.brewFormula) ?? undefined;
+}
+
+/** On PATH, as far as the probe could tell. */
+export function isInstalled(status: ToolStatus | null): boolean {
+	return status !== null && status.state !== "install";
+}
+
+/** A version for display, with exactly one leading "v". */
+export function displayVersion(v: string): string {
+	return `v${v.replace(/^v/i, "")}`;
+}
+
+export interface CliToolStatusText {
+	/** Text after the version, with its leading space; "" for nothing to say. */
+	suffix: string;
+	tone: StatusTone;
+}
+
+/**
+ * The row's status words. An `unknown` shows its note verbatim — the same
+ * string `claudeup update` prints for that tool.
+ */
+export function cliToolStatusText(row: CliToolRow): CliToolStatusText {
+	const { status } = row;
+	if (row.checking || !status) return { suffix: " ...", tone: "muted" };
+	switch (status.state) {
+		case "unknown":
+			return {
+				suffix: ` ? ${status.note ?? "cannot tell whether it is current"}`,
+				tone: "warning",
+			};
+		case "upgrade":
+			return {
+				suffix: status.target
+					? ` → ${displayVersion(status.target)}`
+					: " update available",
+				tone: "warning",
+			};
+		case "install":
+		case "current":
+			return { suffix: "", tone: "muted" };
+	}
+}
+
+/** Header counts, from the rows' states. */
+export function countToolRows(rows: readonly CliToolRow[]): {
+	installed: number;
+	updates: number;
+	unverified: number;
+} {
+	let installed = 0;
+	let updates = 0;
+	let unverified = 0;
+	for (const row of rows) {
+		if (isInstalled(row.status)) installed++;
+		if (row.status?.state === "upgrade") updates++;
+		if (row.status?.state === "unknown") unverified++;
+	}
+	return { installed, updates, unverified };
+}

package/src/ui/adapters/pluginsAdapter.ts

@@ -1,5 +1,7 @@
 import type { PluginInfo } from "../../services/plugin-manager.js";
 import type { PluginComponent } from "../../services/skills-manager.js";
+import type { ApplyReporter } from "../../services/update-engine.js";
+import type { PluginUpdateItem } from "../../services/update-plan.js";
 import type { Marketplace } from "../../types/index.js";
 import type { PluginContentsEntry } from "../state/types.js";
 
@@ -37,6 +39,12 @@ export interface PluginPluginItem {
 	isExpandable: boolean;
 	/** True when its component rows follow below. */
 	isExpanded: boolean;
+	/**
+	 * The classifier's answer for this plugin — the same item `claudeup 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.
+	 */
+	status: PluginUpdateItem | null;
 }
 
 /**
@@ -87,6 +95,8 @@ export interface BuildPluginBrowserItemsArgs {
 	collapsedMarketplaces: Set<string>;
 	expandedPlugins?: Set<string>;
 	pluginContents?: Map<string, PluginContentsEntry>;
+	/** `classifyPluginRows` output, by plugin id. A plugin absent from it gets no status. */
+	statuses?: ReadonlyMap<string, PluginUpdateItem>;
 }
 
 /**
@@ -111,6 +121,7 @@ function pushPluginItems(
 	marketplace: Marketplace,
 	expandedPlugins: Set<string>,
 	pluginContents: Map<string, PluginContentsEntry>,
+	statuses: ReadonlyMap<string, PluginUpdateItem>,
 ): void {
 	const repo = pluginContentsRepo(plugin, marketplace);
 	const isExpandable = !plugin.isOrphaned && !!repo;
@@ -123,6 +134,7 @@ function pushPluginItems(
 		plugin,
 		isExpandable,
 		isExpanded,
+		status: statuses.get(plugin.id) ?? null,
 	});
 
 	if (!isExpanded) return;
@@ -214,6 +226,47 @@ function isMadAppGang(mp: Marketplace): boolean {
 	return (mp.source.repo ?? "").toLowerCase().startsWith("madappgang/");
 }
 
+// ─── "Ran, but nothing moved" ─────────────────────────────────────────────────
+
+/**
+ * Collect the engine's no-move reasons so the screen can name them.
+ *
+ * `ApplyResult.unchanged` is the whole point of the read-back: an item that
+ * ran, exited 0, and left the machine exactly as it was. The CLI prints
+ * `N item(s) ran but did not change:` with each cause; the TUI used to branch
+ * on `failed.length` alone, show a success, and refetch a row that had not
+ * moved — "press U, press U, forever", which is the experience the read-back
+ * was added to remove.
+ *
+ * The cause itself only ever reaches the reporter (`applyPlugins` formats it as
+ * `no change — <why>`), so this captures it there, exactly as `cli/update.ts`
+ * does with `finishedDetail`.
+ */
+export function noMoveReasons(): {
+	reporter: ApplyReporter;
+	/** One line per unchanged item, with its cause when one was reported. */
+	lines(unchanged: readonly string[]): string;
+} {
+	const why = new Map<string, string>();
+	return {
+		reporter: {
+			begin: () => {},
+			finish: (_ok, name, detail) => {
+				const reason = detail.replace(/^no change — /, "");
+				if (reason !== detail) why.set(name, reason);
+			},
+			detach: (work) => work(),
+		},
+		lines: (unchanged) =>
+			unchanged
+				.map((name) => {
+					const reason = why.get(name);
+					return reason ? `${name}: ${reason}` : name;
+				})
+				.join("\n"),
+	};
+}
+
 /**
  * Builds the flat list of items for the PluginsScreen list panel.
  * Extracted from PluginsScreen so it can be tested independently.
@@ -224,6 +277,7 @@ export function buildPluginBrowserItems({
 	collapsedMarketplaces,
 	expandedPlugins = new Set(),
 	pluginContents = new Map(),
+	statuses = new Map(),
 }: BuildPluginBrowserItemsArgs): PluginBrowserItem[] {
 	const pluginsByMarketplace = new Map<string, PluginInfo[]>();
 	for (const plugin of plugins) {
@@ -279,6 +333,7 @@ export function buildPluginBrowserItems({
 						marketplace,
 						expandedPlugins,
 						pluginContents,
+						statuses,
 					);
 				}
 			}
@@ -316,6 +371,7 @@ export function buildPluginBrowserItems({
 							communityVirtualMp,
 							expandedPlugins,
 							pluginContents,
+							statuses,
 						);
 					}
 				}
@@ -347,6 +403,7 @@ export function buildPluginBrowserItems({
 					marketplace,
 					expandedPlugins,
 					pluginContents,
+					statuses,
 				);
 			}
 		}

package/src/ui/components/modals/ModalContainer.tsx

@@ -6,7 +6,6 @@ import { InputModal } from "./InputModal.js";
 import { LoadingModal } from "./LoadingModal.js";
 import { MessageModal } from "./MessageModal.js";
 import { SelectModal } from "./SelectModal.js";
-import { VersionMismatchModal } from "./VersionMismatchModal.js";
 
 /**
  * Container that renders the active modal as an overlay
@@ -29,8 +28,6 @@ export function ModalContainer() {
 		modalRef.current = modal;
 		if (modal?.type === "select") {
 			setSelectIndex(modal.defaultIndex ?? 0);
-		} else if (modal?.type === "version-mismatch") {
-			setSelectIndex(0);
 		}
 	}
 
@@ -45,7 +42,6 @@ export function ModalContainer() {
 			else if (modal.type === "input") modal.onCancel();
 			else if (modal.type === "select") modal.onCancel();
 			else if (modal.type === "message") modal.onDismiss();
-			else if (modal.type === "version-mismatch") modal.onDismiss();
 			return;
 		}
 
@@ -54,7 +50,6 @@ export function ModalContainer() {
 			if (modal.type === "confirm") modal.onCancel();
 			else if (modal.type === "select") modal.onCancel();
 			else if (modal.type === "message") modal.onDismiss();
-			else if (modal.type === "version-mismatch") modal.onDismiss();
 			return;
 		}
 
@@ -75,19 +70,6 @@ export function ModalContainer() {
 			return;
 		}
 
-		// Version-mismatch modal — handle navigation and selection (2 options)
-		if (modal.type === "version-mismatch") {
-			if (key.name === "return" || key.name === "enter") {
-				if (selectIndex === 0) modal.onFix();
-				else modal.onDismiss();
-			} else if (key.name === "up" || key.name === "k") {
-				setSelectIndex((prev) => Math.max(0, prev - 1));
-			} else if (key.name === "down" || key.name === "j") {
-				setSelectIndex((prev) => Math.min(1, prev + 1));
-			}
-			return;
-		}
-
 		// Message modal — Enter to dismiss
 		if (modal.type === "message") {
 			if (key.name === "return" || key.name === "enter") {
@@ -155,14 +137,6 @@ export function ModalContainer() {
 			case "loading":
 				return <LoadingModal message={modal.message} />;
 
-			case "version-mismatch":
-				return (
-					<VersionMismatchModal
-						mismatches={modal.mismatches}
-						defaultIndex={selectIndex}
-					/>
-				);
-
 			default:
 				return null;
 		}

package/src/ui/hooks/index.ts

@@ -1,3 +1,2 @@
 export { useKeyboardHandler } from "./useKeyboardHandler.js";
 export { useKeyboard } from "./useKeyboard.js";
-export { useMismatchModal } from "./useMismatchModal.js";

package/src/ui/hooks/useGitignoreModal.ts

@@ -3,9 +3,8 @@ import { useApp, useNavigation } from "../state/AppContext.js";
 import type { ModalState } from "../state/types.js";
 
 /**
- * Startup gitignore-violation modal. Mirrors `useMismatchModal` so the
- * two flows feel identical to the user — claudeup launches, detects
- * a problem, asks "add missing ignores / open the tab / dismiss".
+ * Startup gitignore-violation modal: claudeup launches, detects a problem, and
+ * asks "add missing ignores / open the tab / dismiss".
  *
  * Pure builder is exported separately for tests.
  */