claude-usage-rzp 0.1.0

package/src/commands/interactive.ts

@@ -0,0 +1,271 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import Table from 'cli-table3';
+import { loadStatsCache, buildProjectSummaries } from '../loader';
+import { estimateCost, formatCost, formatTokens } from '../pricing';
+import { getDataDir, hasStatsCache } from '../config';
+
+async function showSummary() {
+  const stats = loadStatsCache();
+  if (!stats) return false;
+
+  // Calculate total cost
+  const totalCost = Object.entries(stats.modelStats).reduce((sum, [modelId, model]) => {
+    return (
+      sum +
+      estimateCost(
+        modelId,
+        model.inputTokens,
+        model.outputTokens,
+        model.cacheCreationInputTokens,
+        model.cacheReadInputTokens
+      )
+    );
+  }, 0);
+
+  // Calculate total cache tokens across all models
+  let totalCacheWrite = 0;
+  let totalCacheRead = 0;
+  for (const model of Object.values(stats.modelStats)) {
+    totalCacheWrite += model.cacheCreationInputTokens;
+    totalCacheRead += model.cacheReadInputTokens;
+  }
+
+  const totalTokens = stats.totalInputTokens + stats.totalOutputTokens + totalCacheWrite + totalCacheRead;
+
+  console.log(chalk.bold('\n📊 Summary:'));
+  console.log(`  💬 Total Sessions:      ${chalk.green(stats.totalSessions.toLocaleString('en-US'))}`);
+  console.log(`  📨 Total Messages:      ${chalk.green(stats.totalMessages.toLocaleString('en-US'))}`);
+  console.log(`  🔢 Total Tokens Used:   ${chalk.green.bold(formatTokens(totalTokens))}`);
+  console.log(`  ⬆️  Total Input Tokens:  ${chalk.cyan(formatTokens(stats.totalInputTokens))}`);
+  console.log(`  ⬇️  Total Output Tokens: ${chalk.green(formatTokens(stats.totalOutputTokens))}`);
+  console.log(`  💰 Estimated Cost:      ${chalk.hex('#FF6B35').bold(formatCost(totalCost))}`);
+
+  return true;
+}
+
+async function showLast7Days() {
+  const stats = loadStatsCache();
+  if (!stats) return;
+
+  const recent = stats.dailyActivity.slice(-7);
+
+  console.log(chalk.bold('\n📅 Recent Activity (Last 7 Days):'));
+
+  const activityTable = new Table({
+    head: [
+      chalk.cyan('Date'),
+      chalk.white('Sessions'),
+      chalk.white('Messages'),
+      chalk.white('Tool Calls'),
+    ],
+    colAligns: ['left', 'right', 'right', 'right'],
+  });
+
+  for (const day of recent) {
+    activityTable.push([
+      day.date,
+      day.sessionCount.toString(),
+      day.messageCount.toString(),
+      day.toolCallCount.toString(),
+    ]);
+  }
+
+  console.log(activityTable.toString());
+}
+
+async function showTokensByModel() {
+  const stats = loadStatsCache();
+  if (!stats) return;
+
+  console.log(chalk.bold('\n💎 Token Usage by Model:'));
+
+  const table = new Table({
+    head: [
+      chalk.cyan('Model'),
+      chalk.blue('Input'),
+      chalk.green('Output'),
+      chalk.yellow('Cache Write'),
+      chalk.magenta('Cache Read'),
+      chalk.green.bold('Cost'),
+    ],
+    colAligns: ['left', 'right', 'right', 'right', 'right', 'right'],
+  });
+
+  for (const [modelId, model] of Object.entries(stats.modelStats)) {
+    const cost = estimateCost(
+      modelId,
+      model.inputTokens,
+      model.outputTokens,
+      model.cacheCreationInputTokens,
+      model.cacheReadInputTokens
+    );
+
+    let displayName = modelId.replace('claude-', '').replace(/-20\d{6}/, (match) => ` (${match.substring(1)})`);
+
+    table.push([
+      displayName,
+      formatTokens(model.inputTokens),
+      formatTokens(model.outputTokens),
+      formatTokens(model.cacheCreationInputTokens),
+      formatTokens(model.cacheReadInputTokens),
+      formatCost(cost),
+    ]);
+  }
+
+  console.log(table.toString());
+}
+
+async function showProjects() {
+  const projectSummaries = buildProjectSummaries();
+
+  if (Object.keys(projectSummaries).length === 0) {
+    console.log(chalk.yellow('\nNo projects found'));
+    return;
+  }
+
+  interface ProjectData {
+    path: string;
+    encoded: string;
+    sessions: number;
+    input: number;
+    output: number;
+    cost: number;
+  }
+
+  const projectData: 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,
+    });
+  }
+
+  projectData.sort((a, b) => b.cost - a.cost);
+
+  console.log(chalk.bold(`\n📁 Projects (${projectData.length} total):`));
+
+  const table = new Table({
+    head: [
+      chalk.cyan('Project Path'),
+      chalk.white('Sessions'),
+      chalk.blue('Input Tokens'),
+      chalk.green('Output Tokens'),
+      chalk.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(),
+      formatTokens(proj.input),
+      formatTokens(proj.output),
+      formatCost(proj.cost),
+    ]);
+  }
+
+  console.log(table.toString());
+}
+
+export async function interactiveCommand() {
+  if (!hasStatsCache()) {
+    console.log(chalk.red(`\n✗ No stats-cache.json found in ${getDataDir()}`));
+    console.log(
+      chalk.dim('Make sure CLAUDE_DATA_DIR is set correctly or use --data-dir option.\n')
+    );
+    process.exit(1);
+  }
+
+  // Clear screen and show header
+  console.clear();
+
+  // ASCII Art Header - Claude orange color
+  console.log(chalk.hex('#FF6B35').bold(`
+   ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
+  ██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
+  ██║     ██║     ███████║██║   ██║██║  ██║█████╗
+  ██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝
+  ╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗
+   ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝
+  `));
+  console.log(chalk.hex('#FF6B35')('           Usage Visualizer') + chalk.dim('  ・  Track your AI costs\n'));
+  console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+
+  // Show summary first
+  const hasData = await showSummary();
+  if (!hasData) {
+    console.log(chalk.red('\n✗ Failed to load stats cache\n'));
+    process.exit(1);
+  }
+
+  // Interactive menu loop
+  let running = true;
+
+  while (running) {
+    console.log(); // spacing
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to see?',
+        choices: [
+          { name: '📅 Last 7 Days Activity', value: 'last7days' },
+          { name: '💎 Token Usage by Model', value: 'tokens' },
+          { name: '📁 All Projects', value: 'projects' },
+          new inquirer.Separator(),
+          { name: '🔄 Refresh Data', value: 'refresh' },
+          { name: '❌ Exit', value: 'exit' },
+        ],
+      },
+    ]);
+
+    console.log(); // spacing
+
+    switch (action) {
+      case 'last7days':
+        await showLast7Days();
+        break;
+      case 'tokens':
+        await showTokensByModel();
+        break;
+      case 'projects':
+        await showProjects();
+        break;
+      case 'refresh':
+        console.clear();
+        // ASCII Art Header - Claude orange color
+        console.log(chalk.hex('#FF6B35').bold(`
+   ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
+  ██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
+  ██║     ██║     ███████║██║   ██║██║  ██║█████╗
+  ██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝
+  ╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗
+   ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝
+  `));
+        console.log(chalk.hex('#FF6B35')('           Usage Visualizer') + chalk.dim('  ・  Track your AI costs\n'));
+        console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        await showSummary();
+        break;
+      case 'exit':
+        console.log(chalk.dim('\nHamid said Goodbye! 👋\n'));
+        running = false;
+        break;
+    }
+  }
+}

