bmad-method 4.2.0 → 4.4.1

package/expansion-packs/bmad-2d-phaser-game-dev/workflows/game-dev-greenfield.yml

@@ -0,0 +1,183 @@
+workflow:
+  id: game-dev-greenfield
+  name: Game Development - Greenfield Project
+  description: Specialized workflow for creating 2D games from concept to implementation using Phaser 3 and TypeScript. Guides teams through game concept development, design documentation, technical architecture, and story-driven development for professional game development.
+  type: greenfield
+  project_types:
+    - indie-game
+    - mobile-game
+    - web-game
+    - educational-game
+    - prototype-game
+    - game-jam
+  full_game_sequence:
+    - agent: game-designer
+      creates: game-brief.md
+      optional_steps:
+        - brainstorming_session
+        - game_research_prompt
+        - player_research
+      notes: 'Start with brainstorming game concepts, then create comprehensive game brief. SAVE OUTPUT: Copy final game-brief.md to your project''s docs/design/ folder.'
+    - agent: game-designer
+      creates: game-design-doc.md
+      requires: game-brief.md
+      optional_steps:
+        - competitive_analysis
+        - technical_research
+      notes: 'Create detailed Game Design Document using game-design-doc-tmpl. Defines all gameplay mechanics, progression, and technical requirements. SAVE OUTPUT: Copy final game-design-doc.md to your project''s docs/design/ folder.'
+    - agent: game-designer
+      creates: level-design-doc.md
+      requires: game-design-doc.md
+      optional_steps:
+        - level_prototyping
+        - difficulty_analysis
+      notes: 'Create level design framework using level-design-doc-tmpl. Establishes content creation guidelines and performance requirements. SAVE OUTPUT: Copy final level-design-doc.md to your project''s docs/design/ folder.'
+    - agent: solution-architect
+      creates: game-architecture.md
+      requires:
+        - game-design-doc.md
+        - level-design-doc.md
+      optional_steps:
+        - technical_research_prompt
+        - performance_analysis
+        - platform_research
+      notes: 'Create comprehensive technical architecture using game-architecture-tmpl. Defines Phaser 3 systems, performance optimization, and code structure. SAVE OUTPUT: Copy final game-architecture.md to your project''s docs/architecture/ folder.'
+    - agent: game-designer
+      validates: design_consistency
+      requires: all_design_documents
+      uses: game-design-checklist
+      notes: Validate all design documents for consistency, completeness, and implementability. May require updates to any design document.
+    - agent: various
+      updates: flagged_design_documents
+      condition: design_validation_issues
+      notes: If design validation finds issues, return to relevant agent to fix and re-export updated documents to docs/ folder.
+  project_setup_guidance:
+    action: guide_game_project_structure
+    notes: Set up game project structure following game architecture document. Create src/, assets/, docs/, and tests/ directories. Initialize TypeScript and Phaser 3 configuration.
+  workflow_end:
+    action: move_to_story_development
+    notes: All design artifacts complete. Begin story-driven development phase. Use Game Scrum Master to create implementation stories from design documents.
+  prototype_sequence:
+    - step: prototype_scope
+      action: assess_prototype_complexity
+      notes: First, assess if this needs full game design (use full_game_sequence) or can be a rapid prototype.
+    - agent: game-designer
+      creates: game-brief.md
+      optional_steps:
+        - quick_brainstorming
+        - concept_validation
+      notes: 'Create focused game brief for prototype. Emphasize core mechanics and immediate playability. SAVE OUTPUT: Copy final game-brief.md to your project''s docs/ folder.'
+    - agent: game-designer
+      creates: prototype-design.md
+      uses: create-doc prototype-design OR create-game-story
+      requires: game-brief.md
+      notes: Create minimal design document or jump directly to implementation stories for rapid prototyping. Choose based on prototype complexity.
+  prototype_workflow_end:
+    action: move_to_rapid_implementation
+    notes: Prototype defined. Begin immediate implementation with Game Developer. Focus on core mechanics first, then iterate based on playtesting.
+  flow_diagram: |
+    ```mermaid
+    graph TD
+        A[Start: Game Development Project] --> B{Project Scope?}
+        B -->|Full Game/Production| C[game-designer: game-brief.md]
+        B -->|Prototype/Game Jam| D[game-designer: focused game-brief.md]
+
+        C --> E[game-designer: game-design-doc.md]
+        E --> F[game-designer: level-design-doc.md]
+        F --> G[solution-architect: game-architecture.md]
+        G --> H[game-designer: validate design consistency]
+        H --> I{Design validation issues?}
+        I -->|Yes| J[Return to relevant agent for fixes]
+        I -->|No| K[Set up game project structure]
+        J --> H
+        K --> L[Move to Story Development Phase]
+
+        D --> M[game-designer: prototype-design.md]
+        M --> N[Move to Rapid Implementation]
+
+        C -.-> C1[Optional: brainstorming]
+        C -.-> C2[Optional: game research]
+        E -.-> E1[Optional: competitive analysis]
+        F -.-> F1[Optional: level prototyping]
+        G -.-> G1[Optional: technical research]
+        D -.-> D1[Optional: quick brainstorming]
+
+        style L fill:#90EE90
+        style N fill:#90EE90
+        style C fill:#FFE4B5
+        style E fill:#FFE4B5
+        style F fill:#FFE4B5
+        style G fill:#FFE4B5
+        style D fill:#FFB6C1
+        style M fill:#FFB6C1
+    ```
+  decision_guidance:
+    use_full_sequence_when:
+      - Building commercial or production games
+      - Multiple team members involved
+      - Complex gameplay systems (3+ core mechanics)
+      - Long-term development timeline (2+ months)
+      - Need comprehensive documentation for team coordination
+      - Targeting multiple platforms
+      - Educational or enterprise game projects
+    use_prototype_sequence_when:
+      - Game jams or time-constrained development
+      - Solo developer or very small team
+      - Experimental or proof-of-concept games
+      - Simple mechanics (1-2 core systems)
+      - Quick validation of game concepts
+      - Learning projects or technical demos
+  handoff_prompts:
+    designer_to_gdd: Game brief is complete. Save it as docs/design/game-brief.md in your project, then create the comprehensive Game Design Document.
+    gdd_to_level: Game Design Document ready. Save it as docs/design/game-design-doc.md, then create the level design framework.
+    level_to_architect: Level design complete. Save it as docs/design/level-design-doc.md, then create the technical architecture.
+    architect_review: Architecture complete. Save it as docs/architecture/game-architecture.md. Please validate all design documents for consistency.
+    validation_issues: Design validation found issues with [document]. Please return to [agent] to fix and re-save the updated document.
+    full_complete: All design artifacts validated and saved. Set up game project structure and move to story development phase.
+    prototype_designer_to_dev: Prototype brief complete. Save it as docs/game-brief.md, then create minimal design or jump directly to implementation stories.
+    prototype_complete: Prototype defined. Begin rapid implementation focusing on core mechanics and immediate playability.
+  story_development_guidance:
+    epic_breakdown:
+      - Core Game Systems" - Fundamental gameplay mechanics and player controls
+      - Level Content" - Individual levels, progression, and content implementation
+      - User Interface" - Menus, HUD, settings, and player feedback systems
+      - Audio Integration" - Music, sound effects, and audio systems
+      - Performance Optimization" - Platform optimization and technical polish
+      - Game Polish" - Visual effects, animations, and final user experience
+    story_creation_process:
+      - Use Game Scrum Master to create detailed implementation stories
+      - Each story should reference specific GDD sections
+      - Include performance requirements (60 FPS target)
+      - Specify Phaser 3 implementation details
+      - Apply game-story-dod-checklist for quality validation
+      - Ensure stories are immediately actionable by Game Developer
+  game_development_best_practices:
+    performance_targets:
+      - Maintain 60 FPS on target devices throughout development
+      - Memory usage under specified limits per game system
+      - Loading times under 3 seconds for levels
+      - Smooth animation and responsive player controls
+    technical_standards:
+      - TypeScript strict mode compliance
+      - Component-based game architecture
+      - Object pooling for performance-critical objects
+      - Cross-platform input handling
+      - Comprehensive error handling and graceful degradation
+    playtesting_integration:
+      - Test core mechanics early and frequently
+      - Validate game balance through metrics and player feedback
+      - Iterate on design based on implementation discoveries
+      - Document design changes and rationale
+  success_criteria:
+    design_phase_complete:
+      - All design documents created and validated
+      - Technical architecture aligns with game design requirements
+      - Performance targets defined and achievable
+      - Story breakdown ready for implementation
+      - Project structure established
+    implementation_readiness:
+      - Development environment configured for Phaser 3 + TypeScript
+      - Asset pipeline and build system established
+      - Testing framework in place
+      - Team roles and responsibilities defined
+      - First implementation stories created and ready

