claude-flow-novice 2.2.3 → 2.2.5

package/scripts/validate-entry-points.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+/**
+ * Entry Point Validation Script
+ * Validates all package.json entry points work correctly after build
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { pathToFileURL } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.join(__dirname, '..');
+
+// ANSI colors for output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  gray: '\x1b[90m'
+};
+
+class EntryPointValidator {
+  constructor() {
+    this.results = {
+      passed: [],
+      failed: [],
+      warnings: []
+    };
+  }
+
+  log(message, color = 'reset') {
+    console.log(colors[color] + message + colors.reset);
+  }
+
+  async validatePackageJson() {
+    this.log('\n🔍 Reading package.json...', 'blue');
+
+    const pkgPath = path.join(rootDir, 'package.json');
+    const pkgContent = await fs.readFile(pkgPath, 'utf8');
+    const pkg = JSON.parse(pkgContent);
+
+    return {
+      main: pkg.main,
+      types: pkg.types,
+      bin: pkg.bin,
+      exports: pkg.exports
+    };
+  }
+
+  async checkFileExists(filePath, description) {
+    const fullPath = path.join(rootDir, filePath);
+
+    try {
+      await fs.access(fullPath);
+      this.log(`  ✓ ${description}: ${filePath}`, 'green');
+      this.results.passed.push({ type: 'file-exists', description, path: filePath });
+      return true;
+    } catch {
+      this.log(`  ✗ ${description}: ${filePath}`, 'red');
+      this.results.failed.push({ type: 'file-missing', description, path: filePath });
+      return false;
+    }
+  }
+
+  async testImport(filePath, description) {
+    const fullPath = path.join(rootDir, filePath);
+
+    try {
+      // Convert to file URL for dynamic import
+      const fileUrl = pathToFileURL(fullPath).href;
+      await import(fileUrl);
+      this.log(`  ✓ ${description}: imports successfully`, 'green');
+      this.results.passed.push({ type: 'import', description, path: filePath });
+      return true;
+    } catch (error) {
+      this.log(`  ✗ ${description}: ${error.message}`, 'red');
+      this.results.failed.push({
+        type: 'import-failed',
+        description,
+        path: filePath,
+        error: error.message
+      });
+      return false;
+    }
+  }
+
+  async validateMainEntry(pkg) {
+    this.log('\n📦 Validating main entry point...', 'blue');
+
+    if (!pkg.main) {
+      this.results.warnings.push('No main entry point defined');
+      this.log('  ⚠ No main entry point defined', 'yellow');
+      return;
+    }
+
+    await this.checkFileExists(pkg.main, 'main');
+    await this.testImport(pkg.main, 'main');
+  }
+
+  async validateTypesEntry(pkg) {
+    this.log('\n📘 Validating TypeScript types...', 'blue');
+
+    if (!pkg.types) {
+      this.results.warnings.push('No types entry point defined');
+      this.log('  ⚠ No types entry point defined', 'yellow');
+      return;
+    }
+
+    await this.checkFileExists(pkg.types, 'types');
+  }
+
+  async validateBinEntries(pkg) {
+    this.log('\n🔧 Validating bin entries...', 'blue');
+
+    if (!pkg.bin) {
+      this.results.warnings.push('No bin entries defined');
+      this.log('  ⚠ No bin entries defined', 'yellow');
+      return;
+    }
+
+    for (const [name, binPath] of Object.entries(pkg.bin)) {
+      await this.checkFileExists(binPath, `bin/${name}`);
+
+      // Check if bin file has shebang
+      try {
+        const fullPath = path.join(rootDir, binPath);
+        const content = await fs.readFile(fullPath, 'utf8');
+        const firstLine = content.split('\n')[0];
+
+        if (!firstLine.startsWith('#!')) {
+          this.results.warnings.push(`bin/${name} missing shebang: ${binPath}`);
+          this.log(`  ⚠ ${name}: missing shebang`, 'yellow');
+        } else {
+          this.log(`  ✓ ${name}: has shebang`, 'gray');
+        }
+      } catch {
+        // File doesn't exist, already reported above
+      }
+    }
+  }
+
+  async validateExports(pkg) {
+    this.log('\n📤 Validating exports...', 'blue');
+
+    if (!pkg.exports) {
+      this.results.warnings.push('No exports defined');
+      this.log('  ⚠ No exports defined', 'yellow');
+      return;
+    }
+
+    for (const [exportName, exportPath] of Object.entries(pkg.exports)) {
+      const description = exportName === '.' ? 'exports (default)' : `exports (${exportName})`;
+      await this.checkFileExists(exportPath, description);
+    }
+  }
+
+  async validateImportable(pkg) {
+    this.log('\n🧪 Testing module imports...', 'blue');
+
+    // Test main entry
+    if (pkg.main) {
+      await this.testImport(pkg.main, 'main entry');
+    }
+
+    // Test key exports
+    const criticalExports = [
+      { key: '.', name: 'default export' },
+      { key: './cli', name: 'CLI export' },
+      { key: './mcp', name: 'MCP export' }
+    ];
+
+    for (const { key, name } of criticalExports) {
+      if (pkg.exports && pkg.exports[key]) {
+        await this.testImport(pkg.exports[key], name);
+      }
+    }
+  }
+
+  async validateBuildStructure() {
+    this.log('\n🏗️  Validating build structure...', 'blue');
+
+    const criticalPaths = [
+      '.claude-flow-novice/dist/src',
+      '.claude-flow-novice/dist/src/cli',
+      '.claude-flow-novice/dist/src/core',
+      '.claude-flow-novice/dist/src/agents'
+    ];
+
+    for (const dirPath of criticalPaths) {
+      await this.checkFileExists(dirPath, `directory: ${dirPath}`);
+    }
+  }
+
+  printSummary() {
+    this.log('\n' + '='.repeat(60), 'blue');
+    this.log('📊 VALIDATION SUMMARY', 'blue');
+    this.log('='.repeat(60), 'blue');
+
+    this.log(`\n✓ Passed: ${this.results.passed.length}`, 'green');
+    this.log(`✗ Failed: ${this.results.failed.length}`, this.results.failed.length > 0 ? 'red' : 'green');
+    this.log(`⚠ Warnings: ${this.results.warnings.length}`, this.results.warnings.length > 0 ? 'yellow' : 'gray');
+
+    if (this.results.failed.length > 0) {
+      this.log('\n❌ FAILURES:', 'red');
+      this.results.failed.forEach(failure => {
+        this.log(`  • ${failure.description}: ${failure.path}`, 'red');
+        if (failure.error) {
+          this.log(`    ${failure.error}`, 'gray');
+        }
+      });
+    }
+
+    if (this.results.warnings.length > 0) {
+      this.log('\n⚠️  WARNINGS:', 'yellow');
+      this.results.warnings.forEach(warning => {
+        this.log(`  • ${warning}`, 'yellow');
+      });
+    }
+
+    const confidence = this.calculateConfidence();
+    this.log(`\n🎯 Confidence Score: ${(confidence * 100).toFixed(1)}%`,
+      confidence >= 0.75 ? 'green' : 'red');
+
+    return {
+      passed: this.results.passed.length,
+      failed: this.results.failed.length,
+      warnings: this.results.warnings.length,
+      confidence,
+      success: this.results.failed.length === 0
+    };
+  }
+
+  calculateConfidence() {
+    const total = this.results.passed.length + this.results.failed.length;
+    if (total === 0) return 0;
+
+    const passRate = this.results.passed.length / total;
+    const warningPenalty = Math.min(this.results.warnings.length * 0.02, 0.1);
+
+    return Math.max(0, Math.min(1, passRate - warningPenalty));
+  }
+
+  async exportReport() {
+    const reportPath = path.join(rootDir, 'entry-points-validation-report.json');
+    const report = {
+      timestamp: new Date().toISOString(),
+      summary: {
+        passed: this.results.passed.length,
+        failed: this.results.failed.length,
+        warnings: this.results.warnings.length,
+        confidence: this.calculateConfidence()
+      },
+      results: this.results
+    };
+
+    await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+    this.log(`\n📄 Report exported to: ${reportPath}`, 'blue');
+  }
+
+  async run() {
+    this.log('🚀 Entry Point Validation Starting...', 'blue');
+
+    try {
+      const pkg = await this.validatePackageJson();
+
+      await this.validateBuildStructure();
+      await this.validateMainEntry(pkg);
+      await this.validateTypesEntry(pkg);
+      await this.validateBinEntries(pkg);
+      await this.validateExports(pkg);
+      await this.validateImportable(pkg);
+
+      const summary = this.printSummary();
+      await this.exportReport();
+
+      // Exit with error code if validation failed
+      if (!summary.success) {
+        process.exit(1);
+      }
+
+      this.log('\n✅ All entry points validated successfully!', 'green');
+
+    } catch (error) {
+      this.log(`\n❌ Fatal validation error: ${error.message}`, 'red');
+      console.error(error);
+      process.exit(1);
+    }
+  }
+}
+
+// Run validation
+const validator = new EntryPointValidator();
+validator.run().catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/scripts/validate-stage3-performance.ts

@@ -0,0 +1,377 @@
+#!/usr/bin/env tsx
+/**
+ * Stage 3 Performance Validation Script
+ * CLI tool to validate unified system performance targets
+ */
+
+import { performance } from 'perf_hooks';
+import { stage3Validator } from '../src/agents/stage3-integration-validator.js';
+
+interface CliOptions {
+  scenario?: string;
+  verbose?: boolean;
+  output?: 'console' | 'json' | 'csv';
+  timeout?: number;
+  help?: boolean;
+}
+
+class Stage3PerformanceCLI {
+  private options: CliOptions = {};
+
+  constructor() {
+    this.parseArguments();
+  }
+
+  private parseArguments(): void {
+    const args = process.argv.slice(2);
+    
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      
+      switch (arg) {
+        case '--help':
+        case '-h':
+          this.options.help = true;
+          break;
+          
+        case '--verbose':
+        case '-v':
+          this.options.verbose = true;
+          break;
+          
+        case '--scenario':
+        case '-s':
+          this.options.scenario = args[++i];
+          break;
+          
+        case '--output':
+        case '-o':
+          this.options.output = args[++i] as 'console' | 'json' | 'csv';
+          break;
+          
+        case '--timeout':
+        case '-t':
+          this.options.timeout = parseInt(args[++i], 10);
+          break;
+          
+        default:
+          console.warn(`Unknown option: ${arg}`);
+      }
+    }
+  }
+
+  private showHelp(): void {
+    console.log(`
+🎯 Stage 3 Performance Validation Tool
+
+Usage: tsx scripts/validate-stage3-performance.ts [options]
+
+Options:
+  -h, --help           Show this help message
+  -v, --verbose        Enable verbose output
+  -s, --scenario NAME  Run specific scenario only
+  -o, --output FORMAT  Output format: console, json, csv (default: console)
+  -t, --timeout MS     Set timeout in milliseconds (default: 300000)
+
+Scenarios:
+  - Baseline Performance       (100 agents, 500 messages, 200 tasks)
+  - High Concurrency          (1000 agents, 5000 messages, 2000 tasks)
+  - Peak Load                 (5000 agents, 25000 messages, 10000 tasks)
+  - Ultra High Load           (10000 agents, 50000 messages, 20000 tasks)
+  - Sustained Load            (2000 agents + 60s duration)
+  - Communication Intensive    (500 agents, 50000 messages)
+  - Task Execution Heavy      (1000 agents, 25000 tasks)
+
+Performance Targets:
+  ✅ Agent spawn time: <100ms P95
+  ✅ Communication latency: <5ms P95
+  ✅ Concurrent agents: Up to 10,000
+  ✅ Memory usage: <2GB peak
+  ✅ Success rate: >80%
+
+Examples:
+  tsx scripts/validate-stage3-performance.ts --verbose
+  tsx scripts/validate-stage3-performance.ts --scenario "High Concurrency"
+  tsx scripts/validate-stage3-performance.ts --output json > results.json
+    `);
+  }
+
+  async run(): Promise<void> {
+    if (this.options.help) {
+      this.showHelp();
+      return;
+    }
+
+    console.log('🚀 Starting Stage 3 Performance Validation');
+    console.log('==========================================');
+    
+    if (this.options.verbose) {
+      console.log('Configuration:');
+      console.log(`  Scenario filter: ${this.options.scenario || 'all'}`);
+      console.log(`  Output format: ${this.options.output || 'console'}`);
+      console.log(`  Timeout: ${this.options.timeout || 300000}ms`);
+      console.log('');
+    }
+
+    try {
+      const startTime = performance.now();
+      
+      if (this.options.scenario) {
+        await this.runSpecificScenario(this.options.scenario);
+      } else {
+        await this.runFullValidation();
+      }
+      
+      const totalTime = performance.now() - startTime;
+      
+      if (this.options.verbose) {
+        console.log(`\n⏱️  Total validation time: ${(totalTime / 1000).toFixed(2)}s`);
+      }
+      
+    } catch (error) {
+      console.error('❌ Validation failed:', error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }
+
+  private async runFullValidation(): Promise<void> {
+    const result = await stage3Validator.validateStage3();
+    
+    this.outputResults(result.results);
+    
+    if (result.passed) {
+      console.log('\n🎉 STAGE 3 VALIDATION: PASSED');
+      console.log('All performance targets met!');
+      process.exit(0);
+    } else {
+      console.log('\n❌ STAGE 3 VALIDATION: FAILED');
+      console.log('Some performance targets not met.');
+      process.exit(1);
+    }
+  }
+
+  private async runSpecificScenario(scenarioName: string): Promise<void> {
+    // Create a test scenario based on the name
+    const scenarios = {
+      'Baseline Performance': {
+        name: 'Baseline Performance',
+        description: 'Basic system functionality validation',
+        agentCount: 100,
+        messageCount: 500,
+        taskCount: 200,
+        targets: {
+          spawnTimeP95Ms: 80,
+          communicationP95Ms: 3,
+          concurrentAgents: 100,
+          memoryLimitMB: 200,
+          successRate: 0.95
+        }
+      },
+      'High Concurrency': {
+        name: 'High Concurrency',
+        description: 'Test system with 1000+ concurrent agents',
+        agentCount: 1000,
+        messageCount: 5000,
+        taskCount: 2000,
+        targets: {
+          spawnTimeP95Ms: 100,
+          communicationP95Ms: 5,
+          concurrentAgents: 1000,
+          memoryLimitMB: 500,
+          successRate: 0.90
+        }
+      },
+      'Peak Load': {
+        name: 'Peak Load',
+        description: 'Maximum system capacity test',
+        agentCount: 5000,
+        messageCount: 25000,
+        taskCount: 10000,
+        targets: {
+          spawnTimeP95Ms: 150,
+          communicationP95Ms: 8,
+          concurrentAgents: 5000,
+          memoryLimitMB: 1000,
+          successRate: 0.85
+        }
+      },
+      'Ultra High Load': {
+        name: 'Ultra High Load',
+        description: 'Stress test with 10k+ agents',
+        agentCount: 10000,
+        messageCount: 50000,
+        taskCount: 20000,
+        targets: {
+          spawnTimeP95Ms: 200,
+          communicationP95Ms: 10,
+          concurrentAgents: 10000,
+          memoryLimitMB: 2000,
+          successRate: 0.80
+        }
+      }
+    };
+
+    const scenario = scenarios[scenarioName as keyof typeof scenarios];
+    if (!scenario) {
+      console.error(`❌ Unknown scenario: ${scenarioName}`);
+      console.log('Available scenarios:', Object.keys(scenarios).join(', '));
+      process.exit(1);
+    }
+
+    console.log(`🎯 Running scenario: ${scenario.name}`);
+    console.log(`📝 ${scenario.description}`);
+    console.log(`📊 ${scenario.agentCount} agents, ${scenario.messageCount} messages, ${scenario.taskCount} tasks\n`);
+
+    // Initialize validator and run scenario
+    const validator = stage3Validator;
+    await (validator as any).agentManager.initialize();
+    
+    try {
+      const result = await (validator as any).executeValidationScenario(scenario);
+      this.outputResults([result]);
+      
+      if (result.passed) {
+        console.log(`\n✅ Scenario "${scenarioName}": PASSED`);
+        process.exit(0);
+      } else {
+        console.log(`\n❌ Scenario "${scenarioName}": FAILED`);
+        process.exit(1);
+      }
+    } finally {
+      await (validator as any).agentManager.shutdown();
+    }
+  }
+
+  private outputResults(results: any[]): void {
+    switch (this.options.output) {
+      case 'json':
+        this.outputJSON(results);
+        break;
+      case 'csv':
+        this.outputCSV(results);
+        break;
+      default:
+        this.outputConsole(results);
+    }
+  }
+
+  private outputConsole(results: any[]): void {
+    console.log('\n📊 Performance Validation Results');
+    console.log('================================');
+    
+    results.forEach((result, index) => {
+      const status = result.passed ? '✅ PASS' : '❌ FAIL';
+      const statusIcon = result.passed ? '🟢' : '🔴';
+      
+      console.log(`\n${statusIcon} ${index + 1}. ${result.scenario}: ${status}`);
+      
+      if (this.options.verbose) {
+        console.log(`   Description: ${result.scenario}`);
+        console.log(`   Duration: ${(result.details.totalTime / 1000).toFixed(2)}s`);
+      }
+      
+      // Performance metrics
+      console.log(`   📈 Performance Metrics:`);
+      console.log(`      Spawn Time P95: ${result.metrics.spawnTimeP95.toFixed(2)}ms`);
+      console.log(`      Communication P95: ${result.metrics.communicationP95.toFixed(2)}ms`);
+      console.log(`      Concurrent Agents: ${result.metrics.concurrentAgents.toLocaleString()}`);
+      console.log(`      Memory Usage: ${result.metrics.memoryUsage.toFixed(2)}MB`);
+      console.log(`      Success Rate: ${(result.metrics.successRate * 100).toFixed(1)}%`);
+      console.log(`      Throughput: ${result.metrics.throughput.toFixed(0)} ops/sec`);
+      
+      // Operation details
+      if (this.options.verbose) {
+        console.log(`   🔧 Operation Details:`);
+        console.log(`      Agents Spawned: ${result.details.agentsSpawned.toLocaleString()}`);
+        console.log(`      Messages Sent: ${result.details.messagesSent.toLocaleString()}`);
+        console.log(`      Tasks Executed: ${result.details.tasksExecuted.toLocaleString()}`);
+        console.log(`      Errors: ${result.details.errors}`);
+      }
+    });
+    
+    // Summary
+    const passedCount = results.filter(r => r.passed).length;
+    const totalCount = results.length;
+    const overallSuccessRate = (passedCount / totalCount) * 100;
+    
+    console.log('\n📋 Summary');
+    console.log('==========');
+    console.log(`Overall Result: ${passedCount}/${totalCount} scenarios passed`);
+    console.log(`Success Rate: ${overallSuccessRate.toFixed(1)}%`);
+    
+    if (passedCount === totalCount) {
+      console.log('🎉 All performance targets met!');
+    } else {
+      console.log('⚠️  Some performance targets not met.');
+    }
+  }
+
+  private outputJSON(results: any[]): void {
+    const output = {
+      timestamp: new Date().toISOString(),
+      validation: 'Stage 3 Performance',
+      summary: {
+        total: results.length,
+        passed: results.filter(r => r.passed).length,
+        failed: results.filter(r => !r.passed).length,
+        successRate: (results.filter(r => r.passed).length / results.length) * 100
+      },
+      results
+    };
+    
+    console.log(JSON.stringify(output, null, 2));
+  }
+
+  private outputCSV(results: any[]): void {
+    // CSV header
+    const headers = [
+      'Scenario',
+      'Status',
+      'Spawn Time P95 (ms)',
+      'Communication P95 (ms)',
+      'Concurrent Agents',
+      'Memory Usage (MB)',
+      'Success Rate (%)',
+      'Throughput (ops/sec)',
+      'Total Time (s)',
+      'Agents Spawned',
+      'Messages Sent',
+      'Tasks Executed',
+      'Errors'
+    ];
+    
+    console.log(headers.join(','));
+    
+    // CSV data
+    results.forEach(result => {
+      const row = [
+        `"${result.scenario}"`,
+        result.passed ? 'PASS' : 'FAIL',
+        result.metrics.spawnTimeP95.toFixed(2),
+        result.metrics.communicationP95.toFixed(2),
+        result.metrics.concurrentAgents,
+        result.metrics.memoryUsage.toFixed(2),
+        (result.metrics.successRate * 100).toFixed(1),
+        result.metrics.throughput.toFixed(0),
+        (result.details.totalTime / 1000).toFixed(2),
+        result.details.agentsSpawned,
+        result.details.messagesSent,
+        result.details.tasksExecuted,
+        result.details.errors
+      ];
+      
+      console.log(row.join(','));
+    });
+  }
+}
+
+// Run CLI if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const cli = new Stage3PerformanceCLI();
+  cli.run().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+  });
+}
+
+export { Stage3PerformanceCLI };