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

package/tools/cli/lib/agent-party-generator.js

@@ -3,7 +3,7 @@ const fs = require('fs-extra');
 
 const AgentPartyGenerator = {
   /**
-   * Generate agent-party.xml content
+   * Generate agent-manifest.csv content
    * @param {Array} agentDetails - Array of agent details
    * @param {Object} options - Generation options
    * @returns {string} XML content
@@ -28,7 +28,7 @@ const AgentPartyGenerator = {
     let xmlContent = `<!-- Powered by BMAD-CORE™ -->
 <!-- Agent Manifest - Generated during BMAD ${forWeb ? 'bundling' : 'installation'} -->
 <!-- This file contains a summary of all ${forWeb ? 'bundled' : 'installed'} agents for quick reference -->
-<manifest id="bmad/_cfg/agent-party.xml" version="1.0" generated="${new Date().toISOString()}">
+<manifest id="bmad/_cfg/agent-manifest.csv" version="1.0" generated="${new Date().toISOString()}">
   <description>
     Complete roster of ${forWeb ? 'bundled' : 'installed'} BMAD agents with summarized personas for efficient multi-agent orchestration.
     Used by party-mode and other multi-agent coordination features.
@@ -193,7 +193,7 @@ const AgentPartyGenerator = {
   },
 
   /**
-   * Write agent-party.xml to file
+   * Write agent-manifest.csv to file
    */
   async writeAgentParty(filePath, agentDetails, options = {}) {
     const content = this.generateAgentParty(agentDetails, options);

package/tools/cli/lib/ui.js

@@ -20,6 +20,72 @@ class UI {
     CLIUtils.displaySection('BMAD™ Setup', 'Build More, Architect Dreams');
 
     const confirmedDirectory = await this.getConfirmedDirectory();
+
+    // Check if there's an existing BMAD installation
+    const fs = require('fs-extra');
+    const path = require('node:path');
+    const bmadDir = path.join(confirmedDirectory, 'bmad');
+    const hasExistingInstall = await fs.pathExists(bmadDir);
+
+    // Track action type (only set if there's an existing installation)
+    let actionType;
+
+    // Only show action menu if there's an existing installation
+    if (hasExistingInstall) {
+      const promptResult = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'actionType',
+          message: 'What would you like to do?',
+          choices: [
+            { name: 'Quick Update (Settings Preserved)', value: 'quick-update' },
+            { name: 'Modify BMAD Installation (Confirm or change each setting)', value: 'update' },
+            { name: 'Remove BMad Folder and Reinstall (Full clean install - BMad Customization Will Be Lost)', value: 'reinstall' },
+            { name: 'Compile Agents (Quick rebuild of all agent .md files)', value: 'compile' },
+            { name: 'Cancel', value: 'cancel' },
+          ],
+          default: 'quick-update',
+        },
+      ]);
+
+      // Extract actionType from prompt result
+      actionType = promptResult.actionType;
+
+      // Handle quick update separately
+      if (actionType === 'quick-update') {
+        return {
+          actionType: 'quick-update',
+          directory: confirmedDirectory,
+        };
+      }
+
+      // Handle agent compilation separately
+      if (actionType === 'compile') {
+        return {
+          actionType: 'compile',
+          directory: confirmedDirectory,
+        };
+      }
+
+      // Handle cancel
+      if (actionType === 'cancel') {
+        return {
+          actionType: 'cancel',
+          directory: confirmedDirectory,
+        };
+      }
+
+      // Handle reinstall - DON'T return early, let it flow through configuration collection
+      // The installer will handle deletion when it sees actionType === 'reinstall'
+      // For now, just note that we're in reinstall mode and continue below
+
+      // If actionType === 'update' or 'reinstall', continue with normal flow below
+    }
+
+    // Collect IDE tool selection EARLY (before module configuration)
+    // This allows users to make all decisions upfront before file copying begins
+    const toolSelection = await this.promptToolSelection(confirmedDirectory, []);
+
     const { installedModuleIds } = await this.getExistingInstallation(confirmedDirectory);
     const coreConfig = await this.collectCoreConfig(confirmedDirectory);
     const moduleChoices = await this.getModuleChoices(installedModuleIds);
