rafcode 2.1.0 → 2.2.0

package/src/utils/token-tracker.ts

@@ -0,0 +1,135 @@
+import { UsageData, PricingConfig } from '../types/config.js';
+import { resolveModelPricingCategory, getPricingConfig } from './config.js';
+
+/** Cost breakdown for a single task or accumulated total. */
+export interface CostBreakdown {
+  inputCost: number;
+  outputCost: number;
+  cacheReadCost: number;
+  cacheCreateCost: number;
+  totalCost: number;
+}
+
+/** Per-task usage snapshot stored by the tracker. */
+export interface TaskUsageEntry {
+  taskId: string;
+  usage: UsageData;
+  cost: CostBreakdown;
+}
+
+/**
+ * Accumulates token usage across multiple task executions and calculates costs
+ * using configurable per-model pricing.
+ */
+export class TokenTracker {
+  private entries: TaskUsageEntry[] = [];
+  private pricingConfig: PricingConfig;
+
+  constructor(pricingConfig?: PricingConfig) {
+    this.pricingConfig = pricingConfig ?? getPricingConfig();
+  }
+
+  /**
+   * Record usage data from a completed task.
+   */
+  addTask(taskId: string, usage: UsageData): TaskUsageEntry {
+    const cost = this.calculateCost(usage);
+    const entry: TaskUsageEntry = { taskId, usage, cost };
+    this.entries.push(entry);
+    return entry;
+  }
+
+  /**
+   * Get all recorded task entries.
+   */
+  getEntries(): readonly TaskUsageEntry[] {
+    return this.entries;
+  }
+
+  /**
+   * Get accumulated totals across all tasks.
+   */
+  getTotals(): { usage: UsageData; cost: CostBreakdown } {
+    const totalUsage: UsageData = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      modelUsage: {},
+    };
+    const totalCost: CostBreakdown = {
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: 0,
+    };
+
+    for (const entry of this.entries) {
+      totalUsage.inputTokens += entry.usage.inputTokens;
+      totalUsage.outputTokens += entry.usage.outputTokens;
+      totalUsage.cacheReadInputTokens += entry.usage.cacheReadInputTokens;
+      totalUsage.cacheCreationInputTokens += entry.usage.cacheCreationInputTokens;
+
+      // Merge per-model usage
+      for (const [modelId, modelUsage] of Object.entries(entry.usage.modelUsage)) {
+        const existing = totalUsage.modelUsage[modelId];
+        if (existing) {
+          existing.inputTokens += modelUsage.inputTokens;
+          existing.outputTokens += modelUsage.outputTokens;
+          existing.cacheReadInputTokens += modelUsage.cacheReadInputTokens;
+          existing.cacheCreationInputTokens += modelUsage.cacheCreationInputTokens;
+        } else {
+          totalUsage.modelUsage[modelId] = { ...modelUsage };
+        }
+      }
+
+      totalCost.inputCost += entry.cost.inputCost;
+      totalCost.outputCost += entry.cost.outputCost;
+      totalCost.cacheReadCost += entry.cost.cacheReadCost;
+      totalCost.cacheCreateCost += entry.cost.cacheCreateCost;
+      totalCost.totalCost += entry.cost.totalCost;
+    }
+
+    return { usage: totalUsage, cost: totalCost };
+  }
+
+  /**
+   * Calculate cost for a given UsageData using per-model pricing.
+   * Uses per-model breakdown when available, falls back to aggregate with sonnet pricing.
+   */
+  calculateCost(usage: UsageData): CostBreakdown {
+    const result: CostBreakdown = {
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: 0,
+    };
+
+    const modelEntries = Object.entries(usage.modelUsage);
+
+    if (modelEntries.length > 0) {
+      // Use per-model breakdown for accurate pricing
+      for (const [modelId, modelUsage] of modelEntries) {
+        const category = resolveModelPricingCategory(modelId);
+        const pricing = this.pricingConfig[category ?? 'sonnet'];
+
+        result.inputCost += (modelUsage.inputTokens / 1_000_000) * pricing.inputPerMTok;
+        result.outputCost += (modelUsage.outputTokens / 1_000_000) * pricing.outputPerMTok;
+        result.cacheReadCost += (modelUsage.cacheReadInputTokens / 1_000_000) * pricing.cacheReadPerMTok;
+        result.cacheCreateCost += (modelUsage.cacheCreationInputTokens / 1_000_000) * pricing.cacheCreatePerMTok;
+      }
+    } else {
+      // Fallback: use aggregate totals with sonnet pricing
+      const pricing = this.pricingConfig.sonnet;
+      result.inputCost = (usage.inputTokens / 1_000_000) * pricing.inputPerMTok;
+      result.outputCost = (usage.outputTokens / 1_000_000) * pricing.outputPerMTok;
+      result.cacheReadCost = (usage.cacheReadInputTokens / 1_000_000) * pricing.cacheReadPerMTok;
+      result.cacheCreateCost = (usage.cacheCreationInputTokens / 1_000_000) * pricing.cacheCreatePerMTok;
+    }
+
+    result.totalCost = result.inputCost + result.outputCost + result.cacheReadCost + result.cacheCreateCost;
+    return result;
+  }
+}

