hanzo-mcp 0.7.7__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/tools/agent/review_tool.py

@@ -1,16 +1,17 @@
 """Review tool for agents to request balanced code review from main loop."""
 
-import json
-from typing import Any, Dict, List, Optional, override
 from enum import Enum
+from typing import List, Optional, override
 
-from hanzo_mcp.tools.common.base import BaseTool
-from mcp.server.fastmcp import Context as MCPContext
 from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
 
 
 class ReviewFocus(Enum):
     """Types of review focus areas."""
+
     GENERAL = "general"
     FUNCTIONALITY = "functionality"
     READABILITY = "readability"
@@ -22,9 +23,9 @@ class ReviewFocus(Enum):
 
 class ReviewTool(BaseTool):
     """Tool for agents to request balanced code review from the main loop."""
-    
+
     name = "review"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -55,7 +56,7 @@ review(
     file_paths=["/path/to/import_handler.go"],
     context="This will be used to automatically fix missing imports in Go files"
 )"""
-    
+
     async def call(
         self,
         ctx: MCPContext,
@@ -63,16 +64,16 @@ review(
         work_description: str,
         code_snippets: Optional[List[str]] = None,
         file_paths: Optional[List[str]] = None,
-        context: Optional[str] = None
+        context: Optional[str] = None,
     ) -> str:
         """This is a placeholder - actual implementation happens in AgentTool."""
         # This tool is handled specially in the agent execution
         return f"Review requested for: {work_description}"
-    
+
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
         tool_self = self
-        
+
         @server.tool(name=self.name, description=self.description)
         async def review(
             ctx: MCPContext,
@@ -80,21 +81,16 @@ review(
             work_description: str,
             code_snippets: Optional[List[str]] = None,
             file_paths: Optional[List[str]] = None,
-            context: Optional[str] = None
+            context: Optional[str] = None,
         ) -> str:
             return await tool_self.call(
-                ctx,
-                focus,
-                work_description,
-                code_snippets,
-                file_paths,
-                context
+                ctx, focus, work_description, code_snippets, file_paths, context
             )
 
 
 class BalancedReviewer:
     """Provides balanced, constructive code reviews."""
-    
+
     def __init__(self):
         self.review_handlers = {
             ReviewFocus.GENERAL: self._review_general,
@@ -105,30 +101,30 @@ class BalancedReviewer:
             ReviewFocus.DOCUMENTATION: self._review_documentation,
             ReviewFocus.ARCHITECTURE: self._review_architecture,
         }
-    
+
     def review(
         self,
         focus: ReviewFocus,
         work_description: str,
         code_snippets: Optional[List[str]] = None,
         file_paths: Optional[List[str]] = None,
-        context: Optional[str] = None
+        context: Optional[str] = None,
     ) -> str:
         """Perform a balanced code review."""
         review_func = self.review_handlers.get(focus, self._review_general)
         return review_func(work_description, code_snippets, file_paths, context)
-    
+
     def _review_general(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        context: Optional[str]
+        context: Optional[str],
     ) -> str:
         """Provide a general balanced review."""
         response = "📋 GENERAL CODE REVIEW:\n\n"
         response += f"**Work Reviewed:** {work_description}\n\n"
-        
+
         # Positive observations
         response += "**Positive Aspects:**\n"
         if "fix" in work_description.lower():
@@ -141,293 +137,300 @@ class BalancedReviewer:
             response += "✓ Focused changes in a single file (good for reviewability)\n"
         elif file_paths and len(file_paths) > 1:
             response += "✓ Comprehensive approach across multiple files\n"
-        
+
         # Constructive suggestions
         response += "\n**Suggestions for Consideration:**\n"
         response += "• Ensure all edge cases are handled appropriately\n"
         response += "• Consider adding unit tests if not already present\n"
         response += "• Verify the changes integrate well with existing code\n"
-        
+
         if context:
             response += f"\n**Context Consideration:**\n{context}\n"
             response += "→ This context helps understand the implementation choices.\n"
-        
+
         # Summary
         response += "\n**Summary:**\n"
         response += "The implementation appears sound. Consider the suggestions above to further strengthen the code."
-        
+
         return response
-    
+
     def _review_functionality(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        context: Optional[str]
+        context: Optional[str],
     ) -> str:
         """Review functionality aspects."""
         response = "📋 FUNCTIONALITY REVIEW:\n\n"
         response += f"**Implementation:** {work_description}\n\n"
-        
+
         response += "**Functional Assessment:**\n"
-        
+
         # Analyze code snippets if provided
         if code_snippets:
             for i, snippet in enumerate(code_snippets, 1):
                 response += f"\nCode Snippet {i}:\n"
-                
+
                 # Check for function definitions
                 if "func " in snippet or "def " in snippet or "function " in snippet:
                     response += "✓ Function definition looks properly structured\n"
-                
+
                 # Check for error handling
                 if "error" in snippet or "err" in snippet or "try" in snippet:
                     response += "✓ Error handling is present\n"
                 elif "return" in snippet:
                     response += "• Consider adding error handling if applicable\n"
-                
+
                 # Check for input validation
                 if "if " in snippet or "check" in snippet.lower():
                     response += "✓ Input validation appears to be present\n"
-        
+
         response += "\n**Functional Considerations:**\n"
         response += "• Does the implementation handle all expected inputs?\n"
         response += "• Are return values meaningful and consistent?\n"
         response += "• Is the functionality easily testable?\n"
         response += "• Does it integrate well with existing features?\n"
-        
+
         response += "\n**Overall:** The functionality appears to meet the described requirements."
-        
+
         return response
-    
+
     def _review_readability(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        context: Optional[str]
+        context: Optional[str],
     ) -> str:
         """Review code readability."""
         response = "📋 READABILITY REVIEW:\n\n"
-        
+
         response += "**Readability Factors:**\n"
-        
+
         if code_snippets:
-            total_lines = sum(snippet.count('\n') + 1 for snippet in code_snippets)
-            avg_line_length = sum(len(line) for snippet in code_snippets for line in snippet.split('\n')) / max(total_lines, 1)
-            
+            total_lines = sum(snippet.count("\n") + 1 for snippet in code_snippets)
+            avg_line_length = sum(
+                len(line) for snippet in code_snippets for line in snippet.split("\n")
+            ) / max(total_lines, 1)
+
             if avg_line_length < 80:
                 response += "✓ Line lengths are reasonable\n"
             else:
-                response += "• Some lines might be too long, consider breaking them up\n"
-            
+                response += (
+                    "• Some lines might be too long, consider breaking them up\n"
+                )
+
             # Check naming
             has_good_names = any(
-                any(word in snippet for word in ['Add', 'Get', 'Set', 'Create', 'Update', 'Delete'])
+                any(
+                    word in snippet
+                    for word in ["Add", "Get", "Set", "Create", "Update", "Delete"]
+                )
                 for snippet in code_snippets
             )
             if has_good_names:
                 response += "✓ Function/method names appear descriptive\n"
-        
+
         response += "\n**Readability Suggestions:**\n"
         response += "• Use meaningful variable and function names\n"
         response += "• Keep functions focused on a single responsibility\n"
         response += "• Add comments for complex logic sections\n"
         response += "• Maintain consistent indentation and formatting\n"
-        
+
         response += "\n**Overall:** Code readability appears acceptable with room for minor improvements."
-        
+
         return response
-    
+
     def _review_maintainability(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        context: Optional[str]
+        context: Optional[str],
     ) -> str:
         """Review maintainability aspects."""
         response = "📋 MAINTAINABILITY REVIEW:\n\n"
-        
+
         response += "**Maintainability Factors:**\n"
-        
+
         # Check file organization
         if file_paths:
             if len(file_paths) == 1:
                 response += "✓ Changes are localized to a single file\n"
             else:
                 response += "✓ Changes are logically distributed across files\n"
-        
+
         # Check for modularity in code
         if code_snippets:
             function_count = sum(
-                snippet.count('func ') + snippet.count('def ') + snippet.count('function ')
+                snippet.count("func ")
+                + snippet.count("def ")
+                + snippet.count("function ")
                 for snippet in code_snippets
             )
             if function_count > 0:
                 response += "✓ Code is broken into functions/methods\n"
-        
+
         response += "\n**Maintainability Considerations:**\n"
         response += "• Is the code modular and reusable?\n"
         response += "• Are dependencies clearly defined?\n"
         response += "• Will future developers understand the intent?\n"
         response += "• Is the code structured to allow easy updates?\n"
-        
+
         response += "\n**Recommendations:**\n"
         response += "• Consider extracting common patterns into utilities\n"
         response += "• Ensure consistent patterns across the codebase\n"
         response += "• Document any non-obvious design decisions\n"
-        
+
         return response
-    
+
     def _review_testing(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        context: Optional[str]
+        context: Optional[str],
     ) -> str:
         """Review testing aspects."""
         response = "📋 TESTING REVIEW:\n\n"
-        
+
         has_test_files = any("test" in str(path).lower() for path in (file_paths or []))
-        
+
         if has_test_files:
             response += "✓ Test files are included with the changes\n\n"
         else:
             response += "⚠️ No test files detected in the changes\n\n"
-        
+
         response += "**Testing Checklist:**\n"
         response += "□ Unit tests for new functions\n"
         response += "□ Integration tests for feature interactions\n"
         response += "□ Edge case coverage\n"
         response += "□ Error condition testing\n"
         response += "□ Performance tests (if applicable)\n"
-        
+
         response += "\n**Testing Recommendations:**\n"
         response += "• Write tests that document expected behavior\n"
         response += "• Include both positive and negative test cases\n"
         response += "• Ensure tests are maintainable and clear\n"
         response += "• Aim for good coverage of critical paths\n"
-        
+
         if not has_test_files:
             response += "\n💡 Consider adding tests to ensure reliability and prevent regressions."
-        
+
         return response
-    
+
     def _review_documentation(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        context: Optional[str]
+        context: Optional[str],
     ) -> str:
         """Review documentation aspects."""
         response = "📋 DOCUMENTATION REVIEW:\n\n"
-        
+
         # Check for documentation in code
         has_comments = False
         if code_snippets:
             has_comments = any(
-                '//' in snippet or '/*' in snippet or '#' in snippet or '"""' in snippet
+                "//" in snippet or "/*" in snippet or "#" in snippet or '"""' in snippet
                 for snippet in code_snippets
             )
