claude-session-viewer 0.3.4 → 0.3.6

package/dist/server/routes/statistics.js

@@ -1,327 +1,51 @@
-import { readdir, stat } from 'fs/promises';
+import { stat } from 'fs/promises';
 import { join } from 'path';
 import { CLAUDE_DIR } from '../constants.js';
-import { PRICING, DEFAULT_PRICING_MODEL, WEEKDAY_NAMES } from '../claude/config.js';
-import { parseJsonl } from '../utils/jsonl.js';
-import { extractTokenUsage, aggregateTokenUsage, calculateCost, createEmptyTokenUsage } from '../utils/tokenStats.js';
-import { getProjectDisplayName } from '../claude/projects/repository.js';
-import { collectAgentDescriptions } from '../claude/sessions/agents.js';
-import { shouldSkipSession, isAgentSession, isEmptyFile } from '../claude/sessions/filters.js';
+import { getOverallStatistics, getProjectStatistics } from '../statistics/service.js';
 /**
  * Statistics routes
  */
 export async function registerStatisticsRoutes(server) {
-    server.get('/api/statistics/tokens', async (request, reply) => {
+    /**
+     * GET /api/statistics/overall
+     * Get overall usage statistics across all projects
+     */
+    server.get('/api/statistics/overall', async (request, reply) => {
         try {
+            const days = request.query.days || '7';
+            const statistics = await getOverallStatistics(days);
+            return statistics;
+        }
+        catch (error) {
+            console.error('Error calculating overall statistics:', error);
+            return reply.code(500).send({ error: 'Internal server error' });
+        }
+    });
+    /**
+     * GET /api/statistics/projects/:projectId
+     * Get usage statistics for a specific project
+     */
+    server.get('/api/statistics/projects/:projectId', async (request, reply) => {
+        try {
+            const { projectId } = request.params;
             const projectsDir = join(CLAUDE_DIR, 'projects');
-            const projects = await readdir(projectsDir);
-            const daysParam = request.query.days || '30';
-            const cutoffDate = new Date();
-            if (daysParam !== 'all') {
-                const days = parseInt(daysParam, 10);
-                cutoffDate.setDate(cutoffDate.getDate() - days);
-                cutoffDate.setHours(0, 0, 0, 0);
-            }
-            else {
-                cutoffDate.setFullYear(2000, 0, 1);
-            }
-            const dailyMap = new Map();
-            const projectMap = new Map();
-            const modelMap = new Map();
-            let totalMessages = 0;
-            let totalSessions = 0;
-            let minDate = null;
-            let maxDate = null;
-            let totalCacheCreation = 0;
-            let totalCacheRead = 0;
-            let ephemeral5mTokens = 0;
-            let ephemeral1hTokens = 0;
-            const allUsages = [];
-            const allCosts = [];
-            const toolUsageMap = new Map();
-            let totalAgentSessions = 0;
-            const hourlyMap = new Map();
-            const weekdayMap = new Map();
-            for (let hour = 0; hour < 24; hour++) {
-                hourlyMap.set(hour, {
-                    usage: createEmptyTokenUsage(),
-                    sessionIds: new Set(),
-                    messageCount: 0
-                });
-            }
-            for (let weekday = 0; weekday < 7; weekday++) {
-                weekdayMap.set(weekday, {
-                    usage: createEmptyTokenUsage(),
-                    sessionIds: new Set(),
-                    messageCount: 0
-                });
-            }
-            for (const project of projects) {
-                const projectPath = join(projectsDir, project);
+            const projectPath = join(projectsDir, projectId);
+            // Check if project exists
+            try {
                 const projectStat = await stat(projectPath);
-                if (!projectStat.isDirectory())
-                    continue;
-                const files = await readdir(projectPath);
-                const displayName = getProjectDisplayName(project);
-                if (!projectMap.has(project)) {
-                    projectMap.set(project, {
-                        usage: createEmptyTokenUsage(),
-                        sessionIds: new Set(),
-                        displayName
-                    });
-                }
-                for (const file of files) {
-                    if (!file.endsWith('.jsonl'))
-                        continue;
-                    const filePath = join(projectPath, file);
-                    const fileStat = await stat(filePath);
-                    if (isEmptyFile(fileStat.size))
-                        continue;
-                    const sessionId = file.replace('.jsonl', '');
-                    if (isAgentSession(sessionId))
-                        continue;
-                    try {
-                        const messages = await parseJsonl(filePath);
-                        if (shouldSkipSession(messages))
-                            continue;
-                        totalSessions++;
-                        const projectData = projectMap.get(project);
-                        projectData.sessionIds.add(sessionId);
-                        const agentDescriptions = collectAgentDescriptions(messages);
-                        if (agentDescriptions.size > 0) {
-                            totalAgentSessions++;
-                        }
-                        for (const message of messages) {
-                            const tokenData = extractTokenUsage(message);
-                            if (!tokenData)
-                                continue;
-                            const messageDate = new Date(message.timestamp);
-                            if (messageDate < cutoffDate)
-                                continue;
-                            totalMessages++;
-                            const { usage, model } = tokenData;
-                            const pricing = PRICING[model] || PRICING[DEFAULT_PRICING_MODEL];
-                            allUsages.push(usage);
-                            allCosts.push(calculateCost(usage, pricing));
-                            const dateKey = messageDate.toISOString().split('T')[0];
-                            if (!minDate || messageDate < minDate)
-                                minDate = messageDate;
-                            if (!maxDate || messageDate > maxDate)
-                                maxDate = messageDate;
-                            if (!dailyMap.has(dateKey)) {
-                                dailyMap.set(dateKey, {
-                                    usage: createEmptyTokenUsage(),
-                                    sessionIds: new Set()
-                                });
-                            }
-                            const dailyData = dailyMap.get(dateKey);
-                            dailyData.usage.inputTokens += usage.inputTokens;
-                            dailyData.usage.cacheCreationTokens += usage.cacheCreationTokens;
-                            dailyData.usage.cacheReadTokens += usage.cacheReadTokens;
-                            dailyData.usage.outputTokens += usage.outputTokens;
-                            dailyData.usage.totalTokens += usage.totalTokens;
-                            dailyData.sessionIds.add(sessionId);
-                            const hour = messageDate.getHours();
-                            const hourData = hourlyMap.get(hour);
-                            hourData.usage.inputTokens += usage.inputTokens;
-                            hourData.usage.cacheCreationTokens += usage.cacheCreationTokens;
-                            hourData.usage.cacheReadTokens += usage.cacheReadTokens;
-                            hourData.usage.outputTokens += usage.outputTokens;
-                            hourData.usage.totalTokens += usage.totalTokens;
-                            hourData.sessionIds.add(sessionId);
-                            hourData.messageCount++;
-                            const weekday = messageDate.getDay();
-                            const weekdayData = weekdayMap.get(weekday);
-                            weekdayData.usage.inputTokens += usage.inputTokens;
-                            weekdayData.usage.cacheCreationTokens += usage.cacheCreationTokens;
-                            weekdayData.usage.cacheReadTokens += usage.cacheReadTokens;
-                            weekdayData.usage.outputTokens += usage.outputTokens;
-                            weekdayData.usage.totalTokens += usage.totalTokens;
-                            weekdayData.sessionIds.add(sessionId);
-                            weekdayData.messageCount++;
-                            projectData.usage.inputTokens += usage.inputTokens;
-                            projectData.usage.cacheCreationTokens += usage.cacheCreationTokens;
-                            projectData.usage.cacheReadTokens += usage.cacheReadTokens;
-                            projectData.usage.outputTokens += usage.outputTokens;
-                            projectData.usage.totalTokens += usage.totalTokens;
-                            if (!modelMap.has(model)) {
-                                modelMap.set(model, {
-                                    usage: createEmptyTokenUsage(),
-                                    messageCount: 0
-                                });
-                            }
-                            const modelData = modelMap.get(model);
-                            modelData.usage.inputTokens += usage.inputTokens;
-                            modelData.usage.cacheCreationTokens += usage.cacheCreationTokens;
-                            modelData.usage.cacheReadTokens += usage.cacheReadTokens;
-                            modelData.usage.outputTokens += usage.outputTokens;
-                            modelData.usage.totalTokens += usage.totalTokens;
-                            modelData.messageCount++;
-                            totalCacheCreation += usage.cacheCreationTokens;
-                            totalCacheRead += usage.cacheReadTokens;
-                            const cacheCreation = message.message?.usage?.cache_creation;
-                            if (cacheCreation) {
-                                ephemeral5mTokens += cacheCreation.ephemeral_5m_input_tokens || 0;
-                                ephemeral1hTokens += cacheCreation.ephemeral_1h_input_tokens || 0;
-                            }
-                        }
-                        const toolUseIds = new Set();
-                        const successfulToolUseIds = new Set();
-                        for (const message of messages) {
-                            const messageDate = new Date(message.timestamp);
-                            if (messageDate < cutoffDate)
-                                continue;
-                            if (message.type === 'assistant' && message.message?.content && Array.isArray(message.message.content)) {
-                                for (const item of message.message.content) {
-                                    if (item.type === 'tool_use' && item.name && item.id) {
-                                        const toolName = item.name;
-                                        if (!toolUsageMap.has(toolName)) {
-                                            toolUsageMap.set(toolName, { total: 0, successful: 0 });
-                                        }
-                                        if (!toolUseIds.has(item.id)) {
-                                            toolUseIds.add(item.id);
-                                            toolUsageMap.get(toolName).total++;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        for (const message of messages) {
-                            const messageDate = new Date(message.timestamp);
-                            if (messageDate < cutoffDate)
-                                continue;
-                            if (message.message?.content && Array.isArray(message.message.content)) {
-                                for (const item of message.message.content) {
-                                    if (item.type === 'tool_result' && !item.is_error && item.tool_use_id) {
-                                        if (!successfulToolUseIds.has(item.tool_use_id)) {
-                                            successfulToolUseIds.add(item.tool_use_id);
-                                            let found = false;
-                                            for (const msg of messages) {
-                                                if (found)
-                                                    break;
-                                                if (msg.type === 'assistant' && msg.message?.content && Array.isArray(msg.message.content)) {
-                                                    for (const toolUseItem of msg.message.content) {
-                                                        if (toolUseItem.type === 'tool_use' && toolUseItem.id === item.tool_use_id && toolUseItem.name) {
-                                                            const toolStats = toolUsageMap.get(toolUseItem.name);
-                                                            if (toolStats) {
-                                                                toolStats.successful++;
-                                                                found = true;
-                                                                break;
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    catch (error) {
-                        console.error(`Error processing ${file}:`, error);
-                    }
+                if (!projectStat.isDirectory()) {
+                    return reply.code(404).send({ error: 'Project not found' });
                 }
             }
-            const totalUsage = aggregateTokenUsage(allUsages);
-            const totalCost = allCosts.reduce((acc, cost) => ({
-                inputCost: acc.inputCost + cost.inputCost,
-                outputCost: acc.outputCost + cost.outputCost,
-                cacheCreationCost: acc.cacheCreationCost + cost.cacheCreationCost,
-                cacheReadCost: acc.cacheReadCost + cost.cacheReadCost,
-                totalCost: acc.totalCost + cost.totalCost
-            }), { inputCost: 0, outputCost: 0, cacheCreationCost: 0, cacheReadCost: 0, totalCost: 0 });
-            const totalPotentialInput = totalUsage.inputTokens + totalCacheCreation + totalCacheRead;
-            const cacheHitRate = totalPotentialInput > 0 ? (totalCacheRead / totalPotentialInput) * 100 : 0;
-            const defaultPricing = PRICING[DEFAULT_PRICING_MODEL];
-            const savedCost = (totalCacheRead / 1000000) * (defaultPricing.input - defaultPricing.cacheRead);
-            const daily = Array.from(dailyMap.entries())
-                .map(([date, data]) => ({
-                date,
-                usage: data.usage,
-                sessionCount: data.sessionIds.size
-            }))
-                .sort((a, b) => a.date.localeCompare(b.date));
-            const byProject = Array.from(projectMap.entries())
-                .map(([project, data]) => ({
-                project,
-                displayName: data.displayName,
-                usage: data.usage,
-                sessionCount: data.sessionIds.size
-            }))
-                .sort((a, b) => b.usage.totalTokens - a.usage.totalTokens);
-            const byModel = Array.from(modelMap.entries())
-                .map(([model, data]) => ({
-                model,
-                usage: data.usage,
-                messageCount: data.messageCount
-            }))
-                .sort((a, b) => b.usage.totalTokens - a.usage.totalTokens);
-            const toolUsage = Array.from(toolUsageMap.entries())
-                .map(([toolName, stats]) => ({
-                toolName,
-                totalUses: stats.total,
-                successfulUses: stats.successful,
-                successRate: stats.total > 0 ? (stats.successful / stats.total) * 100 : 0
-            }))
-                .sort((a, b) => b.totalUses - a.totalUses);
-            const totalToolCalls = Array.from(toolUsageMap.values()).reduce((sum, stats) => sum + stats.total, 0);
-            const agentUsageRate = totalSessions > 0 ? (totalAgentSessions / totalSessions) * 100 : 0;
-            const byHour = Array.from(hourlyMap.entries())
-                .map(([hour, data]) => ({
-                hour,
-                sessionCount: data.sessionIds.size,
-                messageCount: data.messageCount,
-                usage: data.usage
-            }))
-                .sort((a, b) => a.hour - b.hour);
-            const byWeekday = Array.from(weekdayMap.entries())
-                .map(([weekday, data]) => ({
-                weekday,
-                weekdayName: WEEKDAY_NAMES[weekday],
-                sessionCount: data.sessionIds.size,
-                messageCount: data.messageCount,
-                usage: data.usage
-            }))
-                .sort((a, b) => a.weekday - b.weekday);
-            const statistics = {
-                overview: {
-                    total: totalUsage,
-                    totalSessions,
-                    totalMessages,
-                    dateRange: {
-                        start: minDate?.toISOString() || new Date().toISOString(),
-                        end: maxDate?.toISOString() || new Date().toISOString()
-                    }
-                },
-                daily,
-                byProject,
-                byModel,
-                cache: {
-                    totalCacheCreation,
-                    totalCacheRead,
-                    ephemeral5mTokens,
-                    ephemeral1hTokens,
-                    cacheHitRate,
-                    estimatedSavings: savedCost
-                },
-                cost: totalCost,
-                productivity: {
-                    toolUsage,
-                    totalToolCalls,
-                    agentSessions: totalAgentSessions,
-                    totalSessions,
-                    agentUsageRate
-                },
-                trends: {
-                    byHour,
-                    byWeekday
-                }
-            };
+            catch (error) {
+                return reply.code(404).send({ error: 'Project not found' });
+            }
+            const days = request.query.days || '7';
+            const statistics = await getProjectStatistics(projectId, days);
             return statistics;
         }
         catch (error) {
-            console.error('Error calculating token statistics:', error);
+            console.error('Error calculating project statistics:', error);
             return reply.code(500).send({ error: 'Internal server error' });
         }
     });

package/dist/server/statistics/aggregator.js

@@ -0,0 +1,290 @@
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { CLAUDE_DIR } from '../constants.js';
+import { PRICING, DEFAULT_PRICING_MODEL } from '../claude/config.js';
+import { parseJsonl } from '../utils/jsonl.js';
+import { extractTokenUsage, calculateCost, createEmptyTokenUsage } from './tokenUsage.js';
+import { getProjectName } from '../claude/projects/repository.js';
+import { collectAgentDescriptions } from '../claude/sessions/agents.js';
+import { shouldSkipSession, isAgentSession, isEmptyFile } from '../claude/sessions/filters.js';
+/**
+ * Format date to YYYY-MM-DD in local timezone
+ */
+function formatDateLocal(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+/**
+ * Create empty aggregated data structure
+ */
+function createEmptyAggregatedData() {
+    const hourlyMap = new Map();
+    const weekdayMap = new Map();
+    for (let hour = 0; hour < 24; hour++) {
+        hourlyMap.set(hour, {
+            tokenUsage: createEmptyTokenUsage(),
+            sessionIds: new Set(),
+            messageCount: 0
+        });
+    }
+    for (let weekday = 0; weekday < 7; weekday++) {
+        weekdayMap.set(weekday, {
+            tokenUsage: createEmptyTokenUsage(),
+            sessionIds: new Set(),
+            messageCount: 0
+        });
+    }
+    return {
+        dailyMap: new Map(),
+        projectMap: new Map(),
+        modelMap: new Map(),
+        hourlyMap,
+        weekdayMap,
+        toolUsageMap: new Map(),
+        totalMessages: 0,
+        totalSessions: 0,
+        minDate: null,
+        maxDate: null,
+        totalCacheCreation: 0,
+        totalCacheRead: 0,
+        ephemeral5mTokens: 0,
+        ephemeral1hTokens: 0,
+        allUsages: [],
+        allCosts: [],
+        totalAgentSessions: 0
+    };
+}
+/**
+ * Process a single message and update aggregated data
+ */
+function processMessage(message, sessionId, projectId, data, toolUseIdMap // Maps tool_use_id to tool name
+) {
+    // Process tool_result first (before extractTokenUsage check) since user messages don't have usage
+    if (message.type === 'user' && message.message?.content) {
+        const content = Array.isArray(message.message.content)
+            ? message.message.content
+            : [{ type: 'text', text: message.message.content }];
+        for (const item of content) {
+            if (item.type === 'tool_result') {
+                const toolUseId = item.tool_use_id;
+                const toolName = toolUseIdMap.get(toolUseId);
+                // Count as successful if:
+                // 1. We can find the tool name from toolUseIdMap
+                // 2. Either is_error is false/undefined, OR there's no error field at all
+                if (toolName) {
+                    const isError = item.is_error === true;
+                    if (!isError) {
+                        const stats = data.toolUsageMap.get(toolName);
+                        if (stats) {
+                            stats.successful++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const result = extractTokenUsage(message);
+    if (!result)
+        return;
+    const { usage, model } = result;
+    const messageDate = new Date(message.timestamp);
+    // Update min/max dates
+    if (!data.minDate || messageDate < data.minDate) {
+        data.minDate = messageDate;
+    }
+    if (!data.maxDate || messageDate > data.maxDate) {
+        data.maxDate = messageDate;
+    }
+    data.totalMessages++;
+    const pricing = PRICING[model] || PRICING[DEFAULT_PRICING_MODEL];
+    data.allUsages.push(usage);
+    const costBreakdown = calculateCost(usage, pricing);
+    data.allCosts.push(costBreakdown.totalCost);
+    // Update daily map
+    const dateKey = formatDateLocal(messageDate);
+    if (!data.dailyMap.has(dateKey)) {
+        data.dailyMap.set(dateKey, {
+            tokenUsage: createEmptyTokenUsage(),
+            sessionIds: new Set()
+        });
+    }
+    const dailyData = data.dailyMap.get(dateKey);
+    dailyData.tokenUsage.inputTokens += usage.inputTokens;
+    dailyData.tokenUsage.cacheCreationTokens += usage.cacheCreationTokens;
+    dailyData.tokenUsage.cacheReadTokens += usage.cacheReadTokens;
+    dailyData.tokenUsage.outputTokens += usage.outputTokens;
+    dailyData.tokenUsage.totalTokens += usage.totalTokens;
+    dailyData.sessionIds.add(sessionId);
+    // Update hourly map
+    const hour = messageDate.getHours();
+    const hourData = data.hourlyMap.get(hour);
+    hourData.tokenUsage.inputTokens += usage.inputTokens;
+    hourData.tokenUsage.cacheCreationTokens += usage.cacheCreationTokens;
+    hourData.tokenUsage.cacheReadTokens += usage.cacheReadTokens;
+    hourData.tokenUsage.outputTokens += usage.outputTokens;
+    hourData.tokenUsage.totalTokens += usage.totalTokens;
+    hourData.sessionIds.add(sessionId);
+    hourData.messageCount++;
+    // Update weekday map
+    const weekday = messageDate.getDay();
+    const weekdayData = data.weekdayMap.get(weekday);
+    weekdayData.tokenUsage.inputTokens += usage.inputTokens;
+    weekdayData.tokenUsage.cacheCreationTokens += usage.cacheCreationTokens;
+    weekdayData.tokenUsage.cacheReadTokens += usage.cacheReadTokens;
+    weekdayData.tokenUsage.outputTokens += usage.outputTokens;
+    weekdayData.tokenUsage.totalTokens += usage.totalTokens;
+    weekdayData.sessionIds.add(sessionId);
+    weekdayData.messageCount++;
+    // Update project map
+    if (!data.projectMap.has(projectId)) {
+        data.projectMap.set(projectId, {
+            tokenUsage: createEmptyTokenUsage(),
+            sessionIds: new Set(),
+            name: getProjectName(projectId)
+        });
+    }
+    const projectData = data.projectMap.get(projectId);
+    projectData.tokenUsage.inputTokens += usage.inputTokens;
+    projectData.tokenUsage.cacheCreationTokens += usage.cacheCreationTokens;
+    projectData.tokenUsage.cacheReadTokens += usage.cacheReadTokens;
+    projectData.tokenUsage.outputTokens += usage.outputTokens;
+    projectData.tokenUsage.totalTokens += usage.totalTokens;
+    // Update model map
+    if (!data.modelMap.has(model)) {
+        data.modelMap.set(model, {
+            tokenUsage: createEmptyTokenUsage(),
+            messageCount: 0
+        });
+    }
+    const modelData = data.modelMap.get(model);
+    modelData.tokenUsage.inputTokens += usage.inputTokens;
+    modelData.tokenUsage.cacheCreationTokens += usage.cacheCreationTokens;
+    modelData.tokenUsage.cacheReadTokens += usage.cacheReadTokens;
+    modelData.tokenUsage.outputTokens += usage.outputTokens;
+    modelData.tokenUsage.totalTokens += usage.totalTokens;
+    modelData.messageCount++;
+    // Update cache stats
+    data.totalCacheCreation += usage.cacheCreationTokens;
+    data.totalCacheRead += usage.cacheReadTokens;
+    const cacheCreation = message.message?.usage?.cache_creation;
+    if (cacheCreation) {
+        data.ephemeral5mTokens += cacheCreation.ephemeral_5m_input_tokens || 0;
+        data.ephemeral1hTokens += cacheCreation.ephemeral_1h_input_tokens || 0;
+    }
+    // Process tool_use in assistant messages
+    if (message.message?.role === 'assistant' && message.message?.content) {
+        const content = Array.isArray(message.message.content)
+            ? message.message.content
+            : [{ type: 'text', text: message.message.content }];
+        for (const item of content) {
+            if (item.type === 'tool_use') {
+                const toolName = item.name;
+                const toolUseId = item.id;
+                // Track tool_use_id to tool name mapping
+                if (toolUseId && toolName) {
+                    toolUseIdMap.set(toolUseId, toolName);
+                    // Increment total uses
+                    if (!data.toolUsageMap.has(toolName)) {
+                        data.toolUsageMap.set(toolName, { total: 0, successful: 0 });
+                    }
+                    data.toolUsageMap.get(toolName).total++;
+                }
+            }
+        }
+    }
+}
+/**
+ * Aggregate statistics for all projects
+ */
+export async function aggregateAllProjects(cutoffDate) {
+    const data = createEmptyAggregatedData();
+    const projectsDir = join(CLAUDE_DIR, 'projects');
+    const projects = await readdir(projectsDir);
+    for (const project of projects) {
+        const projectPath = join(projectsDir, project);
+        const projectStat = await stat(projectPath);
+        if (!projectStat.isDirectory())
+            continue;
+        const files = await readdir(projectPath);
+        const name = getProjectName(project);
+        if (!data.projectMap.has(project)) {
+            data.projectMap.set(project, {
+                tokenUsage: createEmptyTokenUsage(),
+                sessionIds: new Set(),
+                name
+            });
+        }
+        for (const file of files) {
+            if (!file.endsWith('.jsonl'))
+                continue;
+            const filePath = join(projectPath, file);
+            const sessionId = file.replace('.jsonl', '');
+            if (isAgentSession(sessionId))
+                continue;
+            const fileStat = await stat(filePath);
+            if (isEmptyFile(fileStat.size))
+                continue;
+            const messages = await parseJsonl(filePath);
+            if (shouldSkipSession(messages))
+                continue;
+            const agentDescriptions = collectAgentDescriptions(messages);
+            const isAgent = agentDescriptions.size > 0;
+            if (isAgent) {
+                data.totalAgentSessions++;
+            }
+            const projectData = data.projectMap.get(project);
+            projectData.sessionIds.add(sessionId);
+            data.totalSessions++;
+            // Track tool_use_id to tool name mapping for this session
+            const toolUseIdMap = new Map();
+            for (const message of messages) {
+                const messageDate = new Date(message.timestamp);
+                if (messageDate < cutoffDate)
+                    continue;
+                processMessage(message, sessionId, project, data, toolUseIdMap);
+            }
+        }
+    }
+    return data;
+}
+/**
+ * Aggregate statistics for a single project
+ */
+export async function aggregateProject(projectId, cutoffDate) {
+    const data = createEmptyAggregatedData();
+    const projectsDir = join(CLAUDE_DIR, 'projects');
+    const projectPath = join(projectsDir, projectId);
+    const files = await readdir(projectPath);
+    const name = getProjectName(projectId);
+    for (const file of files) {
+        if (!file.endsWith('.jsonl'))
+            continue;
+        const filePath = join(projectPath, file);
+        const sessionId = file.replace('.jsonl', '');
+        if (isAgentSession(sessionId))
+            continue;
+        const fileStat = await stat(filePath);
+        if (isEmptyFile(fileStat.size))
+            continue;
+        const messages = await parseJsonl(filePath);
+        if (shouldSkipSession(messages))
+            continue;
+        const agentDescriptions = collectAgentDescriptions(messages);
+        const isAgent = agentDescriptions.size > 0;
+        if (isAgent) {
+            data.totalAgentSessions++;
+        }
+        data.totalSessions++;
+        // Track tool_use_id to tool name mapping for this session
+        const toolUseIdMap = new Map();
+        for (const message of messages) {
+            const messageDate = new Date(message.timestamp);
+            if (messageDate < cutoffDate)
+                continue;
+            processMessage(message, sessionId, projectId, data, toolUseIdMap);
+        }
+    }
+    return data;
+}