bmad-elsabro 1.0.0

package/src/bmm/workflows/4-implementation/sprint-status/workflow.yaml

@@ -0,0 +1,36 @@
+# Sprint Status - Implementation Tracker
+name: sprint-status
+description: "Summarize sprint-status.yaml, surface risks, and route to the right implementation workflow."
+author: "BMad"
+
+# Critical variables from config
+config_source: "{project-root}/_bmad/bmm/config.yaml"
+output_folder: "{config_source}:output_folder"
+user_name: "{config_source}:user_name"
+communication_language: "{config_source}:communication_language"
+document_output_language: "{config_source}:document_output_language"
+date: system-generated
+implementation_artifacts: "{config_source}:implementation_artifacts"
+planning_artifacts: "{config_source}:planning_artifacts"
+
+# Workflow components
+installed_path: "{project-root}/_bmad/bmm/workflows/4-implementation/sprint-status"
+instructions: "{installed_path}/instructions.md"
+
+# Inputs
+variables:
+  sprint_status_file: "{implementation_artifacts}/sprint-status.yaml"
+  tracking_system: "file-system"
+
+# Smart input file references
+input_file_patterns:
+  sprint_status:
+    description: "Sprint status file generated by sprint-planning"
+    whole: "{implementation_artifacts}/sprint-status.yaml"
+    load_strategy: "FULL_LOAD"
+
+# Standalone so IDE commands get generated
+standalone: true
+
+# No web bundle needed
+web_bundle: false

package/src/bmm/workflows/bmad-quick-flow/brownfield-fast-track/steps/step-01-detect.md

@@ -0,0 +1,55 @@
+---
+name: step-01-detect
+description: Auto-analyze existing project patterns and conventions
+---
+
+# Step 1: Detect Project Patterns
+
+## OBJECTIVE
+
+Scan the codebase and detect ALL relevant patterns before making changes.
+
+## EXECUTION
+
+### 1. Tech Stack Detection
+
+Scan for:
+- **Package Manager**: package.json, requirements.txt, go.mod, Cargo.toml
+- **Framework**: React, Vue, Angular, Next.js, Django, FastAPI, etc.
+- **Styling**: Tailwind, CSS Modules, styled-components, SCSS
+- **State**: Redux, Zustand, Context, Pinia, etc.
+- **Testing**: Jest, Vitest, Pytest, Go test
+
+### 2. Code Pattern Detection
+
+Analyze existing code for:
+- **Component Structure**: functional vs class, hooks usage
+- **Naming Conventions**: camelCase, PascalCase, snake_case
+- **File Organization**: feature folders, domain layers, flat
+- **Import Style**: absolute, relative, aliases
+- **Error Handling**: try/catch, Result types, error boundaries
+
+### 3. Test Pattern Detection
+
+Find existing tests and detect:
+- **Test Framework**: Jest, Vitest, Pytest, etc.
+- **Test Style**: unit, integration, e2e
+- **Mocking Approach**: jest.mock, vi.mock, fixtures
+- **Assertion Style**: expect, assert, should
+
+### 4. Generate Pattern Report
+
+Create mental model of:
+```yaml
+project_patterns:
+  tech_stack: "Next.js 14 + TypeScript + Tailwind"
+  component_style: "functional with hooks"
+  state_management: "Zustand"
+  testing: "Vitest with Testing Library"
+  naming: "camelCase functions, PascalCase components"
+  structure: "feature folders under src/"
+```
+
+## NEXT STEP
+
+Proceed to: `step-02-confirm.md`

package/src/bmm/workflows/bmad-quick-flow/brownfield-fast-track/steps/step-02-confirm.md

