@iservu-inc/adf-cli 0.13.0 → 0.14.1

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

@@ -0,0 +1,428 @@
+#!/usr/bin/env node
+
+/**
+ * AgentDevFramework Environment Validator
+ * Validates .env configuration and API keys for MCP tools
+ */
+
+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 ENV_TEMPLATE = path.join(FRAMEWORK_ROOT, '.env.template');
+
+// Define required and optional environment variables
+const ENV_VARS = {
+  required: {
+    // Core MCP tools
+    BRAVE_API_KEY: {
+      description: 'Brave Search API key (required for web search)',
+      url: 'https://brave.com/search/api/',
+      freeT tier: '2,000 queries/month'
+    },
+    OPENAI_API_KEY: {
+      description: 'OpenAI API key (required for mem0, archon, clear-thought)',
+      url: 'https://platform.openai.com/api-keys'
+    },
+
+    // Memory & Knowledge Management
+    LLM_PROVIDER: {
+      description: 'LLM provider for mem0',
+      default: 'openai',
+      validation: (val) => ['openai', 'anthropic', 'ollama'].includes(val)
+    },
+    LLM_CHOICE: {
+      description: 'LLM model choice for mem0',
+      default: 'gpt-4o-mini'
+    },
+    EMBEDDING_MODEL_CHOICE: {
+      description: 'Embedding model for mem0',
+      default: 'text-embedding-3-small'
+    }
+  },
+
+  optional: {
+    // Optional API keys
+    CONTEXT7_API_KEY: {
+      description: 'Context7 API key (optional - provides higher rate limits)',
+      url: 'https://context7.com'
+    },
+    OPENMEMORY_API_KEY: {
+      description: 'OpenMemory API key (alternative memory system)',
+      url: 'https://openmemory.ai'
+    },
+
+    // Supabase (for Archon)
+    SUPABASE_URL: {
+      description: 'Supabase URL (required if using Archon)',
+      url: 'https://supabase.com/dashboard'
+    },
+    SUPABASE_SERVICE_ROLE_KEY: {
+      description: 'Supabase service role key (required if using Archon)'
+    },
+    SUPABASE_ANON_KEY: {
+      description: 'Supabase anonymous key (required if using Archon)'
+    },
+
+    // Smithery
+    SMITHERY_KEY: {
+      description: 'Smithery API key (for mem0 and clear-thought)',
+      url: 'https://smithery.ai'
+    },
+    SMITHERY_PROFILE: {
+      description: 'Smithery profile name'
+    },
+
+    // OpenAI Organization
+    OPENAI_ORG_ID: {
+      description: 'OpenAI organization ID (optional)'
+    },
+
+    // Archon
+    ARCHON_URL: {
+      description: 'Local Archon instance URL (if self-hosting)',
+      default: 'http://localhost:8051/mcp'
+    },
+
+    // Neo4j (for Archon knowledge graphs)
+    NEO4J_URI: {
+      description: 'Neo4j URI (optional - for advanced Archon features)',
+      default: 'bolt://localhost:7687'
+    },
+    NEO4J_USER: {
+      description: 'Neo4j username',
+      default: 'neo4j'
+    },
+    NEO4J_PASSWORD: {
+      description: 'Neo4j password'
+    },
+
+    // Memory databases
+    DATABASE_URL: {
+      description: 'PostgreSQL database URL for mem0',
+      default: 'postgresql://user:password@localhost:5432/mem0'
+    },
+    MEMORY_DB_PATH: {
+      description: 'SQLite database path for local memory',
+      default: './data/memory.sqlite'
+    },
+
+    // Development settings
+    NODE_ENV: {
+      description: 'Node environment',
+      default: 'development',
+      validation: (val) => ['development', 'production', 'test'].includes(val)
+    },
+    DEBUG: {
+      description: 'Enable debug mode',
+      default: 'false',
+      validation: (val) => ['true', 'false'].includes(val)
+    },
+    LOG_LEVEL: {
+      description: 'Logging level',
+      default: 'info',
+      validation: (val) => ['error', 'warn', 'info', 'debug'].includes(val)
+    },
+
+    // Client identification
+    CLIENT_NAME: {
+      description: 'Client name for openmemory',
+      default: 'agentdevframework'
+    }
+  }
+};
+
+class EnvValidator {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+    this.passed = 0;
+    this.failed = 0;
+    this.env = {};
+  }
+
+  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);
+  }
+
+  checkEnvFileExists() {
+    if (fs.existsSync(ENV_FILE)) {
+      this.log('.env file found', 'success');
+      this.passed++;
+      return true;
+    } else {
+      this.addError('.env file not found');
+
+      if (fs.existsSync(ENV_TEMPLATE)) {
+        this.log('Found .env.template - copy it to .env to get started', 'info');
+        console.log(chalk.cyan(`\n  Run: cp .env.template .env\n`));
+      }
+
+      return false;
+    }
+  }
+
+  loadEnvFile() {
+    try {
+      const result = dotenv.config({ path: ENV_FILE });
+
+      if (result.error) {
+        this.addError(`Failed to load .env file: ${result.error.message}`);
+        return false;
+      }
+
+      this.env = result.parsed || {};
+      this.log(`Loaded ${Object.keys(this.env).length} environment variables`, 'success');
+      this.passed++;
+      return true;
+    } catch (error) {
+      this.addError(`Failed to parse .env file: ${error.message}`);
+      return false;
+    }
+  }
+
+  validateRequired() {
+    console.log(chalk.bold('\n🔑 Validating Required Variables...'));
+
+    Object.entries(ENV_VARS.required).forEach(([key, config]) => {
+      const value = this.env[key] || process.env[key];
+
+      if (!value || value.trim() === '') {
+        this.addError(`Missing required variable: ${key}`);
+        console.log(chalk.red(`  ✗ ${key}`));
+        console.log(chalk.gray(`    ${config.description}`));
+        if (config.url) {
+          console.log(chalk.cyan(`    Get key: ${config.url}`));
+        }
+        if (config.default) {
+          console.log(chalk.yellow(`    Default: ${config.default}`));
+        }
+      } else {
+        // Validate value if validation function exists
+        if (config.validation && !config.validation(value)) {
+          this.addError(`Invalid value for ${key}: ${value}`);
+        } else {
+          this.passed++;
+          this.log(`${key} is set`, 'success');
+        }
+      }
+    });
+  }
+
+  validateOptional() {
+    console.log(chalk.bold('\n🔧 Validating Optional Variables...'));
+
+    const configuredOptional = [];
+    const missingOptional = [];
+
+    Object.entries(ENV_VARS.optional).forEach(([key, config]) => {
+      const value = this.env[key] || process.env[key];
+
+      if (value && value.trim() !== '') {
+        // Validate value if validation function exists
+        if (config.validation && !config.validation(value)) {
+          this.addWarning(`Invalid value for ${key}: ${value}`);
+        } else {
+          this.passed++;
+          configuredOptional.push(key);
+        }
+      } else {
+        missingOptional.push({ key, config });
+      }
+    });
+
+    if (configuredOptional.length > 0) {
+      this.log(`${configuredOptional.length} optional variables configured`, 'success');
+    }
+
+    if (missingOptional.length > 0) {
+      console.log(chalk.yellow(`\n  ${missingOptional.length} optional variables not configured:`));
+      missingOptional.forEach(({ key, config }) => {
+        console.log(chalk.gray(`    ${key} - ${config.description}`));
+        if (config.url) {
+          console.log(chalk.cyan(`      ${config.url}`));
+        }
+      });
+    }
+  }
+
+  checkForSensitiveData() {
+    console.log(chalk.bold('\n🔒 Checking for Sensitive Data...'));
+
+    // Check if .env is in .gitignore
+    const gitignorePath = path.join(FRAMEWORK_ROOT, '.gitignore');
+
+    if (fs.existsSync(gitignorePath)) {
+      const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
+
+      if (gitignore.includes('.env') || gitignore.includes('*.env')) {
+        this.log('.env is properly excluded from git', 'success');
+        this.passed++;
+      } else {
+        this.addWarning('.env should be added to .gitignore');
+      }
+    } else {
+      this.addWarning('.gitignore file not found');
+    }
+
+    // Warn about placeholder values
+    Object.entries(this.env).forEach(([key, value]) => {
+      if (value.includes('your-') || value.includes('placeholder') || value === 'changeme') {
+        this.addWarning(`${key} appears to contain a placeholder value`);
+      }
+    });
+  }
+
+  validateMCPToolCompatibility() {
+    console.log(chalk.bold('\n🔌 Checking MCP Tool Compatibility...'));
+
+    const tools = {
+      'context7': ['CONTEXT7_API_KEY'],
+      'brave-search': ['BRAVE_API_KEY'],
+      'mem0': ['OPENAI_API_KEY', 'LLM_PROVIDER', 'LLM_CHOICE', 'EMBEDDING_MODEL_CHOICE'],
+      'clear-thought': ['OPENAI_API_KEY'],
+      'archon': ['OPENAI_API_KEY', 'SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY'],
+      'openmemory': ['OPENMEMORY_API_KEY', 'CLIENT_NAME'],
+      'deepwiki': [] // No API key required
+    };
+
+    Object.entries(tools).forEach(([tool, requiredVars]) => {
+      if (requiredVars.length === 0) {
+        this.log(`${tool}: Ready (no API key required)`, 'success');
+        this.passed++;
+        return;
+      }
+
+      const missing = requiredVars.filter(
+        varName => !this.env[varName] && !process.env[varName]
+      );
+
+      if (missing.length === 0) {
+        this.log(`${tool}: Ready`, 'success');
+        this.passed++;
+      } else {
+        this.addWarning(`${tool}: Missing ${missing.join(', ')}`);
+      }
+    });
+  }
+
+  generateReport() {
+    console.log(chalk.bold('\n\n📊 Environment Validation 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\nRequired Configuration Missing:'));
+      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('  ✓ Environment configuration is valid'));
+      console.log(chalk.green('\n  All required MCP tools are configured!\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. Copy .env.template to .env:'));
+      console.log(chalk.gray('     cp .env.template .env\n'));
+      console.log(chalk.cyan('  2. Add your API keys to .env\n'));
+      console.log(chalk.cyan('  3. Run validation again:'));
+      console.log(chalk.gray('     npm run validate:env\n'));
+    }
+
+    return this.failed === 0;
+  }
+
+  async run() {
+    console.log(chalk.bold.cyan('\n🔍 AgentDevFramework Environment Validator\n'));
+
+    const spinner = ora('Starting validation...').start();
+
+    try {
+      spinner.text = 'Checking .env file...';
+      const envExists = this.checkEnvFileExists();
+
+      if (!envExists) {
+        spinner.fail('Environment file not found');
+        return this.generateReport();
+      }
+
+      spinner.text = 'Loading environment variables...';
+      const loaded = this.loadEnvFile();
+
+      if (!loaded) {
+        spinner.fail('Failed to load environment file');
+        return this.generateReport();
+      }
+
+      spinner.text = 'Validating required variables...';
+      this.validateRequired();
+
+      spinner.text = 'Validating optional variables...';
+      this.validateOptional();
+
+      spinner.text = 'Checking for sensitive data...';
+      this.checkForSensitiveData();
+
+      spinner.text = 'Checking MCP tool compatibility...';
+      this.validateMCPToolCompatibility();
+
+      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 EnvValidator();
+  validator.run().then(success => {
+    process.exit(success ? 0 : 1);
+  });
+}
+
+module.exports = EnvValidator;