@vibe-cafe/vibe-usage 0.2.4 → 0.2.5

package/package.json

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

package/src/parsers/claude-code.js

@@ -1,5 +1,39 @@
 import { loadSessionData } from 'ccusage/data-loader';
 import { aggregateToBuckets } from './index.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+
+const STATE_FILE = join(homedir(), '.vibe-usage', 'claude-code-state.json');
+
+/** Pending state staged during parse(), committed only after successful upload. */
+let _pendingState = null;
+
+function loadState() {
+  try {
+    return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveState(state) {
+  const dir = join(homedir(), '.vibe-usage');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(STATE_FILE, JSON.stringify(state), 'utf-8');
+}
+
+/**
+ * Commit pending state to disk.
+ * Called by sync.js AFTER successful upload to ensure we only advance
+ * the watermark when data has been safely delivered to the server.
+ */
+export function commitState() {
+  if (_pendingState) {
+    saveState(_pendingState);
+    _pendingState = null;
+  }
+}
 
 export async function parse(lastSync) {
   let sessions;
@@ -11,36 +45,80 @@ export async function parse(lastSync) {
 
   if (!sessions || sessions.length === 0) return [];
 
+  const state = loadState();
+  const nextState = { ...state };
   const entries = [];
 
   for (const session of sessions) {
     if (lastSync && new Date(session.lastActivity) <= new Date(lastSync)) continue;
 
+    const project = resolveProject(session);
+    const sessionKey = `${session.projectPath}\0${session.sessionId}`;
+    const prev = state[sessionKey] || {};
+
     for (const breakdown of session.modelBreakdowns || []) {
+      const model = breakdown.modelName;
+      const prevModel = prev[model] || { i: 0, o: 0, c: 0 };
+
+      const deltaInput = (breakdown.inputTokens || 0) - (prevModel.i || 0);
+      const deltaOutput = (breakdown.outputTokens || 0) - (prevModel.o || 0);
+      const deltaCached = (breakdown.cacheReadTokens || 0) - (prevModel.c || 0);
+
+      // Always record current cumulative totals for next sync
+      if (!nextState[sessionKey]) nextState[sessionKey] = {};
+      nextState[sessionKey][model] = {
+        i: breakdown.inputTokens || 0,
+        o: breakdown.outputTokens || 0,
+        c: breakdown.cacheReadTokens || 0,
+      };
+
+      // Only emit entries with positive deltas
+      if (deltaInput <= 0 && deltaOutput <= 0 && deltaCached <= 0) continue;
+
       entries.push({
         source: 'claude-code',
-        model: breakdown.modelName,
-        project: stripSessionId(session.projectPath),
+        model,
+        project,
         timestamp: new Date(session.lastActivity),
-        inputTokens: breakdown.inputTokens,
-        outputTokens: breakdown.outputTokens,
-        cachedInputTokens: breakdown.cacheReadTokens,
+        inputTokens: Math.max(0, deltaInput),
+        outputTokens: Math.max(0, deltaOutput),
+        cachedInputTokens: Math.max(0, deltaCached),
         reasoningOutputTokens: 0,
       });
     }
   }
 
+  // Stage state — only persisted to disk after successful upload
+  _pendingState = nextState;
+
   return aggregateToBuckets(entries);
 }
 
 /**
- * Strip session UUID suffix from ccusage project path.
- * ccusage returns paths like '-Users-foo-project/77e854f9-...' for subagent sessions.
- * We only keep the directory name part before the first '/'.
+ * Resolve project name from ccusage session data.
+ *
+ * ccusage v18 assumes 3-layer: projects/{projectPath}/{sessionId}/{file}.jsonl
+ * but Claude Code main sessions are 2-layer: projects/{projectPath}/{sessionId}.jsonl
+ *
+ * For 2-layer files ccusage incorrectly puts the project dir name into sessionId
+ * and sets projectPath to "Unknown Project". We detect and correct this.
+ */
+function resolveProject(session) {
+  if (session.projectPath === 'Unknown Project') {
+    // 2-layer: sessionId actually holds the project directory name
+    return cleanProjectDir(session.sessionId);
+  }
+  // 3-layer: projectPath is correct, strip any session UUID suffix
+  return cleanProjectDir(session.projectPath);
+}
+
+/**
+ * Clean a raw project directory name from ccusage.
+ * Strips session UUID suffix for subagent paths like '-Users-foo-project/77e854f9-...'.
  */
-function stripSessionId(raw) {
+function cleanProjectDir(raw) {
   if (!raw || raw === 'unknown' || raw === 'Unknown Project') return 'unknown';
   const slashIdx = raw.indexOf('/');
-  if (slashIdx !== -1) return raw.slice(0, slashIdx);
+  if (slashIdx !== -1) raw = raw.slice(0, slashIdx);
   return raw;
 }

package/src/parsers/index.js

@@ -1,4 +1,4 @@
-import { parse as parseClaudeCode } from './claude-code.js';
+import { parse as parseClaudeCode, commitState as commitClaudeCodeState } from './claude-code.js';
 import { parse as parseCodex } from './codex.js';
 import { parse as parseGeminiCli } from './gemini-cli.js';
 import { parse as parseOpencode } from './opencode.js';
@@ -12,6 +12,8 @@ export const parsers = {
   'openclaw': parseOpenclaw,
 };
 
+export const postSyncHooks = [commitClaudeCodeState];
+
 export function roundToHalfHour(date) {
   const d = new Date(date);
   d.setMinutes(d.getMinutes() < 30 ? 0 : 30, 0, 0);

package/src/sync.js

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
 import { ingest } from './api.js';
-import { parsers } from './parsers/index.js';
+import { parsers, postSyncHooks } from './parsers/index.js';
 import { TOOLS } from './hooks.js';
 
 const BATCH_SIZE = 100;
@@ -75,6 +75,14 @@ export async function runSync() {
       saveConfig(config);
     }
 
+
+    // Commit parser state now that all data has been uploaded successfully.
+    // State is staged during parse() but only persisted here to prevent
+    // data loss if uploads fail (deltas would be re-computed on retry).
+    for (const hook of postSyncHooks) {
+      try { hook(); } catch { /* best effort */ }
+    }
+
     if (totalBatches > 1 || allBuckets.length > 0) {
       process.stdout.write('\n');
     }