Upload jedi/swarm/coordinator.py with huggingface_hub

jedi/swarm/coordinator.py

@@ -0,0 +1,249 @@
+"""
+JEDI Swarm Coordinator — Multi-agent orchestration.
+
+Manages nanobot swarms with:
+- Distributed consensus protocols
+- Emergent behavior management
+- Stigmergy-based coordination
+- Swarm-level memory
+- Collective decision making
+
+Inspired by: FSI_FELON Chimera + Natural swarm intelligence
+"""
+
+import json
+import time
+import random
+import threading
+from typing import Dict, List, Optional, Any
+from collections import Counter
+
+
+class SwarmCoordinator:
+    """
+    Coordinates multiple nanobots as a unified swarm.
+    Uses decentralized consensus for decisions.
+    """
+    
+    def __init__(self, swarm_id: str, config: Optional[Dict] = None):
+        self.swarm_id = swarm_id
+        self.config = config or self._default_config()
+        self.members = {}  # bot_id -> Nanobot
+        self.shared_wisdom = SharedWisdom()
+        self.consensus = ConsensusProtocol(threshold=self.config.get("consensus_threshold", 0.7))
+        self.role_assignments = {}
+        self.swarm_state = "idle"
+        self._lock = threading.Lock()
+        self._task_queue = []
+    
+    def _default_config(self) -> Dict:
+        return {
+            "consensus_threshold": 0.7,
+            "max_members": 100,
+            "min_members_for_quorum": 3,
+            "emergency_response": True,
+            "task_redundancy": 2,  # Each task assigned to at least N bots
+        }
+    
+    def add_member(self, bot_id: str, bot_type: str) -> Dict:
+        """Add a nanobot to the swarm."""
+        with self._lock:
+            if len(self.members) >= self.config["max_members"]:
+                return {"error": "Swarm at capacity"}
+            self.members[bot_id] = {
+                "id": bot_id,
+                "type": bot_type,
+                "joined": time.time(),
+                "last_contact": time.time(),
+                "alive": True,
+            }
+            return {"success": True, "swarm_size": len(self.members)}
+    
+    def assign_role(self, bot_id: str, role: str) -> Dict:
+        """Assign a specific role to a nanobot in the swarm."""
+        if bot_id not in self.members:
+            return {"error": "Bot not in swarm"}
+        
+        self.role_assignments[bot_id] = role
+        return {"success": True, "bot_id": bot_id, "role": role}
+    
+    def queue_task(self, task: Dict) -> Dict:
+        """Add a task to the swarm's queue for execution."""
+        task_id = f"TASK-{int(time.time())}-{random.randint(1000,9999)}"
+        task["task_id"] = task_id
+        task["status"] = "queued"
+        task["created_at"] = time.time()
+        
+        with self._lock:
+            self._task_queue.append(task)
+        
+        # Assign to available bots
+        assignment = self._assign_task(task)
+        return {"task_id": task_id, "assignment": assignment, "queue_position": len(self._task_queue)}
+    
+    def _assign_task(self, task: Dict) -> Dict:
+        """Intelligently assign a task to the best nanobot(s)."""
+        task_type = task.get("type", "unknown")
+        bots_by_type = {}
+        
+        for bid, info in self.members.items():
+            if not info["alive"]:
+                continue
+            role = self.role_assignments.get(bid, info["type"])
+            if role not in bots_by_type:
+                bots_by_type[role] = []
+            bots_by_type[role].append(bid)
+        
+        # Map task types to required roles
+        role_map = {
+            "recon": ["scout", "recon", "ghost"],
+            "defense": ["guardian", "sentinel", "medic"],
+            "offense": ["striker", "shadow", "ghost"],
+            "audit": ["auditor"],
+            "secure_dev": ["architect", "weaver"],
+            "coordination": ["synapse"],
+            "forensics": ["medic", "guardian"],
+        }
+        
+        required_roles = role_map.get(task_type, ["scout"])
+        assigned = []
+        
+        for role in required_roles:
+            if role in bots_by_type:
+                selected = bots_by_type[role][:self.config["task_redundancy"]]
+                assigned.extend(selected)
+        
+        return {
+            "task_id": task["task_id"],
+            "assigned_bots": assigned,
+            "redundancy": self.config["task_redundancy"],
+            "not_enough": len(assigned) == 0,
+        }
+    
+    def collect_intel(self, bot_id: str, intel: Dict):
+        """Collect intelligence from a nanobot into shared wisdom."""
+        self.shared_wisdom.add_intel(bot_id, intel)
+        with self._lock:
+            if bot_id in self.members:
+                self.members[bot_id]["last_contact"] = time.time()
+    
+    def swarm_decision(self, proposals: List[Dict]) -> Optional[Dict]:
+        """Make a swarm-level decision using consensus protocol."""
+        return self.consensus.reach_consensus(proposals, min_voters=self.config["min_members_for_quorum"])
+    
+    def get_swarm_status(self) -> Dict:
+        """Get comprehensive swarm status."""
+        active_bots = sum(1 for info in self.members.values() if info["alive"])
+        return {
+            "swarm_id": self.swarm_id,
+            "total_members": len(self.members),
+            "active_members": active_bots,
+            "state": self.swarm_state,
+            "tasks_queued": len(self._task_queue),
+            "wisdom_size": self.shared_wisdom.size(),
+            "consensus_reached": self.consensus.total_decisions,
+            "role_distribution": dict(Counter(self.role_assignments.values())),
+        }
+
+
+class SharedWisdom:
+    """
+    Collective swarm memory — stigmergy-based.
+    Nanobots leave traces that others follow.
+    """
+    
+    def __init__(self):
+        self._intel = []
+        self._pheromone_trails = {}
+        self._lock = threading.Lock()
+    
+    def add_intel(self, bot_id: str, intel: Dict):
+        with self._lock:
+            self._intel.append({
+                "bot_id": bot_id,
+                "data": intel,
+                "timestamp": time.time()
+            })
+    
+    def add_pheromone(self, trail_id: str, strength: float):
+        """Add to a pheromone trail. Higher strength = more bots recommend this path."""
+        with self._lock:
+            current = self._pheromone_trails.get(trail_id, {"strength": 0, "voters": set()})
+            current["strength"] += strength
+            current["last_updated"] = time.time()
+            self._pheromone_trails[trail_id] = current
+    
+    def get_strongest_trails(self, limit: int = 5) -> List[tuple]:
+        """Get the pheromone trails with highest strength."""
+        with self._lock:
+            sorted_trails = sorted(
+                self._pheromone_trails.items(),
+                key=lambda x: x[1]["strength"],
+                reverse=True
+            )
+            return sorted_trails[:limit]
+    
+    def size(self) -> Dict:
+        with self._lock:
+            return {
+                "intel_entries": len(self._intel),
+                "pheromone_trails": len(self._pheromone_trails),
+            }
+
+
+class ConsensusProtocol:
+    """
+    Distributed consensus for swarm decision-making.
+    Used for critical operations like attack authorization or target selection.
+    """
+    
+    def __init__(self, threshold: float = 0.7):
+        self.threshold = threshold
+        self.total_decisions = 0
+        self.history = []
+    
+    def reach_consensus(self, proposals: List[Dict], min_voters: int = 3) -> Optional[Dict]:
+        """
+        Process nanobot proposals and reach consensus.
+        
+        Each proposal has:
+        - bot_id: identifying the nanobot
+        - action: proposed action
+        - confidence: 0.0-1.0 confidence in the proposal
+        - evidence: supporting evidence
+        """
+        if len(proposals) < min_voters:
+            return None
+        
+        # Group proposals by action
+        action_votes = {}
+        for prop in proposals:
+            action = prop.get("action", "unknown")
+            confidence = prop.get("confidence", 0.5)
+            if action not in action_votes:
+                action_votes[action] = []
+            action_votes[action].append(confidence)
+        
+        # Find action with highest weighted support
+        action_scores = {
+            action: (sum(confidences) / len(confidences)) * (len(confidences) / len(proposals))
+            for action, confidences in action_votes.items()
+        }
+        
+        best_action = max(action_scores, key=action_scores.get)
+        best_score = action_scores[best_action]
+        
+        result = {
+            "consensus_reached": best_score >= self.threshold,
+            "selected_action": best_action if best_score >= self.threshold else "no_consensus",
+            "confidence": best_score,
+            "threshold": self.threshold,
+            "total_voters": len(proposals),
+            "actions_proposed": list(action_votes.keys()),
+            "action_scores": action_scores,
+        }
+        
+        self.total_decisions += 1
+        self.history.append(result)
+        
+        return result