create-byan-agent 2.0.1 → 2.1.0

package/_bmad/tea/workflows/testarch/automate/steps-c/step-01-preflight-and-context.md

@@ -0,0 +1,127 @@
+---
+name: 'step-01-preflight-and-context'
+description: 'Determine mode, verify framework, and load context and knowledge'
+nextStepFile: './step-02-identify-targets.md'
+knowledgeIndex: '{project-root}/_bmad/tea/testarch/tea-index.csv'
+---
+
+# Step 1: Preflight & Context Loading
+
+## STEP GOAL
+
+Determine execution mode, verify framework readiness, and load the necessary artifacts and knowledge fragments.
+
+## MANDATORY EXECUTION RULES
+
+- 📖 Read the entire step file before acting
+- ✅ Speak in `{communication_language}`
+- 🚫 Halt if framework scaffolding is missing
+
+---
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 💾 Record outputs before proceeding
+- 📖 Load the next step only when instructed
+
+## CONTEXT BOUNDARIES:
+
+- Available context: config, loaded artifacts, and knowledge fragments
+- Focus: this step's goal only
+- Limits: do not execute future steps
+- Dependencies: prior steps' outputs (if any)
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+## 1. Verify Framework
+
+Ensure a framework exists:
+
+- `playwright.config.ts` or `cypress.config.ts`
+- `package.json` includes test dependencies
+
+If missing: **HALT** with message "Run `framework` workflow first."
+
+---
+
+## 2. Determine Execution Mode
+
+- **BMad-Integrated** if story/tech-spec/test-design artifacts are provided or found
+- **Standalone** if only source code is available
+- If unclear, ask the user which mode to use
+
+---
+
+## 3. Load Context
+
+### BMad-Integrated (if available)
+
+- Story with acceptance criteria
+- PRD and/or tech spec
+- Test-design document (if exists)
+
+### Standalone
+
+- Skip artifacts; proceed to codebase analysis
+
+### Always Load
+
+- Test framework config
+- Existing test structure in `{test_dir}`
+- Existing tests (for coverage gaps)
+
+### Read TEA Config Flags
+
+- From `{config_source}` read `tea_use_playwright_utils`
+
+---
+
+## 4. Load Knowledge Base Fragments
+
+Use `{knowledgeIndex}` and load only what is required.
+
+**Core (always load):**
+
+- `test-levels-framework.md`
+- `test-priorities-matrix.md`
+- `data-factories.md`
+- `selective-testing.md`
+- `ci-burn-in.md`
+- `test-quality.md`
+
+**Playwright Utils (if enabled):**
+
+- `overview.md`, `api-request.md`, `network-recorder.md`, `auth-session.md`, `intercept-network-call.md`, `recurse.md`, `log.md`, `file-utils.md`, `burn-in.md`, `network-error-monitor.md`, `fixtures-composition.md`
+
+**Traditional Patterns (if Playwright Utils disabled):**
+
+- `fixture-architecture.md`
+- `network-first.md`
+
+**Healing (if auto-heal enabled):**
+
+- `test-healing-patterns.md`
+- `selector-resilience.md`
+- `timing-debugging.md`
+
+---
+
+## 5. Confirm Inputs
+
+Summarize loaded artifacts, framework, and knowledge fragments, then proceed.
+
+Load next step: `{nextStepFile}`
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+
+### ✅ SUCCESS:
+
+- Step completed in full with required outputs
+
+### ❌ SYSTEM FAILURE:
+
+- Skipped sequence steps or missing outputs
+  **Master Rule:** Skipping steps is FORBIDDEN.

package/_bmad/tea/workflows/testarch/automate/steps-c/step-02-identify-targets.md

