@vibe-cafe/vibe-usage 0.10.16 → 0.10.17

package/package.json

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

package/src/claude-roots.js

@@ -128,7 +128,9 @@ export function getClaudeRoots({ onWarning = () => {} } = {}) {
       // The default/configured roots remain usable if home discovery fails.
     }
 
-    roots.push(...findClaudeDesktopRoots(getClaudeDesktopDataDirs(), onWarning));
+    for (const root of findClaudeDesktopRoots(getClaudeDesktopDataDirs(), onWarning)) {
+      roots.push(root);
+    }
   }
 
   const seen = new Set();

package/src/parsers/aggregate.js

@@ -80,6 +80,93 @@ export function aggregateToBuckets(entries) {
   });
 }
 
+/**
+ * Incremental session aggregation for parsers whose event stream is already
+ * chronological. `extractSessions()` below keeps the sorting fallback for
+ * parsers that emit mixed or out-of-order sessions.
+ */
+export function createSessionAccumulator() {
+  return {
+    ordered: true,
+    first: null,
+    last: null,
+    lastTimestampMs: null,
+    activeSeconds: 0,
+    turnStartMs: null,
+    turnEndMs: null,
+    waitingForFirstResponse: false,
+    messageCount: 0,
+    userMessageCount: 0,
+    userPromptHours: new Array(24).fill(0),
+  };
+}
+
+function commitTurn(accumulator) {
+  const { turnStartMs, turnEndMs } = accumulator;
+  if (turnStartMs !== null && turnEndMs !== null && turnEndMs > turnStartMs) {
+    accumulator.activeSeconds += Math.round((turnEndMs - turnStartMs) / 1000);
+  }
+}
+
+export function accumulateSessionEvent(accumulator, event) {
+  const timestampMs = event.timestamp.getTime();
+  if (accumulator.lastTimestampMs !== null && timestampMs < accumulator.lastTimestampMs) {
+    accumulator.ordered = false;
+  }
+  if (accumulator.first === null) accumulator.first = event;
+  accumulator.last = event;
+  accumulator.lastTimestampMs = timestampMs;
+  accumulator.messageCount++;
+
+  if (event.role === 'user') {
+    commitTurn(accumulator);
+    accumulator.turnStartMs = null;
+    accumulator.turnEndMs = null;
+    accumulator.waitingForFirstResponse = true;
+    accumulator.userMessageCount++;
+    accumulator.userPromptHours[event.timestamp.getUTCHours()]++;
+  } else if (accumulator.waitingForFirstResponse) {
+    accumulator.turnStartMs = timestampMs;
+    accumulator.turnEndMs = timestampMs;
+    accumulator.waitingForFirstResponse = false;
+  } else if (accumulator.turnStartMs !== null) {
+    accumulator.turnEndMs = timestampMs;
+  }
+}
+
+export function sessionAccumulatorIsOrdered(accumulator) {
+  return accumulator.ordered;
+}
+
+export function finalizeSessionAccumulator(accumulator, sessionId, projectOverride) {
+  if (accumulator.first === null || accumulator.last === null) return null;
+  if (!accumulator.ordered) {
+    throw new TypeError('Session accumulator received out-of-order events');
+  }
+
+  let activeSeconds = accumulator.activeSeconds;
+  const { turnStartMs, turnEndMs } = accumulator;
+  if (turnStartMs !== null && turnEndMs !== null && turnEndMs > turnStartMs) {
+    activeSeconds += Math.round((turnEndMs - turnStartMs) / 1000);
+  }
+
+  const first = accumulator.first;
+  const last = accumulator.last;
+  const sessionHash = createHash('sha256').update(sessionId).digest('hex').slice(0, 16);
+  return {
+    source: first.source,
+    project: projectOverride || first.project || 'unknown',
+    sessionHash,
+    firstMessageAt: first.timestamp.toISOString(),
+    lastMessageAt: last.timestamp.toISOString(),
+    durationSeconds: Math.round((last.timestamp - first.timestamp) / 1000),
+    activeSeconds,
+    messageCount: accumulator.messageCount,
+    userMessageCount: accumulator.userMessageCount,
+    userPromptHours: accumulator.userPromptHours,
+  };
+}
+
 /**
  * Extract session metadata from timing events.
  * Each event: { sessionId, source, project, timestamp: Date, role: 'user'|'assistant' }
@@ -90,68 +177,18 @@ export function aggregateToBuckets(entries) {
  */
 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);
