rafcode 2.1.1 → 2.2.0

package/src/utils/config.ts

@@ -1,10 +1,31 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import { RafConfig, DEFAULT_RAF_CONFIG } from '../types/config.js';
+import {
+  RafConfig,
+  DEFAULT_CONFIG,
+  DEFAULT_RAF_CONFIG,
+  UserConfig,
+  VALID_MODEL_ALIASES,
+  FULL_MODEL_ID_PATTERN,
+  VALID_EFFORTS,
+  ClaudeModelName,
+  EffortLevel,
+  ModelScenario,
+  EffortScenario,
+  CommitFormatType,
+  PricingCategory,
+  ModelPricing,
+  PricingConfig,
+} from '../types/config.js';
 
+const CONFIG_DIR = path.join(os.homedir(), '.raf');
 const CONFIG_FILENAME = 'raf.config.json';
 
+export function getConfigPath(): string {
+  return path.join(CONFIG_DIR, CONFIG_FILENAME);
+}
+
 /**
  * Get the path to Claude CLI settings file.
  */
@@ -12,25 +33,320 @@ export function getClaudeSettingsPath(): string {
   return path.join(os.homedir(), '.claude', 'settings.json');
 }
 
-export function loadConfig(rafDir: string): RafConfig {
-  const configPath = path.join(rafDir, CONFIG_FILENAME);
+// ---- Validation ----
+
+const VALID_TOP_LEVEL_KEYS = new Set<string>([
+  'models', 'effort', 'timeout', 'maxRetries', 'autoCommit',
+  'worktree', 'commitFormat', 'claudeCommand', 'pricing',
+]);
+
+const VALID_PRICING_CATEGORIES = new Set<string>(['opus', 'sonnet', 'haiku']);
+const VALID_PRICING_FIELDS = new Set<string>(['inputPerMTok', 'outputPerMTok', 'cacheReadPerMTok', 'cacheCreatePerMTok']);
 
-  if (!fs.existsSync(configPath)) {
-    return { ...DEFAULT_RAF_CONFIG };
+const VALID_MODEL_KEYS = new Set<string>([
+  'plan', 'execute', 'nameGeneration', 'failureAnalysis', 'prGeneration', 'config',
+]);
+
+const VALID_EFFORT_KEYS = new Set<string>([
+  'plan', 'execute', 'nameGeneration', 'failureAnalysis', 'prGeneration', 'config',
+]);
+
+const VALID_COMMIT_FORMAT_KEYS = new Set<string>(['task', 'plan', 'amend', 'prefix']);
+
+export class ConfigValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ConfigValidationError';
   }
+}
 
