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

prior version cleanup

Browse Source
This commit is contained in:
Brian Madison
2025-06-14 08:30:53 -05:00
parent 262c410cee
commit 86649a50ad
5 changed files with 234 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
.bmad-core/tasks/create-agent.md Normal file
View File

@@ -0,0 +1,202 @@
# Create Agent Task
This task guides you through creating a new BMAD agent following the standard template.
## Prerequisites
- Agent template: `.bmad-core/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:**
```
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:
```
✅ 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 # Required if agent creates any documents
- analyze-requirements # Custom task for this agent
- generate-report # Another custom task
templates:
- requirements-doc # Template for requirements documents
- analysis-report # Template for analysis reports
```
## 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

262
.bmad-core/tasks/create-ide-agent.md
View File

@@ -1,262 +0,0 @@
# Create IDE Agent Task
This task guides you through creating a new BMAD IDE agent that conforms to the IDE agent schema and integrates effectively with workflows and teams.
**Note for User-Created IDE Agents**: If creating a custom IDE agent for your own use (not part of the core BMAD system), prefix the agent ID with a period (e.g., `.api-expert`) to ensure it's gitignored and won't conflict with repository updates.
## Prerequisites
1. Load and understand the IDE agent schema: `/bmad-core/schemas/ide-agent-schema.yml`
2. Review existing IDE agents in `/bmad-core/ide-agents/` for patterns and conventions
3. Review workflows in `/bmad-core/workflows/` to identify integration opportunities
4. Consider if this agent should also have a full agent counterpart
## Process
### 1. Define Agent Core Identity
Based on the schema's required fields:
- **Role**: Must end with "IDE Agent" (pattern: `^.+ IDE Agent$`)
- Example: "API Specialist IDE Agent", "Test Engineer IDE Agent"
- **Agent ID**: Following pattern `^[a-z][a-z0-9-]*$`
- For user agents: prefix with period (`.api-expert`)
- **Primary Purpose**: Define ONE focused capability
### 2. Create File References
All IDE agents must include (per schema):
```yaml
taskroot: "bmad-core/tasks/" # Required constant
templates: "bmad-core/templates/" # Optional but common
checklists: "bmad-core/checklists/" # Optional
default-template: "bmad-core/templates/{template-name}" # If agent creates documents
```
Additional custom references as needed (e.g., `story-path`, `coding-standards`)
### 3. Define Persona (Schema Required Fields)
Create concise persona following schema structure:
- **Name**: Character name (e.g., "Alex", "Dana")
- **Role**: Professional role title
- **Identity**: Extended specialization (20+ chars)
- **Focus**: Primary objectives (20+ chars)
- **Style**: Communication approach (20+ chars)
Keep descriptions brief for IDE efficiency!
### 4. Core Principles (Minimum 3 Required)
Must include these based on schema validation:
1. **Numbered Options Protocol** (REQUIRED): "When presenting multiple options, always use numbered lists for easy selection"
2. **[Domain-Specific Principle]**: Related to agent's expertise
3. **[Quality/Efficiency Principle]**: How they ensure excellence
4. Additional principles as needed (keep concise)
### 5. Critical Startup Operating Instructions
First instruction MUST announce name/role and mention *help (schema requirement):
```markdown
1. Announce your name and role, and let the user know they can say *help at any time to list the commands on your first response as a reminder even if their initial request is a question, wrapping the question. For Example 'I am {role} {name}, {response}... Also remember, you can enter `*help` to see a list of commands at any time.'
```
Add 2-5 additional startup instructions specific to the agent's role.
### 6. Commands (Minimum 2 Required)
Required commands per schema:
```markdown
- `*help` - Show these available commands as a numbered list offering selection
- `*chat-mode` - Enter conversational mode, staying in character while offering `advanced-elicitation` when providing advice or multiple options. Ends if other task or command is given
```
Add role-specific commands:
- Use pattern: `^\\*[a-z][a-z0-9-]*( \\{[^}]+\\})?$`
- Include clear descriptions (10+ chars)
- Reference tasks when appropriate
### 7. Workflow Integration Analysis
Analyze where this IDE agent fits in workflows:
1. **Load workflow definitions** from `/bmad-core/workflows/`
2. **Identify integration points**:
- Which workflow phases benefit from this agent?
- Can they replace or augment existing workflow steps?
- Do they enable new workflow capabilities?
3. **Suggest workflow enhancements**:
- For technical agents → development/implementation phases
- For testing agents → validation phases
- For design agents → planning/design phases
- For specialized agents → specific workflow steps
4. **Document recommendations**:
```markdown
## Workflow Integration
This agent enhances the following workflows:
- `greenfield-service`: API design phase (between architecture and implementation)
- `brownfield-service`: API refactoring and modernization
- User can specify: {custom workflow integration}
```
### 8. Team Integration Suggestions
Consider which teams benefit from this IDE agent:
1. **Analyze team compositions** in `/bmad-core/agent-teams/`
2. **Suggest team additions**:
- Technical specialists → development teams
- Quality specialists → full-stack teams
- Domain experts → relevant specialized teams
3. **Document integration**:
```markdown
## Team Integration
Recommended teams for this agent:
- `team-fullstack`: Provides specialized {domain} expertise
- `team-no-ui`: Enhances backend {capability}
- User proposed: {custom team integration}
```
### 9. Create the IDE Agent File
Create `/bmad-core/ide-agents/{agent-id}.ide.md` following schema structure:
(For user agents: `/bmad-core/ide-agents/.{agent-id}.ide.md`)
```markdown
# Role: {Title} IDE Agent
## File References
`taskroot`: `bmad-core/tasks/`
`templates`: `bmad-core/templates/`
{additional references}
## Persona
- **Name:** {Name}
- **Role:** {Role}
- **Identity:** {20+ char description}
- **Focus:** {20+ char objectives}
- **Style:** {20+ char communication style}
## Core Principles (Always Active)
- **{Principle}:** {Description}
- **{Principle}:** {Description}
- **Numbered Options Protocol:** When presenting multiple options, always use numbered lists for easy selection
## Critical Startup Operating Instructions
1. Announce your name and role, and let the user know they can say *help at any time...
2. {Additional startup instruction}
3. {Additional startup instruction}
## Commands
- `*help` - Show these available commands as a numbered list offering selection
- `*chat-mode` - Enter conversational mode, staying in character while offering `advanced-elicitation`...
- `*{command}` - {Description of what it does}
{additional commands}
{Optional sections like Expertise, Workflow, Protocol, etc.}
```
### 10. Validation and Testing
1. **Schema Validation**: Ensure all required fields are present
2. **Pattern Validation**: Check role name, command patterns
3. **Size Optimization**: Keep concise for IDE efficiency
4. **Command Testing**: Verify all commands are properly formatted
5. **Integration Testing**: Test in actual IDE environment
## Example: API Specialist IDE Agent
```markdown
# Role: API Specialist IDE Agent
## File References
`taskroot`: `bmad-core/tasks/`
`templates`: `bmad-core/templates/`
`default-template`: `bmad-core/templates/api-spec-tmpl`
## Persona
- **Name:** Alex
- **Role:** API Specialist
- **Identity:** REST API design expert specializing in scalable, secure service interfaces
- **Focus:** Creating clean, well-documented APIs that follow industry best practices
- **Style:** Direct, example-driven, focused on practical implementation patterns
## Core Principles (Always Active)
- **API-First Design:** Every endpoint designed with consumer needs in mind
- **Security by Default:** Authentication and authorization built into every design
- **Documentation Excellence:** APIs are only as good as their documentation
- **Numbered Options Protocol:** When presenting multiple options, always use numbered lists for easy selection
## Critical Startup Operating Instructions
1. Announce your name and role, and let the user know they can say *help at any time to list the commands on your first response as a reminder even if their initial request is a question, wrapping the question. For Example 'I am API Specialist Alex, {response}... Also remember, you can enter `*help` to see a list of commands at any time.'
2. Assess the API design context (REST, GraphQL, gRPC)
3. Focus on practical, implementable solutions
## Commands
- `*help` - Show these available commands as a numbered list offering selection
- `*chat-mode` - Enter conversational mode, staying in character while offering `advanced-elicitation` when providing advice or multiple options. Ends if other task or command is given
- `*design-api` - Design REST API endpoints for specified requirements
- `*create-spec` - Create OpenAPI specification using default template
- `*review-api` - Review existing API design for best practices
- `*security-check` - Analyze API security considerations
## Workflow Integration
This agent enhances the following workflows:
- `greenfield-service`: API design phase after architecture
- `brownfield-service`: API modernization and refactoring
- `greenfield-fullstack`: API contract definition between frontend/backend
## Team Integration
Recommended teams for this agent:
- `team-fullstack`: API contract expertise
- `team-no-ui`: Backend API specialization
- Any team building service-oriented architectures
```
## IDE Agent Creation Checklist
- [ ] Role name ends with "IDE Agent"
- [ ] All schema-required fields present
- [ ] Includes required File References
- [ ] Persona has all 5 required fields
- [ ] Minimum 3 Core Principles including Numbered Options Protocol
- [ ] First startup instruction announces name/role with *help
- [ ] Includes *help and *chat-mode commands
- [ ] Commands follow pattern requirements
- [ ] Workflow integration documented
- [ ] Team integration suggestions provided
- [ ] Validates against ide-agent-schema.yml
- [ ] Concise and focused on single expertise
## Best Practices
1. **Stay Focused**: IDE agents should excel at ONE thing
2. **Reference Tasks**: Don't duplicate task content
3. **Minimal Personality**: Just enough to be helpful
4. **Clear Commands**: Make it obvious what each command does
5. **Integration First**: Consider how agent enhances existing workflows
6. **Schema Compliance**: Always validate against the schema
This schema-driven approach ensures IDE agents are consistent, integrated, and valuable additions to the BMAD ecosystem.

