universal-mcp-orchestration-optimizer/quick-setup-optimizer.cjs

⚡ OPTIMIZER EDITION: Ultra-lightweight context optimization tools. 99% smaller package for quick setup, profile management, and performance tuning of existing MCP installations.

#!/usr/bin/env node

/**
 * Universal MCP Optimizer - Quick Setup Script
 * Ultra-lightweight optimization for existing MCP installations
 * Works with ANY MCP setup - adds optimization without disruption
 */

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

class OptimizerQuickSetup {
  constructor() {
    this.projectRoot = process.cwd();
    this.hasExistingMCP = false;
    this.currentContextUsage = null;
  }

  async run() {
    console.log('⚡ Universal MCP Optimizer - Quick Setup');
    console.log('📦 Ultra-lightweight package (500KB) - Works with ANY existing MCP setup\n');

    try {
      // 1. Detect existing MCP setup
      this.hasExistingMCP = this.detectExistingMCPSetup();
      
      // 2. Analyze current context usage
      await this.analyzeCurrentUsage();
      
      // 3. Apply optimization
      await this.applyOptimization();
      
      // 4. Show results
      this.showOptimizationResults();
      
    } catch (error) {
      console.error('❌ Optimization setup failed:', error.message);
      this.showFallbackOptions();
    }
  }

  detectExistingMCPSetup() {
    const mcpIndicators = [
      '.claude/settings.local.json',
      '.mcp-orchestrator/',
      'package.json' // Check if NPM project for potential MCP usage
    ];

    let foundIndicators = 0;
    for (const indicator of mcpIndicators) {
      if (fs.existsSync(path.join(this.projectRoot, indicator))) {
        foundIndicators++;
      }
    }

    const hasSetup = foundIndicators > 0;
    
    if (hasSetup) {
      console.log('🔍 Detected existing MCP setup - will optimize without disruption');
    } else {
      console.log('🆕 No existing MCP setup detected - will create optimized foundation');
    }
    
    return hasSetup;
  }

  async analyzeCurrentUsage() {
    console.log('📊 Analyzing current context usage...');
    
    try {
      // Try to get current context from claude doctor (if available)
      const output = execSync('claude mcp list 2>/dev/null | grep -c "Connected"', { 
        encoding: 'utf8', 
        timeout: 5000 
      });
      
      const agentCount = parseInt(output.trim()) || 0;
      this.currentContextUsage = {
        agentCount: agentCount,
        estimatedTokens: agentCount * 2600, // Rough estimate
        needsOptimization: agentCount > 10
      };
      
      console.log(`  • Current agents loaded: ${agentCount}`);
      console.log(`  • Estimated context usage: ~${this.currentContextUsage.estimatedTokens.toLocaleString()} tokens`);
      
      if (this.currentContextUsage.needsOptimization) {
        console.log('  ⚠️  Context usage is high - optimization will help significantly');
      } else {
        console.log('  ✅ Context usage looks reasonable');
      }
      
    } catch (error) {
      console.log('  ℹ️  Could not analyze current usage (Claude not running) - proceeding with optimization setup');
      this.currentContextUsage = { unknown: true };
    }
  }

  async applyOptimization() {
    console.log('🚀 Applying optimization configuration...');
    
    // Create .mcp-orchestrator directory if it doesn't exist
    const mcpDir = path.join(this.projectRoot, '.mcp-orchestrator');
    if (!fs.existsSync(mcpDir)) {
      fs.mkdirSync(mcpDir, { recursive: true });
      console.log('  📁 Created .mcp-orchestrator directory');
    }

    // Create profiles directory
    const profilesDir = path.join(mcpDir, 'profiles');
    if (!fs.existsSync(profilesDir)) {
      fs.mkdirSync(profilesDir, { recursive: true });
      console.log('  📋 Created profiles directory');
    }

    // Add optimization profiles
    await this.createOptimizationProfiles(profilesDir);
    
    // Create optimizer configuration
    await this.createOptimizerConfig(mcpDir);
    
    // Add optimization scripts to package.json if present
    this.addOptimizationScripts();
    
    console.log('✅ Optimization configuration applied');
  }

