rafcode 2.4.0 → 2.5.0-0

package/src/types/config.ts

@@ -39,38 +39,12 @@ export interface CommitFormatConfig {
   prefix: string;
 }
 
-/** Pricing category derived from model family name. */
-export type PricingCategory = 'opus' | 'sonnet' | 'haiku';
-
-/** Per-direction pricing for a single model category, in dollars per million tokens. */
-export interface ModelPricing {
-  inputPerMTok: number;
-  outputPerMTok: number;
-  cacheReadPerMTok: number;
-  cacheCreatePerMTok: number;
-}
-
-/** Pricing config: per-category pricing in dollars per million tokens. */
-export interface PricingConfig {
-  opus: ModelPricing;
-  sonnet: ModelPricing;
-  haiku: ModelPricing;
-}
-
 /** Display options for token usage summaries. */
 export interface DisplayConfig {
-  /** Show estimated 5h rate limit window percentage. Default: true */
-  showRateLimitEstimate: boolean;
   /** Show cache token counts in summaries. Default: true */
   showCacheTokens: boolean;
 }
 
-/** Rate limit window configuration. */
-export interface RateLimitWindowConfig {
-  /** Sonnet-equivalent token cap for the 5h window. Default: 88000 */
-  sonnetTokenCap: number;
-}
-
 export interface RafConfig {
   models: ModelsConfig;
   /** Maps task complexity labels (low/medium/high) to models. Used for per-task effort frontmatter. */
@@ -82,9 +56,7 @@ export interface RafConfig {
   /** Sync main branch with remote before worktree/PR operations. Default: true */
   syncMainBranch: boolean;
   commitFormat: CommitFormatConfig;
-  pricing: PricingConfig;
   display: DisplayConfig;
-  rateLimitWindow: RateLimitWindowConfig;
 }
 
 export const DEFAULT_CONFIG: RafConfig = {
@@ -112,33 +84,9 @@ export const DEFAULT_CONFIG: RafConfig = {
     amend: '{prefix}[{projectId}] Amend: {projectName}',
     prefix: 'RAF',
   },
-  pricing: {
-    opus: {
-      inputPerMTok: 15,
-      outputPerMTok: 75,
-      cacheReadPerMTok: 1.5,
-      cacheCreatePerMTok: 18.75,
-    },
-    sonnet: {
-      inputPerMTok: 3,
-      outputPerMTok: 15,
-      cacheReadPerMTok: 0.3,
-      cacheCreatePerMTok: 3.75,
-    },
-    haiku: {
-      inputPerMTok: 1,
-      outputPerMTok: 5,
-      cacheReadPerMTok: 0.1,
-      cacheCreatePerMTok: 1.25,
-    },
-  },
   display: {
-    showRateLimitEstimate: true,
     showCacheTokens: true,
   },
-  rateLimitWindow: {
-    sonnetTokenCap: 88000,
-  },
 };
 
 /** Deep partial type for user config files — all fields optional at every level */
@@ -201,6 +149,8 @@ export interface ModelTokenUsage {
   outputTokens: number;
   cacheReadInputTokens: number;
   cacheCreationInputTokens: number;
+  /** Cost in USD for this model's usage (provided by Claude CLI). */
+  costUsd: number;
 }
 
 /** Token usage data extracted from Claude CLI stream-json result event. */
@@ -212,4 +162,6 @@ export interface UsageData {
   cacheCreationInputTokens: number;
   /** Per-model breakdown (e.g., { "claude-opus-4-6": { ... } }). */
   modelUsage: Record<string, ModelTokenUsage>;
+  /** Total cost in USD for this usage (provided by Claude CLI). */
+  totalCostUsd: number;
 }

package/src/utils/config.ts

@@ -12,11 +12,7 @@ import {
   TaskEffortLevel,
   ModelScenario,
   CommitFormatType,
-  PricingCategory,
-  ModelPricing,
-  PricingConfig,
   DisplayConfig,
-  RateLimitWindowConfig,
   EffortMappingConfig,
 } from '../types/config.js';
 
@@ -38,12 +34,9 @@ export function getClaudeSettingsPath(): string {
 
 const VALID_TOP_LEVEL_KEYS = new Set<string>([
   'models', 'effortMapping', 'timeout', 'maxRetries', 'autoCommit',
-  'worktree', 'syncMainBranch', 'commitFormat', 'pricing', 'display', 'rateLimitWindow',
+  'worktree', 'syncMainBranch', 'commitFormat', 'display',
 ]);
 
-const VALID_PRICING_CATEGORIES = new Set<string>(['opus', 'sonnet', 'haiku']);
-const VALID_PRICING_FIELDS = new Set<string>(['inputPerMTok', 'outputPerMTok', 'cacheReadPerMTok', 'cacheCreatePerMTok']);
-
 const VALID_MODEL_KEYS = new Set<string>([
   'plan', 'execute', 'nameGeneration', 'failureAnalysis', 'prGeneration', 'config',
 ]);
@@ -52,9 +45,7 @@ const VALID_EFFORT_MAPPING_KEYS = new Set<string>(['low', 'medium', 'high']);
 
 const VALID_COMMIT_FORMAT_KEYS = new Set<string>(['task', 'plan', 'amend', 'prefix']);
 
-const VALID_DISPLAY_KEYS = new Set<string>(['showRateLimitEstimate', 'showCacheTokens']);
-
-const VALID_RATE_LIMIT_WINDOW_KEYS = new Set<string>(['sonnetTokenCap']);
+const VALID_DISPLAY_KEYS = new Set<string>(['showCacheTokens']);
 
 export class ConfigValidationError extends Error {
   constructor(message: string) {
@@ -167,27 +158,6 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
-  // 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`);
-        }
-      }
-    }
-  }
-
   // display
   if (obj.display !== undefined) {
     if (typeof obj.display !== 'object' || obj.display === null || Array.isArray(obj.display)) {
@@ -202,20 +172,6 @@ export function validateConfig(config: unknown): UserConfig {
     }
   }
 
-  // rateLimitWindow
-  if (obj.rateLimitWindow !== undefined) {
-    if (typeof obj.rateLimitWindow !== 'object' || obj.rateLimitWindow === null || Array.isArray(obj.rateLimitWindow)) {
-      throw new ConfigValidationError('rateLimitWindow must be an object');
-    }
-    const rlw = obj.rateLimitWindow as Record<string, unknown>;
-    checkUnknownKeys(rlw, VALID_RATE_LIMIT_WINDOW_KEYS, 'rateLimitWindow');
-    if (rlw.sonnetTokenCap !== undefined) {
-      if (typeof rlw.sonnetTokenCap !== 'number' || rlw.sonnetTokenCap <= 0 || !Number.isFinite(rlw.sonnetTokenCap)) {
-        throw new ConfigValidationError('rateLimitWindow.sonnetTokenCap must be a positive number');
-      }
-    }
-  }
-
   return config as UserConfig;
 }
 
