pi-bar 0.3.2 → 0.3.4

package/README.md

@@ -9,7 +9,7 @@
 ◈ claude-opus-4.7  ❯  ✦ think:med  ❯  ◷ 2.6% / 1.0M  ❯  ✧ plan:active
 ```
 
-![pi-bar screenshot, three rows showing green, yellow, and red context usage](https://cdn.jsdelivr.net/npm/pi-bar@0.3.2/assets/screenshot.png)
+![pi-bar screenshot, three rows showing green, yellow, and red context usage](https://cdn.jsdelivr.net/npm/pi-bar@0.3.4/assets/screenshot.png)
 
 ## Why use it?
 
@@ -45,6 +45,19 @@ PI_BAR_SHOW=model,context pi
 
 Allowed segments are `model`, `thinking`, `context`, and `extensions`. The `extensions` segment is hidden when no extension has set a status.
 
+### Configure extension statuses
+
+pi-bar shows statuses set by other extensions with `ctx.ui.setStatus()`.
+Use `/bar` inside pi to open an interactive status-visibility picker.
+
+```text
+/bar
+```
+
+Toggle each status key between `shown` and `hidden`. The `New statuses` row controls whether status keys discovered later are shown or hidden by default.
+
+Status filter choices persist in the current session. Advanced command forms like `/bar status hide <key>` still work for scripting.
+
 ### Change context thresholds
 
 ```bash

package/extensions/status-footer.ts

@@ -16,11 +16,28 @@
  *   PI_BAR_ICONS=unicode|plain|emoji|nerdfont
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth } from "@earendil-works/pi-tui";
+import {
+	getSettingsListTheme,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+	Container,
+	type SettingItem,
+	SettingsList,
+	truncateToWidth,
+} from "@earendil-works/pi-tui";
 
 type SegmentName = "model" | "thinking" | "context" | "extensions";
 type IconPreset = "unicode" | "plain" | "emoji" | "nerdfont";
