bmad-enhanced 1.1.2 → 1.3.0

package/scripts/update/bmad-migrate.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+const chalk = require('chalk');
+const registry = require('./migrations/registry');
+
+/**
+ * BMAD-Enhanced Migrate CLI
+ * Manual migration control for advanced users
+ */
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // No args - show available migrations
+  if (args.length === 0) {
+    showAvailableMigrations();
+    return;
+  }
+
+  const migrationName = args[0];
+
+  // Find migration
+  const migrations = registry.getAllMigrations();
+  const migration = migrations.find(m => m.name === migrationName);
+
+  if (!migration) {
+    console.error('');
+    console.error(chalk.red(`Migration '${migrationName}' not found.`));
+    console.error('');
+    console.error('Run ' + chalk.cyan('npx bmad-migrate') + ' to see available migrations.');
+    console.error('');
+    process.exit(1);
+  }
+
+  // Load migration module
+  if (!migration.module) {
+    try {
+      migration.module = require(`./migrations/${migration.name}`);
+    } catch (error) {
+      console.error('');
+      console.error(chalk.red(`Failed to load migration: ${error.message}`));
+      console.error('');
+      process.exit(1);
+    }
+  }
+
+  // Run migration
+  console.log('');
+  console.log(chalk.cyan.bold(`Running migration: ${migration.name}`));
+  console.log(chalk.gray(migration.description));
+  console.log('');
+
+  try {
+    const changes = await migration.module.apply();
+
+    console.log('');
+    console.log(chalk.green.bold('✓ Migration completed'));
+    console.log('');
+    console.log(chalk.cyan('Changes:'));
+    changes.forEach(change => {
+      console.log(chalk.gray(`  - ${change}`));
+    });
+    console.log('');
+
+  } catch (error) {
+    console.error('');
+    console.error(chalk.red.bold('✗ Migration failed'));
+    console.error(chalk.red(error.message));
+    console.error('');
+    if (error.stack) {
+      console.error(chalk.gray(error.stack));
+      console.error('');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Show available migrations
+ */
+function showAvailableMigrations() {
+  const migrations = registry.getAllMigrations();
+
+  console.log('');
+  console.log(chalk.bold('Available Migrations'));
+  console.log('');
+
+  if (migrations.length === 0) {
+    console.log(chalk.yellow('No migrations available'));
+    console.log('');
+    return;
+  }
+
+  migrations.forEach((m, index) => {
+    const breaking = m.breaking ? chalk.red('[BREAKING]') : chalk.green('[SAFE]');
+    console.log(`  ${index + 1}. ${chalk.cyan(m.name)} ${breaking}`);
+    console.log(`     ${chalk.gray(m.description)}`);
+    console.log(`     ${chalk.gray(`${m.fromVersion} → ${m.toVersion}`)}`);
+    console.log('');
+  });
+
+  console.log('Usage: ' + chalk.cyan('npx bmad-migrate <migration-name>'));
+  console.log('');
+  console.log(chalk.yellow('Warning: Manual migrations bypass safety checks.'));
+  console.log(chalk.yellow('         Use ' + chalk.cyan('npx bmad-update') + ' for normal updates.'));
+  console.log('');
+}
+
+// Run main
+main().catch(error => {
+  console.error('');
+  console.error(chalk.red('Unexpected error:'));
+  console.error(chalk.red(error.message));
+  console.error('');
+  process.exit(1);
+});

package/scripts/update/bmad-update.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+const readline = require('readline');
+const chalk = require('chalk');
+const versionDetector = require('./lib/version-detector');
+const migrationRunner = require('./lib/migration-runner');
+const registry = require('./migrations/registry');
+
+/**
+ * BMAD-Enhanced Update CLI
+ * Main update command for users
+ */
+
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const yes = args.includes('--yes') || args.includes('-y');
+  const force = args.includes('--force');
+  const verbose = args.includes('--verbose') || args.includes('-v');
+
+  // Header
+  console.log('');
+  console.log(chalk.bold.magenta('╔════════════════════════════════════════╗'));
+  console.log(chalk.bold.magenta('║   BMAD-Enhanced Update Manager         ║'));
+  console.log(chalk.bold.magenta('╚════════════════════════════════════════╝'));
+  console.log('');
+
+  // 1. Detect current state
+  const currentVersion = versionDetector.getCurrentVersion();
+  const targetVersion = versionDetector.getTargetVersion();
+  const scenario = versionDetector.detectInstallationScenario();
+
+  // Handle different scenarios
+  if (scenario === 'fresh') {
+    console.log(chalk.yellow('No previous installation detected.'));
+    console.log('');
+    console.log('Run: ' + chalk.cyan('npx bmad-install-agents'));
+    console.log('');
+    process.exit(0);
+  }
+
+  if (scenario === 'partial' || scenario === 'corrupted') {
+    console.log(chalk.red('Installation appears incomplete or corrupted.'));
+    console.log('');
+    console.log('Recommend running: ' + chalk.cyan('npx bmad-install-agents'));
+    console.log('');
+    process.exit(1);
+  }
+
+  if (!currentVersion) {
+    console.log(chalk.yellow('Could not detect current version.'));
+    console.log('');
+    console.log('Run: ' + chalk.cyan('npx bmad-install-agents'));
+    console.log('');
+    process.exit(0);
+  }
+
+  // Get migration path
+  const migrationPath = versionDetector.getMigrationPath(currentVersion, targetVersion);
+
+  // Already up to date
+  if (migrationPath.type === 'up-to-date') {
+    console.log(chalk.green(`✓ Already up to date! (v${currentVersion})`));
+    console.log('');
+    process.exit(0);
+  }
+
+  // Downgrade attempt
+  if (migrationPath.type === 'downgrade') {
+    console.log(chalk.red.bold('⚠ DOWNGRADE DETECTED'));
+    console.log('');
+    console.log(`  Current version: ${currentVersion}`);
+    console.log(`  Package version: ${targetVersion}`);
+    console.log('');
+    console.log(chalk.yellow('Downgrades are not officially supported.'));
+    console.log('');
+    console.log('If you want to downgrade, please:');
+    console.log('  1. Backup your installation');
+    console.log('  2. Uninstall current version');
+    console.log('  3. Install desired version');
+    console.log('');
+    process.exit(1);
+  }
+
+  // 2. Show migration plan
+  console.log(chalk.cyan('Migration Plan:'));
+  console.log(`  From: ${chalk.red(currentVersion)}`);
+  console.log(`  To:   ${chalk.green(targetVersion)}`);
+  console.log('');
+
+  const migrations = registry.getMigrationsFor(currentVersion, targetVersion);
+
+  if (migrations.length === 0) {
+    console.log(chalk.yellow('No migrations needed (versions compatible)'));
+    console.log('');
+    process.exit(0);
+  }
+
+  console.log(chalk.cyan('Migrations to apply:'));
+  migrations.forEach((m, i) => {
+    const icon = m.breaking ? chalk.red('⚠') : chalk.green('✓');
+    console.log(`  ${i + 1}. ${icon} ${m.description}`);
+  });
+  console.log('');
+
+  // 3. Show breaking changes warning
+  const breakingChanges = registry.getBreakingChanges(currentVersion, targetVersion);
+  if (breakingChanges.length > 0) {
+    console.log(chalk.red.bold('⚠ BREAKING CHANGES:'));
+    breakingChanges.forEach(change => {
+      console.log(chalk.yellow(`  - ${change}`));
+    });
+    console.log('');
+  }
+
+  // 4. Dry run - preview only
+  if (dryRun) {
+    console.log(chalk.yellow.bold('DRY RUN - Previewing changes'));
+    console.log('');
+
+    try {
+      await migrationRunner.runMigrations(currentVersion, targetVersion, { dryRun: true, verbose });
+    } catch (error) {
+      console.error(chalk.red('Error during preview:'), error.message);
+      process.exit(1);
+    }
+
+    process.exit(0);
+  }
+
+  // 5. Confirm with user (unless --yes)
+  if (!yes) {
+    console.log(chalk.cyan('Your data will be backed up automatically before migration.'));
+    console.log('');
+
+    const confirmed = await confirm('Proceed with migration?');
+
+    if (!confirmed) {
+      console.log('');
+      console.log(chalk.yellow('Migration cancelled.'));
+      console.log('');
+      process.exit(0);
+    }
+  }
+
+  // 6. Run migrations
+  console.log('');
+  console.log(chalk.cyan.bold('Starting migration...'));
+
+  try {
+    const result = await migrationRunner.runMigrations(currentVersion, targetVersion, { verbose });
+
+    // 7. Show success report
+    console.log('');
+    console.log(chalk.green.bold('✓ Migration completed successfully!'));
+    console.log('');
+    console.log(chalk.cyan('Changes applied:'));
+    result.results.forEach(r => {
+      console.log(chalk.green(`  ✓ ${r.name}`));
+      if (verbose) {
+        r.changes.forEach(change => {
+          console.log(chalk.gray(`    - ${change}`));
+        });
+      }
+    });
+    console.log('');
+    console.log(chalk.gray(`Backup location: ${result.backupMetadata.backup_dir}`));
+    console.log('');
+
+  } catch (error) {
+    // Error already logged by migration-runner
+    process.exit(1);
+  }
+}
+
+/**
+ * Confirm action with user
+ * @param {string} message - Confirmation message
+ * @returns {Promise<boolean>} True if user confirms
+ */
+async function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise(resolve => {
+    rl.question(chalk.yellow(`${message} [y/N]: `), answer => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+// Run main
+main().catch(error => {
+  console.error('');
+  console.error(chalk.red.bold('Unexpected error:'));
+  console.error(chalk.red(error.message));
+  console.error('');
+  if (error.stack) {
+    console.error(chalk.gray(error.stack));
+    console.error('');
+  }
+  process.exit(1);
+});

package/scripts/update/bmad-version.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const versionDetector = require('./lib/version-detector');
+
+/**
+ * BMAD-Enhanced Version CLI
+ * Show version information and migration history
+ */
+
+async function main() {
+  const currentVersion = versionDetector.getCurrentVersion();
+  const targetVersion = versionDetector.getTargetVersion();
+  const scenario = versionDetector.detectInstallationScenario();
+
+  console.log('');
+  console.log(chalk.bold('BMAD-Enhanced Version Information'));
+  console.log('');
+
+  // Fresh install - not installed yet
+  if (scenario === 'fresh' || !currentVersion) {
+    console.log(chalk.yellow('Status:           Not installed'));
+    console.log(`Package version:  ${chalk.cyan(targetVersion)}`);
+    console.log('');
+    console.log('Run: ' + chalk.cyan('npx bmad-install-agents'));
+    console.log('');
+    return;
+  }
+
+  // Installed
+  console.log(`Installed version: ${chalk.cyan(currentVersion)}`);
+  console.log(`Package version:   ${chalk.cyan(targetVersion)}`);
+  console.log('');
+
+  // Status
+  if (currentVersion === targetVersion) {
+    console.log(chalk.green('Status: ✓ Up to date'));
+  } else if (versionDetector.compareVersions(currentVersion, targetVersion) < 0) {
+    console.log(chalk.yellow('Status: ⚠ Update available'));
+    console.log('');
+    console.log('Run: ' + chalk.cyan('npx bmad-update --dry-run') + ' (to preview)');
+    console.log('     ' + chalk.cyan('npx bmad-update') + ' (to apply)');
+  } else {
+    console.log(chalk.yellow(`Status: Package version (${targetVersion}) is older than installed (${currentVersion})`));
+  }
+
+  // Show migration history
+  const migrationHistory = await getMigrationHistory();
+  if (migrationHistory && migrationHistory.length > 0) {
+    console.log('');
+    console.log(chalk.cyan('Migration History:'));
+    migrationHistory.forEach((entry, index) => {
+      const timestamp = new Date(entry.timestamp).toLocaleDateString();
+      console.log(chalk.gray(`  ${index + 1}. ${entry.from_version} → ${entry.to_version} (${timestamp})`));
+      if (entry.migrations_applied && entry.migrations_applied.length > 0) {
+        entry.migrations_applied.forEach(m => {
+          console.log(chalk.gray(`     - ${m}`));
+        });
+      }
+    });
+  }
+
+  console.log('');
+}
+
+/**
+ * Get migration history from config.yaml
+ * @returns {Promise<Array|null>} Migration history or null
+ */
+async function getMigrationHistory() {
+  const configPath = path.join(process.cwd(), '_bmad/bme/_vortex/config.yaml');
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const configContent = await fs.readFile(configPath, 'utf8');
+    const config = yaml.load(configContent);
+
+    return config.migration_history || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+// Run main
+main().catch(error => {
+  console.error('Error:', error.message);
+  process.exit(1);
+});

package/scripts/update/lib/backup-manager.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Backup Manager for BMAD-Enhanced
+ * Creates backups before migrations and restores on failure
+ */
+
+/**
+ * Create a backup of critical installation files
+ * @param {string} version - Current version being backed up
+ * @returns {Promise<object>} Backup metadata
+ */
+async function createBackup(version) {
+  const timestamp = Date.now();
+  const backupDir = path.join(
+    process.cwd(),
+    '_bmad-output/.backups',
+    `backup-${version}-${timestamp}`
+  );
+
+  console.log(`Creating backup in: ${backupDir}`);
+
+  // Ensure backup directory exists
+  await ensureBackupDirectory();
+
+  // Create backup directory
+  await fs.ensureDir(backupDir);
+
+  const filesToBackup = getFilesToBackup();
+  const backedUpFiles = [];
+
+  // Copy each file/directory to backup
+  for (const file of filesToBackup) {
+    const sourcePath = path.join(process.cwd(), file.path);
+
+    if (!fs.existsSync(sourcePath)) {
+      console.log(`  Skipping ${file.path} (does not exist)`);
+      continue;
+    }
+
+    const destPath = path.join(backupDir, file.name);
+
+    try {
+      if (file.type === 'file') {
+        await fs.copy(sourcePath, destPath);
+      } else if (file.type === 'directory') {
+        await fs.copy(sourcePath, destPath);
+      }
+
+      backedUpFiles.push(file.path);
+      console.log(`  ✓ Backed up: ${file.path}`);
+    } catch (error) {
+      console.error(`  ✗ Failed to backup ${file.path}:`, error.message);
+      throw error;
+    }
+  }
+
+  // Count user data files (for integrity check)
+  const userDataCount = await countUserDataFiles();
+
+  // Create backup manifest
+  const manifest = {
+    version,
+    timestamp: new Date().toISOString(),
+    timestampMs: timestamp,
+    files_backed_up: backedUpFiles,
+    user_data_count: userDataCount,
+    backup_dir: backupDir
+  };
+
+  await fs.writeJson(path.join(backupDir, 'backup-manifest.json'), manifest, { spaces: 2 });
+
+  console.log(`  ✓ Backup manifest created`);
+  console.log(`  ✓ Backup complete: ${backedUpFiles.length} items backed up`);
+
+  return manifest;
+}
+
+/**
+ * Restore from backup after migration failure
+ * @param {object} backupMetadata - Metadata from createBackup
+ * @returns {Promise<void>}
+ */
+async function restoreBackup(backupMetadata) {
+  const backupDir = backupMetadata.backup_dir;
+
+  console.log('');
+  console.log(`Restoring from backup: ${backupDir}`);
+
+  if (!fs.existsSync(backupDir)) {
+    throw new Error(`Backup directory not found: ${backupDir}`);
+  }
+
+  const filesToRestore = getFilesToBackup();
+
+  for (const file of filesToRestore) {
+    const sourcePath = path.join(backupDir, file.name);
+
+    if (!fs.existsSync(sourcePath)) {
+      console.log(`  Skipping ${file.name} (not in backup)`);
+      continue;
+    }
+
+    const destPath = path.join(process.cwd(), file.path);
+
+    try {
+      // Remove existing file/directory first
+      if (fs.existsSync(destPath)) {
+        await fs.remove(destPath);
+      }
+
+      // Restore from backup
+      await fs.copy(sourcePath, destPath);
+      console.log(`  ✓ Restored: ${file.path}`);
+    } catch (error) {
+      console.error(`  ✗ Failed to restore ${file.path}:`, error.message);
+      throw error;
+    }
+  }
+
+  console.log(`  ✓ Restoration complete`);
+}
+
+/**
+ * List available backups
+ * @returns {Promise<Array>} List of backup metadata
+ */
+async function listBackups() {
+  const backupsDir = path.join(process.cwd(), '_bmad-output/.backups');
+
+  if (!fs.existsSync(backupsDir)) {
+    return [];
+  }
+
+  const entries = await fs.readdir(backupsDir);
+  const backups = [];
+
+  for (const entry of entries) {
+    const backupPath = path.join(backupsDir, entry);
+    const manifestPath = path.join(backupPath, 'backup-manifest.json');
+
+    if (fs.existsSync(manifestPath)) {
+      try {
+        const manifest = await fs.readJson(manifestPath);
+        backups.push(manifest);
+      } catch (error) {
+        console.warn(`Could not read manifest for ${entry}:`, error.message);
+      }
+    }
+  }
+
+  // Sort by timestamp (newest first)
+  backups.sort((a, b) => b.timestampMs - a.timestampMs);
+
+  return backups;
+}
+
+/**
+ * Clean up old backups, keeping only the most recent N
+ * @param {number} keepCount - Number of backups to keep
+ * @returns {Promise<number>} Number of backups deleted
+ */
+async function cleanupOldBackups(keepCount = 5) {
+  const backups = await listBackups();
+
+  if (backups.length <= keepCount) {
+    return 0; // Nothing to clean up
+  }
+
+  const toDelete = backups.slice(keepCount);
+  let deletedCount = 0;
+
+  for (const backup of toDelete) {
+    try {
+      await fs.remove(backup.backup_dir);
+      console.log(`  Deleted old backup: ${path.basename(backup.backup_dir)}`);
+      deletedCount++;
+    } catch (error) {
+      console.warn(`  Could not delete backup ${backup.backup_dir}:`, error.message);
+    }
+  }
+
+  return deletedCount;
+}
+
+/**
+ * Ensure backup directory exists
+ * @returns {Promise<void>}
+ */
+async function ensureBackupDirectory() {
+  const backupDir = path.join(process.cwd(), '_bmad-output/.backups');
+
+  if (!fs.existsSync(backupDir)) {
+    const outputDir = path.join(process.cwd(), '_bmad-output');
+
+    if (!fs.existsSync(outputDir)) {
+      throw new Error('_bmad-output directory not found. Is BMAD Method installed?');
+    }
+
+    await fs.ensureDir(backupDir);
+  }
+}
+
+/**
+ * Get list of files/directories to backup
+ * @returns {Array} List of file/directory definitions
+ */
+function getFilesToBackup() {
+  return [
+    {
+      name: 'config.yaml',
+      path: '_bmad/bme/_vortex/config.yaml',
+      type: 'file'
+    },
+    {
+      name: 'agents',
+      path: '_bmad/bme/_vortex/agents',
+      type: 'directory'
+    },
+    {
+      name: 'workflows',
+      path: '_bmad/bme/_vortex/workflows',
+      type: 'directory'
+    },
+    {
+      name: 'agent-manifest.csv',
+      path: '_bmad/_config/agent-manifest.csv',
+      type: 'file'
+    }
+  ];
+}
+
+/**
+ * Count user data files in _bmad-output (for integrity check)
+ * @returns {Promise<number>} Number of user files
+ */
+async function countUserDataFiles() {
+  const outputDir = path.join(process.cwd(), '_bmad-output');
+
+  if (!fs.existsSync(outputDir)) {
+    return 0;
+  }
+
+  let count = 0;
+
+  async function countRecursive(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      // Skip .backups and .logs directories
+      if (entry.name === '.backups' || entry.name === '.logs') {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        await countRecursive(fullPath);
+      } else if (entry.isFile()) {
+        count++;
+      }
+    }
+  }
+
+  await countRecursive(outputDir);
+  return count;
+}
+
+module.exports = {
+  createBackup,
+  restoreBackup,
+  listBackups,
+  cleanupOldBackups,
+  ensureBackupDirectory,
+  countUserDataFiles
+};