@@ -0,0 +1,48 @@
+---
+name: step-02-confirm
+description: Single confirmation - follow detected conventions?
+---
+
+# Step 2: Confirm Approach
+
+## OBJECTIVE
+
+ONE question to user: Follow detected conventions or establish new patterns?
+
+## EXECUTION
+
+### Present Detected Patterns
+
+Show user what was detected:
+
+```
+Detected Project Patterns:
+
+Tech: {tech_stack}
+Components: {component_style}
+State: {state_management}
+Testing: {testing}
+Naming: {naming}
+Structure: {structure}
+
+Your request: "{user_request}"
+```
+
+### Single Question
+
+Ask ONLY:
+
+**"Follow these patterns for {feature/fix}? [Y/n]"**
+
+If YES (default): Use all detected patterns
+If NO: Ask what to do differently (1 follow-up max)
+
+### Handle Edge Cases
+
+- **No tests detected**: "No tests found. Should I add tests? [Y/n]"
+- **Mixed patterns**: "Found inconsistent patterns. Use most common? [Y/n]"
+- **New tech needed**: "Feature needs {X}. Add dependency? [Y/n]"
+
+## NEXT STEP
+
+Proceed to: `step-03-implement.md`

package/src/bmm/workflows/bmad-quick-flow/brownfield-fast-track/steps/step-03-implement.md

@@ -0,0 +1,61 @@
+---
+name: step-03-implement
+description: Implement following detected patterns, generate matching tests
+---
+
+# Step 3: Implement
+
+## OBJECTIVE
+
+Write code and tests that perfectly match existing project patterns.
+
+## EXECUTION
+
+### 1. Implement Feature/Fix
+
+Following detected patterns:
+- Use same component structure
+- Use same naming conventions
+- Use same import style
+- Use same error handling
+
+### 2. Generate Matching Tests
+
+Create tests that:
+- Use same test framework
+- Follow same test file structure
+- Use same mocking approach
+- Use same assertion style
+
+Example matching:
+```typescript
+// If project uses: describe/it + vi.mock
+describe('NewFeature', () => {
+  it('should do the thing', () => {
+    // ...
+  });
+});
+
+// NOT: test() if project uses it()
+// NOT: jest.mock if project uses vi.mock
+```
+
+### 3. Run Existing Test Suite
+
+```bash
+# Run full suite to ensure no regressions
+npm test / yarn test / pnpm test
+```
+
+### 4. Report
+
+```
+IMPLEMENTED: {feature/fix}
+Changed: {files}
+Tests: {X} new, {Y} total passing
+Patterns: Followed {detected patterns}
+```
+
+## WORKFLOW COMPLETE
+
+Brownfield Fast-Track done. Minimal disruption, maximum value.

package/src/bmm/workflows/bmad-quick-flow/brownfield-fast-track/workflow.md

@@ -0,0 +1,41 @@
+---
+name: brownfield-fast-track
+description: 'Quick fixes and features for existing projects. Auto-detects patterns and conventions.'
+---
+
+# Brownfield Fast-Track Workflow
+
+**Goal:** Add features or fixes to existing projects WITHOUT planning overhead. Auto-detect patterns, follow conventions.
+
+**Your Role:** Expert brownfield developer. Respect existing code. Add value without disruption.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+3-step focused execution for existing codebases:
+
+- Step 1: Detect (auto-analyze project patterns)
+- Step 2: Confirm (1 question: follow conventions?)
+- Step 3: Implement (code + tests following detected patterns)
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load from `{project-root}/_bmad/bmm/config.yaml`:
+- All standard config values
+- `brownfield_mode` = true
+
+### Paths
+
+- `installed_path` = `{project-root}/_bmad/bmm/workflows/bmad-quick-flow/brownfield-fast-track`
+- `project_context` = `**/project-context.md` (prioritize if exists)
+
+---
+
+## EXECUTION
+
+Read fully and follow: `steps/step-01-detect.md` to begin.

package/src/bmm/workflows/bmad-quick-flow/quick-dev/steps/step-01-mode-detection.md

