hanzo-mcp 0.1.36__py3-none-any.whl → 0.3.1__py3-none-any.whl

hanzo_mcp/__init__.py

@@ -1,3 +1,3 @@
 """Hanzo MCP - Implementation of Hanzo capabilities using MCP."""
 
-__version__ = "0.1.36"
+__version__ = "0.3.1"

hanzo_mcp/cli.py

@@ -1,21 +1,42 @@
-"""Command-line interface for the Hanzo MCP server."""
+"""Command-line interface for the Hanzo MCP server.
+
+Includes logging configuration and enhanced error handling.
+"""
 
 import argparse
 import json
+import logging
 import os
 import sys
 from pathlib import Path
 from typing import Any, cast
 
+from hanzo_mcp import __version__
+from hanzo_mcp.tools.common.logging_config import setup_logging
+
 from hanzo_mcp.server import HanzoServer
-from hanzo_mcp.tools.common.path_utils import PathUtils
 
 
 def main() -> None:
     """Run the CLI for the Hanzo MCP server."""
+    # Initialize logger
+    logger = logging.getLogger(__name__)
+    
+    # Check if 'version' is the first argument
+    if len(sys.argv) > 1 and sys.argv[1] == 'version':
+        print(f"hanzo-mcp {__version__}")
+        return
+        
     parser = argparse.ArgumentParser(
         description="MCP server implementing Hanzo capabilities"
     )
+    
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show the current version and exit"
+    )
 
     _ = parser.add_argument(
         "--transport",
@@ -24,6 +45,19 @@ def main() -> None:
         help="Transport protocol to use (default: stdio)",
     )
 
