rafcode 3.0.0 → 3.8.0

package/src/commands/plan.ts

@@ -13,27 +13,23 @@ import {
   validateEnvironment,
   reportValidation,
   validateProjectName,
-  resolveModelOption,
 } from '../utils/validation.js';
 import { logger } from '../utils/logger.js';
-import { getWorktreeDefault, getModel, getModelShortName, getSyncMainBranch } from '../utils/config.js';
+import { formatModelDisplay, getModel } from '../utils/config.js';
+import type { ModelEntry } from '../types/config.js';
 import { generateProjectNames } from '../utils/name-generator.js';
 import { pickProjectName } from '../ui/name-picker.js';
 import {
   getPlansDir,
   getRafDir,
-  getNextProjectNumber,
-  formatProjectNumber,
   resolveProjectIdentifierWithDetails,
   getInputPath,
-  getDecisionsPath,
-  getOutcomesDir,
   extractTaskNameFromPlanFile,
   decodeTaskId,
   encodeTaskId,
   TASK_ID_PATTERN,
+  numericFileSort,
 } from '../utils/paths.js';
-import { sanitizeProjectName } from '../utils/validation.js';
 import {
   deriveProjectState,
   isProjectComplete,
@@ -42,24 +38,14 @@ import {
 import {
   getRepoBasename,
   getRepoRoot,
-  createWorktree,
-  createWorktreeFromBranch,
-  branchExists,
   validateWorktree,
-  removeWorktree,
-  computeWorktreeBaseDir,
-  pullMainBranch,
   resolveWorktreeProjectByIdentifier,
 } from '../core/worktree.js';
 
 interface PlanCommandOptions {
   amend?: boolean;
-  model?: string;
-  sonnet?: boolean;
   auto?: boolean;
-  worktree?: boolean;
   resume?: string;
-  provider?: string;
 }
 
 export function createPlanCommand(): Command {
@@ -70,28 +56,15 @@ export function createPlanCommand(): Command {
       '-a, --amend',
       'Add tasks to an existing project (requires project identifier as argument)'
     )
-    .option('-m, --model <name>', 'Model to use (sonnet, haiku, opus)')
-    .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
     .option('-y, --auto', 'Skip permission prompts for file operations')
-    .option('-w, --worktree', 'Create a git worktree for isolated planning')
-    .option('--no-worktree', 'Disable worktree mode (overrides config)')
     .option('-r, --resume <identifier>', 'Resume a planning session for an existing project')
-    .option('-p, --provider <provider>', 'CLI provider to use (claude, codex)')
     .action(async (projectName: string | undefined, options: PlanCommandOptions) => {
-      // Validate and resolve model option
-      let model: string;
-      try {
-        model = resolveModelOption(options.model, options.sonnet, 'plan');
-      } catch (error) {
-        logger.error((error as Error).message);
-        process.exit(1);
-      }
+      const modelEntry = getModel('plan');
 
       const autoMode = options.auto ?? false;
-      const worktreeMode = options.worktree ?? getWorktreeDefault();
 
       if (options.resume) {
-        await runResumeCommand(options.resume, model);
+        await runResumeCommand(options.resume, modelEntry);
       } else if (options.amend) {
         if (!projectName) {
           logger.error('--amend requires a project identifier');
@@ -99,16 +72,16 @@ export function createPlanCommand(): Command {
           logger.error('   or: raf plan --amend <project>');
           process.exit(1);
         }
-        await runAmendCommand(projectName, model, autoMode, worktreeMode);
+        await runAmendCommand(projectName, modelEntry, autoMode);
       } else {
-        await runPlanCommand(projectName, model, autoMode, worktreeMode);
+        await runPlanCommand(projectName, modelEntry, autoMode);
       }
     });
 
   return command;
 }
 
-async function runPlanCommand(projectName?: string, model?: string, autoMode: boolean = false, worktreeMode: boolean = false): Promise<void> {
+async function runPlanCommand(projectName?: string, modelEntry?: ModelEntry, autoMode: boolean = false): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -124,7 +97,6 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     const mainResult = resolveProjectIdentifierWithDetails(rafDir, projectName);
 
     let existingFolder: string | null = null;
-    let existingWorktreeMode = false;
 
     if (mainResult.path) {
       existingFolder = path.basename(mainResult.path);
@@ -134,7 +106,6 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
         const wtResult = resolveWorktreeProjectByIdentifier(repoBasename, projectName);
         if (wtResult) {
           existingFolder = wtResult.folder;
-          existingWorktreeMode = true;
         }
       }
     }
@@ -153,7 +124,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
       });
 
       if (answer === 'amend') {
-        await runAmendCommand(existingFolder, model, autoMode, existingWorktreeMode);
+        await runAmendCommand(existingFolder, modelEntry, autoMode);
         return;
       } else if (answer === 'cancel') {
         logger.info('Aborted.');
@@ -163,15 +134,6 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     }
   }
 