@@ -0,0 +1,176 @@
+---
+name: 'step-01-mode-detection'
+description: 'Determine execution mode (tech-spec vs direct), handle escalation, set state variables'
+
+workflow_path: '{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-dev'
+thisStepFile: './step-01-mode-detection.md'
+nextStepFile_modeA: './step-03-execute.md'
+nextStepFile_modeB: './step-02-context-gathering.md'
+---
+
+# Step 1: Mode Detection
+
+**Goal:** Determine execution mode, capture baseline, handle escalation if needed.
+
+---
+
+## STATE VARIABLES (capture now, persist throughout)
+
+These variables MUST be set in this step and available to all subsequent steps:
+
+- `{baseline_commit}` - Git HEAD at workflow start (or "NO_GIT" if not a git repo)
+- `{execution_mode}` - "tech-spec" or "direct"
+- `{tech_spec_path}` - Path to tech-spec file (if Mode A)
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Capture Baseline
+
+First, check if the project uses Git version control:
+
+**If Git repo exists** (`.git` directory present or `git rev-parse --is-inside-work-tree` succeeds):
+
+- Run `git rev-parse HEAD` and store result as `{baseline_commit}`
+
+**If NOT a Git repo:**
+
+- Set `{baseline_commit}` = "NO_GIT"
+
+### 2. Load Project Context
+
+Check if `{project_context}` exists (`**/project-context.md`). If found, load it as a foundational reference for ALL implementation decisions.
+
+### 3. Parse User Input
+
+Analyze the user's input to determine mode:
+
+**Mode A: Tech-Spec**
+
+- User provided a path to a tech-spec file (e.g., `quick-dev tech-spec-auth.md`)
+- Load the spec, extract tasks/context/AC
+- Set `{execution_mode}` = "tech-spec"
+- Set `{tech_spec_path}` = provided path
+- **NEXT:** Read fully and follow: `step-03-execute.md`
+
+**Mode B: Direct Instructions**
+
+- User provided task description directly (e.g., `refactor src/foo.ts...`)
+- Set `{execution_mode}` = "direct"
+- **NEXT:** Evaluate escalation threshold, then proceed
+
+---
+
+## ESCALATION THRESHOLD (Mode B only)
+
+Evaluate user input with minimal token usage (no file loading):
+
+**Triggers escalation (if 2+ signals present):**
+
+- Multiple components mentioned (dashboard + api + database)
+- System-level language (platform, integration, architecture)
+- Uncertainty about approach ("how should I", "best way to")
+- Multi-layer scope (UI + backend + data together)
+- Extended timeframe ("this week", "over the next few days")
+
+**Reduces signal:**
+
+- Simplicity markers ("just", "quickly", "fix", "bug", "typo", "simple")
+- Single file/component focus
+- Confident, specific request
+
+Use holistic judgment, not mechanical keyword matching.
+
+---
+
+## ESCALATION HANDLING
+
+### No Escalation (simple request)
+
+Display: "**Select:** [P] Plan first (tech-spec) [E] Execute directly"
+
+#### Menu Handling Logic:
+
+- IF P: Direct user to `{quick_spec_workflow}`. **EXIT Quick Dev.**
+- IF E: Ask for any additional guidance, then **NEXT:** Read fully and follow: `step-02-context-gathering.md`
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed when user makes a selection
+
+---
+
+### Escalation Triggered - Level 0-2
+
+Present: "This looks like a focused feature with multiple components."
+
+Display:
+
+**[P] Plan first (tech-spec)** (recommended)
+**[W] Seems bigger than quick-dev** - Recommend the Full BMad Flow PRD Process
+**[E] Execute directly**
+
+#### Menu Handling Logic:
+
+- IF P: Direct to `{quick_spec_workflow}`. **EXIT Quick Dev.**
+- IF W: Direct user to run the PRD workflow instead. **EXIT Quick Dev.**
+- IF E: Ask for guidance, then **NEXT:** Read fully and follow: `step-02-context-gathering.md`
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed when user makes a selection
+
+---
+
+### Escalation Triggered - Level 3+
+
+Present: "This sounds like platform/system work."
+
+Display:
+
+**[W] Start BMad Method** (recommended)
+**[P] Plan first (tech-spec)** (lighter planning)
+**[E] Execute directly** - feeling lucky
+
+#### Menu Handling Logic:
+
+- IF P: Direct to `{quick_spec_workflow}`. **EXIT Quick Dev.**
+- IF W: Direct user to run the PRD workflow instead. **EXIT Quick Dev.**
+- IF E: Ask for guidance, then **NEXT:** Read fully and follow: `step-02-context-gathering.md`
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed when user makes a selection
+
+---
+
+## NEXT STEP DIRECTIVE
+
+**CRITICAL:** When this step completes, explicitly state which step to load:
+
+- Mode A (tech-spec): "**NEXT:** read fully and follow: `step-03-execute.md`"
+- Mode B (direct, [E] selected): "**NEXT:** Read fully and follow: `step-02-context-gathering.md`"
+- Escalation ([P] or [W]): "**EXITING Quick Dev.** Follow the directed workflow."
+
+---
+
+## SUCCESS METRICS
+
+- `{baseline_commit}` captured and stored
+- `{execution_mode}` determined ("tech-spec" or "direct")
+- `{tech_spec_path}` set if Mode A
+- Project context loaded if exists
+- Escalation evaluated appropriately (Mode B)
+- Explicit NEXT directive provided
+
+## FAILURE MODES
+
+- Proceeding without capturing baseline commit
+- Not setting execution_mode variable
+- Loading step-02 when Mode A (tech-spec provided)
+- Attempting to "return" after escalation instead of EXIT
+- No explicit NEXT directive at step completion

