cursor-usage-analyzer 0.1.0

package/.idea/cursor-usage-analyzer.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/cursor-usage-analyzer.iml" filepath="$PROJECT_DIR$/.idea/cursor-usage-analyzer.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/README.md

@@ -0,0 +1,266 @@
+# Cursor Usage Analyzer
+
+A powerful Node.js tool to analyze and visualize your Cursor AI editor usage. Extract conversation histories, track token usage, and generate beautiful HTML reports with interactive charts.
+
+## Features
+
+- 📊 **Comprehensive Analytics**: Track conversations, messages, tokens, code changes, and more
+- 📈 **Interactive Charts**: Visualize usage patterns with Chart.js-powered graphs
+- 🔍 **Smart Filtering**: Filter and sort conversations by project, model, date, and name
+- 📁 **Full Export**: Export complete conversation histories as readable text files
+- 🎯 **Project Detection**: Automatically resolves workspace names from Cursor's database
+- 📅 **Flexible Date Ranges**: Analyze single days, months, or custom periods
+
+## Installation
+
+### Option 1: Use with npx (Recommended)
+
+No installation needed! Run directly from npm:
+
+```bash
+npx cursor-usage-analyzer
+```
+
+**First run**: npx will download and cache the package automatically. Subsequent runs use the cached version.
+
+### Option 2: Clone Locally
+
+```bash
+# Clone the repository
+git clone https://github.com/xaverric/cursor-usage-analyzer.git
+cd cursor-usage-analyzer
+
+# Install dependencies
+npm install
+```
+
+## Quick Start
+
+### Using npx
+
+```bash
+# Analyze today's usage
+npx cursor-usage-analyzer
+
+# Analyze yesterday
+npx cursor-usage-analyzer --yesterday
+
+# Analyze last month
+npx cursor-usage-analyzer --last-month
+
+# Analyze this month
+npx cursor-usage-analyzer --this-month
+```
+
+### Using locally installed version
+
+```bash
+# Using npm scripts
+npm run analyze
+npm run yesterday
+npm run last-month
+npm run this-month
+```
+
+## Usage
+
+### Command Line Arguments
+
+All these work with both `npx cursor-usage-analyzer` and local `node analyze.js`:
+
+```bash
+# Today (default)
+npx cursor-usage-analyzer
+
+# Yesterday
+npx cursor-usage-analyzer --yesterday
+
+# Specific date
+npx cursor-usage-analyzer --date 2025-12-01
+
+# Date range
+npx cursor-usage-analyzer --from 2025-11-01 --to 2025-11-30
+
+# Last month
+npx cursor-usage-analyzer --last-month
+
+# This month
+npx cursor-usage-analyzer --this-month
+```
+
+### NPM Scripts (Local Installation Only)
+
+If you cloned the repo locally, you can use these convenient shortcuts:
+
+```bash
+npm run analyze    # Today
+npm run yesterday  # Yesterday
+npm run last-month # Previous month
+npm run this-month # Current month
+```
+
+## Output
+
+The tool generates the following in `cursor-logs-export/`:
+
+### 1. Text Files (`chats/`)
+Individual conversation exports with full message history:
+```
+CONVERSATION #1
+Name: Feature implementation
+Workspace: my-project
+Time: 12/8/2025, 2:30:45 PM
+Model: claude-4.5-sonnet-thinking
+Tokens: 15,234 / 200,000 (7.6%)
+Changes: +245 -12 lines in 8 files
+Messages: 23
+```
+
+### 2. HTML Report (`report.html`)
+
+Interactive dashboard featuring:
+
+**Summary Statistics**
+- Total conversations, messages, and tokens
+- Lines added/removed and files changed
+- Averages per conversation
+
+**Interactive Charts**
+- Tokens over time (bar chart)
+- Messages over time (line chart)
+- Activity distribution (hourly/daily)
+- Model usage (doughnut chart)
+- Project distribution (pie chart)
+
+**Filterable Table**
+- Sort by any column (date, name, project, model, etc.)
+- Filter by project, model, name, or date range
+- View complete conversation metadata
+
+## Data Source
+
+The analyzer reads from Cursor's local SQLite database:
+```
+~/Library/Application Support/Cursor/User/globalStorage/state.vscdb
+```
+
+It extracts:
+- **Conversation metadata**: Names, timestamps, models
+- **Message content**: Full chat history (user prompts & AI responses)
+- **Code changes**: Lines added/removed, files modified
+- **Token usage**: Context tokens used and limits
+- **Project information**: Workspace paths and names
+
+## Requirements
+
+- **Node.js**: v14 or higher
+- **Cursor Editor**: Must have conversations stored locally
+- **OS**: macOS (paths are macOS-specific)
+
+## Project Structure
+
+```
+cursor-usage-analyzer/
+├── analyze.js          # Main extraction and analysis logic
+├── html-template.js    # HTML report generation
+├── package.json        # Dependencies and scripts
+└── cursor-logs-export/ # Generated output (gitignored)
+    ├── chats/          # Individual conversation text files
+    └── report.html     # Interactive HTML dashboard
+```
+
+## Tips
+
+### Analyze Specific Periods
+
+```bash
+# Q4 2024
+npx cursor-usage-analyzer --from 2024-10-01 --to 2024-12-31
+
+# Specific week
+npx cursor-usage-analyzer --from 2025-12-01 --to 2025-12-07
+
+# Single day
+npx cursor-usage-analyzer --date 2025-11-15
+```
+
+### Understanding the Report
+
+- **Context Tokens**: Tokens used in the conversation context (what the AI "sees")
+- **Messages**: Individual chat messages (both user and assistant)
+- **Changes**: Code modifications tracked by Cursor's composer
+- **Unknown Projects**: Conversations where workspace couldn't be determined
+
+### Performance
+
+- Large date ranges (e.g., entire year) may take longer to process
+- The tool processes thousands of messages efficiently
+- HTML reports remain performant even with 100+ conversations
+
+## Troubleshooting
+
+### "Database not found"
+Ensure Cursor has been used and conversations exist. Database path:
+```
+~/Library/Application Support/Cursor/User/globalStorage/state.vscdb
+```
+
+### "No conversations found"
+- Check the date range is correct
+- Verify you have conversations in Cursor from that period
+- Ensure Cursor isn't currently running (may lock database)
+
+### 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.
+
+## Privacy & Security
+
+- All processing is **100% local** - no data leaves your machine
+- The tool only reads Cursor's database (read-only access)
+- Generated reports can be freely shared or kept private
+- Sensitive conversation content is exported as-is (review before sharing)
+
+## License
+
+MIT
+
+## Development
+
+### Testing npx Locally
+
+Before publishing to npm, you can test the npx functionality:
+
+```bash
+# In the project directory
+npm link
+
+# Now you can run from anywhere
+cursor-usage-analyzer --yesterday
+cursor-usage-analyzer --last-month
+
+# Unlink when done testing
+npm unlink -g cursor-usage-analyzer
+```
+
+### Publishing to npm
+
+Once ready to publish (requires npm account):
+
+```bash
+# Login to npm
+npm login
+
+# Publish the package
+npm publish
+
+# Now anyone can use it
+npx cursor-usage-analyzer
+```
+
+## Contributing
+
+Feel free to open issues or submit pull requests for improvements!
+
+---
+
+**Made with ❤️ for Cursor users who love data**

