@vibe-cafe/vibe-usage 0.7.15 → 0.7.17

package/README.md

@@ -70,6 +70,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 - Extracts session metadata from all parsers: active time (AI generation time, excluding queue/TTFT wait), total duration, message counts
 - Uploads buckets + sessions to your vibecafe.ai dashboard (gzip-compressed when ≥ 1 KB, ~94% smaller)
 - Stateless: computes full totals from local logs each sync (idempotent, no state files)
+- SQLite-backed tools (Cursor, OpenCode, Kiro, Hermes) are read via Node's built-in `node:sqlite` on Node ≥ 22.5 — no `sqlite3` binary needed (works on Windows out of the box); on older Node it falls back to the system `sqlite3` CLI
 - For continuous syncing, use `npx @vibe-cafe/vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 
 ## AI Skill

package/package.json

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

package/src/parsers/codex.js

@@ -27,6 +27,26 @@ function findJsonlFiles(dir) {
   return results;
 }
 
+/**
+ * Count the leading `event_msg/token_count` records in a session file.
+ * Used to size the replayed-history block of a forked session: a fork
+ * copies the original conversation verbatim, so it begins with exactly as
+ * many token_count records as the original session has in total.
+ */
+function countTokenCountRecords(content) {
+  let n = 0;
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === 'event_msg' && obj.payload?.type === 'token_count') n++;
+    } catch {
+      continue;
+    }
+  }
+  return n;
+}
+
 export async function parse() {
   if (!existsSync(SESSIONS_DIR)) return { buckets: [], sessions: [] };
 
@@ -34,19 +54,72 @@ export async function parse() {
   const sessionEvents = [];
   const files = findJsonlFiles(SESSIONS_DIR);
   if (files.length === 0) return { buckets: [], sessions: [] };
-  for (const filePath of files) {
 
+  // Pass 1: index every session by its UUID and count its token_count
+  // records. A forked session (session_meta.payload.forked_from_id) starts
+  // with the original conversation replayed verbatim — including every
+  // token_count, all timestamped in a burst at the fork instant. Those
+  // tokens are already counted from the original session's own file, so
+  // re-counting them here double-counts usage and produces a spurious
+  // token/cost spike at the fork time. Timestamps cannot distinguish the
+  // replay from new activity (the replay burst is stamped at/after the fork
+  // instant, within the same 1–3s window), so we instead skip exactly the
+  // original session's token_count count from the start of each fork.
+  const tokenCountById = new Map(); // sessionId → number of token_count records
+  const fileMeta = new Map(); // filePath → { content, forkedFromId }
+  for (const filePath of files) {
     let content;
     try {
       content = readFileSync(filePath, 'utf-8');
     } catch {
       continue;
     }
+    let sessionId = null;
+    let forkedFromId = null;
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === 'session_meta' && obj.payload) {
+          sessionId = obj.payload.id || null;
+          forkedFromId = obj.payload.forked_from_id || null;
+        }
+      } catch { /* ignore */ }
+      break; // session_meta is always the first line
+    }
+    fileMeta.set(filePath, { content, forkedFromId });
+    if (sessionId) {
+      tokenCountById.set(sessionId, countTokenCountRecords(content));
+    }
+  }
 
-    // Extract project name and model from session_meta line
+  // Pass 2: parse usage, skipping each fork's replayed-history token_counts.
+  for (const filePath of files) {
+    const fm = fileMeta.get(filePath);
+    if (!fm) continue;
+    const { content, forkedFromId } = fm;
+
+    const lines = content.split('\n');
+
+    // How many leading token_count records are copied history. A fork's file
+    // begins with the *entire* source file replayed verbatim, so the count
+    // to skip is the source's total token_count count. This is correct even
+    // for chained forks: a fork-of-a-fork replays the parent fork's whole
+    // file (which itself already contains the grandparent's replay), so
+    // skipping the parent's full count skips exactly the duplicated region.
+    // If the source file is missing (rotated/deleted) we cannot locate the
+    // boundary; skip nothing so incomplete data over-counts rather than
+    // silently dropping real usage.
+    let replayTokenCountToSkip = 0;
+    if (forkedFromId != null) {
+      replayTokenCountToSkip = tokenCountById.get(forkedFromId) ?? 0;
+    }
+    let tokenCountSeen = 0;
+
+    // Extract project name from session_meta.
     let sessionProject = 'unknown';
     let sessionModel = 'unknown';
-    for (const line of content.split('\n')) {
+    for (const line of lines) {
       if (!line.trim()) continue;
       try {
         const obj = JSON.parse(line);
@@ -60,29 +133,44 @@ export async function parse() {
             const match = meta.git.repository_url.match(/([^/]+\/[^/]+?)(?:\.git)?$/);
             if (match) sessionProject = match[1];
           }
-          break;
         }
-      } catch { break; }
+      } catch { /* ignore */ }
+      break; // session_meta is always the first line
     }
 
     let turnContextModel = 'unknown';
     const prevTotal = new Map();
-    for (const line of content.split('\n')) {
+    for (const line of lines) {
       if (!line.trim()) continue;
       try {
         const obj = JSON.parse(line);
 
+        // A fork's replayed-history block is the run from the start of the
+        // file up to and including the Nth token_count, where N is the source
+        // session's total token_count count. We are still inside that block
+        // until we have *passed* the Nth token_count. (token_count is the
+        // last event of each turn, so the boundary lands cleanly at a turn
+        // edge — the new conversation's events come strictly after it.)
+        const inReplayBlock = tokenCountSeen < replayTokenCountToSkip;
+
         if (obj.timestamp) {
           const evTs = new Date(obj.timestamp);
           if (!isNaN(evTs.getTime())) {
-            const isUserTurn = obj.type === 'turn_context' || obj.type === 'session_meta';
-            sessionEvents.push({
-              sessionId: filePath,
-              source: 'codex',
-              project: sessionProject,
-              timestamp: evTs,
-              role: isUserTurn ? 'user' : 'assistant',
-            });
+            // Skip replayed history events so a forked session's
+            // duration/active-time/message counts reflect only the new
+            // conversation, not the copied original. session_meta itself is
+            // kept: it marks when the fork actually started.
+            const isReplay = inReplayBlock && obj.type !== 'session_meta';
+            if (!isReplay) {
+              const isUserTurn = obj.type === 'turn_context' || obj.type === 'session_meta';
+              sessionEvents.push({
+                sessionId: filePath,
+                source: 'codex',
+                project: sessionProject,
+                timestamp: evTs,
+                role: isUserTurn ? 'user' : 'assistant',
+              });
+            }
           }
         }
 
@@ -104,6 +192,14 @@ export async function parse() {
         const timestamp = obj.timestamp ? new Date(obj.timestamp) : null;
         if (!timestamp || isNaN(timestamp.getTime())) continue;
 
+        // This is the (tokenCountSeen+1)-th token_count in the file. If it
+        // falls inside the fork's replay block it's an exact copy of a record
+        // already counted from the source session's own file — skip it (but
+        // still advance the cumulative-total baseline below so the first real
+        // post-fork delta is measured correctly).
+        const isReplayedHistory = tokenCountSeen < replayTokenCountToSkip;
+        tokenCountSeen++;
+
         // Prefer incremental per-request usage; compute delta from cumulative total as fallback
         let usage = info.last_token_usage;
         if (!usage && info.total_token_usage) {
@@ -121,9 +217,13 @@ export async function parse() {
             // First cumulative entry — use as-is (it's the first event's total)
             usage = curr;
           }
+          // Always advance the cumulative baseline, even for replayed history,
+          // so the first real post-fork delta is measured against the last
+          // replayed total instead of being mistaken for a fresh "first entry".
           prevTotal.set(totalKey, { ...curr });
         }
         if (!usage) continue;
+        if (isReplayedHistory) continue;
 
         const model = info.model || payload.model || turnContextModel || sessionModel;
 

package/src/parsers/cursor.js

@@ -1,8 +1,8 @@
-import { execFileSync } from 'node:child_process';
 import { copyFileSync, existsSync, mkdtempSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { aggregateToBuckets } from './index.js';
+import { queryDbJson } from './sqlite.js';
 
 const STATE_DB_RELATIVE = join('User', 'globalStorage', 'state.vscdb');
 const ACCESS_TOKEN_KEY = 'cursorAuth/accessToken';
@@ -66,14 +66,7 @@ function readAccessToken(dbPath) {
 
 function queryAccessToken(dbPath) {
   const sql = `SELECT value FROM ItemTable WHERE key = '${ACCESS_TOKEN_KEY}' LIMIT 1`;
-  const out = execFileSync('sqlite3', ['-json', dbPath, sql], {
-    encoding: 'utf-8',
-    maxBuffer: 4 * 1024 * 1024,
-    timeout: 15000,
-  });
-  const trimmed = out.trim();
-  if (!trimmed || trimmed === '[]') return null;
-  const rows = JSON.parse(trimmed);
+  const rows = queryDbJson(dbPath, sql, { maxBuffer: 4 * 1024 * 1024, timeout: 15000 });
   const value = rows[0]?.value;
   if (typeof value !== 'string') return null;
   const t = value.trim();
@@ -182,7 +175,7 @@ export async function parse() {
     token = readAccessToken(dbPath);
   } catch (err) {
     if (err && typeof err.message === 'string' && err.message.includes('ENOENT')) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Cursor data.');
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Cursor data.');
     }
     throw err;
   }

package/src/parsers/hermes.js

@@ -1,8 +1,8 @@
-import { execFileSync } from 'node:child_process';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
+import { queryDbJson } from './sqlite.js';
 
 const HERMES_HOME = process.env.HERMES_HOME || join(homedir(), '.hermes');
 
@@ -38,7 +38,7 @@ export async function parse() {
         WHERE input_tokens > 0 OR output_tokens > 0`);
     } catch (err) {
       if (err.message && err.message.includes('ENOENT')) {
-        throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Hermes data.');
+        throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Hermes data.');
       }
       throw err;
     }