@@ -0,0 +1,95 @@
+---
+name: 'step-02-identify-targets'
+description: 'Identify automation targets and create coverage plan'
+nextStepFile: './step-03-generate-tests.md'
+---
+
+# Step 2: Identify Automation Targets
+
+## STEP GOAL
+
+Determine what needs to be tested and select appropriate test levels and priorities.
+
+## MANDATORY EXECUTION RULES
+
+- 📖 Read the entire step file before acting
+- ✅ Speak in `{communication_language}`
+- 🚫 Avoid duplicate coverage across test levels
+
+---
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 💾 Record outputs before proceeding
+- 📖 Load the next step only when instructed
+
+## CONTEXT BOUNDARIES:
+
+- Available context: config, loaded artifacts, and knowledge fragments
+- Focus: this step's goal only
+- Limits: do not execute future steps
+- Dependencies: prior steps' outputs (if any)
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+## 1. Determine Targets
+
+**BMad-Integrated:**
+
+- Map acceptance criteria to test scenarios
+- Check for existing ATDD outputs to avoid duplication
+- Expand coverage with edge cases and negative paths
+
+**Standalone:**
+
+- If specific target feature/files are provided, focus there
+- Otherwise auto-discover features in `{source_dir}`
+- Prioritize critical paths, integrations, and untested logic
+
+---
+
+## 2. Choose Test Levels
+
+Use `test-levels-framework.md` to select:
+
+- **E2E** for critical user journeys
+- **API** for business logic and service contracts
+- **Component** for UI behavior
+- **Unit** for pure logic and edge cases
+
+---
+
+## 3. Assign Priorities
+
+Use `test-priorities-matrix.md`:
+
+- P0: Critical path + high risk
+- P1: Important flows + medium/high risk
+- P2: Secondary + edge cases
+- P3: Optional/rare scenarios
+
+---
+
+## 4. Coverage Plan
+
+Produce a concise coverage plan:
+
+- Targets by test level
+- Priority assignments
+- Justification for coverage scope (critical-paths/comprehensive/selective)
+
+Load next step: `{nextStepFile}`
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+
+### ✅ SUCCESS:
+
+- Step completed in full with required outputs
+
+### ❌ SYSTEM FAILURE:
+
+- Skipped sequence steps or missing outputs
+  **Master Rule:** Skipping steps is FORBIDDEN.

package/_bmad/tea/workflows/testarch/automate/steps-c/step-03-generate-tests.md