package/analyze.js

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import Database from 'better-sqlite3';
+import { generateHTMLReport } from './html-template.js';
+
+// Constants
+const CURSOR_GLOBAL_STORAGE = path.join(os.homedir(), 'Library/Application Support/Cursor/User/globalStorage');
+const CURSOR_WORKSPACE_STORAGE = path.join(os.homedir(), 'Library/Application Support/Cursor/User/workspaceStorage');
+const OUTPUT_DIR = path.join(process.cwd(), 'cursor-logs-export');
+const CHATS_DIR = path.join(OUTPUT_DIR, 'chats');
+const REPORT_PATH = path.join(OUTPUT_DIR, 'report.html');
+
+// Helpers
+const formatDate = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+
+const setDayBounds = (date, start = true) => {
+  const d = new Date(date);
+  d.setHours(start ? 0 : 23, start ? 0 : 59, start ? 0 : 59, start ? 0 : 999);
+  return d;
+};
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let startDate, endDate, dateStr;
+  
+  if (args.includes('--last-month')) {
+    const now = new Date();
+    startDate = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+    endDate = new Date(now.getFullYear(), now.getMonth(), 0);
+    dateStr = `${formatDate(startDate)}_${formatDate(endDate)}`;
+  } else if (args.includes('--this-month')) {
+    const now = new Date();
+    startDate = new Date(now.getFullYear(), now.getMonth(), 1);
+    endDate = new Date();
+    dateStr = `${formatDate(startDate)}_${formatDate(endDate)}`;
+  } else if (args.includes('--from') && args.includes('--to')) {
+    const fromIdx = args.indexOf('--from');
+    const toIdx = args.indexOf('--to');
+    startDate = new Date(args[fromIdx + 1]);
+    endDate = new Date(args[toIdx + 1]);
+    dateStr = `${args[fromIdx + 1]}_${args[toIdx + 1]}`;
+  } else if (args.includes('--yesterday')) {
+    startDate = new Date();
+    startDate.setDate(startDate.getDate() - 1);
+    endDate = new Date(startDate);
+    dateStr = formatDate(startDate);
+  } else if (args.includes('--date')) {
+    const dateIdx = args.indexOf('--date');
+    startDate = new Date(args[dateIdx + 1]);
+    endDate = new Date(startDate);
+    dateStr = formatDate(startDate);
+  } else {
+    startDate = endDate = new Date();
+    dateStr = formatDate(startDate);
+  }
+  
+  return {
+    startOfDay: setDayBounds(startDate, true).getTime(),
+    endOfDay: setDayBounds(endDate, false).getTime(),
+    dateStr
+  };
+}
+
+// Extract text from various bubble formats
+function extractTextFromBubble(bubble) {
+  if (bubble.text?.trim()) return bubble.text;
+  
+  if (bubble.richText) {
+    try {
+      const richData = JSON.parse(bubble.richText);
+      if (richData.root?.children) {
+        return extractRichText(richData.root.children);
+      }
+    } catch (e) {}
+  }
+  
+  let text = '';
+  if (bubble.codeBlocks?.length) {
+    text = bubble.codeBlocks
+      .filter(cb => cb.content)
+      .map(cb => `\n\`\`\`${cb.language || ''}\n${cb.content}\n\`\`\``)
+      .join('');
+  }
+  
+  return text;
+}
+
+function extractRichText(children) {
+  return children.map(child => {
+    if (child.type === 'text' && child.text) return child.text;
+    if (child.type === 'code' && child.children) return '\n```\n' + extractRichText(child.children) + '\n```\n';
+    if (child.children?.length) return extractRichText(child.children);
+    return '';
+  }).join('');
+}
+
+// Read workspace name from workspace.json
+function readWorkspaceJson(workspaceId) {
+  try {
+    const jsonPath = path.join(CURSOR_WORKSPACE_STORAGE, workspaceId, 'workspace.json');
+    if (fs.existsSync(jsonPath)) {
+      const data = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
+      if (data.folder) {
+        return path.basename(data.folder.replace('file://', ''));
+      }
+    }
+  } catch (e) {}
+  return null;
+}
+
+// Find workspace name from file path
+function findWorkspaceFromPath(filePath) {
+  try {
+    const entries = fs.readdirSync(CURSOR_WORKSPACE_STORAGE);
+    let bestMatch = null;
+    let bestLen = 0;
+    
+    for (const entry of entries) {
+      const name = readWorkspaceJson(entry);
+      if (!name) continue;
+      
+      try {
+        const jsonPath = path.join(CURSOR_WORKSPACE_STORAGE, entry, 'workspace.json');
+        const data = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
+        const wsPath = data.folder?.replace('file://', '');
+        
+        if (wsPath && filePath.startsWith(wsPath) && wsPath.length > bestLen) {
+          bestMatch = name;
+          bestLen = wsPath.length;
+        }
+      } catch (e) {}
+    }
+    
+    if (bestMatch) return bestMatch;
+  } catch (e) {}
+  
+  const parts = filePath.split('/');
+  return parts[parts.length - 2] || 'unknown';
+}
+
+// Determine workspace name from multiple sources
+function resolveWorkspace(composerData, headers, db, composerId) {
+  // Try workspaceId first
+  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) {
+    if (filePath) {
+      const name = findWorkspaceFromPath(filePath);
+      if (name !== 'unknown') return name;
+    }
+  }
+  
+  // 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);
+      if (row) {
+        const context = JSON.parse(row.value);
+        if (context.projectLayouts?.length > 0) {
+          const layout = JSON.parse(context.projectLayouts[0]);
+          const absPath = layout.listDirV2Result?.directoryTreeRoot?.absPath;
+          if (absPath) return findWorkspaceFromPath(absPath);
+        }
+      }
+    } catch (e) {}
+  }
+  
+  return 'unknown';
+}
+
+// Extract conversations from database
+function extractConversations(startTime, endTime) {
+  const dbPath = path.join(CURSOR_GLOBAL_STORAGE, 'state.vscdb');
+  
+  if (!fs.existsSync(dbPath)) {
+    console.log('Database not found');
+    return [];
+  }
+  
+  try {
+    const db = new Database(dbPath, { readonly: true });
+    
+    // Load all bubbles
+    const bubbleMap = {};
+    const bubbleRows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'").all();
+    
+    for (const row of bubbleRows) {
+      try {
+        const bubbleId = row.key.split(':')[2];
+        const bubble = JSON.parse(row.value);
+        if (bubble) bubbleMap[bubbleId] = bubble;
+      } catch (e) {}
+    }
+    
+    // Load composers
+    const composerRows = db.prepare(
+      "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%' AND value LIKE '%fullConversationHeadersOnly%'"
+    ).all();
+    
+    const conversations = [];
+    
+    for (const row of composerRows) {
+      try {
+        const composerId = row.key.split(':')[1];
+        const composer = JSON.parse(row.value);
+        const timestamp = composer.lastUpdatedAt || composer.createdAt || Date.now();
+        
+        if (timestamp < startTime || timestamp > endTime) continue;
+        
+        const headers = composer.fullConversationHeadersOnly || [];
+        if (headers.length === 0) continue;
+        
+        // Extract messages
+        const messages = headers
+          .map(h => {
+            const bubble = bubbleMap[h.bubbleId];
+            if (!bubble) return null;
+            
+            const text = extractTextFromBubble(bubble);
+            if (!text?.trim()) return null;
+            
+            return {
+              role: h.type === 1 ? 'user' : 'assistant',
+              text: text.trim(),
+              timestamp: bubble.timestamp || Date.now()
+            };
+          })
+          .filter(Boolean);
+        
+        if (messages.length === 0) continue;
+        
+        conversations.push({
+          composerId,
+          name: composer.name || 'Untitled Chat',
+          timestamp,
+          messages,
+          messageCount: messages.length,
+          workspace: resolveWorkspace(composer, headers, db, composerId),
+          model: composer.modelConfig?.modelName || 'unknown',
+          contextTokensUsed: composer.contextTokensUsed || 0,
+          contextTokenLimit: composer.contextTokenLimit || 0,
+          totalLinesAdded: composer.totalLinesAdded || 0,
+          totalLinesRemoved: composer.totalLinesRemoved || 0,
+          filesChangedCount: composer.filesChangedCount || 0
+        });
+      } catch (e) {
+        // Silently skip invalid composers
+      }
+    }
+    
+    db.close();
+    return conversations;
+  } catch (error) {
+    console.error('Database error:', error.message);
+    return [];
+  }
+}
+
+// Export conversation to text file
+function exportConversation(conv, index, dateStr) {
+  const timestamp = new Date(conv.timestamp);
+  const timeStr = timestamp.toTimeString().split(' ')[0].replace(/:/g, '-');
+  const workspaceShort = conv.workspace.substring(0, 15).replace(/[^a-zA-Z0-9]/g, '_');
+  const filename = `${dateStr}_${timeStr}_${workspaceShort}_conv${index}.txt`;
+  
+  const percentUsed = (conv.contextTokensUsed / conv.contextTokenLimit * 100).toFixed(1);
+  
+  const lines = [
+    '='.repeat(80),
+    `CONVERSATION #${index}`,
+    `Name: ${conv.name}`,
+    `Workspace: ${conv.workspace}`,
+    `Time: ${timestamp.toLocaleString('en-US')}`,
+    `Model: ${conv.model}`,
+    `Tokens: ${conv.contextTokensUsed.toLocaleString()} / ${conv.contextTokenLimit.toLocaleString()} (${percentUsed}%)`,
+    `Changes: +${conv.totalLinesAdded} -${conv.totalLinesRemoved} lines in ${conv.filesChangedCount} files`,
+    `Messages: ${conv.messageCount}`,
+    `Composer ID: ${conv.composerId}`,
+    '='.repeat(80),
+    ''
+  ];
+  
+  for (const msg of conv.messages) {
+    const msgTime = new Date(msg.timestamp).toLocaleTimeString('en-US');
+    const role = msg.role.toUpperCase();
+    
+    lines.push(
+      '',
+      '-'.repeat(80),
+      `[${role}] ${msgTime}`,
+      '-'.repeat(80),
+      msg.text
+    );
+  }
+  
+  lines.push('', '='.repeat(80), 'End of conversation', '='.repeat(80));
+  
+  fs.writeFileSync(path.join(CHATS_DIR, filename), lines.join('\n'), 'utf-8');
+  return filename;
+}
+
+// Generate statistics
+function generateStats(conversations, startOfDay, endOfDay) {
+  const daysDiff = Math.ceil((endOfDay - startOfDay) / (1000 * 60 * 60 * 24));
+  
+  const stats = {
+    totalConversations: conversations.length,
+    totalMessages: 0,
+    totalTokens: 0,
+    totalLinesAdded: 0,
+    totalLinesRemoved: 0,
+    totalFilesChanged: 0,
+    modelUsage: {},
+    workspaceUsage: {},
+    hourlyDistribution: Array(24).fill(0),
+    dailyDistribution: {},
+    isMultiDay: daysDiff > 1,
+    conversations: [],
+    generatedAt: new Date().toLocaleString('en-US')
+  };
+  
+  for (const conv of conversations) {
+    const ts = new Date(conv.timestamp);
+    
+    stats.totalMessages += conv.messageCount;
+    stats.totalTokens += conv.contextTokensUsed;
+    stats.totalLinesAdded += conv.totalLinesAdded;
+    stats.totalLinesRemoved += conv.totalLinesRemoved;
+    stats.totalFilesChanged += conv.filesChangedCount;
+    
+    stats.modelUsage[conv.model] = (stats.modelUsage[conv.model] || 0) + 1;
+    stats.workspaceUsage[conv.workspace] = (stats.workspaceUsage[conv.workspace] || 0) + 1;
+    stats.hourlyDistribution[ts.getHours()]++;
+    
+    const dateKey = ts.toLocaleDateString('en-US');
+    stats.dailyDistribution[dateKey] = (stats.dailyDistribution[dateKey] || 0) + 1;
+    
+    const firstUserMsg = conv.messages.find(m => m.role === 'user');
+    const preview = firstUserMsg?.text.substring(0, 100) + (firstUserMsg?.text.length > 100 ? '...' : '') || '(no user message)';
+    
+    stats.conversations.push({
+      timestamp: conv.timestamp,
+      time: ts.toLocaleTimeString('en-US'),
+      date: ts.toLocaleDateString('en-US'),
+      datetime: ts.toLocaleString('en-US'),
+      name: conv.name,
+      workspace: conv.workspace,
+      model: conv.model,
+      messages: conv.messageCount,
+      tokens: conv.contextTokensUsed,
+      contextLimit: conv.contextTokenLimit,
+      linesChanged: `+${conv.totalLinesAdded}/-${conv.totalLinesRemoved}`,
+      files: conv.filesChangedCount,
+      preview
+    });
+  }
+  
+  stats.conversations.sort((a, b) => a.timestamp - b.timestamp);
+  
+  return stats;
+}
+
+// Main
+async function main() {
+  console.log('Cursor Usage Analyzer v2\n');
+  
+  const { startOfDay, endOfDay, dateStr } = parseArgs();
+  
+  console.log(`Analyzing: ${dateStr}`);
+  console.log(`Period: ${new Date(startOfDay).toLocaleString('en-US')} - ${new Date(endOfDay).toLocaleString('en-US')}\n`);
+  
+  // Prepare output folders
+  if (fs.existsSync(OUTPUT_DIR)) fs.rmSync(OUTPUT_DIR, { recursive: true });
+  fs.mkdirSync(CHATS_DIR, { recursive: true });
+  
+  console.log('Extracting conversations...');
+  
+  const conversations = extractConversations(startOfDay, endOfDay);
+  
+  console.log(`Found ${conversations.length} conversations\n`);
+  
+  if (conversations.length === 0) {
+    console.log('No conversations found in specified period');
+    return;
+  }
+  
+  console.log('Exporting conversations...');
+  conversations.forEach((conv, i) => {
+    exportConversation(conv, i + 1, dateStr);
+  });
+  
+  console.log('Generating statistics...');
+  const stats = generateStats(conversations, startOfDay, endOfDay);
+  
+  console.log('Generating HTML report...');
+  try {
+    generateHTMLReport(stats, dateStr, REPORT_PATH);
+  } catch (e) {
+    console.error('Error generating report:', e.message);
+    console.error(e.stack);
+    return;
+  }
+  
+  console.log('\nDone!\n');
+  console.log(`Export folder: ${OUTPUT_DIR}`);
+  console.log(`Conversations: ${conversations.length}`);
+  console.log(`Report: ${REPORT_PATH}`);
+}
+
+main().catch(console.error);