@@ -121,14 +121,5 @@ function discoverDbPaths(home) {
 }
 
 function queryDb(dbPath, sql) {
-  const output = execFileSync('sqlite3', [
-    '-json',
-    dbPath,
-    sql,
-  ], { encoding: 'utf-8', maxBuffer: 100 * 1024 * 1024, timeout: 30000 });
-
-  const trimmed = output.trim();
-  if (!trimmed || trimmed === '[]') return [];
-
-  return JSON.parse(trimmed);
+  return queryDbJson(dbPath, sql);
 }

package/src/parsers/kiro.js

@@ -1,4 +1,3 @@
-import { execFileSync } from 'node:child_process';
 import {
   copyFileSync,
   existsSync,
@@ -11,6 +10,7 @@ import {
 import { join, resolve } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { aggregateToBuckets } from './index.js';
+import { queryDbJson } from './sqlite.js';
 
 const KIROAGENT_RELATIVE = join('User', 'globalStorage', 'kiro.kiroagent');
 
@@ -41,14 +41,7 @@ function isLockError(err) {
 }
 
 function queryDb(dbPath, sql) {
-  const out = execFileSync('sqlite3', ['-json', dbPath, sql], {
-    encoding: 'utf-8',
-    maxBuffer: 100 * 1024 * 1024,
-    timeout: 30000,
-  });
-  const trimmed = out.trim();
-  if (!trimmed || trimmed === '[]') return [];
-  return JSON.parse(trimmed);
+  return queryDbJson(dbPath, sql);
 }
 
 const TOKENS_SQL =
@@ -195,7 +188,7 @@ export async function parse() {
     }
   } catch (err) {
     if (err && typeof err.message === 'string' && err.message.includes('ENOENT')) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Kiro data.');
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Kiro data.');
     }
     throw err;
   }

