@erichll/pi-statusline 0.0.0-stage → 0.2.0

package/src/git.ts

@@ -0,0 +1,105 @@
+import { spawn } from "node:child_process";
+import type { GitState } from "./types.ts";
+
+export function emptyGit(kind: GitState["kind"] = "unknown"): GitState {
+  return { kind, branch: null, detached: false, staged: 0, unstaged: 0, untracked: 0, conflicts: 0, ahead: 0, behind: 0 };
+}
+export function parseGitStatus(output: string): GitState {
+  const state = emptyGit("repository");
+  let oid = "";
+  const records = output.split("\0");
+  for (let i = 0; i < records.length; i++) {
+    const line = records[i]!;
+    if (line.startsWith("# branch.head ")) {
+      const name = line.slice(14);
+      state.detached = name === "(detached)";
+      if (!state.detached) state.branch = name;
+    } else if (line.startsWith("# branch.oid ")) oid = line.slice(13);
+    else if (line.startsWith("# branch.ab ")) {
+      const match = /^# branch.ab \+(\d+) -(\d+)$/.exec(line);
+      if (match) { state.ahead = Number(match[1]); state.behind = Number(match[2]); }
+    } else if (line.startsWith("? ")) state.untracked++;
+    else if (line.startsWith("u ")) state.conflicts++;
+    else if (line.startsWith("1 ") || line.startsWith("2 ")) {
+      const fields = line.split(" ", 4);
+      const xy = fields[1] ?? "..";
+      const sub = fields[2] ?? "N...";
+      if (xy[0] !== ".") state.staged++;
+      if (xy[1] !== "." || (sub.startsWith("S") && sub.slice(1) !== "...")) state.unstaged++;
+      if (line.startsWith("2 ")) i++; // Rename source is a separate NUL record, not another status.
+    }
+  }
+  if (state.detached) state.branch = oid && oid !== "(initial)" ? oid.slice(0, 7) : "HEAD";
+  return state;
+}
+export type GitReader = (cwd: string, signal: AbortSignal) => Promise<GitState>;
+export const readGit: GitReader = (cwd, signal) => new Promise((resolve) => {
+  if (signal.aborted) { resolve(emptyGit()); return; }
+  const child = spawn("git", ["--no-optional-locks", "status", "--porcelain=v2", "--branch", "-z"], {
+    cwd, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", LC_ALL: "C" }, stdio: ["ignore", "pipe", "pipe"], windowsHide: true,
+  });
+  const chunks: Buffer[] = [];
+  let bytes = 0, stderr = "", stopped = false;
+  const stop = () => { stopped = true; child.kill("SIGKILL"); };
+  const timer = setTimeout(stop, 1000);
+  timer.unref();
+  signal.addEventListener("abort", stop, { once: true });
+  const finish = (state: GitState) => { clearTimeout(timer); signal.removeEventListener("abort", stop); resolve(state); };
+  child.stdout.on("data", (chunk: Buffer) => { bytes += chunk.length; if (bytes > 8 * 1024 * 1024) stop(); else chunks.push(chunk); });
+  child.stderr.on("data", (chunk: Buffer) => { if (stderr.length < 4096) stderr += chunk.toString(); });
+  child.on("error", () => finish(emptyGit()));
+  child.on("close", (code) => {
+    if (stopped || signal.aborted) finish(emptyGit());
+    else if (code === 0) finish(parseGitStatus(Buffer.concat(chunks).toString("utf8")));
+    else finish(emptyGit(stderr.includes("not a git repository") ? "none" : "unknown"));
+  });
+});
+
+/** One query at a time. Disposal cancels work and prevents stale completion callbacks. */
+export class GitPoller {
+  private controller: AbortController | undefined;
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private state = emptyGit();
+  private disposed = false;
+  private pending = false;
+  private lastStart = 0;
+  private deferred: ReturnType<typeof setTimeout> | undefined;
+  private readonly cwd: string;
+  private readonly changed: (state: GitState) => void;
+  private readonly reader: GitReader;
+  constructor(cwd: string, changed: (state: GitState) => void, reader: GitReader = readGit) {
+    this.cwd = cwd; this.changed = changed; this.reader = reader;
+  }
+  start(): void {
+    if (this.timer || this.disposed) return;
+    void this.refresh();
+    this.timer = setInterval(() => void this.refresh(), 2000);
+    this.timer.unref();
+  }
+  async refresh(): Promise<void> {
+    if (this.disposed) return;
+    if (this.controller) { this.pending = true; return; }
+    const delay = 250 - (Date.now() - this.lastStart);
+    if (delay > 0) {
+      this.deferred ??= setTimeout(() => { this.deferred = undefined; void this.refresh(); }, delay);
+      this.deferred.unref();
+      return;
+    }
+    this.lastStart = Date.now();
+    const controller = new AbortController();
+    this.controller = controller;
+    try {
+      const state = await this.reader(this.cwd, controller.signal);
+      if (!this.disposed && JSON.stringify(state) !== JSON.stringify(this.state)) { this.state = state; this.changed(state); }
+    } catch {
+      if (!this.disposed && this.state.kind !== "unknown") { this.state = emptyGit(); this.changed(this.state); }
+    } finally {
+      this.controller = undefined;
+      if (this.pending && !this.disposed) { this.pending = false; void this.refresh(); }
+    }
+  }
+  dispose(): void {
+    this.disposed = true;
+    clearInterval(this.timer); clearTimeout(this.deferred); this.controller?.abort();
+  }
+}

