claude-flow-novice 2.10.4 → 2.10.6

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

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

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

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

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

@@ -0,0 +1,19 @@
+# swarm-init
+
+Initialize a new swarm with specified topology.
+
+## Usage
+```bash
+npx claude-flow-novice 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-novice swarm init --topology mesh
+npx claude-flow-novice swarm init --topology hierarchical --max-agents 8
+```

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,27 @@
+# swarm
+
+Main swarm orchestration command for Claude Flow.
+
+## Usage
+```bash
+npx claude-flow-novice swarm <objective> [options]
+```
+
+## Options
+- `--strategy <type>` - Execution strategy (research, development, analysis, testing)
+- `--mode <type>` - Coordination mode (centralized, distributed, hierarchical, mesh)
+- `--max-agents <n>` - Maximum number of agents (default: 5)
+- `--claude` - Open Claude Code CLI with swarm prompt
+- `--parallel` - Enable parallel execution
+
+## Examples
+```bash
+# Basic swarm
+npx claude-flow-novice swarm "Build REST API"
+
+# With strategy
+npx claude-flow-novice swarm "Research AI patterns" --strategy research
+
+# Open in Claude Code
+npx claude-flow-novice swarm "Build API" --claude
+```

package/claude-assets/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-novice 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-assets/commands/swarm.js

