opencode-extended-sidebar 0.2.90 → 0.2.91

package/src/pware.oc.perf/pware.oc.perf.realtime.ts

@@ -1,88 +1,88 @@
-/**
- * pware.oc.perf.realtime
- *
- * Real-time metric samples from the live stream. One `StatRealtimeSnapshot`
- * carries the leaf series for every category the OES realtime chart renders
- * (Tokens / Cache / CPU·RAM / Network); sums are derived via `sumSeries`.
- * `StatRealtimeSnapshotHistory` is that sample retained in the rolling RAM
- * history (see `pware.oc.perf.realtimeTimeline.ts`). Pure and host-free.
- */
-import { REALTIME_WINDOW_MS } from "../pware.oc.core/pware.oc.core.timing.js"
-
-/** Token series — tok/s. `out` is visible output; `reasoning` is hidden thinking. */
-export type StatRealtimeTokensSeries = {
-  in: number | null
-  out: number | null
-  reasoning: number | null
-}
-
-/** Token-cache series — tok/s served from / written to cache. */
-export type StatRealtimeCacheSeries = {
-  read: number | null
-  write: number | null
-}
-
-/** CPU/RAM series — cpu as %, ram as MB. */
-export type StatRealtimeCpuRamSeries = {
-  cpu: number | null
-  ram: number | null
-}
-
-/**
- * Network series — kbit/s, estimated from the token flow (≈ `NETWORK_BYTES_PER_TOKEN`
- * per token), not a real socket meter (model traffic lives in the server process).
- * Network convention: `in` is data the machine receives (model output + reasoning),
- * `out` is data the machine sends (input + cache). Null when idle.
- */
-export type StatRealtimeNetworkSeries = {
-  in: number | null
-  out: number | null
-}
-
-/** Rough bytes-per-token used to turn a token rate into a kbit/s estimate. */
-export const NETWORK_BYTES_PER_TOKEN = 4
-
-/** Token rate (tok/s) → kbit/s at `NETWORK_BYTES_PER_TOKEN`. Null stays null. */
-export function tokenRateToKbit(tokPerSec: number | null): number | null {
-  if (tokPerSec == null) return null
-  return (tokPerSec * NETWORK_BYTES_PER_TOKEN * 8) / 1000
-}
-
-/** One point-in-time realtime sample across all categories. Rates are null when idle. */
-export type StatRealtimeSnapshot = {
-  at: number
-  tokens: StatRealtimeTokensSeries
-  cache: StatRealtimeCacheSeries
-  cpuRam: StatRealtimeCpuRamSeries
-  network: StatRealtimeNetworkSeries
-}
-
-/** A realtime sample retained in the rolling history — the same shape as a snapshot. */
-export type StatRealtimeSnapshotHistory = StatRealtimeSnapshot
-
-/** Sum two nullable rates: null only when both are null. */
-export function sumSeries(a: number | null, b: number | null): number | null {
-  if (a == null && b == null) return null
-  return (a ?? 0) + (b ?? 0)
-}
-
-/** An idle sample at `at` — every series null. */
-export function emptyStatRealtimeSnapshot(at = Date.now()): StatRealtimeSnapshot {
-  return {
-    at,
-    tokens: { in: null, out: null, reasoning: null },
-    cache: { read: null, write: null },
-    cpuRam: { cpu: null, ram: null },
-    network: { in: null, out: null },
-  }
-}
-
-/** Append a sample and drop entries older than the window (immutable). */
-export function pushStatRealtimeHistory(
-  history: readonly StatRealtimeSnapshotHistory[],
-  snapshot: StatRealtimeSnapshotHistory,
-  windowMs = REALTIME_WINDOW_MS,
-): StatRealtimeSnapshotHistory[] {
-  const next = [...history, snapshot]
-  return next.filter((s) => snapshot.at - s.at <= windowMs)
-}
+/**
+ * pware.oc.perf.realtime
+ *
+ * Real-time metric samples from the live stream. One `StatRealtimeSnapshot`
+ * carries the leaf series for every category the OES realtime chart renders
+ * (Tokens / Cache / CPU·RAM / Network); sums are derived via `sumSeries`.
+ * `StatRealtimeSnapshotHistory` is that sample retained in the rolling RAM
+ * history (see `pware.oc.perf.realtimeTimeline.ts`). Pure and host-free.
+ */
+import { REALTIME_WINDOW_MS } from "../pware.oc.core/pware.oc.core.timing.js"
+
+/** Token series — tok/s. `out` is visible output; `reasoning` is hidden thinking. */
+export type StatRealtimeTokensSeries = {
+  in: number | null
+  out: number | null
+  reasoning: number | null
+}
+
+/** Token-cache series — tok/s served from / written to cache. */
+export type StatRealtimeCacheSeries = {
+  read: number | null
+  write: number | null
+}
+
+/** CPU/RAM series — cpu as %, ram as MB. */
+export type StatRealtimeCpuRamSeries = {
+  cpu: number | null
+  ram: number | null
+}
+
+/**
+ * Network series — kbit/s, estimated from the token flow (≈ `NETWORK_BYTES_PER_TOKEN`
+ * per token), not a real socket meter (model traffic lives in the server process).
+ * Network convention: `in` is data the machine receives (model output + reasoning),
+ * `out` is data the machine sends (input + cache). Null when idle.
+ */
+export type StatRealtimeNetworkSeries = {
+  in: number | null
+  out: number | null
+}
+
+/** Rough bytes-per-token used to turn a token rate into a kbit/s estimate. */
+export const NETWORK_BYTES_PER_TOKEN = 4
+
+/** Token rate (tok/s) → kbit/s at `NETWORK_BYTES_PER_TOKEN`. Null stays null. */
+export function tokenRateToKbit(tokPerSec: number | null): number | null {
+  if (tokPerSec == null) return null
+  return (tokPerSec * NETWORK_BYTES_PER_TOKEN * 8) / 1000
+}
+
+/** One point-in-time realtime sample across all categories. Rates are null when idle. */
+export type StatRealtimeSnapshot = {
+  at: number
+  tokens: StatRealtimeTokensSeries
+  cache: StatRealtimeCacheSeries
+  cpuRam: StatRealtimeCpuRamSeries
+  network: StatRealtimeNetworkSeries
+}
+
+/** A realtime sample retained in the rolling history — the same shape as a snapshot. */
+export type StatRealtimeSnapshotHistory = StatRealtimeSnapshot
+
+/** Sum two nullable rates: null only when both are null. */
+export function sumSeries(a: number | null, b: number | null): number | null {
+  if (a == null && b == null) return null
+  return (a ?? 0) + (b ?? 0)
+}
+
+/** An idle sample at `at` — every series null. */
+export function emptyStatRealtimeSnapshot(at = Date.now()): StatRealtimeSnapshot {
+  return {
+    at,
+    tokens: { in: null, out: null, reasoning: null },
+    cache: { read: null, write: null },
+    cpuRam: { cpu: null, ram: null },
+    network: { in: null, out: null },
+  }
+}
+
+/** Append a sample and drop entries older than the window (immutable). */
+export function pushStatRealtimeHistory(
+  history: readonly StatRealtimeSnapshotHistory[],
+  snapshot: StatRealtimeSnapshotHistory,
+  windowMs = REALTIME_WINDOW_MS,
+): StatRealtimeSnapshotHistory[] {
+  const next = [...history, snapshot]
+  return next.filter((s) => snapshot.at - s.at <= windowMs)
+}

