bmad-method 4.2.0 → 4.4.1

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "bmad-method",
-  "version": "4.2.0",
+  "version": "4.4.1",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "main": "tools/cli.js",
   "bin": {
-    "bmad": "./tools/bmad-npx-wrapper.js",
-    "bmad-method": "./tools/bmad-npx-wrapper.js"
+    "bmad": "tools/bmad-npx-wrapper.js",
+    "bmad-method": "tools/bmad-npx-wrapper.js"
   },
   "scripts": {
     "build": "node tools/cli.js build",
@@ -23,14 +23,14 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@kayvan/markdown-tree-parser": "^1.4.2",
-    "chalk": "^4.1.2",
-    "commander": "^9.4.1",
-    "fs-extra": "^11.1.0",
-    "glob": "^8.0.3",
-    "inquirer": "^8.2.5",
+    "@kayvan/markdown-tree-parser": "^1.5.0",
+    "chalk": "^5.4.1",
+    "commander": "^14.0.0",
+    "fs-extra": "^11.3.0",
+    "glob": "^11.0.3",
+    "inquirer": "^12.6.3",
     "js-yaml": "^4.1.0",
-    "ora": "^5.4.1"
+    "ora": "^8.2.0"
   },
   "keywords": [
     "agile",
@@ -45,10 +45,10 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/bmadcode/BMAD-METHOD.git"
+    "url": "git+https://github.com/bmadcode/BMAD-METHOD.git"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=20.0.0"
   },
   "devDependencies": {
     "husky": "^9.1.7",
@@ -60,14 +60,20 @@
     "yaml-lint": "^1.7.0"
   },
   "lint-staged": {
-    "*.{yml,yaml}": [
+    "**/*.{yml,yaml}": [
       "node tools/yaml-format.js"
     ],
-    "*.md": [
+    "**/*.md": [
       "node tools/yaml-format.js"
     ],
     ".roomodes": [
       "node tools/yaml-format.js"
+    ],
+    "bmad-core/**/*.yml": [
+      "node tools/yaml-format.js"
+    ],
+    ".github/**/*.yml": [
+      "node tools/yaml-format.js"
     ]
   }
 }

package/tools/builders/web-builder.js

@@ -1,5 +1,5 @@
-const fs = require('fs').promises;
-const path = require('path');
+const fs = require('node:fs').promises;
+const path = require('node:path');
 const DependencyResolver = require('../lib/dependency-resolver');
 
 class WebBuilder {
@@ -7,10 +7,10 @@ class WebBuilder {
     this.rootDir = options.rootDir || process.cwd();
     this.outputDirs = options.outputDirs || [
       path.join(this.rootDir, 'dist'),
-      path.join(this.rootDir, '.bmad-core', 'web-bundles')
+      path.join(this.rootDir, 'bmad-core', 'web-bundles')
     ];
     this.resolver = new DependencyResolver(this.rootDir);
-    this.templatePath = path.join(this.rootDir, '.bmad-core', 'templates', 'web-agent-startup-instructions-template.md');
+    this.templatePath = path.join(this.rootDir, 'bmad-core', 'templates', 'web-agent-startup-instructions-template.md');
   }
 
   async cleanOutputDirs() {
@@ -19,6 +19,7 @@ class WebBuilder {
         await fs.rm(dir, { recursive: true, force: true });
         console.log(`Cleaned: ${path.relative(this.rootDir, dir)}`);
       } catch (error) {
+        console.debug(`Failed to clean directory ${dir}:`, error.message);
         // Directory might not exist, that's fine
       }
     }
@@ -26,11 +27,11 @@ class WebBuilder {
 
   async buildAgents() {
     const agents = await this.resolver.listAgents();
-    
+
     for (const agentId of agents) {
       console.log(`  Building agent: ${agentId}`);
       const bundle = await this.buildAgentBundle(agentId);
-      
+
       // Write to all output directories
       for (const outputDir of this.outputDirs) {
         const outputPath = path.join(outputDir, 'agents');
@@ -45,11 +46,11 @@ class WebBuilder {
 
   async buildTeams() {
     const teams = await this.resolver.listTeams();
-    
+
     for (const teamId of teams) {
       console.log(`  Building team: ${teamId}`);
       const bundle = await this.buildTeamBundle(teamId);
-      
+
       // Write to all output directories
       for (const outputDir of this.outputDirs) {
         const outputPath = path.join(outputDir, 'teams');
@@ -65,39 +66,39 @@ class WebBuilder {
   async buildAgentBundle(agentId) {
     const dependencies = await this.resolver.resolveAgentDependencies(agentId);
     const template = await fs.readFile(this.templatePath, 'utf8');
-    
+
     const sections = [template];
-    
+
     // Add agent configuration
     sections.push(this.formatSection(dependencies.agent.path, dependencies.agent.content));
-    
+
     // Add all dependencies
     for (const resource of dependencies.resources) {
       sections.push(this.formatSection(resource.path, resource.content));
     }
-    
+
     return sections.join('\n');
   }
 
   async buildTeamBundle(teamId) {
     const dependencies = await this.resolver.resolveTeamDependencies(teamId);
     const template = await fs.readFile(this.templatePath, 'utf8');
-    
+
     const sections = [template];
-    
+
     // Add team configuration
     sections.push(this.formatSection(dependencies.team.path, dependencies.team.content));
-    
+
     // Add all agents
     for (const agent of dependencies.agents) {
       sections.push(this.formatSection(agent.path, agent.content));
     }
-    
+
     // Add all deduplicated resources
     for (const resource of dependencies.resources) {
       sections.push(this.formatSection(resource.path, resource.content));
     }
-    
+
     return sections.join('\n');
   }
 
@@ -137,6 +138,195 @@ class WebBuilder {
     }
   }
 
+  async buildAllExpansionPacks(options = {}) {
+    const expansionPacks = await this.listExpansionPacks();
+
+    for (const packName of expansionPacks) {
+      console.log(`  Building expansion pack: ${packName}`);
+      await this.buildExpansionPack(packName, options);
+    }
+
+    console.log(`Built ${expansionPacks.length} expansion pack bundles`);
+  }
+
+  async buildExpansionPack(packName, options = {}) {
+    const packDir = path.join(this.rootDir, 'expansion-packs', packName);
+    const outputDirs = [
+      path.join(packDir, 'web-bundles'),
+      path.join(this.rootDir, 'dist', 'expansion-packs', packName)
+    ];
+
+    // Clean output directories if requested
+    if (options.clean !== false) {
+      for (const outputDir of outputDirs) {
+        try {
+          await fs.rm(outputDir, { recursive: true, force: true });
+        } catch (error) {
+          // Directory might not exist, that's fine
+        }
+      }
+    }
+
+    // Build individual agents first
+    const agentsDir = path.join(packDir, 'agents');
+    try {
+      const agentFiles = await fs.readdir(agentsDir);
+      const agentMarkdownFiles = agentFiles.filter(f => f.endsWith('.md'));
+      
+      if (agentMarkdownFiles.length > 0) {
+        console.log(`    Building individual agents for ${packName}:`);
+        
+        for (const agentFile of agentMarkdownFiles) {
+          const agentName = agentFile.replace('.md', '');
+          console.log(`      - ${agentName}`);
+          
+          // Build individual agent bundle
+          const bundle = await this.buildExpansionAgentBundle(packName, packDir, agentName);
+          
+          // Write to all output directories
+          for (const outputDir of outputDirs) {
+            const agentsOutputDir = path.join(outputDir, 'agents');
+            await fs.mkdir(agentsOutputDir, { recursive: true });
+            const outputFile = path.join(agentsOutputDir, `${agentName}.txt`);
+            await fs.writeFile(outputFile, bundle, 'utf8');
+          }
+        }
+      }
+    } catch (error) {
+      console.debug(`    No agents directory found for ${packName}`);
+    }
+
+    // Build team bundle
+    const agentTeamsDir = path.join(packDir, 'agent-teams');
+    try {
+      const teamFiles = await fs.readdir(agentTeamsDir);
+      const teamFile = teamFiles.find(f => f.startsWith('team-') && f.endsWith('.yml'));
+      
+      if (teamFile) {
+        console.log(`    Building team bundle for ${packName}`);
+        const teamConfigPath = path.join(agentTeamsDir, teamFile);
+        
+        // Build expansion pack as a team bundle
+        const bundle = await this.buildExpansionTeamBundle(packName, packDir, teamConfigPath);
+        
+        // Write to all output directories
+        for (const outputDir of outputDirs) {
+          const teamsOutputDir = path.join(outputDir, 'teams');
+          await fs.mkdir(teamsOutputDir, { recursive: true });
+          const outputFile = path.join(teamsOutputDir, teamFile.replace('.yml', '.txt'));
+          await fs.writeFile(outputFile, bundle, 'utf8');
+          console.log(`    ✓ Created bundle: ${path.relative(this.rootDir, outputFile)}`);
+        }
+      } else {
+        console.warn(`    ⚠ No team configuration found in ${packName}/agent-teams/`);
+      }
+    } catch (error) {
+      console.warn(`    ⚠ No agent-teams directory found for ${packName}`);
+    }
+  }
+
+  async buildExpansionAgentBundle(packName, packDir, agentName) {
+    const template = await fs.readFile(this.templatePath, 'utf8');
+    const sections = [template];
+
+    // Add agent configuration
+    const agentPath = path.join(packDir, 'agents', `${agentName}.md`);
+    const agentContent = await fs.readFile(agentPath, 'utf8');
+    sections.push(this.formatSection(`agents#${agentName}`, agentContent));
+
+    // Resolve and add agent dependencies from expansion pack
+    const agentYaml = agentContent.match(/```yaml\n([\s\S]*?)\n```/);
+    if (agentYaml) {
+      try {
+        const yaml = require('js-yaml');
+        const agentConfig = yaml.load(agentYaml[1]);
+        
+        if (agentConfig.dependencies) {
+          // Add resources from expansion pack
+          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
+                }
+              }
+            }
+          }
+        }
+      } catch (error) {
+        console.debug(`Failed to parse agent YAML for ${agentName}:`, error.message);
+      }
+    }
+
+    return sections.join('\n');
+  }
+
+  async buildExpansionTeamBundle(packName, packDir, teamConfigPath) {
+    const template = await fs.readFile(this.templatePath, 'utf8');
+
+    const sections = [template];
+
+    // Add team configuration
+    const teamContent = await fs.readFile(teamConfigPath, 'utf8');
+    const teamFileName = path.basename(teamConfigPath, '.yml');
+    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
+    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));
+      }
+    } catch (error) {
+      console.warn(`    ⚠ No agents directory found in ${packName}`);
+    }
+
+    // Add expansion pack resources (templates, tasks, checklists)
+    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 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));
+        }
+      } catch (error) {
+        // Directory might not exist, that's fine
+      }
+    }
+
+    return sections.join('\n');
+  }
+
+  async listExpansionPacks() {
+    const expansionPacksDir = path.join(this.rootDir, 'expansion-packs');
+    try {
+      const entries = await fs.readdir(expansionPacksDir, { withFileTypes: true });
+      return entries
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name);
+    } catch (error) {
+      console.warn('No expansion-packs directory found');
+      return [];
+    }
+  }
+
   listAgents() {
     return this.resolver.listAgents();
   }

