getaimeter 0.4.0 → 0.6.0

package/config.js

@@ -76,6 +76,30 @@ function getWatchPaths() {
   const codexHistory = path.join(os.homedir(), '.codex');
   if (fs.existsSync(codexHistory) && !paths.includes(codexHistory)) paths.push(codexHistory);
 
+  // 4. GitHub Copilot CLI sessions
+  const copilotSessions = path.join(os.homedir(), '.copilot', 'session-state');
+  if (fs.existsSync(copilotSessions)) paths.push(copilotSessions);
+
+  // 5. Gemini CLI sessions
+  const geminiDir = path.join(os.homedir(), '.gemini', 'tmp');
+  if (fs.existsSync(geminiDir)) {
+    // Gemini stores sessions under ~/.gemini/tmp/<project_hash>/chats/
+    // Watch the entire tmp dir and findJsonlFiles will recurse into it
+    paths.push(geminiDir);
+  }
+
+  // 6. Cursor IDE — stores conversations in SQLite at globalStorage/state.vscdb
+  //    We watch the globalStorage dir; the watcher handles .vscdb files separately
+  let cursorGlobal;
+  if (platform === 'win32') {
+    cursorGlobal = path.join(process.env.APPDATA || '', 'Cursor', 'User', 'globalStorage');
+  } else if (platform === 'darwin') {
+    cursorGlobal = path.join(os.homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage');
+  } else {
+    cursorGlobal = path.join(os.homedir(), '.config', 'Cursor', 'User', 'globalStorage');
+  }
+  if (fs.existsSync(cursorGlobal)) paths.push(cursorGlobal);
+
   return paths;
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "getaimeter",
-  "version": "0.4.0",
-  "description": "Track your Claude AI usage across CLI, VS Code, and Desktop App. One command to start.",
+  "version": "0.6.0",
+  "description": "Track AI coding costs across Claude, Cursor, Codex, and Gemini. Optimization recommendations that cut costs by 30%.",
   "bin": {
     "aimeter": "cli.js"
   },
@@ -13,14 +13,19 @@
   "keywords": [
     "claude",
     "anthropic",
-    "usage",
-    "tracking",
+    "cursor",
+    "codex",
+    "gemini",
     "ai",
     "tokens",
     "cost",
+    "usage",
+    "tracking",
     "monitor",
+    "optimization",
     "claude-code",
-    "vscode"
+    "vscode",
+    "multi-tool"
   ],
   "files": [
     "cli.js",

package/watcher.js

@@ -3,6 +3,7 @@
 const fs     = require('fs');
 const path   = require('path');
 const crypto = require('crypto');
+const { execSync } = require('child_process');
 const { getApiKey, getWatchPaths } = require('./config');
 const { getOffset, setOffset, isDuplicate, save: saveState } = require('./state');
 const { postUsage } = require('./reporter');
@@ -65,6 +66,23 @@ function detectSource(filePath) {
     }
   }
 
+  if (normalized.includes('.copilot/') || normalized.includes('/copilot/')) {
+    _sourceCache.set(filePath, 'copilot_cli');
+    return 'copilot_cli';
+  }
+  if (normalized.includes('.gemini/') || normalized.includes('/gemini/')) {
+    _sourceCache.set(filePath, 'gemini_cli');
+    return 'gemini_cli';
+  }
+  if (normalized.includes('.codex/') || normalized.includes('/codex/')) {
+    _sourceCache.set(filePath, 'codex_cli');
+    return 'codex_cli';
+  }
+  if (normalized.includes('/Cursor/') || normalized.includes('/cursor/') || normalized.includes('.cursor/')) {
+    _sourceCache.set(filePath, 'cursor');
+    return 'cursor';
+  }
+
   // Read first 10KB of the file to find entrypoint or IDE markers
   let source = 'cli'; // default
   try {
@@ -182,6 +200,49 @@ function extractNewUsage(filePath) {
         continue;
       }
 
+      // ── Copilot CLI format ────────────────────────────────────────
+      // Copilot events: { type: "token_usage", input_tokens, output_tokens, reasoning_tokens, model }
+      if (obj.type === 'token_usage' && (obj.input_tokens !== undefined || obj.output_tokens !== undefined)) {
+        const copilotModel = obj.model || 'copilot';
+        const hashKey = `${filePath}:${lineOffset}:copilot:${obj.input_tokens || 0}:${obj.output_tokens || 0}`;
+        const hash = crypto.createHash('md5').update(hashKey).digest('hex');
+        if (isDuplicate(hash)) continue;
+
+        usageEvents.push({
+          provider:         'github',
+          model:            copilotModel,
+          source:           'copilot_cli',
+          inputTokens:      obj.input_tokens || 0,
+          outputTokens:     obj.output_tokens || 0,
+          thinkingTokens:   obj.reasoning_tokens || 0,
+          cacheReadTokens:  0,
+          cacheWriteTokens: 0,
+        });
+        continue;
+      }
+
+      // ── Gemini CLI format ─────────────────────────────────────────
+      // Gemini events may contain usageMetadata: { promptTokenCount, candidatesTokenCount, totalTokenCount }
+      if (obj.usageMetadata && (obj.usageMetadata.promptTokenCount || obj.usageMetadata.candidatesTokenCount)) {
+        const um = obj.usageMetadata;
+        const geminiModel = obj.modelVersion || obj.model || 'gemini';
+        const hashKey = `${filePath}:${lineOffset}:gemini:${um.promptTokenCount || 0}:${um.candidatesTokenCount || 0}`;
+        const hash = crypto.createHash('md5').update(hashKey).digest('hex');
+        if (isDuplicate(hash)) continue;
+
+        usageEvents.push({
+          provider:         'google',
+          model:            geminiModel,
+          source:           'gemini_cli',
+          inputTokens:      um.promptTokenCount || 0,
+          outputTokens:     um.candidatesTokenCount || 0,
+          thinkingTokens:   um.thoughtsTokenCount || 0,
+          cacheReadTokens:  um.cachedContentTokenCount || 0,
+          cacheWriteTokens: 0,
+        });
+        continue;
+      }
+
       continue;
     }
 
@@ -245,6 +306,129 @@ function extractNewUsage(filePath) {
   return usageEvents;
 }
 
+// ---------------------------------------------------------------------------
+// Cursor IDE — extract usage from SQLite state.vscdb
+// ---------------------------------------------------------------------------
+
+// Track last-seen composerData keys to detect new conversations
+const _cursorSeenKeys = new Set();
+let _cursorSqliteAvailable = null; // null = unchecked, true/false after first check
+
+function isSqliteAvailable() {
+  if (_cursorSqliteAvailable !== null) return _cursorSqliteAvailable;
+  try {
+    execSync('sqlite3 --version', { stdio: 'pipe', timeout: 5000 });
+    _cursorSqliteAvailable = true;
+  } catch {
+    _cursorSqliteAvailable = false;
+    log('sqlite3 CLI not found — Cursor tracking disabled. Install sqlite3 to enable.');
+  }
+  return _cursorSqliteAvailable;
+}
+
+function extractCursorUsage(dbPath) {
+  if (!isSqliteAvailable()) return [];
+  if (!fs.existsSync(dbPath)) return [];
+
+  // Check if the DB file has been modified since our last check
+  let stat;
+  try { stat = fs.statSync(dbPath); } catch { return []; }
+  const currentMtime = stat.mtimeMs;
+  const lastMtime = getOffset(dbPath + ':mtime');
+  if (currentMtime <= lastMtime) return [];
+
+  const usageEvents = [];
+
+  try {
+    // Query composerData entries from Cursor's KV store
+    // Each entry has usageData with per-model cost and count
+    const raw = execSync(
+      `sqlite3 "${dbPath}" "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'"`,
+      { timeout: 10000, maxBuffer: 50 * 1024 * 1024, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+
+    if (!raw || !raw.trim()) {
+      setOffset(dbPath + ':mtime', currentMtime);
+      return [];
+    }
+
+    for (const line of raw.split('\n')) {
+      if (!line.trim()) continue;
+
+      // sqlite3 outputs "key|value" with pipe separator
+      const sepIdx = line.indexOf('|');
+      if (sepIdx < 0) continue;
+
+      const key = line.substring(0, sepIdx);
+      const valueStr = line.substring(sepIdx + 1);
+
+      // Skip already-seen conversations
+      if (_cursorSeenKeys.has(key)) continue;
+
+      let data;
+      try { data = JSON.parse(valueStr); } catch { continue; }
+
+      // Extract usage from composerData.usageData
+      // Format: { "model-name": { costInCents: 0.42, amount: 1 }, ... }
+      const usage = data.usageData;
+      if (!usage || typeof usage !== 'object') {
+        _cursorSeenKeys.add(key);
+        continue;
+      }
+
+      const composerId = data.composerId || key;
+      const timestamp = data.lastUpdatedAt || data.createdAt;
+
+      for (const [model, stats] of Object.entries(usage)) {
+        if (!stats || typeof stats !== 'object') continue;
+
+        const costCents = stats.costInCents || 0;
+        const amount = stats.amount || 0;
+        if (costCents <= 0 && amount <= 0) continue;
+
+        const hashKey = `cursor:${composerId}:${model}:${costCents}:${amount}`;
+        const hash = crypto.createHash('md5').update(hashKey).digest('hex');
+        if (isDuplicate(hash)) continue;
+
+        // Determine provider from model name
+        let provider = 'openai'; // default — Cursor uses OpenAI models primarily
+        if (model.includes('claude') || model.includes('anthropic')) {
+          provider = 'anthropic';
+        } else if (model.includes('gemini')) {
+          provider = 'google';
+        }
+
+        // Estimate tokens from cost (rough inverse of pricing)
+        // costInCents is total cost. We don't have exact input/output split,
+        // so we attribute it all as output tokens for a rough estimate.
+        // Using mid-range pricing for estimation: ~$10/M tokens average
+        const estimatedTokens = Math.round((costCents / 100) / (10 / 1_000_000));
+
+        usageEvents.push({
+          provider,
+          model,
+          source:           'cursor',
+          inputTokens:      0,
+          outputTokens:     estimatedTokens > 0 ? estimatedTokens : amount * 500, // fallback: ~500 tokens per request
+          thinkingTokens:   0,
+          cacheReadTokens:  0,
+          cacheWriteTokens: 0,
+        });
+      }
+
+      _cursorSeenKeys.add(key);
+    }
+  } catch (err) {
+    // SQLite might be locked by Cursor — this is normal, retry next poll
+    if (!err.message.includes('database is locked')) {
+      logError('Cursor SQLite read error:', err.message);
+    }
+  }
+
+  setOffset(dbPath + ':mtime', currentMtime);
+  return usageEvents;
+}
+
 // ---------------------------------------------------------------------------
 // Report usage events to backend
 // ---------------------------------------------------------------------------
@@ -319,6 +503,20 @@ function findJsonlFiles(dir) {
   return results;
 }
 
+/**
+ * Find Cursor state.vscdb files in watch paths.
+ */
+function findCursorDbs(dirs) {
+  const results = [];
+  for (const dir of dirs) {
+    const vscdb = path.join(dir, 'state.vscdb');
+    if (fs.existsSync(vscdb)) {
+      results.push(vscdb);
+    }
+  }
+  return results;
+}
+
 /**
  * Start watching all configured paths.
  * Returns a cleanup function.
@@ -327,7 +525,7 @@ function startWatching() {
   const watchPaths = getWatchPaths();
 
   if (watchPaths.length === 0) {
-    logError('No Claude transcript directories found. Is Claude Code installed?');
+    logError('No AI tool directories found. Is Claude Code, Cursor, Codex, or Gemini CLI installed?');
     process.exit(1);
   }
 
@@ -381,10 +579,29 @@ function startWatching() {
   const POLL_INTERVAL = 5_000;
   let polling = false;
 
+  // Find Cursor DBs once at startup
+  const cursorDbs = findCursorDbs(watchPaths);
+  if (cursorDbs.length > 0) {
+    log('Cursor databases found:', cursorDbs.join(', '));
+    // Mark existing Cursor data as seen on first run
+    if (isFirstRun) {
+      for (const dbPath of cursorDbs) {
+        try {
+          const mtime = fs.statSync(dbPath).mtimeMs;
+          setOffset(dbPath + ':mtime', mtime);
+          // Pre-populate seen keys so we don't report historical data
+          extractCursorUsage(dbPath); // populates _cursorSeenKeys but we discard results
+        } catch {}
+      }
+      log('Cursor: marked existing conversations as read');
+    }
+  }
+
   const pollInterval = setInterval(async () => {
     if (polling) return; // skip if previous poll still running
     polling = true;
     try {
+      // Poll JSONL files (Claude, Codex, Gemini, etc.)
       for (const watchPath of watchPaths) {
         const files = findJsonlFiles(watchPath);
         for (const file of files) {
@@ -397,6 +614,19 @@ function startWatching() {
           } catch {}
         }
       }
+
+      // Poll Cursor SQLite databases
+      for (const dbPath of cursorDbs) {
+        try {
+          const events = extractCursorUsage(dbPath);
+          if (events.length > 0) {
+            await reportEvents(events);
+            saveState();
+          }
+        } catch (err) {
+          logError('Cursor poll error:', err.message);
+        }
+      }
     } finally {
       polling = false;
     }