rafcode 1.2.0 → 2.0.0

package/src/prompts/planning.ts

@@ -1,6 +1,7 @@
 export interface PlanningPromptParams {
   projectPath: string;
   inputContent: string;
+  worktreeMode?: boolean;
 }
 
 export interface PlanningPromptResult {
@@ -14,13 +15,14 @@ export interface PlanningPromptResult {
  * - userMessage: Reference to input.md file (via positional argument, triggers Claude to start)
  */
 export function getPlanningPrompt(params: PlanningPromptParams): PlanningPromptResult {
-  const { projectPath } = params;
+  const { projectPath, worktreeMode } = params;
+  const worktreeFlag = worktreeMode ? ' --worktree' : '';
 
   const systemPrompt = `You are a project planning assistant for RAF (Ralph's Automation Framework). Your task is to analyze the user's project description and create detailed task plans.
 
 ## Your Goals
 
-1. **Analyze the input** and identify 3-8 distinct, actionable tasks
+1. **Analyze the input** and identify distinct, actionable tasks
 2. **Interview the user** about EACH task to gather specific requirements
 3. **Create plan files** for each task with clear instructions
 
@@ -32,7 +34,7 @@ Project folder: ${projectPath}
 
 ### Step 1: Identify and Order Tasks
 
-Based on the project description, identify 3-8 distinct tasks. Each task should:
+Based on the project description, identify distinct tasks. Each task should:
 - Be independently completable
 - Have a clear outcome
 - Take roughly 10-30 minutes of work for Claude
@@ -74,8 +76,8 @@ This file serves as documentation of design choices made during planning. Append
 ### Step 3: Create Plan Files
 
 After interviewing the user about all tasks, create plan files in the plans folder:
-- ${projectPath}/plans/001-task-name.md
-- ${projectPath}/plans/002-task-name.md
+- ${projectPath}/plans/01-task-name.md
+- ${projectPath}/plans/02-task-name.md
 - etc.
 
 Each plan file should follow this structure:
@@ -91,7 +93,7 @@ Each plan file should follow this structure:
 
 ## Dependencies
 [Optional section - omit if task has no dependencies]
-[Comma-separated list of task IDs this task depends on, e.g., "001, 002"]
+[Comma-separated list of task IDs this task depends on, e.g., "01, 02"]
 [If a dependency fails, this task will be automatically blocked]
 
 ## Requirements
@@ -128,12 +130,12 @@ For each task, analyze which other tasks must complete successfully before it ca
 **Dependency format examples:**
 \`\`\`markdown
 ## Dependencies
-001
+01
 \`\`\`
 or for multiple dependencies:
 \`\`\`markdown
 ## Dependencies
-001, 002
+01, 02
 \`\`\`
 
 **Rules for dependencies:**
@@ -151,13 +153,13 @@ After creating all plan files:
 \`\`\`
 Planning complete! To exit this session and run your tasks:
   1. Press Ctrl-C twice to exit
-  2. Then run: raf do <project>
+  2. Then run: raf do <project>${worktreeFlag}
 \`\`\`
 
 ## Important Rules
 
 1. ALWAYS interview the user before creating plans
-2. Create plans in numbered order (001, 002, 003, etc.) reflecting logical execution order
+2. Create plans in numbered order (01, 02, 03, etc.) reflecting logical execution order
 3. Use descriptive, kebab-case names for plan files
 4. Each plan should be self-contained with all context needed
 5. Infer dependencies automatically - analyze task relationships, don't ask the user about dependencies

package/src/types/config.ts

@@ -28,8 +28,14 @@ export interface DoCommandOptions {
   force?: boolean;
   model?: ClaudeModelName;
   sonnet?: boolean;
+  worktree?: boolean;
 }
 
 export interface StatusCommandOptions {
   json?: boolean;
 }
+
+export interface MigrateCommandOptions {
+  dryRun?: boolean;
+  worktree?: boolean;
+}

package/src/ui/project-picker.ts

@@ -1,6 +1,16 @@
 import { select } from '@inquirer/prompts';
 import { discoverProjects, deriveProjectState, getDerivedStats } from '../core/state-derivation.js';
-import { extractProjectNumber, formatProjectNumber } from '../utils/paths.js';
+import { extractProjectNumber, extractProjectName, parseProjectPrefix, formatProjectNumber } from '../utils/paths.js';
+import { listWorktreeProjects, computeWorktreePath } from '../core/worktree.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/**
+ * Source of a pending project.
+ * - 'local': project lives in the main repo's RAF directory
+ * - 'worktree': project lives in a git worktree under ~/.raf/worktrees/
+ */
+export type ProjectSource = 'local' | 'worktree';
 
 /**
  * Information about a pending project for display in the picker.
@@ -12,6 +22,9 @@ export interface PendingProjectInfo {
   path: string;
   completedTasks: number;
   totalTasks: number;
+  source: ProjectSource;
+  /** Worktree root directory — only set when source is 'worktree'. */
+  worktreeRoot?: string;
 }
 
 /**
@@ -38,6 +51,7 @@ export function getPendingProjects(rafDir: string): PendingProjectInfo[] {
         path: project.path,
         completedTasks: stats.completed,
         totalTasks: stats.total,
+        source: 'local',
       });
     }
   }
@@ -48,27 +62,109 @@ export function getPendingProjects(rafDir: string): PendingProjectInfo[] {
 
 /**
  * Format a project for display in the picker.
- * Example: "001 fix-auth-bug (2/5 tasks)"
+ * Example: "aaaaab fix-auth-bug (2/5 tasks)"
+ * Worktree projects get a "[worktree]" suffix: "aaaaab my-feature (2/5 tasks) [worktree]"
  */
 export function formatProjectChoice(project: PendingProjectInfo): string {
   const projectNumber = extractProjectNumber(project.path) ?? formatProjectNumber(project.number);
-  return `${projectNumber} ${project.name} (${project.completedTasks}/${project.totalTasks} tasks)`;
+  const base = `${projectNumber} ${project.name} (${project.completedTasks}/${project.totalTasks} tasks)`;
+  return project.source === 'worktree' ? `${base} [worktree]` : base;
+}
+
+/**
+ * Get pending worktree projects for the current repo.
+ * Scans `~/.raf/worktrees/<repoBasename>/` for projects with pending tasks.
+ *
+ * @param repoBasename - The basename of the current git repo
+ * @param rafRelativePath - The relative path from repo root to the RAF directory (e.g., "RAF")
+ * @returns Pending worktree projects sorted by number
+ */
+export function getPendingWorktreeProjects(
+  repoBasename: string,
+  rafRelativePath: string,
+): PendingProjectInfo[] {
+  const wtProjectDirs = listWorktreeProjects(repoBasename);
+  const pendingProjects: PendingProjectInfo[] = [];
+
+  for (const wtProjectDir of wtProjectDirs) {
+    const numPrefix = extractProjectNumber(wtProjectDir);
+    if (!numPrefix) continue;
+    const projectNumber = parseProjectPrefix(numPrefix);
+    if (projectNumber === null) continue;
+
+    const wtPath = computeWorktreePath(repoBasename, wtProjectDir);
+    const wtProjectPath = path.join(wtPath, rafRelativePath, wtProjectDir);
+
+    if (!fs.existsSync(wtProjectPath)) continue;
+
+    const state = deriveProjectState(wtProjectPath);
+    if (state.tasks.length === 0) continue;
+
+    const stats = getDerivedStats(state);
+
+    // Include projects that are not fully completed
+    if (stats.pending > 0 || stats.failed > 0) {
+      const name = extractProjectName(wtProjectDir) ?? wtProjectDir;
+      pendingProjects.push({
+        folder: wtProjectDir,
+        number: projectNumber,
+        name,
+        path: wtProjectPath,
+        completedTasks: stats.completed,
+        totalTasks: stats.total,
+        source: 'worktree',
+        worktreeRoot: wtPath,
+      });
+    }
+  }
+
+  return pendingProjects.sort((a, b) => a.number - b.number);
+}
+
+/**
+ * Result of the project picker — includes the selected project's folder name
+ * and its source metadata so callers know whether to enable worktree mode.
+ */
+export interface PickerResult {
+  folder: string;
+  source: ProjectSource;
+  worktreeRoot?: string;
 }
 
 /**
  * Display an interactive project picker for pending projects.
- * Returns the selected project folder name or null if no projects or cancelled.
+ * Returns the selected project info or null if no projects or cancelled.
+ *
+ * @param rafDir - The main repo's RAF directory
+ * @param worktreeProjects - Optional worktree projects to merge into the picker
  */
-export async function pickPendingProject(rafDir: string): Promise<string | null> {
-  const pendingProjects = getPendingProjects(rafDir);
+export async function pickPendingProject(
+  rafDir: string,
+  worktreeProjects?: PendingProjectInfo[],
+): Promise<PickerResult | null> {
+  const localProjects = getPendingProjects(rafDir);
+  const allProjects = [...localProjects, ...(worktreeProjects ?? [])];
+
+  // Deduplicate: if a project folder appears in both local and worktree, keep only worktree
+  const seen = new Map<string, PendingProjectInfo>();
+  for (const project of allProjects) {
+    const existing = seen.get(project.folder);
+    if (!existing || project.source === 'worktree') {
+      seen.set(project.folder, project);
+    }
+  }
+  const deduped = Array.from(seen.values());
+
+  // Sort chronologically by number
+  deduped.sort((a, b) => a.number - b.number);
 
-  if (pendingProjects.length === 0) {
+  if (deduped.length === 0) {
     return null;
   }
 
-  const choices = pendingProjects.map((project) => ({
+  const choices = deduped.map((project) => ({
     name: formatProjectChoice(project),
-    value: project.folder,
+    value: project,
   }));
 
   const selected = await select({
@@ -76,5 +172,9 @@ export async function pickPendingProject(rafDir: string): Promise<string | null>
     choices,
   });
 
-  return selected;
+  return {
+    folder: selected.folder,
+    source: selected.source,
+    worktreeRoot: selected.worktreeRoot,
+  };
 }