claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/hive-mind/communication.js

@@ -1,740 +1,645 @@
 /**
  * Swarm Communication System for Hive Mind
  * Handles inter-agent messaging and coordination
- */
-
-import EventEmitter from 'events';
-import crypto from 'crypto';
-
+ */ import EventEmitter from "events";
+import crypto from "crypto";
 /**
  * Message types and their priorities
- */
-const MESSAGE_TYPES = {
-  command: { priority: 1, reliable: true, encrypted: true },
-  query: { priority: 2, reliable: true, encrypted: false },
-  response: { priority: 2, reliable: true, encrypted: false },
-  broadcast: { priority: 3, reliable: false, encrypted: false },
-  heartbeat: { priority: 4, reliable: false, encrypted: false },
-  consensus: { priority: 1, reliable: true, encrypted: true },
-  task: { priority: 2, reliable: true, encrypted: false },
-  result: { priority: 2, reliable: true, encrypted: false },
-  error: { priority: 1, reliable: true, encrypted: false },
-  sync: { priority: 3, reliable: true, encrypted: false },
+ */ const MESSAGE_TYPES = {
+    command: {
+        priority: 1,
+        reliable: true,
+        encrypted: true
+    },
+    query: {
+        priority: 2,
+        reliable: true,
+        encrypted: false
+    },
+    response: {
+        priority: 2,
+        reliable: true,
+        encrypted: false
+    },
+    broadcast: {
+        priority: 3,
+        reliable: false,
+        encrypted: false
+    },
+    heartbeat: {
+        priority: 4,
+        reliable: false,
+        encrypted: false
+    },
+    consensus: {
+        priority: 1,
+        reliable: true,
+        encrypted: true
+    },
+    task: {
+        priority: 2,
+        reliable: true,
+        encrypted: false
+    },
+    result: {
+        priority: 2,
+        reliable: true,
+        encrypted: false
+    },
+    error: {
+        priority: 1,
+        reliable: true,
+        encrypted: false
+    },
+    sync: {
+        priority: 3,
+        reliable: true,
+        encrypted: false
+    }
 };
-
 /**
  * Communication protocols
- */
-const PROTOCOLS = {
-  direct: 'direct', // Point-to-point
-  broadcast: 'broadcast', // One-to-all
-  multicast: 'multicast', // One-to-many
-  gossip: 'gossip', // Epidemic spread
-  consensus: 'consensus', // Byzantine agreement
+ */ const PROTOCOLS = {
+    direct: 'direct',
+    broadcast: 'broadcast',
+    multicast: 'multicast',
+    gossip: 'gossip',
+    consensus: 'consensus'
 };
-
 /**
  * SwarmCommunication class
- */
-export class SwarmCommunication extends EventEmitter {
-  constructor(config = {}) {
-    super();
-
-    this.config = {
-      swarmId: config.swarmId,
-      encryption: config.encryption || false,
-      maxRetries: config.maxRetries || 3,
-      timeout: config.timeout || 5000,
-      bufferSize: config.bufferSize || 1000,
-      gossipFanout: config.gossipFanout || 3,
-      consensusQuorum: config.consensusQuorum || 0.67,
-      ...config,
-    };
-
-    this.state = {
-      agents: new Map(), // Connected agents
-      channels: new Map(), // Communication channels
-      messageBuffer: [], // Message queue
-      messageHistory: new Map(), // Sent messages
-      metrics: {
-        sent: 0,
-        received: 0,
-        failed: 0,
-        encrypted: 0,
-        latency: [],
-      },
-    };
-
-    this.encryptionKey = this.config.encryption ? crypto.randomBytes(32) : null;
-
-    this._initialize();
-  }
-
-  /**
+ */ export class SwarmCommunication extends EventEmitter {
+    /**
    * Initialize communication system
-   */
-  _initialize() {
-    // Set up message processing
-    this.messageProcessor = setInterval(() => {
-      this._processMessageBuffer();
-    }, 100);
-
-    // Set up heartbeat
-    this.heartbeatTimer = setInterval(() => {
-      this._sendHeartbeats();
-    }, 10000);
-
-    this.emit('communication:initialized', { swarmId: this.config.swarmId });
-  }
-
-  /**
+   */ _initialize() {
+        // Set up message processing
+        this.messageProcessor = setInterval(()=>{
+            this._processMessageBuffer();
+        }, 100);
+        // Set up heartbeat
+        this.heartbeatTimer = setInterval(()=>{
+            this._sendHeartbeats();
+        }, 10000);
+        this.emit('communication:initialized', {
+            swarmId: this.config.swarmId
+        });
+    }
+    /**
    * Register agent in communication network
-   */
-  registerAgent(agentId, metadata = {}) {
-    const agent = {
-      id: agentId,
-      status: 'online',
-      lastSeen: Date.now(),
-      metadata,
-      messageCount: 0,
-      channel: this._createChannel(agentId),
-    };
-
-    this.state.agents.set(agentId, agent);
-
-    // Announce new agent to swarm
-    this.broadcast(
-      {
-        type: 'agent_joined',
-        agentId,
-        metadata,
-      },
-      'sync',
-    );
-
-    this.emit('agent:registered', agent);
-    return agent;
-  }
-
-  /**
+   */ registerAgent(agentId, metadata = {}) {
+        const agent = {
+            id: agentId,
+            status: 'online',
+            lastSeen: Date.now(),
+            metadata,
+            messageCount: 0,
+            channel: this._createChannel(agentId)
+        };
+        this.state.agents.set(agentId, agent);
+        // Announce new agent to swarm
+        this.broadcast({
+            type: 'agent_joined',
+            agentId,
+            metadata
+        }, 'sync');
+        this.emit('agent:registered', agent);
+        return agent;
+    }
+    /**
    * Unregister agent from network
-   */
-  unregisterAgent(agentId) {
-    const agent = this.state.agents.get(agentId);
-    if (!agent) return;
-
-    // Close channel
-    const channel = this.state.channels.get(agentId);
-    if (channel) {
-      channel.close();
-      this.state.channels.delete(agentId);
+   */ unregisterAgent(agentId) {
+        const agent = this.state.agents.get(agentId);
+        if (!agent) return;
+        // Close channel
+        const channel = this.state.channels.get(agentId);
+        if (channel) {
+            channel.close();
+            this.state.channels.delete(agentId);
+        }
+        this.state.agents.delete(agentId);
+        // Announce agent departure
+        this.broadcast({
+            type: 'agent_left',
+            agentId
+        }, 'sync');
+        this.emit('agent:unregistered', {
+            agentId
+        });
     }
-
-    this.state.agents.delete(agentId);
-
-    // Announce agent departure
-    this.broadcast(
-      {
-        type: 'agent_left',
-        agentId,
-      },
-      'sync',
-    );
-
-    this.emit('agent:unregistered', { agentId });
-  }
-
-  /**
+    /**
    * Send direct message to agent
-   */
-  async send(toAgentId, message, type = 'query') {
-    const messageId = this._generateMessageId();
-    const timestamp = Date.now();
-
-    const envelope = {
-      id: messageId,
-      from: 'system', // Will be set by sender
-      to: toAgentId,
-      type,
-      timestamp,
-      message,
-      protocol: PROTOCOLS.direct,
-    };
-
-    // Encrypt if needed
-    if (this.config.encryption && MESSAGE_TYPES[type]?.encrypted) {
-      envelope.message = this._encrypt(message);
-      envelope.encrypted = true;
-      this.state.metrics.encrypted++;
+   */ async send(toAgentId, message, type = 'query') {
+        const messageId = this._generateMessageId();
+        const timestamp = Date.now();
+        const envelope = {
+            id: messageId,
+            from: 'system',
+            to: toAgentId,
+            type,
+            timestamp,
+            message,
+            protocol: PROTOCOLS.direct
+        };
+        // Encrypt if needed
+        if (this.config.encryption && MESSAGE_TYPES[type]?.encrypted) {
+            envelope.message = this._encrypt(message);
+            envelope.encrypted = true;
+            this.state.metrics.encrypted++;
+        }
+        // Add to buffer
+        this._addToBuffer(envelope);
+        // Track message
+        this.state.messageHistory.set(messageId, {
+            ...envelope,
+            status: 'pending',
+            attempts: 0
+        });
+        this.state.metrics.sent++;
+        // Return promise that resolves when message is acknowledged
+        return new Promise((resolve, reject)=>{
+            const timeout = setTimeout(()=>{
+                reject(new Error(`Message timeout: ${messageId}`));
+            }, this.config.timeout);
+            this.once(`ack:${messageId}`, ()=>{
+                clearTimeout(timeout);
+                resolve({
+                    messageId,
+                    delivered: true
+                });
+            });
+            this.once(`nack:${messageId}`, (error)=>{
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
     }
-
-    // Add to buffer
-    this._addToBuffer(envelope);
-
-    // Track message
-    this.state.messageHistory.set(messageId, {
-      ...envelope,
-      status: 'pending',
-      attempts: 0,
-    });
-
-    this.state.metrics.sent++;
-
-    // Return promise that resolves when message is acknowledged
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error(`Message timeout: ${messageId}`));
-      }, this.config.timeout);
-
-      this.once(`ack:${messageId}`, () => {
-        clearTimeout(timeout);
-        resolve({ messageId, delivered: true });
-      });
-
-      this.once(`nack:${messageId}`, (error) => {
-        clearTimeout(timeout);
-        reject(error);
-      });
-    });
-  }
-
-  /**
+    /**
    * Broadcast message to all agents
-   */
-  broadcast(message, type = 'broadcast') {
-    const messageId = this._generateMessageId();
-    const timestamp = Date.now();
-
-    const envelope = {
-      id: messageId,
-      from: 'system',
-      to: '*',
-      type,
-      timestamp,
-      message,
-      protocol: PROTOCOLS.broadcast,
-    };
-
-    // Broadcasts are typically not encrypted
-    this._addToBuffer(envelope);
-
-    this.state.metrics.sent++;
-
-    this.emit('message:broadcast', envelope);
-
-    return { messageId, recipients: this.state.agents.size };
-  }
-
-  /**
+   */ broadcast(message, type = 'broadcast') {
+        const messageId = this._generateMessageId();
+        const timestamp = Date.now();
+        const envelope = {
+            id: messageId,
+            from: 'system',
+            to: '*',
+            type,
+            timestamp,
+            message,
+            protocol: PROTOCOLS.broadcast
+        };
+        // Broadcasts are typically not encrypted
+        this._addToBuffer(envelope);
+        this.state.metrics.sent++;
+        this.emit('message:broadcast', envelope);
+        return {
+            messageId,
+            recipients: this.state.agents.size
+        };
+    }
+    /**
    * Multicast message to specific agents
-   */
-  multicast(agentIds, message, type = 'query') {
-    const messageId = this._generateMessageId();
-    const timestamp = Date.now();
-
-    const envelopes = agentIds.map((agentId) => ({
-      id: `${messageId}-${agentId}`,
-      from: 'system',
-      to: agentId,
-      type,
-      timestamp,
-      message,
-      protocol: PROTOCOLS.multicast,
-      groupId: messageId,
-    }));
-
-    envelopes.forEach((envelope) => this._addToBuffer(envelope));
-
-    this.state.metrics.sent += envelopes.length;
-
-    return { messageId, recipients: agentIds.length };
-  }
-
-  /**
-   * Gossip protocol for epidemic spread
-   */
-  gossip(message, type = 'sync') {
-    const messageId = this._generateMessageId();
-    const timestamp = Date.now();
-
-    // Select random agents for initial spread
-    const agents = Array.from(this.state.agents.keys());
-    const selected = this._selectRandomAgents(agents, this.config.gossipFanout);
-
-    selected.forEach((agentId) => {
-      const envelope = {
-        id: `${messageId}-${agentId}`,
-        from: 'system',
-        to: agentId,
-        type,
-        timestamp,
-        message: {
-          ...message,
-          _gossip: {
-            originalId: messageId,
-            hops: 0,
-            seen: [],
-          },
-        },
-        protocol: PROTOCOLS.gossip,
-      };
-
-      this._addToBuffer(envelope);
-    });
-
-    this.state.metrics.sent += selected.length;
-
-    return { messageId, initialTargets: selected };
-  }
-
-  /**
-   * Byzantine consensus protocol
-   */
-  async consensus(proposal, validators = []) {
-    const consensusId = this._generateMessageId();
-    const timestamp = Date.now();
-
-    // If no validators specified, use all online agents
-    if (validators.length === 0) {
-      validators = Array.from(this.state.agents.keys()).filter(
-        (id) => this.state.agents.get(id).status === 'online',
-      );
+   */ multicast(agentIds, message, type = 'query') {
+        const messageId = this._generateMessageId();
+        const timestamp = Date.now();
+        const envelopes = agentIds.map((agentId)=>({
+                id: `${messageId}-${agentId}`,
+                from: 'system',
+                to: agentId,
+                type,
+                timestamp,
+                message,
+                protocol: PROTOCOLS.multicast,
+                groupId: messageId
+            }));
+        envelopes.forEach((envelope)=>this._addToBuffer(envelope));
+        this.state.metrics.sent += envelopes.length;
+        return {
+            messageId,
+            recipients: agentIds.length
+        };
     }
-
-    const votes = new Map();
-    const votePromises = [];
-
-    // Phase 1: Proposal
-    validators.forEach((agentId) => {
-      const envelope = {
-        id: `${consensusId}-propose-${agentId}`,
-        from: 'system',
-        to: agentId,
-        type: 'consensus',
-        timestamp,
-        message: {
-          phase: 'propose',
-          consensusId,
-          proposal,
-        },
-        protocol: PROTOCOLS.consensus,
-      };
-
-      this._addToBuffer(envelope);
-
-      // Create promise for vote
-      const votePromise = new Promise((resolve) => {
-        this.once(`vote:${consensusId}:${agentId}`, (vote) => {
-          votes.set(agentId, vote);
-          resolve({ agentId, vote });
+    /**
+   * Gossip protocol for epidemic spread
+   */ gossip(message, type = 'sync') {
+        const messageId = this._generateMessageId();
+        const timestamp = Date.now();
+        // Select random agents for initial spread
+        const agents = Array.from(this.state.agents.keys());
+        const selected = this._selectRandomAgents(agents, this.config.gossipFanout);
+        selected.forEach((agentId)=>{
+            const envelope = {
+                id: `${messageId}-${agentId}`,
+                from: 'system',
+                to: agentId,
+                type,
+                timestamp,
+                message: {
+                    ...message,
+                    _gossip: {
+                        originalId: messageId,
+                        hops: 0,
+                        seen: []
+                    }
+                },
+                protocol: PROTOCOLS.gossip
+            };
+            this._addToBuffer(envelope);
         });
-
-        // Timeout for vote
-        setTimeout(() => {
-          if (!votes.has(agentId)) {
-            votes.set(agentId, null);
-            resolve({ agentId, vote: null });
-          }
-        }, this.config.timeout);
-      });
-
-      votePromises.push(votePromise);
-    });
-
-    // Wait for all votes
-    await Promise.all(votePromises);
-
-    // Phase 2: Tally and decide
-    const voteCount = {};
-    let totalVotes = 0;
-
-    votes.forEach((vote) => {
-      if (vote !== null) {
-        voteCount[vote] = (voteCount[vote] || 0) + 1;
-        totalVotes++;
-      }
-    });
-
-    // Check if consensus reached
-    const sortedVotes = Object.entries(voteCount).sort((a, b) => b[1] - a[1]);
-    const winner = sortedVotes[0];
-    const consensusReached = winner && winner[1] / validators.length >= this.config.consensusQuorum;
-
-    const result = {
-      consensusId,
-      proposal,
-      validators: validators.length,
-      votes: Object.fromEntries(votes),
-      voteCount,
-      winner: consensusReached ? winner[0] : null,
-      consensusReached,
-      quorum: this.config.consensusQuorum,
-      timestamp: Date.now(),
-    };
-
-    // Phase 3: Announce result
-    this.broadcast(
-      {
-        phase: 'result',
-        consensusId,
-        result,
-      },
-      'consensus',
-    );
-
-    this.emit('consensus:completed', result);
-
-    return result;
-  }
-
-  /**
-   * Handle incoming message
-   */
-  handleMessage(envelope) {
-    this.state.metrics.received++;
-
-    // Update agent last seen
-    const agent = this.state.agents.get(envelope.from);
-    if (agent) {
-      agent.lastSeen = Date.now();
-      agent.messageCount++;
+        this.state.metrics.sent += selected.length;
+        return {
+            messageId,
+            initialTargets: selected
+        };
     }
-
-    // Decrypt if needed
-    if (envelope.encrypted && this.config.encryption) {
-      try {
-        envelope.message = this._decrypt(envelope.message);
-      } catch (error) {
-        this.emit('error', { type: 'decryption_failed', envelope, error });
-        return;
-      }
+    /**
+   * Byzantine consensus protocol
+   */ async consensus(proposal, validators = []) {
+        const consensusId = this._generateMessageId();
+        const timestamp = Date.now();
+        // If no validators specified, use all online agents
+        if (validators.length === 0) {
+            validators = Array.from(this.state.agents.keys()).filter((id)=>this.state.agents.get(id).status === 'online');
+        }
+        const votes = new Map();
+        const votePromises = [];
+        // Phase 1: Proposal
+        validators.forEach((agentId)=>{
+            const envelope = {
+                id: `${consensusId}-propose-${agentId}`,
+                from: 'system',
+                to: agentId,
+                type: 'consensus',
+                timestamp,
+                message: {
+                    phase: 'propose',
+                    consensusId,
+                    proposal
+                },
+                protocol: PROTOCOLS.consensus
+            };
+            this._addToBuffer(envelope);
+            // Create promise for vote
+            const votePromise = new Promise((resolve)=>{
+                this.once(`vote:${consensusId}:${agentId}`, (vote)=>{
+                    votes.set(agentId, vote);
+                    resolve({
+                        agentId,
+                        vote
+                    });
+                });
+                // Timeout for vote
+                setTimeout(()=>{
+                    if (!votes.has(agentId)) {
+                        votes.set(agentId, null);
+                        resolve({
+                            agentId,
+                            vote: null
+                        });
+                    }
+                }, this.config.timeout);
+            });
+            votePromises.push(votePromise);
+        });
+        // Wait for all votes
+        await Promise.all(votePromises);
+        // Phase 2: Tally and decide
+        const voteCount = {};
+        let totalVotes = 0;
+        votes.forEach((vote)=>{
+            if (vote !== null) {
+                voteCount[vote] = (voteCount[vote] || 0) + 1;
+                totalVotes++;
+            }
+        });
+        // Check if consensus reached
+        const sortedVotes = Object.entries(voteCount).sort((a, b)=>b[1] - a[1]);
+        const winner = sortedVotes[0];
+        const consensusReached = winner && winner[1] / validators.length >= this.config.consensusQuorum;
+        const result = {
+            consensusId,
+            proposal,
+            validators: validators.length,
+            votes: Object.fromEntries(votes),
+            voteCount,
+            winner: consensusReached ? winner[0] : null,
+            consensusReached,
+            quorum: this.config.consensusQuorum,
+            timestamp: Date.now()
+        };
+        // Phase 3: Announce result
+        this.broadcast({
+            phase: 'result',
+            consensusId,
+            result
+        }, 'consensus');
+        this.emit('consensus:completed', result);
+        return result;
     }
-
-    // Process based on protocol
-    switch (envelope.protocol) {
-      case PROTOCOLS.direct:
-        this._handleDirectMessage(envelope);
-        break;
-
-      case PROTOCOLS.broadcast:
-        this._handleBroadcastMessage(envelope);
-        break;
-
-      case PROTOCOLS.multicast:
-        this._handleMulticastMessage(envelope);
-        break;
-
-      case PROTOCOLS.gossip:
-        this._handleGossipMessage(envelope);
-        break;
-
-      case PROTOCOLS.consensus:
-        this._handleConsensusMessage(envelope);
-        break;
-
-      default:
-        this.emit('error', { type: 'unknown_protocol', envelope });
+    /**
+   * Handle incoming message
+   */ handleMessage(envelope) {
+        this.state.metrics.received++;
+        // Update agent last seen
+        const agent = this.state.agents.get(envelope.from);
+        if (agent) {
+            agent.lastSeen = Date.now();
+            agent.messageCount++;
+        }
+        // Decrypt if needed
+        if (envelope.encrypted && this.config.encryption) {
+            try {
+                envelope.message = this._decrypt(envelope.message);
+            } catch (error) {
+                this.emit('error', {
+                    type: 'decryption_failed',
+                    envelope,
+                    error
+                });
+                return;
+            }
+        }
+        // Process based on protocol
+        switch(envelope.protocol){
+            case PROTOCOLS.direct:
+                this._handleDirectMessage(envelope);
+                break;
+            case PROTOCOLS.broadcast:
+                this._handleBroadcastMessage(envelope);
+                break;
+            case PROTOCOLS.multicast:
+                this._handleMulticastMessage(envelope);
+                break;
+            case PROTOCOLS.gossip:
+                this._handleGossipMessage(envelope);
+                break;
+            case PROTOCOLS.consensus:
+                this._handleConsensusMessage(envelope);
+                break;
+            default:
+                this.emit('error', {
+                    type: 'unknown_protocol',
+                    envelope
+                });
+        }
+        // Emit general message event
+        this.emit('message:received', envelope);
     }
-
-    // Emit general message event
-    this.emit('message:received', envelope);
-  }
-
-  /**
+    /**
    * Handle direct message
-   */
-  _handleDirectMessage(envelope) {
-    // Send acknowledgment
-    this._sendAck(envelope.id, envelope.from);
-
-    // Emit specific event for message type
-    this.emit(`message:${envelope.type}`, envelope);
-  }
-
-  /**
+   */ _handleDirectMessage(envelope) {
+        // Send acknowledgment
+        this._sendAck(envelope.id, envelope.from);
+        // Emit specific event for message type
+        this.emit(`message:${envelope.type}`, envelope);
+    }
+    /**
    * Handle broadcast message
-   */
-  _handleBroadcastMessage(envelope) {
-    // No ack for broadcasts
-    this.emit(`broadcast:${envelope.type}`, envelope);
-  }
-
-  /**
+   */ _handleBroadcastMessage(envelope) {
+        // No ack for broadcasts
+        this.emit(`broadcast:${envelope.type}`, envelope);
+    }
+    /**
    * Handle multicast message
-   */
-  _handleMulticastMessage(envelope) {
-    // Send ack to original sender
-    this._sendAck(envelope.groupId, envelope.from);
-
-    this.emit(`multicast:${envelope.type}`, envelope);
-  }
-
-  /**
-   * Handle gossip message
-   */
-  _handleGossipMessage(envelope) {
-    const gossipData = envelope.message._gossip;
-
-    // Check if we've seen this message
-    if (gossipData.seen.includes(this.config.swarmId)) {
-      return;
+   */ _handleMulticastMessage(envelope) {
+        // Send ack to original sender
+        this._sendAck(envelope.groupId, envelope.from);
+        this.emit(`multicast:${envelope.type}`, envelope);
     }
-
-    // Mark as seen
-    gossipData.seen.push(this.config.swarmId);
-    gossipData.hops++;
-
-    // Process the message
-    this.emit(`gossip:${envelope.type}`, envelope);
-
-    // Continue spreading if hop count is low
-    if (gossipData.hops < 3) {
-      const agents = Array.from(this.state.agents.keys()).filter(
-        (id) => !gossipData.seen.includes(id),
-      );
-
-      const selected = this._selectRandomAgents(agents, this.config.gossipFanout);
-
-      selected.forEach((agentId) => {
-        const newEnvelope = {
-          ...envelope,
-          id: `${gossipData.originalId}-${agentId}-hop${gossipData.hops}`,
-          to: agentId,
-          from: this.config.swarmId,
-        };
-
-        this._addToBuffer(newEnvelope);
-      });
+    /**
+   * Handle gossip message
+   */ _handleGossipMessage(envelope) {
+        const gossipData = envelope.message._gossip;
+        // Check if we've seen this message
+        if (gossipData.seen.includes(this.config.swarmId)) {
+            return;
+        }
+        // Mark as seen
+        gossipData.seen.push(this.config.swarmId);
+        gossipData.hops++;
+        // Process the message
+        this.emit(`gossip:${envelope.type}`, envelope);
+        // Continue spreading if hop count is low
+        if (gossipData.hops < 3) {
+            const agents = Array.from(this.state.agents.keys()).filter((id)=>!gossipData.seen.includes(id));
+            const selected = this._selectRandomAgents(agents, this.config.gossipFanout);
+            selected.forEach((agentId)=>{
+                const newEnvelope = {
+                    ...envelope,
+                    id: `${gossipData.originalId}-${agentId}-hop${gossipData.hops}`,
+                    to: agentId,
+                    from: this.config.swarmId
+                };
+                this._addToBuffer(newEnvelope);
+            });
+        }
     }
-  }
-
-  /**
+    /**
    * Handle consensus message
-   */
-  _handleConsensusMessage(envelope) {
-    const { phase, consensusId } = envelope.message;
-
-    switch (phase) {
-      case 'propose':
-        // Agent should vote on proposal
-        this.emit('consensus:proposal', envelope);
-        break;
-
-      case 'vote':
-        // Collect vote
-        this.emit(`vote:${consensusId}:${envelope.from}`, envelope.message.vote);
-        break;
-
-      case 'result':
-        // Consensus result announced
-        this.emit('consensus:result', envelope.message.result);
-        break;
+   */ _handleConsensusMessage(envelope) {
+        const { phase, consensusId } = envelope.message;
+        switch(phase){
+            case 'propose':
+                // Agent should vote on proposal
+                this.emit('consensus:proposal', envelope);
+                break;
+            case 'vote':
+                // Collect vote
+                this.emit(`vote:${consensusId}:${envelope.from}`, envelope.message.vote);
+                break;
+            case 'result':
+                // Consensus result announced
+                this.emit('consensus:result', envelope.message.result);
+                break;
+        }
     }
-  }
-
-  /**
+    /**
    * Send acknowledgment
-   */
-  _sendAck(messageId, toAgent) {
-    const ack = {
-      id: `ack-${messageId}`,
-      from: this.config.swarmId,
-      to: toAgent,
-      type: 'ack',
-      timestamp: Date.now(),
-      message: { originalId: messageId },
-      protocol: PROTOCOLS.direct,
-    };
-
-    this._addToBuffer(ack);
-  }
-
-  /**
+   */ _sendAck(messageId, toAgent) {
+        const ack = {
+            id: `ack-${messageId}`,
+            from: this.config.swarmId,
+            to: toAgent,
+            type: 'ack',
+            timestamp: Date.now(),
+            message: {
+                originalId: messageId
+            },
+            protocol: PROTOCOLS.direct
+        };
+        this._addToBuffer(ack);
+    }
+    /**
    * Create communication channel
-   */
-  _createChannel(agentId) {
-    // In production, this would create actual network channels
-    // For now, we simulate with event emitters
-    const channel = new EventEmitter();
-
-    channel.send = (message) => {
-      this.emit(`channel:${agentId}`, message);
-    };
-
-    channel.close = () => {
-      channel.removeAllListeners();
-    };
-
-    this.state.channels.set(agentId, channel);
-
-    return channel;
-  }
-
-  /**
+   */ _createChannel(agentId) {
+        // In production, this would create actual network channels
+        // For now, we simulate with event emitters
+        const channel = new EventEmitter();
+        channel.send = (message)=>{
+            this.emit(`channel:${agentId}`, message);
+        };
+        channel.close = ()=>{
+            channel.removeAllListeners();
+        };
+        this.state.channels.set(agentId, channel);
+        return channel;
+    }
+    /**
    * Add message to buffer
-   */
-  _addToBuffer(envelope) {
-    this.state.messageBuffer.push(envelope);
-
-    // Limit buffer size
-    if (this.state.messageBuffer.length > this.config.bufferSize) {
-      const dropped = this.state.messageBuffer.shift();
-      this.emit('message:dropped', dropped);
+   */ _addToBuffer(envelope) {
+        this.state.messageBuffer.push(envelope);
+        // Limit buffer size
+        if (this.state.messageBuffer.length > this.config.bufferSize) {
+            const dropped = this.state.messageBuffer.shift();
+            this.emit('message:dropped', dropped);
+        }
     }
-  }
-
-  /**
+    /**
    * Process message buffer
-   */
-  _processMessageBuffer() {
-    const toProcess = this.state.messageBuffer.splice(0, 10);
-
-    toProcess.forEach((envelope) => {
-      // Simulate network delay
-      setTimeout(() => {
-        if (envelope.to === '*') {
-          // Broadcast to all agents
-          this.state.agents.forEach((agent) => {
-            this.emit(`deliver:${agent.id}`, envelope);
-          });
-        } else {
-          // Direct delivery
-          this.emit(`deliver:${envelope.to}`, envelope);
-        }
-
-        // Update message history
-        const history = this.state.messageHistory.get(envelope.id);
-        if (history) {
-          history.status = 'sent';
-          history.sentAt = Date.now();
-        }
-      }, Math.random() * 100);
-    });
-  }
-
-  /**
+   */ _processMessageBuffer() {
+        const toProcess = this.state.messageBuffer.splice(0, 10);
+        toProcess.forEach((envelope)=>{
+            // Simulate network delay
+            setTimeout(()=>{
+                if (envelope.to === '*') {
+                    // Broadcast to all agents
+                    this.state.agents.forEach((agent)=>{
+                        this.emit(`deliver:${agent.id}`, envelope);
+                    });
+                } else {
+                    // Direct delivery
+                    this.emit(`deliver:${envelope.to}`, envelope);
+                }
+                // Update message history
+                const history = this.state.messageHistory.get(envelope.id);
+                if (history) {
+                    history.status = 'sent';
+                    history.sentAt = Date.now();
+                }
+            }, Math.random() * 100);
+        });
+    }
+    /**
    * Send heartbeats to all agents
-   */
-  _sendHeartbeats() {
-    const now = Date.now();
-
-    this.state.agents.forEach((agent, agentId) => {
-      // Check if agent is still responsive
-      if (now - agent.lastSeen > 30000) {
-        agent.status = 'offline';
-        this.emit('agent:offline', { agentId });
-      }
-
-      // Send heartbeat
-      const heartbeat = {
-        id: `heartbeat-${now}-${agentId}`,
-        from: 'system',
-        to: agentId,
-        type: 'heartbeat',
-        timestamp: now,
-        message: { timestamp: now },
-        protocol: PROTOCOLS.direct,
-      };
-
-      this._addToBuffer(heartbeat);
-    });
-  }
-
-  /**
+   */ _sendHeartbeats() {
+        const now = Date.now();
+        this.state.agents.forEach((agent, agentId)=>{
+            // Check if agent is still responsive
+            if (now - agent.lastSeen > 30000) {
+                agent.status = 'offline';
+                this.emit('agent:offline', {
+                    agentId
+                });
+            }
+            // Send heartbeat
+            const heartbeat = {
+                id: `heartbeat-${now}-${agentId}`,
+                from: 'system',
+                to: agentId,
+                type: 'heartbeat',
+                timestamp: now,
+                message: {
+                    timestamp: now
+                },
+                protocol: PROTOCOLS.direct
+            };
+            this._addToBuffer(heartbeat);
+        });
+    }
+    /**
    * Select random agents
-   */
-  _selectRandomAgents(agents, count) {
-    const shuffled = [...agents].sort(() => Math.random() - 0.5);
-    return shuffled.slice(0, Math.min(count, agents.length));
-  }
-
-  /**
+   */ _selectRandomAgents(agents, count) {
+        const shuffled = [
+            ...agents
+        ].sort(()=>Math.random() - 0.5);
+        return shuffled.slice(0, Math.min(count, agents.length));
+    }
+    /**
    * Generate unique message ID
-   */
-  _generateMessageId() {
-    return `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
+   */ _generateMessageId() {
+        return `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
    * Encrypt message
-   */
-  _encrypt(data) {
-    if (!this.encryptionKey) return data;
-
-    const iv = crypto.randomBytes(16);
-    const cipher = crypto.createCipheriv('aes-256-cbc', this.encryptionKey, iv);
-
-    let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'hex');
-    encrypted += cipher.final('hex');
-
-    return {
-      iv: iv.toString('hex'),
-      data: encrypted,
-    };
-  }
-
-  /**
+   */ _encrypt(data) {
+        if (!this.encryptionKey) return data;
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv('aes-256-cbc', this.encryptionKey, iv);
+        let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return {
+            iv: iv.toString('hex'),
+            data: encrypted
+        };
+    }
+    /**
    * Decrypt message
-   */
-  _decrypt(encrypted) {
-    if (!this.encryptionKey) return encrypted;
-
-    const iv = Buffer.from(encrypted.iv, 'hex');
-    const decipher = crypto.createDecipheriv('aes-256-cbc', this.encryptionKey, iv);
-
-    let decrypted = decipher.update(encrypted.data, 'hex', 'utf8');
-    decrypted += decipher.final('utf8');
-
-    return JSON.parse(decrypted);
-  }
-
-  /**
+   */ _decrypt(encrypted) {
+        if (!this.encryptionKey) return encrypted;
+        const iv = Buffer.from(encrypted.iv, 'hex');
+        const decipher = crypto.createDecipheriv('aes-256-cbc', this.encryptionKey, iv);
+        let decrypted = decipher.update(encrypted.data, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return JSON.parse(decrypted);
+    }
+    /**
    * Get communication statistics
-   */
-  getStatistics() {
-    const avgLatency =
-      this.state.metrics.latency.length > 0
-        ? this.state.metrics.latency.reduce((a, b) => a + b, 0) / this.state.metrics.latency.length
-        : 0;
-
-    return {
-      agents: {
-        total: this.state.agents.size,
-        online: Array.from(this.state.agents.values()).filter((a) => a.status === 'online').length,
-        offline: Array.from(this.state.agents.values()).filter((a) => a.status === 'offline')
-          .length,
-      },
-      messages: {
-        sent: this.state.metrics.sent,
-        received: this.state.metrics.received,
-        failed: this.state.metrics.failed,
-        encrypted: this.state.metrics.encrypted,
-        buffered: this.state.messageBuffer.length,
-      },
-      performance: {
-        avgLatency: avgLatency.toFixed(2),
-        successRate:
-          this.state.metrics.sent > 0
-            ? (
-                ((this.state.metrics.sent - this.state.metrics.failed) / this.state.metrics.sent) *
-                100
-              ).toFixed(2)
-            : 100,
-      },
-    };
-  }
-
-  /**
+   */ getStatistics() {
+        const avgLatency = this.state.metrics.latency.length > 0 ? this.state.metrics.latency.reduce((a, b)=>a + b, 0) / this.state.metrics.latency.length : 0;
+        return {
+            agents: {
+                total: this.state.agents.size,
+                online: Array.from(this.state.agents.values()).filter((a)=>a.status === 'online').length,
+                offline: Array.from(this.state.agents.values()).filter((a)=>a.status === 'offline').length
+            },
+            messages: {
+                sent: this.state.metrics.sent,
+                received: this.state.metrics.received,
+                failed: this.state.metrics.failed,
+                encrypted: this.state.metrics.encrypted,
+                buffered: this.state.messageBuffer.length
+            },
+            performance: {
+                avgLatency: avgLatency.toFixed(2),
+                successRate: this.state.metrics.sent > 0 ? ((this.state.metrics.sent - this.state.metrics.failed) / this.state.metrics.sent * 100).toFixed(2) : 100
+            }
+        };
+    }
+    /**
    * Close communication system
-   */
-  close() {
-    // Clear timers
-    if (this.messageProcessor) clearInterval(this.messageProcessor);
-    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
-
-    // Close all channels
-    this.state.channels.forEach((channel) => channel.close());
-
-    this.emit('communication:closed');
-  }
+   */ close() {
+        // Clear timers
+        if (this.messageProcessor) clearInterval(this.messageProcessor);
+        if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+        // Close all channels
+        this.state.channels.forEach((channel)=>channel.close());
+        this.emit('communication:closed');
+    }
+    constructor(config = {}){
+        super();
+        this.config = {
+            swarmId: config.swarmId,
+            encryption: config.encryption || false,
+            maxRetries: config.maxRetries || 3,
+            timeout: config.timeout || 5000,
+            bufferSize: config.bufferSize || 1000,
+            gossipFanout: config.gossipFanout || 3,
+            consensusQuorum: config.consensusQuorum || 0.67,
+            ...config
+        };
+        this.state = {
+            agents: new Map(),
+            channels: new Map(),
+            messageBuffer: [],
+            messageHistory: new Map(),
+            metrics: {
+                sent: 0,
+                received: 0,
+                failed: 0,
+                encrypted: 0,
+                latency: []
+            }
+        };
+        this.encryptionKey = this.config.encryption ? crypto.randomBytes(32) : null;
+        this._initialize();
+    }
 }