bmad-elsabro 1.0.0

package/tools/cli/commands/diagnostics.js

@@ -0,0 +1,303 @@
+const chalk = require('chalk');
+const path = require('node:path');
+const os = require('node:os');
+const { execSync } = require('node:child_process');
+const { Installer } = require('../installers/lib/core/installer');
+const { Manifest } = require('../installers/lib/core/manifest');
+const { Detector } = require('../installers/lib/core/detector');
+
+const installer = new Installer();
+const manifest = new Manifest();
+const detector = new Detector();
+
+/**
+ * Execute a command and return output, or error message
+ * @param {string} command - Command to execute
+ * @returns {string} Command output or error message
+ */
+function execCommand(command) {
+  try {
+    return execSync(command, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch (error) {
+    return chalk.red('Not found or error');
+  }
+}
+
+/**
+ * Check for common issues in BMAD installation
+ * @param {string} bmadDir - BMAD directory path
+ * @param {Object} manifestData - Manifest data
+ * @returns {Array} Array of issue objects
+ */
+async function checkForIssues(bmadDir, manifestData) {
+  const issues = [];
+  const fs = require('fs-extra');
+
+  // Check if manifest exists
+  if (!manifestData) {
+    issues.push({
+      severity: 'error',
+      message: 'No manifest.yaml found',
+      suggestion: 'Run "bmad install" to set up or repair installation',
+    });
+    return issues;
+  }
+
+  // Check if installation version matches current CLI version
+  const packageJson = require('../../../package.json');
+  const cliVersion = packageJson.version;
+  const installedVersion = manifestData.installation?.version;
+
+  if (installedVersion && installedVersion !== cliVersion) {
+    issues.push({
+      severity: 'warning',
+      message: `Version mismatch: CLI v${cliVersion} vs Installation v${installedVersion}`,
+      suggestion: 'Run "bmad install" and select "Quick Update" to sync versions',
+    });
+  }
+
+  // Check if modules have their directories
+  const modules = manifestData.modules || [];
+  for (const module of modules) {
+    if (module.source === 'external') {
+      const moduleDir = path.join(bmadDir, '_config', 'external', module.id);
+      if (!(await fs.pathExists(moduleDir))) {
+        issues.push({
+          severity: 'error',
+          message: `Module directory missing: ${module.id}`,
+          suggestion: `Reinstall module using "bmad module add ${module.id}"`,
+        });
+      }
+    }
+  }
+
+  // Check if _config directory is writable
+  const configDir = path.join(bmadDir, '_config');
+  if (await fs.pathExists(configDir)) {
+    try {
+      await fs.access(configDir, fs.constants.W_OK);
+    } catch {
+      issues.push({
+        severity: 'error',
+        message: 'Configuration directory is not writable',
+        suggestion: 'Check file permissions on _config directory',
+      });
+    }
+  }
+
+  // Check for legacy folder structures
+  const legacyCfgPath = path.join(bmadDir, '_cfg');
+  if (await fs.pathExists(legacyCfgPath)) {
+    issues.push({
+      severity: 'warning',
+      message: 'Legacy "_cfg" folder detected',
+      suggestion: 'Run "bmad install" to migrate to current structure',
+    });
+  }
+
+  return issues;
+}
+
+module.exports = {
+  command: 'diagnostics',
+  description: 'Display system diagnostics and troubleshooting information',
+  options: [
+    ['-v, --verbose', 'Show detailed diagnostic information'],
+    ['--json', 'Output diagnostics in JSON format'],
+  ],
+  action: async (options) => {
+    try {
+      const jsonOutput = options.json || false;
+      const verbose = options.verbose || false;
+
+      // Collect diagnostic data
+      const diagnosticData = {
+        timestamp: new Date().toISOString(),
+        system: {},
+        bmad: {},
+        issues: [],
+      };
+
+      // System Information
+      diagnosticData.system = {
+        platform: os.platform(),
+        arch: os.arch(),
+        release: os.release(),
+        nodeVersion: process.version,
+        npmVersion: execCommand('npm --version'),
+        homeDir: os.homedir(),
+        currentDir: process.cwd(),
+      };
+
+      // BMAD Installation
+      const projectDir = process.cwd();
+      const { bmadDir } = await installer.findBmadDir(projectDir);
+
+      const fs = require('fs-extra');
+      if (await fs.pathExists(bmadDir)) {
+        diagnosticData.bmad.installed = true;
+        diagnosticData.bmad.location = bmadDir;
+
+        // Read manifest
+        const manifestData = await manifest._readRaw(bmadDir);
+        if (manifestData) {
+          diagnosticData.bmad.version = manifestData.installation?.version || 'unknown';
+          diagnosticData.bmad.installDate = manifestData.installation?.installDate;
+          diagnosticData.bmad.lastUpdated = manifestData.installation?.lastUpdated;
+          diagnosticData.bmad.modules = (manifestData.modules || []).map((m) => ({
+            id: m.id,
+            name: m.name,
+            version: m.version,
+            source: m.source,
+          }));
+
+          // Detect configured IDEs
+          const existingInstall = await detector.detect(bmadDir);
+          diagnosticData.bmad.ides = existingInstall.ides || [];
+
+          // Check for issues
+          diagnosticData.issues = await checkForIssues(bmadDir, manifestData);
+        } else {
+          diagnosticData.bmad.installed = false;
+          diagnosticData.issues.push({
+            severity: 'error',
+            message: 'BMAD directory exists but manifest is missing or corrupted',
+            suggestion: 'Run "bmad install" to repair installation',
+          });
+        }
+      } else {
+        diagnosticData.bmad.installed = false;
+        diagnosticData.issues.push({
+          severity: 'info',
+          message: 'No BMAD installation found',
+          suggestion: 'Run "bmad install" to set up a new installation',
+        });
+      }
+
+      // Get CLI version
+      const packageJson = require('../../../package.json');
+      diagnosticData.bmad.cliVersion = packageJson.version;
+
+      // Output results
+      if (jsonOutput) {
+        console.log(JSON.stringify(diagnosticData, null, 2));
+        process.exit(0);
+        return;
+      }
+
+      // Human-readable output
+      console.log('');
+      console.log(chalk.cyan.bold('🔍 BMAD Diagnostics'));
+      console.log(chalk.gray('─'.repeat(80)));
+
+      // System Section
+      console.log(chalk.yellow('\n📊 System Information'));
+      console.log(`  ${chalk.gray('Platform:'.padEnd(20))} ${diagnosticData.system.platform} (${diagnosticData.system.arch})`);
+      console.log(`  ${chalk.gray('OS Release:'.padEnd(20))} ${diagnosticData.system.release}`);
+      console.log(`  ${chalk.gray('Node.js:'.padEnd(20))} ${diagnosticData.system.nodeVersion}`);
+      console.log(`  ${chalk.gray('npm:'.padEnd(20))} ${diagnosticData.system.npmVersion}`);
+      console.log(`  ${chalk.gray('Current Directory:'.padEnd(20))} ${diagnosticData.system.currentDir}`);
+
+      if (verbose) {
+        console.log(`  ${chalk.gray('Home Directory:'.padEnd(20))} ${diagnosticData.system.homeDir}`);
+      }
+
+      // BMAD Installation Section
+      console.log(chalk.yellow('\n🔧 BMAD Installation'));
+      console.log(`  ${chalk.gray('CLI Version:'.padEnd(20))} ${diagnosticData.bmad.cliVersion}`);
+
+      if (diagnosticData.bmad.installed) {
+        console.log(`  ${chalk.gray('Installed:'.padEnd(20))} ${chalk.green('Yes')}`);
+        console.log(`  ${chalk.gray('Version:'.padEnd(20))} ${diagnosticData.bmad.version}`);
+        console.log(`  ${chalk.gray('Location:'.padEnd(20))} ${diagnosticData.bmad.location}`);
+
+        if (diagnosticData.bmad.installDate) {
+          console.log(`  ${chalk.gray('Install Date:'.padEnd(20))} ${new Date(diagnosticData.bmad.installDate).toLocaleDateString()}`);
+        }
+
+        if (diagnosticData.bmad.lastUpdated) {
+          console.log(`  ${chalk.gray('Last Updated:'.padEnd(20))} ${new Date(diagnosticData.bmad.lastUpdated).toLocaleDateString()}`);
+        }
+
+        // Modules
+        if (diagnosticData.bmad.modules && diagnosticData.bmad.modules.length > 0) {
+          console.log(chalk.yellow('\n📦 Installed Modules'));
+          for (const module of diagnosticData.bmad.modules) {
+            const versionInfo = module.version ? chalk.gray(`v${module.version}`) : chalk.gray('unknown');
+            const sourceInfo = chalk.dim(`[${module.source}]`);
+            console.log(`  ${chalk.cyan(module.name.padEnd(25))} ${versionInfo.padEnd(15)} ${sourceInfo}`);
+          }
+        }
+
+        // IDEs/Tools
+        if (diagnosticData.bmad.ides && diagnosticData.bmad.ides.length > 0) {
+          console.log(chalk.yellow('\n🛠️  Configured Tools'));
+          for (const ide of diagnosticData.bmad.ides) {
+            console.log(`  ${chalk.cyan('•')} ${ide}`);
+          }
+        } else {
+          console.log(chalk.yellow('\n🛠️  Configured Tools'));
+          console.log(`  ${chalk.gray('No tools configured')}`);
+        }
+      } else {
+        console.log(`  ${chalk.gray('Installed:'.padEnd(20))} ${chalk.red('No')}`);
+        console.log(`  ${chalk.gray('Location:'.padEnd(20))} ${chalk.gray('N/A')}`);
+      }
+
+      // Issues Section
+      if (diagnosticData.issues.length > 0) {
+        console.log(chalk.yellow('\n⚠️  Issues & Recommendations'));
+
+        const errors = diagnosticData.issues.filter((i) => i.severity === 'error');
+        const warnings = diagnosticData.issues.filter((i) => i.severity === 'warning');
+        const info = diagnosticData.issues.filter((i) => i.severity === 'info');
+
+        if (errors.length > 0) {
+          console.log(chalk.red.bold('\n  Errors:'));
+          for (const issue of errors) {
+            console.log(`    ${chalk.red('✗')} ${issue.message}`);
+            console.log(`      ${chalk.dim('→')} ${issue.suggestion}`);
+          }
+        }
+
+        if (warnings.length > 0) {
+          console.log(chalk.yellow.bold('\n  Warnings:'));
+          for (const issue of warnings) {
+            console.log(`    ${chalk.yellow('⚠')} ${issue.message}`);
+            console.log(`      ${chalk.dim('→')} ${issue.suggestion}`);
+          }
+        }
+
+        if (info.length > 0) {
+          console.log(chalk.cyan.bold('\n  Info:'));
+          for (const issue of info) {
+            console.log(`    ${chalk.cyan('ℹ')} ${issue.message}`);
+            console.log(`      ${chalk.dim('→')} ${issue.suggestion}`);
+          }
+        }
+      } else {
+        console.log(chalk.green('\n✓ No issues detected'));
+      }
+
+      // Troubleshooting Tips
+      if (!options.json && verbose) {
+        console.log(chalk.yellow('\n💡 Troubleshooting Tips'));
+        console.log(chalk.dim('  • If commands fail, try running with sudo/admin privileges'));
+        console.log(chalk.dim('  • Check that Node.js version is >= 16.0.0'));
+        console.log(chalk.dim('  • Ensure npm packages are up to date with "npm install"'));
+        console.log(chalk.dim('  • For permission issues, check folder ownership and permissions'));
+        console.log(chalk.dim('  • Use "bmad install" to repair or update your installation'));
+        console.log(chalk.dim('  • Use "bmad status" to check module versions and updates'));
+      }
+
+      console.log('');
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('Diagnostics failed:'), error.message);
+      if (process.env.BMAD_DEBUG) {
+        console.error(chalk.dim(error.stack));
+      }
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/install.js

@@ -0,0 +1,87 @@
+const chalk = require('chalk');
+const path = require('node:path');
+const { Installer } = require('../installers/lib/core/installer');
+const { UI } = require('../lib/ui');
+
+const installer = new Installer();
+const ui = new UI();
+
+module.exports = {
+  command: 'install',
+  description: 'Install BMAD Core agents and tools',
+  options: [['-d, --debug', 'Enable debug output for manifest generation']],
+  action: async (options) => {
+    try {
+      // Set debug flag as environment variable for all components
+      if (options.debug) {
+        process.env.BMAD_DEBUG_MANIFEST = 'true';
+        console.log(chalk.cyan('Debug mode enabled\n'));
+      }
+
+      const config = await ui.promptInstall();
+
+      // Handle cancel
+      if (config.actionType === 'cancel') {
+        console.log(chalk.yellow('Installation cancelled.'));
+        process.exit(0);
+        return;
+      }
+
+      // Handle quick update separately
+      if (config.actionType === 'quick-update') {
+        const result = await installer.quickUpdate(config);
+        console.log(chalk.green('\n✨ Quick update complete!'));
+        console.log(chalk.cyan(`Updated ${result.moduleCount} modules with preserved settings (${result.modules.join(', ')})`));
+
+        // Display version-specific end message
+        const { MessageLoader } = require('../installers/lib/message-loader');
+        const messageLoader = new MessageLoader();
+        messageLoader.displayEndMessage();
+
+        process.exit(0);
+        return;
+      }
+
+      // Handle compile agents separately
+      if (config.actionType === 'compile-agents') {
+        const result = await installer.compileAgents(config);
+        console.log(chalk.green('\n✨ Agent recompilation complete!'));
+        console.log(chalk.cyan(`Recompiled ${result.agentCount} agents with customizations applied`));
+        process.exit(0);
+        return;
+      }
+
+      // Regular install/update flow
+      const result = await installer.install(config);
+
+      // Check if installation was cancelled
+      if (result && result.cancelled) {
+        process.exit(0);
+        return;
+      }
+
+      // Check if installation succeeded
+      if (result && result.success) {
+        // Display version-specific end message from install-messages.yaml
+        const { MessageLoader } = require('../installers/lib/message-loader');
+        const messageLoader = new MessageLoader();
+        messageLoader.displayEndMessage();
+
+        process.exit(0);
+      }
+    } catch (error) {
+      // Check if error has a complete formatted message
+      if (error.fullMessage) {
+        console.error(error.fullMessage);
+        if (error.stack) {
+          console.error('\n' + chalk.dim(error.stack));
+        }
+      } else {
+        // Generic error handling for all other errors
+        console.error(chalk.red('Installation failed:'), error.message);
+        console.error(chalk.dim(error.stack));
+      }
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/module.js

@@ -0,0 +1,210 @@
+const chalk = require('chalk');
+const path = require('node:path');
+const { Installer } = require('../installers/lib/core/installer');
+const { Manifest } = require('../installers/lib/core/manifest');
+const { UI } = require('../lib/ui');
+const { confirm } = require('@clack/prompts');
+const { Command } = require('commander');
+
+const installer = new Installer();
+const manifest = new Manifest();
+const ui = new UI();
+
+// Create the module command with subcommands
+const moduleCommand = new Command('module');
+moduleCommand.description('Manage BMAD modules');
+
+// Add subcommand
+const addCommand = moduleCommand
+  .command('add <module-name>')
+  .description('Add a module to the BMAD installation')
+  .option('-s, --source <url>', 'Git repository URL or npm package name')
+  .option('-v, --version <version>', 'Specific version to install (for npm packages)')
+  .option('-f, --force', 'Force installation even if module already exists')
+  .action(async (moduleName, options) => {
+    try {
+      // Find the bmad directory
+      const projectDir = process.cwd();
+      const { bmadDir } = await installer.findBmadDir(projectDir);
+
+      // Check if bmad directory exists
+      const fs = require('fs-extra');
+      if (!(await fs.pathExists(bmadDir))) {
+        console.log(chalk.red('No BMAD installation found in the current directory.'));
+        console.log(chalk.dim(`Expected location: ${bmadDir}`));
+        console.log(chalk.dim('\nRun "bmad install" to set up a new installation first.'));
+        process.exit(1);
+        return;
+      }
+
+      // Read current manifest
+      const manifestData = await manifest._readRaw(bmadDir);
+
+      if (!manifestData) {
+        console.log(chalk.red('No BMAD installation manifest found.'));
+        console.log(chalk.dim('\nRun "bmad install" to set up a new installation first.'));
+        process.exit(1);
+        return;
+      }
+
+      // Check if module already exists
+      const existingModule = manifestData.modules?.find((m) => m.name === moduleName);
+      if (existingModule && !options.force) {
+        console.log(chalk.yellow(`Module "${moduleName}" is already installed.`));
+        console.log(chalk.dim(`Use --force to reinstall or update the module.`));
+        console.log(chalk.dim(`Current version: ${existingModule.version || 'unknown'}`));
+        process.exit(0);
+        return;
+      }
+
+      // Prepare module configuration
+      const moduleConfig = {
+        name: moduleName,
+        source: options.source || moduleName,
+        version: options.version || 'latest',
+      };
+
+      console.log(chalk.cyan(`\nAdding module: ${moduleName}`));
+      if (options.source) {
+        console.log(chalk.dim(`Source: ${options.source}`));
+      }
+      if (options.version) {
+        console.log(chalk.dim(`Version: ${options.version}`));
+      }
+
+      // Add the module using installer
+      const result = await installer.addModule(bmadDir, moduleConfig);
+
+      if (result && result.success) {
+        console.log(chalk.green('\n✨ Module added successfully!'));
+        console.log(chalk.dim(`Module "${moduleName}" has been added to your BMAD installation.`));
+        process.exit(0);
+      } else {
+        console.log(chalk.yellow('\n⚠️  Module addition completed with warnings.'));
+        if (result && result.message) {
+          console.log(chalk.dim(result.message));
+        }
+        process.exit(0);
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to add module:'), error.message);
+      if (process.env.BMAD_DEBUG) {
+        console.error(chalk.dim(error.stack));
+      }
+      process.exit(1);
+    }
+  });
+
+// Remove subcommand
+const removeCommand = moduleCommand
+  .command('remove <module-name>')
+  .description('Remove a module from the BMAD installation')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .option('--keep-data', 'Remove module but keep its data and configuration files')
+  .action(async (moduleName, options) => {
+    try {
+      // Find the bmad directory
+      const projectDir = process.cwd();
+      const { bmadDir } = await installer.findBmadDir(projectDir);
+
+      // Check if bmad directory exists
+      const fs = require('fs-extra');
+      if (!(await fs.pathExists(bmadDir))) {
+        console.log(chalk.red('No BMAD installation found in the current directory.'));
+        console.log(chalk.dim(`Expected location: ${bmadDir}`));
+        console.log(chalk.dim('\nRun "bmad install" to set up a new installation first.'));
+        process.exit(1);
+        return;
+      }
+
+      // Read current manifest
+      const manifestData = await manifest._readRaw(bmadDir);
+
+      if (!manifestData) {
+        console.log(chalk.red('No BMAD installation manifest found.'));
+        console.log(chalk.dim('\nRun "bmad install" to set up a new installation first.'));
+        process.exit(1);
+        return;
+      }
+
+      // Check if module exists
+      const existingModule = manifestData.modules?.find((m) => m.name === moduleName);
+      if (!existingModule) {
+        console.log(chalk.yellow(`Module "${moduleName}" is not installed.`));
+        console.log(chalk.dim('\nAvailable modules:'));
+        if (manifestData.modules && manifestData.modules.length > 0) {
+          for (const mod of manifestData.modules) {
+            console.log(chalk.dim(`  - ${mod.name} (${mod.version || 'unknown'})`));
+          }
+        } else {
+          console.log(chalk.dim('  (no modules installed)'));
+        }
+        process.exit(0);
+        return;
+      }
+
+      // Confirm removal unless --yes flag is provided
+      if (!options.yes) {
+        console.log(chalk.yellow(`\nYou are about to remove module: ${moduleName}`));
+        console.log(chalk.dim(`Version: ${existingModule.version || 'unknown'}`));
+        if (options.keepData) {
+          console.log(chalk.dim('Data and configuration will be preserved.'));
+        } else {
+          console.log(chalk.dim('All data and configuration will be removed.'));
+        }
+
+        const shouldContinue = await confirm({
+          message: 'Are you sure you want to continue?',
+          initialValue: false,
+        });
+
+        if (!shouldContinue || shouldContinue === 'cancel') {
+          console.log(chalk.yellow('\nModule removal cancelled.'));
+          process.exit(0);
+          return;
+        }
+      }
+
+      console.log(chalk.cyan(`\nRemoving module: ${moduleName}`));
+
+      // Remove the module using installer
+      const result = await installer.removeModule(bmadDir, moduleName, {
+        keepData: options.keepData,
+      });
+
+      if (result && result.success) {
+        console.log(chalk.green('\n✨ Module removed successfully!'));
+        console.log(chalk.dim(`Module "${moduleName}" has been removed from your BMAD installation.`));
+        if (options.keepData) {
+          console.log(chalk.dim('Data and configuration files have been preserved.'));
+        }
+        process.exit(0);
+      } else {
+        console.log(chalk.yellow('\n⚠️  Module removal completed with warnings.'));
+        if (result && result.message) {
+          console.log(chalk.dim(result.message));
+        }
+        process.exit(0);
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to remove module:'), error.message);
+      if (process.env.BMAD_DEBUG) {
+        console.error(chalk.dim(error.stack));
+      }
+      process.exit(1);
+    }
+  });
+
+// Export the module command in the format expected by bmad-cli.js
+// We need to export it in a way that the CLI loader can handle it specially
+module.exports = {
+  command: 'module',
+  description: 'Manage BMAD modules',
+  options: [],
+  // Instead of a simple action, we export the full Command object
+  commandObject: moduleCommand,
+  action: () => {
+    // This will be called if someone runs just 'bmad module' without subcommand
+    moduleCommand.outputHelp();
+  },
+};

package/tools/cli/commands/status.js

@@ -0,0 +1,65 @@
+const chalk = require('chalk');
+const path = require('node:path');
+const { Installer } = require('../installers/lib/core/installer');
+const { Manifest } = require('../installers/lib/core/manifest');
+const { UI } = require('../lib/ui');
+
+const installer = new Installer();
+const manifest = new Manifest();
+const ui = new UI();
+
+module.exports = {
+  command: 'status',
+  description: 'Display BMAD installation status and module versions',
+  options: [],
+  action: async (options) => {
+    try {
+      // Find the bmad directory
+      const projectDir = process.cwd();
+      const { bmadDir } = await installer.findBmadDir(projectDir);
+
+      // Check if bmad directory exists
+      const fs = require('fs-extra');
+      if (!(await fs.pathExists(bmadDir))) {
+        console.log(chalk.yellow('No BMAD installation found in the current directory.'));
+        console.log(chalk.dim(`Expected location: ${bmadDir}`));
+        console.log(chalk.dim('\nRun "bmad install" to set up a new installation.'));
+        process.exit(0);
+        return;
+      }
+
+      // Read manifest
+      const manifestData = await manifest._readRaw(bmadDir);
+
+      if (!manifestData) {
+        console.log(chalk.yellow('No BMAD installation manifest found.'));
+        console.log(chalk.dim('\nRun "bmad install" to set up a new installation.'));
+        process.exit(0);
+        return;
+      }
+
+      // Get installation info
+      const installation = manifestData.installation || {};
+      const modules = manifestData.modules || [];
+
+      // Check for available updates (only for external modules)
+      const availableUpdates = await manifest.checkForUpdates(bmadDir);
+
+      // Display status
+      ui.displayStatus({
+        installation,
+        modules,
+        availableUpdates,
+        bmadDir,
+      });
+
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('Status check failed:'), error.message);
+      if (process.env.BMAD_DEBUG) {
+        console.error(chalk.dim(error.stack));
+      }
+      process.exit(1);
+    }
+  },
+};