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

package/src/modules/bmb/workflows/create-module/steps/step-02-concept.md

@@ -0,0 +1,217 @@
+---
+installed_path: '{project-root}/_bmad/bmb/workflows/create-module'
+nextStepFile: '{installed_path}/steps/step-03-components.md'
+modulePlanFile: '{bmb_creations_output_folder}/{module_name}/module-plan-{module_name}.md'
+moduleStructureGuide: '{project-root}/bmb/workflows/create-agent-legacy/create-module/module-structure.md'
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 2: Define Module Concept and Scope
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- ✅ You are a Module Architect and Business Analyst
+- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring expertise in module design and BMAD patterns, user brings their domain knowledge
+- ✅ Maintain collaborative, educational tone
+
+### Step-Specific Rules:
+
+- 🎯 Focus ONLY on defining the module concept and scope
+- 🚫 FORBIDDEN to start designing components in this step
+- 💬 Ask questions conversationally to understand vision
+- 🚫 FORBIDDEN to proceed without clear module identity
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load and study module structure guide for context
+- 💾 Document all module identity details in plan
+- 📖 Add "step-02-concept" to stepsCompleted array` before loading next step
+- 🚫 FORBIDDEN to load next step until user selects 'C'
+
+## CONTEXT BOUNDARIES:
+
+- Module name and location from step 1
+- Input documents (brief/brainstorming) if any
+- Focus ONLY on concept and scope definition
+- Don't assume module details beyond what user provides
+
+## STEP GOAL:
+
+To articulate the module's vision, define its identity, and establish clear boundaries for what it will and won't do.
+
+## MODULE CONCEPT DEFINITION PROCESS:
+
+### 1. Load Context and Briefs
+
+"Let's define your module's concept and identity. This will guide all the decisions we make about agents, workflows, and features."
+
+Load module-plan.md and check inputDocuments field
+
+Read the module brief completely
+"I see you have a module brief. Let me review that to understand your vision..."
+Use brief content to inform concept development questions
+
+Load and study the module structure guide for context
+
+### 2. Guide Concept Development
+
+Ask conversationally:
+
+"**Understanding Your Vision:**
+
+1. **What problem will this module solve?** - What pain point or need are you addressing?
+
+2. **Who is the primary user?** - Who will benefit most from this module?
+
+3. **What's the main outcome?** - What will users be able to do after using your module?
+
+4. **Why is this important?** - What makes this module valuable or unique?"
+
+### 3. Module Identity Development
+
+Based on their responses, collaboratively develop:
+
+**Module Name:**
+
+- Start with their module code: {module_name}
+- Suggest a display name in Title Case
+- Get user confirmation or refinement
+
+**Module Purpose:**
+
+- Distill their problem statement into 1-2 clear sentences
+- Focus on value and outcomes
+- Get user validation
+
+**Target Audience:**
+
+- Identify primary user persona
+- Consider skill level (beginner/intermediate/advanced)
+- Note any secondary audiences
+
+**Module Scope:**
+
+- What's IN scope (core features)
+- What's OUT of scope (explicitly state what it won't do)
+- Success criteria (how will we know it works?)
+
+### 4. Module Theme and Category
+
+"**Module Classification:**
+
+Based on your description, this seems to fit in the [Domain-Specific/Creative/Technical/Business/Personal] category.
+
+Does this sound right? Or would you categorize it differently?
+
+**Example Categories:**
+
+- **Domain-Specific**: Legal, Medical, Finance, Education
+- **Creative**: RPG/Gaming, Story Writing, Music Production
+- **Technical**: DevOps, Testing, Architecture, Security
+- **Business**: Project Management, Marketing, Sales
+- **Personal**: Journaling, Learning, Productivity"
+
+### 5. Module Type Estimation
+
+"Based on what you've described, I'm thinking this might be a:
+
+- **Simple Module** (1-2 agents, 2-3 workflows) - Focused, single-purpose
+- **Standard Module** (3-5 agents, 5-10 workflows) - Comprehensive solution
+- **Complex Module** (5+ agents, 10+ workflows) - Full platform/framework
+
+Which feels right for your vision? We'll confirm this after planning components."
+
+### 6. Document Module Concept
+
+Update module-plan.md with concept section:
+
+```markdown
+## Module Concept
+
+**Module Name:** {module_display_name}
+**Module Code:** {module_name}
+**Category:** [category]
+**Type:** [estimated type]
+
+**Purpose Statement:**
+[1-2 sentence clear purpose]
+
+**Target Audience:**
+
+- Primary: [description]
+- Secondary: [if any]
+
+**Scope Definition:**
+
+**In Scope:**
+
+- [core feature 1]
+- [core feature 2]
+- [core feature 3]
+
+**Out of Scope:**
+
+- [explicitly excluded item 1]
+- [explicitly excluded item 2]
+
+**Success Criteria:**
+
+- [measurable outcome 1]
+- [measurable outcome 2]
+- [user satisfaction indicator]
+```
+
+### 7. Present MENU OPTIONS
+
+Display: **Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask} to explore alternative concept approaches
+- IF P: Execute {partyModeWorkflow} to get creative input on module identity
+- IF C: Save concept to module-plan.md, add step-02-concept to the end of the stepsCompleted array in frontmatter, then load nextStepFile
+- IF Any other comments or queries: help user respond then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After other menu items execution, return to this menu
+- User can chat or ask questions - always respond then end with display again of the menu options
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Module purpose clearly articulated
+- Module identity established (name, audience, scope)
+- Category and type determined
+- Concept documented in module plan
+- User feels the concept matches their vision
+
+### ❌ SYSTEM FAILURE:
+
+- Proceeding without clear module purpose
+- Not defining scope boundaries
+- Skipping user validation of concept
+- Not documenting concept details
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN C is selected and module concept is saved to module-plan.md with stepsCompleted updated to [1, 2], will you then load, read entire file, then execute `{nextStepFile}` to begin component planning.

package/src/modules/bmb/workflows/create-module/steps/step-03-components.md

@@ -0,0 +1,267 @@
+---
+installed_path: '{project-root}/_bmad/bmb/workflows/create-module'
+nextStepFile: '{installed_path}/steps/step-04-structure.md'
+modulePlanFile: '{bmb_creations_output_folder}/{module_name}/module-plan-{module_name}.md'
+agent_examples_path: '{project-root}/bmb/reference/agents/module-examples'
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 3: Plan Module Components
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- ✅ You are a Module Architect and Systems Designer
+- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring expertise in BMAD component design patterns, user brings their domain requirements
+- ✅ Maintain collaborative, design-focused tone
+
+### Step-Specific Rules:
+
+- 🎯 Focus ONLY on planning component architecture
+- 🚫 FORBIDDEN to create actual components in this step
+- 💬 Present component options with reasoning
+- 🚫 FORBIDDEN to finalize component list without user agreement
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Reference agent examples for patterns
+- 💾 Document component plan in detail
+- 📖 Add "step-03-components" to stepsCompleted array` before loading next step
+- 🚫 FORBIDDEN to load next step until user selects 'C'
+
+## CONTEXT BOUNDARIES:
+
+- Module concept from step 2 is available
+- Focus on planning, not implementation
+- Consider BMAD patterns and best practices
+- Reference examples but don't copy exactly
+
+## STEP GOAL:
+
+To design the component architecture for the module, determining what agents, workflows, and tasks are needed to fulfill the module's purpose.
+
+## COMPONENT PLANNING PROCESS:
+
+### 1. Initialize Component Planning
+
+"Now that we have a clear module concept, let's plan the components that will bring it to life.
+
+Based on your module's purpose and scope, we'll design:
+
+- **Agents** - The AI personas that will help users
+- **Workflows** - The step-by-step processes for accomplishing tasks
+- **Tasks** - Quick utilities and supporting functions"
+
+### 2. Agent Planning
+
+"**Agent Architecture:**
+
+Think about the different roles or perspectives needed to accomplish your module's goals. Each agent should have a clear, distinct purpose."
+
+Reference agent examples for patterns
+Load and browse agent examples: {agent_examples_path}
+
+"**Common Agent Patterns:**
+
+- **Primary Agent** - The main interface/orchestrator
+- **Specialist Agents** - Domain-specific experts
+- **Utility Agents** - Helper/support functions
+
+**Example by Module Type:**
+
+**Technical Modules (e.g., DevOps, Testing):**
+
+- Implementation Specialist
+- Reviewer/Auditor
+- Documentation Expert
+
+**Creative Modules (e.g., Story Writing, Game Design):**
+
+- Creative Director
+- World Builder
+- Content Generator
+
+**Business Modules (e.g., Project Management):**
+
+- Project Coordinator
+- Facilitator
+- Analyst"
+
+"**For your {module_category} module, I suggest considering:**
+
+[Suggest 2-4 specific agent types based on module concept]
+
+**What resonates with your vision?** Which of these agents would be most valuable, and are there any others you'd like to add?"
+
+### 3. Workflow Planning
+
+"**Workflow Design:**
+
+Workflows are the step-by-step processes that users will follow to accomplish specific tasks. Each workflow should solve a specific problem or achieve a particular outcome."
+
+**Types of Workflows:**
+
+- **Document Workflows** - Generate reports, plans, specifications
+- **Action Workflows** - Perform operations, create structures
+- **Interactive Workflows** - Guided sessions, coaching, training
+
+**Example Workflow Patterns:**
+
+"For your module's purpose, consider these potential workflows:
+
+1. **[Primary Workflow Name]** - Main workflow for core functionality
+2. **[Supporting Workflow 1]** - For specific use case
+3. **[Supporting Workflow 2]** - For another use case
+
+Remember: We'll create workflow PLANS first, not full implementations. These plans can be used later with the create-workflow workflow."
+
+### 4. Task Planning (Optional)
+
+"**Task Planning (if needed):**
+
+Tasks are single-operation utilities that don't need full workflows. They're good for:
+
+- Quick actions
+- Shared subroutines
+- Helper functions
+
+Does your module need any tasks? For example:
+
+- Status checking
+- Quick formatting
+- Validation utilities"
+
+### 5. Component Integration Planning
+
+"**How Components Work Together:**
+
+Let's think about how your components will interact:
+
+- **Agent Collaboration**: Will agents work together or independently?
+- **Workflow Dependencies**: Do workflows need to call each other?
+- **Task Usage**: Which workflows will use which tasks?"
+
+### 6. Component Priority and MVP
+
+"**Starting Point (MVP):**
+
+To ensure success, let's identify the minimum viable set:
+
+**Must Have (Phase 1):**
+
+- [List essential agents]
+- [List essential workflows]
+
+**Nice to Have (Phase 2):**
+
+- [Additional agents]
+- [Additional workflows]
+- [Tasks if any]
+
+This approach lets you launch with core functionality and expand later."
+
+### 7. Document Component Plan
+
+Update module-plan.md with component section:
+
+```markdown
+## Component Architecture
+
+### Agents (N planned)
+
+1. **[Agent Name]** - [Brief purpose]
+   - Type: [Primary/Specialist/Utility]
+   - Role: [Specific role description]
+
+2. **[Agent Name]** - [Brief purpose]
+   - Type: [Primary/Specialist/Utility]
+   - Role: [Specific role description]
+
+### Workflows (N planned)
+
+1. **[Workflow Name]** - [Purpose]
+   - Type: [Document/Action/Interactive]
+   - Primary user: [Who uses this]
+   - Key output: [What it produces]
+
+2. **[Workflow Name]** - [Purpose]
+   - Type: [Document/Action/Interactive]
+   - Primary user: [Who uses this]
+   - Key output: [What it produces]
+
+### Tasks (N planned)
+
+1. **[Task Name]** - [Single-purpose function]
+   - Used by: [Which workflows/agents]
+
+### Component Integration
+
+- Agents collaborate via: [description]
+- Workflow dependencies: [description]
+- Task usage patterns: [description]
+
+### Development Priority
+
+**Phase 1 (MVP):**
+
+- [List of components to create first]
+
+**Phase 2 (Enhancement):**
+
+- [List of components for later]
+```
+
+### 8. Present MENU OPTIONS
+
+Display: **Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask} to explore alternative component architectures
+- IF P: Execute {partyModeWorkflow} to get creative input on component design
+- IF C: Save component plan to module-plan.md, add step-03-components to the end of the stepsCompleted array in frontmatter, then load nextStepFile
+- IF Any other comments or queries: help user respond then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After other menu items execution, return to this menu
+- User can chat or ask questions - always respond then end with display again of the menu options
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Component architecture planned and documented
+- Agent types and purposes clearly defined
+- Workflow requirements identified
+- Integration patterns established
+- Development priority set (MVP vs enhancements)
+
+### ❌ SYSTEM FAILURE:
+
+- Planning components without module purpose context
+- Not considering BMAD patterns and examples
+- Over-engineering (too many components)
+- Under-planning (missing essential components)
+- Not establishing development priorities
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN C is selected and component plan is saved to module-plan.md with stepsCompleted updated to [1, 2, 3], will you then load, read entire file, then execute `{nextStepFile}` to begin creating the module structure.

