@iservu-inc/adf-cli 0.13.0 → 0.14.1

package/lib/templates/scripts/validate-mcp.js

@@ -0,0 +1,471 @@
+#!/usr/bin/env node
+
+/**
+ * AgentDevFramework MCP Configuration Validator
+ * Validates MCP server configuration and connectivity
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const dotenv = require('dotenv');
+
+const FRAMEWORK_ROOT = path.join(__dirname, '..');
+const ENV_FILE = path.join(FRAMEWORK_ROOT, '.env');
+const MCP_CONFIG = path.join(FRAMEWORK_ROOT, 'shared', 'mcp', 'mcp-config.json');
+
+// MCP server requirements
+const MCP_SERVERS = {
+  'context7': {
+    type: 'http',
+    required: false,
+    envVars: ['CONTEXT7_API_KEY'],
+    description: 'Current framework documentation retrieval',
+    url: 'https://context7.com'
+  },
+  'brave-search': {
+    type: 'command',
+    required: true,
+    envVars: ['BRAVE_API_KEY'],
+    description: 'Web search for latest information',
+    url: 'https://brave.com/search/api/',
+    freeTier: '2,000 queries/month'
+  },
+  'mem0': {
+    type: 'command',
+    required: true,
+    envVars: ['SMITHERY_KEY', 'SMITHERY_PROFILE', 'OPENAI_API_KEY'],
+    description: 'Persistent memory across sessions',
+    url: 'https://smithery.ai'
+  },
+  'clear-thought': {
+    type: 'command',
+    required: true,
+    envVars: ['SMITHERY_KEY', 'OPENAI_API_KEY'],
+    description: 'Structured reasoning for complex problems',
+    url: 'https://smithery.ai'
+  },
+  'archon': {
+    type: 'http',
+    required: false,
+    envVars: ['ARCHON_URL', 'SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY', 'OPENAI_API_KEY'],
+    description: 'Project knowledge management and task tracking',
+    url: 'https://github.com/archon-ai/archon'
+  },
+  'openmemory': {
+    type: 'command',
+    required: false,
+    envVars: ['OPENMEMORY_API_KEY', 'CLIENT_NAME'],
+    description: 'Alternative persistent memory system',
+    url: 'https://openmemory.ai',
+    note: 'Alternative to mem0 - choose one based on preference'
+  },
+  'deepwiki': {
+    type: 'http',
+    required: true,
+    envVars: [],
+    description: 'GitHub repository documentation and analysis',
+    note: 'No API key required'
+  }
+};
+
+class MCPValidator {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+    this.passed = 0;
+    this.failed = 0;
+    this.env = {};
+    this.mcpConfig = null;
+  }
+
+  log(message, type = 'info') {
+    const symbols = {
+      success: chalk.green('✓'),
+      error: chalk.red('✗'),
+      warning: chalk.yellow('⚠'),
+      info: chalk.blue('ℹ')
+    };
+    console.log(`${symbols[type]} ${message}`);
+  }
+
+  addError(message) {
+    this.errors.push(message);
+    this.failed++;
+  }
+
+  addWarning(message) {
+    this.warnings.push(message);
+  }
+
+  loadEnvFile() {
+    try {
+      if (fs.existsSync(ENV_FILE)) {
+        const result = dotenv.config({ path: ENV_FILE });
+        this.env = result.parsed || {};
+        // Also merge process.env
+        Object.keys(process.env).forEach(key => {
+          if (!this.env[key]) {
+            this.env[key] = process.env[key];
+          }
+        });
+        this.log('Loaded environment variables', 'success');
+        this.passed++;
+        return true;
+      } else {
+        this.addError('.env file not found - run validate:env first');
+        return false;
+      }
+    } catch (error) {
+      this.addError(`Failed to load .env: ${error.message}`);
+      return false;
+    }
+  }
+
+  checkMCPConfigExists() {
+    if (fs.existsSync(MCP_CONFIG)) {
+      this.log('MCP configuration file found', 'success');
+      this.passed++;
+      return true;
+    } else {
+      this.addError('MCP configuration file not found: shared/mcp/mcp-config.json');
+      return false;
+    }
+  }
+
+  loadMCPConfig() {
+    try {
+      const configContent = fs.readFileSync(MCP_CONFIG, 'utf-8');
+      this.mcpConfig = JSON.parse(configContent);
+
+      if (!this.mcpConfig.mcpServers) {
+        this.addError('MCP config missing "mcpServers" section');
+        return false;
+      }
+
+      this.log(`Loaded MCP configuration with ${Object.keys(this.mcpConfig.mcpServers).length} servers`, 'success');
+      this.passed++;
+      return true;
+    } catch (error) {
+      this.addError(`Failed to parse MCP config: ${error.message}`);
+      return false;
+    }
+  }
+
+  replaceEnvVars(value) {
+    if (typeof value !== 'string') return value;
+
+    return value.replace(/\$\{([^}]+)\}/g, (match, envVar) => {
+      return this.env[envVar] || match;
+    });
+  }
+
+  validateServerConfig(serverName, config) {
+    const requirements = MCP_SERVERS[serverName];
+
+    if (!requirements) {
+      this.addWarning(`Unknown MCP server: ${serverName}`);
+      return;
+    }
+
+    console.log(chalk.bold(`\n  ${serverName}:`));
+    console.log(chalk.gray(`    ${requirements.description}`));
+
+    // Check type
+    if (config.type && config.type !== requirements.type) {
+      this.addWarning(`${serverName}: Expected type "${requirements.type}", found "${config.type}"`);
+    }
+
+    // Check required environment variables
+    const missingVars = [];
+    requirements.envVars.forEach(envVar => {
+      const value = this.env[envVar];
+      if (!value || value.trim() === '') {
+        missingVars.push(envVar);
+      }
+    });
+
+    if (missingVars.length > 0) {
+      if (requirements.required) {
+        this.addError(`${serverName}: Missing required environment variables: ${missingVars.join(', ')}`);
+        console.log(chalk.red(`    ✗ Missing: ${missingVars.join(', ')}`));
+        if (requirements.url) {
+          console.log(chalk.cyan(`      Setup: ${requirements.url}`));
+        }
+      } else {
+        this.addWarning(`${serverName}: Missing optional environment variables: ${missingVars.join(', ')}`);
+        console.log(chalk.yellow(`    ⚠ Missing: ${missingVars.join(', ')}`));
+      }
+    } else {
+      this.log(`${serverName}: Configuration valid`, 'success');
+      this.passed++;
+    }
+
+    // Display notes
+    if (requirements.note) {
+      console.log(chalk.gray(`    Note: ${requirements.note}`));
+    }
+    if (requirements.freeTier) {
+      console.log(chalk.gray(`    Free tier: ${requirements.freeTier}`));
+    }
+  }
+
+  validateAllServers() {
+    console.log(chalk.bold('\n🔌 Validating MCP Servers...'));
+
+    const configuredServers = Object.keys(this.mcpConfig.mcpServers);
+    const expectedServers = Object.keys(MCP_SERVERS);
+
+    // Check each expected server
+    expectedServers.forEach(serverName => {
+      if (configuredServers.includes(serverName)) {
+        const config = this.mcpConfig.mcpServers[serverName];
+        this.validateServerConfig(serverName, config);
+      } else {
+        const requirements = MCP_SERVERS[serverName];
+        if (requirements.required) {
+          this.addError(`Missing required MCP server: ${serverName}`);
+          console.log(chalk.red(`\n  ${serverName}: Not configured`));
+          console.log(chalk.gray(`    ${requirements.description}`));
+        } else {
+          this.addWarning(`Missing optional MCP server: ${serverName}`);
+          console.log(chalk.yellow(`\n  ${serverName}: Not configured (optional)`));
+        }
+      }
+    });
+
+    // Check for unknown servers
+    configuredServers.forEach(serverName => {
+      if (!expectedServers.includes(serverName)) {
+        this.addWarning(`Unknown MCP server in config: ${serverName}`);
+      }
+    });
+  }
+
+  validateServerConnectivity() {
+    console.log(chalk.bold('\n🌐 Checking Server Configuration...'));
+
+    Object.entries(this.mcpConfig.mcpServers).forEach(([serverName, config]) => {
+      // Check command-based servers
+      if (config.command) {
+        const command = this.replaceEnvVars(config.command);
+        console.log(chalk.gray(`  ${serverName}: Command-based (${command})`));
+
+        // Check if npx is available for npx-based servers
+        if (command === 'npx') {
+          try {
+            require('child_process').execSync('npx --version', { stdio: 'ignore' });
+            this.log(`${serverName}: npx available`, 'success');
+            this.passed++;
+          } catch (error) {
+            this.addWarning(`${serverName}: npx not available - install Node.js`);
+          }
+        }
+      }
+
+      // Check URL-based servers
+      if (config.url) {
+        const url = this.replaceEnvVars(config.url);
+        console.log(chalk.gray(`  ${serverName}: URL-based (${url})`));
+
+        if (!url.startsWith('http')) {
+          this.addWarning(`${serverName}: Invalid URL format: ${url}`);
+        } else {
+          this.log(`${serverName}: URL configured`, 'success');
+          this.passed++;
+        }
+      }
+
+      // Check environment variables are properly configured
+      if (config.env) {
+        const envKeys = Object.keys(config.env);
+        const hasPlaceholders = envKeys.some(key => {
+          const value = config.env[key];
+          return typeof value === 'string' && value.includes('${');
+        });
+
+        if (hasPlaceholders) {
+          this.log(`${serverName}: Using environment variables`, 'success');
+          this.passed++;
+        }
+      }
+    });
+  }
+
+  checkCriticalToolStatus() {
+    console.log(chalk.bold('\n🎯 Critical Tool Status...'));
+
+    const criticalTools = ['brave-search', 'mem0', 'clear-thought', 'deepwiki'];
+    const configured = [];
+    const missing = [];
+
+    criticalTools.forEach(tool => {
+      const requirements = MCP_SERVERS[tool];
+      const isConfigured = this.mcpConfig.mcpServers[tool];
+
+      if (!isConfigured) {
+        missing.push(tool);
+        return;
+      }
+
+      const missingVars = requirements.envVars.filter(envVar => {
+        const value = this.env[envVar];
+        return !value || value.trim() === '';
+      });
+
+      if (missingVars.length === 0) {
+        configured.push(tool);
+      } else {
+        missing.push(tool);
+      }
+    });
+
+    if (configured.length > 0) {
+      this.log(`${configured.length} critical tools ready: ${configured.join(', ')}`, 'success');
+      this.passed++;
+    }
+
+    if (missing.length > 0) {
+      this.addError(`${missing.length} critical tools not ready: ${missing.join(', ')}`);
+      console.log(chalk.red(`  Missing: ${missing.join(', ')}`));
+    }
+  }
+
+  checkMemorySystemStatus() {
+    console.log(chalk.bold('\n💾 Memory System Status...'));
+
+    const mem0Ready = this.mcpConfig.mcpServers['mem0'] &&
+                      this.env['SMITHERY_KEY'] &&
+                      this.env['OPENAI_API_KEY'];
+
+    const openmemoryReady = this.mcpConfig.mcpServers['openmemory'] &&
+                            this.env['OPENMEMORY_API_KEY'];
+
+    if (mem0Ready && openmemoryReady) {
+      this.log('Both memory systems configured (mem0 and openmemory)', 'success');
+      console.log(chalk.gray('  Note: You only need one memory system'));
+      this.passed++;
+    } else if (mem0Ready) {
+      this.log('mem0 configured and ready', 'success');
+      this.passed++;
+    } else if (openmemoryReady) {
+      this.log('openmemory configured and ready', 'success');
+      this.passed++;
+    } else {
+      this.addError('No memory system configured - configure either mem0 or openmemory');
+      console.log(chalk.red('  Both mem0 and openmemory are unavailable'));
+      console.log(chalk.cyan('  Setup mem0: https://smithery.ai'));
+      console.log(chalk.cyan('  Setup openmemory: https://openmemory.ai'));
+    }
+  }
+
+  generateReport() {
+    console.log(chalk.bold('\n\n📊 MCP Configuration Report\n'));
+    console.log(chalk.bold('━'.repeat(50)));
+
+    // Summary
+    console.log(chalk.bold('\nSummary:'));
+    console.log(`  ${chalk.green('✓')} Configured: ${chalk.bold(this.passed)}`);
+    console.log(`  ${chalk.red('✗')} Missing: ${chalk.bold(this.failed)}`);
+    console.log(`  ${chalk.yellow('⚠')} Warnings: ${chalk.bold(this.warnings.length)}`);
+
+    // Errors
+    if (this.errors.length > 0) {
+      console.log(chalk.bold('\n\nConfiguration Issues:'));
+      this.errors.forEach((error, i) => {
+        console.log(`  ${i + 1}. ${chalk.red(error)}`);
+      });
+    }
+
+    // Warnings
+    if (this.warnings.length > 0) {
+      console.log(chalk.bold('\n\nWarnings:'));
+      this.warnings.forEach((warning, i) => {
+        console.log(`  ${i + 1}. ${chalk.yellow(warning)}`);
+      });
+    }
+
+    console.log(chalk.bold('\n' + '━'.repeat(50)));
+
+    // Overall status
+    console.log(chalk.bold('\nOverall Status:'));
+    if (this.failed === 0) {
+      console.log(chalk.green('  ✓ MCP configuration is valid'));
+      console.log(chalk.green('\n  All critical MCP tools are configured!\n'));
+      console.log(chalk.cyan('  Next steps:'));
+      console.log(chalk.gray('  1. Test your MCP tools in Claude Code or other AI tools'));
+      console.log(chalk.gray('  2. Try: @context7 react'));
+      console.log(chalk.gray('  3. Try: /mem0 save "test message"'));
+      console.log(chalk.gray('  4. Try: @deepwiki facebook/react\n'));
+    } else {
+      console.log(chalk.red(`  ✗ Missing ${this.failed} required configuration(s)`));
+      console.log(chalk.yellow('\n  Setup Instructions:\n'));
+      console.log(chalk.cyan('  1. Fix environment variables:'));
+      console.log(chalk.gray('     npm run validate:env\n'));
+      console.log(chalk.cyan('  2. Add missing API keys to .env\n'));
+      console.log(chalk.cyan('  3. Run MCP validation again:'));
+      console.log(chalk.gray('     npm run validate:mcp\n'));
+    }
+
+    return this.failed === 0;
+  }
+
+  async run() {
+    console.log(chalk.bold.cyan('\n🔍 AgentDevFramework MCP Configuration Validator\n'));
+
+    const spinner = ora('Starting validation...').start();
+
+    try {
+      spinner.text = 'Loading environment variables...';
+      const envLoaded = this.loadEnvFile();
+
+      spinner.text = 'Checking MCP configuration file...';
+      const configExists = this.checkMCPConfigExists();
+
+      if (!configExists) {
+        spinner.fail('MCP configuration file not found');
+        return this.generateReport();
+      }
+
+      spinner.text = 'Loading MCP configuration...';
+      const configLoaded = this.loadMCPConfig();
+
+      if (!configLoaded) {
+        spinner.fail('Failed to load MCP configuration');
+        return this.generateReport();
+      }
+
+      spinner.text = 'Validating MCP servers...';
+      this.validateAllServers();
+
+      spinner.text = 'Checking server connectivity...';
+      this.validateServerConnectivity();
+
+      spinner.text = 'Checking critical tools...';
+      this.checkCriticalToolStatus();
+
+      spinner.text = 'Checking memory systems...';
+      this.checkMemorySystemStatus();
+
+      spinner.succeed('Validation complete');
+
+      return this.generateReport();
+    } catch (error) {
+      spinner.fail('Validation failed');
+      console.error(chalk.red(`\nError: ${error.message}`));
+      console.error(error.stack);
+      return false;
+    }
+  }
+}
+
+// Run validation if called directly
+if (require.main === module) {
+  const validator = new MCPValidator();
+  validator.run().then(success => {
+    process.exit(success ? 0 : 1);
+  });
+}
+
+module.exports = MCPValidator;