claude-flow-novice 2.10.9 → 2.12.0

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

@@ -1,8 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,131 +0,0 @@
-# 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

@@ -1,423 +0,0 @@
-#!/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;