-        
+
         if has_comments:
             response += "✓ Code includes some documentation\n"
         else:
             response += "• Consider adding documentation comments\n"
-        
+
         response += "\n**Documentation Guidelines:**\n"
         response += "• Document the 'why' not just the 'what'\n"
         response += "• Include examples for complex functions\n"
         response += "• Document any assumptions or limitations\n"
         response += "• Keep documentation up-to-date with code changes\n"
-        
+
         response += "\n**Recommended Documentation:**\n"
         response += "• Function/method purpose and parameters\n"
         response += "• Complex algorithm explanations\n"
         response += "• API usage examples\n"
         response += "• Configuration requirements\n"
-        
+
         return response
-    
+
     def _review_architecture(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        context: Optional[str]
+        context: Optional[str],
     ) -> str:
         """Review architectural aspects."""
         response = "📋 ARCHITECTURE REVIEW:\n\n"
-        
+
         response += "**Architectural Considerations:**\n"
-        
+
         # Analyze file structure
         if file_paths:
             # Check for separation of concerns
-            has_separation = len(set(str(p).split('/')[-2] for p in file_paths if '/' in str(p))) > 1
+            has_separation = (
+                len(set(str(p).split("/")[-2] for p in file_paths if "/" in str(p))) > 1
+            )
             if has_separation:
                 response += "✓ Changes span multiple modules (good separation)\n"
             else:
                 response += "✓ Changes are cohesive within a module\n"
