claude-flow-novice 1.3.6 → 1.5.0

package/.claude-flow-novice/dist/mcp/mcp-server-novice.js

@@ -1,595 +0,0 @@
-#!/usr/bin/env node
-/**
- * Claude-Flow Novice MCP Server - SIMPLIFIED STANDALONE VERSION
- * Only 36 essential tools for beginners
- * No external dependencies, completely self-contained
- */
-
-class ClaudeFlowNoviceMCPServer {
-  constructor() {
-    this.version = '2.0.0-novice-simplified';
-    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() {
-    return {
-      // === 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'],
-        },
-      },
-    };
-  }
-
-  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',
-      },
-    };
-  }
-
-  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`);
-    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}`);
-
-    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),
-        },
-      ],
-    };
-  }
-
-  handleResourcesList() {
-    return {
-      resources: Object.values(this.resources),
-    };
-  }
-
-  async handleResourcesRead(params) {
-    const { uri } = params;
-
-    if (!this.resources[uri]) {
-      throw new Error(`Unknown resource: ${uri}`);
-    }
-
-    const mockData = {
-      uri,
-      timestamp: new Date().toISOString(),
-      sessionId: this.sessionId,
-      data: `Mock data for ${uri}`,
-    };
-
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: 'application/json',
-          text: JSON.stringify(mockData, null, 2),
-        },
-      ],
-    };
-  }
-}
-
-// MCP Server Protocol Handler
-async function main() {
-  const server = new ClaudeFlowNoviceMCPServer();
-
-  const toolCount = Object.keys(server.tools).length;
-  console.error(`[${new Date().toISOString()}] INFO [claude-flow-novice-mcp] Claude-Flow Novice MCP server starting in stdio mode`);
-  console.error(`[${new Date().toISOString()}] INFO [claude-flow-novice-mcp] Server starting with ${toolCount} essential tools`);
-
-  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);
-  });
-
-  // Handle process termination
-  process.on('SIGINT', () => {
-    console.error(`[${new Date().toISOString()}] INFO [claude-flow-novice-mcp] Received SIGINT, shutting down gracefully...`);
-    process.exit(0);
-  });
-
-  process.on('SIGTERM', () => {
-    console.error(`[${new Date().toISOString()}] INFO [claude-flow-novice-mcp] Received SIGTERM, shutting down gracefully...`);
-    process.exit(0);
-  });
-}
-
-// ES module entry point detection
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Check if this file is being run directly
-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 };