bmad-method 6.0.0-alpha.0 → 6.0.0-alpha.1

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

@@ -10,6 +10,7 @@ class ConfigCollector {
   constructor() {
     this.collectedConfig = {};
     this.existingConfig = null;
+    this.currentProjectDir = null;
   }
 
   /**
@@ -25,22 +26,25 @@ class ConfigCollector {
       return false;
     }
 
-    // Try to load existing module configs
-    const modules = ['core', 'bmm', 'cis'];
+    // Dynamically discover all installed modules by scanning bmad directory
+    // A directory is a module ONLY if it contains a config.yaml file
     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;
+    const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const moduleConfigPath = path.join(bmadDir, entry.name, 'config.yaml');
+        if (await fs.pathExists(moduleConfigPath)) {
+          try {
+            const content = await fs.readFile(moduleConfigPath, 'utf8');
+            const moduleConfig = yaml.load(content);
+            if (moduleConfig) {
+              this.existingConfig[entry.name] = moduleConfig;
+              foundAny = true;
+            }
+          } catch {
+            // Ignore parse errors for individual modules
           }
-        } catch {
-          // Ignore parse errors for individual modules
         }
       }
     }
@@ -85,6 +89,203 @@ class ConfigCollector {
     return this.collectedConfig;
   }
 
+  /**
+   * Collect configuration for a single module (Quick Update mode - only new fields)
+   * @param {string} moduleName - Module name
+   * @param {string} projectDir - Target project directory
+   * @param {boolean} silentMode - If true, only prompt for new/missing fields
+   * @returns {boolean} True if new fields were prompted, false if all fields existed
+   */
+  async collectModuleConfigQuick(moduleName, projectDir, silentMode = true) {
+    this.currentProjectDir = projectDir;
+
+    // Load existing config if not already loaded
+    if (!this.existingConfig) {
+      await this.loadExistingConfig(projectDir);
+    }
+
+    // Initialize allAnswers if not already initialized
+    if (!this.allAnswers) {
+      this.allAnswers = {};
+    }
+
+    // Load module's install config schema
+    const installerConfigPath = path.join(getModulePath(moduleName), '_module-installer', 'install-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 schema for this module - use existing values
+      if (this.existingConfig && this.existingConfig[moduleName]) {
+        if (!this.collectedConfig[moduleName]) {
+          this.collectedConfig[moduleName] = {};
+        }
+        this.collectedConfig[moduleName] = { ...this.existingConfig[moduleName] };
+      }
+      return false;
+    }
+
+    const configContent = await fs.readFile(configPath, 'utf8');
+    const moduleConfig = yaml.load(configContent);
+
+    if (!moduleConfig) {
+      return false;
+    }
+
+    // Compare schema with existing config to find new/missing fields
+    const configKeys = Object.keys(moduleConfig).filter((key) => key !== 'prompt');
+    const existingKeys = this.existingConfig && this.existingConfig[moduleName] ? Object.keys(this.existingConfig[moduleName]) : [];
+
+    const newKeys = configKeys.filter((key) => {
+      const item = moduleConfig[key];
+      // Check if it's a config item and doesn't exist in existing config
+      return item && typeof item === 'object' && item.prompt && !existingKeys.includes(key);
+    });
+
+    // If in silent mode and no new keys, use existing config and skip prompts
+    if (silentMode && newKeys.length === 0) {
+      if (this.existingConfig && this.existingConfig[moduleName]) {
+        if (!this.collectedConfig[moduleName]) {
+          this.collectedConfig[moduleName] = {};
+        }
+        this.collectedConfig[moduleName] = { ...this.existingConfig[moduleName] };
+
+        // Also populate allAnswers for cross-referencing
+        for (const [key, value] of Object.entries(this.existingConfig[moduleName])) {
+          this.allAnswers[`${moduleName}_${key}`] = value;
+        }
+      }
+      return false; // No new fields
+    }
+
+    // If we have new fields, show prompt section and collect only new fields
+    if (newKeys.length > 0) {
+      console.log(chalk.yellow(`\n📋 New configuration options available for ${moduleName}`));
+      if (moduleConfig.prompt) {
+        const prompts = Array.isArray(moduleConfig.prompt) ? moduleConfig.prompt : [moduleConfig.prompt];
+        CLIUtils.displayPromptSection(prompts);
+      }
+
+      const questions = [];
+      for (const key of newKeys) {
+        const item = moduleConfig[key];
+        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];
+
+          let result;
+          if (Array.isArray(value)) {
+            result = value;
+          } else if (item.result) {
+            result = this.processResultTemplate(item.result, value);
+          } else {
+            result = value;
+          }
+
+          if (!this.collectedConfig[moduleName]) {
+            this.collectedConfig[moduleName] = {};
+          }
+          this.collectedConfig[moduleName][originalKey] = result;
+        }
+      }
+    }
+
+    // Copy over existing values for fields that weren't prompted
+    if (this.existingConfig && this.existingConfig[moduleName]) {
+      if (!this.collectedConfig[moduleName]) {
+        this.collectedConfig[moduleName] = {};
+      }
+      for (const [key, value] of Object.entries(this.existingConfig[moduleName])) {
+        if (!this.collectedConfig[moduleName][key]) {
+          this.collectedConfig[moduleName][key] = value;
+          this.allAnswers[`${moduleName}_${key}`] = value;
+        }
+      }
+    }
+
+    return newKeys.length > 0; // Return true if we prompted for new fields
+  }
+
+  /**
+   * Process a result template with value substitution
+   * @param {*} resultTemplate - The result template
+   * @param {*} value - The value to substitute
+   * @returns {*} Processed result
+   */
+  processResultTemplate(resultTemplate, value) {
+    let result = resultTemplate;
+
+    if (typeof result === 'string' && value !== undefined) {
+      if (typeof value === 'string') {
+        result = result.replace('{value}', value);
+      } else if (typeof value === 'boolean' || typeof value === 'number') {
+        if (result === '{value}') {
+          result = value;
+        } else {
+          result = result.replace('{value}', value);
+        }
+      } else {
+        result = value;
+      }
+
+      if (typeof result === 'string') {
+        result = result.replaceAll(/{([^}]+)}/g, (match, configKey) => {
+          if (configKey === 'project-root') {
+            return '{project-root}';
+          }
+          if (configKey === 'value') {
+            return match;
+          }
+
+          let configValue = this.allAnswers[configKey] || this.allAnswers[`${configKey}`];
+          if (!configValue) {
+            for (const [answerKey, answerValue] of Object.entries(this.allAnswers)) {
+              if (answerKey.endsWith(`_${configKey}`)) {
+                configValue = answerValue;
+                break;
+              }
+            }
+          }
+
+          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];
+                if (typeof configValue === 'string' && configValue.includes('{project-root}/')) {
+                  configValue = configValue.replace('{project-root}/', '');
+                }
+                break;
+              }
+            }
+          }
+
+          return configValue || match;
+        });
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Collect configuration for a single module
    * @param {string} moduleName - Module name
