getaimeter 0.5.0 → 0.6.0

package/config.js

@@ -88,6 +88,18 @@ function getWatchPaths() {
     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.5.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');
@@ -77,6 +78,10 @@ function detectSource(filePath) {
     _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
@@ -301,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
 // ---------------------------------------------------------------------------
@@ -375,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.
@@ -383,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);
   }
 
@@ -437,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) {
@@ -453,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;
     }