@claude-flow/cli 3.0.2 → 3.1.0-alpha.2

package/.claude/commands/swarm/swarm.md

@@ -0,0 +1,87 @@
+# /swarm
+
+Main swarm orchestration command for Claude Flow V3.
+
+## 🚨 CRITICAL: Background Execution Pattern
+
+**When spawning a swarm, Claude Code MUST:**
+
+1. **Spawn ALL agents in background** using `run_in_background: true`
+2. **Put ALL Task calls in ONE message** for parallel execution
+3. **Display status board** with ASCII table and emojis
+4. **STOP and WAIT** - don't add more tool calls or poll status
+
+## ✅ CORRECT Spawn Pattern
+
+```javascript
+// Spawn ALL agents IN BACKGROUND in ONE message
+Task({ prompt: "Research...", subagent_type: "researcher", run_in_background: true })
+Task({ prompt: "Design...", subagent_type: "architect", run_in_background: true })
+Task({ prompt: "Implement...", subagent_type: "coder", run_in_background: true })
+Task({ prompt: "Test...", subagent_type: "tester", run_in_background: true })
+Task({ prompt: "Review...", subagent_type: "reviewer", run_in_background: true })
+```
+
+## 📊 Required Status Display (ASCII Table)
+
+**After spawning, Claude Code MUST display this status board:**
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  🐝 SWARM LAUNCHED                                           ║
+╠══════════════════════════════════════════════════════════════╣
+║  📋 Task: [user's task description]                          ║
+║  🔄 Topology: hierarchical  │  👥 Agents: 5/15               ║
+╠══════════════════════════════════════════════════════════════╣
+║  AGENT           │  STATUS     │  TASK                       ║
+╠══════════════════════════════════════════════════════════════╣
+║  🔍 Researcher   │  🟢 ACTIVE  │  Analyzing requirements     ║
+║  🏗️ Architect    │  🟢 ACTIVE  │  Designing approach         ║
+║  💻 Coder        │  🟢 ACTIVE  │  Implementing solution      ║
+║  🧪 Tester       │  🟢 ACTIVE  │  Writing tests              ║
+║  👀 Reviewer     │  🟢 ACTIVE  │  Code review & security     ║
+╠══════════════════════════════════════════════════════════════╣
+║  ⏳ Working in parallel... Results will arrive automatically ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+## ❌ DO NOT
+
+```
+TaskOutput({ task_id: "..." })     // ❌ Don't poll
+"Should I check on agents?"        // ❌ Don't ask
+swarm status                       // ❌ Don't check repeatedly
+```
+
+## 📋 Agent Types by Task
+
+```
+╔═══════════════════╦═════════════════════════════════════════════╗
+║  TASK TYPE        ║  AGENTS                                     ║
+╠═══════════════════╬═════════════════════════════════════════════╣
+║  🆕 New Feature   ║  researcher, architect, coder, tester, rev  ║
+║  🐛 Bug Fix       ║  researcher, coder, tester                  ║
+║  ♻️ Refactor      ║  architect, coder, reviewer                 ║
+║  🔒 Security      ║  security-architect, auditor, reviewer      ║
+║  ⚡ Performance   ║  researcher, perf-engineer, coder           ║
+║  📚 Documentation ║  researcher, api-docs                       ║
+╚═══════════════════╩═════════════════════════════════════════════╝
+```
+
+## Usage
+```bash
+npx @claude-flow/cli@latest swarm init --topology hierarchical
+npx @claude-flow/cli@latest swarm status  # Only after completion
+```
+
+## Options
+```
+╔════════════════════════╦═══════════════════════════════════════╗
+║  OPTION                ║  DESCRIPTION                          ║
+╠════════════════════════╬═══════════════════════════════════════╣
+║  --strategy <type>     ║  research, development, analysis      ║
+║  --topology <type>     ║  hierarchical, mesh, ring, star       ║
+║  --max-agents <n>      ║  Maximum agents (default: 15)         ║
+║  --background          ║  Run in background (default: true)    ║
+╚════════════════════════╩═══════════════════════════════════════╝
+```

package/.claude/commands/swarm/testing.md

@@ -0,0 +1,131 @@
+# Testing Swarm Strategy
+
+## Purpose
+Comprehensive testing through distributed execution.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize testing swarm
+mcp__claude-flow__swarm_init({
+  "topology": "star",
+  "maxAgents": 7,
+  "strategy": "parallel"
+})
+
+// Orchestrate testing task
+mcp__claude-flow__task_orchestrate({
+  "task": "test application",
+  "strategy": "parallel",
+  "priority": "high"
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow swarm "test application" --strategy testing`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn testing agents
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Unit Tester",
+  "capabilities": ["unit-testing", "mocking", "coverage"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Integration Tester",
+  "capabilities": ["integration", "api-testing", "contract-testing"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "E2E Tester",
+  "capabilities": ["e2e", "ui-testing", "user-flows"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Performance Tester",
+  "capabilities": ["load-testing", "stress-testing", "benchmarking"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "monitor",
+  "name": "Security Tester",
+  "capabilities": ["security-testing", "penetration-testing", "vulnerability-scanning"]
+})
+```
+
+## Test Coverage
+
+### Coverage Analysis
+```javascript
+// Quality assessment
+mcp__claude-flow__quality_assess({
+  "target": "test-coverage",
+  "criteria": ["line-coverage", "branch-coverage", "function-coverage"]
+})
+
+// Edge case detection
+mcp__claude-flow__pattern_recognize({
+  "data": testScenarios,
+  "patterns": ["edge-case", "boundary-condition", "error-path"]
+})
+```
+
+### Test Execution
+```javascript
+// Parallel test execution
+mcp__claude-flow__parallel_execute({
+  "tasks": [
+    { "id": "unit-tests", "command": "npm run test:unit" },
+    { "id": "integration-tests", "command": "npm run test:integration" },
+    { "id": "e2e-tests", "command": "npm run test:e2e" }
+  ]
+})
+
+// Batch processing for test suites
+mcp__claude-flow__batch_process({
+  "items": testSuites,
+  "operation": "execute-test-suite"
+})
+```
+
+### Performance Testing
+```javascript
+// Run performance benchmarks
+mcp__claude-flow__benchmark_run({
+  "suite": "performance-tests"
+})
+
+// Security scanning
+mcp__claude-flow__security_scan({
+  "target": "application",
+  "depth": "comprehensive"
+})
+```
+
+### Monitoring and Reporting
+```javascript
+// Monitor test execution
+mcp__claude-flow__swarm_monitor({
+  "swarmId": "testing-swarm",
+  "interval": 2000
+})
+
+// Generate test report
+mcp__claude-flow__performance_report({
+  "format": "detailed",
+  "timeframe": "current-run"
+})
+
+// Get test results
+mcp__claude-flow__task_results({
+  "taskId": "test-execution-001"
+})
+```

package/.claude/commands/training/README.md

@@ -0,0 +1,9 @@
+# Training Commands
+
+Commands for training operations in Claude Flow.
+
+## Available Commands
+
+- [neural-train](./neural-train.md)
+- [pattern-learn](./pattern-learn.md)
+- [model-update](./model-update.md)

package/.claude/commands/training/model-update.md

@@ -0,0 +1,25 @@
+# model-update
+
+Update neural models with new data.
+
+## Usage
+```bash
+npx claude-flow training model-update [options]
+```
+
+## Options
+- `--model <name>` - Model to update
+- `--incremental` - Incremental update
+- `--validate` - Validate after update
+
+## Examples
+```bash
+# Update all models
+npx claude-flow training model-update
+
+# Specific model
+npx claude-flow training model-update --model agent-selector
+
+# Incremental with validation
+npx claude-flow training model-update --incremental --validate
+```

package/.claude/commands/training/neural-patterns.md

@@ -0,0 +1,108 @@
+# Neural Pattern Training
+
+## Purpose
+Continuously improve coordination through neural network learning with SONA (Self-Optimizing Neural Architecture).
+
+## Pattern Persistence
+
+Patterns are **automatically persisted** to disk:
+- **Patterns**: `.claude-flow/neural/patterns.json`
+- **Stats**: `.claude-flow/neural/stats.json`
+
+Patterns survive process restarts and are loaded automatically on next session.
+
+## How Training Works
+
+### 1. Automatic Learning
+Every successful operation trains the neural networks:
+- Edit patterns for different file types
+- Search strategies that find results faster
+- Task decomposition approaches
+- Agent coordination patterns
+
+### 2. Manual Training
+```bash
+# Train coordination patterns (50 epochs)
+npx claude-flow neural train -p coordination -e 50
+
+# Train optimization patterns with custom learning rate
+npx claude-flow neural train -p optimization -l 0.005
+
+# Quick training (10 epochs)
+npx claude-flow neural train -e 10
+```
+
+### 3. Pattern Types
+
+**Training Pattern Types:**
+- `coordination` - Task coordination strategies (default)
+- `optimization` - Performance optimization patterns
+- `prediction` - Predictive preloading patterns
+
+**Cognitive Patterns:**
+- Convergent: Focused problem-solving
+- Divergent: Creative exploration
+- Lateral: Alternative approaches
+- Systems: Holistic thinking
+- Critical: Analytical evaluation
+- Abstract: High-level design
+
+### 4. Improvement Tracking
+```bash
+# Check neural system status
+npx claude-flow neural status
+```
+
+## Pattern Management
+
+```bash
+# List all persisted patterns
+npx claude-flow neural patterns --action list
+
+# Search patterns by query
+npx claude-flow neural patterns --action list -q "error handling"
+
+# Analyze patterns
+npx claude-flow neural patterns --action analyze -q "coordination"
+```
+
+## Performance Targets
+
+| Metric | Target |
+|--------|--------|
+| SONA Adaptation | <0.05ms (achieved: ~2μs) |
+| Pattern Search | O(log n) with HNSW |
+| Memory Efficient | Circular buffers |
+
+## Benefits
+- 🧠 Learns your coding style
+- 📈 Improves with each use
+- 🎯 Better task predictions
+- ⚡ Faster coordination
+- 💾 Patterns persist across sessions
+
+## CLI Reference
+
+```bash
+# Train neural patterns
+npx claude-flow neural train -p coordination -e 50
+
+# Check neural status
+npx claude-flow neural status
+
+# List patterns
+npx claude-flow neural patterns --action list
+
+# Search patterns
+npx claude-flow neural patterns --action list -q "query"
+
+# Analyze patterns
+npx claude-flow neural patterns --action analyze -q "coordination"
+```
+
+## Related Commands
+
+- `neural train` - Train patterns with SONA
+- `neural status` - Check neural system status
+- `neural patterns` - List and search patterns
+- `neural predict` - Make predictions using trained models

package/.claude/commands/training/neural-train.md

@@ -0,0 +1,75 @@
+# neural-train
+
+Train neural patterns with SONA (Self-Optimizing Neural Architecture) for adaptive learning and pattern recognition.
+
+## Usage
+```bash
+npx claude-flow neural train [options]
+```
+
+## Options
+- `-p, --pattern <type>` - Pattern type: coordination, optimization, prediction (default: coordination)
+- `-e, --epochs <n>` - Number of training epochs (default: 50)
+- `-d, --data <file>` - Training data file (JSON)
+- `-m, --model <id>` - Model ID to train
+- `-l, --learning-rate <rate>` - Learning rate (default: 0.001)
+- `-b, --batch-size <n>` - Batch size (default: 32)
+
+## Pattern Persistence
+
+Trained patterns are **automatically persisted** to disk:
+- **Location**: `.claude-flow/neural/patterns.json`
+- **Stats**: `.claude-flow/neural/stats.json`
+
+Patterns survive process restarts and are loaded automatically on next session.
+
+## Examples
+
+```bash
+# Train coordination patterns (50 epochs)
+npx claude-flow neural train -p coordination -e 50
+
+# Train with custom learning rate
+npx claude-flow neural train -p optimization -l 0.005
+
+# Train from file
+npx claude-flow neural train -d ./training-data.json
+
+# Quick training (10 epochs)
+npx claude-flow neural train -e 10
+```
+
+## Output
+
+Training produces:
+- **Patterns Recorded**: Number of patterns stored in ReasoningBank
+- **Trajectories**: Complete learning sequences recorded
+- **SONA Adaptation**: Target is <0.05ms per operation
+- **Persistence Path**: Where patterns are saved
+
+## List Trained Patterns
+
+```bash
+# List all persisted patterns
+npx claude-flow neural patterns --action list
+
+# Search patterns by query
+npx claude-flow neural patterns --action list -q "error handling"
+
+# Analyze patterns
+npx claude-flow neural patterns --action analyze -q "coordination"
+```
+
+## Performance Targets
+
+| Metric | Target |
+|--------|--------|
+| SONA Adaptation | <0.05ms (achieved: ~2μs) |
+| Pattern Search | O(log n) with HNSW |
+| Memory Efficient | Circular buffers |
+
+## Related Commands
+
+- `neural patterns` - List and search patterns
+- `neural status` - Check neural system status
+- `neural predict` - Make predictions using trained models

package/.claude/commands/training/pattern-learn.md

@@ -0,0 +1,25 @@
+# pattern-learn
+
+Learn patterns from successful operations.
+
+## Usage
+```bash
+npx claude-flow training pattern-learn [options]
+```
+
+## Options
+- `--source <type>` - Pattern source
+- `--threshold <score>` - Success threshold
+- `--save <name>` - Save pattern set
+
+## Examples
+```bash
+# Learn from all ops
+npx claude-flow training pattern-learn
+
+# High success only
+npx claude-flow training pattern-learn --threshold 0.9
+
+# Save patterns
+npx claude-flow training pattern-learn --save optimal-patterns
+```

package/.claude/commands/training/specialization.md

@@ -0,0 +1,63 @@
+# Agent Specialization Training
+
+## Purpose
+Train agents to become experts in specific domains for better performance.
+
+## Specialization Areas
+
+### 1. By File Type
+Agents automatically specialize based on file extensions:
+- **.js/.ts**: Modern JavaScript patterns
+- **.py**: Pythonic idioms
+- **.go**: Go best practices
+- **.rs**: Rust safety patterns
+
+### 2. By Task Type
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "coder",
+  "capabilities": ["react", "typescript", "testing"],
+  "name": "React Specialist"
+}
+```
+
+### 3. Training Process
+The system trains through:
+- Successful edit operations
+- Code review patterns
+- Error fix approaches
+- Performance optimizations
+
+### 4. Specialization Benefits
+```
+# Check agent specializations
+Tool: mcp__claude-flow__agent_list
+Parameters: {"swarmId": "current"}
+
+Result shows expertise levels:
+{
+  "agents": [
+    {
+      "id": "coder-123",
+      "specializations": {
+        "javascript": 0.95,
+        "react": 0.88,
+        "testing": 0.82
+      }
+    }
+  ]
+}
+```
+
+## Continuous Improvement
+Agents share learnings across sessions for cumulative expertise!
+
+## CLI Usage
+```bash
+# Train agent specialization via CLI
+npx claude-flow train agent --type coder --capabilities "react,typescript"
+
+# Check specializations
+npx claude-flow agent list --specializations
+```

package/.claude/commands/truth/start.md

@@ -0,0 +1,143 @@
+# 📊 Truth Command
+
+View truth scores and reliability metrics for your codebase and agent tasks.
+
+## Overview
+
+The `truth` command provides comprehensive insights into code quality, agent performance, and verification metrics.
+
+## Usage
+
+```bash
+claude-flow truth [options]
+```
+
+## Options
+
+- `--format <type>` - Output format: table (default), json, csv, html
+- `--period <time>` - Time period: 1h, 24h, 7d, 30d
+- `--agent <name>` - Filter by specific agent
+- `--threshold <0-1>` - Show only scores below threshold
+- `--export <file>` - Export metrics to file
+- `--watch` - Real-time monitoring mode
+
+## Metrics Displayed
+
+### Truth Scores
+- **Overall Score**: Aggregate truth score (0.0-1.0)
+- **File Scores**: Individual file truth ratings
+- **Agent Scores**: Per-agent reliability metrics
+- **Task Scores**: Task completion quality
+
+### Trends
+- **Improvement Rate**: Quality trend over time
+- **Regression Detection**: Identifies declining scores
+- **Agent Learning**: Shows agent improvement curves
+
+### Statistics
+- **Mean Score**: Average truth score
+- **Median Score**: Middle value of scores
+- **Standard Deviation**: Score consistency
+- **Confidence Interval**: Statistical reliability
+
+## Examples
+
+### Basic Usage
+```bash
+# View current truth scores
+claude-flow truth
+
+# View scores for last 7 days
+claude-flow truth --period 7d
+
+# Export to HTML report
+claude-flow truth --export report.html --format html
+```
+
+### Advanced Analysis
+```bash
+# Monitor real-time scores
+claude-flow truth --watch
+
+# Find problematic files
+claude-flow truth --threshold 0.8
+
+# Agent-specific metrics
+claude-flow truth --agent coder --period 24h
+
+# JSON for processing
+claude-flow truth --format json | jq '.overall_score'
+```
+
+## Dashboard View
+
+```
+📊 Truth Metrics Dashboard
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Overall Truth Score: 0.947 ✅
+Trend: ↗️ +2.3% (7d)
+
+Top Performers:
+  verification-agent   0.982 ⭐
+  code-analyzer       0.971 ⭐
+  test-generator      0.958 ✅
+
+Needs Attention:
+  refactor-agent      0.821 ⚠️
+  docs-generator      0.794 ⚠️
+
+Recent Tasks:
+  task-456  0.991 ✅  "Implement auth"
+  task-455  0.967 ✅  "Add tests"
+  task-454  0.743 ❌  "Refactor API"
+```
+
+## Integration
+
+### With CI/CD
+```yaml
+# GitHub Actions example
+- name: Check Truth Scores
+  run: |
+    claude-flow truth --format json > truth.json
+    score=$(jq '.overall_score' truth.json)
+    if (( $(echo "$score < 0.95" | bc -l) )); then
+      echo "Truth score too low: $score"
+      exit 1
+    fi
+```
+
+### With Monitoring
+```bash
+# Send to monitoring system
+claude-flow truth --format json | \
+  curl -X POST https://metrics.example.com/api/truth \
+  -H "Content-Type: application/json" \
+  -d @-
+```
+
+## Configuration
+
+Set truth display preferences in `.claude-flow/config.json`:
+
+```json
+{
+  "truth": {
+    "defaultFormat": "table",
+    "defaultPeriod": "24h",
+    "warningThreshold": 0.85,
+    "criticalThreshold": 0.75,
+    "autoExport": {
+      "enabled": true,
+      "path": ".claude-flow/metrics/truth-daily.json"
+    }
+  }
+}
+```
+
+## Related Commands
+
+- `verify` - Run verification checks
+- `pair` - Collaborative development with truth tracking
+- `report` - Generate detailed reports