package/src/commands/overview.ts

@@ -0,0 +1,126 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { loadStatsCache } from '../loader';
+import { estimateCost, formatCost, formatTokens } from '../pricing';
+import { getDataDir, hasStatsCache } from '../config';
+
+export function overviewCommand() {
+  if (!hasStatsCache()) {
+    console.log(chalk.red(`✗ No stats-cache.json found in ${getDataDir()}`));
+    console.log(
+      chalk.dim('\nMake sure CLAUDE_DATA_DIR is set correctly or use --data-dir option.')
+    );
+    process.exit(1);
+  }
+
+  const stats = loadStatsCache();
+
+  if (!stats) {
+    console.log(chalk.red('✗ Failed to load stats cache'));
+    process.exit(1);
+  }
+
+  // Header
+  console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.cyan.bold('  Claude Code Usage Overview'));
+  console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  // Calculate total cost
+  const totalCost = Object.entries(stats.modelStats).reduce((sum, [modelId, model]) => {
+    return (
+      sum +
+      estimateCost(
+        modelId,
+        model.inputTokens,
+        model.outputTokens,
+        model.cacheCreationInputTokens,
+        model.cacheReadInputTokens
+      )
+    );
+  }, 0);
+
+  // Summary stats
+  console.log(chalk.bold('Summary:'));
+  console.log(`  Total Sessions:      ${chalk.green(stats.totalSessions.toLocaleString('en-US'))}`);
+  console.log(`  Total Messages:      ${chalk.green(stats.totalMessages.toLocaleString('en-US'))}`);
+  console.log(`  Total Input Tokens:  ${chalk.blue(formatTokens(stats.totalInputTokens))}`);
+  console.log(`  Total Output Tokens: ${chalk.green(formatTokens(stats.totalOutputTokens))}`);
+  console.log(`  Estimated Cost:      ${chalk.green.bold(formatCost(totalCost))}`);
+
+  if (stats.firstSessionDate) {
+    console.log(`  First Session:       ${chalk.dim(stats.firstSessionDate)}`);
+  }
+  if (stats.lastComputedDate) {
+    console.log(`  Last Computed:       ${chalk.dim(stats.lastComputedDate)}`);
+  }
+
+  // Token breakdown by model
+  if (Object.keys(stats.modelStats).length > 0) {
+    console.log(chalk.bold('\nToken Usage by Model:'));
+
+    const table = new Table({
+      head: [
+        chalk.cyan('Model'),
+        chalk.blue('Input'),
+        chalk.green('Output'),
+        chalk.yellow('Cache Write'),
+        chalk.magenta('Cache Read'),
+        chalk.green.bold('Cost'),
+      ],
+      colAligns: ['left', 'right', 'right', 'right', 'right', 'right'],
+    });
+
+    for (const [modelId, model] of Object.entries(stats.modelStats)) {
+      const cost = estimateCost(
+        modelId,
+        model.inputTokens,
+        model.outputTokens,
+        model.cacheCreationInputTokens,
+        model.cacheReadInputTokens
+      );
+
+      // Simplify model name
+      let displayName = modelId.replace('claude-', '').replace(/-20\d{6}/, (match) => ` (${match.substring(1)})`);
+
+      table.push([
+        displayName,
+        formatTokens(model.inputTokens),
+        formatTokens(model.outputTokens),
+        formatTokens(model.cacheCreationInputTokens),
+        formatTokens(model.cacheReadInputTokens),
+        formatCost(cost),
+      ]);
+    }
+
+    console.log(table.toString());
+  }
+
+  // Recent activity
+  if (stats.dailyActivity.length > 0) {
+    const recent = stats.dailyActivity.slice(-7); // Last 7 days
+    console.log(chalk.bold('\nRecent Activity (Last 7 Days):'));
+
+    const activityTable = new Table({
+      head: [
+        chalk.cyan('Date'),
+        chalk.white('Sessions'),
+        chalk.white('Messages'),
+        chalk.white('Tool Calls'),
+      ],
+      colAligns: ['left', 'right', 'right', 'right'],
+    });
+
+    for (const day of recent) {
+      activityTable.push([
+        day.date,
+        day.sessionCount.toString(),
+        day.messageCount.toString(),
+        day.toolCallCount.toString(),
+      ]);
+    }
+
+    console.log(activityTable.toString());
+  }
+
+  console.log(chalk.dim('\n💡 Tip: Use "claude-usage projects" to see all projects\n'));
+}

