hanzo-mcp 0.8.0__tar.gz → 0.8.2__tar.gz

{hanzo_mcp-0.8.0 → hanzo_mcp-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.8.0
+Version: 0.8.2
 Summary: The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others.
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT
@@ -24,8 +24,8 @@ Requires-Dist: grep-ast>=0.8.1
 Requires-Dist: bashlex>=0.18
 Requires-Dist: libtmux>=0.39.0
 Requires-Dist: nbformat>=5.10.4
-Requires-Dist: psutil>=6.1.1
-Requires-Dist: pydantic>=2.11.1
+Requires-Dist: psutil>=6.0.0
+Requires-Dist: pydantic>=2.9.2
 Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: typing-extensions>=4.13.0
 Requires-Dist: watchdog>=6.0.0

hanzo_mcp-0.8.2/hanzo_mcp/bridge.py

@@ -0,0 +1,478 @@
+"""MCP Bridge for inter-Claude communication.
+
+This module provides MCP server functionality that allows Claude instances
+to communicate with each other, enabling peer-to-peer agent networks.
+"""
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import sys
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, asdict
+
+import mcp.server.fastmcp as mcp
+from mcp import tool
+from mcp.server.fastmcp import FastMCP
+from mcp.server.models import InitializationOptions
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool, INTERNAL_ERROR
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BridgeConfig:
+    """Configuration for MCP bridge."""
+    target_port: int
+    instance_id: int
+    role: str
+    source_instance: Optional[int] = None
+    target_instance: Optional[int] = None
+    
+    
+class ClaudeBridge(FastMCP):
+    """MCP Bridge server for Claude-to-Claude communication."""
+    
+    def __init__(self, config: BridgeConfig):
+        """Initialize the bridge.
+        
+        Args:
+            config: Bridge configuration
+        """
+        # Set server name based on target instance
+        super().__init__(f"claude_instance_{config.instance_id}")
+        
+        self.config = config
+        self.conversation_history: List[Dict[str, Any]] = []
+        self.shared_context: Dict[str, Any] = {}
+        
+        # Register tools
+        self._register_tools()
+        
+    def _register_tools(self):
+        """Register MCP tools for inter-Claude communication."""
+        
+        @self.tool()
+        async def chat_with_claude(message: str, context: Optional[str] = None) -> str:
+            """Chat with another Claude instance.
+            
+            Args:
+                message: Message to send to the other Claude
+                context: Optional context to provide
+                
+            Returns:
+                Response from the other Claude instance
+            """
+            logger.info(f"Bridge {self.config.instance_id}: Received chat request")
+            
+            # Record in conversation history
+            self.conversation_history.append({
+                "from": self.config.source_instance,
+                "to": self.config.target_instance,
+                "message": message,
+                "context": context
+            })
+            
+            # Simulate response (in production, this would make actual API call)
+            response = await self._forward_to_claude(message, context)
+            
+            self.conversation_history.append({
+                "from": self.config.target_instance,
+                "to": self.config.source_instance,
+                "response": response
+            })
+            
+            return response
+        
+        @self.tool()
+        async def ask_claude_to_review(
+            code: str,
+            description: str,
+            focus_areas: Optional[List[str]] = None
+        ) -> Dict[str, Any]:
+            """Ask another Claude to review code.
+            
+            Args:
+                code: Code to review
+                description: Description of what the code does
+                focus_areas: Specific areas to focus on (e.g., ["security", "performance"])
+                
+            Returns:
+                Review feedback from the other Claude
+            """
+            logger.info(f"Bridge {self.config.instance_id}: Code review request")
+            
+            review_prompt = self._build_review_prompt(code, description, focus_areas)
+            review = await self._forward_to_claude(review_prompt)
+            
+            return {
+                "reviewer": f"claude_{self.config.instance_id}",
+                "role": self.config.role,
+                "feedback": review,
+                "focus_areas": focus_areas or ["general"]
+            }
+        
+        @self.tool()
+        async def delegate_to_claude(
+            task: str,
+            requirements: List[str],
+            constraints: Optional[List[str]] = None
+        ) -> Dict[str, Any]:
+            """Delegate a task to another Claude instance.
+            
+            Args:
+                task: Task description
+                requirements: List of requirements
+                constraints: Optional constraints
+                
+            Returns:
+                Task completion result from the other Claude
+            """
+            logger.info(f"Bridge {self.config.instance_id}: Task delegation")
+            
+            delegation_prompt = self._build_delegation_prompt(task, requirements, constraints)
+            result = await self._forward_to_claude(delegation_prompt)
+            
+            return {
+                "delegated_to": f"claude_{self.config.instance_id}",
+                "role": self.config.role,
+                "task": task,
+                "result": result,
+                "status": "completed"
+            }
+        
+        @self.tool()
+        async def get_claude_opinion(
+            question: str,
+            options: Optional[List[str]] = None,
+            criteria: Optional[List[str]] = None
+        ) -> Dict[str, Any]:
+            """Get another Claude's opinion on a decision.
+            
+            Args:
+                question: The question or decision to get opinion on
+                options: Optional list of options to choose from
+                criteria: Optional evaluation criteria
+                
+            Returns:
+                Opinion and reasoning from the other Claude
+            """
+            logger.info(f"Bridge {self.config.instance_id}: Opinion request")
+            
+            opinion_prompt = self._build_opinion_prompt(question, options, criteria)
+            opinion = await self._forward_to_claude(opinion_prompt)
+            
+            return {
+                "advisor": f"claude_{self.config.instance_id}",
+                "role": self.config.role,
+                "question": question,
+                "opinion": opinion,
+                "options_considered": options,
+                "criteria_used": criteria
+            }
+        
+        @self.tool()
+        async def share_context_with_claude(
+            key: str,
+            value: Any,
+            description: Optional[str] = None
+        ) -> bool:
+            """Share context with another Claude instance.
+            
+            Args:
+                key: Context key
+                value: Context value
+                description: Optional description of the context
+                
+            Returns:
+                Success status
+            """
+            logger.info(f"Bridge {self.config.instance_id}: Sharing context '{key}'")
+            
+            self.shared_context[key] = {
+                "value": value,
+                "description": description,
+                "shared_by": self.config.source_instance,
+                "shared_with": self.config.target_instance
+            }
+            
+            return True
+        
+        @self.tool()
+        async def get_shared_context(key: Optional[str] = None) -> Dict[str, Any]:
+            """Get shared context from Claude network.
+            
+            Args:
+                key: Optional specific key to retrieve
+                
+            Returns:
+                Shared context data
+            """
+            if key:
+                return self.shared_context.get(key, {})
+            return self.shared_context
+        
+        @self.tool()
+        async def brainstorm_with_claude(
+            topic: str,
+            num_ideas: int = 5,
+            constraints: Optional[List[str]] = None
+        ) -> List[str]:
+            """Brainstorm ideas with another Claude.
+            
+            Args:
+                topic: Topic to brainstorm about
+                num_ideas: Number of ideas to generate
+                constraints: Optional constraints
+                
+            Returns:
+                List of brainstormed ideas
+            """
+            logger.info(f"Bridge {self.config.instance_id}: Brainstorming request")
+            
+            brainstorm_prompt = f"""
+            Please brainstorm {num_ideas} ideas about: {topic}
+            
+            {"Constraints: " + ", ".join(constraints) if constraints else ""}
+            
+            Provide creative and practical ideas.
+            """
+            
+            response = await self._forward_to_claude(brainstorm_prompt)
+            
+            # Parse response into list (simplified)
+            ideas = response.split("\n")
+            ideas = [idea.strip() for idea in ideas if idea.strip()]
+            
+            return ideas[:num_ideas]
+        
+        @self.tool()
+        async def get_claude_status() -> Dict[str, Any]:
+            """Get status of the connected Claude instance.
+            
+            Returns:
+                Status information
+            """
+            return {
+                "instance_id": self.config.instance_id,
+                "role": self.config.role,
+                "status": "available",
+                "conversation_count": len(self.conversation_history),
+                "shared_context_keys": list(self.shared_context.keys())
+            }
+    
+    def _build_review_prompt(self, code: str, description: str, 
+                            focus_areas: Optional[List[str]]) -> str:
+        """Build a code review prompt."""
+        prompt = f"""
+        Please review the following code:
+        
+        Description: {description}
+        
+        Code:
+        ```
+        {code}
+        ```
+        """
+        
+        if focus_areas:
+            prompt += f"\n\nPlease focus particularly on: {', '.join(focus_areas)}"
+        
+        prompt += """
+        
+        Provide constructive feedback on:
+        1. Potential bugs or issues
+        2. Code quality and best practices
+        3. Performance considerations
+        4. Security concerns
+        5. Suggestions for improvement
+        """
+        
+        return prompt
+    
+    def _build_delegation_prompt(self, task: str, requirements: List[str],
+                                constraints: Optional[List[str]]) -> str:
+        """Build a task delegation prompt."""
+        prompt = f"""
+        Please complete the following task:
+        
+        Task: {task}
+        
+        Requirements:
+        {chr(10).join(f"- {req}" for req in requirements)}
+        """
+        
+        if constraints:
+            prompt += f"""
+        
+        Constraints:
+        {chr(10).join(f"- {con}" for con in constraints)}
+        """
+        
+        prompt += """
+        
+        Provide a complete solution that meets all requirements.
+        """
+        
+        return prompt
+    
+    def _build_opinion_prompt(self, question: str, options: Optional[List[str]],
+                             criteria: Optional[List[str]]) -> str:
+        """Build an opinion request prompt."""
+        prompt = f"""
+        I need your opinion on the following:
+        
+        Question: {question}
+        """
+        
+        if options:
+            prompt += f"""
+        
+        Options to consider:
+        {chr(10).join(f"{i+1}. {opt}" for i, opt in enumerate(options))}
+        """
+        
+        if criteria:
+            prompt += f"""
+        
+        Please evaluate based on these criteria:
+        {chr(10).join(f"- {crit}" for crit in criteria)}
+        """
+        
+        prompt += """
+        
+        Provide your recommendation with clear reasoning.
+        """
+        
+        return prompt
+    
+    async def _forward_to_claude(self, prompt: str, context: Optional[str] = None) -> str:
+        """Forward a request to the target Claude instance.
+        
+        In production, this would make an actual API call to the Claude instance.
+        For now, it returns a simulated response.
+        """
+        # Add context if provided
+        full_prompt = prompt
+        if context:
+            full_prompt = f"Context: {context}\n\n{prompt}"
+        
+        # Log the forwarding
+        logger.info(f"Forwarding from instance {self.config.source_instance} to {self.config.target_instance}")
+        logger.debug(f"Prompt: {full_prompt[:200]}...")
+        
+        # In production, this would:
+        # 1. Connect to the target Claude instance API
+        # 2. Send the prompt
+        # 3. Receive and return the response
+        
+        # Simulated response based on role
+        if self.config.role.startswith("critic"):
+            return f"""
+            As {self.config.role}, I've analyzed your request:
+            
+            Strengths:
+            - The approach is logical and well-structured
+            - Good attention to requirements
+            
+            Areas for improvement:
+            - Consider edge cases more thoroughly
+            - Add more comprehensive error handling
+            - Optimize for performance in high-load scenarios
+            
+            Recommendation: Proceed with suggested improvements.
+            """
+        else:
+            return f"""
+            Response from {self.config.role} (instance {self.config.instance_id}):
+            
+            I've processed your request: "{prompt[:100]}..."
+            
+            The task has been completed successfully with the following approach:
+            1. Analyzed the requirements
+            2. Implemented the solution
+            3. Validated the results
+            
+            The solution meets all specified criteria.
+            """
+
+
+async def run_bridge_server(config: BridgeConfig):
+    """Run the MCP bridge server.
+    
+    Args:
+        config: Bridge configuration
+    """
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    logger.info(f"Starting MCP Bridge for Claude instance {config.instance_id}")
+    logger.info(f"Role: {config.role}")
+    logger.info(f"Target port: {config.target_port}")
+    
+    # Create and run the bridge
+    bridge = ClaudeBridge(config)
+    
+    # Run the stdio server
+    async with stdio_server() as (read_stream, write_stream):
+        await bridge.run(
+            read_stream=read_stream,
+            write_stream=write_stream,
+            InitializationOptions(
+                server_name=bridge.name,
+                server_version="1.0.0",
+                capabilities=bridge.get_capabilities()
+            )
+        )
+
+
+def main():
+    """Main entry point for the bridge."""
+    parser = argparse.ArgumentParser(
+        description="MCP Bridge for Claude-to-Claude communication"
+    )
+    parser.add_argument(
+        "--target-port",
+        type=int,
+        required=True,
+        help="Port of the target Claude instance"
+    )
+    parser.add_argument(
+        "--instance-id",
+        type=int,
+        required=True,
+        help="ID of the target Claude instance"
+    )
+    parser.add_argument(
+        "--role",
+        type=str,
+        required=True,
+        help="Role of the target instance (primary, critic_1, etc.)"
+    )
+    
+    args = parser.parse_args()
+    
+    # Get source/target from environment
+    source_instance = int(os.environ.get("SOURCE_INSTANCE", "0"))
+    target_instance = int(os.environ.get("TARGET_INSTANCE", args.instance_id))
+    
+    config = BridgeConfig(
+        target_port=args.target_port,
+        instance_id=args.instance_id,
+        role=args.role,
+        source_instance=source_instance,
+        target_instance=target_instance
+    )
+    
+    # Run the bridge
+    asyncio.run(run_bridge_server(config))
+
+
+if __name__ == "__main__":
+    main()

hanzo_mcp-0.8.2/hanzo_mcp/compute_nodes.py

@@ -0,0 +1,179 @@
+"""Compute node detection and management for distributed processing."""
+
+import os
+import platform
+import subprocess
+from typing import Any, Dict, List
+
+
+class ComputeNodeDetector:
+    """Detect available compute nodes (GPUs, WebGPU, CPUs) for distributed work."""
+    
+    @staticmethod
+    def detect_local_gpus() -> List[Dict[str, Any]]:
+        """Detect local GPU devices."""
+        gpus = []
+        
+        # Try NVIDIA GPUs
+        try:
+            result = subprocess.run(
+                ["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"],
+                capture_output=True,
+                text=True,
+                timeout=2
+            )
+            if result.returncode == 0:
+                for line in result.stdout.strip().split('\n'):
+                    if line:
+                        name, memory = line.split(', ')
+                        gpus.append({
+                            "type": "cuda",
+                            "name": name,
+                            "memory": memory,
+                            "id": f"cuda:{len(gpus)}"
+                        })
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            pass
+        
+        # Try Metal GPUs (macOS)
+        if platform.system() == "Darwin":
+            try:
+                # Check for Metal support
+                result = subprocess.run(
+                    ["system_profiler", "SPDisplaysDataType"],
+                    capture_output=True,
+                    text=True,
+                    timeout=2
+                )
+                if result.returncode == 0 and "Metal" in result.stdout:
+                    # Parse GPU info from system_profiler
+                    lines = result.stdout.split('\n')
+                    for i, line in enumerate(lines):
+                        if 'Chipset Model:' in line:
+                            gpu_name = line.split(':')[1].strip()
+                            gpus.append({
+                                "type": "metal",
+                                "name": gpu_name,
+                                "memory": "Shared",
+                                "id": f"metal:{len(gpus)}"
+                            })
+            except (FileNotFoundError, subprocess.TimeoutExpired):
+                pass
+        
+        return gpus
+    
+    @staticmethod
+    def detect_webgpu_nodes() -> List[Dict[str, Any]]:
+        """Detect connected WebGPU nodes (from browsers)."""
+        webgpu_nodes = []
+        
+        # Check for WebGPU connections (would need actual WebSocket/server to track)
+        # For now, check if a WebGPU server is running
+        webgpu_port = os.environ.get("HANZO_WEBGPU_PORT", "8765")
+        try:
+            import socket
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            result = sock.connect_ex(('localhost', int(webgpu_port)))
+            sock.close()
+            if result == 0:
+                webgpu_nodes.append({
+                    "type": "webgpu",
+                    "name": "Chrome WebGPU",
+                    "memory": "Browser",
+                    "id": "webgpu:0"
+                })
+        except Exception:
+            pass
+        
+        return webgpu_nodes
+    
+    @staticmethod
+    def detect_cpu_nodes() -> List[Dict[str, Any]]:
+        """Detect CPU compute nodes."""
+        import multiprocessing
+        
+        return [{
+            "type": "cpu",
+            "name": f"{platform.processor() or 'CPU'}",
+            "cores": multiprocessing.cpu_count(),
+            "id": "cpu:0"
+        }]
+    
+    @classmethod
+    def get_all_nodes(cls) -> List[Dict[str, Any]]:
+        """Get all available compute nodes."""
+        nodes = []
+        
+        # Detect GPUs
+        gpus = cls.detect_local_gpus()
+        nodes.extend(gpus)
+        
+        # Detect WebGPU connections
+        webgpu = cls.detect_webgpu_nodes()
+        nodes.extend(webgpu)
+        
+        # If no GPUs/WebGPU, add CPU as compute node
+        if not nodes:
+            nodes.extend(cls.detect_cpu_nodes())
+        
+        return nodes
+    
+    @classmethod
+    def get_node_count(cls) -> int:
+        """Get total number of available compute nodes."""
+        return len(cls.get_all_nodes())
+    
+    @classmethod
+    def get_node_summary(cls) -> str:
+        """Get a summary string of available nodes."""
+        nodes = cls.get_all_nodes()
+        if not nodes:
+            return "No compute nodes available"
+        
+        count = len(nodes)
+        node_word = "node" if count == 1 else "nodes"
+        
+        # Group by type
+        types = {}
+        for node in nodes:
+            node_type = node["type"]
+            if node_type not in types:
+                types[node_type] = 0
+            types[node_type] += 1
+        
+        # Build summary
+        parts = []
+        for node_type, type_count in types.items():
+            if node_type == "cuda":
+                parts.append(f"{type_count} CUDA GPU{'s' if type_count > 1 else ''}")
+            elif node_type == "metal":
+                parts.append(f"{type_count} Metal GPU{'s' if type_count > 1 else ''}")
+            elif node_type == "webgpu":
+                parts.append(f"{type_count} WebGPU")
+            elif node_type == "cpu":
+                parts.append(f"{type_count} CPU")
+        
+        type_str = ", ".join(parts)
+        return f"{count} {node_word} available ({type_str})"
+
+
+def print_node_status():
+    """Print current node status."""
+    detector = ComputeNodeDetector()
+    nodes = detector.get_all_nodes()
+    
+    print(f"\n🖥️  Compute Nodes: {len(nodes)}")
+    for node in nodes:
+        if node["type"] in ["cuda", "metal"]:
+            print(f"  • {node['id']}: {node['name']} ({node['memory']})")
+        elif node["type"] == "webgpu":
+            print(f"  • {node['id']}: {node['name']}")
+        elif node["type"] == "cpu":
+            print(f"  • {node['id']}: {node['name']} ({node['cores']} cores)")
+    print()
+
+
+if __name__ == "__main__":
+    # Test the detector
+    print_node_status()
+    print(ComputeNodeDetector.get_node_summary())

{hanzo_mcp-0.8.0 → hanzo_mcp-0.8.2}/hanzo_mcp/dev_server.py

@@ -172,6 +172,17 @@ class DevServer:
 
         logger = logging.getLogger(__name__)
         logger.info(f"\n🚀 Starting Hanzo AI in development mode...")
+        
+        # Show compute nodes
+        try:
+            from hanzo_mcp.compute_nodes import ComputeNodeDetector
+            detector = ComputeNodeDetector()
+            summary = detector.get_node_summary()
+            logger.info(f"🖥️  {summary}")
+        except Exception:
+            # Silently ignore if compute node detection fails
+            pass
+        
         logger.info(f"🔧 Hot reload enabled - watching for file changes")
         logger.info(f"📁 Project: {self.project_dir or 'current directory'}")
         logger.info(f"🌐 Transport: {transport}\n")