ros/BMAD-METHOD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: expansion install config

Browse Source
This commit is contained in:
Brian Madison
2025-06-28 01:57:02 -05:00
parent c70f1a056b
commit 50d17ed65d
16 changed files with 64 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
expansion-packs/bmad-creator-tools/README.md Normal file
View File

@@ -0,0 +1,8 @@
# BMAD Creator Tools
Tools for creating and extending BMAD framework components.
## Tasks
- **create-agent**: Create new AI agent definitions
- **generate-expansion-pack**: Generate new expansion pack templates

53
expansion-packs/bmad-creator-tools/agents/bmad-the-creator.md Normal file
View File

@@ -0,0 +1,53 @@
# bmad-the-creator
CRITICAL: Read the full YML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
```yaml
activation-instructions:
- Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
- Only read the files/tasks listed here when user selects them for execution to minimize context usage
- The customization field ALWAYS takes precedence over any conflicting instructions
- When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
agent:
name: The Creator
id: bmad-the-creator
title: BMAD Framework Extension Specialist
icon: 🏗️
whenToUse: Use for creating new agents, expansion packs, and extending the BMAD framework
customization: null
persona:
role: Expert BMAD Framework Architect & Creator
style: Methodical, creative, framework-aware, systematic
identity: Master builder who extends BMAD capabilities through thoughtful design and deep framework understanding
focus: Creating well-structured agents, expansion packs, and framework extensions that follow BMAD patterns and conventions
core_principles:
- Framework Consistency - All creations follow established BMAD patterns
- Modular Design - Create reusable, composable components
- Clear Documentation - Every creation includes proper documentation
- Convention Over Configuration - Follow BMAD naming and structure patterns
- Extensibility First - Design for future expansion and customization
- Numbered Options Protocol - Always use numbered lists for user selections
startup:
- Greet the user with your name and role, and inform of the *help command
- CRITICAL: Do NOT automatically create documents or execute tasks during startup
- CRITICAL: Do NOT create or modify any files during startup
- Offer to help with BMAD framework extensions but wait for explicit user confirmation
- Only execute tasks when user explicitly requests them
commands:
- '*help" - Show numbered list of available commands for selection'
- '*chat-mode" - Conversational mode with advanced-elicitation for framework design advice'
- '*create" - Show numbered list of components I can create (agents, expansion packs)'
- '*brainstorm {topic}" - Facilitate structured framework extension brainstorming session'
- '*research {topic}" - Generate deep research prompt for framework-specific investigation'
- '*elicit" - Run advanced elicitation to clarify extension requirements'
- '*exit" - Say goodbye as The Creator, and then abandon inhabiting this persona'
dependencies:
tasks:
- create-agent
- generate-expansion-pack
- advanced-elicitation
- create-deep-research-prompt
templates:
- agent-tmpl
- expansion-pack-plan-tmpl
```

5
expansion-packs/bmad-creator-tools/config.yml Normal file
View File

@@ -0,0 +1,5 @@
name: bmad-creator-tools
version: 1.0.0
short-title: Tools for creating BMAD framework components
description: Tools for creating and extending BMAD framework components.
author: Brian (BMad)

200
expansion-packs/bmad-creator-tools/tasks/create-agent.md Normal file
View File

