cc-mirror 1.1.2 → 1.1.4

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

@@ -1,285 +0,0 @@
-# Research Orchestration Patterns
-
-## 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]
-```
-
-### TodoWrite for Research
-
-```
-TodoWrite([
-  {content: "Define research scope and questions", status: "in_progress", activeForm: "Defining scope"},
-  {content: "Gather relevant sources and code", status: "pending", activeForm: "Gathering sources"},
-  {content: "Analyze findings", status: "pending", activeForm: "Analyzing findings"},
-  {content: "Synthesize conclusions", status: "pending", activeForm: "Synthesizing conclusions"},
-  {content: "Document recommendations", status: "pending", activeForm: "Documenting recommendations"}
-])
-```
-
-## 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 |

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

@@ -1,242 +0,0 @@
-# Software Development Orchestration Patterns
-
-## 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
-```
-
----
-
-## TodoWrite Integration
-
-For any software development task:
-
-```
-TodoWrite([
-  {content: "Analyze requirements and codebase", status: "in_progress", activeForm: "Analyzing requirements"},
-  {content: "Design implementation approach", status: "pending", activeForm: "Designing approach"},
-  {content: "Implement core functionality", status: "pending", activeForm: "Implementing core"},
-  {content: "Add error handling and edge cases", status: "pending", activeForm: "Adding error handling"},
-  {content: "Write tests", status: "pending", activeForm: "Writing tests"},
-  {content: "Verify and cleanup", status: "pending", activeForm: "Verifying implementation"}
-])
-```
-
-Update status as work progresses. Mark completed IMMEDIATELY after finishing each task.