claude-flow-novice 1.3.6 → 1.5.1

package/.claude-flow-novice/dist/mcp/mcp-server-with-slash-commands.js

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