@cesarus777/opencode-cgp 0.1.0 → 0.2.1

package/dist/core.js

@@ -46,7 +46,16 @@ function threshold(v, path) {
 }
 function parseConfig(value = {}) {
   const o = object(value, "options");
-  keys(o, ["enabled", "mode", "defaults", "policies", "safety", "telemetry"], "options");
+  keys(o, [
+    "enabled",
+    "mode",
+    "defaults",
+    "policies",
+    "safety",
+    "telemetry",
+    "metrics",
+    "history"
+  ], "options");
   if (o.mode !== undefined && o.mode !== "observe" && o.mode !== "enforce")
     throw new Error("mode: expected observe or enforce");
   const d = object(o.defaults ?? {}, "defaults");
@@ -62,6 +71,12 @@ function parseConfig(value = {}) {
     "sessionTtlMs",
     "outputReserveTokens"
   ], "safety");
+  const metrics = object(o.metrics ?? {}, "metrics");
+  keys(metrics, ["enabled", "sampleIntervalMs", "rollingWindowMs"], "metrics");
+  const history = object(o.history ?? {}, "history");
+  keys(history, ["enabled", "retentionDays", "maxBytes", "path"], "history");
+  if (history.path !== undefined && (typeof history.path !== "string" || !history.path.startsWith("/")))
+    throw new Error("history.path: expected absolute directory path");
   const t = object(o.telemetry ?? {}, "telemetry");
   keys(t, ["enabled", "jsonl", "path", "maxBytes"], "telemetry");
   if (t.path !== undefined && (typeof t.path !== "string" || !t.path.startsWith("/")))
@@ -109,6 +124,17 @@ function parseConfig(value = {}) {
         outputReserveTokens: number(s.outputReserveTokens, 0, "outputReserveTokens")
       }
     },
+    metrics: {
+      enabled: bool(metrics.enabled, true, "metrics.enabled"),
+      sampleIntervalMs: number(metrics.sampleIntervalMs, 500, "metrics.sampleIntervalMs", 100),
+      rollingWindowMs: number(metrics.rollingWindowMs, 2000, "metrics.rollingWindowMs", 100)
+    },
+    history: {
+      enabled: bool(history.enabled, true, "history.enabled"),
+      retentionDays: number(history.retentionDays, 7, "history.retentionDays", 1),
+      maxBytes: number(history.maxBytes, 64 * 1024 * 1024, "history.maxBytes", 4096),
+      ...typeof history.path === "string" ? { path: history.path } : {}
+    },
     telemetry: {
       enabled: bool(t.enabled, true, "telemetry.enabled"),
       jsonl: bool(t.jsonl, true, "telemetry.jsonl"),
@@ -116,6 +142,8 @@ function parseConfig(value = {}) {
       ...typeof t.path === "string" ? { path: t.path } : {}
     }
   };