@@ -233,19 +189,9 @@ function deepMerge(defaults: RafConfig, overrides: UserConfig): RafConfig {
   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.display) {
     result.display = { ...defaults.display, ...overrides.display };
   }
-  if (overrides.rateLimitWindow) {
-    result.rateLimitWindow = { ...defaults.rateLimitWindow, ...overrides.rateLimitWindow };
-  }
   if (overrides.timeout !== undefined) result.timeout = overrides.timeout;
   if (overrides.maxRetries !== undefined) result.maxRetries = overrides.maxRetries;
   if (overrides.autoCommit !== undefined) result.autoCommit = overrides.autoCommit;
@@ -271,7 +217,6 @@ export function resolveConfig(configPath?: string): RafConfig {
       effortMapping: { ...DEFAULT_CONFIG.effortMapping },
       commitFormat: { ...DEFAULT_CONFIG.commitFormat },
       display: { ...DEFAULT_CONFIG.display },
-      rateLimitWindow: { ...DEFAULT_CONFIG.rateLimitWindow },
     };
   }
 
@@ -459,40 +404,6 @@ export function resolveFullModelId(modelName: string): string {
   return modelName;
 }
 
-/**
- * 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;
-}
-
 /**
  * Get the full display config.
  */
@@ -500,20 +411,6 @@ export function getDisplayConfig(): DisplayConfig {
   return getResolvedConfig().display;
 }
 
-/**
- * Get the full rate limit window config.
- */
-export function getRateLimitWindowConfig(): RateLimitWindowConfig {
-  return getResolvedConfig().rateLimitWindow;
-}
-
-/**
- * Get whether to show rate limit estimate in token summaries.
- */
-export function getShowRateLimitEstimate(): boolean {
-  return getResolvedConfig().display.showRateLimitEstimate;
-}
-
 /**
  * Get whether to show cache tokens in summaries.
  */
