claude-flow-novice 1.2.1 → 1.3.0

package/config/consensus/quorum.config.js

@@ -0,0 +1,400 @@
+/**
+ * Quorum Configuration for Verification Consensus
+ *
+ * Configuration settings for Byzantine fault-tolerant quorum management
+ * and verification consensus protocols.
+ */
+
+module.exports = {
+  // Core quorum settings
+  quorum: {
+    minSize: 3,
+    maxSize: 21,
+    defaultSize: 5,
+
+    // Byzantine fault tolerance configuration
+    byzantineFaultTolerance: {
+      enabled: true,
+      maxByzantineNodesFormula: '(n-1)/3', // Standard BFT formula
+      requiredMajority: 0.67, // 2/3 majority for BFT
+      detectionEnabled: true,
+      recoveryEnabled: true
+    },
+
+    // Dynamic scaling settings
+    scaling: {
+      enabled: true,
+      autoScaling: true,
+      scaleUpThreshold: 0.8, // Scale up when 80% capacity
+      scaleDownThreshold: 0.3, // Scale down when 30% capacity
+      maxScaleUpNodes: 5, // Maximum nodes to add at once
+      maxScaleDownNodes: 2, // Maximum nodes to remove at once
+      cooldownPeriod: 60000, // 1 minute between scaling operations
+
+      // Scaling strategies
+      strategies: {
+        performance: {
+          enabled: true,
+          latencyThreshold: 3000, // Scale if latency > 3s
+          throughputThreshold: 100 // Scale if TPS < 100
+        },
+        network: {
+          enabled: true,
+          partitionRiskThreshold: 0.3,
+          connectivityThreshold: 0.8
+        },
+        faultTolerance: {
+          enabled: true,
+          minToleranceLevel: 1,
+          adaptiveAdjustment: true
+        }
+      }
+    },
+
+    // Node selection criteria
+    nodeSelection: {
+      // Reliability requirements
+      reliability: {
+        minUptimePercent: 95,
+        maxFailuresPerHour: 2,
+        minResponseTime: 1000, // ms
+        historicalWindowHours: 24
+      },
+
+      // Performance requirements
+      performance: {
+        minCpuCores: 2,
+        minMemoryMB: 4096,
+        minBandwidthMbps: 100,
+        maxLatencyMs: 500
+      },
+
+      // Geographic distribution
+      geographic: {
+        enableDistribution: true,
+        minRegions: 2,
+        maxNodesPerRegion: 10,
+        diversityWeight: 0.2
+      },
+
+      // Security requirements
+      security: {
+        requireTLS: true,
+        requireAuthentication: true,
+        requireDigitalSignatures: true,
+        certificateValidation: true
+      }
+    }
+  },
+
+  // Voting system configuration
+  voting: {
+    // Default voting settings
+    defaults: {
+      votingMethod: 'BYZANTINE_AGREEMENT',
+      requiredMajority: 0.67,
+      timeout: 30000, // 30 seconds
+      allowAbstention: true,
+      requireUnanimity: false,
+      maxRetries: 3
+    },
+
+    // Vote validation
+    validation: {
+      requireDigitalSignatures: true,
+      signatureAlgorithm: 'ECDSA',
+      hashAlgorithm: 'SHA-256',
+      timestampTolerance: 30000, // 30 second tolerance
+
+      // Byzantine detection
+      byzantineDetection: {
+        enabled: true,
+        doubleVotingCheck: true,
+        signatureValidation: true,
+        timingAnomalyDetection: true,
+        behaviorAnalysis: true,
+        suspiciousPatternThreshold: 3
+      }
+    },
+
+    // Vote aggregation
+    aggregation: {
+      weightingEnabled: true,
+      nodeWeightCalculation: 'PERFORMANCE_BASED', // or 'STAKE_BASED', 'EQUAL'
+      consensusStrengthCalculation: true,
+      marginalVictoryThreshold: 0.1 // 10% margin for clear victory
+    }
+  },
+
+  // Network monitoring configuration
+  network: {
+    monitoring: {
+      enabled: true,
+      interval: 5000, // 5 seconds
+      metrics: [
+        'latency',
+        'bandwidth',
+        'packet_loss',
+        'jitter',
+        'connectivity'
+      ]
+    },
+
+    // Network conditions thresholds
+    thresholds: {
+      latency: {
+        good: 100, // ms
+        warning: 500,
+        critical: 1000
+      },
+      packetLoss: {
+        good: 0.001, // 0.1%
+        warning: 0.01, // 1%
+        critical: 0.05 // 5%
+      },
+      bandwidth: {
+        minimum: 10, // Mbps
+        recommended: 100,
+        optimal: 1000
+      }
+    },
+
+    // Partition detection and recovery
+    partitionDetection: {
+      enabled: true,
+      detectionTimeout: 10000, // 10 seconds
+      recoveryTimeout: 60000, // 1 minute
+      maxPartitionDuration: 300000, // 5 minutes
+      autoRecovery: true
+    }
+  },
+
+  // Performance settings
+  performance: {
+    // Consensus performance targets
+    targets: {
+      maxConsensusLatency: 5000, // 5 seconds
+      minThroughput: 100, // transactions per second
+      maxResourceUsage: {
+        cpu: 0.8, // 80%
+        memory: 0.9, // 90%
+        network: 0.7 // 70%
+      }
+    },
+
+    // Performance optimization
+    optimization: {
+      enabled: true,
+      autoTuning: true,
+      metrics: [
+        'consensus_latency',
+        'throughput',
+        'resource_usage',
+        'queue_length'
+      ]
+    },
+
+    // Load balancing
+    loadBalancing: {
+      enabled: true,
+      algorithm: 'WEIGHTED_ROUND_ROBIN', // or 'LEAST_CONNECTIONS', 'CONSISTENT_HASH'
+      rebalancingInterval: 30000, // 30 seconds
+      maxLoadImbalance: 0.3 // 30% imbalance threshold
+    }
+  },
+
+  // Security configuration
+  security: {
+    // Cryptographic settings
+    cryptography: {
+      hashAlgorithm: 'SHA-256',
+      signatureScheme: 'ECDSA',
+      keyLength: 256,
+      saltLength: 32
+    },
+
+    // Authentication and authorization
+    authentication: {
+      methods: ['DIGITAL_SIGNATURES', 'CERTIFICATES'],
+      certificateValidation: true,
+      certificateRevocation: true,
+      sessionTimeout: 3600000 // 1 hour
+    },
+
+    // Communication security
+    communication: {
+      encryption: 'TLS_1_3',
+      mutualAuthentication: true,
+      certificatePinning: true,
+      endToEndEncryption: true
+    },
+
+    // Audit and logging
+    audit: {
+      enabled: true,
+      logLevel: 'INFO',
+      logRotation: true,
+      maxLogSize: '100MB',
+      retentionDays: 90,
+
+      // Audit events
+      events: [
+        'quorum_establishment',
+        'voting_start',
+        'voting_end',
+        'byzantine_detection',
+        'scaling_operation',
+        'network_partition'
+      ]
+    }
+  },
+
+  // Specification validation
+  validation: {
+    // Compliance rules
+    compliance: {
+      strictMode: true,
+      failOnViolation: true,
+      warningThreshold: 5,
+
+      // Required specifications
+      requiredSpecs: [
+        'consensus_algorithm',
+        'byzantine_fault_tolerance',
+        'performance_requirements',
+        'security_requirements'
+      ]
+    },
+
+    // Validation intervals
+    intervals: {
+      continuous: true,
+      periodicValidation: 3600000, // 1 hour
+      onDemandValidation: true,
+      preChangeValidation: true
+    },
+
+    // Test scenarios
+    testing: {
+      enabled: true,
+      scenarios: [
+        'single_byzantine_node',
+        'multiple_byzantine_nodes',
+        'network_partition',
+        'high_latency',
+        'node_failures',
+        'scaling_stress_test'
+      ],
+
+      // Test execution
+      execution: {
+        concurrent: true,
+        timeout: 300000, // 5 minutes per test
+        retries: 2,
+        reportGeneration: true
+      }
+    }
+  },
+
+  // Hooks configuration
+  hooks: {
+    enabled: true,
+
+    // Pre-task hooks
+    preTask: {
+      enabled: true,
+      timeout: 5000,
+      actions: [
+        'session_restore',
+        'resource_preparation',
+        'context_loading'
+      ]
+    },
+
+    // Post-edit hooks
+    postEdit: {
+      enabled: true,
+      timeout: 3000,
+      actions: [
+        'memory_store',
+        'metrics_update',
+        'pattern_training'
+      ]
+    },
+
+    // Post-task hooks
+    postTask: {
+      enabled: true,
+      timeout: 10000,
+      actions: [
+        'result_storage',
+        'metrics_export',
+        'history_update',
+        'session_cleanup'
+      ]
+    },
+
+    // Session management
+    sessions: {
+      enabled: true,
+      persistence: true,
+      compression: true,
+      encryption: true,
+      maxSessionAge: 86400000 // 24 hours
+    }
+  },
+
+  // Development and testing settings
+  development: {
+    debugging: {
+      enabled: process.env.NODE_ENV !== 'production',
+      verbose: false,
+      tracing: false,
+      profiling: false
+    },
+
+    // Simulation settings
+    simulation: {
+      enabled: process.env.NODE_ENV === 'development',
+      networkLatencyRange: [50, 500], // ms
+      nodeFailureRate: 0.05, // 5%
+      byzantineNodeRate: 0.1, // 10%
+      partitionProbability: 0.02 // 2%
+    },
+
+    // Mock data
+    mocking: {
+      enabled: process.env.NODE_ENV === 'test',
+      mockNetworkConditions: true,
+      mockNodeMetrics: true,
+      mockVotingBehavior: true,
+      deterministicRandom: true
+    }
+  },
+
+  // Integration settings
+  integration: {
+    // MCP tool integration
+    mcp: {
+      enabled: true,
+      coordinationEnabled: true,
+      memoryIntegration: true,
+      neuralIntegration: true
+    },
+
+    // External systems
+    external: {
+      monitoring: {
+        enabled: false,
+        endpoints: [],
+        authentication: null
+      },
+
+      alerting: {
+        enabled: false,
+        webhooks: [],
+        emailNotifications: false
+      }
+    }
+  }
+};

