cursor-usage 0.1.0

package/dist/event-loader.js

@@ -0,0 +1,350 @@
+/**
+ * Event loading utilities for detailed usage analysis
+ * Fetches granular usage events for building daily/weekly reports
+ */
+import { CURSOR_API_URL_EVENTS, DEFAULT_TIMEOUT, USER_AGENT, } from './_consts';
+import { logger } from './logger';
+/**
+ * Fetch usage events for a date range
+ */
+export async function fetchUsageEvents(credentials, startDate, endDate, pageSize = 100) {
+    try {
+        const sessionToken = `${credentials.userId}::${credentials.accessToken}`;
+        const headers = {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            'User-Agent': USER_AGENT,
+            Origin: 'https://cursor.com',
+        };
+        const cookieHeader = `WorkosCursorSessionToken=${encodeURIComponent(sessionToken)}`;
+        // Convert dates to millisecond timestamps
+        const startTimestamp = startDate.getTime().toString();
+        const endTimestamp = endDate.getTime().toString();
+        const body = {
+            teamId: 0,
+            startDate: startTimestamp,
+            endDate: endTimestamp,
+            page: 1,
+            pageSize,
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+        const response = await fetch(CURSOR_API_URL_EVENTS, {
+            method: 'POST',
+            headers: {
+                ...headers,
+                Cookie: cookieHeader,
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            logger.error(`Events API request failed with status ${response.status}: ${response.statusText}`);
+            return [];
+        }
+        const data = (await response.json());
+        return parseEvents(data);
+    }
+    catch (error) {
+        logger.error(`Error fetching usage events: ${String(error)}`);
+        return [];
+    }
+}
+/**
+ * Parse and validate events response
+ */
+function parseEvents(data) {
+    try {
+        if (!Array.isArray(data?.usageEventsDisplay)) {
+            return [];
+        }
+        return data.usageEventsDisplay.map((event) => {
+            const tokenUsage = event.tokenUsage || {};
+            const totalTokens = (tokenUsage.inputTokens || 0) +
+                (tokenUsage.outputTokens || 0) +
+                (tokenUsage.cacheWriteTokens || 0) +
+                (tokenUsage.cacheReadTokens || 0);
+            return {
+                id: event.id || `${event.timestamp}-${event.model}`,
+                timestamp: Number(event.timestamp) || Date.now(),
+                model: event.model || 'unknown',
+                tokens: totalTokens,
+                inputTokens: Number(tokenUsage.inputTokens) || 0,
+                outputTokens: Number(tokenUsage.outputTokens) || 0,
+                cacheWriteTokens: Number(tokenUsage.cacheWriteTokens) || 0,
+                cacheReadTokens: Number(tokenUsage.cacheReadTokens) || 0,
+                type: 'usage',
+                kind: event.kind || 'unknown',
+                cost: Number(tokenUsage.totalCents) / 100 || 0, // Convert cents to dollars
+                maxMode: event.maxMode || false,
+            };
+        });
+    }
+    catch (error) {
+        logger.error(`Error parsing events: ${String(error)}`);
+        return [];
+    }
+}
+/**
+ * Group events by day
+ */
+export function groupByDay(events) {
+    const grouped = new Map();
+    events.forEach((event) => {
+        const date = new Date(event.timestamp);
+        const dateKey = date.toISOString().split('T')[0]; // YYYY-MM-DD
+        if (!grouped.has(dateKey)) {
+            grouped.set(dateKey, []);
+        }
+        grouped.get(dateKey).push(event);
+    });
+    return grouped;
+}
+export function calculateDailyStats(groupedEvents) {
+    const stats = [];
+    Array.from(groupedEvents.entries())
+        .sort()
+        .forEach(([date, events]) => {
+        const models = new Map();
+        let totalTokens = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let totalCost = 0;
+        events.forEach((event) => {
+            totalTokens += event.tokens;
+            inputTokens += event.inputTokens;
+            outputTokens += event.outputTokens;
+            totalCost += event.cost || 0;
+            const count = models.get(event.model) || 0;
+            models.set(event.model, count + 1);
+        });
+        stats.push({
+            date,
+            eventCount: events.length,
+            totalTokens,
+            inputTokens,
+            outputTokens,
+            totalCost,
+            models,
+        });
+    });
+    return stats;
+}
+/**
+ * Format daily stats for table display
+ */
+export function formatDailyStatsTable(stats) {
+    return stats.map((day) => {
+        const modelList = Array.from(day.models.entries())
+            .map(([model, count]) => `${model}(${count})`)
+            .join(', ');
+        return [
+            day.date,
+            day.eventCount.toString(),
+            day.totalTokens.toLocaleString(),
+            day.inputTokens.toLocaleString(),
+            day.outputTokens.toLocaleString(),
+            `$${day.totalCost.toFixed(2)}`,
+            modelList || 'N/A',
+        ];
+    });
+}
+/**
+ * Group events by month
+ */
+export function groupByMonth(events) {
+    const grouped = new Map();
+    events.forEach((event) => {
+        const date = new Date(event.timestamp);
+        const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`; // YYYY-MM
+        if (!grouped.has(monthKey)) {
+            grouped.set(monthKey, []);
+        }
+        grouped.get(monthKey).push(event);
+    });
+    return grouped;
+}
+/**
+ * Calculate monthly statistics
+ */
+export function calculateMonthlyStats(groupedEvents) {
+    const monthNames = [
+        'January', 'February', 'March', 'April', 'May', 'June',
+        'July', 'August', 'September', 'October', 'November', 'December',
+    ];
+    const stats = [];
+    Array.from(groupedEvents.entries())
+        .sort()
+        .forEach(([monthKey, events]) => {
+        const [yearStr, monthStr] = monthKey.split('-');
+        const year = Number(yearStr);
+        const month = Number(monthStr);
+        const models = new Map();
+        let totalTokens = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let totalCost = 0;
+        events.forEach((event) => {
+            totalTokens += event.tokens;
+            inputTokens += event.inputTokens;
+            outputTokens += event.outputTokens;
+            totalCost += event.cost || 0;
+            const count = models.get(event.model) || 0;
+            models.set(event.model, count + 1);
+        });
+        stats.push({
+            year,
+            month,
+            monthName: monthNames[month - 1],
+            monthKey,
+            eventCount: events.length,
+            totalTokens,
+            inputTokens,
+            outputTokens,
+            totalCost,
+            models,
+        });
+    });
+    return stats;
+}
+/**
+ * Format monthly stats for table display
+ */
+export function formatMonthlyStatsTable(stats) {
+    return stats.map((month) => {
+        const modelList = Array.from(month.models.entries())
+            .map(([model, count]) => `${model}(${count})`)
+            .join(', ');
+        return [
+            `${month.monthName} ${month.year}`,
+            month.eventCount.toString(),
+            month.totalTokens.toLocaleString(),
+            month.inputTokens.toLocaleString(),
+            month.outputTokens.toLocaleString(),
+            `$${month.totalCost.toFixed(2)}`,
+            modelList || 'N/A',
+        ];
+    });
+}
+/**
+ * Calculate per-model breakdown
+ */
+export function calculateModelBreakdown(events) {
+    const breakdown = new Map();
+    events.forEach((event) => {
+        const model = event.model || 'unknown';
+        if (!breakdown.has(model)) {
+            breakdown.set(model, {
+                model,
+                count: 0,
+                totalTokens: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                totalCost: 0,
+            });
+        }
+        const stats = breakdown.get(model);
+        stats.count += 1;
+        stats.totalTokens += event.tokens;
+        stats.inputTokens += event.inputTokens;
+        stats.outputTokens += event.outputTokens;
+        stats.totalCost += event.cost || 0;
+    });
+    return breakdown;
+}
+/**
+ * Format model breakdown for display
+ */
+export function formatModelBreakdownTable(breakdown, totalTokens, totalCost) {
+    const sorted = Array.from(breakdown.values()).sort((a, b) => b.totalTokens - a.totalTokens);
+    return sorted.map((model) => {
+        const tokenPercent = totalTokens > 0 ? (model.totalTokens / totalTokens * 100).toFixed(1) : '0.0';
+        const costPercent = totalCost > 0 ? (model.totalCost / totalCost * 100).toFixed(1) : '0.0';
+        return [
+            model.model,
+            model.count.toString(),
+            model.totalTokens.toLocaleString(),
+            `$${model.totalCost.toFixed(2)}`,
+            `${tokenPercent}%`,
+            `${costPercent}%`,
+        ];
+    });
+}
+/**
+ * Group events by week
+ */
+export function groupByWeek(events) {
+    const grouped = new Map();
+    events.forEach((event) => {
+        const date = new Date(event.timestamp);
+        // ISO week starts on Monday
+        const weekStart = new Date(date);
+        const day = weekStart.getUTCDay();
+        const diff = weekStart.getUTCDate() - day + (day === 0 ? -6 : 1);
+        weekStart.setUTCDate(diff);
+        weekStart.setUTCHours(0, 0, 0, 0);
+        const weekKey = weekStart.toISOString().split('T')[0];
+        if (!grouped.has(weekKey)) {
+            grouped.set(weekKey, []);
+        }
+        grouped.get(weekKey).push(event);
+    });
+    return grouped;
+}
+/**
+ * Calculate weekly statistics
+ */
+export function calculateWeeklyStats(groupedEvents) {
+    const stats = [];
+    Array.from(groupedEvents.entries())
+        .sort()
+        .forEach(([weekKey, events]) => {
+        const weekStart = new Date(weekKey);
+        const weekEnd = new Date(weekStart);
+        weekEnd.setDate(weekEnd.getDate() + 6);
+        const models = new Map();
+        let totalTokens = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let totalCost = 0;
+        events.forEach((event) => {
+            totalTokens += event.tokens;
+            inputTokens += event.inputTokens;
+            outputTokens += event.outputTokens;
+            totalCost += event.cost || 0;
+            const count = models.get(event.model) || 0;
+            models.set(event.model, count + 1);
+        });
+        stats.push({
+            weekStart: weekKey,
+            weekEnd: weekEnd.toISOString().split('T')[0],
+            eventCount: events.length,
+            totalTokens,
+            inputTokens,
+            outputTokens,
+            totalCost,
+            models,
+        });
+    });
+    return stats;
+}
+/**
+ * Format weekly stats for table display
+ */
+export function formatWeeklyStatsTable(stats) {
+    return stats.map((week) => {
+        const modelList = Array.from(week.models.entries())
+            .map(([model, count]) => `${model}(${count})`)
+            .join(', ');
+        return [
+            `${week.weekStart} to ${week.weekEnd}`,
+            week.eventCount.toString(),
+            week.totalTokens.toLocaleString(),
+            week.inputTokens.toLocaleString(),
+            week.outputTokens.toLocaleString(),
+            `$${week.totalCost.toFixed(2)}`,
+            modelList || 'N/A',
+        ];
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Cursor Usage Analyzer
+ * A CLI tool for analyzing Cursor API usage and token consumption
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Cursor Usage Analyzer
+ * A CLI tool for analyzing Cursor API usage and token consumption
+ */
+import { runCLI } from './cli.js';
+const argv = process.argv.slice(2);
+runCLI(argv).catch((error) => {
+    console.error(`Fatal error: ${String(error)}`);
+    process.exit(1);
+});

package/dist/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Simple logging utilities
+ */
+export declare const logger: {
+    log: (message: string) => void;
+    info: (message: string) => void;
+    success: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    debug: (message: string) => void;
+};

package/dist/logger.js

@@ -0,0 +1,34 @@
+/**
+ * Simple logging utilities
+ */
+const COLORS = {
+    reset: '\x1b[0m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+};
+export const logger = {
+    log: (message) => {
+        console.log(message);
+    },
+    info: (message) => {
+        console.log(`${COLORS.cyan}ℹ ${COLORS.reset}${message}`);
+    },
+    success: (message) => {
+        console.log(`${COLORS.green}✓ ${COLORS.reset}${message}`);
+    },
+    warn: (message) => {
+        console.warn(`${COLORS.yellow}⚠ ${COLORS.reset}${message}`);
+    },
+    error: (message) => {
+        console.error(`${COLORS.red}✗ ${COLORS.reset}${message}`);
+    },
+    debug: (message) => {
+        if (process.env.DEBUG) {
+            console.log(`${COLORS.dim}[DEBUG] ${message}${COLORS.reset}`);
+        }
+    },
+};

package/dist/table-formatter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Simple table formatting utilities
+ */
+export interface TableOptions {
+    headers: string[];
+    rows: string[][];
+    maxWidth?: number;
+}
+/**
+ * Format data as a simple ASCII table
+ */
+export declare function formatTable(options: TableOptions): string;
+/**
+ * Create a simple data table with borders
+ */
+export declare function createTable(headers: string[], rows: string[][]): string;

package/dist/table-formatter.js

@@ -0,0 +1,40 @@
+/**
+ * Simple table formatting utilities
+ */
+/**
+ * Format data as a simple ASCII table
+ */
+export function formatTable(options) {
+    const { headers, rows } = options;
+    if (rows.length === 0) {
+        return 'No data to display';
+    }
+    // Calculate column widths
+    const colWidths = headers.map((h, i) => {
+        const headerWidth = h.length;
+        const maxRowWidth = Math.max(...rows.map((row) => (row[i] ? row[i].length : 0)));
+        return Math.max(headerWidth, maxRowWidth);
+    });
+    // Build separator line
+    const separator = '+' + colWidths.map((w) => '-'.repeat(w + 2)).join('+') + '+';
+    // Build header line
+    const headerLine = '| ' +
+        headers
+            .map((h, i) => h.padEnd(colWidths[i]))
+            .join(' | ') +
+        ' |';
+    // Build data lines
+    const dataLines = rows.map((row) => '| ' +
+        row
+            .map((cell, i) => (cell || '').padEnd(colWidths[i]))
+            .join(' | ') +
+        ' |');
+    // Combine all parts
+    return [separator, headerLine, separator, ...dataLines, separator].join('\n');
+}
+/**
+ * Create a simple data table with borders
+ */
+export function createTable(headers, rows) {
+    return formatTable({ headers, rows });
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "cursor-usage",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "CLI tool for analyzing Cursor usage and token consumption",
+  "author": "yifen <anthonyeef@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Anthonyeef/cursor-usage.git"
+  },
+  "keywords": [
+    "cursor",
+    "cli",
+    "usage",
+    "analytics",
+    "tokens",
+    "api",
+    "cursor-ai"
+  ],
+  "bugs": {
+    "url": "https://github.com/Anthonyeef/cursor-usage/issues"
+  },
+  "homepage": "https://github.com/Anthonyeef/cursor-usage#readme",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "tsx src/index.ts",
+    "test": "vitest",
+    "lint": "eslint src/",
+    "format": "prettier --write src/"
+  },
+  "dependencies": {
+    "sql.js": "^1.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "typescript": "^5.3.3",
+    "tsx": "^4.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}