@@ -0,0 +1,423 @@
+#!/usr/bin/env node
+
+/**
+ * Swarm Management Slash Command
+ * Usage: /swarm <action> [options]
+ */
+
+import { SlashCommand } from '../core/slash-command.js';
+
+export class SwarmCommand extends SlashCommand {
+  constructor() {
+    super('swarm', 'Manage AI agent swarms with various topologies and coordination patterns');
+  }
+
+  getUsage() {
+    return '/swarm <action> [options]';
+  }
+
+  getExamples() {
+    return [
+      '/swarm init mesh 8 - Initialize mesh topology with 8 agents',
+      '/swarm status - Get current swarm status',
+      '/swarm spawn researcher - Spawn a researcher agent',
+      '/swarm orchestrate "Build REST API" - Orchestrate a task',
+      '/swarm monitor - Monitor swarm activity',
+      '/swarm scale 12 - Scale swarm to 12 agents',
+      '/swarm destroy - Gracefully shutdown swarm'
+    ];
+  }
+
+  async execute(args, context) {
+    const [action, ...params] = args;
+
+    if (!action) {
+      return this.formatResponse({
+        success: false,
+        error: 'Action required',
+        usage: this.getUsage(),
+        availableActions: [
+          'init', 'status', 'spawn', 'orchestrate', 'monitor', 'scale', 'destroy'
+        ]
+      });
+    }
+
+    try {
+      let result;
+
+      switch (action.toLowerCase()) {
+        case 'init':
+          result = await this.initSwarm(params);
+          break;
+        
+        case 'status':
+          result = await this.getStatus(params);
+          break;
+        
+        case 'spawn':
+          result = await this.spawnAgent(params);
+          break;
+        
+        case 'orchestrate':
+          result = await this.orchestrateTask(params);
+          break;
+        
+        case 'monitor':
+          result = await this.monitorSwarm(params);
+          break;
+        
+        case 'scale':
+          result = await this.scaleSwarm(params);
+          break;
+        
+        case 'destroy':
+          result = await this.destroySwarm(params);
+          break;
+        
+        default:
+          result = {
+            success: false,
+            error: `Unknown action: ${action}`,
+            availableActions: [
+              'init', 'status', 'spawn', 'orchestrate', 'monitor', 'scale', 'destroy'
+            ]
+          };
+      }
+
+      return this.formatResponse(result);
+    } catch (error) {
+      return this.formatResponse({
+        success: false,
+        error: error.message,
+        action: action
+      });
+    }
+  }
+
+  async initSwarm(params) {
+    const [topology = 'mesh', maxAgents = '8', strategy = 'balanced'] = params;
+
+    const validTopologies = ['mesh', 'hierarchical', 'ring', 'star'];
+    if (!validTopologies.includes(topology)) {
+      return {
+        success: false,
+        error: `Invalid topology. Valid options: ${validTopologies.join(', ')}`
+      };
+    }
+
+    const agentCount = parseInt(maxAgents);
+    if (isNaN(agentCount) || agentCount < 1 || agentCount > 100) {
+      return {
+        success: false,
+        error: 'Agent count must be between 1 and 100'
+      };
+    }
+
+    console.log(`🚀 Initializing ${topology} swarm with ${agentCount} agents...`);
+
+    const prompt = `
+🚀 **SWARM INITIALIZATION**
+
+**Configuration:**
+- Topology: ${topology}
+- Max Agents: ${agentCount}
+- Strategy: ${strategy}
+
+**Initialize the swarm with MCP tools:**
+
+\`\`\`javascript
+// Step 1: Initialize swarm coordination
+mcp__claude-flow__swarm_init({
+  topology: "${topology}",
+  maxAgents: ${agentCount},
+  strategy: "${strategy}"
+});
+
+// Step 2: Set up agent coordination patterns
+mcp__claude-flow__coordination_sync({ swarmId: "swarm-${Date.now()}" });
+\`\`\`
+
+**Then use Claude Code's Task tool to spawn actual working agents:**
+\`\`\`javascript
+Task("Coordinator Agent", "Coordinate swarm activities and task distribution", "coordinator")
+Task("Research Agent", "Analyze requirements and gather information", "researcher")
+Task("Coder Agent", "Implement code and solutions", "coder")
+Task("Tester Agent", "Create and run comprehensive tests", "tester")
+\`\`\`
+
+**Execute this swarm initialization now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      topology: topology,
+      maxAgents: agentCount,
+      strategy: strategy,
+      swarmId: `swarm-${Date.now()}`
+    };
+  }
+
+  async getStatus(params) {
+    const [verbose = 'false'] = params;
+    const isVerbose = verbose.toLowerCase() === 'true';
+
+    console.log('📊 Getting swarm status...');
+
+    const prompt = `
+📊 **SWARM STATUS CHECK**
+
+**Get current swarm information:**
+
+\`\`\`javascript
+// Check swarm status with MCP tools
+mcp__claude-flow__swarm_status({ verbose: ${isVerbose} });
+
+// Get agent metrics
+mcp__claude-flow__agent_metrics({ metric: "all" });
+
+// Check active tasks
+mcp__claude-flow__task_status({ detailed: ${isVerbose} });
+\`\`\`
+
+**Execute this status check now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      verbose: isVerbose
+    };
+  }
+
+  async spawnAgent(params) {
+    const [type, ...nameParams] = params;
+    const name = nameParams.join(' ');
+
+    if (!type) {
+      return {
+        success: false,
+        error: 'Agent type required',
+        availableTypes: [
+          'researcher', 'coder', 'analyst', 'optimizer', 'coordinator',
+          'tester', 'reviewer', 'architect', 'documenter'
+        ]
+      };
+    }
+
+    console.log(`🤖 Spawning ${type} agent${name ? ` named "${name}"` : ''}...`);
+
+    const prompt = `
+🤖 **SPAWN AGENT**
+
+**Agent Configuration:**
+- Type: ${type}
+- Name: ${name || `${type}-${Date.now()}`}
+
+**Use both MCP coordination and Claude Code execution:**
+
+\`\`\`javascript
+// Step 1: Register agent with MCP coordination
+mcp__claude-flow__agent_spawn({
+  type: "${type}",
+  name: "${name || `${type}-${Date.now()}`}",
+  capabilities: ["${type}-specific-capabilities"]
+});
+
+// Step 2: Spawn actual working agent with Claude Code's Task tool
+Task("${name || `${type} Agent`}", "Execute ${type} tasks with coordination hooks", "${type}")
+\`\`\`
+
+**Agent Instructions:**
+The agent should use hooks for coordination:
+- Pre-task: \`npx claude-flow@alpha hooks pre-task\`
+- Post-edit: \`npx claude-flow@alpha hooks post-edit\`
+- Post-task: \`npx claude-flow@alpha hooks post-task\`
+
+**Execute this agent spawn now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      agentType: type,
+      agentName: name || `${type}-${Date.now()}`
+    };
+  }
+
+  async orchestrateTask(params) {
+    const task = params.join(' ');
+
+    if (!task) {
+      return {
+        success: false,
+        error: 'Task description required'
+      };
+    }
+
+    console.log(`🎯 Orchestrating task: ${task}`);
+
+    const prompt = `
+🎯 **TASK ORCHESTRATION**
+
+**Task:** ${task}
+
+**Orchestrate with coordinated agents:**
+
+\`\`\`javascript
+// Step 1: Set up task orchestration
+mcp__claude-flow__task_orchestrate({
+  task: "${task}",
+  strategy: "adaptive",
+  priority: "high"
+});
+
+// Step 2: Spawn coordinated agents with Claude Code's Task tool
+Task("Task Coordinator", "Break down and coordinate: ${task}", "coordinator")
+Task("Implementation Agent", "Execute main implementation for: ${task}", "coder")
+Task("Quality Agent", "Ensure quality and testing for: ${task}", "tester")
+Task("Review Agent", "Review and validate: ${task}", "reviewer")
+\`\`\`
+
+**Coordination Protocol:**
+1. Each agent uses hooks for coordination
+2. Shared memory for context and progress
+3. Automatic load balancing and optimization
+
+**Execute this task orchestration now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      task: task,
+      taskId: `task-${Date.now()}`
+    };
+  }
+
+  async monitorSwarm(params) {
+    const [duration = '30'] = params;
+    const monitorDuration = parseInt(duration);
+
+    console.log(`👁️ Monitoring swarm for ${monitorDuration} seconds...`);
+
+    const prompt = `
+👁️ **SWARM MONITORING**
+
+**Monitor swarm activity:**
+
+\`\`\`javascript
+// Real-time swarm monitoring
+mcp__claude-flow__swarm_monitor({
+  interval: 5,
+  duration: ${monitorDuration}
+});
+
+// Performance metrics
+mcp__claude-flow__performance_report({ format: "detailed" });
+
+// Agent performance
+mcp__claude-flow__agent_metrics({ metric: "performance" });
+\`\`\`
+
+**Monitoring Dashboard:**
+- Agent status and performance
+- Task progress and completion
+- Resource utilization
+- Coordination efficiency
+
+**Execute this monitoring now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      duration: monitorDuration
+    };
+  }
+
+  async scaleSwarm(params) {
+    const [targetSize] = params;
+    const newSize = parseInt(targetSize);
+
+    if (isNaN(newSize) || newSize < 1 || newSize > 100) {
+      return {
+        success: false,
+        error: 'Target size must be between 1 and 100'
+      };
+    }
+
+    console.log(`📈 Scaling swarm to ${newSize} agents...`);
+
+    const prompt = `
+📈 **SWARM SCALING**
+
+**Scale to ${newSize} agents:**
+
+\`\`\`javascript
+// Auto-scale swarm
+mcp__claude-flow__swarm_scale({
+  targetSize: ${newSize}
+});
+
+// Optimize topology for new size
+mcp__claude-flow__topology_optimize();
+
+// Rebalance tasks
+mcp__claude-flow__load_balance({ tasks: ["current-tasks"] });
+\`\`\`
+
+**Scaling Strategy:**
+- Graceful addition/removal of agents
+- Automatic task redistribution
+- Topology optimization
+- Performance monitoring
+
+**Execute this scaling now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      targetSize: newSize
+    };
+  }
+
+  async destroySwarm(params) {
+    console.log('🛑 Destroying swarm...');
+
+    const prompt = `
+🛑 **SWARM DESTRUCTION**
+
+**Gracefully shutdown swarm:**
+
+\`\`\`javascript
+// Step 1: Complete current tasks
+mcp__claude-flow__task_status({ detailed: true });
+
+// Step 2: Save state and metrics
+mcp__claude-flow__state_snapshot({ name: "final-state" });
+
+// Step 3: Destroy swarm
+mcp__claude-flow__swarm_destroy();
+\`\`\`
+
+**Shutdown Checklist:**
+- ✅ Complete active tasks
+- ✅ Save coordination state
+- ✅ Export performance metrics
+- ✅ Clean up resources
+- ✅ Graceful agent termination
+
+**Execute this shutdown now**:
+`;
+
+    return {
+      success: true,
+      prompt: prompt,
+      action: 'destroy'
+    };
+  }
+}
+
+export default SwarmCommand;