package/expansion-packs/bmad-2d-phaser-game-dev/workflows/game-prototype.yml

@@ -0,0 +1,175 @@
+workflow:
+  id: game-prototype
+  name: Game Prototype Development
+  description: Fast-track workflow for rapid game prototyping and concept validation. Optimized for game jams, proof-of-concept development, and quick iteration on game mechanics using Phaser 3 and TypeScript.
+  type: prototype
+  project_types:
+    - game-jam
+    - proof-of-concept
+    - mechanic-test
+    - technical-demo
+    - learning-project
+    - rapid-iteration
+  prototype_sequence:
+    - step: concept_definition
+      agent: game-designer
+      duration: 15-30 minutes
+      creates: concept-summary.md
+      notes: Quickly define core game concept, primary mechanic, and target experience. Focus on what makes this game unique and fun.
+    - step: rapid_design
+      agent: game-designer
+      duration: 30-60 minutes
+      creates: prototype-spec.md
+      requires: concept-summary.md
+      optional_steps:
+        - quick_brainstorming
+        - reference_research
+      notes: Create minimal but complete design specification. Focus on core mechanics, basic controls, and success/failure conditions.
+    - step: technical_planning
+      agent: game-developer
+      duration: 15-30 minutes
+      creates: prototype-architecture.md
+      requires: prototype-spec.md
+      notes: Define minimal technical implementation plan. Identify core Phaser 3 systems needed and performance constraints.
+    - step: implementation_stories
+      agent: game-sm
+      duration: 30-45 minutes
+      creates: prototype-stories/
+      requires: prototype-spec.md, prototype-architecture.md
+      notes: Create 3-5 focused implementation stories for core prototype features. Each story should be completable in 2-4 hours.
+    - step: iterative_development
+      agent: game-developer
+      duration: varies
+      implements: prototype-stories/
+      notes: Implement stories in priority order. Test frequently and adjust design based on what feels fun. Document discoveries.
+  workflow_end:
+    action: prototype_evaluation
+    notes: 'Prototype complete. Evaluate core mechanics, gather feedback, and decide next steps: iterate, expand, or archive.'
+  game_jam_sequence:
+    - step: jam_concept
+      agent: game-designer
+      duration: 10-15 minutes
+      creates: jam-concept.md
+      notes: Define game concept based on jam theme. One sentence core mechanic, basic controls, win condition.
+    - step: jam_implementation
+      agent: game-developer
+      duration: varies (jam timeline)
+      creates: working-prototype
+      requires: jam-concept.md
+      notes: Directly implement core mechanic. No formal stories - iterate rapidly on what's fun. Document major decisions.
+  jam_workflow_end:
+    action: jam_submission
+    notes: Submit to game jam. Capture lessons learned and consider post-jam development if concept shows promise.
+  flow_diagram: |
+    ```mermaid
+    graph TD
+        A[Start: Prototype Project] --> B{Development Context?}
+        B -->|Standard Prototype| C[game-designer: concept-summary.md]
+        B -->|Game Jam| D[game-designer: jam-concept.md]
+
+        C --> E[game-designer: prototype-spec.md]
+        E --> F[game-developer: prototype-architecture.md]
+        F --> G[game-sm: create prototype stories]
+        G --> H[game-developer: iterative implementation]
+        H --> I[Prototype Evaluation]
+
+        D --> J[game-developer: direct implementation]
+        J --> K[Game Jam Submission]
+
+        E -.-> E1[Optional: quick brainstorming]
+        E -.-> E2[Optional: reference research]
+
+        style I fill:#90EE90
+        style K fill:#90EE90
+        style C fill:#FFE4B5
+        style E fill:#FFE4B5
+        style F fill:#FFE4B5
+        style G fill:#FFE4B5
+        style H fill:#FFE4B5
+        style D fill:#FFB6C1
+        style J fill:#FFB6C1
+    ```
+  decision_guidance:
+    use_prototype_sequence_when:
+      - Learning new game development concepts
+      - Testing specific game mechanics
+      - Building portfolio pieces
+      - Have 1-7 days for development
+      - Need structured but fast development
+      - Want to validate game concepts before full development
+    use_game_jam_sequence_when:
+      - Participating in time-constrained game jams
+      - Have 24-72 hours total development time
+      - Want to experiment with wild or unusual concepts
+      - Learning through rapid iteration
+      - Building networking/portfolio presence
+  prototype_best_practices:
+    scope_management:
+      - Start with absolute minimum viable gameplay
+      - One core mechanic implemented well beats many mechanics poorly
+      - Focus on "game feel" over features
+      - Cut features ruthlessly to meet timeline
+    rapid_iteration:
+      - Test the game every 1-2 hours of development
+      - Ask "Is this fun?" frequently during development
+      - Be willing to pivot mechanics if they don't feel good
+      - Document what works and what doesn't
+    technical_efficiency:
+      - Use simple graphics (geometric shapes, basic sprites)
+      - Leverage Phaser 3's built-in systems heavily
+      - Avoid complex custom systems in prototypes
+      - Prioritize functional over polished
+  prototype_evaluation_criteria:
+    core_mechanic_validation:
+      - Is the primary mechanic engaging for 30+ seconds?
+      - Do players understand the mechanic without explanation?
+      - Does the mechanic have depth for extended play?
+      - Are there natural difficulty progression opportunities?
+    technical_feasibility:
+      - Does the prototype run at acceptable frame rates?
+      - Are there obvious technical blockers for expansion?
+      - Is the codebase clean enough for further development?
+      - Are performance targets realistic for full game?
+    player_experience:
+      - Do testers engage with the game voluntarily?
+      - What emotions does the game create in players?
+      - Are players asking for "just one more try"?
+      - What do players want to see added or changed?
+  post_prototype_options:
+    iterate_and_improve:
+      action: continue_prototyping
+      when: Core mechanic shows promise but needs refinement
+      next_steps: Create new prototype iteration focusing on identified improvements
+    expand_to_full_game:
+      action: transition_to_full_development
+      when: Prototype validates strong game concept
+      next_steps: Use game-dev-greenfield workflow to create full game design and architecture
+    pivot_concept:
+      action: new_prototype_direction
+      when: Current mechanic doesn't work but insights suggest new direction
+      next_steps: Apply learnings to new prototype concept
+    archive_and_learn:
+      action: document_learnings
+      when: Prototype doesn't work but provides valuable insights
+      next_steps: Document lessons learned and move to next prototype concept
+  time_boxing_guidance:
+    concept_phase: Maximum 30 minutes - if you can't explain the game simply, simplify it
+    design_phase: Maximum 1 hour - focus on core mechanics only
+    planning_phase: Maximum 30 minutes - identify critical path to playable prototype
+    implementation_phase: Time-boxed iterations - test every 2-4 hours of work
+  success_metrics:
+    development_velocity:
+      - Playable prototype in first day of development
+      - Core mechanic demonstrable within 4-6 hours of coding
+      - Major iteration cycles completed in 2-4 hour blocks
+    learning_objectives:
+      - Clear understanding of what makes the mechanic fun (or not)
+      - Technical feasibility assessment for full development
+      - Player reaction and engagement validation
+      - Design insights for future development
+  handoff_prompts:
+    concept_to_design: Game concept defined. Create minimal design specification focusing on core mechanics and player experience.
+    design_to_technical: Design specification ready. Create technical implementation plan for rapid prototyping.
+    technical_to_stories: Technical plan complete. Create focused implementation stories for prototype development.
+    stories_to_implementation: Stories ready. Begin iterative implementation with frequent playtesting and design validation.
+    prototype_to_evaluation: Prototype playable. Evaluate core mechanics, gather feedback, and determine next development steps.

