rafcode 2.5.0-0 → 2.5.1-0

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/tests/unit/worktree-flag-override.test.ts

@@ -0,0 +1,186 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { Command } from 'commander';
+import { createPlanCommand } from '../../src/commands/plan.js';
+import { createDoCommand } from '../../src/commands/do.js';
+import { getWorktreeDefault, resetConfigCache, saveConfig } from '../../src/utils/config.js';
+
+describe('Worktree Flag Override', () => {
+  let tempDir: string;
+  let originalHome: string | undefined;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-worktree-flag-test-'));
+    originalHome = process.env.HOME;
+    process.env.HOME = tempDir;
+    resetConfigCache();
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    resetConfigCache();
+  });
+
+  describe('Commander.js --no-worktree flag parsing', () => {
+    it('should parse --worktree as true', () => {
+      const planCommand = createPlanCommand();
+      // Use parseOptions instead of parse to avoid running the action
+      planCommand.parseOptions(['--worktree']);
+      const opts = planCommand.opts();
+      expect(opts.worktree).toBe(true);
+    });
+
+    it('should parse --no-worktree as false', () => {
+      const planCommand = createPlanCommand();
+      planCommand.parseOptions(['--no-worktree']);
+      const opts = planCommand.opts();
+      expect(opts.worktree).toBe(false);
+    });
+
+    it('should parse omitted flag as undefined', () => {
+      const planCommand = createPlanCommand();
+      planCommand.parseOptions([]);
+      const opts = planCommand.opts();
+      expect(opts.worktree).toBeUndefined();
+    });
+
+    it('should parse --worktree for do command as true', () => {
+      const doCommand = createDoCommand();
+      doCommand.parseOptions(['--worktree']);
+      const opts = doCommand.opts();
+      expect(opts.worktree).toBe(true);
+    });
+
+    it('should parse --no-worktree for do command as false', () => {
+      const doCommand = createDoCommand();
+      doCommand.parseOptions(['--no-worktree']);
+      const opts = doCommand.opts();
+      expect(opts.worktree).toBe(false);
+    });
+
+    it('should parse omitted flag for do command as undefined', () => {
+      const doCommand = createDoCommand();
+      doCommand.parseOptions([]);
+      const opts = doCommand.opts();
+      expect(opts.worktree).toBeUndefined();
+    });
+  });
+
+  describe('Config resolution with --no-worktree flag', () => {
+    it('should resolve to true when --worktree flag is passed (regardless of config)', () => {
+      // Simulate: options.worktree = true (from --worktree flag)
+      const options = { worktree: true };
+      // With nullish coalescing, explicit true takes precedence
+      const resolved = options.worktree ?? getWorktreeDefault();
+      expect(resolved).toBe(true);
+    });
+
+    it('should resolve to false when --no-worktree flag is passed (regardless of config)', () => {
+      // Simulate: options.worktree = false (from --no-worktree flag)
+      const options = { worktree: false };
+      // With nullish coalescing, explicit false takes precedence
+      const resolved = options.worktree ?? getWorktreeDefault();
+      expect(resolved).toBe(false);
+    });
+
+    it('should resolve to config default when no flag is passed', () => {
+      // Simulate: options.worktree = undefined (no flag passed)
+      const options = { worktree: undefined };
+      // With nullish coalescing, undefined falls back to getWorktreeDefault()
+      const resolved = options.worktree ?? getWorktreeDefault();
+      // We can't assert a specific value here since it depends on the user's actual config
+      expect(typeof resolved).toBe('boolean');
+    });
+  });
+
+  describe('Tri-state behavior verification', () => {
+    it('should correctly handle all three states (true/false/undefined) in plan command', () => {
+      // State 1: --worktree (explicit true)
+      const planCmd1 = createPlanCommand();
+      planCmd1.parseOptions(['--worktree']);
+      const opts1 = planCmd1.opts();
+      expect(opts1.worktree).toBe(true);
+      const resolved1 = opts1.worktree ?? getWorktreeDefault();
+      expect(resolved1).toBe(true);
+
+      // State 2: --no-worktree (explicit false)
+      const planCmd2 = createPlanCommand();
+      planCmd2.parseOptions(['--no-worktree']);
+      const opts2 = planCmd2.opts();
+      expect(opts2.worktree).toBe(false);
+      const resolved2 = opts2.worktree ?? getWorktreeDefault();
+      expect(resolved2).toBe(false);
+
+      // State 3: omitted (undefined, falls back to config)
+      const planCmd3 = createPlanCommand();
+      planCmd3.parseOptions([]);
+      const opts3 = planCmd3.opts();
+      expect(opts3.worktree).toBeUndefined();
+      const resolved3 = opts3.worktree ?? getWorktreeDefault();
+      // Should be a boolean (actual value depends on config)
+      expect(typeof resolved3).toBe('boolean');
+    });
+
+    it('should correctly handle all three states (true/false/undefined) in do command', () => {
+      // State 1: --worktree (explicit true)
+      const doCmd1 = createDoCommand();
+      doCmd1.parseOptions(['--worktree']);
+      const opts1 = doCmd1.opts();
+      expect(opts1.worktree).toBe(true);
+      const resolved1 = opts1.worktree ?? getWorktreeDefault();
+      expect(resolved1).toBe(true);
+
+      // State 2: --no-worktree (explicit false)
+      const doCmd2 = createDoCommand();
+      doCmd2.parseOptions(['--no-worktree']);
+      const opts2 = doCmd2.opts();
+      expect(opts2.worktree).toBe(false);
+      const resolved2 = opts2.worktree ?? getWorktreeDefault();
+      expect(resolved2).toBe(false);
+
+      // State 3: omitted (undefined, falls back to config)
+      const doCmd3 = createDoCommand();
+      doCmd3.parseOptions([]);
+      const opts3 = doCmd3.opts();
+      expect(opts3.worktree).toBeUndefined();
+      const resolved3 = opts3.worktree ?? getWorktreeDefault();
+      // Should be a boolean (actual value depends on config)
+      expect(typeof resolved3).toBe('boolean');
+    });
+  });
+
+  describe('Override semantics', () => {
+    it('--no-worktree should override config default (explicit false takes precedence)', () => {
+      const planCommand = createPlanCommand();
+      planCommand.parseOptions(['--no-worktree']);
+      const opts = planCommand.opts();
+      const resolved = opts.worktree ?? getWorktreeDefault();
+
+      expect(opts.worktree).toBe(false); // Flag sets explicit false
+      expect(resolved).toBe(false); // Final result is false (flag takes precedence)
+    });
+
+    it('--worktree should override config default (explicit true takes precedence)', () => {
+      const doCommand = createDoCommand();
+      doCommand.parseOptions(['--worktree']);
+      const opts = doCommand.opts();
+      const resolved = opts.worktree ?? getWorktreeDefault();
+
+      expect(opts.worktree).toBe(true); // Flag sets explicit true
+      expect(resolved).toBe(true); // Final result is true (flag takes precedence)
+    });
+
+    it('omitting flag should fall back to config default', () => {
+      const planCommand = createPlanCommand();
+      planCommand.parseOptions([]);
+      const opts = planCommand.opts();
+      const resolved = opts.worktree ?? getWorktreeDefault();
+
+      expect(opts.worktree).toBeUndefined(); // Flag not set
+      expect(typeof resolved).toBe('boolean'); // Falls back to config (which is a boolean)
+      expect(resolved).toBe(getWorktreeDefault()); // Final result matches config
+    });
+  });
+});

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);
-  }
-}