+  if (config.metrics.rollingWindowMs < config.metrics.sampleIntervalMs || config.metrics.rollingWindowMs > 60000)
+    throw new Error("metrics.rollingWindowMs must be >= sampleIntervalMs and <= 60000");
   for (const policy of [config.defaults, ...config.policies]) {
     if (policy.threshold.type === "tokens" && config.safety.minReclaimTokens >= policy.threshold.value)
       throw new Error("minReclaimTokens must be smaller than each absolute threshold");
@@ -570,6 +598,7 @@ class SnapshotStore {
   config;
   sessions;
   now;
+  performanceSnapshot;
   epoch;
   sequence = 0;
   revision = 0;
@@ -579,10 +608,11 @@ class SnapshotStore {
   listeners = new Set;
   healthKey = "";
   reasons = new Set;
-  constructor(config, sessions, now = Date.now, epoch = crypto.randomUUID()) {
+  constructor(config, sessions, now = Date.now, epoch = crypto.randomUUID(), performanceSnapshot) {
     this.config = config;
     this.sessions = sessions;
     this.now = now;
+    this.performanceSnapshot = performanceSnapshot;
     this.epoch = epoch;
   }
   health() {
@@ -643,7 +673,11 @@ class SnapshotStore {
       const s = resident.get(id);
       if (!s)
         continue;
-      const next = project(s, this.config, this.now());
+      const performance = this.performanceSnapshot?.(id);
+      const next = freezeSnapshot({
+        ...project(s, this.config, this.now()),
+        ...performance ? { performance } : {}
+      });
       const old = this.rows.get(id);
       if (old && JSON.stringify({ ...old, revision: 0 }) === JSON.stringify(next))
         continue;
@@ -693,6 +727,8 @@ class SnapshotStore {
   }
 }
 function freezeSnapshot(row) {
+  if (row.performance)
+    Object.freeze(row.performance);
   if (row.measurement)
     Object.freeze(row.measurement);
   if (row.limits)
@@ -807,19 +843,404 @@ function executionStatus(known, nativeRunning, evidence) {
     return evidence.outcome === "succeeded" ? "completed" : evidence.outcome === "failed" ? "failed" : "unknown";
   return known ? "idle" : "unknown";
 }
+// src/performance.ts
+var valid = (n) => Number.isFinite(n) && n >= 0;
+var rate = (tokens, ms) => valid(tokens) && ms > 0 ? tokens * 1000 / ms : undefined;
+function outputTokens(tokens) {
+  const n = tokens.output + tokens.reasoning;
+  return Number.isSafeInteger(tokens.output) && tokens.output >= 0 && Number.isSafeInteger(tokens.reasoning) && tokens.reasoning >= 0 && Number.isSafeInteger(n) ? n : undefined;
+}
+
+class PerformanceTracker {
+  maxSessions;
+  windowMs;
+  now;
+  rows = new Map;
+  constructor(maxSessions, windowMs = 2000, now = Date.now) {
+    this.maxSessions = maxSessions;
+    this.windowMs = windowMs;
+    this.now = now;
+  }
+  observe(id, created, cumulative) {
+    let row = this.rows.get(id);
+    if (!row) {
+      if (this.rows.size >= this.maxSessions)
+        return;
+      row = {
+        observedSince: this.now(),
+        created,
+        partial: cumulative !== 0,
+        output: 0,
+        duration: 0,
+        completed: 0,
+        sequence: -1
+      };
+      this.rows.set(id, row);
+    }
+    if (valid(created))
+      row.created = created;
+    if (cumulative !== undefined && valid(cumulative))
+      row.cumulative = cumulative;
+  }
+  accept(id, sequence) {
+    const row = this.rows.get(id);
+    if (!row || sequence <= row.sequence)
+      return false;
+    row.sequence = sequence;
+    return true;
+  }
+  start(id, requestId, agent, model, started) {
+    const row = this.rows.get(id);
+    if (!row || !valid(started))
+      return;
+    const old = row.request;
+    if (old?.id === requestId && old.started === started)
+      return;
+    if (old && !old.settled)
+      row.partial = true;
+    row.request = {
+      id: requestId,
+      agent,
+      model,
+      started,
+      chars: 0,
+      settled: false,
+      events: new Set,
+      buckets: new Map
+    };
+  }
+  delta(id, requestId, eventId, at, characters) {
+    const row = this.rows.get(id), r = row?.request;
+    if (!row || !r || r.id !== requestId || r.settled || r.ended !== undefined || !valid(at) || at < r.started || !valid(characters) || !characters || r.events.has(eventId))
+      return;
+    if (r.events.size >= 256)
+      r.events.delete(r.events.values().next().value ?? "");
+    r.events.add(eventId);
+    r.first = r.first === undefined ? at : Math.min(r.first, at);
+    r.chars += characters;
+    const bucket = Math.floor(at / 100) * 100;
+    r.buckets.set(bucket, (r.buckets.get(bucket) ?? 0) + characters);
+    this.prune(r, Math.max(at, this.now()));
+    while (r.buckets.size > Math.ceil(this.windowMs / 100) + 2) {
+      r.buckets.delete(Math.min(...r.buckets.keys()));
+    }
+  }
+  streamed(id, requestId, at) {
+    const row = this.rows.get(id), r = row?.request;
+    if (!row || !r || r.id !== requestId || r.settled || r.ended !== undefined)
+      return;
+    if (!valid(at) || at <= r.started || r.first !== undefined && at < r.first) {
+      row.partial = true;
+      return;
+    }
+    r.ended = at;
+  }
+  settle(id, requestId, tokens) {
+    const row = this.rows.get(id), r = row?.request;
+    if (!row)
+      return;
+    if (!r || r.id !== requestId) {
+      row.partial = true;
+      return;
+    }
+    if (r.settled)
+      return;
+    r.settled = true;
+    if (tokens !== undefined && valid(tokens))
+      r.output = tokens;
+    if (tokens !== undefined && valid(tokens) && r.ended !== undefined) {
+      row.output += tokens;
+      row.duration += r.ended - r.started;
+      row.completed++;
+    } else
+      row.partial = true;
+    const snapshot = this.snapshot(id);
+    if (snapshot) {
+      const { latestRequestTps: _previousRate, ...current } = snapshot;
+      row.latest = {
+        ...current,
+        tokenSource: tokens === undefined ? "unavailable" : "reported",
+        ...tokens !== undefined && r.ended !== undefined ? { latestRequestTps: tokens * 1000 / (r.ended - r.started) } : {}
+      };
+    }
+    r.events.clear();
+    r.buckets.clear();
+  }
+  gap(id) {
+    for (const [key, row] of this.rows) {
+      if (id !== undefined && key !== id)
+        continue;
+      row.partial = true;
+      delete row.request;
+    }
+  }
+  prune(r, at) {
+    for (const time of r.buckets.keys())
+      if (time < at - this.windowMs)
+        r.buckets.delete(time);
+  }
+  snapshot(id) {
+    const row = this.rows.get(id);
+    if (!row)
+      return;
+    const at = this.now(), r = row.request;
+    const active = r && !r.settled && r.ended === undefined;
+    if (r)
+      this.prune(r, at);
+    const live = active ? rate([...r.buckets.values()].reduce((a, b) => a + b, 0) / 4, Math.min(this.windowMs, at - r.started)) : 0;
+    const averageModelTps = rate(row.output, row.duration);
+    const averageSessionTps = row.cumulative === undefined ? undefined : rate(row.cumulative, at - row.created);
+    return {
+      observedSince: row.observedSince,
+      at,
+      sessionCreatedAt: row.created,
+      ...row.cumulative === undefined ? {} : { sessionOutputTokens: row.cumulative },
+      status: active ? r.first === undefined ? "waiting" : "streaming" : !r && row.partial ? "unavailable" : "idle",
+      partial: row.partial,
+      ...live === undefined || !r && row.partial ? {} : { liveTps: live },
+      ...averageModelTps === undefined ? {} : { averageModelTps },
+      ...averageSessionTps === undefined ? {} : { averageSessionTps },
+      ...r ? {
+        requestId: r.id,
+        requestAgent: r.agent,
+        requestModel: r.model,
+        requestStartedAt: r.started,
+        ...r.output === undefined ? {} : { requestOutputTokens: r.output },
+        ...r.first === undefined ? {} : { firstOutputAt: r.first, ttftMs: r.first - r.started },
+        ...r.ended === undefined ? {} : { streamEndedAt: r.ended }
+      } : row.latest ? {
+        ...row.latest.ttftMs === undefined ? {} : { ttftMs: row.latest.ttftMs }
+      } : {},
+      ...row.latest?.latestRequestTps === undefined ? {} : { latestRequestTps: row.latest.latestRequestTps },
+      estimatedOutputTokens: r ? r.chars / 4 : 0,
+      modelOutputTokens: row.output,
+      modelDurationMs: row.duration,
+      completedRequests: row.completed,
+      tokenSource: r && !r.settled ? "estimated" : row.latest?.tokenSource ?? "unavailable"
+    };
+  }
+  checkpoint() {
+    return [...this.rows].map(([sessionId, r]) => ({
+      sessionId,
+      observedSince: r.observedSince,
+      created: r.created,
+      output: r.output,
+      duration: r.duration,
+      completed: r.completed,
+      sequence: r.sequence
+    }));
+  }
+  restore(value) {
+    if (!Array.isArray(value))
+      return;
+    for (const item of value.slice(0, this.maxSessions)) {
+      if (!item || typeof item !== "object")
+        continue;
+      const r = item;
+      if (typeof r.sessionId !== "string" || !r.sessionId.length || r.sessionId.length > 512 || ![r.observedSince, r.created, r.output, r.duration, r.completed].every((n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0) || typeof r.sequence !== "number" || !Number.isSafeInteger(r.sequence) || r.sequence < -1)
+        continue;
+      const { observedSince, created, output, duration, completed, sequence } = r;
+      if (typeof observedSince !== "number" || typeof created !== "number" || typeof output !== "number" || typeof duration !== "number" || typeof completed !== "number")
+        continue;
+      this.rows.set(r.sessionId, {
+        observedSince,
+        created,
+        output,
+        duration,
+        completed,
+        sequence,
+        partial: true
+      });
+    }
+  }
+  remove(id) {
+    this.rows.delete(id);
+  }
+  ids() {
+    return this.rows.keys();
+  }
+}
+// src/charts.ts
+var rateFields = [
+  "liveTps",
+  "averageModelTps",
+  "averageSessionTps",
+  "sessionOutputTokens"
+];
+function downsamplePoints(points, limit) {
+  if (!Number.isSafeInteger(limit) || limit < 16 || limit > 5000)
+    throw new Error("maxPoints must be an integer from 16 to 5000");
+  if (points.length <= limit)
+    return [...points];
+  const buckets = Math.max(1, Math.floor(limit / (2 + rateFields.length * 2)));
+  const selected = new Set;
+  for (let b = 0;b < buckets; b++) {
+    const start = Math.floor(b * points.length / buckets), end = Math.floor((b + 1) * points.length / buckets);
+    selected.add(start);
+    selected.add(end - 1);
+    for (const field of rateFields) {
+      let low, high;
+      for (let i = start;i < end; i++) {
+        const value = points[i]?.[field];
+        if (value === undefined)
+          continue;
+        if (low === undefined || value < (points[low]?.[field] ?? Infinity))
+          low = i;
+        if (high === undefined || value > (points[high]?.[field] ?? -Infinity))
+          high = i;
+      }
+      if (low !== undefined)
+        selected.add(low);
+      if (high !== undefined)
+        selected.add(high);
+    }
+  }
+  let previous = -1;
+  return [...selected].sort((a, b) => a - b).flatMap((index) => {
+    const point = points[index];
+    if (!point)
+      return [];
+    const skippedGap = points.slice(previous + 1, index + 1).some((p) => p.breakBefore);
+    previous = index;
+    return [{ ...point, breakBefore: point.breakBefore || skippedGap }];
+  });
+}
+function buildChartData(records, options = {}) {
+  const maxPoints = options.maxPoints ?? 1000, maxSessions = options.maxSessions ?? 128;
+  if (!Number.isSafeInteger(maxSessions) || maxSessions < 1 || maxSessions > 1024)
+    throw new Error("maxSessions must be from 1 to 1024");
+  downsamplePoints([], maxPoints);
+  const sorted = [...records].sort((a, b) => a.time - b.time || a.recordId.localeCompare(b.recordId));
+  const lastSeen = new Map;
+  for (const r of sorted)
+    if (r.performance && (!options.sessionId || r.sessionId === options.sessionId))
+      lastSeen.set(r.sessionId, r.time);
+  const sessions = [...lastSeen].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  const selected = new Set(sessions.slice(0, maxSessions).map(([id]) => id));
+  const series = new Map, gaps = [];
+  const seen = new Set, requestSeen = new Set;
+  const pendingGaps = new Set;
+  const observedSince = new Map;
+  for (const r of sorted) {
+    if (seen.has(r.recordId))
+      continue;
+    seen.add(r.recordId);
+    if (r.type === "gap") {
+      if (r.sessionId === "__history__" || selected.has(r.sessionId)) {
+        gaps.push({
+          time: r.time,
+          sessionId: r.sessionId,
+          reason: r.event ?? "observation-gap"
+        });
+        if (r.sessionId === "__history__")
+          for (const id of selected)
+            pendingGaps.add(id);
+        else
+          pendingGaps.add(r.sessionId);
+      }
+      continue;
+    }
+    const p = r.performance;
+    if (!p || !selected.has(r.sessionId))
+      continue;
+    let s = series.get(r.sessionId);
+    if (!s) {
+      s = {
+        sessionId: r.sessionId,
+        ...r.parentId ? { parentId: r.parentId } : {},
+        agents: [],
+        models: [],
+        points: [],
+        requests: [],
+        originalPoints: 0
+      };
+      series.set(r.sessionId, s);
+    }
+    const agent = p.requestAgent ?? r.agent, model = p.requestModel ?? r.model;
+    if (agent && !s.agents.includes(agent))
+      s.agents.push(agent);
+    if (model && !s.models.includes(model))
+      s.models.push(model);
+    const previous = s.points.at(-1);
+    const restart = observedSince.has(r.sessionId) && observedSince.get(r.sessionId) !== p.observedSince;
+    const reset = previous?.sessionOutputTokens !== undefined && p.sessionOutputTokens !== undefined && p.sessionOutputTokens < previous.sessionOutputTokens;
+    const discontinuity = pendingGaps.has(r.sessionId) || restart || reset || !previous || previous.partial !== p.partial || previous.liveTps === undefined || p.liveTps === undefined || r.time - previous.time > 2500 || previous.agent !== agent || previous.model !== model;
+    const point = {
+      time: r.time,
+      ...agent ? { agent } : {},
+      ...model ? { model } : {},
+      breakBefore: discontinuity,
+      partial: p.partial,
+      ...p.liveTps === undefined ? {} : { liveTps: p.liveTps },
+      ...p.averageModelTps === undefined ? {} : { averageModelTps: p.averageModelTps },
+      ...p.averageSessionTps === undefined ? {} : { averageSessionTps: p.averageSessionTps },
+      ...p.sessionOutputTokens === undefined ? {} : { sessionOutputTokens: p.sessionOutputTokens }
+    };
+    if (previous?.time === point.time)
+      s.points[s.points.length - 1] = {
+        ...point,
+        breakBefore: point.breakBefore || previous.breakBefore
+      };
+    else
+      s.points.push(point);
+    observedSince.set(r.sessionId, p.observedSince);
+    pendingGaps.delete(r.sessionId);
+    if (r.type === "request" && p.requestId !== undefined && p.requestStartedAt !== undefined) {
+      const key = JSON.stringify([
+        r.sessionId,
+        p.requestId,
+        p.requestStartedAt
+      ]);
+      if (requestSeen.has(key))
+        continue;
+      requestSeen.add(key);
+      const duration = p.streamEndedAt === undefined ? undefined : p.streamEndedAt - p.requestStartedAt;
+      const validDuration = duration !== undefined && duration > 0;
+      const output = p.tokenSource === "reported" ? p.requestOutputTokens : undefined;
+      s.requests.push({
+        time: r.time,
+        requestId: p.requestId,
+        started: p.requestStartedAt,
+        ...agent ? { agent } : {},
+        ...model ? { model } : {},
+        partial: p.partial,
+        ...p.ttftMs === undefined ? {} : { ttftMs: p.ttftMs },
+        ...output === undefined ? {} : { outputTokens: output },
+        ...validDuration ? { durationMs: duration } : {},
+        ...output !== undefined && validDuration ? { tps: output * 1000 / duration } : {}
+      });
+    }
+  }
+  return {
+    schema: 1,
+    series: [...series.values()].map((s) => ({
+      ...s,
+      originalPoints: s.points.length,
+      points: downsamplePoints(s.points, maxPoints)
+    })),
+    gaps: gaps.slice(-1024),
+    omittedGaps: Math.max(0, gaps.length - 1024),
+    omittedSessions: Math.max(0, sessions.length - selected.size),
+    maxPoints
+  };
+}
 export {
   usableInput,
   promptTokens,
   project,
   parseConfig,
+  outputTokens,
   metric,
   glob,
   familyRows,
   executionStatus,
   evaluateThreshold,
   estimate,
+  downsamplePoints,
+  buildChartData,
   SnapshotStore,
   PolicyResolver,
+  PerformanceTracker,
   NoopBudgetController,
   ContextMonitor,
   CompactionScheduler