one-code-extension 0.1.3 → 0.3.0

package/extensions/plugins/panel/rows.ts

@@ -0,0 +1,230 @@
+/**
+ * Row models for the /plugins panel tabs (pure).
+ *
+ * The Installed tab's grouping is One Code's own heuristic (Claude Code's
+ * usage-recency data doesn't exist here): Favorites float first, then
+ * "Needs attention" (MCP servers that failed or need auth), then plugins split
+ * into "Not used recently" (no recorded command/skill use in 30 days,
+ * including never) and "Plugins", then healthy "MCP servers", then "Skills".
+ */
+
+import type { McpServerStatus } from "../../lib/mcp-status.ts";
+import type { Plugin } from "../../lib/plugins.ts";
+import type { ScannedSkill } from "../../lib/skill-scan.ts";
+import { isSkillEnabled, type SkillState, skillOverrideKey } from "../../lib/skill-overrides.ts";
+import { formatRecency, type UsageEntry, usageKey } from "../../lib/usage-tracker.ts";
+import type { Favorites } from "../../lib/favorites.ts";
+import type { MarketplaceSnapshot } from "../marketplace/sync.ts";
+import type { KnownMarketplace } from "../marketplace/types.ts";
+import { OFFICIAL_MARKETPLACE_NAME } from "../marketplace/official.ts";
+
+const RECENT_MS = 30 * 24 * 60 * 60 * 1000;
+
+export interface DiscoverRow {
+	/** `name@marketplace`. */
+	id: string;
+	name: string;
+	marketplace: string;
+	description?: string;
+	installs?: number;
+	installed: boolean;
+	busy: boolean;
+}
+
+export function buildDiscoverRows(input: {
+	snapshots: MarketplaceSnapshot[];
+	installedIds: Set<string>;
+	counts?: Map<string, number>;
+	busy: Set<string>;
+	search: string;
+}): DiscoverRow[] {
+	const query = input.search.trim().toLowerCase();
+	const rows: DiscoverRow[] = [];
+	for (const snapshot of input.snapshots) {
+		if (!snapshot.manifest) continue;
+		for (const entry of snapshot.manifest.plugins) {
+			const id = `${entry.name}@${snapshot.name}`;
+			if (query && !entry.name.toLowerCase().includes(query) && !(entry.description ?? "").toLowerCase().includes(query)) {
+				continue;
+			}
+			rows.push({
+				id,
+				name: entry.name,
+				marketplace: snapshot.name,
+				description: entry.description,
+				installs: input.counts?.get(id),
+				installed: input.installedIds.has(id),
+				busy: input.busy.has(id),
+			});
+		}
+	}
+	rows.sort((a, b) => (b.installs ?? -1) - (a.installs ?? -1) || a.name.localeCompare(b.name));
+	return rows;
+}
+
+export type InstalledRow =
+	| { kind: "section"; title: string }
+	| {
+			kind: "plugin";
+			id: string;
+			name: string;
+			marketplace?: string;
+			enabled: boolean;
+			origin: Plugin["originRoot"];
+			overridden: boolean;
+			favorite: boolean;
+			busy: boolean;
+	  }
+	| { kind: "mcp"; name: string; status: McpServerStatus["status"]; detail?: string; toolCount?: number; source?: string }
+	| {
+			kind: "skill";
+			overrideKey: string;
+			name: string;
+			scope: ScannedSkill["scope"];
+			tokens: number;
+			recency: string;
+			enabled: boolean;
+			favorite: boolean;
+	  };
+
+/** Latest use across a plugin's namespaced commands/skills (`<plugin>:<name>` keys). */
+function pluginLastUsed(plugin: Plugin, usage: Record<string, UsageEntry>): number | undefined {
+	let latest: number | undefined;
+	for (const [key, entry] of Object.entries(usage)) {
+		const [, name] = key.split(/:(.+)/);
+		if (!name?.startsWith(`${plugin.name}:`)) continue;
+		const at = Date.parse(entry.lastUsedAt);
+		if (!Number.isNaN(at) && (latest === undefined || at > latest)) latest = at;
+	}
+	return latest;
+}
+
+export function buildInstalledRows(input: {
+	plugins: Plugin[];
+	mcpServers?: McpServerStatus[];
+	skills: Array<ScannedSkill & { tokens: number }>;
+	usage: Record<string, UsageEntry>;
+	skillOverrides: Record<string, SkillState>;
+	favorites: Favorites;
+	busy: Set<string>;
+	search: string;
+	now?: Date;
+}): InstalledRow[] {
+	const query = input.search.trim().toLowerCase();
+	const matches = (name: string) => !query || name.toLowerCase().includes(query);
+	const now = (input.now ?? new Date()).getTime();
+
+	const pluginRow = (plugin: Plugin): Extract<InstalledRow, { kind: "plugin" }> => ({
+		kind: "plugin",
+		id: plugin.id,
+		name: plugin.name,
+		marketplace: plugin.marketplace,
+		enabled: plugin.enabled,
+		origin: plugin.originRoot,
+		overridden: plugin.overridden ?? false,
+		favorite: input.favorites.plugins.includes(plugin.id),
+		busy: input.busy.has(plugin.id),
+	});
+
+	const skillRow = (skill: ScannedSkill & { tokens: number }): Extract<InstalledRow, { kind: "skill" }> => {
+		const key = skillOverrideKey(skill.scope, skill.name);
+		return {
+			kind: "skill",
+			overrideKey: key,
+			name: skill.name,
+			scope: skill.scope,
+			tokens: skill.tokens,
+			recency: formatRecency(input.usage[usageKey("skill", skill.name)], input.now),
+			enabled: isSkillEnabled(input.skillOverrides, key),
+			favorite: input.favorites.skills.includes(key),
+		};
+	};
+
+	const mcpRow = (server: McpServerStatus): Extract<InstalledRow, { kind: "mcp" }> => ({
+		kind: "mcp",
+		name: server.name,
+		status: server.status,
+		detail: server.detail,
+		toolCount: server.toolCount,
+		source: server.source,
+	});
+
+	const plugins = input.plugins.filter((p) => matches(p.name));
+	const skills = input.skills.filter((s) => matches(s.name)).map(skillRow);
+	const mcp = (input.mcpServers ?? []).filter((s) => matches(s.name));
+
+	const favoritePluginRows = plugins.filter((p) => input.favorites.plugins.includes(p.id)).map(pluginRow);
+	const favoriteSkillRows = skills.filter((s) => s.favorite);
+	const attention = mcp.filter((s) => s.status === "failed" || s.status === "authNeeded").map(mcpRow);
+	const rest = plugins.filter((p) => !input.favorites.plugins.includes(p.id));
+	const stale = rest.filter((p) => {
+		const last = pluginLastUsed(p, input.usage);
+		return last === undefined || now - last > RECENT_MS;
+	});
+	const active = rest.filter((p) => !stale.includes(p));
+	const healthyMcp = mcp.filter((s) => s.status === "connected" || s.status === "connecting").map(mcpRow);
+	const normalSkills = skills.filter((s) => !s.favorite);
+
+	const rows: InstalledRow[] = [];
+	const section = (title: string, content: InstalledRow[]) => {
+		if (content.length > 0) rows.push({ kind: "section", title }, ...content);
+	};
+	section("Favorites", [...favoritePluginRows, ...favoriteSkillRows]);
+	section("Needs attention", attention);
+	section("Not used recently", stale.map(pluginRow));
+	section("Plugins", active.map(pluginRow));
+	section("MCP servers", healthyMcp);
+	section("Skills", normalSkills);
+	return rows;
+}
+
+export type MarketplaceRow =
+	| { kind: "add" }
+	| {
+			kind: "marketplace";
+			name: string;
+			sourceLine: string;
+			available?: number;
+			installedCount: number;
+			updated: string;
+			official: boolean;
+			error?: string;
+	  };
+
+function sourceLine(known: KnownMarketplace): string {
+	const { source } = known;
+	switch (source.source) {
+		case "github":
+			return source.repo;
+		case "git":
+			return source.url;
+		case "url":
+			return source.url;
+		case "file":
+		case "directory":
+			return source.path;
+	}
+}
+
+export function buildMarketplaceRows(input: {
+	known: Record<string, KnownMarketplace>;
+	snapshots: Map<string, MarketplaceSnapshot>;
+	installedIds: Set<string>;
+}): MarketplaceRow[] {
+	const rows: MarketplaceRow[] = [{ kind: "add" }];
+	for (const [name, known] of Object.entries(input.known).sort(([a], [b]) => a.localeCompare(b))) {
+		const snapshot = input.snapshots.get(name);
+		const installedCount = [...input.installedIds].filter((id) => id.endsWith(`@${name}`)).length;
+		rows.push({
+			kind: "marketplace",
+			name,
+			sourceLine: sourceLine(known),
+			available: snapshot?.manifest?.plugins.length,
+			installedCount,
+			updated: known.lastUpdated,
+			official: name === OFFICIAL_MARKETPLACE_NAME,
+			error: snapshot?.errors[0],
+		});
+	}
+	return rows;
+}

