rafcode 2.5.1 → 3.2.1

package/src/commands/plan.ts

@@ -1,8 +1,9 @@
 import * as fs from 'node:fs';
 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 { openEditor, getInputTemplate } from '../core/editor.js';
 import { shutdownHandler } from '../core/shutdown-handler.js';
 import { commitPlanningArtifacts } from '../core/git.js';
@@ -23,7 +24,6 @@ import {
   getRafDir,
   getNextProjectNumber,
   formatProjectNumber,
-  resolveProjectIdentifier,
   resolveProjectIdentifierWithDetails,
   getInputPath,
   getDecisionsPath,
@@ -32,6 +32,7 @@ import {
   decodeTaskId,
   encodeTaskId,
   TASK_ID_PATTERN,
+  numericFileSort,
 } from '../utils/paths.js';
 import { sanitizeProjectName } from '../utils/validation.js';
 import {
@@ -43,11 +44,8 @@ import {
   getRepoBasename,
   getRepoRoot,
   createWorktree,
-  createWorktreeFromBranch,
-  branchExists,
   validateWorktree,
   removeWorktree,
-  computeWorktreeBaseDir,
   pullMainBranch,
   resolveWorktreeProjectByIdentifier,
 } from '../core/worktree.js';
@@ -59,22 +57,24 @@ interface PlanCommandOptions {
   auto?: boolean;
   worktree?: boolean;
   resume?: string;
+  provider?: string;
 }
 
 export function createPlanCommand(): Command {
   const command = new Command('plan')
-    .description('Create a new project and interactively plan tasks with Claude')
+    .description('Create a new project and interactively plan tasks')
     .argument('[projectName]', 'Optional project name (will be prompted if not provided)')
     .option(
       '-a, --amend',
       'Add tasks to an existing project (requires project identifier as argument)'
     )
-    .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('-y, --auto', "Skip Claude's permission prompts for file operations")
+    .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;
@@ -88,8 +88,10 @@ export function createPlanCommand(): Command {
       const autoMode = options.auto ?? false;
       const worktreeMode = options.worktree ?? getWorktreeDefault();
 
+      const provider = options.provider as import('../types/config.js').HarnessProvider | undefined;
+
       if (options.resume) {
-        await runResumeCommand(options.resume, model);
+        await runResumeCommand(options.resume, model, provider);
       } else if (options.amend) {
         if (!projectName) {
           logger.error('--amend requires a project identifier');
@@ -97,16 +99,16 @@ export function createPlanCommand(): Command {
           logger.error('   or: raf plan --amend <project>');
           process.exit(1);
         }
-        await runAmendCommand(projectName, model, autoMode, worktreeMode);
+        await runAmendCommand(projectName, model, autoMode, provider);
       } else {
-        await runPlanCommand(projectName, model, autoMode, worktreeMode);
+        await runPlanCommand(projectName, model, autoMode, worktreeMode, provider);
       }
     });
 
   return command;
 }
 
-async function runPlanCommand(projectName?: string, model?: string, autoMode: boolean = false, worktreeMode: boolean = false): Promise<void> {
+async function runPlanCommand(projectName?: string, model?: string, autoMode: boolean = false, worktreeMode: boolean = false, provider?: import('../types/config.js').HarnessProvider): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -116,13 +118,46 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   }
 
   // Check if project name matches an existing project
+  // This runs even in auto mode — silently duplicating a project is worse than interrupting
   if (projectName) {
     const rafDir = getRafDir();
-    const existingProject = resolveProjectIdentifier(rafDir, projectName);
-    if (existingProject) {
-      logger.error(`Project already exists: ${existingProject}`);
-      logger.error(`To add tasks to an existing project, use: raf plan --amend ${projectName}`);
-      process.exit(1);
+    const mainResult = resolveProjectIdentifierWithDetails(rafDir, projectName);
+
+    let existingFolder: string | null = null;
+
+    if (mainResult.path) {
+      existingFolder = path.basename(mainResult.path);
+    } else {
+      const repoBasename = getRepoBasename();
+      if (repoBasename) {
+        const wtResult = resolveWorktreeProjectByIdentifier(repoBasename, projectName);
+        if (wtResult) {
+          existingFolder = wtResult.folder;
+        }
+      }
+    }
+
+    if (existingFolder) {
+      const numMatch = existingFolder.match(/^(\d+)-/);
+      const projectId = numMatch ? numMatch[1] : existingFolder;
+
+      const answer = await select({
+        message: `Project '${projectName}' already exists (ID: ${projectId}). Did you want to amend it?`,
+        choices: [
+          { name: 'Yes, amend it', value: 'amend' },
+          { name: 'No, create a new project', value: 'create' },
+          { name: 'Cancel', value: 'cancel' },
+        ],
+      });
+
+      if (answer === 'amend') {
+        await runAmendCommand(existingFolder, model, autoMode, provider);
+        return;
+      } else if (answer === 'cancel') {
+        logger.info('Aborted.');
+        process.exit(0);
+      }
+      // 'create': fall through to normal project creation
     }
   }
 
@@ -204,8 +239,8 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
       }
     }
 
-    // Compute project number from main repo's RAF directory
-    const projectNumber = getNextProjectNumber(rafDir);
+    // 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}`;
 
@@ -249,7 +284,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   }
 
   // Set up shutdown handler
-  const claudeRunner = new ClaudeRunner({ model });
+  const claudeRunner = createRunner({ model, provider });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
@@ -275,8 +310,8 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   });
 
   // Run planning session
