@ymys4ever/opencode-throughput-v2 4.0.0 → 4.0.2

package/src/types.ts

@@ -1,44 +0,0 @@
-/** frozen on-disk JSONL schema, never rename fields */
-export type LogEntry = {
-  ts: string
-  /** composite key: providerID/modelID (frozen) */
-  model: string
-  providerID: string
-  modelID: string
-  sessionID: string
-  messageID: string
-  ttft_ms: number | null
-  tps: number | null
-  latency_ms: number | null
-  inputTokens: number
-  outputTokens: number
-  reasoningTokens: number
-  cacheReadTokens: number
-  cacheWriteTokens: number
-  cost: number
-  finish: string
-}
-
-/**
- * Aggregated per-model statistics. Metric fields (avg/min/max/maxTPS) are null
- * when no entry provided a valid sample; total* fields are plain sums, count counts every entry.
- */
-export type ModelStats = {
-  model: string
-  count: number
-  avgTTFT: number | null
-  avgTPS: number | null
-  avgLatency: number | null
-  minTTFT: number | null
-  maxTTFT: number | null
-  minLatency: number | null
-  maxLatency: number | null
-  maxTPS: number | null
-  totalInputTokens: number
-  totalOutputTokens: number
-  totalReasoningTokens: number
-  totalCacheReadTokens: number
-  totalCacheWriteTokens: number
-  totalCost: number
-  lastUpdated: number
-}

package/src/ui/sidebar.ts

