vibeusage 0.2.9 → 0.2.11

package/README.md

@@ -91,6 +91,8 @@ npx --yes vibeusage status
 
 - `VIBESCORE_HTTP_TIMEOUT_MS`: CLI HTTP timeout in ms (default `20000`, `0` disables, clamped to `1000..120000`).
 - `VITE_VIBESCORE_HTTP_TIMEOUT_MS`: Dashboard request timeout in ms (default `15000`, `0` disables, clamped to `1000..30000`).
+- `VIBEUSAGE_ROLLUP_ENABLED`: Currently ignored; rollup aggregation is disabled in code until the daily rollup table is deployed.
+- `VIBESCORE_ROLLUP_ENABLED`: Legacy alias for `VIBEUSAGE_ROLLUP_ENABLED` (ignored).
 - `GEMINI_HOME`: Override Gemini CLI home (defaults to `~/.gemini`).
 
 ## 🧰 Troubleshooting
@@ -170,6 +172,16 @@ npm run validate:copy
 npm run smoke
 ```
 
+### Architecture Canvas Focus
+
+```bash
+# Generate a focused canvas for a top-level module
+node scripts/ops/architecture-canvas.cjs --focus src
+
+# Alias: --module
+node scripts/ops/architecture-canvas.cjs --module dashboard
+```
+
 ## 📜 License
 
 This project is licensed under the [MIT License](LICENSE).

package/README.zh-CN.md

@@ -91,6 +91,8 @@ npx --yes vibeusage status
 
 - `VIBESCORE_HTTP_TIMEOUT_MS`：CLI 请求超时（毫秒，默认 `20000`，`0` 表示关闭，范围 `1000..120000`）。
 - `VITE_VIBESCORE_HTTP_TIMEOUT_MS`：Dashboard 请求超时（毫秒，默认 `15000`，`0` 表示关闭，范围 `1000..30000`）。
+- `VIBEUSAGE_ROLLUP_ENABLED`：当前被忽略，rollup 聚合在代码层禁用，等待 rollup 表部署完成后再恢复。
+- `VIBESCORE_ROLLUP_ENABLED`：`VIBEUSAGE_ROLLUP_ENABLED` 的兼容别名（同样无效）。
 - `GEMINI_HOME`：覆盖 Gemini CLI 的 home（默认 `~/.gemini`）。
 
 ## 🧰 常见问题
@@ -170,6 +172,16 @@ npm run validate:copy
 npm run smoke
 ```
 