package/tools/cli.js

@@ -18,6 +18,8 @@ program
   .description('Build web bundles for agents and teams')
   .option('-a, --agents-only', 'Build only agent bundles')
   .option('-t, --teams-only', 'Build only team bundles')
+  .option('-e, --expansions-only', 'Build only expansion pack bundles')
+  .option('--no-expansions', 'Skip building expansion packs')
   .option('--no-clean', 'Skip cleaning output directories')
   .action(async (options) => {
     const builder = new WebBuilder({
@@ -30,14 +32,24 @@ program
         await builder.cleanOutputDirs();
       }
 
-      if (!options.teamsOnly) {
-        console.log('Building agent bundles...');
-        await builder.buildAgents();
-      }
+      if (options.expansionsOnly) {
+        console.log('Building expansion pack bundles...');
+        await builder.buildAllExpansionPacks({ clean: false });
+      } else {
+        if (!options.teamsOnly) {
+          console.log('Building agent bundles...');
+          await builder.buildAgents();
+        }
+
+        if (!options.agentsOnly) {
+          console.log('Building team bundles...');
+          await builder.buildTeams();
+        }
 
-      if (!options.agentsOnly) {
-        console.log('Building team bundles...');
-        await builder.buildTeams();
+        if (!options.noExpansions) {
+          console.log('Building expansion pack bundles...');
+          await builder.buildAllExpansionPacks({ clean: false });
+        }
       }
 
       // Generate IDE configuration folders
@@ -62,6 +74,32 @@ program
     }
   });
 
+program
+  .command('build:expansions')
+  .description('Build web bundles for all expansion packs')
+  .option('--expansion <name>', 'Build specific expansion pack only')
+  .option('--no-clean', 'Skip cleaning output directories')
+  .action(async (options) => {
+    const builder = new WebBuilder({
+      rootDir: process.cwd()
+    });
+
+    try {
+      if (options.expansion) {
+        console.log(`Building expansion pack: ${options.expansion}`);
+        await builder.buildExpansionPack(options.expansion, { clean: options.clean });
+      } else {
+        console.log('Building all expansion packs...');
+        await builder.buildAllExpansionPacks({ clean: options.clean });
+      }
+
+      console.log('Expansion pack build completed successfully!');
+    } catch (error) {
+      console.error('Expansion pack build failed:', error.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('list:agents')
   .description('List all available agents')
@@ -72,6 +110,16 @@ program
     agents.forEach(agent => console.log(`  - ${agent}`));
   });
 
+program
+  .command('list:expansions')
+  .description('List all available expansion packs')
+  .action(async () => {
+    const builder = new WebBuilder({ rootDir: process.cwd() });
+    const expansions = await builder.listExpansionPacks();
+    console.log('Available expansion packs:');
+    expansions.forEach(expansion => console.log(`  - ${expansion}`));
+  });
+
 program
   .command('validate')
   .description('Validate agent and team configurations')

package/tools/installer/README.md

@@ -33,7 +33,7 @@ installer/
 
 ## Usage
 
-```bash
+````bash
 # Interactive installation
 npx bmad-method install
 
@@ -55,4 +55,4 @@ npm test
 
 # Lint code
 npm run lint
-```
+````