+    _ = parser.add_argument(
+        "--port",
+        type=int,
+        default=3001,
+        help="Port to use for SSE transport (default: 3001)",
+    )
+
+    _ = parser.add_argument(
+        "--host",
+        default="0.0.0.0",
+        help="Host to bind to for SSE transport (default: 0.0.0.0)",
+    )
+
     _ = parser.add_argument(
         "--name",
         default="claude-code",
@@ -40,26 +74,26 @@ def main() -> None:
     _ = parser.add_argument(
         "--project-dir", dest="project_dir", help="Set the project directory to analyze"
     )
-    
+
     _ = parser.add_argument(
         "--agent-model",
         dest="agent_model",
         help="Specify the model name in LiteLLM format (e.g., 'openai/gpt-4o', 'anthropic/claude-3-sonnet')"
     )
-    
+
     _ = parser.add_argument(
         "--agent-max-tokens",
         dest="agent_max_tokens",
         type=int,
         help="Specify the maximum tokens for agent responses"
     )
-    
+
     _ = parser.add_argument(
         "--agent-api-key",
         dest="agent_api_key",
         help="Specify the API key for the LLM provider (for development/testing only)"
     )
-    
+
     _ = parser.add_argument(
         "--agent-max-iterations",
         dest="agent_max_iterations",
@@ -67,7 +101,7 @@ def main() -> None:
         default=10,
         help="Maximum number of iterations for agent (default: 10)"
     )
-    
+
     _ = parser.add_argument(
         "--agent-max-tool-uses",
         dest="agent_max_tool_uses",
@@ -75,7 +109,7 @@ def main() -> None:
         default=30,
         help="Maximum number of total tool uses for agent (default: 30)"
     )
-    
+
     _ = parser.add_argument(
         "--enable-agent-tool",
         dest="enable_agent_tool",
@@ -84,6 +118,30 @@ def main() -> None:
         help="Enable the agent tool (disabled by default)"
     )
 
+    _ = parser.add_argument(
+        "--log-level",
+        dest="log_level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
+        help="Set the logging level (default: INFO)"
+    )
+
+    _ = parser.add_argument(
+        "--disable-file-logging",
+        dest="disable_file_logging",
+        action="store_true",
+        default=False,
+        help="Disable logging to file (logs to console only)"
+    )
+
+    _ = parser.add_argument(
+        "--disable-write-tools",
+        dest="disable_write_tools",
+        action="store_true",
+        default=False,
+        help="Disable write/edit tools (file writing, editing, notebook editing) to use IDE tools instead. Note: Shell commands can still modify files."
+    )
+
     _ = parser.add_argument(
         "--install",
         action="store_true",
@@ -96,6 +154,8 @@ def main() -> None:
     name: str = cast(str, args.name)
     install: bool = cast(bool, args.install)
     transport: str = cast(str, args.transport)
+    port: int = cast(int, args.port)
+    host: str = cast(str, args.host)
     project_dir: str | None = cast(str | None, args.project_dir)
     agent_model: str | None = cast(str | None, args.agent_model)
     agent_max_tokens: int | None = cast(int | None, args.agent_max_tokens)
@@ -103,55 +163,88 @@ def main() -> None:
     agent_max_iterations: int = cast(int, args.agent_max_iterations)
     agent_max_tool_uses: int = cast(int, args.agent_max_tool_uses)
     enable_agent_tool: bool = cast(bool, args.enable_agent_tool)
+    disable_write_tools: bool = cast(bool, args.disable_write_tools)
+    log_level: str = cast(str, args.log_level)
+    disable_file_logging: bool = cast(bool, args.disable_file_logging)
     allowed_paths: list[str] = (
         cast(list[str], args.allowed_paths) if args.allowed_paths else []
     )
 
+    # Setup logging
+    setup_logging(log_level=log_level, log_to_file=not disable_file_logging, testing="pytest" in sys.modules)
+    logger.debug(f"Hanzo MCP CLI started with arguments: {args}")
+
+
     if install:
-        install_claude_desktop_config(name, allowed_paths)
+        install_claude_desktop_config(name, allowed_paths, host, port)
         return
 
     # If no allowed paths are specified, use the user's home directory
     if not allowed_paths:
         allowed_paths = [str(Path.home())]
-        
-    # Normalize all allowed paths
-    allowed_paths = [PathUtils.normalize_path(path) for path in allowed_paths]
+        logger.info(f"No allowed paths specified, using home directory: {allowed_paths[0]}")
 
-    # If project directory is specified, normalize it and add to allowed paths
+    # If project directory is specified, add it to allowed paths
+    if project_dir and project_dir not in allowed_paths:
+        allowed_paths.append(project_dir)
+
+    # Set project directory as initial working directory if provided
     if project_dir:
-        project_dir = PathUtils.normalize_path(project_dir)
-        if project_dir not in allowed_paths:
-            allowed_paths.append(project_dir)
+        # Expand user paths
+        project_dir = os.path.expanduser(project_dir)
+        # Make absolute
+        if not os.path.isabs(project_dir):
+            project_dir = os.path.abspath(project_dir)
 
     # If no specific project directory, use the first allowed path
-    if not project_dir and allowed_paths:
+    elif allowed_paths:
         project_dir = allowed_paths[0]
 
     # Run the server
-    server = HanzoServer(
-        name=name, 
-        allowed_paths=allowed_paths,
-        project_dir=project_dir,  # Pass project_dir for initial working directory
-        agent_model=agent_model,
-        agent_max_tokens=agent_max_tokens,
-        agent_api_key=agent_api_key,
-        agent_max_iterations=agent_max_iterations,
-        agent_max_tool_uses=agent_max_tool_uses,
-        enable_agent_tool=enable_agent_tool
-    )
-    # Transport will be automatically cast to Literal['stdio', 'sse'] by the server
-    server.run(transport=transport)
+    logger.info(f"Starting Hanzo MCP server with name: {name}")
+    logger.debug(f"Allowed paths: {allowed_paths}")
+    logger.debug(f"Project directory: {project_dir}")
+
+    try:
+        server = HanzoServer(
+            name=name,
+            allowed_paths=allowed_paths,
+            project_dir=project_dir,  # Pass project_dir for initial working directory
+            agent_model=agent_model,
+            agent_max_tokens=agent_max_tokens,
+            agent_api_key=agent_api_key,
+            agent_max_iterations=agent_max_iterations,
+            agent_max_tool_uses=agent_max_tool_uses,
+            enable_agent_tool=enable_agent_tool,
+            disable_write_tools=disable_write_tools,
+            host=host,
+            port=port
+        )
+        logger.info(f"Server initialized successfully, running with transport: {transport}")
+        # Transport will be automatically cast to Literal['stdio', 'sse'] by the server
+        server.run(transport=transport)
+    except Exception as e:
+        logger.error(f"Error starting server: {str(e)}")
+        logger.exception("Server startup failed with exception:")
+        # Re-raise the exception for proper error handling
+        raise
 
 
 def install_claude_desktop_config(
-    name: str = "claude-code", allowed_paths: list[str] | None = None
+    name: str = "claude-code", allowed_paths: list[str] | None = None,
+    disable_write_tools: bool = False,
+    host: str = "0.0.0.0", port: int = 3001
 ) -> None:
     """Install the server configuration in Claude Desktop.
 
     Args:
         name: The name to use for the server in the config
         allowed_paths: Optional list of paths to allow
+        disable_write_tools: Whether to disable write/edit tools (file writing, editing, notebook editing)
+                          to use IDE tools instead. Note: Shell commands can still modify files.
+                          (default: False)
+        host: Host to bind to for SSE transport (default: '0.0.0.0')
+        port: Port to use for SSE transport (default: 3001)
     """
     # Find the Claude Desktop config directory
     home: Path = Path.home()
@@ -182,6 +275,18 @@ def install_claude_desktop_config(
         # Allow home directory by default
         args.extend(["--allow-path", str(home)])
 
+    # Add host and port
+    args.extend(["--host", host])
+    args.extend(["--port", str(port)])
+
+    # Add disable_write_tools flag if specified
+    if disable_write_tools:
+        args.append("--disable-write-tools")
+
+    # Add host and port
+    args.extend(["--host", host])
+    args.extend(["--port", str(port)])
+
     # Create config object
     config: dict[str, Any] = {
         "mcpServers": {name: {"command": str(script_path), "args": args}}

hanzo_mcp/server.py

@@ -1,4 +1,7 @@
-"""MCP server implementing Hanzo capabilities."""
+"""MCP server implementing Hanzo capabilities.
+
+Includes improved error handling and debugging for tool execution.
+"""
 
 from typing import Literal, cast, final
 
@@ -6,7 +9,6 @@ from mcp.server.fastmcp import FastMCP
 
 from hanzo_mcp.tools import register_all_tools
 from hanzo_mcp.tools.common.context import DocumentContext
-from hanzo_mcp.tools.common.path_utils import PathUtils
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.project.analysis import ProjectAnalyzer, ProjectManager
 from hanzo_mcp.tools.shell.command_executor import CommandExecutor
@@ -14,7 +16,10 @@ from hanzo_mcp.tools.shell.command_executor import CommandExecutor
 
 @final
 class HanzoServer:
-    """MCP server implementing Hanzo capabilities."""
+    """MCP server implementing Hanzo capabilities.
+
+Includes improved error handling and debugging for tool execution.
+"""
 
     def __init__(
         self,
@@ -28,6 +33,9 @@ class HanzoServer:
         agent_max_iterations: int = 10,
         agent_max_tool_uses: int = 30,
         enable_agent_tool: bool = False,
+        disable_write_tools: bool = False,
+        host: str = "0.0.0.0",
+        port: int = 3001,
     ):
         """Initialize the Hanzo server.
 
@@ -42,6 +50,9 @@ class HanzoServer:
             agent_max_iterations: Maximum number of iterations for agent (default: 10)
             agent_max_tool_uses: Maximum number of total tool uses for agent (default: 30)
             enable_agent_tool: Whether to enable the agent tool (default: False)
+            disable_write_tools: Whether to disable write/edit tools (default: False)
+            host: Host to bind to for SSE transport (default: '0.0.0.0')
+            port: Port to use for SSE transport (default: 3001)
         """
         self.mcp = mcp_instance if mcp_instance is not None else FastMCP(name)
 
@@ -54,7 +65,7 @@ class HanzoServer:
             permission_manager=self.permission_manager,
             verbose=False,  # Set to True for debugging
         )
-        
+
         # If project_dir is specified, set it as initial working directory for all sessions
         if project_dir:
             initial_session_id = name  # Use server name as default session ID
@@ -71,10 +82,8 @@ class HanzoServer:
         # Add allowed paths
         if allowed_paths:
             for path in allowed_paths:
-                # Path should already be normalized from CLI, but normalize here for safety
-                normalized_path = PathUtils.normalize_path(path)
-                self.permission_manager.add_allowed_path(normalized_path)
-                self.document_context.add_allowed_path(normalized_path)
+                self.permission_manager.add_allowed_path(path)
+                self.document_context.add_allowed_path(path)
 
         # Store agent options
         self.agent_model = agent_model
@@ -83,7 +92,12 @@ class HanzoServer:
         self.agent_max_iterations = agent_max_iterations
         self.agent_max_tool_uses = agent_max_tool_uses
         self.enable_agent_tool = enable_agent_tool
-        
+        self.disable_write_tools = disable_write_tools
+
+        # Store network options
+        self.host = host
+        self.port = port
+
         # Register all tools
         register_all_tools(
             mcp_server=self.mcp,
@@ -95,6 +109,7 @@ class HanzoServer:
             agent_max_iterations=self.agent_max_iterations,
             agent_max_tool_uses=self.agent_max_tool_uses,
             enable_agent_tool=self.enable_agent_tool,
+            disable_write_tools=self.disable_write_tools,
         )
 
     def run(self, transport: str = "stdio", allowed_paths: list[str] | None = None):
@@ -107,10 +122,16 @@ class HanzoServer:
         # Add allowed paths if provided
         allowed_paths_list = allowed_paths or []
         for path in allowed_paths_list:
-            # Normalize path before adding
-            normalized_path = PathUtils.normalize_path(path)
-            self.permission_manager.add_allowed_path(normalized_path)
-            self.document_context.add_allowed_path(normalized_path)
+            self.permission_manager.add_allowed_path(path)
+            self.document_context.add_allowed_path(path)
+
+        # If using SSE, set the port and host in the environment variables
+        if transport == "sse":
+            import os
+            # Set environment variables for FastMCP settings
+            os.environ["FASTMCP_PORT"] = str(self.port)
+            os.environ["FASTMCP_HOST"] = self.host
+            print(f"Starting SSE server on {self.host}:{self.port}")
 
         # Run the server
         transport_type = cast(Literal["stdio", "sse"], transport)

hanzo_mcp/tools/__init__.py

@@ -32,6 +32,7 @@ def register_all_tools(
     agent_max_iterations: int = 10,
     agent_max_tool_uses: int = 30,
     enable_agent_tool: bool = False,
+    disable_write_tools: bool = False,
 ) -> None:
     """Register all Hanzo tools with the MCP server.
 
@@ -45,12 +46,13 @@ def register_all_tools(
         agent_max_iterations: Maximum number of iterations for agent (default: 10)
         agent_max_tool_uses: Maximum number of total tool uses for agent (default: 30)
         enable_agent_tool: Whether to enable the agent tool (default: False)
+        disable_write_tools: Whether to disable write/edit tools (default: False)
     """
     # Register all filesystem tools
-    register_filesystem_tools(mcp_server, document_context, permission_manager)
+    register_filesystem_tools(mcp_server, document_context, permission_manager, disable_write_tools)
 
     # Register all jupyter tools
-    register_jupyter_tools(mcp_server, document_context, permission_manager)
+    register_jupyter_tools(mcp_server, document_context, permission_manager, disable_write_tools)
 
     # Register shell tools
     register_shell_tools(mcp_server, permission_manager)

hanzo_mcp/tools/agent/base_provider.py

@@ -0,0 +1,73 @@
+"""Base model provider for agent delegation.
+
+Defines the interface for model providers.
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class BaseModelProvider(ABC):
+    """Base class for model providers."""
+    
+    @abstractmethod
+    async def initialize(self) -> None:
+        """Initialize the provider."""
+        pass
+        
+    @abstractmethod
+    async def load_model(self, model_name: str, identifier: Optional[str] = None) -> str:
+        """Load a model.
+        
+        Args:
+            model_name: The name of the model to load
+            identifier: Optional identifier for the model instance
+            
+        Returns:
+            The identifier for the loaded model
+        """
+        pass
+        
+    @abstractmethod
+    async def generate(
+        self,
+        model_id: str,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.7,
+        top_p: float = 0.95,
+        stop_sequences: Optional[List[str]] = None,
+    ) -> Tuple[str, Dict[str, Any]]:
+        """Generate a response from the model.
+        
+        Args:
+            model_id: The identifier of the model to use
+            prompt: The prompt to send to the model
+            system_prompt: Optional system prompt to send to the model
+            max_tokens: Maximum number of tokens to generate
+            temperature: Sampling temperature
+            top_p: Top-p sampling parameter
+            stop_sequences: Optional list of strings that will stop generation
+            
+        Returns:
+            A tuple of (generated text, metadata)
+        """
+        pass
+        
+    @abstractmethod
+    async def unload_model(self, model_id: str) -> None:
+        """Unload a model.
+        
+        Args:
+            model_id: The identifier of the model to unload
+        """
+        pass
+        
+    @abstractmethod
+    async def shutdown(self) -> None:
+        """Shutdown the provider."""
+        pass

hanzo_mcp/tools/agent/litellm_provider.py

@@ -0,0 +1,45 @@
+"""LiteLLM provider for agent delegation.
+
+Enables the use of various cloud LLM providers via LiteLLM.
+"""
+
+import asyncio
+import logging
+import json
+from typing import Any, Dict, List, Optional, Tuple
+
+from hanzo_mcp.tools.agent.base_provider import BaseModelProvider
+
+logger = logging.getLogger(__name__)
+
+# Define model capabilities
+DEFAULT_MAX_TOKENS = 4096
+DEFAULT_CONTEXT_WINDOW = 8192
+
+
+class LiteLLMProvider(BaseModelProvider):
+    """Provider for cloud models via LiteLLM."""
+
+    def __init__(self):
+        """Initialize the LiteLLM provider."""
+        self.models = {}
+        self.initialized = False
+        
+    async def initialize(self) -> None:
+        """Initialize the LiteLLM provider."""
+        if self.initialized:
+            return
+            
+        try:
+            # Import LiteLLM
+            import litellm
+            self.litellm = litellm
+            self.initialized = True
+            logger.info("LiteLLM provider initialized successfully")
+        except ImportError:
+            logger.error("Failed to import LiteLLM")
+            logger.error("Install LiteLLM with 'pip install litellm'")
+        except Exception as e:
+            logger.error(f"Failed to initialize LiteLLM provider: {str(e)}")
+            
+    async def load_model(self, model_name: str, identifier: Optional[str] = None