claudeup 6.5.1 → 6.7.1

package/src/ui/renderers/pluginRenderers.tsx

@@ -1,11 +1,16 @@
 import type React from "react";
 import { getMarketplaceVersion } from "../../services/marketplace-fetcher.js";
 import {
+	compareVersions,
 	isEnabledButNotInstalled,
 	isInstalledInScope,
 } from "../../services/plugin-manager.js";
 import type { ScopeStatus } from "../../services/plugin-manager.js";
 import type { PluginComponentKind } from "../../services/skills-manager.js";
+import type {
+	PluginUpdateAction,
+	PluginUpdateItem,
+} from "../../services/update-plan.js";
 import { isKnownVersion } from "../../services/version-snapshot.js";
 import type { PluginRelease } from "../../types/index.js";
 import { highlightMatches } from "../../utils/fuzzy-search.js";
@@ -32,6 +37,8 @@ import type {
 import { componentBadge as badgeColors } from "../theme-mode.js";
 import { type UiColor, theme } from "../theme.js";
 import { renderMarkdown } from "./markdownRenderer.js";
+import { type PluginRowSegment, pluginRowText } from "./pluginRowText.js";
+import { type StatusTone, pluginStatusText } from "./pluginStatusText.js";
 
 // ─── Category renderers ───────────────────────────────────────────────────────
 
@@ -137,6 +144,47 @@ function categoryDetail(
 
 // ─── Plugin renderers ─────────────────────────────────────────────────────────
 
+/**
+ * The row's text after the name, drawn exactly as `pluginRowText` produced it.
+ *
+ * On a selected row the tone's hue is surrendered to the selection (see
+ * MetaText); the words are the same either way.
+ */
+function RowSegments({
+	segments,
+	selected,
+}: {
+	segments: PluginRowSegment[];
+	selected: boolean;
+}): React.ReactNode {
+	return (
+		<>
+			{segments.map((seg, i) => {
+				const key = `${i}:${seg.text}`;
+				if (seg.tone === "text") return <span key={key}>{seg.text}</span>;
+				if (seg.tone === "info") {
+					return (
+						<span
+							key={key}
+							fg={selected ? theme.selection.fg : theme.colors.info}
+						>
+							{seg.text}
+						</span>
+					);
+				}
+				return (
+					<MetaText
+						key={key}
+						text={seg.text}
+						tone={seg.tone}
+						selected={selected}
+					/>
+				);
+			})}
+		</>
+	);
+}
+
 function pluginRow(
 	item: PluginPluginItem,
 	isSelected: boolean,
@@ -147,57 +195,10 @@ function pluginRow(
 	const hasLocal = !!plugin.localScope?.enabled;
 	const hasAnyScope = hasUser || hasProject || hasLocal;
 
-	// Enabled somewhere but nothing actually installed — a broken state that used
-	// to render exactly like a healthy install.
-	const notInstalled = isEnabledButNotInstalled(plugin);
-
-	// A known version is one we can actually show. "0.0.0" means installed with an
-	// unknown version (every official Anthropic plugin records it) — never render it.
-	const shownVersion = isKnownVersion(plugin.installedVersion)
-		? plugin.installedVersion
-		: undefined;
-
-	let versionStr = "";
-	if (plugin.isOrphaned) {
-		// "deprecated" alone reads as "delete me" — but a plugin that merely moved
-		// marketplace is still published, and deleting it loses it for no reason.
-		versionStr = plugin.movedTo ? ` moved → ${plugin.movedTo}` : " deprecated";
-	} else if (notInstalled) {
-		versionStr = " not installed";
-	} else if (hasAnyScope) {
-		// "what just changed" and "what is still available" are independent facts,
-		// and both can be true at once: the prerunner can move a plugin 2.9.0→3.0.1
-		// while the marketplace already offers 3.3.1. These used to share one
-		// if/else chain, so the "updated" badge silently swallowed the pending
-		// update — and the update only reappeared on the next refresh, which read
-		// as the state spontaneously changing. Render them as separate clauses.
-		if (plugin.recentlyUpdatedFrom && shownVersion) {
-			// Show what actually happened, not just where it landed — the update may
-			// have come from Claude Code or the prerunner without ever telling us.
-			versionStr = ` v${plugin.recentlyUpdatedFrom} → v${shownVersion} updated`;
-		} else if (plugin.recentlyInstalled) {
-			// Newly seen. Version is optional here: a plugin can be genuinely
-			// installed with no version we can name.
-			versionStr = shownVersion ? ` v${shownVersion} new` : " new";
-		} else if (shownVersion) {
-			versionStr = ` v${shownVersion}`;
-		}
-
-		// Pending update, regardless of which badge above applied.
-		if (plugin.hasUpdate && plugin.version && versionStr) {
-			versionStr += ` → v${plugin.version} available`;
-		} else if (plugin.contentStale && versionStr) {
-			// Same version, different files. The version compare says "up to date"
-			// and is wrong — only a reinstall delivers the current content.
-			versionStr += " stale — reinstall";
-		} else if (plugin.updateCheckFailed && versionStr) {
-			// No update to show — but we never confirmed there wasn't one. Neither
-			// upstream source could be read, so the compare ran against the pinned
-			// clone, which by policy never advances. A bare version here reads as
-			// "current", which is the exact claim we cannot make.
-			versionStr += " ? unverified";
-		}
-	}
+	// Everything after the name — version, history badge, status — comes from
+	// ONE pure function over the classifier's answer, and is drawn verbatim in
+	// every branch below. No branch here decides plugin state.
+	const { segments } = pluginRowText(item);
 
 	// Same glyphs as a marketplace row, in a cell that is always two columns
 	// wide. Both halves matter: a different arrow at each level reads as a
@@ -218,23 +219,23 @@ function pluginRow(
 				/>{" "}
 				{arrow}
 				{plugin.name}
-				{versionStr}{" "}
+				<RowSegments segments={segments} selected={true} />{" "}
 			</text>
 		);
 	}
 
 	// Fuzzy highlight
-	const segments = item.matches
+	const nameSegments = item.matches
 		? highlightMatches(plugin.name, item.matches)
 		: null;
-	const displayName = segments
-		? segments.map((seg) => seg.text).join("")
+	const displayName = nameSegments
+		? nameSegments.map((seg) => seg.text).join("")
 		: plugin.name;
 
 	if (plugin.isOrphaned) {
-		const ver = isKnownVersion(plugin.installedVersion)
-			? ` v${plugin.installedVersion}`
-			: "";
+		// The red squares are the presence marker for "published by no marketplace
+		// we read". WHAT is known about it — moved, withdrawn, or its marketplace
+		// was never read — is the status suffix, the same words the CLI prints.
 		return (
 			<text fg={theme.colors.text}>
 				<span fg={theme.colors.danger}> ■■■ </span>
@@ -242,12 +243,16 @@ function pluginRow(
 				    name lands in the same column as every other plugin's. */}
 				<span>{"  "}</span>
 				<span fg={theme.colors.muted}>{displayName}</span>
-				{ver ? <span fg={theme.colors.warning}>{ver}</span> : null}
-				<span fg={theme.colors.danger}> deprecated</span>
+				<RowSegments segments={segments} selected={false} />
 			</text>
 		);
 	}
 
+	const installedSomewhere =
+		isInstalledInScope(plugin.userScope) ||
+		isInstalledInScope(plugin.projectScope) ||
+		isInstalledInScope(plugin.localScope);
+
 	return (
 		<text fg={theme.colors.text}>
 			<span> </span>
@@ -256,41 +261,77 @@ function pluginRow(
 			<span fg={theme.colors.dim}>{arrow}</span>
 			<span
 				fg={
-					hasAnyScope && !notInstalled ? theme.colors.text : theme.colors.muted
+					hasAnyScope && installedSomewhere
+						? theme.colors.text
+						: theme.colors.muted
 				}
 			>
 				{displayName}
 			</span>
-			<MetaText
-				text={versionStr}
-				tone={
-					plugin.recentlyUpdatedFrom || plugin.recentlyInstalled
-						? "success"
-						: // "not installed" is a broken state — enabled somewhere with
-							// nothing actually installed — while a pending update is
-							// routine. They shared `warning` and so read as the same
-							// severity; red vs amber is the distinction that matters.
-							notInstalled
-							? "danger"
-							: plugin.hasUpdate
-								? "warning"
-								: plugin.updateCheckFailed
-									? // Dimmer than a real update: nothing is known to be
-										// wrong. But not `muted` either, which is the colour
-										// of a verified-current plugin.
-										"warning"
-									: "muted"
-				}
-			/>
+			<RowSegments segments={segments} selected={false} />
 		</text>
 	);
 }
 
+const ACTION_LABEL: Record<PluginUpdateAction, string> = {
+	install: "NOT INSTALLED",
+	update: "UPDATE AVAILABLE",
+	repair: "NEEDS REINSTALL",
+	current: "UP TO DATE",
+	unknown: "UNKNOWN",
+};
+
+/** Resolved at render time, so a theme switch is honoured. */
+function toneColor(tone: StatusTone): UiColor {
+	switch (tone) {
+		case "danger":
+			return theme.colors.danger;
+		case "warning":
+			return theme.colors.warning;
+		case "success":
+			return theme.colors.success;
+		case "info":
+			return theme.colors.info;
+		case "muted":
+			return theme.colors.muted;
+	}
+}
+
+/**
+ * The detail panel's `Status:` line: the classifier's action, and its note
+ * VERBATIM — the same words `claudeup update` prints for this plugin.
+ */
+function StatusLine({
+	status,
+}: {
+	status: PluginUpdateItem | null;
+}): React.ReactNode {
+	if (!status) return null;
+	const tone =
+		status.action === "current" ? "success" : pluginStatusText(status).tone;
+	const detail = status.note
+		? status.note
+		: status.action === "update" && status.target
+			? `→ v${status.target}`
+			: "";
+	return (
+		<KeyValueLine
+			label="Status"
+			value={
+				<span>
+					<span fg={toneColor(tone)}>{ACTION_LABEL[status.action]}</span>
+					{detail ? <span fg={theme.colors.text}> {detail}</span> : null}
+				</span>
+			}
+		/>
+	);
+}
+
 function pluginDetail(
 	item: PluginPluginItem,
 	fetched?: PluginContentsEntry,
 ): React.ReactNode {
-	const { plugin } = item;
+	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".
@@ -299,25 +340,32 @@ function pluginDetail(
 		isInstalledInScope(plugin.projectScope) ||
 		isInstalledInScope(plugin.localScope);
 	const brokenInstall = isEnabledButNotInstalled(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";
 
-	// Orphaned/deprecated plugin
+	// Published by no marketplace we read. The status line says which of the
+	// three things that means — moved, withdrawn, or its marketplace unread.
 	if (plugin.isOrphaned) {
 		return (
 			<box flexDirection="column">
 				<box justifyContent="center">
 					<text bg={theme.colors.warning} fg={theme.hints.fg}>
-						<strong> {plugin.name} — DEPRECATED </strong>
+						<strong> {plugin.name} — NOT LISTED </strong>
 					</text>
 				</box>
+				<box marginTop={1}>
+					<StatusLine status={status} />
+				</box>
 				<box marginTop={1}>
 					<text fg={theme.colors.warning}>
-						This plugin is no longer in the marketplace.
+						No marketplace claudeup read lists this plugin.
 					</text>
 				</box>
 				<box marginTop={1}>
 					<text fg={theme.colors.muted}>
-						It was removed from the marketplace but still referenced in your
-						settings. Press d to uninstall and clean up.
+						It is still installed or referenced in your settings. Press d to
+						uninstall and clean up, or to migrate it if it moved.
 					</text>
 				</box>
 				<ActionHints
@@ -365,8 +413,16 @@ function pluginDetail(
 	}
 
 	const showVersion = isKnownVersion(plugin.version ?? undefined);
+	// The shared comparator, not `!==`: "1.2" and "1.2.0" are the same version,
+	// and the classifier's `Status:` line right above says so. Raw inequality
+	// made this line contradict it. `null` (no shared ordering) is a genuine
+	// difference and shows.
 	const showInstalledVersion =
-		isInstalled && isKnownVersion(plugin.installedVersion);
+		isInstalled &&
+		isKnownVersion(plugin.installedVersion) &&
+		plugin.installedVersion !== undefined &&
+		plugin.version !== null &&
+		compareVersions(plugin.version, plugin.installedVersion) !== 0;
 
 	return (
 		<box flexDirection="column">
@@ -376,7 +432,7 @@ function pluginDetail(
 					<strong>
 						{" "}
 						{plugin.name}
-						{isInstalled && plugin.hasUpdate ? " ⬆" : ""}{" "}
+						{needsWork ? " ⬆" : ""}{" "}
 					</strong>
 				</text>
 			</box>
@@ -414,14 +470,14 @@ function pluginDetail(
 			</box>
 
 			{/* Metadata */}
+			<StatusLine status={status} />
 			{showVersion ? (
 				<KeyValueLine
 					label="Version"
 					value={
 						<span>
 							<span fg={theme.colors.link}>v{plugin.version}</span>
-							{showInstalledVersion &&
-							plugin.installedVersion !== plugin.version ? (
+							{showInstalledVersion ? (
 								<span> (v{plugin.installedVersion} installed)</span>
 							) : null}
 						</span>
@@ -435,7 +491,7 @@ function pluginDetail(
 			 * when in fact GitHub was never reached and the number came off a clone
 			 * that had not moved in days.
 			 */}
-			{plugin.updateCheckFailed ? (
+			{status?.reason === "catalog-unverified" ? (
 				<>
 					<KeyValueLine
 						label="Latest"
@@ -445,9 +501,7 @@ function pluginDetail(
 					/>
 					<box>
 						<text fg={theme.colors.muted}>
-							{plugin.updateCheckFailure
-								? `  ${plugin.updateCheckFailure.detail}. `
-								: "  "}
+							{"  "}
 							{plugin.catalogSource === "local-clone"
 								? "Version shown is from the pinned marketplace clone, so a newer release may exist. Press r to retry."
 								: "Press r to retry."}
@@ -521,12 +575,17 @@ function pluginDetail(
 			/>
 
 			{/* Update action */}
-			{isInstalled && plugin.hasUpdate ? (
+			{needsWork ? (
 				<ActionHints
 					hints={[
 						{
 							key: "U",
-							label: `Update to v${plugin.version}`,
+							label:
+								status?.action === "repair"
+									? "Reinstall (files changed)"
+									: status?.target
+										? `Update to v${status.target}`
+										: "Update",
 							tone: "primary",
 						},
 					]}

package/src/ui/renderers/pluginRowText.ts

@@ -0,0 +1,70 @@
+/**
+ * Everything a Plugins row shows after the plugin's name, as plain segments.
+ *
+ * `pluginRow` renders these segments verbatim — for the selected row, the
+ * unselected row, and an orphan alike — and holds no conditional on plugin
+ * state of its own. That is the point. The row used to carry three rules of
+ * its own, and each one was a way to disagree with `claudeup update`:
+ *
+ *  - every status clause was gated on the installed version being displayable,
+ *    so a plugin recorded as "0.0.0" showed no status and read as healthy;
+ *  - its reason words ("? not comparable") were not the CLI's reason;
+ *  - an orphan's text depended on the cursor — the selected row said
+ *    "moved → X", the unselected one always said "deprecated".
+ *
+ * Pure and `.ts`, so a test can assert on exactly what the row prints.
+ */
+
+import { isKnownVersion } from "../../services/version-snapshot.js";
+import type { PluginPluginItem } from "../adapters/pluginsAdapter.js";
+import { type StatusTone, pluginStatusText } from "./pluginStatusText.js";
+
+export interface PluginRowSegment {
+	text: string;
+	tone: StatusTone | "text";
+}
+
+export interface PluginRowText {
+	/** After the name: the version, a history badge, then the status suffix. */
+	segments: PluginRowSegment[];
+	/** The segments joined — exactly what the row renders after the name. */
+	text: string;
+}
+
+export function pluginRowText(item: PluginPluginItem): PluginRowText {
+	const { plugin, status } = item;
+	const segments: PluginRowSegment[] = [];
+
+	// 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;
+
+	// "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
+	// 2.9.0 → 3.0.1 while the marketplace already offers 3.3.1. So the badge
+	// replaces only the version, and the status suffix is always appended.
+	if (plugin.recentlyUpdatedFrom && shown) {
+		// Show what actually happened, not just where it landed — the update may
+		// have come from Claude Code or a direct CLI call without telling us.
+		segments.push({
+			text: ` v${plugin.recentlyUpdatedFrom} → v${shown} updated`,
+			tone: "success",
+		});
+	} else if (plugin.recentlyInstalled) {
+		// Newly seen. A plugin can be genuinely installed with no version we can
+		// name, so the version is optional here.
+		segments.push({
+			text: shown ? ` v${shown} new` : " new",
+			tone: "success",
+		});
+	} else if (shown) {
+		segments.push({ text: ` v${shown}`, tone: "muted" });
+	}
+
+	const suffix = pluginStatusText(status);
+	if (suffix.suffix) segments.push({ text: suffix.suffix, tone: suffix.tone });
+
+	return { segments, text: segments.map((s) => s.text).join("") };
+}

package/src/ui/renderers/pluginStatusText.ts

@@ -0,0 +1,56 @@
+/**
+ * A plugin's status, as the words and tone the Plugins screen shows.
+ *
+ * Pure, and a function of the classifier's answer ALONE. The row used to build
+ * this text from `PluginInfo` flags with its own rules, and every clause was
+ * gated on the installed version being displayable — so a plugin recorded as
+ * "0.0.0" rendered with no status at all and read as healthy, while
+ * `claudeup update` said `unknown`. Nothing here looks at the version.
+ *
+ * The note is shown VERBATIM: it is the exact string `claudeup update` prints,
+ * which is what makes the two front ends say the same thing.
+ */
+
+import type { PluginUpdateItem } from "../../services/update-plan.js";
+
+export type StatusTone = "muted" | "warning" | "danger" | "success" | "info";
+
+export interface PluginStatusText {
+	/** Text after the version, with its leading space; "" for nothing to say. */
+	suffix: string;
+	tone: StatusTone;
+}
+
+export function pluginStatusText(
+	status: PluginUpdateItem | null,
+): PluginStatusText {
+	if (!status) return { suffix: "", tone: "muted" };
+	const withNote = status.note ? ` (${status.note})` : "";
+
+	switch (status.action) {
+		case "unknown":
+			// Amber, not red: "cannot tell" is not a failure.
+			return {
+				suffix: ` ? ${status.note ?? "cannot tell whether it is current"}`,
+				tone: "warning",
+			};
+		case "update":
+			return {
+				suffix: `${status.target ? ` → v${status.target} available` : " update available"}${withNote}`,
+				tone: "warning",
+			};
+		case "repair":
+			return { suffix: ` stale — reinstall${withNote}`, tone: "warning" };
+		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.
+			return status.reason === "absent"
+				? { suffix: " not installed — profile declares it", tone: "warning" }
+				: // Enabled with nothing on disk is a broken state; a missing
+					// declared plugin is routine work. Red against amber is the
+					// distinction that matters.
+					{ suffix: ` not installed${withNote}`, tone: "danger" };
+		case "current":
+			return { suffix: withNote, tone: "muted" };
+	}
+}