@@ -30,12 +96,13 @@ class UI {
     CLIUtils.displayModuleComplete('core', false); // false = don't clear the screen again
 
     return {
+      actionType: actionType || 'update', // Preserve reinstall or update action
       directory: confirmedDirectory,
       installCore: true, // Always install core
       modules: selectedModules,
-      // IDE selection moved to after module configuration
-      ides: [],
-      skipIde: true, // Will be handled later
+      // IDE selection collected early, will be configured later
+      ides: toolSelection.ides,
+      skipIde: toolSelection.skipIde,
       coreConfig: coreConfig, // Pass collected core config to installer
     };
   }
@@ -69,6 +136,11 @@ class UI {
     if (configuredIdes.length > 0) {
       ideChoices.push(new inquirer.Separator('── Previously Configured ──'));
       for (const ideValue of configuredIdes) {
+        // Skip empty or invalid IDE values
+        if (!ideValue || typeof ideValue !== 'string') {
+          continue;
+        }
+
         // Find the IDE in either preferred or other lists
         const preferredIde = preferredIdes.find((ide) => ide.value === ideValue);
         const otherIde = otherIdes.find((ide) => ide.value === ideValue);
@@ -81,6 +153,9 @@ class UI {
             checked: true, // Previously configured IDEs are checked by default
           });
           processedIdes.add(ide.value);
+        } else {
+          // Warn about unrecognized IDE (but don't fail)
+          console.log(chalk.yellow(`⚠️  Previously configured IDE '${ideValue}' is no longer available`));
         }
       }
     }

package/tools/cli/lib/xml-handler.js

@@ -2,9 +2,11 @@ const xml2js = require('xml2js');
 const fs = require('fs-extra');
 const path = require('node:path');
 const { getProjectRoot, getSourcePath } = require('./project-root');
+const { YamlXmlBuilder } = require('./yaml-xml-builder');
 
 /**
  * XML utility functions for BMAD installer
+ * Now supports both legacy XML agents and new YAML-based agents
  */
 class XmlHandler {
   constructor() {
@@ -33,6 +35,8 @@ class XmlHandler {
       attrkey: '$',
       charkey: '_',
     });
+
+    this.yamlBuilder = new YamlXmlBuilder();
   }
 
   /**
@@ -132,7 +136,7 @@ class XmlHandler {
   }
 
   /**
-   * Simple string-based injection (fallback method)
+   * Simple string-based injection (fallback method for legacy XML agents)
    * This preserves formatting better than XML parsing
    */
   injectActivationSimple(agentContent, metadata = {}) {
@@ -178,6 +182,47 @@ class XmlHandler {
       return agentContent;
     }
   }
