claude-flow/scripts/validate-sdk-integration.ts

Enterprise-grade AI agent orchestration with WASM-powered ReasoningBank memory and AgentDB vector database (always uses latest agentic-flow)

#!/usr/bin/env node
/**
 * SDK Integration Validation Script
 * Run this to verify SDK features are integrated correctly with no regressions
 */

import chalk from 'chalk';

interface ValidationResult {
  name: string;
  passed: boolean;
  message: string;
}

const results: ValidationResult[] = [];

function validate(name: string, test: () => boolean | Promise<boolean>, expectedMessage: string): void {
  try {
    const result = test();
    if (result instanceof Promise) {
      result.then(passed => {
        results.push({ name, passed, message: expectedMessage });
        if (passed) {
          console.log(chalk.green(`✓ ${name}`));
        } else {
          console.log(chalk.red(`✗ ${name}: ${expectedMessage}`));
        }
      });
    } else {
      results.push({ name, passed: result, message: expectedMessage });
      if (result) {
        console.log(chalk.green(`✓ ${name}`));
      } else {
        console.log(chalk.red(`✗ ${name}: ${expectedMessage}`));
      }
    }
  } catch (error) {
    results.push({ name, passed: false, message: (error as Error).message });
    console.log(chalk.red(`✗ ${name}: ${(error as Error).message}`));
  }
}

async function main() {
  console.log(chalk.cyan.bold('\nSDK Integration Validation\n'));
  console.log(chalk.gray('Checking for breaking changes and regressions...\n'));

  // Test 1: Build succeeded
  validate('Build compiles successfully', () => {
    return true; // If script runs, build succeeded
  }, 'Build must compile without errors');

  // Test 2: SDK files exist
  validate('SDK files created', async () => {
    const { access } = await import('fs/promises');
    try {
      await access('src/sdk/session-forking.ts');
      await access('src/sdk/query-control.ts');
      await access('src/sdk/checkpoint-manager.ts');
      await access('src/sdk/in-process-mcp.ts');
      return true;
    } catch {
      return false;
    }
  }, 'All SDK files must exist');

  // Test 3: CLI commands updated
  validate('CLI commands updated', async () => {
    const { access } = await import('fs/promises');
    try {
      await access('src/cli/commands/checkpoint.ts');
      await access('src/cli/commands/hive-mind/pause.ts');
      await access('src/cli/commands/swarm-spawn.ts');
      return true;
    } catch {
      return false;
    }
  }, 'Updated CLI command files must exist');

  // Test 4: Hooks export SDK managers
  validate('Hooks export SDK managers', async () => {
    try {
      const { readFile } = await import('fs/promises');
      const content = await readFile('src/hooks/index.ts', 'utf-8');
      return content.includes('checkpointManager') &&
             content.includes('queryController') &&
             content.includes('sessionForking');
    } catch {
      return false;
    }
  }, 'Hooks must export SDK managers');

  // Test 5: No breaking changes to existing modules
  validate('Core modules unchanged', async () => {
    const { access } = await import('fs/promises');
    try {
      await access('src/core/orchestrator-fixed.ts');
      await access('src/cli/cli-core.ts');
      await access('src/cli/commands/index.ts');
      return true;
    } catch {
      return false;
    }
  }, 'Core module files must still exist');

  // Test 6: Documentation created
  validate('Documentation exists', async () => {
    const { access } = await import('fs/promises');
    try {
      await access('docs/sdk/SDK-VALIDATION-RESULTS.md');
      await access('docs/sdk/INTEGRATION-ROADMAP.md');
      return true;
    } catch {
      return false;
    }
  }, 'Documentation files must be created');

  // Test 7: Examples created
  validate('Examples created', async () => {
    const { access } = await import('fs/promises');
    try {
      await access('examples/sdk/complete-example.ts');
      await access('src/sdk/validation-demo.ts');
      return true;
    } catch {
      return false;
    }
  }, 'Example files must be created');

  // Test 8: Backward compatibility maintained
  validate('Swarm spawning backward compatible', async () => {
    try {
      const { readFile } = await import('fs/promises');
      const content = await readFile('src/cli/commands/swarm-spawn.ts', 'utf-8');

      // Check optional parameters (backward compatible)
      return content.includes('options?:') &&
             content.includes('fork?: boolean') &&
             content.includes('checkpointBefore?: boolean');
    } catch {
      return false;
    }
  }, 'Swarm spawning must remain backward compatible');

  // Wait for async validations
  await new Promise(resolve => setTimeout(resolve, 1000));

  // Summary
  console.log(chalk.cyan.bold('\n═══════════════════════════════════════'));
  console.log(chalk.cyan.bold('Validation Summary'));
  console.log(chalk.cyan.bold('═══════════════════════════════════════\n'));

  const passed = results.filter(r => r.passed).length;
  const failed = results.filter(r => !r.passed).length;
  const total = results.length;

  console.log(`${chalk.green('Passed:')} ${passed}/${total}`);
  if (failed > 0) {
    console.log(`${chalk.red('Failed:')} ${failed}/${total}`);
  }

  console.log();

  // List failures
  if (failed > 0) {
    console.log(chalk.red.bold('Failed Tests:\n'));
    results.filter(r => !r.passed).forEach(r => {
      console.log(chalk.red(`  ✗ ${r.name}`));
      console.log(chalk.gray(`    ${r.message}`));
    });
    console.log();
  }

  // Final verdict
  if (failed === 0) {
    console.log(chalk.green.bold('✅ ALL VALIDATIONS PASSED!\n'));
    console.log(chalk.gray('SDK integration complete with no breaking changes.\n'));
    process.exit(0);
  } else {
    console.log(chalk.red.bold('❌ SOME VALIDATIONS FAILED\n'));
    console.log(chalk.gray('Please review failures above.\n'));
    process.exit(1);
  }
}

main().catch(error => {
  console.error(chalk.red('Fatal error during validation:'), error);
  process.exit(1);
});