package/src/pware.oc.perf/pware.oc.perf.realtimeBlock.ts

@@ -1,118 +1,118 @@
-/**
- * pware.oc.perf.realtimeBlock
- *
- * The static definition of the OES realtime widget: which category tabs exist,
- * which selector rows each tab offers, and how each row reads its series from a
- * `StatRealtimeSnapshot`. This is a pure, host-free model — the TUI layer
- * renders it and owns the runtime state (active tab, fullscreen).
- */
-import { sumSeries, type StatRealtimeSnapshot, type StatRealtimeSnapshotHistory } from "./pware.oc.perf.realtime.js"
-
-/** A selector row's series key — unique within its tab. */
-export type StatRealtimeSeriesKey =
-  | "avg"
-  | "sum"
-  | "in"
-  | "out"
-  | "reasoning"
-  | "read"
-  | "write"
-  | "cpu"
-  | "ram"
-  | "tok/s"
-
-/** One selector row: its key, label, unit, and how to read the series from a sample. */
-export type StatRealtimeRowTab = {
-  key: StatRealtimeSeriesKey
-  label: string
-  unit: string
-  read: (snap: StatRealtimeSnapshot) => number | null
-}
-
-/** A category tab id. */
-export type StatRealtimeTabId = "tokens" | "cache" | "cpu-ram" | "network"
-/** One category tab: its id, label, unit, and selector rows. */
-export type StatRealtimeTab = {
-  id: StatRealtimeTabId
-  label: string
-  unit: string
-  rows: readonly StatRealtimeRowTab[]
-}
-
-/** The whole realtime widget definition: the tabs the selector offers. */
-export type StatRealtimeBlock = {
-  tabs: readonly StatRealtimeTab[]
-}
-
-/** Extract one selector row's series across history as a chartable `number[]` (null → 0). */
-export function seriesValues(
-  history: readonly StatRealtimeSnapshotHistory[],
-  read: (snap: StatRealtimeSnapshot) => number | null,
-): number[] {
-  return history.map((s) => read(s) ?? 0)
-}
-
-/** The tab for `id`, or the first tab if `id` is unknown. */
-export function realtimeTab(
-  tabs: readonly StatRealtimeTab[],
-  id: StatRealtimeTabId,
-): StatRealtimeTab {
-  return tabs.find((t) => t.id === id) ?? tabs[0]!
-}
-
-/** The selector row for `key` on `tab`, or the tab's first row if `key` is missing. */
-export function realtimeRow(
-  tab: StatRealtimeTab,
-  key: StatRealtimeSeriesKey,
-): StatRealtimeRowTab {
-  return tab.rows.find((r) => r.key === key) ?? tab.rows[0]!
-}
-
-/** The default OES realtime block. Network is estimated from the token flow (kbit/s). */
-export const STAT_REALTIME_BLOCK: StatRealtimeBlock = {
-  tabs: [
-    {
-      id: "tokens",
-      label: "Tok",
-      unit: "tok/s",
-      rows: [
-        // avg is the OES bar's old live reading — the chart smooths this series.
-        { key: "avg", label: "avg", unit: "tok/s", read: (s) => sumSeries(s.tokens.in, s.tokens.out) },
-        { key: "sum", label: "sum", unit: "tok/s", read: (s) => sumSeries(s.tokens.in, s.tokens.out) },
-        { key: "in", label: "in", unit: "tok/s", read: (s) => s.tokens.in },
-        { key: "out", label: "out", unit: "tok/s", read: (s) => s.tokens.out },
-        // tok/s duplicates sum (in+out) — kept as the bar's old label per UX.
-        { key: "tok/s", label: "tok/s", unit: "tok/s", read: (s) => sumSeries(s.tokens.in, s.tokens.out) },
-      ],
-    },
-    {
-      id: "cache",
-      label: "Cache",
-      unit: "tok/s",
-      rows: [
-        { key: "sum", label: "sum", unit: "tok/s", read: (s) => sumSeries(s.cache.read, s.cache.write) },
-        { key: "read", label: "read", unit: "tok/s", read: (s) => s.cache.read },
-        { key: "write", label: "write", unit: "tok/s", read: (s) => s.cache.write },
-      ],
-    },
-    {
-      id: "cpu-ram",
-      label: "Proc",
-      unit: "%/MB",
-      rows: [
-        { key: "cpu", label: "cpu", unit: "%", read: (s) => s.cpuRam.cpu },
-        { key: "ram", label: "ram", unit: "MB", read: (s) => s.cpuRam.ram },
-      ],
-    },
-    {
-      id: "network",
-      label: "Net",
-      unit: "kbit/s",
-      rows: [
-        { key: "in", label: "in", unit: "kbit/s", read: (s) => s.network.in },
-        { key: "out", label: "out", unit: "kbit/s", read: (s) => s.network.out },
-        { key: "sum", label: "sum", unit: "kbit/s", read: (s) => sumSeries(s.network.in, s.network.out) },
-      ],
-    },
-  ],
-}
+/**
+ * pware.oc.perf.realtimeBlock
+ *
+ * The static definition of the OES realtime widget: which category tabs exist,
+ * which selector rows each tab offers, and how each row reads its series from a
+ * `StatRealtimeSnapshot`. This is a pure, host-free model — the TUI layer
+ * renders it and owns the runtime state (active tab, fullscreen).
+ */
+import { sumSeries, type StatRealtimeSnapshot, type StatRealtimeSnapshotHistory } from "./pware.oc.perf.realtime.js"
+
+/** A selector row's series key — unique within its tab. */
+export type StatRealtimeSeriesKey =
+  | "avg"
+  | "sum"
+  | "in"
+  | "out"
+  | "reasoning"
+  | "read"
+  | "write"
+  | "cpu"
+  | "ram"
+  | "tok/s"
+
+/** One selector row: its key, label, unit, and how to read the series from a sample. */
+export type StatRealtimeRowTab = {
+  key: StatRealtimeSeriesKey
+  label: string
+  unit: string
+  read: (snap: StatRealtimeSnapshot) => number | null
+}
+
+/** A category tab id. */
+export type StatRealtimeTabId = "tokens" | "cache" | "cpu-ram" | "network"
+/** One category tab: its id, label, unit, and selector rows. */
+export type StatRealtimeTab = {
+  id: StatRealtimeTabId
+  label: string
+  unit: string
+  rows: readonly StatRealtimeRowTab[]
+}
+
+/** The whole realtime widget definition: the tabs the selector offers. */
+export type StatRealtimeBlock = {
+  tabs: readonly StatRealtimeTab[]
+}
+
+/** Extract one selector row's series across history as a chartable `number[]` (null → 0). */
+export function seriesValues(
+  history: readonly StatRealtimeSnapshotHistory[],
+  read: (snap: StatRealtimeSnapshot) => number | null,
+): number[] {
+  return history.map((s) => read(s) ?? 0)
+}
+
+/** The tab for `id`, or the first tab if `id` is unknown. */
+export function realtimeTab(
+  tabs: readonly StatRealtimeTab[],
+  id: StatRealtimeTabId,
+): StatRealtimeTab {
+  return tabs.find((t) => t.id === id) ?? tabs[0]!
+}
+
+/** The selector row for `key` on `tab`, or the tab's first row if `key` is missing. */
+export function realtimeRow(
+  tab: StatRealtimeTab,
+  key: StatRealtimeSeriesKey,
+): StatRealtimeRowTab {
+  return tab.rows.find((r) => r.key === key) ?? tab.rows[0]!
+}
+
+/** The default OES realtime block. Network is estimated from the token flow (kbit/s). */
+export const STAT_REALTIME_BLOCK: StatRealtimeBlock = {
+  tabs: [
+    {
+      id: "tokens",
+      label: "Tok",
+      unit: "tok/s",
+      rows: [
+        // avg is the OES bar's old live reading — the chart smooths this series.
+        { key: "avg", label: "avg", unit: "tok/s", read: (s) => sumSeries(s.tokens.in, s.tokens.out) },
+        { key: "sum", label: "sum", unit: "tok/s", read: (s) => sumSeries(s.tokens.in, s.tokens.out) },
+        { key: "in", label: "in", unit: "tok/s", read: (s) => s.tokens.in },
+        { key: "out", label: "out", unit: "tok/s", read: (s) => s.tokens.out },
+        // tok/s duplicates sum (in+out) — kept as the bar's old label per UX.
+        { key: "tok/s", label: "tok/s", unit: "tok/s", read: (s) => sumSeries(s.tokens.in, s.tokens.out) },
+      ],
+    },
+    {
+      id: "cache",
+      label: "Cache",
+      unit: "tok/s",
+      rows: [
+        { key: "sum", label: "sum", unit: "tok/s", read: (s) => sumSeries(s.cache.read, s.cache.write) },
+        { key: "read", label: "read", unit: "tok/s", read: (s) => s.cache.read },
+        { key: "write", label: "write", unit: "tok/s", read: (s) => s.cache.write },
+      ],
+    },
+    {
+      id: "cpu-ram",
+      label: "Proc",
+      unit: "%/MB",
+      rows: [
+        { key: "cpu", label: "cpu", unit: "%", read: (s) => s.cpuRam.cpu },
+        { key: "ram", label: "ram", unit: "MB", read: (s) => s.cpuRam.ram },
+      ],
+    },
+    {
+      id: "network",
+      label: "Net",
+      unit: "kbit/s",
+      rows: [
+        { key: "in", label: "in", unit: "kbit/s", read: (s) => s.network.in },
+        { key: "out", label: "out", unit: "kbit/s", read: (s) => s.network.out },
+        { key: "sum", label: "sum", unit: "kbit/s", read: (s) => sumSeries(s.network.in, s.network.out) },
+      ],
+    },
+  ],
+}

