@gavin-hu/my-pi-agent 0.7.0 → 0.8.1

package/extensions/bytefly/footer/register.ts

@@ -1,14 +1,12 @@
 /**
- * The footer surface: the two-line status bar, the `/bytefly` surface toggle,
- * and the session lifecycle that installs and restores the footer.
+ * The footer surface: the two-line status bar and the session lifecycle that
+ * installs and restores it.
  *
  * The footer is installed only in interactive (`tui`) sessions, and the price
- * configuration is read once per install, so toggling the footer — or starting
- * a new session — is how an edited `bytefly.json` is picked up. Nothing watches
- * the file.
- *
- * `/bytefly` also drives the header surface, injected by the composition root
- * so this folder never imports `header/`.
+ * configuration is read once per install, so starting a new session or changing
+ * the session tree is how an edited `bytefly.json` is picked up. Nothing watches
+ * the file. The surface is always on; `pi config` is the way to turn bytefly's
+ * chrome off.
  */
 
 import { homedir } from "node:os";
@@ -17,96 +15,24 @@ import { createSnapshotReader } from "./collect/snapshot.ts";
 import { loadByteflyConfig } from "./price/config.ts";
 import { createFooter } from "./render/footer.ts";
 
-/** A bytefly surface the `/bytefly` command can enable or disable. */
-export interface ChromeSurface {
-	/** Install the surface, or restore Pi's built-in one, from the current state. */
-	apply(ctx: ExtensionContext): void;
-	/** Whether the surface is currently on. */
-	isEnabled(): boolean;
-	/** Set the enabled flag without installing. */
-	setEnabled(enabled: boolean): void;
-}
-
-/** Host seams for the footer surface. */
-export interface FooterDeps {
-	/** The header surface, toggled by `/bytefly header` and the master switch. */
-	header?: ChromeSurface;
-}
-
-/** Register `/bytefly [header|footer|status]` and the install/restore lifecycle. */
-export function registerFooter(pi: ExtensionAPI, deps: FooterDeps = {}): void {
-	let enabled = true;
-
+/** Register the footer install/restore lifecycle. */
+export function registerFooter(pi: ExtensionAPI): void {
 	const install = (ctx: ExtensionContext): void => {
 		if (ctx.mode !== "tui") return;
 		const config = loadByteflyConfig(ctx.cwd);
 		const read = createSnapshotReader(config);
 
-		if (enabled) {
-			ctx.ui.setFooter((tui, _theme, footerData) =>
-				createFooter(
-					tui,
-					footerData,
-					() => read(ctx, footerData),
-					() => ctx.ui.theme,
-					homedir(),
-				),
-			);
-		} else {
-			ctx.ui.setFooter(undefined);
-		}
+		ctx.ui.setFooter((tui, _theme, footerData) =>
+			createFooter(
+				tui,
+				footerData,
+				() => read(ctx, footerData),
+				() => ctx.ui.theme,
+				homedir(),
+			),
+		);
 	};
 
-	const header = deps.header;
-	const headerState = (): string => (header?.isEnabled() ? "on" : "off");
-
-	pi.registerCommand("bytefly", {
-		description: "Toggle the TUI bytefly chrome: /bytefly [header|footer|status]",
-		getArgumentCompletions: (prefix: string) => {
-			const action = prefix.trim();
-			const options = ["footer", "header", "status"].filter((option) => option.startsWith(action));
-			return options.length > 0 ? options.map((value) => ({ value, label: value })) : null;
-		},
-		handler: async (args, ctx) => {
-			if (ctx.mode !== "tui") return;
-			const sub = args.trim().toLowerCase();
-
-			if (sub === "status") {
-				ctx.ui.notify(`bytefly: header ${headerState()}, footer ${enabled ? "on" : "off"}`, "info");
-				return;
-			}
-			if (sub === "header") {
-				if (!header) {
-					ctx.ui.notify("bytefly: header surface is not available", "warning");
-					return;
-				}
-				header.setEnabled(!header.isEnabled());
-				header.apply(ctx);
-				ctx.ui.notify(`bytefly header ${headerState()}`, "info");
-				return;
-			}
-			if (sub === "footer") {
-				enabled = !enabled;
-				install(ctx);
-				ctx.ui.notify(`bytefly footer ${enabled ? "on" : "off"}`, "info");
-				return;
-			}
-			if (sub === "") {
-				// The master switch brings both surfaces to one state.
-				const next = !(enabled && (header?.isEnabled() ?? true));
-				enabled = next;
-				install(ctx);
-				if (header) {
-					header.setEnabled(next);
-					header.apply(ctx);
-				}
-				ctx.ui.notify(`bytefly ${next ? "on" : "off"}`, "info");
-				return;
-			}
-			ctx.ui.notify("usage: /bytefly [header|footer|status]", "warning");
-		},
-	});
-
 	pi.on("session_start", (_event, ctx) => install(ctx));
 	pi.on("session_tree", (_event, ctx) => install(ctx));
 	pi.on("session_shutdown", (_event, ctx) => {

package/extensions/bytefly/header/component.ts

@@ -65,10 +65,14 @@ export class ByteflyHeader implements Component {
 		const pad = " ".repeat(Math.min(padX, Math.max(0, w - 1)));
 		const [markTop, markBottom] = markLines(theme, view.halfBlocks);
 
-		const agent =
-			view.showVersion && this.version
-				? `${theme.fg(nameColor, HEADER_CONFIG.appName)} ${theme.fg(versionColor, `v${this.version}`)}`
-				: theme.fg(nameColor, HEADER_CONFIG.appName);
+		const version = view.showVersion && this.version ? theme.fg(versionColor, `v${this.version}`) : "";
+		// The wordmark mark spells the app name, so the agent cell carries only the
+		// version there; the half-block mark does not, so the name stays beside it.
+		const agent = view.halfBlocks
+			? version
+				? `${theme.fg(nameColor, HEADER_CONFIG.appName)} ${version}`
+				: theme.fg(nameColor, HEADER_CONFIG.appName)
+			: version;
 		const chrome = `${theme.fg(versionColor, chromeTagline)} ${theme.fg(nameColor, chromeName)}`;
 		const chromeVersioned = chromeVersion ? `${chrome} ${theme.fg(versionColor, `v${chromeVersion}`)}` : chrome;
 

package/extensions/bytefly/header/config.ts

@@ -58,20 +58,25 @@ export const HEADER_CONFIG: HeaderConfig = {
 		[
 			{ binding: "app.interrupt", description: "to interrupt" },
 			{ binding: "app.clear", description: "to clear" },
-			{ binding: "app.exit", description: "to exit" },
+			{ binding: "app.exit", description: "to exit (empty)" },
 			{ binding: "app.suspend", description: "to suspend" },
 		],
 		[
-			{ binding: EXPAND_KEYBINDING, description: "more" },
-			{ binding: "app.thinking.toggle", description: "to think" },
-			{ binding: "app.model.select", description: "models" },
-			{ binding: "app.editor.external", description: "editor" },
+			{ binding: EXPAND_KEYBINDING, description: "to expand tools" },
+			{ binding: "app.thinking.toggle", description: "to expand thinking" },
+			{ binding: "app.model.select", description: "to select model" },
+			{ binding: "app.model.cycleForward", description: "to cycle models" },
+			{ binding: "app.thinking.cycle", description: "to cycle thinking" },
+			{ binding: "app.editor.external", description: "for external editor" },
 		],
 		[
 			{ raw: "/", description: "commands" },
 			{ raw: "!", description: "bash" },
-			{ raw: "/bytefly", description: "chrome" },
+			{ raw: "!!", description: "bash (no context)" },
+			{ raw: "/bytefly", description: "extensions" },
 			{ raw: "/doctor", description: "checks" },
+			{ binding: "app.message.followUp", description: "to queue follow-up" },
+			{ binding: "app.clipboard.pasteImage", description: "paste files" },
 		],
 	],
 };

package/extensions/bytefly/header/register.ts

@@ -1,11 +1,10 @@
 /**
- * The header surface: installs bytefly's custom header on interactive
- * sessions and restores Pi's built-in header on shutdown.
+ * The header surface: installs bytefly's custom header on interactive sessions
+ * and restores Pi's built-in header on shutdown.
  *
- * The surface is toggleable: `/bytefly header` (and the `/bytefly` master
- * switch) calls `setEnabled` then `apply`, and a new session re-applies the
- * current state. It is installed only in interactive (`tui`) sessions; every
- * other mode leaves Pi's built-in header in place, which does not exist there.
+ * The surface is always on; `pi config` is the way to turn bytefly's chrome off.
+ * It is installed only in interactive (`tui`) sessions; every other mode leaves
+ * Pi's built-in header in place, which does not exist there.
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -13,27 +12,16 @@ import { isAppleTerminalSession } from "@earendil-works/pi-tui";
 import { createHeader, type HeaderView } from "./component.ts";
 import { HEADER_CONFIG } from "./config.ts";
 
-/** The header surface, as `/bytefly` drives it. */
-export interface HeaderSurface {
-	/** Install the header, or restore Pi's built-in one, from the current state. */
-	apply(ctx: ExtensionContext): void;
-	/** Whether the header is currently on. */
-	isEnabled(): boolean;
-	/** Set the enabled flag without installing. */
-	setEnabled(enabled: boolean): void;
-}
-
 /** Register the install/restore lifecycle for the custom header. */
-export function registerHeader(pi: ExtensionAPI): HeaderSurface {
+export function registerHeader(pi: ExtensionAPI): void {
 	// Half blocks misalign in Apple Terminal, so the mark falls back to a wordmark
 	// there, mirroring Pi's own built-in header.
 	const halfBlocks = !isAppleTerminalSession();
 	const view = (): HeaderView => ({ showVersion: HEADER_CONFIG.showVersion, halfBlocks });
-	let enabled = true;
 
 	const apply = (ctx: ExtensionContext): void => {
 		if (ctx.mode !== "tui") return;
-		ctx.ui.setHeader(enabled ? createHeader(() => ctx.ui.theme, view) : undefined);
+		ctx.ui.setHeader(createHeader(() => ctx.ui.theme, view));
 	};
 
 	pi.on("session_start", (_event, ctx) => apply(ctx));
@@ -42,12 +30,4 @@ export function registerHeader(pi: ExtensionAPI): HeaderSurface {
 		if (ctx.mode !== "tui") return;
 		ctx.ui.setHeader(undefined);
 	});
-
-	return {
-		apply,
-		isEnabled: () => enabled,
-		setEnabled: (value: boolean) => {
-			enabled = value;
-		},
-	};
 }

package/extensions/bytefly/index.ts

@@ -2,16 +2,17 @@
  * bytefly — the package's terminal chrome and diagnostics, composed from six
  * feature folders: `header/` (the themed startup mark and version), `footer/`
  * (the two-line, width-adaptive status bar with its price calculation),
- * `separator/` (the transcript turn rule), `picker/` (the `/extensions`
- * manager), `doctor/` (`/doctor` and `run_doctor`), and `notify/` (OS
+ * `separator/` (the transcript turn rule), `panel/` (the unified `/bytefly`
+ * screen, also reachable as `/extensions` and `/doctor`), `doctor/` (the
+ * `run_doctor` tool and its session-scoped probe runtime), and `notify/` (OS
  * notifications for unattended runs).
  *
  * The header, footer, and turn rule are installed only in interactive (`tui`)
- * sessions; the picker and doctor work in every mode, and notify works wherever
- * the environment can deliver it. The footer is priced from DeepSeek's published
- * rates by default and from `bytefly.json` otherwise, the same file whose
- * `notify` section configures notifications, and `/bytefly [header|footer|status]`
- * toggles the chrome.
+ * sessions and are always on; `pi config` turns bytefly's chrome off. The panel
+ * and doctor work in every mode, and notify works wherever the environment can
+ * deliver it. The footer is priced from DeepSeek's published rates by default
+ * and from `bytefly.json` otherwise, the same file whose `notify` section
+ * configures notifications.
  *
  * Load with:  pi --extension ./extensions/bytefly
  */
@@ -22,13 +23,13 @@ import { type DoctorDeps, registerDoctor } from "./doctor/register.ts";
 import { registerFooter } from "./footer/register.ts";
 import { registerHeader } from "./header/register.ts";
 import { type NotifyDeps, registerNotify } from "./notify/register.ts";
-import { type CommandDeps, registerExtensionsCommand } from "./picker/commands.ts";
+import { type PanelCommandDeps, registerPanel } from "./panel/commands.ts";
 import { registerTurnSeparator } from "./separator/register.ts";
 
 /** Host seams, injected by tests. */
 export interface ByteflyDeps {
-	/** Seams for the `/extensions` picker. */
-	extensions?: CommandDeps;
+	/** Seams for the picker side of the unified panel. */
+	extensions?: Pick<PanelCommandDeps, "discover">;
 	/** Seams for the doctor surface. */
 	doctor?: DoctorDeps;
 	/** Seams for the notify capability. */
@@ -39,10 +40,10 @@ export interface ByteflyDeps {
 export default function bytefly(pi: ExtensionAPI, deps: ByteflyDeps = {}): void {
 	if (!isExtensionEnabled("bytefly")) return;
 
-	const header = registerHeader(pi);
-	registerFooter(pi, { header });
+	registerHeader(pi);
+	registerFooter(pi);
 	registerTurnSeparator(pi);
-	registerExtensionsCommand(pi, deps.extensions);
-	registerDoctor(pi, deps.doctor);
+	const doctor = registerDoctor(pi, deps.doctor);
+	registerPanel(pi, { doctor, discover: deps.extensions?.discover });
 	registerNotify(pi, deps.notify);
 }

package/extensions/bytefly/panel/commands.ts

@@ -0,0 +1,147 @@
+/**
+ * The `/bytefly` surface: one runner that opens the unified panel, with
+ * `/extensions` and `/doctor` registered against the same handler.
+ *
+ * In `tui` mode it mounts the dock screen; every other mode prints the same
+ * information as text. Discovery, the doctor probe, and the dirty-to-reload
+ * confirm all live here, so the three command names cannot drift. The doctor
+ * runtime is injected by the composition root, so `run_doctor` and the screen
+ * keep reading one session cache.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { sanitizeLine } from "../../../lib/format.ts";
+import { withRailsSuppressed } from "../../../lib/rails.ts";
+import { REQUIREMENTS, type ExtensionReport } from "../../../lib/requirements.ts";
+import { formatExtension, hasProblems } from "../doctor/format.ts";
+import type { DoctorRuntime } from "../doctor/runtime.ts";
+import { discoverExtensions, type DiscoveryDeps } from "../picker/discovery.ts";
+import { createExtensionsPickerRuntime } from "../picker/runtime.ts";
+import type { Discovery } from "../picker/types.ts";
+import { formatListing } from "./format.ts";
+import { buildPanelModel, extensionName } from "./join.ts";
+import { PanelComponent } from "./tui.ts";
+
+/** Host seams for the panel command, injected by tests and the composition root. */
+export interface PanelCommandDeps {
+	/** The doctor runtime created by `registerDoctor`; shared with `run_doctor`. */
+	doctor: DoctorRuntime;
+	/** The picker's discovery seam. */
+	discover?: (deps: DiscoveryDeps) => Promise<Discovery>;
+}
+
+/**
+ * Names `/bytefly <name>` accepts: every declared extension, plus the directory
+ * of any resource in either discovery view. Reading both views keeps a
+ * project-only name valid before the screen has switched to Project scope.
+ */
+function selectableNames(discovery: Discovery): Set<string> {
+	const names = new Set<string>(Object.keys(REQUIREMENTS));
+	for (const item of [...discovery.global, ...discovery.effective]) names.add(extensionName(item.path));
+	return names;
+}
+
+/** The shared completion list: every declared extension, then `refresh`. */
+function completions(prefix: string): Array<{ value: string; label: string }> | null {
+	const options = [...Object.keys(REQUIREMENTS), "refresh"].filter((option) => option.startsWith(prefix));
+	return options.length > 0 ? options.map((value) => ({ value, label: value })) : null;
+}
+
+/** Register `/bytefly`, `/extensions`, and `/doctor` against one runner. */
+export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
+	const discover = deps.discover ?? discoverExtensions;
+
+	const handler = async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
+		const parts = args.trim().split(/\s+/).filter(Boolean);
+		const refresh = parts.includes("refresh");
+		const name = parts.find((part) => part !== "refresh");
+
+		const cwd = ctx.cwd ?? process.cwd();
+		const agentDir = getAgentDir();
+		let discovery: Discovery;
+		try {
+			discovery = await discover({ cwd, agentDir, trusted: ctx.isProjectTrusted() });
+		} catch (error) {
+			ctx.ui.notify(`Could not list extensions: ${error instanceof Error ? error.message : String(error)}`, "error");
+			return;
+		}
+
+		const runtime = createExtensionsPickerRuntime({
+			discovery,
+			cwd,
+			agentDir,
+			onError: (message) => ctx.ui.notify(message, "error"),
+		});
+
+		let reports: ExtensionReport[];
+		try {
+			reports = await deps.doctor.probeAll({ refresh });
+		} catch (error) {
+			ctx.ui.notify(`Could not probe extensions: ${error instanceof Error ? error.message : String(error)}`, "error");
+			return;
+		}
+		if (name !== undefined && !selectableNames(discovery).has(name)) {
+			ctx.ui.notify(`bytefly: no extension named "${sanitizeLine(name)}"`, "warning");
+			return;
+		}
+
+		if (ctx.mode !== "tui") {
+			if (name !== undefined) {
+				const report = reports.find((entry) => entry.extension === name);
+				if (report) {
+					ctx.ui.notify(formatExtension(report), hasProblems([report]) ? "warning" : "info");
+					return;
+				}
+				const item = runtime.items().find((entry) => extensionName(entry.path) === name);
+				ctx.ui.notify(
+					item
+						? `bytefly: ${sanitizeLine(item.path)} — no doctor report`
+						: `bytefly: no extension named "${sanitizeLine(name)}"`,
+					"info",
+				);
+				return;
+			}
+			const model = buildPanelModel({ items: runtime.items(), reports, agentDir });
+			ctx.ui.notify(formatListing(model, runtime.scope()), "info");
+			return;
+		}
+
+		// The dock screen owns the editor slot; hide the rails for its lifetime.
+		await withRailsSuppressed(pi, () =>
+			ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+				const unsubscribe = runtime.onChange(() => tui.requestRender());
+				return new PanelComponent({
+					runtime,
+					reports: () => reports,
+					filter: name,
+					theme,
+					agentDir,
+					viewportRows: () => tui.terminal?.rows,
+					requestRender: () => tui.requestRender(),
+					refresh: async () => {
+						reports = await deps.doctor.probeAll({ refresh: true });
+					},
+					onClose: () => {
+						unsubscribe();
+						done();
+					},
+					onNotice: (message) => ctx.ui.notify(message, "warning"),
+				});
+			}),
+		);
+
+		if (!runtime.isDirty()) return;
+		const reload = await ctx.ui.confirm("Reload to apply changes?", "Extension changes take effect after a reload.");
+		if (reload) await ctx.reload();
+	};
+
+	const descriptions: Array<[string, string]> = [
+		["bytefly", "Open the bytefly extension screen: /bytefly [extension] [refresh]"],
+		["extensions", "List and enable/disable extensions"],
+		["doctor", "Check extensions and enable or disable one: /doctor [extension] [refresh]"],
+	];
+	for (const [command, description] of descriptions) {
+		pi.registerCommand(command, { description, getArgumentCompletions: completions, handler });
+	}
+}

package/extensions/bytefly/panel/format.ts

@@ -0,0 +1,135 @@
+/**
+ * Non-TUI text for the unified panel.
+ *
+ * Every mode other than `tui` gets the same facts the screen shows, as plain
+ * text: a headline with the scope and the counts, then the picker's grouped
+ * listing with a health suffix on each row. A single named extension prints its
+ * full findings instead. Nothing here touches the host, and every string that
+ * came from a probe is sanitized by `doctor/format.ts`.
+ */
+
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+import { GLYPHS } from "../../../lib/ui.ts";
+import { reportSeverity, reportSummary } from "../doctor/format.ts";
+import type { PanelModel, PanelRow } from "./types.ts";
+
+/** The settings scope the screen shows. */
+export type PanelScope = "global" | "project";
+
+/** One segment of the headline, with its semantic color for the TUI. */
+export interface SummarySegment {
+	text: string;
+	color: ThemeColor;
+}
+
+/** Row and problem counts over a model. */
+export interface PanelCounts {
+	extensions: number;
+	disabled: number;
+	missing: number;
+	degraded: number;
+}
+
+/** Options for the plain-text headline and listing. */
+export interface PanelTextOptions {
+	/** Abbreviate counts (`15 ext · 3 off`) for a narrow terminal. */
+	compact?: boolean;
+}
+
+/** Options for the TUI headline, which can also name a narrowed extension. */
+export interface SummaryOptions extends PanelTextOptions {
+	/** Name the narrowed extension instead of counting the list. */
+	filter?: string;
+}
+
+/** Count the rows and their problems, once per unique report. */
+export function panelCounts(model: PanelModel): PanelCounts {
+	let disabled = 0;
+	let missing = 0;
+	let degraded = 0;
+	const seen = new Set<string>();
+	for (const row of model.rows) {
+		if (row.item && !row.item.enabled) disabled += 1;
+		const report = row.report;
+		if (!report || seen.has(report.extension)) continue;
+		seen.add(report.extension);
+		missing += report.findings.filter((finding) => finding.severity === "missing").length;
+		degraded += report.findings.filter((finding) => finding.severity === "degraded").length;
+	}
+	return { extensions: model.rows.length, disabled, missing, degraded };
+}
+
+/**
+ * The headline segments, e.g. `Global · 15 extensions · 3 disabled · 1 missing`.
+ * A narrowed model names the extension instead of counting.
+ */
+export function summarySegments(model: PanelModel, scope: PanelScope, options: SummaryOptions = {}): SummarySegment[] {
+	const counts = panelCounts(model);
+	const segments: SummarySegment[] = [{ text: scope === "global" ? "Global" : "Project", color: "accent" }];
+	if (options.filter !== undefined) {
+		segments.push({ text: `${options.filter} only`, color: "muted" });
+	} else {
+		const noun = options.compact ? "ext" : counts.extensions === 1 ? "extension" : "extensions";
+		segments.push({ text: `${counts.extensions} ${noun}`, color: "muted" });
+		if (counts.disabled > 0) {
+			segments.push({ text: `${counts.disabled} ${options.compact ? "off" : "disabled"}`, color: "muted" });
+		}
+	}
+	const problems: string[] = [];
+	if (counts.missing > 0) problems.push(`${counts.missing} missing`);
+	if (counts.degraded > 0) problems.push(`${counts.degraded} degraded`);
+	if (problems.length > 0) {
+		segments.push({ text: problems.join(", "), color: counts.missing > 0 ? "error" : "warning" });
+	}
+	return segments;
+}
+
+/** The headline as one plain line, e.g. `bytefly: Global · 15 extensions · 1 missing`. */
+export function formatHeadline(model: PanelModel, scope: PanelScope, options: PanelTextOptions = {}): string {
+	return `bytefly: ${summarySegments(model, scope, options)
+		.map((segment) => segment.text)
+		.join(" · ")}`;
+}
+
+/** Plain severity glyph for a row, or `undefined` when it has no report. */
+function rowGlyph(row: PanelRow): string | undefined {
+	if (!row.report) return undefined;
+	switch (reportSeverity(row.report)) {
+		case "missing":
+			return GLYPHS.cross;
+		case "degraded":
+			return GLYPHS.warn;
+		case "info":
+			return GLYPHS.disabled;
+		default:
+			return GLYPHS.check;
+	}
+}
+
+/** One listing row: `[x] ✓ label — summary`, with the suffix only when reported. */
+export function formatRow(row: PanelRow): string {
+	const glyph = rowGlyph(row);
+	const summary = row.report ? ` — ${reportSummary(row.report)}` : "";
+	if (!row.item) {
+		// Reported-only: there is no enable pattern to show, so no checkbox column.
+		return `  ${glyph ? `${glyph} ` : ""}${row.label}${summary}`;
+	}
+	const checkbox = row.item.enabled ? "[x]" : "[ ]";
+	return `  ${checkbox} ${glyph ? `${glyph} ` : ""}${row.label}${summary}`;
+}
+
+/** The grouped text listing, headline first, for RPC/JSON/print modes. */
+export function formatListing(model: PanelModel, scope: PanelScope, options: PanelTextOptions = {}): string {
+	const lines = [formatHeadline(model, scope, options)];
+	if (model.rows.length === 0) {
+		lines.push("", "No extensions found.");
+		return lines.join("\n");
+	}
+	for (const group of model.groups) {
+		lines.push("", `${group.label} (${group.count})`);
+		for (const row of model.rows) {
+			if (row.group === group.key) lines.push(formatRow(row));
+		}
+	}
+	return lines.join("\n");
+}