From e39aa33eea15ec3c9c7c6776fa9d4b8e8971501b Mon Sep 17 00:00:00 2001 From: sjennings Date: Thu, 18 Dec 2025 02:14:18 -0600 Subject: [PATCH] fix(bmgd): add workflow status update to game-architecture completion (#1161) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(bmgd): add workflow status update to game-architecture completion The game-architecture workflow was not updating the bmgd-workflow-status.yaml file on completion, unlike other BMGD workflows (narrative, brainstorm-game). Changes: - Add step 4 "Update Workflow Status" to update create-architecture status - Renumber subsequent steps (5-8 → 6-9) - Add success metric for workflow status update - Add failure condition for missing status update * feat(bmgd): add generate-project-context workflow for game development Adds a new workflow to create optimized project-context.md files for AI agent consistency in game development projects. New workflow files: - workflow.md: Main workflow entry point - project-context-template.md: Template for context file - steps/step-01-discover.md: Context discovery & initialization - steps/step-02-generate.md: Rules generation with A/P/C menus - steps/step-03-complete.md: Finalization & optimization Integration: - Added generate-project-context trigger to game-architect agent menu - Added project context creation option to game-architecture completion step - Renumbered steps 6-9 → 7-10 to accommodate new step 6 Adapted from BMM generate-project-context with game-specific: - Engine patterns (Unity, Unreal, Godot) - Performance and frame budget rules - Platform-specific requirements - Game testing patterns --------- Co-authored-by: Scott Jennings Co-authored-by: Brian --- .../bmgd/agents/game-architect.agent.yaml | 4 + .../steps/step-09-complete.md | 66 +++- .../project-context-template.md | 20 + .../steps/step-01-discover.md | 201 ++++++++++ .../steps/step-02-generate.md | 373 ++++++++++++++++++ .../steps/step-03-complete.md | 279 +++++++++++++ .../generate-project-context/workflow.md | 48 +++ 7 files changed, 985 insertions(+), 6 deletions(-) create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/project-context-template.md create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-01-discover.md create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-02-generate.md create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-03-complete.md create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/workflow.md diff --git a/src/modules/bmgd/agents/game-architect.agent.yaml b/src/modules/bmgd/agents/game-architect.agent.yaml index 8e218901..3b28024d 100644 --- a/src/modules/bmgd/agents/game-architect.agent.yaml +++ b/src/modules/bmgd/agents/game-architect.agent.yaml @@ -33,6 +33,10 @@ agent: exec: "{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.md" description: Produce a Scale Adaptive Game Architecture + - trigger: generate-project-context + exec: "{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context/workflow.md" + description: Create optimized project-context.md for AI agent consistency + - trigger: correct-course workflow: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml" description: Course Correction Analysis (when implementation is off-track) diff --git a/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-09-complete.md b/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-09-complete.md index 7e71161e..51f022e3 100644 --- a/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-09-complete.md +++ b/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-09-complete.md @@ -12,6 +12,7 @@ outputFile: '{output_folder}/game-architecture.md' # Handoff References epicWorkflow: '{project-root}/_bmad/bmgd/workflows/4-production/epic-workflow/workflow.yaml' +projectContextWorkflow: '{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context/workflow.md' --- # Step 9: Completion @@ -131,7 +132,17 @@ platform: '{{platform}}' --- ```` -### 4. Present Completion Summary +### 4. Update Workflow Status + +**If not in standalone mode:** + +Load `{output_folder}/bmgd-workflow-status.yaml` and: + +- Update `create-architecture` status to the output file path +- Preserve all comments and structure +- Determine next workflow in sequence + +### 5. Present Completion Summary "**Architecture Complete!** @@ -158,9 +169,50 @@ platform: '{{platform}}' **Document saved to:** `{outputFile}` -Do you want to review or adjust anything before we finalize?" +Do you want to review or adjust anything before we finalize? -### 5. Handle Review Requests +**Optional Enhancement: Project Context File** + +Would you like to create a `project-context.md` file? This is a concise, optimized guide for AI agents that captures: + +- Critical engine-specific rules they might miss +- Specific patterns and conventions for your game project +- Performance and optimization requirements +- Anti-patterns and edge cases to avoid + +{if_existing_project_context} +I noticed you already have a project context file. Would you like to update it with your new architectural decisions? +{else} +This file helps ensure AI agents implement game code consistently with your project's unique requirements and patterns. +{/if_existing_project_context} + +**Create/Update project context?** [Y/N]" + +### 6. Handle Project Context Creation Choice + +If user responds 'Y' or 'yes' to creating/updating project context: + +"Excellent choice! Let me launch the Generate Project Context workflow to create a comprehensive guide for AI agents. + +This will help ensure consistent implementation by capturing: + +- Engine-specific patterns and rules +- Performance and optimization conventions from your architecture +- Testing and quality standards +- Anti-patterns to avoid + +The workflow will collaborate with you to create an optimized `project-context.md` file that AI agents will read before implementing any game code." + +**Execute the Generate Project Context workflow:** + +- Load and execute: `{projectContextWorkflow}` +- The workflow will handle discovery, generation, and completion of the project context file +- After completion, return here for final handoff + +If user responds 'N' or 'no': +"Understood! Your architecture is complete and ready for implementation. You can always create a project context file later using the Generate Project Context workflow if needed." + +### 7. Handle Review Requests **If user wants to review:** @@ -179,7 +231,7 @@ Or type 'all' to see the complete document." **Show requested section and allow edits.** -### 6. Present Next Steps Menu +### 8. Present Next Steps Menu **After user confirms completion:** @@ -204,7 +256,7 @@ Or type 'all' to see the complete document." 2. Proceed to Epic creation workflow 3. Exit workflow" -### 7. Handle User Selection +### 9. Handle User Selection Based on user choice: @@ -224,7 +276,7 @@ Based on user choice: - Confirm document is saved and complete - Exit workflow gracefully -### 8. Provide Handoff Guidance +### 10. Provide Handoff Guidance **For Epic Creation handoff:** @@ -270,6 +322,7 @@ This is the final step. Ensure: - Development setup is complete - Document status updated to 'complete' - Frontmatter shows all steps completed +- Workflow status updated (if tracking) - User has clear next steps - Document saved and ready for AI agent consumption @@ -278,6 +331,7 @@ This is the final step. Ensure: - Missing executive summary - Incomplete development setup - Frontmatter not updated +- Status not updated when tracking - No clear next steps provided - User left without actionable guidance diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/project-context-template.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/project-context-template.md new file mode 100644 index 00000000..b9e4d3bc --- /dev/null +++ b/src/modules/bmgd/workflows/3-technical/generate-project-context/project-context-template.md @@ -0,0 +1,20 @@ +--- +project_name: '{{project_name}}' +user_name: '{{user_name}}' +date: '{{date}}' +sections_completed: [] +--- + +# Project Context for AI Agents + +_This file contains critical rules and patterns that AI agents must follow when implementing game code in this project. Focus on unobvious details that agents might otherwise miss._ + +--- + +## Technology Stack & Versions + +_Documented after discovery phase_ + +## Critical Implementation Rules + +_Documented after discovery phase_ diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-01-discover.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-01-discover.md new file mode 100644 index 00000000..a92db901 --- /dev/null +++ b/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 `{output_folder}/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! diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-02-generate.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-02-generate.md new file mode 100644 index 00000000..75e978cb --- /dev/null +++ b/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! diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-03-complete.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-03-complete.md new file mode 100644 index 00000000..e87e1382 --- /dev/null +++ b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-03-complete.md @@ -0,0 +1,279 @@ +# Step 3: Context Completion & Finalization + +## MANDATORY EXECUTION RULES (READ FIRST): + +- NEVER generate content without user input +- ALWAYS treat this as collaborative completion between technical peers +- YOU ARE A FACILITATOR, not a content generator +- FOCUS on finalizing a lean, LLM-optimized project context +- ENSURE all critical rules are captured and actionable +- ABSOLUTELY NO TIME ESTIMATES + +## EXECUTION PROTOCOLS: + +- Show your analysis before taking any action +- Review and optimize content for LLM context efficiency +- Update frontmatter with completion status +- NO MORE STEPS - this is the final step + +## CONTEXT BOUNDARIES: + +- All rule categories from step-2 are complete +- Technology stack and versions are documented +- Focus on final review, optimization, and completion +- Ensure the context file is ready for AI agent consumption + +## YOUR TASK: + +Complete the project context file, optimize it for LLM efficiency, and provide guidance for usage and maintenance. + +## COMPLETION SEQUENCE: + +### 1. Review Complete Context File + +Read the entire project context file and analyze: + +**Content Analysis:** + +- Total length and readability for LLMs +- Clarity and specificity of rules +- Coverage of all critical areas +- Actionability of each rule + +**Structure Analysis:** + +- Logical organization of sections +- Consistency of formatting +- Absence of redundant or obvious information +- Optimization for quick scanning + +### 2. Optimize for LLM Context + +Ensure the file is lean and efficient: + +**Content Optimization:** + +- Remove any redundant rules or obvious information +- Combine related rules into concise bullet points +- Use specific, actionable language +- Ensure each rule provides unique value + +**Formatting Optimization:** + +- Use consistent markdown formatting +- Implement clear section hierarchy +- Ensure scannability with strategic use of bolding +- Maintain readability while maximizing information density + +### 3. Final Content Structure + +Ensure the final structure follows this optimized format: + +```markdown +# Project Context for AI Agents + +_This file contains critical rules and patterns that AI agents must follow when implementing game code in this project. Focus on unobvious details that agents might otherwise miss._ + +--- + +## Technology Stack & Versions + +{{concise_technology_list}} + +## Critical Implementation Rules + +### Engine-Specific Rules + +{{engine_rules}} + +### Performance Rules + +{{performance_requirements}} + +### Code Organization Rules + +{{organization_patterns}} + +### Testing Rules + +{{testing_requirements}} + +### Platform & Build Rules + +{{platform_requirements}} + +### Critical Don't-Miss Rules + +{{anti_patterns_and_gotchas}} + +--- + +## Usage Guidelines + +**For AI Agents:** + +- Read this file before implementing any game code +- Follow ALL rules exactly as documented +- When in doubt, prefer the more restrictive option +- Update this file if new patterns emerge + +**For Humans:** + +- Keep this file lean and focused on agent needs +- Update when technology stack changes +- Review quarterly for outdated rules +- Remove rules that become obvious over time + +Last Updated: {{date}} +``` + +### 4. Present Completion Summary + +Based on user skill level, present the completion: + +**Expert Mode:** +"Project context complete. Optimized for LLM consumption with {{rule_count}} critical rules across {{section_count}} sections. + +File saved to: `{output_folder}/project-context.md` + +Ready for AI agent integration." + +**Intermediate Mode:** +"Your project context is complete and optimized for AI agents! + +**What we created:** + +- {{rule_count}} critical implementation rules +- Technology stack with exact versions +- Engine-specific patterns and conventions +- Performance and optimization guidelines +- Testing and platform requirements + +**Key benefits:** + +- AI agents will implement consistently with your standards +- Reduced context switching and implementation errors +- Clear guidance for unobvious project requirements + +**Next steps:** + +- AI agents should read this file before implementing +- Update as your project evolves +- Review periodically for optimization" + +**Beginner Mode:** +"Excellent! Your project context guide is ready! + +**What this does:** +Think of this as a 'rules of the road' guide for AI agents working on your game. It ensures they all follow the same patterns and avoid common mistakes. + +**What's included:** + +- Exact engine and technology versions to use +- Critical coding rules they might miss +- Performance and optimization standards +- Testing and platform requirements + +**How AI agents use it:** +They read this file before writing any code, ensuring everything they create follows your project's standards perfectly. + +Your project context is saved and ready to help agents implement consistently!" + +### 5. Final File Updates + +Update the project context file with completion information: + +**Frontmatter Update:** + +```yaml +--- +project_name: '{{project_name}}' +user_name: '{{user_name}}' +date: '{{date}}' +sections_completed: + ['technology_stack', 'engine_rules', 'performance_rules', 'organization_rules', 'testing_rules', 'platform_rules', 'anti_patterns'] +status: 'complete' +rule_count: { { total_rules } } +optimized_for_llm: true +--- +``` + +**Add Usage Section:** +Append the usage guidelines from step 3 to complete the document. + +### 6. Completion Validation + +Final checks before completion: + +**Content Validation:** + +- All critical technology versions documented +- Engine-specific rules are specific and actionable +- Performance rules capture project requirements +- Code organization rules maintain standards +- Testing rules ensure consistency +- Platform rules prevent cross-platform issues +- Anti-pattern rules prevent common mistakes + +**Format Validation:** + +- Content is lean and optimized for LLMs +- Structure is logical and scannable +- No redundant or obvious information +- Consistent formatting throughout + +### 7. Completion Message + +Present final completion to user: + +"**Project Context Generation Complete!** + +Your optimized project context file is ready at: +`{output_folder}/project-context.md` + +**Context Summary:** + +- {{rule_count}} critical rules for AI agents +- {{section_count}} comprehensive sections +- Optimized for LLM context efficiency +- Ready for immediate agent integration + +**Key Benefits:** + +- Consistent implementation across all AI agents +- Reduced common mistakes and edge cases +- Clear guidance for project-specific patterns +- Minimal LLM context usage + +**Next Steps:** + +1. AI agents will automatically read this file when implementing +2. Update this file when your technology stack or patterns evolve +3. Review quarterly to optimize and remove outdated rules + +Your project context will help ensure high-quality, consistent game implementation across all development work. Great work capturing your project's critical implementation requirements!" + +## SUCCESS METRICS: + +- Complete project context file with all critical rules +- Content optimized for LLM context efficiency +- All technology versions and patterns documented +- File structure is logical and scannable +- Usage guidelines included for agents and humans +- Frontmatter properly updated with completion status +- User provided with clear next steps and benefits + +## FAILURE MODES: + +- Final content is too verbose for LLM consumption +- Missing critical implementation rules or patterns +- Not optimizing content for agent readability +- Not providing clear usage guidelines +- Frontmatter not properly updated +- Not validating file completion before ending + +## WORKFLOW COMPLETE: + +This is the final step of the Generate Project Context workflow. The user now has a comprehensive, optimized project context file that will ensure consistent, high-quality game implementation across all AI agents working on the project. + +The project context file serves as the critical "rules of the road" that agents need to implement game code consistently with the project's standards and patterns. diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/workflow.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/workflow.md new file mode 100644 index 00000000..8eb8945c --- /dev/null +++ b/src/modules/bmgd/workflows/3-technical/generate-project-context/workflow.md @@ -0,0 +1,48 @@ +--- +name: generate-project-context +description: Creates a concise project-context.md file with critical rules and patterns that AI agents must follow when implementing game code. Optimized for LLM context efficiency. +--- + +# Generate Project Context Workflow + +**Goal:** Create a concise, optimized `project-context.md` file containing critical rules, patterns, and guidelines that AI agents must follow when implementing game code. This file focuses on unobvious details that LLMs need to be reminded of. + +**Your Role:** You are a technical facilitator working with a peer to capture the essential implementation rules that will ensure consistent, high-quality game code generation across all AI agents working on the project. + +--- + +## WORKFLOW ARCHITECTURE + +This uses **micro-file architecture** for disciplined execution: + +- Each step is a self-contained file with embedded rules +- Sequential progression with user control at each step +- Document state tracked in frontmatter +- Focus on lean, LLM-optimized content generation +- You NEVER proceed to a step file if the current step file indicates the user must approve and indicate continuation. + +--- + +## INITIALIZATION + +### Configuration Loading + +Load config from `{project-root}/_bmad/bmgd/config.yaml` and resolve: + +- `project_name`, `output_folder`, `user_name` +- `communication_language`, `document_output_language`, `game_dev_experience` +- `date` as system-generated current datetime + +### Paths + +- `installed_path` = `{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context` +- `template_path` = `{installed_path}/project-context-template.md` +- `output_file` = `{output_folder}/project-context.md` + +--- + +## EXECUTION + +Load and execute `steps/step-01-discover.md` to begin the workflow. + +**Note:** Input document discovery and initialization protocols are handled in step-01-discover.md.