@@ -1,90 +0,0 @@
-import type { ModelStats } from "../types.js"
-
-/** Three-column model key: provider initial, first version digit, final non-version token initial. */
-export function abbreviateModel(modelID: string): string {
-  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()}`
-}
-
-/** Sidebar column widths shared by the header and every data row. */
-const COL_ID = 3
-const COL_TIME = 4
-const COL_TOKEN = 5
-
-/**
- * Collision-aware display IDs: the first model keeps the 3-char
- * abbreviateModel form; later colliders widen to 4 then 5 chars of
- * modelID until unique (a still-colliding 5-char form is kept as-is,
- * never widened further). Deterministic for a given input sequence:
- * first-seen order wins, so existing IDs stay stable as new models appear.
- */
-export function buildDisplayIds(modelIDs: readonly string[]): Map<string, string> {
-  const taken = new Set<string>()
-  const ids = new Map<string, string>()
-  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
-}
-
-/** One sidebar stats row: aggregated metrics plus the structured display modelID
- *  and its collision-aware display ID (see buildDisplayIds). */
-export type StatsRow = { stats: ModelStats; modelID: string; displayID: string }
-
-/** Sidebar duration in seconds: compact precision without a unit suffix. */
-export function formatSidebarSeconds(ms: number | null): string {
-  if (ms == null) return " N/A"
-  return fitColumn4(ms / 1000)
-}
-
-/** Sidebar metric without a unit suffix, fitted to a 4-char column. */
-export function formatSidebarMetric(value: number | null): string {
-  if (value == null) return " N/A"
-  return fitColumn4(value)
-}
-
-/** Fit into 4 chars: one decimal (xxx.x), else the integer as-is. A 5-digit integer overflows by design rather than losing digits. */
-function fitColumn4(value: number): string {
-  const s = value.toFixed(1)
-  return s.length > COL_TIME ? value.toFixed(0) : s
-}
-
-/**
- * Sidebar token volume in a 5-char column: the unit (none / k / m) is
- * chosen so the numeric part always fits with rounding-safe boundaries.
- * @param value non-negative token count (clamped)
- */
-export function formatSidebarTokens(value: number): string {
-  value = Math.max(0, Math.round(value))
-  if (value < 1_000) return value.toFixed(1) // "892.0"
-  if (value < 99_950) return (value / 1e3).toFixed(1) + "k" // "1.0k".."99.9k"
-  if (value < 999_500) return (value / 1e3).toFixed(0) + "k" // "100k".."999k"
-  if (value < 99_950_000) return (value / 1e6).toFixed(1) + "m" // "1.0m".."99.9m"
-  if (value < 999_500_000) return (value / 1e6).toFixed(0) + "m"
-  return "999m" // cap
-}
-
-/** Sidebar data row; `displayID` is a collision-aware display ID from buildDisplayIds (3-5 chars, rendered as-is). */
-export function formatSidebarRow(displayID: string, ttft: number | null, tps: number | null, latency: number | null, input: number, output: number): string {
-  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)}`
-}
-
-/** Sidebar header sharing the exact column layout of formatSidebarRow. */
-export function formatSidebarHeader(): string {
-  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)}`
-}

package/src/ui/throughput-widget.tsx

@@ -1,95 +0,0 @@
-import { abbreviateModel, formatSidebarHeader, formatSidebarRow } from "./sidebar.js"
-import type { LogEntry } from "../types.js"
-import type { StatsRow } from "./sidebar.js"
-
-// Structural subset of ResolvedTheme from @opencode/theme/tui; kept local so
-// the TUI entry does not need a direct @opencode/theme dependency.
-export type ThemeTokens = {
-  readonly text?: {
-    readonly base?: string | undefined
-    readonly muted?: string | undefined
-  }
-}
-
-// Plain JSX expressions only — plugin-local solid may not notify the renderer (see tui/controller.ts header).
-export function ThroughputWidget(props: {
-  readonly theme: ThemeTokens
-  readonly recent: () => LogEntry[]
-  readonly stats: () => StatsRow[]
-  readonly open: () => boolean
-  readonly onToggle: () => void
-}) {
-  const fg = () => props.theme.text?.base
-  const muted = () => props.theme.text?.muted
-  const totalCount = () => props.stats().reduce((sum, row) => sum + row.stats.count, 0)
-
-  // Same-screen consistency: recent rows resolve their display ID through
-  // the stats rows (built from the controller's collision-aware map), so a
-  // widened collider renders identically in both sections.
-  const displayIDFor = (modelID: string): string => {
-    for (const row of props.stats()) {
-      if (row.modelID === modelID) return row.displayID
-    }
-    // Every recorded model has a row; this fallback only guards hostless
-    // edge cases and keeps the plain 3-char abbreviation.
-    return abbreviateModel(modelID)
-  }
-
-  return (
-    <box>
-      <box
-        flexDirection="row"
-        gap={1}
-        onMouseDown={() => totalCount() > 0 && props.onToggle()}
-      >
-        {totalCount() > 0 ? <text fg={fg()}>{props.open() ? "▼" : "▶"}</text> : null}
-        <text fg={fg()}>
-          <b>Throughput</b>
-        </text>
-        {totalCount() > 0 ? (
-          <text fg={muted()}>{totalCount() + " reqs"}</text>
-        ) : null}
-      </box>
-      {totalCount() === 0 ? (
-        <text fg={muted()}>{" Waiting for requests..."}</text>
-      ) : null}
-      {props.open() && totalCount() > 0 ? (
-        <box flexDirection="column">
-          <text fg={muted()}>{formatSidebarHeader()}</text>
-          {props.stats().map((row) => (
-            <text fg={muted()}>
-              {formatSidebarRow(
-                row.displayID,
-                row.stats.avgTTFT,
-                row.stats.avgTPS,
-                row.stats.avgLatency,
-                row.stats.totalInputTokens,
-                row.stats.totalOutputTokens,
-              )}
-            </text>
-          ))}
-          {props.recent().length > 0 ? (
-            <box flexDirection="column">
-              <text fg={fg()}>
-                {"  "}
-                <b>Recent</b>
-              </text>
-              {props.recent().map((entry: LogEntry) => (
-                <text fg={muted()}>
-                  {formatSidebarRow(
-                    displayIDFor(entry.modelID),
-                    entry.ttft_ms,
-                    entry.tps,
-                    entry.latency_ms,
-                    entry.inputTokens,
-                    entry.outputTokens,
-                  )}
-                </text>
-              ))}
-            </box>
-          ) : null}
-        </box>
-      ) : null}
-    </box>
-  )
-}