+  for (const event of events) {
+    if (!groups.has(event.sessionId)) groups.set(event.sessionId, []);
+    groups.get(event.sessionId).push(event);
   }
 
   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,
-    });
+    const accumulator = createSessionAccumulator();
+    for (const event of sessionEvents) accumulateSessionEvent(accumulator, event);
+    const session = finalizeSessionAccumulator(accumulator, sessionId);
+    if (session) sessions.push(session);
   }
-
   return sessions;
 }

package/src/parsers/amp.js

@@ -17,7 +17,7 @@ function findThreadFiles(dir) {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const fullPath = join(dir, entry.name);
       if (entry.isDirectory()) {
-        results.push(...findThreadFiles(fullPath));
+        for (const nested of findThreadFiles(fullPath)) results.push(nested);
       } else if (entry.isFile() && entry.name.startsWith('T-') && entry.name.endsWith('.json')) {
         results.push(fullPath);
       }

package/src/parsers/cindy-ledger.js

@@ -75,9 +75,10 @@ export function readCindyHarnessUsage(agentKind) {
   const rows = [];
   for (const dbPath of dbPaths) {
     try {
-      rows.push(...queryDbJsonSnapshot(dbPath, CINDY_USAGE_SQL, {
+      const dbRows = queryDbJsonSnapshot(dbPath, CINDY_USAGE_SQL, {
         tempPrefix: 'vibe-usage-cindy-',
-      }));
+      });
+      for (const row of dbRows) rows.push(row);
     } catch (error) {
       if (isSqliteUnavailableError(error)) throw sqliteUnavailableError('Cindy');
       // Cindy versions before the daily ledger was introduced have no usage

package/src/parsers/claude-code.js

@@ -1,7 +1,14 @@
 import { createReadStream, readdirSync, statSync } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { join, basename, sep } from 'node:path';
-import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import {
+  accumulateSessionEvent,
+  aggregateToBuckets,
+  createSessionAccumulator,
+  extractSessions,
+  finalizeSessionAccumulator,
+  sessionAccumulatorIsOrdered,
+} from './aggregate.js';
 import { projectFromCwd, toCount } from './fs-utils.js';
 import { getClaudeRoots } from '../claude-roots.js';
 
@@ -28,7 +35,7 @@ function findJsonlFiles(dir, ctx) {
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     if (entry.isDirectory()) {
-      results.push(...findJsonlFiles(fullPath, ctx));
+      for (const nested of findJsonlFiles(fullPath, ctx)) results.push(nested);
     } else if (entry.name.endsWith('.jsonl')) {
       results.push(fullPath);
     }
@@ -155,10 +162,46 @@ function timingEvent(obj, sessionId, project) {
     role: obj.type === 'user' ? 'user' : 'assistant',
   };
 }
+async function collectTimingEvents(candidate, projectForObject) {
+  const events = [];
+  await readJsonl(candidate, (obj) => {
+    const event = timingEvent(
+      obj,
+      candidate.sessionId,
+      projectForObject(obj),
+    );
+    if (event) events.push(event);
+  });
+  return events;
+}
+
+async function finalizeCandidateSession(
+  candidate,
+  accumulator,
+  projectForObject,
+  projectOverride,
+) {
+  if (sessionAccumulatorIsOrdered(accumulator)) {
+    return finalizeSessionAccumulator(
+      accumulator,
+      candidate.sessionId,
+      projectOverride,
+    );
+  }
+
+  // JSONL is normally append-ordered. Preserve the old sort semantics for an
+  // unusual copied/rewritten file without retaining every event on the common
+  // path: re-read only that candidate and let extractSessions() sort it.
+  const events = await collectTimingEvents(candidate, projectForObject);
+  return extractSessions(events)[0] || null;
+}
 
 async function scanProjectCandidate(candidate) {
-  const entries = [];
-  const events = [];
+  const usageEntries = {
+    entriesByKey: new Map(),
+    anonymousEntries: [],
+  };
+  const sessionAccumulator = createSessionAccumulator();
   let lastModel = null;
   let sessionProject = candidate.fallbackProject;
   let foundSessionCwd = false;
@@ -171,7 +214,7 @@ async function scanProjectCandidate(candidate) {
       foundSessionCwd = true;
     }
     const event = timingEvent(obj, candidate.sessionId, sessionProject);
-    if (event) events.push(event);
+    if (event) accumulateSessionEvent(sessionAccumulator, event);
 
     if (obj.type !== 'assistant' || !obj.message?.usage || !obj.timestamp) return;
     const timestamp = new Date(obj.timestamp);
@@ -194,7 +237,7 @@ async function scanProjectCandidate(candidate) {
     // inflate the CLI's bucket count with rows the server will discard anyway.
     if (usageScore === 0) return;
 
-    entries.push({
+    mergeUsageEntry(usageEntries, {
       dedupeKey: usageDedupeKey(obj),
       usageScore,
       source: 'claude-code',
@@ -210,22 +253,34 @@ async function scanProjectCandidate(candidate) {
 
   // A cwd can appear after initial metadata/messages. Normalize the completed
   // session in one place so early records receive the same project label.
-  for (const entry of entries) entry.project = sessionProject;
-  for (const event of events) event.project = sessionProject;
-  return { entries, events };
+  for (const entry of usageEntries.anonymousEntries) entry.project = sessionProject;
+  for (const entry of usageEntries.entriesByKey.values()) entry.project = sessionProject;
+  const session = await finalizeCandidateSession(
+    candidate,
+    sessionAccumulator,
+    () => sessionProject,
+    sessionProject,
+  );
+  return { usageEntries, session };
 }
 
 async function scanTranscriptCandidate(candidate) {
-  const events = [];
+  const sessionAccumulator = createSessionAccumulator();
+  const projectForObject = (obj) => projectFromCwd(obj.cwd, 'unknown');
   await readJsonl(candidate, (obj) => {
     const event = timingEvent(
       obj,
       candidate.sessionId,
-      projectFromCwd(obj.cwd, 'unknown'),
+      projectForObject(obj),
     );
-    if (event) events.push(event);
+    if (event) accumulateSessionEvent(sessionAccumulator, event);
   });
-  return { entries: [], events };
+  const session = await finalizeCandidateSession(
+    candidate,
+    sessionAccumulator,
+    projectForObject,
+  );
+  return { session };
 }
 
 async function scanBestCandidate(candidates, scanner, ctx) {
@@ -266,11 +321,21 @@ function mergeUsageEntry(ctx, entry) {
   }
 }
 
+function mergeUsageEntries(target, source) {
+  for (const entry of source.anonymousEntries) mergeUsageEntry(target, entry);
+  for (const entry of source.entriesByKey.values()) mergeUsageEntry(target, entry);
+}
+
+function* iterateUsageEntries(ctx) {
+  for (const entry of ctx.anonymousEntries) yield entry;
+  for (const entry of ctx.entriesByKey.values()) yield entry;
+}
+
 export async function parse() {
   const ctx = {
     entriesByKey: new Map(),
     anonymousEntries: [],
-    sessionEvents: [],
+    sessions: [],
     warnings: [],
     incomplete: false,
   };
@@ -284,25 +349,20 @@ export async function parse() {
     const parsed = await scanBestCandidate(candidates, scanProjectCandidate, ctx);
     if (!parsed) continue;
     projectSessionIds.add(sessionId);
-    ctx.sessionEvents.push(...parsed.events);
-    for (const entry of parsed.entries) mergeUsageEntry(ctx, entry);
+    if (parsed.session) ctx.sessions.push(parsed.session);
+    mergeUsageEntries(ctx, parsed.usageEntries);
   }
 
   const transcriptGroups = collectCandidates(roots, 'transcripts', ctx);
   for (const [sessionId, candidates] of transcriptGroups) {
     if (projectSessionIds.has(sessionId)) continue;
     const parsed = await scanBestCandidate(candidates, scanTranscriptCandidate, ctx);
-    if (parsed) ctx.sessionEvents.push(...parsed.events);
+    if (parsed?.session) ctx.sessions.push(parsed.session);
   }
 
-  const entries = [
-    ...ctx.anonymousEntries,
-    ...ctx.entriesByKey.values(),
-  ].map(({ dedupeKey: _dedupeKey, usageScore: _usageScore, ...entry }) => entry);
-
   return {
-    buckets: aggregateToBuckets(entries),
-    sessions: extractSessions(ctx.sessionEvents),
+    buckets: aggregateToBuckets(iterateUsageEntries(ctx)),
+    sessions: ctx.sessions,
     ...(ctx.incomplete ? { skipped: true } : {}),
     ...(ctx.warnings.length > 0 ? { warnings: ctx.warnings } : {}),
   };

package/src/parsers/codex.js

@@ -44,7 +44,7 @@ function findJsonlFiles(dir) {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const fullPath = join(dir, entry.name);
       if (entry.isDirectory()) {
-        results.push(...findJsonlFiles(fullPath));
+        for (const nested of findJsonlFiles(fullPath)) results.push(nested);
       } else if (entry.name.endsWith('.jsonl')) {
         results.push(fullPath);
       }
@@ -792,7 +792,7 @@ function mergeFileResults(results) {
         reasoningOutputTokens: bucket.reasoningOutputTokens,
       });
     }
-    sessions.push(...(result.sessions || []));
+    for (const session of result.sessions || []) sessions.push(session);
   }
   return { buckets: aggregateToBuckets(entries), sessions };
 }

package/src/parsers/droid.js

@@ -13,7 +13,7 @@ function findJsonlFiles(dir) {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const fullPath = join(dir, entry.name);
       if (entry.isDirectory()) {
-        results.push(...findJsonlFiles(fullPath));
+        for (const nested of findJsonlFiles(fullPath)) results.push(nested);
       } else if (entry.name.endsWith('.jsonl') && !entry.name.endsWith('.settings.json')) {
         results.push(fullPath);
       }

package/src/parsers/dsh.js

@@ -535,7 +535,7 @@ export async function parse() {
       model.parentSessionId == null ? null : perSession.get(model.parentSessionId);
     const skip = parent ? replaySkipCount(model, parent.model) : 0;
     const { entries: fileEntries, events: fileEvents } = modelToResult(model, skip);
-    entries.push(...fileEntries);
+    for (const entry of fileEntries) entries.push(entry);
     for (const event of fileEvents) {
       if (!eventsBySession.has(event.sessionId)) eventsBySession.set(event.sessionId, []);
       eventsBySession.get(event.sessionId).push(event);
@@ -547,7 +547,7 @@ export async function parse() {
   const events = [];
   for (const sessionEvents of eventsBySession.values()) {
     if (sessionEvents.some((event) => event.role === 'user')) {
-      events.push(...sessionEvents);
+      for (const event of sessionEvents) events.push(event);
     }
   }
 

package/src/parsers/kiro.js

@@ -326,7 +326,7 @@ export function conversationsToEstimateEntries(conversations) {
     }
   }
   for (const conversation of byId.values()) {
-    entries.push(...conversationToEntries(conversation));
+    for (const entry of conversationToEntries(conversation)) entries.push(entry);
   }
   return entries;
 }
@@ -557,7 +557,7 @@ async function readCliSessionStreamEntries() {
   const entries = [];
   for (const file of files) {
     try {
-      entries.push(...await readCliSessionEntries(dir, file));
+      for (const entry of await readCliSessionEntries(dir, file)) entries.push(entry);
     } catch {
       // skip unreadable / concurrently rotated session
     }
@@ -677,7 +677,7 @@ async function readUsageSnapshots(userPath) {
   const snapshots = [];
   for (const file of files) {
     try {
-      snapshots.push(...await readLogSnapshots(file));
+      for (const snapshot of await readLogSnapshots(file)) snapshots.push(snapshot);
     } catch {
       // skip unreadable / concurrently rotated logs
     }

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

@@ -23,8 +23,11 @@ function findJsonlFiles(dir, includeFile, ctx) {
   const files = [];
   for (const child of children) {
     const filePath = join(dir, child.name);
-    if (child.isDirectory()) files.push(...findJsonlFiles(filePath, includeFile, ctx));
-    else if (child.name.endsWith('.jsonl') && includeFile(filePath)) files.push(filePath);
+    if (child.isDirectory()) {
+      for (const nested of findJsonlFiles(filePath, includeFile, ctx)) files.push(nested);
+    } else if (child.name.endsWith('.jsonl') && includeFile(filePath)) {
+      files.push(filePath);
+    }
   }
   return files;
 }

package/src/parsers/workbuddy.js

@@ -62,8 +62,11 @@ function findJsonlFiles(dir, ctx) {
   const files = [];
   for (const child of children) {
     const filePath = join(dir, child.name);
-    if (child.isDirectory()) files.push(...findJsonlFiles(filePath, ctx));
-    else if (child.isFile() && child.name.endsWith('.jsonl')) files.push(filePath);
+    if (child.isDirectory()) {
+      for (const nested of findJsonlFiles(filePath, ctx)) files.push(nested);
+    } else if (child.isFile() && child.name.endsWith('.jsonl')) {
+      files.push(filePath);
+    }
   }
   return files;
 }

package/src/pi-roots.js

@@ -63,7 +63,9 @@ export function getOmpSessionDirs() {
   const configName = process.env.PI_CONFIG_DIR?.trim() || '.omp';
   const configRoot = join(homedir(), configName);
   dirs.push(join(configRoot, 'agent', 'sessions'));
-  dirs.push(...profileSessionDirs(join(configRoot, 'profiles'), true));
+  for (const dir of profileSessionDirs(join(configRoot, 'profiles'), true)) {
+    dirs.push(dir);
+  }
 
   const agentOverride = process.env.PI_CODING_AGENT_DIR?.trim();
   if (agentOverride) {
@@ -78,7 +80,9 @@ export function getOmpSessionDirs() {
     if (xdgDataHome) {
       const xdgRoot = join(expandHome(xdgDataHome), 'omp');
       dirs.push(join(xdgRoot, 'sessions'));
-      dirs.push(...profileSessionDirs(join(xdgRoot, 'profiles'), false));
+      for (const dir of profileSessionDirs(join(xdgRoot, 'profiles'), false)) {
+        dirs.push(dir);
+      }
     }
   }
 

package/src/sync.js

@@ -181,8 +181,8 @@ export async function runSync({
     // timeout) to keep daemon logs quiet. Its empty result is not proof that
     // its prior data disappeared, so it must not be pruned this run.
     if (!skipped) okSources.add(source);
-    if (buckets.length > 0) allBuckets.push(...buckets);
-    if (sessions.length > 0) allSessions.push(...sessions);
+    for (const bucket of buckets) allBuckets.push(bucket);
+    for (const session of sessions) allSessions.push(session);
     if (buckets.length > 0 || sessions.length > 0) {
       parserResults.push({ source, buckets: buckets.length, sessions: sessions.length });
     }