claude-flow-novice 2.10.5 → 2.10.6

package/claude-assets/commands/neural.js

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

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

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

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

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