-        
+
         response += "\n**Architectural Principles:**\n"
         response += "• Single Responsibility - Each component has one clear purpose\n"
         response += "• Open/Closed - Open for extension, closed for modification\n"
         response += "• Dependency Inversion - Depend on abstractions, not concretions\n"
         response += "• Interface Segregation - Keep interfaces focused and minimal\n"
-        
+
         response += "\n**Questions to Consider:**\n"
         response += "• Does this fit well with the existing architecture?\n"
         response += "• Are the right abstractions in place?\n"
         response += "• Is the coupling between components appropriate?\n"
         response += "• Will this scale as requirements grow?\n"
-        
+
         if context:
             response += f"\n**Context Impact:**\n{context}\n"
             response += "→ Ensure the architectural choices align with this context.\n"
-        
+
         return response
 
 
 class ReviewProtocol:
     """Protocol for review interactions."""
-    
+
     def __init__(self):
         self.reviewer = BalancedReviewer()
         self.review_count = 0
         self.max_reviews = 3  # Allow up to 3 reviews per task
-    
+
     def request_review(
         self,
         focus: str,
         work_description: str,
         code_snippets: Optional[List[str]] = None,
         file_paths: Optional[List[str]] = None,
-        context: Optional[str] = None
+        context: Optional[str] = None,
     ) -> str:
         """Request a balanced review."""
         if self.review_count >= self.max_reviews:
             return "📋 Review limit reached. You've received comprehensive feedback - time to finalize your implementation."