@@ -521,13 +418,6 @@ export function getShowCacheTokens(): boolean {
   return getResolvedConfig().display.showCacheTokens;
 }
 
-/**
- * Get the Sonnet-equivalent token cap for the 5h rate limit window.
- */
-export function getSonnetTokenCap(): number {
-  return getResolvedConfig().rateLimitWindow.sonnetTokenCap;
-}
-
 /**
  * Render a commit message template by replacing {placeholder} tokens with values.
  * Unknown placeholders are left as-is.

package/src/utils/frontmatter.ts

@@ -26,10 +26,20 @@ export interface FrontmatterParseResult {
 /**
  * Parse Obsidian-style frontmatter from plan file content.
  *
- * Format: `key: value` lines at the top of the file, terminated by a `---` line.
- * There is NO opening `---` delimiter — just properties followed by `---`.
+ * Supports two formats:
+ * 1. Standard format (preferred): `---` delimiter at the top and bottom
+ * 2. Legacy format (backward compatibility): properties followed by closing `---` only
  *
- * Example:
+ * Standard format example:
+ * ```
+ * ---
+ * effort: medium
+ * model: sonnet
+ * ---
+ * # Task: ...
+ * ```
+ *
+ * Legacy format example:
  * ```
  * effort: medium
  * model: sonnet
@@ -50,15 +60,35 @@ export function parsePlanFrontmatter(content: string): FrontmatterParseResult {
     warnings: [],
   };
 
-  // Find the closing `---` delimiter
-  const delimiterIndex = content.indexOf('---');
-  if (delimiterIndex === -1) {
-    // No delimiter found - no frontmatter
-    return result;
-  }
+  const trimmedContent = content.trimStart();
 
-  // Extract the frontmatter section (everything before the delimiter)
-  const frontmatterSection = content.substring(0, delimiterIndex);
+  let frontmatterSection: string;
+
+  if (trimmedContent.startsWith('---')) {
+    // Standard format: ---\nkey: value\n---
+    const afterOpener = trimmedContent.substring(3);
+    // Skip the rest of the opener line (handles "---\n" or "--- \n")
+    const openerEnd = afterOpener.indexOf('\n');
+    if (openerEnd === -1) {
+      // No newline after opening delimiter - no valid frontmatter
+      return result;
+    }
+    const rest = afterOpener.substring(openerEnd + 1);
+    const closerIndex = rest.indexOf('---');
+    if (closerIndex === -1) {
+      // No closing delimiter - no valid frontmatter
+      return result;
+    }
+    frontmatterSection = rest.substring(0, closerIndex);
+  } else {
+    // Legacy format: key: value\n---
+    const delimiterIndex = content.indexOf('---');
+    if (delimiterIndex === -1) {
+      // No delimiter found - no frontmatter
+      return result;
+    }
+    frontmatterSection = content.substring(0, delimiterIndex);
+  }
 
   // Parse key: value lines
   const lines = frontmatterSection.split('\n');

package/src/utils/name-generator.ts

@@ -3,7 +3,9 @@ import { logger } from './logger.js';
 import { sanitizeProjectName } from './validation.js';
 import { getModel } from './config.js';
 
-const NAME_GENERATION_PROMPT = `Generate a short, punchy, creative project name (1-3 words, kebab-case).
+const NAME_GENERATION_PROMPT = `Output ONLY the kebab-case name. No introduction, no explanation, no quotes.
+
+Generate a short, punchy, creative project name (1-3 words, kebab-case).
 
 Be creative! Use metaphors, analogies, or evocative words that capture the SPIRIT of the project.
 Don't literally describe what it does - make it memorable and fun.
@@ -15,26 +17,15 @@ Good examples:
 - Refactoring → 'spring-cleaning', 'phoenix', 'makeover'
 - New feature → 'moonshot', 'secret-sauce', 'magic-wand'
 
-Output ONLY the kebab-case name. No quotes, no explanation.
-
 Project description:`;
 
-const MULTI_NAME_GENERATION_PROMPT = `Generate 5 creative project names for the description below.
-
-IMPORTANT: Each name should use a DIFFERENT naming style:
-1. **Metaphorical** - Use a metaphor or analogy (e.g., 'phoenix', 'lighthouse', 'compass')
-2. **Fun/Playful** - Make it fun or quirky (e.g., 'turbo-boost', 'magic-beans', 'ninja-move')
-3. **Action-oriented** - Focus on what it does with flair (e.g., 'bug-squasher', 'speed-demon', 'data-whisperer')
-4. **Abstract** - Use abstract/poetic concepts (e.g., 'horizon', 'cascade', 'catalyst')
-5. **Cultural reference** - Reference pop culture, mythology, or literature (e.g., 'atlas', 'merlin', 'gandalf')
+const MULTI_NAME_GENERATION_PROMPT = `Output EXACTLY 5 project names, one per line. Do NOT include any introduction, explanation, preamble, numbering, or quotes.
 
 Rules:
-- Each name should be 1-3 words in kebab-case
-- Names must be lowercase with hyphens only
+- Each name: 1-3 words, kebab-case, lowercase with hyphens only
+- Use varied styles: metaphorical, playful, action-oriented, abstract, cultural reference
 - Make them memorable and evocative
-- If the project has many unrelated tasks, prefer abstract/metaphorical/fun names over descriptive ones
-
-Output format: ONLY output 5 names, one per line, no numbers, no explanations, no quotes.
+- For projects with many unrelated tasks, prefer abstract/metaphorical names
 
 Project description:`;
 

package/src/utils/terminal-symbols.ts

@@ -11,10 +11,6 @@ import type { CostBreakdown, TaskUsageEntry } from './token-tracker.js';
 export interface TokenSummaryOptions {
   /** Whether to show cache token counts. Default: true */
   showCacheTokens?: boolean;
