cc-mirror 1.0.4 → 1.1.1

package/dist/skills/multi-agent-orchestrator/references/domains/testing.md

@@ -0,0 +1,313 @@
+# Testing Orchestration Patterns
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                                                             │
+│   Confidence through verification.                          │
+│   Generate, execute, analyze — all in parallel.             │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+> **Load when**: Test generation, test execution, coverage analysis, test maintenance, E2E testing
+> **Common patterns**: Coverage-Driven Generation, Parallel Test Suites, Broken Test Triage
+
+## Table of Contents
+
+1. [Test Generation](#test-generation)
+2. [Test Execution](#test-execution)
+3. [Coverage Analysis](#coverage-analysis)
+4. [Test Maintenance](#test-maintenance)
+5. [E2E Testing](#e2e-testing)
+
+---
+
+## Test Generation
+
+### Pattern: Coverage-Driven Generation
+
+```
+User Request: "Add tests for the UserService"
+
+Phase 1: EXPLORE
+└─ Explore agent: Understand UserService methods, dependencies
+
+Phase 2: FAN-OUT (Parallel test writing)
+├─ Agent A: Unit tests for method group 1
+├─ Agent B: Unit tests for method group 2
+├─ Agent C: Integration tests for external dependencies
+└─ Agent D: Edge cases and error scenarios
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Verify tests pass, check coverage
+```
+
+### Pattern: Behavior-First
+
+```
+User Request: "Test the checkout flow"
+
+Phase 1: EXPLORE
+└─ Explore agent: Map checkout flow steps and branches
+
+Phase 2: PIPELINE (Generate by behavior)
+├─ General-purpose agent: Happy path tests
+├─ General-purpose agent: Error path tests
+└─ General-purpose agent: Edge case tests
+
+Phase 3: BACKGROUND
+└─ Background agent: Run tests, report results
+```
+
+### Pattern: Contract Testing
+
+```
+User Request: "Add API contract tests"
+
+Phase 1: EXPLORE
+└─ Explore agent: Document API endpoints and schemas
+
+Phase 2: FAN-OUT
+├─ Agent A: Request validation tests
+├─ Agent B: Response schema tests
+└─ Agent C: Error response tests
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Integrate with CI, add OpenAPI validation
+```
+
+---
+
+## Test Execution
+
+### Pattern: Parallel Test Suites
+
+```
+User Request: "Run all tests"
+
+Phase 1: FAN-OUT (Parallel suites)
+├─ Background agent: Unit tests
+├─ Background agent: Integration tests
+├─ Background agent: E2E tests
+└─ Background agent: Performance tests
+
+Phase 2: REDUCE
+└─ General-purpose agent: Aggregate results, identify failures
+```
+
+### Pattern: Targeted Execution
+
+```
+User Request: "Test the changes I made"
+
+Phase 1: EXPLORE
+└─ Explore agent: Identify changed files and affected tests
+
+Phase 2: FAN-OUT
+├─ Background agent: Run directly affected tests
+└─ Background agent: Run dependent module tests
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Report results, suggest additional tests
+```
+
+### Pattern: Flaky Test Detection
+
+```
+Phase 1: BACKGROUND (Multiple runs)
+├─ Background agent: Run test suite (run 1)
+├─ Background agent: Run test suite (run 2)
+└─ Background agent: Run test suite (run 3)
+
+Phase 2: REDUCE
+└─ General-purpose agent: Compare results, identify inconsistencies
+```
+
+---
+
+## Coverage Analysis
+
+### Pattern: Gap Identification
+
+```
+User Request: "Improve test coverage"
+
+Phase 1: BACKGROUND
+└─ Background agent: Run coverage report
+
+Phase 2: EXPLORE
+└─ Explore agent: Identify critical uncovered paths
+
+Phase 3: FAN-OUT (Prioritized gap filling)
+├─ Agent A: Tests for critical uncovered module 1
+├─ Agent B: Tests for critical uncovered module 2
+└─ Agent C: Tests for error handlers
+
+Phase 4: PIPELINE
+└─ General-purpose agent: Re-run coverage, verify improvement
+```
+
+### Pattern: Risk-Based Coverage
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify high-risk code (complexity, change frequency)
+
+Phase 2: FAN-OUT
+├─ Agent A: Analyze coverage of high-risk area 1
+├─ Agent B: Analyze coverage of high-risk area 2
+└─ Agent C: Analyze coverage of high-risk area 3
+
+Phase 3: REDUCE
+└─ General-purpose agent: Prioritized test improvement plan
+```
+
+---
+
+## Test Maintenance
+
+### Pattern: Broken Test Triage
+
+```
+User Request: "Fix failing tests"
+
+Phase 1: BACKGROUND
+└─ Background agent: Run tests, capture failures
+
+Phase 2: FAN-OUT (Parallel diagnosis)
+├─ Agent A: Diagnose failure group 1
+├─ Agent B: Diagnose failure group 2
+└─ Agent C: Diagnose failure group 3
+
+Phase 3: FAN-OUT (Parallel fixes)
+├─ Agent A: Fix test group 1
+├─ Agent B: Fix test group 2
+└─ Agent C: Fix test group 3
+
+Phase 4: PIPELINE
+└─ Background agent: Verify all tests pass
+```
+
+### Pattern: Test Refactoring
+
+```
+User Request: "Clean up test duplication"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find duplicate test patterns
+
+Phase 2: PLAN
+└─ Plan agent: Design shared fixtures, helpers, patterns
+
+Phase 3: FAN-OUT
+├─ Agent A: Extract shared fixtures
+├─ Agent B: Refactor test file group 1
+└─ Agent C: Refactor test file group 2
+
+Phase 4: PIPELINE
+└─ Background agent: Verify tests still pass
+```
+
+### Pattern: Mock Maintenance
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Find outdated mocks (API changes, schema changes)
+
+Phase 2: FAN-OUT
+├─ Agent A: Update mock group 1
+├─ Agent B: Update mock group 2
+└─ Agent C: Update fixtures and factories
+
+Phase 3: PIPELINE
+└─ Background agent: Run affected tests
+```
+
+---
+
+## E2E Testing
+
+### Pattern: User Journey Testing
+
+```
+User Request: "Add E2E tests for user registration"
+
+Phase 1: EXPLORE
+└─ Explore agent: Map registration flow, identify test scenarios
+
+Phase 2: PIPELINE (Sequential scenarios)
+├─ General-purpose agent: Happy path registration
+├─ General-purpose agent: Validation error scenarios
+├─ General-purpose agent: Duplicate email handling
+└─ General-purpose agent: Email verification flow
+
+Phase 3: BACKGROUND
+└─ Background agent: Run E2E suite, capture screenshots
+```
+
+### Pattern: Cross-Browser Testing
+
+```
+Phase 1: FAN-OUT (Parallel browsers)
+├─ Background agent: Run E2E in Chrome
+├─ Background agent: Run E2E in Firefox
+├─ Background agent: Run E2E in Safari
+└─ Background agent: Run E2E in Edge
+
+Phase 2: REDUCE
+└─ General-purpose agent: Browser compatibility report
+```
+
+### Pattern: Visual Regression
+
+```
+Phase 1: BACKGROUND
+└─ Background agent: Run visual regression tests
+
+Phase 2: EXPLORE (If failures)
+└─ Explore agent: Compare screenshots, identify changes
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Categorize as bugs vs intentional changes
+```
+
+---
+
+## Task Management for Testing
+
+Structure testing work as tasks with clear dependencies:
+
+```python
+# Create testing tasks
+TaskCreate(subject="Identify testing scope", description="Analyze what needs testing...")
+TaskCreate(subject="Generate unit tests", description="Tests for module A...")
+TaskCreate(subject="Generate integration tests", description="Tests for API endpoints...")
+TaskCreate(subject="Run test suite", description="Execute all tests, capture results...")
+TaskCreate(subject="Fix failures", description="Address any failing tests...")
+TaskCreate(subject="Verify all pass", description="Final test run to confirm...")
+
+# Dependencies
+TaskUpdate(taskId="2", addBlockedBy=["1"])
+TaskUpdate(taskId="3", addBlockedBy=["1"])
+TaskUpdate(taskId="4", addBlockedBy=["2", "3"])
+TaskUpdate(taskId="5", addBlockedBy=["4"])
+TaskUpdate(taskId="6", addBlockedBy=["5"])
+
+# Parallel test generation
+Task(subagent_type="general-purpose", prompt="TaskId 2: Generate unit tests...")
+Task(subagent_type="general-purpose", prompt="TaskId 3: Generate integration tests...")
+```
+
+## Test Execution Best Practices
+
+1. **Always run in background** for long test suites
+2. **Parallelize independent suites** (unit, integration, e2e)
+3. **Fail fast** - stop on first failure for quick feedback
+4. **Capture artifacts** - screenshots, logs, coverage reports
+5. **Report actionable results** - file:line for failures
+
+---
+
+```
+─── ◈ Testing ───────────────────────────
+```

package/dist/skills/multi-agent-orchestrator/references/examples.md

@@ -0,0 +1,377 @@
+# Orchestration Examples
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                                                             │
+│   Real-world workflows, end to end.                         │
+│   See how patterns come together in practice.               │
+│                                                             │
+│   Each example shows:                                       │
+│   • What the user says                                      │
+│   • How you orchestrate (internal)                          │
+│   • What the user experiences (external)                    │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Table of Contents
+
+1. [Review a PR](#review-a-pr)
+2. [Implement a Feature](#implement-a-feature)
+3. [Fix a Bug](#fix-a-bug)
+4. [Understand a Codebase](#understand-a-codebase)
+5. [Run Tests and Fix Failures](#run-tests-and-fix-failures)
+
+---
+
+## Review a PR
+
+**User says:** "Review PR #123"
+
+### Internal Analysis
+
+- Multi-dimensional analysis needed (code quality, security, performance)
+- Independent dimensions → **Fan-Out**
+- Need to aggregate findings → **Map-Reduce**
+
+### Execution
+
+```python
+# Phase 1: Gather context + parallel analysis (single message)
+Task(subagent_type="Explore", description="Get PR context",
+     prompt="Fetch PR #123 details, understand what changed and why")
+Task(subagent_type="general-purpose", description="Review quality",
+     prompt="Review code quality: readability, patterns, maintainability")
+Task(subagent_type="general-purpose", description="Review security",
+     prompt="Review security: injection, auth, data exposure risks")
+Task(subagent_type="general-purpose", description="Review performance",
+     prompt="Review performance: complexity, queries, memory usage")
+```
+
+### User Sees
+
+```
+Reviewing PR #123 from multiple angles...
+
+---
+
+## Summary
+Adds user profile editing with image upload capability.
+
+## Risk Assessment
+- Security: Medium (file upload needs validation)
+- Performance: Low
+- Breaking Changes: No
+
+## Must Fix
+1. Missing file type validation in upload handler (line 47)
+   - Could allow malicious file uploads
+
+## Should Fix
+1. Add rate limiting to profile update endpoint
+2. Consider compressing uploaded images
+
+## Looks Good
+- Clean component structure
+- Good error handling in UI
+- Tests cover happy path
+```
+
+---
+
+## Implement a Feature
+
+**User says:** "Add dark mode to the app"
+
+### Internal Analysis
+
+- Need to understand existing styling → Research first
+- Multiple independent components → **Fan-Out** for implementation
+- Must integrate at end → **Pipeline** finish
+
+### Execution
+
+```python
+# Phase 1: Research (Pipeline)
+context = Task(subagent_type="Explore", description="Find styling patterns",
+               prompt="Find existing theme/styling patterns, CSS architecture")
+
+# Phase 2: Plan
+plan = Task(subagent_type="Plan", description="Design dark mode",
+            prompt=f"Given: {context}. Design dark mode implementation.")
+
+# Phase 3: Implement (Fan-Out - single message)
+Task(subagent_type="general-purpose", description="Add CSS variables",
+     prompt="Add dark theme CSS variables...")
+Task(subagent_type="general-purpose", description="Create toggle",
+     prompt="Create theme toggle component...")
+Task(subagent_type="general-purpose", description="Add persistence",
+     prompt="Add localStorage persistence for theme preference...")
+
+# Phase 4: Integration (Pipeline)
+Task(subagent_type="general-purpose", description="Wire and test",
+     prompt="Wire components together, test theme switching works")
+```
+
+### User Sees
+
+```
+Adding dark mode to your app.
+
+Exploring your codebase to understand styling patterns...
+
+Found: Tailwind with CSS variables in globals.css, no existing theme system.
+
+Plan:
+1. Add CSS variables for dark theme colors
+2. Create theme toggle component
+3. Persist preference in localStorage
+4. Wire up and test
+
+Starting implementation...
+
+---
+
+Progress:
+- Added dark theme variables to globals.css
+- Created ThemeToggle component at components/theme-toggle.tsx
+
+Working on persistence...
+
+---
+
+Done! Dark mode is ready:
+- Toggle in header (components/theme-toggle.tsx)
+- Preference saved to localStorage
+- System preference detected on first visit
+
+Try it: Click the moon/sun icon in the header.
+```
+
+---
+
+## Fix a Bug
+
+**User says:** "Users can't log in after password reset"
+
+### Internal Analysis
+
+- Unknown cause → Need parallel investigation
+- Multiple hypotheses → **Fan-Out** for diagnosis
+- May need **Speculative** if cause unclear
+
+### Execution
+
+```python
+# Phase 1: Parallel diagnosis (Fan-Out - single message)
+Task(subagent_type="Explore", description="Check logs",
+     prompt="Search for login errors, password reset issues in logs")
+Task(subagent_type="Explore", description="Find reset flow",
+     prompt="Find password reset implementation, trace the flow")
+Task(subagent_type="Explore", description="Check session handling",
+     prompt="How are sessions/tokens handled after password change?")
+
+# Phase 2: Synthesize (after results return)
+# Identify: Password reset invalidates session but doesn't clear cookie
+
+# Phase 3: Fix
+Task(subagent_type="general-purpose", description="Fix session bug",
+     prompt="Clear session cookie after password reset...")
+
+# Phase 4: Verify
+Task(subagent_type="general-purpose", description="Add regression test",
+     prompt="Add test for login after password reset...")
+```
+
+### User Sees
+
+```
+Investigating the login issue after password reset...
+
+Checking a few things:
+- Error logs
+- Password reset flow
+- Session handling
+
+---
+
+Found the issue: Password reset invalidates the session token in the database,
+but the old session cookie remains in the browser. On next login attempt,
+the invalid cookie causes auth to fail.
+
+Fix: Clear the session cookie when password is reset.
+
+Implementing fix...
+
+---
+
+Fixed in auth/password-reset.ts (line 89).
+Added regression test in __tests__/auth.test.ts.
+
+The flow now:
+1. User resets password
+2. Session cookie is cleared
+3. User redirected to login
+4. Fresh login works correctly
+```
+
+---
+
+## Understand a Codebase
+
+**User says:** "Help me understand this codebase"
+
+### Internal Analysis
+
+- Breadth-first exploration needed
+- Multiple independent areas → **Fan-Out**
+- Aggregate into overview → **Map-Reduce**
+
+### Execution
+
+```python
+# Phase 1: Parallel exploration (Fan-Out - single message)
+Task(subagent_type="Explore", description="Project structure",
+     prompt="Analyze project structure, entry points, build system")
+Task(subagent_type="Explore", description="Core patterns",
+     prompt="Identify core architectural patterns, frameworks used")
+Task(subagent_type="Explore", description="Data flow",
+     prompt="Trace main data flows, API structure, state management")
+```
+
+### User Sees
+
+```
+Exploring the codebase...
+
+---
+
+## Overview
+Next.js 14 app with TypeScript, using App Router.
+
+## Structure
+```
+
+src/
+├── app/ # Routes and pages
+├── components/ # React components (shadcn/ui)
+├── lib/ # Utilities and helpers
+├── services/ # API clients and business logic
+└── types/ # TypeScript types
+
+````
+
+## Key Patterns
+- **Data fetching**: Server components with async/await
+- **State**: React Context for auth, Zustand for UI state
+- **Styling**: Tailwind CSS with shadcn/ui components
+- **API**: REST endpoints in app/api/, Prisma for database
+
+## Entry Points
+- `app/page.tsx` - Home page
+- `app/api/` - API routes
+- `middleware.ts` - Auth middleware
+
+## Getting Started
+```bash
+npm install
+npm run dev
+````
+
+Want me to dive deeper into any area?
+
+````
+
+---
+
+## Run Tests and Fix Failures
+
+**User says:** "Run tests and fix any failures"
+
+### Internal Analysis
+- Long-running task → **Background** for tests
+- Multiple failures → **Fan-Out** for fixes
+
+### Execution
+
+```python
+# Phase 1: Run tests in background
+Task(subagent_type="general-purpose", description="Run tests",
+     prompt="Run full test suite, report failures",
+     run_in_background=True)
+
+# Continue with other work or wait
+result = TaskOutput(task_id="...", block=True)
+
+# Phase 2: Fix failures (Fan-Out if multiple)
+# If 3 failures found:
+Task(subagent_type="general-purpose", description="Fix test 1",
+     prompt="Fix failing test in auth.test.ts...")
+Task(subagent_type="general-purpose", description="Fix test 2",
+     prompt="Fix failing test in api.test.ts...")
+Task(subagent_type="general-purpose", description="Fix test 3",
+     prompt="Fix failing test in utils.test.ts...")
+
+# Phase 3: Verify
+Task(subagent_type="general-purpose", description="Re-run tests",
+     prompt="Run test suite again to verify fixes")
+````
+
+### User Sees
+
+```
+Running test suite...
+
+---
+
+Test Results: 47 passed, 3 failed
+
+Failures:
+1. auth.test.ts - "should reject expired tokens"
+2. api.test.ts - "should handle rate limiting"
+3. utils.test.ts - "should format dates correctly"
+
+Fixing these now...
+
+---
+
+Fixed all 3 failures:
+1. auth.test.ts - Updated mock token expiry time
+2. api.test.ts - Added missing rate limit header in test
+3. utils.test.ts - Fixed timezone handling in date formatter
+
+Re-running tests...
+
+---
+
+All 50 tests passing.
+```
+
+---
+
+## Key Patterns Summary
+
+| Scenario    | Pattern                       | Why                                 |
+| ----------- | ----------------------------- | ----------------------------------- |
+| PR Review   | Fan-Out → Reduce              | Parallel analysis, unified output   |
+| Feature     | Pipeline → Fan-Out → Pipeline | Research, parallel build, integrate |
+| Bug Fix     | Fan-Out → Pipeline            | Parallel diagnosis, sequential fix  |
+| Exploration | Fan-Out → Reduce              | Parallel discovery, synthesize      |
+| Tests       | Background → Fan-Out          | Long-running, parallel fixes        |
+
+---
+
+```
+┌────────────────────────────────────────┐
+│  Remember:                             │
+│                                        │
+│  • Users see natural conversation      │
+│  • Pattern names stay internal         │
+│  • Results feel like magic             │
+│                                        │
+└────────────────────────────────────────┘
+```
+
+```
+─── ◈ Examples Complete ─────────────────
+```