bmad-method 4.4.0 → 4.4.2

package/tools/installer/lib/config-loader.js

@@ -30,6 +30,43 @@ class ConfigLoader {
     return config['available-agents'] || [];
   }
 
+  async getAvailableExpansionPacks() {
+    const expansionPacksDir = path.join(this.getBmadCorePath(), '..', 'expansion-packs');
+    
+    try {
+      const entries = await fs.readdir(expansionPacksDir, { withFileTypes: true });
+      const expansionPacks = [];
+      
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const manifestPath = path.join(expansionPacksDir, entry.name, 'manifest.yml');
+          
+          try {
+            const manifestContent = await fs.readFile(manifestPath, 'utf8');
+            const manifest = yaml.load(manifestContent);
+            
+            expansionPacks.push({
+              id: entry.name,
+              name: manifest.name || entry.name,
+              description: manifest.description || 'No description available',
+              version: manifest.version || '1.0.0',
+              author: manifest.author || 'Unknown',
+              manifestPath: manifestPath,
+              dependencies: manifest.dependencies || []
+            });
+          } catch (error) {
+            console.warn(`Failed to read manifest for expansion pack ${entry.name}: ${error.message}`);
+          }
+        }
+      }
+      
+      return expansionPacks;
+    } catch (error) {
+      console.warn(`Failed to read expansion packs directory: ${error.message}`);
+      return [];
+    }
+  }
+
   async getAgentDependencies(agentId) {
     // Use DependencyResolver to dynamically parse agent dependencies
     const DependencyResolver = require('../../lib/dependency-resolver');
@@ -41,10 +78,7 @@ class ConfigLoader {
       // Convert to flat list of file paths
       const depPaths = [];
       
-      // Add core files
-      const config = await this.load();
-      const coreFiles = config['agent-dependencies']?.['core-files'] || [];
-      depPaths.push(...coreFiles);
+      // Core files and utilities are included automatically by DependencyResolver
       
       // Add agent file itself is already handled by installer
       
@@ -77,13 +111,89 @@ class ConfigLoader {
   }
 
   getBmadCorePath() {
-    // Get the path to .bmad-core relative to the installer (now under tools)
-    return path.join(__dirname, '..', '..', '..', '.bmad-core');
+    // Get the path to bmad-core relative to the installer (now under tools)
+    return path.join(__dirname, '..', '..', '..', 'bmad-core');
   }
 
   getAgentPath(agentId) {
     return path.join(this.getBmadCorePath(), 'agents', `${agentId}.md`);
   }
+
+  async getAvailableTeams() {
+    const teamsDir = path.join(this.getBmadCorePath(), 'agent-teams');
+    
+    try {
+      const entries = await fs.readdir(teamsDir, { withFileTypes: true });
+      const teams = [];
+      
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.yml')) {
+          const teamPath = path.join(teamsDir, entry.name);
+          
+          try {
+            const teamContent = await fs.readFile(teamPath, 'utf8');
+            const teamConfig = yaml.load(teamContent);
+            
+            if (teamConfig.bundle) {
+              teams.push({
+                id: path.basename(entry.name, '.yml'),
+                name: teamConfig.bundle.name || entry.name,
+                description: teamConfig.bundle.description || 'Team configuration',
+                icon: teamConfig.bundle.icon || '📋'
+              });
+            }
+          } catch (error) {
+            console.warn(`Warning: Could not load team config ${entry.name}: ${error.message}`);
+          }
+        }
+      }
+      
+      return teams;
+    } catch (error) {
+      console.warn(`Warning: Could not scan teams directory: ${error.message}`);
+      return [];
+    }
+  }
+
+  getTeamPath(teamId) {
+    return path.join(this.getBmadCorePath(), 'agent-teams', `${teamId}.yml`);
+  }
+
+  async getTeamDependencies(teamId) {
+    // Use DependencyResolver to dynamically parse team dependencies
+    const DependencyResolver = require('../../lib/dependency-resolver');
+    const resolver = new DependencyResolver(path.join(__dirname, '..', '..', '..'));
+    
+    try {
+      const teamDeps = await resolver.resolveTeamDependencies(teamId);
+      
+      // Convert to flat list of file paths
+      const depPaths = [];
+      
+      // Add team config file
+      depPaths.push(`.bmad-core/agent-teams/${teamId}.yml`);
+      
+      // Add all agents
+      for (const agent of teamDeps.agents) {
+        const filePath = `.bmad-core/agents/${agent.id}.md`;
+        if (!depPaths.includes(filePath)) {
+          depPaths.push(filePath);
+        }
+      }
+      
+      // Add all resolved resources
+      for (const resource of teamDeps.resources) {
+        const filePath = `.bmad-core/${resource.type}/${resource.id}.${resource.type === 'workflows' ? 'yml' : 'md'}`;
+        if (!depPaths.includes(filePath)) {
+          depPaths.push(filePath);
+        }
+      }
+      
+      return depPaths;
+    } catch (error) {
+      throw new Error(`Failed to resolve team dependencies for ${teamId}: ${error.message}`);
+    }
+  }
 }
 
 module.exports = new ConfigLoader();