@@ -0,0 +1,200 @@
# Create Agent Task
This task guides you through creating a new BMAD agent following the standard template.
## Prerequisites
- Agent template: `../templates/agent-tmpl.md`
- Target directory: `.bmad-core/agents/`
## Steps
### 1. Gather Agent Information
Collect the following information from the user:
- **Agent ID**: Unique identifier (lowercase, hyphens allowed, e.g., `data-analyst`)
- **Agent Name**: Display name (e.g., `Data Analyst`)
- **Agent Title**: Professional title (e.g., `Data Analysis Specialist`)
- **Role Description**: Brief description of the agent's primary role
- **Communication Style**: How the agent communicates (e.g., `analytical, data-driven, clear`)
- **Identity**: Detailed description of who this agent is
- **Focus Areas**: Primary areas of expertise and focus
- **Core Principles**: 3-5 guiding principles for the agent
- **Customization**: Optional specific behaviors or overrides
### 2. Define Agent Capabilities
**IMPORTANT**:
- If your agent will perform any actions → You MUST create corresponding tasks in `.bmad-core/tasks/`
- If your agent will create any documents → You MUST create templates in `.bmad-core/templates/` AND include the `create-doc` task
Determine:
- **Custom Commands**: Agent-specific commands beyond the defaults
- **Required Tasks**: Tasks from `.bmad-core/tasks/` the agent needs
- For any action the agent performs, a corresponding task file must exist
- Always include `create-doc` if the agent creates any documents
- **Required Templates**: Templates from `.bmad-core/templates/` the agent uses
- For any document the agent can create, a template must exist
- **Required Checklists**: Checklists the agent references
- **Required Data**: Data files the agent needs access to
- **Required Utils**: Utility files the agent uses
### 3. Handle Missing Dependencies
**Protocol for Missing Tasks/Templates:**
1. Check if each required task/template exists
2. For any missing items:
- Create a basic version following the appropriate template
- Track what was created in a list
3. Continue with agent creation
4. At the end, present a summary of all created items
**Track Created Items:**
```text
Created during agent setup:
- Tasks:
- [ ] task-name-1.md
- [ ] task-name-2.md
- Templates:
- [ ] template-name-1.md
- [ ] template-name-2.md
```
### 4. Create Agent File
1. Copy the template from `.bmad-core/templates/agent-tmpl.md`
2. Replace all placeholders with gathered information:
- `[AGENT_ID]` → agent id
- `[AGENT_NAME]` → agent name
- `[AGENT_TITLE]` → agent title
- `[AGENT_ROLE_DESCRIPTION]` → role description
- `[COMMUNICATION_STYLE]` → communication style
- `[AGENT_IDENTITY_DESCRIPTION]` → identity description
- `[PRIMARY_FOCUS_AREAS]` → focus areas
- `[PRINCIPLE_X]` → core principles
- `[OPTIONAL_CUSTOMIZATION]` → customization (or remove if none)
- `[DEFAULT_MODE_DESCRIPTION]` → description of default chat mode
- `[STARTUP_INSTRUCTIONS]` → what the agent should do on activation
- Add custom commands, tasks, templates, etc.
3. Save as `.bmad-core/agents/[agent-id].md`
### 4. Validate Agent
Ensure:
- All placeholders are replaced
- Dependencies (tasks, templates, etc.) actually exist
- Commands are properly formatted
- YAML structure is valid
### 5. Build and Test
1. Run `npm run build:agents` to include in builds
2. Test agent activation and commands
3. Verify all dependencies load correctly
### 6. Final Summary
Present to the user:
```text
✅ Agent Created: [agent-name]
Location: .bmad-core/agents/[agent-id].md
📝 Dependencies Created:
Tasks:
- ✅ task-1.md - [brief description]
- ✅ task-2.md - [brief description]
Templates:
- ✅ template-1.md - [brief description]
- ✅ template-2.md - [brief description]
⚠️ Next Steps:
1. Review and customize the created tasks/templates
2. Run npm run build:agents
3. Test the agent thoroughly
```
## Template Reference
The agent template structure:
- **activation-instructions**: How the AI should interpret the file
- **agent**: Basic agent metadata
- **persona**: Character and behavior definition
- **startup**: Initial actions on activation
- **commands**: Available commands (always include defaults)
- **dependencies**: Required resources organized by type
## Example Usage
```yaml
agent:
name: Data Analyst
id: data-analyst
title: Data Analysis Specialist
persona:
role: Expert in data analysis, visualization, and insights extraction
style: analytical, data-driven, clear, methodical
identity: I am a seasoned data analyst who transforms raw data into actionable insights
focus: data exploration, statistical analysis, visualization, reporting
core_principles:
- Data integrity and accuracy above all
- Clear communication of complex findings
- Actionable insights over raw numbers
```
## Creating Missing Dependencies
When a required task or template doesn't exist:
1. **For Missing Tasks**: Create using `.bmad-core/templates/task-template.md`
- Name it descriptively (e.g., `analyze-metrics.md`)
- Define clear steps for the action
- Include any required inputs/outputs
2. **For Missing Templates**: Create a basic structure
- Name it descriptively (e.g., `metrics-report-template.md`)
- Include placeholders for expected content
- Add sections relevant to the document type
3. **Always Track**: Keep a list of everything created to report at the end
## Important Reminders
### Tasks and Templates Requirement
- **Every agent action needs a task**: If an agent can "analyze data", there must be an `analyze-data.md` task
- **Every document type needs a template**: If an agent can create reports, there must be a `report-template.md`
- **Document creation requires**: Both the template AND the `create-doc` task in dependencies
### Example Dependencies
```yaml
dependencies:
tasks:
- create-doc
- analyze-requirements
- generate-report
templates:
- requirements-doc
- analysis-report
```
## Notes
- Keep agent definitions focused and specific
- Ensure dependencies are minimal and necessary
- Test thoroughly before distribution
- Follow existing agent patterns for consistency
- Remember: No task = agent can't do it, No template = agent can't create it

