graphorama-mcp/scripts/build.js

High-performance MCP server for code validation and service orchestration

#!/usr/bin/env node

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

// Build script for NPM package preparation
function buildPackage() {
  console.log('🔨 Building Graphorama NPM package...');
  console.log('');
  
  try {
    const projectRoot = path.join(__dirname, '..');
    const packageJson = require('../package.json');
    
    console.log(`📦 Package: ${packageJson.name}@${packageJson.version}`);
    console.log('');
    
    // Step 1: Validate package structure
    console.log('🔍 Validating package structure...');
    
    const requiredFiles = [
      'package.json',
      'lib/install.js',
      'lib/test.js',
      'bin/graphorama',
      'README.md'
    ];
    
    const requiredDirs = [
      'lib',
      'bin'
    ];
    
    // Check required directories
    for (const dir of requiredDirs) {
      const dirPath = path.join(projectRoot, dir);
      if (!fs.existsSync(dirPath)) {
        throw new Error(`Required directory missing: ${dir}`);
      }
    }
    console.log('  ✅ Required directories exist');
    
    // Check required files
    for (const file of requiredFiles) {
      const filePath = path.join(projectRoot, file);
      if (!fs.existsSync(filePath)) {
        console.log(`  ⚠️  Optional file missing: ${file}`);
      }
    }
    console.log('  ✅ Package structure validated');
    
    // Step 2: Validate JavaScript files
    console.log('🔍 Validating JavaScript files...');
    
    const jsFiles = [
      'lib/install.js',
      'lib/test.js', 
      'bin/graphorama',
      'scripts/build.js'
    ];
    
    for (const file of jsFiles) {
      const filePath = path.join(projectRoot, file);
      if (fs.existsSync(filePath)) {
        try {
          // Basic syntax check by requiring the file
          if (file.endsWith('.js')) {
            require(filePath);
          }
          console.log(`  ✅ ${file} - syntax OK`);
        } catch (error) {
          console.log(`  ❌ ${file} - syntax error: ${error.message}`);
        }
      }
    }
    
    // Step 3: Check executability
    console.log('🔍 Checking file permissions...');
    
    const executableFiles = ['bin/graphorama'];
    for (const file of executableFiles) {
      const filePath = path.join(projectRoot, file);
      if (fs.existsSync(filePath)) {
        try {
          fs.accessSync(filePath, fs.constants.X_OK);
          console.log(`  ✅ ${file} - executable`);
        } catch (error) {
          console.log(`  ❌ ${file} - not executable`);
        }
      }
    }
    
    // Step 4: Update version consistency
    console.log('🔍 Checking version consistency...');
    
    // Read Cargo.toml version
    const cargoTomlPath = path.join(projectRoot, 'Cargo.toml');
    if (fs.existsSync(cargoTomlPath)) {
      const cargoToml = fs.readFileSync(cargoTomlPath, 'utf8');
      const cargoVersionMatch = cargoToml.match(/version = "([^"]+)"/);
      
      if (cargoVersionMatch) {
        const cargoVersion = cargoVersionMatch[1];
        if (cargoVersion !== packageJson.version) {
          console.log(`  ⚠️  Version mismatch: Cargo.toml=${cargoVersion}, package.json=${packageJson.version}`);
        } else {
          console.log(`  ✅ Versions match: ${packageJson.version}`);
        }
      }
    }
    
    // Step 5: Generate NPM package files list
    console.log('🔍 Generating package files list...');
    
    const packageFiles = [];
    
    function scanDirectory(dir, relativePath = '') {
      const fullPath = path.join(projectRoot, relativePath);
      const items = fs.readdirSync(fullPath);
      
      for (const item of items) {
        const itemPath = path.join(fullPath, item);
        const relativeItemPath = path.join(relativePath, item).replace(/\\/g, '/');
        
        if (fs.statSync(itemPath).isDirectory()) {
          if (['lib', 'bin'].includes(item) || relativePath.startsWith('lib/') || relativePath.startsWith('bin/')) {
            scanDirectory(item, relativeItemPath);
          }
        } else {
          if (relativePath.startsWith('lib/') || relativePath.startsWith('bin/') || 
              ['README.md', 'LICENSE', 'package.json'].includes(item)) {
            packageFiles.push(relativeItemPath);
          }
        }
      }
    }
    
    scanDirectory('');
    
    console.log('  📄 Package will include:');
    packageFiles.sort().forEach(file => console.log(`     ${file}`));
    
    // Step 6: Test installation script
    console.log('🧪 Testing installation logic...');
    
    try {
      const installer = require('../lib/install.js');
      const platform = installer.detectPlatform();
      const binaryName = installer.getBinaryName(platform);
      
      console.log(`  ✅ Platform detection: ${platform}`);
      console.log(`  ✅ Binary name: ${binaryName}`);
      
      // Test shouldInstall logic
      const shouldInstall = installer.shouldInstall();
      console.log(`  ✅ Install check: ${shouldInstall ? 'will install' : 'skip install'}`);
      
    } catch (error) {
      console.log(`  ❌ Installation test failed: ${error.message}`);
    }
    
    // Step 7: Size check
    console.log('🔍 Package size analysis...');
    
    let totalSize = 0;
    for (const file of packageFiles) {
      const filePath = path.join(projectRoot, file);
      if (fs.existsSync(filePath)) {
        const stats = fs.statSync(filePath);
        totalSize += stats.size;
      }
    }
    
    const sizeKB = Math.round(totalSize / 1024);
    console.log(`  📏 Total package size: ${sizeKB} KB`);
    
    if (sizeKB > 1024) {
      console.log('  ⚠️  Package is large (>1MB) - consider optimizing');
    } else {
      console.log('  ✅ Package size is reasonable');
    }
    
    console.log('');
    console.log('🎉 Build validation complete!');
    console.log('');
    console.log('📦 Ready to publish:');
    console.log('   npm pack          # Test package creation');
    console.log('   npm login         # Login to NPM');
    console.log('   npm publish       # Publish to NPM registry');
    console.log('');
    console.log('🧪 Test locally first:');
    console.log('   npm pack');
    console.log('   npm install -g ./graphorama-*.tgz');
    console.log('   graphorama --version');
    
  } catch (error) {
    console.error('❌ Build failed:', error.message);
    process.exit(1);
  }
}

// Main execution
if (require.main === module) {
  buildPackage();
}

module.exports = { buildPackage };