pi-input-bar 1.0.0

package/.gitattributes

@@ -0,0 +1,16 @@
+# Force LF line endings for all text files
+* text=auto
+
+# Force LF for source files
+*.ts text eol=lf
+*.js text eol=lf
+*.json text eol=lf
+*.md text eol=lf
+
+# Binary files
+*.png binary
+*.jpg binary
+*.gif binary
+*.ico binary
+*.ttf binary
+*.woff2 binary

package/.github/workflows/publish.yml

@@ -0,0 +1,16 @@
+name: Publish to npm
+on:
+  push:
+    tags: ['v*']
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,71 @@
+# pi-input-bar
+
+[![npm](https://img.shields.io/npm/v/pi-input-bar)](https://www.npmjs.com/package/pi-input-bar)
+
+A [pi](https://pi.dev) extension that embeds live status in your editor's border — no extra rows, no clutter. Everything fits inside the input box: folder, branch, model, speed, context, cost.
+
+```
+╭─ ⌂ agent :: ⎇ main ● ────────────────── openrouter/tencent/hy3:free :: ✦ high  ─╮
+│ _                                                                                │
+╰─────────────────────── ⛁ 10%/262k :: ↑29k ↓1.6k R24k :: ⚡pp 512 · tg 34.2 t/s ─╯
+```
+
+## Install
+
+From npm:
+
+```bash
+pi install npm:pi-input-bar
+```
+
+Or from git:
+
+```bash
+pi install git:github.com/sebaxzero/pi-input-bar.git
+```
+
+Add `-l` to either form to install project-locally (adds to `.pi/settings.json` only).
+
+No dependencies, no build step, nothing to configure — the bar appears as soon as it loads.
+
+## What you see
+
+**Top border** — where you are and what's thinking:
+- Current folder and git branch
+- A dot that pulses while the agent is responding (`●`)
+- `provider/model` and thinking effort level (color-coded)
+
+**Bottom border** — what's happening under the hood:
+- **Context usage** — fill level, colored green → yellow → red as it fills
+- **Token stats** — input, output, cache reads/writes
+- **Session cost** — running total
+- **Speed** — prefill (`pp`) and generation (`tg`) tokens/sec, llama.cpp style
+
+**While streaming** — a random working word replaces the default label:
+_Pondering…, Percolating…, Marinating…_ — re-rolled on every agent run.
+
+## Commands
+
+```
+/input-bar                 — show current config
+/input-bar set KEY=VAL     — override config for the current session only
+/input-bar save            — write the current config to input-bar.json
+/input-bar reset           — restore defaults
+```
+
+## Configuration
+
+Persistent configuration lives in `extensions/input-bar.json` next to the installed extension (auto-created on first load with defaults). You can ask the agent to edit it, or tune values live with `/input-bar set`.
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `TOP` | `true` | Show folder/branch/model/effort in the top border |
+| `BOTTOM` | `true` | Show stats in the bottom border (and slim down the footer) |
+| `TPS` | `true` | Show tokens/sec |
+| `ANIM` | `true` | Random working word while streaming |
+| `ICONS` | `true` | Glyphs (⌂ ⎇ ⛁ ⚡) in the bars |
+| `WORDS` | `""` | Comma-separated custom working-word pool |
+
+## License
+
+MIT

package/extensions/index.ts

@@ -0,0 +1 @@
+export { default } from "./input-bar.ts";

package/extensions/input-bar.ts

@@ -0,0 +1,407 @@
+/**
+ * pi-input-bar
+ *
+ * Embeds live status into the input editor's own border lines (no extra rows):
+ *
+ *   ─ ⌂ folder :: ⎇ branch ● ─────── provider/model :: ✦ effort ─   ← top border
+ *   > (editor content)
+ *   ────────────────── ⛁ 10%/262k :: ↑29k ↓1.6k R24k :: ⚡34 t/s ─   ← bottom border
+ *
+ * Implementation: a CustomEditor subclass whose render() takes the default
+ * editor output and rewrites the two full-rule border lines. The built-in
+ * footer is replaced by a minimal one that only shows extension statuses, so
+ * no duplicate stats lines appear below the editor.
+ *
+ * While streaming, a random working word (Claude Code style) replaces pi's
+ * default label, re-rolled on every agent run. Tokens/sec: live ~4 chars/token
+ * estimate (marked "~") while streaming, exact usage.output / elapsed after.
+ */
+
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { CustomEditor } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth as tuiVisibleWidth } from "@earendil-works/pi-tui";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  bottomBarSegments,
+  composeBottomLine,
+  composeLine,
+  DEFAULT_WORDS,
+  pickWord,
+  replaceEdgeChars,
+  stripAnsi,
+  tokensPerSecond,
+  topBarSegments,
+  type ColorName,
+  type Colorize,
+} from "./render.ts";
+
+// Config lives next to the extension file: ./extensions/input-bar.json
+const EXT_DIR = dirname(fileURLToPath(import.meta.url));
+const CONFIG_PATH = join(EXT_DIR, "input-bar.json");
+
+const DEFAULTS = {
+  TOP: true, // embed folder/branch/model/effort into the editor's top border
+  BOTTOM: true, // embed context/tokens/tps into the editor's bottom border
+  TPS: true, // show tokens/sec
+  ANIM: true, // random working word while streaming
+  ICONS: true, // glyphs (⌂ ⎇ ⛁ ⚡) in the bars
+  WORDS: "", // comma-separated override for the working-word pool
+};
+
+const cfg: typeof DEFAULTS = (() => {
+  if (!existsSync(CONFIG_PATH)) {
+    try {
+      writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULTS, null, 2) + "\n", "utf-8");
+    } catch {
+      // Read-only install location — keep defaults in memory
+    }
+  }
+  try {
+    return { ...DEFAULTS, ...JSON.parse(readFileSync(CONFIG_PATH, "utf-8")) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+})();
+
+function wordPool(): string[] {
+  const custom = cfg.WORDS.split(",").map((w) => w.trim()).filter(Boolean);
+  return custom.length ? custom : DEFAULT_WORDS;
+}
+
+// Fallback branch resolution for when the FooterDataProvider isn't captured yet
+// (it only reaches us through the setFooter factory). Cached with a short TTL.
+let branchCache: { value: string | null; at: number } = { value: null, at: 0 };
+
+function gitBranchFallback(cwd: string): string | null {
+  if (Date.now() - branchCache.at < 5000) return branchCache.value;
+  let value: string | null = null;
+  try {
+    let dir = cwd;
+    for (;;) {
+      const gitPath = join(dir, ".git");
+      if (existsSync(gitPath)) {
+        let headPath = join(gitPath, "HEAD");
+        if (statSync(gitPath).isFile()) {
+          // Worktree/submodule: .git is a file pointing at the real git dir
+          const m = readFileSync(gitPath, "utf-8").match(/^gitdir:\s*(.+)$/m);
+          if (m) headPath = join(m[1].trim(), "HEAD");
+        }
+        const head = readFileSync(headPath, "utf-8").trim();
+        const ref = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+        value = ref ? ref[1] : "detached";
+        break;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    value = null;
+  }
+  branchCache = { value, at: Date.now() };
+  return value;
+}
+
+/** Total characters of text + thinking in an assistant message. */
+function messageChars(message: any): number {
+  let chars = 0;
+  for (const block of message?.content ?? []) {
+    if (typeof block?.text === "string") chars += block.text.length;
+    else if (typeof block?.thinking === "string") chars += block.thinking.length;
+  }
+  return chars;
+}
+
+export default function (pi: ExtensionAPI) {
+  // Latest context seen by any handler — its methods are stable runtime bindings.
+  let ctxRef: ExtensionContext | undefined;
+  // FooterDataProvider captured from the setFooter factory; the editor reads it too.
+  let footerData: { getGitBranch(): string | null } | undefined;
+
+  // t/s tracking. The clock starts at the FIRST streamed token, not at
+  // message_start — otherwise prompt-processing time (long on local servers)
+  // dilutes the average and the value creeps up without ever reaching the
+  // real generation speed.
+  let streaming = false;
+  let messageStartMs = 0;
+  let firstTokenMs = 0;
+  let liveChars = 0;
+  let lastTps: number | undefined;
+  // Prefill (prompt processing) speed: tokens processed / time until first token
+  let lastPps: number | undefined;
+  // Live-estimate calibration: learned chars/token ratio from finished messages
+  let charsPerToken = 4;
+
+  function snapshotTps(): { tps: number | undefined; live: boolean } {
+    if (streaming && firstTokenMs) {
+      const est = tokensPerSecond(liveChars / charsPerToken, Date.now() - firstTokenMs);
+      if (est !== undefined) return { tps: est, live: true };
+    }
+    return { tps: lastTps, live: false };
+  }
+
+  function makeColorize(theme: { fg(color: any, text: string): string }, effortLevel: string): Colorize {
+    const thinkingKey = "thinking" + effortLevel.charAt(0).toUpperCase() + effortLevel.slice(1);
+    return (color: ColorName, text: string) =>
+      theme.fg(color === "thinking" ? thinkingKey : color, text);
+  }
+
+  function currentEffort(): string {
+    try {
+      return pi.getThinkingLevel();
+    } catch {
+      return "off";
+    }
+  }
+
+  /** Top border line with folder/branch/model/effort embedded. */
+  function topLine(width: number, theme: any): string {
+    const ctx = ctxRef;
+    const effort = currentEffort();
+    const { left, right } = topBarSegments({
+      folder: basename(ctx?.cwd || process.cwd()) || "/",
+      branch: footerData?.getGitBranch() ?? gitBranchFallback(ctx?.cwd || process.cwd()),
+      streaming,
+      provider: ctx?.model?.provider,
+      modelId: ctx?.model?.id,
+      effort: ctx?.model?.reasoning ? effort : undefined,
+      icons: cfg.ICONS,
+    });
+    const line = composeLine(left, right, width, makeColorize(theme, effort), tuiVisibleWidth);
+    return truncateToWidth(line, width);
+  }
+
+  /** Bottom border line with context/token/tps stats embedded, right-aligned. */
+  function bottomLine(width: number, theme: any): string {
+    const ctx = ctxRef;
+    let input = 0, output = 0, cacheRead = 0, cacheWrite = 0, cost = 0;
+    try {
+      for (const entry of ctx?.sessionManager.getEntries() ?? []) {
+        if (entry.type === "message" && (entry as any).message.role === "assistant") {
+          const u = (entry as any).message.usage;
+          input += u.input;
+          output += u.output;
+          cacheRead += u.cacheRead;
+          cacheWrite += u.cacheWrite;
+          cost += u.cost.total;
+        }
+      }
+    } catch {
+      // Session shape changed — leave totals at 0
+    }
+    const usage = ctx?.getContextUsage();
+    const { tps, live } = snapshotTps();
+    const segs = bottomBarSegments({
+      percent: usage?.percent ?? null,
+      contextWindow: usage?.contextWindow ?? ctx?.model?.contextWindow ?? 0,
+      input, output, cacheRead, cacheWrite, cost,
+      tps: cfg.TPS ? tps : undefined,
+      tpsLive: live,
+      pps: cfg.TPS ? lastPps : undefined,
+      icons: cfg.ICONS,
+    });
+    const line = composeBottomLine(segs, width, makeColorize(theme, currentEffort()), tuiVisibleWidth);
+    return truncateToWidth(line, width);
+  }
+
+  /**
+   * Editor that rewrites its full-rule border lines with the info bars.
+   * With both bars active the box is closed: rounded corners on the border
+   * lines and │ sides painted over the paddingX columns of content lines.
+   */
+  class BarEditor extends CustomEditor {
+    /**
+     * pi copies the default editor's paddingX onto custom editors right after
+     * the factory runs (setCustomEditorComponent), which would collapse our
+     * side columns to the user's setting (often 0). Enforce a minimum of 2 so
+     * the │ sides always have a spare space column next to the content/cursor.
+     */
+    setPaddingX(padding: number): void {
+      super.setPaddingX(Math.max(2, Number.isFinite(padding) ? padding : 2));
+    }
+
+    render(width: number): string[] {
+      const lines = super.render(width);
+      const theme = ctxRef?.ui?.theme;
+      if (!theme || width < 10) return lines;
+      const rule = "─".repeat(width);
+      const isRule = (l: string) => stripAnsi(l) === rule;
+      // Top border is the first full-rule line (absent while scrolled — the
+      // "↑ N more" indicator takes its place and is left untouched).
+      const topIdx = cfg.TOP ? lines.findIndex(isRule) : -1;
+      // Bottom border is the last full-rule line (autocomplete rows follow it).
+      let bottomIdx = -1;
+      if (cfg.BOTTOM) {
+        for (let i = lines.length - 1; i > topIdx; i--) {
+          if (isRule(lines[i])) {
+            bottomIdx = i;
+            break;
+          }
+        }
+      }
+      const closed = topIdx !== -1 && bottomIdx !== -1;
+      if (topIdx !== -1) {
+        const line = topLine(width, theme);
+        lines[topIdx] = closed ? replaceEdgeChars(line, "╭", "╮") : line;
+      }
+      if (bottomIdx !== -1) {
+        const line = bottomLine(width, theme);
+        lines[bottomIdx] = closed ? replaceEdgeChars(line, "╰", "╯") : line;
+      }
+      if (closed) {
+        // Paint │ over the outermost padding column of the rows in between.
+        const side = theme.fg("dim", "│");
+        for (let i = topIdx + 1; i < bottomIdx; i++) {
+          const l = lines[i];
+          if (l.startsWith(" ") && l.endsWith(" ")) {
+            lines[i] = side + l.slice(1, -1) + side;
+          }
+        }
+      }
+      return lines;
+    }
+  }
+
+  function installBars(ctx: ExtensionContext) {
+    if (cfg.TOP || cfg.BOTTOM) {
+      // paddingX: 2 keeps a spare space column on each side of the content so
+      // the │ sides can be painted without touching text or the cursor cell.
+      ctx.ui.setEditorComponent(
+        (tui, theme, keybindings) => new BarEditor(tui, theme, keybindings, { paddingX: 2 }),
+      );
+    } else {
+      ctx.ui.setEditorComponent(undefined);
+    }
+    if (cfg.BOTTOM) {
+      // Minimal footer: kills the built-in stats lines (now embedded in the
+      // editor border) but keeps extension statuses and the branch watcher.
+      ctx.ui.setFooter((tui, theme, fd) => {
+        footerData = fd;
+        const unsub = fd.onBranchChange(() => tui.requestRender());
+        return {
+          render(width: number): string[] {
+            const statuses: ReadonlyMap<string, string> = fd.getExtensionStatuses();
+            if (statuses.size === 0) return [];
+            const line = Array.from(statuses.entries())
+              .sort(([a], [b]) => a.localeCompare(b))
+              .map(([, text]) => text.replace(/[\r\n\t]/g, " ").trim())
+              .join(" ");
+            return [truncateToWidth(theme.fg("dim", line), width)];
+          },
+          invalidate() {},
+          dispose() { unsub(); },
+        };
+      });
+    } else {
+      ctx.ui.setFooter(undefined);
+    }
+  }
+
+  pi.on("session_start", (_event, ctx) => {
+    ctxRef = ctx;
+    if (ctx.mode !== "tui") return;
+    installBars(ctx);
+  });
+
+  pi.on("agent_start", (_event, ctx) => {
+    ctxRef = ctx;
+    if (ctx.hasUI && cfg.ANIM) {
+      ctx.ui.setWorkingMessage(pickWord(wordPool()));
+    }
+  });
+
+  pi.on("message_start", (event, ctx) => {
+    ctxRef = ctx;
+    if (event.message.role !== "assistant") return;
+    streaming = true;
+    messageStartMs = Date.now();
+    firstTokenMs = 0;
+    liveChars = 0;
+  });
+
+  pi.on("message_update", (event) => {
+    if (event.message.role !== "assistant") return;
+    const chars = messageChars(event.message);
+    if (!firstTokenMs && chars > 0) firstTokenMs = Date.now();
+    liveChars = chars;
+  });
+
+  pi.on("message_end", (event, ctx) => {
+    ctxRef = ctx;
+    if (event.message.role !== "assistant") return;
+    streaming = false;
+    if (!firstTokenMs) return;
+    const usage = (event.message as any).usage;
+    const outTokens = usage?.output ?? 0;
+    if (outTokens > 0 && liveChars > 0) {
+      charsPerToken = Math.min(8, Math.max(1, liveChars / outTokens));
+    }
+    const tps = tokensPerSecond(outTokens, Date.now() - firstTokenMs);
+    if (tps !== undefined) lastTps = tps;
+    // Prefill: prompt tokens actually processed (cached reads cost ~nothing)
+    // over the message_start → first-token window. Skip tiny windows where
+    // network/server overhead dominates the measurement.
+    const prefillTokens = (usage?.input ?? 0) + (usage?.cacheWrite ?? 0);
+    const prefillMs = firstTokenMs - messageStartMs;
+    if (prefillTokens > 0 && prefillMs > 150) {
+      lastPps = prefillTokens / (prefillMs / 1000);
+    }
+  });
+
+  pi.on("agent_end", (_event, ctx) => {
+    ctxRef = ctx;
+    streaming = false;
+  });
+
+  pi.registerCommand("input-bar", {
+    description: "Configure the input bar (show | set KEY=VAL | save | reset)",
+    handler: async (args, ctx) => {
+      ctxRef = ctx;
+      const trimmed = args.trim();
+      const notify = (msg: string) => ctx.ui.notify(msg, "info");
+
+      if (!trimmed || trimmed === "show") {
+        notify(
+          Object.entries(cfg)
+            .map(([k, v]) => `${k}=${v}`)
+            .join(" "),
+        );
+        return;
+      }
+      if (trimmed === "save") {
+        try {
+          writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+          notify(`saved ${CONFIG_PATH}`);
+        } catch (e) {
+          ctx.ui.notify(`could not save: ${e}`, "error");
+        }
+        return;
+      }
+      if (trimmed === "reset") {
+        Object.assign(cfg, DEFAULTS);
+        installBars(ctx);
+        notify("input-bar config reset (session only; use save to persist)");
+        return;
+      }
+      const match = trimmed.match(/^set\s+([A-Z]+)\s*=\s*(.*)$/);
+      if (!match) {
+        ctx.ui.notify("usage: /input-bar [show | set KEY=VAL | save | reset]", "warning");
+        return;
+      }
+      const [, key, raw] = match;
+      if (!(key in cfg)) {
+        ctx.ui.notify(`unknown key ${key} (${Object.keys(cfg).join(", ")})`, "error");
+        return;
+      }
+      (cfg as any)[key] = typeof (cfg as any)[key] === "boolean" ? raw === "true" || raw === "1" : raw;
+      installBars(ctx);
+      if (key === "ANIM" && !cfg.ANIM) ctx.ui.setWorkingMessage();
+      notify(`${key}=${(cfg as any)[key]} (session only; use /input-bar save to persist)`);
+    },
+  });
+}

package/extensions/render.ts

@@ -0,0 +1,264 @@
+/**
+ * Pure rendering logic for pi-input-bar. No pi imports so test.mjs can import
+ * this file directly (Node ≥ 22.18 type stripping).
+ *
+ * Lines are built from plain-text segments with a color name attached; the
+ * extension maps color names to theme.fg() calls. Width math always runs on
+ * the plain text, so ANSI codes never break the layout.
+ */
+
+export type ColorName =
+  | "dim"
+  | "muted"
+  | "text"
+  | "accent"
+  | "success"
+  | "warning"
+  | "error"
+  | "thinking";
+
+export type Colorize = (color: ColorName, text: string) => string;
+
+export interface Segment {
+  text: string;
+  color: ColorName;
+}
+
+/** Format token counts for compact display (same semantics as pi's footer). */
+export function formatTokens(count: number): string {
+  if (count < 1000) return count.toString();
+  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1000000) return `${Math.round(count / 1000)}k`;
+  if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
+  return `${Math.round(count / 1000000)}M`;
+}
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+export function stripAnsi(s: string): string {
+  return s.replace(ANSI_RE, "");
+}
+
+/** Approximate terminal cell width of a single code point. */
+function charWidth(cp: number): number {
+  // Zero-width: combining marks, ZWJ/ZWNJ, variation selectors
+  if (
+    (cp >= 0x0300 && cp <= 0x036f) ||
+    cp === 0x200b ||
+    cp === 0x200c ||
+    cp === 0x200d ||
+    (cp >= 0xfe00 && cp <= 0xfe0f)
+  ) {
+    return 0;
+  }
+  // Wide: CJK, Hangul, fullwidth forms, emoji blocks
+  if (
+    (cp >= 0x1100 && cp <= 0x115f) ||
+    (cp >= 0x2e80 && cp <= 0xa4cf) ||
+    (cp >= 0xac00 && cp <= 0xd7a3) ||
+    (cp >= 0xf900 && cp <= 0xfaff) ||
+    (cp >= 0xff00 && cp <= 0xff60) ||
+    (cp >= 0xffe0 && cp <= 0xffe6) ||
+    (cp >= 0x1f300 && cp <= 0x1faff) ||
+    (cp >= 0x20000 && cp <= 0x3fffd)
+  ) {
+    return 2;
+  }
+  return 1;
+}
+
+/** Visible terminal width of a string (ANSI stripped, wide chars counted as 2). */
+export function visibleWidth(s: string): number {
+  let w = 0;
+  for (const ch of stripAnsi(s)) w += charWidth(ch.codePointAt(0)!);
+  return w;
+}
+
+/** Width-measuring function; pi-tui's visibleWidth is injected at runtime. */
+export type WidthFn = (s: string) => number;
+
+function segsWidth(segs: Segment[], widthFn: WidthFn): number {
+  let w = 0;
+  for (const s of segs) w += widthFn(s.text);
+  return w;
+}
+
+function paint(segs: Segment[], c: Colorize): string {
+  return segs.map((s) => c(s.color, s.text)).join("");
+}
+
+/**
+ * Compose one line: left segments, a dim "─" filler, right segments.
+ * If both sides don't fit, the right side is dropped; if the left alone
+ * doesn't fit, its last segments are dropped until it does.
+ */
+export function composeLine(
+  left: Segment[],
+  right: Segment[],
+  width: number,
+  c: Colorize,
+  widthFn: WidthFn = visibleWidth,
+): string {
+  const l = [...left];
+  let r = [...right];
+  if (segsWidth(l, widthFn) + segsWidth(r, widthFn) + 2 > width) r = [];
+  while (l.length > 1 && segsWidth(l, widthFn) + segsWidth(r, widthFn) + 2 > width) l.pop();
+  const gap = Math.max(1, width - segsWidth(l, widthFn) - segsWidth(r, widthFn));
+  return paint(l, c) + c("dim", "─".repeat(gap)) + paint(r, c);
+}
+
+export interface TopBarData {
+  folder: string;
+  branch: string | null;
+  streaming: boolean;
+  provider: string | undefined;
+  modelId: string | undefined;
+  /** Thinking level, or undefined when the model has no reasoning. */
+  effort: string | undefined;
+  icons: boolean;
+}
+
+export function topBarSegments(d: TopBarData): { left: Segment[]; right: Segment[] } {
+  const sep: Segment = { text: " :: ", color: "dim" };
+  const left: Segment[] = [
+    { text: "──", color: "dim" },
+    { text: d.icons ? " ⌂ " : " ", color: "accent" },
+    { text: d.folder, color: "accent" },
+  ];
+  if (d.branch) {
+    left.push(sep, { text: d.icons ? "⎇ " : "", color: "success" }, { text: d.branch, color: "success" });
+  }
+  left.push({ text: d.streaming ? " ● " : " ○ ", color: d.streaming ? "warning" : "dim" });
+
+  const right: Segment[] = [];
+  if (d.modelId) {
+    const model = d.provider ? `${d.provider}/${d.modelId}` : d.modelId;
+    right.push({ text: ` ${model}`, color: "success" });
+    if (d.effort) {
+      right.push(sep, { text: (d.icons ? "✦ " : "") + d.effort, color: "thinking" });
+    }
+    right.push({ text: " ──", color: "dim" });
+  }
+  return { left, right };
+}
+
+export interface BottomBarData {
+  /** Context usage percent, or null when unknown (right after compaction). */
+  percent: number | null;
+  contextWindow: number;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+  /** Generation tokens per second, or undefined when not yet measured. */
+  tps: number | undefined;
+  /** True while the tps value is a live in-stream estimate. */
+  tpsLive: boolean;
+  /** Prefill (prompt processing) tokens per second, or undefined when unknown. */
+  pps: number | undefined;
+  icons: boolean;
+}
+
+function formatRate(rate: number): string {
+  return rate >= 100 ? rate.toFixed(0) : rate.toFixed(1);
+}
+
+export function bottomBarSegments(d: BottomBarData): Segment[] {
+  const sep: Segment = { text: " :: ", color: "dim" };
+  const pctColor: ColorName = d.percent === null ? "muted" : d.percent > 90 ? "error" : d.percent > 70 ? "warning" : "success";
+  const pct = d.percent === null ? "?" : `${d.percent.toFixed(0)}%`;
+  const segs: Segment[] = [
+    { text: d.icons ? " ⛁ " : " ", color: pctColor },
+    { text: `${pct}/${formatTokens(d.contextWindow)}`, color: pctColor },
+  ];
+
+  const stats: string[] = [];
+  if (d.input) stats.push(`↑${formatTokens(d.input)}`);
+  if (d.output) stats.push(`↓${formatTokens(d.output)}`);
+  if (d.cacheRead) stats.push(`R${formatTokens(d.cacheRead)}`);
+  if (d.cacheWrite) stats.push(`W${formatTokens(d.cacheWrite)}`);
+  if (stats.length) segs.push(sep, { text: stats.join(" "), color: "muted" });
+
+  if (d.cost) segs.push(sep, { text: `$${d.cost.toFixed(3)}`, color: "muted" });
+
+  if (d.tps !== undefined || d.pps !== undefined) {
+    // With both rates, label them llama.cpp-style (pp = prefill, tg = generation)
+    const parts: string[] = [];
+    if (d.pps !== undefined) parts.push(`pp ${formatRate(d.pps)}`);
+    if (d.tps !== undefined) {
+      const tg = `${formatRate(d.tps)}${d.tpsLive ? "~" : ""}`;
+      parts.push(d.pps !== undefined ? `tg ${tg}` : tg);
+    }
+    segs.push(sep, {
+      text: `${d.icons ? "⚡" : ""}${parts.join(" · ")} t/s`,
+      color: d.tpsLive ? "warning" : "muted",
+    });
+  }
+  segs.push({ text: " ──", color: "dim" });
+  return segs;
+}
+
+/** Right-aligned bottom line: dim filler, then the stats block. */
+export function composeBottomLine(
+  segs: Segment[],
+  width: number,
+  c: Colorize,
+  widthFn: WidthFn = visibleWidth,
+): string {
+  const s = [...segs];
+  // Drop middle segments (keep context% and trailing space) until it fits.
+  while (s.length > 2 && segsWidth(s, widthFn) + 1 > width) s.splice(2, 1);
+  const gap = Math.max(1, width - segsWidth(s, widthFn));
+  return c("dim", "─".repeat(gap)) + paint(s, c);
+}
+
+/**
+ * Replace the first and last visible characters of a line (skipping ANSI
+ * codes) — used to turn flat border lines into box corners (╭─…─╮ / ╰─…─╯).
+ * Assumes the replacements have the same cell width as the replaced chars.
+ */
+export function replaceEdgeChars(line: string, open: string, close: string): string {
+  const tokens = line.split(/(\x1b\[[0-9;]*m)/);
+  let first = -1;
+  let last = -1;
+  for (let i = 0; i < tokens.length; i++) {
+    if (tokens[i].length === 0 || tokens[i].startsWith("\x1b")) continue;
+    if (first === -1) first = i;
+    last = i;
+  }
+  if (first === -1) return line;
+  const firstChars = [...tokens[first]];
+  firstChars[0] = open;
+  tokens[first] = firstChars.join("");
+  // When first === last this reads the already-updated token, which is intended
+  const lastChars = [...tokens[last]];
+  lastChars[lastChars.length - 1] = close;
+  tokens[last] = lastChars.join("");
+  return tokens.join("");
+}
+
+/** Working-word pool, Claude Code style. */
+export const DEFAULT_WORDS = [
+  "Thinking", "Pondering", "Percolating", "Brewing", "Conjuring", "Scheming",
+  "Marinating", "Ruminating", "Noodling", "Cogitating", "Simmering", "Musing",
+  "Tinkering", "Weaving", "Distilling", "Incubating", "Hatching", "Whirring",
+  "Crunching", "Divining", "Untangling", "Spelunking", "Wrangling", "Vibing",
+];
+
+/** Pick a random word; rnd injectable for tests. */
+export function pickWord(words: readonly string[], rnd: () => number = Math.random): string {
+  if (words.length === 0) return "Thinking";
+  return words[Math.min(words.length - 1, Math.floor(rnd() * words.length))];
+}
+
+/** Estimate tokens from a character count (~4 chars/token). */
+export function estimateTokens(chars: number): number {
+  return chars / 4;
+}
+
+/** Compute tokens/sec; undefined when the sample is too small to be meaningful. */
+export function tokensPerSecond(tokens: number, elapsedMs: number): number | undefined {
+  if (tokens <= 0 || elapsedMs < 500) return undefined;
+  return tokens / (elapsedMs / 1000);
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "pi-input-bar",
+  "version": "1.0.0",
+  "description": "Pi extension: decorated input bar — folder/branch/model/effort above the editor, context/token usage and tokens-per-second below, plus random working words while the agent streams.",
+  "keywords": ["pi-package", "pi", "pi-coding-agent", "extension", "tui", "statusbar", "footer", "input-bar"],
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://github.com/sebaxzero/pi-input-bar",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sebaxzero/pi-input-bar.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sebaxzero/pi-input-bar/issues"
+  },
+  "pi": {
+    "extensions": ["./extensions"]
+  }
+}