claude-flow-novice 2.10.9 → 2.11.0

package/claude-assets/commands/neural.js

@@ -1,572 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Neural Networks Slash Command
- * Usage: /neural <action> [options]
- */
-
-import { SlashCommand } from '../core/slash-command.js';
-
-export class NeuralCommand extends SlashCommand {
-  constructor() {
-    super('neural', 'Manage neural networks and AI training for agent coordination');
-  }
-
-  getUsage() {
-    return '/neural <action> [options]';
-  }
-
-  getExamples() {
-    return [
-      '/neural status - Check neural network status',
-      '/neural train coordination 50 - Train coordination patterns for 50 epochs',
-      '/neural patterns analyze - Analyze cognitive patterns',
-      '/neural predict "task completion" - Make AI predictions',
-      '/neural compress model-123 0.5 - Compress neural model by 50%',
-      '/neural ensemble create - Create model ensemble',
-      '/neural explain prediction-456 - Get AI explainability'
-    ];
-  }
-
-  async execute(args, context) {
-    const [action, ...params] = args;
-
-    if (!action) {
-      return this.formatResponse({
-        success: false,
-        error: 'Action required',
-        usage: this.getUsage(),
-        availableActions: [
-          'status', 'train', 'patterns', 'predict', 'compress',
-          'ensemble', 'explain', 'transfer', 'load', 'save'
-        ]
-      });
-    }
-
-    try {
-      let result;
-
-      switch (action.toLowerCase()) {
-        case 'status':
-          result = await this.getStatus(params);
-          break;
-        
-        case 'train':
-          result = await this.trainModel(params);
-          break;
-        
-        case 'patterns':
-          result = await this.analyzePatterns(params);
-          break;
-        
-        case 'predict':
-          result = await this.makePrediction(params);
-          break;
-        
-        case 'compress':
-          result = await this.compressModel(params);
-          break;
-        
-        case 'ensemble':
-          result = await this.manageEnsemble(params);
-          break;
-        
-        case 'explain':
-          result = await this.explainPrediction(params);
-          break;
-        
-        case 'transfer':
-          result = await this.transferLearning(params);
-          break;
-        
-        case 'load':
-          result = await this.loadModel(params);
-          break;
-        
-        case 'save':
-          result = await this.saveModel(params);
-          break;
-        
-        default:
-          result = {
-            success: false,
-            error: `Unknown action: ${action}`,
-            availableActions: [
-              'status', 'train', 'patterns', 'predict', 'compress',
-              'ensemble', 'explain', 'transfer', 'load', 'save'
-            ]
-          };
-      }
-
-      return this.formatResponse(result);
-    } catch (error) {
-      return this.formatResponse({
-        success: false,
-        error: error.message,
-        action: action
-      });
-    }
-  }
-
-  async getStatus(params) {
-    const [modelId] = params;
-    
-    console.log(`🧠 Checking neural network status${modelId ? ` for model: ${modelId}` : ''}...`);
-
-    const prompt = `
-🧠 **NEURAL NETWORK STATUS**
-
-**Check neural network status and performance:**
-
-\`\`\`javascript
-// Get neural status with MCP tools
-mcp__claude-flow__neural_status(${modelId ? `{ modelId: "${modelId}" }` : '{}'});
-
-// Check cognitive patterns
-mcp__claude-flow__neural_patterns({ action: "analyze" });
-
-// Get performance metrics
-mcp__claude-flow__performance_report({ format: "neural" });
-\`\`\`
-
-**Status Information:**
-- Neural model health and performance
-- Training progress and accuracy
-- Resource utilization
-- Pattern recognition capabilities
-- WASM SIMD optimization status
-
-**Execute neural status check now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      modelId: modelId
-    };
-  }
-
-  async trainModel(params) {
-    const [patternType, epochs = '50', trainingData] = params;
-
-    if (!patternType) {
-      return {
-        success: false,
-        error: 'Pattern type required',
-        availableTypes: ['coordination', 'optimization', 'prediction']
-      };
-    }
-
-    const epochCount = parseInt(epochs);
-    if (isNaN(epochCount) || epochCount < 1 || epochCount > 1000) {
-      return {
-        success: false,
-        error: 'Epochs must be between 1 and 1000'
-      };
-    }
-
-    console.log(`🎯 Training ${patternType} patterns for ${epochCount} epochs...`);
-
-    const prompt = `
-🎯 **NEURAL NETWORK TRAINING**
-
-**Configuration:**
-- Pattern Type: ${patternType}
-- Epochs: ${epochCount}
-- Training Data: ${trainingData || 'auto-generated'}
-
-**Start neural training:**
-
-\`\`\`javascript
-// Train neural patterns with WASM SIMD acceleration
-mcp__claude-flow__neural_train({
-  pattern_type: "${patternType}",
-  epochs: ${epochCount},
-  training_data: "${trainingData || 'agent-coordination-data'}"
-});
-
-// Enable WASM optimization
-mcp__claude-flow__wasm_optimize({ operation: "neural-training" });
-
-// Monitor training progress
-mcp__claude-flow__neural_status({ modelId: "training-${Date.now()}" });
-\`\`\`
-
-**Training Features:**
-- ✅ WASM SIMD acceleration for 2.8-4.4x speed
-- ✅ Adaptive learning algorithms
-- ✅ Pattern recognition optimization
-- ✅ Real-time performance monitoring
-- ✅ Automatic checkpoint saving
-
-**Execute neural training now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      patternType: patternType,
-      epochs: epochCount,
-      trainingData: trainingData
-    };
-  }
-
-  async analyzePatterns(params) {
-    const [action = 'analyze', operation, outcome] = params;
-
-    console.log(`🔍 Analyzing cognitive patterns with action: ${action}`);
-
-    const prompt = `
-🔍 **COGNITIVE PATTERN ANALYSIS**
-
-**Action:** ${action}
-
-**Analyze cognitive and coordination patterns:**
-
-\`\`\`javascript
-// Analyze cognitive patterns
-mcp__claude-flow__neural_patterns({
-  action: "${action}",
-  ${operation ? `operation: "${operation}",` : ''}
-  ${outcome ? `outcome: "${outcome}"` : ''}
-});
-
-// Pattern recognition
-mcp__claude-flow__pattern_recognize({
-  data: ["current-agent-behaviors"],
-  patterns: ["convergent", "divergent", "lateral", "systems"]
-});
-
-// Cognitive behavior analysis
-mcp__claude-flow__cognitive_analyze({
-  behavior: "${action}-pattern"
-});
-\`\`\`
-
-**Pattern Types:**
-- 🎯 Convergent thinking patterns
-- 🎆 Divergent creativity patterns
-- 🔄 Lateral problem-solving
-- 🌐 Systems thinking
-- ⚙️ Critical analysis patterns
-- 🎨 Abstract reasoning
-
-**Execute pattern analysis now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      action: action,
-      operation: operation,
-      outcome: outcome
-    };
-  }
-
-  async makePrediction(params) {
-    const input = params.join(' ');
-
-    if (!input) {
-      return {
-        success: false,
-        error: 'Input required for prediction'
-      };
-    }
-
-    console.log(`🔮 Making AI prediction for: ${input}`);
-
-    const prompt = `
-🔮 **AI PREDICTION**
-
-**Input:** ${input}
-
-**Generate AI predictions:**
-
-\`\`\`javascript
-// Make neural predictions
-mcp__claude-flow__neural_predict({
-  modelId: "coordination-model",
-  input: "${input}"
-});
-
-// Run inference
-mcp__claude-flow__inference_run({
-  modelId: "coordination-model",
-  data: ["${input}"]
-});
-\`\`\`
-
-**Prediction Capabilities:**
-- Task completion probability
-- Resource requirements estimation
-- Performance optimization suggestions
-- Coordination efficiency predictions
-- Risk assessment and mitigation
-
-**Execute AI prediction now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      input: input
-    };
-  }
-
-  async compressModel(params) {
-    const [modelId, ratio = '0.5'] = params;
-
-    if (!modelId) {
-      return {
-        success: false,
-        error: 'Model ID required for compression'
-      };
-    }
-
-    const compressionRatio = parseFloat(ratio);
-    if (isNaN(compressionRatio) || compressionRatio <= 0 || compressionRatio >= 1) {
-      return {
-        success: false,
-        error: 'Compression ratio must be between 0 and 1'
-      };
-    }
-
-    console.log(`🗃️ Compressing model ${modelId} by ${(compressionRatio * 100).toFixed(1)}%...`);
-
-    const prompt = `
-🗃️ **NEURAL MODEL COMPRESSION**
-
-**Model ID:** ${modelId}
-**Compression Ratio:** ${(compressionRatio * 100).toFixed(1)}%
-
-**Compress neural model:**
-
-\`\`\`javascript
-// Compress neural model
-mcp__claude-flow__neural_compress({
-  modelId: "${modelId}",
-  ratio: ${compressionRatio}
-});
-\`\`\`
-
-**Compression Benefits:**
-- ⚙️ Reduced memory usage
-- ⚡ Faster inference speed
-- 💾 Smaller storage footprint
-- 🚀 Improved deployment efficiency
-
-**Execute model compression now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      modelId: modelId,
-      compressionRatio: compressionRatio
-    };
-  }
-
-  async manageEnsemble(params) {
-    const [action = 'create', ...models] = params;
-
-    console.log(`🎵 Managing model ensemble: ${action}`);
-
-    const prompt = `
-🎵 **MODEL ENSEMBLE MANAGEMENT**
-
-**Action:** ${action}
-**Models:** ${models.length > 0 ? models.join(', ') : 'auto-select'}
-
-**Manage model ensemble:**
-
-\`\`\`javascript
-// Create model ensemble
-mcp__claude-flow__ensemble_create({
-  models: [${models.length > 0 ? models.map(m => `"${m}"`).join(', ') : '"coordination-model", "optimization-model", "prediction-model"'}],
-  strategy: "voting"
-});
-\`\`\`
-
-**Ensemble Benefits:**
-- 🎯 Improved accuracy through model combination
-- 🔄 Robust predictions with multiple perspectives
-- ⚙️ Reduced overfitting risk
-- 📈 Enhanced performance metrics
-
-**Execute ensemble management now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      action: action,
-      models: models
-    };
-  }
-
-  async explainPrediction(params) {
-    const [predictionId] = params;
-
-    if (!predictionId) {
-      return {
-        success: false,
-        error: 'Prediction ID required for explainability'
-      };
-    }
-
-    console.log(`🔎 Explaining prediction: ${predictionId}`);
-
-    const prompt = `
-🔎 **AI EXPLAINABILITY**
-
-**Prediction ID:** ${predictionId}
-
-**Generate AI explanation:**
-
-\`\`\`javascript
-// Get AI explainability
-mcp__claude-flow__neural_explain({
-  modelId: "coordination-model",
-  prediction: { id: "${predictionId}" }
-});
-\`\`\`
-
-**Explainability Features:**
-- 📊 Feature importance analysis
-- 🔄 Decision path visualization
-- ⚙️ Model behavior interpretation
-- 🎯 Confidence score breakdown
-- 📝 Human-readable explanations
-
-**Execute AI explanation now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      predictionId: predictionId
-    };
-  }
-
-  async transferLearning(params) {
-    const [sourceModel, targetDomain] = params;
-
-    if (!sourceModel || !targetDomain) {
-      return {
-        success: false,
-        error: 'Source model and target domain required for transfer learning'
-      };
-    }
-
-    console.log(`🔄 Transfer learning from ${sourceModel} to ${targetDomain}...`);
-
-    const prompt = `
-🔄 **TRANSFER LEARNING**
-
-**Source Model:** ${sourceModel}
-**Target Domain:** ${targetDomain}
-
-**Execute transfer learning:**
-
-\`\`\`javascript
-// Transfer learning
-mcp__claude-flow__transfer_learn({
-  sourceModel: "${sourceModel}",
-  targetDomain: "${targetDomain}"
-});
-\`\`\`
-
-**Transfer Learning Benefits:**
-- ⚡ Faster training on new domains
-- 🎯 Leverages existing knowledge
-- 📉 Reduced data requirements
-- ⚙️ Improved generalization
-
-**Execute transfer learning now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      sourceModel: sourceModel,
-      targetDomain: targetDomain
-    };
-  }
-
-  async loadModel(params) {
-    const [modelPath] = params;
-
-    if (!modelPath) {
-      return {
-        success: false,
-        error: 'Model path required for loading'
-      };
-    }
-
-    console.log(`📥 Loading model from: ${modelPath}`);
-
-    const prompt = `
-📥 **LOAD NEURAL MODEL**
-
-**Model Path:** ${modelPath}
-
-**Load pre-trained model:**
-
-\`\`\`javascript
-// Load pre-trained model
-mcp__claude-flow__model_load({
-  modelPath: "${modelPath}"
-});
-\`\`\`
-
-**Execute model loading now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      modelPath: modelPath
-    };
-  }
-
-  async saveModel(params) {
-    const [modelId, path] = params;
-
-    if (!modelId || !path) {
-      return {
-        success: false,
-        error: 'Model ID and path required for saving'
-      };
-    }
-
-    console.log(`💾 Saving model ${modelId} to: ${path}`);
-
-    const prompt = `
-💾 **SAVE NEURAL MODEL**
-
-**Model ID:** ${modelId}
-**Save Path:** ${path}
-
-**Save trained model:**
-
-\`\`\`javascript
-// Save trained model
-mcp__claude-flow__model_save({
-  modelId: "${modelId}",
-  path: "${path}"
-});
-\`\`\`
-
-**Execute model saving now**:
-`;
-
-    return {
-      success: true,
-      prompt: prompt,
-      modelId: modelId,
-      path: path
-    };
-  }
-}
-
-export default NeuralCommand;