-  // Validate git repo for worktree mode
-  if (worktreeMode) {
-    const repoRoot = getRepoRoot();
-    if (!repoRoot) {
-      logger.error('--worktree requires a git repository');
-      process.exit(1);
-    }
-  }
-
   // Open editor for user input
   logger.info('Opening editor for project description...');
   logger.info('(Save and close the editor when done)');
@@ -199,7 +161,8 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   // Get or generate project name
   let finalProjectName = projectName;
   if (!finalProjectName) {
-    const nameModel = getModelShortName(getModel('nameGeneration'));
+    const nameEntry = getModel('nameGeneration');
+    const nameModel = formatModelDisplay(nameEntry.model);
     logger.info(`Generating project name suggestions with ${nameModel}...`);
     const suggestedNames = await generateProjectNames(cleanInput);
     logger.newline();
@@ -219,103 +182,32 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     process.exit(1);
   }
 
-  let projectPath: string;
-  let worktreePath: string | null = null;
-  let worktreeBranch: string | null = null;
-
-  if (worktreeMode) {
-    // Worktree mode: create worktree, then project folder inside it
-    const repoBasename = getRepoBasename()!;
-    const repoRoot = getRepoRoot()!;
-    const rafDir = getRafDir();
-
-    // Sync main branch before creating worktree (if enabled)
-    if (getSyncMainBranch()) {
-      const syncResult = pullMainBranch();
-      if (syncResult.success) {
-        if (syncResult.hadChanges) {
-          logger.info(`Synced ${syncResult.mainBranch} from remote`);
-        }
-      } else {
-        logger.warn(`Could not sync main branch: ${syncResult.error}`);
-      }
-    }
-
-    // Compute project number from main repo's RAF directory (scan worktrees too)
-    const projectNumber = getNextProjectNumber(rafDir, repoBasename);
-    const sanitizedName = sanitizeProjectName(finalProjectName);
-    const folderName = `${formatProjectNumber(projectNumber)}-${sanitizedName}`;
-
-    // Create worktree
-    const result = createWorktree(repoBasename, folderName);
-    if (!result.success) {
-      logger.error(`Failed to create worktree: ${result.error}`);
-      process.exit(1);
-    }
-
-    worktreePath = result.worktreePath;
-    worktreeBranch = result.branch;
+  // Standard mode: create project in main repo
+  const projectManager = new ProjectManager();
+  const projectPath = projectManager.createProject(finalProjectName);
 
-    // Compute project path inside worktree at the same relative path
-    const rafRelativePath = path.relative(repoRoot, rafDir);
-    projectPath = path.join(worktreePath, rafRelativePath, folderName);
-
-    // Create project folder structure inside the worktree
-    fs.mkdirSync(projectPath, { recursive: true });
-    fs.mkdirSync(getPlansDir(projectPath), { recursive: true });
-    fs.mkdirSync(getOutcomesDir(projectPath), { recursive: true });
-    fs.writeFileSync(getDecisionsPath(projectPath), '# Project Decisions\n');
-
-    // Save input inside worktree project folder
-    fs.writeFileSync(getInputPath(projectPath), userInput);
-
-    logger.success(`Created worktree: ${worktreePath}`);
-    logger.success(`Branch: ${worktreeBranch}`);
-    logger.success(`Project: ${projectPath}`);
-    logger.newline();
-  } else {
-    // Standard mode: create project in main repo
-    const projectManager = new ProjectManager();
-    projectPath = projectManager.createProject(finalProjectName);
-
-    logger.success(`Created project: ${projectPath}`);
-    logger.newline();
+  logger.success(`Created project: ${projectPath}`);
+  logger.newline();
 
-    // Save input
-    projectManager.saveInput(projectPath, userInput);
-  }
+  // Save input
+  projectManager.saveInput(projectPath, userInput);
 
   // Set up shutdown handler
