@vibe-cafe/vibe-usage 0.10.10 → 0.10.12

package/src/parsers/cursor.js

@@ -1,8 +1,8 @@
-import { copyFileSync, existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { existsSync } 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';
+import { homedir } from 'node:os';
+import { aggregateToBuckets } from './aggregate.js';
+import { queryDbJsonSnapshotOnLock, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 
 const STATE_DB_RELATIVE = join('User', 'globalStorage', 'state.vscdb');
 const ACCESS_TOKEN_KEY = 'cursorAuth/accessToken';
@@ -42,41 +42,19 @@ export function getCursorStateDbPath() {
 }
 
 function readAccessToken(dbPath) {
-  let snapshotDir = null;
-  let queryPath = dbPath;
-  try {
-    return queryAccessToken(queryPath);
-  } catch (err) {
-    // Cursor app holds a write lock; copy WAL set to a temp dir and retry
-    if (!isLockError(err)) throw err;
-    snapshotDir = mkdtempSync(join(tmpdir(), 'vibe-usage-cursor-'));
-    queryPath = join(snapshotDir, 'state.vscdb');
-    copyFileSync(dbPath, queryPath);
-    for (const suffix of ['-shm', '-wal']) {
-      const companion = `${dbPath}${suffix}`;
-      if (existsSync(companion)) copyFileSync(companion, `${queryPath}${suffix}`);
-    }
-    try {
-      return queryAccessToken(queryPath);
-    } finally {
-      rmSync(snapshotDir, { recursive: true, force: true });
-    }
-  }
-}
-
-function queryAccessToken(dbPath) {
+  // Cursor app holds a write lock; queryDbJsonSnapshotOnLock copies the WAL set
+  // to a temp dir and retries on "database is locked".
   const sql = `SELECT value FROM ItemTable WHERE key = '${ACCESS_TOKEN_KEY}' LIMIT 1`;
-  const rows = queryDbJson(dbPath, sql, { maxBuffer: 4 * 1024 * 1024, timeout: 15000 });
+  const rows = queryDbJsonSnapshotOnLock(dbPath, sql, {
+    tempPrefix: 'vibe-usage-cursor-',
+    opts: { maxBuffer: 4 * 1024 * 1024, timeout: 15000 },
+  });
   const value = rows[0]?.value;
   if (typeof value !== 'string') return null;
   const t = value.trim();
   return t || null;
 }
 
-function isLockError(err) {
-  return err && typeof err.message === 'string' && /database is locked/i.test(err.message);
-}
-
 function decodeJwtSub(token) {
   const payload = token.split('.')[1];
   if (!payload) return null;
@@ -197,8 +175,8 @@ export async function parse() {
   try {
     token = readAccessToken(dbPath);
   } catch (err) {
-    if (err && typeof err.message === 'string' && err.message.includes('ENOENT')) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Cursor data.');
+    if (isSqliteUnavailableError(err)) {
+      throw sqliteUnavailableError('Cursor');
     }
     throw err;
   }

package/src/parsers/dimagent.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
-import { aggregateToBuckets, extractSessions } from './index.js';
-import { queryDbJson } from './sqlite.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { toCount } from './fs-utils.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 import { getDimAgentDbPath } from '../tools.js';
 
 const SOURCE = 'dimagent';
@@ -12,11 +13,6 @@ function projectName(cwd) {
   return parts.at(-1) || 'unknown';
 }
 
-function tokenCount(value) {
-  const count = Number(value);
-  return Number.isFinite(count) && count > 0 ? count : 0;
-}
-
 function usageSignature(row) {
   return [
     row.runId || '',
@@ -55,10 +51,10 @@ function parseUsageRows(rows) {
     const timestamp = new Date(row.createdAt);
     if (Number.isNaN(timestamp.getTime())) continue;
 
-    const promptTokens = tokenCount(usage.promptTokens);
-    const cachedInputTokens = tokenCount(usage.cacheReadTokens);
+    const promptTokens = toCount(usage.promptTokens);
+    const cachedInputTokens = toCount(usage.cacheReadTokens);
     const inputTokens = Math.max(0, promptTokens - cachedInputTokens);
-    const outputTokens = tokenCount(usage.completionTokens);
+    const outputTokens = toCount(usage.completionTokens);
     if (inputTokens + outputTokens + cachedInputTokens === 0) continue;
 
     entries.push({
@@ -80,9 +76,7 @@ function queryDb(dbPath, sql) {
   try {
     return queryDbJson(dbPath, sql);
   } catch (err) {
-    if (err.code === 'ENOENT' || err.status === 127 || err.message?.includes('ENOENT')) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync DimAgent data.');
-    }
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('DimAgent');
     throw err;
   }
 }

package/src/parsers/droid.js

@@ -1,7 +1,7 @@
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
-import { aggregateToBuckets, extractSessions } from './index.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
 
 const DROID_SESSIONS_DIR = join(homedir(), '.factory', 'sessions');
 

package/src/parsers/dsh.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { basename, join, relative } from 'node:path';
 import zlib from 'node:zlib';
 import { getDshSessionsDir } from '../tools.js';
-import { aggregateToBuckets, extractSessions } from './index.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
 
 const SOURCE = 'dsh';
 

package/src/parsers/fs-utils.js

@@ -0,0 +1,36 @@
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+
+// Small shared filesystem/parsing helpers used across parsers. Keeping them in
+// one place removes the same ~10-line functions copied into every parser.
+
+/** Read and parse a JSON file, returning null on any failure. */
+export function readJsonSafe(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Last path component (project name), or 'unknown'. */
+export function projectFromPath(absPath) {
+  if (!absPath || typeof absPath !== 'string') return 'unknown';
+  const trimmed = absPath.replace(/[\\/]+$/, '');
+  const name = basename(trimmed);
+  return name || 'unknown';
+}
+
+/** Last path component of a cwd value (works for both Unix and Windows paths). */
+export function projectFromCwd(cwd, fallback = 'unknown') {
+  if (typeof cwd !== 'string') return fallback;
+  const trimmed = cwd.trim().replace(/[\\/]+$/, '');
+  if (!trimmed) return fallback;
+  return trimmed.split(/[\\/]/).filter(Boolean).at(-1) || fallback;
+}
+
+/** Coerce a token count to a finite positive number, else 0. */
+export function toCount(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}

package/src/parsers/gemini-cli.js

@@ -1,7 +1,7 @@
 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 { aggregateToBuckets, extractSessions } from './aggregate.js';
 
 const TMP_DIR = join(homedir(), '.gemini', 'tmp');
 

package/src/parsers/grok.js

@@ -1,8 +1,9 @@
 import { createReadStream, existsSync, readdirSync, readFileSync } from 'node:fs';
 import { createInterface } from 'node:readline';
-import { basename, join } from 'node:path';
+import { join } from 'node:path';
 import { findGrokDataDirs, getGrokSessionsDir } from '../tools.js';
-import { aggregateToBuckets, extractSessions } from './index.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { readJsonSafe, projectFromPath } from './fs-utils.js';
 
 const SOURCE = 'grok';
 
@@ -23,21 +24,6 @@ const SOURCE = 'grok';
  * reads), matching Codex/Copilot so totalTokens does not double-count cache.
  */
 
-function readJsonSafe(path) {
-  try {
-    return JSON.parse(readFileSync(path, 'utf-8'));
-  } catch {
-    return null;
-  }
-}
-
-function projectFromPath(absPath) {
-  if (!absPath || typeof absPath !== 'string') return 'unknown';
-  const trimmed = absPath.replace(/[\\/]+$/, '');
-  const name = basename(trimmed);
-  return name || 'unknown';
-}
-
 /** Decode a sessions group dirname; fall back to basename after decode. */
 function projectFromGroupDir(groupName, groupPath) {
   const cwdFile = join(groupPath, '.cwd');

package/src/parsers/hermes.js

@@ -1,8 +1,8 @@
 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';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 
 const HERMES_HOME = process.env.HERMES_HOME || join(homedir(), '.hermes');
 
@@ -37,9 +37,7 @@ export async function parse() {
         FROM sessions
         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 (or use Node >= 22.5) to sync Hermes data.');
-      }
+      if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('Hermes');
       throw err;
     }
 

package/src/parsers/index.js

@@ -1,4 +1,3 @@
-import { createHash } from 'node:crypto';
 import { parse as parseClaudeCode } from './claude-code.js';
 import { parse as parseCline } from './cline.js';
 import { parse as parseCodex } from './codex.js';
@@ -57,150 +56,4 @@ export const parsers = {
   'zcode': parseZcode,
 };
 
-
-export function roundToHalfHour(date) {
-  const d = new Date(date);
-  d.setMinutes(d.getMinutes() < 30 ? 0 : 30, 0, 0);
-  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}|${model}|${project}|${e.hostname || ''}|${bucketStart}`;
-
-    if (!map.has(key)) {
-      map.set(key, {
-        source: e.source,
-        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,
-      });
-    }
-
-    const b = map.get(key);
-    b.inputTokens += e.inputTokens || 0;
-    b.outputTokens += e.outputTokens || 0;
-    b.cachedInputTokens += e.cachedInputTokens || 0;
-    b.reasoningOutputTokens += e.reasoningOutputTokens || 0;
-  }
-
-  // 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,
-    };
-  });
-}
-
-/**
- * Extract session metadata from timing events.
- * Each event: { sessionId, source, project, timestamp: Date, role: 'user'|'assistant' }
- *
- * Turn = first AI response → last AI response before next user prompt.
- * activeSeconds = sum(generation durations), excluding queue/TTFT wait.
- * durationSeconds = wall clock from first to last message.
- */
-export function extractSessions(events) {
-  const groups = new Map();
-  for (const e of events) {
-    if (!groups.has(e.sessionId)) groups.set(e.sessionId, []);
-    groups.get(e.sessionId).push(e);
-  }
-
-  const sessions = [];
-  for (const [sessionId, sessionEvents] of groups) {
-    sessionEvents.sort((a, b) => a.timestamp - b.timestamp);
-
-    const first = sessionEvents[0];
-    const last = sessionEvents[sessionEvents.length - 1];
-    const durationSeconds = Math.round((last.timestamp - first.timestamp) / 1000);
-
-    let activeSeconds = 0;
-    let turnStart = null;
-    let turnEnd = null;
-    let waitingForFirstResponse = false;
-
-    for (const event of sessionEvents) {
-      if (event.role === 'user') {
-        if (turnStart !== null && turnEnd !== null && turnEnd > turnStart) {
-          activeSeconds += Math.round((turnEnd - turnStart) / 1000);
-        }
-        turnStart = null;
-        turnEnd = null;
-        waitingForFirstResponse = true;
-      } else if (waitingForFirstResponse) {
-        turnStart = event.timestamp;
-        turnEnd = event.timestamp;
-        waitingForFirstResponse = false;
-      } else if (turnStart !== null) {
-        turnEnd = event.timestamp;
-      }
-    }
-    if (turnStart !== null && turnEnd !== null && turnEnd > turnStart) {
-      activeSeconds += Math.round((turnEnd - turnStart) / 1000);
-    }
-
-    const userPromptHours = new Array(24).fill(0);
-    let userMessageCount = 0;
-    for (const event of sessionEvents) {
-      if (event.role === 'user') {
-        userMessageCount++;
-        userPromptHours[event.timestamp.getUTCHours()]++;
-      }
-    }
-
-    const sessionHash = createHash('sha256').update(sessionId).digest('hex').slice(0, 16);
-
-    sessions.push({
-      source: first.source,
-      project: first.project || 'unknown',
-      sessionHash,
-      firstMessageAt: first.timestamp.toISOString(),
-      lastMessageAt: last.timestamp.toISOString(),
-      durationSeconds,
-      activeSeconds,
-      messageCount: sessionEvents.length,
-      userMessageCount,
-      userPromptHours,
-    });
-  }
-
-  return sessions;
-}
+export { roundToHalfHour, aggregateToBuckets, extractSessions } from './aggregate.js';

package/src/parsers/kimi-code.js

@@ -2,7 +2,7 @@ import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
-import { aggregateToBuckets, extractSessions } from './index.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
 
 /**
  * Kimi Code CLI parser. MoonshotAI/kimi-cli (a.k.a. "Kimi Code").

package/src/parsers/kiro.js

@@ -1,18 +1,15 @@
 import {
-  copyFileSync,
   createReadStream,
   existsSync,
-  mkdtempSync,
   readFileSync,
   readdirSync,
-  rmSync,
   statSync,
 } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { dirname, join, resolve } from 'node:path';
-import { homedir, tmpdir } from 'node:os';
-import { aggregateToBuckets } from './index.js';
-import { queryDbJson } from './sqlite.js';
+import { homedir } from 'node:os';
+import { aggregateToBuckets } from './aggregate.js';
+import { queryDbJsonSnapshotOnLock, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 
 const KIRO_AGENT_RELATIVE = join('User', 'globalStorage', 'kiro.kiroagent');
 const KIRO_USER_RELATIVE = 'User';
@@ -122,37 +119,9 @@ export function getKiroCliSessionsDir() {
   return existsSync(def) ? def : null;
 }
 
-function isLockError(err) {
-  return err && typeof err.message === 'string' && /database is locked/i.test(err.message);
-}
-
-function queryDb(dbPath, sql) {
-  return queryDbJson(dbPath, sql);
-}
-
-function queryDbSnapshotOnLock(dbPath, sql) {
-  try {
-    return queryDb(dbPath, sql);
-  } catch (err) {
-    if (!isLockError(err)) throw err;
-    const snapshotDir = mkdtempSync(join(tmpdir(), 'vibe-usage-kiro-'));
-    const queryPath = join(snapshotDir, 'data.sqlite3');
-    copyFileSync(dbPath, queryPath);
-    for (const suffix of ['-shm', '-wal']) {
-      const companion = `${dbPath}${suffix}`;
-      if (existsSync(companion)) copyFileSync(companion, `${queryPath}${suffix}`);
-    }
-    try {
-      return queryDb(queryPath, sql);
-    } finally {
-      rmSync(snapshotDir, { recursive: true, force: true });
-    }
-  }
-}
-
 function queryOptionalDb(dbPath, sql) {
   try {
-    return queryDbSnapshotOnLock(dbPath, sql);
+    return queryDbJsonSnapshotOnLock(dbPath, sql, { tempPrefix: 'vibe-usage-kiro-' });
   } catch (err) {
     const msg = err && typeof err.message === 'string' ? err.message : '';
     if (/no such table|no such column/i.test(msg)) return [];
@@ -167,7 +136,7 @@ const TOKENS_SQL =
   'ORDER BY id ASC';
 
 function readLegacyDb(dbPath) {
-  return queryDbSnapshotOnLock(dbPath, TOKENS_SQL);
+  return queryDbJsonSnapshotOnLock(dbPath, TOKENS_SQL, { tempPrefix: 'vibe-usage-kiro-' });
 }
 
 // Legacy Kiro dev telemetry fallback. This is opt-in because recent Kiro builds
@@ -790,9 +759,7 @@ export async function parse() {
       return { buckets: aggregateToBuckets(estimateEntries), sessions: [] };
     }
   } catch (err) {
-    if (err && typeof err.message === 'string' && err.message.includes('ENOENT')) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Kiro CLI data.');
-    }
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('Kiro CLI');
     throw err;
   }
 

package/src/parsers/mimocode.js

@@ -1,8 +1,8 @@
 import { existsSync } from 'node:fs';
 import { basename } from 'node:path';
 import { getMimocodeDbPath } from '../tools.js';
-import { aggregateToBuckets, extractSessions } from './index.js';
-import { queryDbJson } from './sqlite.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 
 export { getMimocodeDbPath as resolveMimocodeDbPath };
 
@@ -36,9 +36,7 @@ export async function parse() {
       ${externalImportFilter}
     `);
   } catch (err) {
-    if (err.status === 127 || err.message?.includes('ENOENT')) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync MiMoCode data.');
-    }
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('MiMoCode');
     throw err;
   }
 

package/src/parsers/openclaw.js

@@ -1,7 +1,7 @@
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { aggregateToBuckets, extractSessions } from './index.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
 
 // OpenClaw stores data at ~/.openclaw/agents/<agentId>/sessions/*.jsonl
 // Profile deployments use ~/.openclaw-<profile>/agents/...

package/src/parsers/opencode.js

@@ -1,8 +1,8 @@
 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';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 
 const DATA_DIR = join(homedir(), '.local', 'share', 'opencode');
 const DB_PATH = join(DATA_DIR, 'opencode.db');
@@ -37,9 +37,7 @@ function parseFromSqlite() {
   try {
     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 (or use Node >= 22.5) to sync opencode data.');
-    }
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('OpenCode');
     throw err;
   }
   if (!rows.length) return { buckets: [], sessions: [] };

package/src/parsers/pi-session-jsonl.js

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { basename, join, relative } from 'node:path';
-import { aggregateToBuckets, extractSessions } from './index.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { projectFromCwd, toCount } from './fs-utils.js';
 
 const MAX_WARNINGS = 20;
 
@@ -28,17 +29,6 @@ function findJsonlFiles(dir, includeFile, ctx) {
   return files;
 }
 
-function tokenCount(value) {
-  const number = Number(value);
-  return Number.isFinite(number) && number > 0 ? number : 0;
-}
-
-export function projectFromCwd(cwd) {
-  if (typeof cwd !== 'string') return 'unknown';
-  const parts = cwd.replace(/\\/g, '/').split('/').filter(Boolean);
-  return parts.at(-1) || 'unknown';
-}
-
 export function projectFromFirstDir(filePath, sessionsDir) {
   const first = relative(sessionsDir, filePath).split(/[\\/]/)[0];
   if (!first) return 'unknown';
@@ -105,12 +95,12 @@ export async function parsePiSessionJsonl({
 
         if (message.role !== 'assistant' || !message.usage) continue;
         const usage = message.usage;
-        const inputTokens = tokenCount(usage.input) + tokenCount(usage.cacheWrite);
-        const reasoningOutputTokens = tokenCount(usage.reasoningTokens);
+        const inputTokens = toCount(usage.input) + toCount(usage.cacheWrite);
+        const reasoningOutputTokens = toCount(usage.reasoningTokens);
         // OMP/Pi usage.output includes reasoning; the shared bucket contract
         // stores non-reasoning output and reasoning separately.
-        const outputTokens = Math.max(0, tokenCount(usage.output) - reasoningOutputTokens);
-        const cachedInputTokens = tokenCount(usage.cacheRead);
+        const outputTokens = Math.max(0, toCount(usage.output) - reasoningOutputTokens);
+        const cachedInputTokens = toCount(usage.cacheRead);
         const score = inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens;
         if (score === 0) continue;
 

package/src/parsers/qwen-code.js

@@ -1,7 +1,7 @@
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, basename, sep } from 'node:path';
 import { homedir } from 'node:os';
-import { aggregateToBuckets, extractSessions } from './index.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
 
 /**
  * Qwen Code parser (Gemini CLI fork).

package/src/parsers/roo-code.js

@@ -1,7 +1,8 @@
-import { readFileSync, readdirSync, statSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { aggregateToBuckets, extractSessions } from './index.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { readJsonSafe, projectFromPath } from './fs-utils.js';
 
 const EXTENSION_ID = 'rooveterinaryinc.roo-cline';
 
@@ -35,17 +36,6 @@ export function findRooCodeExtensionDirs() {
   return dirs;
 }
 
-function readJsonSafe(path) {
-  try { return JSON.parse(readFileSync(path, 'utf-8')); } catch { return null; }
-}
-
-function projectFromPath(absPath) {
-  if (!absPath || typeof absPath !== 'string') return 'unknown';
-  const trimmed = absPath.replace(/[\\/]+$/, '');
-  const name = basename(trimmed);
-  return name || 'unknown';
-}
-
 // Read all HistoryItems from `_index.json` if present, else fall back to
 // scanning per-task `history_item.json` files (Roo migrated to per-task
 // files in 2025; the index is a cache).