cc-codeconductor 0.4.3 → 0.5.0

package/presets/cursor/skills/multi-agent-orchestration/scripts/agent_communication.py

@@ -0,0 +1,334 @@
+"""
+Agent Communication Management
+
+Handle agent-to-agent communication, message passing, and shared state.
+"""
+
+from typing import Dict, List, Optional, Any, Callable
+from dataclasses import dataclass, field
+from enum import Enum
+import json
+
+
+class MessageType(Enum):
+    """Types of messages between agents."""
+
+    DIRECT = "direct"
+    BROADCAST = "broadcast"
+    REQUEST = "request"
+    RESPONSE = "response"
+    FEEDBACK = "feedback"
+    ERROR = "error"
+
+
+@dataclass
+class Message:
+    """Message between agents."""
+
+    sender: str
+    recipient: str
+    content: str
+    message_type: MessageType
+    timestamp: float = field(default_factory=lambda: 0)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict:
+        """Convert to dictionary."""
+        return {
+            "sender": self.sender,
+            "recipient": self.recipient,
+            "content": self.content,
+            "type": self.message_type.value,
+            "timestamp": self.timestamp,
+            "metadata": self.metadata,
+        }
+
+
+class MessageBroker:
+    """Central message broker for agent communication."""
+
+    def __init__(self):
+        """Initialize message broker."""
+        self.message_queue: List[Message] = []
+        self.agent_inboxes: Dict[str, List[Message]] = {}
+        self.message_handlers: Dict[MessageType, List[Callable]] = {}
+
+    def send_message(self, message: Message) -> bool:
+        """
+        Send message from one agent to another.
+
+        Args:
+            message: Message object
+
+        Returns:
+            Whether message was delivered
+        """
+        self.message_queue.append(message)
+
+        # Add to recipient's inbox
+        if message.recipient not in self.agent_inboxes:
+            self.agent_inboxes[message.recipient] = []
+        self.agent_inboxes[message.recipient].append(message)
+
+        # Trigger handlers
+        self._trigger_handlers(message)
+
+        return True
+
+    def broadcast_message(self, sender: str, content: str, recipients: List[str]):
+        """
+        Broadcast message to multiple agents.
+
+        Args:
+            sender: Sending agent
+            content: Message content
+            recipients: List of recipient agents
+        """
+        for recipient in recipients:
+            message = Message(
+                sender=sender,
+                recipient=recipient,
+                content=content,
+                message_type=MessageType.BROADCAST,
+            )
+            self.send_message(message)
+
+    def request_response(
+        self, sender: str, recipient: str, content: str, timeout: float = 5.0
+    ) -> Optional[Message]:
+        """
+        Send request and wait for response.
+
+        Args:
+            sender: Requesting agent
+            recipient: Agent to respond
+            content: Request content
+            timeout: Response timeout in seconds
+
+        Returns:
+            Response message or None
+        """
+        message = Message(
+            sender=sender,
+            recipient=recipient,
+            content=content,
+            message_type=MessageType.REQUEST,
+            metadata={"timeout": timeout},
+        )
+        self.send_message(message)
+
+        # Placeholder - wait for response
+        # In production, implement actual timeout/wait mechanism
+        return None
+
+    def get_inbox(self, agent: str) -> List[Message]:
+        """Get messages for specific agent."""
+        return self.agent_inboxes.get(agent, [])
+
+    def clear_inbox(self, agent: str) -> None:
+        """Clear agent's inbox."""
+        self.agent_inboxes[agent] = []
+
+    def register_handler(
+        self, message_type: MessageType, handler: Callable
+    ) -> None:
+        """Register handler for message type."""
+        if message_type not in self.message_handlers:
+            self.message_handlers[message_type] = []
+        self.message_handlers[message_type].append(handler)
+
+    def _trigger_handlers(self, message: Message) -> None:
+        """Trigger registered handlers."""
+        handlers = self.message_handlers.get(message.message_type, [])
+        for handler in handlers:
+            try:
+                handler(message)
+            except Exception:
+                pass
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get communication statistics."""
+        type_counts = {}
+        for message in self.message_queue:
+            msg_type = message.message_type.value
+            type_counts[msg_type] = type_counts.get(msg_type, 0) + 1
+
+        return {
+            "total_messages": len(self.message_queue),
+            "by_type": type_counts,
+            "total_agents": len(self.agent_inboxes),
+            "agents": list(self.agent_inboxes.keys()),
+        }
+
+
+class SharedMemory:
+    """Shared memory for tool-mediated agent communication."""
+
+    def __init__(self):
+        """Initialize shared memory."""
+        self.memory: Dict[str, Any] = {}
+        self.access_log: List[Dict] = []
+
+    def write(self, key: str, value: Any, agent: str = "system") -> None:
+        """
+        Write to shared memory.
+
+        Args:
+            key: Memory key
+            value: Value to store
+            agent: Agent writing
+        """
+        self.memory[key] = {
+            "value": value,
+            "writer": agent,
+            "access_count": 0,
+        }
+        self.access_log.append({
+            "action": "write",
+            "key": key,
+            "agent": agent,
+        })
+
+    def read(self, key: str, agent: str = "system") -> Optional[Any]:
+        """
+        Read from shared memory.
+
+        Args:
+            key: Memory key
+            agent: Agent reading
+
+        Returns:
+            Stored value or None
+        """
+        if key in self.memory:
+            entry = self.memory[key]
+            entry["access_count"] += 1
+            self.access_log.append({
+                "action": "read",
+                "key": key,
+                "agent": agent,
+            })
+            return entry["value"]
+        return None
+
+    def append(self, key: str, value: Any, agent: str = "system") -> None:
+        """Append to list in shared memory."""
+        if key not in self.memory:
+            self.memory[key] = {
+                "value": [],
+                "writer": agent,
+                "access_count": 0,
+            }
+        if isinstance(self.memory[key]["value"], list):
+            self.memory[key]["value"].append(value)
+
+    def get_all(self) -> Dict[str, Any]:
+        """Get all shared memory contents."""
+        return {
+            key: entry["value"] for key, entry in self.memory.items()
+        }
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get memory access statistics."""
+        total_accesses = sum(
+            entry["access_count"] for entry in self.memory.values()
+        )
+
+        return {
+            "total_keys": len(self.memory),
+            "total_accesses": total_accesses,
+            "access_log_size": len(self.access_log),
+        }
+
+
+class ContextManager:
+    """Manage context sharing between agents."""
+
+    def __init__(self):
+        """Initialize context manager."""
+        self.contexts: Dict[str, Dict[str, Any]] = {}
+        self.global_context: Dict[str, Any] = {}
+
+    def create_context(self, context_id: str, initial_data: Optional[Dict] = None) -> None:
+        """Create new context."""
+        self.contexts[context_id] = initial_data or {}
+
+    def update_context(self, context_id: str, data: Dict) -> None:
+        """Update context data."""
+        if context_id in self.contexts:
+            self.contexts[context_id].update(data)
+
+    def get_context(self, context_id: str) -> Dict[str, Any]:
+        """Get context data."""
+        return self.contexts.get(context_id, {})
+
+    def set_global_context(self, key: str, value: Any) -> None:
+        """Set global context variable."""
+        self.global_context[key] = value
+
+    def get_global_context(self, key: str) -> Optional[Any]:
+        """Get global context variable."""
+        return self.global_context.get(key)
+
+    def context_to_string(self, context_id: str) -> str:
+        """Convert context to formatted string."""
+        context = self.get_context(context_id)
+        return json.dumps(context, indent=2)
+
+
+class CommunicationProtocol:
+    """Define communication protocol between agents."""
+
+    def __init__(self, broker: MessageBroker, shared_memory: SharedMemory):
+        """Initialize protocol."""
+        self.broker = broker
+        self.shared_memory = shared_memory
+
+    def request_analysis(
+        self, requester: str, analyzer: str, subject: str
+    ) -> None:
+        """Request analysis from another agent."""
+        message = Message(
+            sender=requester,
+            recipient=analyzer,
+            content=f"Analyze: {subject}",
+            message_type=MessageType.REQUEST,
+            metadata={"action": "analyze"},
+        )
+        self.broker.send_message(message)
+
+    def share_findings(self, source_agent: str, key: str, findings: Dict) -> None:
+        """Share findings through shared memory."""
+        self.shared_memory.write(key, findings, source_agent)
+
+    def aggregate_results(
+        self, agents: List[str], result_key: str
+    ) -> Dict[str, Any]:
+        """Aggregate results from multiple agents."""
+        results = {}
+        for agent in agents:
+            agent_results = self.shared_memory.read(f"{agent}_{result_key}")
+            if agent_results:
+                results[agent] = agent_results
+
+        return results
+
+    def notify_status(self, agent: str, status: str) -> None:
+        """Notify status update."""
+        message = Message(
+            sender=agent,
+            recipient="orchestrator",
+            content=f"Status: {status}",
+            message_type=MessageType.FEEDBACK,
+        )
+        self.broker.send_message(message)
+
+    def error_propagation(self, source_agent: str, error: str) -> None:
+        """Propagate error to relevant agents."""
+        message = Message(
+            sender=source_agent,
+            recipient="orchestrator",
+            content=f"Error: {error}",
+            message_type=MessageType.ERROR,
+        )
+        self.broker.send_message(message)

