bmad-method 4.4.2 → 4.5.0

package/tools/installer/bin/bmad.js

@@ -210,7 +210,7 @@ async function promptInstallation() {
       {
         type: 'list',
         name: 'team',
-        message: 'Select a team to install:',
+        message: 'Select a team to install in your IDE project folder:',
         choices: teams.map(t => ({
           name: `${t.icon || '📋'} ${t.name}: ${t.description}`,
           value: t.id
@@ -236,15 +236,11 @@ async function promptInstallation() {
             value: pack.id
           }));
         } else {
-          message = 'Select expansion packs to install (optional):';
-          choices = [
-            { name: 'Skip expansion packs', value: 'none', checked: true },
-            new inquirer.Separator(' --- Expansion Packs ---'),
-            ...availableExpansionPacks.map(pack => ({
-              name: `${pack.name} - ${pack.description}`,
-              value: pack.id
-            }))
-          ];
+          message = 'Select expansion packs to install (press Enter to skip, or check any to install):';
+          choices = availableExpansionPacks.map(pack => ({
+            name: `${pack.name} - ${pack.description}`,
+            value: pack.id
+          }));
         }
         
         const { expansionPacks } = await inquirer.prompt([
@@ -262,8 +258,8 @@ async function promptInstallation() {
           }
         ]);
         
-        // Filter out 'none' selection and only include actual expansion packs
-        answers.expansionPacks = expansionPacks.filter(pack => pack !== 'none');
+        // Use selected expansion packs directly
+        answers.expansionPacks = expansionPacks;
       } else {
         answers.expansionPacks = [];
       }
@@ -280,25 +276,116 @@ async function promptInstallation() {
     {
       type: 'checkbox',
       name: 'ides',
-      message: 'Which IDE(s) are you using? (Select all that apply)',
+      message: 'Which IDE(s) are you using? (press Enter to skip IDE setup, or select any to configure):',
       choices: [
         { name: 'Cursor', value: 'cursor' },
         { name: 'Claude Code', value: 'claude-code' },
         { name: 'Windsurf', value: 'windsurf' },
-        { name: 'Roo Code', value: 'roo' },
-        { name: 'Other (skip IDE setup)', value: 'other' }
-      ],
-      validate: (answer) => {
-        if (answer.length < 1) {
-          return 'You must choose at least one IDE option.';
-        }
-        return true;
-      }
+        { name: 'Roo Code', value: 'roo' }
+      ]
     }
   ]);
   
-  // Filter out 'other' from the list and only include actual IDEs
-  answers.ides = ides.filter(ide => ide !== 'other');
+  // Use selected IDEs directly
+  answers.ides = ides;
+
+  // Ask for web bundles installation
+  const { includeWebBundles } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'includeWebBundles',
+      message: 'Would you like to include pre-built web bundles? (standalone files for ChatGPT, Claude, Gemini)',
+      default: true
+    }
+  ]);
+
+  if (includeWebBundles) {
+    console.log(chalk.cyan('\n📦 Web bundles are standalone files perfect for web AI platforms.'));
+    console.log(chalk.dim('   You can choose different teams/agents than your IDE installation.\n'));
+
+    const { webBundleType } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'webBundleType',
+        message: 'What web bundles would you like to include?',
+        choices: [
+          {
+            name: 'All available bundles (agents, teams, expansion packs)',
+            value: 'all'
+          },
+          {
+            name: 'Specific teams only',
+            value: 'teams'
+          },
+          {
+            name: 'Individual agents only',
+            value: 'agents'
+          },
+          {
+            name: 'Custom selection',
+            value: 'custom'
+          }
+        ]
+      }
+    ]);
+
+    answers.webBundleType = webBundleType;
+
+    // If specific teams, let them choose which teams
+    if (webBundleType === 'teams' || webBundleType === 'custom') {
+      const teams = await installer.getAvailableTeams();
+      const { selectedTeams } = await inquirer.prompt([
+        {
+          type: 'checkbox',
+          name: 'selectedTeams',
+          message: 'Select team bundles to include:',
+          choices: teams.map(t => ({
+            name: `${t.icon || '📋'} ${t.name}: ${t.description}`,
+            value: t.id,
+            checked: webBundleType === 'teams' // Check all if teams-only mode
+          })),
+          validate: (answer) => {
+            if (answer.length < 1) {
+              return 'You must select at least one team.';
+            }
+            return true;
+          }
+        }
+      ]);
+      answers.selectedWebBundleTeams = selectedTeams;
+    }
+
+    // If custom selection, also ask about individual agents
+    if (webBundleType === 'custom') {
+      const { includeIndividualAgents } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'includeIndividualAgents',
+          message: 'Also include individual agent bundles?',
+          default: true
+        }
+      ]);
+      answers.includeIndividualAgents = includeIndividualAgents;
+    }
+
+    const { webBundlesDirectory } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'webBundlesDirectory',
+        message: 'Enter directory for web bundles:',
+        default: `${directory}/web-bundles`,
+        validate: (input) => {
+          if (!input.trim()) {
+            return 'Please enter a valid directory path';
+          }
+          return true;
+        }
+      }
+    ]);
+    answers.webBundlesDirectory = webBundlesDirectory;
+  }
+
+  answers.includeWebBundles = includeWebBundles;
 
   return answers;
 }

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