package/src/parsers/opencode.js

@@ -1,8 +1,8 @@
-import { execFileSync } from 'node:child_process';
-import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
+import { queryDbJson } from './sqlite.js';
 
 const DATA_DIR = join(homedir(), '.local', 'share', 'opencode');
 const DB_PATH = join(DATA_DIR, 'opencode.db');
@@ -33,29 +33,16 @@ function parseFromSqlite() {
     json_extract(data, '$.path.root') as rootPath
     FROM message`;
 
-  let output;
+  let rows;
   try {
-    output = execFileSync('sqlite3', [
-      '-json',
-      DB_PATH,
-      query,
-    ], { encoding: 'utf-8', maxBuffer: 100 * 1024 * 1024, timeout: 30000 });
+    rows = queryDbJson(DB_PATH, query);
   } catch (err) {
     if (err.status === 127 || (err.message && err.message.includes('ENOENT'))) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync opencode data.');
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync opencode data.');
     }
     throw err;
   }
-
-  output = output.trim();
-  if (!output || output === '[]') return { buckets: [], sessions: [] };
-
-  let rows;
-  try {
-    rows = JSON.parse(output);
-  } catch {
-    throw new Error('Failed to parse sqlite3 JSON output');
-  }
+  if (!rows.length) return { buckets: [], sessions: [] };
 
   const entries = [];
   const sessionEvents = [];

package/src/parsers/sqlite.js

@@ -0,0 +1,74 @@
+import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Run a SQL query against a SQLite database and return rows as plain objects
+ * (column name → value), mirroring the shape of `sqlite3 -json` output.
+ *
+ * Prefers Node's built-in `node:sqlite` (available on Node >= 22.5, no external
+ * binary needed — important on Windows where the `sqlite3` CLI is rarely on
+ * PATH). Falls back to shelling out to the `sqlite3` CLI on older Node.
+ *
+ * If neither is available, throws an Error whose message contains "ENOENT" so
+ * callers can surface an "Install sqlite3" hint, matching the previous behavior.
+ */
+export function queryDbJson(dbPath, sql, { timeout = 30000, maxBuffer = 100 * 1024 * 1024 } = {}) {
+  const db = openNodeSqlite(dbPath);
+  if (db) {
+    try {
+      return db.prepare(sql).all();
+    } finally {
+      db.close();
+    }
+  }
+  return queryViaCli(dbPath, sql, { timeout, maxBuffer });
+}
+
+let nodeSqlite; // undefined = not tried, null = unavailable
+
+function getNodeSqlite() {
+  if (nodeSqlite !== undefined) return nodeSqlite;
+  try {
+    // Suppress the one-time "SQLite is an experimental feature" ExperimentalWarning
+    // on Node versions where node:sqlite is still flagged experimental.
+    const prevEmit = process.emitWarning;
+    process.emitWarning = (warning, ...rest) => {
+      const opts = rest[0];
+      const type = typeof opts === 'object' && opts ? opts.type : opts;
+      const name = typeof warning === 'object' && warning ? warning.name : undefined;
+      if ((type === 'ExperimentalWarning' || name === 'ExperimentalWarning') && String(warning).includes('SQLite')) return;
+      return prevEmit.call(process, warning, ...rest);
+    };
+    try {
+      nodeSqlite = require('node:sqlite');
+    } finally {
+      process.emitWarning = prevEmit;
+    }
+  } catch {
+    nodeSqlite = null;
+  }
+  return nodeSqlite;
+}
+
+function openNodeSqlite(dbPath) {
+  const mod = getNodeSqlite();
+  if (!mod || !mod.DatabaseSync) return null;
+  try {
+    return new mod.DatabaseSync(dbPath, { readOnly: true });
+  } catch {
+    return null;
+  }
+}
+
+function queryViaCli(dbPath, sql, { timeout, maxBuffer }) {
+  const out = execFileSync('sqlite3', ['-json', dbPath, sql], {
+    encoding: 'utf-8',
+    maxBuffer,
+    timeout,
+  });
+  const trimmed = out.trim();
+  if (!trimmed || trimmed === '[]') return [];
+  return JSON.parse(trimmed);
+}