grimoire-framework 1.0.0

package/.grimoire/cli/commands/migrate/rollback.js

@@ -0,0 +1,325 @@
+/**
+ * Migration Rollback Module
+ *
+ * Handles rollback from v4.0.4 back to v2.0 structure using backup.
+ *
+ * @module cli/commands/migrate/rollback
+ * @version 1.0.0
+ * @story 2.14 - Migration Script v2.0 → v4.0.4
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { findLatestBackup, verifyBackup, copyFileWithMetadata } = require('./backup');
+const { clearMigrationState } = require('./execute');
+
+/**
+ * Remove v4.0.4 module directories
+ * @param {string} grimoireCoreDir - Path to .grimoire
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Removal result
+ */
+async function removeV21Structure(grimoireCoreDir, options = {}) {
+  const { onProgress = () => {} } = options;
+
+  const v21Modules = ['core', 'development', 'product', 'infrastructure'];
+  const result = {
+    removed: [],
+    errors: [],
+  };
+
+  onProgress({ phase: 'remove', message: '✓ Removing v4.0.4 structure...' });
+
+  for (const moduleName of v21Modules) {
+    const moduleDir = path.join(grimoireCoreDir, moduleName);
+
+    if (fs.existsSync(moduleDir)) {
+      try {
+        await fs.promises.rm(moduleDir, { recursive: true, force: true });
+        result.removed.push(moduleDir);
+        onProgress({ phase: 'removed', message: `  ✓ Removed ${moduleName}/` });
+      } catch (error) {
+        result.errors.push({
+          path: moduleDir,
+          error: error.message,
+        });
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Restore files from backup
+ * @param {Object} backup - Backup info from findLatestBackup
+ * @param {string} projectRoot - Project root
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Restore result
+ */
+async function restoreFromBackup(backup, projectRoot, options = {}) {
+  const { onProgress = () => {}, verifyFirst = true } = options;
+
+  const result = {
+    success: false,
+    restored: 0,
+    errors: [],
+    warnings: [],
+  };
+
+  // Verify backup integrity first
+  if (verifyFirst) {
+    onProgress({ phase: 'verify', message: 'Verifying backup integrity...' });
+
+    const verification = await verifyBackup(backup.path);
+
+    if (!verification.valid) {
+      result.errors.push({
+        type: 'verification',
+        message: 'Backup verification failed',
+        details: {
+          missing: verification.missing,
+          failed: verification.failed,
+        },
+      });
+      return result;
+    }
+
+    onProgress({ phase: 'verified', message: `  ✓ Verified ${verification.verified} files` });
+  }
+
+  const grimoireCoreDir = path.join(projectRoot, '.grimoire');
+  const backupgrimoireCoreDir = path.join(backup.path, '.grimoire');
+
+  // Restore .grimoire files
+  onProgress({ phase: 'restore', message: '✓ Restoring v2.0 files...' });
+
+  for (const file of backup.manifest.files) {
+    try {
+      const sourcePath = file.isConfig
+        ? path.join(backup.path, file.relativePath)
+        : path.join(backupgrimoireCoreDir, file.relativePath);
+
+      const targetPath = file.isConfig
+        ? path.join(projectRoot, file.relativePath)
+        : path.join(grimoireCoreDir, file.relativePath);
+
+      await copyFileWithMetadata(sourcePath, targetPath);
+      result.restored++;
+
+    } catch (error) {
+      result.errors.push({
+        file: file.relativePath,
+        error: error.message,
+      });
+    }
+  }
+
+  onProgress({ phase: 'restored', message: `  ✓ Restored ${result.restored} files` });
+
+  result.success = result.errors.length === 0;
+
+  return result;
+}
+
+/**
+ * Execute full rollback operation
+ * @param {string} projectRoot - Project root
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Rollback result
+ */
+async function executeRollback(projectRoot, options = {}) {
+  const { onProgress = () => {}, backupPath = null } = options;
+
+  const result = {
+    success: false,
+    backup: null,
+    removal: null,
+    restore: null,
+    errors: [],
+  };
+
+  // Find backup
+  onProgress({ phase: 'find', message: 'Looking for backup...' });
+
+  let backup;
+
+  if (backupPath) {
+    // Use specified backup
+    const manifestPath = path.join(backupPath, 'backup-manifest.json');
+
+    if (!fs.existsSync(manifestPath)) {
+      result.errors.push({ type: 'backup', message: `No manifest found at ${backupPath}` });
+      return result;
+    }
+
+    const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
+    backup = { path: backupPath, manifest };
+
+  } else {
+    // Find latest backup
+    backup = await findLatestBackup(projectRoot);
+
+    if (!backup) {
+      result.errors.push({ type: 'backup', message: 'No backup found. Cannot rollback.' });
+      return result;
+    }
+  }
+
+  result.backup = {
+    path: backup.path,
+    date: backup.manifest?.created,
+    files: backup.manifest?.totalFiles,
+    size: backup.manifest?.totalSize,
+  };
+
+  onProgress({
+    phase: 'found',
+    message: `Found backup: ${path.basename(backup.path)}`,
+    details: {
+      created: backup.manifest?.created,
+      files: backup.manifest?.totalFiles,
+    },
+  });
+
+  // Step 1: Remove v4.0.4 structure
+  const grimoireCoreDir = path.join(projectRoot, '.grimoire');
+  result.removal = await removeV21Structure(grimoireCoreDir, { onProgress });
+
+  if (result.removal.errors.length > 0) {
+    result.errors.push(...result.removal.errors);
+    // Continue anyway - partial removal is okay
+  }
+
+  // Step 2: Restore from backup
+  result.restore = await restoreFromBackup(backup, projectRoot, { onProgress });
+
+  if (!result.restore.success) {
+    result.errors.push(...result.restore.errors);
+    return result;
+  }
+
+  // Step 3: Clear migration state
+  await clearMigrationState(projectRoot);
+
+  // Step 4: Validate restored structure
+  onProgress({ phase: 'validate', message: '✓ Validating restored structure...' });
+
+  // Simple validation - check a few expected directories exist
+  const expectedDirs = ['agents', 'tasks', 'registry'];
+  let validCount = 0;
+
+  for (const dir of expectedDirs) {
+    if (fs.existsSync(path.join(grimoireCoreDir, dir))) {
+      validCount++;
+    }
+  }
+
+  if (validCount >= 2) {
+    onProgress({ phase: 'complete', message: '✅ Rollback complete!' });
+    result.success = true;
+  } else {
+    result.warnings = result.warnings || [];
+    result.warnings.push('Restored structure may be incomplete');
+  }
+
+  return result;
+}
+
+/**
+ * Generate rollback summary output
+ * @param {Object} result - Rollback result
+ * @returns {string} Formatted summary
+ */
+function formatRollbackSummary(result) {
+  const lines = [];
+
+  lines.push('');
+  lines.push('🔙 grimoire Migration Rollback');
+  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+  if (result.backup) {
+    lines.push('');
+    lines.push(`Backup: ${path.basename(result.backup.path)}`);
+    if (result.backup.date) {
+      lines.push(`  Created: ${new Date(result.backup.date).toLocaleString()}`);
+    }
+    if (result.backup.files) {
+      lines.push(`  Files: ${result.backup.files}`);
+    }
+  }
+
+  if (result.success) {
+    lines.push('');
+    lines.push('✅ Rollback complete!');
+    lines.push('');
+    lines.push('Your project is now at v2.0 state.');
+  } else {
+    lines.push('');
+    lines.push('⚠️  Rollback completed with issues:');
+
+    for (const error of result.errors || []) {
+      if (error.message) {
+        lines.push(`  • ${error.message}`);
+      } else {
+        lines.push(`  • ${JSON.stringify(error)}`);
+      }
+    }
+  }
+
+  if (result.restore) {
+    lines.push('');
+    lines.push(`Restored: ${result.restore.restored} files`);
+  }
+
+  if (result.removal?.removed?.length > 0) {
+    lines.push(`Removed: ${result.removal.removed.length} v4.0.4 directories`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Check if rollback is possible
+ * @param {string} projectRoot - Project root
+ * @returns {Promise<Object>} Rollback status
+ */
+async function canRollback(projectRoot) {
+  const backup = await findLatestBackup(projectRoot);
+
+  if (!backup) {
+    return {
+      canRollback: false,
+      reason: 'No backup found',
+    };
+  }
+
+  const verification = await verifyBackup(backup.path);
+
+  if (!verification.valid) {
+    return {
+      canRollback: false,
+      reason: 'Backup verification failed',
+      details: verification,
+    };
+  }
+
+  return {
+    canRollback: true,
+    backup: {
+      path: backup.path,
+      date: backup.manifest?.created,
+      files: backup.manifest?.totalFiles,
+    },
+  };
+}
+
+module.exports = {
+  removeV21Structure,
+  restoreFromBackup,
+  executeRollback,
+  formatRollbackSummary,
+  canRollback,
+};
+
+

package/.grimoire/cli/commands/migrate/update-imports.js

@@ -0,0 +1,398 @@
+/**
+ * Import Path Update Module
+ *
+ * Scans and updates require/import paths after migration.
+ *
+ * @module cli/commands/migrate/update-imports
+ * @version 1.0.0
+ * @story 2.14 - Migration Script v2.0 → v4.0.4
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { MODULE_MAPPING, categorizeFile } = require('./analyze');
+
+/**
+ * Regex patterns for import detection
+ */
+const IMPORT_PATTERNS = {
+  // require('./path') or require('../path')
+  commonjs: /require\s*\(\s*['"`](\.[^'"`]+)['"`]\s*\)/g,
+
+  // import from './path' or import from '../path'
+  esm: /from\s+['"`](\.[^'"`]+)['"`]/g,
+
+  // import('./path') dynamic imports
+  dynamicImport: /import\s*\(\s*['"`](\.[^'"`]+)['"`]\s*\)/g,
+
+  // /// <reference path="./path" />
+  tsReference: /\/\/\/\s*<reference\s+path=['"`](\.[^'"`]+)['"`]\s*\/>/g,
+};
+
+/**
+ * Build path transformation map for the migration
+ * @param {Object} plan - Migration plan
+ * @returns {Map<string, string>} Old path to new path map
+ */
+function buildPathTransformMap(plan) {
+  const transformMap = new Map();
+
+  for (const [moduleName, moduleData] of Object.entries(plan.modules)) {
+    for (const file of moduleData.files) {
+      // Store both with and without extension
+      const oldPath = file.relativePath;
+      const newPath = path.join(moduleName, file.relativePath);
+
+      transformMap.set(oldPath, newPath);
+
+      // Also store without .js extension for require compatibility
+      if (oldPath.endsWith('.js')) {
+        const noExt = oldPath.slice(0, -3);
+        const newNoExt = newPath.slice(0, -3);
+        transformMap.set(noExt, newNoExt);
+      }
+    }
+  }
+
+  return transformMap;
+}
+
+/**
+ * Scan a file for import statements
+ * @param {string} filePath - Path to file
+ * @returns {Promise<Object[]>} Array of import info
+ */
+async function scanFileImports(filePath) {
+  const content = await fs.promises.readFile(filePath, 'utf8');
+  const imports = [];
+
+  for (const [patternName, pattern] of Object.entries(IMPORT_PATTERNS)) {
+    // Reset regex lastIndex
+    pattern.lastIndex = 0;
+
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      imports.push({
+        type: patternName,
+        fullMatch: match[0],
+        importPath: match[1],
+        index: match.index,
+        length: match[0].length,
+      });
+    }
+  }
+
+  return imports;
+}
+
+/**
+ * Transform an import path from v2.0 to v4.0.4 structure
+ * @param {string} importPath - Original import path
+ * @param {string} currentFileModule - Module of the file containing the import
+ * @param {string} currentFilePath - Path of the file containing the import
+ * @param {Map} transformMap - Path transformation map
+ * @returns {string|null} Transformed path or null if no change needed
+ */
+function transformImportPath(importPath, currentFileModule, currentFilePath, transformMap) {
+  // Resolve the import path relative to the current file
+  const currentDir = path.dirname(currentFilePath);
+  const resolvedPath = path.normalize(path.join(currentDir, importPath));
+
+  // Check if this path needs transformation
+  // We need to detect if it's pointing to a file that moved
+
+  // For paths starting with ../, they might reference files now in different modules
+  if (importPath.startsWith('../') || importPath.startsWith('./')) {
+    // This is a complex transformation - need to figure out what file it's importing
+    // and where that file now lives
+
+    // For now, we'll use heuristics:
+    // 1. If the path goes up to .grimoire root and then into a folder, update it
+
+    const parts = importPath.split('/');
+    let upCount = 0;
+    const restParts = [];
+
+    for (const part of parts) {
+      if (part === '..') {
+        upCount++;
+      } else if (part !== '.') {
+        restParts.push(part);
+      }
+    }
+
+    // If going up enough to reach .grimoire root
+    if (restParts.length > 0) {
+      const targetDir = restParts[0];
+
+      // Find which module this directory belongs to
+      for (const [moduleName, config] of Object.entries(MODULE_MAPPING)) {
+        if (config.directories.includes(targetDir)) {
+          // This needs to be updated to go through the module directory
+          // New path: go up, then into module, then the rest
+
+          // Calculate how to get from current location to target
+          const newParts = [];
+
+          // From current file's module directory
+          // Current structure after migration: .grimoire/{module}/...
+          // Need to go to: .grimoire/{targetModule}/...
+
+          if (currentFileModule === moduleName) {
+            // Same module, just adjust the path
+            return importPath; // No change needed within same module
+          } else {
+            // Different module, need to go up and into the other module
+            // Example: from development/agents/ to core/registry/
+            // Need: ../../core/registry/...
+
+            const currentDepth = currentFilePath.split(path.sep).length - 1;
+            const ups = '../'.repeat(currentDepth + 1); // +1 to get out of module dir
+
+            return `${ups}${moduleName}/${restParts.join('/')}`;
+          }
+        }
+      }
+    }
+  }
+
+  return null; // No transformation needed
+}
+
+/**
+ * Update imports in a single file
+ * @param {string} filePath - Path to file
+ * @param {Map} transformMap - Path transformation map
+ * @param {string} fileModule - Module this file belongs to
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Update result
+ */
+async function updateFileImports(filePath, transformMap, fileModule, options = {}) {
+  const { dryRun = false, verbose = false } = options;
+
+  const result = {
+    file: filePath,
+    imports: [],
+    updated: 0,
+    unchanged: 0,
+    errors: [],
+  };
+
+  try {
+    let content = await fs.promises.readFile(filePath, 'utf8');
+    const originalContent = content;
+    const imports = await scanFileImports(filePath);
+
+    for (const imp of imports) {
+      const relativePath = path.relative(
+        path.dirname(filePath).split('.grimoire')[1]?.slice(1) || '',
+        '',
+      );
+
+      const newPath = transformImportPath(
+        imp.importPath,
+        fileModule,
+        filePath,
+        transformMap,
+      );
+
+      if (newPath && newPath !== imp.importPath) {
+        // Replace in content
+        const oldStatement = imp.fullMatch;
+        const newStatement = oldStatement.replace(imp.importPath, newPath);
+
+        content = content.replace(oldStatement, newStatement);
+
+        result.imports.push({
+          old: imp.importPath,
+          new: newPath,
+          type: imp.type,
+        });
+        result.updated++;
+      } else {
+        result.unchanged++;
+      }
+    }
+
+    // Write updated content if changes were made
+    if (content !== originalContent && !dryRun) {
+      await fs.promises.writeFile(filePath, content, 'utf8');
+    }
+
+    result.modified = content !== originalContent;
+
+  } catch (error) {
+    result.errors.push(error.message);
+  }
+
+  return result;
+}
+
+/**
+ * Scan and update all imports in the migrated structure
+ * @param {string} grimoireCoreDir - Path to .grimoire
+ * @param {Object} plan - Migration plan
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Update results
+ */
+async function updateAllImports(grimoireCoreDir, plan, options = {}) {
+  const { verbose = false, dryRun = false, onProgress = () => {} } = options;
+
+  const transformMap = buildPathTransformMap(plan);
+
+  const result = {
+    totalFiles: 0,
+    filesModified: 0,
+    importsUpdated: 0,
+    errors: [],
+    details: [],
+  };
+
+  onProgress({ phase: 'scan', message: 'Scanning for import statements...' });
+
+  // Process each module
+  const modules = ['core', 'development', 'product', 'infrastructure'];
+
+  for (const moduleName of modules) {
+    const moduleDir = path.join(grimoireCoreDir, moduleName);
+
+    if (!fs.existsSync(moduleDir)) continue;
+
+    // Get all JS/TS files in module
+    const files = await getJsFiles(moduleDir);
+
+    for (const file of files) {
+      result.totalFiles++;
+
+      const updateResult = await updateFileImports(
+        file,
+        transformMap,
+        moduleName,
+        { dryRun, verbose },
+      );
+
+      if (updateResult.modified) {
+        result.filesModified++;
+      }
+
+      result.importsUpdated += updateResult.updated;
+
+      if (updateResult.errors.length > 0) {
+        result.errors.push(...updateResult.errors.map(e => ({
+          file,
+          error: e,
+        })));
+      }
+
+      if (verbose && updateResult.updated > 0) {
+        result.details.push(updateResult);
+        onProgress({
+          phase: 'file',
+          message: `  → ${path.relative(grimoireCoreDir, file)} (${updateResult.updated} imports)`,
+        });
+      }
+    }
+  }
+
+  onProgress({
+    phase: 'complete',
+    message: `Found ${result.importsUpdated} imports to update`,
+  });
+
+  return result;
+}
+
+/**
+ * Get all JavaScript/TypeScript files in a directory recursively
+ * @param {string} dir - Directory path
+ * @param {string[]} [files] - Accumulated files
+ * @returns {Promise<string[]>} Array of file paths
+ */
+async function getJsFiles(dir, files = []) {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      await getJsFiles(fullPath, files);
+    } else if (/\.(js|ts|mjs|cjs|jsx|tsx)$/.test(entry.name)) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Verify no broken imports exist after migration
+ * @param {string} grimoireCoreDir - Path to .grimoire
+ * @returns {Promise<Object>} Verification result
+ */
+async function verifyImports(grimoireCoreDir) {
+  const result = {
+    valid: true,
+    totalImports: 0,
+    brokenImports: [],
+    warnings: [],
+  };
+
+  const modules = ['core', 'development', 'product', 'infrastructure'];
+
+  for (const moduleName of modules) {
+    const moduleDir = path.join(grimoireCoreDir, moduleName);
+
+    if (!fs.existsSync(moduleDir)) continue;
+
+    const files = await getJsFiles(moduleDir);
+
+    for (const file of files) {
+      const imports = await scanFileImports(file);
+
+      for (const imp of imports) {
+        result.totalImports++;
+
+        // Try to resolve the import
+        if (imp.importPath.startsWith('.')) {
+          const resolvedPath = path.resolve(path.dirname(file), imp.importPath);
+
+          // Check various extensions
+          const extensions = ['', '.js', '.ts', '.json', '/index.js', '/index.ts'];
+          let found = false;
+
+          for (const ext of extensions) {
+            if (fs.existsSync(resolvedPath + ext)) {
+              found = true;
+              break;
+            }
+          }
+
+          if (!found) {
+            result.brokenImports.push({
+              file: path.relative(grimoireCoreDir, file),
+              import: imp.importPath,
+              type: imp.type,
+              resolvedPath,
+            });
+            result.valid = false;
+          }
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  IMPORT_PATTERNS,
+  buildPathTransformMap,
+  scanFileImports,
+  transformImportPath,
+  updateFileImports,
+  updateAllImports,
+  getJsFiles,
+  verifyImports,
+};
+
+