npm - ma-agents - Versions diffs - 3.4.9 → 3.5.0 - Mend

ma-agents 3.4.9 → 3.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (826) hide show

package/.opencode/skills/bmad-generate-project-context/steps/step-02-generate.md DELETED Viewed

@@ -1,321 +0,0 @@
-# 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 - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-## 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: Invoke the `bmad-advanced-elicitation` skill
-- When 'P' selected: Invoke the `bmad-party-mode` skill
-- 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
-- Technology stack 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 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 package files:
-{{exact_technologies_with_versions}}
-Any critical version constraints I should document for agents?"
-**Intermediate Mode:**
-"I found your technology stack:
-**Core Technologies:**
-{{main_technologies_with_versions}}
-**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:
-**Main Technologies:**
-{{friendly_description_of_tech_stack}}
-**Important Notes:**
-{{key_things_agents_need_to_know_about_versions}}
-Should I document any special version rules or compatibility requirements?"
-### 2. Language-Specific Rules
-Focus on unobvious language patterns agents might miss:
-**TypeScript/JavaScript Rules:**
-"Based on your codebase, I notice some specific patterns:
-**Configuration Requirements:**
-{{typescript_config_rules}}
-**Import/Export Patterns:**
-{{import_export_conventions}}
-**Error Handling Patterns:**
-{{error_handling_requirements}}
-Are these patterns correct? Any other language-specific rules agents should follow?"
-**Python/Ruby/Other Language Rules:**
-Adapt to the actual language in use with similar focused questions.
-### 3. Framework-Specific Rules
-Document framework-specific patterns:
-**React Rules (if applicable):**
-"For React development, I see these patterns:
-**Hooks Usage:**
-{{hooks_usage_patterns}}
-**Component Structure:**
-{{component_organization_rules}}
-**State Management:**
-{{state_management_patterns}}
-**Performance Rules:**
-{{performance_optimization_requirements}}
-Should I add any other React-specific rules?"
-**Other Framework Rules:**
-Adapt for Vue, Angular, Next.js, Express, etc.
-### 4. Testing Rules
-Focus on testing patterns that ensure consistency:
-**Test Structure Rules:**
-"Your testing setup shows these patterns:
-**Test Organization:**
-{{test_file_organization}}
-**Mock Usage:**
-{{mock_patterns_and_conventions}}
-**Test Coverage Requirements:**
-{{coverage_expectations}}
-**Integration vs Unit Test Rules:**
-{{test_boundary_patterns}}
-Are there testing rules agents should always follow?"
-### 5. Code Quality & Style Rules
-Document critical style and quality rules:
-**Linting/Formatting:**
-"Your code style configuration requires:
-**ESLint/Prettier Rules:**
-{{specific_linting_rules}}
-**Code Organization:**
-{{file_and_folder_structure_rules}}
-**Naming Conventions:**
-{{naming_patterns_agents_must_follow}}
-**Documentation Requirements:**
-{{comment_and_documentation_patterns}}
-Any additional code quality rules?"
-### 6. Development Workflow Rules
-Document workflow patterns that affect implementation:
-**Git/Repository Rules:**
-"Your project uses these patterns:
-**Branch Naming:**
-{{branch_naming_conventions}}
-**Commit Message Format:**
-{{commit_message_patterns}}
-**PR Requirements:**
-{{pull_request_checklist}}
-**Deployment Patterns:**
-{{deployment_considerations}}
-Should I document any other workflow rules?"
-### 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}}
-**Security Rules:**
-{{security_considerations_agents_must_follow}}
-**Performance Gotchas:**
-{{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
-### Language-Specific Rules
-{{bullet_points_of_critical_language_rules}}
-### Framework-Specific Rules
-{{bullet_points_of_framework_patterns}}
-### Testing Rules
-{{bullet_points_of_testing_requirements}}
-### Code Quality & Style Rules
-{{bullet_points_of_style_and_quality_rules}}
-### Development Workflow Rules
-{{bullet_points_of_workflow_patterns}}
-### Critical Don't-Miss Rules
-{{bullet_points_of_anti_patterns_and_edge_cases}}
-```
-### 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"
-**HALT — wait for user selection before proceeding.**
-### 10. Handle Menu Selection
-#### If 'A' (Advanced Elicitation):
-- Invoke the `bmad-advanced-elicitation` skill 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):
-- Invoke the `bmad-party-mode` skill 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
-✅ Language-specific rules cover unobvious patterns
-✅ Framework rules capture project-specific conventions
-✅ Testing rules ensure consistent test quality
-✅ Code quality rules maintain project standards
-✅ Workflow rules prevent implementation conflicts
-✅ 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!

package/.opencode/skills/bmad-generate-project-context/steps/step-03-complete.md DELETED Viewed

@@ -1,278 +0,0 @@
-# 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 - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-## 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 code in this project. Focus on unobvious details that agents might otherwise miss._
----
-## Technology Stack & Versions
-{{concise_technology_list}}
-## Critical Implementation Rules
-### Language-Specific Rules
-{{specific_language_rules}}
-### Framework-Specific Rules
-{{framework_patterns}}
-### Testing Rules
-{{testing_requirements}}
-### Code Quality & Style Rules
-{{style_and_quality_patterns}}
-### Development Workflow Rules
-{{workflow_patterns}}
-### Critical Don't-Miss Rules
-{{anti_patterns_and_edge_cases}}
----
-## Usage Guidelines
-**For AI Agents:**
-- Read this file before implementing any 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
-- Framework-specific patterns and conventions
-- Testing and quality guidelines
-- Workflow and anti-pattern rules
-**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 project. It ensures they all follow the same patterns and avoid common mistakes.
-**What's included:**
-- Exact technology versions to use
-- Critical coding rules they might miss
-- Testing and quality standards
-- Workflow patterns to follow
-**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', 'language_rules', 'framework_rules', 'testing_rules', 'quality_rules', 'workflow_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
-✅ Language-specific rules are specific and actionable
-✅ Framework rules cover project conventions
-✅ Testing rules ensure consistency
-✅ Code quality rules maintain standards
-✅ Workflow rules prevent conflicts
-✅ 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 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 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 code consistently with the project's standards and patterns.

package/.opencode/skills/bmad-generate-project-context/workflow.md DELETED Viewed

@@ -1,43 +0,0 @@
-# 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 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 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/bmm/config.yaml` and resolve:
-- `project_name`, `output_folder`, `user_name`
-- `communication_language`, `document_output_language`, `user_skill_level`
-- `date` as system-generated current datetime
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-- ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
-### Paths
-- `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.