@vibe-cafe/vibe-usage 0.8.1 → 0.8.2

package/README.md

@@ -50,7 +50,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | 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.2",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "bin": {

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,
+      });
     }
   }