cc-mirror 1.1.1 → 1.1.4

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

@@ -1,310 +0,0 @@
-# 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/project-management.md

@@ -1,345 +0,0 @@
-# Project Management Orchestration Patterns
-
-## 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
-```
-
----
-
-## TodoWrite Integration
-
-For session-based project tracking:
-```
-TodoWrite([
-  {content: "Review current backlog", status: "in_progress", activeForm: "Reviewing backlog"},
-  {content: "Identify priorities", status: "pending", activeForm: "Identifying priorities"},
-  {content: "Break down into tasks", status: "pending", activeForm: "Breaking down tasks"},
-  {content: "Set dependencies", status: "pending", activeForm: "Setting dependencies"},
-  {content: "Assign and communicate", status: "pending", activeForm: "Assigning work"}
-])
-```
-
-## Task vs Todo Selection
-
-| Scenario | Use TaskCreate | Use TodoWrite |
-|----------|---------------|---------------|
-| Multi-session project | Yes | No |
-| Quick session work | No | Yes |
-| Team visibility needed | Yes | No |
-| Dependencies to track | Yes | Maybe |
-| Persistent record | Yes | No |
-
-## 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