cc-mirror 1.0.3 → 1.1.0

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

@@ -0,0 +1,310 @@
+# Documentation Orchestration Patterns
+
+## Table of Contents
+1. [API Documentation](#api-documentation)
+2. [Code Documentation](#code-documentation)
+3. [README Generation](#readme-generation)
+4. [Architecture Documentation](#architecture-documentation)
+5. [User Guides](#user-guides)
+
+---
+
+## API Documentation
+
+### Pattern: Endpoint Discovery and Documentation
+
+```
+User Request: "Document all REST API endpoints"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find all route definitions
+
+Phase 2: FAN-OUT (Parallel documentation by domain)
+├─ Agent A: Document auth endpoints
+├─ Agent B: Document user endpoints
+├─ Agent C: Document product endpoints
+└─ Agent D: Document order endpoints
+
+Phase 3: REDUCE
+└─ General-purpose agent: Compile into unified OpenAPI/Swagger spec
+```
+
+### Pattern: Request/Response Documentation
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Find endpoint handlers and schemas
+
+Phase 2: FAN-OUT (Per endpoint group)
+├─ Agent A: Document request schemas, validation
+├─ Agent B: Document response schemas, status codes
+└─ Agent C: Document error responses
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Generate examples, test payloads
+```
+
+### Pattern: Interactive Documentation
+
+```
+Phase 1: PIPELINE (Foundation)
+├─ Explore agent: Extract all endpoints with types
+└─ General-purpose agent: Generate OpenAPI spec
+
+Phase 2: FAN-OUT (Enhancement)
+├─ Agent A: Add example requests
+├─ Agent B: Add example responses
+└─ Agent C: Add authentication examples
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Setup Swagger UI / Redoc
+```
+
+---
+
+## Code Documentation
+
+### Pattern: Batch JSDoc/Docstring Generation
+
+```
+User Request: "Add documentation to the utils module"
+
+Phase 1: EXPLORE
+└─ Explore agent: Find all undocumented functions
+
+Phase 2: MAP (Parallel documentation)
+├─ Agent A: Document file1.ts functions
+├─ Agent B: Document file2.ts functions
+└─ Agent C: Document file3.ts functions
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Verify consistency, generate type docs
+```
+
+### Pattern: Complexity-Driven Documentation
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Find complex functions (high cyclomatic complexity)
+
+Phase 2: FAN-OUT (Prioritized)
+├─ Agent A: Document most complex function
+├─ Agent B: Document second most complex
+└─ Agent C: Document third most complex
+
+Each agent:
+- Explain algorithm/logic
+- Document edge cases
+- Add usage examples
+```
+
+### Pattern: Module Overview Generation
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Map module structure, exports, dependencies
+
+Phase 2: PIPELINE
+├─ General-purpose agent: Write module overview
+├─ General-purpose agent: Document public API
+└─ General-purpose agent: Add usage examples
+
+Phase 3: FAN-OUT (Internal docs)
+├─ Agent A: Document internal utilities
+└─ Agent B: Document configuration options
+```
+
+---
+
+## README Generation
+
+### Pattern: Comprehensive README
+
+```
+User Request: "Create a README for this project"
+
+Phase 1: FAN-OUT (Parallel information gathering)
+├─ Explore agent: Project structure and technologies
+├─ Explore agent: Build and run scripts (package.json, Makefile)
+├─ Explore agent: Environment variables and config
+├─ Explore agent: Test setup and commands
+└─ Explore agent: Existing docs and comments
+
+Phase 2: REDUCE
+└─ General-purpose agent: Synthesize into structured README
+
+Sections:
+- Overview and purpose
+- Quick start
+- Installation
+- Configuration
+- Usage examples
+- Development setup
+- Testing
+- Contributing
+```
+
+### Pattern: README Update
+
+```
+Phase 1: FAN-OUT
+├─ Explore agent: Current README content
+├─ Explore agent: Recent changes to codebase
+└─ Explore agent: New dependencies or features
+
+Phase 2: PIPELINE
+└─ General-purpose agent: Update README sections, maintain style
+```
+
+---
+
+## Architecture Documentation
+
+### Pattern: C4 Model Documentation
+
+```
+User Request: "Document the system architecture"
+
+Phase 1: FAN-OUT (Parallel level documentation)
+├─ Agent A: Context diagram (system + external actors)
+├─ Agent B: Container diagram (applications, data stores)
+├─ Agent C: Component diagram (internal components)
+└─ Agent D: Code diagram (critical classes/modules)
+
+Phase 2: REDUCE
+└─ General-purpose agent: Compile into architecture doc with diagrams
+```
+
+### Pattern: Decision Record Generation
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Find architectural patterns in code
+
+Phase 2: FAN-OUT
+├─ Agent A: Document decision 1 (why this database?)
+├─ Agent B: Document decision 2 (why this framework?)
+└─ Agent C: Document decision 3 (why this structure?)
+
+Each ADR includes:
+- Context
+- Decision
+- Consequences
+- Alternatives considered
+```
+
+### Pattern: Data Flow Documentation
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Trace data through system
+
+Phase 2: PIPELINE
+├─ General-purpose agent: Document ingress points
+├─ General-purpose agent: Document transformations
+├─ General-purpose agent: Document storage
+└─ General-purpose agent: Document egress points
+
+Phase 3: REDUCE
+└─ General-purpose agent: Create data flow diagram
+```
+
+---
+
+## User Guides
+
+### Pattern: Feature-Based Guides
+
+```
+User Request: "Write user documentation for the dashboard"
+
+Phase 1: EXPLORE
+└─ Explore agent: Map dashboard features and capabilities
+
+Phase 2: FAN-OUT (Parallel feature guides)
+├─ Agent A: Guide for feature 1 (with screenshots)
+├─ Agent B: Guide for feature 2
+├─ Agent C: Guide for feature 3
+└─ Agent D: Troubleshooting guide
+
+Phase 3: REDUCE
+└─ General-purpose agent: Compile into user manual with TOC
+```
+
+### Pattern: Tutorial Generation
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify key user workflows
+
+Phase 2: PIPELINE (Sequential tutorials)
+├─ General-purpose agent: Getting started tutorial
+├─ General-purpose agent: Basic usage tutorial
+├─ General-purpose agent: Advanced usage tutorial
+└─ General-purpose agent: Best practices guide
+```
+
+### Pattern: FAQ Generation
+
+```
+Phase 1: FAN-OUT
+├─ Explore agent: Common patterns in issues/tickets
+├─ Explore agent: Error messages and their causes
+└─ Explore agent: Configuration gotchas
+
+Phase 2: REDUCE
+└─ General-purpose agent: Compile FAQ with clear answers
+```
+
+---
+
+## Documentation Quality Patterns
+
+### Pattern: Consistency Audit
+
+```
+Phase 1: FAN-OUT
+├─ Agent A: Check terminology consistency
+├─ Agent B: Check formatting consistency
+├─ Agent C: Check example code validity
+└─ Agent D: Check link validity
+
+Phase 2: REDUCE
+└─ General-purpose agent: Inconsistency report with fixes
+```
+
+### Pattern: Freshness Check
+
+```
+Phase 1: FAN-OUT
+├─ Explore agent: Find outdated code examples
+├─ Explore agent: Find references to removed features
+└─ Explore agent: Find mismatched version numbers
+
+Phase 2: PIPELINE
+└─ General-purpose agent: Update stale documentation
+```
+
+---
+
+## TodoWrite for Documentation
+
+```
+TodoWrite([
+  {content: "Audit existing documentation", status: "in_progress", activeForm: "Auditing documentation"},
+  {content: "Identify documentation gaps", status: "pending", activeForm: "Finding gaps"},
+  {content: "Generate missing documentation", status: "pending", activeForm: "Generating docs"},
+  {content: "Review for consistency", status: "pending", activeForm: "Reviewing consistency"},
+  {content: "Verify examples work", status: "pending", activeForm: "Verifying examples"}
+])
+```
+
+## Output Formats
+
+| Doc Type | Format | Tool |
+|----------|--------|------|
+| API docs | OpenAPI/Swagger | YAML/JSON |
+| Code docs | JSDoc/docstrings | Inline |
+| READMEs | Markdown | .md files |
+| Architecture | Markdown + diagrams | Mermaid/PlantUML |
+| User guides | Markdown/HTML | Static site generators |

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

@@ -0,0 +1,301 @@
+# Code Review Orchestration Patterns
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                                                             │
+│   Reviews should be thorough, fast, and actionable.         │
+│   Parallel analysis. Unified feedback. Clear priorities.    │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+> **Load when**: PR review, security audit, performance review, architecture review, pre-merge validation
+> **Common patterns**: Multi-Dimensional Analysis, OWASP-Parallel, Layer-by-Layer
+
+## Table of Contents
+
+1. [Pull Request Review](#pull-request-review)
+2. [Security Audit](#security-audit)
+3. [Performance Review](#performance-review)
+4. [Architecture Review](#architecture-review)
+5. [Pre-merge Validation](#pre-merge-validation)
+
+---
+
+## Pull Request Review
+
+### Pattern: Multi-Dimensional Analysis
+
+```
+User Request: "Review PR #123"
+
+Phase 1: FAN-OUT (Parallel analysis dimensions)
+├─ Explore agent: Understand PR context, related issues
+├─ Agent A: Code quality analysis (style, patterns, DRY)
+├─ Agent B: Logic correctness (edge cases, error handling)
+├─ Agent C: Security implications
+└─ Agent D: Performance implications
+
+Phase 2: REDUCE (Synthesize)
+└─ General-purpose agent: Aggregate findings, prioritize, format review
+```
+
+**Implementation:**
+
+```
+# All in single message for parallelism
+Task(subagent_type="Explore", prompt="Fetch PR #123 details, understand context and related issues")
+Task(subagent_type="general-purpose", prompt="Review code quality: patterns, readability, maintainability")
+Task(subagent_type="general-purpose", prompt="Review logic: correctness, edge cases, error handling")
+Task(subagent_type="general-purpose", prompt="Review security: injection, auth, data exposure")
+Task(subagent_type="general-purpose", prompt="Review performance: complexity, queries, memory")
+```
+
+### Pattern: Contextual Deep-Dive
+
+```
+Phase 1: PIPELINE (Understand)
+├─ Explore agent: Get PR diff, commit messages
+└─ Explore agent: Find related code, understand impact
+
+Phase 2: FAN-OUT (File-by-file)
+├─ Agent per changed file (for large PRs)
+
+Phase 3: PIPELINE (Consolidate)
+└─ General-purpose agent: Create cohesive review
+```
+
+---
+
+## Security Audit
+
+### Pattern: OWASP-Parallel
+
+```
+User Request: "Security audit the authentication module"
+
+Phase 1: FAN-OUT (OWASP categories in parallel)
+├─ Agent A: Injection vulnerabilities (SQL, command, XSS)
+├─ Agent B: Authentication/session issues
+├─ Agent C: Access control problems
+├─ Agent D: Cryptographic weaknesses
+├─ Agent E: Data exposure risks
+└─ Agent F: Security misconfiguration
+
+Phase 2: REDUCE
+└─ General-purpose agent: Risk-ranked findings with remediation
+```
+
+### Pattern: Attack Surface Mapping
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Map all entry points (APIs, forms, file uploads)
+
+Phase 2: FAN-OUT (Per entry point)
+├─ Agent per entry point: Analyze input validation, sanitization
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Threat model, prioritized vulnerabilities
+```
+
+### Pattern: Dependency Audit
+
+```
+Phase 1: FAN-OUT
+├─ Agent A: Scan npm/pip dependencies for CVEs
+├─ Agent B: Check for outdated packages
+└─ Agent C: Analyze transitive dependencies
+
+Phase 2: REDUCE
+└─ General-purpose agent: Prioritized upgrade plan
+```
+
+---
+
+## Performance Review
+
+### Pattern: Layer-by-Layer
+
+```
+User Request: "Find performance bottlenecks"
+
+Phase 1: FAN-OUT (Analyze each layer)
+├─ Agent A: Database queries (N+1, missing indexes, slow queries)
+├─ Agent B: API layer (response times, payload sizes)
+├─ Agent C: Frontend (bundle size, render performance)
+└─ Agent D: Infrastructure (caching, connection pooling)
+
+Phase 2: REDUCE
+└─ General-purpose agent: Prioritized optimization roadmap
+```
+
+### Pattern: Hot Path Analysis
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify critical user flows
+
+Phase 2: PIPELINE (Per flow)
+└─ General-purpose agent: Trace request lifecycle, find bottlenecks
+
+Phase 3: FAN-OUT (Optimization)
+├─ Agent per bottleneck: Implement optimization
+```
+
+### Pattern: Complexity Audit
+
+```
+Phase 1: MAP
+└─ Explore agent: Find all functions, measure complexity
+
+Phase 2: FAN-OUT (High complexity functions)
+├─ Agent A: Analyze function X, suggest optimizations
+├─ Agent B: Analyze function Y, suggest optimizations
+└─ Agent C: Analyze function Z, suggest optimizations
+```
+
+---
+
+## Architecture Review
+
+### Pattern: Multi-Stakeholder
+
+```
+User Request: "Review system architecture"
+
+Phase 1: FAN-OUT (Perspectives)
+├─ Agent A: Scalability assessment
+├─ Agent B: Maintainability assessment
+├─ Agent C: Security architecture
+├─ Agent D: Cost efficiency
+└─ Agent E: Developer experience
+
+Phase 2: REDUCE
+└─ Plan agent: Synthesize into architecture decision record
+```
+
+### Pattern: Dependency Analysis
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Map all module dependencies
+
+Phase 2: FAN-OUT
+├─ Agent A: Identify circular dependencies
+├─ Agent B: Find coupling hotspots
+└─ Agent C: Assess abstraction boundaries
+
+Phase 3: PIPELINE
+└─ Plan agent: Recommend architectural improvements
+```
+
+### Pattern: Standards Compliance
+
+```
+Phase 1: FAN-OUT
+├─ Agent A: Check against SOLID principles
+├─ Agent B: Check against team style guide
+├─ Agent C: Check against industry patterns
+└─ Agent D: Check against regulatory requirements
+
+Phase 2: REDUCE
+└─ General-purpose agent: Compliance report with gaps
+```
+
+---
+
+## Pre-merge Validation
+
+### Pattern: Comprehensive Gate
+
+```
+User Request: "Validate PR ready for merge"
+
+Phase 1: FAN-OUT (All checks in parallel)
+├─ Background agent: Run full test suite
+├─ Agent A: Verify all review comments addressed
+├─ Agent B: Check for merge conflicts
+├─ Agent C: Validate documentation updated
+└─ Agent D: Confirm CI checks passing
+
+Phase 2: REDUCE
+└─ General-purpose agent: Go/no-go recommendation with blockers
+```
+
+### Pattern: Regression Check
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify areas affected by changes
+
+Phase 2: FAN-OUT
+├─ Agent A: Test affected area 1
+├─ Agent B: Test affected area 2
+└─ Agent C: Integration test critical paths
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Regression report
+```
+
+---
+
+## Review Output Formats
+
+### Structured Review Template
+
+```markdown
+## Summary
+
+[1-2 sentence overview]
+
+## Risk Assessment
+
+- **Security**: Low/Medium/High
+- **Performance**: Low/Medium/High
+- **Breaking Changes**: Yes/No
+
+## Must Fix (Blocking)
+
+1. [Critical issue with line reference]
+
+## Should Fix (Non-blocking)
+
+1. [Important improvement]
+
+## Consider (Optional)
+
+1. [Nice-to-have suggestion]
+
+## Positive Notes
+
+- [What was done well]
+```
+
+### Task Management for Reviews
+
+For comprehensive reviews, create parallel analysis tasks:
+
+```python
+# Create review tasks (can run in parallel)
+TaskCreate(subject="Analyze PR context", description="Understand changes, related issues...")
+TaskCreate(subject="Review code quality", description="Patterns, readability, maintainability...")
+TaskCreate(subject="Check security", description="Injection, auth, data exposure...")
+TaskCreate(subject="Assess performance", description="Complexity, queries, memory...")
+TaskCreate(subject="Synthesize review", description="Aggregate findings into review...")
+
+# Synthesis blocked by analysis tasks
+TaskUpdate(taskId="5", addBlockedBy=["1", "2", "3", "4"])
+
+# Spawn parallel agents for analysis
+Task(subagent_type="general-purpose", prompt="TaskId 1: Analyze PR context...")
+Task(subagent_type="general-purpose", prompt="TaskId 2: Review code quality...")
+Task(subagent_type="general-purpose", prompt="TaskId 3: Check security...")
+Task(subagent_type="general-purpose", prompt="TaskId 4: Assess performance...")
+```
+
+---
+
+```
+─── ◈ Code Review ───────────────────────
+```