bmad-method 4.42.1 → 4.43.1

package/expansion-packs/bmad-godot-game-dev/utils/bmad-doc-template.md

@@ -0,0 +1,327 @@
+<!-- Powered by BMAD™ Core -->
+
+# BMad Document Template Specification
+
+## Overview
+
+BMad document templates are defined in YAML format to drive interactive document generation and agent interaction. Templates separate structure definition from content generation, making them both human and LLM-agent-friendly.
+
+## Template Structure
+
+```yaml
+template:
+  id: template-identifier
+  name: Human Readable Template Name
+  version: 1.0
+  output:
+    format: markdown
+    filename: default-path/to/{{filename}}.md
+    title: '{{variable}} Document Title'
+
+workflow:
+  mode: interactive
+  elicitation: advanced-elicitation
+
+sections:
+  - id: section-id
+    title: Section Title
+    instruction: |
+      Detailed instructions for the LLM on how to handle this section
+    # ... additional section properties
+```
+
+## Core Fields
+
+### Template Metadata
+
+- **id**: Unique identifier for the template
+- **name**: Human-readable name displayed in UI
+- **version**: Template version for tracking changes
+- **output.format**: Default "markdown" for document templates
+- **output.filename**: Default output file path (can include variables)
+- **output.title**: Document title (becomes H1 in markdown)
+
+### Workflow Configuration
+
+- **workflow.mode**: Default interaction mode ("interactive" or "yolo")
+- **workflow.elicitation**: Elicitation task to use ("advanced-elicitation")
+
+## Section Properties
+
+### Required Fields
+
+- **id**: Unique section identifier
+- **title**: Section heading text
+- **instruction**: Detailed guidance for LLM on handling this section
+
+### Optional Fields
+
+#### Content Control
+
+- **type**: Content type hint for structured sections
+- **template**: Fixed template text for section content
+- **item_template**: Template for repeatable items within section
+- **prefix**: Prefix for numbered items (e.g., "FR", "NFR")
+
+#### Behavior Flags
+
+- **elicit**: Boolean - Apply elicitation after section rendered
+- **repeatable**: Boolean - Section can be repeated multiple times
+- **condition**: String - Condition for including section (e.g., "has ui requirements")
+
+#### Agent Permissions
+
+- **owner**: String - Agent role that initially creates/populates this section
+- **editors**: Array - List of agent roles allowed to modify this section
+- **readonly**: Boolean - Section cannot be modified after initial creation
+
+#### Content Guidance
+
+- **examples**: Array of example content (not included in output)
+- **choices**: Object with choice options for common decisions
+- **placeholder**: Default placeholder text
+
+#### Structure
+
+- **sections**: Array of nested child sections
+
+## Supported Types
+
+### Content Types
+
+- **bullet-list**: Unordered list items
+- **numbered-list**: Ordered list with optional prefix
+- **paragraphs**: Free-form paragraph text
+- **table**: Structured table data
+- **code-block**: Code or configuration blocks
+- **template-text**: Fixed template with variable substitution
+- **mermaid**: Mermaid diagram with specified type and details
+
+### Special Types
+
+- **repeatable-container**: Container for multiple instances
+- **conditional-block**: Content shown based on conditions
+- **choice-selector**: Present choices to user
+
+## Advanced Features
+
+### Variable Substitution
+
+Use `{{variable_name}}` in titles, templates, and content:
+
+```yaml
+title: 'Epic {{epic_number}} {{epic_title}}'
+template: 'As a {{user_type}}, I want {{action}}, so that {{benefit}}.'
+```
+
+### Conditional Sections
+
+```yaml
+- id: ui-section
+  title: User Interface Design
+  condition: Project has UX/UI Requirements
+  instruction: Only include if project has UI components
+```
+
+### Choice Integration
+
+```yaml
+choices:
+  architecture: [Monolith, Microservices, Serverless]
+  testing: [Unit Only, Unit + Integration, Full Pyramid]
+```
+
+### Mermaid Diagrams
+
+```yaml
+- id: system-architecture
+  title: System Architecture Diagram
+  type: mermaid
+  instruction: Create a system architecture diagram showing key components and data flow
+  mermaid_type: flowchart
+  details: |
+    Show the following components:
+    - User interface layer
+    - API gateway
+    - Core services
+    - Database layer
+    - External integrations
+```
+
+**Supported mermaid_type values:**
+
+**Core Diagram Types:**
+
+- `flowchart` - Flow charts and process diagrams
+- `sequenceDiagram` - Sequence diagrams for interactions
+- `classDiagram` - Class relationship diagrams (UML)
+- `stateDiagram` - State transition diagrams
+- `erDiagram` - Entity relationship diagrams
+- `gantt` - Gantt charts for timelines
+- `pie` - Pie charts for data visualization
+
+**Advanced Diagram Types:**
+
+- `journey` - User journey maps
+- `mindmap` - Mindmaps for brainstorming
+- `timeline` - Timeline diagrams for chronological events
+- `quadrantChart` - Quadrant charts for data categorization
+- `xyChart` - XY charts (bar charts, line charts)
+- `sankey` - Sankey diagrams for flow visualization
+
+**Specialized Types:**
+
+- `c4Context` - C4 context diagrams (experimental)
+- `requirement` - Requirement diagrams
+- `packet` - Network packet diagrams
+- `block` - Block diagrams
+- `kanban` - Kanban boards
+
+### Agent Permissions Example
+
+```yaml
+- id: story-details
+  title: Story
+  owner: scrum-master
+  editors: [scrum-master]
+  readonly: false
+  sections:
+    - id: dev-notes
+      title: Dev Notes
+      owner: dev-agent
+      editors: [dev-agent]
+      readonly: false
+      instruction: Implementation notes and technical details
+    - id: qa-results
+      title: QA Results
+      owner: qa-agent
+      editors: [qa-agent]
+      readonly: true
+      instruction: Quality assurance test results
+```
+
+### Repeatable Sections
+
+```yaml
+- id: epic-details
+  title: Epic {{epic_number}} {{epic_title}}
+  repeatable: true
+  sections:
+    - id: story
+      title: Story {{epic_number}}.{{story_number}} {{story_title}}
+      repeatable: true
+      sections:
+        - id: criteria
+          title: Acceptance Criteria
+          type: numbered-list
+          item_template: '{{criterion_number}}: {{criteria}}'
+          repeatable: true
+```
+
+### Examples with Code Blocks
+
+````yaml
+examples:
+  - 'FR6: The system must authenticate users within 2 seconds'
+  - |
+    ```mermaid
+    sequenceDiagram
+        participant User
+        participant API
+        participant DB
+        User->>API: POST /login
+        API->>DB: Validate credentials
+        DB-->>API: User data
+        API-->>User: JWT token
+    ```
+  - |
+    **Architecture Decision Record**
+
+    **Decision**: Use PostgreSQL for primary database
+    **Rationale**: ACID compliance and JSON support needed
+    **Consequences**: Requires database management expertise
+````
+
+## Section Hierarchy
+
+Templates define the complete document structure starting with the first H2 - each level in is the next H#:
+
+```yaml
+sections:
+  - id: overview
+    title: Project Overview
+    sections:
+      - id: goals
+        title: Goals
+      - id: scope
+        title: Scope
+        sections:
+          - id: in-scope
+            title: In Scope
+          - id: out-scope
+            title: Out of Scope
+```
+
+## Processing Flow
+
+1. **Parse Template**: Load and validate YAML structure
+2. **Initialize Workflow**: Set interaction mode and elicitation
+3. **Process Sections**: Handle each section in order:
+   - Check conditions
+   - Apply instructions
+   - Generate content
+   - Handle choices and variables
+   - Apply elicitation if specified
+   - Process nested sections
+4. **Generate Output**: Create clean markdown document
+
+## Best Practices
+
+### Template Design
+
+- Keep instructions clear and specific
+- Use examples for complex content
+- Structure sections logically
+- Include all necessary guidance for LLM
+
+### Content Instructions
+
+- Be explicit about expected format
+- Include reasoning for decisions
+- Specify interaction patterns
+- Reference other documents when needed
+
+### Variable Naming
+
+- Use descriptive variable names
+- Follow consistent naming conventions
+- Document expected variable values
+
+### Examples Usage
+
+- Provide concrete examples for complex sections
+- Include both simple and complex cases
+- Use realistic project scenarios
+- Include code blocks and diagrams when helpful
+
+## Validation
+
+Templates should be validated for:
+
+- Valid YAML syntax
+- Required fields present
+- Consistent section IDs
+- Proper nesting structure
+- Valid variable references
+
+## Migration from Legacy
+
+When converting from markdown+frontmatter templates:
+
+1. Extract embedded `[[LLM:]]` instructions to `instruction` fields
+2. Convert `<<REPEAT>>` blocks to `repeatable: true` sections
+3. Extract `^^CONDITIONS^^` to `condition` fields
+4. Move `@{examples}` to `examples` arrays
+5. Convert `{{placeholders}}` to proper variable syntax
+
+This specification ensures templates are both human-readable and machine-processable while maintaining the flexibility needed for complex document generation.

