cc-mirror 1.0.3 → 1.1.0

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

@@ -0,0 +1,322 @@
+# Research Orchestration Patterns
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                                                             │
+│   Discovery is where great work begins.                     │
+│   Explore broadly, synthesize clearly, answer confidently.  │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+> **Load when**: Codebase exploration, technical investigation, dependency analysis, documentation research
+> **Common patterns**: Breadth-First Discovery, Feature Tracing, Root Cause Analysis
+
+## Table of Contents
+
+1. [Codebase Exploration](#codebase-exploration)
+2. [Technical Investigation](#technical-investigation)
+3. [Dependency Analysis](#dependency-analysis)
+4. [Documentation Research](#documentation-research)
+5. [Competitive Analysis](#competitive-analysis)
+
+---
+
+## Codebase Exploration
+
+### Pattern: Breadth-First Discovery
+
+```
+User Request: "Help me understand this codebase"
+
+Phase 1: FAN-OUT (Parallel surface scan)
+├─ Explore agent: Project structure, entry points
+├─ Explore agent: Package.json/requirements/build files
+├─ Explore agent: README, docs folder
+└─ Explore agent: Test structure and patterns
+
+Phase 2: REDUCE
+└─ General-purpose agent: Synthesize codebase overview
+
+Phase 3: FAN-OUT (Deep dive areas of interest)
+├─ Explore agent: Deep dive area 1
+├─ Explore agent: Deep dive area 2
+└─ Explore agent: Deep dive area 3
+```
+
+### Pattern: Feature Tracing
+
+```
+User Request: "How does user authentication work?"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find auth-related files (grep patterns)
+
+Phase 2: PIPELINE (Follow the flow)
+├─ Explore agent: Entry point (login route/component)
+├─ Explore agent: Middleware/validation layer
+├─ Explore agent: Session/token handling
+└─ Explore agent: Database/storage layer
+
+Phase 3: REDUCE
+└─ General-purpose agent: Document complete auth flow
+```
+
+### Pattern: Impact Analysis
+
+```
+User Request: "What would break if I change UserService?"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find UserService definition and interface
+
+Phase 2: FAN-OUT
+├─ Explore agent: Find all imports of UserService
+├─ Explore agent: Find all usages of each method
+└─ Explore agent: Find tests depending on UserService
+
+Phase 3: REDUCE
+└─ General-purpose agent: Impact report with risk assessment
+```
+
+---
+
+## Technical Investigation
+
+### Pattern: Root Cause Analysis
+
+```
+User Request: "Why is the API slow?"
+
+Phase 1: FAN-OUT (Parallel hypothesis generation)
+├─ Explore agent: Check database query patterns
+├─ Explore agent: Check API middleware chain
+├─ Explore agent: Check external service calls
+└─ Explore agent: Check caching implementation
+
+Phase 2: REDUCE
+└─ General-purpose agent: Ranked hypotheses with evidence
+
+Phase 3: PIPELINE (Validate top hypothesis)
+└─ General-purpose agent: Instrument/test to confirm
+```
+
+### Pattern: Technology Evaluation
+
+```
+User Request: "Should we use Redis or Memcached?"
+
+Phase 1: FAN-OUT (Parallel research)
+├─ Agent A (WebSearch): Redis features, use cases, benchmarks
+├─ Agent B (WebSearch): Memcached features, use cases, benchmarks
+└─ Explore agent: Current caching patterns in codebase
+
+Phase 2: REDUCE
+└─ Plan agent: Comparison matrix, recommendation with rationale
+```
+
+### Pattern: Bug Archaeology
+
+```
+User Request: "When did this bug get introduced?"
+
+Phase 1: EXPLORE
+└─ Explore agent: Identify relevant files and functions
+
+Phase 2: BACKGROUND
+└─ Background agent: Git bisect or log analysis
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Timeline of changes, root cause commit
+```
+
+---
+
+## Dependency Analysis
+
+### Pattern: Dependency Graph
+
+```
+User Request: "Map all dependencies for the auth module"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find auth module entry points
+
+Phase 2: FAN-OUT (Parallel tracing)
+├─ Explore agent: Trace internal dependencies
+├─ Explore agent: Trace external package dependencies
+└─ Explore agent: Trace database/service dependencies
+
+Phase 3: REDUCE
+└─ General-purpose agent: Dependency graph visualization
+```
+
+### Pattern: Upgrade Impact
+
+```
+User Request: "What happens if we upgrade lodash?"
+
+Phase 1: FAN-OUT
+├─ Explore agent: Find all lodash usages
+├─ Agent (WebSearch): lodash changelog, breaking changes
+└─ Explore agent: Find tests covering lodash functionality
+
+Phase 2: REDUCE
+└─ General-purpose agent: Impact assessment, migration guide
+```
+
+### Pattern: Dead Code Detection
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Build export/import graph
+
+Phase 2: FAN-OUT
+├─ Explore agent: Find unreferenced exports
+├─ Explore agent: Find unused internal functions
+└─ Explore agent: Find commented/disabled code
+
+Phase 3: REDUCE
+└─ General-purpose agent: Dead code report with safe removal list
+```
+
+---
+
+## Documentation Research
+
+### Pattern: API Discovery
+
+```
+User Request: "Document all API endpoints"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find route definitions (express routes, decorators, etc.)
+
+Phase 2: MAP (Per endpoint)
+├─ Agent A: Document endpoint group 1 (params, responses)
+├─ Agent B: Document endpoint group 2
+└─ Agent C: Document endpoint group 3
+
+Phase 3: REDUCE
+└─ General-purpose agent: Unified API documentation
+```
+
+### Pattern: Cross-Reference
+
+```
+User Request: "Find all documentation for the payment system"
+
+Phase 1: FAN-OUT
+├─ Explore agent: Search code comments
+├─ Explore agent: Search markdown files
+├─ Explore agent: Search wiki/confluence (if accessible)
+└─ Explore agent: Search inline JSDoc/docstrings
+
+Phase 2: REDUCE
+└─ General-purpose agent: Consolidated documentation index
+```
+
+---
+
+## Competitive Analysis
+
+### Pattern: Feature Comparison
+
+```
+User Request: "Compare our auth to Auth0"
+
+Phase 1: FAN-OUT
+├─ Explore agent: Document our auth capabilities
+├─ Agent (WebSearch): Auth0 features and pricing
+└─ Agent (WebSearch): Auth0 limitations and reviews
+
+Phase 2: REDUCE
+└─ Plan agent: Feature matrix, gap analysis
+```
+
+### Pattern: Best Practices Research
+
+```
+User Request: "What are best practices for rate limiting?"
+
+Phase 1: FAN-OUT
+├─ Agent (WebSearch): Industry rate limiting patterns
+├─ Agent (WebSearch): Framework-specific implementations
+├─ Explore agent: Current rate limiting in codebase
+└─ Agent (WebSearch): Case studies and failure modes
+
+Phase 2: REDUCE
+└─ General-purpose agent: Best practices guide with recommendations
+```
+
+---
+
+## Research Output Formats
+
+### Investigation Report Template
+
+```markdown
+## Question
+
+[Original question/request]
+
+## Summary
+
+[1-2 sentence answer]
+
+## Evidence
+
+1. [Finding 1 with file:line references]
+2. [Finding 2 with file:line references]
+
+## Analysis
+
+[Interpretation of evidence]
+
+## Recommendations
+
+1. [Actionable recommendation]
+
+## Open Questions
+
+- [What wasn't answered]
+```
+
+### Task Management for Research
+
+For research tasks, structure as exploration followed by synthesis:
+
+```python
+# Create research tasks
+TaskCreate(subject="Define research scope", description="Clarify questions, identify sources...")
+TaskCreate(subject="Explore area 1", description="Search for patterns in auth module...")
+TaskCreate(subject="Explore area 2", description="Search for patterns in API layer...")
+TaskCreate(subject="Explore area 3", description="Search for patterns in database...")
+TaskCreate(subject="Synthesize findings", description="Aggregate discoveries, form conclusions...")
+
+# Exploration can run in parallel, synthesis waits
+TaskUpdate(taskId="2", addBlockedBy=["1"])
+TaskUpdate(taskId="3", addBlockedBy=["1"])
+TaskUpdate(taskId="4", addBlockedBy=["1"])
+TaskUpdate(taskId="5", addBlockedBy=["2", "3", "4"])
+
+# Spawn Explore agents in parallel
+Task(subagent_type="Explore", prompt="TaskId 2: Find auth patterns...")
+Task(subagent_type="Explore", prompt="TaskId 3: Find API patterns...")
+Task(subagent_type="Explore", prompt="TaskId 4: Find database patterns...")
+```
+
+## Agent Selection for Research
+
+| Research Type      | Primary Agent      | Secondary Agents                |
+| ------------------ | ------------------ | ------------------------------- |
+| Codebase questions | Explore            | General-purpose for synthesis   |
+| External research  | WebSearch-enabled  | Explore for local context       |
+| Architecture       | Plan               | Explore for discovery           |
+| Impact analysis    | Explore (parallel) | General-purpose for aggregation |
+
+---
+
+```
+─── ◈ Research ──────────────────────────
+```

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

@@ -0,0 +1,269 @@
+# Software Development Orchestration Patterns
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                                                             │
+│   Building software is what we do best.                     │
+│   Features, fixes, refactors — all orchestrated elegantly.  │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+> **Load when**: Feature implementation, bug fixes, refactoring, migrations, greenfield development
+> **Common patterns**: Plan-Parallel-Integrate, Diagnose-Hypothesize-Fix, Map-Analyze-Transform
+
+## Table of Contents
+
+1. [Feature Implementation](#feature-implementation)
+2. [Bug Fixing](#bug-fixing)
+3. [Refactoring](#refactoring)
+4. [Migration](#migration)
+5. [Greenfield Development](#greenfield-development)
+
+---
+
+## Feature Implementation
+
+### Pattern: Plan-Parallel-Integrate
+
+```
+User Request: "Add user authentication"
+
+Phase 1: PIPELINE (Research → Plan)
+├─ Explore agent: Find existing auth patterns, user models, middleware
+└─ Plan agent: Design auth architecture using findings
+
+Phase 2: FAN-OUT (Parallel Implementation)
+├─ Agent A: Implement user model + database schema
+├─ Agent B: Implement JWT/session middleware
+├─ Agent C: Implement login/logout routes
+└─ Agent D: Implement frontend auth components
+
+Phase 3: PIPELINE (Integration)
+└─ General-purpose agent: Wire components, add tests, verify flow
+```
+
+**Task breakdown:**
+
+```
+TaskCreate("Design authentication architecture")
+TaskCreate("Implement user model and schema")
+TaskCreate("Build auth middleware")
+TaskCreate("Create auth API routes")
+TaskCreate("Build frontend auth UI")
+TaskCreate("Integration testing")
+
+# Dependencies
+Task 2-5 blocked by Task 1
+Task 6 blocked by Tasks 2-5
+```
+
+### Pattern: Vertical Slice
+
+For full-stack features, implement one complete slice first:
+
+```
+Phase 1: Single complete flow
+└─ General-purpose agent: DB → API → UI for one use case
+
+Phase 2: FAN-OUT expansion
+├─ Agent A: Additional DB operations
+├─ Agent B: Additional API endpoints
+└─ Agent C: Additional UI components
+```
+
+---
+
+## Bug Fixing
+
+### Pattern: Diagnose-Hypothesize-Fix
+
+```
+User Request: "Users can't log in after password reset"
+
+Phase 1: FAN-OUT (Parallel Diagnosis)
+├─ Explore agent: Search error logs, recent changes to auth
+├─ Explore agent: Find password reset flow implementation
+└─ Explore agent: Check session/token handling
+
+Phase 2: PIPELINE (Analysis)
+└─ General-purpose agent: Synthesize findings, form hypotheses
+
+Phase 3: SPECULATIVE (If cause unclear)
+├─ Agent A: Test hypothesis 1 (token expiry issue)
+├─ Agent B: Test hypothesis 2 (session invalidation)
+└─ Agent C: Test hypothesis 3 (password hash mismatch)
+
+Phase 4: PIPELINE
+└─ General-purpose agent: Implement fix, add regression test
+```
+
+### Pattern: Reproduction-First
+
+```
+Phase 1: Reproduce
+└─ General-purpose agent: Create minimal reproduction case
+
+Phase 2: Bisect (if needed)
+└─ Background agent: Git bisect to find breaking commit
+
+Phase 3: Fix
+└─ General-purpose agent: Implement and verify fix
+```
+
+---
+
+## Refactoring
+
+### Pattern: Map-Analyze-Transform
+
+```
+User Request: "Refactor callback-based code to async/await"
+
+Phase 1: MAP (Find all instances)
+└─ Explore agent: Find all callback patterns in codebase
+
+Phase 2: FAN-OUT (Analyze impact)
+├─ Agent A: Analyze module A dependencies
+├─ Agent B: Analyze module B dependencies
+└─ Agent C: Analyze module C dependencies
+
+Phase 3: PIPELINE (Safe transformation)
+├─ Plan agent: Design migration order (leaf nodes first)
+└─ General-purpose agent: Transform files in dependency order
+```
+
+### Pattern: Strangler Fig
+
+For large refactors, wrap old with new:
+
+```
+Phase 1: Create parallel implementation
+├─ Agent A: Build new abstraction layer
+└─ Agent B: Implement new pattern alongside old
+
+Phase 2: Gradual migration
+└─ General-purpose agents: Migrate consumers one by one
+
+Phase 3: Cleanup
+└─ General-purpose agent: Remove old implementation
+```
+
+---
+
+## Migration
+
+### Pattern: Schema-Data-Code
+
+```
+User Request: "Migrate from MongoDB to PostgreSQL"
+
+Phase 1: FAN-OUT (Analysis)
+├─ Explore agent: Document all MongoDB schemas
+├─ Explore agent: Find all database queries
+└─ Explore agent: Identify data transformation needs
+
+Phase 2: PIPELINE (Schema)
+└─ General-purpose agent: Create PostgreSQL schemas, migrations
+
+Phase 3: FAN-OUT (Code updates)
+├─ Agent A: Update user-related queries
+├─ Agent B: Update product-related queries
+└─ Agent C: Update order-related queries
+
+Phase 4: PIPELINE (Data migration)
+└─ General-purpose agent: Write and run data migration scripts
+```
+
+### Pattern: Version Upgrade
+
+```
+User Request: "Upgrade React from v17 to v18"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find breaking changes, deprecated APIs used
+
+Phase 2: MAP-REDUCE
+├─ Agent A: Update component files batch 1
+├─ Agent B: Update component files batch 2
+└─ Agent C: Update component files batch 3
+→ Aggregate: Collect all breaking changes found
+
+Phase 3: PIPELINE
+├─ General-purpose agent: Fix breaking changes
+└─ Background agent: Run full test suite
+```
+
+---
+
+## Greenfield Development
+
+### Pattern: Scaffold-Parallel-Integrate
+
+```
+User Request: "Build a REST API for task management"
+
+Phase 1: PIPELINE (Foundation)
+├─ Plan agent: Design API architecture, endpoints, data models
+└─ General-purpose agent: Scaffold project, setup tooling
+
+Phase 2: FAN-OUT (Core features)
+├─ Agent A: User management (model, routes, auth)
+├─ Agent B: Task CRUD operations
+├─ Agent C: Project/workspace management
+└─ Agent D: Shared middleware, utilities
+
+Phase 3: FAN-OUT (Cross-cutting)
+├─ Agent A: Error handling, validation
+├─ Agent B: Logging, monitoring setup
+└─ Agent C: API documentation
+
+Phase 4: PIPELINE (Polish)
+└─ General-purpose agent: Integration tests, final wiring
+```
+
+### Pattern: MVP-First
+
+```
+Phase 1: Minimal viable implementation
+└─ General-purpose agent: End-to-end flow, minimal features
+
+Phase 2: BACKGROUND (Feedback loop)
+├─ User testing while...
+└─ Background agents prepare next features
+
+Phase 3: FAN-OUT (Feature expansion)
+├─ Multiple agents expand different features in parallel
+```
+
+---
+
+## Task Management Integration
+
+For any software development task, create explicit tasks:
+
+```python
+# Decompose the work
+TaskCreate(subject="Analyze requirements", description="Understand codebase patterns, existing code...")
+TaskCreate(subject="Design approach", description="Plan implementation strategy...")
+TaskCreate(subject="Implement core functionality", description="Build the main feature...")
+TaskCreate(subject="Add error handling", description="Handle edge cases, validation...")
+TaskCreate(subject="Write tests", description="Unit and integration tests...")
+
+# Set dependencies
+TaskUpdate(taskId="2", addBlockedBy=["1"])  # Design after analysis
+TaskUpdate(taskId="3", addBlockedBy=["2"])  # Implement after design
+TaskUpdate(taskId="4", addBlockedBy=["3"])  # Error handling after core
+TaskUpdate(taskId="5", addBlockedBy=["3"])  # Tests can parallel with error handling
+
+# Spawn agents for unblocked tasks
+Task(subagent_type="general-purpose", prompt="TaskId 1: Analyze requirements...")
+```
+
+Agents mark tasks resolved immediately upon completion.
+
+---
+
+```
+─── ◈ Software Development ─────────────
+```