package/src/index.ts

@@ -0,0 +1,108 @@
+import { join } from "node:path";
+import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { ConfigStore, presetConfig } from "./config.ts";
+import { StatuslinePanel } from "./panel.ts";
+import { sampleSnapshot } from "./render.ts";
+import { FooterSession } from "./session.ts";
+
+export default function statusline(pi: ExtensionAPI): void {
+  const store = new ConfigStore(join(getAgentDir(), "extensions", "pi-statusline", "config.json"));
+  let config = presetConfig();
+  let session: FooterSession | undefined;
+  let generation = 0;
+
+  pi.on("session_start", async (_event, ctx) => {
+    const token = ++generation;
+    session?.dispose(); session = undefined;
+    if (ctx.mode !== "tui") return;
+    const loaded = await store.load(config);
+    if (token !== generation) return;
+    config = loaded.config;
+    if (loaded.warning) ctx.ui.notify(loaded.warning, "warning");
+    session = new FooterSession(ctx, config);
+    session.refresh(true);
+    session.install();
+  });
+  pi.on("session_shutdown", () => { generation++; session?.dispose(); session = undefined; });
+  pi.on("agent_start", (_event, ctx) => { session?.setContext(ctx); session?.startRun(); session?.schedule(true); });
+  pi.on("turn_start", (_event, ctx) => { session?.setContext(ctx); session?.startTurn(); session?.schedule(true); });
+  pi.on("agent_before_settle", (event) => { session?.runtime.beforeSettle(event.outcome); });
+  pi.on("agent_settled", (_event, ctx) => { session?.setContext(ctx); session?.settle(); session?.schedule(true); });
+  pi.on("ui_prompt_start", () => { session?.runtime.uiStart(); session?.schedule(true); });
+  pi.on("ui_prompt_end", () => { session?.runtime.uiEnd(); session?.schedule(true); });
+  pi.on("tool_execution_start", (event, ctx) => { session?.setContext(ctx); session?.runtime.toolStart(event.toolCallId, event.toolName); session?.schedule(true); });
+  pi.on("session_before_compact", (_event, ctx) => {
+    session?.setContext(ctx); session?.compaction.start(); session?.runtime.compaction(true); session?.schedule(true);
+  });
+  pi.on("message_start", (event, ctx) => {
+    session?.setContext(ctx);
+    if (event.message.role === "assistant") { session?.setLive(undefined); session?.runtime.messageStart(event.message); }
+    session?.schedule(true);
+  });
+  pi.on("message_update", (event, ctx) => {
+    session?.setContext(ctx);
+    if (event.message.role === "assistant") { session?.setLive(event.message); session?.runtime.stream(event.assistantMessageEvent); session?.runtime.message(event.message); }
+    session?.schedule();
+  });
+  pi.on("message_end", (event, ctx) => {
+    session?.setContext(ctx);
+    if (event.message.role === "assistant") { session?.setLive(event.message); session?.runtime.message(event.message, true); }
+    session?.schedule(true);
+  });
+  const refresh = (_event: unknown, ctx: ExtensionContext) => { session?.setContext(ctx); session?.schedule(true); };
+  const resetLive = (event: unknown, ctx: ExtensionContext) => { session?.setLive(undefined); refresh(event, ctx); };
+  pi.on("agent_end", resetLive);
+  pi.on("turn_end", (event, ctx) => { if (event.message.role === "assistant") session?.runtime.message(event.message, true); session?.runtime.turnEnd(); refresh(event, ctx); });
+  pi.on("model_select", refresh);
+  pi.on("thinking_level_select", refresh);
+  pi.on("session_compact", (event, ctx) => {
+    session?.compaction.finish("success", event.compactionEntry.id); session?.runtime.compaction(false); resetLive(event, ctx);
+  });
+  pi.on("session_compact_failed", (event, ctx) => {
+    session?.compaction.finish(event.aborted ? "cancelled" : "failed", undefined, event.errorMessage); session?.runtime.compaction(false); refresh(event, ctx);
+  });
+  pi.on("session_tree", resetLive);
+  pi.on("tool_execution_end", (event, ctx) => { session?.setContext(ctx); session?.runtime.toolEnd(event.toolCallId); session?.requestGit(); session?.schedule(true); });
+  pi.on("user_bash", (_event, ctx) => { session?.setContext(ctx); session?.requestGit(); });
+
+  pi.registerCommand("statusline", {
+    description: "Configure the statusline, or on | off | reload",
+    handler: async (args, ctx) => {
+      if (ctx.mode !== "tui") { ctx.ui.notify("Statusline configuration requires Pi terminal mode.", "info"); return; }
+      const token = generation;
+      const current = session;
+      if (!current) return;
+      current.setContext(ctx);
+      const command = args.trim();
+      if (command === "off") { current.disable(); return; }
+      if (command === "on") { current.apply({ ...config, enabled: true }); return; }
+      if (command === "reload") {
+        const loaded = await store.load(config);
+        if (token !== generation) return;
+        config = loaded.config;
+        if (loaded.warning) ctx.ui.notify(loaded.warning, "warning");
+        current.dispose();
+        session = new FooterSession(ctx, config);
+        session.refresh(true); session.install();
+        return;
+      }
+      if (command) { ctx.ui.notify("Usage: /statusline [on|off|reload]", "info"); return; }
+      current.refresh(true);
+      await ctx.ui.custom<void>((tui, _theme, _keys, done) => new StatuslinePanel({
+        config, theme: () => ctx.ui.theme,
+        snapshot: () => {
+          const example = ctx.sessionManager.getLeafId() === null;
+          return { data: example ? sampleSnapshot() : current.snapshot(), example };
+        },
+        requestRender: () => tui.requestRender(), height: () => tui.terminal.rows,
+        done: () => done(),
+        save: async (next) => {
+          if (token !== generation) throw new Error("Session changed; reopen settings");
+          await store.save(next);
+          if (token !== generation) return;
+          config = next; current.apply(config);
+        },
+      }));
+    },
+  });
+}

