bmad-method 4.6.0 → 4.6.1

package/tools/builders/web-builder.js

@@ -12,6 +12,11 @@ class WebBuilder {
     this.templatePath = path.join(this.rootDir, 'bmad-core', 'templates', 'web-agent-startup-instructions-template.md');
   }
 
+  parseYaml(content) {
+    const yaml = require('js-yaml');
+    return yaml.load(content);
+  }
+
   async cleanOutputDirs() {
     for (const dir of this.outputDirs) {
       try {
@@ -232,7 +237,7 @@ class WebBuilder {
     const agentContent = await fs.readFile(agentPath, 'utf8');
     sections.push(this.formatSection(`agents#${agentName}`, agentContent));
 
-    // Resolve and add agent dependencies from expansion pack
+    // Resolve and add agent dependencies
     const agentYaml = agentContent.match(/```yaml\n([\s\S]*?)\n```/);
     if (agentYaml) {
       try {
@@ -240,16 +245,43 @@ class WebBuilder {
         const agentConfig = yaml.load(agentYaml[1]);
         
         if (agentConfig.dependencies) {
-          // Add resources from expansion pack
+          // Add resources, first try expansion pack, then core
           for (const [resourceType, resources] of Object.entries(agentConfig.dependencies)) {
             if (Array.isArray(resources)) {
               for (const resourceName of resources) {
-                const resourcePath = path.join(packDir, resourceType, `${resourceName}.md`);
-                try {
-                  const resourceContent = await fs.readFile(resourcePath, 'utf8');
-                  sections.push(this.formatSection(`${resourceType}#${resourceName}`, resourceContent));
-                } catch (error) {
-                  // Resource might not exist in expansion pack, that's ok
+                let found = false;
+                const extensions = ['.md', '.yml', '.yaml'];
+                
+                // Try expansion pack first
+                for (const ext of extensions) {
+                  const resourcePath = path.join(packDir, resourceType, `${resourceName}${ext}`);
+                  try {
+                    const resourceContent = await fs.readFile(resourcePath, 'utf8');
+                    sections.push(this.formatSection(`${resourceType}#${resourceName}`, resourceContent));
+                    found = true;
+                    break;
+                  } catch (error) {
+                    // Not in expansion pack, continue
+                  }
+                }
+                
+                // If not found in expansion pack, try core
+                if (!found) {
+                  for (const ext of extensions) {
+                    const corePath = path.join(this.rootDir, 'bmad-core', resourceType, `${resourceName}${ext}`);
+                    try {
+                      const coreContent = await fs.readFile(corePath, 'utf8');
+                      sections.push(this.formatSection(`${resourceType}#${resourceName}`, coreContent));
+                      found = true;
+                      break;
+                    } catch (error) {
+                      // Not in core either, continue
+                    }
+                  }
+                }
+                
+                if (!found) {
+                  console.warn(`    ⚠ Dependency ${resourceType}#${resourceName} not found in expansion pack or core`);
                 }
               }
             }
@@ -268,32 +300,164 @@ class WebBuilder {
 
     const sections = [template];
 
-    // Add team configuration
+    // Add team configuration and parse to get agent list
     const teamContent = await fs.readFile(teamConfigPath, 'utf8');
     const teamFileName = path.basename(teamConfigPath, '.yml');
+    const teamConfig = this.parseYaml(teamContent);
     sections.push(this.formatSection(`agent-teams#${teamFileName}`, teamContent));
 
-    // Add bmad-orchestrator (required for all teams)
-    const orchestratorPath = path.join(this.rootDir, 'bmad-core', 'agents', 'bmad-orchestrator.md');
-    const orchestratorContent = await fs.readFile(orchestratorPath, 'utf8');
-    sections.push(this.formatSection('agents#bmad-orchestrator', orchestratorContent));
-
-    // Add expansion pack agents
+    // Get list of expansion pack agents
+    const expansionAgents = new Set();
     const agentsDir = path.join(packDir, 'agents');
     try {
       const agentFiles = await fs.readdir(agentsDir);
       for (const agentFile of agentFiles.filter(f => f.endsWith('.md'))) {
-        const agentPath = path.join(agentsDir, agentFile);
-        const agentContent = await fs.readFile(agentPath, 'utf8');
         const agentName = agentFile.replace('.md', '');
-        sections.push(this.formatSection(`agents#${agentName}`, agentContent));
+        expansionAgents.add(agentName);
       }
     } catch (error) {
       console.warn(`    ⚠ No agents directory found in ${packName}`);
     }
 
-    // Add expansion pack resources (templates, tasks, checklists)
+    // Build a map of all available expansion pack resources for override checking
+    const expansionResources = new Map();
     const resourceDirs = ['templates', 'tasks', 'checklists', 'workflows', 'data'];
+    for (const resourceDir of resourceDirs) {
+      const resourcePath = path.join(packDir, resourceDir);
+      try {
+        const resourceFiles = await fs.readdir(resourcePath);
+        for (const resourceFile of resourceFiles.filter(f => f.endsWith('.md') || f.endsWith('.yml'))) {
+          const fileName = resourceFile.replace(/\.(md|yml)$/, '');
+          expansionResources.set(`${resourceDir}#${fileName}`, true);
+        }
+      } catch (error) {
+        // Directory might not exist, that's fine
+      }
+    }
+
+    // Process all agents listed in team configuration
+    const agentsToProcess = teamConfig.agents || [];
+    
+    // Ensure bmad-orchestrator is always included for teams
+    if (!agentsToProcess.includes('bmad-orchestrator')) {
+      console.warn(`    ⚠ Team ${teamFileName} missing bmad-orchestrator, adding automatically`);
+      agentsToProcess.unshift('bmad-orchestrator');
+    }
+
+    // Track all dependencies from all agents (deduplicated)
+    const allDependencies = new Map();
+
+    for (const agentId of agentsToProcess) {
+
+      if (expansionAgents.has(agentId)) {
+        // Use expansion pack version (override)
+        const agentPath = path.join(agentsDir, `${agentId}.md`);
+        const agentContent = await fs.readFile(agentPath, 'utf8');
+        sections.push(this.formatSection(`agents#${agentId}`, agentContent));
+
+        // Parse and collect dependencies from expansion agent
+        const agentYaml = agentContent.match(/```yaml\n([\s\S]*?)\n```/);
+        if (agentYaml) {
+          try {
+            const agentConfig = this.parseYaml(agentYaml[1]);
+            if (agentConfig.dependencies) {
+              for (const [resourceType, resources] of Object.entries(agentConfig.dependencies)) {
+                if (Array.isArray(resources)) {
+                  for (const resourceName of resources) {
+                    const key = `${resourceType}#${resourceName}`;
+                    if (!allDependencies.has(key)) {
+                      allDependencies.set(key, { type: resourceType, name: resourceName });
+                    }
+                  }
+                }
+              }
+            }
+          } catch (error) {
+            console.debug(`Failed to parse agent YAML for ${agentId}:`, error.message);
+          }
+        }
+      } else {
+        // Use core BMAD version
+        try {
+          const coreAgentPath = path.join(this.rootDir, 'bmad-core', 'agents', `${agentId}.md`);
+          const coreAgentContent = await fs.readFile(coreAgentPath, 'utf8');
+          sections.push(this.formatSection(`agents#${agentId}`, coreAgentContent));
+
+          // Parse and collect dependencies from core agent
+          const agentYaml = coreAgentContent.match(/```yaml\n([\s\S]*?)\n```/);
+          if (agentYaml) {
+            try {
+              // Clean up the YAML to handle command descriptions after dashes
+              let yamlContent = agentYaml[1];
+              yamlContent = yamlContent.replace(/^(\s*-)(\s*"[^"]+")(\s*-\s*.*)$/gm, '$1$2');
+              
+              const agentConfig = this.parseYaml(yamlContent);
+              if (agentConfig.dependencies) {
+                for (const [resourceType, resources] of Object.entries(agentConfig.dependencies)) {
+                  if (Array.isArray(resources)) {
+                    for (const resourceName of resources) {
+                      const key = `${resourceType}#${resourceName}`;
+                      if (!allDependencies.has(key)) {
+                        allDependencies.set(key, { type: resourceType, name: resourceName });
+                      }
+                    }
+                  }
+                }
+              }
+            } catch (error) {
+              console.debug(`Failed to parse agent YAML for ${agentId}:`, error.message);
+            }
+          }
+        } catch (error) {
+          console.warn(`    ⚠ Agent ${agentId} not found in core or expansion pack`);
+        }
+      }
+    }
+
+    // Add all collected dependencies from agents
+    // Always prefer expansion pack versions if they exist
+    for (const [key, dep] of allDependencies) {
+      let found = false;
+      const extensions = ['.md', '.yml', '.yaml'];
+      
+      // Always check expansion pack first, even if the dependency came from a core agent
+      if (expansionResources.has(key)) {
+        // We know it exists in expansion pack, find and load it
+        for (const ext of extensions) {
+          const expansionPath = path.join(packDir, dep.type, `${dep.name}${ext}`);
+          try {
+            const content = await fs.readFile(expansionPath, 'utf8');
+            sections.push(this.formatSection(key, content));
+            console.log(`      ✓ Using expansion override for ${key}`);
+            found = true;
+            break;
+          } catch (error) {
+            // Try next extension
+          }
+        }
+      }
+      
+      // If not found in expansion pack (or doesn't exist there), try core
+      if (!found) {
+        for (const ext of extensions) {
+          const corePath = path.join(this.rootDir, 'bmad-core', dep.type, `${dep.name}${ext}`);
+          try {
+            const content = await fs.readFile(corePath, 'utf8');
+            sections.push(this.formatSection(key, content));
+            found = true;
+            break;
+          } catch (error) {
+            // Not in core either, continue
+          }
+        }
+      }
+      
+      if (!found) {
+        console.warn(`    ⚠ Dependency ${key} not found in expansion pack or core`);
+      }
+    }
+
+    // Add remaining expansion pack resources not already included as dependencies
     for (const resourceDir of resourceDirs) {
       const resourcePath = path.join(packDir, resourceDir);
       try {
@@ -302,7 +466,12 @@ class WebBuilder {
           const filePath = path.join(resourcePath, resourceFile);
           const fileContent = await fs.readFile(filePath, 'utf8');
           const fileName = resourceFile.replace(/\.(md|yml)$/, '');
-          sections.push(this.formatSection(`${resourceDir}#${fileName}`, fileContent));
+          
+          // Only add if not already included as a dependency
+          const resourceKey = `${resourceDir}#${fileName}`;
+          if (!allDependencies.has(resourceKey)) {
+            sections.push(this.formatSection(resourceKey, fileContent));
+          }
         }
       } catch (error) {
         // Directory might not exist, that's fine

package/tools/installer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmad-method",
-  "version": "4.6.0",
+  "version": "4.6.1",
   "description": "BMAD Method installer - AI-powered Agile development framework",
   "main": "lib/installer.js",
   "bin": {