claude-usage-rzp 0.1.0

package/dist/commands/projects.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectsCommand = projectsCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const loader_1 = require("../loader");
+const pricing_1 = require("../pricing");
+const config_1 = require("../config");
+function projectsCommand() {
+    if (!(0, config_1.hasProjects)()) {
+        console.log(chalk_1.default.red(`✗ No projects directory found in ${(0, config_1.getDataDir)()}`));
+        process.exit(1);
+    }
+    const projectSummaries = (0, loader_1.buildProjectSummaries)();
+    if (Object.keys(projectSummaries).length === 0) {
+        console.log(chalk_1.default.yellow('No projects found'));
+        return;
+    }
+    const projectData = [];
+    for (const [encodedPath, sessions] of Object.entries(projectSummaries)) {
+        const displayPath = decodeURIComponent(encodedPath);
+        const sessionCount = sessions.length;
+        const totalInput = sessions.reduce((sum, s) => sum + s.totalInputTokens, 0);
+        const totalOutput = sessions.reduce((sum, s) => sum + s.totalOutputTokens, 0);
+        const totalCost = sessions.reduce((sum, s) => sum + s.totalCostUsd, 0);
+        projectData.push({
+            path: displayPath,
+            encoded: encodedPath,
+            sessions: sessionCount,
+            input: totalInput,
+            output: totalOutput,
+            cost: totalCost,
+        });
+    }
+    // Sort by cost descending
+    projectData.sort((a, b) => b.cost - a.cost);
+    console.log(chalk_1.default.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(chalk_1.default.cyan.bold(`  Projects (${projectData.length} total)`));
+    console.log(chalk_1.default.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+    const table = new cli_table3_1.default({
+        head: [
+            chalk_1.default.cyan('Project Path'),
+            chalk_1.default.white('Sessions'),
+            chalk_1.default.blue('Input Tokens'),
+            chalk_1.default.green('Output Tokens'),
+            chalk_1.default.green.bold('Total Cost'),
+        ],
+        colAligns: ['left', 'right', 'right', 'right', 'right'],
+        colWidths: [40, 10, 15, 15, 12],
+        wordWrap: true,
+    });
+    for (const proj of projectData) {
+        table.push([
+            proj.path,
+            proj.sessions.toString(),
+            (0, pricing_1.formatTokens)(proj.input),
+            (0, pricing_1.formatTokens)(proj.output),
+            (0, pricing_1.formatCost)(proj.cost),
+        ]);
+    }
+    console.log(table.toString());
+    console.log(chalk_1.default.dim('\n💡 Tip: Use "claude-usage project <path>" to see sessions in a project\n'));
+}

package/dist/commands/session.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionCommand = sessionCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const loader_1 = require("../loader");
+const pricing_1 = require("../pricing");
+function sessionCommand(sessionId, options) {
+    const projectSummaries = (0, loader_1.buildProjectSummaries)();
+    let foundSession = null;
+    let foundProject = '';
+    if (options.project) {
+        // User specified project
+        const encoded = encodeURIComponent(options.project);
+        if (encoded in projectSummaries) {
+            for (const sess of projectSummaries[encoded]) {
+                if (sess.sessionId === sessionId || sess.sessionId.startsWith(sessionId)) {
+                    foundSession = sess;
+                    foundProject = encoded;
+                    break;
+                }
+            }
+        }
+    }
+    else {
+        // Search all projects
+        for (const [encodedPath, sessions] of Object.entries(projectSummaries)) {
+            for (const sess of sessions) {
+                if (sess.sessionId === sessionId || sess.sessionId.startsWith(sessionId)) {
+                    foundSession = sess;
+                    foundProject = encodedPath;
+                    break;
+                }
+            }
+            if (foundSession)
+                break;
+        }
+    }
+    if (!foundSession) {
+        console.log(chalk_1.default.red(`✗ Session not found: ${sessionId}`));
+        process.exit(1);
+    }
+    // Load messages
+    const messages = (0, loader_1.loadSessionMessages)(foundProject, foundSession.sessionId);
+    if (messages.length === 0) {
+        console.log(chalk_1.default.yellow('No messages found in this session'));
+        return;
+    }
+    console.log(chalk_1.default.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(chalk_1.default.cyan.bold(`  Session: ${foundSession.slug}`));
+    console.log(chalk_1.default.dim(`  Project: ${decodeURIComponent(foundProject)}`));
+    console.log(chalk_1.default.dim(`  ID: ${foundSession.sessionId}`));
+    console.log(chalk_1.default.dim(`  ${messages.length} messages`));
+    console.log(chalk_1.default.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+    // Summary
+    console.log(chalk_1.default.bold('Summary:'));
+    console.log(`  Total Input Tokens:  ${chalk_1.default.blue((0, pricing_1.formatTokens)(foundSession.totalInputTokens))}`);
+    console.log(`  Total Output Tokens: ${chalk_1.default.green((0, pricing_1.formatTokens)(foundSession.totalOutputTokens))}`);
+    console.log(`  Total Cost:          ${chalk_1.default.green.bold((0, pricing_1.formatCost)(foundSession.totalCostUsd))}`);
+    console.log(`  Models Used:         ${chalk_1.default.yellow(Array.from(foundSession.modelsUsed).join(', '))}`);
+    // Message breakdown
+    console.log(chalk_1.default.bold('\nMessage Details:'));
+    const table = new cli_table3_1.default({
+        head: [
+            chalk_1.default.dim('#'),
+            chalk_1.default.dim('Timestamp'),
+            chalk_1.default.cyan('Model'),
+            chalk_1.default.blue('Input'),
+            chalk_1.default.green('Output'),
+            chalk_1.default.yellow('Cache Write'),
+            chalk_1.default.magenta('Cache Read'),
+            chalk_1.default.green.bold('Cost'),
+        ],
+        colAligns: ['right', 'left', 'left', 'right', 'right', 'right', 'right', 'right'],
+    });
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        // Simplify model name
+        let modelDisplay = msg.model.replace('claude-', '').replace(/-20\d{6}/, (match) => ` (${match.substring(1)})`);
+        // Format timestamp
+        const timestamp = msg.timestamp ? new Date(msg.timestamp).toLocaleString('en-US') : 'N/A';
+        table.push([
+            (i + 1).toString(),
+            timestamp,
+            modelDisplay,
+            (0, pricing_1.formatTokens)(msg.inputTokens),
+            (0, pricing_1.formatTokens)(msg.outputTokens),
+            (0, pricing_1.formatTokens)(msg.cacheCreationInputTokens),
+            (0, pricing_1.formatTokens)(msg.cacheReadInputTokens),
+            (0, pricing_1.formatCost)(msg.costUsd),
+        ]);
+    }
+    console.log(table.toString());
+    console.log();
+}

package/dist/config.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDataDir = getDataDir;
+exports.setDataDir = setDataDir;
+exports.hasStatsCache = hasStatsCache;
+exports.hasProjects = hasProjects;
+const os_1 = require("os");
+const path_1 = require("path");
+const fs_1 = require("fs");
+let dataDir = null;
+function getDataDir() {
+    if (dataDir) {
+        return dataDir;
+    }
+    // Check environment variable
+    const envDir = process.env.CLAUDE_DATA_DIR;
+    if (envDir) {
+        dataDir = envDir;
+        return dataDir;
+    }
+    // Default to ~/.claude
+    dataDir = (0, path_1.join)((0, os_1.homedir)(), '.claude');
+    return dataDir;
+}
+function setDataDir(path) {
+    dataDir = path;
+}
+function hasStatsCache() {
+    return (0, fs_1.existsSync)((0, path_1.join)(getDataDir(), 'stats-cache.json'));
+}
+function hasProjects() {
+    return (0, fs_1.existsSync)((0, path_1.join)(getDataDir(), 'projects'));
+}

package/dist/index.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const config_1 = require("./config");
+const interactive_1 = require("./commands/interactive");
+const overview_1 = require("./commands/overview");
+const projects_1 = require("./commands/projects");
+const project_1 = require("./commands/project");
+const session_1 = require("./commands/session");
+const config_2 = require("./commands/config");
+const program = new commander_1.Command();
+program
+    .name('claude-usage')
+    .description('View Claude Code API usage directly in your terminal')
+    .version('0.1.0')
+    .option('--data-dir <path>', 'Path to Claude data directory')
+    .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.dataDir) {
+        (0, config_1.setDataDir)(opts.dataDir);
+    }
+});
+// Default command (interactive)
+program
+    .action(async () => {
+    await (0, interactive_1.interactiveCommand)();
+});
+// Overview command (non-interactive, one-shot)
+program
+    .command('overview')
+    .description('Show usage overview and statistics (non-interactive)')
+    .action(() => {
+    (0, overview_1.overviewCommand)();
+});
+// Projects command
+program
+    .command('projects')
+    .description('List all projects with session counts and costs')
+    .action(() => {
+    (0, projects_1.projectsCommand)();
+});
+// Project command
+program
+    .command('project <path>')
+    .description('Show sessions for a specific project')
+    .action((path) => {
+    (0, project_1.projectCommand)(path);
+});
+// Session command
+program
+    .command('session <session-id>')
+    .description('Show detailed message breakdown for a session')
+    .option('--project <path>', 'Project path (encoded or decoded)')
+    .action((sessionId, options) => {
+    (0, session_1.sessionCommand)(sessionId, options);
+});
+// Config command
+program
+    .command('config')
+    .description('Show current configuration')
+    .action(() => {
+    (0, config_2.configCommand)();
+});
+program.parse();

