@vibe-cafe/vibe-usage 0.4.2 → 0.5.1

package/README.md

@@ -40,12 +40,12 @@ npx vibe-usage status       # Show config & detected tools
 - Parses local session logs from each AI coding tool
 - Aggregates token usage into 30-minute buckets
 - Uploads to your vibecafe.ai dashboard
-- Only syncs new data since last sync (incremental)
+- Stateless: computes full totals from local logs each sync (idempotent, no state files)
 - For continuous syncing, use `npx vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 
 ## Config
 
-Config stored at `~/.vibe-usage/config.json`. Contains your API key and last sync timestamp.
+Config stored at `~/.vibe-usage/config.json`. Contains your API key and server URL.
 
 ## Daemon Mode
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "bin": {
@@ -22,9 +22,7 @@
     "codex",
     "gemini"
   ],
-  "dependencies": {
-    "ccusage": "18.0.5"
-  },
+  "dependencies": {},
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vibe-cafe/vibe-usage.git"

package/src/parsers/claude-code.js

@@ -1,123 +1,121 @@
-import { loadSessionData } from 'ccusage/data-loader';
-import { aggregateToBuckets } from './index.js';
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, basename, sep } from 'node:path';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { aggregateToBuckets } from './index.js';
 
-const STATE_FILE = join(homedir(), '.vibe-usage', 'claude-code-state.json');
+/**
+ * Stateless Claude Code parser.
+ * Reads ALL *.jsonl files under ~/.claude/projects/ and extracts per-message
+ * token usage from assistant messages. No state file needed — every sync
+ * computes the full bucket totals from raw data, making server-side
+ * ON CONFLICT ... DO UPDATE SET idempotent.
+ */
 
-/** Pending state staged during parse(), committed only after successful upload. */
-let _pendingState = null;
+const CLAUDE_DIR = join(homedir(), '.claude', 'projects');
 
-function loadState() {
+/**
+ * Recursively find all .jsonl files under a directory.
+ * Claude Code stores sessions in two layouts:
+ *   2-layer: projects/{projectPath}/{sessionId}.jsonl
+ *   3-layer: projects/{projectPath}/{sessionId}/subagents/agent-*.jsonl
+ */
+function findJsonlFiles(dir) {
+  const results = [];
+  if (!existsSync(dir)) return results;
   try {
-    return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findJsonlFiles(fullPath));
+      } else if (entry.name.endsWith('.jsonl')) {
+        results.push(fullPath);
+      }
+    }
   } catch {
-    return {};
+    // ignore unreadable directories
   }
-}
-
-function saveState(state) {
-  const dir = join(homedir(), '.vibe-usage');
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(STATE_FILE, JSON.stringify(state), 'utf-8');
+  return results;
 }
 
 /**
- * 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.
+ * Extract project name from file path.
+ * Path format: ~/.claude/projects/{encodedProjectPath}/{sessionId}.jsonl
+ * The encodedProjectPath uses dashes for separators (e.g. -Users-foo-myproject).
+ * We extract the last path segment as the project name.
  */
-export function commitState() {
-  if (_pendingState) {
-    saveState(_pendingState);
-    _pendingState = null;
-  }
+function extractProject(filePath) {
+  // Get relative path from the projects dir
+  const projectsPrefix = CLAUDE_DIR + sep;
+  if (!filePath.startsWith(projectsPrefix)) return 'unknown';
+  const relative = filePath.slice(projectsPrefix.length);
+  // First segment is the encoded project path
+  const firstSeg = relative.split(sep)[0];
+  if (!firstSeg) return 'unknown';
+  // The encoded path uses dashes: -Users-kalasoo-Projects-myproject
+  // Take the last segment after splitting by dash
+  const parts = firstSeg.split('-').filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : 'unknown';
 }
 
 export async function parse() {
-  let sessions;
-  try {
-    sessions = await loadSessionData({ mode: 'display' });
-  } catch {
-    return [];
-  }
+  if (!existsSync(CLAUDE_DIR)) return [];
 
-  if (!sessions || sessions.length === 0) return [];
+  const files = findJsonlFiles(CLAUDE_DIR);
+  if (files.length === 0) return [];
 
-  const state = loadState();
-  const nextState = { ...state };
   const entries = [];
+  const seenUuids = new Set();
+
+  for (const filePath of files) {
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
 
-  for (const session of sessions) {
-
-    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,
-        project,
-        timestamp: new Date(session.lastActivity),
-        inputTokens: Math.max(0, deltaInput),
-        outputTokens: Math.max(0, deltaOutput),
-        cachedInputTokens: Math.max(0, deltaCached),
-        reasoningOutputTokens: 0,
-      });
+    const project = extractProject(filePath);
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+
+        // Only process assistant messages with usage data
+        if (obj.type !== 'assistant') continue;
+        const msg = obj.message;
+        if (!msg || !msg.usage) continue;
+
+        const usage = msg.usage;
+        if (usage.input_tokens == null && usage.output_tokens == null) continue;
+
+        // Deduplicate by UUID across all files
+        const uuid = obj.uuid;
+        if (uuid) {
+          if (seenUuids.has(uuid)) continue;
+          seenUuids.add(uuid);
+        }
+
+        const timestamp = obj.timestamp;
+        if (!timestamp) continue;
+        const ts = new Date(timestamp);
+        if (isNaN(ts.getTime())) continue;
+
+        entries.push({
+          source: 'claude-code',
+          model: msg.model || 'unknown',
+          project,
+          timestamp: ts,
+          inputTokens: usage.input_tokens || 0,
+          outputTokens: usage.output_tokens || 0,
+          cachedInputTokens: usage.cache_read_input_tokens || 0,
+          reasoningOutputTokens: 0,
+        });
+      } catch {
+        continue;
+      }
     }
   }
 
-  // Stage state — only persisted to disk after successful upload
-  _pendingState = nextState;
-
   return aggregateToBuckets(entries);
 }
-
-/**
- * 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 cleanProjectDir(raw) {
-  if (!raw || raw === 'unknown' || raw === 'Unknown Project') return 'unknown';
-  const slashIdx = raw.indexOf('/');
-  if (slashIdx !== -1) raw = raw.slice(0, slashIdx);
-  return raw;
-}

package/src/parsers/codex.js

@@ -115,15 +115,19 @@ export async function parse() {
 
         const model = info.model || payload.model || turnContextModel || sessionModel;
 
+        // OpenAI API: input_tokens INCLUDES cached, output_tokens INCLUDES reasoning.
+        // Normalize to Anthropic-style semantics where each field is non-overlapping.
+        const cachedInput = usage.cached_input_tokens || usage.cache_read_input_tokens || 0;
+        const reasoningOutput = usage.reasoning_output_tokens || 0;
         entries.push({
           source: 'codex',
           model,
           project: sessionProject,
           timestamp,
-          inputTokens: usage.input_tokens || 0,
-          outputTokens: usage.output_tokens || 0,
-          cachedInputTokens: usage.cached_input_tokens || usage.cache_read_input_tokens || 0,
-          reasoningOutputTokens: usage.reasoning_output_tokens || 0,
+          inputTokens: (usage.input_tokens || 0) - cachedInput,
+          outputTokens: (usage.output_tokens || 0) - reasoningOutput,
+          cachedInputTokens: cachedInput,
+          reasoningOutputTokens: reasoningOutput,
         });
       } catch {
         continue;

package/src/parsers/gemini-cli.js

@@ -59,28 +59,32 @@ export async function parse() {
       if (isNaN(ts.getTime())) continue;
 
       if (tokens) {
-        // New format: { input, output, cached, thoughts, tool, total }
+        // Gemini API: input INCLUDES cached, output INCLUDES thoughts. Normalize to non-overlapping.
+        const cached = tokens.cached || 0;
+        const thoughts = tokens.thoughts || 0;
         entries.push({
           source: 'gemini-cli',
           model: msg.model || data.model || 'unknown',
           project: 'unknown',
           timestamp: ts,
-          inputTokens: tokens.input || 0,
-          outputTokens: tokens.output || 0,
-          cachedInputTokens: tokens.cached || 0,
-          reasoningOutputTokens: tokens.thoughts || 0,
+          inputTokens: (tokens.input || 0) - cached,
+          outputTokens: (tokens.output || 0) - thoughts,
+          cachedInputTokens: cached,
+          reasoningOutputTokens: thoughts,
         });
       } else {
-        // Old format: { promptTokenCount, candidatesTokenCount, ... }
+        // Gemini API: promptTokenCount INCLUDES cachedContentTokenCount. Normalize to non-overlapping.
+        const cached = usage.cachedContentTokenCount || 0;
+        const thoughts = usage.thoughtsTokenCount || 0;
         entries.push({
           source: 'gemini-cli',
           model: msg.model || data.model || 'unknown',
           project: 'unknown',
           timestamp: ts,
-          inputTokens: usage.promptTokenCount || usage.input_tokens || 0,
-          outputTokens: usage.candidatesTokenCount || usage.output_tokens || 0,
-          cachedInputTokens: usage.cachedContentTokenCount || 0,
-          reasoningOutputTokens: usage.thoughtsTokenCount || 0,
+          inputTokens: (usage.promptTokenCount || usage.input_tokens || 0) - cached,
+          outputTokens: (usage.candidatesTokenCount || usage.output_tokens || 0) - thoughts,
+          cachedInputTokens: cached,
+          reasoningOutputTokens: thoughts,
         });
       }
     }

package/src/parsers/index.js

@@ -1,4 +1,4 @@
-import { parse as parseClaudeCode, commitState as commitClaudeCodeState } from './claude-code.js';
+import { parse as parseClaudeCode } 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,7 +12,6 @@ export const parsers = {
   'openclaw': parseOpenclaw,
 };
 
-export const postSyncHooks = [commitClaudeCodeState];
 
 export function roundToHalfHour(date) {
   const d = new Date(date);
@@ -46,7 +45,7 @@ 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);
+    b.totalTokens += (e.inputTokens || 0) + (e.outputTokens || 0) + (e.reasoningOutputTokens || 0);
   }
 
   return Array.from(map.values());

package/src/reset.js

@@ -1,14 +1,11 @@
 import { createInterface } from 'node:readline';
-import { existsSync, unlinkSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir, hostname as getHostname } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
 import { deleteAllData } from './api.js';
 import { runSync } from './sync.js';
 
-const STATE_FILES = [
-  join(homedir(), '.vibe-usage', 'claude-code-state.json'),
-];
 
 function prompt(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -73,15 +70,9 @@ export async function runReset(args = []) {
     }
   }
 
-  // 2. Clear local state
+  // 2. Clear local state (legacy — no state files needed for current parsers)
   config.lastSync = null;
   saveConfig(config);
-
-  for (const stateFile of STATE_FILES) {
-    if (existsSync(stateFile)) {
-      unlinkSync(stateFile);
-    }
-  }
   console.log('Cleared local sync state.');
 
   // 3. Re-upload everything

package/src/sync.js

@@ -1,7 +1,7 @@
 import { hostname as osHostname } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
 import { ingest, fetchSettings } from './api.js';
-import { parsers, postSyncHooks } from './parsers/index.js';
+import { parsers } from './parsers/index.js';
 
 const BATCH_SIZE = 100;
 
@@ -81,16 +81,6 @@ export async function runSync({ throws = false, quiet = false } = {}) {
         },
       });
       totalIngested += result.ingested ?? batch.length;
-
-      // State commit happens after ALL batches complete (see postSyncHooks below)
-    }
-
-
-    // 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) {