magus-cli 0.0.0-placeholder → 7.1.0

package/src/ui/adapters/pluginsAdapter.ts

@@ -0,0 +1,413 @@
+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";
+
+// Virtual marketplace name for the community sub-section of claude-plugins-official
+export const COMMUNITY_VIRTUAL_MARKETPLACE =
+	"claude-plugins-official:community";
+// The marketplace that gets split into Anthropic Official + Community sections
+export const SPLIT_MARKETPLACE = "claude-plugins-official";
+
+// ─── Item types ───────────────────────────────────────────────────────────────
+
+export interface PluginCategoryItem {
+	id: string;
+	kind: "category";
+	label: string;
+	marketplace: Marketplace;
+	marketplaceEnabled: boolean;
+	pluginCount: number;
+	isExpanded: boolean;
+	isCommunitySection?: boolean;
+	/** Visual tone for the category row */
+	tone: "yellow" | "gray" | "green" | "red" | "purple" | "teal" | "byline";
+	/** Badge text shown on category row (e.g. "★ Official") */
+	badge?: string;
+}
+
+export interface PluginPluginItem {
+	id: string;
+	kind: "plugin";
+	label: string;
+	plugin: PluginInfo;
+	/** Fuzzy match highlight indices, if search is active */
+	matches?: number[];
+	/** True when this plugin's contents can be opened with ← / →. */
+	isExpandable: boolean;
+	/** True when its component rows follow below. */
+	isExpanded: boolean;
+	/**
+	 * 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.
+	 */
+	status: PluginUpdateItem | null;
+}
+
+/**
+ * One component inside an expanded plugin — display only.
+ *
+ * Claude Code installs plugins, not individual pieces, so these rows carry no
+ * action. They exist because a plugin row alone says nothing about what
+ * installing it brings: a marketplace that publishes its whole repo as one
+ * plugin (mattpocock, ecc, ponytail, addy-agent-skills, humanizer and
+ * opendesign all do) rendered as a single unexplained line, and a plugin whose
+ * only content is an MCP server — mnemex — looked like it shipped nothing at
+ * all.
+ */
+export interface PluginComponentItem {
+	id: string;
+	kind: "component";
+	label: string;
+	/** The plugin this belongs to, for the detail panel. */
+	plugin: PluginInfo;
+	component: PluginComponent;
+	/** Repo the component's file is read from. */
+	repo: string;
+	/** Cache key for this component's content. */
+	detailKey: string;
+}
+
+/** Placeholder row shown while a plugin's contents load, or when they cannot. */
+export interface PluginContentsStatusItem {
+	id: string;
+	kind: "contents-status";
+	label: string;
+	plugin: PluginInfo;
+	status: "loading" | "error" | "empty";
+	error?: string;
+}
+
+export type PluginBrowserItem =
+	| PluginCategoryItem
+	| PluginPluginItem
+	| PluginComponentItem
+	| PluginContentsStatusItem;
+
+// ─── Adapter ─────────────────────────────────────────────────────────────────
+
+export interface BuildPluginBrowserItemsArgs {
+	marketplaces: Marketplace[];
+	plugins: PluginInfo[];
+	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>;
+}
+
+/**
+ * A plugin's contents are listed from its repo tree, so a plugin with no repo
+ * to read (a local-path marketplace, or a plugin whose marketplace has no git
+ * remote) cannot be expanded. Offering the arrow there would open a row that
+ * can only ever say "could not load".
+ */
+export function pluginContentsRepo(
+	plugin: PluginInfo,
+	marketplace: Marketplace,
+): string | undefined {
+	return plugin.sourceRepo || marketplace.source.repo || undefined;
+}
+
+/**
+ * Appends a plugin row, plus its component rows when expanded.
+ */
+function pushPluginItems(
+	items: PluginBrowserItem[],
+	plugin: PluginInfo,
+	marketplace: Marketplace,
+	expandedPlugins: Set<string>,
+	pluginContents: Map<string, PluginContentsEntry>,
+	statuses: ReadonlyMap<string, PluginUpdateItem>,
+): void {
+	const repo = pluginContentsRepo(plugin, marketplace);
+	const isExpandable = !plugin.isOrphaned && !!repo;
+	const isExpanded = isExpandable && expandedPlugins.has(plugin.id);
+
+	items.push({
+		id: `pl:${plugin.id}`,
+		kind: "plugin",
+		label: plugin.name,
+		plugin,
+		isExpandable,
+		isExpanded,
+		status: statuses.get(plugin.id) ?? null,
+	});
+
+	if (!isExpanded) return;
+
+	const entry = pluginContents.get(plugin.id);
+	if (!entry || entry.status === "loading") {
+		items.push({
+			id: `c:${plugin.id}:loading`,
+			kind: "contents-status",
+			label: "Reading the plugin…",
+			plugin,
+			status: "loading",
+		});
+		return;
+	}
+	if (entry.status === "error") {
+		items.push({
+			id: `c:${plugin.id}:error`,
+			kind: "contents-status",
+			label: "Could not read the plugin",
+			plugin,
+			status: "error",
+			error: entry.error,
+		});
+		return;
+	}
+	const components = entry.components ?? [];
+	if (components.length === 0) {
+		items.push({
+			id: `c:${plugin.id}:empty`,
+			kind: "contents-status",
+			label: "Ships no skills, commands, agents or MCP servers",
+			plugin,
+			status: "empty",
+		});
+		return;
+	}
+	for (const component of components) {
+		items.push({
+			id: `c:${plugin.id}:${component.kind}:${component.repoPath}:${component.name}`,
+			kind: "component",
+			label: component.name,
+			plugin,
+			component,
+			// `repo` is non-null here: without one the plugin is not expandable and
+			// this loop is unreachable.
+			repo: repo as string,
+			detailKey: `${repo}/${component.repoPath}#${component.name}`,
+		});
+	}
+}
+
+/**
+ * Derives tone and badge for a category item based on marketplace identity.
+ */
+function categoryStyling(
+	mp: Marketplace,
+	isCommunitySection: boolean,
+	marketplaceEnabled: boolean,
+): { tone: PluginCategoryItem["tone"]; badge?: string } {
+	if (!marketplaceEnabled) {
+		return { tone: "gray" };
+	}
+	if (isCommunitySection) {
+		return { tone: "gray", badge: "3rd Party" };
+	}
+	if (mp.name === "claude-plugins-official") {
+		return { tone: "yellow", badge: "★ Official" };
+	}
+	if (mp.name === "claude-code-plugins") {
+		return { tone: "red", badge: "⚠ Deprecated" };
+	}
+	if (mp.official) {
+		return { tone: "yellow", badge: "★ Official" };
+	}
+	if (isMadAppGang(mp)) {
+		return { tone: "byline", badge: "by MadAppGang" };
+	}
+	return { tone: "green", badge: "✓ Added" };
+}
+
+/**
+ * Our own marketplaces (magus, magus-marketing, magus-alpha) get the byline
+ * instead of the generic "Added". Matched on the repo owner rather than a list
+ * of names, so a new channel picks it up without a code change. Same idiom the
+ * marketplace sort uses to float MadAppGang entries to the top.
+ */
+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.
+ */
+export function buildPluginBrowserItems({
+	marketplaces,
+	plugins,
+	collapsedMarketplaces,
+	expandedPlugins = new Set(),
+	pluginContents = new Map(),
+	statuses = new Map(),
+}: BuildPluginBrowserItemsArgs): PluginBrowserItem[] {
+	const pluginsByMarketplace = new Map<string, PluginInfo[]>();
+	for (const plugin of plugins) {
+		const existing = pluginsByMarketplace.get(plugin.marketplace) || [];
+		existing.push(plugin);
+		pluginsByMarketplace.set(plugin.marketplace, existing);
+	}
+
+	// Sort marketplaces: our own (magus*) first, deprecated last, others between.
+	const rank = (m: Marketplace) =>
+		m.owned ? 0 : m.deprecated || m.name === "claude-code-plugins" ? 2 : 1;
+	const sortedMarketplaces = [...marketplaces].sort(
+		(a, b) => rank(a) - rank(b),
+	);
+
+	const items: PluginBrowserItem[] = [];
+
+	for (const marketplace of sortedMarketplaces) {
+		const marketplacePlugins = pluginsByMarketplace.get(marketplace.name) || [];
+		const isCollapsed = collapsedMarketplaces.has(marketplace.name);
+		const isEnabled = marketplacePlugins.length > 0 || !!marketplace.official;
+		const hasPlugins = marketplacePlugins.length > 0;
+
+		// Special handling: split claude-plugins-official into two sub-sections
+		if (marketplace.name === SPLIT_MARKETPLACE && hasPlugins) {
+			const anthropicPlugins = marketplacePlugins.filter(
+				(p) => p.author?.name?.toLowerCase() === "anthropic",
+			);
+			const communityPlugins = marketplacePlugins.filter(
+				(p) => p.author?.name?.toLowerCase() !== "anthropic",
+			);
+
+			// Sub-section 1: Anthropic Official (plugins by Anthropic)
+			const anthropicCollapsed = collapsedMarketplaces.has(marketplace.name);
+			const anthropicHasPlugins = anthropicPlugins.length > 0;
+			const anthropicStyle = categoryStyling(marketplace, false, isEnabled);
+			items.push({
+				id: `mp:${marketplace.name}`,
+				kind: "category",
+				label: marketplace.displayName,
+				marketplace,
+				marketplaceEnabled: isEnabled,
+				pluginCount: anthropicPlugins.length,
+				isExpanded: !anthropicCollapsed && anthropicHasPlugins,
+				tone: anthropicStyle.tone,
+				badge: anthropicStyle.badge,
+			});
+			if (isEnabled && anthropicHasPlugins && !anthropicCollapsed) {
+				for (const plugin of anthropicPlugins) {
+					pushPluginItems(
+						items,
+						plugin,
+						marketplace,
+						expandedPlugins,
+						pluginContents,
+						statuses,
+					);
+				}
+			}
+
+			// Sub-section 2: Community (third-party plugins in same marketplace)
+			if (communityPlugins.length > 0) {
+				const communityVirtualMp: Marketplace = {
+					name: COMMUNITY_VIRTUAL_MARKETPLACE,
+					displayName: "Anthropic Official — 3rd Party",
+					source: marketplace.source,
+					description:
+						"Third-party plugins in the Anthropic Official marketplace",
+				};
+				const communityCollapsed = collapsedMarketplaces.has(
+					COMMUNITY_VIRTUAL_MARKETPLACE,
+				);
+				const communityStyle = categoryStyling(communityVirtualMp, true, true);
+				items.push({
+					id: `mp:${COMMUNITY_VIRTUAL_MARKETPLACE}`,
+					kind: "category",
+					label: "Anthropic Official — 3rd Party",
+					marketplace: communityVirtualMp,
+					marketplaceEnabled: true,
+					pluginCount: communityPlugins.length,
+					isExpanded: !communityCollapsed,
+					isCommunitySection: true,
+					tone: communityStyle.tone,
+					badge: communityStyle.badge,
+				});
+				if (!communityCollapsed) {
+					for (const plugin of communityPlugins) {
+						pushPluginItems(
+							items,
+							plugin,
+							communityVirtualMp,
+							expandedPlugins,
+							pluginContents,
+							statuses,
+						);
+					}
+				}
+			}
+
+			continue;
+		}
+
+		// Category header (marketplace)
+		const style = categoryStyling(marketplace, false, isEnabled);
+		items.push({
+			id: `mp:${marketplace.name}`,
+			kind: "category",
+			label: marketplace.displayName,
+			marketplace,
+			marketplaceEnabled: isEnabled,
+			pluginCount: marketplacePlugins.length,
+			isExpanded: !isCollapsed && hasPlugins,
+			tone: style.tone,
+			badge: style.badge,
+		});
+
+		// Plugins under this marketplace (if expanded)
+		if (isEnabled && hasPlugins && !isCollapsed) {
+			for (const plugin of marketplacePlugins) {
+				pushPluginItems(
+					items,
+					plugin,
+					marketplace,
+					expandedPlugins,
+					pluginContents,
+					statuses,
+				);
+			}
+		}
+	}
+
+	return items;
+}