package/claude-assets/commands/optimization/README.md

@@ -1,9 +0,0 @@
-# Optimization Commands
-
-Commands for optimization operations in Claude Flow.
-
-## Available Commands
-
-- [topology-optimize](./topology-optimize.md)
-- [parallel-execute](./parallel-execute.md)
-- [cache-manage](./cache-manage.md)

package/claude-assets/commands/optimization/auto-topology.md

@@ -1,62 +0,0 @@
-# Automatic Topology Selection
-
-## Purpose
-Automatically select the optimal swarm topology based on task complexity analysis.
-
-## How It Works
-
-### 1. Task Analysis
-The system analyzes your task description to determine:
-- Complexity level (simple/medium/complex)
-- Required agent types
-- Estimated duration
-- Resource requirements
-
-### 2. Topology Selection
-Based on analysis, it selects:
-- **Star**: For simple, centralized tasks
-- **Mesh**: For medium complexity with flexibility needs
-- **Hierarchical**: For complex tasks requiring structure
-- **Ring**: For sequential processing workflows
-
-### 3. Example Usage
-
-**Simple Task:**
-```
-Tool: mcp__claude-flow__task_orchestrate
-Parameters: {"task": "Fix typo in README.md"}
-Result: Automatically uses star topology with single agent
-```
-
-**Complex Task:**
-```
-Tool: mcp__claude-flow__task_orchestrate
-Parameters: {"task": "Refactor authentication system with JWT, add tests, update documentation"}
-Result: Automatically uses hierarchical topology with architect, coder, and tester agents
-```
-
-## Benefits
-- 🎯 Optimal performance for each task type
-- 🤖 Automatic agent assignment
-- ⚡ Reduced setup time
-- 📊 Better resource utilization
-
-## Hook Configuration
-The pre-task hook automatically handles topology selection:
-```json
-{
-  "command": "npx claude-flow-novice hook pre-task --optimize-topology"
-}
-```
-
-## Direct Optimization
-```
-Tool: mcp__claude-flow__topology_optimize
-Parameters: {"swarmId": "current"}
-```
-
-## CLI Usage
-```bash
-# Auto-optimize topology via CLI
-npx claude-flow-novice optimize topology
-```

