claude-flow-novice 1.1.8 → 1.1.9

package/src/slash-commands/index.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+/**
+ * Slash Commands Index
+ * 
+ * Exports all slash commands and utilities
+ */
+
+// Base command class
+export { SlashCommand } from '../core/slash-command.js';
+
+// Individual command classes
+export { SparcCommand } from './sparc.js';
+export { SwarmCommand } from './swarm.js';
+export { HooksCommand } from './hooks.js';
+export { NeuralCommand } from './neural.js';
+export { PerformanceCommand } from './performance.js';
+export { GitHubCommand } from './github.js';
+export { WorkflowCommand } from './workflow.js';
+export { ClaudeMdSlashCommand } from './claude-md.js';
+
+// Command executors
+export { executeClaudeSoulCommand } from './claude-soul.js';
+export { executeClaudeMdCommand } from './claude-md.js';
+
+// Registry and utilities
+export {
+  SlashCommandRegistry,
+  globalRegistry,
+  executeSlashCommand,
+  getAllCommands,
+  getCommandHelp,
+  registerCommand
+} from './register-all-commands.js';
+
+// Registration functions
+export { registerClaudeSoulCommand } from './register-claude-soul.js';
+export { default as registerClaudeMd } from './register-claude-md.js';
+
+/**
+ * Quick access to commonly used commands
+ */
+export const Commands = {
+  SPARC: 'sparc',
+  SWARM: 'swarm',
+  HOOKS: 'hooks',
+  NEURAL: 'neural',
+  PERFORMANCE: 'performance',
+  GITHUB: 'github',
+  WORKFLOW: 'workflow',
+  CLAUDE_MD: 'claude-md',
+  CLAUDE_SOUL: 'claude-soul'
+};
+
+/**
+ * Command aliases for quick access
+ */
+export const Aliases = {
+  s: 'swarm',
+  h: 'hooks',
+  n: 'neural',
+  p: 'performance',
+  perf: 'performance',
+  gh: 'github',
+  git: 'github',
+  w: 'workflow',
+  wf: 'workflow'
+};
+
+/**
+ * Initialize all slash commands
+ * @returns {SlashCommandRegistry} - Initialized registry
+ */
+export function initializeSlashCommands() {
+  console.log('🚀 Initializing Claude-Flow slash commands...');
+  
+  // Registry is automatically initialized when imported
+  const commandCount = globalRegistry.listCommands().length;
+  
+  console.log(`✅ Initialized ${commandCount} slash commands`);
+  console.log('Available commands:', Object.values(Commands).join(', '));
+  
+  return globalRegistry;
+}
+
+/**
+ * Get quick help text
+ */
+export function getQuickHelp() {
+  return `
+🚀 **CLAUDE-FLOW SLASH COMMANDS**
+
+**Essential Commands:**
+- \`/swarm init mesh 8\` - Initialize agent swarm
+- \`/hooks enable\` - Enable automation hooks
+- \`/sparc spec "task"\` - Run SPARC methodology
+- \`/neural train coordination\` - Train neural patterns
+- \`/performance report\` - Generate performance report
+- \`/github analyze repo\` - Analyze GitHub repository
+- \`/workflow create "name"\` - Create automated workflow
+
+**For full help:** Use \`/help\` or see individual command documentation
+`;
+}
+
+export default {
+  Commands,
+  Aliases,
+  globalRegistry,
+  executeSlashCommand,
+  getAllCommands,
+  getCommandHelp,
+  initializeSlashCommands,
+  getQuickHelp
+};

package/src/slash-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;