aios-core 2.1.0

package/.aios-core/cli/commands/migrate/analyze.js

@@ -0,0 +1,353 @@
+/**
+ * Migration Structure Analysis Module
+ *
+ * Detects v2.0 structure and generates migration plan
+ * for v2.0 → v2.1 migration.
+ *
+ * @module cli/commands/migrate/analyze
+ * @version 1.0.0
+ * @story 2.14 - Migration Script v2.0 → v2.1
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getAllFiles } = require('./backup');
+
+/**
+ * Module mapping configuration for v2.0 → v2.1 migration
+ */
+const MODULE_MAPPING = {
+  core: {
+    target: 'core',
+    patterns: [
+      'registry/**',
+      'quality-gates/**',
+      'manifest/**',
+      'utils/**',
+      'elicitation/**',
+      'session/**',
+      'config/**',
+      'mcp/**',
+      'data/**',
+      'docs/**',
+    ],
+    directories: ['registry', 'quality-gates', 'manifest', 'utils', 'elicitation', 'session', 'config', 'mcp', 'data', 'docs'],
+  },
+  development: {
+    target: 'development',
+    patterns: [
+      'agents/**',
+      'tasks/**',
+      'templates/**',
+      'checklists/**',
+      'scripts/**',
+      'personas/**',
+    ],
+    directories: ['agents', 'tasks', 'templates', 'checklists', 'scripts', 'personas'],
+  },
+  product: {
+    target: 'product',
+    patterns: [
+      'cli/**',
+      'api/**',
+    ],
+    directories: ['cli', 'api'],
+  },
+  infrastructure: {
+    target: 'infrastructure',
+    patterns: [
+      'hooks/**',
+      'telemetry/**',
+      'integrations/**',
+    ],
+    directories: ['hooks', 'telemetry', 'integrations'],
+  },
+};
+
+/**
+ * Detect if project is v2.0 structure
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<Object>} Detection result
+ */
+async function detectV2Structure(projectRoot) {
+  const aiosCoreDir = path.join(projectRoot, '.aios-core');
+
+  if (!fs.existsSync(aiosCoreDir)) {
+    return {
+      isV2: false,
+      isV21: false,
+      version: null,
+      error: 'No .aios-core directory found',
+    };
+  }
+
+  // Check for v2.1 modular structure (core, development, product, infrastructure dirs)
+  const v21Modules = ['core', 'development', 'product', 'infrastructure'];
+  const hasV21Structure = v21Modules.every(module =>
+    fs.existsSync(path.join(aiosCoreDir, module)),
+  );
+
+  if (hasV21Structure) {
+    return {
+      isV2: false,
+      isV21: true,
+      version: '2.1',
+      message: 'Project already has v2.1 modular structure',
+    };
+  }
+
+  // Check for v2.0 flat structure
+  const v20Indicators = ['agents', 'tasks', 'registry', 'cli'];
+  const hasV20Structure = v20Indicators.some(dir =>
+    fs.existsSync(path.join(aiosCoreDir, dir)),
+  );
+
+  if (hasV20Structure) {
+    return {
+      isV2: true,
+      isV21: false,
+      version: '2.0',
+      message: 'Project has v2.0 flat structure',
+    };
+  }
+
+  return {
+    isV2: false,
+    isV21: false,
+    version: null,
+    error: 'Unable to detect AIOS version structure',
+  };
+}
+
+/**
+ * Categorize file into target module
+ * @param {string} relativePath - Relative path from .aios-core
+ * @returns {string|null} Module name or null
+ */
+function categorizeFile(relativePath) {
+  // Normalize path separators for cross-platform compatibility
+  const normalizedPath = relativePath.replace(/\\/g, '/');
+  const topDir = normalizedPath.split('/')[0];
+
+  for (const [moduleName, config] of Object.entries(MODULE_MAPPING)) {
+    if (config.directories.includes(topDir)) {
+      return moduleName;
+    }
+  }
+
+  // Root level files stay in core
+  if (!normalizedPath.includes('/')) {
+    return 'core';
+  }
+
+  return null;
+}
+
+/**
+ * Analyze current structure and create migration plan
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Analysis options
+ * @returns {Promise<Object>} Migration plan
+ */
+async function analyzeMigrationPlan(projectRoot, options = {}) {
+  const { verbose: _verbose = false } = options;
+  const aiosCoreDir = path.join(projectRoot, '.aios-core');
+
+  // First detect version
+  const versionInfo = await detectV2Structure(projectRoot);
+
+  if (!versionInfo.isV2) {
+    return {
+      canMigrate: false,
+      ...versionInfo,
+    };
+  }
+
+  // Get all files
+  const allFiles = await getAllFiles(aiosCoreDir);
+
+  // Build migration plan
+  const plan = {
+    canMigrate: true,
+    sourceVersion: '2.0',
+    targetVersion: '2.1',
+    projectRoot,
+    aiosCoreDir,
+    modules: {
+      core: { files: [], size: 0 },
+      development: { files: [], size: 0 },
+      product: { files: [], size: 0 },
+      infrastructure: { files: [], size: 0 },
+    },
+    uncategorized: [],
+    conflicts: [],
+    totalFiles: 0,
+    totalSize: 0,
+    stats: {},
+  };
+
+  // Categorize each file
+  for (const filePath of allFiles) {
+    const relativePath = path.relative(aiosCoreDir, filePath);
+    const stats = await fs.promises.stat(filePath);
+    const module = categorizeFile(relativePath);
+
+    const fileInfo = {
+      sourcePath: filePath,
+      relativePath,
+      size: stats.size,
+    };
+
+    if (module && plan.modules[module]) {
+      // Calculate target path
+      fileInfo.targetPath = path.join(aiosCoreDir, module, relativePath);
+      plan.modules[module].files.push(fileInfo);
+      plan.modules[module].size += stats.size;
+    } else {
+      plan.uncategorized.push(fileInfo);
+    }
+
+    plan.totalFiles++;
+    plan.totalSize += stats.size;
+  }
+
+  // Check for potential conflicts (existing v2.1 directories)
+  for (const moduleName of Object.keys(plan.modules)) {
+    const targetDir = path.join(aiosCoreDir, moduleName);
+    if (fs.existsSync(targetDir)) {
+      plan.conflicts.push({
+        type: 'existing_directory',
+        path: targetDir,
+        module: moduleName,
+      });
+    }
+  }
+
+  // Generate stats
+  plan.stats = {
+    core: {
+      files: plan.modules.core.files.length,
+      size: formatSize(plan.modules.core.size),
+    },
+    development: {
+      files: plan.modules.development.files.length,
+      size: formatSize(plan.modules.development.size),
+    },
+    product: {
+      files: plan.modules.product.files.length,
+      size: formatSize(plan.modules.product.size),
+    },
+    infrastructure: {
+      files: plan.modules.infrastructure.files.length,
+      size: formatSize(plan.modules.infrastructure.size),
+    },
+    uncategorized: plan.uncategorized.length,
+    total: {
+      files: plan.totalFiles,
+      size: formatSize(plan.totalSize),
+    },
+  };
+
+  return plan;
+}
+
+/**
+ * Format byte size to human readable
+ * @param {number} bytes - Size in bytes
+ * @returns {string} Formatted size
+ */
+function formatSize(bytes) {
+  const units = ['B', 'KB', 'MB', 'GB'];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+
+  return `${size.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+}
+
+/**
+ * Generate printable migration plan table
+ * @param {Object} plan - Migration plan
+ * @returns {string} Formatted table
+ */
+function formatMigrationPlan(plan) {
+  const lines = [];
+
+  lines.push('Migration Plan:');
+  lines.push('┌─────────────────┬───────┬─────────────┐');
+  lines.push('│ Module          │ Files │ Size        │');
+  lines.push('├─────────────────┼───────┼─────────────┤');
+
+  for (const [moduleName, stats] of Object.entries(plan.stats)) {
+    if (moduleName === 'total' || moduleName === 'uncategorized') continue;
+
+    const name = moduleName.padEnd(15);
+    const files = String(stats.files).padStart(5);
+    const size = stats.size.padStart(11);
+
+    lines.push(`│ ${name} │ ${files} │ ${size} │`);
+  }
+
+  lines.push('└─────────────────┴───────┴─────────────┘');
+  lines.push(`Total: ${plan.stats.total.files} files, ${plan.stats.total.size}`);
+
+  if (plan.stats.uncategorized > 0) {
+    lines.push(`\n⚠️  ${plan.stats.uncategorized} uncategorized files (will be moved to core/)`);
+  }
+
+  if (plan.conflicts.length > 0) {
+    lines.push('\n⚠️  Potential conflicts detected:');
+    for (const conflict of plan.conflicts) {
+      lines.push(`   - ${conflict.path}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Identify potential import/require paths that need updating
+ * @param {Object} plan - Migration plan
+ * @returns {Object} Import analysis
+ */
+function analyzeImports(plan) {
+  const importPaths = [];
+
+  for (const [moduleName, moduleData] of Object.entries(plan.modules)) {
+    for (const file of moduleData.files) {
+      if (file.relativePath.endsWith('.js') || file.relativePath.endsWith('.ts')) {
+        importPaths.push({
+          file: file.relativePath,
+          module: moduleName,
+          oldPath: file.relativePath,
+          newPath: path.join(moduleName, file.relativePath),
+        });
+      }
+    }
+  }
+
+  return {
+    totalImportableFiles: importPaths.length,
+    byModule: {
+      core: importPaths.filter(f => f.module === 'core').length,
+      development: importPaths.filter(f => f.module === 'development').length,
+      product: importPaths.filter(f => f.module === 'product').length,
+      infrastructure: importPaths.filter(f => f.module === 'infrastructure').length,
+    },
+    files: importPaths,
+  };
+}
+
+module.exports = {
+  MODULE_MAPPING,
+  detectV2Structure,
+  categorizeFile,
+  analyzeMigrationPlan,
+  formatSize,
+  formatMigrationPlan,
+  analyzeImports,
+};

package/.aios-core/cli/commands/migrate/backup.js

@@ -0,0 +1,352 @@
+/**
+ * Migration Backup Module
+ *
+ * Handles backup creation, verification, and manifest generation
+ * for v2.0 → v2.1 migration.
+ *
+ * @module cli/commands/migrate/backup
+ * @version 1.0.0
+ * @story 2.14 - Migration Script v2.0 → v2.1
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Create a backup directory name with timestamp
+ * @returns {string} Backup directory name
+ */
+function createBackupDirName() {
+  const date = new Date();
+  const dateStr = date.toISOString().split('T')[0];
+  return `.aios-backup-${dateStr}`;
+}
+
+/**
+ * Calculate MD5 checksum for a file
+ * @param {string} filePath - Path to file
+ * @returns {Promise<string>} MD5 checksum
+ */
+async function calculateChecksum(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('md5');
+    const stream = fs.createReadStream(filePath);
+
+    stream.on('data', data => hash.update(data));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+/**
+ * Get file stats including permissions
+ * @param {string} filePath - Path to file
+ * @returns {Promise<Object>} File stats
+ */
+async function getFileStats(filePath) {
+  const stats = await fs.promises.stat(filePath);
+  return {
+    size: stats.size,
+    mode: stats.mode,
+    mtime: stats.mtime.toISOString(),
+    isDirectory: stats.isDirectory(),
+  };
+}
+
+/**
+ * Copy file with metadata preservation
+ * @param {string} src - Source path
+ * @param {string} dest - Destination path
+ * @returns {Promise<Object>} Copy result with checksum
+ */
+async function copyFileWithMetadata(src, dest) {
+  const stats = await fs.promises.stat(src);
+
+  // Ensure destination directory exists
+  await fs.promises.mkdir(path.dirname(dest), { recursive: true });
+
+  // Copy file
+  await fs.promises.copyFile(src, dest);
+
+  // Preserve timestamps and permissions
+  await fs.promises.utimes(dest, stats.atime, stats.mtime);
+  await fs.promises.chmod(dest, stats.mode);
+
+  // Calculate checksum
+  const checksum = await calculateChecksum(dest);
+
+  return {
+    src,
+    dest,
+    size: stats.size,
+    mode: stats.mode,
+    checksum,
+  };
+}
+
+/**
+ * Recursively get all files in a directory
+ * @param {string} dir - Directory path
+ * @param {string[]} [fileList] - Accumulated file list
+ * @returns {Promise<string[]>} Array of file paths
+ */
+async function getAllFiles(dir, fileList = []) {
+  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 getAllFiles(fullPath, fileList);
+    } else {
+      fileList.push(fullPath);
+    }
+  }
+
+  return fileList;
+}
+
+/**
+ * Create backup of .aios-core directory
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Backup options
+ * @param {boolean} options.verbose - Show detailed progress
+ * @param {Function} options.onProgress - Progress callback
+ * @returns {Promise<Object>} Backup result
+ */
+async function createBackup(projectRoot, options = {}) {
+  const { verbose = false, onProgress = () => {} } = options;
+
+  const aiosCoreDir = path.join(projectRoot, '.aios-core');
+  const backupDirName = createBackupDirName();
+  const backupDir = path.join(projectRoot, backupDirName);
+
+  // Check if .aios-core exists
+  if (!fs.existsSync(aiosCoreDir)) {
+    throw new Error('No .aios-core directory found. Is this an AIOS v2.0 project?');
+  }
+
+  // Check if backup already exists
+  if (fs.existsSync(backupDir)) {
+    throw new Error(`Backup directory ${backupDirName} already exists. Remove it or use a different name.`);
+  }
+
+  onProgress({ phase: 'start', message: 'Creating backup directory...' });
+
+  // Create backup directory
+  await fs.promises.mkdir(backupDir, { recursive: true });
+
+  // Get all files to backup
+  const files = await getAllFiles(aiosCoreDir);
+  const manifest = {
+    version: '2.0',
+    created: new Date().toISOString(),
+    projectRoot,
+    backupDir,
+    files: [],
+    totalSize: 0,
+    totalFiles: files.length,
+    checksums: {},
+  };
+
+  onProgress({ phase: 'copying', message: `Backing up ${files.length} files...`, total: files.length });
+
+  // Copy each file
+  for (let i = 0; i < files.length; i++) {
+    const srcFile = files[i];
+    const relativePath = path.relative(aiosCoreDir, srcFile);
+    const destFile = path.join(backupDir, '.aios-core', relativePath);
+
+    const result = await copyFileWithMetadata(srcFile, destFile);
+
+    manifest.files.push({
+      relativePath,
+      size: result.size,
+      mode: result.mode,
+      checksum: result.checksum,
+    });
+    manifest.checksums[relativePath] = result.checksum;
+    manifest.totalSize += result.size;
+
+    if (verbose) {
+      onProgress({ phase: 'file', message: `  → ${relativePath}`, current: i + 1, total: files.length });
+    }
+  }
+
+  // Backup config files if they exist
+  const configFiles = [
+    'aios.config.js',
+    'aios.config.json',
+    '.aios/config.yaml',
+    '.mcp.json',
+  ];
+
+  for (const configFile of configFiles) {
+    const srcPath = path.join(projectRoot, configFile);
+    if (fs.existsSync(srcPath)) {
+      const destPath = path.join(backupDir, configFile);
+      const result = await copyFileWithMetadata(srcPath, destPath);
+
+      manifest.files.push({
+        relativePath: configFile,
+        size: result.size,
+        mode: result.mode,
+        checksum: result.checksum,
+        isConfig: true,
+      });
+      manifest.checksums[configFile] = result.checksum;
+      manifest.totalSize += result.size;
+    }
+  }
+
+  onProgress({ phase: 'manifest', message: 'Creating backup manifest...' });
+
+  // Write manifest
+  const manifestPath = path.join(backupDir, 'backup-manifest.json');
+  await fs.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+
+  onProgress({ phase: 'complete', message: 'Backup complete!' });
+
+  return {
+    success: true,
+    backupDir,
+    backupDirName,
+    manifest,
+  };
+}
+
+/**
+ * Verify backup integrity using checksums
+ * @param {string} backupDir - Backup directory path
+ * @returns {Promise<Object>} Verification result
+ */
+async function verifyBackup(backupDir) {
+  const manifestPath = path.join(backupDir, 'backup-manifest.json');
+
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error('Backup manifest not found. Is this a valid AIOS backup?');
+  }
+
+  const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
+  const results = {
+    valid: true,
+    totalFiles: manifest.files.length,
+    verified: 0,
+    failed: [],
+    missing: [],
+  };
+
+  for (const file of manifest.files) {
+    const filePath = file.isConfig
+      ? path.join(backupDir, file.relativePath)
+      : path.join(backupDir, '.aios-core', file.relativePath);
+
+    if (!fs.existsSync(filePath)) {
+      results.missing.push(file.relativePath);
+      results.valid = false;
+      continue;
+    }
+
+    const checksum = await calculateChecksum(filePath);
+
+    if (checksum !== file.checksum) {
+      results.failed.push({
+        file: file.relativePath,
+        expected: file.checksum,
+        actual: checksum,
+      });
+      results.valid = false;
+    } else {
+      results.verified++;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Find the most recent backup directory
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<Object|null>} Backup info or null
+ */
+async function findLatestBackup(projectRoot) {
+  const entries = await fs.promises.readdir(projectRoot, { withFileTypes: true });
+
+  const backups = entries
+    .filter(entry => entry.isDirectory() && entry.name.startsWith('.aios-backup-'))
+    .map(entry => ({
+      name: entry.name,
+      path: path.join(projectRoot, entry.name),
+      date: entry.name.replace('.aios-backup-', ''),
+    }))
+    .sort((a, b) => b.date.localeCompare(a.date));
+
+  if (backups.length === 0) {
+    return null;
+  }
+
+  const latestBackup = backups[0];
+  const manifestPath = path.join(latestBackup.path, 'backup-manifest.json');
+
+  if (fs.existsSync(manifestPath)) {
+    const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
+    return {
+      ...latestBackup,
+      manifest,
+    };
+  }
+
+  return latestBackup;
+}
+
+/**
+ * List all available backups
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<Object[]>} Array of backup info
+ */
+async function listBackups(projectRoot) {
+  const entries = await fs.promises.readdir(projectRoot, { withFileTypes: true });
+
+  const backups = [];
+
+  for (const entry of entries) {
+    if (entry.isDirectory() && entry.name.startsWith('.aios-backup-')) {
+      const backupPath = path.join(projectRoot, entry.name);
+      const manifestPath = path.join(backupPath, 'backup-manifest.json');
+
+      const backup = {
+        name: entry.name,
+        path: backupPath,
+        date: entry.name.replace('.aios-backup-', ''),
+        hasManifest: false,
+        fileCount: 0,
+        totalSize: 0,
+      };
+
+      if (fs.existsSync(manifestPath)) {
+        const manifest = JSON.parse(await fs.promises.readFile(manifestPath, 'utf8'));
+        backup.hasManifest = true;
+        backup.fileCount = manifest.totalFiles;
+        backup.totalSize = manifest.totalSize;
+        backup.created = manifest.created;
+      }
+
+      backups.push(backup);
+    }
+  }
+
+  return backups.sort((a, b) => b.date.localeCompare(a.date));
+}
+
+module.exports = {
+  createBackupDirName,
+  calculateChecksum,
+  getFileStats,
+  copyFileWithMetadata,
+  getAllFiles,
+  createBackup,
+  verifyBackup,
+  findLatestBackup,
+  listBackups,
+};