@vibe-cafe/vibe-usage 0.1.7 → 0.1.9

package/package.json

@@ -1,14 +1,27 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "bin": {
-    "vibe-usage": "./bin/vibe-usage.js"
+    "vibe-usage": "bin/vibe-usage.js"
   },
-  "files": ["bin/", "src/"],
-  "engines": { "node": ">=20" },
-  "keywords": ["ai", "coding", "usage", "tokens", "claude", "codex", "gemini"],
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "ai",
+    "coding",
+    "usage",
+    "tokens",
+    "claude",
+    "codex",
+    "gemini"
+  ],
   "dependencies": {
     "ccusage": "18.0.5"
   },

package/src/hooks.js

@@ -4,9 +4,38 @@ import { homedir } from 'node:os';
 
 const SYNC_CMD = 'npx @vibe-cafe/vibe-usage sync 2>/dev/null &';
 
+/**
+ * Check if a SessionEnd hook array (new or old format) already contains a vibe-usage hook.
+ */
 function hasVibeUsageHook(hooks) {
   if (!Array.isArray(hooks)) return false;
-  return hooks.some(h => h.command && h.command.includes('vibe-usage'));
+  return hooks.some(entry => {
+    // New format: { matcher?: "...", hooks: [{ type, command }] }
+    if (Array.isArray(entry.hooks)) {
+      return entry.hooks.some(h => h.command && h.command.includes('vibe-usage'));
+    }
+    // Old format: { type, command } directly
+    if (entry.command && entry.command.includes('vibe-usage')) return true;
+    return false;
+  });
+}
+
+/**
+ * Migrate old-format hook entries to the new matcher format.
+ * Old: [{ type: "command", command: "..." }]
+ * New: [{ hooks: [{ type: "command", command: "..." }] }]
+ */
+function migrateOldFormatHooks(hooks) {
+  if (!Array.isArray(hooks)) return hooks;
+  return hooks.map(entry => {
+    // Already new format (has "hooks" array)
+    if (Array.isArray(entry.hooks)) return entry;
+    // Old format: bare handler → wrap in matcher group
+    if (entry.type && entry.command) {
+      return { hooks: [entry] };
+    }
+    return entry;
+  });
 }
 
 export function injectClaudeCode() {
@@ -21,11 +50,28 @@ export function injectClaudeCode() {
   if (!settings.hooks) settings.hooks = {};
   if (!settings.hooks.SessionEnd) settings.hooks.SessionEnd = [];
 
+  // Migrate any old-format hooks first
+  settings.hooks.SessionEnd = migrateOldFormatHooks(settings.hooks.SessionEnd);
+
   if (hasVibeUsageHook(settings.hooks.SessionEnd)) {
-    return { injected: false, reason: 'already installed' };
+    // Update the command in existing hook to use latest
+    for (const group of settings.hooks.SessionEnd) {
+      if (Array.isArray(group.hooks)) {
+        for (const h of group.hooks) {
+          if (h.command && h.command.includes('vibe-usage')) {
+            h.command = SYNC_CMD;
+          }
+        }
+      }
+    }
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    return { injected: false, reason: 'already installed (updated)' };
   }
 
-  settings.hooks.SessionEnd.push({ type: 'command', command: SYNC_CMD });
+  // New format: matcher group with hooks array
+  settings.hooks.SessionEnd.push({
+    hooks: [{ type: 'command', command: SYNC_CMD }],
+  });
   writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
   return { injected: true };
 }
@@ -40,7 +86,13 @@ export function injectCodex() {
   }
 
   if (content.includes('vibe-usage')) {
-    return { injected: false, reason: 'already installed' };
+    // Update existing command to use latest
+    content = content.replace(
+      /npx @vibe-cafe\/vibe-usage(?:@[\d.]+)? sync[^"']*/g,
+      SYNC_CMD,
+    );
+    writeFileSync(configPath, content, 'utf-8');
+    return { injected: false, reason: 'already installed (updated)' };
   }
 
   const notifySection = `\n[notify]\ncommand = "${SYNC_CMD}"\n`;
@@ -73,6 +125,7 @@ export function injectGeminiCli() {
     return { injected: false, reason: 'already installed' };
   }
 
+  // Gemini CLI still uses the flat format (no matcher groups)
   settings.hooks.SessionEnd.push({ type: 'command', command: SYNC_CMD });
   writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
   return { injected: true };

package/src/parsers/codex.js

@@ -1,23 +1,39 @@
 import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
-import { join, basename } from 'node:path';
+import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets } from './index.js';
 
 const SESSIONS_DIR = join(homedir(), '.codex', 'sessions');
 
-export async function parse(lastSync) {
-  if (!existsSync(SESSIONS_DIR)) return [];
-
-  const entries = [];
-  let files;
+/**
+ * Recursively find all .jsonl files under a directory.
+ * Codex CLI stores sessions as: ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
+ */
+function findJsonlFiles(dir) {
+  const results = [];
+  if (!existsSync(dir)) return results;
   try {
-    files = readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.jsonl'));
+    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
   }
+  return results;
+}
 
-  for (const file of files) {
-    const filePath = join(SESSIONS_DIR, file);
+export async function parse(lastSync) {
+  if (!existsSync(SESSIONS_DIR)) return [];
+
+  const entries = [];
+  const files = findJsonlFiles(SESSIONS_DIR);
+  if (files.length === 0) return [];
+  for (const filePath of files) {
     if (lastSync) {
       try {
         const stat = statSync(filePath);
@@ -27,8 +43,6 @@ export async function parse(lastSync) {
       }
     }
 
-    const project = basename(file, '.jsonl');
-
     let content;
     try {
       content = readFileSync(filePath, 'utf-8');
@@ -36,9 +50,30 @@ export async function parse(lastSync) {
       continue;
     }
 
+    // Extract project name and model from session_meta line
+    let sessionProject = 'unknown';
+    let sessionModel = 'unknown';
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === 'session_meta' && obj.payload) {
+          const meta = obj.payload;
+          if (meta.cwd) {
+            sessionProject = meta.cwd.split('/').pop() || 'unknown';
+          }
+          if (meta.git?.repository_url) {
+            // e.g. https://github.com/org/repo.git → org/repo
+            const match = meta.git.repository_url.match(/([^/]+\/[^/]+?)(?:\.git)?$/);
+            if (match) sessionProject = match[1];
+          }
+          break;
+        }
+      } catch { break; }
+    }
+
     // Track previous cumulative totals per model to compute deltas when only total_token_usage is available
     const prevTotal = new Map();
-
     for (const line of content.split('\n')) {
       if (!line.trim()) continue;
       try {
@@ -78,12 +113,12 @@ export async function parse(lastSync) {
         }
         if (!usage) continue;
 
-        const model = info.model || payload.model || 'unknown';
+        const model = info.model || payload.model || sessionModel;
 
         entries.push({
           source: 'codex',
           model,
-          project,
+          project: sessionProject,
           timestamp,
           inputTokens: usage.input_tokens || 0,
           outputTokens: usage.output_tokens || 0,

package/src/parsers/gemini-cli.js

@@ -55,8 +55,11 @@ export async function parse(lastSync) {
 
     const messages = data.messages || data.history || [];
     for (const msg of messages) {
+      // New format: tokens on type=gemini messages (ChatRecordingService)
+      // Old format: usage/usageMetadata on any message
+      const tokens = msg.tokens;
       const usage = msg.usage || msg.usageMetadata || msg.token_count;
-      if (!usage) continue;
+      if (!tokens && !usage) continue;
 
       const timestamp = msg.timestamp || msg.createTime || data.createTime;
       if (!timestamp) continue;
@@ -64,16 +67,31 @@ export async function parse(lastSync) {
       if (isNaN(ts.getTime())) continue;
       if (lastSync && ts <= new Date(lastSync)) continue;
 
-      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,
-      });
+      if (tokens) {
+        // New format: { input, output, cached, thoughts, tool, total }
+        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,
+        });
+      } else {
+        // Old format: { promptTokenCount, candidatesTokenCount, ... }
+        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,
+        });
+      }
     }
   }