package/tools/installer/lib/installer.js

@@ -220,11 +220,12 @@ class Installer {
       const agentPath = configLoader.getAgentPath(config.agent);
       const destAgentPath = path.join(
         installDir,
+        ".bmad-core",
         "agents",
         `${config.agent}.md`
       );
       await fileManager.copyFile(agentPath, destAgentPath);
-      files.push(`agents/${config.agent}.md`);
+      files.push(`.bmad-core/agents/${config.agent}.md`);
 
       // Copy dependencies
       const dependencies = await configLoader.getAgentDependencies(
@@ -240,9 +241,9 @@ class Installer {
           const copiedFiles = await fileManager.copyGlobPattern(
             dep.replace(".bmad-core/", ""),
             sourceBase,
-            installDir
+            path.join(installDir, ".bmad-core")
           );
-          files.push(...copiedFiles);
+          files.push(...copiedFiles.map(f => `.bmad-core/${f}`));
         } else {
           // Handle single files
           const sourcePath = path.join(
@@ -251,16 +252,78 @@ class Installer {
           );
           const destPath = path.join(
             installDir,
-            dep.replace(".bmad-core/", "")
+            dep
           );
 
           if (await fileManager.copyFile(sourcePath, destPath)) {
-            files.push(dep.replace(".bmad-core/", ""));
+            files.push(dep);
+          }
+        }
+      }
+    } else if (config.installType === "team") {
+      // Team installation
+      spinner.text = `Installing ${config.team} team...`;
+      
+      // Get team dependencies
+      const teamDependencies = await configLoader.getTeamDependencies(config.team);
+      const sourceBase = configLoader.getBmadCorePath();
+      
+      // Install all team dependencies
+      for (const dep of teamDependencies) {
+        spinner.text = `Copying team dependency: ${dep}`;
+        
+        if (dep.includes("*")) {
+          // Handle glob patterns
+          const copiedFiles = await fileManager.copyGlobPattern(
+            dep.replace(".bmad-core/", ""),
+            sourceBase,
+            path.join(installDir, ".bmad-core")
+          );
+          files.push(...copiedFiles.map(f => `.bmad-core/${f}`));
+        } else {
+          // Handle single files
+          const sourcePath = path.join(sourceBase, dep.replace(".bmad-core/", ""));
+          const destPath = path.join(installDir, dep);
+          
+          if (await fileManager.copyFile(sourcePath, destPath)) {
+            files.push(dep);
           }
         }
       }
+    } else if (config.installType === "expansion-only") {
+      // Expansion-only installation - create minimal .bmad-core structure
+      spinner.text = "Creating minimal .bmad-core structure for expansion packs...";
+      
+      const bmadCoreDestDir = path.join(installDir, ".bmad-core");
+      await fileManager.ensureDirectory(bmadCoreDestDir);
+      
+      // Create basic directory structure
+      const dirs = ['agents', 'agent-teams', 'templates', 'tasks', 'checklists', 'workflows', 'data', 'utils', 'schemas'];
+      for (const dir of dirs) {
+        await fileManager.ensureDirectory(path.join(bmadCoreDestDir, dir));
+      }
+      
+      // Copy minimal required files (schemas, utils, etc.)
+      const sourceBase = configLoader.getBmadCorePath();
+      const essentialFiles = [
+        'schemas/**/*',
+        'utils/**/*'
+      ];
+      
+      for (const pattern of essentialFiles) {
+        const copiedFiles = await fileManager.copyGlobPattern(
+          pattern,
+          sourceBase,
+          bmadCoreDestDir
+        );
+        files.push(...copiedFiles.map(f => `.bmad-core/${f}`));
+      }
     }
 
+    // Install expansion packs if requested
+    const expansionFiles = await this.installExpansionPacks(installDir, config.expansionPacks, spinner);
+    files.push(...expansionFiles);
+
     // Set up IDE integration if requested
     const ides = config.ides || (config.ide ? [config.ide] : []);
     if (ides.length > 0) {
@@ -505,6 +568,11 @@ class Installer {
     console.log(chalk.bold("\n🎯 Installation Summary:"));
     console.log(chalk.green("✓ .bmad-core framework installed with all agents and workflows"));
     
+    if (config.expansionPacks && config.expansionPacks.length > 0) {
+      const packNames = config.expansionPacks.join(", ");
+      console.log(chalk.green(`✓ Expansion packs installed: ${packNames}`));
+    }
+    
     if (ides.length > 0) {
       const ideNames = ides.map(ide => {
         const ideConfig = configLoader.getIdeConfiguration(ide);
@@ -569,6 +637,33 @@ class Installer {
     );
   }
 
+  async listExpansionPacks() {
+    // Initialize ES modules
+    await initializeModules();
+    const expansionPacks = await this.getAvailableExpansionPacks();
+
+    console.log(chalk.bold("\nAvailable BMAD Expansion Packs:\n"));
+
+    if (expansionPacks.length === 0) {
+      console.log(chalk.yellow("No expansion packs found."));
+      return;
+    }
+
+    for (const pack of expansionPacks) {
+      console.log(chalk.cyan(`  ${pack.id.padEnd(20)}`), 
+                  `${pack.name} v${pack.version}`);
+      console.log(chalk.dim(`  ${' '.repeat(22)}${pack.description}`));
+      if (pack.author && pack.author !== 'Unknown') {
+        console.log(chalk.dim(`  ${' '.repeat(22)}by ${pack.author}`));
+      }
+      console.log();
+    }
+
+    console.log(
+      chalk.dim("Install with: npx bmad-method install --full --expansion-packs <id>\n")
+    );
+  }
+
   async showStatus() {
     // Initialize ES modules
     await initializeModules();
@@ -624,6 +719,100 @@ class Installer {
     return configLoader.getAvailableAgents();
   }
 
+  async getAvailableExpansionPacks() {
+    return configLoader.getAvailableExpansionPacks();
+  }
+
+  async getAvailableTeams() {
+    return configLoader.getAvailableTeams();
+  }
+
+  async installExpansionPacks(installDir, selectedPacks, spinner) {
+    if (!selectedPacks || selectedPacks.length === 0) {
+      return [];
+    }
+
+    const installedFiles = [];
+    const glob = require('glob');
+
+    for (const packId of selectedPacks) {
+      spinner.text = `Installing expansion pack: ${packId}...`;
+      
+      try {
+        const expansionPacks = await this.getAvailableExpansionPacks();
+        const pack = expansionPacks.find(p => p.id === packId);
+        
+        if (!pack) {
+          console.warn(`Expansion pack ${packId} not found, skipping...`);
+          continue;
+        }
+
+        const expansionPackDir = path.dirname(pack.manifestPath);
+        
+        // Define the folders to copy from expansion packs to .bmad-core
+        const foldersToSync = [
+          'agents',
+          'agent-teams',
+          'templates',
+          'tasks',
+          'checklists',
+          'workflows',
+          'data',
+          'utils',
+          'schemas'
+        ];
+
+        // Copy each folder if it exists
+        for (const folder of foldersToSync) {
+          const sourceFolder = path.join(expansionPackDir, folder);
+          
+          // Check if folder exists in expansion pack
+          if (await fileManager.pathExists(sourceFolder)) {
+            // Get all files in this folder
+            const files = glob.sync('**/*', {
+              cwd: sourceFolder,
+              nodir: true
+            });
+
+            // Copy each file to the destination
+            for (const file of files) {
+              const sourcePath = path.join(sourceFolder, file);
+              const destPath = path.join(installDir, '.bmad-core', folder, file);
+              
+              if (await fileManager.copyFile(sourcePath, destPath)) {
+                installedFiles.push(path.join('.bmad-core', folder, file));
+              }
+            }
+          }
+        }
+
+        // Also copy web-bundles if they exist (to a different location)
+        const webBundlesSource = path.join(expansionPackDir, 'web-bundles');
+        if (await fileManager.pathExists(webBundlesSource)) {
+          const files = glob.sync('**/*', {
+            cwd: webBundlesSource,
+            nodir: true
+          });
+
+          for (const file of files) {
+            const sourcePath = path.join(webBundlesSource, file);
+            const destPath = path.join(installDir, '.bmad-core', 'web-bundles', 'expansion-packs', packId, file);
+            
+            if (await fileManager.copyFile(sourcePath, destPath)) {
+              installedFiles.push(path.join('.bmad-core', 'web-bundles', 'expansion-packs', packId, file));
+            }
+          }
+        }
+
+        console.log(chalk.green(`✓ Installed expansion pack: ${pack.name}`));
+      } catch (error) {
+        console.error(chalk.red(`Failed to install expansion pack ${packId}: ${error.message}`));
+      }
+    }
+
+    return installedFiles;
+  }
+
   async findInstallation() {
     // Look for .bmad-core in current directory or parent directories
     let currentDir = process.cwd();

package/tools/installer/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "bmad-method",
-  "version": "4.0.1",
+  "version": "4.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "bmad-method",
-      "version": "4.0.1",
+      "version": "4.3.0",
       "license": "MIT",
       "dependencies": {
         "chalk": "^5.4.1",
@@ -21,7 +21,7 @@
         "bmad-method": "bin/bmad.js"
       },
       "engines": {
-        "node": ">=14.0.0"
+        "node": ">=20.0.0"
       }
     },
     "node_modules/@inquirer/checkbox": {

package/tools/installer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmad-method",
-  "version": "4.4.0",
+  "version": "4.4.2",
   "description": "BMAD Method installer - AI-powered Agile development framework",
   "main": "lib/installer.js",
   "bin": {
@@ -30,7 +30,7 @@
     "ora": "^8.2.0"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=20.0.0"
   },
   "repository": {
     "type": "git",

package/tools/lib/dependency-resolver.js

@@ -5,7 +5,7 @@ const yaml = require('js-yaml');
 class DependencyResolver {
   constructor(rootDir) {
     this.rootDir = rootDir;
-    this.bmadCore = path.join(rootDir, '.bmad-core');
+    this.bmadCore = path.join(rootDir, 'bmad-core');
     this.cache = new Map();
   }
 

package/.bmad-core/agent-teams/team-fullstack.yml

@@ -1,26 +0,0 @@
-bundle:
-  name: Team Fullstack
-  icon: 🚀
-  description: >-
-    Comprehensive full-stack development team capable of handling both greenfield 
-    application development and brownfield enhancement projects. This team combines 
-    strategic planning, user experience design, and holistic system architecture 
-    to deliver complete solutions from concept to deployment. Specializes in 
-    full-stack applications, SaaS platforms, enterprise apps, feature additions, 
-    refactoring, and system modernization.
-
-agents:
-  - bmad-orchestrator
-  - analyst
-  - pm
-  - ux-expert
-  - architect
-  - po
-
-workflows:
-  - brownfield-fullstack
-  - brownfield-service
-  - brownfield-ui
-  - greenfield-fullstack
-  - greenfield-service
-  - greenfield-ui

package/.bmad-core/agents/bmad-orchestrator.md

@@ -1,69 +0,0 @@
-# bmad
-
-CRITICAL: Read the full YML to understand your operating params, start activation to alter your state of being, follow startup instructions, stay in this being until told to exit this mode:
-
-```yaml
-agent:
-  name: BMad Orchestrator
-  id: bmad-orchestrator
-  title: BMAD Master Orchestrator
-  icon: 🎭
-  whenToUse: Use for workflow coordination, multi-agent tasks, role switching guidance, and when unsure which specialist to consult
-persona:
-  role: Master Orchestrator & BMAD Method Expert
-  style: Knowledgeable, guiding, adaptable, efficient, encouraging, technically brilliant yet approachable. Helps customize and use BMAD Method while orchestrating agents
-  identity: Unified interface to all BMAD-METHOD capabilities, dynamically transforms into any specialized agent
-  focus: Orchestrating the right agent/capability for each need, loading resources only when needed
-  core_principles:
-    - Become any agent on demand, loading files only when needed
-    - Never pre-load resources - discover and load at runtime
-    - Assess needs and recommend best approach/agent/workflow
-    - Track current state and guide to next logical steps
-    - When embodied, specialized persona's principles take precedence
-    - Be explicit about active persona and current task
-    - Always use numbered lists for choices
-    - Process (*) commands immediately
-startup:
-  - Announce: Hey! I'm BMad, your BMAD-METHOD orchestrator. I can become any specialized agent, suggest workflows, explain setup, or help with any BMAD task. Type *help for options.
-  - Assess user goal, suggest agent transformation if match, offer numbered options if generic
-  - Load resources only when needed
-commands:
-  - '*help" - Show commands/workflows/agents'
-  - '*chat-mode" - Conversational mode with advanced-elicitation'
-  - '*kb-mode" - Load knowledge base for full BMAD help'
-  - '*status" - Show current context/agent/progress'
-  - '*agent {name}" - Transform into agent (list if unspecified)'
-  - '*exit" - Return to BMad or exit (confirm if exiting BMad)'
-  - '*task {name}" - Run task (list if unspecified)'
-  - '*workflow {type}" - Start/list workflows'
-  - '*checklist {name}" - Execute checklist (list if unspecified)'
-  - '*yolo" - Toggle skip confirmations'
-  - '*party-mode" - Group chat with all agents'
-  - '*doc-out" - Output full document'
-fuzzy-matching:
-  - 85% confidence threshold
-  - Show numbered list if unsure
-transformation:
-  - Match name/role to agents
-  - Announce transformation
-  - Operate until exit
-loading:
-  - KB: Only for *kb-mode or BMAD questions
-  - Agents: Only when transforming
-  - "Templates/Tasks: Only when executing"
-  - Always indicate loading
-workflow:
-  - Ask project type (greenfield/brownfield)
-  - Ask scope (UI/service/fullstack/other)
-  - Recommend workflow, guide through stages
-  - Explain web context management if needed
-dependencies:
-  tasks:
-    - advanced-elicitation
-    - create-doc
-  data:
-    - bmad-kb
-  utils:
-    - workflow-management
-    - template-format
-```