@vibe-cafe/vibe-usage 0.8.1 → 0.8.3

package/README.md

@@ -46,11 +46,11 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 
 | Tool | Data Location |
 |------|---------------|
-| Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only) |
+| Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only); also scans `$CLAUDE_CONFIG_DIR` when set (deduped), so relocated configs and GUI/CLI env mismatches are both covered |
 | Codex CLI | `~/.codex/sessions/` and `~/.codex/archived_sessions/` |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
 | Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`); cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count |
-| Gemini CLI | `~/.gemini/tmp/` |
+| Gemini CLI | `~/.gemini/tmp/<project_hash>/chats/session-*.jsonl` (current line-delimited format) and legacy `session-*.json`; recurses into nested subagent sessions |
 | OpenCode | `~/.local/share/opencode/opencode.db` (SQLite, `json_extract` query) |
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments) |
 | pi | `~/.pi/agent/sessions/` |

package/package.json

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

package/src/parsers/claude-code.js

@@ -1,18 +1,54 @@
-import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { readdirSync, readFileSync, existsSync, realpathSync } from 'node:fs';
 import { join, basename, sep } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
 
 /**
  * Stateless Claude Code parser.
- * Reads ALL *.jsonl files under ~/.claude/projects/ and extracts per-message
+ * Reads ALL *.jsonl files under <root>/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.
+ *
+ * Roots: always ~/.claude, plus $CLAUDE_CONFIG_DIR when set to a different
+ * path. Claude Code itself relocates its whole tree (incl. projects/) to
+ * $CLAUDE_CONFIG_DIR and uses only that dir — but a GUI launched from the
+ * Dock may not inherit the shell's env, so usage can be split across both
+ * roots. We scan both and dedup so neither source is missed or double-counted.
  */
 
-const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');
-const CLAUDE_TRANSCRIPTS_DIR = join(homedir(), '.claude', 'transcripts');
+/**
+ * Resolve the set of Claude config roots to scan.
+ * Always includes ~/.claude; adds $CLAUDE_CONFIG_DIR when set and it resolves
+ * to a different real path. Deduped by canonical path.
+ */
+function getClaudeRoots() {
+  const roots = [join(homedir(), '.claude')];
+
+  const cfg = process.env.CLAUDE_CONFIG_DIR?.trim();
+  if (cfg) {
+    let custom = cfg;
+    if (custom.startsWith('~')) custom = join(homedir(), custom.slice(1));
+    custom = custom.replace(/[/\\]+$/, '') || custom;
+    roots.push(custom);
+  }
+
+  // Dedup by canonical path (realpath when the dir exists, else the raw string).
+  const seen = new Set();
+  const unique = [];
+  for (const r of roots) {
+    let key = r;
+    try {
+      key = realpathSync(r);
+    } catch {
+      // dir may not exist yet — fall back to the literal path
+    }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(r);
+  }
+  return unique;
+}
 
 /**
  * Recursively find all .jsonl files under a directory.
@@ -39,15 +75,22 @@ function findJsonlFiles(dir) {
 }
 
 /**
- * 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.
+ * Path of a project file relative to its root's projects/ dir, e.g.
+ * "<root>/projects/-Users-foo-app/abc.jsonl" → "-Users-foo-app/abc.jsonl".
+ * Used both for project-name extraction and cross-root dedup.
+ */
+function projectRelativePath(filePath, projectsDir) {
+  const prefix = projectsDir + sep;
+  return filePath.startsWith(prefix) ? filePath.slice(prefix.length) : null;
+}
+
+/**
+ * Extract project name from a projects-relative path.
+ * The first segment is the dash-encoded project path (e.g. -Users-foo-myproject);
+ * we take its last component as the project name.
  */
-function extractProject(filePath) {
-  const projectsPrefix = CLAUDE_PROJECTS_DIR + sep;
-  if (!filePath.startsWith(projectsPrefix)) return 'unknown';
-  const relative = filePath.slice(projectsPrefix.length);
+function extractProject(relative) {
+  if (!relative) return 'unknown';
   const firstSeg = relative.split(sep)[0];
   if (!firstSeg) return 'unknown';
   const parts = firstSeg.split('-').filter(Boolean);
@@ -58,16 +101,21 @@ function extractSessionId(filePath) {
   return basename(filePath, '.jsonl');
 }
 
-export async function parse() {
-  const entries = [];
-  const sessionEvents = [];
-  const seenUuids = new Set();
-  const seenSessionIds = new Set();
-
-  // --- projects/ directory: extract BOTH token buckets AND session events ---
-  const projectFiles = findJsonlFiles(CLAUDE_PROJECTS_DIR);
+/**
+ * Scan one root's projects/ dir → token entries + session events (mutates ctx).
+ */
+function scanProjectsRoot(root, ctx) {
+  const projectsDir = join(root, 'projects');
+
+  for (const filePath of findJsonlFiles(projectsDir)) {
+    const relative = projectRelativePath(filePath, projectsDir);
+    // Same session present under two roots (e.g. data copied between them):
+    // process it once so session message counts aren't inflated.
+    if (relative !== null) {
+      if (ctx.seenProjectFiles.has(relative)) continue;
+      ctx.seenProjectFiles.add(relative);
+    }
 
-  for (const filePath of projectFiles) {
     let content;
     try {
       content = readFileSync(filePath, 'utf-8');
@@ -75,9 +123,9 @@ export async function parse() {
       continue;
     }
 
-    const project = extractProject(filePath);
+    const project = extractProject(relative);
     const sessionId = extractSessionId(filePath);
-    seenSessionIds.add(sessionId);
+    ctx.seenSessionIds.add(sessionId);
 
     for (const line of content.split('\n')) {
       if (!line.trim()) continue;
@@ -90,7 +138,7 @@ export async function parse() {
         if (isNaN(ts.getTime())) continue;
 
         if (obj.type === 'user' || obj.type === 'assistant' || obj.type === 'tool_use' || obj.type === 'tool_result') {
-          sessionEvents.push({
+          ctx.sessionEvents.push({
             sessionId,
             source: 'claude-code',
             project,
@@ -108,11 +156,11 @@ export async function parse() {
 
         const uuid = obj.uuid;
         if (uuid) {
-          if (seenUuids.has(uuid)) continue;
-          seenUuids.add(uuid);
+          if (ctx.seenUuids.has(uuid)) continue;
+          ctx.seenUuids.add(uuid);
         }
 
-        entries.push({
+        ctx.entries.push({
           source: 'claude-code',
           model: msg.model || 'unknown',
           project,
@@ -127,13 +175,17 @@ export async function parse() {
       }
     }
   }
+}
 
-  // --- transcripts/ directory: extract session events ONLY (no token data) ---
-  const transcriptFiles = findJsonlFiles(CLAUDE_TRANSCRIPTS_DIR);
-
-  for (const filePath of transcriptFiles) {
+/**
+ * Scan one root's transcripts/ dir → session events only (no token data).
+ * Skips sessions already covered by a projects/ or transcripts/ scan.
+ */
+function scanTranscriptsRoot(root, ctx) {
+  for (const filePath of findJsonlFiles(join(root, 'transcripts'))) {
     const sessionId = extractSessionId(filePath);
-    if (seenSessionIds.has(sessionId)) continue;
+    if (ctx.seenSessionIds.has(sessionId)) continue;
+    ctx.seenSessionIds.add(sessionId);
 
     let content;
     try {
@@ -153,7 +205,7 @@ export async function parse() {
         if (isNaN(ts.getTime())) continue;
 
         if (obj.type === 'user' || obj.type === 'assistant' || obj.type === 'tool_use' || obj.type === 'tool_result') {
-          sessionEvents.push({
+          ctx.sessionEvents.push({
             sessionId,
             source: 'claude-code',
             project: 'unknown',
@@ -166,6 +218,26 @@ export async function parse() {
       }
     }
   }
+}
 
-  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+export async function parse() {
+  const ctx = {
+    entries: [],
+    sessionEvents: [],
+    seenUuids: new Set(),
+    seenSessionIds: new Set(),
+    seenProjectFiles: new Set(), // projects-relative path → dedup same session across roots
+  };
+
+  const roots = getClaudeRoots();
+
+  // projects/ yields BOTH token buckets and session events.
+  for (const root of roots) scanProjectsRoot(root, ctx);
+  // transcripts/ yields session events only, for sessions not already covered.
+  for (const root of roots) scanTranscriptsRoot(root, ctx);
+
+  return {
+    buckets: aggregateToBuckets(ctx.entries),
+    sessions: extractSessions(ctx.sessionEvents),
+  };
 }

package/src/parsers/gemini-cli.js

@@ -1,33 +1,145 @@
-import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
 
 const TMP_DIR = join(homedir(), '.gemini', 'tmp');
 
+// Gemini CLI session storage:
+//   ~/.gemini/tmp/<project_hash>/chats/session-<ts>-<id>.jsonl   (current, v0.39+)
+//   ~/.gemini/tmp/<project_hash>/chats/session-<ts>-<id>.json    (legacy, single JSON object)
+//   ~/.gemini/tmp/<project_hash>/chats/<parent_id>/<sub_id>.jsonl (subagent sessions, nested)
+// The .jsonl migration (PR #23749, ~v0.39.0) made the old .json-only glob miss every new
+// session — collect both extensions, and recurse one level for nested subagent files.
+
+/**
+ * Walk each project's chats/ directory and collect every session file
+ * (both .json and .jsonl), descending into subagent subdirectories.
+ */
 function findSessionFiles(baseDir) {
   const results = [];
   if (!existsSync(baseDir)) return results;
 
+  let projectDirs;
+  try {
+    projectDirs = readdirSync(baseDir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+
+  for (const entry of projectDirs) {
+    if (!entry.isDirectory()) continue;
+    collectChatFiles(join(baseDir, entry.name, 'chats'), results, 0);
+  }
+  return results;
+}
+
+function collectChatFiles(dir, out, depth) {
+  if (depth > 2) return; // chats/ + nested subagent dirs is as deep as it goes
+  let entries;
   try {
-    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const chatsDir = join(baseDir, entry.name, 'chats');
-      if (!existsSync(chatsDir)) continue;
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const full = join(dir, e.name);
+    if (e.isDirectory()) {
+      collectChatFiles(full, out, depth + 1);
+    } else if (e.name.endsWith('.jsonl') || e.name.endsWith('.json')) {
+      out.push(full);
+    }
+  }
+}
+
+/**
+ * Read a session file into a uniform { messages, directories } shape.
+ * .jsonl: line 1 is session metadata, each following line is one record.
+ * .json:  a single ConversationRecord object with a messages[] array.
+ */
+function readRecords(filePath) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  if (filePath.endsWith('.jsonl')) {
+    const messages = [];
+    let directories = null;
+    for (const line of raw.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let obj;
       try {
-        for (const f of readdirSync(chatsDir)) {
-          if (f.startsWith('session-') && f.endsWith('.json')) {
-            results.push(join(chatsDir, f));
-          }
-        }
+        obj = JSON.parse(trimmed);
       } catch {
         continue;
       }
+      // The metadata line carries directories; message lines carry a `type`.
+      if (!directories && Array.isArray(obj.directories)) directories = obj.directories;
+      if (typeof obj.type === 'string' || typeof obj.role === 'string') messages.push(obj);
     }
+    return { messages, directories };
+  }
+
+  let data;
+  try {
+    data = JSON.parse(raw);
   } catch {
-    return results;
+    return null;
   }
-  return results;
+  return {
+    messages: data.messages || data.history || [],
+    directories: Array.isArray(data.directories) ? data.directories : null,
+  };
+}
+
+// Model/assistant messages are recorded as type 'gemini'; user turns as 'user'.
+// info/error/warning are system noise and skipped. `role` is accepted as a
+// fallback for any older format that used it.
+function classifyRole(msg) {
+  const t = msg.type ?? msg.role;
+  if (t === 'user') return 'user';
+  if (t === 'gemini' || t === 'model' || t === 'assistant') return 'assistant';
+  return null;
+}
+
+// Tokens live in msg.tokens.{input,output,cached,thoughts} (TokensSummary, where
+// `input` already includes cached). Fall back to the raw Gemini API usageMetadata
+// shape for any legacy record that stored it.
+function extractTokens(msg) {
+  const t = msg.tokens;
+  if (t) {
+    const cached = t.cached || 0;
+    const thoughts = t.thoughts || 0;
+    return {
+      inputTokens: (t.input || 0) - cached,
+      outputTokens: (t.output || 0) - thoughts,
+      cachedInputTokens: cached,
+      reasoningOutputTokens: thoughts,
+    };
+  }
+  const u = msg.usageMetadata || msg.usage;
+  if (u) {
+    const cached = u.cachedContentTokenCount || 0;
+    const thoughts = u.thoughtsTokenCount || 0;
+    return {
+      inputTokens: (u.promptTokenCount || u.input_tokens || 0) - cached,
+      outputTokens: (u.candidatesTokenCount || u.output_tokens || 0) - thoughts,
+      cachedInputTokens: cached,
+      reasoningOutputTokens: thoughts,
+    };
+  }
+  return null;
+}
+
+function projectFromDirectories(directories) {
+  if (!directories || directories.length === 0) return 'unknown';
+  const first = directories[0];
+  if (!first) return 'unknown';
+  return basename(String(first).replace(/[\\/]+$/, '')) || 'unknown';
 }
 
 export async function parse() {
@@ -38,61 +150,39 @@ export async function parse() {
   const sessionEvents = [];
 
   for (const filePath of sessionFiles) {
+    const record = readRecords(filePath);
+    if (!record) continue;
 
-    let data;
-    try {
-      data = JSON.parse(readFileSync(filePath, 'utf-8'));
-    } catch {
-      continue;
-    }
+    const project = projectFromDirectories(record.directories);
+
+    for (const msg of record.messages) {
+      const role = classifyRole(msg);
+      if (!role) continue;
 
-    const messages = data.messages || data.history || [];
-    for (const msg of messages) {
-      const timestamp = msg.timestamp || msg.createTime || data.createTime;
-      if (!timestamp) continue;
-      const ts = new Date(timestamp);
+      const stamp = msg.timestamp || msg.createTime;
+      if (!stamp) continue;
+      const ts = new Date(stamp);
       if (isNaN(ts.getTime())) continue;
 
-      const role = (msg.role === 'user') ? 'user' : 'assistant';
       sessionEvents.push({
         sessionId: filePath,
         source: 'gemini-cli',
-        project: 'unknown',
+        project,
         timestamp: ts,
         role,
       });
 
-      const tokens = msg.tokens;
-      const usage = msg.usage || msg.usageMetadata || msg.token_count;
-      if (!tokens && !usage) continue;
-
-      if (tokens) {
-        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) - cached,
-          outputTokens: (tokens.output || 0) - thoughts,
-          cachedInputTokens: cached,
-          reasoningOutputTokens: thoughts,
-        });
-      } else {
-        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) - cached,
-          outputTokens: (usage.candidatesTokenCount || usage.output_tokens || 0) - thoughts,
-          cachedInputTokens: cached,
-          reasoningOutputTokens: thoughts,
-        });
-      }
+      if (role !== 'assistant') continue;
+      const tokens = extractTokens(msg);
+      if (!tokens) continue;
+
+      entries.push({
+        source: 'gemini-cli',
+        model: msg.model || 'unknown',
+        project,
+        timestamp: ts,
+        ...tokens,
+      });
     }
   }
 

package/src/tools.js

@@ -80,6 +80,20 @@ function findOpenclawDataDirs() {
   return dirs;
 }
 
+// Claude Code lives in ~/.claude/projects, but $CLAUDE_CONFIG_DIR relocates its
+// whole tree. Detect either so a user who only set CLAUDE_CONFIG_DIR is still
+// recognized (the parser scans both roots; see parsers/claude-code.js).
+function findClaudeCodeDataDirs() {
+  const dirs = [join(homedir(), '.claude', 'projects')];
+  const cfg = process.env.CLAUDE_CONFIG_DIR?.trim();
+  if (cfg) {
+    let custom = cfg.startsWith('~') ? join(homedir(), cfg.slice(1)) : cfg;
+    custom = custom.replace(/[/\\]+$/, '') || custom;
+    dirs.push(join(custom, 'projects'));
+  }
+  return dirs.filter(existsSync);
+}
+
 // Codex keeps live sessions in ~/.codex/sessions and moves completed ones to
 // ~/.codex/archived_sessions. Detect Codex if either dir exists, so a user
 // whose sessions have all been archived is still recognized.
@@ -100,6 +114,7 @@ export const TOOLS = [
     name: 'Claude Code',
     id: 'claude-code',
     dataDir: join(homedir(), '.claude', 'projects'),
+    detectDataDirs: findClaudeCodeDataDirs,
   },
   {
     name: 'Cline',