package/presets/cursor/skills/multi-agent-orchestration/scripts/benchmarking.py

@@ -0,0 +1,341 @@
+"""
+Multi-Agent System Benchmarking
+
+Evaluate team performance and agent effectiveness.
+"""
+
+from typing import Dict, List, Any, Callable, Optional
+from dataclasses import dataclass
+import time
+import statistics
+
+
+@dataclass
+class BenchmarkResult:
+    """Result from benchmark run."""
+
+    test_name: str
+    total_time: float
+    task_count: int
+    success_count: int
+    failure_count: int
+    quality_score: float
+    cost_tokens: int
+
+
+class TeamBenchmark:
+    """Benchmark multi-agent team performance."""
+
+    def __init__(self):
+        """Initialize benchmarking suite."""
+        self.results: List[BenchmarkResult] = []
+        self.agent_metrics: Dict[str, Dict] = {}
+
+    def run_benchmark(
+        self,
+        test_name: str,
+        orchestrator,
+        test_data: List[Dict],
+        quality_metric: Optional[Callable] = None,
+    ) -> BenchmarkResult:
+        """
+        Run benchmark test.
+
+        Args:
+            test_name: Name of benchmark
+            orchestrator: Orchestrator instance
+            test_data: Test cases
+            quality_metric: Function to evaluate quality
+
+        Returns:
+            Benchmark result
+        """
+        start_time = time.time()
+        results = []
+        costs = []
+
+        for test_case in test_data:
+            try:
+                result = orchestrator.execute(test_case)
+                results.append(result)
+                # Assume cost in test_case
+                costs.append(test_case.get("cost", 0))
+            except Exception:
+                pass
+
+        end_time = time.time()
+
+        success_count = len(results)
+        failure_count = len(test_data) - success_count
+        total_time = end_time - start_time
+
+        # Calculate quality score
+        quality_score = (
+            quality_metric(results) if quality_metric else success_count / len(test_data)
+        )
+
+        benchmark_result = BenchmarkResult(
+            test_name=test_name,
+            total_time=total_time,
+            task_count=len(test_data),
+            success_count=success_count,
+            failure_count=failure_count,
+            quality_score=quality_score,
+            cost_tokens=sum(costs),
+        )
+
+        self.results.append(benchmark_result)
+        return benchmark_result
+
+    def compare_orchestration_methods(
+        self,
+        methods: Dict[str, Callable],
+        test_data: List[Dict],
+    ) -> Dict[str, Any]:
+        """
+        Compare different orchestration methods.
+
+        Args:
+            methods: Dict of method name to orchestrator
+            test_data: Test cases
+
+        Returns:
+            Comparison results
+        """
+        comparison = {}
+
+        for method_name, orchestrator in methods.items():
+            result = self.run_benchmark(method_name, orchestrator, test_data)
+            comparison[method_name] = {
+                "total_time": result.total_time,
+                "success_rate": result.success_count / result.task_count,
+                "quality_score": result.quality_score,
+                "efficiency": result.success_count / (result.total_time + 0.001),
+                "cost_per_success": (
+                    result.cost_tokens / result.success_count
+                    if result.success_count > 0
+                    else float("inf")
+                ),
+            }
+
+        return comparison
+
+    def get_summary(self) -> Dict[str, Any]:
+        """Get benchmark summary."""
+        if not self.results:
+            return {"status": "no_results"}
+
+        times = [r.total_time for r in self.results]
+        success_rates = [
+            r.success_count / r.task_count for r in self.results
+        ]
+        quality_scores = [r.quality_score for r in self.results]
+
+        return {
+            "total_benchmarks": len(self.results),
+            "avg_time": statistics.mean(times),
+            "median_time": statistics.median(times),
+            "avg_success_rate": statistics.mean(success_rates),
+            "avg_quality": statistics.mean(quality_scores),
+            "benchmarks": [r.__dict__ for r in self.results],
+        }
+
+
+class AgentEffectiveness:
+    """Measure individual agent effectiveness."""
+
+    def __init__(self):
+        """Initialize effectiveness tracker."""
+        self.agent_stats: Dict[str, Dict] = {}
+
+    def record_agent_task(
+        self,
+        agent: str,
+        task_id: str,
+        success: bool,
+        quality_score: float,
+        duration: float,
+    ) -> None:
+        """Record agent task execution."""
+        if agent not in self.agent_stats:
+            self.agent_stats[agent] = {
+                "tasks": [],
+                "successes": 0,
+                "failures": 0,
+            }
+
+        stats = self.agent_stats[agent]
+        stats["tasks"].append({
+            "task_id": task_id,
+            "success": success,
+            "quality": quality_score,
+            "duration": duration,
+        })
+
+        if success:
+            stats["successes"] += 1
+        else:
+            stats["failures"] += 1
+
+    def get_agent_metrics(self, agent: str) -> Dict[str, Any]:
+        """Get metrics for specific agent."""
+        if agent not in self.agent_stats:
+            return {"status": "no_data"}
+
+        stats = self.agent_stats[agent]
+        tasks = stats["tasks"]
+
+        if not tasks:
+            return {"status": "no_tasks"}
+
+        success_rate = stats["successes"] / (stats["successes"] + stats["failures"])
+        quality_scores = [t["quality"] for t in tasks]
+        durations = [t["duration"] for t in tasks]
+
+        return {
+            "agent": agent,
+            "total_tasks": len(tasks),
+            "success_rate": success_rate,
+            "avg_quality": statistics.mean(quality_scores),
+            "avg_duration": statistics.mean(durations),
+            "reliability": success_rate,  # Alias for clarity
+        }
+
+    def rank_agents(self) -> List[tuple]:
+        """Rank agents by effectiveness."""
+        rankings = []
+
+        for agent in self.agent_stats.keys():
+            metrics = self.get_agent_metrics(agent)
+            if "success_rate" in metrics:
+                score = (
+                    metrics["success_rate"] * 0.4 +
+                    metrics["avg_quality"] * 0.4 +
+                    (1 - min(metrics["avg_duration"] / 10.0, 1.0)) * 0.2
+                )
+                rankings.append((agent, score, metrics))
+
+        rankings.sort(key=lambda x: x[1], reverse=True)
+        return rankings
+
+    def get_team_report(self) -> Dict[str, Any]:
+        """Get team effectiveness report."""
+        rankings = self.rank_agents()
+
+        return {
+            "total_agents": len(self.agent_stats),
+            "rankings": [
+                {
+                    "rank": i + 1,
+                    "agent": agent,
+                    "score": score,
+                    "metrics": metrics,
+                }
+                for i, (agent, score, metrics) in enumerate(rankings)
+            ],
+        }
+
+
+class CollaborationMetrics:
+    """Measure collaboration effectiveness between agents."""
+
+    def __init__(self):
+        """Initialize collaboration metrics."""
+        self.interactions: List[Dict] = []
+
+    def record_interaction(
+        self,
+        agent_a: str,
+        agent_b: str,
+        message: str,
+        response_time: float,
+        successful: bool,
+    ) -> None:
+        """Record agent-to-agent interaction."""
+        self.interactions.append({
+            "agent_a": agent_a,
+            "agent_b": agent_b,
+            "message": message,
+            "response_time": response_time,
+            "successful": successful,
+        })
+
+    def get_collaboration_graph(self) -> Dict[str, List[str]]:
+        """Get collaboration graph between agents."""
+        graph = {}
+
+        for interaction in self.interactions:
+            agent_a = interaction["agent_a"]
+            agent_b = interaction["agent_b"]
+
+            if agent_a not in graph:
+                graph[agent_a] = []
+            if agent_b not in graph[agent_a]:
+                graph[agent_a].append(agent_b)
+
+        return graph
+
+    def get_interaction_metrics(self) -> Dict[str, Any]:
+        """Get interaction metrics."""
+        if not self.interactions:
+            return {"total_interactions": 0}
+
+        response_times = [i["response_time"] for i in self.interactions]
+        success_rate = sum(1 for i in self.interactions if i["successful"]) / len(
+            self.interactions
+        )
+
+        return {
+            "total_interactions": len(self.interactions),
+            "success_rate": success_rate,
+            "avg_response_time": statistics.mean(response_times),
+            "median_response_time": statistics.median(response_times),
+            "max_response_time": max(response_times),
+            "collaboration_score": success_rate * (1 - min(statistics.mean(response_times) / 10.0, 1.0)),
+        }
+
+    def get_agent_collaboration_analysis(self, agent: str) -> Dict[str, Any]:
+        """Get collaboration analysis for specific agent."""
+        agent_interactions = [
+            i for i in self.interactions
+            if i["agent_a"] == agent or i["agent_b"] == agent
+        ]
+
+        if not agent_interactions:
+            return {"agent": agent, "status": "no_interactions"}
+
+        partners = set()
+        for interaction in agent_interactions:
+            if interaction["agent_a"] == agent:
+                partners.add(interaction["agent_b"])
+            else:
+                partners.add(interaction["agent_a"])
+
+        success_rate = sum(
+            1 for i in agent_interactions if i["successful"]
+        ) / len(agent_interactions)
+
+        return {
+            "agent": agent,
+            "collaboration_partners": list(partners),
+            "total_interactions": len(agent_interactions),
+            "collaboration_success_rate": success_rate,
+        }
+
+
+def create_benchmark_suite() -> Dict[str, Callable]:
+    """Create standard benchmark suite."""
+    return {
+        "sequential_tasks": lambda orchestrator: orchestrator.execute(
+            {"type": "sequential", "task_count": 5}
+        ),
+        "parallel_tasks": lambda orchestrator: orchestrator.execute(
+            {"type": "parallel", "task_count": 10}
+        ),
+        "complex_workflow": lambda orchestrator: orchestrator.execute(
+            {"type": "complex", "task_count": 20}
+        ),
+        "error_handling": lambda orchestrator: orchestrator.execute(
+            {"type": "with_errors", "task_count": 10}
+        ),
+    }