rafcode 2.4.1-0 → 2.5.0

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

package/tests/unit/migrate-command.test.ts

@@ -1,197 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { detectMigrations, type MigrationEntry } from '../../src/commands/migrate.js';
-import { encodeBase26 } from '../../src/utils/paths.js';
-
-describe('migrate-project-ids-base26', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-migrate-test-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('detectMigrations', () => {
-    it('should detect 3-char base36 legacy folders', () => {
-      fs.mkdirSync(path.join(tempDir, '007-my-project'));
-      fs.mkdirSync(path.join(tempDir, '01a-feature'));
-
-      const migrations = detectMigrations(tempDir);
-
-      expect(migrations).toHaveLength(2);
-
-      // 007 in base36 = 7, encodeBase26(7) = "aaaaah"
-      const m007 = migrations.find(m => m.oldName === '007-my-project');
-      expect(m007).toBeDefined();
-      expect(m007!.newName).toBe(`${encodeBase26(parseInt('007', 36))}-my-project`);
-      expect(m007!.newName).toBe('aaaaah-my-project');
-
-      // 01a in base36 = 46, encodeBase26(46) = "aaaabu"
-      const m01a = migrations.find(m => m.oldName === '01a-feature');
-      expect(m01a).toBeDefined();
-      expect(m01a!.newName).toBe(`${encodeBase26(parseInt('01a', 36))}-feature`);
-      expect(m01a!.newName).toBe('aaaabu-feature');
-    });
-
-    it('should detect 6-char base36 legacy folders with digits', () => {
-      fs.mkdirSync(path.join(tempDir, '021h44-letterjam'));
-      fs.mkdirSync(path.join(tempDir, '00j3k1-fix-stuff'));
-
-      const migrations = detectMigrations(tempDir);
-
-      expect(migrations).toHaveLength(2);
-
-      const m1 = migrations.find(m => m.oldName === '021h44-letterjam');
-      expect(m1).toBeDefined();
-      expect(m1!.newName).toBe(`${encodeBase26(parseInt('021h44', 36))}-letterjam`);
-
-      const m2 = migrations.find(m => m.oldName === '00j3k1-fix-stuff');
-      expect(m2).toBeDefined();
-      expect(m2!.newName).toBe(`${encodeBase26(parseInt('00j3k1', 36))}-fix-stuff`);
-    });
-
-    it('should skip already-migrated base26 folders', () => {
-      fs.mkdirSync(path.join(tempDir, 'abcdef-my-project'));
-      fs.mkdirSync(path.join(tempDir, 'aaaaab-another'));
-
-      const migrations = detectMigrations(tempDir);
-      expect(migrations).toHaveLength(0);
-    });
-
-    it('should skip non-directory entries', () => {
-      fs.writeFileSync(path.join(tempDir, '007-not-a-dir'), 'file');
-
-      const migrations = detectMigrations(tempDir);
-      expect(migrations).toHaveLength(0);
-    });
-
-    it('should return empty array for non-existent directory', () => {
-      const migrations = detectMigrations(path.join(tempDir, 'nonexistent'));
-      expect(migrations).toHaveLength(0);
-    });
-
-    it('should return empty array when no legacy folders exist', () => {
-      fs.mkdirSync(path.join(tempDir, 'abcdef-project'));
-      fs.mkdirSync(path.join(tempDir, 'random-folder'));
-
-      const migrations = detectMigrations(tempDir);
-      expect(migrations).toHaveLength(0);
-    });
-
-    it('should handle mixed legacy and migrated folders', () => {
-      fs.mkdirSync(path.join(tempDir, '007-old-project'));
-      fs.mkdirSync(path.join(tempDir, 'abcdef-new-project'));
-      fs.mkdirSync(path.join(tempDir, '021h44-medium-project'));
-
-      const migrations = detectMigrations(tempDir);
-      expect(migrations).toHaveLength(2);
-      expect(migrations.map(m => m.oldName).sort()).toEqual(['007-old-project', '021h44-medium-project']);
-    });
-
-    it('should produce correct paths', () => {
-      fs.mkdirSync(path.join(tempDir, '007-my-project'));
-
-      const migrations = detectMigrations(tempDir);
-      expect(migrations[0]!.oldPath).toBe(path.join(tempDir, '007-my-project'));
-      expect(migrations[0]!.newPath).toBe(path.join(tempDir, 'aaaaah-my-project'));
-    });
-
-    it('should handle 3-char base36 edge cases', () => {
-      // "000" = 0
-      fs.mkdirSync(path.join(tempDir, '000-zero'));
-      // "zzz" = 36^3 - 1 = 46655
-      fs.mkdirSync(path.join(tempDir, 'zzz-max'));
-
-      const migrations = detectMigrations(tempDir);
-
-      // "zzz" contains no digits but matches 3-char pattern
-      // Wait — "zzz" has no digits. The 3-char pattern is [0-9a-z]{3}
-      // so "zzz" matches the 3-char pattern (3 chars, all lowercase letters/digits)
-      // It gets detected as a legacy 3-char folder
-
-      const m000 = migrations.find(m => m.oldName === '000-zero');
-      expect(m000).toBeDefined();
-      expect(m000!.newName).toBe('aaaaaa-zero');
-
-      const mZzz = migrations.find(m => m.oldName === 'zzz-max');
-      expect(mZzz).toBeDefined();
-      expect(mZzz!.newName).toBe(`${encodeBase26(46655)}-max`);
-    });
-
-    it('should not match folders without a hyphen after the prefix', () => {
-      fs.mkdirSync(path.join(tempDir, '007'));
-
-      const migrations = detectMigrations(tempDir);
-      expect(migrations).toHaveLength(0);
-    });
-
-    it('should handle 6-char all-letter prefix that is not pure a-z', () => {
-      // "abcde1" has a digit, so it's legacy
-      fs.mkdirSync(path.join(tempDir, 'abcde1-mixed'));
-
-      const migrations = detectMigrations(tempDir);
-      expect(migrations).toHaveLength(1);
-      expect(migrations[0]!.oldName).toBe('abcde1-mixed');
-    });
-  });
-
-  describe('migration execution (integration)', () => {
-    it('should rename folders when executed', () => {
-      fs.mkdirSync(path.join(tempDir, '007-my-project'));
-      fs.writeFileSync(path.join(tempDir, '007-my-project', 'input.md'), 'test');
-
-      const migrations = detectMigrations(tempDir);
-      expect(migrations).toHaveLength(1);
-
-      // Simulate what executeMigrations does
-      const m = migrations[0]!;
-      fs.renameSync(m.oldPath, m.newPath);
-
-      // Old folder should not exist
-      expect(fs.existsSync(path.join(tempDir, '007-my-project'))).toBe(false);
-      // New folder should exist with contents
-      expect(fs.existsSync(path.join(tempDir, 'aaaaah-my-project'))).toBe(true);
-      expect(fs.readFileSync(path.join(tempDir, 'aaaaah-my-project', 'input.md'), 'utf-8')).toBe('test');
-    });
-
-    it('should preserve folder contents during rename', () => {
-      const oldDir = path.join(tempDir, '021h44-letterjam');
-      fs.mkdirSync(oldDir);
-      fs.mkdirSync(path.join(oldDir, 'plans'));
-      fs.mkdirSync(path.join(oldDir, 'outcomes'));
-      fs.writeFileSync(path.join(oldDir, 'input.md'), 'requirements');
-      fs.writeFileSync(path.join(oldDir, 'plans', '01-task.md'), 'plan');
-
-      const migrations = detectMigrations(tempDir);
-      const m = migrations[0]!;
-      fs.renameSync(m.oldPath, m.newPath);
-
-      expect(fs.existsSync(path.join(m.newPath, 'input.md'))).toBe(true);
-      expect(fs.existsSync(path.join(m.newPath, 'plans', '01-task.md'))).toBe(true);
-      expect(fs.readFileSync(path.join(m.newPath, 'input.md'), 'utf-8')).toBe('requirements');
-    });
-  });
-
-  describe('encoding correctness', () => {
-    it('3-char base36 IDs produce small base26 values', () => {
-      // 007 base36 = 7
-      expect(encodeBase26(7)).toBe('aaaaah');
-      // 023 base36 = 75
-      expect(encodeBase26(parseInt('023', 36))).toBe('aaaacx');
-      // 100 base36 = 1296
-      expect(encodeBase26(parseInt('100', 36))).toBe('aaabxw');
-    });
-
-    it('6-char base36 epoch IDs produce reasonable base26 values', () => {
-      // These are large numbers (seconds since epoch)
-      const val = parseInt('021h44', 36);
-      const encoded = encodeBase26(val);
-      expect(encoded).toHaveLength(6);
-      expect(/^[a-z]{6}$/.test(encoded)).toBe(true);
-    });
-  });
-});