@underactive/pi-topping-statusline 0.1.0

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+Copyright (c) 2025-2026 Can Bölük
+Copyright (c) 2026 Eric Sison
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,208 @@
+# pi-topping-statusline
+
+[OMP](https://github.com/can1357/oh-my-pi)'s powerline statusline, ported as a Pi extension with modifications. 
+
+![The statusline rendered around the editor box](https://raw.githubusercontent.com/underactive/pi-topping-statusline/main/media/topping-statusline.png)
+
+The bar renders into the editor's
+**top border**: `π > model · thinking level > path > git > PR` (with the default
+powerline-thin separator), with the session name (hue hashed from the name) right-aligned
+over a border-colored fill. The box's **bottom border** carries configurable left/right
+segment groups — by default a scroll hint on the left, and pi's footer stats plus a context
+usage graph on the right.
+
+## Install
+
+```bash
+pi install npm:@underactive/pi-topping-statusline
+```
+
+Then `/reload` (or restart pi). Requirements: a [Nerd Font](https://www.nerdfonts.com) and a
+truecolor terminal for the default look — the Symbols setting in
+`/topping-statusline-settings` (`unicode` or `ascii`) drops the font requirement.
+
+## Configuration — `/topping-statusline-settings`
+
+`/topping-statusline-settings` opens a settings TUI with a live preview of the box's top and
+bottom bars. Requires TUI mode. Settings persist to `~/.pi/agent/pi-topping-statusline/settings.json`
+and apply live.
+
+```
+╔═[ Pi Topping Statusline: Settings ]════════════════════════════╗
+╟─ Preview ──────────────────────────────────────────────────────╢
+║                                                                ║
+║ ╭── π > ⬢ Sonnet · ◉ max > pi/pi-topping > main ── session ──╮ ║
+║ │                                                            │ ║
+║ ╰── ↑ 3 more ── ↑ 12.4K ↓ 3.1K R 148K W 12K 92.3% $0.42 42%──╯ ║
+║                                                                ║
+╟─ Global ───────────────────────────────────────────────────────╢
+║  ▸ [■] Transparent Segments                                ON  ║
+║    Separator                               ‹ powerline-thin ›  ║
+║    Symbols                                       ‹ nerdfont ›  ║
+║    Border style                                   ‹ rounded ›  ║
+║    [■] Rainbow border on max thinking                      ON  ║
+║                                                                ║
+╟─ Top Left Segment Group ───────────────────────────────────────╢
+║    [■] Pi symbol                                           ON  ║
+║    [■] Model                                               ON  ║
+║    [ ] Provider                                            OFF ║
+║    [■] Thinking level                                      ON  ║
+║    [■] Path                                                ON  ║
+║    [■] Git                                                 ON  ║
+║    [■] PR                                                  ON  ║
+║                                                                ║
+╟─ Top Right Segment Group ──────────────────────────────────────╢
+║    [ ] Token rate                                          OFF ║
+║    [■] Session name                                        ON  ║
+║  … Bottom Right / Bottom Left groups — 8 more toggles          ║
+║                                                                ║
+╟─ Feeds ────────────────────────────────────────────────────────╢
+║    1. type         pi-prompt-cache/savings                     ║
+║    1. field        savedUsd                                    ║
+║    1. prefix       CS                                          ║
+║    1. format                                     ‹ currency ›  ║
+║    1. remove this feed                                         ║
+║    + add feed                                                  ║
+║                                                                ║
+║  ↑↓ move  ←→ cycle  ␣ toggle  ⏎ apply/edit  esc cancel         ║
+╚════════════════════════════════════════════════════════[ 1/28 ]╝
+```
+
+| Section | Settings |
+| --- | --- |
+| Global | Transparent Segments · Separator (`powerline` `powerline-thin` `slash` `pipe` `ascii`) · Symbols (`nerdfont` `unicode` `ascii` — stored in settings.json as `nerd`/`unicode`/`ascii`) · Border style (`rounded` `heavy` `double` `single`) · Rainbow border on max thinking |
+| Top Left Segment Group | Pi symbol · Model · Provider · Thinking level · Path · Git · PR |
+| Top Right Segment Group | Token rate · Session name |
+| Bottom Right Segment Group | Feeds · Token rate · Pi stats · Context bar · Context stats |
+| Bottom Left Segment Group | Scroll hint · Feeds · Token rate |
+| Feeds | One subscription per row: type · field · prefix · format, plus add/remove |
+| Defaults | Transparent on · Separator `powerline-thin` · Symbols `nerdfont` · Border style `rounded` · Rainbow border on |
+
+With **Rainbow border on max thinking** on (the default), cycling the thinking level to `max`
+replaces the border's fixed theme color with an animated rainbow: a full hue cycle distributed
+around the box perimeter that slowly flows around the border (~14s per rotation), like Apple
+Intelligence's screen border. Any other thinking level keeps the normal theme border color.
+The settings preview animates while the toggle is on; the effect repaints the border about
+20 times a second, so switch it off over slow SSH links or in terminals with expensive
+redraws.
+
+## Segments
+
+Ported with pi data: `pi`, `model` (model · provider · thinking level), `path`
+(worktree/scratch-dir aware; always strips `~/Projects` and `/work` prefixes — not exposed in
+the settings TUI), `git` (branch + `*unstaged +staged ?untracked`, HEAD
+fs-watch), `pr` (via `gh`, hidden if missing), `session_name`, `token_rate` (live tok/s —
+accent while active, held 1.5s, faded 0.5s, then a dim `--- tok/s` placeholder; estimate
+pipelined from pi-topping's word-count EMA; available in the top-right, bottom-left, and
+bottom-right groups), `pi_stats`, `context_graph` (bar + stats), `scroll_hint`, plus `feeds`
+(documented below).
+
+When the terminal narrows: right segments drop first, then the path shrinks (to ~8 cells),
+then left segments drop end-first — the path is always the last to go.
+
+## Feeds
+
+`feeds` surfaces values other extensions publish as custom session entries, so the bar can
+carry figures this extension knows nothing about. There is one subscription list, shared by
+the Bottom Right and Bottom Left Feeds toggles — enabling both shows the same values twice.
+Each subscription is four fields, all configurable in the settings TUI:
+
+| Field | Meaning | Example |
+| --- | --- | --- |
+| type | the publisher's `customType` | `pi-prompt-cache/savings` |
+| field | property of the entry's `data` to read | `savedUsd` |
+| prefix | literal label drawn before the value | `CS` |
+| format | `currency`, `number`, or `text` | `currency` |
+
+In `settings.json` the first column is persisted as `customType`; the settings TUI labels it
+*type*. That example renders `CS$1.44`. The prefix is glued directly to the value, so write
+it as `TOK ` when you want `TOK 42`; leading and trailing spaces survive, while escape
+sequences and control characters are stripped.
+
+The list ships seeded with the savings feed published by
+[pi-prompt-cache](https://github.com/underactive/pi-prompt-cache), which is where the
+`currency` rules come from: figures under half a cent are hidden, matching that extension's
+own footer cutoff so the two never disagree. That floor hides the negative values published
+early in a session, before the cache-write premium is amortized by reads. Above the floor,
+`currency` shows two decimals below $100 and whole dollars above.
+
+A feed contributes nothing when its publisher is absent, has published nothing this run, or
+reports a value its format suppresses; the segment disappears entirely once every feed is
+quiet, so it costs nothing to leave switched on. Publishers typically reset per process run,
+so entries predating the current session start (`--resume`, `/reload`, `/new`, fork) are
+ignored rather than shown as a stale total. The session is re-read at most once every two
+seconds, because pi copies the whole entry list on each read while the bar re-renders on
+every keystroke.
+
+### Publishing a feed
+
+Any extension can expose a value to this bar with one call and no dependency on this
+package — the contract is a pi custom session entry, not an API of ours:
+
+```ts
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+	let published = 0;
+	pi.on("turn_end", () => {
+		const savedUsd = currentSavings();
+		// Publish only when the figure actually moves: consumers read the newest
+		// entry, never the history.
+		if (Math.abs(savedUsd - published) < 0.01) return;
+		published = savedUsd;
+		pi.appendEntry("my-extension/savings", { savedUsd });
+	});
+}
+```
+
+A user then subscribes with type `my-extension/savings`, field `savedUsd`, and whatever
+prefix and format they like.
+
+**Use `appendEntry`.** It writes a `type: "custom"` entry, which is what the bar looks for.
+It checks the entry kind *before* the `customType`, because custom message entries carry a
+`customType` field too — so a value pushed through `sendMessage` is never read.
+
+**Make `data` an object.** The subscription names a field, and the bar reads `data[field]`.
+A bare number or string published as the whole payload cannot be addressed. Several fields
+in one entry are fine; each can be subscribed to separately, and one entry can feed several
+segments.
+
+**Match the value to the format.** `currency` and `number` need a finite number and ignore
+anything else, so a pre-formatted `"$1.44"` string only works under `text`. Publish the raw
+number and let the user pick the presentation.
+
+**Publish at turn boundaries, not per token.** A high emission rate buys no extra freshness,
+and every append writes to the session file.
+
+**Re-publish after a session start if your figure carries over.** As noted above, entries
+written before the consumer's `session_start` are ignored, so after `--resume` the segment
+stays empty until you publish again. Per-run counters get this for free; a lifetime counter
+should emit once on the first turn of each run to become visible again.
+
+**Nothing appears in the transcript.** Custom entries are excluded from LLM context, and pi
+renders nothing for a `customType` with no registered entry renderer — a feed costs a line
+in the session file and no screen space.
+
+Name the type after your extension (`your-extension/metric`) to avoid collisions, and
+document the field names and units — those are the strings your users type into the
+settings TUI.
+
+## Caveats
+
+- Other editor-replacing extensions are wrapped rather than raced — their editor renders inside this box — but ones that draw their own bar or chrome will clash visually.
+- The palette is OMP's **dark** theme; light terminal themes will look off.
+
+## Development
+
+Requires Node >= 22.19 (the test runner uses `--import` with TypeScript resolution).
+
+```sh
+ln -s "$(pwd)" ~/.pi/agent/extensions/pi-topping-statusline
+npm install && npm run typecheck && npm test
+```
+
+## Attribution
+
+The statusline design and most of the rendering code come from
+[oh-my-pi](https://github.com/can1357/oh-my-pi) (MIT, © 2025 Mario Zechner,
+© 2025–2026 Can Bölük), itself a fork of Mario Zechner's pi. This port is MIT as well.

package/index.ts

@@ -0,0 +1,355 @@
+/**
+ * pi-topping-statusline — oh-my-pi's statusline as a pi extension.
+ *
+ * Direct port of oh-my-pi's status-line module (can1357/oh-my-pi,
+ * packages/coding-agent/src/modes/components/status-line/, MIT). OMP mounts
+ * the bar via its editor's setTopBorderProvider. Upstream pi's editor draws
+ * plain ─── rows with no corners or sides, so the wrapper re-renders the inner
+ * editor 6 columns narrower and rebuilds a full rounded box around its rows:
+ * the bar in ╭─ … ─╮, │ sides on every text row, and a dedicated ╰─ … ─╯
+ * bottom border carrying configurable left/right segment groups. Upstream's
+ * own bottom border row is dropped.
+ *
+ * ctx.ui.setEditorComponent is a single last-writer-wins slot that other
+ * extensions also claim (e.g. rpiv-pi's lane dock installs its own editor on
+ * every session_start, and npm packages load after global extensions). Rather
+ * than racing for the slot, this extension wraps whichever factory currently
+ * owns it — decorating the produced editor's render() output — and re-wraps
+ * when the owner changes (checked on an unref'd 1s timer). The host preserves
+ * editor text and handlers across setEditorComponent swaps, so re-installing
+ * the wrapper mid-session is lossless.
+ */
+import {
+	CustomEditor,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { SegmentContextBuilder } from "./src/context.js";
+import { buildStatusLine } from "./src/layout.js";
+import {
+	perimeterLength,
+	perimeterPosition,
+	RAINBOW_DEG_PER_FRAME,
+	RAINBOW_FRAME_MS,
+	RainbowBorder,
+} from "./src/rainbow.js";
+import { registerSettingsCommand } from "./src/settings-menu.js";
+import { createSettingsState } from "./src/settings.js";
+import { theme } from "./src/theme.js";
+import { TokenRateMonitor } from "./src/token-rate.js";
+import type { EffectiveStatusLineSettings, SegmentIncludes } from "./src/types.js";
+
+function segmentIncludes(effective: EffectiveStatusLineSettings): SegmentIncludes {
+	const allSegments = [
+		...effective.leftSegments,
+		...effective.rightSegments,
+		...effective.bottomLeftSegments,
+		...effective.bottomRightSegments,
+	];
+	return {
+		git: allSegments.includes("git"),
+		pr: allSegments.includes("pr"),
+		piStats: allSegments.includes("pi_stats"),
+		tokenRate: allSegments.includes("token_rate"),
+		feeds: allSegments.includes("feeds") ? effective.segmentOptions.feeds.map(feed => feed.customType) : [],
+	};
+}
+
+type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
+
+export default function (pi: ExtensionAPI) {
+	const state = createSettingsState();
+	const builder = new SegmentContextBuilder(pi);
+
+	let activeTui: TUI | undefined;
+	let activeCtx: ExtensionContext | undefined;
+	let ourFactory: EditorFactory | undefined;
+	let wrappedFactory: EditorFactory | undefined;
+	let ensureTimer: ReturnType<typeof setInterval> | undefined;
+	let patchedFooter: Component | undefined;
+	let footerRenderOriginal: ((width: number) => string[]) | undefined;
+
+	const requestRender = () => activeTui?.requestRender();
+	builder.setRequestRender(requestRender);
+
+	const rateMonitor = new TokenRateMonitor(requestRender);
+	rateMonitor.attach(pi);
+	builder.setTokenRateProvider(() => rateMonitor.getDisplay());
+
+	// Animated rainbow border while the thinking level is max: a timer steps
+	// the hue phase and re-renders; renderBoxed paints the box glyphs from it.
+	const rainbow = new RainbowBorder();
+	let rainbowTimer: ReturnType<typeof setInterval> | undefined;
+	const rainbowActive = (): boolean =>
+		state.effective.rainbowBorder && activeCtx !== undefined && pi.getThinkingLevel() === "max";
+	const syncRainbow = (): void => {
+		if (rainbowActive()) {
+			if (!rainbowTimer) {
+				rainbowTimer = setInterval(() => {
+					if (!rainbowActive()) {
+						syncRainbow();
+						return;
+					}
+					rainbow.step(RAINBOW_DEG_PER_FRAME);
+					requestRender();
+				}, RAINBOW_FRAME_MS);
+				rainbowTimer.unref?.();
+			}
+		} else if (rainbowTimer) {
+			clearInterval(rainbowTimer);
+			rainbowTimer = undefined;
+		}
+	};
+
+	registerSettingsCommand(pi, state, builder, () => {
+		syncRainbow();
+		requestRender();
+	});
+
+	const MIN_BOXED_WIDTH = 12;
+	const ANSI_RE = /\x1b\[[0-9;]*m/g;
+	const isBorderRow = (row: string): boolean => {
+		const text = row.replace(ANSI_RE, "");
+		return /^─+$/.test(text) || /^─+ [↑↓] \d+ more\s*─*$/.test(text);
+	};
+
+	const renderBoxed = (
+		innerRender: (width: number) => string[],
+		width: number,
+		editor: { borderColor?: (str: string) => string },
+	): string[] => {
+		const ctx = activeCtx;
+		if (!ctx || width < MIN_BOXED_WIDTH) return innerRender(width);
+
+		// Chrome totals 6 cells on every row, so the bar and the inner text rows
+		// share one width budget. Border rows split it 3/3 (╭── … ──╮); text rows
+		// split it 2/4 to sit the cursor one column closer to the left edge.
+		const innerWidth = width - 6;
+		const lines = innerRender(innerWidth);
+		// Rows are [top border, ...text rows, bottom border, ...autocomplete rows];
+		// autocomplete rows only exist while the dropdown is open, so the bottom
+		// border is the last row unless autocompleteState (TS-private on Editor,
+		// a plain property at runtime) says otherwise.
+		let bottomIdx = lines.length - 1;
+		if ((editor as unknown as { autocompleteState?: unknown }).autocompleteState) {
+			while (bottomIdx > 0 && !isBorderRow(lines[bottomIdx] ?? "")) bottomIdx--;
+		}
+		if (lines.length < 3 || bottomIdx < 2) return innerRender(width);
+
+		const hint = (lines[bottomIdx] ?? "").replace(ANSI_RE, "").match(/[↑↓] \d+ more/)?.[0] ?? "";
+		const effective = state.effective;
+		const include = segmentIncludes(effective);
+		const segCtx = builder.build(innerWidth, effective.segmentOptions, include, hint || undefined);
+		// borderColor is assigned by the host after the factory returns — read late.
+		const border = editor.borderColor ?? ((s: string) => s);
+		const rainbowOn = rainbowActive();
+		const box = theme.getBox(effective.borderStyle);
+		const perimeter = perimeterLength(width, bottomIdx);
+		// Per-glyph paint: rainbow mode colors each cell by its perimeter walk
+		// position; otherwise the host border color is applied per glyph, which
+		// renders identically to the old per-fragment wraps.
+		const paint = (row: number, col: number, ch: string): string =>
+			rainbowOn ? rainbow.colorChar(ch, perimeterPosition(row, col, width, bottomIdx), perimeter) : border(ch);
+		const horizRun = (row: number, startCol: number, count: number): string => {
+			if (!rainbowOn) return border(box.horizontal.repeat(count));
+			let out = "";
+			for (let k = 0; k < count; k++) out += paint(row, startCol + k, box.horizontal);
+			return out;
+		};
+		const gapColor = (str: string, startCol: number, row: number): string => {
+			if (!rainbowOn) return border(str);
+			let out = "";
+			for (let k = 0; k < str.length; k++) out += paint(row, startCol + k, str[k]!);
+			return out;
+		};
+		const bar = buildStatusLine(
+			innerWidth,
+			segCtx,
+			effective,
+			gapColor,
+			{
+				left: effective.leftSegments,
+				right: effective.rightSegments,
+			},
+			{ col: 3, row: 0 },
+		);
+		const barWidth = visibleWidth(bar);
+		const pad = Math.max(0, innerWidth - barWidth);
+		// Leading spacer row: keeps the transcript from sitting flush on the box.
+		const out: string[] = [
+			"",
+			paint(0, 0, box.topLeft) +
+				horizRun(0, 1, 2) +
+				bar +
+				horizRun(0, 3 + barWidth, pad + 2) +
+				paint(0, width - 1, box.topRight),
+		];
+		for (let i = 1; i < bottomIdx; i++) {
+			out.push(paint(i, 0, box.vertical) + " " + (lines[i] ?? "") + "   " + paint(i, width - 1, box.vertical));
+		}
+		const bottomBar = buildStatusLine(
+			innerWidth,
+			segCtx,
+			effective,
+			gapColor,
+			{
+				left: effective.bottomLeftSegments,
+				right: effective.bottomRightSegments,
+			},
+			{ col: 3, row: bottomIdx },
+		);
+		const bottomBarWidth = visibleWidth(bottomBar);
+		const bottomPad = Math.max(0, innerWidth - bottomBarWidth);
+		out.push(
+			paint(bottomIdx, 0, box.bottomLeft) +
+				horizRun(bottomIdx, 1, 2) +
+				bottomBar +
+				horizRun(bottomIdx, 3 + bottomBarWidth, bottomPad + 2) +
+				paint(bottomIdx, width - 1, box.bottomRight),
+		);
+		for (let i = bottomIdx + 1; i < lines.length; i++) {
+			out.push(`  ${lines[i]}`);
+		}
+		return out;
+	};
+
+	const wrapFactory = (inner: EditorFactory | undefined): EditorFactory => {
+		return (tui, editorTheme, keybindings) => {
+			activeTui = tui;
+			const editor = inner
+				? inner(tui, editorTheme, keybindings)
+				: new CustomEditor(tui, editorTheme, keybindings);
+			const innerRender = editor.render.bind(editor);
+			editor.render = width => renderBoxed(innerRender, width, editor);
+			return editor;
+		};
+	};
+
+	const ensureInstalled = () => {
+		const ctx = activeCtx;
+		if (!ctx) return;
+		const current = ctx.ui.getEditorComponent();
+		if (ourFactory && current === ourFactory) return;
+		wrappedFactory = current;
+		ourFactory = wrapFactory(current);
+		ctx.ui.setEditorComponent(ourFactory);
+	};
+
+	// Redundant with the bar or the graph: the footer's first line (cwd + git
+	// branch + session name) entirely, and — within the stats line — the context
+	// chunk ("22.8%/1.0M (auto)", which the graph's own label repeats) and the
+	// right-aligned model side ("(provider) model • thinking"). The unique stats
+	// (↑↓ tokens, cache R/W, hit rate, cost) survive; when nothing unique remains
+	// the line collapses entirely.
+	const CONTEXT_CHUNK_RE = /(?:\?|\d+(?:\.\d+)?%)\/\S+(?: \(auto\))?/;
+	const stripRedundantStats = (statsLine: string | undefined): string | undefined => {
+		if (!statsLine) return undefined;
+		const plain = statsLine.replace(ANSI_RE, "");
+		// The model side is right-aligned with >=2 spaces of padding; stats parts
+		// are single-space separated, so the first 2+ space run is the boundary.
+		const left = (plain.split(/ {2,}/)[0] ?? "")
+			.replace(CONTEXT_CHUNK_RE, "")
+			.replace(/\s+/g, " ")
+			.trim();
+		return left || undefined;
+	};
+
+	const PI_STATS_CACHE_MS = 250;
+	let piStatsCache: { at: number; value: string | undefined } | undefined;
+	builder.setPiStatsProvider(width => {
+		if (!footerRenderOriginal) return undefined;
+		const now = Date.now();
+		if (piStatsCache && now - piStatsCache.at < PI_STATS_CACHE_MS) return piStatsCache.value;
+		// Render wide so Pi does not truncate the model side before
+		// stripRedundantStats finds its separating padding.
+		const line = footerRenderOriginal(Math.max(width, 200))[1];
+		const value = stripRedundantStats(line);
+		piStatsCache = { at: now, value };
+		return value;
+	});
+
+	// The default footer is the only component with both setAutoCompactEnabled
+	// and setSession. Pi >= 0.84 nests it inside the fullscreen dock's footer
+	// Container rather than mounting it directly on the TUI, so search the whole
+	// subtree instead of just the top-level children.
+	const findFooter = (node: Component): Component | undefined => {
+		const probe = node as unknown as Record<string, unknown>;
+		if (typeof probe.setAutoCompactEnabled === "function" && typeof probe.setSession === "function") return node;
+		if (!Array.isArray(probe.children)) return undefined;
+		for (const child of probe.children as Component[]) {
+			const found = findFooter(child);
+			if (found) return found;
+		}
+		return undefined;
+	};
+
+	// setFooter would replace the whole component (stats + extension-status
+	// lines included), so instead patch the live default footer in place and drop
+	// its cwd and stats lines, which the box now carries itself.
+	const ensureFooterPatched = () => {
+		const tui = activeTui;
+		if (!tui || patchedFooter) return;
+		let footer: Component | undefined;
+		for (const child of tui.children) {
+			footer = findFooter(child);
+			if (footer) break;
+		}
+		if (!footer) return;
+		const orig = footer.render.bind(footer);
+		footerRenderOriginal = orig;
+		footer.render = width => orig(width).slice(2);
+		patchedFooter = footer;
+	};
+
+	pi.on("model_select", () => requestRender());
+	pi.on("thinking_level_select", () => {
+		syncRainbow();
+		requestRender();
+	});
+	pi.on("session_info_changed", () => requestRender());
+
+	pi.on("session_start", (_event, ctx) => {
+		if (!ctx.hasUI || ctx.mode !== "tui") return;
+		activeCtx = ctx;
+		builder.attach(ctx);
+		rateMonitor.enable();
+		syncRainbow();
+		ensureInstalled();
+		ensureFooterPatched();
+		ensureTimer ??= setInterval(() => {
+			ensureInstalled();
+			ensureFooterPatched();
+			// The host's /settings dialog can change the thinking level without
+			// firing thinking_level_select, so reconcile the animator periodically.
+			syncRainbow();
+		}, 1000);
+		ensureTimer.unref?.();
+	});
+
+	pi.on("session_shutdown", () => {
+		rateMonitor.disable();
+		builder.dispose();
+		if (rainbowTimer) {
+			clearInterval(rainbowTimer);
+			rainbowTimer = undefined;
+		}
+		if (ensureTimer) {
+			clearInterval(ensureTimer);
+			ensureTimer = undefined;
+		}
+		if (activeCtx && ourFactory && activeCtx.ui.getEditorComponent() === ourFactory) {
+			activeCtx.ui.setEditorComponent(wrappedFactory);
+		}
+		if (patchedFooter && footerRenderOriginal) {
+			patchedFooter.render = footerRenderOriginal;
+		}
+		patchedFooter = undefined;
+		footerRenderOriginal = undefined;
+		ourFactory = undefined;
+		wrappedFactory = undefined;
+		activeTui = undefined;
+		activeCtx = undefined;
+	});
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@underactive/pi-topping-statusline",
+	"version": "0.1.0",
+	"description": "oh-my-pi's powerline statusline as a pi extension with some customizations",
+	"keywords": [
+		"pi-package",
+		"pi-extension"
+	],
+	"license": "MIT",
+	"author": "Eric Sison",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/underactive/pi-topping-statusline.git"
+	},
+	"bugs": {
+		"url": "https://github.com/underactive/pi-topping-statusline/issues"
+	},
+	"homepage": "https://github.com/underactive/pi-topping-statusline#readme",
+	"type": "module",
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"files": [
+		"src",
+		"index.ts",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"test": "node --import ./src/tests/ts-resolve.ts --test src/tests/*.test.ts"
+	},
+	"pi": {
+		"extensions": [
+			"./index.ts"
+		],
+		"image": "https://raw.githubusercontent.com/underactive/pi-topping-statusline/main/media/poster.png"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "0.80.10",
+		"@earendil-works/pi-coding-agent": "0.80.10",
+		"@earendil-works/pi-tui": "0.80.10",
+		"@types/node": "^22.0.0",
+		"typescript": "^5.7.0"
+	}
+}