package/src/ui/adapters/settingsAdapter.ts

@@ -0,0 +1,168 @@
+import {
+	SETTINGS_CATALOG,
+	type SettingCategory,
+	type SettingDefinition,
+} from "../../data/settings-catalog.js";
+import type { ScopedSettingValues } from "../../services/settings-manager.js";
+import { type UiColor, theme } from "../theme.js";
+
+// ─── Item types ────────────────────────────────────────────────────────────────
+
+export interface SettingsCategoryItem {
+	id: string;
+	kind: "category";
+	label: string;
+	category: SettingCategory;
+	isDefault: true;
+}
+
+export interface SettingsSettingItem {
+	id: string;
+	kind: "setting";
+	label: string;
+	category: SettingCategory;
+	setting: SettingDefinition;
+	scopedValues: ScopedSettingValues;
+	effectiveValue: string | undefined;
+	isDefault: boolean;
+}
+
+export type SettingsBrowserItem = SettingsCategoryItem | SettingsSettingItem;
+
+// ─── Constants ─────────────────────────────────────────────────────────────────
+
+export const CATEGORY_LABELS: Record<SettingCategory, string> = {
+	recommended: "Recommended",
+	agents: "Agents & Teams",
+	models: "Models & Thinking",
+	workflow: "Workflow",
+	terminal: "Terminal & UI",
+	performance: "Performance",
+	advanced: "Advanced",
+};
+
+export const CATEGORY_ORDER: SettingCategory[] = [
+	"recommended",
+	"agents",
+	"models",
+	"workflow",
+	"terminal",
+	"performance",
+	"advanced",
+];
+
+export const CATEGORY_BG: Record<SettingCategory, UiColor> = {
+	recommended: theme.colors.success,
+	agents: theme.colors.info,
+	models: theme.colors.accent,
+	workflow: theme.colors.link,
+	terminal: theme.colors.warning,
+	performance: theme.colors.accent,
+	advanced: theme.colors.warning,
+};
+
+export const CATEGORY_COLOR: Record<SettingCategory, UiColor> = {
+	recommended: theme.colors.success,
+	agents: theme.colors.info,
+	models: theme.colors.info,
+	workflow: theme.colors.link,
+	terminal: theme.colors.link,
+	performance: "magentaBright",
+	advanced: theme.colors.warning,
+};
+
+export const CATEGORY_DESCRIPTIONS: Record<SettingCategory, string> = {
+	recommended: "Most impactful settings every user should know.",
+	agents: "Agent teams, task lists, and subagent configuration.",
+	models: "Model selection, extended thinking, and effort.",
+	workflow: "Git, plans, permissions, output style, and languages.",
+	terminal: "Shell, spinners, progress bars, voice, and UI behavior.",
+	performance: "Compaction, token limits, timeouts, and caching.",
+	advanced: "Telemetry, updates, debugging, and internal controls.",
+};
+
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+
+/** Get the effective value (project overrides user) */
+export function getEffectiveValue(
+	scoped: ScopedSettingValues,
+): string | undefined {
+	return scoped.project !== undefined ? scoped.project : scoped.user;
+}
+
+export function formatValue(
+	setting: SettingDefinition,
+	value: string | undefined,
+): string {
+	if (value === undefined || value === "") {
+		if (setting.type === "boolean" && setting.defaultValue !== undefined) {
+			return setting.defaultValue === "true" ? "on" : "off";
+		}
+		if (setting.type === "select" && setting.defaultValue !== undefined) {
+			const opt = setting.options?.find(
+				(o) => o.value === setting.defaultValue,
+			);
+			return opt ? opt.label : setting.defaultValue;
+		}
+		return "—";
+	}
+
+	if (setting.type === "boolean") {
+		return value === "true" || value === "1" ? "on" : "off";
+	}
+
+	if (setting.type === "select" && setting.options) {
+		const opt = setting.options.find((o) => o.value === value);
+		return opt ? opt.label : value;
+	}
+
+	if (value.length > 12) {
+		return `${value.slice(0, 12)}…`;
+	}
+	return value;
+}
+
+// ─── Adapter ───────────────────────────────────────────────────────────────────
+
+/**
+ * Builds the flat list of items for the SettingsScreen list panel.
+ * Extracted from SettingsScreen so it can be tested independently.
+ */
+export function buildSettingsBrowserItems(
+	values: Map<string, ScopedSettingValues>,
+): SettingsBrowserItem[] {
+	const items: SettingsBrowserItem[] = [];
+
+	for (const category of CATEGORY_ORDER) {
+		items.push({
+			id: `cat:${category}`,
+			kind: "category",
+			label: CATEGORY_LABELS[category],
+			category,
+			isDefault: true,
+		});
+
+		const categorySettings = SETTINGS_CATALOG.filter(
+			(s) => s.category === category,
+		);
+		for (const setting of categorySettings) {
+			const scoped = values.get(setting.id) || {
+				user: undefined,
+				project: undefined,
+			};
+			const effective = getEffectiveValue(scoped);
+			items.push({
+				id: `setting:${setting.id}`,
+				kind: "setting",
+				label: setting.name,
+				category,
+				setting,
+				scopedValues: scoped,
+				effectiveValue: effective,
+				isDefault: effective === undefined || effective === "",
+			});
+		}
+	}
+
+	return items;
+}