+### 架构画布聚焦
+
+```bash
+# 生成指定顶层模块的聚焦画布
+node scripts/ops/architecture-canvas.cjs --focus src
+
+# 别名：--module
+node scripts/ops/architecture-canvas.cjs --module dashboard
+```
+
 ## 📜 开源协议
 
 本项目基于 [MIT](LICENSE) 协议开源。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeusage",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
   "publishConfig": {
@@ -20,6 +20,8 @@
     "copy:pull": "node scripts/copy-sync.cjs pull",
     "copy:push": "node scripts/copy-sync.cjs push",
     "architecture:canvas": "node scripts/ops/architecture-canvas.cjs",
+    "architecture:canvas:focus": "node scripts/ops/architecture-canvas.cjs --focus",
+    "architecture:canvas:list-modules": "node scripts/ops/architecture-canvas.cjs --list-modules",
     "validate:guardrails": "node scripts/validate-architecture-guardrails.cjs"
   },
   "bin": {

package/src/lib/insforge-client.js

@@ -1,6 +1,14 @@
 'use strict';
 
-const { createClient } = require('@insforge/sdk');
+function loadInsforgeSdk() {
+  try {
+    return require('@insforge/sdk');
+  } catch (err) {
+    const wrapped = new Error('Missing dependency @insforge/sdk. Please reinstall vibeusage.');
+    wrapped.cause = err;
+    throw wrapped;
+  }
+}
 
 function getAnonKey({ env = process.env } = {}) {
   return (
@@ -44,6 +52,7 @@ function createTimeoutFetch(baseFetch) {
 
 function createInsforgeClient({ baseUrl, accessToken } = {}) {
   if (!baseUrl) throw new Error('Missing baseUrl');
+  const { createClient } = loadInsforgeSdk();
   const anonKey = getAnonKey();
   return createClient({
     baseUrl,

package/src/lib/opencode-usage-audit.js

@@ -0,0 +1,202 @@
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const { listOpencodeMessageFiles, parseOpencodeIncremental } = require('./rollout');
+
+const BUCKET_SEPARATOR = '|';
+const DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+function formatHourKey(date) {
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}-${String(
+    date.getUTCDate()
+  ).padStart(2, '0')}T${String(date.getUTCHours()).padStart(2, '0')}:${String(
+    date.getUTCMinutes() >= 30 ? 30 : 0
+  ).padStart(2, '0')}:00`;
+}
+
+function toBig(value) {
+  if (typeof value === 'bigint') return value;
+  if (typeof value === 'number') return BigInt(value);
+  if (typeof value === 'string' && value.trim()) return BigInt(value);
+  return 0n;
+}
+
+function addTotals(target, delta) {
+  target.input_tokens += toBig(delta.input_tokens);
+  target.cached_input_tokens += toBig(delta.cached_input_tokens);
+  target.output_tokens += toBig(delta.output_tokens);
+  target.reasoning_output_tokens += toBig(delta.reasoning_output_tokens);
+  target.total_tokens += toBig(delta.total_tokens);
+}
+
+async function buildLocalHourlyTotals({ storageDir, source = 'opencode' }) {
+  const messageFiles = await listOpencodeMessageFiles(storageDir);
+  const queuePath = path.join(os.tmpdir(), `vibeusage-opencode-audit-${process.pid}-${Date.now()}.jsonl`);
+  const cursors = { version: 1, files: {}, hourly: null, opencode: null };
+
+  await parseOpencodeIncremental({ messageFiles, cursors, queuePath, source });
+  await fs.rm(queuePath, { force: true }).catch(() => {});
+
+  const byHour = new Map();
+  let minDay = null;
+  let maxDay = null;
+
+  for (const [key, bucket] of Object.entries(cursors.hourly?.buckets || {})) {
+    const [bucketSource, , hourStart] = String(key).split(BUCKET_SEPARATOR);
+    if (bucketSource !== source || !hourStart) continue;
+    const dt = new Date(hourStart);
+    if (!Number.isFinite(dt.getTime())) continue;
+    const hourKey = formatHourKey(dt);
+    const dayKey = hourKey.slice(0, 10);
+
+    if (!minDay || dayKey < minDay) minDay = dayKey;
+    if (!maxDay || dayKey > maxDay) maxDay = dayKey;
+
+    const totals = byHour.get(hourKey) || {
+      input_tokens: 0n,
+      cached_input_tokens: 0n,
+      output_tokens: 0n,
+      reasoning_output_tokens: 0n,
+      total_tokens: 0n
+    };
+    addTotals(totals, bucket.totals || {});
+    byHour.set(hourKey, totals);
+  }
+
+  return { byHour, minDay, maxDay };
+}
+
+function normalizeServerRows(rows) {
+  const map = new Map();
+  for (const row of rows || []) {
+    if (!row || !row.hour) continue;
+    map.set(row.hour, {
+      missing: Boolean(row.missing),
+      totals: {
+        input_tokens: toBig(row.input_tokens),
+        cached_input_tokens: toBig(row.cached_input_tokens),
+        output_tokens: toBig(row.output_tokens),
+        reasoning_output_tokens: toBig(row.reasoning_output_tokens),
+        total_tokens: toBig(row.total_tokens)
+      }
+    });
+  }
+  return map;
+}
+
+function diffTotals(local, server) {
+  return {
+    input_tokens: local.input_tokens - server.input_tokens,
+    cached_input_tokens: local.cached_input_tokens - server.cached_input_tokens,
+    output_tokens: local.output_tokens - server.output_tokens,
+    reasoning_output_tokens: local.reasoning_output_tokens - server.reasoning_output_tokens,
+    total_tokens: local.total_tokens - server.total_tokens
+  };
+}
+
+function maxAbsDelta(delta) {
+  return [
+    delta.input_tokens,
+    delta.cached_input_tokens,
+    delta.output_tokens,
+    delta.reasoning_output_tokens,
+    delta.total_tokens
+  ].reduce((acc, value) => {
+    const abs = value < 0n ? -value : value;
+    return abs > acc ? abs : acc;
+  }, 0n);
+}
+
+function isValidDay(value) {
+  if (!DAY_RE.test(value)) return false;
+  const dt = new Date(`${value}T00:00:00.000Z`);
+  return Number.isFinite(dt.getTime());
+}
+
+function listDays(from, to) {
+  if (!isValidDay(from) || !isValidDay(to)) return [];
+  if (from > to) return [];
+  const out = [];
+  const start = new Date(`${from}T00:00:00.000Z`);
+  const end = new Date(`${to}T00:00:00.000Z`);
+  for (let dt = start; dt <= end; dt = new Date(dt.getTime() + 24 * 60 * 60 * 1000)) {
+    const day = `${dt.getUTCFullYear()}-${String(dt.getUTCMonth() + 1).padStart(2, '0')}-${String(
+      dt.getUTCDate()
+    ).padStart(2, '0')}`;
+    out.push(day);
+  }
+  return out;
+}
+
+async function auditOpencodeUsage({ storageDir, from, to, fetchHourly, includeMissing = false }) {
+  const local = await buildLocalHourlyTotals({ storageDir, source: 'opencode' });
+  if (!local.minDay || !local.maxDay) {
+    throw new Error('No local opencode data found');
+  }
+
+  const fromDay = from || local.minDay;
+  const toDay = to || local.maxDay;
+  const days = listDays(fromDay, toDay);
+  if (days.length === 0) {
+    throw new Error('Invalid date range for audit');
+  }
+
+  const diffs = [];
+  let matched = 0;
+  let mismatched = 0;
+  let incomplete = 0;
+  let maxDelta = 0n;
+
+  for (const day of days) {
+    const server = await fetchHourly(day);
+    const serverByHour = normalizeServerRows(server?.data || []);
+    for (let h = 0; h < 24; h++) {
+      for (const m of [0, 30]) {
+        const hourKey = `${day}T${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:00`;
+        const localTotals = local.byHour.get(hourKey) || {
+          input_tokens: 0n,
+          cached_input_tokens: 0n,
+          output_tokens: 0n,
+          reasoning_output_tokens: 0n,
+          total_tokens: 0n
+        };
+        const serverEntry = serverByHour.get(hourKey) || null;
+        if (serverEntry?.missing && !includeMissing) {
+          incomplete += 1;
+          continue;
+        }
+        const serverTotals = serverEntry?.totals || {
+          input_tokens: 0n,
+          cached_input_tokens: 0n,
+          output_tokens: 0n,
+          reasoning_output_tokens: 0n,
+          total_tokens: 0n
+        };
+        const delta = diffTotals(localTotals, serverTotals);
+        const deltaMax = maxAbsDelta(delta);
+        if (deltaMax === 0n) {
+          matched += 1;
+        } else {
+          mismatched += 1;
+          if (deltaMax > maxDelta) maxDelta = deltaMax;
+          diffs.push({ hour: hourKey, local: localTotals, server: serverTotals, delta });
+        }
+      }
+    }
+  }
+
+  return {
+    summary: {
+      days: days.length,
+      slots: days.length * 48,
+      matched,
+      mismatched,
+      incomplete,
+      maxDelta
+    },
+    diffs
+  };
+}
+
+module.exports = { auditOpencodeUsage, buildLocalHourlyTotals };

package/src/lib/rollout.js

@@ -287,6 +287,8 @@ async function parseOpencodeIncremental({ messageFiles, cursors, queuePath, onPr
   const files = Array.isArray(messageFiles) ? messageFiles : [];
   const totalFiles = files.length;
   const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const opencodeState = normalizeOpencodeState(cursors?.opencode);
+  const messageIndex = opencodeState.messages;
   const touchedBuckets = new Set();
   const defaultSource = normalizeSourceInput(source) || 'opencode';
 
@@ -324,10 +326,14 @@ async function parseOpencodeIncremental({ messageFiles, cursors, queuePath, onPr
       continue;
     }
 
-    const lastTotals = prev && prev.inode === inode ? prev.lastTotals || null : null;
+    const fallbackTotals = prev && typeof prev.lastTotals === 'object' ? prev.lastTotals : null;
+    const fallbackMessageKey =
+      prev && typeof prev.messageKey === 'string' && prev.messageKey.trim() ? prev.messageKey.trim() : null;
     const result = await parseOpencodeMessageFile({
       filePath,
-      lastTotals,
+      messageIndex,
+      fallbackTotals,
+      fallbackMessageKey,
       hourlyState,
       touchedBuckets,
       source: fileSource
@@ -338,12 +344,20 @@ async function parseOpencodeIncremental({ messageFiles, cursors, queuePath, onPr
       size,
       mtimeMs,
       lastTotals: result.lastTotals,
+      messageKey: result.messageKey || null,
       updatedAt: new Date().toISOString()
     };
 
     filesProcessed += 1;
     eventsAggregated += result.eventsAggregated;
 
+    if (result.messageKey && result.shouldUpdate) {
+      messageIndex[result.messageKey] = {
+        lastTotals: result.lastTotals,
+        updatedAt: new Date().toISOString()
+      };
+    }
+
     if (cb) {
       cb({
         index: idx + 1,
@@ -359,6 +373,8 @@ async function parseOpencodeIncremental({ messageFiles, cursors, queuePath, onPr
   const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
   hourlyState.updatedAt = new Date().toISOString();
   cursors.hourly = hourlyState;
+  opencodeState.updatedAt = new Date().toISOString();
+  cursors.opencode = opencodeState;
 
   return { filesProcessed, eventsAggregated, bucketsQueued };
 }
@@ -550,35 +566,86 @@ async function parseGeminiFile({
   };
 }
 
-async function parseOpencodeMessageFile({ filePath, lastTotals, hourlyState, touchedBuckets, source }) {
+async function parseOpencodeMessageFile({
+  filePath,
+  messageIndex,
+  fallbackTotals,
+  fallbackMessageKey,
+  hourlyState,
+  touchedBuckets,
+  source
+}) {
+  const fallbackKey =
+    typeof fallbackMessageKey === 'string' && fallbackMessageKey.trim() ? fallbackMessageKey.trim() : null;
+  const legacyTotals = fallbackTotals && typeof fallbackTotals === 'object' ? fallbackTotals : null;
+  const fallbackEntry = messageIndex && fallbackKey ? messageIndex[fallbackKey] : null;
+  const fallbackLastTotals =
+    fallbackEntry && typeof fallbackEntry.lastTotals === 'object' ? fallbackEntry.lastTotals : legacyTotals;
+
   const raw = await fs.readFile(filePath, 'utf8').catch(() => '');
-  if (!raw.trim()) return { lastTotals, eventsAggregated: 0 };
+  if (!raw.trim()) {
+    return {
+      messageKey: fallbackKey,
+      lastTotals: fallbackLastTotals,
+      eventsAggregated: 0,
+      shouldUpdate: false
+    };
+  }
 
   let msg;
   try {
     msg = JSON.parse(raw);
   } catch (_e) {
-    return { lastTotals, eventsAggregated: 0 };
+    return {
+      messageKey: fallbackKey,
+      lastTotals: fallbackLastTotals,
+      eventsAggregated: 0,
+      shouldUpdate: false
+    };
   }
 
+  const messageKey = deriveOpencodeMessageKey(msg, filePath);
+  const prev = messageIndex && messageKey ? messageIndex[messageKey] : null;
+  const indexTotals = prev && typeof prev.lastTotals === 'object' ? prev.lastTotals : null;
+  const fallbackMatch = !fallbackKey || fallbackKey === messageKey;
+  const lastTotals = indexTotals || (fallbackMatch ? fallbackLastTotals : null);
+
   const currentTotals = normalizeOpencodeTokens(msg?.tokens);
-  if (!currentTotals) return { lastTotals, eventsAggregated: 0 };
+  if (!currentTotals) {
+    return { messageKey, lastTotals, eventsAggregated: 0, shouldUpdate: false };
+  }
 
   const delta = diffGeminiTotals(currentTotals, lastTotals);
-  if (!delta || isAllZeroUsage(delta)) return { lastTotals: currentTotals, eventsAggregated: 0 };
+  if (!delta || isAllZeroUsage(delta)) {
+    return { messageKey, lastTotals: currentTotals, eventsAggregated: 0, shouldUpdate: true };
+  }
 
   const timestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
-  if (!timestampMs) return { lastTotals, eventsAggregated: 0 };
+  if (!timestampMs) {
+    return {
+      messageKey,
+      lastTotals,
+      eventsAggregated: 0,
+      shouldUpdate: Boolean(lastTotals)
+    };
+  }
 
   const tsIso = new Date(timestampMs).toISOString();
   const bucketStart = toUtcHalfHourStart(tsIso);
-  if (!bucketStart) return { lastTotals, eventsAggregated: 0 };
+  if (!bucketStart) {
+    return {
+      messageKey,
+      lastTotals,
+      eventsAggregated: 0,
+      shouldUpdate: Boolean(lastTotals)
+    };
+  }
 
   const model = normalizeModelInput(msg?.modelID || msg?.model || msg?.modelId) || DEFAULT_MODEL;
   const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
   addTotals(bucket.totals, delta);
   touchedBuckets.add(bucketKey(source, model, bucketStart));
-  return { lastTotals: currentTotals, eventsAggregated: 1 };
+  return { messageKey, lastTotals: currentTotals, eventsAggregated: 1, shouldUpdate: true };
 }
 
 async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets }) {
@@ -982,6 +1049,27 @@ function normalizeHourlyState(raw) {
   };
 }
 
+function normalizeOpencodeState(raw) {
+  const state = raw && typeof raw === 'object' ? raw : {};
+  const messages = state.messages && typeof state.messages === 'object' ? state.messages : {};
+  return {
+    messages,
+    updatedAt: typeof state.updatedAt === 'string' ? state.updatedAt : null
+  };
+}
+
+function normalizeMessageKeyPart(value) {
+  if (typeof value !== 'string') return '';
+  return value.trim();
+}
+
+function deriveOpencodeMessageKey(msg, fallback) {
+  const sessionId = normalizeMessageKeyPart(msg?.sessionID || msg?.sessionId || msg?.session_id);
+  const messageId = normalizeMessageKeyPart(msg?.id || msg?.messageID || msg?.messageId);
+  if (sessionId && messageId) return `${sessionId}|${messageId}`;
+  return fallback;
+}
+
 function getHourlyBucket(state, source, model, hourStart) {
   const buckets = state.buckets;
   const normalizedSource = normalizeSourceInput(source) || DEFAULT_SOURCE;
@@ -1114,10 +1202,12 @@ function normalizeOpencodeTokens(tokens) {
   const output = toNonNegativeInt(tokens.output);
   const reasoning = toNonNegativeInt(tokens.reasoning);
   const cached = toNonNegativeInt(tokens.cache?.read);
-  const total = input + output + reasoning;
+  const cacheWrite = toNonNegativeInt(tokens.cache?.write);
+  const inputTokens = input + cacheWrite;
+  const total = inputTokens + output + reasoning;
 
   return {
-    input_tokens: input,
+    input_tokens: inputTokens,
     cached_input_tokens: cached,
     output_tokens: output,
     reasoning_output_tokens: reasoning,
@@ -1217,7 +1307,7 @@ function normalizeUsage(u) {
 }
 
 function normalizeClaudeUsage(u) {
-  const inputTokens = toNonNegativeInt(u?.input_tokens);
+  const inputTokens = toNonNegativeInt(u?.input_tokens) + toNonNegativeInt(u?.cache_creation_input_tokens);
   const outputTokens = toNonNegativeInt(u?.output_tokens);
   const hasTotal = u && Object.prototype.hasOwnProperty.call(u, 'total_tokens');
   const totalTokens = hasTotal ? toNonNegativeInt(u?.total_tokens) : inputTokens + outputTokens;