package/extensions/plugins/panel/state.ts

@@ -0,0 +1,333 @@
+/**
+ * /plugins panel state machine (pure).
+ *
+ * `applyPanelKey` mutates the state in place (the wiring owns the object and
+ * repaints after every key) and returns an effect when the key demands I/O —
+ * installs, toggles, marketplace operations — which the wiring executes
+ * asynchronously and reflects back through the data it renders.
+ *
+ * Key routing: navigation keys are always controls. Printable text feeds the
+ * search box in Discover (a browse tab: type to filter, Enter to read before
+ * installing), the draft in the Add Marketplace dialog, and single-letter
+ * actions in Marketplaces (`u` update, `d` remove) and the detail view
+ * (`i`/`u`/`e`/`d`/`f`) — the views without a text field.
+ *
+ * The Installed tab follows the /skills panel instead: Enter and Space act on
+ * the row in place (toggle a plugin or skill; open an MCP server's detail,
+ * which has no toggle), search sits behind `/` (Esc leaves it), and the free
+ * letters act directly — `v` view, `e`/`d` set, `u` uninstall, `f` favorite.
+ */
+
+import type { PanelKey } from "./keys.ts";
+import type { DiscoverRow, InstalledRow, MarketplaceRow } from "./rows.ts";
+
+export type Tab = "discover" | "installed" | "marketplaces" | "errors";
+export const TABS: Tab[] = ["discover", "installed", "marketplaces", "errors"];
+
+export type DetailRef =
+	| { kind: "discover"; id: string }
+	| { kind: "plugin"; id: string }
+	| { kind: "skill"; overrideKey: string }
+	| { kind: "mcp"; name: string };
+
+export interface PanelState {
+	tab: Tab;
+	cursor: Record<Tab, number>;
+	search: { discover: string; installed: string };
+	/** Installed tab: `/` opened the search box, so typed text feeds it. */
+	installedSearching: boolean;
+	addDialog?: { draft: string };
+	detail?: DetailRef;
+	restartNeeded: boolean;
+	notice?: string;
+}
+
+export interface PanelView {
+	discover: DiscoverRow[];
+	installed: InstalledRow[];
+	marketplaces: MarketplaceRow[];
+	errors: string[];
+}
+
+export type PanelEffect =
+	| { kind: "close" }
+	| { kind: "installToggle"; row: DiscoverRow }
+	| { kind: "setPluginEnabled"; id: string; origin: "claude" | "one-code"; enabled: boolean }
+	| { kind: "uninstall"; id: string }
+	| { kind: "setSkillEnabled"; overrideKey: string; enabled: boolean }
+	| { kind: "toggleFavorite"; target: "plugin" | "skill"; key: string }
+	| { kind: "addMarketplace"; input: string }
+	| { kind: "removeMarketplace"; name: string }
+	| { kind: "refreshMarketplace"; name: string };
+
+export function initialPanelState(): PanelState {
+	return {
+		tab: "discover",
+		cursor: { discover: 0, installed: 0, marketplaces: 0, errors: 0 },
+		search: { discover: "", installed: "" },
+		installedSearching: false,
+		restartNeeded: false,
+	};
+}
+
+/** Rows the cursor can land on (Installed section headers are skipped). */
+export function selectableRows(state: PanelState, view: PanelView): Array<DiscoverRow | InstalledRow | MarketplaceRow | string> {
+	switch (state.tab) {
+		case "discover":
+			return view.discover;
+		case "installed":
+			return view.installed.filter((row) => row.kind !== "section");
+		case "marketplaces":
+			return view.marketplaces;
+		case "errors":
+			return view.errors;
+	}
+}
+
+export function clampPanelState(state: PanelState, view: PanelView): void {
+	const max = Math.max(0, selectableRows(state, view).length - 1);
+	state.cursor[state.tab] = Math.min(Math.max(0, state.cursor[state.tab]), max);
+}
+
+function selected(state: PanelState, view: PanelView): DiscoverRow | InstalledRow | MarketplaceRow | string | undefined {
+	return selectableRows(state, view)[state.cursor[state.tab]];
+}
+
+function detailFor(row: DiscoverRow | InstalledRow | MarketplaceRow | string, tab: Tab): DetailRef | undefined {
+	if (typeof row === "string") return undefined;
+	if (tab === "discover") return { kind: "discover", id: (row as DiscoverRow).id };
+	if ("kind" in row) {
+		if (row.kind === "plugin") return { kind: "plugin", id: row.id };
+		if (row.kind === "skill") return { kind: "skill", overrideKey: row.overrideKey };
+		if (row.kind === "mcp") return { kind: "mcp", name: row.name };
+	}
+	return undefined;
+}
+
+/** Resolve a detail ref against the CURRENT view (rows shift under async refreshes). */
+export function resolveDetail(ref: DetailRef, view: PanelView): DiscoverRow | InstalledRow | undefined {
+	switch (ref.kind) {
+		case "discover":
+			return view.discover.find((row) => row.id === ref.id);
+		case "plugin":
+			return view.installed.find((row) => row.kind === "plugin" && row.id === ref.id);
+		case "skill":
+			return view.installed.find((row) => row.kind === "skill" && row.overrideKey === ref.overrideKey);
+		case "mcp":
+			return view.installed.find((row) => row.kind === "mcp" && row.name === ref.name);
+	}
+}
+
+function detailEffect(state: PanelState, view: PanelView, letter: string): PanelEffect | undefined {
+	const ref = state.detail;
+	if (!ref) return undefined;
+	const row = resolveDetail(ref, view);
+	if (!row || typeof row === "string") return undefined;
+
+	if (ref.kind === "discover") {
+		const discover = row as DiscoverRow;
+		if (letter === "i" && !discover.installed) return { kind: "installToggle", row: discover };
+		if (letter === "u" && discover.installed) return { kind: "installToggle", row: discover };
+		return undefined;
+	}
+	return "kind" in row ? installedLetterEffect(row, letter) : undefined;
+}
+
+/** `e`/`d` set, `u` uninstall (One Code-installed only), `f` favorite — shared by the detail view and the Installed list. */
+function installedLetterEffect(row: InstalledRow, letter: string): PanelEffect | undefined {
+	if (row.kind === "plugin") {
+		if (letter === "e") return { kind: "setPluginEnabled", id: row.id, origin: row.origin, enabled: true };
+		if (letter === "d") return { kind: "setPluginEnabled", id: row.id, origin: row.origin, enabled: false };
+		if (letter === "u" && row.origin === "one-code") return { kind: "uninstall", id: row.id };
+		if (letter === "f") return { kind: "toggleFavorite", target: "plugin", key: row.id };
+	}
+	if (row.kind === "skill") {
+		if (letter === "e") return { kind: "setSkillEnabled", overrideKey: row.overrideKey, enabled: true };
+		if (letter === "d") return { kind: "setSkillEnabled", overrideKey: row.overrideKey, enabled: false };
+		if (letter === "f") return { kind: "toggleFavorite", target: "skill", key: row.overrideKey };
+	}
+	return undefined;
+}
+
+/**
+ * Installed tab, Enter or Space: toggle a plugin/skill row in place (the
+ * /skills model); an MCP row has no toggle, so open its detail instead.
+ */
+function selectedInstalled(state: PanelState, view: PanelView): Exclude<InstalledRow, { kind: "section" }> | undefined {
+	if (state.tab !== "installed") return undefined;
+	return view.installed.filter((r) => r.kind !== "section")[state.cursor.installed];
+}
+
+function installedPrimary(state: PanelState, view: PanelView): PanelEffect | undefined {
+	const row = selectedInstalled(state, view);
+	if (!row) return undefined;
+	if (row.kind === "plugin") return { kind: "setPluginEnabled", id: row.id, origin: row.origin, enabled: !row.enabled };
+	if (row.kind === "skill") return { kind: "setSkillEnabled", overrideKey: row.overrideKey, enabled: !row.enabled };
+	if (row.kind === "mcp") state.detail = { kind: "mcp", name: row.name };
+	return undefined;
+}
+
+/** Installed tab, single letters outside search: `v` view, `e`/`d` set, `u` uninstall, `f` favorite. */
+function installedLetter(state: PanelState, view: PanelView, letter: string): PanelEffect | undefined {
+	const row = selectedInstalled(state, view);
+	if (!row) return undefined;
+	if (letter === "v") {
+		state.detail = detailFor(row, "installed");
+		return undefined;
+	}
+	return installedLetterEffect(row, letter);
+}
+
+export function applyPanelKey(state: PanelState, key: PanelKey, view: PanelView): PanelEffect | undefined {
+	state.notice = undefined;
+
+	// Modal Add Marketplace dialog captures everything.
+	if (state.addDialog) {
+		const dialog = state.addDialog;
+		switch (key.kind) {
+			case "text":
+				dialog.draft += key.text;
+				return undefined;
+			case "backspace":
+				dialog.draft = dialog.draft.slice(0, -1);
+				return undefined;
+			case "enter": {
+				const input = dialog.draft.trim();
+				state.addDialog = undefined;
+				return input ? { kind: "addMarketplace", input } : undefined;
+			}
+			case "back":
+			case "close":
+				state.addDialog = undefined;
+				return undefined;
+			default:
+				return undefined;
+		}
+	}
+
+	if (state.detail) {
+		switch (key.kind) {
+			case "back":
+				state.detail = undefined;
+				return undefined;
+			case "close":
+				return { kind: "close" };
+			case "enter":
+			case "space": {
+				const row = resolveDetail(state.detail, view);
+				if (row && "kind" in row) {
+					if (row.kind === "plugin") {
+						return { kind: "setPluginEnabled", id: row.id, origin: row.origin, enabled: !row.enabled };
+					}
+					if (row.kind === "skill") {
+						return { kind: "setSkillEnabled", overrideKey: row.overrideKey, enabled: !row.enabled };
+					}
+				}
+				return undefined;
+			}
+			case "text":
+				return key.text.length === 1 ? detailEffect(state, view, key.text.toLowerCase()) : undefined;
+			default:
+				return undefined;
+		}
+	}
+
+	switch (key.kind) {
+		case "close":
+			return { kind: "close" };
+		case "back": {
+			if (state.tab === "discover" && state.search.discover) {
+				state.search.discover = "";
+				return undefined;
+			}
+			if (state.tab === "installed" && (state.installedSearching || state.search.installed)) {
+				state.installedSearching = false;
+				state.search.installed = "";
+				return undefined;
+			}
+			return { kind: "close" };
+		}
+		case "nextTab":
+		case "prevTab": {
+			const delta = key.kind === "nextTab" ? 1 : -1;
+			state.tab = TABS[(TABS.indexOf(state.tab) + delta + TABS.length) % TABS.length];
+			return undefined;
+		}
+		case "up":
+		case "down":
+		case "pageUp":
+		case "pageDown": {
+			const step = key.kind === "up" ? -1 : key.kind === "down" ? 1 : key.kind === "pageUp" ? -10 : 10;
+			state.cursor[state.tab] += step;
+			clampPanelState(state, view);
+			return undefined;
+		}
+		case "enter": {
+			const row = selected(state, view);
+			if (row === undefined) return undefined;
+			if (state.tab === "marketplaces") {
+				if (typeof row !== "string" && "kind" in row && row.kind === "add") {
+					state.addDialog = { draft: "" };
+					return undefined;
+				}
+				if (typeof row !== "string" && "kind" in row && row.kind === "marketplace") {
+					state.notice = `${row.name} — ${row.sourceLine}${row.error ? ` — ${row.error}` : ""}`;
+					return undefined;
+				}
+				return undefined;
+			}
+			if (state.tab === "installed") return installedPrimary(state, view);
+			const ref = detailFor(row, state.tab);
+			if (ref) state.detail = ref;
+			return undefined;
+		}
+		case "space": {
+			const row = selected(state, view);
+			if (row === undefined || typeof row === "string") return undefined;
+			if (state.tab === "discover") return { kind: "installToggle", row: row as DiscoverRow };
+			if (state.tab === "installed") return installedPrimary(state, view);
+			return undefined;
+		}
+		case "backspace": {
+			if (state.tab === "discover") state.search.discover = state.search.discover.slice(0, -1);
+			else if (state.tab === "installed" && state.installedSearching) {
+				state.search.installed = state.search.installed.slice(0, -1);
+			}
+			return undefined;
+		}
+		case "text": {
+			if (state.tab === "discover") {
+				state.search.discover += key.text;
+				state.cursor.discover = 0;
+				return undefined;
+			}
+			if (state.tab === "installed") {
+				if (state.installedSearching) {
+					state.search.installed += key.text;
+					state.cursor.installed = 0;
+					return undefined;
+				}
+				if (key.text === "/") {
+					state.installedSearching = true;
+					return undefined;
+				}
+				return key.text.length === 1 ? installedLetter(state, view, key.text.toLowerCase()) : undefined;
+			}
+			if (state.tab === "marketplaces" && key.text.length === 1) {
+				const letter = key.text.toLowerCase();
+				const row = selected(state, view);
+				if (letter === "a") {
+					state.addDialog = { draft: "" };
+					return undefined;
+				}
+				if (row && typeof row !== "string" && "kind" in row && row.kind === "marketplace") {
+					if (letter === "u") return { kind: "refreshMarketplace", name: row.name };
+					if (letter === "d") return { kind: "removeMarketplace", name: row.name };
+				}
+			}
+			return undefined;
+		}
+		default:
+			return undefined;
+	}
+}