-  logger.info('Starting planning session with Claude...');
-  logger.info('Claude will interview you about each task.');
+  logger.info('Starting planning session...');
+  logger.info('The planner will interview you about each task.');
   if (model) {
     logger.info(`Using model: ${model}`);
   }
@@ -294,18 +329,18 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   try {
     const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
       dangerouslySkipPermissions: autoMode,
-      // Run Claude session in the worktree root if in worktree mode
+      // Run session in the worktree root if in worktree mode
       cwd: worktreePath ?? undefined,
     });
 
     if (exitCode !== 0) {
-      logger.warn(`Claude exited with code ${exitCode}`);
+      logger.warn(`Process exited with code ${exitCode}`);
     }
 
     // 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) {
@@ -330,7 +365,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
       if (worktreeMode) {
         logger.info(`Worktree: ${worktreePath}`);
         logger.info(`Branch: ${worktreeBranch}`);
-        logger.info(`Run 'raf do ${finalProjectName} --worktree' to execute the plans.`);
+        logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
       } else {
         logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
       }
@@ -360,7 +395,7 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
   }
 }
 
-async function runAmendCommand(identifier: string, model?: string, autoMode: boolean = false, worktreeMode: boolean = false): Promise<void> {
+async function runAmendCommand(identifier: string, model?: string, autoMode: boolean = false, provider?: import('../types/config.js').HarnessProvider): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -369,112 +404,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) {
@@ -518,7 +467,7 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     }
   );
 
-  // Calculate next task number (decode base36 task IDs)
+  // Calculate next task number (numeric task IDs)
   const maxTaskNumber = Math.max(
     ...projectState.tasks.map((t) => decodeTaskId(t.id) ?? 0)
   );
@@ -533,7 +482,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}`);
@@ -579,13 +528,13 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
   fs.writeFileSync(inputPath, updatedInput);
 
   // Set up shutdown handler
-  const claudeRunner = new ClaudeRunner({ model });
+  const claudeRunner = createRunner({ model, provider });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
   // Run amend planning session
-  logger.info('Starting amendment session with Claude...');
-  logger.info('Claude will interview you about each new task.');
+  logger.info('Starting amendment session...');
+  logger.info('The planner will interview you about each new task.');
   if (model) {
     logger.info(`Using model: ${model}`);
   }
@@ -599,23 +548,22 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     existingTasks,
     nextTaskNumber,
     newTaskDescription: cleanInput,
-    worktreeMode,
   });
 
   try {
     const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
       dangerouslySkipPermissions: autoMode,
-      // Run Claude session in the worktree root if in worktree mode
+      // Run session in the worktree root if in worktree mode
       cwd: worktreePath ?? undefined,
     });
 
     if (exitCode !== 0) {
-      logger.warn(`Claude exited with code ${exitCode}`);
+      logger.warn(`Process exited with code ${exitCode}`);
     }
 
     // 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) => {
@@ -636,22 +584,21 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
       for (const planFile of newPlanFiles) {
         logger.info(`  - plans/${planFile}`);
       }
+    }
 
-      // Commit planning artifacts (input.md, decisions.md, and new plan files)
-      const newPlanAbsolutePaths = newPlanFiles.map((f) => path.join(plansDir, f));
-      await commitPlanningArtifacts(projectPath, {
-        cwd: worktreePath ?? undefined,
-        isAmend: true,
-        additionalFiles: newPlanAbsolutePaths,
-      });
+    // Commit planning artifacts (input.md, decisions.md, and all plan files)
+    // Always attempt commit — even without new plans, existing files may have been updated
+    const allPlanAbsolutePaths = allPlanFiles.map((f) => path.join(plansDir, f));
+    await commitPlanningArtifacts(projectPath, {
+      cwd: worktreePath ?? undefined,
+      isAmend: true,
+      additionalFiles: allPlanAbsolutePaths,
+    });
 
+    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}`);
@@ -689,7 +636,7 @@ ${taskList}
 `;
 }
 
-async function runResumeCommand(identifier: string, model?: string): Promise<void> {
+async function runResumeCommand(identifier: string, model?: string, provider?: import('../types/config.js').HarnessProvider): Promise<void> {
   // Validate environment
   const validation = validateEnvironment();
   reportValidation(validation);
@@ -759,25 +706,25 @@ async function runResumeCommand(identifier: string, model?: string): Promise<voi
   logger.newline();
 
   // Set up shutdown handler
-  const claudeRunner = new ClaudeRunner({ model });
+  const claudeRunner = createRunner({ model, provider });
   shutdownHandler.init();
   shutdownHandler.registerClaudeRunner(claudeRunner);
 
-  // Launch Claude's resume picker
-  logger.info('Starting Claude session resume picker...');
+  // Launch session resume picker
+  logger.info('Starting session resume picker...');
   logger.newline();
 
   try {
     const exitCode = await claudeRunner.runResume({ cwd: resumeCwd });
 
     if (exitCode !== 0) {
-      logger.warn(`Claude exited with code ${exitCode}`);
+      logger.warn(`Process exited with code ${exitCode}`);
     }
 
     // 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) {

package/src/commands/status.ts

@@ -26,7 +26,7 @@ const MAX_DISPLAYED_PROJECTS = 10;
 export function createStatusCommand(): Command {
   const command = new Command('status')
     .description('Show status of a project or list all projects')
-    .argument('[identifier]', 'Project identifier: ID (00j3k1), name (my-project), or folder (00j3k1-my-project)')
+    .argument('[identifier]', 'Project identifier: number (3), name (my-project), or folder (3-my-project)')
     .option('--json', 'Output as JSON')
     .action(async (identifier?: string, options?: StatusCommandOptions) => {
       await runStatusCommand(identifier, options);