hanzo-mcp 0.3.8__py3-none-any.whl → 0.5.1__py3-none-any.whl

hanzo_mcp/tools/agent/provider_registry.py

@@ -1,120 +0,0 @@
-"""Provider registry for agent delegation.
-
-Manages different model providers for agent delegation.
-"""
-
-import logging
-from typing import Any, Dict, List, Optional, Tuple, Type
-
-from hanzo_mcp.tools.agent.base_provider import BaseModelProvider
-
-logger = logging.getLogger(__name__)
-
-
-class ProviderRegistry:
-    """Registry for model providers."""
-    
-    _instance = None
-    
-    def __new__(cls):
-        """Singleton pattern to ensure only one registry instance exists."""
-        if cls._instance is None:
-            cls._instance = super(ProviderRegistry, cls).__new__(cls)
-            cls._instance._initialized = False
-        return cls._instance
-        
-    def __init__(self):
-        """Initialize the provider registry."""
-        if self._initialized:
-            return
-            
-        self.providers = {}
-        self.provider_classes = {}
-        self._initialized = True
-        logger.info("Provider registry initialized")
-        
-    def register_provider_class(self, provider_type: str, provider_class: Type[BaseModelProvider]) -> None:
-        """Register a provider class with the registry.
-        
-        Args:
-            provider_type: The type identifier for the provider
-            provider_class: The provider class to register
-        """
-        self.provider_classes[provider_type] = provider_class
-        logger.info(f"Registered provider class: {provider_type}")
-        
-    async def get_provider(self, provider_type: str) -> BaseModelProvider:
-        """Get or create a provider instance for the given type.
-        
-        Args:
-            provider_type: The type identifier for the provider
-            
-        Returns:
-            A provider instance
-            
-        Raises:
-            ValueError: If the provider type is not registered
-        """
-        # Check if we already have an instance
-        if provider_type in self.providers:
-            return self.providers[provider_type]
-            
-        # Check if we have a class for this type
-        if provider_type not in self.provider_classes:
-            raise ValueError(f"Unknown provider type: {provider_type}")
-            
-        # Create a new instance
-        provider_class = self.provider_classes[provider_type]
-        provider = provider_class()
-        
-        # Initialize the provider
-        await provider.initialize()
-        
-        # Store and return the provider
-        self.providers[provider_type] = provider
-        logger.info(f"Created and initialized provider: {provider_type}")
-        return provider
-        
-    async def shutdown_all(self) -> None:
-        """Shutdown all providers."""
-        for provider_type, provider in self.providers.items():
-            try:
-                await provider.shutdown()
-                logger.info(f"Provider shut down: {provider_type}")
-            except Exception as e:
-                logger.error(f"Failed to shut down provider {provider_type}: {str(e)}")
-                
-        self.providers = {}
-        logger.info("All providers shut down")
-        
-    async def shutdown_provider(self, provider_type: str) -> None:
-        """Shutdown a specific provider.
-        
-        Args:
-            provider_type: The type identifier for the provider
-        """
-        if provider_type not in self.providers:
-            logger.warning(f"Provider not found: {provider_type}")
-            return
-            
-        try:
-            await self.providers[provider_type].shutdown()
-            del self.providers[provider_type]
-            logger.info(f"Provider shut down: {provider_type}")
-        except Exception as e:
-            logger.error(f"Failed to shut down provider {provider_type}: {str(e)}")
-
-
-# Create a singleton instance
-registry = ProviderRegistry()
-
-# Register LiteLLM provider
-from hanzo_mcp.tools.agent.litellm_provider import LiteLLMProvider
-registry.register_provider_class("litellm", LiteLLMProvider)
-
-# Try to register LM Studio provider if available
-try:
-    from hanzo_mcp.tools.agent.lmstudio_provider import LMStudioProvider
-    registry.register_provider_class("lmstudio", LMStudioProvider)
-except ImportError:
-    logger.warning("LM Studio provider not available. Install the package if needed.")