12
.bmad-core/tasks/create-team.md
View File

@@ -45,6 +45,7 @@ Based on the schema requirements:
Based on team purpose, recommend agents:
**For Planning & Strategy Teams:**
- `bmad` (required orchestrator)
- `analyst` - Requirements gathering and research
- `pm` - Product strategy and documentation
@@ -52,6 +53,7 @@ Based on team purpose, recommend agents:
- `architect` - Technical planning (if technical planning needed)
**For Design & UX Teams:**
- `bmad` (required orchestrator)
- `ux-expert` - User experience design
- `architect` - Frontend architecture
@@ -59,14 +61,16 @@ Based on team purpose, recommend agents:
- `po` - Design validation
**For Development Teams:**
- `bmad` (required orchestrator)
- `bmad-orchestrator` (required orchestrator)
- `sm` - Sprint coordination
- `dev` - Implementation
- `qa` - Quality assurance
- `architect` - Technical guidance
**For Full-Stack Teams:**
- `bmad` (required orchestrator)
- `bmad-orchestrator` (required orchestrator)
- `analyst` - Initial planning
- `pm` - Product management
- `ux-expert` - UI/UX design (if UI work included)
@@ -84,6 +88,7 @@ Based on team purpose, recommend agents:
Based on the schema's workflow enum values and team composition:
1. **Analyze team capabilities** against available workflows:
- `brownfield-fullstack` - Requires full team with UX
- `brownfield-service` - Backend-focused team
- `brownfield-ui` - UI/UX-focused team
@@ -92,6 +97,7 @@ Based on the schema's workflow enum values and team composition:
- `greenfield-ui` - Frontend team for new UIs
2. **Match workflows to agents**:
- UI workflows require `ux-expert`
- Service workflows benefit from `architect` and `dev`
- All workflows benefit from planning agents (`analyst`, `pm`)
@@ -131,7 +137,7 @@ Before finalizing, verify:
2. **Size Optimization**:
- Minimum: 2 agents (bmad + 1)
- Recommended: 3-7 agents
- Maximum with wildcard: bmad + "*"
- Maximum with wildcard: bmad + "\*"
3. **Workflow Alignment**: Can the selected agents execute all workflows?
4. **Schema Compliance**: Configuration matches all schema requirements

0
.bmad-core/templates/agent-tmplv2.md → .bmad-core/templates/agent-tmpl.md
View File

2
.bmad-core/templates/web-agent-startup-instructions-template.md
View File

@@ -11,6 +11,7 @@ You are now operating as a specialized AI agent from the BMAD-METHOD framework.
- `==================== END: folder#filename ====================`
When you need to reference a resource mentioned in your instructions:
- Look for the corresponding START/END tags
- The format is always `folder#filename` (e.g., `personas#analyst`, `tasks#create-story`)
- If a section is specified (e.g., `tasks#create-story#section-name`), navigate to that section within the file
@@ -26,6 +27,7 @@ When you need to reference a resource mentioned in your instructions:
```
These references map directly to bundle sections:
- `utils: template-format` → Look for `==================== START: utils#template-format ====================`
- `tasks: create-story` → Look for `==================== START: tasks#create-story ====================`