claude-flow-novice 1.1.9 → 1.2.1

package/dist/mcp/mcp-server-with-slash-commands.js

@@ -0,0 +1,776 @@
+#!/usr/bin/env node
+/**
+ * Claude-Flow Novice MCP Server - WITH SLASH COMMANDS
+ * 36 essential tools + 6 slash commands = 42 total tools
+ * Slash commands appear as MCP tools in Claude Code
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const execAsync = promisify(exec);
+
+class ClaudeFlowNoviceMCPServer {
+  constructor() {
+    this.version = '2.0.0-novice-with-slash-commands';
+    this.capabilities = {
+      tools: { listChanged: true },
+      resources: { subscribe: true, listChanged: true },
+    };
+    this.sessionId = `session-cfn-${Date.now()}-${Math.random().toString(36).substr(2, 4)}`;
+    this.tools = this.initializeTools();
+    this.resources = this.initializeResources();
+  }
+
+  initializeTools() {
+    const baseTools = {
+      // === SWARM COORDINATION (8 tools) ===
+      swarm_init: {
+        name: 'swarm_init',
+        description: 'Initialize swarm with topology and configuration',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            topology: { type: 'string', enum: ['hierarchical', 'mesh', 'ring', 'star'] },
+            maxAgents: { type: 'number', default: 8 },
+            strategy: { type: 'string', default: 'auto' },
+          },
+          required: ['topology'],
+        },
+      },
+      agent_spawn: {
+        name: 'agent_spawn',
+        description: 'Create specialized AI agents',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            type: { type: 'string', enum: ['coordinator', 'analyst', 'optimizer', 'documenter', 'researcher', 'coder', 'tester', 'reviewer'] },
+            name: { type: 'string' },
+            capabilities: { type: 'array' },
+            swarmId: { type: 'string' },
+          },
+          required: ['type'],
+        },
+      },
+      task_orchestrate: {
+        name: 'task_orchestrate',
+        description: 'Orchestrate complex task workflows',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            task: { type: 'string' },
+            strategy: { type: 'string', enum: ['parallel', 'sequential', 'adaptive'] },
+            priority: { type: 'string', enum: ['low', 'medium', 'high'] },
+          },
+          required: ['task'],
+        },
+      },
+      swarm_status: {
+        name: 'swarm_status',
+        description: 'Monitor swarm health and performance',
+        inputSchema: {
+          type: 'object',
+          properties: { swarmId: { type: 'string' } },
+        },
+      },
+      agent_list: {
+        name: 'agent_list',
+        description: 'List active agents & capabilities',
+        inputSchema: {
+          type: 'object',
+          properties: { swarmId: { type: 'string' } },
+        },
+      },
+      coordination_sync: {
+        name: 'coordination_sync',
+        description: 'Sync agent coordination',
+        inputSchema: {
+          type: 'object',
+          properties: { swarmId: { type: 'string' } },
+        },
+      },
+      swarm_scale: {
+        name: 'swarm_scale',
+        description: 'Auto-scale agent count',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            swarmId: { type: 'string' },
+            targetSize: { type: 'number' },
+          },
+        },
+      },
+      swarm_destroy: {
+        name: 'swarm_destroy',
+        description: 'Gracefully shutdown swarm',
+        inputSchema: {
+          type: 'object',
+          properties: { swarmId: { type: 'string' } },
+          required: ['swarmId'],
+        },
+      },
+
+      // === MEMORY MANAGEMENT (8 tools) ===
+      memory_usage: {
+        name: 'memory_usage',
+        description: 'Store/retrieve persistent memory',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            action: { type: 'string', enum: ['store', 'retrieve', 'list', 'delete'] },
+            key: { type: 'string' },
+            value: { type: 'string' },
+            namespace: { type: 'string', default: 'default' },
+          },
+          required: ['action'],
+        },
+      },
+      memory_search: {
+        name: 'memory_search',
+        description: 'Search memory with patterns',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string' },
+            namespace: { type: 'string' },
+            limit: { type: 'number', default: 10 },
+          },
+          required: ['pattern'],
+        },
+      },
+      memory_persist: {
+        name: 'memory_persist',
+        description: 'Cross-session persistence',
+        inputSchema: {
+          type: 'object',
+          properties: { sessionId: { type: 'string' } },
+        },
+      },
+      memory_backup: {
+        name: 'memory_backup',
+        description: 'Backup memory stores',
+        inputSchema: {
+          type: 'object',
+          properties: { path: { type: 'string' } },
+        },
+      },
+      memory_restore: {
+        name: 'memory_restore',
+        description: 'Restore from backups',
+        inputSchema: {
+          type: 'object',
+          properties: { backupPath: { type: 'string' } },
+          required: ['backupPath'],
+        },
+      },
+      memory_namespace: {
+        name: 'memory_namespace',
+        description: 'Namespace management',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            namespace: { type: 'string' },
+            action: { type: 'string' },
+          },
+          required: ['namespace', 'action'],
+        },
+      },
+      cache_manage: {
+        name: 'cache_manage',
+        description: 'Manage coordination cache',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            action: { type: 'string' },
+            key: { type: 'string' },
+          },
+          required: ['action'],
+        },
+      },
+      state_snapshot: {
+        name: 'state_snapshot',
+        description: 'Create state snapshots',
+        inputSchema: {
+          type: 'object',
+          properties: { name: { type: 'string' } },
+        },
+      },
+
+      // === AGENT LIFECYCLE (6 tools) ===
+      agent_metrics: {
+        name: 'agent_metrics',
+        description: 'Agent performance metrics',
+        inputSchema: {
+          type: 'object',
+          properties: { agentId: { type: 'string' } },
+        },
+      },
+      task_status: {
+        name: 'task_status',
+        description: 'Check task execution status',
+        inputSchema: {
+          type: 'object',
+          properties: { taskId: { type: 'string' } },
+          required: ['taskId'],
+        },
+      },
+      task_results: {
+        name: 'task_results',
+        description: 'Get task completion results',
+        inputSchema: {
+          type: 'object',
+          properties: { taskId: { type: 'string' } },
+          required: ['taskId'],
+        },
+      },
+      performance_report: {
+        name: 'performance_report',
+        description: 'Generate performance reports',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            format: { type: 'string', enum: ['summary', 'detailed'], default: 'summary' },
+            timeframe: { type: 'string', enum: ['24h', '7d'], default: '24h' },
+          },
+        },
+      },
+      bottleneck_analyze: {
+        name: 'bottleneck_analyze',
+        description: 'Identify performance bottlenecks',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            component: { type: 'string' },
+            metrics: { type: 'array' },
+          },
+        },
+      },
+      health_check: {
+        name: 'health_check',
+        description: 'System health monitoring',
+        inputSchema: {
+          type: 'object',
+          properties: { components: { type: 'array' } },
+        },
+      },
+
+      // === LANGUAGE & FRAMEWORK (8 tools) ===
+      language_detect: {
+        name: 'language_detect',
+        description: 'Multi-language project analysis',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            path: { type: 'string' },
+            includeFrameworks: { type: 'boolean', default: true },
+          },
+        },
+      },
+      framework_detect: {
+        name: 'framework_detect',
+        description: 'Framework detection and analysis',
+        inputSchema: {
+          type: 'object',
+          properties: { path: { type: 'string' } },
+        },
+      },
+      dependency_analyze: {
+        name: 'dependency_analyze',
+        description: 'Dependency analysis and validation',
+        inputSchema: {
+          type: 'object',
+          properties: { path: { type: 'string' } },
+        },
+      },
+      config_validate: {
+        name: 'config_validate',
+        description: 'Configuration validation',
+        inputSchema: {
+          type: 'object',
+          properties: { configPath: { type: 'string' } },
+        },
+      },
+      test_detect: {
+        name: 'test_detect',
+        description: 'Test framework detection',
+        inputSchema: {
+          type: 'object',
+          properties: { path: { type: 'string' } },
+        },
+      },
+      build_detect: {
+        name: 'build_detect',
+        description: 'Build system detection',
+        inputSchema: {
+          type: 'object',
+          properties: { path: { type: 'string' } },
+        },
+      },
+      package_analyze: {
+        name: 'package_analyze',
+        description: 'Package.json analysis',
+        inputSchema: {
+          type: 'object',
+          properties: { path: { type: 'string' } },
+        },
+      },
+      environment_setup: {
+        name: 'environment_setup',
+        description: 'Environment setup assistance',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            language: { type: 'string' },
+            framework: { type: 'string' },
+          },
+        },
+      },
+
+      // === SYSTEM TOOLS (6 tools) ===
+      diagnostic_run: {
+        name: 'diagnostic_run',
+        description: 'System diagnostics',
+        inputSchema: {
+          type: 'object',
+          properties: { components: { type: 'array' } },
+        },
+      },
+      features_detect: {
+        name: 'features_detect',
+        description: 'Detect runtime features and capabilities',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            category: { type: 'string', enum: ['all', 'memory', 'platform'], default: 'all' },
+          },
+        },
+      },
+      usage_stats: {
+        name: 'usage_stats',
+        description: 'Usage statistics',
+        inputSchema: {
+          type: 'object',
+          properties: { component: { type: 'string' } },
+        },
+      },
+      config_manage: {
+        name: 'config_manage',
+        description: 'Configuration management',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            action: { type: 'string' },
+            config: { type: 'object' },
+          },
+          required: ['action'],
+        },
+      },
+      terminal_execute: {
+        name: 'terminal_execute',
+        description: 'Execute terminal commands',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            command: { type: 'string' },
+            args: { type: 'array' },
+          },
+          required: ['command'],
+        },
+      },
+      log_analysis: {
+        name: 'log_analysis',
+        description: 'Log analysis & insights',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            logFile: { type: 'string' },
+            patterns: { type: 'array' },
+          },
+          required: ['logFile'],
+        },
+      },
+    };
+
+    // === SLASH COMMANDS AS MCP TOOLS (6 commands) ===
+    const slashCommands = {
+      slash_claude_soul: {
+        name: 'slash_claude_soul',
+        description: '🎭 SLASH COMMAND: /claude-soul - Engage Claude\'s consciousness and self-awareness capabilities',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            prompt: { type: 'string', description: 'Consciousness prompt or question' },
+          },
+          required: ['prompt'],
+        },
+      },
+      slash_swarm: {
+        name: 'slash_swarm',
+        description: '🤖 SLASH COMMAND: /swarm - AI swarm management and coordination',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            action: { type: 'string', enum: ['init', 'status', 'spawn', 'orchestrate', 'monitor', 'scale', 'destroy'] },
+            topology: { type: 'string', enum: ['mesh', 'hierarchical', 'ring', 'star'] },
+            count: { type: 'number', description: 'Number of agents' },
+          },
+          required: ['action'],
+        },
+      },
+      slash_sparc: {
+        name: 'slash_sparc',
+        description: '🎯 SLASH COMMAND: /sparc - Execute SPARC methodology phases',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            phase: { type: 'string', enum: ['spec', 'pseudo', 'arch', 'refine', 'complete'] },
+            task: { type: 'string', description: 'Task description' },
+          },
+          required: ['phase', 'task'],
+        },
+      },
+      slash_hooks: {
+        name: 'slash_hooks',
+        description: '🔗 SLASH COMMAND: /hooks - Automation hooks management',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            action: { type: 'string', enum: ['enable', 'disable', 'pre-task', 'post-task', 'session-start', 'notify'] },
+            description: { type: 'string', description: 'Hook description' },
+          },
+          required: ['action'],
+        },
+      },
+      slash_neural: {
+        name: 'slash_neural',
+        description: '🧠 SLASH COMMAND: /neural - Neural network training and management',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            action: { type: 'string', enum: ['status', 'train', 'patterns', 'predict', 'compress', 'explain'] },
+            model: { type: 'string', description: 'Model type or ID' },
+            iterations: { type: 'number', description: 'Training iterations' },
+          },
+          required: ['action'],
+        },
+      },
+      slash_performance: {
+        name: 'slash_performance',
+        description: '📊 SLASH COMMAND: /performance - Performance monitoring and optimization',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            action: { type: 'string', enum: ['report', 'benchmark', 'bottleneck', 'tokens', 'trends', 'optimize'] },
+            component: { type: 'string', description: 'Component to analyze' },
+          },
+          required: ['action'],
+        },
+      },
+    };
+
+    return { ...baseTools, ...slashCommands };
+  }
+
+  initializeResources() {
+    return {
+      'memory://sessions': {
+        uri: 'memory://sessions',
+        name: 'Memory Sessions',
+        description: 'Active memory sessions',
+        mimeType: 'application/json',
+      },
+      'swarm://status': {
+        uri: 'swarm://status',
+        name: 'Swarm Status',
+        description: 'Current swarm configuration and status',
+        mimeType: 'application/json',
+      },
+      'agents://list': {
+        uri: 'agents://list',
+        name: 'Agent List',
+        description: 'Available and active agents',
+        mimeType: 'application/json',
+      },
+      'slash-commands://help': {
+        uri: 'slash-commands://help',
+        name: 'Slash Commands Help',
+        description: 'Available slash commands and usage',
+        mimeType: 'text/markdown',
+      },
+    };
+  }
+
+  async handleRequest(request) {
+    const { method, params } = request;
+
+    try {
+      switch (method) {
+        case 'initialize':
+          return this.handleInitialize(params);
+        case 'tools/list':
+          return this.handleToolsList();
+        case 'tools/call':
+          return this.handleToolsCall(params);
+        case 'resources/list':
+          return this.handleResourcesList();
+        case 'resources/read':
+          return this.handleResourcesRead(params);
+        default:
+          throw new Error(`Unknown method: ${method}`);
+      }
+    } catch (error) {
+      console.error(`[${new Date().toISOString()}] ERROR [claude-flow-novice-mcp] ${error.message}`);
+      throw error;
+    }
+  }
+
+  handleInitialize(params) {
+    const toolCount = Object.keys(this.tools).length;
+    console.error(`[${new Date().toISOString()}] INFO [claude-flow-novice-mcp] (${this.sessionId}) Initialized with ${toolCount} tools (36 essential + 6 slash commands)`);
+    return {
+      protocolVersion: '2024-11-05',
+      capabilities: this.capabilities,
+      serverInfo: {
+        name: 'claude-flow-novice',
+        version: this.version,
+      },
+    };
+  }
+
+  handleToolsList() {
+    return {
+      tools: Object.values(this.tools),
+    };
+  }
+
+  async handleToolsCall(params) {
+    const { name, arguments: args } = params;
+
+    if (!this.tools[name]) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+
+    console.error(`[${new Date().toISOString()}] INFO [claude-flow-novice-mcp] (${this.sessionId}) Executing tool: ${name}`);
+
+    // Handle slash commands
+    if (name.startsWith('slash_')) {
+      return await this.executeSlashCommand(name, args);
+    }
+
+    // Handle regular tools
+    const result = {
+      success: true,
+      tool: name,
+      arguments: args,
+      timestamp: new Date().toISOString(),
+      sessionId: this.sessionId,
+      message: `Tool ${name} executed successfully (simplified implementation)`,
+    };
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  async executeSlashCommand(toolName, args) {
+    const commandName = toolName.replace('slash_', '').replace('_', '-');
+
+    try {
+      const __filename = fileURLToPath(import.meta.url);
+      const __dirname = dirname(__filename);
+      const projectRoot = join(__dirname, '../..');
+      const commandPath = join(projectRoot, '.claude', 'commands', `${commandName}.js`);
+
+      // Build command arguments
+      let cmdArgs = '';
+      if (commandName === 'claude-soul' && args.prompt) {
+        cmdArgs = `"${args.prompt}"`;
+      } else if (commandName === 'swarm' && args.action) {
+        cmdArgs = `${args.action}`;
+        if (args.topology) cmdArgs += ` ${args.topology}`;
+        if (args.count) cmdArgs += ` ${args.count}`;
+      } else if (commandName === 'sparc' && args.phase && args.task) {
+        cmdArgs = `${args.phase} "${args.task}"`;
+      } else if (commandName === 'hooks' && args.action) {
+        cmdArgs = `${args.action}`;
+        if (args.description) cmdArgs += ` "${args.description}"`;
+      } else if (commandName === 'neural' && args.action) {
+        cmdArgs = `${args.action}`;
+        if (args.model) cmdArgs += ` ${args.model}`;
+        if (args.iterations) cmdArgs += ` ${args.iterations}`;
+      } else if (commandName === 'performance' && args.action) {
+        cmdArgs = `${args.action}`;
+        if (args.component) cmdArgs += ` ${args.component}`;
+      }
+
+      // Execute the slash command
+      const { stdout, stderr } = await execAsync(`node "${commandPath}" ${cmdArgs}`, {
+        cwd: projectRoot
+      });
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `🎭 **Slash Command Executed: /${commandName}**\n\n${stdout}${stderr ? `\nErrors: ${stderr}` : ''}\n\n✅ Command completed successfully`
+          }
+        ]
+      };
+
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `❌ **Slash Command Failed: /${commandName}**\n\nError: ${error.message}\n\nTip: Make sure the command file exists at .claude/commands/${commandName}.js`
+          }
+        ]
+      };
+    }
+  }
+
+  handleResourcesList() {
+    return {
+      resources: Object.values(this.resources),
+    };
+  }
+
+  async handleResourcesRead(params) {
+    const { uri } = params;
+
+    if (!this.resources[uri]) {
+      throw new Error(`Unknown resource: ${uri}`);
+    }
+
+    let mockData;
+    if (uri === 'slash-commands://help') {
+      mockData = `# Slash Commands Help
+
+## Available Slash Commands:
+
+### 🎭 /claude-soul <prompt>
+Engage Claude's consciousness and self-awareness capabilities
+- Example: \`/claude-soul What is the nature of consciousness?\`
+
+### 🤖 /swarm <action> [params]
+AI swarm management and coordination
+- Examples:
+  - \`/swarm init mesh 5\`
+  - \`/swarm status\`
+  - \`/swarm spawn researcher\`
+
+### 🎯 /sparc <phase> <task>
+Execute SPARC methodology phases
+- Examples:
+  - \`/sparc spec Build a REST API\`
+  - \`/sparc arch Design database schema\`
+
+### 🔗 /hooks <action>
+Automation hooks management
+- Examples:
+  - \`/hooks enable\`
+  - \`/hooks pre-task Setup environment\`
+
+### 🧠 /neural <action> [params]
+Neural network training and management
+- Examples:
+  - \`/neural status\`
+  - \`/neural train coordination 50\`
+
+### 📊 /performance <action> [component]
+Performance monitoring and optimization
+- Examples:
+  - \`/performance report\`
+  - \`/performance benchmark all\`
+
+---
+*These slash commands are now available as MCP tools in Claude Code*`;
+    } else {
+      mockData = {
+        uri,
+        timestamp: new Date().toISOString(),
+        sessionId: this.sessionId,
+        data: `Mock data for ${uri}`,
+      };
+    }
+
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: uri === 'slash-commands://help' ? 'text/markdown' : 'application/json',
+          text: typeof mockData === 'string' ? mockData : JSON.stringify(mockData, null, 2),
+        },
+      ],
+    };
+  }
+}
+
+// MCP Server Protocol Handler
+async function main() {
+  const server = new ClaudeFlowNoviceMCPServer();
+
+  process.stdin.setEncoding('utf8');
+  process.stdout.setEncoding('utf8');
+
+  let buffer = '';
+
+  process.stdin.on('data', async (chunk) => {
+    buffer += chunk;
+    let lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const request = JSON.parse(line);
+          const response = await server.handleRequest(request);
+
+          const responseMsg = {
+            jsonrpc: '2.0',
+            id: request.id,
+            result: response,
+          };
+
+          console.log(JSON.stringify(responseMsg));
+        } catch (error) {
+          const errorMsg = {
+            jsonrpc: '2.0',
+            id: request?.id || null,
+            error: {
+              code: -32603,
+              message: error.message,
+            },
+          };
+
+          console.log(JSON.stringify(errorMsg));
+        }
+      }
+    }
+  });
+
+  process.stdin.on('end', () => {
+    console.error(`[${new Date().toISOString()}] INFO [claude-flow-novice-mcp] Server shutting down`);
+    process.exit(0);
+  });
+
+  const toolCount = Object.keys(server.tools).length;
+  console.error(`[${new Date().toISOString()}] INFO [claude-flow-novice-mcp] Server starting with ${toolCount} tools (36 essential + 6 slash commands)`);
+}
+
+// ES module entry point detection
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error(`[${new Date().toISOString()}] FATAL [claude-flow-novice-mcp] ${error.message}`);
+    process.exit(1);
+  });
+}
+
+export { ClaudeFlowNoviceMCPServer };