package/src/pware.oc.perf/pware.oc.perf.realtimeCpuRam.ts

@@ -1,79 +1,79 @@
-/**
- * pware.oc.perf.realtimeCpuRam
- *
- * Process-level CPU/RAM reading for the OES realtime block. CPU% is the
- * OpenCode process's load across all cores; RAM is its resident set. Both come
- * from Node/Bun built-ins (`process.cpuUsage`, `process.memoryUsage`,
- * `os.cpus`), so they work identically on Linux, macOS and Windows with no
- * dependencies. The sampling math is pure and exported for tests; the host
- * read helpers (`readCpuRam`, `cpuCores`) are thin edges the UI tick calls.
- */
-import os from "node:os"
-
-/** A raw CPU/RAM reading: cumulative CPU µs (user/system) + resident bytes. */
-export type CpuRamReading = {
-  user: number
-  system: number
-  rss: number
-}
-
-/** One raw reading from the host: process CPU µs since start + resident bytes. Never throws. */
-export function readCpuRam(): CpuRamReading {
-  try {
-    const cpu = process.cpuUsage()
-    return { user: cpu.user, system: cpu.system, rss: process.memoryUsage().rss }
-  } catch {
-    return { user: 0, system: 0, rss: 0 }
-  }
-}
-
-/** Logical CPU count — divides CPU% so a full core is never above 100. */
-export function cpuCores(): number {
-  return os.cpus().length
-}
-
-/** A reading stamped with when it was taken. */
-export type CpuRamStampedReading = CpuRamReading & { at: number }
-
-/** Process CPU% over an interval, relative to `cores` cores. Null when unmeasurable. */
-export function cpuPercent(
-  prev: CpuRamReading,
-  next: CpuRamReading,
-  wallMs: number,
-  cores: number,
-): number | null {
-  if (wallMs <= 0 || cores <= 0) return null
-  const usedMs = (next.user - prev.user + next.system - prev.system) / 1000
-  return (usedMs / wallMs / cores) * 100
-}
-
-/**
- * CPU% across a rolling window of stamped readings (oldest first): the delta
- * between the newest and the first reading still inside the window, over their
- * wall span. Null while fewer than two readings fit. This is what damps the
- * fine sampling cadence into a stable utilisation number.
- */
-export function cpuPercentOverWindow(
-  readings: readonly CpuRamStampedReading[],
-  cores: number,
-  windowMs: number,
-): number | null {
-  if (cores <= 0 || windowMs <= 0 || readings.length < 2) return null
-  const last = readings[readings.length - 1]!
-  const minAt = last.at - windowMs
-  let first = readings[0]!
-  for (let i = 0; i < readings.length; i += 1) {
-    if (readings[i]!.at >= minAt) {
-      first = readings[i]!
-      break
-    }
-  }
-  const wall = last.at - first.at
-  if (wall <= 0) return null
-  return cpuPercent(first, last, wall, cores)
-}
-
-/** Resident bytes → MB. */
-export function ramMb(rssBytes: number): number {
-  return rssBytes / (1024 * 1024)
-}
+/**
+ * pware.oc.perf.realtimeCpuRam
+ *
+ * Process-level CPU/RAM reading for the OES realtime block. CPU% is the
+ * OpenCode process's load across all cores; RAM is its resident set. Both come
+ * from Node/Bun built-ins (`process.cpuUsage`, `process.memoryUsage`,
+ * `os.cpus`), so they work identically on Linux, macOS and Windows with no
+ * dependencies. The sampling math is pure and exported for tests; the host
+ * read helpers (`readCpuRam`, `cpuCores`) are thin edges the UI tick calls.
+ */
+import os from "node:os"
+
+/** A raw CPU/RAM reading: cumulative CPU µs (user/system) + resident bytes. */
+export type CpuRamReading = {
+  user: number
+  system: number
+  rss: number
+}
+
+/** One raw reading from the host: process CPU µs since start + resident bytes. Never throws. */
+export function readCpuRam(): CpuRamReading {
+  try {
+    const cpu = process.cpuUsage()
+    return { user: cpu.user, system: cpu.system, rss: process.memoryUsage().rss }
+  } catch {
+    return { user: 0, system: 0, rss: 0 }
+  }
+}
+
+/** Logical CPU count — divides CPU% so a full core is never above 100. */
+export function cpuCores(): number {
+  return os.cpus().length
+}
+
+/** A reading stamped with when it was taken. */
+export type CpuRamStampedReading = CpuRamReading & { at: number }
+
+/** Process CPU% over an interval, relative to `cores` cores. Null when unmeasurable. */
+export function cpuPercent(
+  prev: CpuRamReading,
+  next: CpuRamReading,
+  wallMs: number,
+  cores: number,
+): number | null {
+  if (wallMs <= 0 || cores <= 0) return null
+  const usedMs = (next.user - prev.user + next.system - prev.system) / 1000
+  return (usedMs / wallMs / cores) * 100
+}
+
+/**
+ * CPU% across a rolling window of stamped readings (oldest first): the delta
+ * between the newest and the first reading still inside the window, over their
+ * wall span. Null while fewer than two readings fit. This is what damps the
+ * fine sampling cadence into a stable utilisation number.
+ */
+export function cpuPercentOverWindow(
+  readings: readonly CpuRamStampedReading[],
+  cores: number,
+  windowMs: number,
+): number | null {
+  if (cores <= 0 || windowMs <= 0 || readings.length < 2) return null
+  const last = readings[readings.length - 1]!
+  const minAt = last.at - windowMs
+  let first = readings[0]!
+  for (let i = 0; i < readings.length; i += 1) {
+    if (readings[i]!.at >= minAt) {
+      first = readings[i]!
+      break
+    }
+  }
+  const wall = last.at - first.at
+  if (wall <= 0) return null
+  return cpuPercent(first, last, wall, cores)
+}
+
+/** Resident bytes → MB. */
+export function ramMb(rssBytes: number): number {
+  return rssBytes / (1024 * 1024)
+}