package/expansion-packs/bmad-godot-game-dev/utils/workflow-management.md

@@ -0,0 +1,71 @@
+<!-- Powered by BMAD™ Core -->
+
+# Workflow Management
+
+Enables BMad orchestrator to manage and execute team workflows.
+
+## Dynamic Workflow Loading
+
+Read available workflows from current team configuration's `workflows` field. Each team bundle defines its own supported workflows.
+
+**Key Commands**:
+
+- `/workflows` - List workflows in current bundle or workflows folder
+- `/agent-list` - Show agents in current bundle
+
+## Workflow Commands
+
+### /workflows
+
+Lists available workflows with titles and descriptions.
+
+### /workflow-start {workflow-id}
+
+Starts workflow and transitions to first agent.
+
+### /workflow-status
+
+Shows current progress, completed artifacts, and next steps.
+
+### /workflow-resume
+
+Resumes workflow from last position. User can provide completed artifacts.
+
+### /workflow-next
+
+Shows next recommended agent and action.
+
+## Execution Flow
+
+1. **Starting**: Load definition → Identify first stage → Transition to agent → Guide artifact creation
+
+2. **Stage Transitions**: Mark complete → Check conditions → Load next agent → Pass artifacts
+
+3. **Artifact Tracking**: Track status, creator, timestamps in workflow_state
+
+4. **Interruption Handling**: Analyze provided artifacts → Determine position → Suggest next step
+
+## Context Passing
+
+When transitioning, pass:
+
+- Previous artifacts
+- Current workflow stage
+- Expected outputs
+- Decisions/constraints
+
+## Multi-Path Workflows
+
+Handle conditional paths by asking clarifying questions when needed.
+
+## Best Practices
+
+1. Show progress
+2. Explain transitions
+3. Preserve context
+4. Allow flexibility
+5. Track state
+
+## Agent Integration
+
+Agents should be workflow-aware: know active workflow, their role, access artifacts, understand expected outputs.

