rafcode 2.1.0 → 2.2.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,7 +80,8 @@ export interface RunResult {
   exitCode: number;
   timedOut: boolean;
   contextOverflow: boolean;
-  sessionId?: string;
+  /** Token usage data from the stream-json result event. */
+  usageData?: UsageData;
 }
 
 const CONTEXT_OVERFLOW_PATTERNS = [
@@ -259,18 +269,9 @@ export class ClaudeRunner {
   private activeProcess: pty.IPty | null = null;
   private killed = false;
   private model: string;
-  private _sessionId: string | undefined;
 
   constructor(config: ClaudeRunnerConfig = {}) {
-    this.model = config.model ?? 'opus';
-  }
-
-  /**
-   * Get the session ID captured from the most recent Claude session.
-   * Available after the system.init event is received during run() or runVerbose().
-   */
-  get sessionId(): string | undefined {
-    return this._sessionId;
+    this.model = config.model ?? getModel('execute');
   }
 
   /**
@@ -372,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
@@ -383,147 +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;
-      let sessionId: string | undefined;
-
-      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 --output-format stream-json to get structured events including session_id.
-      // Unlike runVerbose(), output is parsed silently without writing to stdout.
-      // --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,
-        '--output-format',
-        'stream-json',
-        '--verbose',
-        '-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');
-        if (sessionId) {
-          logger.info(`Session ID: ${sessionId}`);
-        }
-        proc.kill('SIGTERM');
-      }, timeoutMs);
-
-      // Set up completion detection (stdout marker + outcome file polling)
-      const completionDetector = createCompletionDetector(
-        () => proc.kill('SIGTERM'),
-        outcomeFilePath,
-        commitContext,
-      );
-
-      // Buffer for incomplete NDJSON lines (data chunks may split across line boundaries)
-      let lineBuffer = '';
-
-      // Collect stdout - parse NDJSON silently (no display output)
-      proc.stdout.on('data', (data) => {
-        lineBuffer += data.toString();
-
-        // Process complete lines from the NDJSON stream
-        let newlineIndex: number;
-        while ((newlineIndex = lineBuffer.indexOf('\n')) !== -1) {
-          const line = lineBuffer.substring(0, newlineIndex);
-          lineBuffer = lineBuffer.substring(newlineIndex + 1);
-
-          const result = renderStreamEvent(line);
-
-          if (result.sessionId && !sessionId) {
-            sessionId = result.sessionId;
-            this._sessionId = sessionId;
-          }
-
-          if (result.textContent) {
-            output += result.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(result.textContent)) {
-                contextOverflow = true;
-                logger.warn('Context overflow detected');
-                if (sessionId) {
-                  logger.info(`Session ID: ${sessionId}`);
-                }
-                proc.kill('SIGTERM');
-                break;
-              }
-            }
-          }
-
-          // Silently discard display output (unlike runVerbose)
-        }
-      });
-
-      // Collect stderr
-      proc.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      proc.on('close', (exitCode) => {
-        // Process any remaining data in the line buffer
-        if (lineBuffer.trim()) {
-          const result = renderStreamEvent(lineBuffer);
-          if (result.sessionId && !sessionId) {
-            sessionId = result.sessionId;
-          }
-          if (result.textContent) {
-            output += result.textContent;
-          }
-        }
-
-        clearTimeout(timeoutHandle);
-        completionDetector.cleanup();
-        this.activeProcess = null;
-
-        if (stderr) {
-          logger.debug(`Claude stderr: ${stderr}`);
-        }
-
-        resolve({
-          output,
-          exitCode: exitCode ?? (this.killed ? 130 : 1),
-          timedOut,
-          contextOverflow,
-          sessionId,
-        });
-      });
-    });
+    return this._runStreamJson(prompt, options, false);
   }
 
   /**
@@ -539,21 +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 sessionId: string | undefined;
+      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}`);
 
@@ -564,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, [
@@ -592,9 +472,6 @@ export class ClaudeRunner {
       const timeoutHandle = setTimeout(() => {
         timedOut = true;
         logger.warn('Claude session timed out');
-        if (sessionId) {
-          logger.info(`Session ID: ${sessionId}`);
-        }
         proc.kill('SIGTERM');
       }, timeoutMs);
 
@@ -623,35 +500,32 @@ export class ClaudeRunner {
           const line = lineBuffer.substring(0, newlineIndex);
           lineBuffer = lineBuffer.substring(newlineIndex + 1);
 
-          const result = renderStreamEvent(line);
+          const rendered = renderStreamEvent(line);
 
-          if (result.sessionId && !sessionId) {
-            sessionId = result.sessionId;
-            this._sessionId = sessionId;
-          }
-
-          if (result.textContent) {
-            output += result.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(result.textContent)) {
+              if (pattern.test(rendered.textContent)) {
                 contextOverflow = true;
                 logger.warn('Context overflow detected');
-                if (sessionId) {
-                  logger.info(`Session ID: ${sessionId}`);
-                }
                 proc.kill('SIGTERM');
                 break;
               }
             }
           }
 
-          if (result.display) {
-            process.stdout.write(result.display);
+          // Capture usage data from result events
+          if (rendered.usageData) {
+            usageData = rendered.usageData;
+          }
+
+          if (shouldDisplay() && rendered.display) {
+            process.stdout.write(rendered.display);
           }
         }
       });
@@ -664,15 +538,15 @@ export class ClaudeRunner {
       proc.on('close', (exitCode) => {
         // Process any remaining data in the line buffer
         if (lineBuffer.trim()) {
-          const result = renderStreamEvent(lineBuffer);
-          if (result.sessionId && !sessionId) {
-            sessionId = result.sessionId;
+          const rendered = renderStreamEvent(lineBuffer);
+          if (rendered.textContent) {
+            output += rendered.textContent;
           }
-          if (result.textContent) {
-            output += result.textContent;
+          if (rendered.usageData) {
+            usageData = rendered.usageData;
           }
-          if (result.display) {
-            process.stdout.write(result.display);
+          if (shouldDisplay() && rendered.display) {
+            process.stdout.write(rendered.display);
           }
         }
 
@@ -690,134 +564,7 @@ export class ClaudeRunner {
           exitCode: exitCode ?? (this.killed ? 130 : 1),
           timedOut,
           contextOverflow,
-          sessionId,
-        });
-      });
-    });
-  }
-
-  /**
-   * Resume an interrupted Claude session by session ID.
-   * Spawns Claude with --resume flag only — no prompt, model, or system prompt flags.
-   * Uses stream-json output format for session ID extraction and completion detection.
-   */
-  async runResume(sessionId: string, options: ClaudeRunnerOptions = {}): Promise<RunResult> {
-    const { timeout = 60, cwd = process.cwd(), outcomeFilePath, commitContext, effortLevel } = options;
-    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;
-      let newSessionId: string | undefined;
-
-      const claudePath = getClaudePath();
-
-      logger.debug(`Resuming Claude session: ${sessionId}`);
-
-      const env = effortLevel
-        ? { ...process.env, CLAUDE_CODE_EFFORT_LEVEL: effortLevel }
-        : process.env;
-
-      // Resume with minimal flags: --resume, --dangerously-skip-permissions, --output-format stream-json --verbose
-      // Do NOT pass --model, --append-system-prompt, or -p — Claude restores these from the session
-      const proc = spawn(claudePath, [
-        '--resume',
-        sessionId,
-        '--dangerously-skip-permissions',
-        '--output-format',
-        'stream-json',
-        '--verbose',
-      ], {
-        cwd,
-        env,
-        stdio: ['ignore', 'pipe', 'pipe'],
-      });
-
-      this.activeProcess = proc as any;
-
-      const timeoutHandle = setTimeout(() => {
-        timedOut = true;
-        logger.warn('Resumed Claude session timed out');
-        if (newSessionId) {
-          logger.info(`Session ID: ${newSessionId}`);
-        }
-        proc.kill('SIGTERM');
-      }, timeoutMs);
-
-      const completionDetector = createCompletionDetector(
-        () => proc.kill('SIGTERM'),
-        outcomeFilePath,
-        commitContext,
-      );
-
-      let lineBuffer = '';
-
-      proc.stdout.on('data', (data) => {
-        lineBuffer += data.toString();
-
-        let newlineIndex: number;
-        while ((newlineIndex = lineBuffer.indexOf('\n')) !== -1) {
-          const line = lineBuffer.substring(0, newlineIndex);
-          lineBuffer = lineBuffer.substring(newlineIndex + 1);
-
-          const result = renderStreamEvent(line);
-
-          if (result.sessionId && !newSessionId) {
-            newSessionId = result.sessionId;
-            this._sessionId = newSessionId;
-          }
-
-          if (result.textContent) {
-            output += result.textContent;
-            completionDetector.checkOutput(output);
-
-            for (const pattern of CONTEXT_OVERFLOW_PATTERNS) {
-              if (pattern.test(result.textContent)) {
-                contextOverflow = true;
-                logger.warn('Context overflow detected');
-                if (newSessionId) {
-                  logger.info(`Session ID: ${newSessionId}`);
-                }
-                proc.kill('SIGTERM');
-                break;
-              }
-            }
-          }
-        }
-      });
-
-      proc.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      proc.on('close', (exitCode) => {
-        if (lineBuffer.trim()) {
-          const result = renderStreamEvent(lineBuffer);
-          if (result.sessionId && !newSessionId) {
-            newSessionId = result.sessionId;
-          }
-          if (result.textContent) {
-            output += result.textContent;
-          }
-        }
-
-        clearTimeout(timeoutHandle);
-        completionDetector.cleanup();
-        this.activeProcess = null;
-
-        if (stderr) {
-          logger.debug(`Claude stderr: ${stderr}`);
-        }
-
-        resolve({
-          output,
-          exitCode: exitCode ?? (this.killed ? 130 : 1),
-          timedOut,
-          contextOverflow,
-          sessionId: newSessionId,
+          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 } 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(
@@ -348,12 +349,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 +364,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/core/shutdown-handler.ts

@@ -54,11 +54,6 @@ class ShutdownHandler {
     this.isShuttingDown = true;
     logger.info(`\nReceived ${signal}, shutting down gracefully...`);
 
-    // Print session ID if available (for resumption/debugging)
-    if (this.claudeRunner?.sessionId) {
-      logger.info(`Session ID: ${this.claudeRunner.sessionId}`);
-    }
-
     // Kill Claude process if running
     if (this.claudeRunner?.isRunning()) {
       logger.debug('Killing Claude process...');

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();