claude-flow-novice 2.15.0 → 2.15.1

package/claude-assets/skills/cfn-docker-skill-mcp-selection/skill-mcp-selector.js

@@ -1,472 +1,472 @@
-/**
- * Skill-based MCP Selection System
- * Automatically selects MCP servers based on agent skills and requirements
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const AgentTokenManager = require('../cli/agent-token-manager.js');
-
-class SkillMCPSelector {
-  constructor(options = {}) {
-    this.tokenManager = new AgentTokenManager(options);
-    this.agentConfigPath = options.agentConfigPath || './config/agent-whitelist.json';
-    this.skillConfigPath = options.skillConfigPath || './config/skill-requirements.json';
-    this.mcpServersPath = options.mcpServersPath || './config/mcp-servers.json';
-
-    this.agentWhitelist = new Map();
-    this.skillRequirements = new Map();
-    this.mcpServers = new Map();
-  }
-
-  async initialize() {
-    await this.tokenManager.initialize();
-    await this.loadConfigurations();
-    console.log('[SkillMCPSelector] Initialized successfully');
-  }
-
-  async loadConfigurations() {
-    // Load agent whitelist
-    const agentConfig = await this.loadJson(this.agentConfigPath);
-    this.agentWhitelist.clear();
-    for (const agent of agentConfig.agents) {
-      this.agentWhitelist.set(agent.type, agent);
-    }
-
-    // Load skill requirements
-    const skillConfig = await this.loadJson(this.skillConfigPath);
-    this.skillRequirements.clear();
-    for (const [tool, requirements] of Object.entries(skillConfig.tools)) {
-      this.skillRequirements.set(tool, requirements);
-    }
-
-    // Load MCP server configurations
-    try {
-      const mcpConfig = await this.loadJson(this.mcpServersPath);
-      for (const [name, config] of Object.entries(mcpConfig.servers)) {
-        this.mcpServers.set(name, config);
-      }
-    } catch (error) {
-      console.warn('[SkillMCPSelector] MCP servers config not found, using defaults');
-      this.initializeDefaultMCPServers();
-    }
-  }
-
-  async loadJson(filePath) {
-    const resolvedPath = path.resolve(filePath);
-    const content = await fs.readFile(resolvedPath, 'utf8');
-    return JSON.parse(content);
-  }
-
-  initializeDefaultMCPServers() {
-    // Default MCP server configurations
-    const defaultServers = {
-      'playwright': {
-        name: 'playwright',
-        displayName: 'Playwright Browser Automation',
-        description: 'Browser automation and screenshot capabilities',
-        containerImage: 'claude-flow-novice:mcp-playwright',
-        tools: ['take_screenshot', 'search_google', 'navigate_and_interact'],
-        skills: ['browser-automation', 'screenshot-capture', 'web-interaction'],
-        resourceRequirements: {
-          memoryMB: 1024,
-          cpuUnits: 2
-        }
-      },
-      'redis': {
-        name: 'redis',
-        displayName: 'Redis Database',
-        description: 'Redis key-value store operations',
-        containerImage: 'claude-flow-novice:mcp-redis',
-        tools: ['redis_get', 'redis_set', 'redis_keys'],
-        skills: ['redis-operations', 'cache-management'],
-        resourceRequirements: {
-          memoryMB: 256,
-          cpuUnits: 1
-        }
-      },
-      'postgres': {
-        name: 'postgres',
-        displayName: 'PostgreSQL Database',
-        description: 'PostgreSQL database operations',
-        containerImage: 'claude-flow-novice:mcp-postgres',
-        tools: ['postgres_query', 'postgres_schema', 'postgres_migrate'],
-        skills: ['database-design', 'sql-operations'],
-        resourceRequirements: {
-          memoryMB: 512,
-          cpuUnits: 2
-        }
-      },
-      'security-scanner': {
-        name: 'security-scanner',
-        displayName: 'Security Scanner',
-        description: 'Security vulnerability scanning and analysis',
-        containerImage: 'claude-flow-novice:mcp-security',
-        tools: ['security_scan', 'vulnerability_check', 'compliance_validate'],
-        skills: ['security-auditing', 'vulnerability-scanning'],
-        resourceRequirements: {
-          memoryMB: 1536,
-          cpuUnits: 4
-        }
-      }
-    };
-
-    for (const [name, config] of Object.entries(defaultServers)) {
-      this.mcpServers.set(name, config);
-    }
-  }
-
-  /**
-   * Determine which MCP servers an agent needs based on their skills
-   */
-  selectMCPServers(agentType, agentSkills = null) {
-    const agentConfig = this.agentWhitelist.get(agentType);
-    if (!agentConfig) {
-      throw new Error(`Unknown agent type: ${agentType}`);
-    }
-
-    // Use provided skills or fall back to agent config
-    const skills = agentSkills || agentConfig.skills;
-
-    // Determine required MCP servers based on skills
-    const requiredMCPServers = new Set();
-    const skillToMCPServerMap = this.getSkillToMCPServerMapping();
-
-    // Map skills to required MCP servers
-    for (const skill of skills) {
-      if (skillToMCPServerMap.has(skill)) {
-        const servers = skillToMCPServerMap.get(skill);
-        servers.forEach(server => requiredMCPServers.add(server));
-      }
-    }
-
-    // Add explicitly allowed MCP servers from agent config
-    if (agentConfig.allowedMcpServers) {
-      agentConfig.allowedMcpServers.forEach(server => requiredMCPServers.add(server));
-    }
-
-    // Convert to array and sort by priority
-    const selectedServers = Array.from(requiredMCPServers)
-      .filter(server => this.mcpServers.has(server))
-      .sort((a, b) => {
-        const priorityA = this.mcpServers.get(a).priority || 999;
-        const priorityB = this.mcpServers.get(b).priority || 999;
-        return priorityA - priorityB;
-      });
-
-    return {
-      agentType,
-      agentSkills: skills,
-      selectedMCPServers,
-      serverDetails: selectedServers.map(server => this.mcpServers.get(server)),
-      totalMemoryRequired: selectedServers.reduce((sum, server) =>
-        sum + (this.mcpServers.get(server).resourceRequirements?.memoryMB || 512), 0),
-      totalCPURequired: selectedServers.reduce((sum, server) =>
-        sum + (this.mcpServers.get(server).resourceRequirements?.cpuUnits || 1), 0)
-    };
-  }
-
-  /**
-   * Get mapping from skills to required MCP servers
-   */
-  getSkillToMCPServerMapping() {
-    const skillMap = new Map();
-
-    // Build mapping from MCP server configurations
-    for (const [serverName, serverConfig] of this.mcpServers.entries()) {
-      for (const skill of serverConfig.skills || []) {
-        if (!skillMap.has(skill)) {
-          skillMap.set(skill, new Set());
-        }
-        skillMap.get(skill).add(serverName);
-      }
-    }
-
-    // Also add mappings from tool requirements
-    for (const [toolName, toolConfig] of this.skillRequirements.entries()) {
-      for (const skill of toolConfig.requiredSkills || []) {
-        // Find MCP servers that provide this tool
-        for (const [serverName, serverConfig] of this.mcpServers.entries()) {
-          if (serverConfig.tools?.includes(toolName)) {
-            if (!skillMap.has(skill)) {
-              skillMap.set(skill, new Set());
-            }
-            skillMap.get(skill).add(serverName);
-          }
-        }
-      }
-    }
-
-    return skillMap;
-  }
-
-  /**
-   * Generate tokens for selected MCP servers
-   */
-  async generateMCPTokens(agentType, selectedServers, options = {}) {
-    const tokens = [];
-
-    for (const serverName of selectedServers) {
-      try {
-        const serverConfig = this.mcpServers.get(serverName);
-        if (!serverConfig) {
-          console.warn(`[SkillMCPSelector] Server configuration not found: ${serverName}`);
-          continue;
-        }
-
-        // Generate server-specific token
-        const tokenData = await this.tokenManager.registerAgentToken(agentType, {
-          expiresIn: options.expiresIn || '24h',
-          description: `Token for ${serverConfig.displayName}`,
-          createdBy: 'skill-mcp-selector',
-          mcpServer: serverName
-        });
-
-        tokens.push({
-          serverName,
-          displayName: serverConfig.displayName,
-          token: tokenData.token,
-          expiresAt: tokenData.expiresAt,
-          containerImage: serverConfig.containerImage,
-          connectionInfo: this.generateConnectionInfo(serverName, serverConfig, tokenData.token)
-        });
-
-        console.log(`[SkillMCPSelector] Generated token for ${agentType} → ${serverName}`);
-      } catch (error) {
-        console.error(`[SkillMCPSelector] Failed to generate token for ${serverName}:`, error);
-      }
-    }
-
-    return tokens;
-  }
-
-  /**
-   * Generate connection information for MCP server
-   */
-  generateConnectionInfo(serverName, serverConfig, token) {
-    const baseInfo = {
-      serverName,
-      token,
-      authentication: {
-        type: 'token-based',
-        header: 'x-agent-token',
-        agentTypeHeader: 'x-agent-type'
-      }
-    };
-
-    // Add server-specific connection details
-    if (serverConfig.connectionType === 'docker') {
-      return {
-        ...baseInfo,
-        type: 'docker-container',
-        containerName: `mcp-${serverName}`,
-        containerImage: serverConfig.containerImage,
-        dockerArgs: [
-          'run', '--rm', '--init',
-          '--name', `mcp-${serverName}`,
-          '--memory', `${serverConfig.resourceRequirements?.memoryMB || 512}m`,
-          '--cpus', `${serverConfig.resourceRequirements?.cpuUnits || 1}`,
-          '-e', `MCP_SERVER=${serverName}`,
-          '-e', `MCP_AUTH_REQUIRED=true`,
-          '-e', `MCP_REDIS_URL=${process.env.MCP_REDIS_URL || 'redis://localhost:6379'}`,
-          serverConfig.containerImage,
-          'node', `/app/mcp-${serverName}-server.js`
-        ]
-      };
-    } else {
-      return {
-        ...baseInfo,
-        type: 'http-endpoint',
-        url: serverConfig.url || `http://localhost:${3000 + this.mcpServers.size}`,
-        headers: {
-          'Content-Type': 'application/json',
-          'x-agent-token': token,
-          'x-agent-type': 'dynamic'
-        }
-      };
-    }
-  }
-
-  /**
-   * Get complete MCP configuration for an agent
-   */
-  async getAgentMCPConfiguration(agentType, agentSkills = null, options = {}) {
-    try {
-      // Select required MCP servers
-      const selection = this.selectMCPServers(agentType, agentSkills);
-
-      // Generate tokens for selected servers
-      const tokens = await this.generateMCPTokens(
-        agentType,
-        selection.selectedMCPServers,
-        options
-      );
-
-      return {
-        agentType,
-        agentSkills: selection.agentSkills,
-        mcpConfiguration: {
-          mcpServers: tokens.reduce((config, tokenInfo) => {
-            config[tokenInfo.serverName] = {
-              command: 'docker',
-              args: tokenInfo.connectionInfo.dockerArgs,
-              env: {
-                'MCP_SERVER': tokenInfo.serverName,
-                'MCP_AUTH_REQUIRED': 'true',
-                'AGENT_TOKEN': tokenInfo.token
-              }
-            };
-            return config;
-          }, {})
-        },
-        selection,
-        tokens,
-        resourceSummary: {
-          totalMemoryMB: selection.totalMemoryRequired,
-          totalCPUUnits: selection.totalCPUUnits,
-          serverCount: selection.selectedMCPServers.length
-        }
-      };
-    } catch (error) {
-      console.error(`[SkillMCPSelector] Failed to get MCP configuration for ${agentType}:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Generate Docker Compose configuration for agent with MCP servers
-   */
-  async generateDockerComposeConfiguration(agentType, agentSkills = null, options = {}) {
-    const config = await this.getAgentMCPConfiguration(agentType, agentSkills, options);
-
-    const dockerCompose = {
-      version: '3.8',
-      services: {},
-      networks: {
-        'mcp-network': {
-          driver: 'bridge'
-        }
-      }
-    };
-
-    // Add agent service
-    dockerCompose.services[`${agentType}-agent`] = {
-      image: 'claude-flow-novice:agent-container',
-      container_name: `agent-${agentType}-${Date.now()}`,
-      networks: ['mcp-network'],
-      environment: {
-        'AGENT_TYPE': agentType,
-        'AGENT_MODE': 'containerized',
-        'MCP_AUTH_ENABLED': 'true',
-        'REDIS_URL': process.env.MCP_REDIS_URL || 'redis://redis:6379'
-      },
-      volumes: [
-        '${PWD}/.claude:/app/.claude:ro',
-        '${PWD}/screenshots:/app/screenshots'
-      ],
-      mem_limit: `${config.resourceSummary.totalMemoryMB + 512}m`,
-      depends_on: config.selection.selectedMCPServers.map(server => `mcp-${server}`).join(' ')
-    };
-
-    // Add MCP server services
-    for (const tokenInfo of config.tokens) {
-      const serverName = `mcp-${tokenInfo.serverName}`;
-      const serverConfig = this.mcpServers.get(tokenInfo.serverName);
-
-      dockerCompose.services[serverName] = {
-        image: tokenInfo.containerImage,
-        container_name: `${serverName}-${Date.now()}`,
-        networks: ['mcp-network'],
-        environment: {
-          'MCP_SERVER': tokenInfo.serverName,
-          'MCP_AUTH_REQUIRED': 'true',
-          'MCP_REDIS_URL': process.env.MCP_REDIS_URL || 'redis://redis:6379',
-          'AGENT_TOKEN': tokenInfo.token
-        },
-        volumes: [
-          '${PWD}/screenshots:/app/screenshots'
-        ],
-        mem_limit: `${serverConfig.resourceRequirements?.memoryMB || 512}m`,
-        cpus: `${(serverConfig.resourceRequirements?.cpuUnits || 1) / 4}`
-      };
-    }
-
-    // Add Redis service if not present
-    if (!dockerCompose.services.redis) {
-      dockerCompose.services.redis = {
-        image: 'redis:7-alpine',
-        container_name: 'mcp-redis',
-        networks: ['mcp-network'],
-        volumes: ['redis-data:/data'],
-        mem_limit: '256m'
-      };
-      dockerCompose.volumes = {
-        'redis-data': {}
-      };
-    }
-
-    return dockerCompose;
-  }
-
-  /**
-   * Get statistics about skill-MCP mappings
-   */
-  getStatistics() {
-    const skillMap = this.getSkillToMCPServerMapping();
-
-    return {
-      totalAgents: this.agentWhitelist.size,
-      totalMCPServers: this.mcpServers.size,
-      totalSkills: skillMap.size,
-      agentTypes: Array.from(this.agentWhitelist.keys()),
-      mcpServerNames: Array.from(this.mcpServers.keys()),
-      skillCoverage: Array.from(skillMap.entries()).map(([skill, servers]) => ({
-        skill,
-        requiredServers: Array.from(servers),
-        serverCount: servers.size
-      }))
-    };
-  }
-
-  /**
-   * Validate agent-MCP configuration
-   */
-  validateConfiguration(agentType, mcpConfiguration) {
-    const agentConfig = this.agentWhitelist.get(agentType);
-    if (!agentConfig) {
-      return { valid: false, errors: [`Unknown agent type: ${agentType}`] };
-    }
-
-    const errors = [];
-    const warnings = [];
-
-    // Check required MCP servers
-    const requiredServers = agentConfig.allowedMcpServers || [];
-    const configuredServers = Object.keys(mcpConfiguration.mcpServers || {});
-
-    for (const server of requiredServers) {
-      if (!configuredServers.includes(server)) {
-        errors.push(`Required MCP server missing: ${server}`);
-      }
-    }
-
-    // Check for unauthorized servers
-    for (const server of configuredServers) {
-      if (!requiredServers.includes(server)) {
-        warnings.push(`Potentially unauthorized MCP server: ${server}`);
-      }
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings
-    };
-  }
-
-  async shutdown() {
-    await this.tokenManager.shutdown();
-  }
-}
-
+/**
+ * Skill-based MCP Selection System
+ * Automatically selects MCP servers based on agent skills and requirements
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const AgentTokenManager = require('../cli/agent-token-manager.js');
+
+class SkillMCPSelector {
+  constructor(options = {}) {
+    this.tokenManager = new AgentTokenManager(options);
+    this.agentConfigPath = options.agentConfigPath || './config/agent-whitelist.json';
+    this.skillConfigPath = options.skillConfigPath || './config/skill-requirements.json';
+    this.mcpServersPath = options.mcpServersPath || './config/mcp-servers.json';
+
+    this.agentWhitelist = new Map();
+    this.skillRequirements = new Map();
+    this.mcpServers = new Map();
+  }
+
+  async initialize() {
+    await this.tokenManager.initialize();
+    await this.loadConfigurations();
+    console.log('[SkillMCPSelector] Initialized successfully');
+  }
+
+  async loadConfigurations() {
+    // Load agent whitelist
+    const agentConfig = await this.loadJson(this.agentConfigPath);
+    this.agentWhitelist.clear();
+    for (const agent of agentConfig.agents) {
+      this.agentWhitelist.set(agent.type, agent);
+    }
+
+    // Load skill requirements
+    const skillConfig = await this.loadJson(this.skillConfigPath);
+    this.skillRequirements.clear();
+    for (const [tool, requirements] of Object.entries(skillConfig.tools)) {
+      this.skillRequirements.set(tool, requirements);
+    }
+
+    // Load MCP server configurations
+    try {
+      const mcpConfig = await this.loadJson(this.mcpServersPath);
+      for (const [name, config] of Object.entries(mcpConfig.servers)) {
+        this.mcpServers.set(name, config);
+      }
+    } catch (error) {
+      console.warn('[SkillMCPSelector] MCP servers config not found, using defaults');
+      this.initializeDefaultMCPServers();
+    }
+  }
+
+  async loadJson(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    const content = await fs.readFile(resolvedPath, 'utf8');
+    return JSON.parse(content);
+  }
+
+  initializeDefaultMCPServers() {
+    // Default MCP server configurations
+    const defaultServers = {
+      'playwright': {
+        name: 'playwright',
+        displayName: 'Playwright Browser Automation',
+        description: 'Browser automation and screenshot capabilities',
+        containerImage: 'claude-flow-novice:mcp-playwright',
+        tools: ['take_screenshot', 'search_google', 'navigate_and_interact'],
+        skills: ['browser-automation', 'screenshot-capture', 'web-interaction'],
+        resourceRequirements: {
+          memoryMB: 1024,
+          cpuUnits: 2
+        }
+      },
+      'redis': {
+        name: 'redis',
+        displayName: 'Redis Database',
+        description: 'Redis key-value store operations',
+        containerImage: 'claude-flow-novice:mcp-redis',
+        tools: ['redis_get', 'redis_set', 'redis_keys'],
+        skills: ['redis-operations', 'cache-management'],
+        resourceRequirements: {
+          memoryMB: 256,
+          cpuUnits: 1
+        }
+      },
+      'postgres': {
+        name: 'postgres',
+        displayName: 'PostgreSQL Database',
+        description: 'PostgreSQL database operations',
+        containerImage: 'claude-flow-novice:mcp-postgres',
+        tools: ['postgres_query', 'postgres_schema', 'postgres_migrate'],
+        skills: ['database-design', 'sql-operations'],
+        resourceRequirements: {
+          memoryMB: 512,
+          cpuUnits: 2
+        }
+      },
+      'security-scanner': {
+        name: 'security-scanner',
+        displayName: 'Security Scanner',
+        description: 'Security vulnerability scanning and analysis',
+        containerImage: 'claude-flow-novice:mcp-security',
+        tools: ['security_scan', 'vulnerability_check', 'compliance_validate'],
+        skills: ['security-auditing', 'vulnerability-scanning'],
+        resourceRequirements: {
+          memoryMB: 1536,
+          cpuUnits: 4
+        }
+      }
+    };
+
+    for (const [name, config] of Object.entries(defaultServers)) {
+      this.mcpServers.set(name, config);
+    }
+  }
+
+  /**
+   * Determine which MCP servers an agent needs based on their skills
+   */
+  selectMCPServers(agentType, agentSkills = null) {
+    const agentConfig = this.agentWhitelist.get(agentType);
+    if (!agentConfig) {
+      throw new Error(`Unknown agent type: ${agentType}`);
+    }
+
+    // Use provided skills or fall back to agent config
+    const skills = agentSkills || agentConfig.skills;
+
+    // Determine required MCP servers based on skills
+    const requiredMCPServers = new Set();
+    const skillToMCPServerMap = this.getSkillToMCPServerMapping();
+
+    // Map skills to required MCP servers
+    for (const skill of skills) {
+      if (skillToMCPServerMap.has(skill)) {
+        const servers = skillToMCPServerMap.get(skill);
+        servers.forEach(server => requiredMCPServers.add(server));
+      }
+    }
+
+    // Add explicitly allowed MCP servers from agent config
+    if (agentConfig.allowedMcpServers) {
+      agentConfig.allowedMcpServers.forEach(server => requiredMCPServers.add(server));
+    }
+
+    // Convert to array and sort by priority
+    const selectedServers = Array.from(requiredMCPServers)
+      .filter(server => this.mcpServers.has(server))
+      .sort((a, b) => {
+        const priorityA = this.mcpServers.get(a).priority || 999;
+        const priorityB = this.mcpServers.get(b).priority || 999;
+        return priorityA - priorityB;
+      });
+
+    return {
+      agentType,
+      agentSkills: skills,
+      selectedMCPServers,
+      serverDetails: selectedServers.map(server => this.mcpServers.get(server)),
+      totalMemoryRequired: selectedServers.reduce((sum, server) =>
+        sum + (this.mcpServers.get(server).resourceRequirements?.memoryMB || 512), 0),
+      totalCPURequired: selectedServers.reduce((sum, server) =>
+        sum + (this.mcpServers.get(server).resourceRequirements?.cpuUnits || 1), 0)
+    };
+  }
+
+  /**
+   * Get mapping from skills to required MCP servers
+   */
+  getSkillToMCPServerMapping() {
+    const skillMap = new Map();
+
+    // Build mapping from MCP server configurations
+    for (const [serverName, serverConfig] of this.mcpServers.entries()) {
+      for (const skill of serverConfig.skills || []) {
+        if (!skillMap.has(skill)) {
+          skillMap.set(skill, new Set());
+        }
+        skillMap.get(skill).add(serverName);
+      }
+    }
+
+    // Also add mappings from tool requirements
+    for (const [toolName, toolConfig] of this.skillRequirements.entries()) {
+      for (const skill of toolConfig.requiredSkills || []) {
+        // Find MCP servers that provide this tool
+        for (const [serverName, serverConfig] of this.mcpServers.entries()) {
+          if (serverConfig.tools?.includes(toolName)) {
+            if (!skillMap.has(skill)) {
+              skillMap.set(skill, new Set());
+            }
+            skillMap.get(skill).add(serverName);
+          }
+        }
+      }
+    }
+
+    return skillMap;
+  }
+
+  /**
+   * Generate tokens for selected MCP servers
+   */
+  async generateMCPTokens(agentType, selectedServers, options = {}) {
+    const tokens = [];
+
+    for (const serverName of selectedServers) {
+      try {
+        const serverConfig = this.mcpServers.get(serverName);
+        if (!serverConfig) {
+          console.warn(`[SkillMCPSelector] Server configuration not found: ${serverName}`);
+          continue;
+        }
+
+        // Generate server-specific token
+        const tokenData = await this.tokenManager.registerAgentToken(agentType, {
+          expiresIn: options.expiresIn || '24h',
+          description: `Token for ${serverConfig.displayName}`,
+          createdBy: 'skill-mcp-selector',
+          mcpServer: serverName
+        });
+
+        tokens.push({
+          serverName,
+          displayName: serverConfig.displayName,
+          token: tokenData.token,
+          expiresAt: tokenData.expiresAt,
+          containerImage: serverConfig.containerImage,
+          connectionInfo: this.generateConnectionInfo(serverName, serverConfig, tokenData.token)
+        });
+
+        console.log(`[SkillMCPSelector] Generated token for ${agentType} → ${serverName}`);
+      } catch (error) {
+        console.error(`[SkillMCPSelector] Failed to generate token for ${serverName}:`, error);
+      }
+    }
+
+    return tokens;
+  }
+
+  /**
+   * Generate connection information for MCP server
+   */
+  generateConnectionInfo(serverName, serverConfig, token) {
+    const baseInfo = {
+      serverName,
+      token,
+      authentication: {
+        type: 'token-based',
+        header: 'x-agent-token',
+        agentTypeHeader: 'x-agent-type'
+      }
+    };
+
+    // Add server-specific connection details
+    if (serverConfig.connectionType === 'docker') {
+      return {
+        ...baseInfo,
+        type: 'docker-container',
+        containerName: `mcp-${serverName}`,
+        containerImage: serverConfig.containerImage,
+        dockerArgs: [
+          'run', '--rm', '--init',
+          '--name', `mcp-${serverName}`,
+          '--memory', `${serverConfig.resourceRequirements?.memoryMB || 512}m`,
+          '--cpus', `${serverConfig.resourceRequirements?.cpuUnits || 1}`,
+          '-e', `MCP_SERVER=${serverName}`,
+          '-e', `MCP_AUTH_REQUIRED=true`,
+          '-e', `MCP_REDIS_URL=${process.env.MCP_REDIS_URL || 'redis://localhost:6379'}`,
+          serverConfig.containerImage,
+          'node', `/app/mcp-${serverName}-server.js`
+        ]
+      };
+    } else {
+      return {
+        ...baseInfo,
+        type: 'http-endpoint',
+        url: serverConfig.url || `http://localhost:${3000 + this.mcpServers.size}`,
+        headers: {
+          'Content-Type': 'application/json',
+          'x-agent-token': token,
+          'x-agent-type': 'dynamic'
+        }
+      };
+    }
+  }
+
+  /**
+   * Get complete MCP configuration for an agent
+   */
+  async getAgentMCPConfiguration(agentType, agentSkills = null, options = {}) {
+    try {
+      // Select required MCP servers
+      const selection = this.selectMCPServers(agentType, agentSkills);
+
+      // Generate tokens for selected servers
+      const tokens = await this.generateMCPTokens(
+        agentType,
+        selection.selectedMCPServers,
+        options
+      );
+
+      return {
+        agentType,
+        agentSkills: selection.agentSkills,
+        mcpConfiguration: {
+          mcpServers: tokens.reduce((config, tokenInfo) => {
+            config[tokenInfo.serverName] = {
+              command: 'docker',
+              args: tokenInfo.connectionInfo.dockerArgs,
+              env: {
+                'MCP_SERVER': tokenInfo.serverName,
+                'MCP_AUTH_REQUIRED': 'true',
+                'AGENT_TOKEN': tokenInfo.token
+              }
+            };
+            return config;
+          }, {})
+        },
+        selection,
+        tokens,
+        resourceSummary: {
+          totalMemoryMB: selection.totalMemoryRequired,
+          totalCPUUnits: selection.totalCPUUnits,
+          serverCount: selection.selectedMCPServers.length
+        }
+      };
+    } catch (error) {
+      console.error(`[SkillMCPSelector] Failed to get MCP configuration for ${agentType}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Generate Docker Compose configuration for agent with MCP servers
+   */
+  async generateDockerComposeConfiguration(agentType, agentSkills = null, options = {}) {
+    const config = await this.getAgentMCPConfiguration(agentType, agentSkills, options);
+
+    const dockerCompose = {
+      version: '3.8',
+      services: {},
+      networks: {
+        'mcp-network': {
+          driver: 'bridge'
+        }
+      }
+    };
+
+    // Add agent service
+    dockerCompose.services[`${agentType}-agent`] = {
+      image: 'claude-flow-novice:agent-container',
+      container_name: `agent-${agentType}-${Date.now()}`,
+      networks: ['mcp-network'],
+      environment: {
+        'AGENT_TYPE': agentType,
+        'AGENT_MODE': 'containerized',
+        'MCP_AUTH_ENABLED': 'true',
+        'REDIS_URL': process.env.MCP_REDIS_URL || 'redis://redis:6379'
+      },
+      volumes: [
+        '${PWD}/.claude:/app/.claude:ro',
+        '${PWD}/screenshots:/app/screenshots'
+      ],
+      mem_limit: `${config.resourceSummary.totalMemoryMB + 512}m`,
+      depends_on: config.selection.selectedMCPServers.map(server => `mcp-${server}`).join(' ')
+    };
+
+    // Add MCP server services
+    for (const tokenInfo of config.tokens) {
+      const serverName = `mcp-${tokenInfo.serverName}`;
+      const serverConfig = this.mcpServers.get(tokenInfo.serverName);
+
+      dockerCompose.services[serverName] = {
+        image: tokenInfo.containerImage,
+        container_name: `${serverName}-${Date.now()}`,
+        networks: ['mcp-network'],
+        environment: {
+          'MCP_SERVER': tokenInfo.serverName,
+          'MCP_AUTH_REQUIRED': 'true',
+          'MCP_REDIS_URL': process.env.MCP_REDIS_URL || 'redis://redis:6379',
+          'AGENT_TOKEN': tokenInfo.token
+        },
+        volumes: [
+          '${PWD}/screenshots:/app/screenshots'
+        ],
+        mem_limit: `${serverConfig.resourceRequirements?.memoryMB || 512}m`,
+        cpus: `${(serverConfig.resourceRequirements?.cpuUnits || 1) / 4}`
+      };
+    }
+
+    // Add Redis service if not present
+    if (!dockerCompose.services.redis) {
+      dockerCompose.services.redis = {
+        image: 'redis:7-alpine',
+        container_name: 'mcp-redis',
+        networks: ['mcp-network'],
+        volumes: ['redis-data:/data'],
+        mem_limit: '256m'
+      };
+      dockerCompose.volumes = {
+        'redis-data': {}
+      };
+    }
+
+    return dockerCompose;
+  }
+
+  /**
+   * Get statistics about skill-MCP mappings
+   */
+  getStatistics() {
+    const skillMap = this.getSkillToMCPServerMapping();
+
+    return {
+      totalAgents: this.agentWhitelist.size,
+      totalMCPServers: this.mcpServers.size,
+      totalSkills: skillMap.size,
+      agentTypes: Array.from(this.agentWhitelist.keys()),
+      mcpServerNames: Array.from(this.mcpServers.keys()),
+      skillCoverage: Array.from(skillMap.entries()).map(([skill, servers]) => ({
+        skill,
+        requiredServers: Array.from(servers),
+        serverCount: servers.size
+      }))
+    };
+  }
+
+  /**
+   * Validate agent-MCP configuration
+   */
+  validateConfiguration(agentType, mcpConfiguration) {
+    const agentConfig = this.agentWhitelist.get(agentType);
+    if (!agentConfig) {
+      return { valid: false, errors: [`Unknown agent type: ${agentType}`] };
+    }
+
+    const errors = [];
+    const warnings = [];
+
+    // Check required MCP servers
+    const requiredServers = agentConfig.allowedMcpServers || [];
+    const configuredServers = Object.keys(mcpConfiguration.mcpServers || {});
+
+    for (const server of requiredServers) {
+      if (!configuredServers.includes(server)) {
+        errors.push(`Required MCP server missing: ${server}`);
+      }
+    }
+
+    // Check for unauthorized servers
+    for (const server of configuredServers) {
+      if (!requiredServers.includes(server)) {
+        warnings.push(`Potentially unauthorized MCP server: ${server}`);
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+
+  async shutdown() {
+    await this.tokenManager.shutdown();
+  }
+}
+
 module.exports = SkillMCPSelector;