claude-stats 0.1.0

package/dist/collector.d.ts

@@ -0,0 +1,3 @@
+import { MonitorData } from '@claude-monitor/shared';
+export declare function getAccountId(): string;
+export declare function collectData(): MonitorData;

package/dist/collector.js

@@ -0,0 +1,676 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountId = getAccountId;
+exports.collectData = collectData;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const shared_1 = require("@claude-monitor/shared");
+const usage_limits_1 = require("./usage-limits");
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const STATS_FILE = path.join(CLAUDE_DIR, 'stats-cache.json');
+const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects');
+// Generate a unique account ID based on Claude account data
+// This will be the same across machines using the same Claude account
+let cachedAccountId = null;
+function getAccountId() {
+    if (cachedAccountId)
+        return cachedAccountId;
+    try {
+        const stats = getStats();
+        // Use firstSessionDate as the primary identifier - it's unique per account
+        // and won't change over time
+        const firstSession = stats.firstSessionDate || '';
+        // Also include a hash of the projects directory structure for extra uniqueness
+        let projectsHash = '';
+        if (fs.existsSync(PROJECTS_DIR)) {
+            const projects = fs.readdirSync(PROJECTS_DIR).sort().join(',');
+            projectsHash = projects;
+        }
+        const combined = `${firstSession}:${projectsHash}`;
+        cachedAccountId = crypto.createHash('md5').update(combined).digest('hex').slice(0, 12);
+        return cachedAccountId;
+    }
+    catch {
+        // Fallback to a random ID if we can't generate one
+        cachedAccountId = crypto.randomBytes(6).toString('hex');
+        return cachedAccountId;
+    }
+}
+function getStats() {
+    try {
+        if (fs.existsSync(STATS_FILE)) {
+            const content = fs.readFileSync(STATS_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch (e) {
+        // Ignore errors
+    }
+    return {};
+}
+function parseSessionTokens(sessionFile) {
+    const result = {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_read: 0,
+        cache_write: 0,
+        model: null,
+        messages: 0,
+    };
+    try {
+        const content = fs.readFileSync(sessionFile, 'utf-8');
+        const lines = content.trim().split('\n');
+        for (const line of lines) {
+            try {
+                const msg = JSON.parse(line);
+                if (msg.type === 'assistant') {
+                    result.messages++;
+                    const usage = msg.message?.usage || {};
+                    result.input_tokens += usage.input_tokens || 0;
+                    result.output_tokens += usage.output_tokens || 0;
+                    result.cache_read += usage.cache_read_input_tokens || 0;
+                    result.cache_write += usage.cache_creation_input_tokens || 0;
+                    if (!result.model) {
+                        result.model = msg.message?.model || null;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return result;
+}
+function parseSessionActivity(sessionFile) {
+    const activity = {
+        status: 'idle',
+        current_activity: null,
+        last_tool: null,
+        last_user_message: null,
+        subagent_detail: null,
+        waiting_reason: null,
+    };
+    try {
+        const stats = fs.statSync(sessionFile);
+        const fd = fs.openSync(sessionFile, 'r');
+        const bufferSize = Math.min(80000, stats.size);
+        const buffer = Buffer.alloc(bufferSize);
+        const startPos = Math.max(0, stats.size - bufferSize);
+        fs.readSync(fd, buffer, 0, bufferSize, startPos);
+        fs.closeSync(fd);
+        const content = buffer.toString('utf-8');
+        const lines = content.trim().split('\n');
+        const lastMessages = [];
+        for (const line of lines.slice(-30)) {
+            try {
+                lastMessages.push(JSON.parse(line));
+            }
+            catch {
+                continue;
+            }
+        }
+        if (lastMessages.length === 0)
+            return activity;
+        const lastMsg = lastMessages[lastMessages.length - 1];
+        const lastType = lastMsg.type;
+        // Check if waiting for user input
+        if (lastType === 'assistant') {
+            const content = lastMsg.message?.content || [];
+            let hasToolUse = false;
+            let lastText = '';
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block?.type === 'tool_use')
+                        hasToolUse = true;
+                    if (block?.type === 'text')
+                        lastText = block.text || '';
+                }
+            }
+            if (!hasToolUse && lastText) {
+                activity.status = 'waiting_input';
+                const textLines = lastText.trim().split('\n');
+                const lastLine = textLines[textLines.length - 1] || '';
+                if (lastText.slice(-300).includes('?')) {
+                    activity.waiting_reason = 'Asking a question';
+                    for (let i = textLines.length - 1; i >= 0; i--) {
+                        if (textLines[i].includes('?')) {
+                            const q = textLines[i].slice(0, 80);
+                            activity.current_activity = `❓ ${q}${textLines[i].length > 80 ? '...' : ''}`;
+                            break;
+                        }
+                    }
+                }
+                else {
+                    activity.waiting_reason = 'Waiting for your response';
+                    activity.current_activity = `💬 ${lastLine.slice(0, 60)}${lastLine.length > 60 ? '...' : ''}`;
+                }
+            }
+        }
+        // Analyze messages for tool activity
+        for (let i = lastMessages.length - 1; i >= 0; i--) {
+            const msg = lastMessages[i];
+            const msgType = msg.type;
+            // Check for user message
+            if (msgType === 'user' && !activity.last_user_message) {
+                const content = msg.message?.content;
+                if (typeof content === 'string') {
+                    activity.last_user_message = content.slice(0, 100) + (content.length > 100 ? '...' : '');
+                }
+                else if (Array.isArray(content)) {
+                    for (const c of content) {
+                        if (c?.type === 'text') {
+                            const text = (c.text || '').slice(0, 100);
+                            activity.last_user_message = text + (text.length >= 100 ? '...' : '');
+                            break;
+                        }
+                    }
+                }
+            }
+            // Check for assistant activity
+            if (msgType === 'assistant' && activity.status !== 'waiting_input') {
+                const content = msg.message?.content || [];
+                if (Array.isArray(content)) {
+                    for (let j = content.length - 1; j >= 0; j--) {
+                        const block = content[j];
+                        if (block?.type === 'tool_use') {
+                            const toolName = block.name || 'unknown';
+                            activity.last_tool = toolName;
+                            activity.status = 'working';
+                            const inp = block.input || {};
+                            // Detailed activity based on tool
+                            if (toolName === 'TodoWrite') {
+                                const todos = inp.todos || [];
+                                const inProgress = todos.filter((t) => t.status === 'in_progress');
+                                if (inProgress.length > 0) {
+                                    activity.current_activity = `📋 ${(inProgress[0].content || 'Working on task').slice(0, 50)}`;
+                                }
+                                else {
+                                    activity.current_activity = '📋 Updating task list';
+                                }
+                            }
+                            else if (toolName === 'Read') {
+                                const file = (inp.file_path || '').split('/').pop();
+                                activity.current_activity = `📖 Reading ${file}`;
+                            }
+                            else if (toolName === 'Write') {
+                                const file = (inp.file_path || '').split('/').pop();
+                                activity.current_activity = `✏️ Writing ${file}`;
+                            }
+                            else if (toolName === 'Edit') {
+                                const file = (inp.file_path || '').split('/').pop();
+                                activity.current_activity = `✏️ Editing ${file}`;
+                            }
+                            else if (toolName === 'Bash') {
+                                const cmd = inp.command || '';
+                                const desc = inp.description || '';
+                                if (desc) {
+                                    activity.current_activity = `⚡ ${desc.slice(0, 50)}`;
+                                }
+                                else {
+                                    activity.current_activity = `⚡ $ ${cmd.slice(0, 45)}`;
+                                }
+                            }
+                            else if (toolName === 'Task') {
+                                const desc = inp.description || 'task';
+                                const agentType = inp.subagent_type || '';
+                                const prompt = inp.prompt || '';
+                                if (agentType) {
+                                    activity.current_activity = `🤖 ${agentType} agent: ${desc}`;
+                                }
+                                else {
+                                    activity.current_activity = `🤖 Subagent: ${desc}`;
+                                }
+                                if (prompt) {
+                                    activity.subagent_detail = prompt.slice(0, 120) + (prompt.length > 120 ? '...' : '');
+                                }
+                            }
+                            else if (toolName === 'Grep') {
+                                const pattern = inp.pattern || '';
+                                activity.current_activity = `🔍 Searching: ${pattern.slice(0, 40)}`;
+                            }
+                            else if (toolName === 'Glob') {
+                                const pattern = inp.pattern || '';
+                                activity.current_activity = `📁 Finding: ${pattern.slice(0, 40)}`;
+                            }
+                            else if (toolName === 'AskUserQuestion') {
+                                const questions = inp.questions || [];
+                                if (questions.length > 0) {
+                                    const q = (questions[0].question || '').slice(0, 60);
+                                    activity.current_activity = `❓ ${q}`;
+                                }
+                                else {
+                                    activity.current_activity = '❓ Asking question';
+                                }
+                                activity.status = 'waiting_input';
+                                activity.waiting_reason = 'Needs your input';
+                            }
+                            else if (['WebSearch', 'WebFetch', 'mcp__web-search-prime__webSearchPrime'].includes(toolName)) {
+                                const query = (inp.query || inp.search_query || '').slice(0, 40);
+                                activity.current_activity = `🌐 Searching: ${query}`;
+                            }
+                            else if (toolName.startsWith('mcp__')) {
+                                const shortName = toolName.split('__').pop();
+                                activity.current_activity = `🔌 ${shortName}`;
+                            }
+                            else {
+                                activity.current_activity = `🔧 ${toolName}`;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            if (activity.current_activity)
+                break;
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return activity;
+}
+function getCliProcesses() {
+    try {
+        const result = (0, child_process_1.execSync)('ps aux', { encoding: 'utf-8', timeout: 5000 });
+        const processes = [];
+        for (const line of result.trim().split('\n').slice(1)) {
+            const parts = line.split(/\s+/);
+            if (parts.length < 11)
+                continue;
+            const cmd = parts.slice(10).join(' ');
+            if (cmd.startsWith('claude') && !cmd.includes('Claude.app')) {
+                const pid = parseInt(parts[1], 10);
+                const cpu = parseFloat(parts[2]);
+                const mem = parseFloat(parts[3]);
+                let cwd = null;
+                try {
+                    const lsof = (0, child_process_1.execSync)(`lsof -p ${pid} -Fn`, { encoding: 'utf-8', timeout: 2000 });
+                    for (const lline of lsof.split('\n')) {
+                        if (lline.startsWith('n') && lline.includes('projects') && lline.includes('.jsonl')) {
+                            const filePath = lline.slice(1);
+                            const match = filePath.split('/projects/')[1];
+                            if (match) {
+                                cwd = match.split('/')[0].replace(/-/g, '/');
+                            }
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // Ignore
+                }
+                processes.push({ pid, cpu, mem, cwd });
+            }
+        }
+        return processes;
+    }
+    catch {
+        return [];
+    }
+}
+function getOpenFiles() {
+    const openFiles = new Set();
+    try {
+        const result = (0, child_process_1.execSync)('lsof -c claude', { encoding: 'utf-8', timeout: 5000 });
+        for (const line of result.split('\n')) {
+            if (line.includes('.jsonl') && line.includes('projects')) {
+                const parts = line.split(/\s+/);
+                for (const part of parts) {
+                    if (part.includes('.jsonl')) {
+                        openFiles.add(part);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return openFiles;
+}
+function getTodayUsageFromSessions() {
+    const today = new Date().toISOString().split('T')[0];
+    const todayStart = new Date();
+    todayStart.setHours(0, 0, 0, 0);
+    const todayStartTs = todayStart.getTime();
+    const modelTokens = {};
+    let messages = 0;
+    let sessions = 0;
+    if (!fs.existsSync(PROJECTS_DIR)) {
+        return {
+            date: today,
+            tokens: 0,
+            cost: 0,
+            messages: 0,
+            sessions: 0,
+            models: [],
+            model_breakdown: {},
+        };
+    }
+    const projectDirs = fs.readdirSync(PROJECTS_DIR);
+    for (const projectDir of projectDirs) {
+        const projectPath = path.join(PROJECTS_DIR, projectDir);
+        if (!fs.statSync(projectPath).isDirectory())
+            continue;
+        const sessionFiles = fs.readdirSync(projectPath).filter((f) => f.endsWith('.jsonl'));
+        for (const sessionFile of sessionFiles) {
+            const sessionPath = path.join(projectPath, sessionFile);
+            const stat = fs.statSync(sessionPath);
+            if (stat.mtimeMs < todayStartTs)
+                continue;
+            sessions++;
+            try {
+                const content = fs.readFileSync(sessionPath, 'utf-8');
+                for (const line of content.trim().split('\n')) {
+                    try {
+                        const msg = JSON.parse(line);
+                        const ts = msg.timestamp || '';
+                        if (!ts.startsWith(today))
+                            continue;
+                        if (msg.type === 'assistant') {
+                            messages++;
+                            const usage = msg.message?.usage || {};
+                            const model = msg.message?.model || 'unknown';
+                            if (!modelTokens[model]) {
+                                modelTokens[model] = { input: 0, output: 0, cache_read: 0, cache_write: 0 };
+                            }
+                            modelTokens[model].input += usage.input_tokens || 0;
+                            modelTokens[model].output += usage.output_tokens || 0;
+                            modelTokens[model].cache_read += usage.cache_read_input_tokens || 0;
+                            modelTokens[model].cache_write += usage.cache_creation_input_tokens || 0;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    let allTokens = 0;
+    let totalCost = 0;
+    const modelBreakdown = {};
+    for (const [model, tokens] of Object.entries(modelTokens)) {
+        const modelTotal = tokens.input + tokens.output + tokens.cache_read + tokens.cache_write;
+        allTokens += modelTotal;
+        const pricing = shared_1.MODEL_PRICING[model] || shared_1.DEFAULT_PRICING;
+        const cost = (tokens.input / 1000000) * pricing.input +
+            (tokens.output / 1000000) * pricing.output +
+            (tokens.cache_read / 1000000) * pricing.cache_read +
+            (tokens.cache_write / 1000000) * pricing.cache_write;
+        totalCost += cost;
+        modelBreakdown[model] = {
+            inputTokens: tokens.input,
+            outputTokens: tokens.output,
+            cacheReadInputTokens: tokens.cache_read,
+            cacheCreationInputTokens: tokens.cache_write,
+            cost: Math.round(cost * 10000) / 10000,
+        };
+    }
+    return {
+        date: today,
+        tokens: allTokens,
+        cost: Math.round(totalCost * 10000) / 10000,
+        messages,
+        sessions,
+        models: Object.keys(modelTokens),
+        model_breakdown: modelBreakdown,
+    };
+}
+function getDailyUsage(stats) {
+    const dailyTokens = stats.dailyModelTokens || [];
+    const dailyActivity = {};
+    for (const d of stats.dailyActivity || []) {
+        dailyActivity[d.date] = d;
+    }
+    const result = [];
+    for (const day of dailyTokens.slice(-14)) {
+        const date = day.date;
+        const tokensByModel = day.tokensByModel || {};
+        const totalTokens = Object.values(tokensByModel).reduce((sum, t) => sum + t, 0);
+        let dayCost = 0;
+        for (const [model, tokens] of Object.entries(tokensByModel)) {
+            const pricing = shared_1.MODEL_PRICING[model] || shared_1.DEFAULT_PRICING;
+            dayCost += (tokens / 1000000) * pricing.input;
+        }
+        const activity = dailyActivity[date] || { messageCount: 0, sessionCount: 0 };
+        result.push({
+            date,
+            tokens: totalTokens,
+            cost: Math.round(dayCost * 10000) / 10000,
+            messages: activity.messageCount,
+            sessions: activity.sessionCount,
+            models: Object.keys(tokensByModel),
+        });
+    }
+    return result;
+}
+function getSessions() {
+    const active = [];
+    const recent = [];
+    if (!fs.existsSync(PROJECTS_DIR)) {
+        return { active, recent };
+    }
+    const openFiles = getOpenFiles();
+    const now = Date.now();
+    const projectDirs = fs.readdirSync(PROJECTS_DIR);
+    for (const projectDir of projectDirs) {
+        const projectPath = path.join(PROJECTS_DIR, projectDir);
+        if (!fs.statSync(projectPath).isDirectory())
+            continue;
+        const sessionFiles = fs.readdirSync(projectPath).filter((f) => f.endsWith('.jsonl'));
+        for (const sessionFile of sessionFiles) {
+            const sessionPath = path.join(projectPath, sessionFile);
+            const stat = fs.statSync(sessionPath);
+            const isActive = openFiles.has(sessionPath) || now - stat.mtimeMs < 30000;
+            const projectName = projectDir.replace(/-/g, '/');
+            const projectShort = projectName.includes('/') ? projectName.split('/').pop() : projectName;
+            let activity = {
+                status: 'idle',
+                current_activity: null,
+                last_tool: null,
+                last_user_message: null,
+                subagent_detail: null,
+                waiting_reason: null,
+            };
+            let tokenData = null;
+            let sessionCost = null;
+            if (isActive) {
+                activity = parseSessionActivity(sessionPath);
+                tokenData = parseSessionTokens(sessionPath);
+                sessionCost = (0, shared_1.calculateCost)(tokenData.model || 'claude-opus-4-5-20251101', {
+                    input_tokens: tokenData.input_tokens,
+                    output_tokens: tokenData.output_tokens,
+                    cache_read_input_tokens: tokenData.cache_read,
+                    cache_creation_input_tokens: tokenData.cache_write,
+                });
+            }
+            const session = {
+                session_id: path.basename(sessionFile, '.jsonl'),
+                project: projectName,
+                project_short: projectShort,
+                last_modified: new Date(stat.mtimeMs).toLocaleTimeString('en-US', { hour12: false }),
+                size_kb: Math.round((stat.size / 1024) * 10) / 10,
+                is_active: isActive,
+                tokens: tokenData,
+                cost: sessionCost,
+                model: tokenData?.model || null,
+                ...activity,
+            };
+            if (isActive) {
+                active.push(session);
+            }
+            else if (now - stat.mtimeMs < 86400000) {
+                recent.push(session);
+            }
+        }
+    }
+    active.sort((a, b) => b.last_modified.localeCompare(a.last_modified));
+    recent.sort((a, b) => b.last_modified.localeCompare(a.last_modified));
+    return { active, recent: recent.slice(0, 10) };
+}
+function collectData() {
+    const stats = getStats();
+    const processes = getCliProcesses();
+    const { active: activeSessions, recent: recentSessions } = getSessions();
+    // Today's usage - compute from session files in real-time
+    const todayUsage = getTodayUsageFromSessions();
+    // Merge historical model usage with today's
+    const modelUsage = { ...stats.modelUsage };
+    const todayBreakdown = todayUsage.model_breakdown;
+    for (const [model, todayData] of Object.entries(todayBreakdown)) {
+        if (modelUsage[model]) {
+            modelUsage[model] = {
+                inputTokens: (modelUsage[model].inputTokens || 0) + (todayData.inputTokens || 0),
+                outputTokens: (modelUsage[model].outputTokens || 0) + (todayData.outputTokens || 0),
+                cacheReadInputTokens: (modelUsage[model].cacheReadInputTokens || 0) + (todayData.cacheReadInputTokens || 0),
+                cacheCreationInputTokens: (modelUsage[model].cacheCreationInputTokens || 0) + (todayData.cacheCreationInputTokens || 0),
+            };
+        }
+        else {
+            modelUsage[model] = {
+                inputTokens: todayData.inputTokens,
+                outputTokens: todayData.outputTokens,
+                cacheReadInputTokens: todayData.cacheReadInputTokens,
+                cacheCreationInputTokens: todayData.cacheCreationInputTokens,
+            };
+        }
+    }
+    // Calculate costs for each model
+    const modelCosts = {};
+    let totalCost = 0;
+    let totalTokens = 0;
+    for (const [model, usage] of Object.entries(modelUsage)) {
+        const cost = (0, shared_1.calculateCost)(model, usage);
+        modelCosts[model] = cost;
+        totalCost += cost;
+        totalTokens +=
+            (usage.inputTokens || 0) +
+                (usage.outputTokens || 0) +
+                (usage.cacheReadInputTokens || 0) +
+                (usage.cacheCreationInputTokens || 0);
+    }
+    // Get daily usage and add today
+    const dailyUsage = getDailyUsage(stats);
+    if (todayUsage.tokens > 0) {
+        dailyUsage.push({
+            date: todayUsage.date,
+            tokens: todayUsage.tokens,
+            cost: todayUsage.cost,
+            messages: todayUsage.messages,
+            sessions: todayUsage.sessions,
+            models: todayUsage.models,
+        });
+    }
+    // Active sessions total cost
+    const activeSessionsCost = activeSessions.reduce((sum, s) => sum + (s.cost || 0), 0);
+    const activeSessionsTokens = activeSessions.reduce((sum, s) => {
+        if (!s.tokens)
+            return sum;
+        return sum + s.tokens.input_tokens + s.tokens.output_tokens + s.tokens.cache_read + s.tokens.cache_write;
+    }, 0);
+    // Calculate averages and projections
+    const totalSessionsCount = (stats.totalSessions || 0) + todayUsage.sessions;
+    const totalMessagesCount = (stats.totalMessages || 0) + todayUsage.messages;
+    const avgCostPerMessage = totalMessagesCount > 0 ? totalCost / totalMessagesCount : 0;
+    const avgCostPerSession = totalSessionsCount > 0 ? totalCost / totalSessionsCount : 0;
+    // Days since first session for projection
+    let daysActive = dailyUsage.length || 1;
+    const firstSessionDate = stats.firstSessionDate;
+    if (firstSessionDate) {
+        try {
+            const firstDt = new Date(firstSessionDate);
+            daysActive = Math.max(1, Math.floor((Date.now() - firstDt.getTime()) / 86400000) + 1);
+        }
+        catch {
+            // Use default
+        }
+    }
+    const dailyAvgCost = daysActive > 0 ? totalCost / daysActive : 0;
+    // Weekly cost calculation (last 7 days from daily_usage)
+    const last7Days = dailyUsage.slice(-7);
+    let weeklyCost = last7Days.reduce((sum, d) => sum + (d.cost || 0), 0);
+    weeklyCost += todayUsage.cost;
+    // Today's hourly rate
+    const currentHour = new Date().getHours();
+    const hoursElapsed = Math.max(currentHour, 1);
+    const todayHourlyRate = hoursElapsed > 0 ? todayUsage.cost / hoursElapsed : 0;
+    const hourCounts = stats.hourCounts || {};
+    const summary = {
+        is_running: activeSessions.length > 0,
+        active_count: activeSessions.length,
+        waiting_input: activeSessions.filter((s) => s.status === 'waiting_input').length,
+        total_sessions: totalSessionsCount,
+        total_messages: totalMessagesCount,
+        total_cost: Math.round(totalCost * 100) / 100,
+        total_tokens: totalTokens,
+        active_sessions_cost: Math.round(activeSessionsCost * 10000) / 10000,
+        active_sessions_tokens: activeSessionsTokens,
+        first_session: firstSessionDate || null,
+        days_active: daysActive,
+        avg_cost_per_message: Math.round(avgCostPerMessage * 10000) / 10000,
+        avg_cost_per_session: Math.round(avgCostPerSession * 100) / 100,
+        daily_avg_cost: Math.round(dailyAvgCost * 100) / 100,
+        projected_monthly: Math.round(dailyAvgCost * 30 * 100) / 100,
+        weekly_cost: Math.round(weeklyCost * 100) / 100,
+        today_hourly_rate: Math.round(todayHourlyRate * 10000) / 10000,
+        est_weekly: Math.round(dailyAvgCost * 7 * 100) / 100,
+    };
+    return {
+        stats,
+        model_usage: modelUsage,
+        processes,
+        active_sessions: activeSessions,
+        recent_sessions: recentSessions,
+        model_costs: modelCosts,
+        daily_usage: dailyUsage,
+        today_usage: todayUsage,
+        hour_counts: hourCounts,
+        summary,
+        usage_limits: (0, usage_limits_1.getUsageLimitsSync)(),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};