-  const claudeRunner = createRunner({ model });
+  const claudeRunner = createRunner({ model: modelEntry?.model, harness: modelEntry?.harness, reasoningEffort: modelEntry?.reasoningEffort, fast: modelEntry?.fast });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
   // Register cleanup callback
   shutdownHandler.onShutdown(() => {
-    if (worktreeMode && worktreePath) {
-      // Clean up worktree if no plans were created
-      const plansDir = getPlansDir(projectPath);
-      const hasPlanFiles = fs.existsSync(plansDir) &&
-        fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).length > 0;
-      if (!hasPlanFiles) {
-        const removal = removeWorktree(worktreePath);
-        if (removal.success) {
-          logger.debug(`Cleaned up worktree: ${worktreePath}`);
-        } else {
-          logger.warn(`Failed to clean up worktree: ${removal.error}`);
-        }
-      }
-    } else {
-      const projectManager = new ProjectManager();
-      projectManager.cleanupEmptyProject(projectPath);
-    }
+    const projectManager = new ProjectManager();
+    projectManager.cleanupEmptyProject(projectPath);
   });
 
   // Run planning session
   logger.info('Starting planning session...');
   logger.info('The planner will interview you about each task.');
-  if (model) {
-    logger.info(`Using model: ${model}`);
+  if (modelEntry) {
+    logger.info(`Using model: ${formatModelDisplay(modelEntry.model, modelEntry.harness, { includeHarness: true })}`);
   }
   if (autoMode) {
     logger.warn('Auto mode enabled: permission prompts will be skipped.');
@@ -325,14 +217,11 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   const { systemPrompt, userMessage } = getPlanningPrompt({
     projectPath,
     inputContent: userInput,
-    worktreeMode,
   });
 
   try {
     const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
       dangerouslySkipPermissions: autoMode,
-      // Run session in the worktree root if in worktree mode
-      cwd: worktreePath ?? undefined,
     });
 
     if (exitCode !== 0) {
@@ -342,7 +231,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     // Check for created plan files
     const plansDir = getPlansDir(projectPath);
     const planFiles = fs.existsSync(plansDir)
-      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
+      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort(numericFileSort)
       : [];
 
     if (planFiles.length === 0) {
@@ -359,45 +248,23 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
       // Commit planning artifacts (input.md, decisions.md, and plan files)
       const planAbsolutePaths = planFiles.map((f) => path.join(plansDir, f));
       await commitPlanningArtifacts(projectPath, {
-        cwd: worktreePath ?? undefined,
         additionalFiles: planAbsolutePaths,
       });
 
       logger.newline();
-      if (worktreeMode) {
-        logger.info(`Worktree: ${worktreePath}`);
-        logger.info(`Branch: ${worktreeBranch}`);
-        logger.info(`Run 'raf do ${finalProjectName} --worktree' to execute the plans.`);
-      } else {
-        logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
-      }
+      logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
     }
   } catch (error) {
     logger.error(`Planning failed: ${error}`);
     throw error;
   } finally {
-    if (worktreeMode && worktreePath) {
-      // Clean up worktree if no plans were created
-      const plansDir = getPlansDir(projectPath);
-      const hasPlanFiles = fs.existsSync(plansDir) &&
-        fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).length > 0;
-      if (!hasPlanFiles) {
-        const removal = removeWorktree(worktreePath);
-        if (removal.success) {
-          logger.debug(`Cleaned up worktree: ${worktreePath}`);
-        } else {
-          logger.warn(`Failed to clean up worktree: ${removal.error}`);
-        }
-      }
-    } else if (!worktreeMode) {
-      // Cleanup empty project folder if no plans were created (standard mode only)
-      const projectManager = new ProjectManager();
-      projectManager.cleanupEmptyProject(projectPath);
-    }
+    // Cleanup empty project folder if no plans were created
+    const projectManager = new ProjectManager();
+    projectManager.cleanupEmptyProject(projectPath);
   }
 }
 
-async function runAmendCommand(identifier: string, model?: string, autoMode: boolean = false, worktreeMode: boolean = false): Promise<void> {
+async function runAmendCommand(identifier: string, modelEntry?: ModelEntry, autoMode: boolean = false): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -406,112 +273,26 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     process.exit(1);
   }
 