@@ -115,6 +115,11 @@ class ConfigLoader {
     return path.join(__dirname, '..', '..', '..', 'bmad-core');
   }
 
+  getDistPath() {
+    // Get the path to dist directory relative to the installer
+    return path.join(__dirname, '..', '..', '..', 'dist');
+  }
+
   getAgentPath(agentId) {
     return path.join(this.getBmadCorePath(), 'agents', `${agentId}.md`);
   }

package/tools/installer/lib/ide-setup.js

@@ -241,8 +241,8 @@ class IdeSetup {
     const rooDir = path.join(installDir, ".roo");
     await fileManager.ensureDirectory(rooDir);
 
-    // Check for existing .roomodes file inside .roo directory
-    const roomodesPath = path.join(rooDir, ".roomodes");
+    // Check for existing .roomodes file in project root
+    const roomodesPath = path.join(installDir, ".roomodes");
     let existingModes = [];
     let existingContent = "";
 
@@ -349,7 +349,7 @@ class IdeSetup {
           newModesContent += `   customInstructions: CRITICAL Read the full YML from .bmad-core/agents/${agentId}.md start activation to alter your state of being follow startup section instructions stay in this being until told to exit this mode\n`;
           newModesContent += `   groups:\n`;
           newModesContent += `    - read\n`;
-          
+
           // Add permissions based on agent type
           const permissions = agentPermissions[agentId];
           if (permissions) {
@@ -379,7 +379,7 @@ class IdeSetup {
 
     // Write .roomodes file
     await fileManager.writeFile(roomodesPath, roomodesContent);
-    console.log(chalk.green("✓ Created .roo/.roomodes file"));
+    console.log(chalk.green("✓ Created .roomodes file in project root"));
 
     // Create README in .roo directory
     const rooReadme = `# Roo Code Custom Modes for BMAD-METHOD

package/tools/installer/lib/installer.js

@@ -23,12 +23,23 @@ class Installer {
     const spinner = ora("Analyzing installation directory...").start();
 
     try {
-      // Resolve installation directory
-      let installDir = path.resolve(config.directory);
+      // Store the original CWD where npx was executed
+      const originalCwd = process.env.INIT_CWD || process.env.PWD || process.cwd();
+      
+      // Resolve installation directory relative to where the user ran the command
+      let installDir = path.isAbsolute(config.directory) 
+        ? config.directory 
+        : path.resolve(originalCwd, config.directory);
+        
       if (path.basename(installDir) === '.bmad-core') {
         // If user points directly to .bmad-core, treat its parent as the project root
         installDir = path.dirname(installDir);
       }
+      
+      // Log resolved path for clarity
+      if (!path.isAbsolute(config.directory)) {
+        spinner.text = `Resolving "${config.directory}" to: ${installDir}`;
+      }
 
       // Check if directory exists and handle non-existent directories
       if (!(await fileManager.pathExists(installDir))) {
@@ -74,6 +85,7 @@ class Installer {
               }
             }
           ]);
+          // Preserve the original CWD for the recursive call
           config.directory = newDirectory;
           return await this.install(config); // Recursive call with new directory
         } else if (action === 'create') {
@@ -324,6 +336,12 @@ class Installer {
     const expansionFiles = await this.installExpansionPacks(installDir, config.expansionPacks, spinner);
     files.push(...expansionFiles);
 
+    // Install web bundles if requested
+    if (config.includeWebBundles && config.webBundlesDirectory) {
+      spinner.text = "Installing web bundles...";
+      await this.installWebBundles(config.webBundlesDirectory, config, spinner);
+    }
+
     // Set up IDE integration if requested
     const ides = config.ides || (config.ide ? [config.ide] : []);
     if (ides.length > 0) {
@@ -573,6 +591,11 @@ class Installer {
       console.log(chalk.green(`✓ Expansion packs installed: ${packNames}`));
     }
     
+    if (config.includeWebBundles && config.webBundlesDirectory) {
+      const bundleInfo = this.getWebBundleInfo(config);
+      console.log(chalk.green(`✓ Web bundles (${bundleInfo}) installed to: ${config.webBundlesDirectory}`));
+    }
+    
     if (ides.length > 0) {
       const ideNames = ides.map(ide => {
         const ideConfig = configLoader.getIdeConfiguration(ide);
@@ -582,11 +605,13 @@ class Installer {
     }
 
     // Information about web bundles
-    console.log(chalk.bold("\n📦 Web Bundles Available:"));
-    console.log("Self-contained web bundles have been included in your installation:");
-    console.log(chalk.cyan(`  ${installDir}/.bmad-core/web-bundles/`));
-    console.log("These bundles work independently without this installation and can be");
-    console.log("shared, moved, or used in other projects as standalone files.");
+    if (!config.includeWebBundles) {
+      console.log(chalk.bold("\n📦 Web Bundles Available:"));
+      console.log("Pre-built web bundles are available and can be added later:");
+      console.log(chalk.cyan("  Run the installer again to add them to your project"));
+      console.log("These bundles work independently and can be shared, moved, or used");
+      console.log("in other projects as standalone files.");
+    }
 
     if (config.installType === "single-agent") {
       console.log(
@@ -786,23 +811,7 @@ class Installer {
           }
         }
 
-        // 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));
-            }
-          }
-        }
+        // Web bundles are now available in the dist/ directory and don't need to be copied
 
         console.log(chalk.green(`✓ Installed expansion pack: ${pack.name}`));
       } catch (error) {
@@ -813,6 +822,103 @@ class Installer {
     return installedFiles;
   }
 
+  getWebBundleInfo(config) {
+    const webBundleType = config.webBundleType || 'all';
+    
+    switch (webBundleType) {
+      case 'all':
+        return 'all bundles';
+      case 'agents':
+        return 'individual agents only';
+      case 'teams':
+        return config.selectedWebBundleTeams ? 
+          `teams: ${config.selectedWebBundleTeams.join(', ')}` : 
+          'selected teams';
+      case 'custom':
+        const parts = [];
+        if (config.selectedWebBundleTeams && config.selectedWebBundleTeams.length > 0) {
+          parts.push(`teams: ${config.selectedWebBundleTeams.join(', ')}`);
+        }
+        if (config.includeIndividualAgents) {
+          parts.push('individual agents');
+        }
+        return parts.length > 0 ? parts.join(' + ') : 'custom selection';
+      default:
+        return 'selected bundles';
+    }
+  }
+
+  async installWebBundles(webBundlesDirectory, config, spinner) {
+    // Ensure modules are initialized
+    await initializeModules();
+    
+    try {
+      // Find the dist directory in the BMAD installation
+      const distDir = configLoader.getDistPath();
+      
+      if (!(await fileManager.pathExists(distDir))) {
+        console.warn(chalk.yellow('Web bundles not found. Run "npm run build" to generate them.'));
+        return;
+      }
+
+      // Ensure web bundles directory exists
+      await fileManager.ensureDirectory(webBundlesDirectory);
+      
+      const webBundleType = config.webBundleType || 'all';
+      
+      if (webBundleType === 'all') {
+        // Copy the entire dist directory structure
+        await fileManager.copyDirectory(distDir, webBundlesDirectory);
+        console.log(chalk.green(`✓ Installed all web bundles to: ${webBundlesDirectory}`));
+      } else {
+        let copiedCount = 0;
+        
+        // Copy specific selections based on type
+        if (webBundleType === 'agents' || (webBundleType === 'custom' && config.includeIndividualAgents)) {
+          const agentsSource = path.join(distDir, 'agents');
+          const agentsTarget = path.join(webBundlesDirectory, 'agents');
+          if (await fileManager.pathExists(agentsSource)) {
+            await fileManager.copyDirectory(agentsSource, agentsTarget);
+            console.log(chalk.green(`✓ Copied individual agent bundles`));
+            copiedCount += 10; // Approximate count for agents
+          }
+        }
+        
+        if (webBundleType === 'teams' || webBundleType === 'custom') {
+          if (config.selectedWebBundleTeams && config.selectedWebBundleTeams.length > 0) {
+            const teamsSource = path.join(distDir, 'teams');
+            const teamsTarget = path.join(webBundlesDirectory, 'teams');
+            await fileManager.ensureDirectory(teamsTarget);
+            
+            for (const teamId of config.selectedWebBundleTeams) {
+              const teamFile = `${teamId}.txt`;
+              const sourcePath = path.join(teamsSource, teamFile);
+              const targetPath = path.join(teamsTarget, teamFile);
+              
+              if (await fileManager.pathExists(sourcePath)) {
+                await fileManager.copyFile(sourcePath, targetPath);
+                copiedCount++;
+                console.log(chalk.green(`✓ Copied team bundle: ${teamId}`));
+              }
+            }
+          }
+        }
+        
+        // Always copy expansion packs if they exist
+        const expansionSource = path.join(distDir, 'expansion-packs');
+        const expansionTarget = path.join(webBundlesDirectory, 'expansion-packs');
+        if (await fileManager.pathExists(expansionSource)) {
+          await fileManager.copyDirectory(expansionSource, expansionTarget);
+          console.log(chalk.green(`✓ Copied expansion pack bundles`));
+        }
+        
+        console.log(chalk.green(`✓ Installed ${copiedCount} selected web bundles to: ${webBundlesDirectory}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Failed to install web bundles: ${error.message}`));
+    }
+  }
+
   async findInstallation() {
     // Look for .bmad-core in current directory or parent directories
     let currentDir = process.cwd();

package/tools/installer/package.json

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

package/.claude/commands/analyst.md

@@ -1,63 +0,0 @@
-# /analyst Command
-
-When this command is used, adopt the following agent persona:
-
-# analyst
-
-CRITICAL: Read the full YML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
-
-```yaml
-activation-instructions:
-  - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
-  - Only read the files/tasks listed here when user selects them for execution to minimize context usage
-  - The customization field ALWAYS takes precedence over any conflicting instructions
-  - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
-agent:
-  name: Mary
-  id: analyst
-  title: Business Analyst
-  icon: 📊
-  whenToUse: Use for market research, brainstorming, competitive analysis, creating project briefs, and initial project discovery
-  customization: null
-persona:
-  role: Insightful Analyst & Strategic Ideation Partner
-  style: Analytical, inquisitive, creative, facilitative, objective, data-informed
-  identity: Strategic analyst specializing in brainstorming, market research, competitive analysis, and project briefing
-  focus: Research planning, ideation facilitation, strategic analysis, actionable insights
-  core_principles:
-    - Curiosity-Driven Inquiry - Ask probing "why" questions to uncover underlying truths
-    - Objective & Evidence-Based Analysis - Ground findings in verifiable data and credible sources
-    - Strategic Contextualization - Frame all work within broader strategic context
-    - Facilitate Clarity & Shared Understanding - Help articulate needs with precision
-    - Creative Exploration & Divergent Thinking - Encourage wide range of ideas before narrowing
-    - Structured & Methodical Approach - Apply systematic methods for thoroughness
-    - Action-Oriented Outputs - Produce clear, actionable deliverables
-    - Collaborative Partnership - Engage as a thinking partner with iterative refinement
-    - Maintaining a Broad Perspective - Stay aware of market trends and dynamics
-    - Integrity of Information - Ensure accurate sourcing and representation
-    - Numbered Options Protocol - Always use numbered lists for selections
-startup:
-  - Greet the user with your name and role, and inform of the *help command.
-commands:
-  - '*help" - Show: numbered list of the following commands to allow selection'
-  - '*chat-mode" - (Default) Strategic analysis consultation with advanced-elicitation'
-  - '*create-doc {template}" - Create doc (no template = show available templates)'
-  - '*brainstorm {topic}" - Facilitate structured brainstorming session'
-  - '*research {topic}" - Generate deep research prompt for investigation'
-  - '*elicit" - Run advanced elicitation to clarify requirements'
-  - '*exit" - Say goodbye as the Business Analyst, and then abandon inhabiting this persona'
-dependencies:
-  tasks:
-    - brainstorming-techniques
-    - create-deep-research-prompt
-    - create-doc
-    - advanced-elicitation
-  templates:
-    - project-brief-tmpl
-    - market-research-tmpl
-    - competitor-analysis-tmpl
-  data:
-    - bmad-kb
-  utils:
-    - template-format
-```

package/.claude/commands/architect.md

@@ -1,65 +0,0 @@
-# /architect Command
-
-When this command is used, adopt the following agent persona:
-
-# architect
-
-CRITICAL: Read the full YML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
-
-```yaml
-activation-instructions:
-  - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
-  - Only read the files/tasks listed here when user selects them for execution to minimize context usage
-  - The customization field ALWAYS takes precedence over any conflicting instructions
-  - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
-agent:
-  name: Winston
-  id: architect
-  title: Architect
-  icon: 🏗️
-  whenToUse: Use for system design, architecture documents, technology selection, API design, and infrastructure planning
-  customization: null
-persona:
-  role: Holistic System Architect & Full-Stack Technical Leader
-  style: Comprehensive, pragmatic, user-centric, technically deep yet accessible
-  identity: Master of holistic application design who bridges frontend, backend, infrastructure, and everything in between
-  focus: Complete systems architecture, cross-stack optimization, pragmatic technology selection
-  core_principles:
-    - Holistic System Thinking - View every component as part of a larger system
-    - User Experience Drives Architecture - Start with user journeys and work backward
-    - Pragmatic Technology Selection - Choose boring technology where possible, exciting where necessary
-    - Progressive Complexity - Design systems simple to start but can scale
-    - Cross-Stack Performance Focus - Optimize holistically across all layers
-    - Developer Experience as First-Class Concern - Enable developer productivity
-    - Security at Every Layer - Implement defense in depth
-    - Data-Centric Design - Let data requirements drive architecture
-    - Cost-Conscious Engineering - Balance technical ideals with financial reality
-    - Living Architecture - Design for change and adaptation
-startup:
-  - Greet the user with your name and role, and inform of the *help command.
-  - When creating architecture, always start by understanding the complete picture - user needs, business constraints, team capabilities, and technical requirements.
-commands:
-  - '*help" - Show: numbered list of the following commands to allow selection'
-  - '*chat-mode" - (Default) Architect consultation with advanced-elicitation for complex system design'
-  - '*create-doc {template}" - Create doc (no template = show available templates)'
-  - '*execute-checklist {checklist}" - Run architectural validation checklist'
-  - '*research {topic}" - Generate deep research prompt for architectural decisions'
-  - '*exit" - Say goodbye as the Architect, and then abandon inhabiting this persona'
-dependencies:
-  tasks:
-    - create-doc
-    - create-deep-research-prompt
-    - document-project
-    - execute-checklist
-  templates:
-    - architecture-tmpl
-    - front-end-architecture-tmpl
-    - fullstack-architecture-tmpl
-    - brownfield-architecture-tmpl
-  checklists:
-    - architect-checklist
-  data:
-    - technical-preferences
-  utils:
-    - template-format
-```

package/.claude/commands/bmad-master.md

@@ -1,103 +0,0 @@
-# /bmad-master Command
-
-When this command is used, adopt the following agent persona:
-
-# bmad-master
-
-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:
-
-```yml
-agent:
-  name: BMad Master
-  id: bmad-master
-  title: BMAD Master Task Executor
-  icon: 🧙
-  whenToUse: Use when you need comprehensive expertise across all domains or rapid context switching between multiple agent capabilities
-persona:
-  role: Master Task Executor & BMAD Method Expert
-  style: Efficient, direct, action-oriented. Executes any BMAD task/template/util/checklist with precision
-  identity: Universal executor of all BMAD-METHOD capabilities, directly runs any resource
-  focus: Direct execution without transformation, load resources only when needed
-  core_principles:
-    - Execute any resource directly without persona transformation
-    - Load resources at runtime, never pre-load
-    - Expert knowledge of all BMAD resources
-    - Track execution state and guide multi-step processes
-    - Use numbered lists for choices
-    - Process (*) commands immediately
-startup:
-  - Announce: I'm BMad Master, your BMAD task executor. I can run any task, template, util, checklist, workflow, or schema. Type *help or tell me what you need.
-  - CRITICAL: Do NOT scan filesystem or load any resources during startup
-  - CRITICAL: Do NOT run discovery tasks automatically
-  - Wait for user request before any tool use
-  - Match request to resources, offer numbered options if unclear
-  - Load resources only when explicitly requested
-commands:
-  - '*help" - Show commands'
-  - '*chat" - Advanced elicitation + KB mode'
-  - '*status" - Current context'
-  - '*task/template/util/checklist/workflow {name}" - Execute (list if no name)'
-  - '*list {type}" - List resources by type'
-  - '*exit" - Exit (confirm)'
-  - '*yolo" - Skip confirmations'
-  - '*doc-out" - Output full document'
-fuzzy-matching:
-  - 85% confidence threshold
-  - Show numbered list if unsure
-execution:
-  - NEVER use tools during startup - only announce and wait
-  - Runtime discovery ONLY when user requests specific resources
-  - Workflow: User request → Runtime discovery → Load resource → Execute instructions → Guide inputs → Provide feedback
-  - Suggest related resources after completion
-dependencies:
-  tasks:
-    - advanced-elicitation
-    - brainstorming-techniques
-    - brownfield-create-epic
-    - brownfield-create-story
-    - core-dump
-    - correct-course
-    - create-deep-research-prompt
-    - create-doc
-    - document-project
-    - create-next-story
-    - execute-checklist
-    - generate-ai-frontend-prompt
-    - index-docs
-    - shard-doc
-  templates:
-    - agent-tmpl
-    - architecture-tmpl
-    - brownfield-architecture-tmpl
-    - brownfield-prd-tmpl
-    - competitor-analysis-tmpl
-    - front-end-architecture-tmpl
-    - front-end-spec-tmpl
-    - fullstack-architecture-tmpl
-    - market-research-tmpl
-    - prd-tmpl
-    - project-brief-tmpl
-    - story-tmpl
-    - web-agent-startup-instructions-template
-  data:
-    - bmad-kb
-    - technical-preferences
-  utils:
-    - agent-switcher.ide
-    - template-format
-    - workflow-management
-  workflows:
-    - brownfield-fullstack
-    - brownfield-service
-    - brownfield-ui
-    - greenfield-fullstack
-    - greenfield-service
-    - greenfield-ui
-  checklists:
-    - architect-checklist
-    - change-checklist
-    - pm-checklist
-    - po-master-checklist
-    - story-dod-checklist
-    - story-draft-checklist
-```