package/expansion-packs/{infrastructure-devops → bmad-infrastructure-devops}/README.md

@@ -64,15 +64,15 @@ This expansion pack integrates with the core BMAD flow at these points:
 
 To install this expansion pack, run:
 
-```bash
+````bash
 npm run install:expansion infrastructure
-```
+```text
 
 Or manually:
 
 ```bash
 node tools/install-expansion-pack.js infrastructure
-```
+```text
 
 This will:
 
@@ -92,7 +92,7 @@ After the main architecture is complete:
 
 # Or directly with DevOps agent
 npm run agent devops
-```
+```text
 
 ### 2. Platform Implementation
 
@@ -101,7 +101,7 @@ With an approved infrastructure architecture:
 ```bash
 # DevOps agent implements the platform
 *implement-platform
-```
+````
 
 ### 3. Infrastructure Validation
 

package/expansion-packs/{infrastructure-devops → bmad-infrastructure-devops}/agents/infra-devops-platform.md

@@ -2,7 +2,7 @@
 
 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:
 
-```yml
+```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
@@ -31,8 +31,8 @@ persona:
     - Collaborative Operations - Work closely with development teams fostering shared responsibility for system reliability
 startup:
   - Announce: Hey! I'm Alex, your DevOps Infrastructure Specialist. I love when things run secure, stable, reliable and performant. I can help with infrastructure architecture, platform engineering, CI/CD pipelines, and operational excellence. What infrastructure challenge can I help you with today?