-  try {
-    const content = fs.readFileSync(configPath, 'utf-8');
-    const userConfig = JSON.parse(content) as Partial<RafConfig>;
-    return { ...DEFAULT_RAF_CONFIG, ...userConfig };
-  } catch {
-    return { ...DEFAULT_RAF_CONFIG };
+function checkUnknownKeys(obj: Record<string, unknown>, validKeys: Set<string>, prefix: string): void {
+  for (const key of Object.keys(obj)) {
+    if (!validKeys.has(key)) {
+      throw new ConfigValidationError(`Unknown config key: ${prefix ? `${prefix}.` : ''}${key}`);
+    }
+  }
+}
+
+/**
+ * Check whether a string is a valid model name — either a short alias or a full model ID.
+ */
+export function isValidModelName(value: string): boolean {
+  return (VALID_MODEL_ALIASES as readonly string[]).includes(value) || FULL_MODEL_ID_PATTERN.test(value);
+}
+
+export function validateConfig(config: unknown): UserConfig {
+  if (config === null || typeof config !== 'object' || Array.isArray(config)) {
+    throw new ConfigValidationError('Config must be a JSON object');
+  }
+
+  const obj = config as Record<string, unknown>;
+  checkUnknownKeys(obj, VALID_TOP_LEVEL_KEYS, '');
+
+  // models
+  if (obj.models !== undefined) {
+    if (typeof obj.models !== 'object' || obj.models === null || Array.isArray(obj.models)) {
+      throw new ConfigValidationError('models must be an object');
+    }
+    const models = obj.models as Record<string, unknown>;
+    checkUnknownKeys(models, VALID_MODEL_KEYS, 'models');
+    for (const [key, val] of Object.entries(models)) {
+      if (typeof val !== 'string' || !isValidModelName(val)) {
+        throw new ConfigValidationError(
+          `models.${key} must be a short alias (${VALID_MODEL_ALIASES.join(', ')}) or a full model ID (e.g., claude-sonnet-4-5-20250929)`
+        );
+      }
+    }
+  }
+
+  // effort
+  if (obj.effort !== undefined) {
+    if (typeof obj.effort !== 'object' || obj.effort === null || Array.isArray(obj.effort)) {
+      throw new ConfigValidationError('effort must be an object');
+    }
+    const effort = obj.effort as Record<string, unknown>;
+    checkUnknownKeys(effort, VALID_EFFORT_KEYS, 'effort');
+    for (const [key, val] of Object.entries(effort)) {
+      if (typeof val !== 'string' || !(VALID_EFFORTS as readonly string[]).includes(val)) {
+        throw new ConfigValidationError(`effort.${key} must be one of: ${VALID_EFFORTS.join(', ')}`);
+      }
+    }
+  }
+
+  // timeout
+  if (obj.timeout !== undefined) {
+    if (typeof obj.timeout !== 'number' || obj.timeout <= 0 || !Number.isFinite(obj.timeout)) {
+      throw new ConfigValidationError('timeout must be a positive number');
+    }
   }
+
+  // maxRetries
+  if (obj.maxRetries !== undefined) {
+    if (typeof obj.maxRetries !== 'number' || obj.maxRetries < 0 || !Number.isInteger(obj.maxRetries)) {
+      throw new ConfigValidationError('maxRetries must be a non-negative integer');
+    }
+  }
+
+  // autoCommit
+  if (obj.autoCommit !== undefined) {
+    if (typeof obj.autoCommit !== 'boolean') {
+      throw new ConfigValidationError('autoCommit must be a boolean');
+    }
+  }
+
+  // worktree
+  if (obj.worktree !== undefined) {
+    if (typeof obj.worktree !== 'boolean') {
+      throw new ConfigValidationError('worktree must be a boolean');
+    }
+  }
+
+  // commitFormat
+  if (obj.commitFormat !== undefined) {
+    if (typeof obj.commitFormat !== 'object' || obj.commitFormat === null || Array.isArray(obj.commitFormat)) {
+      throw new ConfigValidationError('commitFormat must be an object');
+    }
+    const cf = obj.commitFormat as Record<string, unknown>;
+    checkUnknownKeys(cf, VALID_COMMIT_FORMAT_KEYS, 'commitFormat');
+    for (const [key, val] of Object.entries(cf)) {
+      if (typeof val !== 'string') {
+        throw new ConfigValidationError(`commitFormat.${key} must be a string`);
+      }
+    }
+  }
+
+  // claudeCommand
+  if (obj.claudeCommand !== undefined) {
+    if (typeof obj.claudeCommand !== 'string' || obj.claudeCommand.trim() === '') {
+      throw new ConfigValidationError('claudeCommand must be a non-empty string');
+    }
+  }
+
+  // pricing
+  if (obj.pricing !== undefined) {
+    if (typeof obj.pricing !== 'object' || obj.pricing === null || Array.isArray(obj.pricing)) {
+      throw new ConfigValidationError('pricing must be an object');
+    }
+    const pricing = obj.pricing as Record<string, unknown>;
+    checkUnknownKeys(pricing, VALID_PRICING_CATEGORIES, 'pricing');
+    for (const [category, catVal] of Object.entries(pricing)) {
+      if (typeof catVal !== 'object' || catVal === null || Array.isArray(catVal)) {
+        throw new ConfigValidationError(`pricing.${category} must be an object`);
+      }
+      const fields = catVal as Record<string, unknown>;
+      checkUnknownKeys(fields, VALID_PRICING_FIELDS, `pricing.${category}`);
+      for (const [field, val] of Object.entries(fields)) {
+        if (typeof val !== 'number' || val < 0 || !Number.isFinite(val)) {
+          throw new ConfigValidationError(`pricing.${category}.${field} must be a non-negative number`);
+        }
+      }
+    }
+  }
+
+  return config as UserConfig;
+}
+
+// ---- Deep merge ----
+
+function deepMerge(defaults: RafConfig, overrides: UserConfig): RafConfig {
+  const result = { ...defaults };
+
+  if (overrides.models) {
+    result.models = { ...defaults.models, ...overrides.models };
+  }
+  if (overrides.effort) {
+    result.effort = { ...defaults.effort, ...overrides.effort };
+  }
+  if (overrides.commitFormat) {
+    result.commitFormat = { ...defaults.commitFormat, ...overrides.commitFormat };
+  }
+  if (overrides.pricing) {
+    result.pricing = {
+      opus: { ...defaults.pricing.opus, ...overrides.pricing.opus },
+      sonnet: { ...defaults.pricing.sonnet, ...overrides.pricing.sonnet },
+      haiku: { ...defaults.pricing.haiku, ...overrides.pricing.haiku },
+    };
+  }
+  if (overrides.timeout !== undefined) result.timeout = overrides.timeout;
+  if (overrides.maxRetries !== undefined) result.maxRetries = overrides.maxRetries;
+  if (overrides.autoCommit !== undefined) result.autoCommit = overrides.autoCommit;
+  if (overrides.worktree !== undefined) result.worktree = overrides.worktree;
+  if (overrides.claudeCommand !== undefined) result.claudeCommand = overrides.claudeCommand;
+
+  return result;
 }
 
-export function saveConfig(rafDir: string, config: RafConfig): void {
-  const configPath = path.join(rafDir, CONFIG_FILENAME);
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+// ---- Config loading ----
+
+/**
+ * Resolve the final config by loading from ~/.raf/raf.config.json and merging with defaults.
+ * Throws ConfigValidationError if the file contains invalid values.
+ */
+export function resolveConfig(configPath?: string): RafConfig {
+  const filePath = configPath ?? getConfigPath();
+
+  if (!fs.existsSync(filePath)) {
+    return { ...DEFAULT_CONFIG, models: { ...DEFAULT_CONFIG.models }, effort: { ...DEFAULT_CONFIG.effort }, commitFormat: { ...DEFAULT_CONFIG.commitFormat } };
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const parsed: unknown = JSON.parse(content);
+  const validated = validateConfig(parsed);
+  return deepMerge(DEFAULT_CONFIG, validated);
+}
+
+/**
+ * @deprecated Use resolveConfig() instead. Kept for backward compatibility.
+ */
+export function loadConfig(_rafDir: string): { defaultTimeout: number; defaultMaxRetries: number; autoCommit: boolean; claudeCommand: string } {
+  return { ...DEFAULT_RAF_CONFIG };
+}
+
+export function saveConfig(configPath: string, config: UserConfig): void {
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
+// ---- Helper accessors ----
+
+let _cachedConfig: RafConfig | null = null;
+
+/**
+ * Get the resolved config, caching the result for the process lifetime.
+ * Call resetConfigCache() in tests to clear.
+ */
+export function getResolvedConfig(): RafConfig {
+  if (!_cachedConfig) {
+    _cachedConfig = resolveConfig();
+  }
+  return _cachedConfig;
+}
+
+export function resetConfigCache(): void {
+  _cachedConfig = null;
+}
+
+export function getModel(scenario: ModelScenario): ClaudeModelName {
+  return getResolvedConfig().models[scenario];
+}
+
+export function getEffort(scenario: EffortScenario): EffortLevel {
+  return getResolvedConfig().effort[scenario];
+}
+
+export function getCommitFormat(type: CommitFormatType): string {
+  return getResolvedConfig().commitFormat[type];
+}
+
+export function getCommitPrefix(): string {
+  return getResolvedConfig().commitFormat.prefix;
+}
+
+export function getTimeout(): number {
+  return getResolvedConfig().timeout;
+}
+
+export function getMaxRetries(): number {
+  return getResolvedConfig().maxRetries;
+}
+
+export function getAutoCommit(): boolean {
+  return getResolvedConfig().autoCommit;
+}
+
+export function getWorktreeDefault(): boolean {
+  return getResolvedConfig().worktree;
+}
+
+export function getClaudeCommand(): string {
+  return getResolvedConfig().claudeCommand;
+}
+
+/**
+ * Map a full model ID (e.g., `claude-opus-4-6`) or short alias to a pricing category.
+ * Returns null if the model cannot be mapped.
+ */
+export function resolveModelPricingCategory(modelId: string): PricingCategory | null {
+  // Short aliases map directly
+  if (modelId === 'opus' || modelId === 'sonnet' || modelId === 'haiku') {
+    return modelId;
+  }
+  // Full model IDs: extract family from `claude-{family}-{version}`
+  const match = modelId.match(/^claude-([a-z]+)-/);
+  if (match) {
+    const family = match[1];
+    if (family === 'opus' || family === 'sonnet' || family === 'haiku') {
+      return family;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get pricing config for a specific model category.
+ */
+export function getPricing(category: PricingCategory): ModelPricing {
+  return getResolvedConfig().pricing[category];
+}
+
+/**
+ * Get the full pricing config.
+ */
+export function getPricingConfig(): PricingConfig {
+  return getResolvedConfig().pricing;
+}
+
+/**
+ * Render a commit message template by replacing {placeholder} tokens with values.
+ * Unknown placeholders are left as-is.
+ */
+export function renderCommitMessage(template: string, variables: Record<string, string>): string {
+  return template.replace(/\{(\w+)\}/g, (match, key: string) => {
+    return variables[key] ?? match;
+  });
 }
 
 export function getEditor(): string {
@@ -39,8 +355,6 @@ export function getEditor(): string {
 
 /**
  * Get the Claude model name from Claude CLI settings.
- * Returns the model name or null if not found.
- * @param settingsPath Optional path to settings file (for testing)
  */
 export function getClaudeModel(settingsPath?: string): string | null {
   const filePath = settingsPath ?? getClaudeSettingsPath();
@@ -57,13 +371,13 @@ export function getClaudeModel(settingsPath?: string): string | null {
 }
 
 /**
- * Get runtime configuration for task execution.
- * Returns default values which can be overridden by command line options.
+ * @deprecated Use getTimeout(), getMaxRetries(), getAutoCommit() instead.
  */
 export function getConfig(): { timeout: number; maxRetries: number; autoCommit: boolean } {
+  const config = getResolvedConfig();
   return {
-    timeout: DEFAULT_RAF_CONFIG.defaultTimeout,
-    maxRetries: DEFAULT_RAF_CONFIG.defaultMaxRetries,
-    autoCommit: DEFAULT_RAF_CONFIG.autoCommit,
+    timeout: config.timeout,
+    maxRetries: config.maxRetries,
+    autoCommit: config.autoCommit,
   };
 }

package/src/utils/name-generator.ts

@@ -1,8 +1,7 @@
-import { execSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { logger } from './logger.js';
 import { sanitizeProjectName } from './validation.js';
-
-const SONNET_MODEL = 'sonnet';
+import { getModel, getClaudeCommand } from './config.js';
 
 const NAME_GENERATION_PROMPT = `Generate a short, punchy, creative project name (1-3 words, kebab-case).
 
@@ -40,7 +39,60 @@ Output format: ONLY output 5 names, one per line, no numbers, no explanations, n
 Project description:`;
 
 /**
- * Generate a single project name using Claude Sonnet.
+ * Run Claude CLI with the given prompt and return stdout.
+ * Uses spawn with --no-session-persistence to avoid cluttering session history.
+ */
+function runClaudePrint(prompt: string): Promise<string | null> {
+  return new Promise((resolve) => {
+    const model = getModel('nameGeneration');
+    const cmd = getClaudeCommand();
+
+    const proc = spawn(cmd, [
+      '--model', model,
+      '--no-session-persistence',
+      '-p',
+      prompt,
+    ], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    const timeoutHandle = setTimeout(() => {
+      proc.kill('SIGTERM');
+    }, 30000);
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (exitCode) => {
+      clearTimeout(timeoutHandle);
+      if (exitCode !== 0) {
+        if (stderr) {
+          logger.debug(`Claude CLI stderr: ${stderr}`);
+        }
+        resolve(null);
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+
+    proc.on('error', (error) => {
+      clearTimeout(timeoutHandle);
+      logger.debug(`Claude CLI spawn error: ${error}`);
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * Generate a single project name using Claude.
  * Falls back to extracting words from the description if the API call fails.
  */
 export async function generateProjectName(description: string): Promise<string> {
@@ -54,7 +106,7 @@ export async function generateProjectName(description: string): Promise<string>
       }
     }
   } catch (error) {
-    logger.debug(`Failed to generate name with Sonnet: ${error}`);
+    logger.debug(`Failed to generate name with Claude: ${error}`);
   }
 
   // Fallback to extracting words from description
@@ -62,7 +114,7 @@ export async function generateProjectName(description: string): Promise<string>
 }
 
 /**
- * Generate multiple project name suggestions using Claude Sonnet.
+ * Generate multiple project name suggestions using Claude.
  * Returns 3-5 unique names with varied styles.
  */
 export async function generateProjectNames(description: string): Promise<string[]> {
@@ -73,7 +125,7 @@ export async function generateProjectNames(description: string): Promise<string[
       return names;
     }
   } catch (error) {
-    logger.debug(`Failed to generate names with Sonnet: ${error}`);
+    logger.debug(`Failed to generate names with Claude: ${error}`);
   }
 
   // Fallback: generate a single fallback name
@@ -83,80 +135,41 @@ export async function generateProjectNames(description: string): Promise<string[
 }
 
 /**
- * Call Claude Sonnet to generate a single project name.
+ * Call Claude to generate a single project name.
  */
 async function callSonnetForName(description: string): Promise<string | null> {
-  try {
-    const fullPrompt = `${NAME_GENERATION_PROMPT}\n${description}`;
-
-    // Use claude CLI with --model sonnet and --print for non-interactive output
-    const result = execSync(
-      `claude --model ${SONNET_MODEL} --print "${escapeShellArg(fullPrompt)}"`,
-      {
-        encoding: 'utf-8',
-        timeout: 30000, // 30 second timeout
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }
-    );
-
-    return result.trim();
-  } catch (error) {
-    logger.debug(`Sonnet API call failed: ${error}`);
-    return null;
-  }
+  const fullPrompt = `${NAME_GENERATION_PROMPT}\n${description}`;
+  return runClaudePrint(fullPrompt);
 }
 
 /**
- * Call Claude Sonnet to generate multiple project names.
+ * Call Claude to generate multiple project names.
  */
 async function callSonnetForMultipleNames(description: string): Promise<string[]> {
-  try {
-    const fullPrompt = `${MULTI_NAME_GENERATION_PROMPT}\n${description}`;
-
-    const result = execSync(
-      `claude --model ${SONNET_MODEL} --print "${escapeShellArg(fullPrompt)}"`,
-      {
-        encoding: 'utf-8',
-        timeout: 30000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }
-    );
-
-    // Parse the multiline response
-    const lines = result
-      .trim()
-      .split('\n')
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0);
-
-    // Sanitize and validate each name
-    const validNames: string[] = [];
-    for (const line of lines) {
-      const sanitized = sanitizeGeneratedName(line);
-      if (sanitized && !validNames.includes(sanitized)) {
-        validNames.push(sanitized);
-      }
-    }
+  const fullPrompt = `${MULTI_NAME_GENERATION_PROMPT}\n${description}`;
+  const result = await runClaudePrint(fullPrompt);
 
-    // Return 3-5 names
-    return validNames.slice(0, 5);
-  } catch (error) {
-    logger.debug(`Sonnet API call for multiple names failed: ${error}`);
+  if (!result) {
     return [];
   }
-}
 
-/**
- * Escape a string for use as a shell argument.
- */
-function escapeShellArg(arg: string): string {
-  // Replace double quotes with escaped double quotes
-  // Replace backslashes with escaped backslashes
-  return arg
-    .replace(/\\/g, '\\\\')
-    .replace(/"/g, '\\"')
-    .replace(/\$/g, '\\$')
-    .replace(/`/g, '\\`');
+  // Parse the multiline response
+  const lines = result
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+
+  // Sanitize and validate each name
+  const validNames: string[] = [];
+  for (const line of lines) {
+    const sanitized = sanitizeGeneratedName(line);
+    if (sanitized && !validNames.includes(sanitized)) {
+      validNames.push(sanitized);
+    }
+  }
+
+  // Return 3-5 names
+  return validNames.slice(0, 5);
 }
 
 /**
@@ -208,4 +221,4 @@ function generateFallbackName(description: string): string {
 }
 
 // Export for testing
-export { sanitizeGeneratedName, escapeShellArg };
+export { sanitizeGeneratedName };

package/src/utils/terminal-symbols.ts

@@ -4,6 +4,8 @@
  */
 
 import { formatElapsedTime } from './timer.js';
+import type { UsageData } from '../types/config.js';
+import type { CostBreakdown } from './token-tracker.js';
 
 /**
  * Visual symbols for terminal output using dots/symbols style.
@@ -125,3 +127,69 @@ export function formatProgressBar(tasks: TaskStatus[]): string {
 
   return tasks.map((status) => SYMBOLS[status]).join('');
 }
+
+/**
+ * Formats a number with thousands separators (e.g., 12345 -> "12,345").
+ */
+export function formatNumber(n: number): string {
+  return n.toLocaleString('en-US');
+}
+
+/**
+ * Formats a cost in USD with 2-4 decimal places.
+ * Uses 2 decimals for values >= $0.01, 4 decimals for smaller values.
+ */
+export function formatCost(cost: number): string {
+  if (cost === 0) return '$0.00';
+  if (cost < 0.01) return `$${cost.toFixed(4)}`;
+  return `$${cost.toFixed(2)}`;
+}
+
+/**
+ * Formats a per-task token usage summary line.
+ * Example: "  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read | Est. cost: $0.42"
+ */
+export function formatTaskTokenSummary(usage: UsageData, cost: CostBreakdown): string {
+  const parts: string[] = [];
+  parts.push(`Tokens: ${formatNumber(usage.inputTokens)} in / ${formatNumber(usage.outputTokens)} out`);
+
+  const cacheTotal = usage.cacheReadInputTokens + usage.cacheCreationInputTokens;
+  if (cacheTotal > 0) {
+    if (usage.cacheReadInputTokens > 0 && usage.cacheCreationInputTokens > 0) {
+      parts.push(`Cache: ${formatNumber(usage.cacheReadInputTokens)} read / ${formatNumber(usage.cacheCreationInputTokens)} created`);
+    } else if (usage.cacheReadInputTokens > 0) {
+      parts.push(`Cache: ${formatNumber(usage.cacheReadInputTokens)} read`);
+    } else {
+      parts.push(`Cache: ${formatNumber(usage.cacheCreationInputTokens)} created`);
+    }
+  }
+
+  parts.push(`Est. cost: ${formatCost(cost.totalCost)}`);
+  return `  ${parts.join(' | ')}`;
+}
+
+/**
+ * Formats the grand total token usage summary block.
+ * Displayed after all tasks complete.
+ */
+export function formatTokenTotalSummary(usage: UsageData, cost: CostBreakdown): string {
+  const lines: string[] = [];
+  const divider = '── Token Usage Summary ──────────────────';
+  lines.push(divider);
+  lines.push(`Total tokens: ${formatNumber(usage.inputTokens)} in / ${formatNumber(usage.outputTokens)} out`);
+
+  if (usage.cacheReadInputTokens > 0 || usage.cacheCreationInputTokens > 0) {
+    const cacheParts: string[] = [];
+    if (usage.cacheReadInputTokens > 0) {
+      cacheParts.push(`${formatNumber(usage.cacheReadInputTokens)} read`);
+    }
+    if (usage.cacheCreationInputTokens > 0) {
+      cacheParts.push(`${formatNumber(usage.cacheCreationInputTokens)} created`);
+    }
+    lines.push(`Cache: ${cacheParts.join(' / ')}`);
+  }
+
+  lines.push(`Estimated cost: ${formatCost(cost.totalCost)}`);
+  lines.push('─────────────────────────────────────────');
+  return lines.join('\n');
+}