cursor-usage-analyzer 0.2.1 → 0.3.1

package/.claude/settings.local.json

@@ -1,13 +1,19 @@
 {
   "permissions": {
     "allow": [
-      "Bash(npm install)",
-      "Bash(sqlite3:*)",
-      "Bash(python3:*)",
+      "mcp__plus4u-mcp__document_read",
+      "mcp__plus4u-mcp__book_list_structure",
+      "Bash(npm install:*)",
       "Bash(node -e:*)",
-      "Bash(for file in cursor-logs-export/chats/2025-12-17*.txt)",
-      "Bash(grep:*)",
-      "Bash(node analyze.js:*)"
+      "Bash(node analyze.js:*)",
+      "mcp__skilled-plus4u-mcp__login",
+      "Bash(npm rebuild:*)",
+      "mcp__skilled-plus4u-mcp__executeSkill",
+      "Bash(node-gyp rebuild:*)",
+      "Bash(npx node-gyp rebuild:*)",
+      "Bash(npm run install:*)",
+      "Bash(npm run build:*)",
+      "Bash(node validate.js:*)"
     ]
   }
 }

package/README.md

@@ -34,8 +34,13 @@ cd cursor-usage-analyzer
 
 # Install dependencies
 npm install
+
+# Build native bindings (runs automatically via postinstall, but run manually if needed)
+npm run build
 ```
 
+**Note**: The `postinstall` script automatically builds `better-sqlite3` native bindings. If you see SQLite errors, run `npm run build` manually.
+
 ## Quick Start
 
 ### Using npx
@@ -307,6 +312,15 @@ Ensure Cursor has been used and conversations exist. Check the database path for
 - Verify you have conversations in Cursor from that period
 - Ensure Cursor isn't currently running (may lock database)
 
+### SQLite errors or "Database exceeds 2GB limit"
+This means `better-sqlite3` native bindings weren't built properly. Fix it by:
+
+```bash
+npm run build
+```
+
+This rebuilds the native SQLite bindings. The tool will fall back to `sql.js` (pure JavaScript) if native bindings fail, but `sql.js` has a 2GB database size limit.
+
 ### Project shows as "unknown"
 This happens when the analyzer can't determine the workspace from file paths. The conversation is still exported with all content intact.
 

package/analyze.js

@@ -3,10 +3,83 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import Database from 'better-sqlite3';
 import { generateHTMLReport } from './html-template.js';
 import { parse } from 'csv-parse/sync';
 
+// Database abstraction - try better-sqlite3 first, fall back to sql.js
+let dbEngine = null;
+
+async function loadDatabaseEngine() {
+  // Try better-sqlite3 first (faster, handles large files)
+  try {
+    const { default: Database } = await import('better-sqlite3');
+    // Test that it actually works (native bindings compiled)
+    const testDb = new Database(':memory:');
+    testDb.close();
+    dbEngine = { type: 'better-sqlite3', Database };
+    return;
+  } catch (e) {
+    console.log('Note: better-sqlite3 unavailable, trying sql.js fallback...');
+  }
+  
+  // Fall back to sql.js (pure JS, works everywhere, but 2GB limit)
+  try {
+    const { default: initSqlJs } = await import('sql.js');
+    const SQL = await initSqlJs();
+    dbEngine = { type: 'sql.js', SQL };
+  } catch (e) {
+    throw new Error('No SQLite library available. Please run: npm install -g cursor-usage-analyzer');
+  }
+}
+
+function openDatabase(dbPath) {
+  if (dbEngine.type === 'better-sqlite3') {
+    return new dbEngine.Database(dbPath, { readonly: true });
+  } else {
+    const fileSize = fs.statSync(dbPath).size;
+    if (fileSize > 2 * 1024 * 1024 * 1024) {
+      throw new Error(
+        `Database file (${(fileSize / 1024 / 1024 / 1024).toFixed(2)} GB) exceeds sql.js 2GB limit.\n` +
+        `To fix this, install globally with native compilation:\n` +
+        `  npm install -g cursor-usage-analyzer\n` +
+        `Or clone and build locally:\n` +
+        `  git clone https://github.com/xaverric/cursor-usage-analyzer.git\n` +
+        `  cd cursor-usage-analyzer && npm install && npm rebuild better-sqlite3`
+      );
+    }
+    const dbBuffer = fs.readFileSync(dbPath);
+    return new dbEngine.SQL.Database(dbBuffer);
+  }
+}
+
+function dbQueryAll(db, sql, params = []) {
+  if (dbEngine.type === 'better-sqlite3') {
+    return db.prepare(sql).all(...params);
+  } else {
+    const stmt = db.prepare(sql);
+    if (params.length > 0) stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+      results.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return results;
+  }
+}
+
+function dbQueryOne(db, sql, params = []) {
+  if (dbEngine.type === 'better-sqlite3') {
+    return db.prepare(sql).get(...params);
+  } else {
+    const results = dbQueryAll(db, sql, params);
+    return results.length > 0 ? results[0] : null;
+  }
+}
+
+function dbClose(db) {
+  db.close();
+}
+
 // Get Cursor storage paths based on OS
 function getCursorPaths() {
   const platform = os.platform();
@@ -135,13 +208,14 @@ function parseCSVUsage(csvPath) {
 }
 
 // Match API calls to a conversation based on timestamp and model
-function matchAPICallsToConversation(conv, apiCalls, timeWindow = 5 * 60 * 1000) {
+function matchAPICallsToConversation(conv, apiCalls, timeWindow = 10 * 60 * 1000) {
   if (!apiCalls || apiCalls.length === 0) return [];
 
-  const convStart = conv.timestamp;
-  const convEnd = conv.messages.length > 0
-    ? Math.max(...conv.messages.map(m => m.timestamp))
-    : convStart;
+  const convStart = conv.createdAt || conv.timestamp;
+  const convEnd = Math.max(
+    conv.timestamp,
+    conv.messages.length > 0 ? Math.max(...conv.messages.map(m => m.timestamp)) : 0
+  );
 
   const normalizeModel = (model) => {
     if (!model) return 'unknown';
@@ -149,20 +223,21 @@ function matchAPICallsToConversation(conv, apiCalls, timeWindow = 5 * 60 * 1000)
     if (m.includes('sonnet')) return 'sonnet';
     if (m.includes('opus')) return 'opus';
     if (m.includes('composer')) return 'composer';
-    if (m === 'auto' || m === 'default' || m === 'unknown') return 'any';
-    return model;
+    if (m.includes('gpt')) return 'gpt';
+    if (m.includes('gemini')) return 'gemini';
+    return m;
   };
 
   const convModel = normalizeModel(conv.model);
+  // For 'auto', 'default', 'unknown' models - match by time only
+  const isFlexibleModel = ['auto', 'default', 'unknown'].includes(convModel);
 
   return apiCalls.filter(call => {
     const callModel = normalizeModel(call.model);
     const timeMatch = call.timestamp >= (convStart - timeWindow) &&
                      call.timestamp <= (convEnd + timeWindow);
 
-    const modelMatch = convModel === 'any' ||
-                      callModel === 'any' ||
-                      convModel === callModel;
+    const modelMatch = isFlexibleModel || convModel === callModel;
 
     return timeMatch && modelMatch;
   });
@@ -215,6 +290,37 @@ function readWorkspaceJson(workspaceId) {
   return null;
 }
 
+// Build composerId -> workspaceName map from workspace databases
+function buildComposerWorkspaceMap() {
+  const map = {};
+  try {
+    const entries = fs.readdirSync(CURSOR_WORKSPACE_STORAGE);
+    for (const entry of entries) {
+      const wsName = readWorkspaceJson(entry);
+      if (!wsName) continue;
+
+      const dbFile = path.join(CURSOR_WORKSPACE_STORAGE, entry, 'state.vscdb');
+      if (!fs.existsSync(dbFile)) continue;
+
+      try {
+        const db = openDatabase(dbFile);
+        const row = dbQueryOne(db, "SELECT value FROM ItemTable WHERE key = 'composer.composerData'");
+        if (row) {
+          const data = JSON.parse(row.value);
+          const composers = data.allComposers || [];
+          for (const c of composers) {
+            if (c.composerId) {
+              map[c.composerId] = wsName;
+            }
+          }
+        }
+        dbClose(db);
+      } catch (e) {}
+    }
+  } catch (e) {}
+  return map;
+}
+
 // Find workspace name from file path
 function findWorkspaceFromPath(filePath) {
   try {
@@ -245,34 +351,89 @@ function findWorkspaceFromPath(filePath) {
   return parts[parts.length - 2] || 'unknown';
 }
 
+// Extract file paths from various composer data sources
+function extractFilePathsFromComposer(composerData) {
+  const paths = [];
+
+  // newlyCreatedFiles - array of objects with uri.path
+  if (Array.isArray(composerData.newlyCreatedFiles)) {
+    for (const f of composerData.newlyCreatedFiles) {
+      const p = f?.uri?.path || f?.uri?.fsPath;
+      if (p) paths.push(p);
+    }
+  }
+
+  // codeBlockData - can be array of file URI strings or object with file URI keys
+  if (Array.isArray(composerData.codeBlockData)) {
+    for (const item of composerData.codeBlockData) {
+      if (typeof item === 'string') paths.push(item.replace('file://', ''));
+    }
+  } else if (composerData.codeBlockData && typeof composerData.codeBlockData === 'object') {
+    for (const key of Object.keys(composerData.codeBlockData)) {
+      paths.push(key.replace('file://', ''));
+    }
+  }
+
+  // originalFileStates - array of file URI strings
+  if (Array.isArray(composerData.originalFileStates)) {
+    for (const item of composerData.originalFileStates) {
+      if (typeof item === 'string') paths.push(item.replace('file://', ''));
+    }
+  }
+
+  // allAttachedFileCodeChunksUris - array of file URI strings
+  if (Array.isArray(composerData.allAttachedFileCodeChunksUris)) {
+    for (const item of composerData.allAttachedFileCodeChunksUris) {
+      if (typeof item === 'string') paths.push(item.replace('file://', ''));
+    }
+  }
+
+  // addedFiles - can be array of file URI strings (sometimes it's a number)
+  if (Array.isArray(composerData.addedFiles)) {
+    for (const item of composerData.addedFiles) {
+      if (typeof item === 'string') paths.push(item.replace('file://', ''));
+    }
+  }
+
+  return paths;
+}
+
 // Determine workspace name from multiple sources
-function resolveWorkspace(composerData, headers, db, composerId) {
-  // Try workspaceId first
+function resolveWorkspace(composerData, headers, composerId, composerWorkspaceMap) {
+  // Try composer->workspace map first (most reliable)
+  if (composerWorkspaceMap && composerId && composerWorkspaceMap[composerId]) {
+    return composerWorkspaceMap[composerId];
+  }
+
+  // Try workspaceId field
   if (composerData.workspaceId) {
     const name = readWorkspaceJson(composerData.workspaceId);
     if (name) return name;
   }
   
-  // Try file paths from various sources
-  const fileSources = [
-    composerData.newlyCreatedFiles?.[0]?.uri?.path,
-    Object.keys(composerData.codeBlockData || {})[0]?.replace('file://', ''),
-    composerData.addedFiles?.[0]?.replace('file://', ''),
-    composerData.allAttachedFileCodeChunksUris?.[0]?.replace('file://', '')
-  ];
-  
-  for (const filePath of fileSources) {
+  // Try file paths from all available sources
+  const filePaths = extractFilePathsFromComposer(composerData);
+  for (const filePath of filePaths) {
     if (filePath) {
       const name = findWorkspaceFromPath(filePath);
       if (name !== 'unknown') return name;
     }
   }
   
+  return 'unknown';
+}
+
+// Determine workspace name with database access for messageRequestContext
+function resolveWorkspaceWithDb(composerData, headers, db, composerId, composerWorkspaceMap) {
+  // Try basic resolution first
+  const basicResult = resolveWorkspace(composerData, headers, composerId, composerWorkspaceMap);
+  if (basicResult !== 'unknown') return basicResult;
+  
   // Last resort: messageRequestContext
   if (headers?.length > 0) {
     try {
       const contextKey = `messageRequestContext:${composerId}:${headers[0].bubbleId}`;
-      const row = db.prepare("SELECT value FROM cursorDiskKV WHERE key = ?").get(contextKey);
+      const row = dbQueryOne(db, "SELECT value FROM cursorDiskKV WHERE key = ?", [contextKey]);
       if (row) {
         const context = JSON.parse(row.value);
         if (context.projectLayouts?.length > 0) {
@@ -288,7 +449,7 @@ function resolveWorkspace(composerData, headers, db, composerId) {
 }
 
 // Extract conversations from database
-function extractConversations(startTime, endTime, apiCalls = []) {
+async function extractConversations(startTime, endTime, apiCalls = []) {
   const dbPath = path.join(CURSOR_GLOBAL_STORAGE, 'state.vscdb');
 
   if (!fs.existsSync(dbPath)) {
@@ -297,11 +458,15 @@ function extractConversations(startTime, endTime, apiCalls = []) {
   }
 
   try {
-    const db = new Database(dbPath, { readonly: true });
+    console.log('Building workspace map...');
+    const composerWorkspaceMap = buildComposerWorkspaceMap();
+    console.log(`Mapped ${Object.keys(composerWorkspaceMap).length} composer IDs to workspaces`);
+
+    const db = openDatabase(dbPath);
 
     // Load all bubbles
     const bubbleMap = {};
-    const bubbleRows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'").all();
+    const bubbleRows = dbQueryAll(db, "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'");
 
     for (const row of bubbleRows) {
       try {
@@ -312,9 +477,9 @@ function extractConversations(startTime, endTime, apiCalls = []) {
     }
 
     // Load composers
-    const composerRows = db.prepare(
+    const composerRows = dbQueryAll(db,
       "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%' AND value LIKE '%fullConversationHeadersOnly%'"
-    ).all();
+    );
 
     const conversations = [];
 
@@ -322,9 +487,12 @@ function extractConversations(startTime, endTime, apiCalls = []) {
       try {
         const composerId = row.key.split(':')[1];
         const composer = JSON.parse(row.value);
-        const timestamp = composer.lastUpdatedAt || composer.createdAt || Date.now();
+        const createdAt = composer.createdAt || 0;
+        const lastUpdatedAt = composer.lastUpdatedAt || createdAt;
+        const timestamp = lastUpdatedAt || Date.now();
 
-        if (timestamp < startTime || timestamp > endTime) continue;
+        // Include conversation if its time range overlaps with the query range
+        if (lastUpdatedAt < startTime || createdAt > endTime) continue;
 
         const headers = composer.fullConversationHeadersOnly || [];
         if (headers.length === 0) continue;
@@ -341,7 +509,7 @@ function extractConversations(startTime, endTime, apiCalls = []) {
             return {
               role: h.type === 1 ? 'user' : 'assistant',
               text: text.trim(),
-              timestamp: bubble.timestamp || Date.now()
+              timestamp: bubble.timestamp || timestamp
             };
           })
           .filter(Boolean);
@@ -352,9 +520,10 @@ function extractConversations(startTime, endTime, apiCalls = []) {
           composerId,
           name: composer.name || 'Untitled Chat',
           timestamp,
+          createdAt,
           messages,
           messageCount: messages.length,
-          workspace: resolveWorkspace(composer, headers, db, composerId),
+          workspace: resolveWorkspaceWithDb(composer, headers, db, composerId, composerWorkspaceMap),
           model: composer.modelConfig?.modelName || 'unknown',
           contextTokensUsed: composer.contextTokensUsed || 0,
           contextTokenLimit: composer.contextTokenLimit || 0,
@@ -372,22 +541,20 @@ function extractConversations(startTime, endTime, apiCalls = []) {
     // Match API calls to conversations WITHOUT double-counting
     // Each API call should only be matched to ONE conversation
     if (apiCalls.length > 0) {
+      // Tag each API call with its original index for tracking
+      const indexedApiCalls = apiCalls.map((call, idx) => ({ ...call, _origIdx: idx }));
       const usedApiCallIndices = new Set();
 
-      for (const conv of conversations) {
-        const availableApiCalls = apiCalls.filter((_, idx) => !usedApiCallIndices.has(idx));
+      // Sort conversations by timestamp so matching is deterministic
+      const sortedConvs = [...conversations].sort((a, b) => a.timestamp - b.timestamp);
+
+      for (const conv of sortedConvs) {
+        const availableApiCalls = indexedApiCalls.filter(c => !usedApiCallIndices.has(c._origIdx));
         const matchedCalls = matchAPICallsToConversation(conv, availableApiCalls);
 
-        // Mark these API calls as used
+        // Mark these API calls as used by their original index
         matchedCalls.forEach(call => {
-          const originalIndex = apiCalls.findIndex(c =>
-            c.timestamp === call.timestamp &&
-            c.model === call.model &&
-            c.totalTokens === call.totalTokens
-          );
-          if (originalIndex !== -1) {
-            usedApiCallIndices.add(originalIndex);
-          }
+          usedApiCallIndices.add(call._origIdx);
         });
 
         conv.apiCalls = matchedCalls;
@@ -403,6 +570,48 @@ function extractConversations(startTime, endTime, apiCalls = []) {
           cost: matchedCalls.reduce((sum, c) => sum + c.cost, 0)
         };
       }
+
+      // Group unmatched API calls by day and add as synthetic entries
+      const unmatchedCalls = indexedApiCalls.filter(c => !usedApiCallIndices.has(c._origIdx));
+      if (unmatchedCalls.length > 0) {
+        const byDay = {};
+        for (const call of unmatchedCalls) {
+          const day = new Date(call.timestamp).toLocaleDateString('en-US');
+          if (!byDay[day]) byDay[day] = [];
+          byDay[day].push(call);
+        }
+
+        for (const [day, calls] of Object.entries(byDay)) {
+          const firstTs = Math.min(...calls.map(c => c.timestamp));
+          const models = [...new Set(calls.map(c => c.model))];
+          const modelStr = models.length <= 3 ? models.join(', ') : `${models.slice(0, 2).join(', ')} +${models.length - 2}`;
+          conversations.push({
+            composerId: `unmatched-${day}`,
+            name: `Unmatched API calls (${day})`,
+            timestamp: firstTs,
+            messages: [],
+            messageCount: 0,
+            workspace: '(unmatched)',
+            model: modelStr,
+            contextTokensUsed: 0,
+            contextTokenLimit: 0,
+            totalLinesAdded: 0,
+            totalLinesRemoved: 0,
+            filesChangedCount: 0,
+            isUnmatched: true,
+            apiCalls: calls,
+            apiCallCount: calls.length,
+            apiTokens: {
+              inputWithCache: calls.reduce((s, c) => s + c.inputWithCache, 0),
+              inputWithoutCache: calls.reduce((s, c) => s + c.inputWithoutCache, 0),
+              cacheRead: calls.reduce((s, c) => s + c.cacheRead, 0),
+              outputTokens: calls.reduce((s, c) => s + c.outputTokens, 0),
+              totalTokens: calls.reduce((s, c) => s + c.totalTokens, 0),
+              cost: calls.reduce((s, c) => s + c.cost, 0)
+            }
+          });
+        }
+      }
     } else {
       // No API calls to match
       conversations.forEach(conv => {
@@ -419,7 +628,7 @@ function extractConversations(startTime, endTime, apiCalls = []) {
       });
     }
 
-    db.close();
+    dbClose(db);
     return conversations;
   } catch (error) {
     console.error('Database error:', error.message);
@@ -487,7 +696,7 @@ function exportConversation(conv, index, dateStr) {
 }
 
 // Generate statistics
-function generateStats(conversations, startOfDay, endOfDay) {
+function generateStats(conversations, startOfDay, endOfDay, apiCalls = []) {
   const daysDiff = Math.ceil((endOfDay - startOfDay) / (1000 * 60 * 60 * 24));
 
   const stats = {
@@ -560,12 +769,30 @@ function generateStats(conversations, startOfDay, endOfDay) {
       apiTokens: conv.apiTokens,
       linesChanged: `+${conv.totalLinesAdded}/-${conv.totalLinesRemoved}`,
       files: conv.filesChangedCount,
-      preview
+      preview,
+      exportedFile: conv.exportedFile || null,
+      isUnmatched: conv.isUnmatched || false
     });
   }
 
   stats.conversations.sort((a, b) => a.timestamp - b.timestamp);
 
+  // Compute CSV totals (all API calls in range, regardless of matching)
+  if (apiCalls.length > 0) {
+    const csvTotals = { total: 0, onDemand: 0, included: 0, errored: 0, callCount: apiCalls.length };
+    for (const call of apiCalls) {
+      csvTotals.total += call.cost;
+      const kind = (call.kind || '').toLowerCase();
+      if (kind.includes('on-demand')) csvTotals.onDemand += call.cost;
+      else if (kind.includes('included')) csvTotals.included += call.cost;
+      else if (kind.includes('error')) csvTotals.errored += call.cost;
+      else csvTotals.total += 0; // already counted
+    }
+    stats.csvTotals = csvTotals;
+    stats.unmatchedApiCalls = csvTotals.callCount - stats.totalApiCalls;
+    stats.unmatchedCost = csvTotals.total - stats.totalApiTokens.cost;
+  }
+
   return stats;
 }
 
@@ -612,7 +839,8 @@ async function main() {
 
   console.log('Extracting conversations...');
 
-  const conversations = extractConversations(startOfDay, endOfDay, apiCalls);
+  await loadDatabaseEngine();
+  const conversations = await extractConversations(startOfDay, endOfDay, apiCalls);
 
   console.log(`Found ${conversations.length} conversations\n`);
 
@@ -623,11 +851,11 @@ async function main() {
 
   console.log('Exporting conversations...');
   conversations.forEach((conv, i) => {
-    exportConversation(conv, i + 1, dateStr);
+    conv.exportedFile = exportConversation(conv, i + 1, dateStr);
   });
 
   console.log('Generating statistics...');
-  const stats = generateStats(conversations, startOfDay, endOfDay);
+  const stats = generateStats(conversations, startOfDay, endOfDay, apiCalls);
 
   console.log('Generating HTML report...');
   try {

package/cursor-logs-export/chats/2026-02-05_2026-02-10_08-35-54_uu_app_aicoding_conv55.txt

@@ -0,0 +1,49 @@
+================================================================================
+CONVERSATION #55
+Name: Skills reload
+Workspace: uu_app_aicodingg01
+Time: 2/7/2026, 8:35:54 AM
+Model: claude-4.5-opus-high-thinking
+Context Tokens: 25,471 / 164,000 (15.5%)
+Changes: +0 -0 lines in 0 files
+Messages: 2
+Composer ID: 21f2687c-5206-41ff-8d02-bcfe24037482
+
+API TOKEN USAGE (from dashboard export):
+  API Calls: 4
+  Input (w/ Cache Write): 105,264
+  Input (w/o Cache Write): 429
+  Cache Read: 1,429,552
+  Output Tokens: 8,366
+  Total API Tokens: 1,543,611
+  Cost: $1.97
+
+================================================================================
+
+
+--------------------------------------------------------------------------------
+[USER] 8:35:54 AM
+--------------------------------------------------------------------------------
+reload skills
+
+--------------------------------------------------------------------------------
+[ASSISTANT] 8:35:54 AM
+--------------------------------------------------------------------------------
+Skills reloaded successfully. 12 skills are now available:
+
+- `bookkit-add-page`
+- `bookkit-list-pages`
+- `bookkit-read`
+- `bookkit-update`
+- `business-chat`
+- `mngkit-read`
+- `mngkit-update`
+- `sls-read`
+- `validate`
+- `convert`
+- `wtm-worklog`
+- `skill`
+
+================================================================================
+End of conversation
+================================================================================