@@ -0,0 +1,199 @@
+---
+name: 'step-03-generate-tests'
+description: 'Orchestrate parallel test generation via subprocesses'
+nextStepFile: './step-03c-aggregate.md'
+---
+
+# Step 3: Orchestrate Parallel Test Generation
+
+## STEP GOAL
+
+Launch parallel subprocesses to generate API and E2E tests simultaneously for maximum performance.
+
+## MANDATORY EXECUTION RULES
+
+- 📖 Read the entire step file before acting
+- ✅ Speak in `{communication_language}`
+- ✅ Launch TWO subprocesses in PARALLEL
+- ✅ Wait for BOTH subprocesses to complete
+- ❌ Do NOT generate tests sequentially (use subprocesses)
+- ❌ Do NOT proceed until both subprocesses finish
+
+---
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 💾 Wait for subprocess outputs
+- 📖 Load the next step only when instructed
+
+## CONTEXT BOUNDARIES:
+
+- Available context: config, coverage plan from Step 2, knowledge fragments
+- Focus: subprocess orchestration only
+- Limits: do not generate tests directly (delegate to subprocesses)
+- Dependencies: Step 2 outputs (coverage plan, target features)
+
+---
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+### 1. Prepare Subprocess Inputs
+
+**Generate unique timestamp** for temp file naming:
+
+```javascript
+const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+```
+
+**Prepare input context for both subprocesses:**
+
+```javascript
+const subprocessContext = {
+  features: /* from Step 2 coverage plan */,
+  knowledge_fragments_loaded: /* list of fragments */,
+  config: {
+    test_framework: config.test_framework,
+    use_playwright_utils: config.tea_use_playwright_utils,
+    use_mcp_enhancements: config.tea_use_mcp_enhancements
+  },
+  timestamp: timestamp
+};
+```
+
+---
+
+### 2. Launch Subprocess A: API Test Generation
+
+**Launch subprocess in parallel:**
+
+- **Subprocess File:** `./step-03a-subprocess-api.md`
+- **Output File:** `/tmp/tea-automate-api-tests-${timestamp}.json`
+- **Context:** Pass `subprocessContext`
+- **Execution:** PARALLEL (non-blocking)
+
+**System Action:**
+
+```
+🚀 Launching Subprocess A: API Test Generation
+📝 Output: /tmp/tea-automate-api-tests-${timestamp}.json
+⏳ Status: Running in parallel...
+```
+
+---
+
+### 3. Launch Subprocess B: E2E Test Generation
+
+**Launch subprocess in parallel:**
+
+- **Subprocess File:** `./step-03b-subprocess-e2e.md`
+- **Output File:** `/tmp/tea-automate-e2e-tests-${timestamp}.json`
+- **Context:** Pass `subprocessContext`
+- **Execution:** PARALLEL (non-blocking)
+
+**System Action:**
+
+```
+🚀 Launching Subprocess B: E2E Test Generation
+📝 Output: /tmp/tea-automate-e2e-tests-${timestamp}.json
+⏳ Status: Running in parallel...
+```
+
+---
+
+### 4. Wait for Both Subprocesses to Complete
+
+**Monitor subprocess execution:**
+
+```
+⏳ Waiting for subprocesses to complete...
+  ├── Subprocess A (API): Running... ⟳
+  └── Subprocess B (E2E): Running... ⟳
+
+[... time passes ...]
+
+  ├── Subprocess A (API): Complete ✅
+  └── Subprocess B (E2E): Complete ✅
+
+✅ All subprocesses completed successfully!
+```
+
+**Verify both outputs exist:**
+
+```javascript
+const apiOutputExists = fs.existsSync(`/tmp/tea-automate-api-tests-${timestamp}.json`);
+const e2eOutputExists = fs.existsSync(`/tmp/tea-automate-e2e-tests-${timestamp}.json`);
+
+if (!apiOutputExists || !e2eOutputExists) {
+  throw new Error('One or both subprocess outputs missing!');
+}
+```
+
+---
+
+### 5. Performance Report
+
+**Display performance metrics:**
+
+```
+🚀 Performance Report:
+- Execution Mode: PARALLEL (2 subprocesses)
+- API Test Generation: ~X minutes
+- E2E Test Generation: ~Y minutes
+- Total Elapsed: ~max(X, Y) minutes
+- Sequential Would Take: ~(X + Y) minutes
+- Performance Gain: ~50% faster!
+```
+
+---
+
+### 6. Proceed to Aggregation
+
+**Load aggregation step:**
+Load next step: `{nextStepFile}`
+
+The aggregation step (3C) will:
+
+- Read both subprocess outputs
+- Write all test files to disk
+- Generate shared fixtures and helpers
+- Calculate summary statistics
+
+---
+
+## EXIT CONDITION
+
+Proceed to Step 3C (Aggregation) when:
+
+- ✅ Subprocess A (API tests) completed successfully
+- ✅ Subprocess B (E2E tests) completed successfully
+- ✅ Both output files exist and are valid JSON
+- ✅ Performance metrics displayed
+
+**Do NOT proceed if:**
+
+- ❌ One or both subprocesses failed
+- ❌ Output files missing or corrupted
+- ❌ Timeout occurred (subprocesses took too long)
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+
+### ✅ SUCCESS:
+
+- Both subprocesses launched successfully
+- Both subprocesses completed without errors
+- Output files generated and valid
+- Parallel execution achieved ~50% performance gain
+
+### ❌ SYSTEM FAILURE:
+
+- Failed to launch subprocesses
+- One or both subprocesses failed
+- Output files missing or invalid
+- Attempted sequential generation instead of parallel
+
+**Master Rule:** Parallel subprocess execution is MANDATORY for performance.

package/_bmad/tea/workflows/testarch/automate/steps-c/step-03a-subprocess-api.md

