bmad-method 6.0.0-alpha.2 → 6.0.0-alpha.21

package/src/modules/bmb/workflows-legacy/module-brief/checklist.md

@@ -0,0 +1,116 @@
+# Module Brief Validation Checklist
+
+## Core Identity
+
+- [ ] Module code follows kebab-case convention
+- [ ] Module name is clear and memorable
+- [ ] Module category is identified
+- [ ] Target users are clearly defined
+- [ ] Unique value proposition is articulated
+
+## Vision and Concept
+
+- [ ] Problem being solved is clearly stated
+- [ ] Solution approach is explained
+- [ ] Module scope is well-defined
+- [ ] Success criteria are measurable
+
+## Agent Architecture
+
+- [ ] At least one agent is defined
+- [ ] Each agent has a clear role and purpose
+- [ ] Agent personalities are defined (if using personality themes)
+- [ ] Agent interactions are mapped (for multi-agent modules)
+- [ ] Key commands for each agent are listed
+
+## Workflow Ecosystem
+
+- [ ] Core workflows (2-3) are identified
+- [ ] Each workflow has clear purpose
+- [ ] Workflow complexity is assessed
+- [ ] Input/output for workflows is defined
+- [ ] Workflow categories are logical
+
+## User Experience
+
+- [ ] Primary use case is documented
+- [ ] User scenarios demonstrate value
+- [ ] User journey is realistic
+- [ ] Learning curve is considered
+- [ ] User feedback mechanism planned
+
+## Technical Planning
+
+- [ ] Data requirements are identified
+- [ ] Integration points are mapped
+- [ ] Dependencies are listed
+- [ ] Technical complexity is assessed
+- [ ] Performance requirements stated
+
+## Development Roadmap
+
+- [ ] Phase 1 MVP is clearly scoped
+- [ ] Phase 2 enhancements are outlined
+- [ ] Phase 3 polish items listed
+- [ ] Timeline estimates provided
+- [ ] Deliverables are specific
+
+## Risk Management
+
+- [ ] Technical risks identified
+- [ ] Usability risks considered
+- [ ] Scope risks acknowledged
+- [ ] Mitigation strategies provided
+- [ ] Open questions documented
+
+## Creative Elements (Optional)
+
+- [ ] Personality theme is consistent (if used)
+- [ ] Special features add value
+- [ ] Module feels cohesive
+- [ ] Fun elements don't compromise functionality
+
+## Documentation Quality
+
+- [ ] All sections have content (no empty placeholders)
+- [ ] Writing is clear and concise
+- [ ] Technical terms are explained
+- [ ] Examples are provided where helpful
+- [ ] Next steps are actionable
+
+## Implementation Readiness
+
+- [ ] Brief provides enough detail for create-module workflow
+- [ ] Agent specifications sufficient for create-agent workflow
+- [ ] Workflow descriptions ready for create-workflow
+- [ ] Resource requirements are clear
+- [ ] Success metrics are measurable
+
+## Final Validation
+
+- [ ] Module concept is viable
+- [ ] Scope is achievable
+- [ ] Value is clear
+- [ ] Brief is complete
+- [ ] Ready for development
+
+## Issues Found
+
+### Critical Issues
+
+<!-- Must be fixed before proceeding to build -->
+
+### Recommendations
+
+<!-- Suggested improvements -->
+
+### Nice-to-Haves
+
+<!-- Optional enhancements -->
+
+---
+
+**Validation Complete:** ⬜ Yes / ⬜ With Issues / ⬜ Needs Revision
+
+**Validated By:** {name}
+**Date:** {date}

package/src/modules/bmb/workflows-legacy/module-brief/instructions.md