+
+  /**
+   * Build agent from YAML source
+   * @param {string} yamlPath - Path to .agent.yaml file
+   * @param {string} customizePath - Path to .customize.yaml file (optional)
+   * @param {Object} metadata - Build metadata
+   * @returns {string} Generated XML content
+   */
+  async buildFromYaml(yamlPath, customizePath = null, metadata = {}) {
+    try {
+      // Use YamlXmlBuilder to convert YAML to XML
+      const mergedAgent = await this.yamlBuilder.loadAndMergeAgent(yamlPath, customizePath);
+
+      // Build metadata
+      const buildMetadata = {
+        sourceFile: path.basename(yamlPath),
+        sourceHash: await this.yamlBuilder.calculateFileHash(yamlPath),
+        customizeFile: customizePath ? path.basename(customizePath) : null,
+        customizeHash: customizePath ? await this.yamlBuilder.calculateFileHash(customizePath) : null,
+        builderVersion: '1.0.0',
+        includeMetadata: metadata.includeMetadata !== false,
+      };
+
+      // Convert to XML
+      const xml = await this.yamlBuilder.convertToXml(mergedAgent, buildMetadata);
+
+      return xml;
+    } catch (error) {
+      console.error('Error building agent from YAML:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if a path is a YAML agent file
+   * @param {string} filePath - Path to check
+   * @returns {boolean} True if it's a YAML agent file
+   */
+  isYamlAgent(filePath) {
+    return filePath.endsWith('.agent.yaml');
+  }
 }
 
 module.exports = { XmlHandler };

package/tools/cli/lib/yaml-xml-builder.js

@@ -0,0 +1,439 @@
+const yaml = require('js-yaml');
+const fs = require('fs-extra');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { AgentAnalyzer } = require('./agent-analyzer');
+const { ActivationBuilder } = require('./activation-builder');
+
+/**
+ * Converts agent YAML files to XML format with smart activation injection
+ */
+class YamlXmlBuilder {
+  constructor() {
+    this.analyzer = new AgentAnalyzer();
+    this.activationBuilder = new ActivationBuilder();
+  }
+
+  /**
+   * Deep merge two objects (for customize.yaml + agent.yaml)
+   * @param {Object} target - Target object
+   * @param {Object} source - Source object to merge in
+   * @returns {Object} Merged object
+   */
+  deepMerge(target, source) {
+    const output = { ...target };
+
+    if (this.isObject(target) && this.isObject(source)) {
+      for (const key of Object.keys(source)) {
+        if (this.isObject(source[key])) {
+          if (key in target) {
+            output[key] = this.deepMerge(target[key], source[key]);
+          } else {
+            output[key] = source[key];
+          }
+        } else if (Array.isArray(source[key])) {
+          // For arrays, append rather than replace (for commands)
+          if (Array.isArray(target[key])) {
+            output[key] = [...target[key], ...source[key]];
+          } else {
+            output[key] = source[key];
+          }
+        } else {
+          output[key] = source[key];
+        }
+      }
+    }
+
+    return output;
+  }
+
+  /**
+   * Check if value is an object
+   */
+  isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+  }
+
+  /**
+   * Load and merge agent YAML with customization
+   * @param {string} agentYamlPath - Path to base agent YAML
+   * @param {string} customizeYamlPath - Path to customize YAML (optional)
+   * @returns {Object} Merged agent configuration
+   */
+  async loadAndMergeAgent(agentYamlPath, customizeYamlPath = null) {
+    // Load base agent
+    const agentContent = await fs.readFile(agentYamlPath, 'utf8');
+    const agentYaml = yaml.load(agentContent);
+
+    // Load customization if exists
+    let merged = agentYaml;
+    if (customizeYamlPath && (await fs.pathExists(customizeYamlPath))) {
+      const customizeContent = await fs.readFile(customizeYamlPath, 'utf8');
+      const customizeYaml = yaml.load(customizeContent);
+
+      if (customizeYaml) {
+        // Special handling: persona fields are merged, but only non-empty values override
+        if (customizeYaml.persona) {
+          const basePersona = merged.agent.persona || {};
+          const customPersona = {};
+
+          // Only copy non-empty customize values
+          for (const [key, value] of Object.entries(customizeYaml.persona)) {
+            if (value !== '' && value !== null && !(Array.isArray(value) && value.length === 0)) {
+              customPersona[key] = value;
+            }
+          }
+
+          // Merge non-empty customize values over base
+          if (Object.keys(customPersona).length > 0) {
+            merged.agent.persona = { ...basePersona, ...customPersona };
+          }
+        }
+
+        // Merge metadata (only non-empty values)
+        if (customizeYaml.agent && customizeYaml.agent.metadata) {
+          const nonEmptyMetadata = {};
+          for (const [key, value] of Object.entries(customizeYaml.agent.metadata)) {
+            if (value !== '' && value !== null) {
+              nonEmptyMetadata[key] = value;
+            }
+          }
+          merged.agent.metadata = { ...merged.agent.metadata, ...nonEmptyMetadata };
+        }
+
+        // Append menu items (support both 'menu' and legacy 'commands')
+        const customMenuItems = customizeYaml.menu || customizeYaml.commands;
+        if (customMenuItems) {
+          // Determine if base uses 'menu' or 'commands'
+          if (merged.agent.menu) {
+            merged.agent.menu = [...merged.agent.menu, ...customMenuItems];
+          } else if (merged.agent.commands) {
+            merged.agent.commands = [...merged.agent.commands, ...customMenuItems];
+          } else {
+            // Default to 'menu' for new agents
+            merged.agent.menu = customMenuItems;
+          }
+        }
+
+        // Append critical actions
+        if (customizeYaml.critical_actions) {
+          merged.agent.critical_actions = [...(merged.agent.critical_actions || []), ...customizeYaml.critical_actions];
+        }
+      }
+    }
+
+    return merged;
+  }
+
+  /**
+   * Convert agent YAML to XML
+   * @param {Object} agentYaml - Parsed agent YAML object
+   * @param {Object} buildMetadata - Metadata about the build (file paths, hashes, etc.)
+   * @returns {string} XML content
+   */
+  async convertToXml(agentYaml, buildMetadata = {}) {
+    const agent = agentYaml.agent;
+    const metadata = agent.metadata || {};
+
+    // Add module from buildMetadata if available
+    if (buildMetadata.module) {
+      metadata.module = buildMetadata.module;
+    }
+
+    // Analyze agent to determine needed handlers
+    const profile = this.analyzer.analyzeAgentObject(agentYaml);
+
+    // Build activation block only if not skipped
+    let activationBlock = '';
+    if (!buildMetadata.skipActivation) {
+      activationBlock = await this.activationBuilder.buildActivation(
+        profile,
+        metadata,
+        agent.critical_actions || [],
+        buildMetadata.forWebBundle || false, // Pass web bundle flag
+      );
+    }
+
+    // Start building XML
+    let xml = '';
+
+    if (buildMetadata.forWebBundle) {
+      // Web bundle: keep existing format
+      xml += '<!-- Powered by BMAD-CORE™ -->\n\n';
+      xml += `# ${metadata.title || 'Agent'}\n\n`;
+    } else {
+      // Installation: use YAML frontmatter + instruction
+      // Extract name from filename: "cli-chief.yaml" or "pm.agent.yaml" -> "cli chief" or "pm"
+      const filename = buildMetadata.sourceFile || 'agent.yaml';
+      let nameFromFile = path.basename(filename, path.extname(filename)); // Remove .yaml/.md extension
+      nameFromFile = nameFromFile.replace(/\.agent$/, ''); // Remove .agent suffix if present
+      nameFromFile = nameFromFile.replaceAll('-', ' '); // Replace dashes with spaces
+
+      xml += '---\n';
+      xml += `name: "${nameFromFile}"\n`;
+      xml += `description: "${metadata.title || 'BMAD Agent'}"\n`;
+      xml += '---\n\n';
+      xml +=
+        "You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.\n\n";
+    }
+
+    xml += '```xml\n';
+
+    // Agent opening tag
+    const agentAttrs = [
+      `id="${metadata.id || ''}"`,
+      `name="${metadata.name || ''}"`,
+      `title="${metadata.title || ''}"`,
+      `icon="${metadata.icon || '🤖'}"`,
+    ];
+
+    // Add localskip attribute if present
+    if (metadata.localskip === true) {
+      agentAttrs.push('localskip="true"');
+    }
+
+    xml += `<agent ${agentAttrs.join(' ')}>\n`;
+
+    // Activation block (only if not skipped)
+    if (activationBlock) {
+      xml += activationBlock + '\n';
+    }
+
+    // Persona section
+    xml += this.buildPersonaXml(agent.persona);
+
+    // Prompts section (if exists)
+    if (agent.prompts) {
+      xml += this.buildPromptsXml(agent.prompts);
+    }
+
+    // Menu section (support both 'menu' and legacy 'commands')
+    const menuItems = agent.menu || agent.commands || [];
+    xml += this.buildCommandsXml(menuItems);
+
+    xml += '</agent>\n';
+    xml += '```\n';
+
+    return xml;
+  }
+
+  /**
+   * Build metadata comment
+   */
+  buildMetadataComment(metadata) {
+    const lines = ['<!-- BUILD-META', `  source: ${metadata.sourceFile || 'unknown'} (hash: ${metadata.sourceHash || 'unknown'})`];
+
+    if (metadata.customizeFile) {
+      lines.push(`  customize: ${metadata.customizeFile} (hash: ${metadata.customizeHash || 'unknown'})`);
+    }
+
+    lines.push(`  built: ${new Date().toISOString()}`, `  builder-version: ${metadata.builderVersion || '1.0.0'}`, '-->\n');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Build persona XML section
+   */
+  buildPersonaXml(persona) {
+    if (!persona) return '';
+
+    let xml = '  <persona>\n';
+
+    if (persona.role) {
+      xml += `    <role>${this.escapeXml(persona.role)}</role>\n`;
+    }
+
+    if (persona.identity) {
+      xml += `    <identity>${this.escapeXml(persona.identity)}</identity>\n`;
+    }
+
+    if (persona.communication_style) {
+      xml += `    <communication_style>${this.escapeXml(persona.communication_style)}</communication_style>\n`;
+    }
+
+    if (persona.principles) {
+      // Principles can be array or string
+      let principlesText;
+      if (Array.isArray(persona.principles)) {
+        principlesText = persona.principles.join(' ');
+      } else {
+        principlesText = persona.principles;
+      }
+      xml += `    <principles>${this.escapeXml(principlesText)}</principles>\n`;
+    }
+
+    xml += '  </persona>\n';
+
+    return xml;
+  }
+
+  /**
+   * Build prompts XML section
+   */
+  buildPromptsXml(prompts) {
+    if (!prompts || prompts.length === 0) return '';
+
+    let xml = '  <prompts>\n';
+
+    for (const prompt of prompts) {
+      xml += `    <prompt id="${prompt.id || ''}">\n`;
+      xml += `      <![CDATA[\n`;
+      xml += `      ${prompt.content || ''}\n`;
+      xml += `      ]]>\n`;
+      xml += `    </prompt>\n`;
+    }
+
+    xml += '  </prompts>\n';
+
+    return xml;
+  }
+
+  /**
+   * Build menu XML section (renamed from commands for clarity)
+   * Auto-injects *help and *exit, adds * prefix to all triggers
+   */
+  buildCommandsXml(menuItems) {
+    let xml = '  <menu>\n';
+
+    // Always inject *help first
+    xml += `    <item cmd="*help">Show numbered menu</item>\n`;
+
+    // Add user-defined menu items with * prefix
+    if (menuItems && menuItems.length > 0) {
+      for (const item of menuItems) {
+        // Build command attributes - add * prefix if not present
+        let trigger = item.trigger || '';
+        if (!trigger.startsWith('*')) {
+          trigger = '*' + trigger;
+        }
+
+        const attrs = [`cmd="${trigger}"`];
+
+        // Add handler attributes
+        if (item.workflow) attrs.push(`workflow="${item.workflow}"`);
+        if (item['validate-workflow']) attrs.push(`validate-workflow="${item['validate-workflow']}"`);
+        if (item.exec) attrs.push(`exec="${item.exec}"`);
+        if (item.tmpl) attrs.push(`tmpl="${item.tmpl}"`);
+        if (item.data) attrs.push(`data="${item.data}"`);
+        if (item.action) attrs.push(`action="${item.action}"`);
+
+        xml += `    <item ${attrs.join(' ')}>${this.escapeXml(item.description || '')}</item>\n`;
+      }
+    }
+
+    // Always inject *exit last
+    xml += `    <item cmd="*exit">Exit with confirmation</item>\n`;
+
+    xml += '  </menu>\n';
+
+    return xml;
+  }
+
+  /**
+   * Escape XML special characters
+   */
+  escapeXml(text) {
+    if (!text) return '';
+    return text
+      .replaceAll('&', '&amp;')
+      .replaceAll('<', '&lt;')
+      .replaceAll('>', '&gt;')
+      .replaceAll('"', '&quot;')
+      .replaceAll("'", '&apos;');
+  }
+
+  /**
+   * Calculate file hash for build tracking
+   */
+  async calculateFileHash(filePath) {
+    if (!(await fs.pathExists(filePath))) {
+      return null;
+    }
+
+    const content = await fs.readFile(filePath, 'utf8');
+    return crypto.createHash('md5').update(content).digest('hex').slice(0, 8);
+  }
+
+  /**
+   * Build agent XML from YAML files and return as string (for in-memory use)
+   * @param {string} agentYamlPath - Path to agent YAML
+   * @param {string} customizeYamlPath - Path to customize YAML (optional)
+   * @param {Object} options - Build options
+   * @returns {Promise<string>} XML content as string
+   */
+  async buildFromYaml(agentYamlPath, customizeYamlPath = null, options = {}) {
+    // Load and merge YAML files
+    const mergedAgent = await this.loadAndMergeAgent(agentYamlPath, customizeYamlPath);
+
+    // Calculate hashes for build tracking
+    const sourceHash = await this.calculateFileHash(agentYamlPath);
+    const customizeHash = customizeYamlPath ? await this.calculateFileHash(customizeYamlPath) : null;
+
+    // Extract module from path (e.g., /path/to/modules/bmm/agents/pm.yaml -> bmm)
+    // or /path/to/bmad/bmm/agents/pm.yaml -> bmm
+    let module = 'core'; // default to core
+    const pathParts = agentYamlPath.split(path.sep);
+
+    // Look for module indicators in the path
+    const modulesIndex = pathParts.indexOf('modules');
+    const bmadIndex = pathParts.indexOf('bmad');
+
+    if (modulesIndex !== -1 && pathParts[modulesIndex + 1]) {
+      // Path contains /modules/{module}/
+      module = pathParts[modulesIndex + 1];
+    } else if (bmadIndex !== -1 && pathParts[bmadIndex + 1]) {
+      // Path contains /bmad/{module}/
+      const potentialModule = pathParts[bmadIndex + 1];
+      // Check if it's a known module, not 'agents' or '_cfg'
+      if (['bmm', 'bmb', 'cis', 'core'].includes(potentialModule)) {
+        module = potentialModule;
+      }
+    }
+
+    // Build metadata
+    const buildMetadata = {
+      sourceFile: path.basename(agentYamlPath),
+      sourceHash,
+      customizeFile: customizeYamlPath ? path.basename(customizeYamlPath) : null,
+      customizeHash,
+      builderVersion: '1.0.0',
+      includeMetadata: options.includeMetadata !== false,
+      skipActivation: options.skipActivation === true,
+      forWebBundle: options.forWebBundle === true,
+      module: module, // Add module to buildMetadata
+    };
+
+    // Convert to XML and return
+    return await this.convertToXml(mergedAgent, buildMetadata);
+  }
+
+  /**
+   * Build agent XML from YAML files
+   * @param {string} agentYamlPath - Path to agent YAML
+   * @param {string} customizeYamlPath - Path to customize YAML (optional)
+   * @param {string} outputPath - Path to write XML file
+   * @param {Object} options - Build options
+   */
+  async buildAgent(agentYamlPath, customizeYamlPath, outputPath, options = {}) {
+    // Use buildFromYaml to get XML content
+    const xml = await this.buildFromYaml(agentYamlPath, customizeYamlPath, options);
+
+    // Write output file
+    await fs.ensureDir(path.dirname(outputPath));
+    await fs.writeFile(outputPath, xml, 'utf8');
+
+    // Calculate hashes for return value
+    const sourceHash = await this.calculateFileHash(agentYamlPath);
+    const customizeHash = customizeYamlPath ? await this.calculateFileHash(customizeYamlPath) : null;
+
+    return {
+      success: true,
+      outputPath,
+      sourceHash,
+      customizeHash,
+    };
+  }
+}
+
+module.exports = { YamlXmlBuilder };

package/tools/cli/regenerate-manifests.js

@@ -13,7 +13,7 @@ async function regenerateManifests() {
   console.log('Target directory:', bmadDir);
 
   try {
-    const result = await generator.generateManifests(bmadDir, selectedModules);
+    const result = await generator.generateManifests(bmadDir, selectedModules, [], { ides: [] });
     console.log('✓ Manifests generated successfully:');
     console.log(`  - ${result.workflows} workflows`);
     console.log(`  - ${result.agents} agents`);