+type StatusFilter =
+	| { mode: "all"; hidden: Set<string> }
+	| { mode: "only"; shown: Set<string> };
+type SerializedStatusFilter =
+	| { mode: "all"; hidden: string[] }
+	| { mode: "only"; shown: string[] };
+
+const STATUS_FILTER_ENTRY_TYPE = "pi-bar-status-filter";
 
 const DEFAULT_SEGMENTS: SegmentName[] = [
 	"model",
@@ -175,24 +192,272 @@ function prefixed(icon: string, text: string, preset: IconPreset): string {
 	return `${icon} ${text}`;
 }
 
-function formatExtensionStatuses(statuses: ReadonlyMap<string, string>): string | null {
+function shouldShowStatus(key: string, filter: StatusFilter): boolean {
+	if (filter.mode === "only") return filter.shown.has(key);
+	return !filter.hidden.has(key);
+}
+
+function formatExtensionStatuses(
+	statuses: ReadonlyMap<string, string>,
+	filter: StatusFilter,
+	seenStatusKeys: Set<string>,
+): string | null {
 	const parts = Array.from(statuses.entries())
 		.filter(([, text]) => text.trim().length > 0)
+		.filter(([key]) => {
+			seenStatusKeys.add(key);
+			return shouldShowStatus(key, filter);
+		})
 		.map(([key, text]) => `${key}:${text}`);
 
 	return parts.length > 0 ? parts.join(" ") : null;
 }
 
+function serializeStatusFilter(filter: StatusFilter): SerializedStatusFilter {
+	if (filter.mode === "only") {
+		return { mode: "only", shown: Array.from(filter.shown).sort() };
+	}
+	return { mode: "all", hidden: Array.from(filter.hidden).sort() };
+}
+
+function parseSerializedStatusFilter(value: unknown): StatusFilter | null {
+	if (!value || typeof value !== "object") return null;
+	const data = value as Partial<SerializedStatusFilter>;
+
+	if (data.mode === "only" && Array.isArray(data.shown)) {
+		return { mode: "only", shown: new Set(data.shown) };
+	}
+	if (data.mode === "all" && Array.isArray(data.hidden)) {
+		return { mode: "all", hidden: new Set(data.hidden) };
+	}
+	return null;
+}
+
+function splitStatusKeys(raw: string): string[] {
+	return raw
+		.split(/[\s,]+/)
+		.map((key) => key.trim())
+		.filter(Boolean);
+}
+
+function describeStatusFilter(filter: StatusFilter): string {
+	if (filter.mode === "only") {
+		const shown = Array.from(filter.shown).sort();
+		return shown.length > 0 ? `showing only: ${shown.join(", ")}` : "showing none";
+	}
+
+	const hidden = Array.from(filter.hidden).sort();
+	return hidden.length > 0 ? `showing all except: ${hidden.join(", ")}` : "showing all";
+}
+
+function getKnownStatusKeys(filter: StatusFilter, seenStatusKeys: Set<string>): string[] {
+	const keys = new Set(seenStatusKeys);
+	if (filter.mode === "only") {
+		for (const key of filter.shown) keys.add(key);
+	} else {
+		for (const key of filter.hidden) keys.add(key);
+	}
+	return Array.from(keys).sort();
+}
+
 export default function (pi: ExtensionAPI) {
 	let requestRender: (() => void) | undefined;
+	let statusFilter: StatusFilter = { mode: "all", hidden: new Set() };
+	const seenStatusKeys = new Set<string>();
 	const refresh = () => requestRender?.();
+	const restoreStatusFilter = (ctx: ExtensionContext) => {
+		let restoredFilter: StatusFilter | null = null;
+		for (const entry of ctx.sessionManager.getBranch()) {
+			if (entry.type === "custom" && entry.customType === STATUS_FILTER_ENTRY_TYPE) {
+				restoredFilter = parseSerializedStatusFilter(entry.data);
+			}
+		}
+		statusFilter = restoredFilter ?? { mode: "all", hidden: new Set() };
+	};
+	const persistStatusFilter = () => {
+		pi.appendEntry(STATUS_FILTER_ENTRY_TYPE, serializeStatusFilter(statusFilter));
+		refresh();
+	};
+	const openStatusConfigurator = async (ctx: ExtensionContext) => {
+		const knownStatusKeys = getKnownStatusKeys(statusFilter, seenStatusKeys);
+		if (knownStatusKeys.length === 0) {
+			ctx.ui.notify(
+				"No extension statuses seen yet. Open /bar after another extension calls ctx.ui.setStatus().",
+				"info",
+			);
+			return;
+		}
+
+		await ctx.ui.custom((tui, theme, _kb, done) => {
+			let futureShown = statusFilter.mode === "all";
+			const statusVisibility = new Map(
+				knownStatusKeys.map((key) => [key, shouldShowStatus(key, statusFilter)]),
+			);
+			const persistFromVisibility = () => {
+				if (futureShown) {
+					statusFilter = {
+						mode: "all",
+						hidden: new Set(
+							knownStatusKeys.filter((key) => !statusVisibility.get(key)),
+						),
+					};
+				} else {
+					statusFilter = {
+						mode: "only",
+						shown: new Set(
+							knownStatusKeys.filter((key) => statusVisibility.get(key)),
+						),
+					};
+				}
+				persistStatusFilter();
+			};
+
+			const items: SettingItem[] = [
+				{
+					id: "__future",
+					label: "New statuses",
+					description: "Default visibility for status keys discovered later",
+					currentValue: futureShown ? "shown" : "hidden",
+					values: ["shown", "hidden"],
+				},
+				...knownStatusKeys.map((key): SettingItem => ({
+					id: key,
+					label: key,
+					description: "Extension status visibility",
+					currentValue: statusVisibility.get(key) ? "shown" : "hidden",
+					values: ["shown", "hidden"],
+				})),
+			];
+
+			const container = new Container();
+			container.addChild(
+				new (class {
+					render(_width: number) {
+						return [
+							theme.fg("accent", theme.bold("pi-bar status visibility")),
+							theme.fg("dim", "Enter/Space toggles · Esc closes"),
+							"",
+						];
+					}
+					invalidate() {}
+				})(),
+			);
+
+			const settingsList = new SettingsList(
+				items,
+				Math.min(items.length + 2, 15),
+				getSettingsListTheme(),
+				(id, newValue) => {
+					if (id === "__future") {
+						futureShown = newValue === "shown";
+					} else {
+						statusVisibility.set(id, newValue === "shown");
+					}
+					persistFromVisibility();
+				},
+				() => done(undefined),
+				{ enableSearch: true },
+			);
+
+			container.addChild(settingsList);
+
+			return {
+				render(width: number) {
+					return container.render(width);
+				},
+				invalidate() {
+					container.invalidate();
+				},
+				handleInput(data: string) {
+					settingsList.handleInput?.(data);
+					tui.requestRender();
+				},
+			};
+		});
+	};
+
+	pi.registerCommand("bar", {
+		description: "Configure pi-bar footer status segments",
+		handler: async (args, ctx) => {
+			const [section, action, ...rest] = args.trim().split(/\s+/).filter(Boolean);
+			if (!section || ((section === "status" || section === "statuses") && !action)) {
+				await openStatusConfigurator(ctx);
+				return;
+			}
+
+			if (section === "status" || section === "statuses") {
+				const keys = splitStatusKeys(rest.join(" "));
+
+				switch (action) {
+					case "config":
+					case "configure":
+					case "edit":
+						await openStatusConfigurator(ctx);
+						return;
+					case "list":
+					case "ls": {
+						const known = getKnownStatusKeys(statusFilter, seenStatusKeys);
+						ctx.ui.notify(
+							`pi-bar statuses: ${describeStatusFilter(statusFilter)}${known.length > 0 ? `; known: ${known.join(", ")}` : "; known: none yet"}`,
+							"info",
+						);
+						return;
+					}
+					case "all":
+						statusFilter = { mode: "all", hidden: new Set() };
+						break;
+					case "none":
+						statusFilter = { mode: "only", shown: new Set() };
+						break;
+					case "only":
+						statusFilter = { mode: "only", shown: new Set(keys) };
+						break;
+					case "hide":
+						if (statusFilter.mode === "only") {
+							for (const key of keys) statusFilter.shown.delete(key);
+						} else {
+							for (const key of keys) statusFilter.hidden.add(key);
+						}
+						break;
+					case "show":
+						if (statusFilter.mode === "only") {
+							for (const key of keys) statusFilter.shown.add(key);
+						} else {
+							for (const key of keys) statusFilter.hidden.delete(key);
+						}
+						break;
+					default:
+						ctx.ui.notify(
+							"Usage: /bar status [list|all|none|only <keys>|show <keys>|hide <keys>]",
+							"warning",
+						);
+						return;
+				}
+
+				persistStatusFilter();
+				ctx.ui.notify(`pi-bar statuses: ${describeStatusFilter(statusFilter)}`, "info");
+				return;
+			}
+
+			ctx.ui.notify(
+				"Usage: /bar status [list|all|none|only <keys>|show <keys>|hide <keys>]",
+				"warning",
+			);
+		},
+	});
 
 	pi.on("model_select", async () => refresh());
 	pi.on("thinking_level_select", async () => refresh());
 	pi.on("turn_end", async () => refresh());
 	pi.on("message_end", async () => refresh());
+	pi.on("session_tree", async (_event, ctx) => {
+		restoreStatusFilter(ctx);
+		refresh();
+	});
 
 	pi.on("session_start", async (_event, ctx) => {
+		restoreStatusFilter(ctx);
+
 		if (!ctx.hasUI) return;
 
 		const visibleSegments = parseSegments();
@@ -213,6 +478,8 @@ export default function (pi: ExtensionAPI) {
 					const thinkingLevel = String(pi.getThinkingLevel());
 					const extensionStatuses = formatExtensionStatuses(
 						footerData?.getExtensionStatuses?.() ?? new Map(),
+						statusFilter,
+						seenStatusKeys,
 					);
 					const usage = ctx.getContextUsage();
 					const contextSegmentColor = contextColor(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-bar",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Never accidentally run Opus on a typo. Pi footer/statusline showing active model, thinking level, context usage, and extension statuses.",
   "type": "module",
   "keywords": [
@@ -46,6 +46,6 @@
     "extensions": [
       "./extensions/status-footer.ts"
     ],
-    "image": "https://cdn.jsdelivr.net/npm/pi-bar@0.3.2/assets/screenshot.png"
+    "image": "https://cdn.jsdelivr.net/npm/pi-bar@0.3.4/assets/screenshot.png"
   }
 }