@ymys4ever/opencode-throughput-v2 4.0.1 → 4.0.2

package/dist/tui.js

@@ -0,0 +1,663 @@
+// src/tui.tsx
+import { Plugin } from "@opencode/plugin/tui";
+
+// src/core/step-tracker.ts
+function getModelKey(providerID, modelID) {
+  return `${providerID}/${modelID}`;
+}
+var ZERO_TOKENS = {
+  input: 0,
+  output: 0,
+  reasoning: 0,
+  cache: { read: 0, write: 0 }
+};
+function buildLogEntry(state, eventAt, terminal, recordedAt) {
+  const tokens = terminal.tokens ?? ZERO_TOKENS;
+  const latencyMs = eventAt - state.started;
+  const ttftMs = state.firstOutput != null ? state.firstOutput - state.started : null;
+  const genEnd = state.streamEnded ?? eventAt;
+  const genTimeMs = state.firstOutput != null ? genEnd - state.firstOutput : eventAt - state.started;
+  const tps = tokens.output > 0 && genTimeMs > 0 ? tokens.output / genTimeMs * 1000 : null;
+  return {
+    ts: new Date(recordedAt).toISOString(),
+    model: state.modelKey,
+    providerID: state.providerID,
+    modelID: state.modelID,
+    sessionID: terminal.sessionID,
+    messageID: terminal.assistantMessageID,
+    ttft_ms: ttftMs,
+    tps,
+    latency_ms: latencyMs,
+    inputTokens: tokens.input,
+    outputTokens: tokens.output,
+    reasoningTokens: tokens.reasoning,
+    cacheReadTokens: tokens.cache.read,
+    cacheWriteTokens: tokens.cache.write,
+    cost: terminal.cost ?? 0,
+    finish: terminal.finish ?? "error"
+  };
+}
+function buildAbortedEntry(state, assistantMessageID, now) {
+  return buildLogEntry(state, now, { sessionID: state.sessionID, assistantMessageID, finish: "aborted" }, now);
+}
+
+class StepTracker {
+  active = new Map;
+  parked = new Map;
+  activeTtlMs;
+  constructor(options = {}) {
+    const ttl = options.activeTtlMs ?? 600000;
+    this.activeTtlMs = ttl > 0 ? ttl : 0;
+  }
+  start(data) {
+    this.active.set(data.assistantMessageID, {
+      sessionID: data.sessionID,
+      started: data.started,
+      providerID: data.model.providerID,
+      modelID: data.model.id,
+      modelKey: getModelKey(data.model.providerID, data.model.id),
+      firstOutput: null,
+      streamEnded: null
+    });
+  }
+  markFirstOutput(assistantMessageID, created) {
+    const state = this.lookup(assistantMessageID);
+    if (state && state.firstOutput == null)
+      state.firstOutput = created;
+  }
+  markStreamed(assistantMessageID, created) {
+    const state = this.lookup(assistantMessageID);
+    if (state && state.streamEnded == null)
+      state.streamEnded = created;
+  }
+  settle(assistantMessageID, eventAt, terminal, recordedAt) {
+    const activeState = this.active.get(assistantMessageID);
+    if (activeState) {
+      this.active.delete(assistantMessageID);
+      return buildLogEntry(activeState, eventAt, terminal, recordedAt);
+    }
+    const parked = this.parked.get(assistantMessageID);
+    if (parked) {
+      this.parked.delete(assistantMessageID);
+      return buildLogEntry(parked.state, eventAt, terminal, recordedAt);
+    }
+    return null;
+  }
+  parkSession(sessionID, now, ttlMs) {
+    const deadline = now + ttlMs;
+    for (const [id, state] of this.active) {
+      if (state.sessionID === sessionID) {
+        this.parked.set(id, { state, deadline });
+        this.active.delete(id);
+      }
+    }
+  }
+  collectExpired(now) {
+    const expired = [];
+    for (const [id, parked] of this.parked) {
+      if (parked.deadline <= now) {
+        expired.push({ assistantMessageID: id, state: parked.state });
+        this.parked.delete(id);
+      }
+    }
+    if (this.activeTtlMs > 0) {
+      for (const [id, state] of this.active) {
+        if (now - state.started >= this.activeTtlMs) {
+          expired.push({ assistantMessageID: id, state });
+          this.active.delete(id);
+        }
+      }
+    }
+    return expired;
+  }
+  nextDeadline() {
+    let next = null;
+    const consider = (deadline) => {
+      if (next == null || deadline < next)
+        next = deadline;
+    };
+    for (const { deadline } of this.parked.values())
+      consider(deadline);
+    if (this.activeTtlMs > 0) {
+      for (const { started } of this.active.values())
+        consider(started + this.activeTtlMs);
+    }
+    return next;
+  }
+  get size() {
+    return this.active.size + this.parked.size;
+  }
+  lookup(assistantMessageID) {
+    return this.active.get(assistantMessageID) ?? this.parked.get(assistantMessageID)?.state;
+  }
+}
+
+// src/core/events.ts
+var SUBSCRIBED_EVENT_TYPES = [
+  "session.step.started",
+  "session.text.started",
+  "session.reasoning.started",
+  "session.step.streamed",
+  "session.step.ended",
+  "session.step.failed",
+  "session.idle"
+];
+function normalizeEvent(raw) {
+  if (typeof raw === "object" && raw != null && "type" in raw) {
+    const type = raw.type;
+    if (typeof type === "string" && SUBSCRIBED_EVENT_TYPES.includes(type)) {
+      return { ok: true, event: raw };
+    }
+  }
+  return { ok: false, reason: "unknown" };
+}
+function applyThroughputEvent(tracker, ev, deps) {
+  switch (ev.type) {
+    case "session.step.started":
+      tracker.start(ev.data);
+      return null;
+    case "session.text.started":
+    case "session.reasoning.started":
+      tracker.markFirstOutput(ev.data.assistantMessageID, ev.created);
+      return null;
+    case "session.step.streamed":
+      tracker.markStreamed(ev.data.assistantMessageID, ev.created);
+      return null;
+    case "session.step.ended":
+    case "session.step.failed":
+      return tracker.settle(ev.data.assistantMessageID, ev.created, ev.data, deps.recordedAt);
+    case "session.idle":
+      tracker.parkSession(ev.data.sessionID, ev.created, deps.abortTtlMs);
+      return null;
+  }
+  return null;
+}
+
+// src/runtime/pipeline.ts
+function makeSafeOnError(onError) {
+  return (e) => {
+    try {
+      onError(e);
+    } catch (reporterError) {
+      console.error(reporterError);
+    }
+  };
+}
+function createPipeline(deps) {
+  const timers = deps.timers ?? {
+    set: (cb, ms) => setTimeout(cb, ms),
+    clear: (h) => clearTimeout(h)
+  };
+  const safeOnError = makeSafeOnError(deps.onError);
+  const { tracker, now, abortTtlMs, onEntry } = deps;
+  let flushTimer = null;
+  let disposed = false;
+  function drainExpired() {
+    for (const { assistantMessageID, state } of tracker.collectExpired(now())) {
+      try {
+        onEntry(buildAbortedEntry(state, assistantMessageID, now()));
+      } catch (e) {
+        safeOnError(e);
+      }
+    }
+  }
+  function rearm() {
+    if (flushTimer != null)
+      timers.clear(flushTimer);
+    flushTimer = null;
+    if (disposed)
+      return;
+    const next = tracker.nextDeadline();
+    if (next == null)
+      return;
+    flushTimer = timers.set(() => {
+      flushTimer = null;
+      if (disposed)
+        return;
+      try {
+        drainExpired();
+      } catch (e) {
+        safeOnError(e);
+      } finally {
+        rearm();
+      }
+    }, Math.max(0, next - now()));
+  }
+  function dispatch(raw) {
+    if (disposed)
+      return;
+    let owned;
+    try {
+      owned = deps.owns(raw);
+    } catch (e) {
+      safeOnError(e);
+      return;
+    }
+    if (!owned)
+      return;
+    const n = normalizeEvent(raw);
+    if (!n.ok && n.reason === "malformed") {
+      safeOnError(new Error("throughput: malformed event rejected"));
+      return;
+    }
+    try {
+      if (n.ok) {
+        const recordedAt = now();
+        const entry = applyThroughputEvent(tracker, n.event, { recordedAt, abortTtlMs });
+        if (entry)
+          onEntry(entry);
+      }
+    } catch (e) {
+      safeOnError(e);
+    } finally {
+      drainExpired();
+      rearm();
+    }
+  }
+  function dispose() {
+    if (disposed)
+      return;
+    disposed = true;
+    if (flushTimer != null) {
+      timers.clear(flushTimer);
+      flushTimer = null;
+    }
+  }
+  return { dispatch, dispose };
+}
+
+// src/core/ownership.ts
+function makeOwns(selfDir) {
+  return (ev) => {
+    const dir = ev.location?.directory;
+    return dir == null || selfDir == null || dir === selfDir;
+  };
+}
+
+// src/core/stats.ts
+function aggregateAt(entries, now) {
+  const groups = new Map;
+  for (const entry of entries) {
+    let g = groups.get(entry.model);
+    if (!g) {
+      g = {
+        count: 0,
+        ttft: newMetricFold(),
+        tps: newMetricFold(),
+        latency: newMetricFold(),
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalReasoningTokens: 0,
+        totalCacheReadTokens: 0,
+        totalCacheWriteTokens: 0,
+        totalCost: 0
+      };
+      groups.set(entry.model, g);
+    }
+    g.count++;
+    if (entry.ttft_ms != null)
+      foldMetric(g.ttft, entry.ttft_ms);
+    if (entry.tps != null)
+      foldMetric(g.tps, entry.tps);
+    if (entry.latency_ms != null)
+      foldMetric(g.latency, entry.latency_ms);
+    g.totalInputTokens += entry.inputTokens;
+    g.totalOutputTokens += entry.outputTokens;
+    g.totalReasoningTokens += entry.reasoningTokens;
+    g.totalCacheReadTokens += entry.cacheReadTokens;
+    g.totalCacheWriteTokens += entry.cacheWriteTokens;
+    g.totalCost += entry.cost;
+  }
+  const result = new Map;
+  for (const [model, g] of groups) {
+    result.set(model, {
+      model,
+      count: g.count,
+      avgTTFT: metricAvg(g.ttft),
+      minTTFT: metricMin(g.ttft),
+      maxTTFT: metricMax(g.ttft),
+      avgTPS: metricAvg(g.tps),
+      maxTPS: metricMax(g.tps),
+      avgLatency: metricAvg(g.latency),
+      minLatency: metricMin(g.latency),
+      maxLatency: metricMax(g.latency),
+      totalInputTokens: g.totalInputTokens,
+      totalOutputTokens: g.totalOutputTokens,
+      totalReasoningTokens: g.totalReasoningTokens,
+      totalCacheReadTokens: g.totalCacheReadTokens,
+      totalCacheWriteTokens: g.totalCacheWriteTokens,
+      totalCost: g.totalCost,
+      lastUpdated: now
+    });
+  }
+  return result;
+}
+function newMetricFold() {
+  return { sum: 0, count: 0, min: Infinity, max: -Infinity };
+}
+function foldMetric(m, v) {
+  m.sum += v;
+  m.count++;
+  if (v < m.min)
+    m.min = v;
+  if (v > m.max)
+    m.max = v;
+}
+function metricAvg(m) {
+  return m.count > 0 ? m.sum / m.count : null;
+}
+function metricMin(m) {
+  return m.count > 0 ? m.min : null;
+}
+function metricMax(m) {
+  return m.count > 0 ? m.max : null;
+}
+
+// src/format/entry.ts
+function formatMs(ms) {
+  if (ms == null)
+    return "N/A";
+  if (ms >= 60000)
+    return (ms / 60000).toFixed(1) + "m";
+  if (ms >= 1000)
+    return (ms / 1000).toFixed(1) + "s";
+  return ms.toFixed(0) + "ms";
+}
+function formatTokenCount(n) {
+  if (n >= 1e6)
+    return (n / 1e6).toFixed(2) + "M";
+  if (n >= 1000)
+    return (n / 1000).toFixed(1) + "k";
+  return n.toFixed(n >= 100 ? 0 : 1);
+}
+function formatNum(n) {
+  if (n == null)
+    return "N/A";
+  return formatTokenCount(n);
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max - 1) + "…" : s;
+}
+function buildLogMsg(entry) {
+  const parts = [
+    truncate(entry.modelID, 28),
+    formatMs(entry.ttft_ms) + " TTFT",
+    formatNum(entry.tps) + " tok/s",
+    formatMs(entry.latency_ms),
+    "↑" + formatNum(entry.inputTokens) + " ↓" + formatNum(entry.outputTokens)
+  ];
+  return parts.join(" | ");
+}
+
+// src/ui/sidebar.ts
+function abbreviateModel(modelID) {
+  const tokens = modelID.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  const versionIndex = tokens.findIndex((token) => /\d/.test(token));
+  const provider = (tokens[0]?.[0] ?? "?").toLowerCase();
+  if (versionIndex < 0)
+    return (provider + (tokens[1]?.[0] ?? " ").toLowerCase() + " ").slice(0, 3).padEnd(3, " ");
+  const version = tokens[versionIndex].match(/\d/)?.[0] ?? " ";
+  const suffix = tokens.filter((token, index) => index !== 0 && index !== versionIndex && !/^\d+(?:\.\d+)*$/.test(token)).at(-1);
+  return `${provider}${version}${(suffix?.[0] ?? " ").toLowerCase()}`;
+}
+var COL_ID = 3;
+var COL_TIME = 4;
+var COL_TOKEN = 5;
+function buildDisplayIds(modelIDs) {
+  const taken = new Set;
+  const ids = new Map;
+  for (const modelID of modelIDs) {
+    if (ids.has(modelID))
+      continue;
+    const candidates = [abbreviateModel(modelID), modelID.slice(0, COL_ID + 1), modelID.slice(0, COL_TOKEN)];
+    let chosen = candidates[candidates.length - 1];
+    for (const candidate of candidates) {
+      if (!taken.has(candidate)) {
+        chosen = candidate;
+        break;
+      }
+    }
+    taken.add(chosen);
+    ids.set(modelID, chosen);
+  }
+  return ids;
+}
+function formatSidebarSeconds(ms) {
+  if (ms == null)
+    return " N/A";
+  return fitColumn4(ms / 1000);
+}
+function formatSidebarMetric(value) {
+  if (value == null)
+    return " N/A";
+  return fitColumn4(value);
+}
+function fitColumn4(value) {
+  const s = value.toFixed(1);
+  return s.length > COL_TIME ? value.toFixed(0) : s;
+}
+function formatSidebarTokens(value) {
+  value = Math.max(0, Math.round(value));
+  if (value < 1000)
+    return value.toFixed(1);
+  if (value < 99950)
+    return (value / 1000).toFixed(1) + "k";
+  if (value < 999500)
+    return (value / 1000).toFixed(0) + "k";
+  if (value < 99950000)
+    return (value / 1e6).toFixed(1) + "m";
+  if (value < 999500000)
+    return (value / 1e6).toFixed(0) + "m";
+  return "999m";
+}
+function formatSidebarRow(displayID, ttft, tps, latency, input, output) {
+  return `  ${displayID.padEnd(COL_ID)} ${formatSidebarSeconds(ttft).padStart(COL_TIME)} ${formatSidebarMetric(tps).padStart(COL_TIME)} ${formatSidebarSeconds(latency).padStart(COL_TIME)} ${formatSidebarTokens(input).padStart(COL_TOKEN)} ${formatSidebarTokens(output).padStart(COL_TOKEN)}`;
+}
+function formatSidebarHeader() {
+  return `  ${"ID".padEnd(COL_ID)} ${"TTFT".padStart(COL_TIME)} ${"TPS".padStart(COL_TIME)} ${"Lat".padStart(COL_TIME)} ${"↑In".padStart(COL_TOKEN)} ${"↓Out".padStart(COL_TOKEN)}`;
+}
+
+// src/tui/controller.ts
+var MAX_RECENT = 10;
+var BUFFER_CAP = 200;
+function createThroughputController(context, options = {}) {
+  const onError = options.onError ?? ((e) => console.error(e));
+  const now = options.now ?? Date.now;
+  const abortTtlMs = options.abortTtlMs ?? 5000;
+  const tracker = new StepTracker({ activeTtlMs: options.activeTtlMs });
+  const buffers = new Map;
+  const owns = makeOwns(context.location?.directory);
+  const initial = { open: true, recent: [], rows: [] };
+  let fallback = { ...initial };
+  const store = context.storage?.memory("opencode-throughput:tui", { initial });
+  if (store) {
+    try {
+      store[1]((draft) => {
+        draft.open = true;
+        draft.recent = [];
+        draft.rows = [];
+      });
+    } catch (e) {
+      onError(e);
+    }
+  }
+  const read = () => store ? store[0] : fallback;
+  const mutate = (fn) => {
+    if (store)
+      store[1](fn);
+    else
+      fn(fallback);
+    context.renderer?.requestRender();
+  };
+  function recomputeRows() {
+    const modelIDs = new Set;
+    for (const entries of buffers.values())
+      modelIDs.add(entries[entries.length - 1].modelID);
+    const displayIds = buildDisplayIds([...modelIDs]);
+    const rows = [];
+    for (const [modelKey, entries] of buffers) {
+      const stats = aggregateAt(entries, now()).get(modelKey);
+      if (!stats)
+        continue;
+      const modelID = entries[entries.length - 1].modelID;
+      rows.push({ stats, modelID, displayID: displayIds.get(modelID) });
+    }
+    return rows;
+  }
+  function showToast(entry) {
+    context.ui.toast.show({
+      title: "Throughput",
+      message: buildLogMsg(entry),
+      variant: entry.finish === "stop" || entry.finish === "aborted" ? "info" : "warning",
+      duration: 4000
+    });
+  }
+  function record(entry) {
+    const buffer = buffers.get(entry.model) ?? [];
+    buffer.push(entry);
+    if (buffer.length > BUFFER_CAP)
+      buffer.splice(0, buffer.length - BUFFER_CAP);
+    buffers.set(entry.model, buffer);
+    const rows = recomputeRows();
+    mutate((draft) => {
+      const next = [...draft.recent, entry];
+      draft.recent = next.length > MAX_RECENT ? next.slice(-MAX_RECENT) : next;
+      draft.rows = rows;
+    });
+    showToast(entry);
+  }
+  const pipeline = createPipeline({
+    tracker,
+    owns,
+    now,
+    abortTtlMs,
+    onEntry: record,
+    onError,
+    timers: {
+      set: (cb, ms) => setTimeout(cb, ms),
+      clear: (h) => clearTimeout(h)
+    }
+  });
+  const onSessionEvent = (ev) => pipeline.dispatch(ev);
+  const stops = SUBSCRIBED_EVENT_TYPES.map((t) => context.data.on(t, onSessionEvent));
+  function unsubscribe() {
+    pipeline.dispose();
+    for (const off of stops)
+      off();
+  }
+  return {
+    recent: () => read().recent,
+    statsRows: () => read().rows,
+    open: () => read().open,
+    toggleOpen: () => mutate((draft) => {
+      draft.open = !draft.open;
+    }),
+    unsubscribe
+  };
+}
+
+// src/ui/throughput-widget.tsx
+import { jsxDEV } from "@opentui/solid/jsx-dev-runtime";
+function ThroughputWidget(props) {
+  const fg = () => props.theme.text?.base;
+  const muted = () => props.theme.text?.muted;
+  const totalCount = () => props.stats().reduce((sum, row) => sum + row.stats.count, 0);
+  const displayIDFor = (modelID) => {
+    for (const row of props.stats()) {
+      if (row.modelID === modelID)
+        return row.displayID;
+    }
+    return abbreviateModel(modelID);
+  };
+  return /* @__PURE__ */ jsxDEV("box", {
+    children: [
+      /* @__PURE__ */ jsxDEV("box", {
+        flexDirection: "row",
+        gap: 1,
+        onMouseDown: () => totalCount() > 0 && props.onToggle(),
+        children: [
+          totalCount() > 0 ? /* @__PURE__ */ jsxDEV("text", {
+            fg: fg(),
+            children: props.open() ? "▼" : "▶"
+          }, undefined, false, undefined, this) : null,
+          /* @__PURE__ */ jsxDEV("text", {
+            fg: fg(),
+            children: /* @__PURE__ */ jsxDEV("b", {
+              children: "Throughput"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this),
+          totalCount() > 0 ? /* @__PURE__ */ jsxDEV("text", {
+            fg: muted(),
+            children: totalCount() + " reqs"
+          }, undefined, false, undefined, this) : null
+        ]
+      }, undefined, true, undefined, this),
+      totalCount() === 0 ? /* @__PURE__ */ jsxDEV("text", {
+        fg: muted(),
+        children: " Waiting for requests..."
+      }, undefined, false, undefined, this) : null,
+      props.open() && totalCount() > 0 ? /* @__PURE__ */ jsxDEV("box", {
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxDEV("text", {
+            fg: muted(),
+            children: formatSidebarHeader()
+          }, undefined, false, undefined, this),
+          props.stats().map((row) => /* @__PURE__ */ jsxDEV("text", {
+            fg: muted(),
+            children: formatSidebarRow(row.displayID, row.stats.avgTTFT, row.stats.avgTPS, row.stats.avgLatency, row.stats.totalInputTokens, row.stats.totalOutputTokens)
+          }, undefined, false, undefined, this)),
+          props.recent().length > 0 ? /* @__PURE__ */ jsxDEV("box", {
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsxDEV("text", {
+                fg: fg(),
+                children: [
+                  "  ",
+                  /* @__PURE__ */ jsxDEV("b", {
+                    children: "Recent"
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this),
+              props.recent().map((entry) => /* @__PURE__ */ jsxDEV("text", {
+                fg: muted(),
+                children: formatSidebarRow(displayIDFor(entry.modelID), entry.ttft_ms, entry.tps, entry.latency_ms, entry.inputTokens, entry.outputTokens)
+              }, undefined, false, undefined, this))
+            ]
+          }, undefined, true, undefined, this) : null
+        ]
+      }, undefined, true, undefined, this) : null
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/tui.tsx
+function createThroughputTuiPlugin(options = {}) {
+  return Plugin.define({
+    id: "opencode-throughput",
+    setup(context) {
+      const controller = createThroughputController(context, options);
+      const stopSlot = context.ui.slot({
+        append: "sidebar.content",
+        render: () => ThroughputWidget({
+          theme: context.theme,
+          recent: controller.recent,
+          stats: controller.statsRows,
+          open: controller.open,
+          onToggle: controller.toggleOpen
+        })
+      });
+      return () => {
+        stopSlot();
+        controller.unsubscribe();
+      };
+    }
+  });
+}
+var ThroughputTuiPlugin = createThroughputTuiPlugin();
+var tui_default = ThroughputTuiPlugin;
+export {
+  tui_default as default,
+  createThroughputTuiPlugin,
+  ThroughputTuiPlugin
+};

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@ymys4ever/opencode-throughput-v2",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "description": "Real-time LLM performance monitoring plugin for OpenCode V2. Tracks TTFT, TPS, latency, token usage and cost per model with toast notifications and JSONL logging.",
   "type": "module",
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
   "exports": {
-    ".": "./src/index.ts",
-    "./tui": "./src/tui.tsx"
+    ".": "./dist/index.js",
+    "./tui": "./dist/tui.js"
   },
   "files": [
-    "src"
+    "dist"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node --external @opencode/plugin --external effect",
+    "build": "bun build src/index.ts src/tui.tsx --outdir dist --target node --external @opencode/plugin --external \"@opencode/plugin/*\" --external effect --external @opentui/core --external \"@opentui/*\" --external solid-js",
     "prepublishOnly": "bun run build",
     "typecheck": "tsc --noEmit"
   },