package/dist/loader.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadStatsCache = loadStatsCache;
+exports.loadHistory = loadHistory;
+exports.loadSessionMessages = loadSessionMessages;
+exports.buildSessionSummary = buildSessionSummary;
+exports.buildProjectSummaries = buildProjectSummaries;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_1 = require("./config");
+const pricing_1 = require("./pricing");
+function loadStatsCache() {
+    const statsPath = (0, path_1.join)((0, config_1.getDataDir)(), 'stats-cache.json');
+    if (!(0, fs_1.existsSync)(statsPath)) {
+        return null;
+    }
+    try {
+        const raw = JSON.parse((0, fs_1.readFileSync)(statsPath, 'utf-8'));
+        // Parse daily activity
+        const dailyActivity = (raw.dailyActivity || []).map((d) => ({
+            date: d.date,
+            messageCount: d.messageCount || 0,
+            sessionCount: d.sessionCount || 0,
+            toolCallCount: d.toolCallCount || 0,
+        }));
+        // Parse daily model tokens
+        const dailyModelTokens = (raw.dailyModelTokens || []).map((d) => ({
+            date: d.date,
+            tokensByModel: d.tokensByModel || {},
+        }));
+        // Parse model stats
+        const modelStats = {};
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        for (const [modelId, usage] of Object.entries(raw.modelUsage || {})) {
+            const u = usage;
+            const stats = {
+                modelId,
+                inputTokens: u.inputTokens || 0,
+                outputTokens: u.outputTokens || 0,
+                cacheCreationInputTokens: u.cacheCreationInputTokens || 0,
+                cacheReadInputTokens: u.cacheReadInputTokens || 0,
+            };
+            modelStats[modelId] = stats;
+            totalInputTokens += stats.inputTokens;
+            totalOutputTokens += stats.outputTokens;
+        }
+        return {
+            totalSessions: raw.totalSessions || 0,
+            totalMessages: raw.totalMessages || 0,
+            totalInputTokens,
+            totalOutputTokens,
+            firstSessionDate: raw.firstSessionDate,
+            lastComputedDate: raw.lastComputedDate,
+            dailyActivity,
+            dailyModelTokens,
+            modelStats,
+            hourCounts: raw.hourCounts || {},
+        };
+    }
+    catch (error) {
+        console.error('Failed to load stats-cache.json:', error);
+        return null;
+    }
+}
+function loadHistory() {
+    const historyPath = (0, path_1.join)((0, config_1.getDataDir)(), 'history.jsonl');
+    if (!(0, fs_1.existsSync)(historyPath)) {
+        return {};
+    }
+    const history = {};
+    try {
+        const lines = (0, fs_1.readFileSync)(historyPath, 'utf-8').split('\n');
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                const sessionId = entry.sessionId;
+                if (!sessionId)
+                    continue;
+                const display = (entry.display || '').trim();
+                // Check for /rename command
+                if (display.startsWith('/rename')) {
+                    const renamed = display.substring(7).trim();
+                    if (renamed) {
+                        if (sessionId in history) {
+                            history[sessionId].display = renamed;
+                            history[sessionId].renamed = true;
+                        }
+                        else {
+                            history[sessionId] = {
+                                project: entry.project,
+                                timestamp: entry.timestamp,
+                                display: renamed,
+                                renamed: true,
+                            };
+                        }
+                    }
+                }
+                else {
+                    // Regular entry
+                    if (!(sessionId in history)) {
+                        history[sessionId] = {
+                            project: entry.project,
+                            timestamp: entry.timestamp,
+                            display,
+                            renamed: false,
+                        };
+                    }
+                }
+            }
+            catch (err) {
+                // Skip malformed lines
+                continue;
+            }
+        }
+    }
+    catch (error) {
+        console.error('Failed to read history.jsonl:', error);
+        return {};
+    }
+    return history;
+}
+function parseMessageUsage(usage) {
+    return {
+        inputTokens: usage.input_tokens || 0,
+        outputTokens: usage.output_tokens || 0,
+        cacheCreationInputTokens: usage.cache_creation_input_tokens || 0,
+        cacheReadInputTokens: usage.cache_read_input_tokens || 0,
+    };
+}
+function loadSessionMessages(encodedPath, sessionId) {
+    const sessionPath = (0, path_1.join)((0, config_1.getDataDir)(), 'projects', encodedPath, `${sessionId}.jsonl`);
+    if (!(0, fs_1.existsSync)(sessionPath)) {
+        return [];
+    }
+    const messages = [];
+    try {
+        const lines = (0, fs_1.readFileSync)(sessionPath, 'utf-8').split('\n');
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const msg = JSON.parse(line);
+                // Skip non-assistant messages
+                if (msg.type !== 'assistant')
+                    continue;
+                // Skip synthetic models
+                if (msg.message?.model === '<synthetic>')
+                    continue;
+                // Skip sidechain
+                if (msg.isSidechain)
+                    continue;
+                const usage = msg.message?.usage;
+                if (!usage)
+                    continue;
+                const parsed = parseMessageUsage(usage);
+                const model = msg.message?.model || 'unknown';
+                const cost = (0, pricing_1.estimateCost)(model, parsed.inputTokens, parsed.outputTokens, parsed.cacheCreationInputTokens, parsed.cacheReadInputTokens);
+                messages.push({
+                    timestamp: msg.timestamp || '',
+                    model,
+                    inputTokens: parsed.inputTokens,
+                    outputTokens: parsed.outputTokens,
+                    cacheCreationInputTokens: parsed.cacheCreationInputTokens,
+                    cacheReadInputTokens: parsed.cacheReadInputTokens,
+                    costUsd: cost,
+                });
+            }
+            catch (err) {
+                // Skip malformed lines
+                continue;
+            }
+        }
+    }
+    catch (error) {
+        console.error(`Failed to read session ${sessionId}:`, error);
+        return [];
+    }
+    return messages;
+}
+function buildSessionSummary(encodedPath, sessionId, history) {
+    const messages = loadSessionMessages(encodedPath, sessionId);
+    if (messages.length === 0) {
+        return null;
+    }
+    // Compute totals
+    let totalInput = messages.reduce((sum, m) => sum + m.inputTokens, 0);
+    let totalOutput = messages.reduce((sum, m) => sum + m.outputTokens, 0);
+    let totalCost = messages.reduce((sum, m) => sum + m.costUsd, 0);
+    const modelsUsed = new Set(messages.map(m => m.model));
+    const firstMsgTimestamp = messages[0]?.timestamp || '';
+    const histEntry = history[sessionId] || {};
+    const project = histEntry.project || `/${encodedPath}`;
+    let slug = histEntry.display?.trim() || '';
+    // Handle renamed sessions
+    if (histEntry.renamed && slug) {
+        slug = slug.substring(0, 100);
+    }
+    else if (slug) {
+        slug = slug.replace(/\n/g, ' ').trim();
+        // Skip meta commands
+        if (slug.startsWith('/') || slug.startsWith('!') || ['yes', 'Sure', 'go ahead'].includes(slug)) {
+            slug = '';
+        }
+        else {
+            slug = slug.substring(0, 80);
+        }
+    }
+    if (!slug) {
+        slug = sessionId.substring(0, 8);
+    }
+    // Merge subagent tokens
+    const subagentDir = (0, path_1.join)((0, config_1.getDataDir)(), 'projects', encodedPath, sessionId, 'subagents');
+    if ((0, fs_1.existsSync)(subagentDir)) {
+        try {
+            const agentFiles = (0, fs_1.readdirSync)(subagentDir).filter(f => f.startsWith('agent-') && f.endsWith('.jsonl'));
+            for (const agentFile of agentFiles) {
+                const agentPath = (0, path_1.join)(subagentDir, agentFile);
+                const lines = (0, fs_1.readFileSync)(agentPath, 'utf-8').split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.type !== 'assistant')
+                            continue;
+                        if (msg.message?.model === '<synthetic>')
+                            continue;
+                        const usage = msg.message?.usage;
+                        if (!usage)
+                            continue;
+                        const parsed = parseMessageUsage(usage);
+                        const model = msg.message?.model || 'unknown';
+                        const cost = (0, pricing_1.estimateCost)(model, parsed.inputTokens, parsed.outputTokens, parsed.cacheCreationInputTokens, parsed.cacheReadInputTokens);
+                        totalInput += parsed.inputTokens;
+                        totalOutput += parsed.outputTokens;
+                        totalCost += cost;
+                        modelsUsed.add(model);
+                    }
+                    catch (err) {
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore subagent errors
+        }
+    }
+    return {
+        sessionId,
+        slug,
+        project,
+        timestamp: firstMsgTimestamp,
+        messageCount: messages.length,
+        totalInputTokens: totalInput,
+        totalOutputTokens: totalOutput,
+        totalCostUsd: totalCost,
+        modelsUsed,
+    };
+}
+function buildProjectSummaries() {
+    const projectsDir = (0, path_1.join)((0, config_1.getDataDir)(), 'projects');
+    if (!(0, fs_1.existsSync)(projectsDir)) {
+        return {};
+    }
+    const history = loadHistory();
+    const projects = {};
+    try {
+        const encodedDirs = (0, fs_1.readdirSync)(projectsDir);
+        for (const encodedDir of encodedDirs) {
+            const dirPath = (0, path_1.join)(projectsDir, encodedDir);
+            const stat = require('fs').statSync(dirPath);
+            if (!stat.isDirectory())
+                continue;
+            const sessions = [];
+            const files = (0, fs_1.readdirSync)(dirPath);
+            for (const file of files) {
+                if (!file.endsWith('.jsonl'))
+                    continue;
+                const sessionId = file.replace('.jsonl', '');
+                const summary = buildSessionSummary(encodedDir, sessionId, history);
+                if (summary) {
+                    sessions.push(summary);
+                }
+            }
+            if (sessions.length > 0) {
+                projects[encodedDir] = sessions;
+            }
+        }
+    }
+    catch (error) {
+        console.error('Failed to build project summaries:', error);
+        return {};
+    }
+    return projects;
+}