@@ -0,0 +1,268 @@
+# Module Brief Instructions
+
+<critical>The workflow execution engine is governed by: {project-root}/_bmad/core/tasks/workflow.xml</critical>
+<critical>You MUST have already loaded and processed: {project-root}/_bmad/bmb/workflows/module-brief/workflow.yaml</critical>
+<critical>Communicate in {communication_language} throughout the module brief creation process</critical>
+<critical>⚠️ ABSOLUTELY NO TIME ESTIMATES - NEVER mention hours, days, weeks, months, or ANY time-based predictions. AI has fundamentally changed development speed - what once took teams weeks/months can now be done by one person in hours. DO NOT give ANY time estimates whatsoever.</critical>
+
+<workflow>
+
+<step n="1" goal="Setup and context gathering">
+<action>Ask the user which mode they prefer:</action>
+1. **Interactive Mode** - Work through each section collaboratively with detailed questions
+2. **Express Mode** - Quick essential questions only
+3. **YOLO Mode** (#yolo) - Generate complete draft based on minimal input
+
+<action>Check for available inputs:</action>
+
+- Brainstorming results from previous sessions
+- Existing module ideas or notes
+- Similar modules for inspiration
+
+<action>If brainstorming results exist, offer to load and incorporate them</action>
+</step>
+
+<step n="2" goal="Module concept and vision">
+Ask the user to describe their module idea. Probe for:
+- What problem does this module solve?
+- Who would use this module?
+- What makes this module exciting or unique?
+- Any inspiring examples or similar tools?
+
+If they're stuck, offer creative prompts:
+
+- "Imagine you're a [role], what tools would make your life easier?"
+- "What repetitive tasks could be automated with agents?"
+- "What domain expertise could be captured in workflows?"
+
+<template-output>module_vision</template-output>
+</step>
+
+<step n="3" goal="Define module identity">
+Based on the vision, work with user to define:
+
+**Module Code** (kebab-case):
+
+- Suggest 2-3 options based on their description
+- Ensure it's memorable and descriptive
+
+**Module Name** (friendly):
+
+- Creative, engaging name that captures the essence
+
+**Module Category:**
+
+- Domain-Specific (legal, medical, finance)
+- Creative (writing, gaming, music)
+- Technical (devops, testing, architecture)
+- Business (project management, marketing)
+- Personal (productivity, learning)
+
+**Personality Theme** (optional but fun!):
+
+- Should the module have a consistent personality across agents?
+- Star Trek crew? Fantasy party? Corporate team? Reality show cast?
+
+<template-output>module_identity</template-output>
+</step>
+
+<step n="4" goal="Agent architecture planning">
+<action>Help user envision their agent team</action>
+
+For each agent, capture:
+
+- **Role**: What's their specialty?
+- **Personality**: How do they communicate? (reference communication styles)
+- **Key Capabilities**: What can they do?
+- **Signature Commands**: 2-3 main commands
+
+Suggest agent archetypes based on module type:
+
+- The Orchestrator (manages other agents)
+- The Specialist (deep expertise)
+- The Helper (utility functions)
+- The Creator (generates content)
+- The Analyzer (processes and evaluates)
+
+<template-output>agent_architecture</template-output>
+</step>
+
+<step n="5" goal="Workflow ecosystem design">
+<action>Map out the workflow landscape</action>
+
+Categorize workflows:
+
+**Core Workflows** (2-3 essential ones):
+
+- The primary value-delivery workflows
+- What users will use most often
+
+**Feature Workflows** (3-5 specialized):
+
+- Specific capabilities
+- Advanced features
+
+**Utility Workflows** (1-3 supporting):
+
+- Setup, configuration
+- Maintenance, cleanup
+
+For each workflow, define:
+
+- Purpose (one sentence)
+- Input → Process → Output
+- Complexity (simple/standard/complex)
+
+<template-output>workflow_ecosystem</template-output>
+</step>
+
+<step n="6" goal="User journey and scenarios">
+<action>Create usage scenarios to validate the design</action>
+
+Write 2-3 user stories:
+"As a [user type], I want to [goal], so that [outcome]"
+
+Then walk through how they'd use the module:
+
+1. They load [agent]
+2. They run [command/workflow]
+3. They get [result]
+4. This helps them [achievement]
+
+This validates the module makes sense end-to-end.
+
+<template-output>user_scenarios</template-output>
+</step>
+
+<step n="7" goal="Technical and resource planning">
+Assess technical requirements:
+
+**Data Requirements:**
+
+- What data/files does the module need?
+- Any external APIs or services?
+- Storage or state management needs?
+
+**Integration Points:**
+
+- Other BMAD modules it might use
+- External tools or platforms
+- Import/export formats
+
+**Complexity Assessment:**
+
+- Simple (standalone, no dependencies)
+- Standard (some integrations, moderate complexity)
+- Complex (multiple systems, advanced features)
+
+<template-output>technical_planning</template-output>
+</step>
+
+<step n="8" goal="Success metrics and validation">
+Define what success looks like:
+
+**Module Success Criteria:**
+
+- What indicates the module is working well?
+- How will users measure value?
+- What feedback mechanisms?
+
+**Quality Standards:**
+
+- Performance expectations
+- Reliability requirements
+- User experience goals
+
+<template-output>success_metrics</template-output>
+</step>
+
+<step n="9" goal="Development roadmap">
+Create a phased approach:
+
+**Phase 1 - MVP (Minimum Viable Module):**
+
+- 1 primary agent
+- 2-3 core workflows
+- Basic functionality
+
+**Phase 2 - Enhancement:**
+
+- Additional agents
+- More workflows
+- Refined features
+
+**Phase 3 - Polish:**
+
+- Advanced features
+- Optimizations
+- Nice-to-haves
+
+<template-output>development_roadmap</template-output>
+</step>
+
+<step n="10" goal="Creative flourishes and special features" optional="true">
+<action>If user wants to add special touches:</action>
+
+**Easter Eggs:**
+
+- Hidden commands or responses
+- Fun interactions between agents
+
+**Delighters:**
+
+- Unexpected helpful features
+- Personality quirks
+- Creative responses
+
+**Module Lore:**
+
+- Backstory for agents
+- Thematic elements
+- Consistent universe
+
+<template-output>creative_features</template-output>
+</step>
+
+<step n="11" goal="Risk assessment and mitigation">
+Identify potential challenges:
+
+**Technical Risks:**
+
+- Complex integrations
+- Performance concerns
+- Dependency issues
+
+**Usability Risks:**
+
+- Learning curve
+- Complexity creep
+- User confusion
+
+**Scope Risks:**
+
+- Feature bloat
+- Timeline expansion
+- Resource constraints
+
+For each risk, note mitigation strategy.
+
+<template-output>risk_assessment</template-output>
+</step>
+
+<step n="12" goal="Final review and export readiness">
+<action>Review all sections with {user_name}</action>
+<action>Ensure module brief is ready for create-module workflow</action>
+
+<ask>Would {user_name} like to:
+
+1. Proceed directly to create-module workflow
+2. Save and refine later
+3. Generate additional planning documents
+   </ask>
+
+<action>Inform {user_name} in {communication_language} that this brief can be fed directly into create-module workflow</action>
+
+<template-output>final_brief</template-output>
+</step>
+
+</workflow>

package/src/modules/bmb/workflows-legacy/module-brief/workflow.yaml

@@ -0,0 +1,36 @@
+# Module Brief Workflow Configuration
+name: module-brief
+description: "Create a comprehensive Module Brief that serves as the blueprint for building new BMAD modules using strategic analysis and creative vision"
+author: "BMad Builder"
+
+# Critical variables
+config_source: "{project-root}/_bmad/bmb/config.yaml"
+output_folder: "{config_source}:output_folder"
+user_name: "{config_source}:user_name"
+communication_language: "{config_source}:communication_language"
+date: system-generated
+
+# Reference examples and documentation
+existing_modules_dir: "{project-root}/_bmad/"
+module_structure_guide: "{project-root}/_bmad/bmb/workflows/create-module/module-structure.md"
+
+# Optional user inputs - discovered if they exist
+input_file_patterns:
+  brainstorming:
+    description: "Brainstorming session outputs (optional)"
+    whole: "{output_folder}/brainstorming-*.md"
+    load_strategy: "FULL_LOAD"
+
+# Module path and component files
+installed_path: "{project-root}/_bmad/bmb/workflows/module-brief"
+template: "{installed_path}/template.md"
+instructions: "{installed_path}/instructions.md"
+validation: "{installed_path}/checklist.md"
+
+# Output configuration
+default_output_file: "{output_folder}/module-brief-{{module_code}}-{{date}}.md"
+
+standalone: true
+
+# Web bundle configuration
+web_bundle: false # BMB workflows run locally in BMAD-METHOD project

package/src/modules/bmgd/_module-installer/installer.js

@@ -0,0 +1,160 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const chalk = require('chalk');
+const platformCodes = require(path.join(__dirname, '../../../../tools/cli/lib/platform-codes'));
+
+/**
+ * Validate that a resolved path is within the project root (prevents path traversal)
+ * @param {string} resolvedPath - The fully resolved absolute path
+ * @param {string} projectRoot - The project root directory
+ * @returns {boolean} - True if path is within project root
+ */
+function isWithinProjectRoot(resolvedPath, projectRoot) {
+  const normalizedResolved = path.normalize(resolvedPath);
+  const normalizedRoot = path.normalize(projectRoot);
+  return normalizedResolved.startsWith(normalizedRoot + path.sep) || normalizedResolved === normalizedRoot;
+}
+
+/**
+ * BMGD Module Installer
+ * Standard module installer function that executes after IDE installations
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from module.yaml
+ * @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
+ * @param {Object} options.logger - Logger instance for output
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install(options) {
+  const { projectRoot, config, installedIDEs, logger } = options;
+
+  try {
+    logger.log(chalk.blue('🎮 Installing BMGD Module...'));
+
+    // Create planning artifacts directory (for GDDs, game briefs, architecture)
+    if (config['planning_artifacts'] && typeof config['planning_artifacts'] === 'string') {
+      // Strip project-root prefix variations
+      const planningConfig = config['planning_artifacts'].replace(/^\{project-root\}\/?/, '');
+      const planningPath = path.join(projectRoot, planningConfig);
+      if (!isWithinProjectRoot(planningPath, projectRoot)) {
+        logger.warn(chalk.yellow(`Warning: planning_artifacts path escapes project root, skipping: ${planningConfig}`));
+      } else if (!(await fs.pathExists(planningPath))) {
+        logger.log(chalk.yellow(`Creating game planning artifacts directory: ${planningConfig}`));
+        await fs.ensureDir(planningPath);
+      }
+    }
+
+    // Create implementation artifacts directory (sprint status, stories, reviews)
+    // Check both implementation_artifacts and implementation_artifacts for compatibility
+    const implConfig = config['implementation_artifacts'] || config['implementation_artifacts'];
+    if (implConfig && typeof implConfig === 'string') {
+      // Strip project-root prefix variations
+      const implConfigClean = implConfig.replace(/^\{project-root\}\/?/, '');
+      const implPath = path.join(projectRoot, implConfigClean);
+      if (!isWithinProjectRoot(implPath, projectRoot)) {
+        logger.warn(chalk.yellow(`Warning: implementation_artifacts path escapes project root, skipping: ${implConfigClean}`));
+      } else if (!(await fs.pathExists(implPath))) {
+        logger.log(chalk.yellow(`Creating implementation artifacts directory: ${implConfigClean}`));
+        await fs.ensureDir(implPath);
+      }
+    }
+
+    // Create project knowledge directory
+    if (config['project_knowledge'] && typeof config['project_knowledge'] === 'string') {
+      // Strip project-root prefix variations
+      const knowledgeConfig = config['project_knowledge'].replace(/^\{project-root\}\/?/, '');
+      const knowledgePath = path.join(projectRoot, knowledgeConfig);
+      if (!isWithinProjectRoot(knowledgePath, projectRoot)) {
+        logger.warn(chalk.yellow(`Warning: project_knowledge path escapes project root, skipping: ${knowledgeConfig}`));
+      } else if (!(await fs.pathExists(knowledgePath))) {
+        logger.log(chalk.yellow(`Creating project knowledge directory: ${knowledgeConfig}`));
+        await fs.ensureDir(knowledgePath);
+      }
+    }
+
+    // Log selected game engine(s)
+    if (config['primary_platform']) {
+      const platforms = Array.isArray(config['primary_platform']) ? config['primary_platform'] : [config['primary_platform']];
+
+      const platformNames = platforms.map((p) => {
+        switch (p) {
+          case 'unity': {
+            return 'Unity';
+          }
+          case 'unreal': {
+            return 'Unreal Engine';
+          }
+          case 'godot': {
+            return 'Godot';
+          }
+          default: {
+            return p;
+          }
+        }
+      });
+
+      logger.log(chalk.cyan(`Game engine support configured for: ${platformNames.join(', ')}`));
+    }
+
+    // Handle IDE-specific configurations if needed
+    if (installedIDEs && installedIDEs.length > 0) {
+      logger.log(chalk.cyan(`Configuring BMGD for IDEs: ${installedIDEs.join(', ')}`));
+
+      for (const ide of installedIDEs) {
+        await configureForIDE(ide, projectRoot, config, logger);
+      }
+    }
+
+    logger.log(chalk.green('✓ BMGD Module installation complete'));
+    logger.log(chalk.dim('  Game development workflows ready'));
+    logger.log(chalk.dim('  Agents: Game Designer, Game Dev, Game Architect, Game SM, Game QA, Game Solo Dev'));
+
+    return true;
+  } catch (error) {
+    logger.error(chalk.red(`Error installing BMGD module: ${error.message}`));
+    return false;
+  }
+}
+
+/**
+ * Configure BMGD module for specific platform/IDE
+ * @private
+ */
+async function configureForIDE(ide, projectRoot, config, logger) {
+  // Validate platform code
+  if (!platformCodes.isValidPlatform(ide)) {
+    logger.warn(chalk.yellow(`  Warning: Unknown platform code '${ide}'. Skipping BMGD configuration.`));
+    return;
+  }
+
+  const platformName = platformCodes.getDisplayName(ide);
+
+  // Try to load platform-specific handler
+  const platformSpecificPath = path.join(__dirname, 'platform-specifics', `${ide}.js`);
+
+  try {
+    if (await fs.pathExists(platformSpecificPath)) {
+      const platformHandler = require(platformSpecificPath);
+
+      if (typeof platformHandler.install === 'function') {
+        const success = await platformHandler.install({
+          projectRoot,
+          config,
+          logger,
+          platformInfo: platformCodes.getPlatform(ide),
+        });
+        if (!success) {
+          logger.warn(chalk.yellow(`  Warning: BMGD platform handler for ${platformName} returned failure`));
+        }
+      }
+    } else {
+      // No platform-specific handler for this IDE
+      logger.log(chalk.dim(`  No BMGD-specific configuration for ${platformName}`));
+    }
+  } catch (error) {
+    logger.warn(chalk.yellow(`  Warning: Could not load BMGD platform-specific handler for ${platformName}: ${error.message}`));
+  }
+}
+
+module.exports = { install };

package/src/modules/bmgd/_module-installer/platform-specifics/claude-code.js

@@ -0,0 +1,23 @@
+/**
+ * BMGD Platform-specific installer for Claude Code
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from module.yaml
+ * @param {Object} options.logger - Logger instance for output
+ * @param {Object} options.platformInfo - Platform metadata from global config
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install() {
+  // TODO: Add Claude Code specific BMGD configurations here
+  // For example:
+  // - Game-specific slash commands
+  // - Agent party configurations for game dev team
+  // - Workflow integrations for Unity/Unreal/Godot
+  // - Game testing framework integrations
+
+  // Currently a stub - no platform-specific configuration needed yet
+  return true;
+}
+
+module.exports = { install };

package/src/modules/bmgd/_module-installer/platform-specifics/windsurf.js

@@ -0,0 +1,18 @@
+/**
+ * BMGD Platform-specific installer for Windsurf
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from module.yaml
+ * @param {Object} options.logger - Logger instance for output
+ * @param {Object} options.platformInfo - Platform metadata from global config
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install() {
+  // TODO: Add Windsurf specific BMGD configurations here
+
+  // Currently a stub - no platform-specific configuration needed yet
+  return true;
+}
+
+module.exports = { install };

package/src/modules/bmgd/agents/game-architect.agent.yaml

@@ -0,0 +1,43 @@
+# Game Architect Agent Definition
+
+agent:
+  metadata:
+    id: "_bmad/bmgd/agents/game-architect.md"
+    name: Cloud Dragonborn
+    title: Game Architect
+    icon: 🏛️
+    module: bmgd
+
+  persona:
+    role: Principal Game Systems Architect + Technical Director
+    identity: Master architect with 20+ years shipping 30+ titles. Expert in distributed systems, engine design, multiplayer architecture, and technical leadership across all platforms.
+    communication_style: "Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors about building foundations and load-bearing walls"
+    principles: |
+      - Architecture is about delaying decisions until you have enough data
+      - Build for tomorrow without over-engineering today
+      - Hours of planning save weeks of refactoring hell
+      - Every system must handle the hot path at 60fps
+      - Avoid "Not Invented Here" syndrome, always check if work has been done before
+
+  critical_actions:
+    - "Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md`"
+    - "When creating architecture, validate against GDD pillars and target platform constraints"
+    - "Always document performance budgets and critical path decisions"
+
+  menu:
+    - trigger: WS or fuzzy match on workflow-status
+      workflow: "{project-root}/_bmad/bmgd/workflows/workflow-status/workflow.yaml"
+      description: "[WS] Get workflow status or initialize a workflow if not already done (optional)"
+
+    - trigger: GA or fuzzy match on game-architecture
+      exec: "{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.md"
+      description: "[GA] Produce a Scale Adaptive Game Architecture"
+
+    - trigger: PC or fuzzy match on project-context
+      exec: "{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context/workflow.md"
+      description: "[PC] Create optimized project-context.md for AI agent consistency"
+
+    - trigger: CC or fuzzy match on correct-course
+      workflow: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml"
+      description: "[CC] Course Correction Analysis (when implementation is off-track)"
+      ide-only: true