hanzo_mcp/tools/common/error_handling.py

@@ -1,86 +0,0 @@
-"""Error handling utilities for MCP tools.
-
-This module provides utility functions for better error handling in MCP tools.
-"""
-
-import logging
-import traceback
-from functools import wraps
-from typing import Any, Callable, TypeVar, Awaitable, cast
-
-from mcp.server.fastmcp import Context as MCPContext
-
-# Setup logger
-logger = logging.getLogger(__name__)
-
-# Type variables for generic function signatures
-T = TypeVar('T')
-F = TypeVar('F', bound=Callable[..., Awaitable[Any]])
-
-
-async def log_error(ctx: MCPContext, error: Exception, message: str) -> None:
-    """Log an error to both the logger and the MCP context.
-    
-    Args:
-        ctx: The MCP context
-        error: The exception that occurred
-        message: A descriptive message about the error
-    """
-    error_message = f"{message}: {str(error)}"
-    stack_trace = "".join(traceback.format_exception(type(error), error, error.__traceback__))
-    
-    # Log to system logger
-    logger.error(error_message)
-    logger.debug(stack_trace)
-    
-    # Log to MCP context if available
-    try:
-        await ctx.error(error_message)
-    except Exception as e:
-        logger.error(f"Failed to log error to MCP context: {str(e)}")
-
-
-def tool_error_handler(func: F) -> F:
-    """Decorator for handling errors in tool execution.
-    
-    This decorator wraps a tool function to catch and properly handle exceptions,
-    ensuring they are logged and proper error messages are returned.
-    
-    Args:
-        func: The async tool function to wrap
-        
-    Returns:
-        Wrapped function with error handling
-    """
-    @wraps(func)
-    async def wrapper(*args: Any, **kwargs: Any) -> Any:
-        try:
-            # Extract the MCP context from arguments
-            ctx = None
-            for arg in args:
-                if isinstance(arg, MCPContext):
-                    ctx = arg
-                    break
-            
-            if not ctx and 'ctx' in kwargs:
-                ctx = kwargs['ctx']
-                
-            if not ctx:
-                logger.warning("No MCP context found in tool arguments, error handling will be limited")
-            
-            # Call the original function
-            return await func(*args, **kwargs)
-        except Exception as e:
-            # Log the error
-            error_message = f"Error in tool execution: {func.__name__}"
-            if ctx:
-                await log_error(ctx, e, error_message)
-            else:
-                stack_trace = "".join(traceback.format_exception(type(e), e, e.__traceback__))
-                logger.error(f"{error_message}: {str(e)}")
-                logger.debug(stack_trace)
-            
-            # Return a friendly error message
-            return f"Error executing {func.__name__}: {str(e)}"
-    
-    return cast(F, wrapper)

hanzo_mcp/tools/common/logging_config.py

