rafcode 2.5.1-0 → 3.0.0

package/src/core/codex-runner.ts

@@ -0,0 +1,326 @@
+import * as pty from 'node-pty';
+import type { IDisposable } from 'node-pty';
+import { execSync, spawn } from 'node:child_process';
+import { logger } from '../utils/logger.js';
+import { renderCodexStreamEvent } from '../parsers/codex-stream-renderer.js';
+import { getModel } from '../utils/config.js';
+import type { ICliRunner } from './runner-interface.js';
+import type { RunnerOptions, RunnerConfig, RunResult } from './runner-types.js';
+import { createCompletionDetector } from './completion-detector.js';
+
+function getCodexPath(): string {
+  try {
+    return execSync('which codex', { encoding: 'utf-8' }).trim();
+  } catch {
+    throw new Error('Codex CLI not found. Please ensure it is installed and in your PATH.');
+  }
+}
+
+/**
+ * Combine system prompt and user message into a single prompt for Codex.
+ * Codex CLI does not support a separate --system-prompt flag, so the system
+ * instructions are prepended to the user message.
+ */
+function buildCombinedPrompt(systemPrompt: string, userMessage: string): string {
+  return `[System Instructions]\n\n${systemPrompt}\n\n[User Request]\n\n${userMessage}`;
+}
+
+const CONTEXT_OVERFLOW_PATTERNS = [
+  /context length exceeded/i,
+  /token limit/i,
+  /maximum context/i,
+  /context window/i,
+];
+
+export class CodexRunner implements ICliRunner {
+  private activeProcess: pty.IPty | null = null;
+  private killed = false;
+  private model: string;
+
+  constructor(config: RunnerConfig = {}) {
+    this.model = config.model ?? getModel('execute', 'codex');
+  }
+
+  /**
+   * Run Codex interactively with stdin/stdout passthrough via PTY.
+   * Spawns `codex -m <model> <combined_prompt>` (no `exec` subcommand).
+   */
+  async runInteractive(
+    systemPrompt: string,
+    userMessage: string,
+    options: RunnerOptions = {}
+  ): Promise<number> {
+    const { cwd = process.cwd() } = options;
+
+    return new Promise((resolve) => {
+      const combinedPrompt = buildCombinedPrompt(systemPrompt, userMessage);
+      const args = ['-m', this.model, combinedPrompt];
+
+      logger.debug(`Starting interactive Codex session with model: ${this.model}`);
+
+      this.activeProcess = pty.spawn(getCodexPath(), args, {
+        name: 'xterm-256color',
+        cols: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+        cwd,
+        env: process.env as Record<string, string>,
+      });
+
+      // Set raw mode to pass through all input
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+      process.stdin.resume();
+
+      // Pipe input to Codex
+      const onData = (data: Buffer): void => {
+        if (this.activeProcess && !this.killed) {
+          this.activeProcess.write(data.toString());
+        }
+      };
+      process.stdin.on('data', onData);
+
+      // Store disposables for proper cleanup
+      const disposables: IDisposable[] = [];
+
+      // Pipe output to stdout
+      disposables.push(this.activeProcess.onData((data) => {
+        process.stdout.write(data);
+      }));
+
+      disposables.push(this.activeProcess.onExit(({ exitCode }) => {
+        // Cleanup stdin
+        process.stdin.off('data', onData);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+
+        // Dispose all event listeners to prevent FD leaks
+        for (const disposable of disposables) {
+          try {
+            disposable.dispose();
+          } catch {
+            // Ignore disposal errors
+          }
+        }
+
+        // Ensure PTY is fully cleaned up
+        if (this.activeProcess) {
+          try {
+            this.activeProcess.kill();
+          } catch {
+            // Ignore - process may already be dead
+          }
+          this.activeProcess = null;
+        }
+
+        if (this.killed) {
+          resolve(130); // SIGINT exit code
+        } else {
+          resolve(exitCode);
+        }
+      }));
+    });
+  }
+
+  /**
+   * Session resume is not supported by Codex CLI.
+   */
+  async runResume(_options: RunnerOptions = {}): Promise<number> {
+    throw new Error('Session resume is not supported by Codex CLI');
+  }
+
+  /**
+   * Run Codex non-interactively and collect output.
+   * Tool display is suppressed (non-verbose mode).
+   */
+  async run(prompt: string, options: RunnerOptions = {}): Promise<RunResult> {
+    return this._runExec(prompt, options, false);
+  }
+
+  /**
+   * Run Codex non-interactively with verbose output to stdout.
+   * Uses `codex exec --full-auto --json` to get JSONL streaming events.
+   */
+  async runVerbose(prompt: string, options: RunnerOptions = {}): Promise<RunResult> {
+    return this._runExec(prompt, options, true);
+  }
+
+  /**
+   * Internal unified execution method using `codex exec --full-auto --json`.
+   * Both run() and runVerbose() delegate to this method.
+   */
+  private async _runExec(
+    prompt: string,
+    options: RunnerOptions,
+    verbose: boolean,
+  ): Promise<RunResult> {
+    const { timeout = 60, cwd = process.cwd(), outcomeFilePath, commitContext, verboseCheck } = options;
+    const validatedTimeout = Number(timeout) > 0 ? Number(timeout) : 60;
+    const timeoutMs = validatedTimeout * 60 * 1000;
+
+    const shouldDisplay = verboseCheck ?? (() => verbose);
+
+    return new Promise((resolve) => {
+      let output = '';
+      let stderr = '';
+      let timedOut = false;
+      let contextOverflow = false;
+
+      const codexPath = getCodexPath();
+
+      logger.debug(`Starting Codex execution session (json, verbose=${verbose}) with model: ${this.model}`);
+      logger.debug(`Prompt length: ${prompt.length}, timeout: ${timeoutMs}ms, cwd: ${cwd}`);
+      logger.debug(`Codex path: ${codexPath}`);
+
+      logger.debug('Spawning process...');
+      const proc = spawn(codexPath, [
+        'exec',
+        '--full-auto',
+        '--json',
+        '--ephemeral',
+        '-m',
+        this.model,
+        prompt,
+      ], {
+        cwd,
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      // Track this process
+      this.activeProcess = proc as any;
+      logger.debug('Process spawned');
+
+      // Set up timeout
+      const timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        logger.warn('Codex session timed out');
+        proc.kill('SIGTERM');
+      }, timeoutMs);
+
+      // Set up completion detection (stdout marker + outcome file polling)
+      const completionDetector = createCompletionDetector(
+        () => proc.kill('SIGTERM'),
+        outcomeFilePath,
+        commitContext,
+      );
+
+      // Buffer for incomplete JSONL lines
+      let lineBuffer = '';
+      let dataReceived = false;
+
+      proc.stdout.on('data', (data) => {
+        if (!dataReceived) {
+          logger.debug('First data chunk received');
+          dataReceived = true;
+        }
+
+        lineBuffer += data.toString();
+
+        // Process complete lines from the JSONL stream
+        let newlineIndex: number;
+        while ((newlineIndex = lineBuffer.indexOf('\n')) !== -1) {
+          const line = lineBuffer.substring(0, newlineIndex);
+          lineBuffer = lineBuffer.substring(newlineIndex + 1);
+
+          const rendered = renderCodexStreamEvent(line);
+
+          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(rendered.textContent)) {
+                contextOverflow = true;
+                logger.warn('Context overflow detected');
+                proc.kill('SIGTERM');
+                break;
+              }
+            }
+          }
+
+          if (shouldDisplay() && rendered.display) {
+            process.stdout.write(rendered.display);
+          }
+        }
+      });
+
+      // 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 rendered = renderCodexStreamEvent(lineBuffer);
+          if (rendered.textContent) {
+            output += rendered.textContent;
+          }
+          if (shouldDisplay() && rendered.display) {
+            process.stdout.write(rendered.display);
+          }
+        }
+
+        clearTimeout(timeoutHandle);
+        completionDetector.cleanup();
+        this.activeProcess = null;
+        logger.debug(`Codex exited with code ${exitCode}, output length: ${output.length}, timedOut: ${timedOut}, contextOverflow: ${contextOverflow}`);
+
+        if (stderr) {
+          logger.debug(`Codex stderr: ${stderr}`);
+        }
+
+        resolve({
+          output,
+          exitCode: exitCode ?? (this.killed ? 130 : 1),
+          timedOut,
+          contextOverflow,
+          // Codex does not provide usage data in the same format — omit gracefully
+          usageData: undefined,
+        });
+      });
+    });
+  }
+
+  /**
+   * Kill the active Codex process gracefully.
+   */
+  kill(): void {
+    if (this.activeProcess) {
+      this.killed = true;
+
+      // Send Ctrl+C first for graceful shutdown (only for PTY processes)
+      try {
+        if (typeof this.activeProcess.write === 'function') {
+          this.activeProcess.write('\x03');
+        }
+      } catch {
+        // Ignore write errors - process may already be closing
+      }
+
+      // Force kill after 5 seconds if still running
+      setTimeout(() => {
+        if (this.activeProcess) {
+          try {
+            this.activeProcess.kill();
+          } catch {
+            // Ignore kill errors - process may already be dead
+          }
+        }
+      }, 5000);
+    }
+  }
+
+  /**
+   * Check if a process is currently running.
+   */
+  isRunning(): boolean {
+    return this.activeProcess !== null;
+  }
+}

