claude-flow-novice 2.10.5 → 2.10.6

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

@@ -0,0 +1,95 @@
+# Analysis Swarm Strategy
+
+## Purpose
+Comprehensive analysis through distributed agent coordination.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize analysis swarm
+mcp__claude-flow__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 6,
+  "strategy": "adaptive"
+})
+
+// Orchestrate analysis task
+mcp__claude-flow__task_orchestrate({
+  "task": "analyze system performance",
+  "strategy": "parallel",
+  "priority": "medium"
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow-novice swarm "analyze system performance" --strategy analysis`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn analysis agents
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Data Collector",
+  "capabilities": ["metrics", "logging", "monitoring"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Pattern Analyzer",
+  "capabilities": ["pattern-recognition", "anomaly-detection"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "documenter",
+  "name": "Report Generator",
+  "capabilities": ["reporting", "visualization"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "coordinator",
+  "name": "Insight Synthesizer",
+  "capabilities": ["synthesis", "correlation"]
+})
+```
+
+## Coordination Modes
+- Mesh: For exploratory analysis
+- Pipeline: For sequential processing
+- Hierarchical: For complex systems
+
+## Analysis Operations
+```javascript
+// Run performance analysis
+mcp__claude-flow__performance_report({
+  "format": "detailed",
+  "timeframe": "24h"
+})
+
+// Identify bottlenecks
+mcp__claude-flow__bottleneck_analyze({
+  "component": "api",
+  "metrics": ["response-time", "throughput"]
+})
+
+// Pattern recognition
+mcp__claude-flow__pattern_recognize({
+  "data": performanceData,
+  "patterns": ["anomaly", "trend", "cycle"]
+})
+```
+
+## Status Monitoring
+```javascript
+// Monitor analysis progress
+mcp__claude-flow__task_status({
+  "taskId": "analysis-task-001"
+})
+
+// Get analysis results
+mcp__claude-flow__task_results({
+  "taskId": "analysis-task-001"
+})
+```

package/claude-assets/commands/swarm/development.md

@@ -0,0 +1,96 @@
+# Development Swarm Strategy
+
+## Purpose
+Coordinated development through specialized agent teams.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize development swarm
+mcp__claude-flow__swarm_init({
+  "topology": "hierarchical",
+  "maxAgents": 8,
+  "strategy": "balanced"
+})
+
+// Orchestrate development task
+mcp__claude-flow__task_orchestrate({
+  "task": "build feature X",
+  "strategy": "parallel",
+  "priority": "high"
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow-novice swarm "build feature X" --strategy development`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn development agents
+mcp__claude-flow__agent_spawn({
+  "type": "architect",
+  "name": "System Designer",
+  "capabilities": ["system-design", "api-design"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "coder",
+  "name": "Frontend Developer",
+  "capabilities": ["react", "typescript", "ui"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "coder",
+  "name": "Backend Developer",
+  "capabilities": ["nodejs", "api", "database"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "specialist",
+  "name": "Database Expert",
+  "capabilities": ["sql", "nosql", "optimization"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Integration Tester",
+  "capabilities": ["integration", "e2e", "api-testing"]
+})
+```
+
+## Best Practices
+- Use hierarchical mode for large projects
+- Enable parallel execution
+- Implement continuous testing
+- Monitor swarm health regularly
+
+## Status Monitoring
+```javascript
+// Check swarm status
+mcp__claude-flow__swarm_status({
+  "swarmId": "development-swarm"
+})
+
+// Monitor agent performance
+mcp__claude-flow__agent_metrics({
+  "agentId": "architect-001"
+})
+
+// Real-time monitoring
+mcp__claude-flow__swarm_monitor({
+  "swarmId": "development-swarm",
+  "interval": 5000
+})
+```
+
+## Error Handling
+```javascript
+// Enable fault tolerance
+mcp__claude-flow__daa_fault_tolerance({
+  "agentId": "all",
+  "strategy": "auto-recovery"
+})
+```

package/claude-assets/commands/swarm/examples.md

@@ -0,0 +1,168 @@
+# Examples Swarm Strategy
+
+## Common Swarm Patterns
+
+### Research Swarm
+
+#### Using MCP Tools
+```javascript
+// Initialize research swarm
+mcp__claude-flow__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 6,
+  "strategy": "adaptive"
+})
+
+// Spawn research agents
+mcp__claude-flow__agent_spawn({
+  "type": "researcher",
+  "name": "AI Trends Researcher",
+  "capabilities": ["web-search", "analysis", "synthesis"]
+})
+
+// Orchestrate research
+mcp__claude-flow__task_orchestrate({
+  "task": "research AI trends",
+  "strategy": "parallel",
+  "priority": "medium"
+})
+
+// Monitor progress
+mcp__claude-flow__swarm_status({
+  "swarmId": "research-swarm"
+})
+```
+
+#### Using CLI (Fallback)
+```bash
+npx claude-flow-novice swarm "research AI trends" \
+  --strategy research \
+  --mode distributed \
+  --max-agents 6 \
+  --parallel
+```
+
+### Development Swarm
+
+#### Using MCP Tools
+```javascript
+// Initialize development swarm
+mcp__claude-flow__swarm_init({
+  "topology": "hierarchical",
+  "maxAgents": 8,
+  "strategy": "balanced"
+})
+
+// Spawn development team
+const devAgents = [
+  { type: "architect", name: "API Designer" },
+  { type: "coder", name: "Backend Developer" },
+  { type: "tester", name: "API Tester" },
+  { type: "documenter", name: "API Documenter" }
+]
+
+devAgents.forEach(agent => {
+  mcp__claude-flow__agent_spawn({
+    "type": agent.type,
+    "name": agent.name,
+    "swarmId": "dev-swarm"
+  })
+})
+
+// Orchestrate development
+mcp__claude-flow__task_orchestrate({
+  "task": "build REST API",
+  "strategy": "sequential",
+  "dependencies": ["design", "implement", "test", "document"]
+})
+
+// Enable monitoring
+mcp__claude-flow__swarm_monitor({
+  "swarmId": "dev-swarm",
+  "interval": 5000
+})
+```
+
+#### Using CLI (Fallback)
+```bash
+npx claude-flow-novice swarm "build REST API" \
+  --strategy development \
+  --mode hierarchical \
+  --monitor \
+  --output sqlite
+```
+
+### Analysis Swarm
+
+#### Using MCP Tools
+```javascript
+// Initialize analysis swarm
+mcp__claude-flow__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 5,
+  "strategy": "adaptive"
+})
+
+// Spawn analysis agents
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Code Analyzer",
+  "capabilities": ["static-analysis", "complexity-analysis"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Security Analyzer",
+  "capabilities": ["security-scan", "vulnerability-detection"]
+})
+
+// Parallel analysis execution
+mcp__claude-flow__parallel_execute({
+  "tasks": [
+    { "id": "analyze-code", "command": "analyze codebase structure" },
+    { "id": "analyze-security", "command": "scan for vulnerabilities" },
+    { "id": "analyze-performance", "command": "identify bottlenecks" }
+  ]
+})
+
+// Generate comprehensive report
+mcp__claude-flow__performance_report({
+  "format": "detailed",
+  "timeframe": "current"
+})
+```
+
+#### Using CLI (Fallback)
+```bash
+npx claude-flow-novice swarm "analyze codebase" \
+  --strategy analysis \
+  --mode mesh \
+  --parallel \
+  --timeout 300
+```
+
+## Error Handling Examples
+
+```javascript
+// Setup fault tolerance
+mcp__claude-flow__daa_fault_tolerance({
+  "agentId": "all",
+  "strategy": "auto-recovery"
+})
+
+// Handle errors gracefully
+try {
+  await mcp__claude-flow__task_orchestrate({
+    "task": "complex operation",
+    "strategy": "parallel"
+  })
+} catch (error) {
+  // Check swarm health
+  const status = await mcp__claude-flow__swarm_status({})
+  
+  // Log error patterns
+  await mcp__claude-flow__error_analysis({
+    "logs": [error.message]
+  })
+}
+```

package/claude-assets/commands/swarm/maintenance.md

@@ -0,0 +1,102 @@
+# Maintenance Swarm Strategy
+
+## Purpose
+System maintenance and updates through coordinated agents.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize maintenance swarm
+mcp__claude-flow__swarm_init({
+  "topology": "star",
+  "maxAgents": 5,
+  "strategy": "sequential"
+})
+
+// Orchestrate maintenance task
+mcp__claude-flow__task_orchestrate({
+  "task": "update dependencies",
+  "strategy": "sequential",
+  "priority": "medium",
+  "dependencies": ["backup", "test", "update", "verify"]
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow-novice swarm "update dependencies" --strategy maintenance`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn maintenance agents
+mcp__claude-flow__agent_spawn({
+  "type": "analyst",
+  "name": "Dependency Analyzer",
+  "capabilities": ["dependency-analysis", "version-management"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "monitor",
+  "name": "Security Scanner",
+  "capabilities": ["security", "vulnerability-scan"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Test Runner",
+  "capabilities": ["testing", "validation"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "documenter",
+  "name": "Documentation Updater",
+  "capabilities": ["documentation", "changelog"]
+})
+```
+
+## Safety Features
+
+### Backup and Recovery
+```javascript
+// Create system backup
+mcp__claude-flow__backup_create({
+  "components": ["code", "config", "dependencies"],
+  "destination": "./backups/maintenance-" + Date.now()
+})
+
+// Create state snapshot
+mcp__claude-flow__state_snapshot({
+  "name": "pre-maintenance-" + Date.now()
+})
+
+// Enable fault tolerance
+mcp__claude-flow__daa_fault_tolerance({
+  "agentId": "all",
+  "strategy": "checkpoint-recovery"
+})
+```
+
+### Security Scanning
+```javascript
+// Run security scan
+mcp__claude-flow__security_scan({
+  "target": "./",
+  "depth": "comprehensive"
+})
+```
+
+### Monitoring
+```javascript
+// Health check before/after
+mcp__claude-flow__health_check({
+  "components": ["dependencies", "tests", "build"]
+})
+
+// Monitor maintenance progress
+mcp__claude-flow__swarm_monitor({
+  "swarmId": "maintenance-swarm",
+  "interval": 3000
+})
+```

package/claude-assets/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-novice 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-assets/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-novice 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"
+})
+```