-  /** Whether to show rate limit percentage. Default: true */
-  showRateLimitEstimate?: boolean;
-  /** Rate limit percentage to display (requires showRateLimitEstimate: true) */
-  rateLimitPercentage?: number;
 }
 
 /**
@@ -49,7 +45,8 @@ function truncate(str: string, maxLength: number): string {
  * @param name - Task name
  * @param elapsedMs - Optional elapsed time in milliseconds
  * @param taskId - Optional task ID prefix display
- * @returns Formatted string like "● 001-auth-login 1:23" or "✓ 001-auth-login 1/5"
+ * @param model - Optional model short name to display (e.g., "sonnet", "opus", "haiku")
+ * @returns Formatted string like "● 001-auth-login (sonnet) 1:23" or "✓ 001-auth-login (opus) 1/5"
  */
 export function formatTaskProgress(
   current: number,
@@ -57,19 +54,21 @@ export function formatTaskProgress(
   status: TaskStatus,
   name: string,
   elapsedMs?: number,
-  taskId?: string
+  taskId?: string,
+  model?: string
 ): string {
   const symbol = SYMBOLS[status];
   const displayName = truncate(name || 'task', 40);
   const idPrefix = taskId ? `${taskId}-` : '';
+  const modelSuffix = model ? ` (${model})` : '';
 
   // Show elapsed time for running tasks, completed tasks, and failed tasks
   if (elapsedMs !== undefined) {
     const timeStr = formatElapsedTime(elapsedMs);
-    return `${symbol} ${idPrefix}${displayName} ${timeStr}`;
+    return `${symbol} ${idPrefix}${displayName}${modelSuffix} ${timeStr}`;
   }
 
-  return `${symbol} ${idPrefix}${displayName} ${current}/${total}`;
+  return `${symbol} ${idPrefix}${displayName}${modelSuffix} ${current}/${total}`;
 }
 
 /**
@@ -155,17 +154,6 @@ export function formatCost(cost: number): string {
   return `$${cost.toFixed(2)}`;
 }
 
-/**
- * Formats a rate limit percentage for display.
- * Uses tilde (~) prefix to indicate estimate.
- */
-export function formatRateLimitPercentage(percentage: number): string {
-  if (percentage === 0) return '~0% of 5h window';
-  if (percentage < 0.1) return `~${percentage.toFixed(2)}% of 5h window`;
-  if (percentage < 1) return `~${percentage.toFixed(1)}% of 5h window`;
-  return `~${Math.round(percentage)}% of 5h window`;
-}
-
 /**
  * Formats a single line of token usage (for a single attempt or total).
  * Used internally by formatTaskTokenSummary.
@@ -177,7 +165,7 @@ function formatTokenLine(
   indent: string = '  ',
   options: TokenSummaryOptions = {}
 ): string {
-  const { showCacheTokens = true, showRateLimitEstimate = false, rateLimitPercentage } = options;
+  const { showCacheTokens = true } = options;
   const parts: string[] = [];
   const tokenPart = `${formatNumber(usage.inputTokens)} in / ${formatNumber(usage.outputTokens)} out`;
   parts.push(prefix ? `${prefix}: ${tokenPart}` : `Tokens: ${tokenPart}`);
@@ -195,27 +183,21 @@ function formatTokenLine(
     }
   }
 
-  parts.push(`Est. cost: ${formatCost(costValue)}`);
-
-  if (showRateLimitEstimate && rateLimitPercentage !== undefined) {
-    parts.push(formatRateLimitPercentage(rateLimitPercentage));
-  }
+  parts.push(`Cost: ${formatCost(costValue)}`);
 
   return `${indent}${parts.join(' | ')}`;
 }
 
 /**
  * Formats a per-task token usage summary.
- * For single-attempt tasks: "  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read | Est. cost: $0.42 | ~2% of 5h window"
+ * For single-attempt tasks: "  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read | Cost: $0.42"
  * For multi-attempt tasks: shows per-attempt breakdown plus total.
  *
  * @param entry - The TaskUsageEntry containing accumulated usage, cost, and attempts array
- * @param calculateAttemptCost - Optional function to calculate cost for a single attempt's UsageData
- * @param options - Display options for showing cache tokens and rate limit percentage
+ * @param options - Display options for showing cache tokens
  */
 export function formatTaskTokenSummary(
   entry: TaskUsageEntry,
-  calculateAttemptCost?: (usage: UsageData) => CostBreakdown,
   options: TokenSummaryOptions = {}
 ): string {
   // Single-attempt: render exactly as before (no per-attempt breakdown)
@@ -224,19 +206,10 @@ export function formatTaskTokenSummary(
   }
 
   // Multi-attempt: show per-attempt lines plus total
-  // Per-attempt lines don't show rate limit (only show on total)
-  const perAttemptOptions: TokenSummaryOptions = {
-    ...options,
-    showRateLimitEstimate: false,
-    rateLimitPercentage: undefined,
-  };
-
   const lines: string[] = [];
   entry.attempts.forEach((attemptUsage, i) => {
-    const attemptCost = calculateAttemptCost
-      ? calculateAttemptCost(attemptUsage).totalCost
-      : 0;
-    lines.push(formatTokenLine(attemptUsage, attemptCost, `Attempt ${i + 1}`, '    ', perAttemptOptions));
+    const attemptCost = attemptUsage.totalCostUsd;
+    lines.push(formatTokenLine(attemptUsage, attemptCost, `Attempt ${i + 1}`, '    ', options));
   });
   lines.push(formatTokenLine(entry.usage, entry.cost.totalCost, 'Total', '    ', options));
   return lines.join('\n');
@@ -248,14 +221,14 @@ export function formatTaskTokenSummary(
  *
  * @param usage - Total usage data
  * @param cost - Total cost breakdown
- * @param options - Display options for cache tokens and rate limit
+ * @param options - Display options for cache tokens
  */
 export function formatTokenTotalSummary(
   usage: UsageData,
   cost: CostBreakdown,
   options: TokenSummaryOptions = {}
 ): string {
-  const { showCacheTokens = true, showRateLimitEstimate = false, rateLimitPercentage } = options;
+  const { showCacheTokens = true } = options;
   const lines: string[] = [];
   const divider = '── Token Usage Summary ──────────────────';
   lines.push(divider);
@@ -272,11 +245,8 @@ export function formatTokenTotalSummary(
     lines.push(`Cache: ${cacheParts.join(' / ')}`);
   }
 
-  lines.push(`Estimated cost: ${formatCost(cost.totalCost)}`);
+  lines.push(`Total cost: ${formatCost(cost.totalCost)}`);
 
-  if (showRateLimitEstimate && rateLimitPercentage !== undefined) {
-    lines.push(formatRateLimitPercentage(rateLimitPercentage));
-  }
   lines.push('─────────────────────────────────────────');
   return lines.join('\n');
 }