-        
+
         self.review_count += 1
-        
+
         try:
             focus_enum = ReviewFocus[focus.upper()]
         except KeyError:
             focus_enum = ReviewFocus.GENERAL
-        
+
         review = self.reviewer.review(
-            focus_enum,
-            work_description,
-            code_snippets,
-            file_paths,
-            context
+            focus_enum, work_description, code_snippets, file_paths, context
         )
-        
+
         header = f"Review {self.review_count}/{self.max_reviews} (Focus: {focus_enum.value}):\n\n"
         footer = "\n\n💡 This is a balanced review - consider both strengths and suggestions."
-        
-        return header + review + footer
+
+        return header + review + footer

hanzo_mcp/tools/agent/swarm_alias.py

@@ -0,0 +1,87 @@
+"""Swarm tool as an alias to Network tool for backward compatibility.
+
+This module makes swarm an alias to the network tool, as network is the
+evolution of swarm with better distributed execution capabilities.
+"""
+
+from hanzo_mcp.tools.agent.network_tool import NetworkTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
+
+
+class SwarmTool(NetworkTool):
+    """Swarm tool - alias to Network tool for backward compatibility.
+
+    The swarm tool is now an alias to the network tool, which provides
+    all the same functionality plus additional distributed execution modes.
+    Use 'network' for new code, 'swarm' is maintained for compatibility.
+    """
+
+    @property
+    def name(self) -> str:
+        """Get the tool name."""
+        return "swarm"
+
+    @property
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Execute a network of AI agents (alias to 'network' tool).
+
+The 'swarm' tool is now an alias to the 'network' tool for backward compatibility.
+All swarm functionality is available through network, which additionally provides:
+
+- Local-first execution with privacy preservation
+- Distributed compute across devices  
+- Hybrid mode with cloud fallback
+- Integration with hanzo-network for MCP-connected agents
+
+Examples:
+```python
+# These are equivalent:
+swarm(task="Analyze code", agents=["analyzer", "reviewer"])
+network(task="Analyze code", agents=["analyzer", "reviewer"])
+
+# Network adds new modes:
+network(task="Process data", mode="local")  # Privacy-first
+network(task="Large analysis", mode="distributed")  # Scale out
+```
+
+For new code, prefer using 'network' directly."""
+
+    def __init__(
+        self,
+        permission_manager: PermissionManager,
+        default_mode: str = "hybrid",
+        **kwargs,
+    ):
+        """Initialize swarm as an alias to network.
+
+        Args:
+            permission_manager: Permission manager
+            default_mode: Default execution mode (hybrid/local/distributed)
+            **kwargs: Additional arguments passed to NetworkTool
+        """
+        # Just pass through to NetworkTool
+        super().__init__(
+            permission_manager=permission_manager, default_mode=default_mode, **kwargs
+        )
+
+    async def call(self, **kwargs) -> str:
+        """Execute swarm via network tool.
+
+        All parameters are passed through to the network tool.
+        """
+        # For backward compatibility, rename some parameters if needed
+        if "config" in kwargs and "agents" not in kwargs:
+            # Old swarm used 'config' for agent definitions
+            config = kwargs.pop("config")
+            if isinstance(config, dict) and "agents" in config:
+                kwargs["agents"] = config["agents"]
+                if "topology" in config:
+                    kwargs["routing"] = config["topology"]
+
+        # Pass through to network tool
+        return await super().call(**kwargs)
+
+
+# For backward compatibility exports
+__all__ = ["SwarmTool"]