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

package/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-01-discover.md

@@ -0,0 +1,201 @@
+# Step 1: Context Discovery & Initialization
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- NEVER generate content without user input
+- ALWAYS treat this as collaborative discovery between technical peers
+- YOU ARE A FACILITATOR, not a content generator
+- FOCUS on discovering existing project context and technology stack
+- IDENTIFY critical implementation rules that AI agents need
+- ABSOLUTELY NO TIME ESTIMATES
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Read existing project files to understand current context
+- Initialize document and update frontmatter
+- FORBIDDEN to load next step until discovery is complete
+
+## CONTEXT BOUNDARIES:
+
+- Variables from workflow.md are available in memory
+- Focus on existing project files and architecture decisions
+- Look for patterns, conventions, and unique requirements
+- Prioritize rules that prevent implementation mistakes
+
+## YOUR TASK:
+
+Discover the project's game engine, technology stack, existing patterns, and critical implementation rules that AI agents must follow when writing game code.
+
+## DISCOVERY SEQUENCE:
+
+### 1. Check for Existing Project Context
+
+First, check if project context already exists:
+
+- Look for file at `{output_folder}/project-context.md`
+- If exists: Read complete file to understand existing rules
+- Present to user: "Found existing project context with {number_of_sections} sections. Would you like to update this or create a new one?"
+
+### 2. Discover Game Engine & Technology Stack
+
+Load and analyze project files to identify technologies:
+
+**Architecture Document:**
+
+- Look for `{output_folder}/game-architecture.md` or `{planning_artifacts}/architecture.md`
+- Extract engine choice with specific version (Unity, Unreal, Godot, custom)
+- Note architectural decisions that affect implementation
+
+**Engine-Specific Files:**
+
+- Unity: Check for `ProjectSettings/ProjectVersion.txt`, `Packages/manifest.json`
+- Unreal: Check for `.uproject` files, `Config/DefaultEngine.ini`
+- Godot: Check for `project.godot`, `export_presets.cfg`
+- Custom: Check for engine config files, build scripts
+
+**Package/Dependency Files:**
+
+- Unity: `Packages/manifest.json`, NuGet packages
+- Unreal: `.Build.cs` files, plugin configs
+- Godot: `addons/` directory, GDExtension configs
+- Web-based: `package.json`, `requirements.txt`
+
+**Configuration Files:**
+
+- Build tool configs
+- Linting and formatting configs
+- Testing configurations
+- CI/CD pipeline configs
+
+### 3. Identify Existing Code Patterns
+
+Search through existing codebase for patterns:
+
+**Naming Conventions:**
+
+- Script/class naming patterns
+- Asset naming conventions
+- Scene/level naming patterns
+- Test file naming patterns
+
+**Code Organization:**
+
+- How components/scripts are structured
+- Where utilities and helpers are placed
+- How systems are organized
+- Folder hierarchy patterns
+
+**Engine-Specific Patterns:**
+
+- Unity: MonoBehaviour patterns, ScriptableObject usage, serialization rules
+- Unreal: Actor/Component patterns, Blueprint integration, UE macros
+- Godot: Node patterns, signal usage, autoload patterns
+
+### 4. Extract Critical Implementation Rules
+
+Look for rules that AI agents might miss:
+
+**Engine-Specific Rules:**
+
+- Unity: Assembly definitions, Unity lifecycle methods, coroutine patterns
+- Unreal: UPROPERTY/UFUNCTION usage, garbage collection rules, tick patterns
+- Godot: `_ready` vs `_enter_tree`, node ownership, scene instancing
+
+**Performance Rules:**
+
+- Frame budget constraints
+- Memory allocation patterns
+- Hot path optimization requirements
+- Object pooling patterns
+
+**Platform-Specific Rules:**
+
+- Target platform constraints
+- Input handling conventions
+- Platform-specific code patterns
+- Build configuration rules
+
+**Testing Rules:**
+
+- Test structure requirements
+- Mock usage conventions
+- Integration vs unit test boundaries
+- Play mode vs edit mode testing
+
+### 5. Initialize Project Context Document
+
+Based on discovery, create or update the context document:
+
+#### A. Fresh Document Setup (if no existing context)
+
+Copy template from `{installed_path}/project-context-template.md` to `{output_folder}/project-context.md`
+Initialize frontmatter with:
+
+```yaml
+---
+project_name: '{{project_name}}'
+user_name: '{{user_name}}'
+date: '{{date}}'
+sections_completed: ['technology_stack']
+existing_patterns_found: { { number_of_patterns_discovered } }
+---
+```
+
+#### B. Existing Document Update
+
+Load existing context and prepare for updates
+Set frontmatter `sections_completed` to track what will be updated
+
+### 6. Present Discovery Summary
+
+Report findings to user:
+
+"Welcome {{user_name}}! I've analyzed your game project for {{project_name}} to discover the context that AI agents need.
+
+**Game Engine & Stack Discovered:**
+{{engine_and_version}}
+{{list_of_technologies_with_versions}}
+
+**Existing Patterns Found:**
+
+- {{number_of_patterns}} implementation patterns
+- {{number_of_conventions}} coding conventions
+- {{number_of_rules}} critical rules
+
+**Key Areas for Context Rules:**
+
+- {{area_1}} (e.g., Engine lifecycle and patterns)
+- {{area_2}} (e.g., Performance and optimization)
+- {{area_3}} (e.g., Platform-specific requirements)
+
+{if_existing_context}
+**Existing Context:** Found {{sections}} sections already defined. We can update or add to these.
+{/if_existing_context}
+
+Ready to create/update your project context. This will help AI agents implement game code consistently with your project's standards.
+
+[C] Continue to context generation"
+
+## SUCCESS METRICS:
+
+- Existing project context properly detected and handled
+- Game engine and technology stack accurately identified with versions
+- Critical implementation patterns discovered
+- Project context document properly initialized
+- Discovery findings clearly presented to user
+- User ready to proceed with context generation
+
+## FAILURE MODES:
+
+- Not checking for existing project context before creating new one
+- Missing critical engine versions or configurations
+- Overlooking important coding patterns or conventions
+- Not initializing frontmatter properly
+- Not presenting clear discovery summary to user
+
+## NEXT STEP:
+
+After user selects [C] to continue, load `./step-02-generate.md` to collaboratively generate the specific project context rules.
+
+Remember: Do NOT proceed to step-02 until user explicitly selects [C] from the menu and discovery is confirmed!

