bmad-method 5.1.2 → 6.0.0-alpha.0

package/tools/cli/commands/install.js

@@ -0,0 +1,41 @@
+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: [],
+  action: async () => {
+    try {
+      const config = await ui.promptInstall();
+      const result = await installer.install(config);
+
+      console.log(chalk.green('\n✨ Installation complete!'));
+      console.log(
+        chalk.cyan('BMAD Core and Selected Modules have been installed to:'),
+        chalk.bold(result.path || path.resolve(config.directory, 'bmad')),
+      );
+      console.log(chalk.yellow('\nThank you for helping test the early release version of the new BMad Core and BMad Method!'));
+      console.log(chalk.cyan('Check docs/alpha-release-notes.md in this repository for important information.'));
+      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/list.js

@@ -0,0 +1,28 @@
+const chalk = require('chalk');
+const { Installer } = require('../installers/lib/core/installer');
+
+const installer = new Installer();
+
+module.exports = {
+  command: 'list',
+  description: 'List available modules',
+  options: [],
+  action: async () => {
+    try {
+      const modules = await installer.getAvailableModules();
+      console.log(chalk.cyan('\n📦 Available BMAD Modules:\n'));
+
+      for (const module of modules) {
+        console.log(chalk.bold(`  ${module.id}`));
+        console.log(chalk.dim(`    ${module.description}`));
+        console.log(chalk.dim(`    Version: ${module.version}`));
+        console.log();
+      }
+
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/status.js

@@ -0,0 +1,47 @@
+const chalk = require('chalk');
+const { Installer } = require('../installers/lib/core/installer');
+
+const installer = new Installer();
+
+module.exports = {
+  command: 'status',
+  description: 'Show installation status',
+  options: [['-d, --directory <path>', 'Installation directory', '.']],
+  action: async (options) => {
+    try {
+      const status = await installer.getStatus(options.directory);
+
+      if (!status.installed) {
+        console.log(chalk.yellow('\n⚠️  No BMAD installation found in:'), options.directory);
+        console.log(chalk.dim('Run "bmad install" to set up BMAD Method'));
+        process.exit(0);
+      }
+
+      console.log(chalk.cyan('\n📊 BMAD Installation Status\n'));
+      console.log(chalk.bold('Location:'), status.path);
+      console.log(chalk.bold('Version:'), status.version);
+      console.log(chalk.bold('Core:'), status.hasCore ? chalk.green('✓ Installed') : chalk.red('✗ Not installed'));
+
+      if (status.modules.length > 0) {
+        console.log(chalk.bold('\nModules:'));
+        for (const mod of status.modules) {
+          console.log(`  ${chalk.green('✓')} ${mod.id} (v${mod.version})`);
+        }
+      } else {
+        console.log(chalk.bold('\nModules:'), chalk.dim('None installed'));
+      }
+
+      if (status.ides.length > 0) {
+        console.log(chalk.bold('\nConfigured IDEs:'));
+        for (const ide of status.ides) {
+          console.log(`  ${chalk.green('✓')} ${ide}`);
+        }
+      }
+
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/uninstall.js

@@ -0,0 +1,44 @@
+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: 'uninstall',
+  description: 'Remove BMAD installation',
+  options: [
+    ['-d, --directory <path>', 'Installation directory', '.'],
+    ['--force', 'Skip confirmation prompt'],
+  ],
+  action: async (options) => {
+    try {
+      const bmadPath = path.join(options.directory, 'bmad');
+
+      if (!options.force) {
+        const { confirm } = await ui.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to remove BMAD from ${bmadPath}?`,
+            default: false,
+          },
+        ]);
+
+        if (!confirm) {
+          console.log('Uninstall cancelled.');
+          process.exit(0);
+        }
+      }
+
+      await installer.uninstall(options.directory);
+      console.log(chalk.green('\n✨ BMAD Method has been uninstalled.'));
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('Uninstall failed:'), error.message);
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/commands/update.js

@@ -0,0 +1,28 @@
+const chalk = require('chalk');
+const { Installer } = require('../installers/lib/core/installer');
+
+const installer = new Installer();
+
+module.exports = {
+  command: 'update',
+  description: 'Update existing BMAD installation',
+  options: [
+    ['-d, --directory <path>', 'Installation directory', '.'],
+    ['--force', 'Force update, overwriting modified files'],
+    ['--dry-run', 'Show what would be updated without making changes'],
+  ],
+  action: async (options) => {
+    try {
+      await installer.update({
+        directory: options.directory,
+        force: options.force,
+        dryRun: options.dryRun,
+      });
+      console.log(chalk.green('\n✨ Update complete!'));
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('Update failed:'), error.message);
+      process.exit(1);
+    }
+  },
+};

package/tools/cli/installers/lib/core/config-collector.js

@@ -0,0 +1,383 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { getProjectRoot, getModulePath } = require('../../../lib/project-root');
+const { CLIUtils } = require('../../../lib/cli-utils');
+
+class ConfigCollector {
+  constructor() {
+    this.collectedConfig = {};
+    this.existingConfig = null;
+  }
+
+  /**
+   * Load existing config if it exists from module config files
+   * @param {string} projectDir - Target project directory
+   */
+  async loadExistingConfig(projectDir) {
+    const bmadDir = path.join(projectDir, 'bmad');
+    this.existingConfig = {};
+
+    // Check if bmad directory exists
+    if (!(await fs.pathExists(bmadDir))) {
+      return false;
+    }
+
+    // Try to load existing module configs
+    const modules = ['core', 'bmm', 'cis'];
+    let foundAny = false;
+
+    for (const moduleName of modules) {
+      const moduleConfigPath = path.join(bmadDir, moduleName, 'config.yaml');
+      if (await fs.pathExists(moduleConfigPath)) {
+        try {
+          const content = await fs.readFile(moduleConfigPath, 'utf8');
+          const moduleConfig = yaml.load(content);
+          if (moduleConfig) {
+            this.existingConfig[moduleName] = moduleConfig;
+            foundAny = true;
+          }
+        } catch {
+          // Ignore parse errors for individual modules
+        }
+      }
+    }
+
+    if (foundAny) {
+      console.log(chalk.cyan('\n📋 Found existing BMAD module configurations'));
+    }
+
+    return foundAny;
+  }
+
+  /**
+   * Collect configuration for all modules
+   * @param {Array} modules - List of modules to configure (including 'core')
+   * @param {string} projectDir - Target project directory
+   */
+  async collectAllConfigurations(modules, projectDir) {
+    await this.loadExistingConfig(projectDir);
+
+    // Check if core was already collected (e.g., in early collection phase)
+    const coreAlreadyCollected = this.collectedConfig.core && Object.keys(this.collectedConfig.core).length > 0;
+
+    // If core wasn't already collected, include it
+    const allModules = coreAlreadyCollected ? modules.filter((m) => m !== 'core') : ['core', ...modules.filter((m) => m !== 'core')];
+
+    // Store all answers across modules for cross-referencing
+    if (!this.allAnswers) {
+      this.allAnswers = {};
+    }
+
+    for (const moduleName of allModules) {
+      await this.collectModuleConfig(moduleName, projectDir);
+    }
+
+    // Add metadata
+    this.collectedConfig._meta = {
+      version: require(path.join(getProjectRoot(), 'package.json')).version,
+      installDate: new Date().toISOString(),
+      lastModified: new Date().toISOString(),
+    };
+
+    return this.collectedConfig;
+  }
+
+  /**
+   * Collect configuration for a single module
+   * @param {string} moduleName - Module name
+   * @param {string} projectDir - Target project directory
+   * @param {boolean} skipLoadExisting - Skip loading existing config (for early core collection)
+   * @param {boolean} skipCompletion - Skip showing completion message (for early core collection)
+   */
+  async collectModuleConfig(moduleName, projectDir, skipLoadExisting = false, skipCompletion = false) {
+    // Load existing config if needed and not already loaded
+    if (!skipLoadExisting && !this.existingConfig) {
+      await this.loadExistingConfig(projectDir);
+    }
+
+    // Initialize allAnswers if not already initialized
+    if (!this.allAnswers) {
+      this.allAnswers = {};
+    }
+    // Load module's config.yaml (check new location first, then fallback)
+    const installerConfigPath = path.join(getModulePath(moduleName), '_module-installer', 'install-menu-config.yaml');
+    const legacyConfigPath = path.join(getModulePath(moduleName), 'config.yaml');
+
+    let configPath = null;
+    if (await fs.pathExists(installerConfigPath)) {
+      configPath = installerConfigPath;
+    } else if (await fs.pathExists(legacyConfigPath)) {
+      configPath = legacyConfigPath;
+    } else {
+      // No config for this module
+      return;
+    }
+
+    const configContent = await fs.readFile(configPath, 'utf8');
+    const moduleConfig = yaml.load(configContent);
+
+    if (!moduleConfig) {
+      return;
+    }
+
+    // Display module prompts using better formatting
+    if (moduleConfig.prompt) {
+      const prompts = Array.isArray(moduleConfig.prompt) ? moduleConfig.prompt : [moduleConfig.prompt];
+      CLIUtils.displayPromptSection(prompts);
+    }
+
+    // Process each config item
+    const questions = [];
+    const configKeys = Object.keys(moduleConfig).filter((key) => key !== 'prompt');
+
+    for (const key of configKeys) {
+      const item = moduleConfig[key];
+
+      // Skip if not a config object
+      if (!item || typeof item !== 'object' || !item.prompt) {
+        continue;
+      }
+
+      const question = await this.buildQuestion(moduleName, key, item);
+      if (question) {
+        questions.push(question);
+      }
+    }
+
+    if (questions.length > 0) {
+      console.log(); // Line break before questions
+      const answers = await inquirer.prompt(questions);
+
+      // Store answers for cross-referencing
+      Object.assign(this.allAnswers, answers);
+
+      // Process answers and build result values
+      for (const key of Object.keys(answers)) {
+        const originalKey = key.replace(`${moduleName}_`, '');
+        const item = moduleConfig[originalKey];
+        const value = answers[key];
+
+        // Build the result using the template
+        let result;
+
+        // For arrays (multi-select), handle differently
+        if (Array.isArray(value)) {
+          // If there's a result template and it's a string, don't use it for arrays
+          // Just use the array value directly
+          result = value;
+        } else if (item.result) {
+          result = item.result;
+
+          // Replace placeholders only for strings
+          if (typeof result === 'string' && value !== undefined) {
+            // Replace {value} with the actual value
+            if (typeof value === 'string') {
+              result = result.replace('{value}', value);
+            } else if (typeof value === 'boolean' || typeof value === 'number') {
+              // For boolean and number values, if result is just "{value}", use the raw value
+              if (result === '{value}') {
+                result = value;
+              } else {
+                // Otherwise replace in the string
+                result = result.replace('{value}', value);
+              }
+            } else {
+              // For non-string values, use directly
+              result = value;
+            }
+
+            // Only do further replacements if result is still a string
+            if (typeof result === 'string') {
+              // Replace references to other config values
+              result = result.replaceAll(/{([^}]+)}/g, (match, configKey) => {
+                // Check if it's a special placeholder
+                if (configKey === 'project-root') {
+                  return '{project-root}';
+                }
+
+                // Skip if it's the 'value' placeholder we already handled
+                if (configKey === 'value') {
+                  return match;
+                }
+
+                // Look for the config value across all modules
+                // First check if it's in the current module's answers
+                let configValue = answers[`${moduleName}_${configKey}`];
+
+                // Then check all answers (for cross-module references like outputFolder)
+                if (!configValue) {
+                  // Try with various module prefixes
+                  for (const [answerKey, answerValue] of Object.entries(this.allAnswers)) {
+                    if (answerKey.endsWith(`_${configKey}`)) {
+                      configValue = answerValue;
+                      break;
+                    }
+                  }
+                }
+
+                // Check in already collected config
+                if (!configValue) {
+                  for (const mod of Object.keys(this.collectedConfig)) {
+                    if (mod !== '_meta' && this.collectedConfig[mod] && this.collectedConfig[mod][configKey]) {
+                      configValue = this.collectedConfig[mod][configKey];
+                      // Extract just the value part if it's a result template
+                      if (typeof configValue === 'string' && configValue.includes('{project-root}/')) {
+                        configValue = configValue.replace('{project-root}/', '');
+                      }
+                      break;
+                    }
+                  }
+                }
+
+                return configValue || match;
+              });
+            }
+          }
+        } else {
+          // No result template, use value directly
+          result = value;
+        }
+
+        // Store only the result value (no prompts, defaults, examples, etc.)
+        if (!this.collectedConfig[moduleName]) {
+          this.collectedConfig[moduleName] = {};
+        }
+        this.collectedConfig[moduleName][originalKey] = result;
+      }
+
+      // Display module completion message after collecting all answers (unless skipped)
+      if (!skipCompletion) {
+        CLIUtils.displayModuleComplete(moduleName);
+      }
+    }
+  }
+
+  /**
+   * Build an inquirer question from a config item
+   * @param {string} moduleName - Module name
+   * @param {string} key - Config key
+   * @param {Object} item - Config item definition
+   */
+  async buildQuestion(moduleName, key, item) {
+    const questionName = `${moduleName}_${key}`;
+
+    // Check for existing value
+    let existingValue = null;
+    if (this.existingConfig && this.existingConfig[moduleName]) {
+      existingValue = this.existingConfig[moduleName][key];
+
+      // Clean up existing value - remove {project-root}/ prefix if present
+      // This prevents duplication when the result template adds it back
+      if (typeof existingValue === 'string' && existingValue.startsWith('{project-root}/')) {
+        existingValue = existingValue.replace('{project-root}/', '');
+      }
+    }
+
+    // Determine question type and default value
+    let questionType = 'input';
+    let defaultValue = item.default;
+    let choices = null;
+
+    // Handle different question types
+    if (item['single-select']) {
+      questionType = 'list';
+      choices = item['single-select'];
+      if (existingValue && choices.includes(existingValue)) {
+        defaultValue = existingValue;
+      }
+    } else if (item['multi-select']) {
+      questionType = 'checkbox';
+      choices = item['multi-select'].map((choice) => ({
+        name: choice,
+        value: choice,
+        checked: existingValue
+          ? existingValue.includes(choice)
+          : item.default && Array.isArray(item.default)
+            ? item.default.includes(choice)
+            : false,
+      }));
+    } else if (typeof defaultValue === 'boolean') {
+      questionType = 'confirm';
+    }
+
+    // Build the prompt message
+    let message = '';
+
+    // Handle array prompts for multi-line messages
+    if (Array.isArray(item.prompt)) {
+      message = item.prompt.join('\n');
+    } else {
+      message = item.prompt;
+    }
+
+    // Add current value indicator for existing configs
+    if (existingValue !== null && existingValue !== undefined) {
+      if (typeof existingValue === 'boolean') {
+        message += chalk.dim(` (current: ${existingValue ? 'true' : 'false'})`);
+        defaultValue = existingValue;
+      } else if (Array.isArray(existingValue)) {
+        message += chalk.dim(` (current: ${existingValue.join(', ')})`);
+      } else if (questionType !== 'list') {
+        // Show the cleaned value (without {project-root}/) for display
+        message += chalk.dim(` (current: ${existingValue})`);
+        defaultValue = existingValue;
+      }
+    } else if (item.example && questionType === 'input') {
+      // Show example for input fields
+      const exampleText = typeof item.example === 'string' ? item.example.replace('{project-root}/', '') : JSON.stringify(item.example);
+      message += chalk.dim(` (e.g., ${exampleText})`);
+    }
+
+    const question = {
+      type: questionType,
+      name: questionName,
+      message: message,
+      default: defaultValue,
+    };
+
+    // Add choices for select types
+    if (choices) {
+      question.choices = choices;
+    }
+
+    // Add validation for input fields
+    if (questionType === 'input') {
+      question.validate = (input) => {
+        if (!input && item.required) {
+          return 'This field is required';
+        }
+        return true;
+      };
+    }
+
+    return question;
+  }
+
+  /**
+   * Deep merge two objects
+   * @param {Object} target - Target object
+   * @param {Object} source - Source object
+   */
+  deepMerge(target, source) {
+    const result = { ...target };
+
+    for (const key in source) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        if (result[key] && typeof result[key] === 'object' && !Array.isArray(result[key])) {
+          result[key] = this.deepMerge(result[key], source[key]);
+        } else {
+          result[key] = source[key];
+        }
+      } else {
+        result[key] = source[key];
+      }
+    }
+
+    return result;
+  }
+}
+
+module.exports = { ConfigCollector };