vibeusage 0.3.4 → 0.4.0

package/src/lib/rollout.js

@@ -63,6 +63,25 @@ async function listGeminiSessionFiles(tmpDir) {
   return out;
 }
 
+async function listKimiSessionFiles(sessionsDir) {
+  const out = [];
+  const projects = await safeReadDir(sessionsDir);
+  for (const project of projects) {
+    if (!project.isDirectory()) continue;
+    const projectDir = path.join(sessionsDir, project.name);
+    const sessions = await safeReadDir(projectDir);
+    for (const session of sessions) {
+      if (!session.isDirectory()) continue;
+      const wirePath = path.join(projectDir, session.name, "wire.jsonl");
+      const st = await fs.stat(wirePath).catch(() => null);
+      if (!st || !st.isFile()) continue;
+      out.push(wirePath);
+    }
+  }
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
 async function listOpencodeMessageFiles(storageDir) {
   const out = [];
   const messageDir = path.join(storageDir, "message");
@@ -397,23 +416,21 @@ async function parseGeminiIncremental({
   return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
 }
 
-async function parseOpencodeIncremental({
-  messageFiles,
-  opencodeDbPath,
+async function parseKimiIncremental({
+  sessionFiles,
   cursors,
   queuePath,
   projectQueuePath,
   onProgress,
   source,
   publicRepoResolver,
-  readSqliteRows,
 }) {
   await ensureDir(path.dirname(queuePath));
   let filesProcessed = 0;
   let eventsAggregated = 0;
 
   const cb = typeof onProgress === "function" ? onProgress : null;
-  const files = Array.isArray(messageFiles) ? messageFiles : [];
+  const files = Array.isArray(sessionFiles) ? sessionFiles : [];
   const totalFiles = files.length;
   const hourlyState = normalizeHourlyState(cursors?.hourly);
   const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
@@ -421,14 +438,8 @@ async function parseOpencodeIncremental({
   const projectTouchedBuckets = projectEnabled ? new Set() : null;
   const projectMetaCache = projectEnabled ? new Map() : null;
   const publicRepoCache = projectEnabled ? new Map() : null;
-  const opencodeState = normalizeOpencodeState(cursors?.opencode);
-  const opencodeSqliteState = normalizeOpencodeSqliteState(cursors?.opencodeSqlite);
-  const messageIndex = opencodeState.messages;
   const touchedBuckets = new Set();
-  const defaultSource = normalizeSourceInput(source) || "opencode";
-  let sqliteStatus = opencodeSqliteState.lastStatus || "never_checked";
-  let sqliteCheckedAt = opencodeSqliteState.lastCheckedAt || null;
-  let sqliteErrorCode = opencodeSqliteState.lastErrorCode || null;
+  const defaultSource = normalizeSourceInput(source) || "kimi";
 
   if (!cursors.files || typeof cursors.files !== "object") {
     cursors.files = {};
@@ -448,30 +459,8 @@ async function parseOpencodeIncremental({
     const key = filePath;
     const prev = cursors.files[key] || null;
     const inode = st.ino || 0;
-    const size = Number.isFinite(st.size) ? st.size : 0;
-    const mtimeMs = Number.isFinite(st.mtimeMs) ? st.mtimeMs : 0;
-    const unchanged =
-      prev && prev.inode === inode && prev.size === size && prev.mtimeMs === mtimeMs;
-    if (unchanged) {
-      filesProcessed += 1;
-      if (cb) {
-        cb({
-          index: idx + 1,
-          total: totalFiles,
-          filePath,
-          filesProcessed,
-          eventsAggregated,
-          bucketsQueued: touchedBuckets.size,
-        });
-      }
-      continue;
-    }
+    const startOffset = prev && prev.inode === inode ? prev.offset || 0 : 0;
 
-    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 projectContext = projectEnabled
       ? await resolveProjectContextForFile({
           filePath,
@@ -484,11 +473,9 @@ async function parseOpencodeIncremental({
     const projectRef = projectContext?.projectRef || null;
     const projectKey = projectContext?.projectKey || null;
 
-    const result = await parseOpencodeMessageFile({
+    const result = await parseKimiFile({
       filePath,
-      messageIndex,
-      fallbackTotals,
-      fallbackMessageKey,
+      startOffset,
       hourlyState,
       touchedBuckets,
       source: fileSource,
@@ -500,23 +487,13 @@ async function parseOpencodeIncremental({
 
     cursors.files[key] = {
       inode,
-      size,
-      mtimeMs,
-      lastTotals: result.lastTotals,
-      messageKey: result.messageKey || null,
+      offset: result.endOffset,
       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,
@@ -529,6 +506,54 @@ async function parseOpencodeIncremental({
     }
   }
 
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  const projectBucketsQueued = projectEnabled
+    ? await enqueueTouchedProjectBuckets({ projectQueuePath, projectState, projectTouchedBuckets })
+    : 0;
+  hourlyState.updatedAt = new Date().toISOString();
+  cursors.hourly = hourlyState;
+  if (projectState) {
+    projectState.updatedAt = new Date().toISOString();
+    cursors.projectHourly = projectState;
+  }
+
+  return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
+}
+
+async function parseOpencodeIncremental({
+  opencodeDbPath,
+  cursors,
+  queuePath,
+  projectQueuePath,
+  onProgress,
+  source = "opencode",
+  publicRepoResolver = null,
+  readSqliteRows,
+}) {
+  await ensureDir(path.dirname(queuePath));
+  let filesProcessed = 0;
+  let eventsAggregated = 0;
+
+  const cb = typeof onProgress === "function" ? onProgress : null;
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
+  const projectState = projectEnabled ? normalizeProjectState(cursors?.projectHourly) : null;
+  const projectTouchedBuckets = projectEnabled ? new Set() : null;
+  const projectMetaCache = projectEnabled ? new Map() : null;
+  const publicRepoCache = projectEnabled ? new Map() : null;
+  const opencodeState = normalizeOpencodeState(cursors?.opencode);
+  const opencodeSqliteState = normalizeOpencodeSqliteState(cursors?.opencodeSqlite);
+  const messageIndex = opencodeState.messages;
+  const touchedBuckets = new Set();
+  const defaultSource = normalizeSourceInput(source) || "opencode";
+  let sqliteStatus = opencodeSqliteState.lastStatus || "never_checked";
+  let sqliteCheckedAt = opencodeSqliteState.lastCheckedAt || null;
+  let sqliteErrorCode = opencodeSqliteState.lastErrorCode || null;
+
+  if (!cursors.files || typeof cursors.files !== "object") {
+    cursors.files = {};
+  }
+
   if (typeof opencodeDbPath === "string" && opencodeDbPath.length > 0) {
     const readRows =
       typeof readSqliteRows === "function" ? readSqliteRows : readOpencodeSqliteRows;
@@ -818,6 +843,70 @@ async function parseClaudeFile({
   return { endOffset, eventsAggregated };
 }
 
+async function parseKimiFile({
+  filePath,
+  startOffset,
+  hourlyState,
+  touchedBuckets,
+  source,
+  projectState,
+  projectTouchedBuckets,
+  projectRef,
+  projectKey,
+}) {
+  const st = await fs.stat(filePath).catch(() => null);
+  if (!st || !st.isFile()) return { endOffset: startOffset, eventsAggregated: 0 };
+
+  const endOffset = st.size;
+  if (startOffset >= endOffset) return { endOffset, eventsAggregated: 0 };
+
+  const stream = fssync.createReadStream(filePath, { encoding: "utf8", start: startOffset });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+  let eventsAggregated = 0;
+  for await (const line of rl) {
+    if (!line || !line.includes("StatusUpdate")) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch (_e) {
+      continue;
+    }
+    if (!obj || !obj.message || obj.message.type !== "StatusUpdate") continue;
+
+    const payload = obj.message.payload;
+    const delta = normalizeKimiUsage(payload?.token_usage);
+    if (!delta || isAllZeroUsage(delta)) continue;
+
+    const tsIso = kimiTimestampToIso(obj.timestamp);
+    if (!tsIso) continue;
+
+    const bucketStart = toUtcHalfHourStart(tsIso);
+    if (!bucketStart) continue;
+
+    const model = normalizeModelInput(payload?.model) || DEFAULT_MODEL;
+    const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
+    addTotals(bucket.totals, delta);
+    touchedBuckets.add(bucketKey(source, model, bucketStart));
+    if (projectKey && projectState && projectTouchedBuckets) {
+      const projectBucket = getProjectBucket(
+        projectState,
+        projectKey,
+        source,
+        bucketStart,
+        projectRef,
+      );
+      addTotals(projectBucket.totals, delta);
+      projectTouchedBuckets.add(projectBucketKey(projectKey, source, bucketStart));
+    }
+    eventsAggregated += 1;
+  }
+
+  rl.close();
+  stream.close?.();
+  return { endOffset, eventsAggregated };
+}
+
 async function parseGeminiFile({
   filePath,
   startIndex,
@@ -2058,6 +2147,32 @@ function normalizeGeminiTokens(tokens) {
   };
 }
 
+function normalizeKimiUsage(usage) {
+  if (!usage || typeof usage !== "object") return null;
+  const inputOther = toNonNegativeInt(usage.input_other);
+  const cacheCreation = toNonNegativeInt(usage.input_cache_creation);
+  const cacheRead = toNonNegativeInt(usage.input_cache_read);
+  const output = toNonNegativeInt(usage.output);
+  const inputTokens = inputOther + cacheCreation;
+  const total = inputTokens + cacheRead + output;
+  return {
+    input_tokens: inputTokens,
+    cached_input_tokens: cacheRead,
+    output_tokens: output,
+    reasoning_output_tokens: 0,
+    total_tokens: total,
+  };
+}
+
+function kimiTimestampToIso(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const ms = n < 1e12 ? Math.floor(n * 1000) : Math.floor(n);
+  const date = new Date(ms);
+  const iso = date.toISOString();
+  return iso;
+}
+
 function normalizeOpencodeTokens(tokens) {
   if (!tokens || typeof tokens !== "object") return null;
   const input = toNonNegativeInt(tokens.input);
@@ -2293,10 +2408,12 @@ module.exports = {
   listRolloutFiles,
   listClaudeProjectFiles,
   listGeminiSessionFiles,
+  listKimiSessionFiles,
   listOpencodeMessageFiles,
   parseRolloutIncremental,
   parseClaudeIncremental,
   parseGeminiIncremental,
+  parseKimiIncremental,
   parseOpencodeIncremental,
   normalizeHourlyState,
   getHourlyBucket,

package/src/templates/hermes-vibeusage-plugin/__init__.py

@@ -0,0 +1,75 @@
+# VIBEUSAGE_HERMES_PLUGIN
+# Generated by VibeUsage. Do not edit manually.
+import json
+import os
+from datetime import datetime, timezone
+
+LEDGER_PATH = "__LEDGER_PATH__"
+SOURCE = "hermes"
+VERSION = 1
+
+
+def _iso_now():
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _safe_int(value):
+    try:
+        return max(0, int(value or 0))
+    except Exception:
+        return 0
+
+
+def _append_record(record):
+    try:
+        os.makedirs(os.path.dirname(LEDGER_PATH), exist_ok=True)
+        with open(LEDGER_PATH, "a", encoding="utf-8") as handle:
+            handle.write(json.dumps(record, ensure_ascii=False) + "\n")
+    except Exception:
+        return None
+    return None
+
+
+def _base_record(record_type, session_id="", platform="", model="", provider=""):
+    return {
+        "version": VERSION,
+        "type": str(record_type or ""),
+        "source": SOURCE,
+        "session_id": str(session_id or ""),
+        "platform": str(platform or ""),
+        "model": str(model or ""),
+        "provider": str(provider or ""),
+        "emitted_at": _iso_now(),
+    }
+
+
+def on_session_start(session_id="", model="", platform="", **_kwargs):
+    return _append_record(_base_record("session_start", session_id=session_id, platform=platform, model=model))
+
+
+def post_api_request(session_id="", platform="", model="", provider="", api_mode="", api_call_count=0, finish_reason="", usage=None, **_kwargs):
+    if not isinstance(usage, dict):
+        return None
+    record = _base_record("usage", session_id=session_id, platform=platform, model=model, provider=provider)
+    record.update({
+        "api_mode": str(api_mode or ""),
+        "api_call_count": _safe_int(api_call_count),
+        "input_tokens": _safe_int(usage.get("input_tokens")),
+        "output_tokens": _safe_int(usage.get("output_tokens")),
+        "cache_read_tokens": _safe_int(usage.get("cache_read_tokens")),
+        "cache_write_tokens": _safe_int(usage.get("cache_write_tokens")),
+        "reasoning_tokens": _safe_int(usage.get("reasoning_tokens")),
+        "total_tokens": _safe_int(usage.get("total_tokens")),
+        "finish_reason": str(finish_reason or ""),
+    })
+    return _append_record(record)
+
+
+def on_session_end(session_id="", model="", platform="", **_kwargs):
+    return _append_record(_base_record("session_end", session_id=session_id, platform=platform, model=model))
+
+
+def register(ctx):
+    ctx.register_hook("on_session_start", on_session_start)
+    ctx.register_hook("post_api_request", post_api_request)
+    ctx.register_hook("on_session_end", on_session_end)

package/src/templates/hermes-vibeusage-plugin/plugin.yaml

@@ -0,0 +1,9 @@
+# VIBEUSAGE_HERMES_PLUGIN
+name: vibeusage
+version: "1"
+description: "VibeUsage Hermes usage ledger plugin"
+author: "VibeUsage"
+provides_hooks:
+  - "on_session_start"
+  - "post_api_request"
+  - "on_session_end"