@@ -93,6 +294,7 @@ class ConfigCollector {
    * @param {boolean} skipCompletion - Skip showing completion message (for early core collection)
    */
   async collectModuleConfig(moduleName, projectDir, skipLoadExisting = false, skipCompletion = false) {
+    this.currentProjectDir = projectDir;
     // Load existing config if needed and not already loaded
     if (!skipLoadExisting && !this.existingConfig) {
       await this.loadExistingConfig(projectDir);
@@ -103,7 +305,7 @@ class ConfigCollector {
       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 installerConfigPath = path.join(getModulePath(moduleName), '_module-installer', 'install-config.yaml');
     const legacyConfigPath = path.join(getModulePath(moduleName), 'config.yaml');
 
     let configPath = null;
@@ -281,6 +483,11 @@ class ConfigCollector {
     let defaultValue = item.default;
     let choices = null;
 
+    if (typeof defaultValue === 'string' && defaultValue.includes('{directory_name}') && this.currentProjectDir) {
+      const dirName = path.basename(this.currentProjectDir);
+      defaultValue = defaultValue.replaceAll('{directory_name}', dirName);
+    }
+
     // Handle different question types
     if (item['single-select']) {
       questionType = 'list';

package/tools/cli/installers/lib/core/dependency-resolver.js

@@ -599,6 +599,7 @@ class DependencyResolver {
         organized[module] = {
           agents: [],
           tasks: [],
+          tools: [],
           templates: [],
           data: [],
           other: [],
@@ -626,6 +627,8 @@ class DependencyResolver {
         organized[module].agents.push(file);
       } else if (relative.startsWith('tasks/') || file.includes('/tasks/')) {
         organized[module].tasks.push(file);
+      } else if (relative.startsWith('tools/') || file.includes('/tools/')) {
+        organized[module].tools.push(file);
       } else if (relative.includes('template') || file.includes('/templates/')) {
         organized[module].templates.push(file);
       } else if (relative.includes('data/')) {
@@ -646,7 +649,8 @@ class DependencyResolver {
 
     for (const [module, files] of Object.entries(organized)) {
       const isSelected = selectedModules.includes(module) || module === 'core';
-      const totalFiles = files.agents.length + files.tasks.length + files.templates.length + files.data.length + files.other.length;
+      const totalFiles =
+        files.agents.length + files.tasks.length + files.tools.length + files.templates.length + files.data.length + files.other.length;
 
       if (totalFiles > 0) {
         console.log(chalk.cyan(`\n  ${module.toUpperCase()} module:`));

package/tools/cli/installers/lib/core/detector.js

@@ -55,14 +55,16 @@ class Detector {
     }
 
     // Check for modules
-    const entries = await fs.readdir(bmadDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg') {
-        const modulePath = path.join(bmadDir, entry.name);
+    // If manifest exists, use it as the source of truth for installed modules
+    // Otherwise fall back to directory scanning (legacy installations)
+    if (manifestData && manifestData.modules && manifestData.modules.length > 0) {
+      // Use manifest module list - these are officially installed modules
+      for (const moduleId of manifestData.modules) {
+        const modulePath = path.join(bmadDir, moduleId);
         const moduleConfigPath = path.join(modulePath, 'config.yaml');
 
         const moduleInfo = {
-          id: entry.name,
+          id: moduleId,
           path: modulePath,
           version: 'unknown',
         };
@@ -72,7 +74,7 @@ class Detector {
             const configContent = await fs.readFile(moduleConfigPath, 'utf8');
             const config = yaml.load(configContent);
             moduleInfo.version = config.version || 'unknown';
-            moduleInfo.name = config.name || entry.name;
+            moduleInfo.name = config.name || moduleId;
             moduleInfo.description = config.description;
           } catch {
             // Ignore config read errors
@@ -81,11 +83,42 @@ class Detector {
 
         result.modules.push(moduleInfo);
       }
+    } else {
+      // Fallback: scan directory for modules (legacy installations without manifest)
+      const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg') {
+          const modulePath = path.join(bmadDir, entry.name);
+          const moduleConfigPath = path.join(modulePath, 'config.yaml');
+
+          // Only treat it as a module if it has a config.yaml
+          if (await fs.pathExists(moduleConfigPath)) {
+            const moduleInfo = {
+              id: entry.name,
+              path: modulePath,
+              version: 'unknown',
+            };
+
+            try {
+              const configContent = await fs.readFile(moduleConfigPath, 'utf8');
+              const config = yaml.load(configContent);
+              moduleInfo.version = config.version || 'unknown';
+              moduleInfo.name = config.name || entry.name;
+              moduleInfo.description = config.description;
+            } catch {
+              // Ignore config read errors
+            }
+
+            result.modules.push(moduleInfo);
+          }
+        }
+      }
     }
 
     // Check for IDE configurations from manifest
     if (result.manifest && result.manifest.ides) {
-      result.ides = result.manifest.ides;
+      // Filter out any undefined/null values
+      result.ides = result.manifest.ides.filter((ide) => ide && typeof ide === 'string');
     }
 
     // Mark as installed if we found core or modules
@@ -191,14 +224,47 @@ class Detector {
     };
 
     const offenders = [];
-    if (await existsCaseSensitive(projectDir, ['.bmad-core'])) {
-      offenders.push(path.join(projectDir, '.bmad-core'));
-    }
-    if (await existsCaseSensitive(projectDir, ['.claude', 'commands', 'BMad'])) {
-      offenders.push(path.join(projectDir, '.claude', 'commands', 'BMad'));
+
+    // Find all directories starting with .bmad, bmad, or Bmad
+    try {
+      const entries = await fs.readdir(projectDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const name = entry.name;
+          // Match .bmad*, bmad* (lowercase), or Bmad* (capital B)
+          // BUT exclude 'bmad' exactly (that's the new v6 installation directory)
+          if ((name.startsWith('.bmad') || name.startsWith('bmad') || name.startsWith('Bmad')) && name !== 'bmad') {
+            offenders.push(path.join(projectDir, entry.name));
+          }
+        }
+      }
+    } catch {
+      // Ignore errors reading directory
     }
-    if (await existsCaseSensitive(projectDir, ['.crush', 'commands', 'BMad'])) {
-      offenders.push(path.join(projectDir, '.crush', 'commands', 'BMad'));
+
+    // Check inside various IDE command folders for legacy bmad folders
+    // List of IDE config folders that might have commands directories
+    const ideConfigFolders = ['.opencode', '.claude', '.crush', '.continue', '.cursor', '.windsurf', '.cline', '.roo-cline'];
+
+    for (const ideFolder of ideConfigFolders) {
+      const commandsDirName = ideFolder === '.opencode' ? 'command' : 'commands';
+      const commandsPath = path.join(projectDir, ideFolder, commandsDirName);
+      if (await fs.pathExists(commandsPath)) {
+        try {
+          const commandEntries = await fs.readdir(commandsPath, { withFileTypes: true });
+          for (const entry of commandEntries) {
+            if (entry.isDirectory()) {
+              const name = entry.name;
+              // Find bmad-related folders (excluding exact 'bmad' if it exists)
+              if ((name.startsWith('bmad') || name.startsWith('Bmad') || name === 'BMad') && name !== 'bmad') {
+                offenders.push(path.join(commandsPath, entry.name));
+              }
+            }
+          }
+        } catch {
+          // Ignore errors reading commands directory
+        }
+      }
     }
 
     return { hasLegacyV4: offenders.length > 0, offenders };

package/tools/cli/installers/lib/core/ide-config-manager.js

@@ -0,0 +1,152 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+
+/**
+ * Manages IDE configuration persistence
+ * Saves and loads IDE-specific configurations to/from bmad/_cfg/ides/
+ */
+class IdeConfigManager {
+  constructor() {}
+
+  /**
+   * Get path to IDE config directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @returns {string} Path to IDE config directory
+   */
+  getIdeConfigDir(bmadDir) {
+    return path.join(bmadDir, '_cfg', 'ides');
+  }
+
+  /**
+   * Get path to specific IDE config file
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name (e.g., 'claude-code')
+   * @returns {string} Path to IDE config file
+   */
+  getIdeConfigPath(bmadDir, ideName) {
+    return path.join(this.getIdeConfigDir(bmadDir), `${ideName}.yaml`);
+  }
+
+  /**
+   * Save IDE configuration
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name
+   * @param {Object} configuration - IDE-specific configuration object
+   */
+  async saveIdeConfig(bmadDir, ideName, configuration) {
+    const configDir = this.getIdeConfigDir(bmadDir);
+    await fs.ensureDir(configDir);
+
+    const configPath = this.getIdeConfigPath(bmadDir, ideName);
+    const now = new Date().toISOString();
+
+    // Check if config already exists to preserve configured_date
+    let configuredDate = now;
+    if (await fs.pathExists(configPath)) {
+      try {
+        const existing = await this.loadIdeConfig(bmadDir, ideName);
+        if (existing && existing.configured_date) {
+          configuredDate = existing.configured_date;
+        }
+      } catch {
+        // Ignore errors reading existing config
+      }
+    }
+
+    const configData = {
+      ide: ideName,
+      configured_date: configuredDate,
+      last_updated: now,
+      configuration: configuration || {},
+    };
+
+    const yamlContent = yaml.dump(configData, {
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true,
+      sortKeys: false,
+    });
+
+    await fs.writeFile(configPath, yamlContent, 'utf8');
+  }
+
+  /**
+   * Load IDE configuration
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name
+   * @returns {Object|null} IDE configuration or null if not found
+   */
+  async loadIdeConfig(bmadDir, ideName) {
+    const configPath = this.getIdeConfigPath(bmadDir, ideName);
+
+    if (!(await fs.pathExists(configPath))) {
+      return null;
+    }
+
+    try {
+      const content = await fs.readFile(configPath, 'utf8');
+      const config = yaml.load(content);
+      return config;
+    } catch (error) {
+      console.warn(`Warning: Failed to load IDE config for ${ideName}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Load all IDE configurations
+   * @param {string} bmadDir - BMAD installation directory
+   * @returns {Object} Map of IDE name to configuration
+   */
+  async loadAllIdeConfigs(bmadDir) {
+    const configDir = this.getIdeConfigDir(bmadDir);
+    const configs = {};
+
+    if (!(await fs.pathExists(configDir))) {
+      return configs;
+    }
+
+    try {
+      const files = await fs.readdir(configDir);
+      for (const file of files) {
+        if (file.endsWith('.yaml')) {
+          const ideName = file.replace('.yaml', '');
+          const config = await this.loadIdeConfig(bmadDir, ideName);
+          if (config) {
+            configs[ideName] = config.configuration;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn('Warning: Failed to load IDE configs:', error.message);
+    }
+
+    return configs;
+  }
+
+  /**
+   * Check if IDE has saved configuration
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name
+   * @returns {boolean} True if configuration exists
+   */
+  async hasIdeConfig(bmadDir, ideName) {
+    const configPath = this.getIdeConfigPath(bmadDir, ideName);
+    return await fs.pathExists(configPath);
+  }
+
+  /**
+   * Delete IDE configuration
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} ideName - IDE name
+   */
+  async deleteIdeConfig(bmadDir, ideName) {
+    const configPath = this.getIdeConfigPath(bmadDir, ideName);
+    if (await fs.pathExists(configPath)) {
+      await fs.remove(configPath);
+    }
+  }
+}
+
+module.exports = { IdeConfigManager };