@@ -1,115 +0,0 @@
-"""Logging configuration for Hanzo MCP.
-
-This module sets up logging for the Hanzo MCP project.
-"""
-
-import logging
-import os
-import sys
-from datetime import datetime
-from pathlib import Path
-from typing import Optional
-
-
-def setup_logging(
-    log_level: str = "INFO", 
-    log_to_file: bool = True, 
-    log_to_console: bool = False,  # Changed default to False
-    transport: Optional[str] = None,
-    testing: bool = False
-) -> None:
-    """Set up logging configuration.
-    
-    Args:
-        log_level: The logging level ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
-        log_to_file: Whether to log to a file in addition to the console (default: True)
-        log_to_console: Whether to log to the console (default: False to avoid stdio transport conflicts)
-        transport: The transport mechanism being used ("stdio" or "sse")
-        testing: Set to True to disable file operations for testing
-    """
-    # Convert string log level to logging constant
-    numeric_level = getattr(logging, log_level.upper(), None)
-    if not isinstance(numeric_level, int):
-        raise ValueError(f"Invalid log level: {log_level}")
-    
-    # Create logs directory if needed
-    log_dir = Path.home() / ".hanzo" / "logs"
-    if log_to_file and not testing:
-        log_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Generate log filename based on current date
-    current_time = datetime.now().strftime("%Y-%m-%d")
-    log_file = log_dir / f"hanzo-mcp-{current_time}.log"
-    
-    # Base configuration
-    handlers = []
-    
-    # Console handler - Always use stderr to avoid interfering with stdio transport
-    # Disable console logging when using stdio transport to avoid protocol corruption
-    if log_to_console and (transport != "stdio"):
-        console = logging.StreamHandler(sys.stderr)
-        console.setLevel(numeric_level)
-        console_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        console.setFormatter(console_formatter)
-        handlers.append(console)
-    
-    # File handler (if enabled)
-    if log_to_file and not testing:
-        file_handler = logging.FileHandler(log_file)
-        file_handler.setLevel(numeric_level)
-        file_formatter = logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s'
-        )
-        file_handler.setFormatter(file_formatter)
-        handlers.append(file_handler)
-    
-    # Configure root logger
-    logging.basicConfig(
-        level=numeric_level,
-        handlers=handlers,
-        force=True  # Overwrite any existing configuration
-    )
-    
-    # Set specific log levels for third-party libraries
-    logging.getLogger("urllib3").setLevel(logging.WARNING)
-    logging.getLogger("asyncio").setLevel(logging.WARNING)
-    
-    # Log startup message
-    root_logger = logging.getLogger()
-    root_logger.info(f"Logging initialized at level {log_level}")
-    if log_to_file and not testing:
-        root_logger.info(f"Log file: {log_file}")
-    if not log_to_console or transport == "stdio":
-        root_logger.info("Console logging disabled")
-
-
-def get_log_files() -> list[str]:
-    """Get a list of all log files.
-    
-    Returns:
-        List of log file paths
-    """
-    log_dir = Path.home() / ".hanzo" / "logs"
-    if not log_dir.exists():
-        return []
-    
-    log_files = [str(f) for f in log_dir.glob("hanzo-mcp-*.log")]
-    return sorted(log_files, reverse=True)
-
-
-def get_current_log_file() -> Optional[str]:
-    """Get the path to the current log file.
-    
-    Returns:
-        The path to the current log file, or None if no log file exists
-    """
-    log_dir = Path.home() / ".hanzo" / "logs"
-    if not log_dir.exists():
-        return None
-    
-    current_time = datetime.now().strftime("%Y-%m-%d")
-    log_file = log_dir / f"hanzo-mcp-{current_time}.log"
-    
-    if log_file.exists():
-        return str(log_file)
-    return None

hanzo_mcp/tools/common/session.py

@@ -1,91 +0,0 @@
-"""Session management for maintaining state across tool executions."""
-
-import os
-from pathlib import Path
-from typing import Dict, Optional, final
-
-
-@final
-class SessionManager:
-    """Manages session state across tool executions."""
-
-    _instances: Dict[str, "SessionManager"] = {}
-
-    @classmethod
-    def get_instance(cls, session_id: str) -> "SessionManager":
-        """Get or create a session manager instance for the given session ID.
-
-        Args:
-            session_id: The session ID
-
-        Returns:
-            The session manager instance
-        """
-        if session_id not in cls._instances:
-            cls._instances[session_id] = cls(session_id)
-        return cls._instances[session_id]
-
-    def __init__(self, session_id: str):
-        """Initialize the session manager.
-
-        Args:
-            session_id: The session ID
-        """
-        self.session_id = session_id
-        self._current_working_dir: Optional[Path] = None
-        self._initial_working_dir: Optional[Path] = None
-        self._environment_vars: Dict[str, str] = {}
-
-    @property
-    def current_working_dir(self) -> Path:
-        """Get the current working directory.
-
-        Returns:
-            The current working directory
-        """
-        if self._current_working_dir is None:
-            # Default to project directory if set, otherwise use current directory
-            self._current_working_dir = Path(os.getcwd())
-            self._initial_working_dir = self._current_working_dir
-        return self._current_working_dir
-
-    def set_working_dir(self, path: Path) -> None:
-        """Set the current working directory.
-
-        Args:
-            path: The path to set as the current working directory
-        """
-        self._current_working_dir = path
-
-    def reset_working_dir(self) -> None:
-        """Reset the working directory to the initial directory."""
-        if self._initial_working_dir is not None:
-            self._current_working_dir = self._initial_working_dir
-
-    def set_env_var(self, key: str, value: str) -> None:
-        """Set an environment variable.
-
-        Args:
-            key: The environment variable name
-            value: The environment variable value
-        """
-        self._environment_vars[key] = value
-
-    def get_env_var(self, key: str) -> Optional[str]:
-        """Get an environment variable.
-
-        Args:
-            key: The environment variable name
-
-        Returns:
-            The environment variable value, or None if not set
-        """
-        return self._environment_vars.get(key)
-
-    def get_env_vars(self) -> Dict[str, str]:
-        """Get all environment variables.
-
-        Returns:
-            A dictionary of environment variables
-        """
-        return self._environment_vars.copy()