@@ -0,0 +1,183 @@
+---
+name: 'step-03a-subprocess-api'
+description: 'Subprocess: Generate API tests only'
+subprocess: true
+outputFile: '/tmp/tea-automate-api-tests-{{timestamp}}.json'
+---
+
+# Subprocess 3A: Generate API Tests
+
+## SUBPROCESS CONTEXT
+
+This is an **isolated subprocess** running in parallel with E2E test generation.
+
+**What you have from parent workflow:**
+
+- Target features/components identified in Step 2
+- Knowledge fragments loaded: api-request, data-factories, api-testing-patterns
+- Config: test framework, Playwright Utils enabled/disabled
+- Coverage plan: which API endpoints need testing
+
+**Your task:** Generate API tests ONLY (not E2E, not fixtures, not other test types).
+
+---
+
+## MANDATORY EXECUTION RULES
+
+- 📖 Read this entire subprocess file before acting
+- ✅ Generate API tests ONLY
+- ✅ Output structured JSON to temp file
+- ✅ Follow knowledge fragment patterns
+- ❌ Do NOT generate E2E tests (that's subprocess 3B)
+- ❌ Do NOT run tests (that's step 4)
+- ❌ Do NOT generate fixtures yet (that's step 3C aggregation)
+
+---
+
+## SUBPROCESS TASK
+
+### 1. Identify API Endpoints
+
+From the coverage plan (Step 2 output), identify:
+
+- Which API endpoints need test coverage
+- Expected request/response formats
+- Authentication requirements
+- Error scenarios to test
+
+### 2. Generate API Test Files
+
+For each API endpoint, create test file in `tests/api/[feature].spec.ts`:
+
+**Test Structure:**
+
+```typescript
+import { test, expect } from '@playwright/test';
+// If Playwright Utils enabled:
+// import { apiRequest } from '@playwright-utils/api';
+
+test.describe('[Feature] API Tests', () => {
+  test('[P0] should handle successful [operation]', async ({ request }) => {
+    // Use apiRequest helper if Playwright Utils enabled
+    // Otherwise use standard request fixture
+    const response = await request.post('/api/endpoint', {
+      data: {
+        /* test data */
+      },
+    });
+
+    expect(response.status()).toBe(200);
+    expect(await response.json()).toMatchObject({
+      /* expected */
+    });
+  });
+
+  test('[P1] should handle [error scenario]', async ({ request }) => {
+    // Test error handling
+  });
+});
+```
+
+**Requirements:**
+
+- ✅ Use `apiRequest()` helper if Playwright Utils enabled (from api-request fragment)
+- ✅ Use data factories for test data (from data-factories fragment)
+- ✅ Follow API testing patterns (from api-testing-patterns fragment)
+- ✅ Include priority tags [P0], [P1], [P2], [P3]
+- ✅ Test both happy path and error scenarios
+- ✅ Use proper TypeScript types
+- ✅ Deterministic assertions (no timing dependencies)
+
+### 3. Track Fixture Needs
+
+Identify fixtures needed for API tests:
+
+- Authentication fixtures (auth tokens, API keys)
+- Data factories (user data, product data, etc.)
+- API client configurations
+
+**Do NOT create fixtures yet** - just track what's needed for aggregation step.
+
+---
+
+## OUTPUT FORMAT
+
+Write JSON to temp file: `/tmp/tea-automate-api-tests-{{timestamp}}.json`
+
+```json
+{
+  "success": true,
+  "subprocess": "api-tests",
+  "tests": [
+    {
+      "file": "tests/api/auth.spec.ts",
+      "content": "[full TypeScript test file content]",
+      "description": "API tests for authentication endpoints",
+      "priority_coverage": {
+        "P0": 3,
+        "P1": 2,
+        "P2": 1,
+        "P3": 0
+      }
+    },
+    {
+      "file": "tests/api/checkout.spec.ts",
+      "content": "[full TypeScript test file content]",
+      "description": "API tests for checkout endpoints",
+      "priority_coverage": {
+        "P0": 2,
+        "P1": 3,
+        "P2": 1,
+        "P3": 0
+      }
+    }
+  ],
+  "fixture_needs": ["authToken", "userDataFactory", "productDataFactory"],
+  "knowledge_fragments_used": ["api-request", "data-factories", "api-testing-patterns"],
+  "test_count": 12,
+  "summary": "Generated 12 API test cases covering 3 features"
+}
+```
+
+**On Error:**
+
+```json
+{
+  "success": false,
+  "subprocess": "api-tests",
+  "error": "Error message describing what went wrong",
+  "partial_output": {
+    /* any tests generated before error */
+  }
+}
+```
+
+---
+
+## EXIT CONDITION
+
+Subprocess completes when:
+
+- ✅ All API endpoints have test files generated
+- ✅ All tests follow knowledge fragment patterns
+- ✅ JSON output written to temp file
+- ✅ Fixture needs tracked
+
+**Subprocess terminates here.** Parent workflow will read output and proceed to aggregation.
+
+---
+
+## 🚨 SUBPROCESS SUCCESS METRICS
+
+### ✅ SUCCESS:
+
+- All API tests generated following patterns
+- JSON output valid and complete
+- No E2E/component/unit tests included (out of scope)
+
+### ❌ FAILURE:
+
+- Generated tests other than API tests
+- Did not follow knowledge fragment patterns
+- Invalid or missing JSON output
+- Ran tests (not subprocess responsibility)