package/src/core/completion-detector.ts

@@ -0,0 +1,177 @@
+import * as fs from 'node:fs';
+import { logger } from '../utils/logger.js';
+import { getHeadCommitHash, getHeadCommitMessage, isFileCommittedInHead } from './git.js';
+
+/**
+ * Grace period in ms after completion marker is detected before terminating.
+ * Allows time for git commit operations to complete.
+ */
+export const COMPLETION_GRACE_PERIOD_MS = 60_000;
+
+/**
+ * Hard maximum grace period in ms. If the commit hasn't landed by this point,
+ * the process is killed regardless.
+ */
+export const COMPLETION_HARD_MAX_MS = 180_000;
+
+/**
+ * Interval in ms for polling commit verification after the initial grace period expires.
+ */
+export const COMMIT_POLL_INTERVAL_MS = 10_000;
+
+/**
+ * Interval in ms for polling the outcome file for completion markers.
+ */
+export const OUTCOME_POLL_INTERVAL_MS = 5_000;
+
+export const COMPLETION_MARKER_PATTERN = /<promise>(COMPLETE|FAILED)<\/promise>/i;
+
+const COMPLETE_MARKER_PATTERN = /<promise>COMPLETE<\/promise>/i;
+
+/**
+ * Context for commit verification during grace period.
+ */
+export interface CommitContext {
+  /** HEAD commit hash recorded before task execution began. */
+  preExecutionHead: string;
+  /** Expected commit message prefix (e.g., "RAF[005:01]"). */
+  expectedPrefix: string;
+  /** Path to the outcome file that should be committed. */
+  outcomeFilePath: string;
+}
+
+/**
+ * Monitors for task completion markers in stdout and outcome files.
+ * When a marker is detected, starts a grace period before killing the process.
+ */
+export interface CompletionDetector {
+  /** Check accumulated stdout output for completion markers. */
+  checkOutput(output: string): void;
+  /** Clean up all timers. Must be called when the process exits. */
+  cleanup(): void;
+}
+
+/**
+ * Verify that the expected commit has been made.
+ * Checks: HEAD changed, commit message matches prefix, outcome file is committed.
+ */
+export function verifyCommit(commitContext: CommitContext): boolean {
+  const currentHead = getHeadCommitHash();
+  if (!currentHead || currentHead === commitContext.preExecutionHead) {
+    return false;
+  }
+
+  const message = getHeadCommitMessage();
+  if (!message || !message.startsWith(commitContext.expectedPrefix)) {
+    return false;
+  }
+
+  if (!isFileCommittedInHead(commitContext.outcomeFilePath)) {
+    return false;
+  }
+
+  return true;
+}
+
+export function createCompletionDetector(
+  killFn: () => void,
+  outcomeFilePath?: string,
+  commitContext?: CommitContext,
+): CompletionDetector {
+  let graceHandle: ReturnType<typeof setTimeout> | null = null;
+  let commitPollHandle: ReturnType<typeof setInterval> | null = null;
+  let hardMaxHandle: ReturnType<typeof setTimeout> | null = null;
+  let pollHandle: ReturnType<typeof setInterval> | null = null;
+  let initialMtime = 0;
+  let detectedMarkerIsComplete = false;
+
+  // Record initial mtime of outcome file to avoid false positives from previous runs
+  if (outcomeFilePath) {
+    try {
+      if (fs.existsSync(outcomeFilePath)) {
+        initialMtime = fs.statSync(outcomeFilePath).mtimeMs;
+      }
+    } catch {
+      // Ignore stat errors
+    }
+  }
+
+  /**
+   * Called when the initial grace period expires.
+   * If commit verification is needed and the commit hasn't landed yet,
+   * start polling for the commit up to the hard maximum.
+   */
+  function onGracePeriodExpired(): void {
+    if (commitContext && detectedMarkerIsComplete) {
+      // Check if commit already landed
+      if (verifyCommit(commitContext)) {
+        logger.debug('Grace period expired - commit verified, terminating process');
+        killFn();
+        return;
+      }
+
+      // Commit not found yet - extend with polling
+      logger.debug('Grace period expired but commit not verified - extending with polling');
+      const remainingMs = COMPLETION_HARD_MAX_MS - COMPLETION_GRACE_PERIOD_MS;
+
+      hardMaxHandle = setTimeout(() => {
+        logger.warn('Hard maximum grace period reached without commit verification - terminating process');
+        if (commitPollHandle) clearInterval(commitPollHandle);
+        killFn();
+      }, remainingMs);
+
+      commitPollHandle = setInterval(() => {
+        if (commitContext && verifyCommit(commitContext)) {
+          logger.debug('Commit verified during extended grace period - terminating process');
+          if (commitPollHandle) clearInterval(commitPollHandle);
+          if (hardMaxHandle) clearTimeout(hardMaxHandle);
+          killFn();
+        }
+      }, COMMIT_POLL_INTERVAL_MS);
+    } else {
+      // No commit verification needed (FAILED marker or no context) - kill immediately
+      logger.debug('Grace period expired - terminating process');
+      killFn();
+    }
+  }
+
+  function startGracePeriod(markerOutput: string): void {
+    if (graceHandle) return; // Already started
+    detectedMarkerIsComplete = COMPLETE_MARKER_PATTERN.test(markerOutput);
+    logger.debug('Completion marker detected - starting grace period before termination');
+    graceHandle = setTimeout(onGracePeriodExpired, COMPLETION_GRACE_PERIOD_MS);
+  }
+
+  function checkOutput(output: string): void {
+    if (!graceHandle && COMPLETION_MARKER_PATTERN.test(output)) {
+      startGracePeriod(output);
+    }
+  }
+
+  // Start outcome file polling if path provided
+  if (outcomeFilePath) {
+    const filePath = outcomeFilePath;
+    pollHandle = setInterval(() => {
+      try {
+        if (!fs.existsSync(filePath)) return;
+        const stat = fs.statSync(filePath);
+        if (stat.mtimeMs <= initialMtime) return; // File unchanged from before execution
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (COMPLETION_MARKER_PATTERN.test(content)) {
+          startGracePeriod(content);
+        }
+      } catch {
+        // Ignore read errors - file may be mid-write
+      }
+    }, OUTCOME_POLL_INTERVAL_MS);
+  }
+
+  function cleanup(): void {
+    if (graceHandle) clearTimeout(graceHandle);
+    if (pollHandle) clearInterval(pollHandle);
+    if (commitPollHandle) clearInterval(commitPollHandle);
+    if (hardMaxHandle) clearTimeout(hardMaxHandle);
+  }
+
+  return { checkOutput, cleanup };
+}

