@erichll/pi-statusline 0.0.0-stage → 0.2.0

package/src/runtime-render.ts

@@ -0,0 +1,62 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { RenderTheme } from "./render.ts";
+import { cleanText } from "./text.ts";
+import type { StatuslineConfig, StatuslineSnapshot } from "./types.ts";
+
+export function seconds(ms: number): string { return `${Math.floor(ms / 1000)}s`; }
+export function elapsed(ms: number): string {
+  let remaining = Math.max(0, Math.floor(ms / 1000));
+  const parts: string[] = [];
+  for (const [unit, size] of [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]] as const) {
+    const value = Math.floor(remaining / size); remaining %= size;
+    if (value || parts.length || unit === "s") parts.push(`${value}${unit}`);
+  }
+  return parts.join(" ");
+}
+interface Part { id: string; text: string; color?: "text" | "muted" | "warning" | "error" | "success"; styled?: string }
+
+/** Layout consumes snapshots only; width decisions use terminal cells, including ANSI. */
+export function renderRuntime(width: number, data: StatuslineSnapshot, config: StatuslineConfig, theme: RenderTheme, extensionStatus?: string, elapsedStatus?: string): string | undefined {
+  const parts: Part[] = [];
+  const runtime = data.runtime, compact = data.compaction;
+  const enabled = config.runtime.enabled;
+  const add = (id: string, text: string, color?: Part["color"]) => parts.push({ id, text, color });
+  if (elapsedStatus) add("elapsed", elapsedStatus);
+  else if (enabled && config.runtime.status && runtime?.runId) add("elapsed", `Elapsed ${elapsed(runtime.elapsedMs)}`);
+  if (enabled && compact?.active) {
+    add("status", `${config.icons === "ascii" ? "Compacting..." : "Compacting…"} ${seconds(compact.elapsedMs)}`, "warning");
+    if (config.runtime.counts) add("compactions", `Compactions ${compact.count}`);
+  } else {
+    if (enabled && runtime) {
+      if (config.runtime.status) {
+        const failure = compact?.showFailure && runtime.status !== "Running" ? `Compaction ${compact.last?.status}` : undefined;
+        if (failure) add("status", failure, "error");
+      }
+      let busy = false;
+      if (runtime.awaitingInput) { add("activity", "Awaiting input", "warning"); busy = true; }
+      else if (config.runtime.tools && runtime.tools.length) {
+        add("activity", runtime.tools.length > 1 ? `Tools ${runtime.tools.length} active` : `Tool ${cleanText(runtime.tools[0]!.name).slice(0, 40)} ${seconds(runtime.tools[0]!.elapsedMs)}`);
+        busy = true;
+      } else if (config.runtime.noContent && runtime.noContentMs !== null && runtime.noContentMs >= config.runtime.noContentSeconds * 1000) {
+        add("activity", `No content ${seconds(runtime.noContentMs)}`); busy = true;
+      }
+      if (!busy) {
+        if (config.runtime.avg && runtime.avg !== null) add("avg", `Avg ${Math.round(runtime.avg)} tok/s`);
+        if (config.runtime.cache && runtime.cache !== null) add("cache", `Cache ${Math.round(runtime.cache * 100)}%`);
+      }
+      if (config.runtime.counts && runtime.runId) add("turns", `Turns ${runtime.turns}`);
+    }
+    if (enabled && config.runtime.counts && compact) add("compactions", `Compactions ${compact.count}`);
+    if (extensionStatus) parts.push({ id: "statuses", text: extensionStatus, styled: extensionStatus });
+  }
+  const separator = config.icons === "ascii" ? " | " : " · ";
+  const draw = () => parts.map((part) => part.styled ?? theme.style(part.text, { fg: theme.colors[part.color ?? "muted"] })).join(theme.style(separator, { fg: theme.colors.dim }));
+  let line = draw();
+  for (const id of ["statuses", "cache", "avg", "compactions", "turns", "activity"]) {
+    if (visibleWidth(line) <= width) break;
+    const index = parts.findIndex((part) => part.id === id);
+    if (index !== -1) parts.splice(index, 1);
+    line = draw();
+  }
+  return parts.length ? truncateToWidth(line, width, config.icons === "ascii" ? "..." : "…") : undefined;
+}