package/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-02-generate.md

@@ -0,0 +1,373 @@
+# Step 2: Context Rules Generation
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- NEVER generate content without user input
+- ALWAYS treat this as collaborative discovery between technical peers
+- YOU ARE A FACILITATOR, not a content generator
+- FOCUS on unobvious rules that AI agents need to be reminded of
+- KEEP CONTENT LEAN - optimize for LLM context efficiency
+- ABSOLUTELY NO TIME ESTIMATES
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Focus on specific, actionable rules rather than general advice
+- Present A/P/C menu after each major rule category
+- ONLY save when user chooses C (Continue)
+- Update frontmatter with completed sections
+- FORBIDDEN to load next step until all sections are complete
+
+## COLLABORATION MENUS (A/P/C):
+
+This step will generate content and present choices for each rule category:
+
+- **A (Advanced Elicitation)**: Use discovery protocols to explore nuanced implementation rules
+- **P (Party Mode)**: Bring multiple perspectives to identify critical edge cases
+- **C (Continue)**: Save the current rules and proceed to next category
+
+## PROTOCOL INTEGRATION:
+
+- When 'A' selected: Execute {project-root}/_bmad/core/tasks/advanced-elicitation.xml
+- When 'P' selected: Execute {project-root}/_bmad/core/workflows/party-mode
+- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
+- User accepts/rejects protocol changes before proceeding
+
+## CONTEXT BOUNDARIES:
+
+- Discovery results from step-1 are available
+- Game engine and existing patterns are identified
+- Focus on rules that prevent implementation mistakes
+- Prioritize unobvious details that AI agents might miss
+
+## YOUR TASK:
+
+Collaboratively generate specific, critical rules that AI agents must follow when implementing game code in this project.
+
+## CONTEXT GENERATION SEQUENCE:
+
+### 1. Technology Stack & Versions
+
+Document the exact technology stack from discovery:
+
+**Core Technologies:**
+Based on user skill level, present findings:
+
+**Expert Mode:**
+"Technology stack from your architecture and project files:
+{{exact_technologies_with_versions}}
+
+Any critical version constraints I should document for agents?"
+
+**Intermediate Mode:**
+"I found your technology stack:
+
+**Game Engine:**
+{{engine_with_version}}
+
+**Key Dependencies:**
+{{important_dependencies_with_versions}}
+
+Are there any version constraints or compatibility notes agents should know about?"
+
+**Beginner Mode:**
+"Here are the technologies you're using:
+
+**Game Engine:**
+{{friendly_description_of_engine}}
+
+**Important Notes:**
+{{key_things_agents_need_to_know_about_versions}}
+
+Should I document any special version rules or compatibility requirements?"
+
+### 2. Engine-Specific Rules
+
+Focus on unobvious engine patterns agents might miss:
+
+**Unity Rules (if applicable):**
+"Based on your Unity project, I notice some specific patterns:
+
+**Lifecycle Rules:**
+{{unity_lifecycle_patterns}}
+
+**Serialization Rules:**
+{{serialization_requirements}}
+
+**Assembly Definitions:**
+{{assembly_definition_rules}}
+
+**Coroutine/Async Patterns:**
+{{async_patterns}}
+
+Are these patterns correct? Any other Unity-specific rules agents should follow?"
+
+**Unreal Rules (if applicable):**
+"Based on your Unreal project, I notice some specific patterns:
+
+**UPROPERTY/UFUNCTION Rules:**
+{{macro_usage_patterns}}
+
+**Blueprint Integration:**
+{{blueprint_rules}}
+
+**Garbage Collection:**
+{{gc_patterns}}
+
+**Tick Patterns:**
+{{tick_optimization_rules}}
+
+Are these patterns correct? Any other Unreal-specific rules agents should follow?"
+
+**Godot Rules (if applicable):**
+"Based on your Godot project, I notice some specific patterns:
+
+**Node Lifecycle:**
+{{node_lifecycle_patterns}}
+
+**Signal Usage:**
+{{signal_conventions}}
+
+**Scene Instancing:**
+{{scene_patterns}}
+
+**Autoload Patterns:**
+{{autoload_rules}}
+
+Are these patterns correct? Any other Godot-specific rules agents should follow?"
+
+### 3. Performance Rules
+
+Document performance-critical patterns:
+
+**Frame Budget Rules:**
+"Your game has these performance requirements:
+
+**Target Frame Rate:**
+{{target_fps}}
+
+**Frame Budget:**
+{{milliseconds_per_frame}}
+
+**Critical Systems:**
+{{systems_that_must_meet_budget}}
+
+**Hot Path Rules:**
+{{hot_path_patterns}}
+
+Any other performance rules agents must follow?"
+
+**Memory Management:**
+"Memory patterns for your project:
+
+**Allocation Rules:**
+{{allocation_patterns}}
+
+**Pooling Requirements:**
+{{object_pooling_rules}}
+
+**Asset Loading:**
+{{asset_loading_patterns}}
+
+Are there memory constraints agents should know about?"
+
+### 4. Code Organization Rules
+
+Document project structure and organization:
+
+**Folder Structure:**
+"Your project organization:
+
+**Script Organization:**
+{{script_folder_structure}}
+
+**Asset Organization:**
+{{asset_folder_patterns}}
+
+**Scene/Level Organization:**
+{{scene_organization}}
+
+Any organization rules agents must follow?"
+
+**Naming Conventions:**
+"Your naming patterns:
+
+**Script/Class Names:**
+{{class_naming_patterns}}
+
+**Asset Names:**
+{{asset_naming_patterns}}
+
+**Variable/Method Names:**
+{{variable_naming_patterns}}
+
+Any other naming rules?"
+
+### 5. Testing Rules
+
+Focus on testing patterns that ensure consistency:
+
+**Test Structure Rules:**
+"Your testing setup shows these patterns:
+
+**Test Organization:**
+{{test_file_organization}}
+
+**Test Categories:**
+{{unit_vs_integration_boundaries}}
+
+**Mocking Patterns:**
+{{mock_usage_conventions}}
+
+**Play Mode Testing:**
+{{play_mode_test_patterns}}
+
+Are there testing rules agents should always follow?"
+
+### 6. Platform & Build Rules
+
+Document platform-specific requirements:
+
+**Target Platforms:**
+"Your platform configuration:
+
+**Primary Platform:**
+{{primary_platform}}
+
+**Platform-Specific Code:**
+{{platform_conditional_patterns}}
+
+**Build Configurations:**
+{{build_config_rules}}
+
+**Input Handling:**
+{{input_abstraction_patterns}}
+
+Any platform rules agents must know?"
+
+### 7. Critical Don't-Miss Rules
+
+Identify rules that prevent common mistakes:
+
+**Anti-Patterns to Avoid:**
+"Based on your codebase, here are critical things agents must NOT do:
+
+{{critical_anti_patterns_with_examples}}
+
+**Edge Cases:**
+{{specific_edge_cases_agents_should_handle}}
+
+**Common Gotchas:**
+{{engine_specific_gotchas}}
+
+**Performance Traps:**
+{{performance_patterns_to_avoid}}
+
+Are there other 'gotchas' agents should know about?"
+
+### 8. Generate Context Content
+
+For each category, prepare lean content for the project context file:
+
+#### Content Structure:
+
+```markdown
+## Technology Stack & Versions
+
+{{concise_technology_list_with_exact_versions}}
+
+## Critical Implementation Rules
+
+### Engine-Specific Rules
+
+{{bullet_points_of_engine_rules}}
+
+### Performance Rules
+
+{{bullet_points_of_performance_requirements}}
+
+### Code Organization Rules
+
+{{bullet_points_of_organization_patterns}}
+
+### Testing Rules
+
+{{bullet_points_of_testing_requirements}}
+
+### Platform & Build Rules
+
+{{bullet_points_of_platform_requirements}}
+
+### Critical Don't-Miss Rules
+
+{{bullet_points_of_anti_patterns_and_gotchas}}
+```
+
+### 9. Present Content and Menu
+
+After each category, show the generated rules and present choices:
+
+"I've drafted the {{category_name}} rules for your project context.
+
+**Here's what I'll add:**
+
+[Show the complete markdown content for this category]
+
+**What would you like to do?**
+[A] Advanced Elicitation - Explore nuanced rules for this category
+[P] Party Mode - Review from different implementation perspectives
+[C] Continue - Save these rules and move to next category"
+
+### 10. Handle Menu Selection
+
+#### If 'A' (Advanced Elicitation):
+
+- Execute advanced-elicitation.xml with current category rules
+- Process enhanced rules that come back
+- Ask user: "Accept these enhanced rules for {{category}}? (y/n)"
+- If yes: Update content, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'P' (Party Mode):
+
+- Execute party-mode workflow with category rules context
+- Process collaborative insights on implementation patterns
+- Ask user: "Accept these changes to {{category}} rules? (y/n)"
+- If yes: Update content, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'C' (Continue):
+
+- Save the current category content to project context file
+- Update frontmatter: `sections_completed: [...]`
+- Proceed to next category or step-03 if complete
+
+## APPEND TO PROJECT CONTEXT:
+
+When user selects 'C' for a category, append the content directly to `{output_folder}/project-context.md` using the structure from step 8.
+
+## SUCCESS METRICS:
+
+- All critical technology versions accurately documented
+- Engine-specific rules cover unobvious patterns
+- Performance rules capture project-specific requirements
+- Code organization rules maintain project standards
+- Testing rules ensure consistent test quality
+- Platform rules prevent cross-platform issues
+- Content is lean and optimized for LLM context
+- A/P/C menu presented and handled correctly for each category
+
+## FAILURE MODES:
+
+- Including obvious rules that agents already know
+- Making content too verbose for LLM context efficiency
+- Missing critical anti-patterns or edge cases
+- Not getting user validation for each rule category
+- Not documenting exact versions and configurations
+- Not presenting A/P/C menu after content generation
+
+## NEXT STEP:
+
+After completing all rule categories and user selects 'C' for the final category, load `./step-03-complete.md` to finalize the project context file.
+
+Remember: Do NOT proceed to step-03 until all categories are complete and user explicitly selects 'C' for each!