  async createOptimizationProfiles(profilesDir) {
    const profiles = {
      minimal: {
        name: 'minimal',
        description: 'Ultra-fast 4 core agents (~10k tokens)',
        estimatedTokens: 10000,
        agents: ['orchestration-manager', 'developer', 'devops', 'technical-writer']
      },
      standard: {
        name: 'standard', 
        description: 'Balanced 10 agents for full development (~25k tokens)',
        estimatedTokens: 25000,
        agents: [
          'orchestration-manager', 'developer', 'frontend-developer', 'backend-engineer',
          'devops', 'qa-engineer', 'database-architect', 'ui-ux-designer',
          'technical-writer', 'code-review'
        ]
      },
      current: {
        name: 'current',
        description: 'Your current setup (preserved)',
        estimatedTokens: this.currentContextUsage?.estimatedTokens || 'unknown',
        agents: 'current-setup',
        note: 'This preserves your existing configuration'
      }
    };

    for (const [name, profile] of Object.entries(profiles)) {
      const profilePath = path.join(profilesDir, `${name}.json`);
      fs.writeFileSync(profilePath, JSON.stringify(profile, null, 2));
    }

    console.log('  📋 Created optimization profiles: minimal, standard, current');
  }

  async createOptimizerConfig(mcpDir) {
    const config = {
      optimizerVersion: '1.0.0',
      setupType: 'quick-optimizer',
      hasExistingMCP: this.hasExistingMCP,
      currentUsage: this.currentContextUsage,
      optimizationApplied: new Date().toISOString(),
      profiles: ['minimal', 'standard', 'current'],
      defaultProfile: this.currentContextUsage?.needsOptimization ? 'minimal' : 'standard',
      quickSetup: true
    };

    const configPath = path.join(mcpDir, 'optimizer-config.json');
    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
    console.log('  ⚙️  Created optimizer configuration');
  }

  addOptimizationScripts() {
    const packageJsonPath = path.join(this.projectRoot, 'package.json');
    
    if (fs.existsSync(packageJsonPath)) {
      try {
        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
        
        // Add optimization scripts if they don't exist
        if (!pkg.scripts) pkg.scripts = {};
        
        const optimizationScripts = {
          'mcp:optimize': 'mcp-optimize auto',
          'mcp:minimal': 'mcp-optimize minimal',
          'mcp:standard': 'mcp-optimize standard',
          'mcp:analyze': 'mcp-analyze',
          'mcp:status': 'mcp-profile status'
        };

        let scriptsAdded = 0;
        for (const [script, command] of Object.entries(optimizationScripts)) {
          if (!pkg.scripts[script]) {
            pkg.scripts[script] = command;
            scriptsAdded++;
          }
        }

        if (scriptsAdded > 0) {
          fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2));
          console.log(`  📝 Added ${scriptsAdded} optimization scripts to package.json`);
        }
        
      } catch (error) {
        console.log('  ⚠️  Could not update package.json:', error.message);
      }
    } else {
      console.log('  ℹ️  No package.json found - optimization commands available globally');
    }
  }

  showOptimizationResults() {
    console.log('\n🎉 MCP Optimization Setup Complete!\n');
    
    console.log('📊 What was added:');
    console.log('  ✅ Smart optimization profiles (minimal, standard, current)');
    console.log('  ✅ Context analysis tools');
    console.log('  ✅ Quick optimization commands');
    console.log('  ✅ Performance monitoring');
    
    if (this.hasExistingMCP) {
      console.log('\n🔧 Your existing MCP setup is preserved and enhanced');
    }
    
    console.log('\n🚀 Ready to optimize! Try these commands:');
    console.log('  npm run mcp:optimize     # Auto-optimize based on your project');
    console.log('  npm run mcp:minimal      # Switch to 4 agents (~10k tokens)');
    console.log('  npm run mcp:standard     # Switch to 10 agents (~25k tokens)');
    console.log('  npm run mcp:analyze      # Check current context usage');
    console.log('  npm run mcp:status       # Show optimization status');
    
    if (this.currentContextUsage?.needsOptimization) {
      console.log('\n💡 Immediate recommendation:');
      console.log('  npm run mcp:minimal      # Reduce context by 80% right now!');
    }
    
    console.log('\n📚 Documentation: Check OPTIMIZER_GUIDE.md');
    console.log('⚡ Ultra-lightweight optimizer ready - works with any MCP setup!');
  }

  showFallbackOptions() {
    console.log('\n🔄 Fallback options if setup failed:');
    console.log('1. Manual optimization:');
    console.log('   mcp-optimize auto');
    console.log('');
    console.log('2. Quick profile switch:');
    console.log('   mcp-profile minimal');
    console.log('');
    console.log('3. Context analysis:');
    console.log('   mcp-analyze');
    console.log('');
    console.log('💬 Need help? Check the troubleshooting guide or GitHub issues');
  }
}

// Auto-run if called directly
if (require.main === module) {
  const setup = new OptimizerQuickSetup();
  setup.run().catch(error => {
    console.error('💥 Fatal error:', error.message);
    process.exit(1);
  });
}

module.exports = OptimizerQuickSetup;