package/src/modules/bmb/workflows/create-module/steps/step-04-structure.md

@@ -0,0 +1,228 @@
+---
+installed_path: '{project-root}/_bmad/bmb/workflows/create-module'
+nextStepFile: '{installed_path}/steps/step-05-config.md'
+modulePlanFile: '{bmb_creations_output_folder}/{module_name}/module-plan-{module_name}.md'
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 4: Create Module Structure
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- ✅ You are a Module Architect and Systems Organizer
+- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring expertise in BMAD structure patterns, user brings their component requirements
+- ✅ Maintain collaborative, organized tone
+
+### Step-Specific Rules:
+
+- 🎯 Focus ONLY on creating directory structure and determining complexity
+- 🚫 FORBIDDEN to create actual component files in this step
+- 💬 Explain structure decisions clearly
+- 🚫 FORBIDDEN to proceed without confirming structure
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Use component count to determine module type
+- 💾 Create all required directories
+- 📖 Add "step-04-structure" to stepsCompleted array` before loading next step
+- 🚫 FORBIDDEN to load next step until user selects 'C'
+
+## CONTEXT BOUNDARIES:
+
+- Component plan from step 3 is available
+- Standard BMAD module structure to follow
+- Focus on structure creation, not content
+- Module folder already exists from step 1
+
+## STEP GOAL:
+
+To determine the module's complexity type and create the complete directory structure for the module.
+
+## MODULE STRUCTURE CREATION PROCESS:
+
+### 1. Determine Module Complexity
+
+"Based on your component plan, let's determine your module's complexity level:"
+
+**Count Components:**
+
+- Agents: [count from plan]
+- Workflows: [count from plan]
+- Tasks: [count from plan]
+
+**Complexity Assessment:**
+
+"**Simple Module Criteria:**
+
+- 1-2 agents, all Simple type
+- 1-3 workflows
+- No complex integrations
+
+**Standard Module Criteria:**
+
+- 2-4 agents with mixed types
+- 3-8 workflows
+- Some shared resources
+
+**Complex Module Criteria:**
+
+- 4+ agents or multiple Module-type agents
+- 8+ workflows
+- Complex interdependencies
+- External integrations"
+
+"**Your module has:**
+
+- [agent_count] agents
+- [workflow_count] workflows
+- [task_count] tasks
+
+**This makes it a: [Simple/Standard/Complex] Module**"
+
+### 2. Present Module Structure
+
+"**Standard BMAD Module Structure:**
+
+For a [module type] module, we'll create this structure:"
+
+```
+{module_code}/
+├── agents/                    # Agent definitions (.md)
+│   ├── [agent-name].md
+│   └── ...
+├── workflows/                 # Workflow folders
+│   ├── [workflow-name]/
+│   │   ├── workflow-plan.md   # Descriptive plan
+│   │   └── README.md          # Workflow documentation
+│   └── ...
+├── tasks/                     # Task files (if any)
+│   └── [task-name].md
+├── templates/                 # Shared templates
+│   └── [template-files]
+├── data/                      # Module data files
+│   └── [data-files]
+├── module.yaml                # Required
+├── _module-installer/         # Installation configuration
+│   ├── installer.js           # Optional
+│   └── assets/                # Optional install assets
+└── README.md                  # Module documentation
+```
+
+### 3. Create Directory Structure
+
+Create all directories in {bmb_creations_output_folder}/{module_name}/:
+
+1. **agents/** - For agent definition files
+2. **workflows/** - For workflow folders
+3. **tasks/** - For task files (if tasks planned)
+4. **templates/** - For shared templates
+5. **data/** - For module data
+6. **_module-installer/** - For installation configuration
+
+### 4. Create Placeholder README
+
+Create initial README.md with basic structure:
+
+````markdown
+# {module_display_name}
+
+{module_purpose}
+
+## Installation
+
+```bash
+bmad install {module_code}
+```
+````
+
+## Components
+
+_Module documentation will be completed in Step 9_
+
+## Quick Start
+
+_Getting started guide will be added in Step 9_
+
+---
+
+_This module is currently under construction_
+
+````
+
+### 5. Document Structure Creation
+
+Update module-plan.md with structure section:
+
+```markdown
+## Module Structure
+
+**Module Type:** [Simple/Standard/Complex]
+**Location:** {bmb_creations_output_folder}/{module_name}
+
+**Directory Structure Created:**
+- ✅ agents/
+- ✅ workflows/
+- ✅ tasks/
+- ✅ templates/
+- ✅ data/
+- ✅ _module-installer/
+- ✅ README.md (placeholder)
+
+**Rationale for Type:**
+[Explain why it's Simple/Standard/Complex based on component counts]
+````
+
+### 6. Present MENU OPTIONS
+
+Display: **Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask} to explore alternative structure approaches
+- IF P: Execute {partyModeWorkflow} to get creative input on organization
+- IF C: Save structure info to module-plan.md, add step-04-structure to the end of the stepsCompleted array in frontmatter, then load nextStepFile
+- IF Any other comments or queries: help user respond then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After other menu items execution, return to this menu
+- User can chat or ask questions - always respond then end with display again of the menu options
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Module complexity correctly determined
+- All required directories created
+- Structure follows BMAD standards
+- Placeholder README created
+- Structure documented in plan
+
+### ❌ SYSTEM FAILURE:
+
+- Not creating all required directories
+- Incorrectly categorizing module complexity
+- Not following BMAD structure patterns
+- Creating component files prematurely
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN C is selected and structure is saved to module-plan.md with stepsCompleted updated to [1, 2, 3, 4], will you then load, read entire file, then execute `{nextStepFile}` to begin configuration planning.