rafcode 2.5.1 → 3.2.1

package/src/commands/config.ts

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import * as readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
-import { ClaudeRunner } from '../core/claude-runner.js';
+import { createRunner } from '../core/runner-factory.js';
 import { shutdownHandler } from '../core/shutdown-handler.js';
 import { logger } from '../utils/logger.js';
 import {
@@ -53,7 +53,7 @@ function getCurrentConfigState(configPath: string): string {
 }
 
 /**
- * Build the system prompt for the config editing Claude session.
+ * Build the system prompt for the config editing session.
  */
 function buildConfigSystemPrompt(configDocs: string, configState: string): string {
   return [
@@ -69,7 +69,7 @@ function buildConfigSystemPrompt(configDocs: string, configState: string): strin
 }
 
 /**
- * Validate the config file after the Claude session ends and report results.
+ * Validate the config file after the editing session ends and report results.
  */
 function postSessionValidation(configPath: string): void {
   if (!fs.existsSync(configPath)) {
@@ -336,7 +336,7 @@ function handleSet(args: string[]): void {
 
 export function createConfigCommand(): Command {
   const command = new Command('config')
-    .description('View and edit RAF configuration with Claude')
+    .description('View and edit RAF configuration interactively')
     .argument('[prompt...]', 'Optional initial prompt for the config session')
     .option('--reset', 'Delete config file and restore all defaults')
     .option('--get [key]', 'Show config value (all config if no key, or specific dot-notation key)')
@@ -437,8 +437,8 @@ async function runConfigSession(initialPrompt?: string): Promise<void> {
   const userMessage = initialPrompt
     ?? 'Show me my current config and help me make changes.';
 
-  // Set up Claude runner
-  const claudeRunner = new ClaudeRunner({ model });
+  // Set up runner
+  const claudeRunner = createRunner({ model });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
@@ -452,7 +452,7 @@ async function runConfigSession(initialPrompt?: string): Promise<void> {
     });
 
     if (exitCode !== 0) {
-      logger.warn(`Claude exited with code ${exitCode}`);
+      logger.warn(`Process exited with code ${exitCode}`);
     }
 
     // Post-session validation

package/src/commands/do.ts

@@ -3,17 +3,17 @@ import * as path from 'node:path';
 import { Command } from 'commander';
 import { select } from '@inquirer/prompts';
 import { ProjectManager } from '../core/project-manager.js';
-import { ClaudeRunner } from '../core/claude-runner.js';
+import { createRunner } from '../core/runner-factory.js';
 import { shutdownHandler } from '../core/shutdown-handler.js';
 import { stashChanges, hasUncommittedChanges, isGitRepo, getHeadCommitHash } from '../core/git.js';
 import { getExecutionPrompt } from '../prompts/execution.js';
 import { parseOutput, isRetryableFailure } from '../parsers/output-parser.js';
 import { validatePlansExist, resolveModelOption } from '../utils/validation.js';
-import { getRafDir, extractProjectNumber, extractProjectName, extractTaskNameFromPlanFile, resolveProjectIdentifierWithDetails, getOutcomeFilePath, parseProjectPrefix } from '../utils/paths.js';
+import { getRafDir, extractProjectNumber, extractProjectName, extractTaskNameFromPlanFile, resolveProjectIdentifierWithDetails, getOutcomeFilePath } from '../utils/paths.js';
 import { pickPendingProject, getPendingProjects, getPendingWorktreeProjects } from '../ui/project-picker.js';
 import type { PendingProjectInfo } from '../ui/project-picker.js';
 import { logger } from '../utils/logger.js';
-import { getConfig, getWorktreeDefault, getModel, getModelShortName, resolveFullModelId, getSyncMainBranch, resolveEffortToModel, applyModelCeiling, getShowCacheTokens } from '../utils/config.js';
+import { getConfig, getModel, getModelShortName, resolveFullModelId, getSyncMainBranch, resolveEffortToModel, applyModelCeiling, getShowCacheTokens } from '../utils/config.js';
 import type { PlanFrontmatter } from '../utils/frontmatter.js';
 import { getVersion } from '../utils/version.js';
 import { createTaskTimer, formatElapsedTime } from '../utils/timer.js';
@@ -29,7 +29,6 @@ import { TokenTracker } from '../utils/token-tracker.js';
 import { VerboseToggle } from '../utils/verbose-toggle.js';
 import {
   deriveProjectState,
-  discoverProjects,
   getNextExecutableTask,
   getDerivedStats,
   getDerivedStatsForTasks,
@@ -44,10 +43,6 @@ import {
   getRepoRoot,
   getRepoBasename,
   getCurrentBranch,
-  computeWorktreePath,
-  computeWorktreeBaseDir,
-  validateWorktree,
-  listWorktreeProjects,
   mergeWorktreeBranch,
   removeWorktree,
   resolveWorktreeProjectByIdentifier,
@@ -97,6 +92,7 @@ function resolveTaskModel(
   frontmatterWarnings: string[] | undefined,
   ceilingModel: string,
   isRetry: boolean,
+  provider?: import('../types/config.js').HarnessProvider,
 ): TaskModelResolution {
   const warnings = frontmatterWarnings ? [...frontmatterWarnings] : [];
 
@@ -122,7 +118,7 @@ function resolveTaskModel(
 
   // Effort-based resolution - apply ceiling
   if (frontmatter.effort) {
-    const mappedModel = resolveEffortToModel(frontmatter.effort);
+    const mappedModel = resolveEffortToModel(frontmatter.effort, provider);
     const model = applyModelCeiling(mappedModel, ceilingModel);
     return { model, missingFrontmatter: false, warnings };
   }
@@ -196,13 +192,12 @@ export function createDoCommand(): Command {
     .alias('act')
     .argument('[project]', 'Project identifier: ID (00j3k1), name (my-project), or folder (00j3k1-my-project)')
     .option('-t, --timeout <minutes>', 'Timeout per task in minutes', '60')
-    .option('-v, --verbose', 'Show full Claude output')
+    .option('-v, --verbose', 'Show full LLM output')
     .option('-d, --debug', 'Save all logs and show debug output')
     .option('-f, --force', 'Re-run all tasks regardless of status')
-    .option('-m, --model <name>', 'Claude model to use (sonnet, haiku, opus)')
+    .option('-m, --model <name>', 'Model to use (sonnet, haiku, opus)')
     .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
-    .option('-w, --worktree', 'Execute tasks in a git worktree')
-    .option('--no-worktree', 'Disable worktree mode (overrides config)')
+    .option('-p, --provider <provider>', 'CLI provider to use (claude, codex)')
     .action(async (project: string | undefined, options: DoCommandOptions) => {
       await runDoCommand(project, options);
     });
@@ -213,8 +208,6 @@ export function createDoCommand(): Command {
 async function runDoCommand(projectIdentifierArg: string | undefined, options: DoCommandOptions): Promise<void> {
   const rafDir = getRafDir();
   let projectIdentifier = projectIdentifierArg;
-  let worktreeMode = options.worktree ?? getWorktreeDefault();
-
   // Validate and resolve model option
   let model: string;
   try {
@@ -224,48 +217,11 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
     process.exit(1);
   }
 
-  // Variables for worktree context (set when --worktree is used)
+  // Variables for worktree context (derived from where the project is found)
   let worktreeRoot: string | undefined;
   let originalBranch: string | undefined;
   let mainBranchName: string | null = null;
 
-  if (worktreeMode) {
-    // Validate git repo
-    const repoRoot = getRepoRoot();
-    if (!repoRoot) {
-      logger.error('--worktree requires a git repository');
-      process.exit(1);
-    }
-    const repoBasename = getRepoBasename()!;
-    const rafRelativePath = path.relative(repoRoot, rafDir);
-
-    // Record original branch before any worktree operations
-    originalBranch = getCurrentBranch() ?? undefined;
-
-    // Sync main branch before worktree operations (if enabled)
-    if (getSyncMainBranch()) {
-      const syncResult = pullMainBranch();
-      mainBranchName = syncResult.mainBranch;
-      if (syncResult.success) {
-        if (syncResult.hadChanges) {
-          logger.info(`Synced ${syncResult.mainBranch} from remote`);
-        }
-      } else {
-        logger.warn(`Could not sync main branch: ${syncResult.error}`);
-      }
-    }
-
-    if (!projectIdentifier) {
-      // Auto-discovery flow
-      const selected = await discoverAndPickWorktreeProject(repoBasename, rafDir, rafRelativePath);
-      if (!selected) {
-        process.exit(0);
-      }
-      worktreeRoot = selected.worktreeRoot;
-      projectIdentifier = selected.projectFolder;
-    }
-  }
-
   // Handle no project identifier (non-worktree mode) - show interactive picker
   if (!projectIdentifier) {
     // Discover worktree projects for the current repo (if in a git repo)
@@ -297,9 +253,8 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
       // Use the selected project
       projectIdentifier = selectedProject.folder;
 
-      // If a worktree project was selected, auto-switch to worktree mode
+      // If a worktree project was selected, record worktree context
       if (selectedProject.source === 'worktree' && selectedProject.worktreeRoot) {
-        worktreeMode = true;
         worktreeRoot = selectedProject.worktreeRoot;
         originalBranch = getCurrentBranch() ?? undefined;
       }
@@ -315,89 +270,20 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
   // Resolve project identifier
   let resolvedProject: { identifier: string; path: string; name: string } | undefined;
 
-  if (worktreeMode) {
-    // Worktree mode: resolve project inside the worktree
+  if (worktreeRoot) {
+    // Worktree was set by the picker — resolve project inside the worktree
     const repoRoot = getRepoRoot()!;
-    const repoBasename = getRepoBasename()!;
     const rafRelativePath = path.relative(repoRoot, rafDir);
-
-    // If worktreeRoot was set by auto-discovery, use it directly
-    if (worktreeRoot) {
-      const wtRafDir = path.join(worktreeRoot, rafRelativePath);
-      const result = resolveProjectIdentifierWithDetails(wtRafDir, projectIdentifier);
-      if (!result.path) {
-        logger.error(`Project not found in worktree: ${projectIdentifier}`);
-        process.exit(1);
-      }
-      const projectName = extractProjectName(result.path) ?? projectIdentifier;
-      resolvedProject = { identifier: projectIdentifier, path: result.path, name: projectName };
-    } else {
-      // Explicit identifier: resolve from main repo to get folder name, then validate worktree
-      const mainResult = resolveProjectIdentifierWithDetails(rafDir, projectIdentifier);
-
-      let projectFolderName: string;
-      if (mainResult.path) {
-        // Found in main repo - use its folder name
-        projectFolderName = path.basename(mainResult.path);
-      } else {
-        // Not found in main repo - try to find it in worktrees directly
-        // This handles projects that only exist in worktrees
-        const worktreeBaseDir = computeWorktreeBaseDir(repoBasename);
-        if (!fs.existsSync(worktreeBaseDir)) {
-          logger.error(`No worktree found for project "${projectIdentifier}". Did you plan with --worktree?`);
-          process.exit(1);
-        }
-
-        // Search worktrees for the project
-        const wtProjects = listWorktreeProjects(repoBasename);
-        let found = false;
-        for (const wtProjectDir of wtProjects) {
-          const wtPath = computeWorktreePath(repoBasename, wtProjectDir);
-          const wtRafDir = path.join(wtPath, rafRelativePath);
-          if (!fs.existsSync(wtRafDir)) continue;
-
-          const resolution = resolveProjectIdentifierWithDetails(wtRafDir, projectIdentifier);
-          if (resolution.path) {
-            projectFolderName = path.basename(resolution.path);
-            worktreeRoot = wtPath;
-            found = true;
-            break;
-          }
-        }
-
-        if (!found) {
-          logger.error(`No worktree found for project "${projectIdentifier}". Did you plan with --worktree?`);
-          process.exit(1);
-        }
-      }
-
-      // Compute worktree path if not already set
-      if (!worktreeRoot) {
-        worktreeRoot = computeWorktreePath(repoBasename, projectFolderName!);
-      }
-
-      // Validate the worktree
-      const wtProjectRelPath = path.join(rafRelativePath, projectFolderName!);
-      const validation = validateWorktree(worktreeRoot, wtProjectRelPath);
-
-      if (!validation.exists || !validation.isValidWorktree) {
-        logger.error(`No worktree found for project "${projectIdentifier}". Did you plan with --worktree?`);
-        logger.error(`Expected worktree at: ${worktreeRoot}`);
-        process.exit(1);
-      }
-
-      if (!validation.hasProjectFolder || !validation.hasPlans) {
-        logger.error(`Worktree exists but project content is missing.`);
-        logger.error(`Expected project folder at: ${validation.projectPath ?? path.join(worktreeRoot, wtProjectRelPath)}`);
-        process.exit(1);
-      }
-
-      const projectPath = validation.projectPath!;
-      const projectName = extractProjectName(projectPath) ?? projectIdentifier;
-      resolvedProject = { identifier: projectIdentifier, path: projectPath, name: projectName };
+    const wtRafDir = path.join(worktreeRoot, rafRelativePath);
+    const result = resolveProjectIdentifierWithDetails(wtRafDir, projectIdentifier);
+    if (!result.path) {
+      logger.error(`Project not found in worktree: ${projectIdentifier}`);
+      process.exit(1);
     }
+    const projectName = extractProjectName(result.path) ?? projectIdentifier;
+    resolvedProject = { identifier: projectIdentifier, path: result.path, name: projectName };
   } else {
-    // Standard mode: check worktrees first (worktree takes priority), then main repo
+    // Auto-detect: check worktrees first (worktree takes priority), then main repo
     const repoRoot = getRepoRoot();
     const repoBasename = repoRoot ? getRepoBasename() : null;
 
@@ -410,8 +296,6 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
         const wtProjectPath = path.join(wtRafDir, wtResolution.folder);
 
         if (fs.existsSync(wtProjectPath)) {
-          // Auto-switch to worktree mode
-          worktreeMode = true;
           worktreeRoot = wtResolution.worktreeRoot;
           originalBranch = getCurrentBranch() ?? undefined;
 
@@ -455,9 +339,26 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
   // Configure logger
   logger.configure({ verbose, debug });
 
-  // Show post-execution picker before task execution (worktree mode only)
+  // Worktree setup: sync main branch and show post-execution picker
   let postAction: PostExecutionAction = 'leave';
-  if (worktreeMode && worktreeRoot) {
+  if (worktreeRoot) {
+    if (!originalBranch) {
+      originalBranch = getCurrentBranch() ?? undefined;
+    }
+
+    // Sync main branch before worktree operations (if enabled)
+    if (getSyncMainBranch()) {
+      const syncResult = pullMainBranch();
+      mainBranchName = syncResult.mainBranch;
+      if (syncResult.success) {
+        if (syncResult.hadChanges) {
+          logger.info(`Synced ${syncResult.mainBranch} from remote`);
+        }
+      } else {
+        logger.warn(`Could not sync main branch: ${syncResult.error}`);
+      }
+    }
+
     try {
       postAction = await pickPostExecutionAction(worktreeRoot);
     } catch (error) {
@@ -498,6 +399,7 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
         maxRetries,
         autoCommit,
         model,
+        provider: options.provider,
         worktreeCwd: worktreeRoot,
       }
     );
@@ -508,7 +410,7 @@ async function runDoCommand(projectIdentifierArg: string | undefined, options: D
   }
 
   // Execute post-execution action based on picker choice
-  if (worktreeMode && worktreeRoot) {
+  if (worktreeRoot) {
     const worktreeBranch = path.basename(worktreeRoot);
 
     if (result.success) {
@@ -649,123 +551,6 @@ async function executePostAction(
   }
 }
 
-/**
- * Auto-discovery flow for `raf do --worktree` without a project identifier.
- * Lists worktree projects, finds latest completed main-tree project, filters,
- * and shows an interactive picker.
- *
- * @returns Selected project info or null if cancelled/no projects
- */
-async function discoverAndPickWorktreeProject(
-  repoBasename: string,
-  rafDir: string,
-  rafRelativePath: string,
-): Promise<{ worktreeRoot: string; projectFolder: string } | null> {
-  // List all worktree projects for this repo
-  const wtProjects = listWorktreeProjects(repoBasename);
-
-  if (wtProjects.length === 0) {
-    logger.error('No worktree projects found. Did you plan with --worktree?');
-    process.exit(1);
-  }
-
-  // Find the highest-numbered completed project in the MAIN tree
-  const mainProjects = discoverProjects(rafDir);
-  let highestCompletedNumber = 0;
-
-  for (const project of mainProjects) {
-    const state = deriveProjectState(project.path);
-    if (isProjectComplete(state) && state.tasks.length > 0) {
-      if (project.number > highestCompletedNumber) {
-        highestCompletedNumber = project.number;
-      }
-    }
-  }
-
-  // Filter threshold: highest completed - 3 (or 0 if none completed)
-  const threshold = highestCompletedNumber > 3 ? highestCompletedNumber - 3 : 0;
-
-  // Filter worktree projects by number threshold and completion status
-  const uncompletedProjects: Array<{
-    folder: string;
-    worktreeRoot: string;
-    projectPath: string;
-    completedTasks: number;
-    totalTasks: number;
-    projectNumber: number;
-  }> = [];
-
-  for (const wtProjectDir of wtProjects) {
-    // Extract project number from the worktree directory name
-    const numPrefix = extractProjectNumber(wtProjectDir);
-    if (!numPrefix) continue;
-    const projectNumber = parseProjectPrefix(numPrefix);
-    if (projectNumber === null) continue;
-
-    // Apply threshold filter
-    if (projectNumber < threshold) continue;
-
-    // Check if this worktree has a valid project
-    const wtPath = computeWorktreePath(repoBasename, wtProjectDir);
-    const wtProjectPath = path.join(wtPath, rafRelativePath, wtProjectDir);
-
-    if (!fs.existsSync(wtProjectPath)) continue;
-
-    // Derive project state from worktree
-    const state = deriveProjectState(wtProjectPath);
-    if (state.tasks.length === 0) continue;
-
-    // Keep only uncompleted projects
-    if (isProjectComplete(state)) continue;
-
-    const stats = getDerivedStats(state);
-    uncompletedProjects.push({
-      folder: wtProjectDir,
-      worktreeRoot: wtPath,
-      projectPath: wtProjectPath,
-      completedTasks: stats.completed,
-      totalTasks: stats.total,
-      projectNumber,
-    });
-  }
-
-  if (uncompletedProjects.length === 0) {
-    logger.info('All worktree projects are completed.');
-    return null;
-  }
-
-  // Sort by project number
-  uncompletedProjects.sort((a, b) => a.projectNumber - b.projectNumber);
-
-  // Show interactive picker (even if only one project)
-  const choices = uncompletedProjects.map((p) => {
-    const name = extractProjectName(p.folder) ?? p.folder;
-    const numPrefix = extractProjectNumber(p.folder) ?? '';
-    return {
-      name: `${numPrefix} ${name} (${p.completedTasks}/${p.totalTasks} tasks)`,
-      value: p,
-    };
-  });
-
-  try {
-    const selected = await select({
-      message: 'Select a worktree project to execute:',
-      choices,
-    });
-
-    return {
-      worktreeRoot: selected.worktreeRoot,
-      projectFolder: selected.folder,
-    };
-  } catch (error) {
-    // Handle Ctrl+C (user cancellation)
-    if (error instanceof Error && error.message.includes('User force closed')) {
-      return null;
-    }
-    throw error;
-  }
-}
-
 interface SingleProjectOptions {
   timeout: number;
   verbose: boolean;
@@ -774,7 +559,9 @@ interface SingleProjectOptions {
   maxRetries: number;
   autoCommit: boolean;
   model: string;
-  /** Worktree root directory. When set, Claude runs with cwd in the worktree. */
+  /** CLI provider to use (claude, codex). */
+  provider?: import('../types/config.js').HarnessProvider;
+  /** Worktree root directory. When set, the runner uses cwd in the worktree. */
   worktreeCwd?: string;
 }
 
@@ -783,7 +570,7 @@ async function executeSingleProject(
   projectName: string,
   options: SingleProjectOptions
 ): Promise<ProjectExecutionResult> {
-  const { timeout, verbose, debug, force, maxRetries, autoCommit, model, worktreeCwd } = options;
+  const { timeout, verbose, debug, force, maxRetries, autoCommit, model, provider, worktreeCwd } = options;
 
   if (!validatePlansExist(projectPath)) {
     return {
@@ -953,7 +740,7 @@ async function executeSingleProject(
     const taskId = task.id;  // Capture for closure
     const taskLabel = displayName !== task.id ? `${task.id} (${displayName})` : task.id;
 
-    // Handle blocked tasks separately - skip Claude execution
+    // Handle blocked tasks separately - skip LLM execution
     if (task.status === 'blocked') {
       // Find which dependency caused the block for the message
       const failedOrBlockedDeps = task.dependencies.filter((depId) => {
@@ -1056,6 +843,7 @@ async function executeSingleProject(
         undefined, // warnings already logged above
         ceilingModel,
         isRetry,
+        provider,
       );
 
       // Update current model for timer callback display
@@ -1067,7 +855,7 @@ async function executeSingleProject(
       }
 
       // Create a runner for this attempt's model
-      const taskRunner = new ClaudeRunner({ model: modelResolution.model });
+      const taskRunner = createRunner({ model: modelResolution.model, provider });
       shutdownHandler.registerClaudeRunner(taskRunner);
 
       if (verbose && isRetry) {
@@ -1108,7 +896,7 @@ async function executeSingleProject(
         outcomeFilePath,
       } : undefined;
 
-      // Run Claude (use worktree root as cwd if in worktree mode)
+      // Run task (use worktree root as cwd if in worktree mode)
       const runnerOptions = {
         timeout,
         outcomeFilePath,
@@ -1194,18 +982,18 @@ async function executeSingleProject(
     }
 
     if (success) {
-      // Check if Claude wrote an outcome file with valid marker
+      // Check if the LLM wrote an outcome file with valid marker
       // If so, keep it as-is; otherwise create fallback
       // NOTE: Successful outcomes do NOT get ## Details section appended
       let outcomeContent: string;
-      const claudeWroteOutcome = fs.existsSync(outcomeFilePath);
+      const llmWroteOutcome = fs.existsSync(outcomeFilePath);
 
-      if (claudeWroteOutcome) {
+      if (llmWroteOutcome) {
         const existingContent = fs.readFileSync(outcomeFilePath, 'utf-8');
         const status = parseOutcomeStatus(existingContent);
 
         if (status === 'completed') {
-          // Claude wrote a valid outcome - keep it as-is (no metadata added)
+          // LLM wrote a valid outcome - keep it as-is (no metadata added)
           outcomeContent = existingContent;
         } else {
           // Outcome file exists but no valid COMPLETE marker - create fallback