rafcode 2.1.1 → 2.3.0

package/src/core/claude-runner.ts

@@ -4,11 +4,14 @@ import type { IDisposable } from 'node-pty';
 import { execSync, spawn } from 'node:child_process';
 import { logger } from '../utils/logger.js';
 import { renderStreamEvent } from '../parsers/stream-renderer.js';
+import type { UsageData } from '../types/config.js';
 import { getHeadCommitHash, getHeadCommitMessage, isFileCommittedInHead } from './git.js';
+import { getClaudeCommand, getModel } from '../utils/config.js';
 
 function getClaudePath(): string {
+  const cmd = getClaudeCommand();
   try {
-    return execSync('which claude', { encoding: 'utf-8' }).trim();
+    return execSync(`which ${cmd}`, { encoding: 'utf-8' }).trim();
   } catch {
     throw new Error('Claude CLI not found. Please ensure it is installed and in your PATH.');
   }
@@ -56,6 +59,12 @@ export interface ClaudeRunnerOptions {
    * Only applied in non-interactive modes (run, runVerbose).
    */
   effortLevel?: 'low' | 'medium' | 'high';
+  /**
+   * Dynamic verbose display callback. When provided, called for each stream event
+   * to determine whether to write display output to stdout. Overrides the static
+   * verbose parameter in _runStreamJson. Used by the runtime verbose toggle.
+   */
+  verboseCheck?: () => boolean;
 }
 
 export interface ClaudeRunnerConfig {
@@ -71,6 +80,8 @@ export interface RunResult {
   exitCode: number;
   timedOut: boolean;
   contextOverflow: boolean;
+  /** Token usage data from the stream-json result event. */
+  usageData?: UsageData;
 }
 
 const CONTEXT_OVERFLOW_PATTERNS = [
@@ -260,7 +271,7 @@ export class ClaudeRunner {
   private model: string;
 
   constructor(config: ClaudeRunnerConfig = {}) {
-    this.model = config.model ?? 'opus';
+    this.model = config.model ?? getModel('execute');
   }
 
   /**
@@ -362,8 +373,8 @@ export class ClaudeRunner {
 
   /**
    * Run Claude non-interactively and collect output.
-   * Used for execution phase where we parse the results.
-   * Uses child_process.spawn with -p flag for prompt (like ralphy).
+   * Uses stream-json format internally to capture token usage data.
+   * Tool display is suppressed (non-verbose mode).
    *
    * TIMEOUT BEHAVIOR:
    * - The timeout is applied per individual call to this method
@@ -373,103 +384,7 @@ export class ClaudeRunner {
    * - Default timeout is 60 minutes if not specified
    */
   async run(prompt: string, options: ClaudeRunnerOptions = {}): Promise<RunResult> {
-    const { timeout = 60, cwd = process.cwd(), outcomeFilePath, commitContext, effortLevel } = options;
-    // Ensure timeout is a positive number, fallback to 60 minutes
-    const validatedTimeout = Number(timeout) > 0 ? Number(timeout) : 60;
-    const timeoutMs = validatedTimeout * 60 * 1000;
-
-    return new Promise((resolve) => {
-      let output = '';
-      let stderr = '';
-      let timedOut = false;
-      let contextOverflow = false;
-
-      const claudePath = getClaudePath();
-
-      logger.debug(`Starting Claude execution session with model: ${this.model}`);
-      logger.debug(`Claude path: ${claudePath}`);
-
-      // Build env, optionally injecting effort level
-      const env = effortLevel
-        ? { ...process.env, CLAUDE_CODE_EFFORT_LEVEL: effortLevel }
-        : process.env;
-
-      // Use --append-system-prompt to add RAF instructions to system prompt
-      // This gives RAF instructions stronger precedence than passing as user message
-      // --dangerously-skip-permissions bypasses interactive prompts
-      // -p enables print mode (non-interactive)
-      const proc = spawn(claudePath, [
-        '--dangerously-skip-permissions',
-        '--model',
-        this.model,
-        '--append-system-prompt',
-        prompt,
-        '-p',
-        'Execute the task as described in the system prompt.',
-      ], {
-        cwd,
-        env,
-        stdio: ['ignore', 'pipe', 'pipe'], // no stdin needed
-      });
-
-      // Track this process
-      this.activeProcess = proc as any;
-
-      // Set up timeout
-      const timeoutHandle = setTimeout(() => {
-        timedOut = true;
-        logger.warn('Claude session timed out');
-        proc.kill('SIGTERM');
-      }, timeoutMs);
-
-      // Set up completion detection (stdout marker + outcome file polling)
-      const completionDetector = createCompletionDetector(
-        () => proc.kill('SIGTERM'),
-        outcomeFilePath,
-        commitContext,
-      );
-
-      // Collect stdout
-      proc.stdout.on('data', (data) => {
-        const text = data.toString();
-        output += text;
-
-        // Check for completion marker to start grace period
-        completionDetector.checkOutput(output);
-
-        // Check for context overflow
-        for (const pattern of CONTEXT_OVERFLOW_PATTERNS) {
-          if (pattern.test(text)) {
-            contextOverflow = true;
-            logger.warn('Context overflow detected');
-            proc.kill('SIGTERM');
-            break;
-          }
-        }
-      });
-
-      // Collect stderr
-      proc.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      proc.on('close', (exitCode) => {
-        clearTimeout(timeoutHandle);
-        completionDetector.cleanup();
-        this.activeProcess = null;
-
-        if (stderr) {
-          logger.debug(`Claude stderr: ${stderr}`);
-        }
-
-        resolve({
-          output,
-          exitCode: exitCode ?? (this.killed ? 130 : 1),
-          timedOut,
-          contextOverflow,
-        });
-      });
-    });
+    return this._runStreamJson(prompt, options, false);
   }
 
   /**
@@ -485,20 +400,40 @@ export class ClaudeRunner {
    * - Default timeout is 60 minutes if not specified
    */
   async runVerbose(prompt: string, options: ClaudeRunnerOptions = {}): Promise<RunResult> {
-    const { timeout = 60, cwd = process.cwd(), outcomeFilePath, commitContext, effortLevel } = options;
+    return this._runStreamJson(prompt, options, true);
+  }
+
+  /**
+   * Internal unified execution method using stream-json format.
+   * Both run() and runVerbose() delegate to this method.
+   *
+   * @param verbose - When true, tool descriptions and text are printed to stdout.
+   *                  When false, display output is suppressed but usage data is still captured.
+   */
+  private async _runStreamJson(
+    prompt: string,
+    options: ClaudeRunnerOptions,
+    verbose: boolean,
+  ): Promise<RunResult> {
+    const { timeout = 60, cwd = process.cwd(), outcomeFilePath, commitContext, effortLevel, verboseCheck } = options;
     // Ensure timeout is a positive number, fallback to 60 minutes
     const validatedTimeout = Number(timeout) > 0 ? Number(timeout) : 60;
     const timeoutMs = validatedTimeout * 60 * 1000;
 
+    // When verboseCheck callback is provided, use it to dynamically determine display.
+    // Otherwise, fall back to the static verbose parameter.
+    const shouldDisplay = verboseCheck ?? (() => verbose);
+
     return new Promise((resolve) => {
       let output = '';
       let stderr = '';
       let timedOut = false;
       let contextOverflow = false;
+      let usageData: import('../types/config.js').UsageData | undefined;
 
       const claudePath = getClaudePath();
 
-      logger.debug(`Starting Claude execution session (verbose/stream-json) with model: ${this.model}`);
+      logger.debug(`Starting Claude execution session (stream-json, verbose=${verbose}) with model: ${this.model}`);
       logger.debug(`Prompt length: ${prompt.length}, timeout: ${timeoutMs}ms, cwd: ${cwd}`);
       logger.debug(`Claude path: ${claudePath}`);
 
@@ -509,7 +444,7 @@ export class ClaudeRunner {
 
       logger.debug('Spawning process...');
       // Use --output-format stream-json --verbose to get real-time streaming events
-      // including tool calls, file operations, and intermediate output.
+      // including tool calls, file operations, and token usage in the result event.
       // --dangerously-skip-permissions bypasses interactive prompts
       // -p enables print mode (non-interactive)
       const proc = spawn(claudePath, [
@@ -565,17 +500,17 @@ export class ClaudeRunner {
           const line = lineBuffer.substring(0, newlineIndex);
           lineBuffer = lineBuffer.substring(newlineIndex + 1);
 
-          const { display, textContent } = renderStreamEvent(line);
+          const rendered = renderStreamEvent(line);
 
-          if (textContent) {
-            output += textContent;
+          if (rendered.textContent) {
+            output += rendered.textContent;
 
             // Check for completion marker to start grace period
             completionDetector.checkOutput(output);
 
             // Check for context overflow
             for (const pattern of CONTEXT_OVERFLOW_PATTERNS) {
-              if (pattern.test(textContent)) {
+              if (pattern.test(rendered.textContent)) {
                 contextOverflow = true;
                 logger.warn('Context overflow detected');
                 proc.kill('SIGTERM');
@@ -584,8 +519,13 @@ export class ClaudeRunner {
             }
           }
 
-          if (display) {
-            process.stdout.write(display);
+          // Capture usage data from result events
+          if (rendered.usageData) {
+            usageData = rendered.usageData;
+          }
+
+          if (shouldDisplay() && rendered.display) {
+            process.stdout.write(rendered.display);
           }
         }
       });
@@ -598,12 +538,15 @@ export class ClaudeRunner {
       proc.on('close', (exitCode) => {
         // Process any remaining data in the line buffer
         if (lineBuffer.trim()) {
-          const { display, textContent } = renderStreamEvent(lineBuffer);
-          if (textContent) {
-            output += textContent;
+          const rendered = renderStreamEvent(lineBuffer);
+          if (rendered.textContent) {
+            output += rendered.textContent;
+          }
+          if (rendered.usageData) {
+            usageData = rendered.usageData;
           }
-          if (display) {
-            process.stdout.write(display);
+          if (shouldDisplay() && rendered.display) {
+            process.stdout.write(rendered.display);
           }
         }
 
@@ -621,6 +564,7 @@ export class ClaudeRunner {
           exitCode: exitCode ?? (this.killed ? 130 : 1),
           timedOut,
           contextOverflow,
+          usageData,
         });
       });
     });

package/src/core/failure-analyzer.ts

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { execSync } from 'node:child_process';
+import { getModel, getClaudeCommand } from '../utils/config.js';
 
 /**
  * Failure types that can be detected programmatically without using the API.
@@ -212,8 +213,9 @@ function extractRelevantOutput(output: string, maxLines: number): string {
  * Get the path to Claude CLI.
  */
 function getClaudePath(): string {
+  const cmd = getClaudeCommand();
   try {
-    return execSync('which claude', { encoding: 'utf-8' }).trim();
+    return execSync(`which ${cmd}`, { encoding: 'utf-8' }).trim();
   } catch {
     throw new Error('Claude CLI not found. Please ensure it is installed and in your PATH.');
   }
@@ -306,9 +308,10 @@ Respond with ONLY a markdown report in this exact format:
 
     const claudePath = getClaudePath();
 
-    // Use haiku model for fast, cost-effective analysis
+    // Use configured model for failure analysis
+    const failureModel = getModel('failureAnalysis');
     const proc = spawn(claudePath, [
-      '--model', 'haiku',
+      '--model', failureModel,
       '--dangerously-skip-permissions',
       '-p',
       prompt,

package/src/core/git.ts

@@ -2,6 +2,7 @@ import { execSync } from 'node:child_process';
 import * as path from 'node:path';
 import { logger } from '../utils/logger.js';
 import { extractProjectNumber, extractProjectName } from '../utils/paths.js';
+import { getCommitFormat, getCommitPrefix, renderCommitMessage } from '../utils/config.js';
 
 export interface GitStatus {
   isRepo: boolean;
@@ -246,9 +247,15 @@ export async function commitPlanningArtifacts(projectPath: string, options?: { c
   const inputFile = path.join(projectPath, 'input.md');
   const decisionsFile = path.join(projectPath, 'decisions.md');
 
-  // Build commit message
-  const prefix = options?.isAmend ? 'Amend' : 'Plan';
-  const commitMessage = `RAF[${projectNumber}] ${prefix}: ${projectName}`;
+  // Build commit message from config template
+  const formatType = options?.isAmend ? 'amend' as const : 'plan' as const;
+  const template = getCommitFormat(formatType);
+  const commitPrefix = getCommitPrefix();
+  const commitMessage = renderCommitMessage(template, {
+    prefix: commitPrefix,
+    projectId: projectNumber,
+    projectName,
+  });
 
   // Build list of files to stage (absolute paths)
   const absoluteFiles = [inputFile, decisionsFile, ...(options?.additionalFiles ?? [])];

package/src/core/pull-request.ts

@@ -3,6 +3,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { logger } from '../utils/logger.js';
+import { getModel, getClaudeCommand, getModelShortName } from '../utils/config.js';
 import { extractProjectName, getInputPath, getDecisionsPath, getOutcomesDir, TASK_ID_PATTERN } from '../utils/paths.js';
 
 export interface PrCreateResult {
@@ -222,7 +223,7 @@ export function readProjectContext(projectPath: string): {
 }
 
 /**
- * Generate a PR body by calling Claude Sonnet to summarize project context.
+ * Generate a PR body by calling Claude to summarize project context.
  * Falls back to a simple body if Claude is unavailable.
  */
 export async function generatePrBody(
@@ -278,6 +279,8 @@ Respond with ONLY the PR body in this exact format (no extra text, no code fence
 [1-3 bullet points describing how to verify these changes work correctly]`;
 
   try {
+    const prModel = getModelShortName(getModel('prGeneration'));
+    logger.info(`Generating PR with ${prModel}...`);
     const body = await callClaudeForPrBody(prompt, timeoutMs);
     return body;
   } catch (error) {
@@ -348,12 +351,13 @@ export function filterClaudeOutput(output: string): string {
 }
 
 /**
- * Call Claude Sonnet to generate a PR body.
+ * Call Claude to generate a PR body.
  */
 async function callClaudeForPrBody(prompt: string, timeoutMs: number): Promise<string> {
+  const cmd = getClaudeCommand();
   let claudePath: string;
   try {
-    claudePath = execSync('which claude', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    claudePath = execSync(`which ${cmd}`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
   } catch {
     throw new Error('Claude CLI not found');
   }
@@ -362,8 +366,9 @@ async function callClaudeForPrBody(prompt: string, timeoutMs: number): Promise<s
     let output = '';
     let stderr = '';
 
+    const prModel = getModel('prGeneration');
     const proc = spawn(claudePath, [
-      '--model', 'sonnet',
+      '--model', prModel,
       '--dangerously-skip-permissions',
       '-p',
       prompt,

package/src/index.ts

@@ -5,6 +5,7 @@ import { createPlanCommand } from './commands/plan.js';
 import { createDoCommand } from './commands/do.js';
 import { createStatusCommand } from './commands/status.js';
 import { createMigrateCommand } from './commands/migrate.js';
+import { createConfigCommand } from './commands/config.js';
 import { getVersion } from './utils/version.js';
 
 const program = new Command();
@@ -18,5 +19,6 @@ program.addCommand(createPlanCommand());
 program.addCommand(createDoCommand());
 program.addCommand(createStatusCommand());
 program.addCommand(createMigrateCommand());
+program.addCommand(createConfigCommand());
 
 program.parse();

package/src/parsers/stream-renderer.ts

@@ -5,9 +5,11 @@
  * - system (init): Session initialization info
  * - assistant: Claude's response with text or tool_use content blocks
  * - user: Tool results (tool_result content blocks)
- * - result: Final result with success/failure status
+ * - result: Final result with success/failure status and token usage
  */
 
+import type { UsageData, ModelTokenUsage } from '../types/config.js';
+
 export interface StreamEvent {
   type: string;
   subtype?: string;
@@ -15,6 +17,18 @@ export interface StreamEvent {
     content?: ContentBlock[];
   };
   result?: string;
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+  };
+  modelUsage?: Record<string, {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadInputTokens?: number;
+    cacheCreationInputTokens?: number;
+  }>;
   tool_use_result?: {
     type?: string;
     file?: {
@@ -72,6 +86,8 @@ export interface RenderResult {
   display: string;
   /** Text content to accumulate for output parsing (completion markers, etc.) */
   textContent: string;
+  /** Usage data extracted from result events (only present on result events) */
+  usageData?: UsageData;
 }
 
 /**
@@ -132,8 +148,42 @@ function renderAssistant(event: StreamEvent): RenderResult {
   return { display, textContent };
 }
 
-function renderResult(_event: StreamEvent): RenderResult {
+function renderResult(event: StreamEvent): RenderResult {
   // The result event's text duplicates the last assistant message,
-  // which is already captured. Skip to avoid double-counting.
-  return { display: '', textContent: '' };
+  // which is already captured. Skip text to avoid double-counting.
+  // But extract usage data if present.
+  const usageData = extractUsageData(event);
+  return { display: '', textContent: '', usageData };
+}
+
+/**
+ * Extract usage data from a stream-json result event.
+ * Returns undefined if no usage data is present.
+ */
+function extractUsageData(event: StreamEvent): UsageData | undefined {
+  if (!event.usage && !event.modelUsage) {
+    return undefined;
+  }
+
+  const usage = event.usage;
+  const modelUsage: Record<string, ModelTokenUsage> = {};
+
+  if (event.modelUsage) {
+    for (const [model, data] of Object.entries(event.modelUsage)) {
+      modelUsage[model] = {
+        inputTokens: data.inputTokens ?? 0,
+        outputTokens: data.outputTokens ?? 0,
+        cacheReadInputTokens: data.cacheReadInputTokens ?? 0,
+        cacheCreationInputTokens: data.cacheCreationInputTokens ?? 0,
+      };
+    }
+  }
+
+  return {
+    inputTokens: usage?.input_tokens ?? 0,
+    outputTokens: usage?.output_tokens ?? 0,
+    cacheReadInputTokens: usage?.cache_read_input_tokens ?? 0,
+    cacheCreationInputTokens: usage?.cache_creation_input_tokens ?? 0,
+    modelUsage,
+  };
 }