-  - 'List available tasks: review-infrastructure, validate-infrastructure, create infrastructure documentation'
-  - 'List available templates: infrastructure-architecture, infrastructure-platform-from-arch'
+  - "List available tasks: review-infrastructure, validate-infrastructure, create infrastructure documentation"
+  - "List available templates: infrastructure-architecture, infrastructure-platform-from-arch"
   - Execute selected task or stay in persona to help guided by Core DevOps Principles
 commands:
   - '*help" - Show: numbered list of the following commands to allow selection'

package/expansion-packs/bmad-infrastructure-devops/manifest.yml

@@ -0,0 +1,23 @@
+name: bmad-infrastructure-devops
+version: 1.0.0
+description: Infrastructure & DevOps expansion pack for BMAD Method - Platform engineering and cloud infrastructure focused
+author: BMAD Team
+files:
+  - source: agents/infra-devops-platform.md
+    destination: .bmad-core/agents/infra-devops-platform.md
+  - source: templates/infrastructure-architecture-tmpl.md
+    destination: .bmad-core/templates/infrastructure-architecture-tmpl.md
+  - source: templates/infrastructure-platform-from-arch-tmpl.md
+    destination: .bmad-core/templates/infrastructure-platform-from-arch-tmpl.md
+  - source: tasks/create-doc.md
+    destination: .bmad-core/tasks/create-doc.md
+  - source: tasks/review-infrastructure.md
+    destination: .bmad-core/tasks/review-infrastructure.md
+  - source: tasks/validate-infrastructure.md
+    destination: .bmad-core/tasks/validate-infrastructure.md
+  - source: checklists/infrastructure-checklist.md
+    destination: .bmad-core/checklists/infrastructure-checklist.md
+dependencies:
+  - architect
+  - operations-specialist
+  - security-specialist

