bmad-method 6.2.1-next.9 → 6.2.2

package/tools/cli/lib/agent/template-engine.js

@@ -1,152 +0,0 @@
-/**
- * Template Engine for BMAD Agent Install Configuration
- * Processes {{variable}}, {{#if}}, {{#unless}}, and {{/if}} blocks
- */
-
-/**
- * Process all template syntax in a string
- * @param {string} content - Content with template syntax
- * @param {Object} variables - Key-value pairs from install_config answers
- * @returns {string} Processed content
- */
-function processTemplate(content, variables = {}) {
-  let result = content;
-
-  // Process conditionals first (they may contain variables)
-  result = processConditionals(result, variables);
-
-  // Then process simple variable replacements
-  result = processVariables(result, variables);
-
-  // Clean up any empty lines left by removed conditionals
-  result = cleanupEmptyLines(result);
-
-  return result;
-}
-
-/**
- * Process {{#if}}, {{#unless}}, {{/if}}, {{/unless}} blocks
- */
-function processConditionals(content, variables) {
-  let result = content;
-
-  // Process {{#if variable == "value"}} blocks
-  // Handle both regular quotes and JSON-escaped quotes (\")
-  const ifEqualsPattern = /\{\{#if\s+(\w+)\s*==\s*\\?"([^"\\]+)\\?"\s*\}\}([\s\S]*?)\{\{\/if\}\}/g;
-  result = result.replaceAll(ifEqualsPattern, (match, varName, value, block) => {
-    return variables[varName] === value ? block : '';
-  });
-
-  // Process {{#if variable}} blocks (boolean or truthy check)
-  const ifBoolPattern = /\{\{#if\s+(\w+)\s*\}\}([\s\S]*?)\{\{\/if\}\}/g;
-  result = result.replaceAll(ifBoolPattern, (match, varName, block) => {
-    const val = variables[varName];
-    // Treat as truthy: true, non-empty string, non-zero number
-    const isTruthy = val === true || (typeof val === 'string' && val.length > 0) || (typeof val === 'number' && val !== 0);
-    return isTruthy ? block : '';
-  });
-
-  // Process {{#unless variable}} blocks (inverse of if)
-  const unlessPattern = /\{\{#unless\s+(\w+)\s*\}\}([\s\S]*?)\{\{\/unless\}\}/g;
-  result = result.replaceAll(unlessPattern, (match, varName, block) => {
-    const val = variables[varName];
-    const isFalsy = val === false || val === '' || val === null || val === undefined || val === 0;
-    return isFalsy ? block : '';
-  });
-
-  return result;
-}
-
-/**
- * Process {{variable}} replacements
- */
-function processVariables(content, variables) {
-  let result = content;
-
-  // Replace {{variable}} with value
-  const varPattern = /\{\{(\w+)\}\}/g;
-  result = result.replaceAll(varPattern, (match, varName) => {
-    if (Object.hasOwn(variables, varName)) {
-      return String(variables[varName]);
-    }
-    // If variable not found, leave as-is (might be runtime variable like {user_name})
-    return match;
-  });
-
-  return result;
-}
-
-/**
- * Clean up excessive empty lines left after removing conditional blocks
- */
-function cleanupEmptyLines(content) {
-  // Replace 3+ consecutive newlines with 2
-  return content.replaceAll(/\n{3,}/g, '\n\n');
-}
-
-/**
- * Extract install_config from agent YAML object
- * @param {Object} agentYaml - Parsed agent YAML
- * @returns {Object|null} install_config section or null
- */
-function extractInstallConfig(agentYaml) {
-  return agentYaml?.agent?.install_config || null;
-}
-
-/**
- * Remove install_config from agent YAML (after processing)
- * @param {Object} agentYaml - Parsed agent YAML
- * @returns {Object} Agent YAML without install_config
- */
-function stripInstallConfig(agentYaml) {
-  const result = structuredClone(agentYaml);
-  if (result.agent) {
-    delete result.agent.install_config;
-  }
-  return result;
-}
-
-/**
- * Process entire agent YAML object with template variables
- * @param {Object} agentYaml - Parsed agent YAML
- * @param {Object} variables - Answers from install_config questions
- * @returns {Object} Processed agent YAML
- */
-function processAgentYaml(agentYaml, variables) {
-  // Convert to JSON string, process templates, parse back
-  const jsonString = JSON.stringify(agentYaml, null, 2);
-  const processed = processTemplate(jsonString, variables);
-  return JSON.parse(processed);
-}
-
-/**
- * Get default values from install_config questions
- * @param {Object} installConfig - install_config section
- * @returns {Object} Default values keyed by variable name
- */
-function getDefaultValues(installConfig) {
-  const defaults = {};
-
-  if (!installConfig?.questions) {
-    return defaults;
-  }
-
-  for (const question of installConfig.questions) {
-    if (question.var && question.default !== undefined) {
-      defaults[question.var] = question.default;
-    }
-  }
-
-  return defaults;
-}
-
-module.exports = {
-  processTemplate,
-  processConditionals,
-  processVariables,
-  extractInstallConfig,
-  stripInstallConfig,
-  processAgentYaml,
-  getDefaultValues,
-  cleanupEmptyLines,
-};

package/tools/cli/lib/agent-analyzer.js

@@ -1,97 +0,0 @@
-const yaml = require('yaml');
-const fs = require('fs-extra');
-
-/**
- * Analyzes agent YAML files to detect which handlers are needed
- */
-class AgentAnalyzer {
-  /**
-   * Analyze an agent YAML structure to determine which handlers it needs
-   * @param {Object} agentYaml - Parsed agent YAML object
-   * @returns {Object} Profile of needed handlers
-   */
-  analyzeAgentObject(agentYaml) {
-    const profile = {
-      usedAttributes: new Set(),
-      hasPrompts: false,
-      menuItems: [],
-    };
-
-    // Check if agent has prompts section
-    if (agentYaml.agent && agentYaml.agent.prompts) {
-      profile.hasPrompts = true;
-    }
-
-    // Analyze menu items (support both 'menu' and legacy 'commands')
-    const menuItems = agentYaml.agent?.menu || agentYaml.agent?.commands || [];
-
-    for (const item of menuItems) {
-      // Track the menu item
-      profile.menuItems.push(item);
-
-      // Check for multi format items
-      if (item.multi && item.triggers) {
-        profile.usedAttributes.add('multi');
-
-        // Also check attributes in nested handlers
-        for (const triggerGroup of item.triggers) {
-          for (const [triggerName, execArray] of Object.entries(triggerGroup)) {
-            if (Array.isArray(execArray)) {
-              for (const exec of execArray) {
-                if (exec.route) {
-                  profile.usedAttributes.add('exec');
-                }
-                if (exec.action) profile.usedAttributes.add('action');
-                if (exec.type && ['exec', 'action'].includes(exec.type)) {
-                  profile.usedAttributes.add(exec.type);
-                }
-              }
-            }
-          }
-        }
-      } else {
-        // Check for each possible attribute in legacy items
-        if (item.exec) {
-          profile.usedAttributes.add('exec');
-        }
-        if (item.tmpl) {
-          profile.usedAttributes.add('tmpl');
-        }
-        if (item.data) {
-          profile.usedAttributes.add('data');
-        }
-        if (item.action) {
-          profile.usedAttributes.add('action');
-        }
-      }
-    }
-
-    // Convert Set to Array for easier use
-    profile.usedAttributes = [...profile.usedAttributes];
-
-    return profile;
-  }
-
-  /**
-   * Analyze an agent YAML file
-   * @param {string} filePath - Path to agent YAML file
-   * @returns {Object} Profile of needed handlers
-   */
-  async analyzeAgentFile(filePath) {
-    const content = await fs.readFile(filePath, 'utf8');
-    const agentYaml = yaml.parse(content);
-    return this.analyzeAgentObject(agentYaml);
-  }
-
-  /**
-   * Check if an agent needs a specific handler
-   * @param {Object} profile - Agent profile from analyze
-   * @param {string} handlerType - Handler type to check
-   * @returns {boolean} True if handler is needed
-   */
-  needsHandler(profile, handlerType) {
-    return profile.usedAttributes.includes(handlerType);
-  }
-}
-
-module.exports = { AgentAnalyzer };

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

@@ -1,194 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const { escapeXml } = require('../../lib/xml-utils');
-
-const AgentPartyGenerator = {
-  /**
-   * Generate agent-manifest.csv content
-   * @param {Array} agentDetails - Array of agent details
-   * @param {Object} options - Generation options
-   * @returns {string} XML content
-   */
-  generateAgentParty(agentDetails, options = {}) {
-    const { forWeb = false } = options;
-
-    // Group agents by module
-    const agentsByModule = {
-      bmm: [],
-      cis: [],
-      core: [],
-      custom: [],
-    };
-
-    for (const agent of agentDetails) {
-      const moduleKey = agentsByModule[agent.module] ? agent.module : 'custom';
-      agentsByModule[moduleKey].push(agent);
-    }
-
-    // Build XML content
-    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/_config/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.
-  </description>
-`;
-
-    // Add agents by module
-    for (const [module, agents] of Object.entries(agentsByModule)) {
-      if (agents.length === 0) continue;
-
-      const moduleTitle =
-        module === 'bmm' ? 'BMM Module' : module === 'cis' ? 'CIS Module' : module === 'core' ? 'Core Module' : 'Custom Module';
-
-      xmlContent += `\n  <!-- ${moduleTitle} Agents -->\n`;
-
-      for (const agent of agents) {
-        xmlContent += `  <agent id="${agent.id}" name="${agent.name}" title="${agent.title || ''}" icon="${agent.icon || ''}">
-    <persona>
-      <role>${escapeXml(agent.role || '')}</role>
-      <identity>${escapeXml(agent.identity || '')}</identity>
-      <communication_style>${escapeXml(agent.communicationStyle || '')}</communication_style>
-      <principles>${agent.principles || ''}</principles>
-    </persona>
-  </agent>\n`;
-      }
-    }
-
-    // Add statistics
-    const totalAgents = agentDetails.length;
-    const moduleList = Object.keys(agentsByModule)
-      .filter((m) => agentsByModule[m].length > 0)
-      .join(', ');
-
-    xmlContent += `\n  <statistics>
-    <total_agents>${totalAgents}</total_agents>
-    <modules>${moduleList}</modules>
-    <last_updated>${new Date().toISOString()}</last_updated>
-  </statistics>
-</manifest>`;
-
-    return xmlContent;
-  },
-
-  /**
-   * Extract agent details from XML content
-   * @param {string} content - Full agent file content (markdown with XML)
-   * @param {string} moduleName - Module name
-   * @param {string} agentName - Agent name
-   * @returns {Object} Agent details
-   */
-  extractAgentDetails(content, moduleName, agentName) {
-    try {
-      // Extract agent XML block
-      const agentMatch = content.match(/<agent[^>]*>([\s\S]*?)<\/agent>/);
-      if (!agentMatch) return null;
-
-      const agentXml = agentMatch[0];
-
-      // Extract attributes from opening tag
-      const nameMatch = agentXml.match(/name="([^"]*)"/);
-      const titleMatch = agentXml.match(/title="([^"]*)"/);
-      const iconMatch = agentXml.match(/icon="([^"]*)"/);
-
-      // Extract persona elements - now we just copy them as-is
-      const roleMatch = agentXml.match(/<role>([\s\S]*?)<\/role>/);
-      const identityMatch = agentXml.match(/<identity>([\s\S]*?)<\/identity>/);
-      const styleMatch = agentXml.match(/<communication_style>([\s\S]*?)<\/communication_style>/);
-      const principlesMatch = agentXml.match(/<principles>([\s\S]*?)<\/principles>/);
-
-      return {
-        id: `bmad/${moduleName}/agents/${agentName}.md`,
-        name: nameMatch ? nameMatch[1] : agentName,
-        title: titleMatch ? titleMatch[1] : 'Agent',
-        icon: iconMatch ? iconMatch[1] : '🤖',
-        module: moduleName,
-        role: roleMatch ? roleMatch[1].trim() : '',
-        identity: identityMatch ? identityMatch[1].trim() : '',
-        communicationStyle: styleMatch ? styleMatch[1].trim() : '',
-        principles: principlesMatch ? principlesMatch[1].trim() : '',
-      };
-    } catch (error) {
-      console.error(`Error extracting details for agent ${agentName}:`, error);
-      return null;
-    }
-  },
-
-  /**
-   * Extract attribute from XML tag
-   */
-  extractAttribute(xml, tagName, attrName) {
-    const regex = new RegExp(`<${tagName}[^>]*\\s${attrName}="([^"]*)"`, 'i');
-    const match = xml.match(regex);
-    return match ? match[1] : '';
-  },
-
-  /**
-   * Apply config overrides to agent details
-   * @param {Object} details - Original agent details
-   * @param {string} configContent - Config file content
-   * @returns {Object} Agent details with overrides applied
-   */
-  applyConfigOverrides(details, configContent) {
-    try {
-      // Extract agent-config XML block
-      const configMatch = configContent.match(/<agent-config>([\s\S]*?)<\/agent-config>/);
-      if (!configMatch) return details;
-
-      const configXml = configMatch[0];
-
-      // Extract override values
-      const nameMatch = configXml.match(/<name>([\s\S]*?)<\/name>/);
-      const titleMatch = configXml.match(/<title>([\s\S]*?)<\/title>/);
-      const roleMatch = configXml.match(/<role>([\s\S]*?)<\/role>/);
-      const identityMatch = configXml.match(/<identity>([\s\S]*?)<\/identity>/);
-      const styleMatch = configXml.match(/<communication_style>([\s\S]*?)<\/communication_style>/);
-      const principlesMatch = configXml.match(/<principles>([\s\S]*?)<\/principles>/);
-
-      // Apply overrides only if values are non-empty
-      if (nameMatch && nameMatch[1].trim()) {
-        details.name = nameMatch[1].trim();
-      }
-
-      if (titleMatch && titleMatch[1].trim()) {
-        details.title = titleMatch[1].trim();
-      }
-
-      if (roleMatch && roleMatch[1].trim()) {
-        details.role = roleMatch[1].trim();
-      }
-
-      if (identityMatch && identityMatch[1].trim()) {
-        details.identity = identityMatch[1].trim();
-      }
-
-      if (styleMatch && styleMatch[1].trim()) {
-        details.communicationStyle = styleMatch[1].trim();
-      }
-
-      if (principlesMatch && principlesMatch[1].trim()) {
-        // Principles are now just copied as-is (narrative paragraph)
-        details.principles = principlesMatch[1].trim();
-      }
-
-      return details;
-    } catch (error) {
-      console.error(`Error applying config overrides:`, error);
-      return details;
-    }
-  },
-
-  /**
-   * Write agent-manifest.csv to file
-   */
-  async writeAgentParty(filePath, agentDetails, options = {}) {
-    const content = this.generateAgentParty(agentDetails, options);
-    await fs.ensureDir(path.dirname(filePath));
-    await fs.writeFile(filePath, content, 'utf8');
-    return content;
-  },
-};
-
-module.exports = { AgentPartyGenerator };

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

@@ -1,177 +0,0 @@
-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() {
-    this.parser = new xml2js.Parser({
-      preserveChildrenOrder: true,
-      explicitChildren: true,
-      explicitArray: false,
-      trim: false,
-      normalizeTags: false,
-      attrkey: '$',
-      charkey: '_',
-    });
-
-    this.builder = new xml2js.Builder({
-      renderOpts: {
-        pretty: true,
-        indent: '  ',
-        newline: '\n',
-      },
-      xmldec: {
-        version: '1.0',
-        encoding: 'utf8',
-        standalone: false,
-      },
-      headless: true, // Don't add XML declaration
-      attrkey: '$',
-      charkey: '_',
-    });
-
-    this.yamlBuilder = new YamlXmlBuilder();
-  }
-
-  /**
-   * Load and parse the activation template
-   * @returns {Object} Parsed activation block
-   */
-  async loadActivationTemplate() {
-    console.error('Failed to load activation template:', error);
-  }
-
-  /**
-   * Inject activation block into agent XML content
-   * @param {string} agentContent - The agent file content
-   * @param {Object} metadata - Metadata containing module and name
-   * @returns {string} Modified content with activation block
-   */
-  async injectActivation(agentContent, metadata = {}) {
-    try {
-      // Check if already has activation
-      if (agentContent.includes('<activation')) {
-        return agentContent;
-      }
-
-      // Extract the XML portion from markdown if needed
-      let xmlContent = agentContent;
-      let beforeXml = '';
-      let afterXml = '';
-
-      const xmlBlockMatch = agentContent.match(/([\s\S]*?)```xml\n([\s\S]*?)\n```([\s\S]*)/);
-      if (xmlBlockMatch) {
-        beforeXml = xmlBlockMatch[1] + '```xml\n';
-        xmlContent = xmlBlockMatch[2];
-        afterXml = '\n```' + xmlBlockMatch[3];
-      }
-
-      // Parse the agent XML
-      const parsed = await this.parser.parseStringPromise(xmlContent);
-
-      // Get the activation template
-      const activationBlock = await this.loadActivationTemplate();
-      if (!activationBlock) {
-        console.warn('Could not load activation template');
-        return agentContent;
-      }
-
-      // Find the agent node
-      if (
-        parsed.agent && // Insert activation as the first child
-        !parsed.agent.activation
-      ) {
-        // Ensure proper structure
-        if (!parsed.agent.$$) {
-          parsed.agent.$$ = [];
-        }
-
-        // Create the activation node with proper structure
-        const activationNode = {
-          '#name': 'activation',
-          $: { critical: '1' },
-          $$: activationBlock.$$,
-        };
-
-        // Insert at the beginning
-        parsed.agent.$$.unshift(activationNode);
-      }
-
-      // Convert back to XML
-      let modifiedXml = this.builder.buildObject(parsed);
-
-      // Fix indentation - xml2js doesn't maintain our exact formatting
-      // Add 2-space base indentation to match our style
-      const lines = modifiedXml.split('\n');
-      const indentedLines = lines.map((line) => {
-        if (line.trim() === '') return line;
-        if (line.startsWith('<agent')) return line; // Keep agent at column 0
-        return '  ' + line; // Indent everything else
-      });
-      modifiedXml = indentedLines.join('\n');
-
-      // Reconstruct the full content
-      return beforeXml + modifiedXml + afterXml;
-    } catch (error) {
-      console.error('Error injecting activation:', error);
-      return agentContent;
-    }
-  }
-
-  /**
-   * TODO: DELETE THIS METHOD
-   */
-  injectActivationSimple(agentContent, metadata = {}) {
-    console.error('Error in simple injection:', error);
-  }
-
-  /**
-   * 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,
-        forWebBundle: metadata.forWebBundle || false, // Pass through forWebBundle flag
-      };
-
-      // 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/xml-to-markdown.js

@@ -1,82 +0,0 @@
-const fs = require('node:fs');
-const path = require('node:path');
-
-function convertXmlToMarkdown(xmlFilePath) {
-  if (!xmlFilePath.endsWith('.xml')) {
-    throw new Error('Input file must be an XML file');
-  }
-
-  const xmlContent = fs.readFileSync(xmlFilePath, 'utf8');
-
-  const basename = path.basename(xmlFilePath, '.xml');
-  const dirname = path.dirname(xmlFilePath);
-  const mdFilePath = path.join(dirname, `${basename}.md`);
-
-  // Extract version and name/title from root element attributes
-  let title = basename;
-  let version = '';
-
-  // Match the root element and its attributes
-  const rootMatch = xmlContent.match(
-    /<[^>\s]+[^>]*?\sv="([^"]+)"[^>]*?(?:\sname="([^"]+)")?|<[^>\s]+[^>]*?(?:\sname="([^"]+)")?[^>]*?\sv="([^"]+)"/,
-  );
-
-  if (rootMatch) {
-    // Handle both v="x" name="y" and name="y" v="x" orders
-    version = rootMatch[1] || rootMatch[4] || '';
-    const nameAttr = rootMatch[2] || rootMatch[3] || '';
-
-    if (nameAttr) {
-      title = nameAttr;
-    } else {
-      // Try to find name in a <name> element if not in attributes
-      const nameElementMatch = xmlContent.match(/<name>([^<]+)<\/name>/);
-      if (nameElementMatch) {
-        title = nameElementMatch[1];
-      }
-    }
-  }
-
-  const heading = version ? `# ${title} v${version}` : `# ${title}`;
-
-  const markdownContent = `${heading}
-
-\`\`\`xml
-${xmlContent}
-\`\`\`
-`;
-
-  fs.writeFileSync(mdFilePath, markdownContent, 'utf8');
-
-  return mdFilePath;
-}
-
-function main() {
-  const args = process.argv.slice(2);
-
-  if (args.length === 0) {
-    console.error('Usage: node xml-to-markdown.js <xml-file-path>');
-    process.exit(1);
-  }
-
-  const xmlFilePath = path.resolve(args[0]);
-
-  if (!fs.existsSync(xmlFilePath)) {
-    console.error(`Error: File not found: ${xmlFilePath}`);
-    process.exit(1);
-  }
-
-  try {
-    const mdFilePath = convertXmlToMarkdown(xmlFilePath);
-    console.log(`Successfully converted: ${xmlFilePath} -> ${mdFilePath}`);
-  } catch (error) {
-    console.error(`Error converting file: ${error.message}`);
-    process.exit(1);
-  }
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = { convertXmlToMarkdown };