package/src/runtime.ts

@@ -0,0 +1,130 @@
+import { randomUUID } from "node:crypto";
+import type { AssistantMessage, AssistantMessageEvent } from "@earendil-works/pi-ai";
+import type { AgentActivityOutcome } from "@earendil-works/pi-coding-agent";
+import { cleanText } from "./text.ts";
+import { emptyUsage, readUsage } from "./usage.ts";
+import type { UsageTotals } from "./types.ts";
+
+export type Clock = () => number;
+export interface RuntimeSnapshot {
+  runId: string | null;
+  status: "Idle" | "Running" | "Done" | "Cancelled" | "Failed";
+  elapsedMs: number;
+  turns: number;
+  toolCalls: number;
+  tools: { name: string; elapsedMs: number }[];
+  awaitingInput: boolean;
+  noContentMs: number | null;
+  usage: UsageTotals | null;
+  avg: number | null;
+  cache: number | null;
+}
+
+/** A run survives agent_end, retries and boundary continuations until agent_settled. */
+export class RuntimeState {
+  private clock: Clock;
+  private startMs = 0;
+  private endMs = 0;
+  private runId: string | null = null;
+  private state: RuntimeSnapshot["status"] = "Idle";
+  private outcome: AgentActivityOutcome = "completed";
+  private aborted = false;
+  private turns = 0;
+  private tools = new Map<string, { name: string; start: number }>();
+  private seenTools = new Set<string>();
+  private prompts = 0;
+  private modelActive = false;
+  private compacting = false;
+  private lastContent = 0;
+  private messages = new Map<string, UsageTotals>();
+  private activeMessage: string | undefined;
+  private messageAliases = new Map<string, string>();
+  private sequence = 0;
+  constructor(clock: Clock = () => performance.now()) { this.clock = clock; }
+  get running(): boolean { return this.state === "Running"; }
+  get id(): string | null { return this.runId; }
+  reset(): void {
+    this.runId = null; this.state = "Idle"; this.startMs = 0; this.endMs = 0;
+    this.outcome = "completed"; this.aborted = false; this.turns = 0; this.tools.clear(); this.seenTools.clear();
+    this.prompts = 0; this.modelActive = false; this.compacting = false;
+    this.messages.clear(); this.messageAliases.clear(); this.activeMessage = undefined; this.sequence = 0;
+  }
+  start(): boolean {
+    if (this.running) return false;
+    const prompts = this.prompts;
+    this.reset(); this.prompts = prompts;
+    this.runId = randomUUID(); this.startMs = this.clock(); this.lastContent = this.startMs; this.state = "Running";
+    return true;
+  }
+  beforeSettle(outcome: AgentActivityOutcome): void { if (this.running && !this.aborted) this.outcome = outcome; }
+  observeAbort(): void { if (this.running) { this.aborted = true; this.outcome = "aborted"; } }
+  settle(): void {
+    if (!this.running) return;
+    this.endMs = this.clock();
+    this.state = { completed: "Done", aborted: "Cancelled", error: "Failed" }[this.outcome] as RuntimeSnapshot["status"];
+    this.modelActive = false; this.tools.clear(); this.activeMessage = undefined;
+  }
+  turnStart(): void {
+    if (!this.running) return;
+    // A continuation/retry supersedes the previous attempt's observed outcome.
+    this.outcome = "completed"; this.aborted = false;
+    this.turns++; this.modelActive = true; this.lastContent = this.clock(); this.activeMessage = undefined;
+  }
+  turnEnd(): void { this.modelActive = false; }
+  content(): void { if (this.running && !this.compacting) this.lastContent = this.clock(); }
+  stream(event: AssistantMessageEvent): void {
+    if ((event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") && event.delta.length > 0) this.content();
+    // A tool name/ID in the initial block is content even before JSON deltas arrive.
+    if (event.type === "toolcall_start") {
+      const block = event.partial.content[event.contentIndex];
+      if (block?.type === "toolCall" && (block.name || block.id)) this.content();
+    }
+  }
+  private alias(message: AssistantMessage): string { return `${message.provider}/${message.model}/${message.timestamp}`; }
+  messageStart(message: AssistantMessage): void {
+    if (!this.running || this.compacting) return;
+    this.activeMessage = String(++this.sequence);
+    this.messageAliases.set(this.alias(message), this.activeMessage);
+  }
+  message(message: AssistantMessage, final = false): void {
+    if (!this.running || this.compacting) return;
+    const alias = this.alias(message);
+    const responseAlias = message.responseId ? `${message.provider}/${message.model}/response:${message.responseId}` : undefined;
+    const key = (responseAlias ? this.messageAliases.get(responseAlias) : undefined) ?? this.messageAliases.get(alias) ?? this.activeMessage ?? String(++this.sequence);
+    this.messageAliases.set(alias, key);
+    if (responseAlias) this.messageAliases.set(responseAlias, key);
+    // Missing usage stays unavailable. Zeroes explicitly supplied by Pi are valid.
+    if (message.usage && [message.usage.input, message.usage.output, message.usage.cacheRead, message.usage.cacheWrite].every((n) => Number.isFinite(n) && n >= 0)) {
+      this.messages.set(key, readUsage(message.usage));
+    }
+    if (final) {
+      this.modelActive = false;
+      if (!this.aborted) this.outcome = message.stopReason === "aborted" ? "aborted" : message.stopReason === "error" ? "error" : "completed";
+    }
+  }
+  toolStart(id: string, name: string): void {
+    if (!this.running || this.seenTools.has(id)) return;
+    this.seenTools.add(id); this.tools.set(id, { name: cleanText(name).slice(0, 40) || "unknown", start: this.clock() });
+  }
+  toolEnd(id: string): void { this.tools.delete(id); }
+  uiStart(): void { this.prompts++; }
+  uiEnd(): void { this.prompts = Math.max(0, this.prompts - 1); this.lastContent = this.clock(); }
+  compaction(active: boolean): void { this.compacting = active; this.lastContent = this.clock(); }
+  snapshot(retainSummary = true): RuntimeSnapshot {
+    const now = this.clock();
+    const hidden = !retainSummary && !this.running;
+    const elapsedMs = hidden || !this.runId ? 0 : Math.max(0, (this.running ? now : this.endMs) - this.startMs);
+    const usage = !hidden && this.messages.size ? emptyUsage() : null;
+    if (usage) for (const contribution of this.messages.values()) for (const key of Object.keys(usage) as (keyof UsageTotals)[]) usage[key] += contribution[key];
+    const denominator = usage ? usage.input + usage.cacheRead + usage.cacheWrite : 0;
+    return {
+      runId: hidden ? null : this.runId, status: hidden ? "Idle" : this.state, elapsedMs,
+      turns: hidden ? 0 : this.turns, toolCalls: hidden ? 0 : this.seenTools.size,
+      tools: [...this.tools.values()].map((tool) => ({ name: tool.name, elapsedMs: Math.max(0, now - tool.start) })),
+      awaitingInput: this.prompts > 0,
+      noContentMs: this.running && this.modelActive && !this.tools.size && !this.prompts && !this.compacting ? Math.max(0, now - this.lastContent) : null,
+      usage, avg: usage && elapsedMs > 0 ? usage.output / (elapsedMs / 1000) : null,
+      cache: usage && denominator > 0 ? usage.cacheRead / denominator : null,
+    };
+  }
+}

package/src/session.ts

@@ -0,0 +1,137 @@
+import { homedir } from "node:os";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ExtensionContext, ReadonlyFooterDataProvider } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+import { emptyGit, GitPoller, type GitReader } from "./git.ts";
+import { renderFooter } from "./render.ts";
+import type { StatuslineConfig, StatuslineSnapshot } from "./types.ts";
+import { UsageCache } from "./usage.ts";
+import { RuntimeState } from "./runtime.ts";
+import { CompactionState } from "./compaction.ts";
+
+export class FooterSession {
+  readonly runtime = new RuntimeState();
+  readonly compaction = new CompactionState();
+  private ctx: ExtensionContext;
+  private config: StatuslineConfig;
+  private usage = new UsageCache();
+  private git = emptyGit();
+  private provider: ReadonlyFooterDataProvider | undefined;
+  private tui: Pick<TUI, "requestRender"> | undefined;
+  private poller: GitPoller | undefined;
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private scheduled: ReturnType<typeof setTimeout> | undefined;
+  private unsubscribe: (() => void) | undefined;
+  private closed = false;
+  private ownsFooter = false;
+  private statsKey = "";
+  private displayKey = "";
+  private context: StatuslineSnapshot["context"] = { tokens: null, contextWindow: 0, percent: null };
+  private readonly gitReader: GitReader | undefined;
+  private signal: AbortSignal | undefined;
+  private readonly onAbort = () => { this.runtime.observeAbort(); this.schedule(true); };
+
+  constructor(ctx: ExtensionContext, config: StatuslineConfig, gitReader?: GitReader) {
+    this.ctx = ctx; this.config = config; this.gitReader = gitReader;
+  }
+  get active(): boolean { return this.ownsFooter && !this.closed; }
+  setContext(ctx: ExtensionContext): void { this.ctx = ctx; this.watchSignal(); }
+  private watchSignal(): void {
+    if (this.closed || !this.ownsFooter || !this.runtime.running) return;
+    const signal = this.ctx.signal;
+    if (!signal || signal === this.signal) return;
+    this.clearSignal(); this.signal = signal;
+    if (signal.aborted) this.onAbort();
+    else signal.addEventListener("abort", this.onAbort, { once: true });
+  }
+  private clearSignal(): void { this.signal?.removeEventListener("abort", this.onAbort); this.signal = undefined; }
+  startRun(): void {
+    this.compaction.activity();
+    this.runtime.start();
+    this.watchSignal();
+  }
+  startTurn(): void {
+    this.compaction.activity(); this.runtime.turnStart(); this.watchSignal();
+  }
+  settle(): void { this.runtime.settle(); this.clearSignal(); }
+  install(): void {
+    if (this.closed || this.ctx.mode !== "tui" || !this.config.enabled) return;
+    this.ctx.ui.setFooter((tui, _theme, provider) => {
+      this.ownsFooter = true; this.tui = tui; this.provider = provider;
+      this.watchSignal();
+      this.poller = new GitPoller(this.ctx.cwd, (git) => { this.git = git; this.repaint(); }, this.gitReader);
+      this.unsubscribe = provider.onBranchChange(() => this.requestGit());
+      if (this.config.segments.some((segment) => segment.id === "git" && segment.enabled)) this.poller.start();
+      this.refresh(true);
+      // Covers usage entries appended outside normal message events (e.g. cache warming).
+      this.timer = setInterval(() => this.refresh(), 1000);
+      this.timer.unref();
+      return {
+        render: (width: number) => renderFooter(width, this.snapshot(), this.config, this.ctx.ui.theme),
+        invalidate: () => {}, // Theme and extension statuses are read fresh on every render.
+        dispose: () => this.stopResources(),
+      };
+    });
+  }
+  private stopResources(): void {
+    this.clearSignal();
+    clearInterval(this.timer); clearTimeout(this.scheduled);
+    this.timer = undefined; this.scheduled = undefined;
+    this.poller?.dispose(); this.poller = undefined;
+    this.unsubscribe?.(); this.unsubscribe = undefined;
+    this.ownsFooter = false; this.tui = undefined; this.provider = undefined;
+  }
+  disable(): void {
+    const restore = this.ownsFooter;
+    this.stopResources();
+    if (restore && !this.closed) this.ctx.ui.setFooter(undefined);
+  }
+  dispose(): void { this.stopResources(); this.clearSignal(); this.closed = true; }
+  apply(config: StatuslineConfig): void {
+    if (this.closed) return;
+    this.disable(); this.config = config;
+    if (config.enabled) this.install();
+  }
+  setLive(message: AssistantMessage | undefined): void { this.usage.setLive(message); }
+  schedule(immediate = false): void {
+    if (!this.active) return;
+    if (immediate) { clearTimeout(this.scheduled); this.scheduled = undefined; }
+    if (this.scheduled) return;
+    // Defer final events too: Pi emits message_end before appending the message.
+    this.scheduled = setTimeout(() => { this.scheduled = undefined; this.refresh(); }, immediate ? 0 : 100);
+    this.scheduled.unref();
+  }
+  requestGit(): void {
+    if (this.active && this.config.segments.some((segment) => segment.id === "git" && segment.enabled)) void this.poller?.refresh();
+  }
+  refresh(force = false): void {
+    if (this.closed) return;
+    const manager = this.ctx.sessionManager;
+    const key = `${manager.getSessionId()}:${manager.getLeafId()}:${this.ctx.model?.provider}/${this.ctx.model?.id}/${this.ctx.model?.contextWindow}`;
+    if (force || key !== this.statsKey) {
+      const entries = manager.getEntries();
+      this.usage.update(entries);
+      this.compaction.update(entries);
+      const context = this.ctx.getContextUsage();
+      this.context = context ?? { tokens: null, contextWindow: this.ctx.model?.contextWindow ?? 0, percent: null };
+    }
+    this.statsKey = key;
+    this.repaint();
+  }
+  private repaint(): void {
+    if (!this.active) return;
+    const snapshot = this.snapshot();
+    const key = JSON.stringify({ ...snapshot, statuses: undefined });
+    if (key === this.displayKey) return;
+    this.displayKey = key; this.tui?.requestRender();
+  }
+  snapshot(): StatuslineSnapshot {
+    return {
+      model: this.ctx.model?.name || this.ctx.model?.id || "No model", modelId: this.ctx.model?.id ?? "", reasoning: this.ctx.model?.reasoning ?? false,
+      thinking: this.ctx.thinkingLevel ?? "off", cwd: this.ctx.cwd, home: homedir(),
+      context: this.context, usage: this.usage.snapshot(), git: this.git,
+      statuses: this.provider?.getExtensionStatuses() ?? new Map(),
+      runtime: this.runtime.snapshot(this.config.runtime.retainSummary), compaction: this.compaction.snapshot(),
+    };
+  }
+}

package/src/text.ts

@@ -0,0 +1,11 @@
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+
+export function cleanText(text: string): string {
+  return stripTerminalSequences(text.replace(/[\r\n\t]/g, " ")).replace(/[\p{Cc}\u202a-\u202e\u2066-\u2069]/gu, "").trim();
+}
+/** Details never echo URLs, credentials or unbounded provider errors. */
+export function safeReason(text: string): string {
+  return cleanText(text).replace(/https?:\/\/\S+/gi, "[URL]")
+    .replace(/\b(Bearer|Basic)\s+\S+/gi, "$1 [redacted]")
+    .replace(/\b(api[-_]?key|token|authorization|password|secret)\s*[:=]\s*\S+/gi, "$1=[redacted]").slice(0, 180);
+}

package/src/types.ts

@@ -0,0 +1,70 @@
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+
+export const SEGMENT_IDS = ["model", "thinking", "context", "directory", "git", "cost", "input", "output", "tokens", "cacheRead", "cacheWrite", "statuses"] as const;
+export type SegmentId = typeof SEGMENT_IDS[number];
+export type ColorValue = ThemeColor | `#${string}`;
+export type Preset = "powerline";
+export type IconMode = "unicode" | "nerd" | "ascii";
+export interface RuntimeConfig {
+  enabled: boolean;
+  status: boolean;
+  tools: boolean;
+  noContent: boolean;
+  noContentSeconds: number;
+  avg: boolean;
+  cache: boolean;
+  counts: boolean;
+  retainSummary: boolean;
+}
+export interface SegmentConfig {
+  id: SegmentId;
+  enabled: boolean;
+  icon?: string;
+  color?: ColorValue;
+  iconColor?: ColorValue;
+  background?: ColorValue;
+}
+export interface StatuslineConfig {
+  version: 1;
+  enabled: boolean;
+  preset: Preset;
+  icons: IconMode;
+  separator: "pipe" | "dot" | "space" | "powerline";
+  pathMode: "basename" | "abbreviated" | "full";
+  modelDisplay: "name" | "last";
+  contextDisplay: "text" | "bar";
+  segments: SegmentConfig[];
+  runtime: RuntimeConfig;
+}
+export interface UsageTotals {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+}
+export interface GitState {
+  kind: "repository" | "none" | "unknown";
+  branch: string | null;
+  detached: boolean;
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  conflicts: number;
+  ahead: number;
+  behind: number;
+}
+export interface StatuslineSnapshot {
+  model: string;
+  modelId: string;
+  reasoning: boolean;
+  thinking: string;
+  cwd: string;
+  home: string;
+  context: { tokens: number | null; contextWindow: number; percent: number | null };
+  usage: UsageTotals;
+  git: GitState;
+  statuses: ReadonlyMap<string, string>;
+  runtime?: import("./runtime.ts").RuntimeSnapshot;
+  compaction?: import("./compaction.ts").CompactionSnapshot;
+}

package/src/usage.ts

@@ -0,0 +1,52 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { UsageTotals } from "./types.ts";
+
+export function emptyUsage(): UsageTotals { return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }; }
+const finite = (value: unknown): number => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+export function readUsage(value: unknown): UsageTotals {
+  if (!value || typeof value !== "object") return emptyUsage();
+  const usage = value as Record<string, unknown>;
+  const cost = usage.cost && typeof usage.cost === "object" ? (usage.cost as Record<string, unknown>).total : 0;
+  return { input: finite(usage.input), output: finite(usage.output), cacheRead: finite(usage.cacheRead), cacheWrite: finite(usage.cacheWrite), cost: finite(cost) };
+}
+export function entryUsage(entry: SessionEntry): UsageTotals {
+  if (entry.type === "usage" || entry.type === "compaction" || entry.type === "branch_summary") return readUsage(entry.usage);
+  if (entry.type === "message" && (entry.message.role === "assistant" || entry.message.role === "toolResult")) return readUsage(entry.message.usage);
+  return emptyUsage();
+}
+function add(target: UsageTotals, value: UsageTotals, sign = 1): void {
+  for (const key of Object.keys(target) as (keyof UsageTotals)[]) target[key] += sign * value[key];
+}
+function messageKey(message: AssistantMessage): string { return `${message.provider}/${message.model}/${message.timestamp}`; }
+
+/** Persisted totals plus one replaceable in-flight response, never summed per streaming event. */
+export class UsageCache {
+  private totals = emptyUsage();
+  private contributions = new Map<string, UsageTotals>();
+  private persistedMessages = new Set<string>();
+  private count = 0;
+  private live: AssistantMessage | undefined;
+  reset(): void {
+    this.totals = emptyUsage(); this.contributions.clear(); this.persistedMessages.clear(); this.count = 0; this.live = undefined;
+  }
+  update(entries: readonly SessionEntry[], rebuild = false): void {
+    if (rebuild || entries.length < this.count) this.reset();
+    // SessionManager appends immutable records; revisit the previous tail as a defensive measure.
+    for (const entry of entries.slice(Math.max(0, this.count - 1))) {
+      const previous = this.contributions.get(entry.id);
+      if (previous) add(this.totals, previous, -1);
+      const usage = entryUsage(entry);
+      add(this.totals, usage);
+      this.contributions.set(entry.id, usage);
+      if (entry.type === "message" && entry.message.role === "assistant") this.persistedMessages.add(messageKey(entry.message));
+    }
+    this.count = entries.length;
+  }
+  setLive(message: AssistantMessage | undefined): void { this.live = message; }
+  snapshot(): UsageTotals {
+    const total = { ...this.totals };
+    if (this.live && !this.persistedMessages.has(messageKey(this.live))) add(total, readUsage(this.live.usage));
+    return total;
+  }
+}