+  // Auto-detect project location: check worktrees first, then main repo
   let worktreePath: string | null = null;
-  let projectPath: string;
-
-  if (worktreeMode) {
-    // Worktree mode: resolve project from worktree directory
-    const repoBasename = getRepoBasename();
-    if (!repoBasename) {
-      logger.error('--worktree requires a git repository');
-      process.exit(1);
-    }
-
-    const repoRoot = getRepoRoot()!;
-    const rafDir = getRafDir();
-    const rafRelativePath = path.relative(repoRoot, rafDir);
-
-    const worktreeBaseDir = computeWorktreeBaseDir(repoBasename);
-
-    // Search through existing worktree directories for the project
-    let matchedWorktreeDir: string | null = null;
-    let matchedProjectPath: string | null = null;
-
-    if (fs.existsSync(worktreeBaseDir)) {
-      const entries = fs.readdirSync(worktreeBaseDir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const wtPath = path.join(worktreeBaseDir, entry.name);
-        const wtRafDir = path.join(wtPath, rafRelativePath);
-        if (!fs.existsSync(wtRafDir)) continue;
-
-        const resolution = resolveProjectIdentifierWithDetails(wtRafDir, identifier);
-        if (resolution.path) {
-          if (matchedWorktreeDir) {
-            logger.error(`Ambiguous: project "${identifier}" found in multiple worktrees`);
-            process.exit(1);
-          }
-          matchedWorktreeDir = wtPath;
-          matchedProjectPath = resolution.path;
-        }
-      }
-    }
-
-    if (!matchedWorktreeDir || !matchedProjectPath) {
-      // Worktree not found — try to recreate it
-      // First, resolve the project from the main repo to get the folder name
-      const mainResolution = resolveProjectIdentifierWithDetails(rafDir, identifier);
-      if (!mainResolution.path) {
-        logger.error(`Project not found in any worktree or main repo: ${identifier}`);
-        logger.error(`Searched in: ${worktreeBaseDir}`);
-        process.exit(1);
-      }
-
-      const folderName = path.basename(mainResolution.path);
+  let projectPath: string | undefined;
 
-      if (branchExists(folderName)) {
-        // Branch exists — recreate worktree from it
-        const result = createWorktreeFromBranch(repoBasename, folderName);
-        if (!result.success) {
-          logger.error(`Failed to recreate worktree from branch: ${result.error}`);
-          process.exit(1);
-        }
-        matchedWorktreeDir = result.worktreePath;
-        matchedProjectPath = path.join(result.worktreePath, rafRelativePath, folderName);
-        logger.info(`Recreated worktree from branch: ${folderName}`);
-      } else {
-        // No branch — create fresh worktree and copy project files
-        // Sync main branch before creating worktree (if enabled)
-        if (getSyncMainBranch()) {
-          const syncResult = pullMainBranch();
-          if (syncResult.success) {
-            if (syncResult.hadChanges) {
-              logger.info(`Synced ${syncResult.mainBranch} from remote`);
-            }
-          } else {
-            logger.warn(`Could not sync main branch: ${syncResult.error}`);
-          }
-        }
+  const repoBasename = getRepoBasename();
+  const rafDir = getRafDir();
 
-        const result = createWorktree(repoBasename, folderName);
-        if (!result.success) {
-          logger.error(`Failed to create worktree: ${result.error}`);
-          process.exit(1);
-        }
-        matchedWorktreeDir = result.worktreePath;
-        const wtProjectPath = path.join(result.worktreePath, rafRelativePath, folderName);
-        // Copy project folder from main repo into the new worktree
-        fs.cpSync(mainResolution.path, wtProjectPath, { recursive: true });
-        matchedProjectPath = wtProjectPath;
-        logger.info(`Created fresh worktree and copied project files: ${folderName}`);
-      }
+  // 1. Try worktree resolution first (if we're in a git repo)
+  if (repoBasename) {
+    const wtResult = resolveWorktreeProjectByIdentifier(repoBasename, identifier);
+    if (wtResult) {
+      const repoRoot = getRepoRoot()!;
+      const rafRelativePath = path.relative(repoRoot, rafDir);
+      worktreePath = wtResult.worktreeRoot;
+      projectPath = path.join(wtResult.worktreeRoot, rafRelativePath, wtResult.folder);
     }
+  }
 
-    worktreePath = matchedWorktreeDir;
-    projectPath = matchedProjectPath;
-
-    // Validate the worktree is valid
-    const relProjectPath = path.relative(worktreePath, projectPath);
-    const wtValidation = validateWorktree(worktreePath, relProjectPath);
-    if (!wtValidation.isValidWorktree) {
-      logger.error(`Invalid worktree at: ${worktreePath}`);
-      logger.error('The worktree may have been removed or corrupted.');
-      process.exit(1);
-    }
-  } else {
-    // Standard mode: resolve from main repo
-    const rafDir = getRafDir();
+  // 2. Fall back to main repo
+  if (!projectPath) {
     const resolution = resolveProjectIdentifierWithDetails(rafDir, identifier);
 
     if (!resolution.path) {
@@ -570,7 +351,7 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
   // Show existing tasks summary
   logger.info('Amending existing project:');
   logger.info(`  Path: ${projectPath}`);
-  if (worktreeMode && worktreePath) {
+  if (worktreePath) {
     logger.info(`  Worktree: ${worktreePath}`);
   }
   logger.info(`  Existing tasks: ${existingTasks.length}`);
@@ -616,15 +397,15 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
   fs.writeFileSync(inputPath, updatedInput);
 
   // Set up shutdown handler
-  const claudeRunner = createRunner({ model });
+  const claudeRunner = createRunner({ model: modelEntry?.model, harness: modelEntry?.harness, reasoningEffort: modelEntry?.reasoningEffort, fast: modelEntry?.fast });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
   // Run amend planning session
   logger.info('Starting amendment session...');
   logger.info('The planner will interview you about each new task.');
-  if (model) {
-    logger.info(`Using model: ${model}`);
+  if (modelEntry) {
+    logger.info(`Using model: ${formatModelDisplay(modelEntry.model, modelEntry.harness, { includeHarness: true })}`);
   }
   if (autoMode) {
     logger.warn('Auto mode enabled: permission prompts will be skipped.');
@@ -636,7 +417,6 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     existingTasks,
     nextTaskNumber,
     newTaskDescription: cleanInput,
-    worktreeMode,
   });
 
   try {
@@ -652,7 +432,7 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
 
     // Check for new plan files
     const allPlanFiles = fs.existsSync(plansDir)
-      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
+      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort(numericFileSort)
       : [];
 
     const newPlanFiles = allPlanFiles.filter((f) => {
@@ -687,11 +467,7 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     if (newPlanFiles.length > 0) {
       logger.newline();
       logger.info(`Total tasks: ${allPlanFiles.length}`);
-      if (worktreeMode) {
-        logger.info(`Run 'raf do ${identifier} --worktree' to execute the new tasks.`);
-      } else {
-        logger.info(`Run 'raf do ${identifier}' to execute the new tasks.`);
-      }
+      logger.info(`Run 'raf do ${identifier}' to execute the new tasks.`);
     }
   } catch (error) {
     logger.error(`Amendment failed: ${error}`);
@@ -729,7 +505,7 @@ ${taskList}
 `;
 }
 
-async function runResumeCommand(identifier: string, model?: string): Promise<void> {
+async function runResumeCommand(identifier: string, modelEntry?: ModelEntry): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -793,13 +569,13 @@ async function runResumeCommand(identifier: string, model?: string): Promise<voi
   }
 
   logger.info(`Project: ${folderName}`);
-  if (model) {
-    logger.info(`Model: ${model}`);
+  if (modelEntry) {
+    logger.info(`Model: ${formatModelDisplay(modelEntry.model, modelEntry.harness, { includeHarness: true })}`);
   }
   logger.newline();
 
   // Set up shutdown handler
-  const claudeRunner = createRunner({ model });
+  const claudeRunner = createRunner({ model: modelEntry?.model, harness: modelEntry?.harness, reasoningEffort: modelEntry?.reasoningEffort, fast: modelEntry?.fast });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
@@ -817,7 +593,7 @@ async function runResumeCommand(identifier: string, model?: string): Promise<voi
     // Check for created/updated plan files after resume session
     const plansDir = getPlansDir(projectPath);
     const planFiles = fs.existsSync(plansDir)
-      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
+      ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort(numericFileSort)
       : [];
 
     if (planFiles.length > 0) {