cc-mirror 1.0.3 → 1.1.0

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

@@ -0,0 +1,343 @@
+# Documentation Orchestration Patterns
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                                                             │
+│   Good documentation is parallel-friendly.                  │
+│   Multiple sections, generated simultaneously.              │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+> **Load when**: API documentation, code documentation, README generation, architecture docs, user guides
+> **Common patterns**: Endpoint Discovery, Batch JSDoc Generation, Comprehensive README
+
+## 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
+```
+
+---
+
+## Task Management for Documentation
+
+Structure documentation work with parallel generation:
+
+```python
+# Create documentation tasks
+TaskCreate(subject="Audit existing docs", description="Review current documentation state...")
+TaskCreate(subject="Document API endpoints", description="REST API documentation...")
+TaskCreate(subject="Document components", description="React component docs...")
+TaskCreate(subject="Document utilities", description="Helper function docs...")
+TaskCreate(subject="Review consistency", description="Ensure consistent style...")
+TaskCreate(subject="Verify examples", description="Test all code examples...")
+
+# Parallel doc generation after audit
+TaskUpdate(taskId="2", addBlockedBy=["1"])
+TaskUpdate(taskId="3", addBlockedBy=["1"])
+TaskUpdate(taskId="4", addBlockedBy=["1"])
+TaskUpdate(taskId="5", addBlockedBy=["2", "3", "4"])
+TaskUpdate(taskId="6", addBlockedBy=["5"])
+
+# Spawn parallel documentation agents
+Task(subagent_type="general-purpose", prompt="TaskId 2: Document API endpoints...")
+Task(subagent_type="general-purpose", prompt="TaskId 3: Document components...")
+Task(subagent_type="general-purpose", prompt="TaskId 4: Document utilities...")
+```
+
+## 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 |
+
+---
+
+```
+─── ◈ Documentation ─────────────────────
+```

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

@@ -0,0 +1,370 @@
+# Project Management Orchestration Patterns
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                                                             │
+│   Complex projects, clearly decomposed.                     │
+│   Dependencies tracked. Progress visible. Team aligned.     │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+> **Load when**: Epic breakdown, sprint planning, progress tracking, dependency management, team coordination
+> **Common patterns**: Hierarchical Decomposition, Capacity-Based Planning, Multi-Dimension Status
+
+## Table of Contents
+
+1. [Epic Breakdown](#epic-breakdown)
+2. [Sprint Planning](#sprint-planning)
+3. [Progress Tracking](#progress-tracking)
+4. [Dependency Management](#dependency-management)
+5. [Team Coordination](#team-coordination)
+
+---
+
+## Epic Breakdown
+
+### Pattern: Hierarchical Decomposition
+
+```
+User Request: "Break down the authentication epic"
+
+Phase 1: EXPLORE
+└─ Explore agent: Understand requirements, existing system
+
+Phase 2: PLAN
+└─ Plan agent: Design high-level feature breakdown
+
+Phase 3: FAN-OUT (Parallel story creation)
+├─ Agent A: User stories for login/logout
+├─ Agent B: User stories for registration
+├─ Agent C: User stories for password management
+├─ Agent D: User stories for session management
+└─ Agent E: User stories for OAuth integration
+
+Phase 4: REDUCE
+└─ General-purpose agent: Organize into coherent backlog
+```
+
+**Task Management Implementation:**
+
+```
+# Create epic
+TaskCreate(subject="Epic: User Authentication", description="Complete auth system")
+
+# Create stories
+TaskCreate(subject="Story: Login flow", description="...")
+TaskCreate(subject="Story: Registration", description="...")
+TaskCreate(subject="Story: Password reset", description="...")
+
+# Set dependencies
+TaskUpdate(taskId="3", addBlockedBy=["2"])  # Reset after registration
+```
+
+### Pattern: Vertical Slice Breakdown
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Map feature touchpoints (UI, API, DB)
+
+Phase 2: FAN-OUT (Slice by user value)
+├─ Agent A: Define slice 1 (minimal viable feature)
+├─ Agent B: Define slice 2 (enhanced feature)
+└─ Agent C: Define slice 3 (complete feature)
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Estimate, prioritize, sequence
+```
+
+### Pattern: Spike-First Breakdown
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify unknowns and risks
+
+Phase 2: FAN-OUT (Parallel spikes)
+├─ Agent A: Technical spike - feasibility
+├─ Agent B: Technical spike - performance
+└─ Agent C: UX spike - user research
+
+Phase 3: REDUCE
+└─ General-purpose agent: Use spike findings to refine breakdown
+```
+
+---
+
+## Sprint Planning
+
+### Pattern: Capacity-Based Planning
+
+```
+User Request: "Plan the next sprint"
+
+Phase 1: FAN-OUT (Gather context)
+├─ Explore agent: Review backlog priority
+├─ Explore agent: Check team capacity
+├─ Explore agent: Review blockers and dependencies
+└─ Explore agent: Check carryover from last sprint
+
+Phase 2: REDUCE
+└─ Plan agent: Propose sprint scope
+
+Phase 3: FAN-OUT (Task breakdown)
+├─ Agent A: Break down story 1 into tasks
+├─ Agent B: Break down story 2 into tasks
+└─ Agent C: Break down story 3 into tasks
+
+Phase 4: PIPELINE
+└─ General-purpose agent: Finalize sprint backlog
+```
+
+**Task Structure:**
+
+```
+# Sprint-level task
+TaskCreate(subject="Sprint 14: Auth Implementation", description="...")
+
+# Stories within sprint
+TaskCreate(subject="Login API endpoint", description="...")
+TaskCreate(subject="Login UI component", description="...")
+TaskUpdate(taskId="2", addBlockedBy=["1"])  # UI needs API first
+
+# Sub-tasks
+TaskCreate(subject="Write login validation", description="...")
+TaskCreate(subject="Add rate limiting", description="...")
+```
+
+### Pattern: Risk-Adjusted Planning
+
+```
+Phase 1: FAN-OUT
+├─ Agent A: Identify technical risks
+├─ Agent B: Identify dependency risks
+└─ Agent C: Identify scope risks
+
+Phase 2: REDUCE
+└─ Plan agent: Adjust estimates with risk buffer
+
+Phase 3: PIPELINE
+└─ General-purpose agent: Create contingency tasks
+```
+
+---
+
+## Progress Tracking
+
+### Pattern: Multi-Dimension Status
+
+```
+User Request: "What's the project status?"
+
+Phase 1: FAN-OUT (Parallel status gathering)
+├─ Agent A: Task completion status (from TaskList)
+├─ Agent B: Blocker analysis
+├─ Agent C: Timeline vs plan
+├─ Agent D: Quality metrics
+└─ Agent E: Risk status
+
+Phase 2: REDUCE
+└─ General-purpose agent: Executive status summary
+```
+
+**Using TaskList:**
+
+```
+# Get current state
+TaskList()  # Returns all tasks with status
+
+# Update progress
+TaskUpdate(taskId="5", addComment={
+  author: "agent-id",
+  content: "50% complete, blocked on API review"
+})
+
+# Mark complete
+TaskUpdate(taskId="5", status="resolved")
+```
+
+### Pattern: Burndown Tracking
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Calculate completed vs remaining work
+
+Phase 2: PIPELINE
+├─ General-purpose agent: Project completion trajectory
+├─ General-purpose agent: Identify velocity trends
+└─ General-purpose agent: Flag at-risk items
+
+Phase 3: REDUCE
+└─ General-purpose agent: Burndown report
+```
+
+### Pattern: Blocker Resolution
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify all blocked tasks
+
+Phase 2: FAN-OUT (Parallel resolution paths)
+├─ Agent A: Investigate blocker 1
+├─ Agent B: Investigate blocker 2
+└─ Agent C: Investigate blocker 3
+
+Phase 3: REDUCE
+└─ General-purpose agent: Resolution plan, escalation needs
+```
+
+---
+
+## Dependency Management
+
+### Pattern: Dependency Graph Construction
+
+```
+User Request: "Map project dependencies"
+
+Phase 1: EXPLORE
+└─ Explore agent: List all tasks and their relationships
+
+Phase 2: FAN-OUT
+├─ Agent A: Map technical dependencies
+├─ Agent B: Map team/resource dependencies
+└─ Agent C: Map external dependencies
+
+Phase 3: REDUCE
+└─ General-purpose agent: Dependency graph, critical path
+```
+
+**Implementation:**
+
+```
+# Create dependency chain
+TaskCreate(subject="Database schema", description="...")
+TaskCreate(subject="API models", description="...")
+TaskCreate(subject="API endpoints", description="...")
+TaskCreate(subject="Frontend integration", description="...")
+
+TaskUpdate(taskId="2", addBlockedBy=["1"])
+TaskUpdate(taskId="3", addBlockedBy=["2"])
+TaskUpdate(taskId="4", addBlockedBy=["3"])
+
+# Cross-team dependency
+TaskCreate(subject="External API access", description="Waiting on partner")
+TaskUpdate(taskId="3", addBlockedBy=["5"])  # Blocked by external
+```
+
+### Pattern: Critical Path Analysis
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Map all task dependencies
+
+Phase 2: PIPELINE
+├─ General-purpose agent: Calculate path lengths
+├─ General-purpose agent: Identify critical path
+└─ General-purpose agent: Find parallel opportunities
+
+Phase 3: REDUCE
+└─ General-purpose agent: Optimization recommendations
+```
+
+### Pattern: Dependency Resolution
+
+```
+Phase 1: FAN-OUT
+├─ Agent A: Identify circular dependencies
+├─ Agent B: Identify unnecessary dependencies
+└─ Agent C: Identify dependency bottlenecks
+
+Phase 2: PIPELINE
+└─ General-purpose agent: Restructure to unblock work
+```
+
+---
+
+## Team Coordination
+
+### Pattern: Work Distribution
+
+```
+User Request: "Assign work for this sprint"
+
+Phase 1: FAN-OUT
+├─ Explore agent: Analyze task requirements
+├─ Explore agent: Review team skills/capacity
+└─ Explore agent: Check current assignments
+
+Phase 2: REDUCE
+└─ Plan agent: Optimal assignment recommendations
+
+Phase 3: FAN-OUT (Parallel task assignment)
+├─ Agent A: Create task assignments for dev 1
+├─ Agent B: Create task assignments for dev 2
+└─ Agent C: Create task assignments for dev 3
+```
+
+### Pattern: Handoff Coordination
+
+```
+Phase 1: EXPLORE
+└─ Explore agent: Identify tasks requiring handoffs
+
+Phase 2: PIPELINE
+├─ General-purpose agent: Document handoff requirements
+├─ General-purpose agent: Create handoff checklist
+└─ General-purpose agent: Schedule coordination points
+```
+
+### Pattern: Multi-Team Sync
+
+```
+Phase 1: FAN-OUT
+├─ Agent A: Gather Team A status
+├─ Agent B: Gather Team B status
+└─ Agent C: Identify cross-team dependencies
+
+Phase 2: REDUCE
+└─ General-purpose agent: Cross-team status, blockers, needs
+```
+
+---
+
+## Task Management in Practice
+
+All project management work should use TaskCreate for proper tracking:
+
+```python
+# Sprint planning example
+TaskCreate(subject="Sprint 14 Planning", description="Plan next sprint scope...")
+TaskCreate(subject="Review backlog", description="Prioritize stories...")
+TaskCreate(subject="Break down Story A", description="Create implementation tasks...")
+TaskCreate(subject="Break down Story B", description="Create implementation tasks...")
+TaskCreate(subject="Set dependencies", description="Wire task dependencies...")
+TaskCreate(subject="Assign work", description="Distribute to team...")
+
+# Planning sequence
+TaskUpdate(taskId="2", addBlockedBy=["1"])
+TaskUpdate(taskId="3", addBlockedBy=["2"])
+TaskUpdate(taskId="4", addBlockedBy=["2"])
+TaskUpdate(taskId="5", addBlockedBy=["3", "4"])
+TaskUpdate(taskId="6", addBlockedBy=["5"])
+
+# Parallel breakdown
+Task(subagent_type="general-purpose", prompt="TaskId 3: Break down Story A...")
+Task(subagent_type="general-purpose", prompt="TaskId 4: Break down Story B...")
+```
+
+## Best Practices
+
+1. **Break down early** - Large tasks are hard to track
+2. **Set dependencies explicitly** - Prevents blocked work
+3. **Update status frequently** - Real-time visibility
+4. **Comment on blockers** - Context for resolution
+5. **Close completed tasks immediately** - Accurate progress
+
+---
+
+```
+─── ◈ Project Management ────────────────
+```