package/dist/pricing.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelPricing = getModelPricing;
+exports.estimateCost = estimateCost;
+exports.formatCost = formatCost;
+exports.formatTokens = formatTokens;
+// Pricing in $/MTok (million tokens)
+const FALLBACK_PRICING = {
+    'claude-opus-4-6': {
+        input: 15.0,
+        output: 75.0,
+        cacheWrite: 18.75,
+        cacheRead: 1.5,
+    },
+    'claude-opus-4-5-20251101': {
+        input: 15.0,
+        output: 75.0,
+        cacheWrite: 18.75,
+        cacheRead: 1.5,
+    },
+    'claude-sonnet-4-5-20250929': {
+        input: 3.0,
+        output: 15.0,
+        cacheWrite: 3.75,
+        cacheRead: 0.3,
+    },
+    'claude-haiku-4-5-20251001': {
+        input: 0.8,
+        output: 4.0,
+        cacheWrite: 1.0,
+        cacheRead: 0.08,
+    },
+};
+const DEFAULT_PRICING = FALLBACK_PRICING['claude-sonnet-4-5-20250929'];
+function getModelPricing(modelId) {
+    if (modelId in FALLBACK_PRICING) {
+        return FALLBACK_PRICING[modelId];
+    }
+    return DEFAULT_PRICING;
+}
+function estimateCost(modelId, inputTokens = 0, outputTokens = 0, cacheCreationInputTokens = 0, cacheReadInputTokens = 0) {
+    const pricing = getModelPricing(modelId);
+    const cost = (inputTokens * pricing.input +
+        outputTokens * pricing.output +
+        cacheCreationInputTokens * pricing.cacheWrite +
+        cacheReadInputTokens * pricing.cacheRead) /
+        1_000_000;
+    return cost;
+}
+function formatCost(cost) {
+    return `$${cost.toFixed(4)}`;
+}
+function formatTokens(tokens) {
+    return tokens.toLocaleString('en-US');
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "claude-usage-rzp",
+  "version": "0.1.0",
+  "description": "View Claude Code API usage directly in your terminal",
+  "main": "dist/index.js",
+  "bin": {
+    "claude-usage": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "usage",
+    "cli",
+    "tokens",
+    "cost"
+  ],
+  "author": "Hamid",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hamid-miran/claude-usage-cli"
+  },
+  "homepage": "https://github.com/hamid-miran/claude-usage-cli#readme",
+  "bugs": {
+    "url": "https://github.com/hamid-miran/claude-usage-cli/issues"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "inquirer": "^9.2.12"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/commands/config.ts

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+import { getDataDir, hasStatsCache, hasProjects } from '../config';
+
+export function configCommand() {
+  console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.cyan.bold('  Configuration'));
+  console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  console.log(`  Data Directory:       ${chalk.green(getDataDir())}`);
+  console.log(`  Has stats-cache.json: ${hasStatsCache() ? chalk.green('✓') : chalk.red('✗')}`);
+  console.log(`  Has projects/:        ${hasProjects() ? chalk.green('✓') : chalk.red('✗')}`);
+
+  console.log(
+    chalk.dim('\n💡 Set CLAUDE_DATA_DIR environment variable or use --data-dir option\n')
+  );
+}