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

hanzo_mcp/tools/common/critic_tool.py

@@ -3,16 +3,15 @@
 This module provides the CriticTool for Claude to engage in critical analysis and code review.
 """
 
-from typing import Annotated, TypedDict, Unpack, final, override
+from typing import Unpack, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.context import create_tool_context
 
-
 Analysis = Annotated[
     str,
     Field(
@@ -189,8 +188,5 @@ Continue with improvements based on this critical review."""
         tool_self = self  # Create a reference to self for use in the closure
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def critic(
-            analysis: Analysis,
-            ctx: MCPContext
-        ) -> str:
+        async def critic(analysis: Analysis, ctx: MCPContext) -> str:
             return await tool_self.call(ctx, analysis=analysis)

hanzo_mcp/tools/common/decorators.py

@@ -4,47 +4,44 @@ This module provides decorators that handle common cross-cutting concerns
 for MCP tools, such as context normalization and error handling.
 """
 
-import functools
 import inspect
-from typing import Any, Callable, TypeVar, cast
-from collections.abc import Awaitable, Coroutine
-
-from mcp.server.fastmcp import Context as MCPContext
+import functools
+from typing import Any, TypeVar, Callable, cast
 
-F = TypeVar('F', bound=Callable[..., Any])
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 class MockContext:
     """Mock context for when no real context is available.
-    
+
     This is used when tools are called externally through the MCP protocol
     and the Context parameter is not properly serialized.
     """
-    
+
     def __init__(self):
         self.request_id = "external-request"
         self.client_id = "external-client"
-    
+
     async def info(self, message: str) -> None:
         """Mock info logging - no-op for external calls."""
         pass
-    
+
     async def debug(self, message: str) -> None:
         """Mock debug logging - no-op for external calls."""
         pass
-    
+
     async def warning(self, message: str) -> None:
         """Mock warning logging - no-op for external calls."""
         pass
-    
+
     async def error(self, message: str) -> None:
         """Mock error logging - no-op for external calls."""
         pass
-    
+
     async def report_progress(self, current: int, total: int) -> None:
         """Mock progress reporting - no-op for external calls."""
         pass
-    
+
     async def read_resource(self, uri: str) -> Any:
         """Mock resource reading - returns empty result."""
         return []
@@ -52,11 +49,11 @@ class MockContext:
 
 def with_context_normalization(func: F) -> F:
     """Decorator that normalizes the context parameter for MCP tools.
-    
+
     This decorator intercepts the ctx parameter and ensures it's a valid
     MCPContext object, even when called externally where it might be
     passed as a string, dict, or None.
-    
+
     Usage:
         @server.tool()
         @with_context_normalization
@@ -64,138 +61,143 @@ def with_context_normalization(func: F) -> F:
             # ctx is guaranteed to be a valid context object
             await ctx.info("Processing...")
             return "result"
-    
+
     Args:
         func: The async function to decorate
-        
+
     Returns:
         The decorated function with context normalization
     """
+
     @functools.wraps(func)
     async def wrapper(*args: Any, **kwargs: Any) -> Any:
         # Get function signature to find ctx parameter
         sig = inspect.signature(func)
         params = list(sig.parameters.keys())
-        
+
         # Handle ctx in kwargs
-        if 'ctx' in kwargs:
-            ctx_value = kwargs['ctx']
+        if "ctx" in kwargs:
+            ctx_value = kwargs["ctx"]
             if not _is_valid_context(ctx_value):
-                kwargs['ctx'] = MockContext()
-        
+                kwargs["ctx"] = MockContext()
+
         # Handle ctx in args (positional)
-        elif 'ctx' in params:
-            ctx_index = params.index('ctx')
+        elif "ctx" in params:
+            ctx_index = params.index("ctx")
             if ctx_index < len(args):
                 ctx_value = args[ctx_index]
                 if not _is_valid_context(ctx_value):
                     args_list = list(args)
                     args_list[ctx_index] = MockContext()
                     args = tuple(args_list)
-        
+
         # Call the original function
         return await func(*args, **kwargs)
-    
+
     return cast(F, wrapper)
 
 
 def _is_valid_context(ctx: Any) -> bool:
     """Check if an object is a valid MCPContext.
-    
+
     Args:
         ctx: The object to check
-        
+
     Returns:
         True if ctx is a valid context object
     """
     # Check for required context methods
     return (
-        hasattr(ctx, 'info') and 
-        hasattr(ctx, 'debug') and
-        hasattr(ctx, 'warning') and
-        hasattr(ctx, 'error') and
-        hasattr(ctx, 'report_progress') and
+        hasattr(ctx, "info")
+        and hasattr(ctx, "debug")
+        and hasattr(ctx, "warning")
+        and hasattr(ctx, "error")
+        and hasattr(ctx, "report_progress")
+        and
         # Ensure they're callable
-        callable(getattr(ctx, 'info', None)) and
-        callable(getattr(ctx, 'debug', None))
+        callable(getattr(ctx, "info", None))
+        and callable(getattr(ctx, "debug", None))
     )
 
 
 def mcp_tool(
-    server: Any,
-    name: str | None = None,
-    description: str | None = None
+    server: Any, name: str | None = None, description: str | None = None
 ) -> Callable[[F], F]:
     """Enhanced MCP tool decorator that includes context normalization.
-    
+
     This decorator combines the standard MCP tool registration with
     automatic context normalization, providing a single-point solution
     for all tools.
-    
+
     Usage:
         @mcp_tool(server, name="my_tool", description="Does something")
         async def my_tool(ctx: MCPContext, param: str) -> str:
             await ctx.info("Processing...")
             return "result"