package/config/gossip/gossip-config.js

@@ -0,0 +1,311 @@
+/**
+ * Gossip Protocol Configuration
+ * Configuration templates for different network topologies and use cases
+ */
+
+const gossipConfigurations = {
+  // Development configuration - fast intervals for testing
+  development: {
+    gossip: {
+      gossipInterval: 500,          // 500ms gossip rounds
+      fanout: 2,                    // Contact 2 peers per round
+      rumorLifetime: 10000,         // 10 second rumor lifetime
+      antiEntropyInterval: 2000,    // 2 second anti-entropy
+      maxRetransmissions: 2
+    },
+    verification: {
+      taskTimeout: 5000,            // 5 second task timeout
+      consensusThreshold: 0.6,      // 60% consensus required
+      maxConcurrentTasks: 5,
+      retryAttempts: 2
+    },
+    monitoring: {
+      monitoringInterval: 1000,     // 1 second monitoring
+      alertThresholds: {
+        memory: 70,
+        cpu: 70,
+        network: 80,
+        agents: 50
+      },
+      alertCooldown: 5000,          // 5 second cooldown
+      historySize: 50
+    },
+    consensus: {
+      validationTimeout: 3000,      // 3 second validation timeout
+      consensusThreshold: 0.6,
+      heartbeatInterval: 2000
+    }
+  },
+
+  // Production configuration - balanced for reliability and performance
+  production: {
+    gossip: {
+      gossipInterval: 1000,         // 1 second gossip rounds
+      fanout: 3,                    // Contact 3 peers per round
+      rumorLifetime: 30000,         // 30 second rumor lifetime
+      antiEntropyInterval: 5000,    // 5 second anti-entropy
+      maxRetransmissions: 3
+    },
+    verification: {
+      taskTimeout: 30000,           // 30 second task timeout
+      consensusThreshold: 0.66,     // 66% consensus required
+      maxConcurrentTasks: 10,
+      retryAttempts: 3
+    },
+    monitoring: {
+      monitoringInterval: 5000,     // 5 second monitoring
+      alertThresholds: {
+        memory: 80,
+        cpu: 75,
+        network: 90,
+        agents: 80
+      },
+      alertCooldown: 30000,         // 30 second cooldown
+      historySize: 200
+    },
+    consensus: {
+      validationTimeout: 15000,     // 15 second validation timeout
+      consensusThreshold: 0.66,
+      heartbeatInterval: 5000
+    }
+  },
+
+  // High-throughput configuration - optimized for many small tasks
+  highThroughput: {
+    gossip: {
+      gossipInterval: 200,          // 200ms gossip rounds
+      fanout: 4,                    // Contact 4 peers per round
+      rumorLifetime: 15000,         // 15 second rumor lifetime
+      antiEntropyInterval: 1000,    // 1 second anti-entropy
+      maxRetransmissions: 2
+    },
+    verification: {
+      taskTimeout: 10000,           // 10 second task timeout
+      consensusThreshold: 0.6,      // 60% consensus for speed
+      maxConcurrentTasks: 20,
+      retryAttempts: 2
+    },
+    monitoring: {
+      monitoringInterval: 2000,     // 2 second monitoring
+      alertThresholds: {
+        memory: 85,
+        cpu: 80,
+        network: 90,
+        agents: 85
+      },
+      alertCooldown: 10000,         // 10 second cooldown
+      historySize: 100
+    },
+    consensus: {
+      validationTimeout: 8000,      // 8 second validation timeout
+      consensusThreshold: 0.6,
+      heartbeatInterval: 3000
+    }
+  },
+
+  // Low-latency configuration - optimized for critical real-time tasks
+  lowLatency: {
+    gossip: {
+      gossipInterval: 100,          // 100ms gossip rounds
+      fanout: 5,                    // Contact 5 peers per round
+      rumorLifetime: 5000,          // 5 second rumor lifetime
+      antiEntropyInterval: 500,     // 500ms anti-entropy
+      maxRetransmissions: 1
+    },
+    verification: {
+      taskTimeout: 3000,            // 3 second task timeout
+      consensusThreshold: 0.5,      // 50% consensus for speed
+      maxConcurrentTasks: 15,
+      retryAttempts: 1
+    },
+    monitoring: {
+      monitoringInterval: 500,      // 500ms monitoring
+      alertThresholds: {
+        memory: 75,
+        cpu: 70,
+        network: 85,
+        agents: 75
+      },
+      alertCooldown: 2000,          // 2 second cooldown
+      historySize: 50
+    },
+    consensus: {
+      validationTimeout: 2000,      // 2 second validation timeout
+      consensusThreshold: 0.5,
+      heartbeatInterval: 1000
+    }
+  },
+
+  // Large-scale configuration - optimized for many nodes
+  largeScale: {
+    gossip: {
+      gossipInterval: 2000,         // 2 second gossip rounds
+      fanout: 6,                    // Contact 6 peers per round
+      rumorLifetime: 60000,         // 60 second rumor lifetime
+      antiEntropyInterval: 10000,   // 10 second anti-entropy
+      maxRetransmissions: 4
+    },
+    verification: {
+      taskTimeout: 45000,           // 45 second task timeout
+      consensusThreshold: 0.75,     // 75% consensus for reliability
+      maxConcurrentTasks: 8,
+      retryAttempts: 3
+    },
+    monitoring: {
+      monitoringInterval: 10000,    // 10 second monitoring
+      alertThresholds: {
+        memory: 85,
+        cpu: 80,
+        network: 95,
+        agents: 90
+      },
+      alertCooldown: 60000,         // 60 second cooldown
+      historySize: 500
+    },
+    consensus: {
+      validationTimeout: 30000,     // 30 second validation timeout
+      consensusThreshold: 0.75,
+      heartbeatInterval: 10000
+    }
+  },
+
+  // Fault-tolerant configuration - optimized for unreliable networks
+  faultTolerant: {
+    gossip: {
+      gossipInterval: 1500,         // 1.5 second gossip rounds
+      fanout: 4,                    // Contact 4 peers per round
+      rumorLifetime: 45000,         // 45 second rumor lifetime
+      antiEntropyInterval: 3000,    // 3 second anti-entropy
+      maxRetransmissions: 5
+    },
+    verification: {
+      taskTimeout: 60000,           // 60 second task timeout
+      consensusThreshold: 0.6,      // 60% consensus (lower for faults)
+      maxConcurrentTasks: 6,
+      retryAttempts: 5
+    },
+    monitoring: {
+      monitoringInterval: 3000,     // 3 second monitoring
+      alertThresholds: {
+        memory: 90,
+        cpu: 85,
+        network: 95,
+        agents: 85
+      },
+      alertCooldown: 45000,         // 45 second cooldown
+      historySize: 300
+    },
+    consensus: {
+      validationTimeout: 45000,     // 45 second validation timeout
+      consensusThreshold: 0.6,
+      heartbeatInterval: 8000
+    }
+  }
+};
+
+/**
+ * Get configuration by environment and scale
+ */
+function getConfiguration(environment = 'production', scale = 'medium') {
+  const baseConfig = gossipConfigurations[environment] || gossipConfigurations.production;
+
+  // Scale adjustments
+  const scaleMultipliers = {
+    small: { fanout: 0.7, timeout: 0.8, threshold: 0.9 },
+    medium: { fanout: 1.0, timeout: 1.0, threshold: 1.0 },
+    large: { fanout: 1.3, timeout: 1.2, threshold: 1.1 },
+    xlarge: { fanout: 1.5, timeout: 1.5, threshold: 1.2 }
+  };
+
+  const multiplier = scaleMultipliers[scale] || scaleMultipliers.medium;
+
+  return {
+    ...baseConfig,
+    gossip: {
+      ...baseConfig.gossip,
+      fanout: Math.max(2, Math.floor(baseConfig.gossip.fanout * multiplier.fanout))
+    },
+    verification: {
+      ...baseConfig.verification,
+      taskTimeout: Math.floor(baseConfig.verification.taskTimeout * multiplier.timeout),
+      consensusThreshold: Math.min(0.9, baseConfig.verification.consensusThreshold * multiplier.threshold)
+    },
+    consensus: {
+      ...baseConfig.consensus,
+      validationTimeout: Math.floor(baseConfig.consensus.validationTimeout * multiplier.timeout),
+      consensusThreshold: Math.min(0.9, baseConfig.consensus.consensusThreshold * multiplier.threshold)
+    }
+  };
+}
+
+/**
+ * Create custom configuration with overrides
+ */
+function createCustomConfiguration(baseEnvironment = 'production', overrides = {}) {
+  const baseConfig = gossipConfigurations[baseEnvironment] || gossipConfigurations.production;
+
+  return {
+    gossip: { ...baseConfig.gossip, ...(overrides.gossip || {}) },
+    verification: { ...baseConfig.verification, ...(overrides.verification || {}) },
+    monitoring: { ...baseConfig.monitoring, ...(overrides.monitoring || {}) },
+    consensus: { ...baseConfig.consensus, ...(overrides.consensus || {}) }
+  };
+}
+
+/**
+ * Network topology configurations
+ */
+const topologyConfigurations = {
+  mesh: {
+    description: "Full mesh - every node connects to every other node",
+    connectToAll: true,
+    minConnections: 3,
+    maxConnections: 20,
+    redundancy: 'high',
+    faultTolerance: 'excellent'
+  },
+
+  star: {
+    description: "Star topology - central coordinator with spoke nodes",
+    centralCoordinator: true,
+    minConnections: 1,
+    maxConnections: 1,
+    redundancy: 'low',
+    faultTolerance: 'poor'
+  },
+
+  ring: {
+    description: "Ring topology - each node connects to next/previous",
+    ringConnections: true,
+    minConnections: 2,
+    maxConnections: 2,
+    redundancy: 'medium',
+    faultTolerance: 'fair'
+  },
+
+  smallWorld: {
+    description: "Small world - local clusters with random long-distance links",
+    localClusters: true,
+    randomLongLinks: true,
+    minConnections: 3,
+    maxConnections: 8,
+    redundancy: 'high',
+    faultTolerance: 'good'
+  },
+
+  hierarchical: {
+    description: "Hierarchical - tree structure with coordinator levels",
+    hierarchyLevels: 3,
+    minConnections: 1,
+    maxConnections: 5,
+    redundancy: 'medium',
+    faultTolerance: 'good'
+  }
+};
+
+module.exports = {
+  gossipConfigurations,
+  topologyConfigurations,
+  getConfiguration,
+  createCustomConfiguration
+};