rafcode 2.5.0-0 → 2.5.0

package/src/commands/plan.ts

@@ -49,6 +49,7 @@ import {
   removeWorktree,
   computeWorktreeBaseDir,
   pullMainBranch,
+  resolveWorktreeProjectByIdentifier,
 } from '../core/worktree.js';
 
 interface PlanCommandOptions {
@@ -690,54 +691,58 @@ async function runResumeCommand(identifier: string, model?: string): Promise<voi
     process.exit(1);
   }
 
-  // First, try to resolve the project from main repo
+  // Try to resolve the project from worktrees first, then fall back to main repo
+  const repoBasename = getRepoBasename();
   const rafDir = getRafDir();
-  const mainResolution = resolveProjectIdentifierWithDetails(rafDir, identifier);
-
-  if (!mainResolution.path) {
-    if (mainResolution.error === 'ambiguous' && mainResolution.matches) {
-      logger.error(`Ambiguous project name: ${identifier}`);
-      logger.error('Multiple projects match:');
-      for (const match of mainResolution.matches) {
-        logger.error(`  - ${match.folder}`);
+
+  let projectPath: string | undefined;
+  let resumeCwd: string | undefined;
+  let folderName: string | undefined;
+
+  // 1. Try worktree resolution first (if we're in a git repo)
+  if (repoBasename) {
+    const worktreeResolution = resolveWorktreeProjectByIdentifier(repoBasename, identifier);
+
+    if (worktreeResolution) {
+      // Found in worktree - validate and use it
+      const wtValidation = validateWorktree(worktreeResolution.worktreeRoot, '');
+
+      if (wtValidation.isValidWorktree) {
+        folderName = worktreeResolution.folder;
+        const repoRoot = getRepoRoot()!;
+        const rafRelativePath = path.relative(repoRoot, rafDir);
+        projectPath = path.join(worktreeResolution.worktreeRoot, rafRelativePath, folderName);
+        resumeCwd = worktreeResolution.worktreeRoot;
+        logger.info(`Resuming session in worktree: ${resumeCwd}`);
+      } else {
+        logger.warn(`Worktree found but invalid: ${worktreeResolution.worktreeRoot}`);
+        logger.warn('Falling back to main repo resolution.');
+        // Fall through to main repo resolution
       }
-      logger.error('Please specify the project ID or full folder name.');
-    } else {
-      logger.error(`Project not found: ${identifier}`);
     }
-    process.exit(1);
   }
 
-  const projectPath = mainResolution.path;
-  const folderName = path.basename(projectPath);
-
-  // Determine if this is a worktree project by checking if a worktree exists
-  let resumeCwd = projectPath; // Default to main repo project path
-  const repoBasename = getRepoBasename();
-
-  if (repoBasename) {
-    const worktreeBaseDir = computeWorktreeBaseDir(repoBasename);
+  // 2. If not found in worktree (or invalid), try main repo
+  if (!projectPath) {
+    const mainResolution = resolveProjectIdentifierWithDetails(rafDir, identifier);
 
-    // Check if a worktree exists for this project
-    if (fs.existsSync(worktreeBaseDir)) {
-      const entries = fs.readdirSync(worktreeBaseDir, { withFileTypes: true });
-      const worktreeEntry = entries.find(
-        (entry) => entry.isDirectory() && entry.name === folderName
-      );
-
-      if (worktreeEntry) {
-        // Worktree exists - use it as the CWD
-        const worktreePath = path.join(worktreeBaseDir, worktreeEntry.name);
-        const wtValidation = validateWorktree(worktreePath, '');
-        if (wtValidation.isValidWorktree) {
-          resumeCwd = worktreePath;
-          logger.info(`Resuming session in worktree: ${worktreePath}`);
-        } else {
-          logger.warn(`Worktree found but invalid: ${worktreePath}`);
-          logger.warn('Falling back to main repo path.');
+    if (!mainResolution.path) {
+      if (mainResolution.error === 'ambiguous' && mainResolution.matches) {
+        logger.error(`Ambiguous project name: ${identifier}`);
+        logger.error('Multiple projects match:');
+        for (const match of mainResolution.matches) {
+          logger.error(`  - ${match.folder}`);
         }
+        logger.error('Please specify the project ID or full folder name.');
+      } else {
+        logger.error(`Project not found: ${identifier}`);
       }
+      process.exit(1);
     }
+
+    projectPath = mainResolution.path;
+    folderName = path.basename(projectPath);
+    resumeCwd = projectPath; // Use main repo project path as CWD
   }
 
   logger.info(`Project: ${folderName}`);

package/src/index.ts

@@ -4,7 +4,6 @@ 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 { createConfigCommand } from './commands/config.js';
 import { getVersion } from './utils/version.js';
 
@@ -18,7 +17,6 @@ program
 program.addCommand(createPlanCommand());
 program.addCommand(createDoCommand());
 program.addCommand(createStatusCommand());
-program.addCommand(createMigrateCommand());
 program.addCommand(createConfigCommand());
 
 program.parse();

package/src/prompts/amend.ts

@@ -200,7 +200,9 @@ This is rarely needed — prefer using the \`effort\` label so the user's config
 
 After creating all new plan files:
 1. Provide a summary of:
-   - The new tasks you've created
+   - The new tasks you've created, including the effort level for each task. Example format:
+     - Task 02: add-caching (effort: medium)
+     - Task 03: update-docs (effort: low)
    - How they relate to existing tasks
    - Total task count in the project
 2. Display this exit message to the user:

package/src/prompts/planning.ts

@@ -168,7 +168,10 @@ or for multiple dependencies:
 ### Step 5: Confirm Completion
 
 After creating all plan files:
-1. Provide a summary of the tasks you've created
+1. Provide a summary of the tasks you've created, including the effort level for each task. Example:
+   - Task 01: setup-database (effort: low)
+   - Task 02: implement-auth (effort: medium)
+   - Task 03: refactor-api (effort: high)
 2. Display this exit message to the user:
 
 \`\`\`

package/src/types/config.ts

@@ -138,11 +138,6 @@ export interface StatusCommandOptions {
   json?: boolean;
 }
 
-export interface MigrateCommandOptions {
-  dryRun?: boolean;
-  worktree?: boolean;
-}
-
 /** Per-model token usage breakdown from stream-json result event. */
 export interface ModelTokenUsage {
   inputTokens: number;

package/tests/unit/plan-resume-worktree-resolution.test.ts

@@ -0,0 +1,153 @@
+import { jest } from '@jest/globals';
+
+/**
+ * Tests for worktree resolution in the --resume command.
+ *
+ * When `raf plan --resume <identifier>` is run, it should:
+ * 1. Search worktrees first
+ * 2. Fall back to main repo if not found in worktree
+ * 3. Auto-detect worktree mode without requiring --worktree flag
+ */
+
+describe('Plan Resume - Worktree Resolution Logic', () => {
+  describe('resolution flow logic', () => {
+    it('should prioritize worktree over main repo when both exist', () => {
+      // This test verifies the conceptual resolution order used in runResumeCommand:
+      // 1. Try worktree resolution via resolveWorktreeProjectByIdentifier()
+      // 2. If found and valid → use worktree path and worktree root as CWD
+      // 3. If not found → fall back to main repo resolution
+
+      // Simulating the flow:
+      const worktreeFound = true;
+      const worktreeValid = true;
+
+      let useWorktree = false;
+      let useMainRepo = false;
+
+      // Step 1: Try worktree
+      if (worktreeFound && worktreeValid) {
+        useWorktree = true;
+      }
+
+      // Step 2: Fall back to main repo if worktree not used
+      if (!useWorktree) {
+        useMainRepo = true;
+      }
+
+      expect(useWorktree).toBe(true);
+      expect(useMainRepo).toBe(false);
+    });
+
+    it('should fall back to main repo when worktree is invalid', () => {
+      const worktreeFound = true;
+      const worktreeValid = false;
+
+      let useWorktree = false;
+      let useMainRepo = false;
+
+      if (worktreeFound && worktreeValid) {
+        useWorktree = true;
+      }
+
+      if (!useWorktree) {
+        useMainRepo = true;
+      }
+
+      expect(useWorktree).toBe(false);
+      expect(useMainRepo).toBe(true);
+    });
+
+    it('should fall back to main repo when worktree not found', () => {
+      const worktreeFound = false;
+
+      let useWorktree = false;
+      let useMainRepo = false;
+
+      if (worktreeFound) {
+        useWorktree = true;
+      }
+
+      if (!useWorktree) {
+        useMainRepo = true;
+      }
+
+      expect(useWorktree).toBe(false);
+      expect(useMainRepo).toBe(true);
+    });
+  });
+
+  describe('resumeCwd determination', () => {
+    it('should set resumeCwd to worktree root when project found in valid worktree', () => {
+      // Simulated values
+      const worktreeRoot = '/Users/user/.raf/worktrees/RAF/ahwvrz-legacy-sunset';
+      const projectPath = '/Users/user/.raf/worktrees/RAF/ahwvrz-legacy-sunset/RAF/ahwvrz-legacy-sunset';
+
+      const worktreeValid = true;
+      let resumeCwd: string | undefined;
+
+      if (worktreeValid) {
+        resumeCwd = worktreeRoot;
+      }
+
+      expect(resumeCwd).toBe(worktreeRoot);
+    });
+
+    it('should set resumeCwd to project path when using main repo', () => {
+      const mainRepoProjectPath = '/Users/user/myapp/RAF/ahwvrz-legacy-sunset';
+
+      const worktreeFound = false;
+      let resumeCwd: string | undefined;
+
+      if (!worktreeFound) {
+        resumeCwd = mainRepoProjectPath;
+      }
+
+      expect(resumeCwd).toBe(mainRepoProjectPath);
+    });
+  });
+
+  describe('variable initialization', () => {
+    it('should handle undefined variables correctly when worktree is found', () => {
+      let projectPath: string | undefined;
+      let resumeCwd: string | undefined;
+      let folderName: string | undefined;
+
+      // Simulate worktree resolution
+      const worktreeResolution = {
+        folder: 'ahwvrz-legacy-sunset',
+        worktreeRoot: '/Users/user/.raf/worktrees/RAF/ahwvrz-legacy-sunset',
+      };
+
+      if (worktreeResolution) {
+        folderName = worktreeResolution.folder;
+        projectPath = `/path/to/${folderName}`;
+        resumeCwd = worktreeResolution.worktreeRoot;
+      }
+
+      expect(folderName).toBeDefined();
+      expect(projectPath).toBeDefined();
+      expect(resumeCwd).toBeDefined();
+    });
+
+    it('should handle undefined variables correctly when falling back to main repo', () => {
+      let projectPath: string | undefined;
+      let resumeCwd: string | undefined;
+      let folderName: string | undefined;
+
+      // Worktree resolution returns null
+      const worktreeResolution = null;
+
+      // Skip worktree assignment since it's null
+      if (!projectPath && !worktreeResolution) {
+        // Main repo resolution
+        projectPath = '/Users/user/myapp/RAF/ahwvrz-legacy-sunset';
+        folderName = 'ahwvrz-legacy-sunset';
+        resumeCwd = projectPath;
+      }
+
+      expect(folderName).toBeDefined();
+      expect(projectPath).toBeDefined();
+      expect(resumeCwd).toBeDefined();
+    });
+  });
+});

package/src/commands/migrate.ts

@@ -1,269 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { Command } from 'commander';
-import { getRafDir, encodeBase26 } from '../utils/paths.js';
-import { logger } from '../utils/logger.js';
-import { getRepoBasename, computeWorktreeBaseDir } from '../core/worktree.js';
-import type { MigrateCommandOptions } from '../types/config.js';
-
-/** 3-char base36 legacy prefix: e.g., "007", "01a", "1zz" */
-const LEGACY_3CHAR_PATTERN = /^([0-9a-z]{3})-(.+)$/;
-
-/** 6-char base36 legacy prefix with at least one digit: e.g., "021h44", "00j3k1" */
-const LEGACY_6CHAR_PATTERN = /^([0-9a-z]{6})-(.+)$/;
-
-/** Already-migrated base26 prefix: all lowercase letters, no digits */
-const BASE26_PATTERN = /^[a-z]{6}-/;
-
-export interface MigrationEntry {
-  oldName: string;
-  newName: string;
-  oldPath: string;
-  newPath: string;
-}
-
-/**
- * Check if a 6-char prefix contains at least one digit (meaning it's legacy base36, not base26).
- */
-function hasDigit(str: string): boolean {
-  return /[0-9]/.test(str);
-}
-
-/**
- * Decode a base36 string of any length back to a number.
- */
-function decodeBase36(str: string): number {
-  return parseInt(str, 36);
-}
-
-/**
- * Scan a directory for legacy project folders and compute migrations.
- * Returns an array of migration entries (old name -> new name).
- */
-export function detectMigrations(dirPath: string): MigrationEntry[] {
-  if (!fs.existsSync(dirPath)) {
-    return [];
-  }
-
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-  const migrations: MigrationEntry[] = [];
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-
-    const name = entry.name;
-
-    // Skip already-migrated base26 folders
-    if (BASE26_PATTERN.test(name)) continue;
-
-    // Try 3-char base36 pattern first
-    const match3 = name.match(LEGACY_3CHAR_PATTERN);
-    if (match3 && match3[1] && match3[2]) {
-      const prefix = match3[1];
-      const projectName = match3[2];
-      const numericValue = decodeBase36(prefix);
-      const newPrefix = encodeBase26(numericValue);
-      const newName = `${newPrefix}-${projectName}`;
-
-      migrations.push({
-        oldName: name,
-        newName,
-        oldPath: path.join(dirPath, name),
-        newPath: path.join(dirPath, newName),
-      });
-      continue;
-    }
-
-    // Try 6-char base36 pattern (must have at least one digit to distinguish from base26)
-    const match6 = name.match(LEGACY_6CHAR_PATTERN);
-    if (match6 && match6[1] && match6[2]) {
-      const prefix = match6[1];
-      if (!hasDigit(prefix)) continue; // Pure letters = already base26
-
-      const projectName = match6[2];
-      const numericValue = decodeBase36(prefix);
-      const newPrefix = encodeBase26(numericValue);
-      const newName = `${newPrefix}-${projectName}`;
-
-      migrations.push({
-        oldName: name,
-        newName,
-        oldPath: path.join(dirPath, name),
-        newPath: path.join(dirPath, newName),
-      });
-    }
-  }
-
-  return migrations;
-}
-
-/**
- * Check for collisions in a set of migrations (two old IDs mapping to the same base26 ID).
- * Returns an array of collision descriptions if found.
- */
-function findCollisions(migrations: MigrationEntry[]): string[] {
-  const targetNames = new Map<string, string[]>();
-  for (const m of migrations) {
-    const existing = targetNames.get(m.newName) ?? [];
-    existing.push(m.oldName);
-    targetNames.set(m.newName, existing);
-  }
-
-  const collisions: string[] = [];
-  for (const [newName, oldNames] of targetNames) {
-    if (oldNames.length > 1) {
-      collisions.push(`${oldNames.join(', ')} -> ${newName}`);
-    }
-  }
-  return collisions;
-}
-
-/**
- * Check if a target name already exists on disk (collision with existing folder).
- */
-function findExistingConflicts(migrations: MigrationEntry[]): string[] {
-  const conflicts: string[] = [];
-  for (const m of migrations) {
-    if (fs.existsSync(m.newPath)) {
-      conflicts.push(`${m.oldName} -> ${m.newName} (target already exists)`);
-    }
-  }
-  return conflicts;
-}
-
-/**
- * Execute migrations: rename folders on disk.
- * Returns count of successful renames.
- */
-function executeMigrations(migrations: MigrationEntry[]): { succeeded: number; errors: string[] } {
-  let succeeded = 0;
-  const errors: string[] = [];
-
-  for (const m of migrations) {
-    try {
-      fs.renameSync(m.oldPath, m.newPath);
-      succeeded++;
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      errors.push(`Failed to rename ${m.oldName}: ${msg}`);
-    }
-  }
-
-  return { succeeded, errors };
-}
-
-export function createMigrateCommand(): Command {
-  const command = new Command('migrate-project-ids-base26')
-    .description('Rename project folders from legacy base36 IDs to base26 encoding')
-    .option('--dry-run', 'Preview changes without renaming')
-    .option('--worktree', 'Also migrate worktree project directories')
-    .action(async (options?: MigrateCommandOptions) => {
-      await runMigrateCommand(options);
-    });
-
-  return command;
-}
-
-async function runMigrateCommand(options?: MigrateCommandOptions): Promise<void> {
-  const dryRun = options?.dryRun ?? false;
-  const includeWorktree = options?.worktree ?? false;
-
-  // Collect directories to scan
-  const dirsToScan: Array<{ label: string; path: string }> = [];
-
-  // Main RAF directory
-  const rafDir = getRafDir();
-  dirsToScan.push({ label: 'RAF', path: rafDir });
-
-  // Worktree directories
-  if (includeWorktree) {
-    const repoBasename = getRepoBasename();
-    if (repoBasename) {
-      const worktreeBaseDir = computeWorktreeBaseDir(repoBasename);
-      if (fs.existsSync(worktreeBaseDir)) {
-        const worktreeEntries = fs.readdirSync(worktreeBaseDir, { withFileTypes: true });
-        for (const entry of worktreeEntries) {
-          if (entry.isDirectory()) {
-            const wtRafDir = path.join(worktreeBaseDir, entry.name, 'RAF');
-            if (fs.existsSync(wtRafDir)) {
-              dirsToScan.push({ label: `worktree:${entry.name}`, path: wtRafDir });
-            }
-          }
-        }
-      }
-    } else {
-      logger.warn('Not in a git repository — skipping worktree scan');
-    }
-  }
-
-  // Detect all migrations
-  let totalMigrations: MigrationEntry[] = [];
-  const migrationsByDir: Array<{ label: string; migrations: MigrationEntry[] }> = [];
-
-  for (const dir of dirsToScan) {
-    const migrations = detectMigrations(dir.path);
-    if (migrations.length > 0) {
-      migrationsByDir.push({ label: dir.label, migrations });
-      totalMigrations = totalMigrations.concat(migrations);
-    }
-  }
-
-  if (totalMigrations.length === 0) {
-    logger.info('No legacy project folders found. Nothing to migrate.');
-    return;
-  }
-
-  // Check for collisions
-  const collisions = findCollisions(totalMigrations);
-  if (collisions.length > 0) {
-    logger.error('Collision detected — multiple old IDs map to the same base26 ID:');
-    for (const c of collisions) {
-      logger.error(`  ${c}`);
-    }
-    process.exit(1);
-  }
-
-  // Check for existing conflicts (target folder already exists)
-  const conflicts = findExistingConflicts(totalMigrations);
-  if (conflicts.length > 0) {
-    logger.error('Target folder already exists:');
-    for (const c of conflicts) {
-      logger.error(`  ${c}`);
-    }
-    process.exit(1);
-  }
-
-  // Print summary
-  if (dryRun) {
-    logger.info('Dry run — no changes will be made:');
-  }
-
-  for (const group of migrationsByDir) {
-    if (migrationsByDir.length > 1) {
-      logger.info(`\n${group.label}:`);
-    }
-    for (const m of group.migrations) {
-      logger.info(`  ${m.oldName} -> ${m.newName}`);
-    }
-  }
-
-  if (dryRun) {
-    logger.info(`\n${totalMigrations.length} folder${totalMigrations.length === 1 ? '' : 's'} would be renamed.`);
-    return;
-  }
-
-  // Execute migrations
-  const { succeeded, errors } = executeMigrations(totalMigrations);
-
-  if (errors.length > 0) {
-    for (const e of errors) {
-      logger.error(e);
-    }
-  }
-
-  logger.success(`${succeeded} folder${succeeded === 1 ? '' : 's'} renamed.`);
-  if (errors.length > 0) {
-    logger.error(`${errors.length} rename${errors.length === 1 ? '' : 's'} failed.`);
-    process.exit(1);
-  }
-}