@underactive/pi-topping 0.6.5 → 0.7.1

package/src/setup-command.ts

@@ -1,74 +1,99 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { hyperlink } from "@earendil-works/pi-tui";
-import { showMenu } from "./menu.ts";
-import { type PiInstallResult, spawnPiInstall } from "./pi-installer.ts";
-import { stripControlChars } from "./util.ts";
+import { type MenuValue, showMenu } from "./menu.ts";
+import { type PiInstallResult, spawnPiInstall, spawnPiRemove } from "./pi-installer.ts";
 import { setSetupCheckDisabled } from "./setup-check.ts";
-import { findMissingToppings, type ToppingStatus } from "./toppings.ts";
+import { detectToppings, type ToppingStatus } from "./toppings.ts";
+import { stripControlChars } from "./util.ts";
 
-const INSTALL_TIMEOUT_MS = 120_000;
+const PI_COMMAND_TIMEOUT_MS = 120_000;
 const STDERR_SNIPPET_CHARS = 300;
 
-type ToppingInstaller = (spec: string, timeoutMs: number) => Promise<PiInstallResult>;
+type PackageAction = "install" | "remove";
+type PiPackageRunner = (spec: string, timeoutMs: number) => Promise<PiInstallResult>;
+type FailedAction = { action: PackageAction; spec: string; error: string };
+type SetupRow = { status: ToppingStatus; action: PackageAction };
 
