cursor-usage-analyzer 0.3.0 → 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

@@ -208,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';
@@ -222,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;
   });
@@ -288,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 {
@@ -318,23 +351,69 @@ 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, 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;
@@ -345,9 +424,9 @@ function resolveWorkspace(composerData, headers, composerId) {
 }
 
 // Determine workspace name with database access for messageRequestContext
-function resolveWorkspaceWithDb(composerData, headers, db, composerId) {
+function resolveWorkspaceWithDb(composerData, headers, db, composerId, composerWorkspaceMap) {
   // Try basic resolution first
-  const basicResult = resolveWorkspace(composerData, headers, composerId);
+  const basicResult = resolveWorkspace(composerData, headers, composerId, composerWorkspaceMap);
   if (basicResult !== 'unknown') return basicResult;
   
   // Last resort: messageRequestContext
@@ -379,6 +458,10 @@ async function extractConversations(startTime, endTime, apiCalls = []) {
   }
 
   try {
+    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
@@ -404,9 +487,12 @@ async 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;
@@ -423,7 +509,7 @@ async 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);
@@ -434,9 +520,10 @@ async function extractConversations(startTime, endTime, apiCalls = []) {
           composerId,
           name: composer.name || 'Untitled Chat',
           timestamp,
+          createdAt,
           messages,
           messageCount: messages.length,
-          workspace: resolveWorkspaceWithDb(composer, headers, db, composerId),
+          workspace: resolveWorkspaceWithDb(composer, headers, db, composerId, composerWorkspaceMap),
           model: composer.modelConfig?.modelName || 'unknown',
           contextTokensUsed: composer.contextTokensUsed || 0,
           contextTokenLimit: composer.contextTokenLimit || 0,
@@ -454,22 +541,20 @@ async 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;
@@ -485,6 +570,48 @@ async 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 => {
@@ -569,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 = {
@@ -642,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;
 }
 
@@ -706,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
+================================================================================