@vibe-cafe/vibe-usage 0.9.6 → 0.9.8

package/README.md

@@ -63,7 +63,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Amp | `~/.local/share/amp/threads/` |
 | Droid | `~/.factory/sessions/` |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
-| Kiro | Kiro CLI `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` plus optional `~/.kiro_sessions/*.json` archives (estimated tokens: CacheWrite = chars/4, CacheRead = accumulated context, Output = streamed chunks). If no CLI data exists, falls back to IDE `q-client.log` credit deltas as `kiro-credits`; legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
+| Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
 | Cline | `<host>/User/globalStorage/saoudrizwan.claude-dev/{state/taskHistory.json,tasks/<id>/ui_messages.json}` (walks all VSCode-fork hosts: Code, Cursor, Windsurf, VSCodium, Trae, ...) |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
 | Antigravity | `~/.gemini/antigravity/conversations/*.pb` to discover cascades, then reads token usage + sessions from the running language server via Connect RPC (process discovered with `ps`/`lsof` on macOS/Linux, PowerShell CIM with a `wmic` fallback on Windows) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "scripts": {

package/src/parsers/index.js

@@ -46,24 +46,43 @@ export function roundToHalfHour(date) {
   return d;
 }
 
+// Server column limits (usage_buckets: model varchar(100), project varchar(200)).
+// Anything longer aborts the whole INSERT chunk with 22001, so clamp here.
+const MODEL_MAX_LENGTH = 100;
+const PROJECT_MAX_LENGTH = 200;
+
+// Server token columns are bigint — a single fractional/NaN value aborts the
+// whole INSERT chunk with 22P02, taking every other tool's rows in the batch
+// down with it.
+function toTokenCount(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  return Math.round(n);
+}
+
 export function aggregateToBuckets(entries) {
   const map = new Map();
 
   for (const e of entries) {
+    const model = String(e.model || 'unknown').slice(0, MODEL_MAX_LENGTH);
+    const project = String(e.project || 'unknown').slice(0, PROJECT_MAX_LENGTH);
     const bucketStart = roundToHalfHour(e.timestamp).toISOString();
-    const key = `${e.source}|${e.model}|${e.project}|${bucketStart}`;
+    const key = `${e.source}|${model}|${project}|${e.hostname || ''}|${bucketStart}`;
 
     if (!map.has(key)) {
       map.set(key, {
         source: e.source,
-        model: e.model,
-        project: e.project,
+        model,
+        project,
+        // Cloud-sourced parsers (cursor) pre-set a fixed hostname sentinel; it
+        // must survive aggregation, or sync.js stamps the machine hostname and
+        // every machine gets its own duplicate row server-side.
+        ...(e.hostname ? { hostname: e.hostname } : {}),
         bucketStart,
         inputTokens: 0,
         outputTokens: 0,
         cachedInputTokens: 0,
         reasoningOutputTokens: 0,
-        totalTokens: 0,
       });
     }
 
@@ -72,10 +91,24 @@ export function aggregateToBuckets(entries) {
     b.outputTokens += e.outputTokens || 0;
     b.cachedInputTokens += e.cachedInputTokens || 0;
     b.reasoningOutputTokens += e.reasoningOutputTokens || 0;
-    b.totalTokens += (e.inputTokens || 0) + (e.outputTokens || 0) + (e.reasoningOutputTokens || 0);
   }
 
-  return Array.from(map.values());
+  // Clamp after summation, not per entry — rounding each entry first would
+  // discard sub-integer values instead of letting them accumulate.
+  return Array.from(map.values()).map((b) => {
+    const inputTokens = toTokenCount(b.inputTokens);
+    const outputTokens = toTokenCount(b.outputTokens);
+    const cachedInputTokens = toTokenCount(b.cachedInputTokens);
+    const reasoningOutputTokens = toTokenCount(b.reasoningOutputTokens);
+    return {
+      ...b,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+      totalTokens: inputTokens + outputTokens + reasoningOutputTokens,
+    };
+  });
 }
 
 /**

package/src/parsers/kiro.js

@@ -19,6 +19,25 @@ const KIRO_USER_RELATIVE = 'User';
 const CREDIT_MODEL = 'kiro-credits';
 const ESTIMATE_MODEL = 'kiro-token-estimate';
 const CHARS_PER_TOKEN = 4;
+const IMAGE_TOKENS = 1600;
+
+// The official Kiro CLI persists each conversation as a `{version, kind, data}`
+// event stream under ~/.kiro/sessions/cli/<uuid>.jsonl (companion <uuid>.json
+// holds cwd + model). It carries NO token counts, so tokens are estimated from
+// text length (chars/CHARS_PER_TOKEN), the same heuristic used elsewhere here.
+//
+// String values that are NOT linguistic tokens are excluded from the count.
+// The big one is `signature`: extended-thinking blocks carry a ~500-char crypto
+// signature; counting it as text inflates "output" by well over 100%.
+const NON_TEXT_KEYS = new Set([
+  'signature', 'redactedContent', 'toolUseId', 'modelId', 'message_id', 'format', 'id',
+]);
+
+// System prompt + tool JSON schemas are injected on every request but never
+// written to the session log, so the stream alone counts none of them. They are
+// a near-constant per-call overhead. Keep the default at 0 so the parser reports
+// only observed log text unless the user explicitly opts into an estimate.
+const DEFAULT_KIRO_CLI_SYSTEM_OVERHEAD_TOKENS = 0;
 
 function getDefaultAppPath() {
   if (process.platform === 'darwin') {
@@ -92,6 +111,17 @@ export function getKiroSessionsDir() {
   return existsSync(def) ? def : null;
 }
 
+// Native Kiro CLI session event streams: ~/.kiro/sessions/cli/*.jsonl
+export function getKiroCliSessionsDir() {
+  const explicit = process.env.KIRO_CLI_SESSIONS_DIR?.trim();
+  if (explicit) {
+    const r = resolve(explicit);
+    return existsSync(r) ? r : null;
+  }
+  const def = join(homedir(), '.kiro', 'sessions', 'cli');
+  return existsSync(def) ? def : null;
+}
+
 function isLockError(err) {
   return err && typeof err.message === 'string' && /database is locked/i.test(err.message);
 }
@@ -400,6 +430,172 @@ function readCliEstimateEntries() {
   return conversationsToEstimateEntries(conversations);
 }
 
+// ---------------------------------------------------------------------------
+// Native Kiro CLI event-stream sessions: ~/.kiro/sessions/cli/<uuid>.jsonl
+// Each line is a {version, kind, data} event. Relevant kinds:
+//   Prompt           user turn; data.content[] (text/image); data.meta.timestamp
+//                    is the ONLY timestamp (epoch SECONDS).
+//   AssistantMessage data.content[] items: text (reply), thinking (reasoning +
+//                    modelId + crypto signature), toolUse (name + input).
+//   ToolResults      tool output fed back as context for the next turn.
+//   Compaction       context was summarized; resets the running context size.
+// ---------------------------------------------------------------------------
+
+// Sum of string-leaf character lengths, skipping non-linguistic keys.
+function textLeafChars(value) {
+  if (typeof value === 'string') return value.length;
+  if (Array.isArray(value)) {
+    let n = 0;
+    for (const v of value) n += textLeafChars(v);
+    return n;
+  }
+  if (value && typeof value === 'object') {
+    let n = 0;
+    for (const [k, v] of Object.entries(value)) {
+      if (NON_TEXT_KEYS.has(k)) continue;
+      n += textLeafChars(v);
+    }
+    return n;
+  }
+  return 0;
+}
+
+function estTokens(value) {
+  return Math.floor(textLeafChars(value) / CHARS_PER_TOKEN);
+}
+
+function getKiroCliSystemOverheadTokens() {
+  const raw = process.env.KIRO_CLI_SYSTEM_OVERHEAD_TOKENS;
+  if (raw === undefined || raw.trim() === '') return DEFAULT_KIRO_CLI_SYSTEM_OVERHEAD_TOKENS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+
+function loadCliSessionMeta(sessionsDir, sessionId) {
+  try {
+    const d = JSON.parse(readFileSync(join(sessionsDir, `${sessionId}.json`), 'utf-8'));
+    return {
+      cwd: (d && typeof d.cwd === 'string' && d.cwd) || 'unknown',
+      model: d?.session_state?.rts_model_state?.model_info?.model_id || null,
+    };
+  } catch {
+    return { cwd: 'unknown', model: null };
+  }
+}
+
+async function readCliSessionEntries(sessionsDir, fileName) {
+  const sessionId = fileName.replace(/\.jsonl$/, '');
+  const { cwd, model: metaModel } = loadCliSessionMeta(sessionsDir, sessionId);
+  const filePath = join(sessionsDir, fileName);
+
+  let mtime;
+  try { mtime = statSync(filePath).mtime; } catch { mtime = new Date(); }
+
+  const events = [];
+  const rl = createInterface({
+    input: createReadStream(filePath, { encoding: 'utf-8' }),
+    crlfDelay: Infinity,
+  });
+  for await (const raw of rl) {
+    const line = raw.trim();
+    if (!line) continue;
+    try { events.push(JSON.parse(line)); } catch { /* skip malformed line */ }
+  }
+
+  return cliEventsToEntries(events, { cwd, model: metaModel, fallbackTimestamp: mtime });
+}
+
+// Pure state machine over a Kiro CLI session's ordered events. Exposed for tests.
+export function cliEventsToEntries(events, { cwd = 'unknown', model = null, fallbackTimestamp = null } = {}) {
+  const entries = [];
+  let curTs = null;      // Date from the enclosing Prompt (epoch seconds)
+  let cumulative = 0;    // running conversation context, re-sent every turn
+  let pendingInput = 0;  // fresh input accumulated since the last assistant turn
+  let curModel = model;
+
+  for (const ev of events) {
+    const data = ev?.data;
+    if (!data || typeof data !== 'object') continue;
+    const content = Array.isArray(data.content) ? data.content : [];
+
+    if (ev.kind === 'Prompt') {
+      const ts = data.meta?.timestamp;
+      if (typeof ts === 'number' && ts > 0) curTs = new Date(ts * 1000);
+      for (const item of content) {
+        pendingInput += item?.kind === 'image' ? IMAGE_TOKENS : estTokens(item?.data);
+      }
+    } else if (ev.kind === 'ToolResults') {
+      for (const item of content) pendingInput += estTokens(item?.data);
+    } else if (ev.kind === 'AssistantMessage') {
+      let output = 0;
+      let reasoning = 0;
+      let signatureTokens = 0;
+      for (const item of content) {
+        const cd = item?.data;
+        if (cd && typeof cd === 'object' && typeof cd.modelId === 'string' && cd.modelId) {
+          curModel = cd.modelId;
+        }
+        if (item?.kind === 'thinking' && cd && typeof cd === 'object') {
+          reasoning += Math.floor(String(cd.text ?? '').length / CHARS_PER_TOKEN);
+          // Signature persists in history and is re-sent as context on every
+          // later turn, but it is NOT model output — keep it out of output.
+          signatureTokens += Math.floor(String(cd.signature ?? '').length / CHARS_PER_TOKEN);
+        } else {
+          output += estTokens(cd);
+        }
+      }
+
+      const inputTokens = pendingInput;
+      // Each request re-sends the whole prior conversation (cache read) plus the
+      // optional per-call system-prompt/tool-schema overhead.
+      const cachedInputTokens = cumulative + getKiroCliSystemOverheadTokens();
+
+      if (inputTokens > 0 || output > 0 || reasoning > 0) {
+        entries.push({
+          source: 'kiro',
+          model: curModel || ESTIMATE_MODEL,
+          project: cwd,
+          timestamp: curTs || fallbackTimestamp || new Date(),
+          inputTokens,
+          outputTokens: output,
+          cachedInputTokens,
+          reasoningOutputTokens: reasoning,
+        });
+      }
+
+      // Grow the running context: fresh input + everything generated this turn,
+      // including the thinking signature (it persists in history and is re-sent).
+      cumulative += inputTokens + output + reasoning + signatureTokens;
+      pendingInput = 0;
+    } else if (ev.kind === 'Compaction') {
+      cumulative = estTokens(data.summary);
+      pendingInput = 0;
+    }
+  }
+
+  return entries;
+}
+
+async function readCliSessionStreamEntries() {
+  const dir = getKiroCliSessionsDir();
+  if (!dir) return [];
+  let files;
+  try {
+    files = readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const file of files) {
+    try {
+      entries.push(...await readCliSessionEntries(dir, file));
+    } catch {
+      // skip unreadable / concurrently rotated session
+    }
+  }
+  return entries;
+}
+
 function parseLogTimestamp(raw) {
   const d = new Date(String(raw).replace(' ', 'T'));
   return isNaN(d.getTime()) ? null : d;
@@ -540,7 +736,12 @@ export function snapshotsToCreditEntries(snapshots) {
       continue;
     }
 
-    const delta = Number((snapshot.currentUsage - prev.currentUsage).toFixed(4));
+    // The server's token columns are bigint, so fractional credit deltas
+    // cannot be uploaded as-is. Diff floored cumulative values instead of
+    // rounding each delta: the diffs telescope, so sub-integer usage is never
+    // lost or double-counted — it surfaces on whichever snapshot crosses the
+    // next whole-credit boundary.
+    const delta = Math.floor(snapshot.currentUsage) - Math.floor(prev.currentUsage);
     if (delta > 0) {
       entries.push({
         source: 'kiro',
@@ -574,6 +775,15 @@ function parseLegacyTokens(base) {
 }
 
 export async function parse() {
+  // 1. Official Kiro CLI native event streams (~/.kiro/sessions/cli/*.jsonl).
+  //    This is where the shipping CLI actually records conversations; the
+  //    conversations_v2 DB path below is empty on those installs.
+  const streamEntries = await readCliSessionStreamEntries();
+  if (streamEntries.length > 0) {
+    return { buckets: aggregateToBuckets(streamEntries), sessions: [] };
+  }
+
+  // 2. Kiro CLI conversations DB / archived snapshots (other CLI variants).
   try {
     const estimateEntries = readCliEstimateEntries();
     if (estimateEntries.length > 0) {