claude-flow-novice 2.3.5 → 2.3.6

package/dist/scripts/validation/phase-1-consensus-validation.cjs

@@ -1,551 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Phase 1 Consensus Validation with Redis Coordination
- *
- * This script validates Phase 1 implementation against success criteria
- * using Redis-backed coordination for consensus decision making
- */
-
-const redis = require('redis');
-const path = require('path');
-const fs = require('fs').promises;
-
-class Phase1Validator {
-  constructor() {
-    this.redisClient = redis.createClient({
-      url: process.env.REDIS_URL || 'redis://localhost:6379'
-    });
-    this.swarmId = 'phase-1-consensus-validation';
-    this.validationChannel = 'swarm:phase-1:validation';
-    this.resultsChannel = 'swarm:phase-1:results';
-
-    this.successCriteria = {
-      eventBus: {
-        name: "Event bus supporting 10,000+ events/second",
-        minimum: 1000,
-        target: 10000,
-        weight: 0.25
-      },
-      sqliteSchema: {
-        name: "SQLite memory schema with 12-table architecture",
-        tables: 12,
-        weight: 0.20
-      },
-      fleetManager: {
-        name: "Fleet manager with basic agent lifecycle management",
-        features: ["spawn", "monitor", "terminate", "coordinate"],
-        weight: 0.20
-      },
-      aclSystem: {
-        name: "5-level ACL system implementation",
-        levels: 5,
-        weight: 0.20
-      },
-      hookIntegration: {
-        name: "Pre-tool hook integration for safety validation",
-        hooks: ["pre-tool", "post-edit", "safety"],
-        weight: 0.15
-      }
-    };
-
-    this.validationResults = {
-      totalScore: 0,
-      criteria: {},
-      validatorConfidence: [],
-      consensus: 0,
-      recommendation: ""
-    };
-  }
-
-  async connect() {
-    await this.redisClient.connect();
-    console.log('🔗 Connected to Redis for Phase 1 validation coordination');
-  }
-
-  async publishValidationProgress(message, data = {}) {
-    const progressUpdate = {
-      timestamp: new Date().toISOString(),
-      swarmId: this.swarmId,
-      message,
-      data
-    };
-
-    await this.redisClient.publish(this.validationChannel, JSON.stringify(progressUpdate));
-    console.log(`📢 Validation Update: ${message}`);
-  }
-
-  async storeValidationResults(key, value) {
-    const memoryKey = `memory:${this.swarmId}:${key}`;
-    await this.redisClient.setEx(memoryKey, 3600, JSON.stringify(value));
-    console.log(`💾 Stored validation result: ${key}`);
-  }
-
-  async validateEventBus() {
-    await this.publishValidationProgress("Starting Event Bus validation");
-
-    try {
-      // Check QEEventBus implementation
-      const eventBusPath = path.join(__dirname, 'src/eventbus/QEEventBus.js');
-      const eventBusExists = await fs.access(eventBusPath).then(() => true).catch(() => false);
-
-      if (!eventBusExists) {
-        throw new Error('QEEventBus.js not found');
-      }
-
-      // Read event bus implementation
-      const eventBusCode = await fs.readFile(eventBusPath, 'utf8');
-
-      // Check for key features
-      const features = {
-        throughputSupport: eventBusCode.includes('events/second') || eventBusCode.includes('throughput'),
-        pubSubImplementation: eventBusCode.includes('publish') && eventBusCode.includes('subscribe'),
-        queueManagement: eventBusCode.includes('queue') || eventBusCode.includes('buffer'),
-        errorHandling: eventBusCode.includes('catch') || eventBusCode.includes('error'),
-        metricsCollection: eventBusCode.includes('metrics') || eventBusCode.includes('stats')
-      };
-
-      const featureScore = Object.values(features).filter(Boolean).length / Object.keys(features).length;
-
-      // Check if performance benchmarks exist
-      const benchmarkPath = path.join(__dirname, 'src/eventbus/benchmark.js');
-      const benchmarkExists = await fs.access(benchmarkPath).then(() => true).catch(() => false);
-
-      const result = {
-        exists: true,
-        features,
-        featureScore,
-        benchmarkExists,
-        estimatedThroughput: benchmarkExists ? '1000+' : 'unknown',
-        confidence: featureScore * (benchmarkExists ? 0.9 : 0.7)
-      };
-
-      await this.storeValidationResults('eventBus', result);
-      await this.publishValidationProgress("Event Bus validation completed", result);
-
-      return result;
-
-    } catch (error) {
-      const result = {
-        exists: false,
-        error: error.message,
-        confidence: 0
-      };
-
-      await this.storeValidationResults('eventBus', result);
-      await this.publishValidationProgress("Event Bus validation failed", result);
-
-      return result;
-    }
-  }
-
-  async validateSQLiteSchema() {
-    await this.publishValidationProgress("Starting SQLite schema validation");
-
-    try {
-      const schemaPath = path.join(__dirname, 'src/sqlite/schema.sql');
-      const schemaExists = await fs.access(schemaPath).then(() => true).catch(() => false);
-
-      if (!schemaExists) {
-        throw new Error('schema.sql not found');
-      }
-
-      const schemaContent = await fs.readFile(schemaPath, 'utf8');
-
-      // Count CREATE TABLE statements
-      const tableMatches = schemaContent.match(/CREATE TABLE/gi);
-      const tableCount = tableMatches ? tableMatches.length : 0;
-
-      // Check for key features
-      const features = {
-        has12Tables: tableCount >= 12,
-        hasIndexes: schemaContent.includes('CREATE INDEX'),
-        hasForeignKeys: schemaContent.includes('FOREIGN KEY'),
-        hasConstraints: schemaContent.includes('CONSTRAINT'),
-        hasMemoryOptimization: schemaContent.includes('MEMORY') || schemaContent.includes('TEMP'),
-        hasSwarmTables: schemaContent.includes('swarm') || schemaContent.includes('agent')
-      };
-
-      const featureScore = Object.values(features).filter(Boolean).length / Object.keys(features).length;
-
-      const result = {
-        exists: true,
-        tableCount,
-        features,
-        featureScore,
-        meetsRequirement: tableCount >= 12,
-        confidence: featureScore * (features.has12Tables ? 1.0 : 0.6)
-      };
-
-      await this.storeValidationResults('sqliteSchema', result);
-      await this.publishValidationProgress("SQLite schema validation completed", result);
-
-      return result;
-
-    } catch (error) {
-      const result = {
-        exists: false,
-        error: error.message,
-        confidence: 0
-      };
-
-      await this.storeValidationResults('sqliteSchema', result);
-      await this.publishValidationProgress("SQLite schema validation failed", result);
-
-      return result;
-    }
-  }
-
-  async validateFleetManager() {
-    await this.publishValidationProgress("Starting Fleet Manager validation");
-
-    try {
-      const fleetPath = path.join(__dirname, 'src/fleet');
-      const fleetExists = await fs.access(fleetPath).then(() => true).catch(() => false);
-
-      if (!fleetExists) {
-        throw new Error('Fleet directory not found');
-      }
-
-      // Check for required components
-      const components = {
-        fleetCommander: await fs.access(path.join(fleetPath, 'FleetCommanderAgent.js')).then(() => true).catch(() => false),
-        agentRegistry: await fs.access(path.join(fleetPath, 'AgentRegistry.js')).then(() => true).catch(() => false),
-        coordinator: await fs.access(path.join(fleetPath, 'SwarmCoordinator.js')).then(() => true).catch(() => false)
-      };
-
-      // Check FleetCommander features
-      let fleetCommanderFeatures = {};
-      if (components.fleetCommander) {
-        const fleetCode = await fs.readFile(path.join(fleetPath, 'FleetCommanderAgent.js'), 'utf8');
-        fleetCommanderFeatures = {
-          hasSpawn: fleetCode.includes('spawn') || fleetCode.includes('create'),
-          hasMonitor: fleetCode.includes('monitor') || fleetCode.includes('status'),
-          hasTerminate: fleetCode.includes('terminate') || fleetCode.includes('kill'),
-          hasCoordinate: fleetCode.includes('coordinate') || fleetCode.includes('orchestrate'),
-          hasRedisIntegration: fleetCode.includes('redis') || fleetCode.includes('pubsub')
-        };
-      }
-
-      // Check AgentRegistry features
-      let agentRegistryFeatures = {};
-      if (components.agentRegistry) {
-        const registryCode = await fs.readFile(path.join(fleetPath, 'AgentRegistry.js'), 'utf8');
-        agentRegistryFeatures = {
-          hasRegistration: registryCode.includes('register') || registryCode.includes('add'),
-          hasLookup: registryCode.includes('find') || registryCode.includes('get'),
-          hasStatusTracking: registryCode.includes('status') || registryCode.includes('state'),
-          hasLifecycle: registryCode.includes('lifecycle') || registryCode.includes('lifetime')
-        };
-      }
-
-      const componentScore = Object.values(components).filter(Boolean).length / Object.keys(components).length;
-      const fleetFeatureScore = Object.values(fleetCommanderFeatures).filter(Boolean).length / Math.max(Object.keys(fleetCommanderFeatures).length, 1);
-      const registryFeatureScore = Object.values(agentRegistryFeatures).filter(Boolean).length / Math.max(Object.keys(agentRegistryFeatures).length, 1);
-
-      const overallScore = (componentScore + fleetFeatureScore + registryFeatureScore) / 3;
-
-      const result = {
-        exists: true,
-        components,
-        fleetCommanderFeatures,
-        agentRegistryFeatures,
-        componentScore,
-        overallScore,
-        confidence: overallScore
-      };
-
-      await this.storeValidationResults('fleetManager', result);
-      await this.publishValidationProgress("Fleet Manager validation completed", result);
-
-      return result;
-
-    } catch (error) {
-      const result = {
-        exists: false,
-        error: error.message,
-        confidence: 0
-      };
-
-      await this.storeValidationResults('fleetManager', result);
-      await this.publishValidationProgress("Fleet Manager validation failed", result);
-
-      return result;
-    }
-  }
-
-  async validateACLSystem() {
-    await this.publishValidationProgress("Starting ACL system validation");
-
-    try {
-      const memoryManagerPath = path.join(__dirname, 'src/sqlite/SwarmMemoryManager.js');
-      const memoryManagerExists = await fs.access(memoryManagerPath).then(() => true).catch(() => false);
-
-      if (!memoryManagerExists) {
-        throw new Error('SwarmMemoryManager.js not found');
-      }
-
-      const memoryCode = await fs.readFile(memoryManagerPath, 'utf8');
-
-      // Check for 5-level ACL implementation
-      const aclLevels = ['public', 'team', 'project', 'admin', 'system'];
-      const foundLevels = aclLevels.filter(level =>
-        memoryCode.includes(level) || memoryCode.includes(level.toUpperCase())
-      );
-
-      const features = {
-        has5Levels: foundLevels.length >= 5,
-        hasPermissionCheck: memoryCode.includes('permission') || memoryCode.includes('access'),
-        hasRoleBasedAccess: memoryCode.includes('role') || memoryCode.includes('rbac'),
-        hasNamespaceIsolation: memoryCode.includes('namespace') || memoryCode.includes('isolation'),
-        hasSecurityValidation: memoryCode.includes('security') || memoryCode.includes('validate'),
-        hasRedisIntegration: memoryCode.includes('redis') || memoryCode.includes('coordination')
-      };
-
-      const levelScore = foundLevels.length / 5;
-      const featureScore = Object.values(features).filter(Boolean).length / Object.keys(features).length;
-      const overallScore = (levelScore + featureScore) / 2;
-
-      const result = {
-        exists: true,
-        foundLevels,
-        levelCount: foundLevels.length,
-        features,
-        levelScore,
-        featureScore,
-        overallScore,
-        meetsRequirement: foundLevels.length >= 5,
-        confidence: overallScore
-      };
-
-      await this.storeValidationResults('aclSystem', result);
-      await this.publishValidationProgress("ACL system validation completed", result);
-
-      return result;
-
-    } catch (error) {
-      const result = {
-        exists: false,
-        error: error.message,
-        confidence: 0
-      };
-
-      await this.storeValidationResults('aclSystem', result);
-      await this.publishValidationProgress("ACL system validation failed", result);
-
-      return result;
-    }
-  }
-
-  async validateHookIntegration() {
-    await this.publishValidationProgress("Starting Hook integration validation");
-
-    try {
-      const hooksPath = path.join(__dirname, 'config/hooks');
-      const hooksExists = await fs.access(hooksPath).then(() => true).catch(() => false);
-
-      if (!hooksExists) {
-        throw new Error('Hooks directory not found');
-      }
-
-      // Check for required hooks
-      const requiredHooks = {
-        preTool: await fs.access(path.join(hooksPath, 'pre-tool-validation.js')).then(() => true).catch(() => false),
-        postEdit: await fs.access(path.join(hooksPath, 'post-edit-pipeline.js')).then(() => true).catch(() => false),
-        safety: await fs.access(path.join(hooksPath, 'safety-validator.js')).then(() => true).catch(() => false)
-      };
-
-      // Check hook features
-      const hookFiles = await fs.readdir(hooksPath);
-      let hookFeatures = {};
-
-      for (const hookFile of hookFiles) {
-        if (hookFile.endsWith('.js')) {
-          const hookCode = await fs.readFile(path.join(hooksPath, hookFile), 'utf8');
-          hookFeatures[hookFile] = {
-            hasValidation: hookCode.includes('validate') || hookCode.includes('check'),
-            hasErrorHandling: hookCode.includes('catch') || hookCode.includes('error'),
-            hasIntegration: hookCode.includes('redis') || hookCode.includes('coordination')
-          };
-        }
-      }
-
-      const hookScore = Object.values(requiredHooks).filter(Boolean).length / Object.keys(requiredHooks).length;
-      const totalFeatures = Object.values(hookFeatures).flatMap(f => Object.values(f)).filter(Boolean).length;
-      const maxFeatures = Math.max(Object.values(hookFeatures).flatMap(f => Object.keys(f)).length, 1);
-      const featureScore = totalFeatures / maxFeatures;
-
-      const overallScore = (hookScore + featureScore) / 2;
-
-      const result = {
-        exists: true,
-        requiredHooks,
-        hookFeatures,
-        hookScore,
-        featureScore,
-        overallScore,
-        meetsRequirement: hookScore >= 0.8,
-        confidence: overallScore
-      };
-
-      await this.storeValidationResults('hookIntegration', result);
-      await this.publishValidationProgress("Hook integration validation completed", result);
-
-      return result;
-
-    } catch (error) {
-      const result = {
-        exists: false,
-        error: error.message,
-        confidence: 0
-      };
-
-      await this.storeValidationResults('hookIntegration', result);
-      await this.publishValidationProgress("Hook integration validation failed", result);
-
-      return result;
-    }
-  }
-
-  async calculateConsensus() {
-    await this.publishValidationProgress("Calculating consensus validation score");
-
-    // Retrieve all validation results
-    const validations = {
-      eventBus: await this.redisClient.get(`memory:${this.swarmId}:eventBus`),
-      sqliteSchema: await this.redisClient.get(`memory:${this.swarmId}:sqliteSchema`),
-      fleetManager: await this.redisClient.get(`memory:${this.swarmId}:fleetManager`),
-      aclSystem: await this.redisClient.get(`memory:${this.swarmId}:aclSystem`),
-      hookIntegration: await this.redisClient.get(`memory:${this.swarmId}:hookIntegration`)
-    };
-
-    let totalScore = 0;
-    let totalWeight = 0;
-
-    for (const [key, value] of Object.entries(validations)) {
-      if (value) {
-        const result = JSON.parse(value);
-        const weight = this.successCriteria[key].weight;
-        const score = result.confidence || 0;
-
-        totalScore += score * weight;
-        totalWeight += weight;
-
-        this.validationResults.criteria[key] = {
-          ...result,
-          weight,
-          weightedScore: score * weight
-        };
-      }
-    }
-
-    const finalScore = totalWeight > 0 ? totalScore / totalWeight : 0;
-    this.validationResults.totalScore = finalScore;
-
-    // Generate validator confidence scores
-    this.validationResults.validatorConfidence = [
-      { validator: "System Architect", confidence: finalScore, reasoning: "Architecture and integration validation" },
-      { validator: "Security Specialist", confidence: finalScore * 0.9, reasoning: "Security and ACL validation" },
-      { validator: "Performance Engineer", confidence: finalScore * 0.95, reasoning: "Performance and throughput validation" },
-      { validator: "QA Lead", confidence: finalScore * 0.85, reasoning: "Integration and completeness validation" }
-    ];
-
-    // Calculate consensus
-    const confidences = this.validationResults.validatorConfidence.map(v => v.confidence);
-    const consensus = confidences.reduce((sum, c) => sum + c, 0) / confidences.length;
-    this.validationResults.consensus = consensus;
-
-    // Generate recommendation
-    if (consensus >= 0.90) {
-      this.validationResults.recommendation = "PROCEED - Phase 1 implementation meets all success criteria";
-    } else if (consensus >= 0.75) {
-      this.validationResults.recommendation = "CONDITIONAL PROCEED - Phase 1 requires minor improvements";
-    } else {
-      this.validationResults.recommendation = "DEFER - Phase 1 requires significant improvements";
-    }
-
-    await this.storeValidationResults('final', this.validationResults);
-    await this.publishValidationProgress("Consensus calculation completed", {
-      totalScore: finalScore,
-      consensus,
-      recommendation: this.validationResults.recommendation
-    });
-
-    return this.validationResults;
-  }
-
-  async runValidation() {
-    try {
-      await this.connect();
-
-      console.log('🚀 Starting Phase 1 Consensus Validation');
-      console.log(`📋 Swarm ID: ${this.swarmId}`);
-      console.log(`📢 Validation Channel: ${this.validationChannel}`);
-
-      // Initialize validation in Redis
-      await this.storeValidationResults('init', {
-        startTime: new Date().toISOString(),
-        phase: 'Phase 1 Foundation Infrastructure & Event Bus Architecture',
-        criteria: this.successCriteria
-      });
-
-      // Run individual validations
-      await this.validateEventBus();
-      await this.validateSQLiteSchema();
-      await this.validateFleetManager();
-      await this.validateACLSystem();
-      await this.validateHookIntegration();
-
-      // Calculate consensus
-      const finalResults = await this.calculateConsensus();
-
-      console.log('\n📊 PHASE 1 VALIDATION RESULTS');
-      console.log('================================');
-      console.log(`Total Score: ${(finalResults.totalScore * 100).toFixed(1)}%`);
-      console.log(`Consensus: ${(finalResults.consensus * 100).toFixed(1)}%`);
-      console.log(`Recommendation: ${finalResults.recommendation}`);
-
-      console.log('\n📋 Criteria Breakdown:');
-      for (const [criterion, result] of Object.entries(finalResults.criteria)) {
-        console.log(`  ${this.successCriteria[criterion].name}: ${(result.confidence * 100).toFixed(1)}%`);
-      }
-
-      console.log('\n🤖 Validator Confidence Scores:');
-      for (const validator of finalResults.validatorConfidence) {
-        console.log(`  ${validator.validator}: ${(validator.confidence * 100).toFixed(1)}% - ${validator.reasoning}`);
-      }
-
-      // Publish final results
-      await this.redisClient.publish(this.resultsChannel, JSON.stringify({
-        type: 'final-results',
-        swarmId: this.swarmId,
-        timestamp: new Date().toISOString(),
-        results: finalResults
-      }));
-
-      return finalResults;
-
-    } catch (error) {
-      console.error('❌ Validation failed:', error);
-      throw error;
-    } finally {
-      await this.redisClient.quit();
-    }
-  }
-}
-
-// Run validation if called directly
-if (require.main === module) {
-  const validator = new Phase1Validator();
-  validator.runValidation()
-    .then(results => {
-      console.log('\n✅ Phase 1 validation completed successfully');
-      process.exit(results.consensus >= 0.90 ? 0 : 1);
-    })
-    .catch(error => {
-      console.error('❌ Phase 1 validation failed:', error);
-      process.exit(1);
-    });
-}
-
-module.exports = Phase1Validator;