package/expansion-packs/bmad-godot-game-dev/workflows/game-dev-greenfield.yaml

@@ -0,0 +1,245 @@
+workflow:
+  id: godot-game-dev-greenfield
+  name: Godot Game Development - Greenfield Project
+  description: Specialized workflow for creating games from concept to implementation using Godot Engine 4.x with GDScript and C#. Guides teams through Godot-specific design patterns, node-based architecture, scene composition, signal systems, and resource management. Emphasizes Godot's unique features like AnimationTree, shader language, and built-in physics while maintaining 60+ FPS performance targets.
+  type: greenfield
+  project_types:
+    - godot-2d-game
+    - godot-3d-game
+    - godot-mobile-game
+    - godot-web-export
+    - godot-vr-game
+    - godot-multiplayer-game
+  sequence:
+    - agent: game-designer
+      creates: project-brief.md
+      optional_steps:
+        - godot_genre_analysis
+        - godot_asset_store_research
+        - target_platform_capabilities
+      notes: "Define game concept with Godot's strengths in mind (2D pixel-perfect, procedural generation, shader effects). Consider Godot's export targets and platform-specific features. SAVE OUTPUT: Copy final project-brief.md to your project's docs/design/ folder."
+
+    - agent: game-designer
+      creates: game-design-doc.md
+      requires: project-brief.md
+      optional_steps:
+        - godot_node_system_planning
+        - scene_hierarchy_design
+        - input_map_configuration
+      notes: "Create Godot-specific GDD defining node hierarchies, scene transitions, input actions, and resource preloading strategies. Map mechanics to Godot's built-in nodes (Area2D, CharacterBody2D, RigidBody2D). SAVE OUTPUT: Copy final game-design-doc.md to your project's docs/design/ folder."
+
+    - agent: game-designer
+      creates: level-design-doc.md (optional)
+      requires: game-design-doc.md
+      optional_steps:
+        - tilemap_system_design
+        - scene_instancing_strategy
+        - godot_room_system_planning
+      notes: "OPTIONAL BUT RECOMMENDED: Design levels using Godot's TileMap, GridMap, or modular scene approach. Define scene instancing patterns, resource groups, and level streaming strategy. SAVE OUTPUT: Copy final level-design-doc.md to your project's docs/design/ folder."
+
+    - agent: game-pm
+      creates: prd.md
+      requires:
+        - project-brief.md
+        - game-design-doc.md
+      notes: "Creates PRD from project brief using game-prd-tmpl. SAVE OUTPUT: Copy final prd.md to your project's docs/ folder."
+
+    - agent: game-architect
+      creates: architecture.md
+      requires:
+        - game-design-doc.md
+        - prd.md
+      optional_steps:
+        - godot_autoload_architecture
+        - signal_bus_design
+        - resource_loading_strategy
+        - gdextension_evaluation
+      notes: "Design Godot-specific architecture: autoload singletons, signal bus patterns, scene tree organization, resource loading (preload vs load), and GDScript/C#/GDExtension strategy. Define custom nodes, resources, and editor tools. SAVE OUTPUT: Copy final architecture.md to your project's docs/architecture/ folder."
+
+    - agent: game-pm
+      updates: prd.md (if needed)
+      requires: architecture.md
+      condition: architecture_suggests_prd_changes
+      notes: "If game-architect suggests story changes, update PRD and re-export the complete unredacted prd.md to docs/ folder."
+
+    - agent: game-po
+      validates: all_artifacts
+      uses: po-master-checklist
+      notes: "Validates all documents for consistency and completeness. May require updates to any document."
+
+    - agent: various
+      updates: any_flagged_documents
+      condition: po_checklist_issues
+      notes: "If game-po finds issues, return to relevant agent to fix and re-export updated documents to docs/ folder."
+
+    - project_setup_guidance:
+        action: initialize_godot_project
+        notes: "Create Godot 4.x project with proper folder structure: scenes/, scripts/, resources/, shaders/, addons/. Configure project settings: rendering (Forward+/Mobile), physics tick rate, input map, autoloads. Install GUT for GDScript testing, configure export presets for target platforms."
+
+    - agent: game-po
+      action: shard_documents
+      creates: sharded_docs
+      requires: all_artifacts_in_project
+      notes: |
+        Shard documents for IDE development:
+        - Option A: Use PO agent to shard: @game-po then ask to shard docs/prd.md
+        - Option B: Manual: Drag shard-doc task + docs/prd.md into chat
+        - Creates docs/prd/ and docs/architecture/ folders with sharded content
+
+    - agent: game-sm
+      action: create_story
+      creates: story.md
+      requires: sharded_docs
+      repeats: for_each_epic
+      notes: |
+        Story creation cycle:
+        - SM Agent (New Chat): @game-sm → *create
+        - Creates next story from sharded docs
+        - Story starts in "Draft" status
+
+    - agent: game-qa
+      action: test_design
+      updates: story.md
+      requires: story.md
+      optional: true
+      condition: user_wants_test_design
+      notes: |
+        OPTIONAL: Design tests for draft story        
+        - Analyze story for possible risks
+        - Create tests to mitigate those risks
+
+    - agent: game-po
+      action: review_draft_story
+      updates: story.md
+      requires: story.md
+      optional: true
+      condition: user_wants_story_review
+      notes: |
+        OPTIONAL: Review and approve draft story        
+        - Review story completeness and alignment
+        - Update story status: Draft → Approved
+
+    - agent: game-dev
+      action: implement_story
+      creates: implementation_files
+      requires: story.md
+      notes: |
+        Dev Agent (New Chat): @game-dev
+        - Implements approved story
+        - Updates File List with all changes
+        - Marks story as "Review" when complete
+
+    - agent: game-qa
+      action: review_implementation
+      updates: implementation_files
+      requires: implementation_files
+      optional: true
+      notes: |
+        OPTIONAL: QA Agent (New Chat): @qa → review-story
+        - Senior dev review with refactoring ability
+        - Fixes small issues directly
+        - Leaves checklist for remaining items
+        - Updates story status (Review → Done or stays Review)
+
+    - agent: game-dev
+      action: address_qa_feedback
+      updates: implementation_files
+      condition: qa_left_unchecked_items
+      notes: |
+        If QA left unchecked items:
+        - Dev Agent (New Chat): Address remaining items
+        - Return to QA for final approval
+
+    - repeat_development_cycle: ""
+      action: continue_for_all_stories
+      notes: |
+        Repeat story cycle (SM → Dev → QA) for all epic stories
+        Continue until all stories in PRD are complete
+
+    - agent: game-po
+      action: epic_retrospective
+      creates: epic-retrospective.md
+      condition: epic_complete
+      optional: true
+      notes: |
+        OPTIONAL: After epic completion
+        - NOTE: epic-retrospective task coming soon
+        - Validate epic was completed correctly
+        - Document learnings and improvements
+
+    - workflow_end: ""
+      action: project_complete
+      notes: |
+        All stories implemented and reviewed!
+        Project development phase complete.
+
+        Reference: {root}/data/bmad-kb.md#IDE Development Workflow
+
+  flow_diagram: |
+    ```mermaid
+    graph TD
+        A[Start: Greenfield Project] --> B[game-designer: project-brief.md]
+        B --> C[game-pm: prd.md]
+        C --> D[game-architect: architecture.md]
+        D --> E{Architecture suggests PRD changes?}
+        E -->|Yes| F[game-pm: update prd.md]
+        E-->|No| G[game-po: validate all artifacts]
+        F--> G
+        G --> I{game-po finds issues?}
+        I -->|Yes| J[Return to relevant agent for fixes]
+        I -->|No| K[game-po: shard documents]
+        J --> H
+
+        K --> L[game-sm: create story]
+        L --> M{Review draft story?}
+        M -->|Yes| N[game-po: review & approve story]
+        M -->|No| O[game-dev: implement story]
+        N --> O
+        O --> P{QA review?}
+        P -->|Yes| Q[game-qa: review implementation]
+        P -->|No| R{More stories?}
+        Q --> S{QA found issues?}
+        S -->|Yes| T[game-dev: address QA feedback]
+        S -->|No| R
+        T --> Q
+        R -->|Yes| L
+        R -->|No| U{Epic retrospective?}
+        U -->|Yes| V[game-po: epic retrospective]
+        U -->|No| W[Project Complete]
+        V --> W
+
+        B -.-> B1[Optional: brainstorming]
+        B -.-> B2[Optional: market research]
+        C -.-> C1[Optional: user research]
+        F -.-> D1[Optional: technical research]
+
+        style W fill:#90EE90
+        style K fill:#ADD8E6
+        style L fill:#ADD8E6
+        style O fill:#ADD8E6
+        style B fill:#FFE4B5
+        style C fill:#FFE4B5
+        style D fill:#FFE4B5
+        style E fill:#FFE4B5
+        style N fill:#F0E68C
+        style Q fill:#F0E68C
+        style V fill:#F0E68C
+    ```
+
+  decision_guidance:
+    when_to_use:
+      - Building complex Godot games with multiple scenes
+      - Implementing networked multiplayer with Godot's high-level API
+      - Complex feature requirements
+      - Need comprehensive documentation
+      - Long-term maintenance expected
+
+  handoff_prompts:
+    analyst_to_pm: "Project brief is complete. Save it as docs/project-brief.md in your project, then create the PRD."
+    pm_to_ux: "PRD is ready. Save it as docs/prd.md in your project, then create the UI/UX specification."
+    ux_to_architect: "UI/UX spec complete. Save it as docs/front-end-spec.md in your project, then create the fullstack architecture."
+    architect_review: "Architecture complete. Save it as docs/architecture.md. Do you suggest any changes to the PRD stories or need new stories added?"
+    architect_to_pm: "Please update the PRD with the suggested story changes, then re-export the complete prd.md to docs/."
+    updated_to_po: "All documents ready in docs/ folder. Please validate all artifacts for consistency."
+    po_issues: "PO found issues with [document]. Please return to [agent] to fix and re-save the updated document."
+    complete: "All planning artifacts validated and saved in docs/ folder. Move to IDE environment to begin development."