package/src/bmm/workflows/bmad-quick-flow/quick-dev/steps/step-02-context-gathering.md

@@ -0,0 +1,120 @@
+---
+name: 'step-02-context-gathering'
+description: 'Quick context gathering for direct mode - identify files, patterns, dependencies'
+
+workflow_path: '{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-dev'
+thisStepFile: './step-02-context-gathering.md'
+nextStepFile: './step-03-execute.md'
+---
+
+# Step 2: Context Gathering (Direct Mode)
+
+**Goal:** Quickly gather context for direct instructions - files, patterns, dependencies.
+
+**Note:** This step only runs for Mode B (direct instructions). If `{execution_mode}` is "tech-spec", this step was skipped.
+
+---
+
+## AVAILABLE STATE
+
+From step-01:
+
+- `{baseline_commit}` - Git HEAD at workflow start
+- `{execution_mode}` - Should be "direct"
+- `{project_context}` - Loaded if exists
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Identify Files to Modify
+
+Based on user's direct instructions:
+
+- Search for relevant files using glob/grep
+- Identify the specific files that need changes
+- Note file locations and purposes
+
+### 2. Find Relevant Patterns
+
+Examine the identified files and their surroundings:
+
+- Code style and conventions used
+- Existing patterns for similar functionality
+- Import/export patterns
+- Error handling approaches
+- Test patterns (if tests exist nearby)
+
+### 3. Note Dependencies
+
+Identify:
+
+- External libraries used
+- Internal module dependencies
+- Configuration files that may need updates
+- Related files that might be affected
+
+### 4. Create Mental Plan
+
+Synthesize gathered context into:
+
+- List of tasks to complete
+- Acceptance criteria (inferred from user request)
+- Order of operations
+- Files to touch
+
+---
+
+## PRESENT PLAN
+
+Display to user:
+
+```
+**Context Gathered:**
+
+**Files to modify:**
+- {list files}
+
+**Patterns identified:**
+- {key patterns}
+
+**Plan:**
+1. {task 1}
+2. {task 2}
+...
+
+**Inferred AC:**
+- {acceptance criteria}
+
+Ready to execute? (y/n/adjust)
+```
+
+- **y:** Proceed to execution
+- **n:** Gather more context or clarify
+- **adjust:** Modify the plan based on feedback
+
+---
+
+## NEXT STEP DIRECTIVE
+
+**CRITICAL:** When user confirms ready, explicitly state:
+
+- **y:** "**NEXT:** Read fully and follow: `step-03-execute.md`"
+- **n/adjust:** Continue gathering context, then re-present plan
+
+---
+
+## SUCCESS METRICS
+
+- Files to modify identified
+- Relevant patterns documented
+- Dependencies noted
+- Mental plan created with tasks and AC
+- User confirmed readiness to proceed
+
+## FAILURE MODES
+
+- Executing this step when Mode A (tech-spec)
+- Proceeding without identifying files to modify
+- Not presenting plan for user confirmation
+- Missing obvious patterns in existing code

package/src/bmm/workflows/bmad-quick-flow/quick-dev/steps/step-03-execute.md

