bmad-method 4.27.6 → 5.0.0

package/tools/installer/config/install.config.yml

@@ -0,0 +1,139 @@
+installation-options:
+  full:
+    name: Complete BMAD Core
+    description: Copy the entire .bmad-core folder with all agents, templates, and tools
+    action: copy-folder
+    source: .bmad-core
+  single-agent:
+    name: Single Agent
+    description: Select and install a single agent with its dependencies
+    action: copy-agent
+agent-dependencies:
+  core-files:
+    - .bmad-core/utils/template-format.md
+  dev:
+    - .bmad-core/templates/story-tmpl.md
+    - .bmad-core/checklists/story-dod-checklist.md
+  pm:
+    - .bmad-core/templates/prd-tmpl.md
+    - .bmad-core/templates/brownfield-prd-tmpl.md
+    - .bmad-core/checklists/pm-checklist.md
+    - .bmad-core/checklists/change-checklist.md
+    - .bmad-core/tasks/advanced-elicitation.md
+    - .bmad-core/tasks/create-doc.md
+    - .bmad-core/tasks/correct-course.md
+    - .bmad-core/tasks/create-deep-research-prompt.md
+    - .bmad-core/tasks/brownfield-create-epic.md
+    - .bmad-core/tasks/brownfield-create-story.md
+    - .bmad-core/tasks/execute-checklist.md
+    - .bmad-core/tasks/shard-doc.md
+  architect:
+    - .bmad-core/templates/architecture-tmpl.md
+    - .bmad-core/checklists/architect-checklist.md
+  sm:
+    - .bmad-core/templates/story-tmpl.md
+    - .bmad-core/checklists/story-draft-checklist.md
+    - .bmad-core/workflows/*.yml
+  po:
+    - .bmad-core/checklists/po-master-checklist.md
+    - .bmad-core/templates/acceptance-criteria-tmpl.md
+  analyst:
+    - .bmad-core/templates/prd-tmpl.md
+    - .bmad-core/tasks/advanced-elicitation.md
+  qa:
+    - .bmad-core/checklists/story-dod-checklist.md
+    - .bmad-core/templates/test-plan-tmpl.md
+  ux-expert:
+    - .bmad-core/templates/ux-tmpl.md
+  bmad-master:
+    - .bmad-core/templates/*.md
+    - .bmad-core/tasks/*.md
+    - .bmad-core/schemas/*.yml
+  bmad-orchestrator:
+    - .bmad-core/agent-teams/*.yml
+    - .bmad-core/workflows/*.yml
+ide-configurations:
+  cursor:
+    name: Cursor
+    rule-dir: .cursor/rules/
+    format: multi-file
+    command-suffix: .mdc
+    instructions: |
+      # To use BMAD agents in Cursor:
+      # 1. Press Ctrl+L (Cmd+L on Mac) to open the chat
+      # 2. Type @agent-name (e.g., "@dev", "@pm", "@architect")
+      # 3. The agent will adopt that persona for the conversation
+  claude-code:
+    name: Claude Code
+    rule-dir: .claude/commands/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMAD agents in Claude Code:
+      # 1. Type /agent-name (e.g., "/dev", "/pm", "/architect")
+      # 2. Claude will switch to that agent's persona
+  windsurf:
+    name: Windsurf
+    rule-dir: .windsurf/rules/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMAD agents in Windsurf:
+      # 1. Type @agent-name (e.g., "@dev", "@pm")
+      # 2. Windsurf will adopt that agent's persona
+  roo:
+    name: Roo Code
+    format: custom-modes
+    file: .roomodes
+    instructions: |
+      # To use BMAD agents in Roo Code:
+      # 1. Open the mode selector (usually in the status bar)
+      # 2. Select any bmad-{agent} mode (e.g., "bmad-dev", "bmad-pm")
+      # 3. The AI will adopt that agent's full personality and capabilities
+  cline:
+    name: Cline
+    format: unknown
+    instructions: |
+      # Cline configuration coming soon
+      # Manual setup: Copy IDE agent files to your Cline configuration
+available-agents:
+  - id: analyst
+    name: Business Analyst
+    file: .bmad-core/agents/analyst.md
+    description: Requirements gathering and analysis
+  - id: pm
+    name: Product Manager
+    file: .bmad-core/agents/pm.md
+    description: Product strategy and roadmap planning
+  - id: architect
+    name: Solution Architect
+    file: .bmad-core/agents/architect.md
+    description: Technical design and architecture
+  - id: po
+    name: Product Owner
+    file: .bmad-core/agents/po.md
+    description: Backlog management and prioritization
+  - id: sm
+    name: Scrum Master
+    file: .bmad-core/agents/sm.md
+    description: Agile process and story creation
+  - id: dev
+    name: Developer
+    file: .bmad-core/agents/dev.md
+    description: Code implementation and testing
+  - id: qa
+    name: QA Engineer
+    file: .bmad-core/agents/qa.md
+    description: Quality assurance and testing
+  - id: ux-expert
+    name: UX Expert
+    file: .bmad-core/agents/ux-expert.md
+    description: User experience design
+  - id: bmad-master
+    name: BMAD Master
+    file: .bmad-core/agents/bmad-master.md
+    description: BMAD framework expert and guide
+  - id: bmad-orchestrator
+    name: BMAD Orchestrator
+    file: .bmad-core/agents/bmad-orchestrator.md
+    description: Multi-agent workflow coordinator

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

@@ -1,11 +1,10 @@
 const fs = require('fs-extra');
 const path = require('path');
 const yaml = require('js-yaml');
-const { extractYamlFromAgent } = require('../../lib/yaml-utils');
 
 class ConfigLoader {
   constructor() {
-    this.configPath = path.join(__dirname, '..', 'config', 'install.config.yaml');
+    this.configPath = path.join(__dirname, '..', 'config', 'install.config.yml');
     this.config = null;
   }
 
@@ -27,130 +26,48 @@ class ConfigLoader {
   }
 
   async getAvailableAgents() {
-    const agentsDir = path.join(this.getBmadCorePath(), 'agents');
+    const config = await this.load();
+    return config['available-agents'] || [];
+  }
+
+  async getAgentDependencies(agentId) {
+    // Use DependencyResolver to dynamically parse agent dependencies
+    const DependencyResolver = require('../../lib/dependency-resolver');
+    const resolver = new DependencyResolver(path.join(__dirname, '..', '..', '..'));
     
     try {
-      const entries = await fs.readdir(agentsDir, { withFileTypes: true });
-      const agents = [];
+      const agentDeps = await resolver.resolveAgentDependencies(agentId);
       
-      for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith('.md')) {
-          const agentPath = path.join(agentsDir, entry.name);
-          const agentId = path.basename(entry.name, '.md');
-          
-          try {
-            const agentContent = await fs.readFile(agentPath, 'utf8');
-            
-            // Extract YAML block from agent file
-            const yamlContentText = extractYamlFromAgent(agentContent);
-            if (yamlContentText) {
-              const yamlContent = yaml.load(yamlContentText);
-              const agentConfig = yamlContent.agent || {};
-              
-              agents.push({
-                id: agentId,
-                name: agentConfig.title || agentConfig.name || agentId,
-                file: `bmad-core/agents/${entry.name}`,
-                description: agentConfig.whenToUse || 'No description available'
-              });
-            }
-          } catch (error) {
-            console.warn(`Failed to read agent ${entry.name}: ${error.message}`);
-          }
-        }
-      }
+      // Convert to flat list of file paths
+      const depPaths = [];
       
-      // Sort agents by name for consistent display
-      agents.sort((a, b) => a.name.localeCompare(b.name));
+      // Add core files
+      const config = await this.load();
+      const coreFiles = config['agent-dependencies']?.['core-files'] || [];
+      depPaths.push(...coreFiles);
       
-      return agents;
-    } catch (error) {
-      console.warn(`Failed to read agents directory: ${error.message}`);
-      return [];
-    }
-  }
-
-  async getAvailableExpansionPacks() {
-    const expansionPacksDir = path.join(this.getBmadCorePath(), '..', 'expansion-packs');
-    
-    try {
-      const entries = await fs.readdir(expansionPacksDir, { withFileTypes: true });
-      const expansionPacks = [];
+      // Add agent file itself is already handled by installer
       
-      for (const entry of entries) {
-        if (entry.isDirectory() && !entry.name.startsWith('.')) {
-          const packPath = path.join(expansionPacksDir, entry.name);
-          const configPath = path.join(packPath, 'config.yaml');
-          
-          try {
-            // Read config.yaml
-            const configContent = await fs.readFile(configPath, 'utf8');
-            const config = yaml.load(configContent);
-            
-            expansionPacks.push({
-              id: entry.name,
-              name: config.name || entry.name,
-              description: config['short-title'] || config.description || 'No description available',
-              fullDescription: config.description || config['short-title'] || 'No description available',
-              version: config.version || '1.0.0',
-              author: config.author || 'BMad Team',
-              packPath: packPath,
-              dependencies: config.dependencies?.agents || []
-            });
-          } catch (error) {
-            // Fallback if config.yaml doesn't exist or can't be read
-            console.warn(`Failed to read config for expansion pack ${entry.name}: ${error.message}`);
-            
-            // Try to derive info from directory name as fallback
-            const name = entry.name
-              .split('-')
-              .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-              .join(' ');
-            
-            expansionPacks.push({
-              id: entry.name,
-              name: name,
-              description: 'No description available',
-              fullDescription: 'No description available',
-              version: '1.0.0',
-              author: 'BMad Team',
-              packPath: packPath,
-              dependencies: []
-            });
-          }
+      // Add all resolved resources
+      for (const resource of agentDeps.resources) {
+        const filePath = `.bmad-core/${resource.type}/${resource.id}.md`;
+        if (!depPaths.includes(filePath)) {
+          depPaths.push(filePath);
         }
       }
       
-      return expansionPacks;
+      return depPaths;
     } 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');
-    const resolver = new DependencyResolver(path.join(__dirname, '..', '..', '..'));
-    
-    const agentDeps = await resolver.resolveAgentDependencies(agentId);
-    
-    // Convert to flat list of file paths
-    const depPaths = [];
-    
-    // Core files and utilities are included automatically by DependencyResolver
-    
-    // Add agent file itself is already handled by installer
-    
-    // Add all resolved resources
-    for (const resource of agentDeps.resources) {
-      const filePath = `.bmad-core/${resource.type}/${resource.id}.md`;
-      if (!depPaths.includes(filePath)) {
-        depPaths.push(filePath);
-      }
+      console.warn(`Failed to dynamically resolve dependencies for ${agentId}: ${error.message}`);
+      
+      // Fall back to static config
+      const config = await this.load();
+      const dependencies = config['agent-dependencies'] || {};
+      const coreFiles = dependencies['core-files'] || [];
+      const agentDeps = dependencies[agentId] || [];
+      
+      return [...coreFiles, ...agentDeps];
     }
-    
-    return depPaths;
   }
 
   async getIdeConfiguration(ide) {
@@ -160,94 +77,13 @@ class ConfigLoader {
   }
 
   getBmadCorePath() {
-    // Get the path to bmad-core relative to the installer (now under tools)
-    return path.join(__dirname, '..', '..', '..', 'bmad-core');
-  }
-
-  getDistPath() {
-    // Get the path to dist directory relative to the installer
-    return path.join(__dirname, '..', '..', '..', 'dist');
+    // 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('.yaml')) {
-          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, '.yaml'),
-                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}.yaml`);
-  }
-
-  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}.yaml`);
-      
-      // 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' ? 'yaml' : '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/file-manager.js

@@ -2,7 +2,6 @@ const fs = require("fs-extra");
 const path = require("path");
 const crypto = require("crypto");
 const glob = require("glob");
-const yaml = require("js-yaml");
 
 // Dynamic import for ES module
 let chalk;
@@ -17,7 +16,7 @@ async function initializeModules() {
 class FileManager {
   constructor() {
     this.manifestDir = ".bmad-core";
-    this.manifestFile = "install-manifest.yaml";
+    this.manifestFile = "install-manifest.yml";
   }
 
   async copyFile(source, destination) {
@@ -47,7 +46,7 @@ class FileManager {
     }
   }
 
-  async copyGlobPattern(pattern, sourceDir, destDir, rootValue = null) {
+  async copyGlobPattern(pattern, sourceDir, destDir) {
     const files = glob.sync(pattern, { cwd: sourceDir });
     const copied = [];
 
@@ -55,17 +54,7 @@ class FileManager {
       const sourcePath = path.join(sourceDir, file);
       const destPath = path.join(destDir, file);
 
-      // Use root replacement if rootValue is provided and file needs it
-      const needsRootReplacement = rootValue && (file.endsWith('.md') || file.endsWith('.yaml') || file.endsWith('.yml'));
-      
-      let success = false;
-      if (needsRootReplacement) {
-        success = await this.copyFileWithRootReplacement(sourcePath, destPath, rootValue);
-      } else {
-        success = await this.copyFile(sourcePath, destPath);
-      }
-
-      if (success) {
+      if (await this.copyFile(sourcePath, destPath)) {
         copied.push(file);
       }
     }
@@ -93,24 +82,13 @@ class FileManager {
       this.manifestFile
     );
 
-    // Read version from core-config.yaml
-    const coreConfigPath = path.join(__dirname, "../../../bmad-core/core-config.yaml");
-    let coreVersion = "unknown";
-    try {
-      const coreConfigContent = await fs.readFile(coreConfigPath, "utf8");
-      const coreConfig = yaml.load(coreConfigContent);
-      coreVersion = coreConfig.version || "unknown";
-    } catch (error) {
-      console.warn("Could not read version from core-config.yaml, using 'unknown'");
-    }
-
     const manifest = {
-      version: coreVersion,
+      version: require("../../../package.json").version,
       installed_at: new Date().toISOString(),
       install_type: config.installType,
       agent: config.agent || null,
+      ide_setup: config.ide || null,
       ides_setup: config.ides || [],
-      expansion_packs: config.expansionPacks || [],
       files: [],
     };
 
@@ -128,7 +106,7 @@ class FileManager {
 
     // Write manifest
     await fs.ensureDir(path.dirname(manifestPath));
-    await fs.writeFile(manifestPath, yaml.dump(manifest, { indent: 2 }));
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 
     return manifest;
   }
@@ -142,22 +120,7 @@ class FileManager {
 
     try {
       const content = await fs.readFile(manifestPath, "utf8");
-      return yaml.load(content);
-    } catch (error) {
-      return null;
-    }
-  }
-
-  async readExpansionPackManifest(installDir, packId) {
-    const manifestPath = path.join(
-      installDir,
-      `.${packId}`,
-      this.manifestFile
-    );
-
-    try {
-      const content = await fs.readFile(manifestPath, "utf8");
-      return yaml.load(content);
+      return JSON.parse(content);
     } catch (error) {
       return null;
     }
@@ -178,33 +141,6 @@ class FileManager {
     return modified;
   }
 
-  async checkFileIntegrity(installDir, manifest) {
-    const result = {
-      missing: [],
-      modified: []
-    };
-
-    for (const file of manifest.files) {
-      const filePath = path.join(installDir, file.path);
-      
-      // Skip checking the manifest file itself - it will always be different due to timestamps
-      if (file.path.endsWith('install-manifest.yaml')) {
-        continue;
-      }
-      
-      if (!(await this.pathExists(filePath))) {
-        result.missing.push(file.path);
-      } else {
-        const currentHash = await this.calculateFileHash(filePath);
-        if (currentHash && currentHash !== file.hash) {
-          result.modified.push(file.path);
-        }
-      }
-    }
-
-    return result;
-  }
-
   async backupFile(filePath) {
     const backupPath = filePath + ".bak";
     let counter = 1;
@@ -245,135 +181,6 @@ class FileManager {
   async removeDirectory(dirPath) {
     await fs.remove(dirPath);
   }
-
-  async createExpansionPackManifest(installDir, packId, config, files) {
-    const manifestPath = path.join(
-      installDir,
-      `.${packId}`,
-      this.manifestFile
-    );
-
-    const manifest = {
-      version: config.expansionPackVersion || require("../../../package.json").version,
-      installed_at: new Date().toISOString(),
-      install_type: config.installType,
-      expansion_pack_id: config.expansionPackId,
-      expansion_pack_name: config.expansionPackName,
-      ides_setup: config.ides || [],
-      files: [],
-    };
-
-    // Add file information
-    for (const file of files) {
-      const filePath = path.join(installDir, file);
-      const hash = await this.calculateFileHash(filePath);
-
-      manifest.files.push({
-        path: file,
-        hash: hash,
-        modified: false,
-      });
-    }
-
-    // Write manifest
-    await fs.ensureDir(path.dirname(manifestPath));
-    await fs.writeFile(manifestPath, yaml.dump(manifest, { indent: 2 }));
-
-    return manifest;
-  }
-
-  async modifyCoreConfig(installDir, config) {
-    const coreConfigPath = path.join(installDir, '.bmad-core', 'core-config.yaml');
-    
-    try {
-      // Read the existing core-config.yaml
-      const coreConfigContent = await fs.readFile(coreConfigPath, 'utf8');
-      const coreConfig = yaml.load(coreConfigContent);
-      
-      // Modify sharding settings if provided
-      if (config.prdSharded !== undefined) {
-        coreConfig.prd.prdSharded = config.prdSharded;
-      }
-      
-      if (config.architectureSharded !== undefined) {
-        coreConfig.architecture.architectureSharded = config.architectureSharded;
-      }
-      
-      // Write back the modified config
-      await fs.writeFile(coreConfigPath, yaml.dump(coreConfig, { indent: 2 }));
-      
-      return true;
-    } catch (error) {
-      await initializeModules();
-      console.error(chalk.red(`Failed to modify core-config.yaml:`), error.message);
-      return false;
-    }
-  }
-
-  async copyFileWithRootReplacement(source, destination, rootValue) {
-    try {
-      // Read the source file content
-      const fs = require('fs').promises;
-      const content = await fs.readFile(source, 'utf8');
-      
-      // Replace {root} with the specified root value
-      const updatedContent = content.replace(/\{root\}/g, rootValue);
-      
-      // Ensure directory exists
-      await this.ensureDirectory(path.dirname(destination));
-      
-      // Write the updated content
-      await fs.writeFile(destination, updatedContent, 'utf8');
-      
-      return true;
-    } catch (error) {
-      await initializeModules();
-      console.error(chalk.red(`Failed to copy ${source} with root replacement:`), error.message);
-      return false;
-    }
-  }
-
-  async copyDirectoryWithRootReplacement(source, destination, rootValue, fileExtensions = ['.md', '.yaml', '.yml']) {
-    try {
-      await initializeModules(); // Ensure chalk is initialized
-      await this.ensureDirectory(destination);
-      
-      // Get all files in source directory
-      const files = glob.sync('**/*', { 
-        cwd: source, 
-        nodir: true 
-      });
-      
-      let replacedCount = 0;
-      
-      for (const file of files) {
-        const sourcePath = path.join(source, file);
-        const destPath = path.join(destination, file);
-        
-        // Check if this file type should have {root} replacement
-        const shouldReplace = fileExtensions.some(ext => file.endsWith(ext));
-        
-        if (shouldReplace) {
-          if (await this.copyFileWithRootReplacement(sourcePath, destPath, rootValue)) {
-            replacedCount++;
-          }
-        } else {
-          // Regular copy for files that don't need replacement
-          await this.copyFile(sourcePath, destPath);
-        }
-      }
-      
-      if (replacedCount > 0) {
-        console.log(chalk.dim(`  Processed ${replacedCount} files with {root} replacement`));
-      }
-      
-      return true;
-    } catch (error) {
-      await initializeModules();
-      console.error(chalk.red(`Failed to copy directory ${source} with root replacement:`), error.message);
-      return false;
-    }
-  }
 }
 
 module.exports = new FileManager();