-type FailedInstall = { spec: string; error: string };
-
-function selectedToppings(missing: readonly ToppingStatus[], values: Record<string, boolean>): ToppingStatus[] {
-	return missing.filter(({ topping }) => values[topping.pkg] === true);
+function selectedRows(
+	rows: ReadonlyMap<string, SetupRow>,
+	values: Record<string, boolean>,
+	action: PackageAction,
+): ToppingStatus[] {
+	return [...rows.entries()]
+		.filter(([id, row]) => row.action === action && values[id] === true)
+		.map(([, row]) => row.status);
 }
 
-function renderDescription(missing: readonly ToppingStatus[], activeItemId: string | undefined): string[] {
-	const active = missing.find(({ topping }) => topping.pkg === activeItemId);
+function renderDescription(
+	rows: ReadonlyMap<string, SetupRow>,
+	activeItemId: string | undefined,
+	values: Record<string, MenuValue>,
+): string[] {
+	if (activeItemId === undefined) return ["Select a topping to see what it does."];
+	const active = rows.get(activeItemId);
 	if (!active) return ["Select a topping to see what it does."];
-	const url = `https://pi.dev/packages/${active.topping.pkg}`;
-	return [active.topping.provides, "", hyperlink(url, url)];
+	const url = `https://pi.dev/packages/${active.status.topping.pkg}`;
+	const action = values[activeItemId] === true
+		? `Checked: will ${active.action === "install" ? "install" : "uninstall"}`
+		: "Unchecked: no change";
+	return [active.status.topping.provides, "", hyperlink(url, url), "", action];
 }
 
 function errorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
 
-function buildReport(succeeded: string[], failed: FailedInstall[]): string {
+function snippet(text: string): string {
+	return stripControlChars(text.trim()).slice(0, STDERR_SNIPPET_CHARS);
+}
+
+function buildReport(installed: string[], removed: string[], failed: FailedAction[]): string {
 	const lines: string[] = [];
-	if (succeeded.length > 0) lines.push(`✓ Installed: ${succeeded.join(", ")}`);
+	if (installed.length > 0) lines.push(`✓ Installed: ${installed.join(", ")}`);
+	if (removed.length > 0) lines.push(`✓ Removed: ${removed.join(", ")}`);
 	if (failed.length > 0) {
 		lines.push("✗ Failed:");
-		for (const failure of failed) lines.push(`  ${failure.spec}: ${failure.error}`);
+		for (const failure of failed) lines.push(`  ${failure.action} ${failure.spec}: ${failure.error}`);
 	}
-	if (succeeded.length > 0) {
+	if (installed.length > 0 || removed.length > 0) {
 		lines.push("");
-		lines.push("Restart Pi afterwards to activate them.");
+		lines.push("Restart Pi afterwards to apply the changes.");
 	}
 	return lines.join("\n");
 }
 
-async function installSelected(
+async function runPackageCommands(
 	ctx: ExtensionCommandContext,
 	selected: readonly ToppingStatus[],
-	install: ToppingInstaller,
-): Promise<{ succeeded: string[]; failed: FailedInstall[] }> {
+	runner: PiPackageRunner,
+	action: PackageAction,
+): Promise<{ succeeded: string[]; failed: FailedAction[] }> {
 	const succeeded: string[] = [];
-	const failed: FailedInstall[] = [];
+	const failed: FailedAction[] = [];
 	for (const { topping } of selected) {
 		const spec = `npm:${topping.pkg}`;
-		ctx.ui.notify(`Installing ${spec}…`, "info");
+		ctx.ui.notify(`${action === "install" ? "Installing" : "Removing"} ${spec}…`, "info");
 		try {
-			const result = await install(spec, INSTALL_TIMEOUT_MS);
+			const result = await runner(spec, PI_COMMAND_TIMEOUT_MS);
 			if (result.code === 0) {
 				succeeded.push(spec);
 			} else {
-				failed.push({ spec, error: stripControlChars((result.stderr || result.stdout || `exit ${result.code}`).trim()).slice(0, STDERR_SNIPPET_CHARS) });
+				failed.push({ action, spec, error: snippet(result.stderr || result.stdout || `exit ${result.code}`) });
 			}
 		} catch (error) {
-			failed.push({ spec, error: stripControlChars(errorMessage(error)).slice(0, STDERR_SNIPPET_CHARS) });
+			failed.push({ action, spec, error: snippet(errorMessage(error)) });
 		}
 	}
 	return { succeeded, failed };
 }
 
-export function registerSetupCommand(pi: ExtensionAPI, install: ToppingInstaller = spawnPiInstall): void {
+export function registerSetupCommand(
+	pi: ExtensionAPI,
+	install: PiPackageRunner = spawnPiInstall,
+	remove: PiPackageRunner = spawnPiRemove,
+): void {
 	pi.registerCommand("topping-setup", {
-		description: "Install missing Pi Topping sibling extensions or manage the missing-extension notice.",
+		description: "Install or uninstall Pi Topping sibling extensions or manage the missing-extension notice.",
 		handler: async (args, ctx) => {
 			const action = args.trim();
 			if (action === "disable-side-toppings-check" || action === "enable-side-toppings-check") {
@@ -96,41 +121,62 @@ export function registerSetupCommand(pi: ExtensionAPI, install: ToppingInstaller
 				return;
 			}
 
-			const missing = findMissingToppings(pi);
-			if (missing.length === 0) {
+			const statuses = detectToppings(pi);
+			const removable = statuses.filter((status) => status.packageSource !== undefined);
+			const missing = statuses.filter((status) => !status.active && status.packageSource === undefined);
+			if (missing.length === 0 && removable.length === 0) {
 				ctx.ui.notify("All Pi Topping extensions are already active in this session.", "info");
 				return;
 			}
 
+			const rows = new Map<string, SetupRow>();
+			for (const status of missing) rows.set(`install:${status.topping.pkg}`, { status, action: "install" });
+			for (const status of removable) rows.set(`remove:${status.topping.pkg}`, { status, action: "remove" });
+			const sections = [];
+			if (missing.length > 0) {
+				sections.push({
+					title: "Missing Toppings",
+					items: missing.map(({ topping, onDisk }) => ({
+						id: `install:${topping.pkg}`,
+						label: `${topping.pkg}${onDisk ? " (on disk, not active)" : ""}`,
+						value: true,
+					})),
+				});
+			}
+			if (removable.length > 0) {
+				sections.push({
+					title: "Installed Toppings",
+					items: removable.map(({ topping, active }) => ({
+						id: `remove:${topping.pkg}`,
+						label: `${topping.pkg}${active ? " (active)" : " (installed, not active)"}`,
+						value: false,
+					})),
+				});
+			}
+
 			const result = await showMenu<Record<string, boolean>>(ctx, {
 				title: "Pi Topping: Setup",
-				sections: [
-					{
-						title: "Missing Toppings",
-						items: missing.map(({ topping, onDisk }) => ({
-							id: topping.pkg,
-							label: `${topping.pkg}${onDisk ? " (on disk, not active)" : ""}`,
-							value: true,
-						})),
-					},
-				],
-				hints: ["↑↓ move", "PgUp/PgDn page", "␣ toggle", "⏎ install", "esc cancel"],
+				sections,
+				hints: ["↑↓ move", "PgUp/PgDn page", "␣ toggle", "⏎ apply", "esc cancel"],
 				previewTitle: "Description",
-				preview: (_values, _elapsedMs, activeItemId) => ({ lines: renderDescription(missing, activeItemId) }),
+				preview: (values, _elapsedMs, activeItemId) => ({ lines: renderDescription(rows, activeItemId, values) }),
 			});
 			if (!result.applied) {
 				ctx.ui.notify("Pi Topping setup cancelled.", "info");
 				return;
 			}
 
-			const selected = selectedToppings(missing, result.values);
-			if (selected.length === 0) {
-				ctx.ui.notify("No Pi Topping extensions selected.", "info");
+			const removals = selectedRows(rows, result.values, "remove");
+			const installs = selectedRows(rows, result.values, "install");
+			if (removals.length === 0 && installs.length === 0) {
+				ctx.ui.notify("No Pi Topping changes selected.", "info");
 				return;
 			}
 
-			const { succeeded, failed } = await installSelected(ctx, selected, install);
-			ctx.ui.notify(buildReport(succeeded, failed), failed.length > 0 ? "warning" : "info");
+			const removalResult = await runPackageCommands(ctx, removals, remove, "remove");
+			const installResult = await runPackageCommands(ctx, installs, install, "install");
+			const failed = [...removalResult.failed, ...installResult.failed];
+			ctx.ui.notify(buildReport(installResult.succeeded, removalResult.succeeded, failed), failed.length > 0 ? "warning" : "info");
 		},
 	});
 }

package/src/toppings.ts

@@ -1,4 +1,5 @@
-import { getAgentDir, type ExtensionAPI, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, type ExtensionAPI, type ExtensionUIContext, type Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { isSetupCheckDisabled } from "./setup-check.ts";
@@ -15,6 +16,8 @@ export interface ToppingStatus {
 	readonly topping: Topping;
 	readonly active: boolean;
 	readonly onDisk: boolean;
+	/** Exact npm source recorded in Pi's user settings for this topping. */
+	readonly packageSource: string | undefined;
 }
 
 export const TOPPINGS: readonly Topping[] = [
@@ -42,6 +45,12 @@ export const TOPPINGS: readonly Topping[] = [
 		dir: "pi-topping-web-tools",
 		provides: "web research and browser automation",
 	},
+	{
+		pkg: "@underactive/pi-topping-moa-fusion",
+		matches: /pi-topping-moa-fusion/i,
+		dir: "pi-topping-moa-fusion",
+		provides: "Mixture-of-Agents Fusion plan mode",
+	},
 ];
 
 interface PiSettings {
@@ -51,6 +60,7 @@ interface PiSettings {
 
 interface SettingsToppingState {
 	packageInstalled: boolean;
+	packageSource?: string;
 	extensionPresent: boolean;
 	extensionActive: boolean;
 }
@@ -61,6 +71,22 @@ function stringEntries(value: unknown): string[] {
 	return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : [];
 }
 
+function sourceEntries(value: unknown): string[] {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry) => {
+		if (typeof entry === "string") return [entry];
+		return isPlainObject(entry) && typeof entry.source === "string" ? [entry.source] : [];
+	});
+}
+
+function npmPackageName(source: string): string | undefined {
+	const value = source.trim();
+	if (!value.startsWith("npm:")) return undefined;
+	const spec = value.slice("npm:".length);
+	const versionIndex = spec.lastIndexOf("@");
+	return versionIndex > 0 ? spec.slice(0, versionIndex) : spec;
+}
+
 function readPiSettings(): PiSettings | undefined {
 	try {
 		const parsed: unknown = JSON.parse(readFileSync(join(getAgentDir(), "settings.json"), "utf8"));
@@ -78,10 +104,12 @@ function extensionEntry(entry: string): { value: string; disabled: boolean } {
 
 function settingsState(settings: PiSettings | undefined, topping: Topping): SettingsToppingState {
 	let packageInstalled = false;
+	let packageSource: string | undefined;
 	let extensionPresent = false;
 	let extensionActive = false;
-	for (const entry of stringEntries(settings?.packages)) {
+	for (const entry of sourceEntries(settings?.packages)) {
 		if (topping.matches.test(entry)) packageInstalled = true;
+		if (npmPackageName(entry) === topping.pkg) packageSource = entry;
 	}
 	for (const entry of stringEntries(settings?.extensions)) {
 		const normalized = extensionEntry(entry);
@@ -89,7 +117,7 @@ function settingsState(settings: PiSettings | undefined, topping: Topping): Sett
 		extensionPresent = true;
 		if (!normalized.disabled) extensionActive = true;
 	}
-	return { packageInstalled, extensionPresent, extensionActive };
+	return { packageInstalled, packageSource, extensionPresent, extensionActive };
 }
 
 function runtimeActiveToppings(pi: ExtensionAPI): Array<true | undefined> | undefined {
@@ -117,7 +145,7 @@ export function detectToppings(pi: ExtensionAPI): ToppingStatus[] {
 		const checkoutPresent = existsSync(join(extensionsDir, topping.dir));
 		const onDisk = configured.packageInstalled || configured.extensionPresent || checkoutPresent;
 		const fallbackActive = configured.packageInstalled || configured.extensionActive || checkoutPresent;
-		return { topping, active: runtime?.[index] ?? fallbackActive, onDisk };
+		return { topping, active: runtime?.[index] ?? fallbackActive, onDisk, packageSource: configured.packageSource };
 	});
 }
 
@@ -125,31 +153,52 @@ export function findMissingToppings(pi: ExtensionAPI): ToppingStatus[] {
 	return detectToppings(pi).filter((status) => !status.active);
 }
 
-function renderMissingBanner(missing: readonly ToppingStatus[]): string {
-	const title = `pi-topping: ${missing.length} topping extensions missing`;
-	const body = [
-		...missing.map(({ topping }) => `• ${topping.pkg} — ${topping.provides}`),
-		"",
-		"Run `/topping-setup` to selectively install them",
-		"Run `/topping-setup disable-side-toppings-check` to suppress this message",
+interface BannerLine {
+	readonly plain: string;
+	readonly styled: string;
+}
+
+function renderMissingBanner(missing: readonly ToppingStatus[], theme: Pick<Theme, "fg">): string {
+	const text = (value: string): string => theme.fg("text", value);
+	const accent = (value: string): string => theme.fg("accent", value);
+	const warning = (value: string): string => theme.fg("warning", value);
+	const title: BannerLine = {
+		plain: `pi-topping: ${missing.length} topping extensions missing`,
+		styled: text(`pi-topping: ${missing.length} topping extensions missing`),
+	};
+	const body: BannerLine[] = [
+		...missing.map(({ topping }) => ({
+			plain: `• ${topping.pkg} — ${topping.provides}`,
+			styled: `${text("• ")}${accent(topping.pkg)}${text(` — ${topping.provides}`)}`,
+		})),
+		{ plain: "", styled: "" },
+		{
+			plain: "Run /topping-setup to selectively install them",
+			styled: `${text("Run ")}${accent("/topping-setup")}${text(" to selectively install them")}`,
+		},
+		{
+			plain: "Run /topping-setup disable-side-toppings-check to suppress this message",
+			styled: `${text("Run ")}${accent("/topping-setup disable-side-toppings-check")}${text(" to suppress this message")}`,
+		},
 	];
-	const width = Math.max(title.length + 6, ...body.map((line) => line.length + 4));
-	const blankRow = `│${" ".repeat(width - 2)}│`;
+	const titleWidth = visibleWidth(title.plain);
+	const width = Math.max(titleWidth + 6, ...body.map((line) => visibleWidth(line.plain) + 4));
+	const blankRow = `${warning("│")}${" ".repeat(width - 2)}${warning("│")}`;
 	return [
-		`╭─ ${title} ${"─".repeat(width - title.length - 5)}╮`,
+		`${warning("╭─")} ${title.styled} ${warning("─".repeat(width - titleWidth - 5))}${warning("╮")}`,
 		blankRow,
-		...body.map((line) => `│ ${line.padEnd(width - 4)} │`),
+		...body.map((line) => `${warning("│")} ${line.styled}${" ".repeat(width - visibleWidth(line.plain) - 4)} ${warning("│")}`),
 		blankRow,
-		`╰${"─".repeat(width - 2)}╯`,
+		`${warning("╰")}${warning("─".repeat(width - 2))}${warning("╯")}`,
 	].join("\n");
 }
 
-export function notifyMissingToppingsOnce(pi: ExtensionAPI, ui: Pick<ExtensionUIContext, "notify">): void {
+export function notifyMissingToppingsOnce(pi: ExtensionAPI, ui: Pick<ExtensionUIContext, "notify" | "theme">): void {
 	if (setupNoticeHandled) return;
 	setupNoticeHandled = true;
 	if (isSetupCheckDisabled()) return;
 	const missing = findMissingToppings(pi);
-	if (missing.length > 0) ui.notify(`\n${renderMissingBanner(missing)}`, "warning");
+	if (missing.length > 0) ui.notify(`\n${renderMissingBanner(missing, ui.theme)}`, "warning");
 }
 
 /** Test-only reset for the once-per-process session-start notice. */

package/src/word-packs.ts

@@ -112,7 +112,7 @@ export function selectWorkingTextSelection(enabled: Record<string, boolean>, pac
 	const total = WORDS.length + enabledWords.length;
 	const idx = Math.min(total - 1, Math.floor(fraction * total));
 	const entry = idx < WORDS.length ? WORDS[idx] : enabledWords[idx - WORDS.length];
-	return { text: `${entry.present_tense}…`, pastTense: entry.past_tense };
+	return { text: entry.present_tense, pastTense: entry.past_tense };
 }
 
 export function pickWorkingTextSelection(enabled: Record<string, boolean>, packs: readonly WordPack[]): WorkingTextSelection {

package/src/words.ts

@@ -1,8 +1,8 @@
 /**
- * Activity word list for the randomized "Working..." indicator.
+ * Activity word list for the randomized "Working" indicator.
  *
  * A random word is picked on prompt and on tool execution start
- * (see index.ts).
+ * (see SessionManager in src/session.ts).
  */
 
 export interface WordEntry {
@@ -10,14 +10,6 @@ export interface WordEntry {
 	past_tense: string;
 }
 
-export function pickRawWord(): WordEntry {
-	return WORDS[Math.floor(Math.random() * WORDS.length)]!;
-}
-
-export function pickRandomWord(): string {
-	return `${pickRawWord().present_tense}…`;
-}
-
 export const WORDS: WordEntry[] = [
 	{ present_tense: "Accomplishing", past_tense: "Accomplished" },
 	{ present_tense: "Actioning", past_tense: "Actioned" },