package/src/utils/validation.ts

@@ -2,6 +2,9 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execSync } from 'node:child_process';
 import { logger } from './logger.js';
+import type { ClaudeModelName, ModelScenario } from '../types/config.js';
+import { VALID_MODEL_ALIASES, FULL_MODEL_ID_PATTERN } from '../types/config.js';
+import { getModel } from './config.js';
 
 export interface ValidationResult {
   valid: boolean;
@@ -88,19 +91,21 @@ export function reportValidation(result: ValidationResult): void {
   }
 }
 
-const VALID_MODELS = ['sonnet', 'haiku', 'opus'] as const;
+/** @deprecated Use ClaudeModelName from types/config.js instead */
+export type ValidModelName = ClaudeModelName;
 
-export type ValidModelName = (typeof VALID_MODELS)[number];
-
-export function validateModelName(model: string): ValidModelName | null {
+export function validateModelName(model: string): ClaudeModelName | null {
   const normalized = model.toLowerCase();
-  if (VALID_MODELS.includes(normalized as ValidModelName)) {
-    return normalized as ValidModelName;
+  if ((VALID_MODEL_ALIASES as readonly string[]).includes(normalized)) {
+    return normalized as ClaudeModelName;
+  }
+  if (FULL_MODEL_ID_PATTERN.test(normalized)) {
+    return normalized as ClaudeModelName;
   }
   return null;
 }
 
-export function resolveModelOption(model?: string, sonnet?: boolean): ValidModelName {
+export function resolveModelOption(model?: string, sonnet?: boolean, scenario: ModelScenario = 'execute'): ClaudeModelName {
   // Check for conflicting flags
   if (model && sonnet) {
     throw new Error('Cannot specify both --model and --sonnet flags');
@@ -115,11 +120,11 @@ export function resolveModelOption(model?: string, sonnet?: boolean): ValidModel
   if (model) {
     const validated = validateModelName(model);
     if (!validated) {
-      throw new Error(`Invalid model name: "${model}". Valid options: ${VALID_MODELS.join(', ')}`);
+      throw new Error(`Invalid model name: "${model}". Valid options: ${VALID_MODEL_ALIASES.join(', ')} or a full model ID (e.g., claude-sonnet-4-5-20250929)`);
     }
     return validated;
   }
 
-  // Default to opus
-  return 'opus';
+  // Default from config
+  return getModel(scenario);
 }

package/src/utils/verbose-toggle.ts

@@ -0,0 +1,103 @@
+/**
+ * Runtime verbose toggle for task execution.
+ *
+ * Listens for Tab keypress on process.stdin to toggle verbose display on/off.
+ * When verbose is on, tool-use activity lines from stream-json are displayed.
+ * When verbose is off, they are suppressed (but data is still captured).
+ *
+ * Requires a TTY stdin. Silently skips setup when stdin is not a TTY (e.g., piped input).
+ */
+
+import { logger } from './logger.js';
+
+export class VerboseToggle {
+  private _verbose: boolean;
+  private _active = false;
+  private _dataHandler: ((data: Buffer) => void) | null = null;
+
+  constructor(initialVerbose: boolean) {
+    this._verbose = initialVerbose;
+  }
+
+  /** Current verbose display state. */
+  get isVerbose(): boolean {
+    return this._verbose;
+  }
+
+  /** Whether the toggle listener is currently active. */
+  get isActive(): boolean {
+    return this._active;
+  }
+
+  /**
+   * Start listening for Tab keypress on stdin.
+   * Sets stdin to raw mode to capture individual keypresses.
+   * Shows a hint message about the toggle.
+   *
+   * No-op if stdin is not a TTY or if already active.
+   */
+  start(): void {
+    if (this._active) return;
+    if (!process.stdin.isTTY) return;
+
+    try {
+      process.stdin.setRawMode(true);
+    } catch {
+      // Cannot set raw mode — skip
+      return;
+    }
+
+    process.stdin.resume();
+
+    this._dataHandler = (data: Buffer) => {
+      for (let i = 0; i < data.length; i++) {
+        const byte = data[i];
+
+        if (byte === 0x09) {
+          // Tab key
+          this._verbose = !this._verbose;
+          const state = this._verbose ? 'on' : 'off';
+          logger.dim(`  [verbose: ${state}]`);
+        } else if (byte === 0x03) {
+          // Ctrl+C — re-emit SIGINT so the shutdown handler catches it
+          process.emit('SIGINT');
+        }
+      }
+    };
+
+    process.stdin.on('data', this._dataHandler);
+    this._active = true;
+
+    // Show toggle hint
+    logger.dim('  Press Tab to toggle verbose mode');
+  }
+
+  /**
+   * Stop listening and restore stdin to normal mode.
+   * Safe to call multiple times.
+   */
+  stop(): void {
+    if (!this._active) return;
+
+    if (this._dataHandler) {
+      process.stdin.off('data', this._dataHandler);
+      this._dataHandler = null;
+    }
+
+    try {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+    } catch {
+      // Ignore — stdin may already be closed
+    }
+
+    try {
+      process.stdin.pause();
+    } catch {
+      // Ignore
+    }
+
+    this._active = false;
+  }
+}