package/src/panel.ts

@@ -0,0 +1,202 @@
+import { Input, matchesKey, SelectList, truncateToWidth, type Component, type Focusable, type SelectItem } from "@earendil-works/pi-tui";
+import { COLORS, parseConfig, presetConfig } from "./config.ts";
+import { cleanText, renderFooter, type RenderTheme } from "./render.ts";
+import type { SegmentConfig, StatuslineConfig, StatuslineSnapshot } from "./types.ts";
+
+interface PanelOptions {
+  config: StatuslineConfig;
+  theme: () => RenderTheme;
+  snapshot: () => { data: StatuslineSnapshot; example: boolean };
+  requestRender: () => void;
+  height: () => number;
+  save: (config: StatuslineConfig) => Promise<void>;
+  done: () => void;
+}
+
+/** All edits belong to a draft. Only a successful explicit Save changes the running footer. */
+export class StatuslinePanel implements Component, Focusable {
+  private options: PanelOptions;
+  private draft: StatuslineConfig;
+  private list!: SelectList;
+  private editing: SegmentConfig | undefined;
+  private input: Input | undefined;
+  private inputLabel = "";
+  private error = "";
+  private saving = false;
+  private disposed = false;
+  private hasFocus = false;
+  private listHeight = 0;
+  private section: "runtime" | undefined;
+
+  constructor(options: PanelOptions) { this.options = options; this.draft = structuredClone(options.config); this.rebuild(); }
+  get focused(): boolean { return this.hasFocus; }
+  set focused(value: boolean) { this.hasFocus = value; if (this.input) this.input.focused = value; }
+  private paint(text: string, color: "text" | "accent" | "muted" | "error" = "text"): string {
+    const theme = this.options.theme(); return theme.style(text, { fg: theme.colors[color] });
+  }
+  private thinkingConfig(): SegmentConfig {
+    let thinking = this.draft.segments.find((segment) => segment.id === "thinking");
+    if (!thinking) { thinking = { id: "thinking", enabled: false }; this.draft.segments.push(thinking); }
+    return thinking;
+  }
+  private items(): SelectItem[] {
+    if (this.section) {
+      const labels: Record<string, string> = { enabled: "Runtime metrics", status: "Elapsed / compaction status", tools: "Tool activity", noContent: "No content warning", noContentSeconds: "No content threshold (seconds)", avg: "Average output speed", cache: "Cache read ratio", counts: "Turns and compactions", retainSummary: "Retain last run summary" };
+      return [...Object.entries(this.draft[this.section]).map(([key, value]) => ({ value: `option:${key}`, label: `${labels[key] ?? key}: ${value}` })), { value: "back", label: "Back to settings" }];
+    }
+    if (this.editing) {
+      const segment = this.editing;
+      return [
+        { value: "enabled", label: `Enabled: ${segment.enabled ? "yes" : "no"}` },
+        ...(["icon", "color", "iconColor", "background"] as const).map((key) => ({ value: key, label: `${key}: ${segment[key] ?? "(default)"}`, description: key === "icon" ? "Empty text hides the icon; :default restores it" : "Semantic color or #RRGGBB; empty restores default" })),
+        ...(segment.id === "model" ? [
+          { value: "thinking", label: `Thinking level: ${this.thinkingConfig().enabled ? "yes" : "no"}`, description: "Colored level in parentheses after the model name" },
+          { value: "thinkingColor", label: `Thinking color: ${this.thinkingConfig().color ?? "automatic"}`, description: "Automatic uses level colors; high/xhigh/max use rainbow" },
+        ] : []),
+        { value: "back", label: "Back to segments" },
+      ];
+    }
+    return [
+      { value: "defaultEnabled", label: `Enable on startup: ${this.draft.enabled ? "yes" : "no"}` },
+      { value: "icons", label: `Icons: ${this.draft.icons}` },
+      { value: "separator", label: `Separator: ${this.draft.separator}` },
+      { value: "pathMode", label: `Path: ${this.draft.pathMode}` },
+      { value: "modelDisplay", label: `Model display: ${this.draft.modelDisplay}`, description: "name: display name · last: final model ID component" },
+      { value: "contextDisplay", label: `Context display: ${this.draft.contextDisplay}`, description: "text: tokens/capacity(percent) · bar: progress and percent" },
+      ...this.draft.segments.filter((segment) => segment.id !== "thinking").map((segment) => ({ value: `segment:${segment.id}`, label: `[${segment.enabled ? "x" : " "}] ${segment.id}`, description: segment.id === "statuses" ? "Secondary row · Space toggles, Enter edits" : "Space toggles · Alt+Up/Down reorders · Enter edits" })),
+      { value: "runtime", label: "Runtime options" },
+      { value: "save", label: "Save and apply globally" },
+      { value: "reset", label: "Restore defaults in preview" },
+      { value: "cancel", label: "Cancel" },
+    ];
+  }
+  private rebuild(selected?: string): void {
+    const items = this.items();
+    this.listHeight = Math.max(1, this.options.height() - 12);
+    this.list = new SelectList(items, this.listHeight, {
+      selectedPrefix: (text) => this.paint(text, "accent"), selectedText: (text) => this.paint(text, "accent"),
+      description: (text) => this.paint(text, "muted"), scrollInfo: (text) => this.paint(text, "muted"), noMatch: (text) => this.paint(text, "muted"),
+    });
+    this.list.onSelect = (item) => this.activate(item.value);
+    this.list.onCancel = () => this.cancel();
+    if (selected) this.list.setSelectedIndex(Math.max(0, items.findIndex((item) => item.value === selected)));
+  }
+  private cancel(): void {
+    if (this.input) { this.input = undefined; this.error = ""; }
+    else if (this.section) { const section = this.section; this.section = undefined; this.rebuild(section); }
+    else if (this.editing) { const id = this.editing.id; this.editing = undefined; this.rebuild(`segment:${id}`); }
+    else this.options.done();
+  }
+  private activate(value: string): void {
+    this.error = "";
+    if (this.section) {
+      if (value === "back") { this.cancel(); return; }
+      const key = value.slice("option:".length);
+      if (key === "noContentSeconds") {
+        this.input = new Input(); this.input.focused = this.hasFocus; this.input.setValue(String(this.draft.runtime.noContentSeconds));
+        this.inputLabel = "No content threshold (1–3600 seconds)";
+        this.input.onEscape = () => this.cancel();
+        this.input.onSubmit = (text) => {
+          try { this.draft = parseConfig({ ...this.draft, runtime: { ...this.draft.runtime, noContentSeconds: Number(text) } }); this.input = undefined; this.error = ""; this.rebuild(value); }
+          catch (error) { this.error = error instanceof Error ? error.message : String(error); }
+        };
+      } else {
+        const group = this.draft[this.section] as unknown as Record<string, unknown>;
+        if (typeof group[key] === "boolean") group[key] = !group[key];
+      }
+      this.rebuild(value); return;
+    }
+    if (this.editing) {
+      if (value === "back") this.cancel();
+      else if (value === "enabled") { this.editing.enabled = !this.editing.enabled; this.rebuild(value); }
+      else if (value === "thinking") { const thinking = this.thinkingConfig(); thinking.enabled = !thinking.enabled; this.rebuild(value); }
+      else this.editProperty(value as "icon" | "color" | "iconColor" | "background" | "thinkingColor");
+      return;
+    }
+    const cycle = <T,>(current: T, options: readonly T[]): T => options[(options.indexOf(current) + 1) % options.length]!;
+    switch (value) {
+      case "defaultEnabled": this.draft.enabled = !this.draft.enabled; break;
+      case "icons": this.draft.icons = cycle(this.draft.icons, ["unicode", "nerd", "ascii"]); break;
+      case "separator": this.draft.separator = cycle(this.draft.separator, ["pipe", "dot", "space", "powerline"]); break;
+      case "pathMode": this.draft.pathMode = cycle(this.draft.pathMode, ["basename", "abbreviated", "full"]); break;
+      case "modelDisplay": this.draft.modelDisplay = cycle(this.draft.modelDisplay, ["name", "last"]); break;
+      case "contextDisplay": this.draft.contextDisplay = cycle(this.draft.contextDisplay, ["text", "bar"]); break;
+      case "runtime": this.section = value; this.rebuild(); return;
+      case "reset": this.draft = presetConfig(); break;
+      case "cancel": this.options.done(); return;
+      case "save": void this.save(); return;
+      default: this.editing = this.draft.segments.find((segment) => `segment:${segment.id}` === value); break;
+    }
+    this.rebuild(this.editing ? undefined : value);
+  }
+  private editProperty(property: "icon" | "color" | "iconColor" | "background" | "thinkingColor"): void {
+    const editingId = this.editing!.id;
+    const segment = property === "thinkingColor" ? this.thinkingConfig() : this.editing!;
+    const key = property === "thinkingColor" ? "color" : property;
+    const input = new Input();
+    input.setValue(segment[key] ?? (key === "icon" ? ":default" : ""));
+    input.focused = this.hasFocus;
+    this.input = input;
+    this.inputLabel = key === "icon" ? "Icon (empty hides; :default restores)" : `${key} (#RRGGBB or ${COLORS.slice(0, 7).join(", ")}; empty restores)`;
+    input.onEscape = () => this.cancel();
+    input.onSubmit = (text) => {
+      const candidate = structuredClone(this.draft);
+      const target = candidate.segments.find((item) => item.id === segment.id)!;
+      if ((key === "icon" && text === ":default") || (key !== "icon" && !text.trim())) delete target[key];
+      else (target as unknown as Record<string, unknown>)[key] = key === "icon" ? text : text.trim();
+      try {
+        this.draft = parseConfig(candidate);
+        this.editing = this.draft.segments.find((item) => item.id === editingId);
+        this.input = undefined; this.error = ""; this.rebuild(property);
+      } catch (error) { this.error = error instanceof Error ? error.message : String(error); }
+    };
+  }
+  private async save(): Promise<void> {
+    this.saving = true;
+    this.options.requestRender();
+    try { await this.options.save(structuredClone(this.draft)); if (!this.disposed) this.options.done(); }
+    catch (error) { if (!this.disposed) this.error = `Save failed: ${error instanceof Error ? error.message : String(error)}`; }
+    finally { this.saving = false; if (!this.disposed) this.options.requestRender(); }
+  }
+  handleInput(data: string): void {
+    if (this.saving || this.disposed) return;
+    if (this.input) this.input.handleInput(data);
+    else {
+      const selected = this.list.getSelectedItem()?.value;
+      const segmentIndex = this.draft.segments.findIndex((segment) => `segment:${segment.id}` === selected);
+      if (!this.editing && segmentIndex >= 0 && matchesKey(data, "space")) {
+        const segment = this.draft.segments[segmentIndex]!; segment.enabled = !segment.enabled; this.rebuild(selected);
+      } else if (!this.editing && segmentIndex >= 0 && (matchesKey(data, "alt+up") || matchesKey(data, "alt+down"))) {
+        const direction = matchesKey(data, "alt+up") ? -1 : 1;
+        let next = segmentIndex + direction;
+        while (this.draft.segments[next]?.id === "thinking") next += direction;
+        if (next >= 0 && next < this.draft.segments.length) {
+          [this.draft.segments[segmentIndex], this.draft.segments[next]] = [this.draft.segments[next]!, this.draft.segments[segmentIndex]!];
+          this.rebuild(selected);
+        }
+      } else if (this.section && matchesKey(data, "space") && selected?.startsWith("option:")) this.activate(selected);
+      else this.list.handleInput(data);
+    }
+    if (!this.disposed) this.options.requestRender();
+  }
+  invalidate(): void { this.list.invalidate(); this.input?.invalidate(); }
+  dispose(): void { this.disposed = true; }
+  render(width: number): string[] {
+    if (width <= 0) return [];
+    if (this.listHeight !== Math.max(1, this.options.height() - 12)) this.rebuild(this.list.getSelectedItem()?.value);
+    const { data, example } = this.options.snapshot();
+    const preview = renderFooter(width, data, this.draft, this.options.theme());
+    const lines = [
+      this.paint(`Statusline settings${this.editing ? ` / ${this.editing.id}` : this.section ? ` / ${this.section}` : ""}`, "accent"),
+      this.paint(example ? "Preview · example data" : "Preview · current session", "muted"),
+      ...(preview.length ? preview : [this.paint("(all segments hidden)", "muted")]),
+      this.paint("Changes are a draft until Save. Fees are Pi-reported USD.", "muted"),
+      "",
+      ...(this.input ? [this.paint(this.inputLabel, "accent"), ...this.input.render(width)] : this.list.render(width)),
+      "",
+      this.paint(this.saving ? "Saving…" : "↑↓ select · Space toggle · Alt+↑↓ reorder · Enter edit · Esc back/cancel", "muted"),
+      ...(this.error ? [this.paint(cleanText(this.error), "error")] : []),
+    ];
+    return lines.map((line) => truncateToWidth(line, width));
+  }
+}