package/html-template.js

@@ -0,0 +1,452 @@
+import fs from 'fs';
+
+export function generateHTMLReport(stats, dateStr, reportPath) {
+  const avg = (total, count) => count > 0 ? Math.round(total / count) : 0;
+  
+  const avgTokens = avg(stats.totalTokens, stats.totalConversations);
+  const avgMessages = avg(stats.totalMessages, stats.totalConversations);
+  const avgLines = avg(stats.totalLinesAdded + stats.totalLinesRemoved, stats.totalConversations);
+  
+  // Prepare chart data
+  const isMultiDay = stats.isMultiDay;
+  const timeLabels = stats.conversations.map(c => 
+    isMultiDay ? `${c.date} ${c.time}` : `${c.time} ${c.name.substring(0, 20)}`
+  );
+  const tokenData = stats.conversations.map(c => c.tokens);
+  const messageData = stats.conversations.map(c => c.messages);
+  
+  const activityTitle = isMultiDay ? 'Activity Over Period' : 'Activity During Day';
+  const activityLabels = isMultiDay 
+    ? Object.keys(stats.dailyDistribution).sort()
+    : Array.from({length: 24}, (_, i) => i + ':00');
+  const activityData = isMultiDay
+    ? activityLabels.map(k => stats.dailyDistribution[k])
+    : stats.hourlyDistribution;
+  
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Cursor Usage Report - ${dateStr}</title>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { 
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+      padding: 20px; 
+      background: #f9fafb;
+      color: #111827;
+    }
+    .container { max-width: 1400px; margin: 0 auto; }
+    h1 { color: #2563eb; margin-bottom: 8px; }
+    h2 { 
+      color: #111827; 
+      margin: 40px 0 20px;
+      font-size: 20px;
+      font-weight: 600;
+      border-bottom: 2px solid #e5e7eb;
+      padding-bottom: 8px;
+    }
+    .date { color: #6b7280; margin-bottom: 32px; font-size: 14px; }
+    
+    .stats-grid, .charts-grid {
+      display: grid;
+      gap: 16px;
+      margin-bottom: 40px;
+    }
+    .stats-grid { grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); }
+    .charts-grid { grid-template-columns: repeat(auto-fit, minmax(400px, 1fr)); gap: 20px; }
+    
+    .stat, .chart-container, .filters, table {
+      background: white;
+      border-radius: 8px;
+      border: 1px solid #e5e7eb;
+      box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+    }
+    
+    .stat { padding: 20px; }
+    .stat-value { font-size: 32px; font-weight: 700; color: #2563eb; margin-bottom: 4px; }
+    .stat-label { color: #6b7280; font-size: 13px; text-transform: uppercase; letter-spacing: 0.5px; }
+    .stat-sublabel { color: #9ca3af; font-size: 12px; margin-top: 4px; }
+    
+    .chart-container { padding: 24px; }
+    .chart-title { font-size: 16px; font-weight: 600; color: #111827; margin-bottom: 16px; }
+    
+    .filters {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+      gap: 12px;
+      padding: 16px;
+      margin-bottom: 20px;
+    }
+    .filter-group { display: flex; flex-direction: column; gap: 4px; }
+    .filter-group label {
+      font-size: 11px;
+      color: #6b7280;
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+      font-weight: 600;
+    }
+    .filter-group input, .filter-group select {
+      padding: 8px 12px;
+      border: 1px solid #e5e7eb;
+      border-radius: 4px;
+      font-size: 13px;
+      background: white;
+    }
+    .filter-group input:focus, .filter-group select:focus {
+      outline: none;
+      border-color: #2563eb;
+      box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.1);
+    }
+    
+    table { width: 100%; border-collapse: collapse; overflow: hidden; }
+    th, td { padding: 12px 16px; text-align: left; border-bottom: 1px solid #e5e7eb; }
+    th { 
+      background: #f9fafb;
+      font-weight: 600;
+      font-size: 13px;
+      color: #6b7280;
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+      cursor: pointer;
+      user-select: none;
+      position: relative;
+      padding-right: 28px;
+    }
+    th:hover { background: #f3f4f6; }
+    th.sortable::after { content: '⇅'; position: absolute; right: 8px; opacity: 0.3; font-size: 14px; }
+    th.sortable.asc::after { content: '↑'; opacity: 1; }
+    th.sortable.desc::after { content: '↓'; opacity: 1; }
+    td { font-size: 14px; }
+    tr:last-child td { border-bottom: none; }
+    tr:hover { background: #f9fafb; }
+    small { font-size: 12px; color: #6b7280; }
+    
+    @media (max-width: 768px) {
+      .charts-grid { grid-template-columns: 1fr; }
+      .stats-grid { grid-template-columns: repeat(2, 1fr); }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Cursor Usage Report</h1>
+    <div class="date">${dateStr}</div>
+    <div class="date" style="font-size: 12px; margin-top: 4px;">Generated: ${stats.generatedAt}</div>
+    
+    <div class="stats-grid">
+      <div class="stat">
+        <div class="stat-value">${stats.totalConversations}</div>
+        <div class="stat-label">Conversations</div>
+      </div>
+      <div class="stat">
+        <div class="stat-value">${stats.totalMessages.toLocaleString()}</div>
+        <div class="stat-label">Messages</div>
+        <div class="stat-sublabel">Ø ${avgMessages} per conversation</div>
+      </div>
+      <div class="stat">
+        <div class="stat-value">${stats.totalTokens.toLocaleString()}</div>
+        <div class="stat-label">Context Tokens</div>
+        <div class="stat-sublabel">Ø ${avgTokens.toLocaleString()} per conversation</div>
+      </div>
+      <div class="stat">
+        <div class="stat-value">+${stats.totalLinesAdded.toLocaleString()}</div>
+        <div class="stat-label">Lines Added</div>
+      </div>
+      <div class="stat">
+        <div class="stat-value">-${stats.totalLinesRemoved.toLocaleString()}</div>
+        <div class="stat-label">Lines Removed</div>
+      </div>
+      <div class="stat">
+        <div class="stat-value">${stats.totalFilesChanged.toLocaleString()}</div>
+        <div class="stat-label">Files Changed</div>
+        <div class="stat-sublabel">Ø ${avgLines} lines per conversation</div>
+      </div>
+    </div>
+    
+    <h2>Usage Charts</h2>
+    
+    <div class="charts-grid">
+      <div class="chart-container">
+        <div class="chart-title">Tokens Over Time</div>
+        <canvas id="tokensChart"></canvas>
+      </div>
+      <div class="chart-container">
+        <div class="chart-title">Messages Over Time</div>
+        <canvas id="messagesChart"></canvas>
+      </div>
+      <div class="chart-container">
+        <div class="chart-title">${activityTitle}</div>
+        <canvas id="activityChart"></canvas>
+      </div>
+      <div class="chart-container">
+        <div class="chart-title">Distribution by Model</div>
+        <canvas id="modelsChart"></canvas>
+      </div>
+      <div class="chart-container">
+        <div class="chart-title">Distribution by Project</div>
+        <canvas id="workspacesChart"></canvas>
+      </div>
+    </div>
+    
+    <h2>Conversation Details</h2>
+    
+    <div class="filters">
+      <div class="filter-group">
+        <label>Name</label>
+        <input type="text" id="filterName" placeholder="Filter...">
+      </div>
+      <div class="filter-group">
+        <label>Project</label>
+        <select id="filterWorkspace">
+          <option value="">All projects</option>
+          ${[...new Set(stats.conversations.map(c => c.workspace))].sort().map(w => 
+            `<option value="${w}">${w}</option>`
+          ).join('')}
+        </select>
+      </div>
+      <div class="filter-group">
+        <label>Model</label>
+        <select id="filterModel">
+          <option value="">All models</option>
+          ${[...new Set(stats.conversations.map(c => c.model))].sort().map(m => 
+            `<option value="${m}">${m}</option>`
+          ).join('')}
+        </select>
+      </div>
+      <div class="filter-group">
+        <label>Date From</label>
+        <input type="date" id="filterDateFrom">
+      </div>
+      <div class="filter-group">
+        <label>Date To</label>
+        <input type="date" id="filterDateTo">
+      </div>
+    </div>
+    
+    <table id="conversationsTable">
+      <thead>
+        <tr>
+          <th class="sortable" data-column="datetime" data-type="date">Date & Time</th>
+          <th class="sortable" data-column="name" data-type="string">Name</th>
+          <th class="sortable" data-column="workspace" data-type="string">Project</th>
+          <th class="sortable" data-column="model" data-type="string">Model</th>
+          <th class="sortable" data-column="messages" data-type="number">Messages</th>
+          <th class="sortable" data-column="tokens" data-type="number">Context Tokens</th>
+          <th class="sortable" data-column="linesChanged" data-type="string">Changes</th>
+          <th class="sortable" data-column="files" data-type="number">Files</th>
+        </tr>
+      </thead>
+      <tbody id="conversationsBody">
+         ${stats.conversations.map((c, idx) => `
+           <tr data-index="${idx}">
+             <td data-value="${c.timestamp}"><small>${c.datetime}</small></td>
+             <td data-value="${c.name}">${c.name}</td>
+             <td data-value="${c.workspace}">${c.workspace}</td>
+             <td data-value="${c.model}"><small>${c.model}</small></td>
+             <td data-value="${c.messages}">${c.messages}</td>
+             <td data-value="${c.tokens}"><small>${c.tokens.toLocaleString()} / ${c.contextLimit.toLocaleString()}</small></td>
+             <td data-value="${c.linesChanged}">${c.linesChanged}</td>
+             <td data-value="${c.files}">${c.files}</td>
+           </tr>
+         `).join('')}
+      </tbody>
+    </table>
+  </div>
+  
+  <script>
+    const data = ${JSON.stringify({
+      conversations: stats.conversations,
+      timeLabels,
+      tokenData,
+      messageData,
+      activityLabels,
+      activityData,
+      modelLabels: Object.keys(stats.modelUsage),
+      modelCounts: Object.values(stats.modelUsage),
+      workspaceLabels: Object.keys(stats.workspaceUsage),
+      workspaceCounts: Object.values(stats.workspaceUsage),
+      isMultiDay
+    })};
+    
+    // Chart defaults
+    const baseOptions = {
+      responsive: true,
+      maintainAspectRatio: true,
+      plugins: { legend: { display: false } },
+      scales: {
+        y: { beginAtZero: true, grid: { color: '#f3f4f6' } },
+        x: { grid: { display: false }, ticks: { maxRotation: 45, minRotation: 45, font: { size: 10 } } }
+      }
+    };
+    
+    // Create chart helper
+    const createChart = (id, type, labels, dataset, options = {}) => {
+      new Chart(document.getElementById(id), {
+        type,
+        data: { labels, datasets: [dataset] },
+        options: { ...baseOptions, ...options }
+      });
+    };
+    
+    // Create charts
+    createChart('tokensChart', 'bar', data.timeLabels, {
+      label: 'Tokens',
+      data: data.tokenData,
+      backgroundColor: 'rgba(37, 99, 235, 0.8)',
+      borderColor: 'rgb(37, 99, 235)',
+      borderWidth: 1
+    }, {
+      scales: {
+        ...baseOptions.scales,
+        y: {
+          ...baseOptions.scales.y,
+          ticks: { callback: v => v.toLocaleString() }
+        }
+      }
+    });
+    
+    createChart('messagesChart', 'line', data.timeLabels, {
+      label: 'Messages',
+      data: data.messageData,
+      backgroundColor: 'rgba(59, 130, 246, 0.1)',
+      borderColor: 'rgb(59, 130, 246)',
+      borderWidth: 2,
+      fill: true,
+      tension: 0.4
+    });
+    
+    createChart('activityChart', 'bar', data.activityLabels, {
+      label: 'Conversations',
+      data: data.activityData,
+      backgroundColor: 'rgba(34, 197, 94, 0.8)',
+      borderColor: 'rgb(34, 197, 94)',
+      borderWidth: 1
+    }, {
+      scales: {
+        ...baseOptions.scales,
+        x: {
+          ...baseOptions.scales.x,
+          ticks: {
+            maxRotation: data.isMultiDay ? 90 : 0,
+            minRotation: data.isMultiDay ? 45 : 0,
+            font: { size: 10 }
+          }
+        }
+      }
+    });
+    
+    const pieColors = [
+      'rgba(37, 99, 235, 0.8)', 'rgba(59, 130, 246, 0.8)',
+      'rgba(96, 165, 250, 0.8)', 'rgba(147, 197, 253, 0.8)',
+      'rgba(34, 197, 94, 0.8)', 'rgba(251, 146, 60, 0.8)',
+      'rgba(168, 85, 247, 0.8)', 'rgba(236, 72, 153, 0.8)'
+    ];
+    
+    new Chart(document.getElementById('modelsChart'), {
+      type: 'doughnut',
+      data: {
+        labels: data.modelLabels,
+        datasets: [{
+          data: data.modelCounts,
+          backgroundColor: pieColors,
+          borderWidth: 1
+        }]
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: true,
+        plugins: { legend: { display: true, position: 'bottom' } }
+      }
+    });
+    
+    new Chart(document.getElementById('workspacesChart'), {
+      type: 'pie',
+      data: {
+        labels: data.workspaceLabels,
+        datasets: [{
+          data: data.workspaceCounts,
+          backgroundColor: pieColors,
+          borderWidth: 1
+        }]
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: true,
+        plugins: { legend: { display: true, position: 'bottom' } }
+      }
+    });
+    
+    // Table sorting
+    let sortState = { column: null, dir: 'asc' };
+    
+    document.querySelectorAll('th.sortable').forEach(th => {
+      th.addEventListener('click', () => {
+        const col = th.dataset.column;
+        const type = th.dataset.type;
+        const colIdx = Array.from(th.parentElement.children).indexOf(th);
+        
+        sortState.dir = sortState.column === col ? (sortState.dir === 'asc' ? 'desc' : 'asc') : 'asc';
+        sortState.column = col;
+        
+        document.querySelectorAll('th.sortable').forEach(h => h.classList.remove('asc', 'desc'));
+        th.classList.add(sortState.dir);
+        
+        const tbody = document.getElementById('conversationsBody');
+        const rows = Array.from(tbody.querySelectorAll('tr'));
+        
+        rows.sort((a, b) => {
+          let aVal = a.children[colIdx].dataset.value;
+          let bVal = b.children[colIdx].dataset.value;
+          
+          if (type === 'number' || type === 'date') {
+            aVal = parseFloat(aVal) || 0;
+            bVal = parseFloat(bVal) || 0;
+          }
+          
+          const result = aVal < bVal ? -1 : (aVal > bVal ? 1 : 0);
+          return sortState.dir === 'asc' ? result : -result;
+        });
+        
+        rows.forEach(row => tbody.appendChild(row));
+      });
+    });
+    
+    // Table filtering
+    const applyFilters = () => {
+      const filters = {
+        name: document.getElementById('filterName').value.toLowerCase(),
+        workspace: document.getElementById('filterWorkspace').value,
+        model: document.getElementById('filterModel').value,
+        dateFrom: document.getElementById('filterDateFrom').value,
+        dateTo: document.getElementById('filterDateTo').value
+      };
+      
+      const fromTs = filters.dateFrom ? new Date(filters.dateFrom).getTime() : 0;
+      const toTs = filters.dateTo ? new Date(filters.dateTo + 'T23:59:59').getTime() : Infinity;
+      
+      document.querySelectorAll('#conversationsBody tr').forEach(row => {
+        const idx = parseInt(row.dataset.index);
+        const conv = data.conversations[idx];
+        
+        const show = (!filters.name || conv.name.toLowerCase().includes(filters.name)) &&
+                     (!filters.workspace || conv.workspace === filters.workspace) &&
+                     (!filters.model || conv.model === filters.model) &&
+                     (conv.timestamp >= fromTs && conv.timestamp <= toTs);
+        
+        row.style.display = show ? '' : 'none';
+      });
+    };
+    
+    ['filterName', 'filterWorkspace', 'filterModel', 'filterDateFrom', 'filterDateTo'].forEach(id => {
+      const el = document.getElementById(id);
+      el.addEventListener(el.tagName === 'SELECT' ? 'change' : 'input', applyFilters);
+    });
+  </script>
+</body>
+</html>`;
+  
+  fs.writeFileSync(reportPath, html, 'utf-8');
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "cursor-usage-analyzer",
+  "version": "0.1.0",
+  "description": "Analyze and visualize your Cursor AI editor usage with interactive reports",
+  "main": "analyze.js",
+  "type": "module",
+  "bin": {
+    "cursor-usage-analyzer": "./analyze.js"
+  },
+  "scripts": {
+    "analyze": "node analyze.js",
+    "today": "node analyze.js --today",
+    "yesterday": "node analyze.js --yesterday",
+    "this-month": "node analyze.js --this-month",
+    "last-month": "node analyze.js --last-month"
+  },
+  "keywords": ["cursor", "ai", "analytics", "usage", "chat", "tokens", "statistics"],
+  "author": "Daniel Jílek",
+  "license": "MIT",
+  "dependencies": {
+    "better-sqlite3": "^9.2.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xaverric/cursor-usage-analyzer.git"
+  }
+}
+