claude-session-viewer 0.3.5 → 0.3.7

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;
+}

package/dist/server/statistics/service.js

@@ -0,0 +1,226 @@
+import { PRICING, DEFAULT_PRICING_MODEL, WEEKDAY_NAMES } from '../claude/config.js';
+import { aggregateTokenUsage, calculateCost } from './tokenUsage.js';
+import { fillMissingDates } from './utils.js';
+import { aggregateAllProjects, aggregateProject } from './aggregator.js';
+/**
+ * Calculate cutoff date based on days parameter
+ */
+function calculateCutoffDate(days) {
+    const cutoffDate = new Date();
+    if (days === 'all') {
+        cutoffDate.setFullYear(2000, 0, 1);
+    }
+    else {
+        const daysNum = typeof days === 'string' ? parseInt(days, 10) : days;
+        cutoffDate.setDate(cutoffDate.getDate() - daysNum);
+        cutoffDate.setHours(0, 0, 0, 0);
+    }
+    return cutoffDate;
+}
+/**
+ * Get overall usage statistics across all projects
+ */
+export async function getOverallStatistics(days = 7) {
+    const daysParam = days.toString();
+    const cutoffDate = calculateCutoffDate(days);
+    const data = await aggregateAllProjects(cutoffDate);
+    // Calculate totals
+    const totalUsage = aggregateTokenUsage(data.allUsages);
+    const defaultPricing = PRICING[DEFAULT_PRICING_MODEL];
+    const costBreakdown = calculateCost(totalUsage, defaultPricing);
+    const savedCost = (data.totalCacheRead / 1000000) * (defaultPricing.input - defaultPricing.cacheRead);
+    // Determine date range first (this drives all other date-based statistics)
+    const startDate = daysParam === 'all' && data.minDate
+        ? data.minDate
+        : cutoffDate;
+    const endDate = new Date();
+    // Fill daily stats based on the determined date range
+    const daily = fillMissingDates(data.dailyMap, startDate, endDate);
+    // Build project stats
+    const byProject = Array.from(data.projectMap.entries())
+        .map(([project, projectData]) => ({
+        id: project,
+        name: projectData.name,
+        tokenUsage: projectData.tokenUsage,
+        sessionCount: projectData.sessionIds.size
+    }))
+        .sort((a, b) => b.tokenUsage.totalTokens - a.tokenUsage.totalTokens);
+    // Build model stats
+    const byModel = Array.from(data.modelMap.entries())
+        .map(([model, modelData]) => ({
+        model,
+        tokenUsage: modelData.tokenUsage,
+        messageCount: modelData.messageCount
+    }))
+        .sort((a, b) => b.tokenUsage.totalTokens - a.tokenUsage.totalTokens);
+    // Build tool usage stats
+    const toolUsage = Array.from(data.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(data.toolUsageMap.values()).reduce((sum, stats) => sum + stats.total, 0);
+    const agentUsageRate = data.totalSessions > 0 ? (data.totalAgentSessions / data.totalSessions) * 100 : 0;
+    // Build hourly stats
+    const byHour = Array.from(data.hourlyMap.entries())
+        .map(([hour, hourData]) => ({
+        hour,
+        sessionCount: hourData.sessionIds.size,
+        messageCount: hourData.messageCount,
+        tokenUsage: hourData.tokenUsage
+    }))
+        .sort((a, b) => a.hour - b.hour);
+    // Build weekday stats
+    const byWeekday = Array.from(data.weekdayMap.entries())
+        .map(([weekday, weekdayData]) => ({
+        weekday,
+        weekdayName: WEEKDAY_NAMES[weekday],
+        sessionCount: weekdayData.sessionIds.size,
+        messageCount: weekdayData.messageCount,
+        tokenUsage: weekdayData.tokenUsage
+    }))
+        .sort((a, b) => a.weekday - b.weekday);
+    const statistics = {
+        overview: {
+            tokenUsage: totalUsage,
+            sessionCount: data.totalSessions,
+            messageCount: data.totalMessages,
+            dateRange: {
+                start: startDate?.toISOString() || endDate.toISOString(),
+                end: endDate.toISOString()
+            }
+        },
+        daily,
+        byProject,
+        byModel,
+        cache: {
+            totalCacheCreation: data.totalCacheCreation,
+            totalCacheRead: data.totalCacheRead,
+            ephemeral5mTokens: data.ephemeral5mTokens,
+            ephemeral1hTokens: data.ephemeral1hTokens,
+            cacheHitRate: (data.totalCacheCreation + data.totalCacheRead) > 0
+                ? (data.totalCacheRead / (data.totalCacheCreation + data.totalCacheRead)) * 100
+                : 0,
+            estimatedSavings: savedCost
+        },
+        cost: costBreakdown,
+        productivity: {
+            toolUsage,
+            totalToolCalls,
+            agentSessions: data.totalAgentSessions,
+            totalSessions: data.totalSessions,
+            agentUsageRate
+        },
+        trends: {
+            byHour,
+            byWeekday
+        }
+    };
+    return statistics;
+}
+/**
+ * Get usage statistics for a specific project
+ */
+export async function getProjectStatistics(projectId, days = 7) {
+    const daysParam = days.toString();
+    const cutoffDate = calculateCutoffDate(days);
+    const data = await aggregateProject(projectId, cutoffDate);
+    // Calculate totals
+    const totalUsage = aggregateTokenUsage(data.allUsages);
+    const defaultPricing = PRICING[DEFAULT_PRICING_MODEL];
+    const costBreakdown = calculateCost(totalUsage, defaultPricing);
+    const savedCost = (data.totalCacheRead / 1000000) * (defaultPricing.input - defaultPricing.cacheRead);
+    // Determine date range first (this drives all other date-based statistics)
+    const startDate = daysParam === 'all' && data.minDate
+        ? data.minDate
+        : cutoffDate;
+    const endDate = new Date();
+    // Fill daily stats based on the determined date range
+    const daily = fillMissingDates(data.dailyMap, startDate, endDate);
+    // Build project stats (single project)
+    const projectData = data.projectMap.get(projectId);
+    const byProject = projectData ? [{
+            id: projectId,
+            name: projectData.name,
+            tokenUsage: totalUsage,
+            sessionCount: data.totalSessions
+        }] : [];
+    // Build model stats
+    const byModel = Array.from(data.modelMap.entries())
+        .map(([model, modelData]) => ({
+        model,
+        tokenUsage: modelData.tokenUsage,
+        messageCount: modelData.messageCount
+    }))
+        .sort((a, b) => b.tokenUsage.totalTokens - a.tokenUsage.totalTokens);
+    // Build tool usage stats
+    const toolUsage = Array.from(data.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(data.toolUsageMap.values()).reduce((sum, stats) => sum + stats.total, 0);
+    const agentUsageRate = data.totalSessions > 0 ? (data.totalAgentSessions / data.totalSessions) * 100 : 0;
+    // Build hourly stats
+    const byHour = Array.from(data.hourlyMap.entries())
+        .map(([hour, hourData]) => ({
+        hour,
+        sessionCount: hourData.sessionIds.size,
+        messageCount: hourData.messageCount,
+        tokenUsage: hourData.tokenUsage
+    }))
+        .sort((a, b) => a.hour - b.hour);
+    // Build weekday stats
+    const byWeekday = Array.from(data.weekdayMap.entries())
+        .map(([weekday, weekdayData]) => ({
+        weekday,
+        weekdayName: WEEKDAY_NAMES[weekday],
+        sessionCount: weekdayData.sessionIds.size,
+        messageCount: weekdayData.messageCount,
+        tokenUsage: weekdayData.tokenUsage
+    }))
+        .sort((a, b) => a.weekday - b.weekday);
+    const statistics = {
+        overview: {
+            tokenUsage: totalUsage,
+            sessionCount: data.totalSessions,
+            messageCount: data.totalMessages,
+            dateRange: {
+                start: startDate?.toISOString() || endDate.toISOString(),
+                end: endDate.toISOString()
+            }
+        },
+        daily,
+        byProject,
+        byModel,
+        cache: {
+            totalCacheCreation: data.totalCacheCreation,
+            totalCacheRead: data.totalCacheRead,
+            ephemeral5mTokens: data.ephemeral5mTokens,
+            ephemeral1hTokens: data.ephemeral1hTokens,
+            cacheHitRate: (data.totalCacheCreation + data.totalCacheRead) > 0
+                ? (data.totalCacheRead / (data.totalCacheCreation + data.totalCacheRead)) * 100
+                : 0,
+            estimatedSavings: savedCost
+        },
+        cost: costBreakdown,
+        productivity: {
+            toolUsage,
+            totalToolCalls,
+            agentSessions: data.totalAgentSessions,
+            totalSessions: data.totalSessions,
+            agentUsageRate
+        },
+        trends: {
+            byHour,
+            byWeekday
+        }
+    };
+    return statistics;
+}

package/dist/server/statistics/tokenStats.js

@@ -0,0 +1,66 @@
+/**
+ * Token statistics utilities
+ * Pure calculation functions for token usage analysis
+ */
+/**
+ * Extract token usage from a message object
+ */
+export function extractTokenUsage(message) {
+    if (message.type !== 'assistant' || !message.message?.usage) {
+        return null;
+    }
+    const usage = message.message.usage;
+    const model = message.message.model || 'unknown';
+    return {
+        usage: {
+            inputTokens: usage.input_tokens || 0,
+            cacheCreationTokens: usage.cache_creation_input_tokens || 0,
+            cacheReadTokens: usage.cache_read_input_tokens || 0,
+            outputTokens: usage.output_tokens || 0,
+            totalTokens: (usage.input_tokens || 0) +
+                (usage.cache_creation_input_tokens || 0) +
+                (usage.cache_read_input_tokens || 0) +
+                (usage.output_tokens || 0)
+        },
+        model
+    };
+}
+/**
+ * Aggregate multiple token usages into a single total
+ */
+export function aggregateTokenUsage(usages) {
+    return usages.reduce((acc, usage) => ({
+        inputTokens: acc.inputTokens + usage.inputTokens,
+        cacheCreationTokens: acc.cacheCreationTokens + usage.cacheCreationTokens,
+        cacheReadTokens: acc.cacheReadTokens + usage.cacheReadTokens,
+        outputTokens: acc.outputTokens + usage.outputTokens,
+        totalTokens: acc.totalTokens + usage.totalTokens
+    }), createEmptyTokenUsage());
+}
+/**
+ * Calculate cost for token usage based on pricing
+ */
+export function calculateCost(usage, pricing) {
+    return {
+        inputCost: (usage.inputTokens / 1000000) * pricing.input,
+        outputCost: (usage.outputTokens / 1000000) * pricing.output,
+        cacheCreationCost: (usage.cacheCreationTokens / 1000000) * pricing.cacheCreation,
+        cacheReadCost: (usage.cacheReadTokens / 1000000) * pricing.cacheRead,
+        totalCost: (usage.inputTokens / 1000000) * pricing.input +
+            (usage.outputTokens / 1000000) * pricing.output +
+            (usage.cacheCreationTokens / 1000000) * pricing.cacheCreation +
+            (usage.cacheReadTokens / 1000000) * pricing.cacheRead
+    };
+}
+/**
+ * Create an empty token usage object
+ */
+export function createEmptyTokenUsage() {
+    return {
+        inputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0
+    };
+}

package/dist/server/statistics/tokenUsage.js

@@ -0,0 +1,66 @@
+/**
+ * Token statistics utilities
+ * Pure calculation functions for token usage analysis
+ */
+/**
+ * Extract token usage from a message object
+ */
+export function extractTokenUsage(message) {
+    if (message.type !== 'assistant' || !message.message?.usage) {
+        return null;
+    }
+    const usage = message.message.usage;
+    const model = message.message.model || 'unknown';
+    return {
+        usage: {
+            inputTokens: usage.input_tokens || 0,
+            cacheCreationTokens: usage.cache_creation_input_tokens || 0,
+            cacheReadTokens: usage.cache_read_input_tokens || 0,
+            outputTokens: usage.output_tokens || 0,
+            totalTokens: (usage.input_tokens || 0) +
+                (usage.cache_creation_input_tokens || 0) +
+                (usage.cache_read_input_tokens || 0) +
+                (usage.output_tokens || 0)
+        },
+        model
+    };
+}
+/**
+ * Aggregate multiple token usages into a single total
+ */
+export function aggregateTokenUsage(usages) {
+    return usages.reduce((acc, usage) => ({
+        inputTokens: acc.inputTokens + usage.inputTokens,
+        cacheCreationTokens: acc.cacheCreationTokens + usage.cacheCreationTokens,
+        cacheReadTokens: acc.cacheReadTokens + usage.cacheReadTokens,
+        outputTokens: acc.outputTokens + usage.outputTokens,
+        totalTokens: acc.totalTokens + usage.totalTokens
+    }), createEmptyTokenUsage());
+}
+/**
+ * Calculate cost for token usage based on pricing
+ */
+export function calculateCost(usage, pricing) {
+    return {
+        inputCost: (usage.inputTokens / 1000000) * pricing.input,
+        outputCost: (usage.outputTokens / 1000000) * pricing.output,
+        cacheCreationCost: (usage.cacheCreationTokens / 1000000) * pricing.cacheCreation,
+        cacheReadCost: (usage.cacheReadTokens / 1000000) * pricing.cacheRead,
+        totalCost: (usage.inputTokens / 1000000) * pricing.input +
+            (usage.outputTokens / 1000000) * pricing.output +
+            (usage.cacheCreationTokens / 1000000) * pricing.cacheCreation +
+            (usage.cacheReadTokens / 1000000) * pricing.cacheRead
+    };
+}
+/**
+ * Create an empty token usage object
+ */
+export function createEmptyTokenUsage() {
+    return {
+        inputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0
+    };
+}

package/dist/server/statistics/utils.js

@@ -0,0 +1,33 @@
+import { createEmptyTokenUsage } from './tokenUsage.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}`;
+}
+/**
+ * Fill in missing dates in daily statistics with zero values
+ * @param dailyMap Map of date string to usage data
+ * @param startDate Start date for the range (inclusive)
+ * @param endDate End date for the range (inclusive)
+ * @returns Array of daily stats with all dates filled in
+ */
+export function fillMissingDates(dailyMap, startDate, endDate) {
+    const daily = [];
+    const currentDate = new Date(startDate);
+    const end = new Date(endDate);
+    while (currentDate <= end) {
+        const dateKey = formatDateLocal(currentDate);
+        const data = dailyMap.get(dateKey);
+        daily.push({
+            date: dateKey,
+            tokenUsage: data?.tokenUsage || createEmptyTokenUsage(),
+            sessionCount: data?.sessionIds.size || 0
+        });
+        currentDate.setDate(currentDate.getDate() + 1);
+    }
+    return daily;
+}