@@ -0,0 +1,153 @@
+---
+name: 'step-03-execute'
+description: 'Execute implementation - iterate through tasks, write code, run tests'
+
+workflow_path: '{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-dev'
+thisStepFile: './step-03-execute.md'
+nextStepFile: './step-04-self-check.md'
+---
+
+# Step 3: Execute Implementation
+
+**Goal:** Implement all tasks, write tests, follow patterns, handle errors.
+
+**Critical:** Continue through ALL tasks without stopping for milestones.
+
+---
+
+## AVAILABLE STATE
+
+From previous steps:
+
+- `{baseline_commit}` - Git HEAD at workflow start
+- `{execution_mode}` - "tech-spec" or "direct"
+- `{tech_spec_path}` - Tech-spec file (if Mode A)
+- `{project_context}` - Project patterns (if exists)
+
+From context:
+
+- Mode A: Tasks and AC extracted from tech-spec
+- Mode B: Tasks and AC from step-02 mental plan
+
+---
+
+## AUTO-PARALLELIZATION (Automatic - No Commands Needed)
+
+**Before starting execution, automatically analyze tasks for parallel opportunities:**
+
+### Dependency Analysis
+
+1. **Parse all tasks** - Extract task descriptions and identify file targets
+2. **Build dependency graph:**
+   - Tasks modifying the SAME file → must be sequential
+   - Tasks modifying DIFFERENT files → can run in parallel
+   - Tasks with explicit "depends on" → respect dependency
+3. **Group into waves:**
+   - Wave 1: All tasks with no dependencies
+   - Wave 2: Tasks that depend on Wave 1 completion
+   - Wave N: Continue until all tasks grouped
+
+### Wave Execution
+
+```
+IF auto_parallelization.enabled == true:
+  Wave 1: [Task 1, Task 3, Task 5]  ← Execute in parallel
+  ─── SYNC POINT ───
+  Wave 2: [Task 2, Task 4]          ← Execute in parallel
+  ─── SYNC POINT ───
+  Wave 3: [Task 6]                  ← Execute sequentially
+ELSE:
+  Execute all tasks sequentially (fallback)
+```
+
+### Parallel Execution Rules
+
+- **Max concurrent:** 4 streams (configurable in parallelization-config.yaml)
+- **Sync after each wave:** Verify all tasks complete before next wave
+- **Show progress:** "Wave 1/3 complete (3 tasks parallel)"
+- **On conflict:** Fall back to sequential for conflicting tasks
+
+---
+
+## EXECUTION LOOP
+
+**For each wave (or sequentially if no parallelization):**
+
+For each task:
+
+### 1. Load Context
+
+- Read files relevant to this task
+- Review patterns from project-context or observed code
+- Understand dependencies
+
+### 2. Implement
+
+- Write code following existing patterns
+- Handle errors appropriately
+- Follow conventions observed in codebase
+- Add appropriate comments where non-obvious
+
+### 3. Test
+
+- Write tests if appropriate for the change
+- Run existing tests to catch regressions
+- Verify the specific AC for this task
+
+### 4. Mark Complete
+
+- Check off task: `- [x] Task N`
+- Continue to next task immediately (or next parallel task in wave)
+
+---
+
+## HALT CONDITIONS
+
+**HALT and request guidance if:**
+
+- 3 consecutive failures on same task
+- Tests fail and fix is not obvious
+- Blocking dependency discovered
+- Ambiguity that requires user decision
+
+**Do NOT halt for:**
+
+- Minor issues that can be noted and continued
+- Warnings that don't block functionality
+- Style preferences (follow existing patterns)
+
+---
+
+## CONTINUOUS EXECUTION
+
+**Critical:** Do not stop between tasks for approval.
+
+- Execute all tasks in sequence
+- Only halt for blocking issues
+- Tests failing = fix before continuing
+- Track all completed work for self-check
+
+---
+
+## NEXT STEP
+
+When ALL tasks are complete (or halted on blocker), read fully and follow: `step-04-self-check.md`.
+
+---
+
+## SUCCESS METRICS
+
+- All tasks attempted
+- Code follows existing patterns
+- Error handling appropriate
+- Tests written where appropriate
+- Tests passing
+- No unnecessary halts
+
+## FAILURE MODES
+
+- Stopping for approval between tasks
+- Ignoring existing patterns
+- Not running tests after changes
+- Giving up after first failure
+- Not following project-context rules (if exists)