@d3ara1n/pi-editor-shell 0.8.3 → 0.9.1

package/README.md

@@ -1,11 +1,13 @@
 # pi-editor-shell
 
+[![npm version](https://img.shields.io/npm/v/@d3ara1n/pi-editor-shell)](https://www.npmjs.com/package/@d3ara1n/pi-editor-shell) [![npm downloads](https://img.shields.io/npm/dm/@d3ara1n/pi-editor-shell)](https://www.npmjs.com/package/@d3ara1n/pi-editor-shell) [![license](https://img.shields.io/npm/l/@d3ara1n/pi-editor-shell)](https://www.npmjs.com/package/@d3ara1n/pi-editor-shell)
+
 Replaces pi's default editor and status bar with a unified rounded-corner shell drawn with box-drawing glyphs (`╭╮││╰╯`), with status info embedded in the border. The frame and spinner use only standard Unicode; the six border icons are Nerd Font glyphs (overridable — see [Configuration](#configuration)).
 
 ## What shows up where
 
 - **Top border** — `  model ·  thinking-level ` (left) + pinned extension statuses (right, via `pinnedStatus` config)
-- **Bottom border** — `  ctx NN%/NNk|N.NM · ⚡ cacheRead (total)  hitRate% ` (left) + `  ~/Projects (main +2 ~1 *4) ` (right, shows git branch plus staged, unstaged, and untracked file counts when in a repo). Session hit rate via `/editor-shell:status`.
+- **Bottom border** — `  ctx NN%/NNk|N.NM · ⚡ cacheRead (total)  hitRate% · NN.N t/s · $N.NNN ` (left) + `  ~/Projects (main +2 ~1 *4) ` (right, shows git branch plus staged, unstaged, and untracked file counts when in a repo). TPS is client-observed visible-text throughput for the latest reliable completed response: `(visible output tokens - 1) / (last text delta - first text delta)`, excluding time-to-first-token and provider-reported reasoning tokens. Responses containing tool calls, failed/aborted responses, samples below 10 visible tokens, and samples shorter than 250 ms do not replace the last valid TPS. Providers without a reasoning-token breakdown may still include hidden reasoning in the count. Session cost includes assistant, tool, compaction, and branch-summary usage; the dollar segment is hidden when the provider reports no priced usage. Session hit rate via `/editor-shell:status`.
 - **Below shell** — Auto-wrapping extension status line (all `setStatus` entries not pinned to the top)
 - **Border color** follows pi's thinking-level / bash-mode indicator automatically.
 
@@ -52,8 +54,8 @@ How the model is labeled in the top-left border (`"name"` by default):
 
 | Value | Example |
 |-------|---------|
-| `"name"` (default) | `Claude Opus 4.8 (Yanproxy)` |
-| `"provider-id"` | `yanproxy/anthropic/claude-opus-4-8` |
+| `"name"` (default) | `Claude Opus 4.8` |
+| `"provider-id"` | `anthropic/claude-opus-4-8` |
 
 `"name"` uses `model.name`; a model with no name falls back to its id, so the slot never goes blank.
 
@@ -61,7 +63,7 @@ How the model is labeled in the top-left border (`"name"` by default):
 
 | Command | Description |
 |---------|-------------|
-| `/editor-shell:status` | Show debug info: pinned config, all extension statuses with their keys, cache totals |
+| `/editor-shell:status` | Show debug info: pinned config, all extension statuses with their keys, cache totals, latest reliable visible-text TPS, and session cost |
 
 ## How it works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-editor-shell",
-  "version": "0.8.3",
+  "version": "0.9.1",
   "type": "module",
   "description": "Replaces pi's default editor and status bar with a unified rounded-corner shell embedding status info in the border",
   "keywords": [

package/src/index.ts

@@ -5,6 +5,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { CardEditor, type FrameProvider, type SpinnerPhase } from "./card-editor.ts";
 import { DEFAULT_CONFIG, loadEditorShellConfig, type EditorShellConfig, type EditorShellIcons } from "./config.ts";
+import { calculateVisibleTextTps } from "./tps.ts";
 
 /**
  * pi-editor-shell — Replaces pi's default editor and status bar with a
@@ -74,16 +75,24 @@ const DEFAULT_ICONS: EditorShellIcons = {
  *  full pi-ai message union tree. */
 interface UsageSnap {
   input?: number;
+  output?: number;
+  reasoning?: number;
   cacheRead?: number;
   cacheWrite?: number;
+  cost?: {
+    total?: number;
+  };
 }
 interface MsgSnap {
   role: string;
+  content?: Array<{ type: string }>;
   usage?: UsageSnap;
+  stopReason?: string;
 }
 interface EntrySnap {
   type: string;
   message?: MsgSnap;
+  usage?: UsageSnap;
 }
 
 /** Sum cache-related usage across all assistant messages on the session.
@@ -102,6 +111,25 @@ function sumSessionUsage(ctx: { sessionManager: { getEntries(): unknown[] } }):
   return { input, cacheRead, cacheWrite };
 }
 
+/** Sum billable usage across the full session, matching pi's built-in footer:
+ *  assistant responses, usage-bearing tool results, compactions, and branch
+ *  summaries. Providers without configured pricing report zero cost. */
+function sumSessionCost(ctx: { sessionManager: { getEntries(): unknown[] } }): number {
+  let total = 0;
+  for (const entry of ctx.sessionManager.getEntries()) {
+    const e = entry as EntrySnap;
+    let usage: UsageSnap | undefined;
+    if (e.type === "message" && (e.message?.role === "assistant" || e.message?.role === "toolResult")) {
+      usage = e.message.usage;
+    } else if (e.type === "compaction" || e.type === "branch_summary") {
+      usage = e.usage;
+    }
+    const cost = usage?.cost?.total;
+    if (typeof cost === "number" && Number.isFinite(cost)) total += cost;
+  }
+  return total;
+}
+
 /** Sum cache-read tokens across all assistant messages — session total for
  *  the "(14.0M)" display in the border. Kept separate from sumSessionUsage
  *  to keep the hot path (agent_end) minimal. */
@@ -260,13 +288,32 @@ export default function (pi: ExtensionAPI) {
   // entries every frame.
   let _cacheTotal = 0;
   let _latestUsage: UsageSnap | undefined;
+  // Latest reliable client-observed text throughput. TTFT is excluded; tool-call,
+  // failed, and statistically tiny responses do not replace the last valid sample.
+  // Persisted messages have no delta timestamps, so resumed sessions start empty.
+  let _firstTextDeltaAt: number | undefined;
+  let _lastTextDeltaAt: number | undefined;
+  let _latestTps: number | undefined;
+  // Full-session billable cost, including tool/summarization usage. Zero means the
+  // provider supplied no priced usage, so the border omits the dollar segment.
+  let _sessionCost = 0;
 
   // ── Phase-aware spinner + lifecycle ────────────────────────────
   // Each event asks the editor for a phase; CardEditor.setSpinner is itself
   // a same-phase no-op, so rapid event streams never reset the animation.
+  pi.on("message_start", (event) => {
+    if (event.message.role !== "assistant") return;
+    _firstTextDeltaAt = undefined;
+    _lastTextDeltaAt = undefined;
+  });
   pi.on("turn_start", () => editor?.setSpinner("thinking"));
   pi.on("message_update", (event) => {
     const t = event.assistantMessageEvent.type;
+    if (t === "text_delta") {
+      const now = performance.now();
+      _firstTextDeltaAt ??= now;
+      _lastTextDeltaAt = now;
+    }
     let next: SpinnerPhase;
     if (t.startsWith("thinking_")) next = "thinking";
     else if (t.startsWith("text_")) next = "outputting";
@@ -280,16 +327,44 @@ export default function (pi: ExtensionAPI) {
     // recompute here instead of on every render frame.
     _cacheTotal = sumCacheRead(ctx);
     _latestUsage = latestAssistantUsage(ctx);
+    _sessionCost = sumSessionCost(ctx);
     editor?.setSpinner(null);
   });
   pi.on("session_shutdown", () => {
+    _firstTextDeltaAt = undefined;
+    _lastTextDeltaAt = undefined;
+    _latestTps = undefined;
+    _sessionCost = 0;
     editor?.setSpinner(null);
     editor = undefined;
   });
+  pi.on("session_compact", (_event, ctx) => {
+    _sessionCost = sumSessionCost(ctx);
+    editor?.requestRender();
+  });
+  pi.on("session_tree", (_event, ctx) => {
+    _sessionCost = sumSessionCost(ctx);
+    editor?.requestRender();
+  });
 
   // Refresh git dirty after every agent turn (tools may have changed files).
   // Async — never blocks the event loop; re-renders once settled.
-  pi.on("turn_end", () => {
+  pi.on("turn_end", (event) => {
+    if (event.message.role === "assistant") {
+      const message = event.message as MsgSnap;
+      const sample = calculateVisibleTextTps({
+        outputTokens: message.usage?.output,
+        reasoningTokens: message.usage?.reasoning,
+        firstTextDeltaAt: _firstTextDeltaAt,
+        lastTextDeltaAt: _lastTextDeltaAt,
+        hasToolCall: message.content?.some((part) => part.type === "toolCall") ?? false,
+        stopReason: message.stopReason,
+      });
+      if (sample != null) _latestTps = sample;
+      _firstTextDeltaAt = undefined;
+      _lastTextDeltaAt = undefined;
+      editor?.requestRender();
+    }
     if (_cwd) refreshGitDirty(_cwd, () => editor?.requestRender());
   });
 
@@ -301,6 +376,10 @@ export default function (pi: ExtensionAPI) {
     icons = { ...DEFAULT_ICONS, ...config.icons };
     _cacheTotal = sumCacheRead(ctx);
     _latestUsage = latestAssistantUsage(ctx);
+    _firstTextDeltaAt = undefined;
+    _lastTextDeltaAt = undefined;
+    _latestTps = undefined;
+    _sessionCost = sumSessionCost(ctx);
     refreshGitDirty(ctx.cwd, () => editor?.requestRender());
 
     // Fresh segments on every render — reads live ctx state, so thinking /
@@ -348,6 +427,14 @@ export default function (pi: ExtensionAPI) {
         _cacheTotal > 0
           ? `${theme.fg("dim", " · ")}${theme.fg("warning", `${icons.cache} ${formatTokens(cacheReadNow)} (${formatTokens(_cacheTotal)})${hitRate != null ? ` ${icons.hitRate} ${hitRate.toFixed(1)}%` : ""}`)}`
           : "";
+      const tpsPart =
+        _latestTps != null
+          ? `${theme.fg("dim", " · ")}${theme.fg("warning", `${_latestTps.toFixed(1)} t/s`)}`
+          : "";
+      const costPart =
+        _sessionCost > 0
+          ? `${theme.fg("dim", " · ")}${theme.fg("warning", `$${_sessionCost.toFixed(3)}`)}`
+          : "";
 
       // Git branch + dirty state — pi's format: ~/Projects (main).
       const cwdText = formatCwd(ctx.cwd);
@@ -364,7 +451,7 @@ export default function (pi: ExtensionAPI) {
         topLeft: ` ${theme.fg("accent", `${icons.model} ${model}`)}${theme.fg("dim", " · ")}${theme.fg(thinkingColor, `${icons.thinking} ${thinking}`)} `,
         topRight: buildPinned(),
         // Context in severity color; cwd stays muted so it never competes.
-        bottomLeft: ` ${theme.fg(contextToken(pct), `${icons.context} ${ctxText}`)}${cachePart} `,
+        bottomLeft: ` ${theme.fg(contextToken(pct), `${icons.context} ${ctxText}`)}${cachePart}${tpsPart}${costPart} `,
         bottomRight: theme.fg("muted", ` ${cwdDisplay} `),
       };
     };
@@ -418,7 +505,7 @@ export default function (pi: ExtensionAPI) {
 
   // ── Debug command ──────────────────────────────────────────────
   pi.registerCommand("editor-shell:status", {
-    description: "Show editor-shell debug state: status keys, pinned config, cache totals",
+    description: "Show editor-shell debug state: status keys, performance, and usage totals",
     handler: async (_args, ctx) => {
       // Refresh git dirty first so the status output reflects the current
       // working tree — the event-driven cache is otherwise only updated at
@@ -459,6 +546,10 @@ export default function (pi: ExtensionAPI) {
       lines.push(`  session cacheWrite: ${formatTokens(sess.cacheWrite ?? 0)}`);
       const sRate = cacheHitRate(sess);
       lines.push(`  session hit rate: ${sRate != null ? `${sRate.toFixed(1)}%` : "n/a"}`);
+      const sessionCost = sumSessionCost(ctx);
+      _sessionCost = sessionCost;
+      lines.push(`  session cost: ${sessionCost > 0 ? `$${sessionCost.toFixed(3)}` : "n/a"}`);
+      lines.push(`  latest reliable text TPS: ${_latestTps != null ? `${_latestTps.toFixed(1)} t/s` : "n/a"}`);
       const latest = latestAssistantUsage(ctx);
       const now = latest?.cacheRead ?? 0;
       lines.push(`  this turn cacheRead: ${formatTokens(now)}`);

package/src/tps.test.ts

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { calculateVisibleTextTps, type VisibleTextTpsSample } from "./tps.ts";
+
+function sample(overrides: Partial<VisibleTextTpsSample> = {}): VisibleTextTpsSample {
+  return {
+    outputTokens: 51,
+    reasoningTokens: 10,
+    firstTextDeltaAt: 1_000,
+    lastTextDeltaAt: 5_000,
+    hasToolCall: false,
+    stopReason: "stop",
+    ...overrides,
+  };
+}
+
+test("calculates visible text TPS over inter-token intervals", () => {
+  assert.equal(calculateVisibleTextTps(sample()), 10);
+});
+
+test("uses all output tokens when the provider has no reasoning breakdown", () => {
+  assert.equal(calculateVisibleTextTps(sample({ reasoningTokens: undefined })), 12.5);
+});
+
+test("accepts the minimum reliable sample", () => {
+  assert.equal(
+    calculateVisibleTextTps(sample({
+      outputTokens: 10,
+      reasoningTokens: 0,
+      firstTextDeltaAt: 1_000,
+      lastTextDeltaAt: 1_250,
+    })),
+    36,
+  );
+});
+
+test("rejects responses containing tool calls", () => {
+  assert.equal(calculateVisibleTextTps(sample({ hasToolCall: true })), undefined);
+});
+
+test("rejects failed and aborted responses", () => {
+  assert.equal(calculateVisibleTextTps(sample({ stopReason: "error" })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ stopReason: "aborted" })), undefined);
+});
+
+test("rejects samples with too few visible tokens", () => {
+  assert.equal(
+    calculateVisibleTextTps(sample({ outputTokens: 18, reasoningTokens: 9 })),
+    undefined,
+  );
+});
+
+test("rejects samples shorter than 250 ms", () => {
+  assert.equal(
+    calculateVisibleTextTps(sample({ firstTextDeltaAt: 1_000, lastTextDeltaAt: 1_249 })),
+    undefined,
+  );
+});
+
+test("rejects missing or invalid usage and timing data", () => {
+  assert.equal(calculateVisibleTextTps(sample({ outputTokens: undefined })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ firstTextDeltaAt: undefined })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ lastTextDeltaAt: undefined })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ reasoningTokens: -1 })), undefined);
+  assert.equal(calculateVisibleTextTps(sample({ lastTextDeltaAt: Number.NaN })), undefined);
+});

package/src/tps.ts

@@ -0,0 +1,53 @@
+const MIN_VISIBLE_TOKENS = 10;
+const MIN_SAMPLE_DURATION_MS = 250;
+
+/** @internal — exported for focused throughput tests. */
+export interface VisibleTextTpsSample {
+  outputTokens?: number;
+  reasoningTokens?: number;
+  firstTextDeltaAt?: number;
+  lastTextDeltaAt?: number;
+  hasToolCall: boolean;
+  stopReason?: string;
+}
+
+/**
+ * Calculate client-observed visible-text throughput for one completed response.
+ *
+ * The provider's reasoning count is removed when available because its tokens may
+ * be generated before the first visible delta. Tool-call responses are excluded:
+ * providers do not expose a portable split between text and serialized tool tokens.
+ *
+ * @internal — exported for focused throughput tests.
+ */
+export function calculateVisibleTextTps(sample: VisibleTextTpsSample): number | undefined {
+  if (sample.hasToolCall || sample.stopReason === "error" || sample.stopReason === "aborted") {
+    return undefined;
+  }
+
+  const output = sample.outputTokens;
+  const reasoning = sample.reasoningTokens ?? 0;
+  const first = sample.firstTextDeltaAt;
+  const last = sample.lastTextDeltaAt;
+  if (
+    output == null ||
+    !Number.isFinite(output) ||
+    !Number.isFinite(reasoning) ||
+    reasoning < 0 ||
+    first == null ||
+    last == null ||
+    !Number.isFinite(first) ||
+    !Number.isFinite(last)
+  ) {
+    return undefined;
+  }
+
+  const visibleTokens = output - reasoning;
+  const elapsedMs = last - first;
+  if (visibleTokens < MIN_VISIBLE_TOKENS || elapsedMs < MIN_SAMPLE_DURATION_MS) {
+    return undefined;
+  }
+
+  // N received tokens span N - 1 inter-token intervals once TTFT is excluded.
+  return (visibleTokens - 1) / (elapsedMs / 1000);
+}