-    
+
     Args:
         server: The MCP server instance
         name: Optional tool name (defaults to function name)
         description: Optional tool description
-        
+
     Returns:
         Decorator function
     """
+
     def decorator(func: F) -> F:
         # Apply context normalization first
         normalized_func = with_context_normalization(func)
-        
+
         # Then apply the server's tool decorator
-        if hasattr(server, 'tool'):
+        if hasattr(server, "tool"):
             # Use the server's tool decorator
             server_decorator = server.tool(name=name, description=description)
             return server_decorator(normalized_func)
         else:
             # Fallback if server doesn't have tool method
             return normalized_func
-    
+
     return decorator
 
 
 def create_tool_handler(server: Any, tool: Any) -> Callable[[], None]:
     """Create a standardized tool registration handler.
-    
+
     This function creates a registration method that automatically applies
     context normalization to any tool handler registered with the server.
-    
+
     Usage:
         class MyTool(BaseTool):
             def register(self, mcp_server):
                 register = create_tool_handler(mcp_server, self)
                 register()
-    
+
     Args:
         server: The MCP server instance
         tool: The tool instance with name, description, and handler
-        
+
     Returns:
         A function that registers the tool with context normalization
     """
+
     def register_with_normalization():
         # Get the original register method
         original_register = tool.__class__.register
-        
+
         # Temporarily replace server.tool to wrap with normalization
         original_tool_decorator = server.tool
-        
+
         def normalized_tool_decorator(name=None, description=None):
             def decorator(func):
                 # Apply context normalization
                 normalized = with_context_normalization(func)
                 # Apply original decorator
-                return original_tool_decorator(name=name, description=description)(normalized)
+                return original_tool_decorator(name=name, description=description)(
+                    normalized
+                )
+
             return decorator
-        
+
         # Monkey-patch temporarily
         server.tool = normalized_tool_decorator
         try:
@@ -204,5 +206,5 @@ def create_tool_handler(server: Any, tool: Any) -> Callable[[], None]:
         finally:
             # Restore original
             server.tool = original_tool_decorator
-    
-    return register_with_normalization
+
+    return register_with_normalization

hanzo_mcp/tools/common/enhanced_base.py

@@ -5,9 +5,9 @@ context normalization and other cross-cutting concerns, ensuring
 consistent behavior across all tools.
 """
 
-from abc import ABC, abstractmethod
-from typing import Any, get_type_hints, get_args, get_origin
 import inspect
+from abc import ABC, abstractmethod
+from typing import Any, get_type_hints
 
 from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
@@ -18,40 +18,37 @@ from hanzo_mcp.tools.common.decorators import with_context_normalization
 
 class EnhancedBaseTool(BaseTool, ABC):
     """Enhanced base class for MCP tools with automatic context normalization.
-    
+
     This base class automatically wraps the tool registration to include
     context normalization, ensuring that all tools handle external calls
     properly without requiring manual decoration or copy-pasted code.
     """
-    
+
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with automatic context normalization.
-        
+
         This method automatically applies context normalization to the tool
         handler, ensuring it works properly when called externally.
-        
+
         Args:
             mcp_server: The FastMCP server instance
         """
         # Get the tool method from the subclass
         tool_method = self._create_tool_handler()
-        
+
         # Apply context normalization decorator
         normalized_method = with_context_normalization(tool_method)
-        
+
         # Register with the server
-        mcp_server.tool(
-            name=self.name,
-            description=self.description
-        )(normalized_method)
-    
+        mcp_server.tool(name=self.name, description=self.description)(normalized_method)
+
     @abstractmethod
     def _create_tool_handler(self) -> Any:
         """Create the tool handler function.
-        
+
         Subclasses must implement this to return an async function
         that will be registered as the tool handler.
-        
+
         Returns:
             An async function that handles tool calls
         """
@@ -60,47 +57,47 @@ class EnhancedBaseTool(BaseTool, ABC):
 
 class AutoRegisterTool(BaseTool, ABC):
     """Base class that automatically generates tool handlers from the call method.
-    
+
     This base class inspects the call method signature and automatically
     creates a properly typed tool handler with context normalization.
     """
-    
+
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with automatic handler generation.
-        
+
         This method inspects the call method signature and automatically
         creates a tool handler with the correct parameters and types.
-        
+
         Args:
             mcp_server: The FastMCP server instance
         """
         # Get the call method signature
         call_method = self.call
         sig = inspect.signature(call_method)
-        
+
         # Get type hints for proper typing
         hints = get_type_hints(call_method)
-        
+
         # Create a dynamic handler function
         tool_self = self
-        
+
         # Build the handler dynamically based on the call signature
         params = list(sig.parameters.items())
-        
+
         # Skip 'self' and 'ctx' parameters
-        tool_params = [(name, param) for name, param in params 
-                      if name not in ('self', 'ctx')]
-        
+        tool_params = [
+            (name, param) for name, param in params if name not in ("self", "ctx")
+        ]
+
         # Create the handler function dynamically
         async def handler(ctx: MCPContext, **kwargs: Any) -> Any:
             # Call the tool's call method with the context and parameters
             return await tool_self.call(ctx, **kwargs)
-        
+
         # Apply context normalization
         normalized_handler = with_context_normalization(handler)
-        
+
         # Register with the server
-        mcp_server.tool(
-            name=self.name,
-            description=self.description
-        )(normalized_handler)
+        mcp_server.tool(name=self.name, description=self.description)(
+            normalized_handler
+        )