claude-flow-novice 1.0.0

package/wiki/command-reference/agent-commands.md

@@ -0,0 +1,571 @@
+# Agent Commands Visual Reference
+
+> **Complete visual guide to agent management with command hierarchies, relationship maps, and coordination patterns**
+
+## 🤖 Agent Ecosystem Overview
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                      CLAUDE FLOW AGENT ECOSYSTEM                   │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐  │
+│  │  CORE AGENTS    │    │ SPECIALIZED     │    │  COORDINATION   │  │
+│  │                 │    │    AGENTS       │    │    AGENTS       │  │
+│  │ • researcher    │    │ • architect     │    │ • coordinator   │  │
+│  │ • coder         │    │ • documenter    │    │ • orchestrator  │  │
+│  │ • tester        │    │ • security      │    │ • monitor       │  │
+│  │ • reviewer      │    │ • ui-designer   │    │ • optimizer     │  │
+│  │ • optimizer     │    │ • devops        │    │ • scheduler     │  │
+│  └─────────────────┘    └─────────────────┘    └─────────────────┘  │
+│           │                       │                       │         │
+│           └───────────────────────┼───────────────────────┘         │
+│                                   │                                 │
+│                           ┌───────▼───────┐                         │
+│                           │  NEURAL AI    │                         │
+│                           │    AGENTS     │                         │
+│                           │               │                         │
+│                           │ • safla-neural│                         │
+│                           │ • consciousness│                        │
+│                           │ • psycho-symbolic│                      │
+│                           │ • phi-calculator│                       │
+│                           └───────────────┘                         │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+## 🌳 Agent Command Hierarchy
+
+```
+claude-flow agents
+├── 📊 MONITORING COMMANDS
+│   ├── list [options]
+│   │   ├── --type <agent-type>      # Filter by agent type
+│   │   ├── --active                 # Show only active agents
+│   │   ├── --detailed (-d)          # Include detailed metrics
+│   │   ├── --watch (-w)             # Real-time monitoring
+│   │   └── --format <type>          # Output format
+│   │
+│   ├── status [agent-id] [options]
+│   │   ├── --detailed (-d)          # Comprehensive status
+│   │   ├── --watch (-w)             # Continuous monitoring
+│   │   ├── --format <type>          # Status format
+│   │   └── --refresh <seconds>      # Update interval
+│   │
+│   └── metrics [agent-id] [options]
+│       ├── --type <metric>          # Specific metric type
+│       ├── --timeframe <period>     # Historical data
+│       ├── --format <type>          # Metric format
+│       └── --export <file>          # Export data
+│
+├── 🚀 LIFECYCLE COMMANDS
+│   ├── spawn <type> [options]
+│   │   ├── --name <custom-name>     # Custom identifier
+│   │   ├── --capabilities <list>    # Specific capabilities
+│   │   ├── --memory <mb>           # Memory allocation
+│   │   ├── --priority <level>      # Execution priority
+│   │   ├── --swarm-id <id>         # Target swarm
+│   │   └── --config <file>         # Configuration file
+│   │
+│   ├── stop <agent-id> [options]
+│   │   ├── --graceful              # Graceful shutdown
+│   │   ├── --force                 # Force termination
+│   │   ├── --save-state            # Preserve state
+│   │   └── --timeout <seconds>     # Stop timeout
+│   │
+│   ├── restart <agent-id> [options]
+│   │   ├── --preserve-memory       # Keep memory state
+│   │   ├── --upgrade               # Update to latest
+│   │   ├── --config <file>         # New configuration
+│   │   └── --timeout <seconds>     # Restart timeout
+│   │
+│   └── clone <agent-id> [options]
+│       ├── --name <new-name>       # Clone identifier
+│       ├── --copy-memory           # Copy memory state
+│       ├── --scale <count>         # Multiple clones
+│       └── --config <overrides>    # Configuration overrides
+│
+├── ⚡ OPTIMIZATION COMMANDS
+│   ├── optimize [options]
+│   │   ├── --algorithm <type>      # Optimization algorithm
+│   │   ├── --target <metric>       # Target optimization
+│   │   ├── --aggressive            # Aggressive optimization
+│   │   └── --safe-only            # Safe optimizations only
+│   │
+│   ├── balance [options]
+│   │   ├── --strategy <type>       # Load balancing strategy
+│   │   ├── --threshold <percent>   # Rebalancing threshold
+│   │   └── --dry-run              # Preview changes
+│   │
+│   └── scale <direction> [options]
+│       ├── up [count]              # Scale up agents
+│       ├── down [count]            # Scale down agents
+│       ├── --auto                  # Auto-scaling
+│       └── --criteria <rules>      # Scaling criteria
+│
+└── 🔧 CONFIGURATION COMMANDS
+    ├── configure <agent-id> [options]
+    │   ├── --capability <add/remove> # Modify capabilities
+    │   ├── --memory <size>          # Adjust memory
+    │   ├── --priority <level>       # Change priority
+    │   └── --config <file>          # Update configuration
+    │
+    ├── reset <agent-id> [options]
+    │   ├── --hard                   # Complete reset
+    │   ├── --soft                   # Preserve core state
+    │   ├── --to-snapshot <id>       # Reset to snapshot
+    │   └── --backup                 # Create backup first
+    │
+    └── backup <agent-id> [options]
+        ├── --include-memory         # Include memory state
+        ├── --compress               # Compress backup
+        ├── --destination <path>     # Backup location
+        └── --encrypt               # Encrypt backup
+```
+
+## 🎯 Agent Type Classification
+
+### Core Development Agents
+
+```
+🔧 CORE DEVELOPMENT AGENTS
+├─ researcher
+│   ├─ Capabilities: Requirements analysis, research, documentation
+│   ├─ Best For: Project planning, technology research, feasibility studies
+│   ├─ Memory Usage: Medium (100-200MB)
+│   ├─ Typical Duration: 30-120 minutes
+│   └─ Output: Research reports, requirements docs, recommendations
+│
+├─ coder
+│   ├─ Capabilities: Code generation, implementation, debugging
+│   ├─ Best For: Feature development, bug fixes, code optimization
+│   ├─ Memory Usage: High (200-500MB)
+│   ├─ Typical Duration: 60-240 minutes
+│   └─ Output: Source code, implementations, code fixes
+│
+├─ tester
+│   ├─ Capabilities: Test generation, execution, validation
+│   ├─ Best For: Unit tests, integration tests, test automation
+│   ├─ Memory Usage: Medium (150-300MB)
+│   ├─ Typical Duration: 45-180 minutes
+│   └─ Output: Test suites, test reports, coverage analysis
+│
+├─ reviewer
+│   ├─ Capabilities: Code review, quality analysis, security audit
+│   ├─ Best For: Code quality, security review, best practices
+│   ├─ Memory Usage: Medium (100-250MB)
+│   ├─ Typical Duration: 30-90 minutes
+│   └─ Output: Review reports, quality metrics, recommendations
+│
+└─ optimizer
+    ├─ Capabilities: Performance analysis, optimization, profiling
+    ├─ Best For: Performance tuning, resource optimization
+    ├─ Memory Usage: High (200-400MB)
+    ├─ Typical Duration: 60-180 minutes
+    └─ Output: Performance reports, optimization suggestions
+```
+
+### Specialized Agents
+
+```
+🎨 SPECIALIZED AGENTS
+├─ architect
+│   ├─ Capabilities: System design, architecture planning, scalability
+│   ├─ Best For: System architecture, design patterns, scalability planning
+│   ├─ Specializations: Microservices, cloud architecture, data modeling
+│   └─ Integration: Works with all development agents
+│
+├─ documenter
+│   ├─ Capabilities: Documentation generation, API docs, user guides
+│   ├─ Best For: Technical documentation, API references, user manuals
+│   ├─ Specializations: OpenAPI, technical writing, tutorials
+│   └─ Integration: Follows coder and architect agents
+│
+├─ security
+│   ├─ Capabilities: Security analysis, vulnerability scanning, compliance
+│   ├─ Best For: Security audits, penetration testing, compliance checks
+│   ├─ Specializations: OWASP, security patterns, encryption
+│   └─ Integration: Reviews coder output, coordinates with reviewer
+│
+├─ ui-designer
+│   ├─ Capabilities: UI/UX design, frontend optimization, accessibility
+│   ├─ Best For: User interface design, user experience optimization
+│   ├─ Specializations: React, Vue, accessibility, responsive design
+│   └─ Integration: Works with frontend coders, coordinates with architect
+│
+└─ devops
+    ├─ Capabilities: CI/CD, deployment, infrastructure, monitoring
+    ├─ Best For: Deployment pipelines, infrastructure management
+    ├─ Specializations: Docker, Kubernetes, cloud platforms, monitoring
+    └─ Integration: Handles deployment of coder output
+```
+
+## 🔄 Agent Relationship Maps
+
+### 1. Standard Development Flow
+
+```
+        ┌─────────────┐
+        │ researcher  │ ────┐
+        └─────────────┘     │
+               │             │
+               ▼             │
+        ┌─────────────┐     │
+        │ architect   │ ◄───┘
+        └─────────────┘
+               │
+               ▼
+        ┌─────────────┐     ┌─────────────┐
+        │   coder     │ ◄─► │   tester    │
+        └─────────────┘     └─────────────┘
+               │                   │
+               ▼                   ▼
+        ┌─────────────┐     ┌─────────────┐
+        │  reviewer   │ ◄─► │ optimizer   │
+        └─────────────┘     └─────────────┘
+               │
+               ▼
+        ┌─────────────┐
+        │ documenter  │
+        └─────────────┘
+```
+
+### 2. Security-First Flow
+
+```
+        ┌─────────────┐
+        │ researcher  │
+        └─────────────┘
+               │
+               ▼
+        ┌─────────────┐     ┌─────────────┐
+        │ architect   │ ◄─► │  security   │
+        └─────────────┘     └─────────────┘
+               │                   │
+               ▼                   ▼
+        ┌─────────────┐     ┌─────────────┐
+        │   coder     │ ◄─► │  security   │ (review)
+        └─────────────┘     └─────────────┘
+               │                   │
+               ▼                   ▼
+        ┌─────────────┐     ┌─────────────┐
+        │   tester    │ ◄─► │  security   │ (test)
+        └─────────────┘     └─────────────┘
+```
+
+### 3. Full-Stack Coordination
+
+```
+    ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+    │  backend    │ ◄─► │  frontend   │ ◄─► │    devops   │
+    │   coder     │     │ ui-designer │     │             │
+    └─────────────┘     └─────────────┘     └─────────────┘
+           │                   │                   │
+           ▼                   ▼                   ▼
+    ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+    │   api       │     │    ui       │     │ deployment  │
+    │  tester     │     │  tester     │     │  monitor    │
+    └─────────────┘     └─────────────┘     └─────────────┘
+           │                   │                   │
+           └─────────┬─────────┴─────────┬─────────┘
+                     ▼                   ▼
+              ┌─────────────┐     ┌─────────────┐
+              │ integration │     │ performance │
+              │   tester    │     │  optimizer  │
+              └─────────────┘     └─────────────┘
+```
+
+## 📊 Agent Performance Matrices
+
+### Resource Allocation Matrix
+
+| Agent Type | CPU Usage | Memory (MB) | Duration (min) | Concurrency | Priority |
+|------------|-----------|-------------|----------------|-------------|----------|
+| researcher | Low | 100-200 | 30-120 | High | Medium |
+| architect | Medium | 150-300 | 45-180 | Medium | High |
+| coder | High | 200-500 | 60-240 | Medium | High |
+| tester | Medium | 150-300 | 45-180 | High | Medium |
+| reviewer | Low | 100-250 | 30-90 | High | Medium |
+| optimizer | High | 200-400 | 60-180 | Low | Medium |
+| security | Medium | 150-250 | 45-120 | Medium | High |
+| documenter | Low | 80-150 | 20-60 | High | Low |
+| ui-designer | Medium | 150-350 | 60-180 | Medium | Medium |
+| devops | Medium | 200-400 | 45-240 | Low | High |
+
+### Capability Compatibility Matrix
+
+| Task Type | Primary Agent | Secondary Agents | Coordination Pattern |
+|-----------|---------------|------------------|---------------------|
+| **Feature Development** | coder | researcher → architect → tester → reviewer | Sequential → Parallel |
+| **Bug Fix** | coder | reviewer → tester | Parallel |
+| **Performance Optimization** | optimizer | coder → tester → reviewer | Sequential |
+| **Security Audit** | security | reviewer → tester | Parallel |
+| **Documentation** | documenter | researcher → coder | Sequential |
+| **UI/UX Design** | ui-designer | researcher → coder → tester | Sequential |
+| **Deployment** | devops | tester → security → optimizer | Sequential |
+| **Architecture Design** | architect | researcher → security → optimizer | Sequential → Parallel |
+
+## 🎮 Agent Command Patterns
+
+### Spawning Patterns
+
+```bash
+# SINGLE AGENT SPAWN
+claude-flow agents spawn coder --name "auth-developer" --priority high
+
+# TEAM SPAWN (Multiple agents for complex task)
+claude-flow agents spawn researcher --name "requirements-analyst"
+claude-flow agents spawn architect --name "system-designer"
+claude-flow agents spawn coder --name "backend-dev"
+claude-flow agents spawn coder --name "frontend-dev"
+claude-flow agents spawn tester --name "qa-engineer"
+
+# SPECIALIZED CAPABILITY SPAWN
+claude-flow agents spawn coder \
+  --capabilities "react,typescript,api-integration" \
+  --memory 512mb \
+  --priority high
+
+# SWARM-TARGETED SPAWN
+claude-flow agents spawn security \
+  --swarm-id "security-audit-swarm" \
+  --capabilities "penetration-testing,compliance" \
+  --config security-audit.yml
+```
+
+### Monitoring Patterns
+
+```bash
+# COMPREHENSIVE MONITORING
+claude-flow agents list --detailed --watch --format table
+
+# SPECIFIC AGENT TRACKING
+claude-flow agents status auth-developer --watch --refresh 5
+
+# PERFORMANCE METRICS
+claude-flow agents metrics --type performance --timeframe 24h --export metrics.json
+
+# RESOURCE UTILIZATION
+claude-flow agents metrics --type memory --format json | jq '.agents[] | select(.usage > 80)'
+```
+
+### Optimization Patterns
+
+```bash
+# AUTO-OPTIMIZATION
+claude-flow agents optimize --algorithm genetic --target efficiency
+
+# LOAD BALANCING
+claude-flow agents balance --strategy round-robin --threshold 75
+
+# SMART SCALING
+claude-flow agents scale up --auto --criteria "cpu>80,memory>70,queue>10"
+
+# RESOURCE OPTIMIZATION
+claude-flow agents optimize --target memory --safe-only --dry-run
+```
+
+## 🔧 Advanced Agent Configuration
+
+### Configuration Templates
+
+#### High-Performance Coder
+```yaml
+# high-performance-coder.yml
+agent:
+  type: coder
+  capabilities:
+    - javascript
+    - typescript
+    - react
+    - node.js
+    - api-development
+  resources:
+    memory: 512mb
+    cpu_priority: high
+    timeout: 3600
+  optimization:
+    parallel_processing: true
+    memory_optimization: aggressive
+    caching: enabled
+  coordination:
+    communication_frequency: high
+    status_reporting: real-time
+    error_propagation: immediate
+```
+
+#### Security Specialist
+```yaml
+# security-specialist.yml
+agent:
+  type: security
+  capabilities:
+    - owasp-scanning
+    - penetration-testing
+    - compliance-checking
+    - vulnerability-assessment
+  resources:
+    memory: 256mb
+    cpu_priority: medium
+    timeout: 2400
+  security:
+    scanning_depth: comprehensive
+    compliance_standards: [SOC2, ISO27001, GDPR]
+    threat_modeling: enabled
+  integration:
+    with_reviewer: parallel
+    with_tester: sequential
+    reporting: detailed
+```
+
+#### Full-Stack Architect
+```yaml
+# fullstack-architect.yml
+agent:
+  type: architect
+  capabilities:
+    - system-design
+    - microservices
+    - database-design
+    - cloud-architecture
+    - scalability-planning
+  resources:
+    memory: 384mb
+    cpu_priority: high
+    timeout: 4800
+  design:
+    methodology: domain-driven
+    patterns: [microservices, event-sourcing, cqrs]
+    cloud_platforms: [aws, azure, gcp]
+  coordination:
+    with_researcher: prerequisite
+    with_coder: guidance
+    with_devops: collaboration
+```
+
+## 🌊 Agent Workflow Orchestration
+
+### Parallel Execution Patterns
+
+```bash
+# PARALLEL DEVELOPMENT TEAM
+claude-flow agents spawn researcher --name "req-analyst" &
+claude-flow agents spawn architect --name "sys-designer" &
+claude-flow agents spawn coder --name "backend-dev" &
+claude-flow agents spawn coder --name "frontend-dev" &
+claude-flow agents spawn tester --name "qa-engineer" &
+wait
+
+# PARALLEL REVIEW TEAM
+claude-flow agents spawn reviewer --name "code-reviewer" &
+claude-flow agents spawn security --name "security-auditor" &
+claude-flow agents spawn optimizer --name "performance-analyst" &
+wait
+```
+
+### Sequential Coordination Patterns
+
+```bash
+# WATERFALL DEVELOPMENT
+claude-flow agents spawn researcher --name "requirements"
+claude-flow agents status requirements --wait-for completion
+claude-flow agents spawn architect --name "design"
+claude-flow agents status design --wait-for completion
+claude-flow agents spawn coder --name "implementation"
+claude-flow agents status implementation --wait-for completion
+claude-flow agents spawn tester --name "validation"
+```
+
+### Adaptive Coordination Patterns
+
+```bash
+# DYNAMIC AGENT ALLOCATION
+claude-flow agents spawn researcher --name "analysis"
+if [analysis_complexity == "high"]; then
+  claude-flow agents spawn researcher --name "deep-research"
+fi
+
+claude-flow agents spawn architect --name "design"
+if [system_complexity == "distributed"]; then
+  claude-flow agents spawn architect --name "microservices-expert"
+fi
+
+# Based on requirements, spawn appropriate coders
+case $project_type in
+  "web") claude-flow agents spawn coder --capabilities "react,node" ;;
+  "mobile") claude-flow agents spawn coder --capabilities "react-native" ;;
+  "api") claude-flow agents spawn coder --capabilities "express,fastapi" ;;
+esac
+```
+
+## 📈 Agent Performance Optimization
+
+### Memory Optimization Strategies
+
+```bash
+# MEMORY-EFFICIENT SPAWNING
+claude-flow agents spawn coder --memory 256mb --optimize memory
+
+# MEMORY MONITORING & ADJUSTMENT
+claude-flow agents metrics coder-1 --type memory
+if [memory_usage > 90%]; then
+  claude-flow agents configure coder-1 --memory 512mb
+fi
+
+# MEMORY CLEANUP
+claude-flow agents optimize --target memory --algorithm aggressive
+```
+
+### Performance Tuning
+
+```bash
+# CPU OPTIMIZATION
+claude-flow agents configure high-priority-agent --priority critical
+
+# PARALLEL PROCESSING OPTIMIZATION
+claude-flow agents balance --strategy cpu-aware --threshold 80
+
+# THROUGHPUT OPTIMIZATION
+claude-flow agents scale up 2 --criteria "queue>5,response_time>30s"
+```
+
+## 🎯 Agent Success Patterns
+
+### High-Success Configurations
+
+| Pattern | Configuration | Success Rate | Use Case |
+|---------|---------------|--------------|----------|
+| **Quick Fix** | Single reviewer + coder | 95% | Bug fixes, small changes |
+| **Feature Team** | Researcher + architect + coder + tester | 88% | New features |
+| **Security Focus** | Security + reviewer + tester | 92% | Security implementations |
+| **Performance Team** | Optimizer + coder + tester | 85% | Performance improvements |
+| **Full Stack** | All agent types | 82% | Complete applications |
+
+### Common Anti-Patterns
+
+```
+❌ AVOID THESE PATTERNS
+
+Too Many Agents:
+├─ More than 8 agents simultaneously
+├─ Overlapping responsibilities
+└─ Resource contention
+
+Under-Specification:
+├─ Generic agent spawning
+├─ No capability specification
+└─ Default memory allocation
+
+Poor Coordination:
+├─ No dependency management
+├─ Concurrent conflicting agents
+└─ No status monitoring
+
+Resource Waste:
+├─ Over-allocating memory
+├─ Long-running idle agents
+└─ No optimization strategy
+```
+
+---
+
+This comprehensive agent command reference provides clear visual understanding of agent types, relationships, coordination patterns, and optimization strategies for maximum development efficiency.