agentic-qe 3.11.0 → 3.11.2

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

@@ -0,0 +1,117 @@
+# Optimization Swarm Strategy
+
+## Purpose
+Performance optimization through specialized analysis.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize optimization swarm
+mcp__claude-flow__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 6,
+  "strategy": "adaptive"
+})
+
+// Orchestrate optimization task
+mcp__claude-flow__task_orchestrate({
+  "task": "optimize performance",
+  "strategy": "parallel",
+  "priority": "high"
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow swarm "optimize performance" --strategy optimization`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn optimization agents
+mcp__claude-flow__agent_spawn({
+  "type": "optimizer",
+  "name": "Performance Profiler",
+  "capabilities": ["profiling", "bottleneck-detection"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Memory Analyzer",
+  "capabilities": ["memory-analysis", "leak-detection"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "optimizer",
+  "name": "Code Optimizer",
+  "capabilities": ["code-optimization", "refactoring"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Benchmark Runner",
+  "capabilities": ["benchmarking", "performance-testing"]
+})
+```
+
+## Optimization Areas
+
+### Performance Analysis
+```javascript
+// Analyze bottlenecks
+mcp__claude-flow__bottleneck_analyze({
+  "component": "all",
+  "metrics": ["cpu", "memory", "io", "network"]
+})
+
+// Run benchmarks
+mcp__claude-flow__benchmark_run({
+  "suite": "performance"
+})
+
+// WASM optimization
+mcp__claude-flow__wasm_optimize({
+  "operation": "simd-acceleration"
+})
+```
+
+### Optimization Operations
+```javascript
+// Optimize topology
+mcp__claude-flow__topology_optimize({
+  "swarmId": "optimization-swarm"
+})
+
+// DAA optimization
+mcp__claude-flow__daa_optimization({
+  "target": "performance",
+  "metrics": ["speed", "memory", "efficiency"]
+})
+
+// Load balancing
+mcp__claude-flow__load_balance({
+  "swarmId": "optimization-swarm",
+  "tasks": optimizationTasks
+})
+```
+
+### Monitoring and Reporting
+```javascript
+// Performance report
+mcp__claude-flow__performance_report({
+  "format": "detailed",
+  "timeframe": "7d"
+})
+
+// Trend analysis
+mcp__claude-flow__trend_analysis({
+  "metric": "performance",
+  "period": "30d"
+})
+
+// Cost analysis
+mcp__claude-flow__cost_analysis({
+  "timeframe": "30d"
+})
+```

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

@@ -0,0 +1,136 @@
+# Research Swarm Strategy
+
+## Purpose
+Deep research through parallel information gathering.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize research swarm
+mcp__claude-flow__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 6,
+  "strategy": "adaptive"
+})
+
+// Orchestrate research task
+mcp__claude-flow__task_orchestrate({
+  "task": "research topic X",
+  "strategy": "parallel",
+  "priority": "medium"
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow swarm "research topic X" --strategy research`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn research agents
+mcp__claude-flow__agent_spawn({
+  "type": "researcher",
+  "name": "Web Researcher",
+  "capabilities": ["web-search", "content-extraction", "source-validation"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "researcher",
+  "name": "Academic Researcher",
+  "capabilities": ["paper-analysis", "citation-tracking", "literature-review"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Data Analyst",
+  "capabilities": ["data-processing", "statistical-analysis", "visualization"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "documenter",
+  "name": "Report Writer",
+  "capabilities": ["synthesis", "technical-writing", "formatting"]
+})
+```
+
+## Research Methods
+
+### Information Gathering
+```javascript
+// Parallel information collection
+mcp__claude-flow__parallel_execute({
+  "tasks": [
+    { "id": "web-search", "command": "search recent publications" },
+    { "id": "academic-search", "command": "search academic databases" },
+    { "id": "data-collection", "command": "gather relevant datasets" }
+  ]
+})
+
+// Store research findings
+mcp__claude-flow__memory_usage({
+  "action": "store",
+  "key": "research-findings-" + Date.now(),
+  "value": JSON.stringify(findings),
+  "namespace": "research",
+  "ttl": 604800 // 7 days
+})
+```
+
+### Analysis and Validation
+```javascript
+// Pattern recognition in findings
+mcp__claude-flow__pattern_recognize({
+  "data": researchData,
+  "patterns": ["trend", "correlation", "outlier"]
+})
+
+// Cognitive analysis
+mcp__claude-flow__cognitive_analyze({
+  "behavior": "research-synthesis"
+})
+
+// Cross-reference validation
+mcp__claude-flow__quality_assess({
+  "target": "research-sources",
+  "criteria": ["credibility", "relevance", "recency"]
+})
+```
+
+### Knowledge Management
+```javascript
+// Search existing knowledge
+mcp__claude-flow__memory_search({
+  "pattern": "topic X",
+  "namespace": "research",
+  "limit": 20
+})
+
+// Create knowledge connections
+mcp__claude-flow__neural_patterns({
+  "action": "learn",
+  "operation": "knowledge-graph",
+  "metadata": {
+    "topic": "X",
+    "connections": relatedTopics
+  }
+})
+```
+
+### Reporting
+```javascript
+// Generate research report
+mcp__claude-flow__workflow_execute({
+  "workflowId": "research-report-generation",
+  "params": {
+    "findings": findings,
+    "format": "comprehensive"
+  }
+})
+
+// Monitor progress
+mcp__claude-flow__swarm_status({
+  "swarmId": "research-swarm"
+})
+```

package/.claude/commands/swarm/swarm-analysis.md

@@ -0,0 +1,8 @@
+# swarm-analysis
+
+Command documentation for swarm-analysis in category swarm.
+
+Usage:
+```bash
+npx claude-flow swarm swarm-analysis [options]
+```

package/.claude/commands/swarm/swarm-background.md

@@ -0,0 +1,8 @@
+# swarm-background
+
+Command documentation for swarm-background in category swarm.
+
+Usage:
+```bash
+npx claude-flow swarm swarm-background [options]
+```

package/.claude/commands/swarm/swarm-init.md

@@ -0,0 +1,19 @@
+# swarm-init
+
+Initialize a new swarm with specified topology.
+
+## Usage
+```bash
+npx claude-flow swarm init [options]
+```
+
+## Options
+- `--topology <type>` - Swarm topology (mesh, hierarchical, ring, star)
+- `--max-agents <n>` - Maximum agents
+- `--strategy <type>` - Distribution strategy
+
+## Examples
+```bash
+npx claude-flow swarm init --topology mesh
+npx claude-flow swarm init --topology hierarchical --max-agents 8
+```

package/.claude/commands/swarm/swarm-modes.md

@@ -0,0 +1,8 @@
+# swarm-modes
+
+Command documentation for swarm-modes in category swarm.
+
+Usage:
+```bash
+npx claude-flow swarm swarm-modes [options]
+```

package/.claude/commands/swarm/swarm-monitor.md

@@ -0,0 +1,8 @@
+# swarm-monitor
+
+Command documentation for swarm-monitor in category swarm.
+
+Usage:
+```bash
+npx claude-flow swarm swarm-monitor [options]
+```

package/.claude/commands/swarm/swarm-spawn.md

@@ -0,0 +1,19 @@
+# swarm-spawn
+
+Spawn agents in the swarm.
+
+## Usage
+```bash
+npx claude-flow swarm spawn [options]
+```
+
+## Options
+- `--type <type>` - Agent type
+- `--count <n>` - Number to spawn
+- `--capabilities <list>` - Agent capabilities
+
+## Examples
+```bash
+npx claude-flow swarm spawn --type coder --count 3
+npx claude-flow swarm spawn --type researcher --capabilities "web-search,analysis"
+```

package/.claude/commands/swarm/swarm-status.md

@@ -0,0 +1,8 @@
+# swarm-status
+
+Command documentation for swarm-status in category swarm.
+
+Usage:
+```bash
+npx claude-flow swarm swarm-status [options]
+```

package/.claude/commands/swarm/swarm-strategies.md

@@ -0,0 +1,8 @@
+# swarm-strategies
+
+Command documentation for swarm-strategies in category swarm.
+
+Usage:
+```bash
+npx claude-flow swarm swarm-strategies [options]
+```

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/workflows/README.md

@@ -0,0 +1,9 @@
+# Workflows Commands
+
+Commands for workflows operations in Claude Flow.
+
+## Available Commands
+
+- [workflow-create](./workflow-create.md)
+- [workflow-execute](./workflow-execute.md)
+- [workflow-export](./workflow-export.md)

package/.claude/commands/workflows/development.md

@@ -0,0 +1,78 @@
+# Development Workflow Coordination
+
+## Purpose
+Structure Claude Code's approach to complex development tasks for maximum efficiency.
+
+## Step-by-Step Coordination
+
+### 1. Initialize Development Framework
+```
+Tool: mcp__claude-flow__swarm_init
+Parameters: {"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}
+```
+Creates hierarchical structure for organized, top-down development.
+
+### 2. Define Development Perspectives
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "architect",
+  "name": "System Design",
+  "capabilities": ["api-design", "database-schema"]
+}
+```
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "coder",
+  "name": "Implementation Focus",
+  "capabilities": ["nodejs", "typescript", "express"]
+}
+```
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "tester",
+  "name": "Quality Assurance",
+  "capabilities": ["unit-testing", "integration-testing"]
+}
+```
+Sets up architectural and implementation thinking patterns.
+
+### 3. Coordinate Implementation
+```
+Tool: mcp__claude-flow__task_orchestrate
+Parameters: {
+  "task": "Build REST API with authentication",
+  "strategy": "parallel",
+  "priority": "high",
+  "dependencies": ["database setup", "auth system"]
+}
+```
+
+### 4. Monitor Progress
+```
+Tool: mcp__claude-flow__task_status
+Parameters: {"taskId": "api-build-task-123"}
+```
+
+## What Claude Code Actually Does
+1. Uses **Write** tool to create new files
+2. Uses **Edit/MultiEdit** tools for code modifications
+3. Uses **Bash** tool for testing and building
+4. Uses **TodoWrite** tool for task tracking
+5. Follows coordination patterns for systematic implementation
+
+Remember: All code is written by Claude Code using its native tools!
+
+## CLI Usage
+```bash
+# Start development workflow via CLI
+npx claude-flow workflow dev "REST API with auth"
+
+# Create custom workflow
+npx claude-flow workflow create --name "api-dev" --steps "design,implement,test,deploy"
+
+# Execute saved workflow
+npx claude-flow workflow execute api-dev
+```