package/claude-assets/commands/optimization/cache-manage.md

@@ -1,25 +0,0 @@
-# cache-manage
-
-Manage operation cache for performance.
-
-## Usage
-```bash
-npx claude-flow-novice optimization cache-manage [options]
-```
-
-## Options
-- `--action <type>` - Action (view, clear, optimize)
-- `--max-size <mb>` - Maximum cache size
-- `--ttl <seconds>` - Time to live
-
-## Examples
-```bash
-# View cache stats
-npx claude-flow-novice optimization cache-manage --action view
-
-# Clear cache
-npx claude-flow-novice optimization cache-manage --action clear
-
-# Set limits
-npx claude-flow-novice optimization cache-manage --max-size 100 --ttl 3600
-```

package/claude-assets/commands/optimization/parallel-execute.md

@@ -1,25 +0,0 @@
-# parallel-execute
-
-Execute tasks in parallel for maximum efficiency.
-
-## Usage
-```bash
-npx claude-flow-novice optimization parallel-execute [options]
-```
-
-## Options
-- `--tasks <file>` - Task list file
-- `--max-parallel <n>` - Maximum parallel tasks
-- `--strategy <type>` - Execution strategy
-
-## Examples
-```bash
-# Execute task list
-npx claude-flow-novice optimization parallel-execute --tasks tasks.json
-
-# Limit parallelism
-npx claude-flow-novice optimization parallel-execute --tasks tasks.json --max-parallel 5
-
-# Custom strategy
-npx claude-flow-novice optimization parallel-execute --strategy adaptive
-```