package/src/commands/project.ts

@@ -0,0 +1,85 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { buildProjectSummaries } from '../loader';
+import { formatCost, formatTokens } from '../pricing';
+import { SessionSummary } from '../types';
+
+export function projectCommand(projectPath: string) {
+  const projectSummaries = buildProjectSummaries();
+
+  // Try to find the project (handle both encoded and unencoded paths)
+  const encodedPath = encodeURIComponent(projectPath);
+  let sessions: SessionSummary[] | undefined;
+  let foundPath = '';
+
+  if (encodedPath in projectSummaries) {
+    sessions = projectSummaries[encodedPath];
+    foundPath = encodedPath;
+  } else {
+    // Try to find by partial match
+    for (const [path, sess] of Object.entries(projectSummaries)) {
+      if (projectPath.includes(decodeURIComponent(path)) || decodeURIComponent(path).includes(projectPath)) {
+        sessions = sess;
+        foundPath = path;
+        break;
+      }
+    }
+  }
+
+  if (!sessions) {
+    console.log(chalk.red(`✗ Project not found: ${projectPath}`));
+    console.log(chalk.dim('\nAvailable projects:'));
+    for (const path of Object.keys(projectSummaries)) {
+      console.log(`  - ${decodeURIComponent(path)}`);
+    }
+    process.exit(1);
+  }
+
+  // Sort sessions by timestamp descending
+  sessions = sessions.slice().sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+
+  console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.cyan.bold(`  Project: ${decodeURIComponent(foundPath)}`));
+  console.log(chalk.dim(`  ${sessions.length} sessions`));
+  console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  const table = new Table({
+    head: [
+      chalk.cyan('Session'),
+      chalk.dim('Timestamp'),
+      chalk.white('Messages'),
+      chalk.blue('Input'),
+      chalk.green('Output'),
+      chalk.green.bold('Cost'),
+      chalk.yellow('Models'),
+    ],
+    colAligns: ['left', 'left', 'right', 'right', 'right', 'right', 'left'],
+    colWidths: [30, 20, 10, 12, 12, 10, 20],
+    wordWrap: true,
+  });
+
+  for (const session of sessions) {
+    // Truncate slug if too long
+    const slugDisplay = session.slug.length > 60 ? session.slug.substring(0, 57) + '...' : session.slug;
+
+    // Format timestamp
+    const timestamp = session.timestamp ? new Date(session.timestamp).toLocaleString('en-US') : 'N/A';
+
+    table.push([
+      slugDisplay,
+      timestamp,
+      session.messageCount.toString(),
+      formatTokens(session.totalInputTokens),
+      formatTokens(session.totalOutputTokens),
+      formatCost(session.totalCostUsd),
+      Array.from(session.modelsUsed)
+        .map(m => m.replace('claude-', ''))
+        .join(', '),
+    ]);
+  }
+
+  console.log(table.toString());
+  console.log(
+    chalk.dim('\n💡 Tip: Use "claude-usage session <session-id>" to see message details\n')
+  );
+}

