pi-tps-meter 2.0.0 → 3.0.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-tps-meter
 
-Tokens per second meter for [pi CLI](https://pi.dev) with sparkline visualization.
+Tokens per second meter for [pi CLI](https://pi.dev) with sparkline trend visualization.
 
 ## Install
 
@@ -8,30 +8,31 @@ Tokens per second meter for [pi CLI](https://pi.dev) with sparkline visualizatio
 pi install npm:pi-tps-meter
 ```
 
-## Features
+## Display
 
-**During streaming** — live animated display:
+**Streaming** — live sparkline updates every 200ms:
 ```
-⠋ ▓▓▓▓▓▓░░░░ 42 tps
+⠹ ▁▂▃▅▇▆▅▃▂▁ 42 tps
 ```
 
-**After message** — aggregate stats:
+**Complete** — aggregate stats with trend:
 ```
-TPS: ▓▓▓▓ 42 | μ 39 | p95 61
+TPS ▁▂▃▅▇▆▅▃▂▁ 42 avg | μ 39 | p95 61
 ```
 
-**Color coding:**
+**Sparkline** uses Unicode block characters `▁▂▃▄▅▆▇█` — each char = one recent message's TPS. Left = oldest, right = newest. Color-coded by speed.
+
+**Colors:**
 - 🟢 Green: >50 tps (fast)
 - 🟡 Yellow: 20-50 tps (medium)
 - 🔴 Red: <20 tps (slow)
 
 ## Optimizations
 
-- Single shared timer (no per-event timers)
-- Fixed-size circular buffer (zero allocations in hot path)
+- Fixed ring buffers (zero allocations)
 - Bitwise token estimation
-- 200ms update throttle during streaming
-- Insertion sort for p95 (fast for ≤500 elements)
+- Single shared timer
+- Insertion sort for p95
 
 ## Author
 

package/extensions/tps-meter.ts

@@ -1,55 +1,60 @@
 /**
- * TPS Meter v2 — Tokens Per Second
+ * TPS Meter v3 — Tokens Per Second with Sparkline Trend
  *
  * Footer display:
- *   Streaming:  ⚡ ▓▓▓▓▓▓░░░░ 42 tps
- *   Complete:   TPS: ▓▓▓▓ 42 avg | μ 39 | p95 61
+ *   Streaming:  ⠹ ▁▂▃▅▇▆▅▃▂▁ 42 tps
+ *   Complete:   TPS ▁▂▃▅▇▆▅▃▂▁ 42 avg | μ 39 | p95 61
  *
  * Features:
- *   - Live sparkline bar during streaming (10-char width)
- *   - Color-coded: green (>50), yellow (20-50), red (<20)
+ *   - Real sparkline: ▁▂▃▄▅▆▇█ showing TPS trend over last 12 messages
+ *   - Color-coded sparkline by speed
+ *   - Animated spinner during streaming
  *   - Rolling 60s window for avg, all-time for μ and p95
- *   - Token estimate: chars / 4
  *
- * Resource optimization:
- *   - Single shared timer (no per-event timers)
- *   - Fixed-size circular buffer for window samples
- *   - Minimal allocations in hot path
- *   - Throttled updates: 200ms streaming, 0ms on finalize
+ * Optimizations:
+ *   - Fixed ring buffer (no allocations)
+ *   - Bitwise token estimation
+ *   - Single shared timer
+ *   - Insertion sort for p95
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 // --- Config ---
-const WINDOW_SIZE = 60; // max samples in rolling window
+const WINDOW_SIZE = 60;
 const WINDOW_MS = 60_000;
-const CHARS_PER_TOKEN = 4;
-const STREAM_INTERVAL_MS = 200; // update freq during streaming
-const SPARK_WIDTH = 10; // sparkline bar width
+const STREAM_INTERVAL_MS = 200;
+const SPARK_LEN = 12;
 const ALLTIME_CAP = 500;
-
-// --- Speed thresholds ---
 const FAST = 50;
 const MED = 20;
 
+// --- Sparkline chars (8 levels) ---
+const BLOCKS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+
 // --- State ---
 let streamStartMs = 0;
 let streamChars = 0;
 let streamTokens = 0;
-let lastTickMs = 0;
 let tickTimer: ReturnType<typeof setInterval> | null = null;
 let streaming = false;
 
-// Circular buffer for rolling window (fixed size, no allocations)
-const windowBuf = new Float64Array(WINDOW_SIZE * 2); // [tps, endMs] pairs
-let windowLen = 0;
-let windowHead = 0;
+// Rolling window (circular buffer)
+const winBuf = new Float64Array(WINDOW_SIZE * 2);
+let winLen = 0;
+let winHead = 0;
 
-// All-time stats (ring buffer)
-const allTimeBuf = new Float64Array(ALLTIME_CAP);
-let allTimeLen = 0;
-let allTimeHead = 0;
-let allTimeSum = 0;
+// All-time stats (circular buffer)
+const atBuf = new Float64Array(ALLTIME_CAP);
+let atLen = 0;
+let atHead = 0;
+let atSum = 0;
+
+// Sparkline history (ring buffer of TPS values, last N messages)
+const sparkBuf = new Float64Array(SPARK_LEN);
+let sparkLen = 0;
+let sparkHead = 0;
+let sparkMax = 1; // track max for normalization
 
 // --- Helpers ---
 
@@ -57,153 +62,158 @@ function now(): number {
   return Date.now();
 }
 
-function estimateTokens(chars: number): number {
-  return (chars >>> 2) + ((chars & 3) > 0 ? 1 : 0); // ceil(chars/4) via bit ops
+function tokEst(ch: number): number {
+  return (ch >>> 2) + ((ch & 3) > 0 ? 1 : 0);
 }
 
-// Circular buffer push
-function windowPush(tps: number, endMs: number): void {
-  const base = windowHead * 2;
-  windowBuf[base] = tps;
-  windowBuf[base + 1] = endMs;
-  windowHead = (windowHead + 1) % WINDOW_SIZE;
-  if (windowLen < WINDOW_SIZE) windowLen++;
+function winPush(tps: number, ms: number): void {
+  const b = winHead * 2;
+  winBuf[b] = tps;
+  winBuf[b + 1] = ms;
+  winHead = (winHead + 1) % WINDOW_SIZE;
+  if (winLen < WINDOW_SIZE) winLen++;
 }
 
-function allTimePush(tps: number): void {
-  allTimeSum += tps;
-  // Subtract old value if buffer is full
-  if (allTimeLen >= ALLTIME_CAP) {
-    allTimeSum -= allTimeBuf[allTimeHead];
-  }
-  allTimeBuf[allTimeHead] = tps;
-  allTimeHead = (allTimeHead + 1) % ALLTIME_CAP;
-  if (allTimeLen < ALLTIME_CAP) allTimeLen++;
+function atPush(tps: number): void {
+  atSum += tps;
+  if (atLen >= ALLTIME_CAP) atSum -= atBuf[atHead];
+  atBuf[atHead] = tps;
+  atHead = (atHead + 1) % ALLTIME_CAP;
+  if (atLen < ALLTIME_CAP) atLen++;
 }
 
-function rollingAvg(): number {
-  if (windowLen === 0) return 0;
+function sparkPush(tps: number): void {
+  sparkBuf[sparkHead] = tps;
+  sparkHead = (sparkHead + 1) % SPARK_LEN;
+  if (sparkLen < SPARK_LEN) sparkLen++;
+  if (tps > sparkMax) sparkMax = tps;
+  // Decay max slowly so sparkline adapts
+  if (sparkMax > 10) sparkMax *= 0.99;
+}
+
+function winAvg(): number {
+  if (winLen === 0) return 0;
   const cutoff = now() - WINDOW_MS;
-  let totalTokens = 0;
-  let firstMs = Infinity;
-  let lastMs = 0;
-  let count = 0;
-
-  // Walk circular buffer
-  const oldest = windowLen < WINDOW_SIZE ? 0 : windowHead;
-  for (let i = 0; i < windowLen; i++) {
+  let sum = 0;
+  let n = 0;
+  const oldest = winLen < WINDOW_SIZE ? 0 : winHead;
+  for (let i = 0; i < winLen; i++) {
     const idx = (oldest + i) % WINDOW_SIZE;
-    const base = idx * 2;
-    const endMs = windowBuf[base + 1];
-    if (endMs < cutoff) continue;
-    const tps = windowBuf[base];
-    // Estimate tokens from tps (we don't store tokens directly)
-    // Approximate: tps * timeBetweenSamples ≈ tokens
-    totalTokens += tps; // we'll divide by count for avg
-    if (endMs < firstMs) firstMs = endMs;
-    if (endMs > lastMs) lastMs = endMs;
-    count++;
+    const b = idx * 2;
+    if (winBuf[b + 1] < cutoff) continue;
+    sum += winBuf[b];
+    n++;
   }
-
-  if (count === 0) return 0;
-  // Return average TPS of recent samples
-  return totalTokens / count;
+  return n === 0 ? 0 : sum / n;
 }
 
-function allTimeMean(): number {
-  return allTimeLen === 0 ? 0 : allTimeSum / allTimeLen;
+function atMean(): number {
+  return atLen === 0 ? 0 : atSum / atLen;
 }
 
-function allTimeP95(): number {
-  if (allTimeLen === 0) return 0;
-
-  // Copy valid entries to temp array for sorting
-  const temp = new Float64Array(allTimeLen);
-  const oldest = allTimeLen < ALLTIME_CAP ? 0 : allTimeHead;
-  for (let i = 0; i < allTimeLen; i++) {
-    temp[i] = allTimeBuf[(oldest + i) % ALLTIME_CAP];
-  }
-
-  // Insertion sort (fast for small arrays)
-  for (let i = 1; i < temp.length; i++) {
-    const val = temp[i];
+function atP95(): number {
+  if (atLen === 0) return 0;
+  const tmp = new Float64Array(atLen);
+  const oldest = atLen < ALLTIME_CAP ? 0 : atHead;
+  for (let i = 0; i < atLen; i++) tmp[i] = atBuf[(oldest + i) % ALLTIME_CAP];
+  // Insertion sort
+  for (let i = 1; i < tmp.length; i++) {
+    const v = tmp[i];
     let j = i - 1;
-    while (j >= 0 && temp[j] > val) {
-      temp[j + 1] = temp[j];
+    while (j >= 0 && tmp[j] > v) {
+      tmp[j + 1] = tmp[j];
       j--;
     }
-    temp[j + 1] = val;
+    tmp[j + 1] = v;
   }
-
-  const idx = Math.ceil(temp.length * 0.95) - 1;
-  return temp[Math.max(0, idx)];
+  return tmp[Math.ceil(tmp.length * 0.95) - 1] || 0;
 }
 
 function fmt(v: number): string {
-  return v < 10 ? v.toFixed(1) : v < 100 ? v.toFixed(0) : `${Math.round(v)}`;
+  if (v < 10) return v.toFixed(1);
+  if (v < 100) return v.toFixed(0);
+  return `${Math.round(v)}`;
 }
 
-// Speed-based color
-function speedColor(tps: number, text: string, theme: any): string {
-  if (tps >= FAST) return theme.fg("success", text);
-  if (tps >= MED) return theme.fg("warning", text);
-  return theme.fg("error", text);
-}
+// --- Sparkline rendering ---
 
-// Sparkline bar: ▓ fast, ▒ medium, ░ slow
-function sparkBar(tps: number, theme: any): string {
-  if (tps <= 0) return theme.fg("dim", "░".repeat(SPARK_WIDTH));
-
-  // Map 0-100 tps to 0-10 width
-  const fill = Math.min(SPARK_WIDTH, Math.round((tps / 100) * SPARK_WIDTH));
-  const empty = SPARK_WIDTH - fill;
-
-  let bar = "";
-  if (tps >= FAST) {
-    bar = theme.fg("success", "▓".repeat(fill)) + theme.fg("dim", "░".repeat(empty));
-  } else if (tps >= MED) {
-    bar = theme.fg("warning", "▓".repeat(fill)) + theme.fg("dim", "░".repeat(empty));
-  } else {
-    bar = theme.fg("error", "▓".repeat(fill)) + theme.fg("dim", "░".repeat(empty));
+function sparkline(theme: any): string {
+  if (sparkLen === 0) return theme.fg("dim", "▁".repeat(SPARK_LEN));
+
+  // Read ring buffer in order (oldest first)
+  const vals = new Float64Array(SPARK_LEN);
+  const oldest = sparkLen < SPARK_LEN ? 0 : sparkHead;
+  for (let i = 0; i < sparkLen; i++) {
+    vals[i] = sparkBuf[(oldest + i) % SPARK_LEN];
+  }
+
+  // Normalize against local max
+  let localMax = 1;
+  for (let i = 0; i < sparkLen; i++) {
+    if (vals[i] > localMax) localMax = vals[i];
+  }
+  // Also consider historical max
+  if (sparkMax > localMax) localMax = sparkMax;
+
+  let result = "";
+  for (let i = 0; i < SPARK_LEN; i++) {
+    const v = vals[i];
+    const norm = Math.min(7, Math.round((v / localMax) * 7));
+    const ch = BLOCKS[norm];
+
+    // Color each block by speed
+    let colored: string;
+    if (v >= FAST) colored = theme.fg("success", ch);
+    else if (v >= MED) colored = theme.fg("warning", ch);
+    else colored = theme.fg("error", ch);
+
+    result += colored;
   }
-  return bar;
+  return result;
 }
 
-// Streaming spinner frames
+// --- Spinner ---
+
 const SPIN = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-let spinIdx = 0;
-function spinFrame(): string {
-  const s = SPIN[spinIdx];
-  spinIdx = (spinIdx + 1) % SPIN.length;
+let spinI = 0;
+function spin(): string {
+  const s = SPIN[spinI];
+  spinI = (spinI + 1) % SPIN.length;
   return s;
 }
 
-// --- Status rendering ---
+function speedColor(tps: number, text: string, theme: any): string {
+  if (tps >= FAST) return theme.fg("success", text);
+  if (tps >= MED) return theme.fg("warning", text);
+  return theme.fg("error", text);
+}
+
+// --- Rendering ---
 
-function renderStreaming(theme: any): string {
+function renderLive(theme: any): string {
   const elapsed = (now() - streamStartMs) / 1000;
   const tps = elapsed > 0.3 ? streamTokens / elapsed : 0;
-  const spin = spinFrame();
-  const bar = sparkBar(tps, theme);
+  const s = spin();
+  const sp = sparkline(theme);
   const num = speedColor(tps, `${fmt(tps)} tps`, theme);
-  return `${theme.fg("accent", spin)} ${bar} ${num}`;
+  return `${theme.fg("accent", s)} ${sp} ${num}`;
 }
 
-function renderComplete(theme: any): string {
-  const avg = rollingAvg();
-  const mu = allTimeMean();
-  const p95 = allTimeP95();
+function renderFinal(theme: any): string {
+  const avg = winAvg();
+  const mu = atMean();
+  const p95 = atP95();
   if (avg === 0 && mu === 0) return "";
 
-  const bar = sparkBar(avg, theme);
-  const avgStr = speedColor(avg, fmt(avg), theme);
-  const muStr = speedColor(mu, `μ ${fmt(mu)}`, theme);
-  const p95Str = speedColor(p95, `p95 ${fmt(p95)}`, theme);
+  const sp = sparkline(theme);
+  const a = speedColor(avg, fmt(avg), theme);
+  const m = speedColor(mu, `μ ${fmt(mu)}`, theme);
+  const p = speedColor(p95, `p95 ${fmt(p95)}`, theme);
 
-  return `TPS: ${bar} ${avgStr} | ${muStr} | ${p95Str}`;
+  return `TPS ${sp} ${a} avg | ${m} | ${p}`;
 }
 
-// --- Tick loop (single timer for all updates) ---
+// --- Single shared timer ---
 
 function startTick(ctx: any, theme: any): void {
   if (tickTimer) return;
@@ -212,7 +222,7 @@ function startTick(ctx: any, theme: any): void {
       stopTick();
       return;
     }
-    ctx.ui.setStatus("tps", renderStreaming(theme));
+    ctx.ui.setStatus("tps", renderLive(theme));
   }, STREAM_INTERVAL_MS);
 }
 
@@ -229,37 +239,29 @@ function stopTick(): void {
 
 export default function tpsMeter(pi: ExtensionAPI): void {
 
-  // New assistant message — start counting
   pi.on("message_start", async (event, ctx) => {
     if (event.message.role !== "assistant") return;
-
     streamStartMs = now();
     streamChars = 0;
     streamTokens = 0;
-    lastTickMs = 0;
     streaming = true;
-    spinIdx = 0;
-
+    spinI = 0;
     startTick(ctx, ctx.ui.theme);
   });
 
-  // Accumulate tokens from stream deltas
-  pi.on("message_update", async (event, ctx) => {
+  pi.on("message_update", async (event) => {
     if (event.message.role !== "assistant") return;
     if (!event.assistantMessageEvent) return;
-
     const evt = event.assistantMessageEvent;
     if (evt.type === "text_delta" || evt.type === "thinking_delta") {
-      const delta = evt.delta as string;
-      streamChars += delta.length;
-      streamTokens = estimateTokens(streamChars);
+      const d = evt.delta as string;
+      streamChars += d.length;
+      streamTokens = tokEst(streamChars);
     }
   });
 
-  // Message done — finalize stats
   pi.on("message_end", async (event, ctx) => {
     if (event.message.role !== "assistant") return;
-
     streaming = false;
     stopTick();
 
@@ -268,30 +270,30 @@ export default function tpsMeter(pi: ExtensionAPI): void {
 
     const tps = streamTokens / elapsed;
 
-    // Record to circular buffers
-    windowPush(tps, now());
-    allTimePush(tps);
+    // Record to all buffers
+    winPush(tps, now());
+    atPush(tps);
+    sparkPush(tps);
 
-    // Show final stats
-    const txt = renderComplete(ctx.ui.theme);
-    if (txt) {
-      ctx.ui.setStatus("tps", txt);
-    }
+    const txt = renderFinal(ctx.ui.theme);
+    if (txt) ctx.ui.setStatus("tps", txt);
   });
 
-  // Clear on session start
   pi.on("session_start", async (_event, ctx) => {
     streaming = false;
     stopTick();
     streamStartMs = 0;
     streamChars = 0;
     streamTokens = 0;
-    windowLen = 0;
-    windowHead = 0;
-    allTimeLen = 0;
-    allTimeHead = 0;
-    allTimeSum = 0;
-    spinIdx = 0;
+    winLen = 0;
+    winHead = 0;
+    atLen = 0;
+    atHead = 0;
+    atSum = 0;
+    sparkLen = 0;
+    sparkHead = 0;
+    sparkMax = 1;
+    spinI = 0;
     ctx.ui.setStatus("tps", undefined);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tps-meter",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Tokens per second meter for pi CLI — live TPS, rolling avg, mean, p95",
   "author": "Venkata Sai Chirasani",
   "license": "MIT",