package/src/render.ts

@@ -0,0 +1,216 @@
+import { basename, isAbsolute, relative, sep } from "node:path";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { parseColor, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { cleanText } from "./text.ts";
+export { cleanText } from "./text.ts";
+import type { ColorValue, SegmentConfig, SegmentId, StatuslineConfig, StatuslineSnapshot } from "./types.ts";
+import { emptyGit } from "./git.ts";
+import { emptyUsage } from "./usage.ts";
+import { renderRuntime } from "./runtime-render.ts";
+
+export type RenderTheme = Pick<Theme, "style" | "colors" | "appearance">;
+// Keep rainbow hues independent of semantic theme colors, which can repeat.
+const THINKING_RAINBOW = ["#c084fc", "#f472b6", "#fb923c", "#facc15", "#4ade80", "#22d3ee", "#60a5fa"].map((value) => parseColor(value));
+const ICONS: Record<StatuslineConfig["icons"], Partial<Record<SegmentId, string>>> = {
+  unicode: { model: "", directory: "▸", git: "⑂", context: "◉", cost: "$", input: "↑", output: "↓", tokens: "Σ", cacheRead: "R", cacheWrite: "W" },
+  nerd: { model: "", directory: "󰉋", git: "", context: "󰆼", cost: "$", input: "↑", output: "↓", tokens: "󰊄", cacheRead: "R", cacheWrite: "W" },
+  ascii: { model: "", directory: "", git: "git:", context: "ctx:", cost: "$", input: "in:", output: "out:", tokens: "tok:", cacheRead: "R:", cacheWrite: "W:" },
+};
+const DROP_ORDER: SegmentId[] = ["cost", "cacheWrite", "cacheRead", "tokens", "output", "input", "thinking", "git", "directory"];
+export function formatTokens(value: number): string {
+  if (value < 1000) return String(Math.round(value));
+  const divisor = value >= 1e6 ? 1e6 : 1000;
+  return `${Number((value / divisor).toFixed(1))}${divisor === 1e6 ? "M" : "k"}`;
+}
+function contextBar(percent: number | null, ascii: boolean): string {
+  const width = 10;
+  if (percent === null || !Number.isFinite(percent)) return `[${"?".repeat(width)}]?%`;
+  const fill = Math.max(0, Math.min(100, percent)) / 100 * width;
+  // Whole cells avoid the blank right side of fractional glyphs such as ▌.
+  // Keep small, non-zero usage visible; the percentage gives the precise value.
+  const full = fill > 0 ? Math.max(1, Math.round(fill)) : 0;
+  const bar = (ascii ? "#" : "█").repeat(full) + (ascii ? "-" : "░").repeat(width - full);
+  return `[${bar}]${Number(percent.toFixed(1))}%`;
+}
+function displayPath(data: StatuslineSnapshot, mode: StatuslineConfig["pathMode"]): string {
+  if (mode === "basename") return basename(data.cwd) || data.cwd;
+  const rel = data.home ? relative(data.home, data.cwd) : "..";
+  const inside = rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+  const full = inside ? (rel ? `~${sep}${rel}` : "~") : data.cwd;
+  if (mode !== "abbreviated" || visibleWidth(full) <= 36) return full;
+  const parts = full.split(sep);
+  return `…${sep}${parts.slice(-2).join(sep)}`;
+}
+function gitText(data: StatuslineSnapshot, ascii: boolean): string | undefined {
+  const git = data.git;
+  if (git.kind === "none") return undefined;
+  if (git.kind === "unknown") return `${git.branch ?? ""} ?`.trim();
+  const bits = [git.branch ?? "HEAD"];
+  if (git.detached) bits.push(ascii ? "(detached)" : "detached");
+  if (git.conflicts) bits.push(`${ascii ? "!" : "⚠"}${git.conflicts}`);
+  else bits.push(git.staged + git.unstaged + git.untracked ? (ascii ? "*" : "●") : (ascii ? "ok" : "✓"));
+  if (git.staged) bits.push(`+${git.staged}`);
+  if (git.unstaged) bits.push(`*${git.unstaged}`);
+  if (git.untracked) bits.push(`?${git.untracked}`);
+  if (git.ahead) bits.push(`${ascii ? "^" : "↑"}${git.ahead}`);
+  if (git.behind) bits.push(`${ascii ? "v" : "↓"}${git.behind}`);
+  return bits.join(" ");
+}
+function segmentText(id: SegmentId, data: StatuslineSnapshot, config: StatuslineConfig): string | undefined {
+  const usage = data.usage;
+  switch (id) {
+    case "model": return (config.modelDisplay === "last" ? data.modelId.split("/").filter(Boolean).at(-1) : undefined) || data.model || "No model";
+    case "thinking": return undefined; // Its settings now control the model's suffix.
+    case "directory": return displayPath(data, config.pathMode);
+    case "git": return gitText(data, config.icons === "ascii");
+    case "context": {
+      const { tokens, percent, contextWindow } = data.context;
+      if (config.contextDisplay === "bar") return contextBar(percent, config.icons === "ascii");
+      const capacity = contextWindow > 0 ? formatTokens(contextWindow) : "?";
+      return `${tokens === null ? "?" : formatTokens(tokens)}/${capacity}(${percent === null ? "?" : Number(percent.toFixed(1))}%)`;
+    }
+    case "cost": return usage.cost.toFixed(3);
+    case "input": return formatTokens(usage.input);
+    case "output": return formatTokens(usage.output);
+    case "tokens": return formatTokens(usage.input + usage.output + usage.cacheRead + usage.cacheWrite);
+    case "cacheRead": return formatTokens(usage.cacheRead);
+    case "cacheWrite": return formatTokens(usage.cacheWrite);
+    case "statuses": return [...data.statuses.values()].map(cleanText).filter(Boolean).join(" · ") || undefined;
+  }
+}
+function defaultColor(id: SegmentId, data: StatuslineSnapshot): ColorValue {
+  if (id === "context") {
+    if ((data.context.percent ?? 0) > 90) return "error";
+    if ((data.context.percent ?? 0) > 70) return "warning";
+  }
+  if (id === "git") {
+    if (data.git.conflicts) return "error";
+    if (data.git.kind === "unknown" || data.git.staged + data.git.unstaged + data.git.untracked) return "warning";
+    return "success";
+  }
+  if (id === "thinking") {
+    const colors: Record<string, ColorValue> = { off: "thinkingOff", minimal: "thinkingMinimal", low: "thinkingLow", medium: "thinkingMedium", high: "thinkingHigh", xhigh: "thinkingXhigh", max: "thinkingMax" };
+    return colors[data.thinking] ?? "muted";
+  }
+  if (id === "model") return "accent";
+  if (id === "directory") return "success";
+  if (id === "context") return "#c678dd";
+  if (id === "cost") return "text";
+  return "muted";
+}
+function color(value: ColorValue, theme: RenderTheme) {
+  return value.startsWith("#") ? parseColor(value) : theme.colors[value as Exclude<ColorValue, `#${string}`>];
+}
+interface Part {
+  config: SegmentConfig;
+  text: string;
+  icon: string;
+  foreground: ColorValue;
+  background?: ColorValue;
+  thinking?: { text: string; foreground: ColorValue | "rainbow" };
+}
+function renderPart(part: Part, theme: RenderTheme): string {
+  const bg = part.background ? color(part.background, theme) : undefined;
+  const style = { fg: color(part.foreground, theme), ...(bg ? { bg } : {}) };
+  const icon = part.icon ? theme.style(`${part.icon} `, { ...style, fg: color(part.config.iconColor ?? part.foreground, theme) }) : "";
+  const text = theme.style(part.text, style);
+  let suffix = "";
+  if (part.thinking) {
+    const { text: level, foreground } = part.thinking;
+    const label = `(${level})`;
+    const characters = Array.from(label);
+    suffix = foreground === "rainbow"
+      ? characters.map((character, i) => theme.style(character, {
+          ...style,
+          fg: THINKING_RAINBOW[Math.round(i * (THINKING_RAINBOW.length - 1) / Math.max(1, characters.length - 1))]!,
+        })).join("")
+      : theme.style(label, { ...style, fg: color(foreground, theme) });
+  }
+  const content = `${icon}${text}${suffix}`;
+  return bg ? `${theme.style(" ", style)}${content}${theme.style(" ", style)}` : content;
+}
+function joinParts(parts: Part[], config: StatuslineConfig, theme: RenderTheme): string {
+  return parts.map((part, i) => {
+    let separator = "";
+    const previous = parts[i - 1];
+    if (previous) {
+      if (config.separator === "powerline" && config.icons !== "ascii") {
+        separator = theme.style("", {
+          fg: color(previous.background ?? previous.foreground, theme),
+          ...(part.background ? { bg: color(part.background, theme) } : {}),
+        });
+      } else {
+        const sep = config.separator === "space" ? " " : config.separator === "dot" && config.icons !== "ascii" ? " · " : " | ";
+        separator = theme.style(sep, { fg: theme.colors.dim });
+      }
+    }
+    return separator + renderPart(part, theme);
+  }).join("");
+}
+
+/** Pure terminal rendering: no disk reads, processes or session traversal. */
+export function renderFooter(width: number, data: StatuslineSnapshot, config: StatuslineConfig, theme: RenderTheme): string[] {
+  width = Math.max(0, Math.floor(width));
+  if (width === 0) return [];
+  const parts: Part[] = [];
+  let secondary: Part | undefined;
+  // CLIProxyAPI's published `tps` status is display text only.
+  const tps = cleanText(data.statuses.get("tps") ?? "");
+  const elapsedStatus = config.segments.some((s) => s.id === "statuses" && s.enabled) && /^Elapsed \d+[dhms](?: \d+[hms])*$/.test(tps) ? tps : undefined;
+  const statuses = elapsedStatus ? new Map([...data.statuses].filter(([key]) => key !== "tps")) : data.statuses;
+  const thinking = config.segments.find((segment) => segment.id === "thinking");
+  for (const segment of config.segments) {
+    if (!segment.enabled) continue;
+    const raw = segmentText(segment.id, segment.id === "statuses" ? { ...data, statuses } : data, config);
+    if (raw === undefined) continue;
+    let text = cleanText(raw);
+    if (config.icons === "ascii") text = text.replaceAll(" · ", " / ").replaceAll("…", "...");
+    const background = segment.background ?? (config.preset === "powerline" ? (theme.appearance === "light" ? (parts.length % 2 ? "#e4e9f2" : "#d6dde9") : (parts.length % 2 ? "#283447" : "#202938")) : undefined);
+    const part: Part = { config: segment, text, icon: cleanText(segment.icon ?? ICONS[config.icons][segment.id] ?? ""), foreground: segment.color ?? defaultColor(segment.id, data), background };
+    if (segment.id === "model" && data.reasoning && thinking?.enabled) {
+      part.thinking = {
+        text: cleanText(data.thinking || "off"),
+        foreground: thinking.color ?? (["high", "xhigh", "max"].includes(data.thinking) ? "rainbow" : defaultColor("thinking", data)),
+      };
+    }
+    if (segment.id === "statuses") secondary = part;
+    else parts.push(part);
+  }
+  let line = joinParts(parts, config, theme);
+  const ellipsis = config.icons === "ascii" ? "..." : "…";
+  if (visibleWidth(line) > width) {
+    for (const id of ["directory", "model"] as const) {
+      const part = parts.find((p) => p.config.id === id);
+      if (part) part.text = truncateToWidth(part.text, Math.max(6, Math.min(24, Math.floor(width / 4))), ellipsis);
+    }
+    line = joinParts(parts, config, theme);
+    for (const id of DROP_ORDER) {
+      if (visibleWidth(line) <= width) break;
+      if (id === "thinking") {
+        const model = parts.find((p) => p.config.id === "model");
+        if (model) model.thinking = undefined;
+      } else {
+        const index = parts.findIndex((p) => p.config.id === id);
+        if (index !== -1) parts.splice(index, 1);
+      }
+      line = joinParts(parts, config, theme);
+    }
+  }
+  const lines: string[] = [];
+  if (parts.length) lines.push(truncateToWidth(line, width, ellipsis));
+  const secondLine = renderRuntime(width, data, config, theme, secondary ? renderPart(secondary, theme) : undefined, elapsedStatus);
+  if (secondLine) lines.push(secondLine);
+  return lines;
+}
+
+export function sampleSnapshot(): StatuslineSnapshot {
+  return {
+    model: "Example model", modelId: "example/provider/model", reasoning: true, thinking: "high", cwd: "/projects/pi-packages", home: "/home/example",
+    context: { tokens: 23800, contextWindow: 200000, percent: 11.9 },
+    usage: { ...emptyUsage(), input: 32000, output: 5400, cacheRead: 12000, cost: 0.12 },
+    git: { ...emptyGit("repository"), branch: "main", unstaged: 2, ahead: 2 },
+    statuses: new Map([["example", "Example extension status"]]),
+    runtime: { runId: "example", status: "Running", elapsedMs: 28000, turns: 3, toolCalls: 2, tools: [], awaitingInput: false, noContentMs: 0, usage: { ...emptyUsage(), output: 1260 }, avg: 45, cache: 0.86 },
+    compaction: { active: false, elapsedMs: 0, count: 1, showFailure: false },
+  };
+}