hanzo_mcp/tools/common/think_tool.py

@@ -1,123 +0,0 @@
-"""Thinking tool implementation.
-
-This module provides the ThinkingTool for Claude to engage in structured thinking.
-"""
-
-from typing import Any, final, override
-
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
-
-from hanzo_mcp.tools.common.base import BaseTool
-from hanzo_mcp.tools.common.context import create_tool_context
-
-
-@final
-class ThinkingTool(BaseTool):
-    """Tool for Claude to engage in structured thinking."""
-    
-    @property
-    @override
-    def name(self) -> str:
-        """Get the tool name.
-        
-        Returns:
-            Tool name
-        """
-        return "think"
-        
-    @property
-    @override
-    def description(self) -> str:
-        """Get the tool description.
-        
-        Returns:
-            Tool description
-        """
-        return """Use the tool to think about something.
-
-It will not obtain new information or make any changes to the repository, but just log the thought. Use it when complex reasoning or brainstorming is needed. For example, if you explore the repo and discover the source of a bug, call this tool to brainstorm several unique ways of fixing the bug, and assess which change(s) are likely to be simplest and most effective. Alternatively, if you receive some test results, call this tool to brainstorm ways to fix the failing tests."""
-        
-    @property
-    @override
-    def parameters(self) -> dict[str, Any]:
-        """Get the parameter specifications for the tool.
-        
-        Returns:
-            Parameter specifications
-        """
-        return {
-            "properties": {
-                "thought": {
-                    "title": "Thought",
-                    "type": "string"
-                }
-            },
-            "required": ["thought"],
-            "title": "thinkArguments",
-            "type": "object"
-        }
-        
-    @property
-    @override
-    def required(self) -> list[str]:
-        """Get the list of required parameter names.
-        
-        Returns:
-            List of required parameter names
-        """
-        return ["thought"]
-        
-    def __init__(self) -> None:
-        """Initialize the thinking tool."""
-        pass
-        
-    @override
-    async def call(self, ctx: MCPContext, **params: Any) -> str:
-        """Execute the tool with the given parameters.
-        
-        Args:
-            ctx: MCP context
-            **params: Tool parameters
-            
-        Returns:
-            Tool result
-        """
-        tool_ctx = create_tool_context(ctx)
-        tool_ctx.set_tool_info(self.name)
-        
-        # Extract parameters
-        thought = params.get("thought")
-        
-        # Validate required thought parameter
-        if not thought:
-            await tool_ctx.error(
-                "Parameter 'thought' is required but was None or empty"
-            )
-            return "Error: Parameter 'thought' is required but was None or empty"
-
-        if thought.strip() == "":
-            await tool_ctx.error("Parameter 'thought' cannot be empty")
-            return "Error: Parameter 'thought' cannot be empty"
-
-        # Log the thought but don't take action
-        await tool_ctx.info("Thinking process recorded")
-
-        # Return confirmation
-        return "I've recorded your thinking process. You can continue with your next action based on this analysis."
-        
-    @override
-    def register(self, mcp_server: FastMCP) -> None:
-        """Register this thinking tool with the MCP server.
-        
-        Creates a wrapper function with explicitly defined parameters that match
-        the tool's parameter schema and registers it with the MCP server.
-        
-        Args:
-            mcp_server: The FastMCP server instance
-        """
-        tool_self = self  # Create a reference to self for use in the closure
-        
-        @mcp_server.tool(name=self.name, description=self.mcp_description)
-        async def think(thought: str, ctx: MCPContext) -> str:
-            return await tool_self.call(ctx, thought=thought)