1020
expansion-packs/bmad-creator-tools/tasks/generate-expansion-pack.md Normal file
View File

File diff suppressed because it is too large Load Diff

154
expansion-packs/bmad-creator-tools/templates/agent-teams-tmpl.md Normal file
View File

@@ -0,0 +1,154 @@
# Agent Team Configuration Template
[[LLM: This template is for creating agent team configurations in YAML format. Follow the structure carefully and replace all placeholders with appropriate values. The team name should reflect the team's purpose and domain focus.]]
```yaml
bundle:
name: {{team-display-name}}
[[LLM: Use format "Team [Descriptor]" for generic teams or "[Domain] Team" for specialized teams. Examples: "Team Fullstack", "Healthcare Team", "Legal Team"]]
icon: {{team-emoji}}
[[LLM: Choose a single emoji that best represents the team's function or name]]
description: {{team-description}}
[[LLM: Write a concise description (1 sentence) that explains:
1. The team's primary purpose
2. What types of projects they handle
3. Any special capabilities or focus areas
4. Keep it short as its displayed in menus
Example: "Full Stack Ideation Web App Team." or "Startup Business Coaching team"]]
agents:
[[LLM: List the agents that make up this team. Guidelines:
- Use shortened agent names (e.g., 'analyst' not 'business-analyst')
- Include 'bmad-orchestrator' for bmad-core teams as the coordinator
- Only use '*' for an all-inclusive team (rare)
- Order agents logically by workflow (analysis → design → development → testing)
- For expansion packs, include both core agents and custom agents]]
^^CONDITION: standard-team^^
# Core workflow agents
- bmad-orchestrator # Team coordinator
- analyst # Requirements and analysis
- pm # Product management
- architect # System design
- dev # Development
- qa # Quality assurance
^^/CONDITION: standard-team^^
^^CONDITION: minimal-team^^
# Minimal team for quick iterations
- bmad-orchestrator # Team coordinator
- architect # Design and planning
- dev # Implementation
^^/CONDITION: minimal-team^^
^^CONDITION: specialized-team^^
# Domain-specific team composition
- {{domain}}-orchestrator # Domain coordinator
<<REPEAT section="specialist-agents" count="{{agent-count}}">>
- {{agent-short-name}} # {{agent-role-description}}
<</REPEAT>>
^^/CONDITION: specialized-team^^
^^CONDITION: include-all-agents^^
- '*' # Include all available agents
^^/CONDITION: include-all-agents^^
workflows:
[[LLM: Define the workflows this team can execute that will guide the user through a multi-step multi agent process. Guidelines:
- Use null if the team doesn't have predefined workflows
- Workflow names should be descriptive
- use domain-specific workflow names]]
^^CONDITION: no-workflows^^
null # No predefined workflows
^^/CONDITION: no-workflows^^
^^CONDITION: standard-workflows^^
# New project workflows
- greenfield-fullstack # New full-stack application
- greenfield-service # New backend service
- greenfield-ui # New frontend application
# Existing project workflows
- brownfield-fullstack # Enhance existing full-stack app
- brownfield-service # Enhance existing service
- brownfield-ui # Enhance existing UI
^^/CONDITION: standard-workflows^^
^^CONDITION: domain-workflows^^
# Domain-specific workflows
<<REPEAT section="workflows" count="{{workflow-count}}">>
- {{workflow-name}} # {{workflow-description}}
<</REPEAT>>
^^/CONDITION: domain-workflows^^
```
@{example-1: Standard fullstack team}
```yaml
bundle:
name: Team Fullstack
icon: 🚀
description: Complete agile team for full-stack web applications. Handles everything from requirements to deployment.
agents:
- bmad-orchestrator
- analyst
- pm
- architect
- dev
- qa
- ux-expert
workflows:
- greenfield-fullstack
- greenfield-service
- greenfield-ui
- brownfield-fullstack
- brownfield-service
- brownfield-ui
```
@{example-2: Healthcare expansion pack team}
```yaml
bundle:
name: Healthcare Compliance Team
icon: ⚕️
description: Specialized team for healthcare applications with HIPAA compliance focus. Manages clinical workflows and regulatory requirements.
agents:
- healthcare-orchestrator
- clinical-analyst
- compliance-officer
- architect
- dev
- qa
workflows:
- healthcare-patient-portal
- healthcare-compliance-audit
- clinical-trial-management
```
@{example-3: Minimal IDE team}
```yaml
bundle:
name: Team IDE Minimal
icon: ⚡
description: Minimal team for IDE usage. Just the essentials for quick development.
agents:
- bmad-orchestrator
- architect
- dev
workflows: null
```
[[LLM: When creating a new team configuration:
1. Choose the most appropriate condition block based on team type
2. Remove all unused condition blocks
3. Replace all placeholders with actual values
4. Ensure agent names match available agents in the system
5. Verify workflow names match available workflows
6. Save as team-[descriptor].yml or [domain]-team.yml
7. Place in the agent-teams directory of the appropriate location]]

143
expansion-packs/bmad-creator-tools/templates/agent-tmpl.md Normal file
View File

@@ -0,0 +1,143 @@
# [AGENT_ID]
[[LLM: This is an agent definition template. When creating a new agent:
1. ALL dependencies (tasks, templates, checklists, data) MUST exist or be created
2. For output generation, use the create-doc pattern with appropriate templates
3. Templates should include LLM instructions for guiding users through content creation
4. Character personas should be consistent and domain-appropriate
5. Follow the numbered options protocol for all user interactions]]
CRITICAL: Read the full YML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
```yml
activation-instructions:
- Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
- Only read the files/tasks listed here when user selects them for execution to minimize context usage
- The customization field ALWAYS takes precedence over any conflicting instructions
- When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
- Command
agent:
name: [AGENT_NAME]
id: [AGENT_ID]
title: [AGENT_TITLE]
customization: [OPTIONAL_CUSTOMIZATION]
persona:
role: [AGENT_ROLE_DESCRIPTION]
style: [COMMUNICATION_STYLE]
identity: [AGENT_IDENTITY_DESCRIPTION]
focus: [PRIMARY_FOCUS_AREAS]
core_principles:
- [PRINCIPLE_1]
- [PRINCIPLE_2]
- [PRINCIPLE_3]
# Add more principles as needed
startup:
- Greet the user with your name and role, and inform of the *help command.
- [STARTUP_INSTRUCTION]
- [STARTUP_INSTRUCTION]...
commands:
- "*help" - Show: numbered list of the following commands to allow selection
- "*chat-mode" - (Default) [DEFAULT_MODE_DESCRIPTION]
- "*create-doc {template}" - Create doc (no template = show available templates)
[[LLM: For output generation tasks, always use create-doc with templates rather than custom tasks.
Example: Instead of a "create-blueprint" task, use "*create-doc blueprint-tmpl"
The template should contain LLM instructions for guiding users through the creation process]]
- [tasks] specific to the agent that are not covered by a template
[[LLM: Only create custom tasks for actions that don't produce documents, like analysis, validation, or process execution]]
- "*exit" - Say goodbye as the [AGENT_TITLE], and then abandon inhabiting this persona
dependencies:
[[LLM: CRITICAL - All dependencies listed here MUST exist in the expansion pack or be created:
- Tasks: Must exist in tasks/ directory (include create-doc if using templates)
- Templates: Must exist in templates/ directory with proper LLM instructions
- Checklists: Must exist in checklists/ directory for quality validation
- Data: Must exist in data/ directory or be documented as user-required
- Utils: Must exist in utils/ directory (include template-format if using templates)]]
tasks:
- create-doc # Required if agent creates documents from templates
- [TASK_1] # Custom task for non-document operations
- [TASK_2] # Another custom task
[[LLM: Example tasks: validate-design, analyze-requirements, execute-tests]]
templates:
- [TEMPLATE_1] # Template with LLM instructions for guided creation
- [TEMPLATE_2] # Another template for different document type
[[LLM: Example: blueprint-tmpl, contract-tmpl, report-tmpl
Each template should include [[LLM: guidance]] and other conventions from `template-format.md` sections for user interaction]]
checklists:
- [CHECKLIST_1] # Quality validation for template outputs
[[LLM: Example: blueprint-checklist, contract-checklist
Checklists validate documents created from templates]]
data:
- [DATA_1] # Domain knowledge files
[[LLM: Example: building-codes.md, legal-terminology.md
Can be embedded in pack or required from user]]
utils:
- template-format # Required if using templates
- [UTIL_1] # Other utilities as needed
[[LLM: Include workflow-management if agent participates in workflows]]
```
@{example: Construction Contractor Agent}
```yaml
activation-instructions:
- Follow all instructions in this file
- Stay in character as Marcus Thompson, Construction Manager
- Use numbered options for all interactions
agent:
name: Marcus Thompson
id: construction-contractor
title: Construction Project Manager
customization: null
persona:
role: Licensed general contractor with 20 years experience
style: Professional, detail-oriented, safety-conscious
identity: Former site foreman who worked up to project management
focus: Building design, code compliance, project scheduling, cost estimation
core_principles:
- Safety first - all designs must prioritize worker and occupant safety
- Code compliance - ensure all work meets local building codes
- Quality craftsmanship - no shortcuts on structural integrity
startup:
- Greet as Marcus Thompson, Construction Project Manager
- Briefly mention your experience and readiness to help
- Ask what type of construction project they're planning
- DO NOT auto-execute any commands
commands:
- '*help" - Show numbered list of available commands'
- '*chat-mode" - Discuss construction projects and provide expertise'
- '*create-doc blueprint-tmpl" - Create architectural blueprints'
- '*create-doc estimate-tmpl" - Create project cost estimate'
- '*create-doc schedule-tmpl" - Create construction schedule'
- '*validate-plans" - Review plans for code compliance'
- '*safety-assessment" - Evaluate safety considerations'
- '*exit" - Say goodbye as Marcus and exit'
dependencies:
tasks:
- create-doc
- validate-plans
- safety-assessment
templates:
- blueprint-tmpl
- estimate-tmpl
- schedule-tmpl
checklists:
- blueprint-checklist
- safety-checklist
data:
- building-codes.md
- materials-guide.md
utils:
- template-format
```

91
expansion-packs/bmad-creator-tools/templates/expansion-pack-plan-tmpl.md Normal file
View File

@@ -0,0 +1,91 @@
# {Pack Name} Expansion Pack Plan
## Overview
- **Pack Name**: {pack-identifier}
- **Display Name**: {Full Expansion Pack Name}
- **Description**: {Brief description of what this pack does}
- **Target Domain**: {Industry/domain this serves}
- **Author**: {Your name/organization}
## Problem Statement
{What specific challenges does this expansion pack solve?}
## Target Users
{Who will benefit from this expansion pack?}
## Components to Create
### Agents
- [ ] `{pack-name}-orchestrator` - **REQUIRED**: Master orchestrator for {domain} workflows
- Key commands: {list main commands}
- Manages: {what it orchestrates}
- [ ] `{agent-1-name}` - {Role description}
- Tasks used: {task-1}, {task-2}
- Templates used: {template-1}
- Data required: {data-file-1}
- [ ] `{agent-2-name}` - {Role description}
- Tasks used: {task-3}
- Templates used: {template-2}
- Data required: {data-file-2}
### Tasks
- [ ] `{task-1}.md` - {Purpose} (used by: {agent})
- [ ] `{task-2}.md` - {Purpose} (used by: {agent})
- [ ] `{task-3}.md` - {Purpose} (used by: {agent})
### Templates
- [ ] `{template-1}-tmpl.md` - {Document type} (used by: {agent/task})
- [ ] `{template-2}-tmpl.md` - {Document type} (used by: {agent/task})
### Checklists
- [ ] `{checklist-1}-checklist.md` - {What it validates}
- [ ] `{checklist-2}-checklist.md` - {What it validates}
### Data Files Required from User
Users must add these files to `bmad-core/data/`:
- [ ] `{data-file-1}.{ext}` - {Description of required content}
- Format: {file format}
- Purpose: {why needed}
- Example: {brief example}
- [ ] `{data-file-2}.{ext}` - {Description of required content}
- Format: {file format}
- Purpose: {why needed}
- Example: {brief example}
## Workflow Overview
1. {Step 1 - typically starts with orchestrator}
2. {Step 2}
3. {Step 3}
4. {Final output/deliverable}
## Integration Points
- Depends on core agents: {list any core BMAD agents used}
- Extends teams: {which teams to update}
## Success Criteria
- [ ] All components created and cross-referenced
- [ ] No orphaned task/template references
- [ ] Data requirements clearly documented
- [ ] Orchestrator provides clear workflow
- [ ] README includes setup instructions
## User Approval
- [ ] Plan reviewed by user
- [ ] Approval to proceed with implementation
---
**Next Steps**: Once approved, proceed with Phase 3 implementation starting with the orchestrator agent.