rafcode 1.3.2 → 2.1.0

package/src/core/worktree.ts

@@ -0,0 +1,434 @@
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { logger } from '../utils/logger.js';
+import { extractProjectNumber, extractProjectName, isBase26Prefix, decodeBase26 } from '../utils/paths.js';
+
+export interface WorktreeCreateResult {
+  success: boolean;
+  worktreePath: string;
+  branch: string;
+  error?: string;
+}
+
+export interface WorktreeMergeResult {
+  success: boolean;
+  merged: boolean;
+  fastForward: boolean;
+  error?: string;
+}
+
+export interface WorktreeValidation {
+  exists: boolean;
+  isValidWorktree: boolean;
+  hasProjectFolder: boolean;
+  hasPlans: boolean;
+  projectPath: string | null;
+}
+
+/**
+ * Get the git toplevel directory (repo root).
+ * Returns null if not in a git repo.
+ */
+export function getRepoRoot(): string | null {
+  try {
+    return execSync('git rev-parse --show-toplevel', { encoding: 'utf-8', stdio: 'pipe' }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the basename of the repo root directory.
+ * E.g., "/Users/me/projects/myapp" -> "myapp"
+ * Returns null if not in a git repo.
+ */
+export function getRepoBasename(): string | null {
+  const root = getRepoRoot();
+  if (!root) {
+    return null;
+  }
+  return path.basename(root);
+}
+
+/**
+ * Get the current branch name.
+ * Returns null if not in a git repo or in detached HEAD state.
+ */
+export function getCurrentBranch(): string | null {
+  try {
+    const branch = execSync('git branch --show-current', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compute the worktree path for a project.
+ * Returns `~/.raf/worktrees/<repo-basename>/<project-id>`.
+ *
+ * @param repoBasename - The basename of the repo root directory
+ * @param projectId - The full project folder name (e.g., "020-worktree-weaver")
+ */
+export function computeWorktreePath(repoBasename: string, projectId: string): string {
+  return path.join(os.homedir(), '.raf', 'worktrees', repoBasename, projectId);
+}
+
+/**
+ * Compute the worktree base directory for a repo.
+ * Returns `~/.raf/worktrees/<repo-basename>/`.
+ *
+ * @param repoBasename - The basename of the repo root directory
+ */
+export function computeWorktreeBaseDir(repoBasename: string): string {
+  return path.join(os.homedir(), '.raf', 'worktrees', repoBasename);
+}
+
+/**
+ * Get the project path inside a worktree.
+ * The project folder is at the same relative path from repo root as in the main repo.
+ *
+ * @param worktreePath - The worktree root directory
+ * @param projectRelativePath - The relative path from repo root to the project folder (e.g., "RAF/020-worktree-weaver")
+ */
+export function getWorktreeProjectPath(worktreePath: string, projectRelativePath: string): string {
+  return path.join(worktreePath, projectRelativePath);
+}
+
+/**
+ * Create a git worktree at the computed path with a new branch.
+ *
+ * @param repoBasename - The basename of the repo root directory
+ * @param projectId - The full project folder name (used as both directory name and branch name)
+ */
+export function createWorktree(repoBasename: string, projectId: string): WorktreeCreateResult {
+  const worktreePath = computeWorktreePath(repoBasename, projectId);
+  const branch = projectId;
+
+  // Ensure parent directory exists
+  const baseDir = computeWorktreeBaseDir(repoBasename);
+  try {
+    fs.mkdirSync(baseDir, { recursive: true });
+  } catch (error) {
+    return {
+      success: false,
+      worktreePath,
+      branch,
+      error: `Failed to create parent directory ${baseDir}: ${error}`,
+    };
+  }
+
+  try {
+    execSync(`git worktree add "${worktreePath}" -b "${branch}"`, {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+    return { success: true, worktreePath, branch };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      worktreePath,
+      branch,
+      error: `Failed to create worktree: ${msg}`,
+    };
+  }
+}
+
+/**
+ * Validate that a worktree exists, is a valid git worktree, and contains the expected project content.
+ *
+ * @param worktreePath - The worktree root directory
+ * @param projectRelativePath - The relative path from repo root to the project folder
+ */
+export function validateWorktree(worktreePath: string, projectRelativePath: string): WorktreeValidation {
+  const result: WorktreeValidation = {
+    exists: false,
+    isValidWorktree: false,
+    hasProjectFolder: false,
+    hasPlans: false,
+    projectPath: null,
+  };
+
+  // Check directory exists
+  if (!fs.existsSync(worktreePath)) {
+    return result;
+  }
+  result.exists = true;
+
+  // Check it appears in git worktree list
+  try {
+    const listOutput = execSync('git worktree list --porcelain', { encoding: 'utf-8', stdio: 'pipe' });
+    const normalizedWorktreePath = path.resolve(worktreePath);
+    const isListed = listOutput.split('\n').some(line => {
+      if (line.startsWith('worktree ')) {
+        const listedPath = path.resolve(line.slice('worktree '.length).trim());
+        return listedPath === normalizedWorktreePath;
+      }
+      return false;
+    });
+    result.isValidWorktree = isListed;
+  } catch {
+    return result;
+  }
+
+  // Check project folder exists in worktree
+  const projectPath = getWorktreeProjectPath(worktreePath, projectRelativePath);
+  if (fs.existsSync(projectPath)) {
+    result.hasProjectFolder = true;
+    result.projectPath = projectPath;
+
+    // Check for plans directory
+    const plansDir = path.join(projectPath, 'plans');
+    if (fs.existsSync(plansDir)) {
+      result.hasPlans = true;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Merge a worktree branch into the current branch.
+ * Attempts fast-forward first; falls back to merge commit.
+ * On conflicts, aborts merge and returns failure.
+ *
+ * MUST be called from the original repo (not the worktree).
+ *
+ * @param branch - The branch name to merge (typically the project folder name)
+ * @param originalBranch - The branch to merge into (the branch that was active when worktree was created)
+ */
+export function mergeWorktreeBranch(branch: string, originalBranch: string): WorktreeMergeResult {
+  // Switch to the original branch
+  try {
+    execSync(`git checkout "${originalBranch}"`, { encoding: 'utf-8', stdio: 'pipe' });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      merged: false,
+      fastForward: false,
+      error: `Failed to checkout ${originalBranch}: ${msg}`,
+    };
+  }
+
+  // Try fast-forward merge first
+  try {
+    execSync(`git merge --ff-only "${branch}"`, { encoding: 'utf-8', stdio: 'pipe' });
+    return { success: true, merged: true, fastForward: true };
+  } catch {
+    // Fast-forward not possible, try regular merge
+  }
+
+  // Try regular merge
+  try {
+    execSync(`git merge "${branch}"`, { encoding: 'utf-8', stdio: 'pipe' });
+    return { success: true, merged: true, fastForward: false };
+  } catch {
+    // Merge conflicts - abort
+    try {
+      execSync('git merge --abort', { encoding: 'utf-8', stdio: 'pipe' });
+    } catch {
+      logger.warn('Failed to abort merge - repo may be in an inconsistent state');
+    }
+
+    return {
+      success: false,
+      merged: false,
+      fastForward: false,
+      error: `Merge conflicts detected. Please merge branch "${branch}" into "${originalBranch}" manually.`,
+    };
+  }
+}
+
+/**
+ * Remove a single worktree.
+ * Used for failed-plan cleanup and post-completion cleanup.
+ * The git branch is preserved — only the worktree directory is removed.
+ *
+ * @param worktreePath - The worktree directory to remove
+ * @returns true if removal succeeded, false otherwise
+ */
+export function removeWorktree(worktreePath: string): { success: boolean; error?: string } {
+  try {
+    execSync(`git worktree remove "${worktreePath}"`, { encoding: 'utf-8', stdio: 'pipe' });
+    return { success: true };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to remove worktree at ${worktreePath}: ${msg}`,
+    };
+  }
+}
+
+/**
+ * Check if a local branch exists.
+ *
+ * @param branchName - The branch name to check
+ * @returns true if the branch exists locally
+ */
+export function branchExists(branchName: string): boolean {
+  try {
+    const output = execSync(`git branch --list "${branchName}"`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    return output.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create a git worktree at the computed path from an existing branch.
+ * Unlike `createWorktree()`, this does NOT create a new branch — it attaches
+ * to a branch that already exists locally.
+ *
+ * @param repoBasename - The basename of the repo root directory
+ * @param projectId - The full project folder name (used as both directory name and branch name)
+ */
+export function createWorktreeFromBranch(repoBasename: string, projectId: string): WorktreeCreateResult {
+  const worktreePath = computeWorktreePath(repoBasename, projectId);
+  const branch = projectId;
+
+  // Check branch exists
+  if (!branchExists(branch)) {
+    return {
+      success: false,
+      worktreePath,
+      branch,
+      error: `Branch "${branch}" does not exist locally`,
+    };
+  }
+
+  // Ensure parent directory exists
+  const baseDir = computeWorktreeBaseDir(repoBasename);
+  try {
+    fs.mkdirSync(baseDir, { recursive: true });
+  } catch (error) {
+    return {
+      success: false,
+      worktreePath,
+      branch,
+      error: `Failed to create parent directory ${baseDir}: ${error}`,
+    };
+  }
+
+  try {
+    execSync(`git worktree add "${worktreePath}" "${branch}"`, {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+    return { success: true, worktreePath, branch };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      worktreePath,
+      branch,
+      error: `Failed to create worktree: ${msg}`,
+    };
+  }
+}
+
+/**
+ * List all worktree project directories for the current repo.
+ * Scans `~/.raf/worktrees/<repo-basename>/` and returns the list of project folder names.
+ *
+ * @param repoBasename - The basename of the repo root directory
+ * @returns Sorted array of project folder names (e.g., ['020-worktree-weaver', '021-another-feature'])
+ */
+export function listWorktreeProjects(repoBasename: string): string[] {
+  const baseDir = computeWorktreeBaseDir(repoBasename);
+
+  if (!fs.existsSync(baseDir)) {
+    return [];
+  }
+
+  try {
+    const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+    const projects = entries
+      .filter(entry => entry.isDirectory())
+      .map(entry => entry.name)
+      .sort();
+    return projects;
+  } catch {
+    return [];
+  }
+}
+
+export interface WorktreeProjectResolution {
+  /** The worktree project folder name (e.g., "ahrren-turbo-finder") */
+  folder: string;
+  /** The worktree root path (e.g., ~/.raf/worktrees/RAF/ahrren-turbo-finder) */
+  worktreeRoot: string;
+}
+
+/**
+ * Resolve a project identifier against worktree folder names.
+ * Uses the same matching strategy as `resolveProjectIdentifierWithDetails`:
+ * 1. Full folder name match (exact, case-insensitive)
+ * 2. Base26 prefix match (6-char ID)
+ * 3. Project name match (the portion after the prefix)
+ *
+ * @param repoBasename - The basename of the current git repo
+ * @param identifier - The project identifier to resolve
+ * @returns The matched worktree project info or null if not found
+ */
+export function resolveWorktreeProjectByIdentifier(
+  repoBasename: string,
+  identifier: string,
+): WorktreeProjectResolution | null {
+  const wtProjectDirs = listWorktreeProjects(repoBasename);
+  if (wtProjectDirs.length === 0) return null;
+
+  const lowerIdentifier = identifier.toLowerCase();
+
+  // 1. Full folder name match (exact, case-insensitive)
+  for (const dir of wtProjectDirs) {
+    if (dir.toLowerCase() === lowerIdentifier) {
+      return {
+        folder: dir,
+        worktreeRoot: computeWorktreePath(repoBasename, dir),
+      };
+    }
+  }
+
+  // 2. Base26 prefix match
+  if (isBase26Prefix(identifier)) {
+    const targetNumber = decodeBase26(identifier);
+    if (targetNumber !== null) {
+      for (const dir of wtProjectDirs) {
+        const prefix = extractProjectNumber(dir);
+        if (prefix) {
+          const dirNumber = decodeBase26(prefix);
+          if (dirNumber === targetNumber) {
+            return {
+              folder: dir,
+              worktreeRoot: computeWorktreePath(repoBasename, dir),
+            };
+          }
+        }
+      }
+    }
+  }
+
+  // 3. Project name match (case-insensitive)
+  const nameMatches: string[] = [];
+  for (const dir of wtProjectDirs) {
+    const name = extractProjectName(dir);
+    if (name && name.toLowerCase() === lowerIdentifier) {
+      nameMatches.push(dir);
+    }
+  }
+
+  if (nameMatches.length === 1) {
+    return {
+      folder: nameMatches[0]!,
+      worktreeRoot: computeWorktreePath(repoBasename, nameMatches[0]!),
+    };
+  }
+
+  // Ambiguous or no match
+  return null;
+}

package/src/index.ts

@@ -4,6 +4,7 @@ import { Command } from 'commander';
 import { createPlanCommand } from './commands/plan.js';
 import { createDoCommand } from './commands/do.js';
 import { createStatusCommand } from './commands/status.js';
+import { createMigrateCommand } from './commands/migrate.js';
 import { getVersion } from './utils/version.js';
 
 const program = new Command();
@@ -16,5 +17,6 @@ program
 program.addCommand(createPlanCommand());
 program.addCommand(createDoCommand());
 program.addCommand(createStatusCommand());
+program.addCommand(createMigrateCommand());
 
 program.parse();

package/src/parsers/stream-renderer.ts

@@ -11,6 +11,7 @@
 export interface StreamEvent {
   type: string;
   subtype?: string;
+  session_id?: string;
   message?: {
     content?: ContentBlock[];
   };
@@ -72,6 +73,8 @@ export interface RenderResult {
   display: string;
   /** Text content to accumulate for output parsing (completion markers, etc.) */
   textContent: string;
+  /** Session ID extracted from system init event, if present */
+  sessionId?: string;
 }
 
 /**
@@ -93,7 +96,7 @@ export function renderStreamEvent(line: string): RenderResult {
 
   switch (event.type) {
     case 'system':
-      return { display: '', textContent: '' };
+      return { display: '', textContent: '', sessionId: event.session_id };
 
     case 'assistant':
       return renderAssistant(event);

package/src/prompts/amend.ts

@@ -1,10 +1,12 @@
 import { DerivedTask } from '../core/state-derivation.js';
+import { encodeTaskId } from '../utils/paths.js';
 
 export interface AmendPromptParams {
   projectPath: string;
   existingTasks: Array<DerivedTask & { taskName: string }>;
   nextTaskNumber: number;
   newTaskDescription: string;
+  worktreeMode?: boolean;
 }
 
 export interface AmendPromptResult {
@@ -23,7 +25,9 @@ export function getAmendPrompt(params: AmendPromptParams): AmendPromptResult {
     existingTasks,
     nextTaskNumber,
     newTaskDescription,
+    worktreeMode,
   } = params;
+  const worktreeFlag = worktreeMode ? ' --worktree' : '';
 
   const existingTasksSummary = existingTasks
     .map((task) => {
@@ -63,7 +67,7 @@ You are in AMENDMENT MODE. This means:
 - You MAY modify [MODIFIABLE] tasks (pending/failed) if the user requests changes
 - NEVER modify [PROTECTED] tasks (completed) - their outcomes depend on the original plan
 - DO NOT renumber existing tasks
-- You can create NEW tasks starting from number ${nextTaskNumber.toString().padStart(3, '0')}
+- You can create NEW tasks starting from number ${encodeTaskId(nextTaskNumber)}
 
 ## Project Location
 
@@ -101,7 +105,7 @@ Read the user's description of new tasks and identify what needs to be added. Co
 **Identifying Follow-up Tasks**: When a new task is a follow-up, fix, or iteration of a previously completed task, you MUST reference the previous task's outcome in the new plan's Context section. This gives the executing agent full context about what was done before.
 
 Use this format in the Context section:
-\`This is a follow-up to task NNN. See outcome: {projectPath}/outcomes/NNN-task-name.md\`
+\`This is a follow-up to task NN. See outcome: {projectPath}/outcomes/NN-task-name.md\`
 
 The outcome file paths for completed tasks are listed above in the Existing Tasks section.
 
@@ -127,8 +131,8 @@ Use this format:
 ### Step 4: Create New Plan Files
 
 After interviewing the user about all NEW tasks, create plan files starting from the next available number:
-- ${projectPath}/plans/${nextTaskNumber.toString().padStart(3, '0')}-task-name.md
-- ${projectPath}/plans/${(nextTaskNumber + 1).toString().padStart(3, '0')}-task-name.md
+- ${projectPath}/plans/${encodeTaskId(nextTaskNumber)}-task-name.md
+- ${projectPath}/plans/${encodeTaskId(nextTaskNumber + 1)}-task-name.md
 - etc.
 
 Each plan file should follow this structure:
@@ -142,11 +146,11 @@ Each plan file should follow this structure:
 ## Context
 [Why this task is needed, how it fits into the larger project]
 [Reference relevant existing tasks if applicable]
-[For follow-up/fix tasks: "This is a follow-up to task NNN. See outcome: {projectPath}/outcomes/NNN-task-name.md"]
+[For follow-up/fix tasks: "This is a follow-up to task NN. See outcome: {projectPath}/outcomes/NN-task-name.md"]
 
 ## 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
@@ -181,7 +185,9 @@ After creating all new plan files:
 2. Display this exit message to the user:
 
 \`\`\`
-Planning complete! Press Ctrl-C twice to exit to exit this session 
+Planning complete! To exit this session and run your tasks:
+  1. Press Ctrl-C twice to exit
+  2. Then run: raf do <project>${worktreeFlag}
 \`\`\`
 
 ## Important Rules
@@ -189,10 +195,10 @@ Planning complete! Press Ctrl-C twice to exit to exit this session
 1. NEVER modify COMPLETED task plans - they are [PROTECTED] because their outcomes depend on the original plan
 2. You MAY modify non-completed task plans (pending/failed) if the user requests changes - they are [MODIFIABLE]
 3. ALWAYS interview the user before creating or modifying plans
-4. New tasks start from number ${nextTaskNumber.toString().padStart(3, '0')}
+4. New tasks start from number ${encodeTaskId(nextTaskNumber)}
 5. Use descriptive, kebab-case names for plan files
 6. Each plan should be self-contained with all context needed
-7. Specify task dependencies using the ## Dependencies section with task IDs only (e.g., "001, 002")
+7. Specify task dependencies using the ## Dependencies section with task IDs only (e.g., "01, 02")
 8. Tasks without dependencies should omit the Dependencies section entirely
 9. Be specific - vague plans lead to poor execution
 

package/src/prompts/execution.ts

@@ -83,8 +83,8 @@ ${previousOutcomes.map((o) => `### Task ${o.taskId}\n${o.content}`).join('\n\n')
 `;
   }
 
-  // Zero-pad task number to 3 digits
-  const paddedTaskNumber = taskNumber.toString().padStart(3, '0');
+  // Encode task number to 2-char base36
+  const paddedTaskNumber = taskNumber.toString(36).padStart(2, '0');
 
   const commitInstructions = autoCommit
     ? `
@@ -98,6 +98,8 @@ After successfully completing the task:
 2. Commit with message: "RAF[${projectNumber}:${paddedTaskNumber}] <description>"
    - Write a concise description of what was accomplished
    - Focus on the actual change, not the task name
+   - The commit message must be a SINGLE LINE — no body, no trailers
+   - Do NOT add Co-Authored-By or any other trailers to the commit message
 
 **IMPORTANT - On Failure**: If the task fails, do NOT commit. Just write the outcome file with the \`<promise>FAILED</promise>\` marker and stop. Uncommitted changes will be preserved for debugging.
 `

package/src/prompts/planning.ts

@@ -1,6 +1,7 @@
 export interface PlanningPromptParams {
   projectPath: string;
   inputContent: string;
+  worktreeMode?: boolean;
 }
 
 export interface PlanningPromptResult {
@@ -14,7 +15,8 @@ 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.
 
@@ -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,15 @@ export interface DoCommandOptions {
   force?: boolean;
   model?: ClaudeModelName;
   sonnet?: boolean;
+  worktree?: boolean;
+  resume?: string;
 }
 
 export interface StatusCommandOptions {
   json?: boolean;
 }
+
+export interface MigrateCommandOptions {
+  dryRun?: boolean;
+  worktree?: boolean;
+}