bmad-method 4.27.4 → 4.27.6

package/expansion-packs/bmad-infrastructure-devops/data/bmad-kb.md

@@ -1,3 +1,308 @@
-# Usage Information
+# BMad Infrastructure DevOps Expansion Pack Knowledge Base
 
-TODO
+## Overview
+
+The BMad Infrastructure DevOps expansion pack extends the BMad Method framework with comprehensive infrastructure and DevOps capabilities. It enables teams to design, implement, validate, and maintain modern cloud-native infrastructure alongside their application development efforts.
+
+**Version**: 1.7.0  
+**BMad Compatibility**: v4+  
+**Author**: Brian (BMad)
+
+## Core Purpose
+
+This expansion pack addresses the critical need for systematic infrastructure planning and implementation in modern software projects. It provides:
+
+- Structured approach to infrastructure architecture design
+- Platform engineering implementation guidance
+- Comprehensive validation and review processes
+- Integration with core BMad development workflows
+- Support for cloud-native and traditional infrastructure patterns
+
+## When to Use This Expansion Pack
+
+Use the BMad Infrastructure DevOps expansion pack when your project involves:
+
+- **Cloud Infrastructure Design**: AWS, Azure, GCP, or multi-cloud architectures
+- **Kubernetes and Container Orchestration**: Container platform design and implementation
+- **Infrastructure as Code**: Terraform, CloudFormation, Pulumi implementations
+- **GitOps Workflows**: ArgoCD, Flux, or similar continuous deployment patterns
+- **Platform Engineering**: Building internal developer platforms and self-service capabilities
+- **Service Mesh Implementation**: Istio, Linkerd, or similar service mesh architectures
+- **DevOps Transformation**: Establishing or improving DevOps practices and culture
+
+## Key Components
+
+### 1. DevOps Agent: Alex
+
+**Role**: DevOps Infrastructure Specialist  
+**Experience**: 15+ years in infrastructure and platform engineering
+
+**Core Principles**:
+
+- Infrastructure as Code (IaC) First
+- Automation and Repeatability
+- Reliability and Scalability
+- Security by Design
+- Cost Optimization
+- Developer Experience Focus
+
+**Commands**:
+
+- `*help` - Display available commands and capabilities
+- `*chat-mode` - Interactive conversation mode for infrastructure discussions
+- `*create-doc` - Generate infrastructure documentation from templates
+- `*review-infrastructure` - Conduct systematic infrastructure review
+- `*validate-infrastructure` - Validate infrastructure against comprehensive checklist
+- `*checklist` - Access the 16-section infrastructure validation checklist
+- `*exit` - Return to normal context
+
+### 2. Infrastructure Templates
+
+#### Infrastructure Architecture Template
+
+**Purpose**: Design comprehensive infrastructure architecture  
+**Key Sections**:
+
+- Infrastructure Overview (providers, regions, environments)
+- Infrastructure as Code approach and tooling
+- Network Architecture with visual diagrams
+- Compute Resources planning
+- Security Architecture design
+- Monitoring and Observability strategy
+- CI/CD Pipeline architecture
+- Disaster Recovery planning
+- BMad Integration points
+
+#### Platform Implementation Template
+
+**Purpose**: Implement platform infrastructure based on approved architecture  
+**Key Sections**:
+
+- Foundation Infrastructure Layer
+- Container Platform (Kubernetes) setup
+- GitOps Workflow implementation
+- Service Mesh configuration
+- Developer Experience Platform
+- Security hardening procedures
+- Platform validation and testing
+
+### 3. Tasks
+
+#### Review Infrastructure Task
+
+**Purpose**: Systematic infrastructure review process  
+**Features**:
+
+- Incremental or rapid assessment modes
+- Architectural escalation for complex issues
+- Advanced elicitation for deep analysis
+- Prioritized findings and recommendations
+- Integration with BMad Architecture phase
+
+#### Validate Infrastructure Task
+
+**Purpose**: Comprehensive infrastructure validation  
+**Features**:
+
+- 16-section validation checklist
+- Architecture Design Review Gate
+- Compliance percentage tracking
+- Remediation planning
+- BMad integration assessment
+
+### 4. Infrastructure Validation Checklist
+
+A comprehensive 16-section checklist covering:
+
+**Foundation Infrastructure (Sections 1-12)**:
+
+1. Security Foundation - IAM, encryption, compliance
+2. Infrastructure as Code - Version control, testing, documentation
+3. Resilience & High Availability - Multi-AZ, failover, SLAs
+4. Backup & Disaster Recovery - Strategies, testing, RTO/RPO
+5. Monitoring & Observability - Metrics, logging, alerting
+6. Performance & Scalability - Auto-scaling, load testing
+7. Infrastructure Operations - Patching, maintenance, runbooks
+8. CI/CD Infrastructure - Pipelines, environments, deployments
+9. Networking & Connectivity - Architecture, security, DNS
+10. Compliance & Governance - Standards, auditing, policies
+11. BMad Integration - Agent support, workflow alignment
+12. Architecture Documentation - Diagrams, decisions, maintenance
+
+**Platform Engineering (Sections 13-16)**: 13. Container Platform - Kubernetes setup, RBAC, networking 14. GitOps Workflows - Repository structure, deployment patterns 15. Service Mesh - Traffic management, security, observability 16. Developer Experience - Self-service, documentation, tooling
+
+## Integration with BMad Flow
+
+### Workflow Integration Points
+
+1. **After Architecture Phase**: Infrastructure design begins after application architecture is defined
+2. **Parallel to Development**: Infrastructure implementation runs alongside application development
+3. **Before Production**: Infrastructure validation gates before production deployment
+4. **Continuous Operation**: Ongoing infrastructure reviews and improvements
+
+### Agent Collaboration
+
+- **With Architect (Sage)**: Joint planning sessions, design reviews, architectural alignment
+- **With Developer (Blake)**: Platform capabilities, development environment setup
+- **With Product Manager (Finley)**: Infrastructure requirements, cost considerations
+- **With Creator Agents**: Infrastructure for creative workflows and asset management
+
+## Best Practices
+
+### Infrastructure Design
+
+1. **Start with Requirements**: Understand application needs before designing infrastructure
+2. **Design for Scale**: Plan for 10x growth from day one
+3. **Security First**: Implement defense in depth at every layer
+4. **Cost Awareness**: Balance performance with budget constraints
+5. **Document Everything**: Maintain comprehensive documentation
+
+### Implementation Approach
+
+1. **Incremental Rollout**: Deploy infrastructure in stages with validation gates
+2. **Automation Focus**: Automate repetitive tasks and deployments
+3. **Testing Strategy**: Include infrastructure testing in CI/CD pipelines
+4. **Monitoring Setup**: Implement observability before production
+5. **Team Training**: Ensure team understanding of infrastructure
+
+### Validation Process
+
+1. **Regular Reviews**: Schedule periodic infrastructure assessments
+2. **Checklist Compliance**: Maintain high compliance with validation checklist
+3. **Performance Baselines**: Establish and monitor performance metrics
+4. **Security Audits**: Regular security assessments and penetration testing
+5. **Cost Optimization**: Monthly cost reviews and optimization
+
+## Common Use Cases
+
+### 1. New Project Infrastructure
+
+**Scenario**: Starting a new cloud-native application  
+**Process**:
+
+1. Use Infrastructure Architecture template for design
+2. Review with Architect agent
+3. Implement using Platform Implementation template
+4. Validate with comprehensive checklist
+5. Deploy incrementally with monitoring
+
+### 2. Infrastructure Modernization
+
+**Scenario**: Migrating legacy infrastructure to cloud  
+**Process**:
+
+1. Review existing infrastructure
+2. Design target architecture
+3. Plan migration phases
+4. Implement with validation gates
+5. Monitor and optimize
+
+### 3. Platform Engineering Initiative
+
+**Scenario**: Building internal developer platform  
+**Process**:
+
+1. Assess developer needs
+2. Design platform architecture
+3. Implement Kubernetes/GitOps foundation
+4. Build self-service capabilities
+5. Enable developer adoption
+
+### 4. Multi-Cloud Strategy
+
+**Scenario**: Implementing multi-cloud architecture  
+**Process**:
+
+1. Define cloud strategy and requirements
+2. Design cloud-agnostic architecture
+3. Implement with IaC abstraction
+4. Validate cross-cloud functionality
+5. Establish unified monitoring
+
+## Advanced Features
+
+### GitOps Workflows
+
+- **Repository Structure**: Organized by environment and application
+- **Deployment Patterns**: Progressive delivery, canary deployments
+- **Secret Management**: External secrets operator integration
+- **Policy Enforcement**: OPA/Gatekeeper for compliance
+
+### Service Mesh Capabilities
+
+- **Traffic Management**: Load balancing, circuit breaking, retries
+- **Security**: mTLS, authorization policies
+- **Observability**: Distributed tracing, service maps
+- **Multi-Cluster**: Cross-cluster communication
+
+### Developer Self-Service
+
+- **Portal Features**: Resource provisioning, environment management
+- **API Gateway**: Centralized API management
+- **Documentation**: Automated API docs, runbooks
+- **Tooling**: CLI tools, IDE integrations
+
+## Troubleshooting Guide
+
+### Common Issues
+
+1. **Infrastructure Drift**
+
+   - Solution: Implement drift detection in IaC pipelines
+   - Prevention: Restrict manual changes, enforce GitOps
+
+2. **Cost Overruns**
+
+   - Solution: Implement cost monitoring and alerts
+   - Prevention: Resource tagging, budget limits
+
+3. **Performance Problems**
+
+   - Solution: Review monitoring data, scale resources
+   - Prevention: Load testing, capacity planning
+
+4. **Security Vulnerabilities**
+   - Solution: Immediate patching, security reviews
+   - Prevention: Automated scanning, compliance checks
+
+## Metrics and KPIs
+
+### Infrastructure Metrics
+
+- **Availability**: Target 99.9%+ uptime
+- **Performance**: Response time < 100ms
+- **Cost Efficiency**: Cost per transaction trending down
+- **Security**: Zero critical vulnerabilities
+- **Automation**: 90%+ automated deployments
+
+### Platform Metrics
+
+- **Developer Satisfaction**: NPS > 50
+- **Self-Service Adoption**: 80%+ platform usage
+- **Deployment Frequency**: Multiple per day
+- **Lead Time**: < 1 hour from commit to production
+- **MTTR**: < 30 minutes for incidents
+
+## Future Enhancements
+
+### Planned Features
+
+1. **AI-Driven Optimization**: Automated infrastructure tuning
+2. **Enhanced Security**: Zero-trust architecture templates
+3. **Edge Computing**: Support for edge infrastructure patterns
+4. **Sustainability**: Carbon footprint optimization
+5. **Advanced Compliance**: Industry-specific compliance templates
+
+### Integration Roadmap
+
+1. **Cloud Provider APIs**: Direct integration with AWS, Azure, GCP
+2. **IaC Tools**: Native support for Terraform, Pulumi
+3. **Monitoring Platforms**: Integration with Datadog, New Relic
+4. **Security Tools**: SIEM and vulnerability scanner integration
+5. **Cost Management**: FinOps platform integration
+
+## Conclusion
+
+The BMad Infrastructure DevOps expansion pack provides a comprehensive framework for modern infrastructure and platform engineering. By following its structured approach and leveraging the provided tools and templates, teams can build reliable, scalable, and secure infrastructure that accelerates application delivery while maintaining operational excellence.
+
+For support and updates, refer to the main BMad Method documentation or contact the BMad community.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmad-method",
-  "version": "4.27.4",
+  "version": "4.27.6",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "main": "tools/cli.js",
   "bin": {

package/tools/installer/bin/bmad.js

@@ -224,6 +224,58 @@ async function promptInstallation() {
   answers.installType = selectedItems.includes('bmad-core') ? 'full' : 'expansion-only';
   answers.expansionPacks = selectedItems.filter(item => item !== 'bmad-core');
 
+  // Ask sharding questions if installing BMad core
+  if (selectedItems.includes('bmad-core')) {
+    console.log(chalk.cyan('\n📋 Document Organization Settings'));
+    console.log(chalk.dim('Configure how your project documentation should be organized.\n'));
+    
+    // Ask about PRD sharding
+    const { prdSharded } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'prdSharded',
+        message: 'Will the PRD (Product Requirements Document) be sharded into multiple files?',
+        default: true
+      }
+    ]);
+    answers.prdSharded = prdSharded;
+    
+    // Ask about architecture sharding
+    const { architectureSharded } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'architectureSharded',
+        message: 'Will the architecture documentation be sharded into multiple files?',
+        default: true
+      }
+    ]);
+    answers.architectureSharded = architectureSharded;
+    
+    // Show warning if architecture sharding is disabled
+    if (!architectureSharded) {
+      console.log(chalk.yellow.bold('\n⚠️  IMPORTANT: Architecture Sharding Disabled'));
+      console.log(chalk.yellow('With architecture sharding disabled, you should still create the files listed'));
+      console.log(chalk.yellow('in devLoadAlwaysFiles (like coding-standards.md, tech-stack.md, source-tree.md)'));
+      console.log(chalk.yellow('as these are used by the dev agent at runtime.'));
+      console.log(chalk.yellow('\nAlternatively, you can remove these files from the devLoadAlwaysFiles list'));
+      console.log(chalk.yellow('in your core-config.yaml after installation.'));
+      
+      const { acknowledge } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'acknowledge',
+          message: 'Do you acknowledge this requirement and want to proceed?',
+          default: false
+        }
+      ]);
+      
+      if (!acknowledge) {
+        console.log(chalk.red('Installation cancelled.'));
+        process.exit(0);
+      }
+    }
+  }
+
   // Ask for IDE configuration
   const { ides } = await inquirer.prompt([
     {
@@ -246,6 +298,37 @@ async function promptInstallation() {
   // Use selected IDEs directly
   answers.ides = ides;
 
+  // Configure GitHub Copilot immediately if selected
+  if (ides.includes('github-copilot')) {
+    console.log(chalk.cyan('\n🔧 GitHub Copilot Configuration'));
+    console.log(chalk.dim('BMad works best with specific VS Code settings for optimal agent experience.\n'));
+    
+    const { configChoice } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'configChoice',
+        message: chalk.yellow('How would you like to configure GitHub Copilot settings?'),
+        choices: [
+          {
+            name: 'Use recommended defaults (fastest setup)',
+            value: 'defaults'
+          },
+          {
+            name: 'Configure each setting manually (customize to your preferences)',
+            value: 'manual'
+          },
+          {
+            name: 'Skip settings configuration (I\'ll configure manually later)',
+            value: 'skip'
+          }
+        ],
+        default: 'defaults'
+      }
+    ]);
+    
+    answers.githubCopilotConfig = { configChoice };
+  }
+
   // Ask for web bundles installation
   const { includeWebBundles } = await inquirer.prompt([
     {

package/tools/installer/lib/file-manager.js

@@ -47,7 +47,7 @@ class FileManager {
     }
   }
 
-  async copyGlobPattern(pattern, sourceDir, destDir) {
+  async copyGlobPattern(pattern, sourceDir, destDir, rootValue = null) {
     const files = glob.sync(pattern, { cwd: sourceDir });
     const copied = [];
 
@@ -55,7 +55,17 @@ class FileManager {
       const sourcePath = path.join(sourceDir, file);
       const destPath = path.join(destDir, file);
 
-      if (await this.copyFile(sourcePath, destPath)) {
+      // 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) {
         copied.push(file);
       }
     }
@@ -271,6 +281,99 @@ class FileManager {
 
     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();

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

@@ -41,7 +41,7 @@ class IdeSetup {
     }
   }
 
-  async setup(ide, installDir, selectedAgent = null, spinner = null) {
+  async setup(ide, installDir, selectedAgent = null, spinner = null, preConfiguredSettings = null) {
     await initializeModules();
     const ideConfig = await configLoader.getIdeConfiguration(ide);
 
@@ -66,7 +66,7 @@ class IdeSetup {
       case "gemini":
         return this.setupGeminiCli(installDir, selectedAgent);
       case "github-copilot":
-        return this.setupGitHubCopilot(installDir, selectedAgent, spinner);
+        return this.setupGitHubCopilot(installDir, selectedAgent, spinner, preConfiguredSettings);
       default:
         console.log(chalk.yellow(`\nIDE ${ide} not yet supported`));
         return false;
@@ -566,11 +566,11 @@ class IdeSetup {
     return true;
   }
 
-  async setupGitHubCopilot(installDir, selectedAgent, spinner = null) {
+  async setupGitHubCopilot(installDir, selectedAgent, spinner = null, preConfiguredSettings = null) {
     await initializeModules();
     
     // Configure VS Code workspace settings first to avoid UI conflicts with loading spinners
-    await this.configureVsCodeSettings(installDir, spinner);
+    await this.configureVsCodeSettings(installDir, spinner, preConfiguredSettings);
     
     const chatmodesDir = path.join(installDir, ".github", "chatmodes");
     const agents = selectedAgent ? [selectedAgent] : await this.getAllAgentIds(installDir);
@@ -616,7 +616,7 @@ tools: ['changes', 'codebase', 'fetch', 'findTestFiles', 'githubRepo', 'problems
     return true;
   }
 
-  async configureVsCodeSettings(installDir, spinner) {
+  async configureVsCodeSettings(installDir, spinner, preConfiguredSettings = null) {
     await initializeModules(); // Ensure inquirer is loaded
     const vscodeDir = path.join(installDir, ".vscode");
     const settingsPath = path.join(vscodeDir, "settings.json");
@@ -636,34 +636,42 @@ tools: ['changes', 'codebase', 'fetch', 'findTestFiles', 'githubRepo', 'problems
       }
     }
     
-    // Clear any previous output and add spacing to avoid conflicts with loaders
-    console.log('\n'.repeat(2));
-    console.log(chalk.blue("🔧 Github Copilot Agent Settings Configuration"));
-    console.log(chalk.dim("BMad works best with specific VS Code settings for optimal agent experience."));
-    console.log(''); // Add extra spacing
-    
-    const { configChoice } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'configChoice',
-        message: 'How would you like to configure Github Copilot settings?',
-        choices: [
-          {
-            name: 'Use recommended defaults (fastest setup)',
-            value: 'defaults'
-          },
-          {
-            name: 'Configure each setting manually (customize to your preferences)',
-            value: 'manual'
-          },
-          {
-            name: 'Skip settings configuration (I\'ll configure manually later)\n',
-            value: 'skip'
-          }
-        ],
-        default: 'defaults'
-      }
-    ]);
+    // Use pre-configured settings if provided, otherwise prompt
+    let configChoice;
+    if (preConfiguredSettings && preConfiguredSettings.configChoice) {
+      configChoice = preConfiguredSettings.configChoice;
+      console.log(chalk.dim(`Using pre-configured GitHub Copilot settings: ${configChoice}`));
+    } else {
+      // Clear any previous output and add spacing to avoid conflicts with loaders
+      console.log('\n'.repeat(2));
+      console.log(chalk.blue("🔧 Github Copilot Agent Settings Configuration"));
+      console.log(chalk.dim("BMad works best with specific VS Code settings for optimal agent experience."));
+      console.log(''); // Add extra spacing
+      
+      const response = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'configChoice',
+          message: chalk.yellow('How would you like to configure GitHub Copilot settings?'),
+          choices: [
+            {
+              name: 'Use recommended defaults (fastest setup)',
+              value: 'defaults'
+            },
+            {
+              name: 'Configure each setting manually (customize to your preferences)',
+              value: 'manual'
+            },
+            {
+              name: 'Skip settings configuration (I\'ll configure manually later)',
+              value: 'skip'
+            }
+          ],
+          default: 'defaults'
+        }
+      ]);
+      configChoice = response.configChoice;
+    }
     
     let bmadSettings = {};