hanzo_mcp/tools/common/version_tool.py

@@ -1,120 +0,0 @@
-"""Version tool for displaying project version information."""
-
-from typing import Any, Dict, TypedDict, final, override
-
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
-
-from hanzo_mcp.tools.common.base import BaseTool
-from hanzo_mcp.tools.common.context import create_tool_context
-
-
-class VersionToolResponse(TypedDict):
-    """Response from the version tool."""
-
-    version: str
-    package_name: str
-
-
-@final
-class VersionTool(BaseTool):
-    """Tool for displaying version information about the Hanzo MCP package."""
-
-    @property
-    @override
-    def name(self) -> str:
-        """Get the tool name.
-        
-        Returns:
-            Tool name
-        """
-        return "version"
-    
-    @property
-    @override
-    def description(self) -> str:
-        """Get the tool description.
-        
-        Returns:
-            Tool description
-        """
-        return "Display the current version of hanzo-mcp"
-    
-    @property
-    @override
-    def parameters(self) -> dict[str, Any]:
-        """Get the parameter specifications for the tool.
-        
-        Returns:
-            Parameter specifications
-        """
-        return {
-            "properties": {},
-            "required": [],
-            "title": "versionArguments",
-            "type": "object"
-        }
-    
-    @property
-    @override
-    def required(self) -> list[str]:
-        """Get the list of required parameter names.
-        
-        Returns:
-            List of required parameter names
-        """
-        return []
-        
-    def __init__(self, mcp_server: FastMCP) -> None:
-        """Initialize the version tool and register it with the server.
-
-        Args:
-            mcp_server: The MCP server to register with
-        """
-        self.register(mcp_server)
-
-    @override
-    async def call(self, ctx: MCPContext, **params: Any) -> str:
-        """Execute the tool with the given parameters.
-        
-        Args:
-            ctx: MCP context
-            **params: Tool parameters
-            
-        Returns:
-            Tool result with version information
-        """
-        tool_ctx = create_tool_context(ctx)
-        tool_ctx.set_tool_info(self.name)
-        
-        version_info = self.get_version()
-        await tool_ctx.info(f"Hanzo MCP version: {version_info['version']}")
-        
-        return f"Hanzo MCP version: {version_info['version']}"
-
-    def get_version(self) -> VersionToolResponse:
-        """Get the current version of the hanzo-mcp package.
-
-        Returns:
-            A dictionary containing the package name and version
-        """
-        # Directly use the __version__ from the hanzo_mcp package
-        from hanzo_mcp import __version__
-        
-        return {"version": __version__, "package_name": "hanzo-mcp"}
-        
-    @override
-    def register(self, mcp_server: FastMCP) -> None:
-        """Register this version tool with the MCP server.
-        
-        Creates a wrapper function that calls this tool's call method and
-        registers it with the MCP server.
-        
-        Args:
-            mcp_server: The FastMCP server instance
-        """
-        tool_self = self  # Create a reference to self for use in the closure
-        
-        @mcp_server.tool(name=self.name, description=self.mcp_description)
-        async def version(ctx: MCPContext) -> str:
-            return await tool_self.call(ctx)