bmad-method 6.0.0-alpha.13 → 6.0.0-alpha.14

package/tools/cli/lib/agent/compiler.js

@@ -438,9 +438,10 @@ function compileToXml(agentYaml, agentName = '', targetPath = '') {
  * @param {Object} answers - Answers from install_config questions (or defaults)
  * @param {string} agentName - Optional final agent name (user's custom persona name)
  * @param {string} targetPath - Optional target path for agent ID
+ * @param {Object} options - Additional options including config
  * @returns {Object} { xml: string, metadata: Object }
  */
-function compileAgent(yamlContent, answers = {}, agentName = '', targetPath = '') {
+function compileAgent(yamlContent, answers = {}, agentName = '', targetPath = '', options = {}) {
   // Parse YAML
   const agentYaml = yaml.parse(yamlContent);
 
@@ -466,14 +467,22 @@ function compileAgent(yamlContent, answers = {}, agentName = '', targetPath = ''
     finalAnswers = { ...defaults, ...answers };
   }
 
+  // Add agent_sidecar_folder to answers if provided in config
+  if (options.config && options.config.agent_sidecar_folder) {
+    finalAnswers.agent_sidecar_folder = options.config.agent_sidecar_folder;
+  }
+
   // Process templates with answers
   const processedYaml = processAgentYaml(agentYaml, finalAnswers);
 
   // Strip install_config from output
   const cleanYaml = stripInstallConfig(processedYaml);
 
-  // Compile to XML
-  const xml = compileToXml(cleanYaml, agentName, targetPath);
+  // Replace {agent_sidecar_folder} in XML content
+  let xml = compileToXml(cleanYaml, agentName, targetPath);
+  if (finalAnswers.agent_sidecar_folder) {
+    xml = xml.replaceAll('{agent_sidecar_folder}', finalAnswers.agent_sidecar_folder);
+  }
 
   return {
     xml,
@@ -482,10 +491,39 @@ function compileAgent(yamlContent, answers = {}, agentName = '', targetPath = ''
   };
 }
 
+/**
+ * Process TTS injection markers in content
+ * @param {string} content - Content to process
+ * @param {boolean} enableAgentVibes - Whether AgentVibes is enabled
+ * @returns {Object} { content: string, hadInjection: boolean }
+ */
+function processTTSInjectionPoints(content, enableAgentVibes) {
+  const hasAgentTTS = content.includes('<!-- TTS_INJECTION:agent-tts -->');
+
+  if (enableAgentVibes && hasAgentTTS) {
+    // Replace agent-tts injection marker with TTS rule
+    content = content.replaceAll(
+      '<!-- TTS_INJECTION:agent-tts -->',
+      `- When responding to user messages, speak your responses using TTS:
+   Call: \`.claude/hooks/bmad-speak.sh '{agent-id}' '{response-text}'\` after each response
+   Replace {agent-id} with YOUR agent ID from <agent id="..."> tag at top of this file
+   Replace {response-text} with the text you just output to the user
+   IMPORTANT: Use single quotes as shown - do NOT escape special characters like ! or $ inside single quotes
+   Run in background (&) to avoid blocking`,
+    );
+    return { content, hadInjection: true };
+  } else if (!enableAgentVibes && hasAgentTTS) {
+    // Strip injection markers when disabled
+    content = content.replaceAll(/<!-- TTS_INJECTION:agent-tts -->\n?/g, '');
+  }
+
+  return { content, hadInjection: false };
+}
+
 /**
  * Compile agent file to .md
  * @param {string} yamlPath - Path to agent YAML file
- * @param {Object} options - { answers: {}, outputPath: string }
+ * @param {Object} options - { answers: {}, outputPath: string, enableAgentVibes: boolean }
  * @returns {Object} Compilation result
  */
 function compileAgentFile(yamlPath, options = {}) {
@@ -501,13 +539,24 @@ function compileAgentFile(yamlPath, options = {}) {
     outputPath = path.join(dir, `${basename}.md`);
   }
 
+  // Process TTS injection points if enableAgentVibes option is provided
+  let xml = result.xml;
+  let ttsInjected = false;
+  if (options.enableAgentVibes !== undefined) {
+    const ttsResult = processTTSInjectionPoints(xml, options.enableAgentVibes);
+    xml = ttsResult.content;
+    ttsInjected = ttsResult.hadInjection;
+  }
+
   // Write compiled XML
-  fs.writeFileSync(outputPath, result.xml, 'utf8');
+  fs.writeFileSync(outputPath, xml, 'utf8');
 
   return {
     ...result,
+    xml,
     outputPath,
     sourcePath: yamlPath,
+    ttsInjected,
   };
 }
 

package/tools/cli/lib/agent/installer.js

@@ -46,7 +46,7 @@ function resolvePath(pathStr, context) {
 }
 
 /**
- * Discover available agents in the custom agent location
+ * Discover available agents in the custom agent location recursively
  * @param {string} searchPath - Path to search for agents
  * @returns {Array} List of agent info objects
  */
@@ -56,35 +56,58 @@ function discoverAgents(searchPath) {
   }
 
   const agents = [];
-  const entries = fs.readdirSync(searchPath, { withFileTypes: true });
 
-  for (const entry of entries) {
-    const fullPath = path.join(searchPath, entry.name);
-
-    if (entry.isFile() && entry.name.endsWith('.agent.yaml')) {
-      // Simple agent (single file)
-      agents.push({
-        type: 'simple',
-        name: entry.name.replace('.agent.yaml', ''),
-        path: fullPath,
-        yamlFile: fullPath,
-      });
-    } else if (entry.isDirectory()) {
-      // Check for agent with sidecar (folder containing .agent.yaml)
-      const yamlFiles = fs.readdirSync(fullPath).filter((f) => f.endsWith('.agent.yaml'));
-      if (yamlFiles.length === 1) {
-        const agentYamlPath = path.join(fullPath, yamlFiles[0]);
+  // Helper function to recursively search
+  function searchDirectory(dir, relativePath = '') {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const agentRelativePath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+
+      if (entry.isFile() && entry.name.endsWith('.agent.yaml')) {
+        // Simple agent (single file)
+        // The agent name is based on the filename
+        const agentName = entry.name.replace('.agent.yaml', '');
         agents.push({
-          type: 'expert',
-          name: entry.name,
+          type: 'simple',
+          name: agentName,
           path: fullPath,
-          yamlFile: agentYamlPath,
-          hasSidecar: true,
+          yamlFile: fullPath,
+          relativePath: agentRelativePath.replace('.agent.yaml', ''),
         });
+      } else if (entry.isDirectory()) {
+        // Check if this directory contains an .agent.yaml file
+        try {
+          const dirContents = fs.readdirSync(fullPath);
+          const yamlFiles = dirContents.filter((f) => f.endsWith('.agent.yaml'));
+
+          if (yamlFiles.length > 0) {
+            // Found .agent.yaml files in this directory
+            for (const yamlFile of yamlFiles) {
+              const agentYamlPath = path.join(fullPath, yamlFile);
+              const agentName = path.basename(yamlFile, '.agent.yaml');
+
+              agents.push({
+                type: 'expert',
+                name: agentName,
+                path: fullPath,
+                yamlFile: agentYamlPath,
+                relativePath: agentRelativePath,
+              });
+            }
+          } else {
+            // No .agent.yaml in this directory, recurse deeper
+            searchDirectory(fullPath, agentRelativePath);
+          }
+        } catch {
+          // Skip directories we can't read
+        }
       }
     }
   }
 
+  searchDirectory(searchPath);
   return agents;
 }
 
@@ -103,12 +126,15 @@ function loadAgentConfig(yamlPath) {
   // These take precedence over defaults
   const savedAnswers = agentYaml?.saved_answers || {};
 
+  const metadata = agentYaml?.agent?.metadata || {};
+
   return {
     yamlContent: content,
     agentYaml,
     installConfig,
     defaults: { ...defaults, ...savedAnswers }, // saved_answers override defaults
-    metadata: agentYaml?.agent?.metadata || {},
+    metadata,
+    hasSidecar: metadata.hasSidecar === true,
   };
 }
 
@@ -208,9 +234,10 @@ async function promptInstallQuestions(installConfig, defaults, presetAnswers = {
  * @param {Object} agentInfo - Agent discovery info
  * @param {Object} answers - User answers for install_config
  * @param {string} targetPath - Target installation directory
+ * @param {Object} options - Additional options including config
  * @returns {Object} Installation result
  */
-function installAgent(agentInfo, answers, targetPath) {
+function installAgent(agentInfo, answers, targetPath, options = {}) {
   // Compile the agent
   const { xml, metadata, processedYaml } = compileAgent(fs.readFileSync(agentInfo.yamlFile, 'utf8'), answers);
 
@@ -237,11 +264,27 @@ function installAgent(agentInfo, answers, targetPath) {
     sidecarCopied: false,
   };
 
-  // Copy sidecar files for expert agents
-  if (agentInfo.hasSidecar && agentInfo.type === 'expert') {
-    const sidecarFiles = copySidecarFiles(agentInfo.path, agentTargetDir, agentInfo.yamlFile);
+  // Handle sidecar files for agents with hasSidecar flag
+  if (agentInfo.hasSidecar === true && agentInfo.type === 'expert') {
+    // Get agent sidecar folder from config or use default
+    const agentSidecarFolder = options.config?.agent_sidecar_folder || '{project-root}/.myagent-data';
+
+    // Resolve path variables
+    const resolvedSidecarFolder = agentSidecarFolder
+      .replaceAll('{project-root}', options.projectRoot || process.cwd())
+      .replaceAll('{bmad_folder}', options.bmadFolder || '.bmad');
+
+    // Create sidecar directory for this agent
+    const agentSidecarDir = path.join(resolvedSidecarFolder, agentFolderName);
+    if (!fs.existsSync(agentSidecarDir)) {
+      fs.mkdirSync(agentSidecarDir, { recursive: true });
+    }
+
+    // Find and copy sidecar folder
+    const sidecarFiles = copyAgentSidecarFiles(agentInfo.path, agentSidecarDir, agentInfo.yamlFile);
     result.sidecarCopied = true;
     result.sidecarFiles = sidecarFiles;
+    result.sidecarDir = agentSidecarDir;
   }
 
   return result;
@@ -285,6 +328,62 @@ function copySidecarFiles(sourceDir, targetDir, excludeYaml) {
   return copied;
 }
 
+/**
+ * Find and copy agent sidecar folders
+ * @param {string} sourceDir - Source agent directory
+ * @param {string} targetSidecarDir - Target sidecar directory for the agent
+ * @param {string} excludeYaml - The .agent.yaml file to exclude
+ * @returns {Array} List of copied files
+ */
+function copyAgentSidecarFiles(sourceDir, targetSidecarDir, excludeYaml) {
+  const copied = [];
+  const preserved = [];
+
+  // Find folders with "sidecar" in the name
+  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isDirectory() && entry.name.toLowerCase().includes('sidecar')) {
+      const sidecarSourcePath = path.join(sourceDir, entry.name);
+
+      // Recursively sync the sidecar folder contents (preserve existing, add new)
+      function syncSidecarDir(src, dest) {
+        if (!fs.existsSync(dest)) {
+          fs.mkdirSync(dest, { recursive: true });
+        }
+
+        // Get all files in source
+        const sourceEntries = fs.readdirSync(src, { withFileTypes: true });
+
+        for (const sourceEntry of sourceEntries) {
+          const srcPath = path.join(src, sourceEntry.name);
+          const destPath = path.join(dest, sourceEntry.name);
+
+          if (sourceEntry.isDirectory()) {
+            // Recursively sync subdirectories
+            syncSidecarDir(srcPath, destPath);
+          } else {
+            // Check if file already exists in destination
+            if (fs.existsSync(destPath)) {
+              // File exists - preserve it
+              preserved.push(destPath);
+            } else {
+              // File doesn't exist - copy it
+              fs.copyFileSync(srcPath, destPath);
+              copied.push(destPath);
+            }
+          }
+        }
+      }
+
+      syncSidecarDir(sidecarSourcePath, targetSidecarDir);
+    }
+  }
+
+  // Return info about what was preserved and what was copied
+  return { copied, preserved };
+}
+
 /**
  * Update agent metadata ID to reflect installed location
  * @param {string} compiledContent - Compiled XML content
@@ -721,6 +820,7 @@ module.exports = {
   promptInstallQuestions,
   installAgent,
   copySidecarFiles,
+  copyAgentSidecarFiles,
   updateAgentId,
   detectBmadProject,
   addToManifest,

package/tools/cli/lib/config.js

@@ -1,6 +1,7 @@
 const fs = require('fs-extra');
 const yaml = require('js-yaml');
 const path = require('node:path');
+const packageJson = require('../../../package.json');
 
 /**
  * Configuration utility class
@@ -50,7 +51,7 @@ class Config {
     const standardReplacements = {
       '{project-root}': replacements.root || '',
       '{module}': replacements.module || '',
-      '{version}': replacements.version || '5.0.0',
+      '{version}': replacements.version || packageJson.version,
       '{date}': new Date().toISOString().split('T')[0],
     };
 

package/tools/cli/lib/ui.js

@@ -116,8 +116,18 @@ class UI {
 
     const { installedModuleIds } = await this.getExistingInstallation(confirmedDirectory);
     const coreConfig = await this.collectCoreConfig(confirmedDirectory);
-    const moduleChoices = await this.getModuleChoices(installedModuleIds);
-    const selectedModules = await this.selectModules(moduleChoices);
+
+    // Skip module selection during update/reinstall - keep existing modules
+    let selectedModules;
+    if (actionType === 'update' || actionType === 'reinstall') {
+      // Keep all existing installed modules during update/reinstall
+      selectedModules = [...installedModuleIds];
+      console.log(chalk.cyan('\n📦 Keeping existing modules: ') + selectedModules.join(', '));
+    } else {
+      // Only show module selection for new installs
+      const moduleChoices = await this.getModuleChoices(installedModuleIds);
+      selectedModules = await this.selectModules(moduleChoices);
+    }
 
     // Prompt for AgentVibes TTS integration
     const agentVibesConfig = await this.promptAgentVibes(confirmedDirectory);
@@ -363,11 +373,60 @@ class UI {
       `🔧 Tools Configured: ${result.ides?.length > 0 ? result.ides.join(', ') : 'none'}`,
     ];
 
+    // Add AgentVibes TTS info if enabled
+    if (result.agentVibesEnabled) {
+      summary.push(`🎤 AgentVibes TTS: Enabled`);
+    }
+
     CLIUtils.displayBox(summary.join('\n\n'), {
       borderColor: 'green',
       borderStyle: 'round',
     });
 
+    // Display TTS injection details if present
+    if (result.ttsInjectedFiles && result.ttsInjectedFiles.length > 0) {
+      console.log('\n' + chalk.cyan.bold('═══════════════════════════════════════════════════'));
+      console.log(chalk.cyan.bold('            AgentVibes TTS Injection Summary'));
+      console.log(chalk.cyan.bold('═══════════════════════════════════════════════════\n'));
+
+      // Explain what TTS injection is
+      console.log(chalk.white.bold('What is TTS Injection?\n'));
+      console.log(chalk.dim('  TTS (Text-to-Speech) injection adds voice instructions to BMAD agents,'));
+      console.log(chalk.dim('  enabling them to speak their responses aloud using AgentVibes.\n'));
+      console.log(chalk.dim('  Example: When you activate the PM agent, it will greet you with'));
+      console.log(chalk.dim('  spoken audio like "Hey! I\'m your Project Manager. How can I help?"\n'));
+
+      console.log(chalk.green(`✅ TTS injection applied to ${result.ttsInjectedFiles.length} file(s):\n`));
+
+      // Group by type
+      const partyModeFiles = result.ttsInjectedFiles.filter((f) => f.type === 'party-mode');
+      const agentTTSFiles = result.ttsInjectedFiles.filter((f) => f.type === 'agent-tts');
+
+      if (partyModeFiles.length > 0) {
+        console.log(chalk.yellow('  Party Mode (multi-agent conversations):'));
+        for (const file of partyModeFiles) {
+          console.log(chalk.dim(`    • ${file.path}`));
+        }
+      }
+
+      if (agentTTSFiles.length > 0) {
+        console.log(chalk.yellow('  Agent TTS (individual agent voices):'));
+        for (const file of agentTTSFiles) {
+          console.log(chalk.dim(`    • ${file.path}`));
+        }
+      }
+
+      // Show backup info and restore command
+      console.log('\n' + chalk.white.bold('Backups & Recovery:\n'));
+      console.log(chalk.dim('  Pre-injection backups are stored in:'));
+      console.log(chalk.cyan('    ~/.bmad-tts-backups/\n'));
+      console.log(chalk.dim('  To restore original files (removes TTS instructions):'));
+      console.log(chalk.cyan(`    bmad-tts-injector.sh --restore ${result.path}\n`));
+
+      console.log(chalk.cyan('💡 BMAD agents will now speak when activated!'));
+      console.log(chalk.dim('   Ensure AgentVibes is installed: https://agentvibes.org'));
+    }
+
     console.log('\n' + chalk.green.bold('✨ BMAD is ready to use!'));
   }
 
@@ -432,11 +491,13 @@ class UI {
     const availableModules = await moduleManager.listAvailable();
 
     const isNewInstallation = installedModuleIds.size === 0;
-    return availableModules.map((mod) => ({
-      name: mod.name,
+    const moduleChoices = availableModules.map((mod) => ({
+      name: mod.isCustom ? `${mod.name} ${chalk.red('(Custom)')}` : mod.name,
       value: mod.id,
       checked: isNewInstallation ? mod.defaultSelected || false : installedModuleIds.has(mod.id),
     }));
+
+    return moduleChoices;
   }
 
   /**

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

@@ -232,21 +232,6 @@ class YamlXmlBuilder {
     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
    */