package/expansion-packs/bmad-infrastructure-devops/tasks/create-doc.md

@@ -0,0 +1,74 @@
+# Create Document from Template Task
+
+## Purpose
+
+- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
+
+## Instructions
+
+### 1. Identify Template and Context
+
+- Determine which template to use (user-provided or list available for selection to user)
+
+  - Agent-specific templates are listed in the agent's dependencies under `templates`. For each template listed, consider it a document the agent can create. So if an agent has:
+
+    @{example}
+    dependencies:
+    templates: - prd-tmpl - architecture-tmpl
+    @{/example}
+
+    You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
+
+- Gather all relevant inputs, or ask for them, or else rely on user providing necessary details to complete the document
+- Understand the document purpose and target audience
+
+### 2. Determine Interaction Mode
+
+Confirm with the user their preferred interaction style:
+
+- **Incremental:** Work through chunks of the document.
+- **YOLO Mode:** Draft complete document making reasonable assumptions in one shot. (Can be entered also after starting incremental by just typing /yolo)
+
+### 3. Execute Template
+
+- Load specified template from `templates#*` or the /templates directory
+- Follow ALL embedded LLM instructions within the template
+- Process template markup according to `utils#template-format` conventions
+
+### 4. Template Processing Rules
+
+#### CRITICAL: Never display template markup, LLM instructions, or examples to users
+
+- Replace all {{placeholders}} with actual content
+- Execute all [[LLM: instructions]] internally
+- Process `<<REPEAT>>` sections as needed
+- Evaluate ^^CONDITION^^ blocks and include only if applicable
+- Use @{examples} for guidance but never output them
+
+### 5. Content Generation
+
+- **Incremental Mode**: Present each major section for review before proceeding
+- **YOLO Mode**: Generate all sections, then review complete document with user
+- Apply any elicitation protocols specified in template
+- Incorporate user feedback and iterate as needed
+
+### 6. Validation
+
+If template specifies a checklist:
+
+- Run the appropriate checklist against completed document
+- Document completion status for each item
+- Address any deficiencies found
+- Present validation summary to user
+
+### 7. Final Presentation
+
+- Present clean, formatted content only
+- Ensure all sections are complete
+- DO NOT truncate or summarize content
+- Begin directly with document content (no preamble)
+- Include any handoff prompts specified in template
+
+## Important Notes
+
+- Template markup is for AI processing only - never expose to users