claude-flow-novice 2.8.1 → 2.9.0

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

@@ -1,95 +0,0 @@
-# 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/commands/swarm/development.md

@@ -1,96 +0,0 @@
-# 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/commands/swarm/examples.md

@@ -1,168 +0,0 @@
-# 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/commands/swarm/maintenance.md

@@ -1,102 +0,0 @@
-# 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/commands/swarm/optimization.md

@@ -1,117 +0,0 @@
-# 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/commands/swarm/research.md

@@ -1,136 +0,0 @@
-# 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"
-})
-```