package/src/core/failure-analyzer.ts

@@ -110,7 +110,7 @@ export function generateProgrammaticReport(
 API error occurred during task execution.
 
 ## Analysis
-The Claude API returned an error response. This is typically a temporary issue with the API service.
+The API returned an error response. This is typically a temporary issue with the API service.
 
 ## Suggested Fix
 - Wait a few minutes and retry the task
@@ -150,13 +150,13 @@ Task execution timed out.
 ## Analysis
 The task took longer than the configured timeout to complete. This could indicate:
 - The task is too complex or large for a single execution
-- Claude is stuck or making slow progress
+- The LLM is stuck or making slow progress
 - Network issues causing delays
 
 ## Suggested Fix
 - Increase the timeout with \`--timeout <minutes>\`
 - Break the task into smaller subtasks
-- Check the logs for what Claude was doing before timeout
+- Check the logs for what the LLM was doing before timeout
 
 ## Relevant Output
 \`\`\`
@@ -170,14 +170,14 @@ ${relevantOutput}
 Context window exceeded during task execution.
 
 ## Analysis
-The conversation context grew too large for Claude to process. This typically happens when:
+The conversation context grew too large for the LLM to process. This typically happens when:
 - Too much code or output was included in the context
 - The task involves very large files
 - Multiple previous outcomes created a large context
 
 ## Suggested Fix
 - Break the task into smaller, independent subtasks
-- Reduce the amount of context passed to Claude
+- Reduce the amount of context passed to the LLM
 - Consider processing files in chunks
 
 ## Relevant Output
@@ -210,18 +210,18 @@ function extractRelevantOutput(output: string, maxLines: number): string {
 }
 
 /**
- * Get the path to Claude CLI.
+ * Get the path to the CLI binary.
  */
 function getClaudePath(): string {
   try {
     return execSync('which claude', { encoding: 'utf-8' }).trim();
   } catch {
-    throw new Error('Claude CLI not found. Please ensure it is installed and in your PATH.');
+    throw new Error('CLI not found. Please ensure it is installed and in your PATH.');
   }
 }
 
 /**
- * Analyze a failure using Claude (Sonnet/Haiku) and generate a structured report.
+ * Analyze a failure using the LLM and generate a structured report.
  * Uses a fast model for cost efficiency.
  */
 export async function analyzeFailure(
@@ -236,7 +236,7 @@ export async function analyzeFailure(
     return generateProgrammaticReport(programmaticType, failureReason, output);
   }
 
-  // For other failures, use Claude to analyze
+  // For other failures, use the LLM to analyze
   try {
     const analysisResult = await callClaudeForAnalysis(output, failureReason, taskId, timeoutMs);
     return analysisResult;
@@ -262,7 +262,7 @@ ${relevantOutput}
 }
 
 /**
- * Call Claude CLI to analyze the failure.
+ * Call the LLM CLI to analyze the failure.
  * Uses the print mode with a concise prompt.
  */
 async function callClaudeForAnalysis(

package/src/core/pull-request.ts

@@ -223,8 +223,8 @@ export function readProjectContext(projectPath: string): {
 }
 
 /**
- * Generate a PR body by calling Claude to summarize project context.
- * Falls back to a simple body if Claude is unavailable.
+ * Generate a PR body by calling the LLM to summarize project context.
+ * Falls back to a simple body if the CLI is unavailable.
  */
 export async function generatePrBody(
   projectPath: string,
@@ -232,7 +232,7 @@ export async function generatePrBody(
 ): Promise<string> {
   const context = readProjectContext(projectPath);
 
-  // Build context for Claude
+  // Build context for LLM
   const parts: string[] = [];
 
   if (context.input) {
@@ -284,13 +284,13 @@ Respond with ONLY the PR body in this exact format (no extra text, no code fence
     const body = await callClaudeForPrBody(prompt, timeoutMs);
     return body;
   } catch (error) {
-    logger.debug(`PR body generation via Claude failed: ${error instanceof Error ? error.message : String(error)}`);
+    logger.debug(`PR body generation failed: ${error instanceof Error ? error.message : String(error)}`);
     return generateFallbackBody(projectPath);
   }
 }
 
 /**
- * Generate a simple fallback PR body when Claude is unavailable.
+ * Generate a simple fallback PR body when the CLI is unavailable.
  */
 function generateFallbackBody(projectPath: string): string {
   const context = readProjectContext(projectPath);
@@ -330,8 +330,8 @@ function generateFallbackBody(projectPath: string): string {
 }
 
 /**
- * Filter Claude CLI output to remove non-markdown log/warning lines.
- * Claude CLI stdout may include warning or progress lines mixed with the response.
+ * Filter CLI output to remove non-markdown log/warning lines.
+ * CLI stdout may include warning or progress lines mixed with the response.
  */
 export function filterClaudeOutput(output: string): string {
   const lines = output.split('\n');
@@ -351,14 +351,14 @@ export function filterClaudeOutput(output: string): string {
 }
 
 /**
- * Call Claude to generate a PR body.
+ * Call the LLM CLI to generate a PR body.
  */
 async function callClaudeForPrBody(prompt: string, timeoutMs: number): Promise<string> {
   let claudePath: string;
   try {
     claudePath = execSync('which claude', { encoding: 'utf-8', stdio: 'pipe' }).trim();
   } catch {
-    throw new Error('Claude CLI not found');
+    throw new Error('CLI not found');
   }
 
   return new Promise((resolve, reject) => {
@@ -394,13 +394,13 @@ async function callClaudeForPrBody(prompt: string, timeoutMs: number): Promise<s
       clearTimeout(timeout);
 
       if (exitCode !== 0) {
-        reject(new Error(`Claude exited with code ${exitCode}: ${stderr}`));
+        reject(new Error(`Process exited with code ${exitCode}: ${stderr}`));
         return;
       }
 
       const filtered = filterClaudeOutput(output);
       if (!filtered) {
-        reject(new Error('Claude returned empty output'));
+        reject(new Error('LLM returned empty output'));
         return;
       }
 

package/src/core/runner-factory.ts

@@ -0,0 +1,35 @@
+import type { HarnessProvider } from '../types/config.js';
+import type { ICliRunner } from './runner-interface.js';
+import type { RunnerConfig } from './runner-types.js';
+import { ClaudeRunner } from './claude-runner.js';
+import { CodexRunner } from './codex-runner.js';
+
+/**
+ * Create a CLI runner for the given provider configuration.
+ */
+export function createRunner(config: RunnerConfig = {}): ICliRunner {
+  const provider = config.provider ?? 'claude';
+
+  switch (provider) {
+    case 'claude':
+      return new ClaudeRunner(config);
+    case 'codex':
+      return new CodexRunner(config);
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+
+/**
+ * Get the binary name for a given provider.
+ */
+export function getProviderBinaryName(provider: HarnessProvider): string {
+  switch (provider) {
+    case 'claude':
+      return 'claude';
+    case 'codex':
+      return 'codex';
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}