package/src/commands/projects.ts

@@ -0,0 +1,83 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { buildProjectSummaries } from '../loader';
+import { formatCost, formatTokens } from '../pricing';
+import { hasProjects, getDataDir } from '../config';
+
+export function projectsCommand() {
+  if (!hasProjects()) {
+    console.log(chalk.red(`✗ No projects directory found in ${getDataDir()}`));
+    process.exit(1);
+  }
+
+  const projectSummaries = buildProjectSummaries();
+
+  if (Object.keys(projectSummaries).length === 0) {
+    console.log(chalk.yellow('No projects found'));
+    return;
+  }
+
+  // Build project-level aggregates
+  interface ProjectData {
+    path: string;
+    encoded: string;
+    sessions: number;
+    input: number;
+    output: number;
+    cost: number;
+  }
+
+  const projectData: 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.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.cyan.bold(`  Projects (${projectData.length} total)`));
+  console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  const table = new Table({
+    head: [
+      chalk.cyan('Project Path'),
+      chalk.white('Sessions'),
+      chalk.blue('Input Tokens'),
+      chalk.green('Output Tokens'),
+      chalk.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(),
+      formatTokens(proj.input),
+      formatTokens(proj.output),
+      formatCost(proj.cost),
+    ]);
+  }
+
+  console.log(table.toString());
+  console.log(
+    chalk.dim('\n💡 Tip: Use "claude-usage project <path>" to see sessions in a project\n')
+  );
+}

package/src/commands/session.ts

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { buildProjectSummaries, loadSessionMessages } from '../loader';
+import { formatCost, formatTokens } from '../pricing';
+
+export function sessionCommand(sessionId: string, options: { project?: string }) {
+  const projectSummaries = buildProjectSummaries();
+
+  let foundSession: any = 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.red(`✗ Session not found: ${sessionId}`));
+    process.exit(1);
+  }
+
+  // Load messages
+  const messages = loadSessionMessages(foundProject, foundSession.sessionId);
+
+  if (messages.length === 0) {
+    console.log(chalk.yellow('No messages found in this session'));
+    return;
+  }
+
+  console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.cyan.bold(`  Session: ${foundSession.slug}`));
+  console.log(chalk.dim(`  Project: ${decodeURIComponent(foundProject)}`));
+  console.log(chalk.dim(`  ID: ${foundSession.sessionId}`));
+  console.log(chalk.dim(`  ${messages.length} messages`));
+  console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  // Summary
+  console.log(chalk.bold('Summary:'));
+  console.log(`  Total Input Tokens:  ${chalk.blue(formatTokens(foundSession.totalInputTokens))}`);
+  console.log(`  Total Output Tokens: ${chalk.green(formatTokens(foundSession.totalOutputTokens))}`);
+  console.log(`  Total Cost:          ${chalk.green.bold(formatCost(foundSession.totalCostUsd))}`);
+  console.log(`  Models Used:         ${chalk.yellow(Array.from(foundSession.modelsUsed).join(', '))}`);
+
+  // Message breakdown
+  console.log(chalk.bold('\nMessage Details:'));
+
+  const table = new Table({
+    head: [
+      chalk.dim('#'),
+      chalk.dim('Timestamp'),
+      chalk.cyan('Model'),
+      chalk.blue('Input'),
+      chalk.green('Output'),
+      chalk.yellow('Cache Write'),
+      chalk.magenta('Cache Read'),
+      chalk.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,
+      formatTokens(msg.inputTokens),
+      formatTokens(msg.outputTokens),
+      formatTokens(msg.cacheCreationInputTokens),
+      formatTokens(msg.cacheReadInputTokens),
+      formatCost(msg.costUsd),
+    ]);
+  }
+
+  console.log(table.toString());
+  console.log();
+}