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

hanzo_mcp/tools/agent/provider_registry.py

@@ -0,0 +1,120 @@
+"""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/__init__.py

@@ -3,7 +3,6 @@
 from mcp.server.fastmcp import FastMCP
 
 from hanzo_mcp.tools.common.base import ToolRegistry
-from hanzo_mcp.tools.common.path_utils import PathUtils
 from hanzo_mcp.tools.common.think_tool import ThinkingTool
 from hanzo_mcp.tools.common.version_tool import VersionTool
 

hanzo_mcp/tools/common/context.py

@@ -14,8 +14,6 @@ from typing import Any, ClassVar, final
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.lowlevel.helper_types import ReadResourceContents
 
-from hanzo_mcp.tools.common.path_utils import PathUtils
-
 
 @final
 class ToolContext:
@@ -181,9 +179,9 @@ class DocumentContext:
         Args:
             path: The path to allow
         """
-        # Normalize path (expand user paths and make absolute)
-        normalized_path = PathUtils.normalize_path(path)
-        resolved_path: Path = Path(normalized_path).resolve()
+        # Expand user path (e.g., ~/ or $HOME)
+        expanded_path = os.path.expanduser(path)
+        resolved_path: Path = Path(expanded_path).resolve()
         self.allowed_paths.add(resolved_path)
 
     def is_path_allowed(self, path: str) -> bool:
@@ -195,9 +193,9 @@ class DocumentContext:
         Returns:
             True if the path is allowed, False otherwise
         """
-        # Normalize path (expand user paths and make absolute)
-        normalized_path = PathUtils.normalize_path(path)
-        resolved_path: Path = Path(normalized_path).resolve()
+        # Expand user path (e.g., ~/ or $HOME)
+        expanded_path = os.path.expanduser(path)
+        resolved_path: Path = Path(expanded_path).resolve()
 
         # Check if the path is within any allowed path
         for allowed_path in self.allowed_paths:

hanzo_mcp/tools/common/error_handling.py

@@ -0,0 +1,86 @@
+"""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

@@ -0,0 +1,84 @@
+"""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
+
+
+def setup_logging(log_level: str = "INFO", log_to_file: bool = True, 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
+        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
+    console = logging.StreamHandler(sys.stdout)
+    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}")
+
+
+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)

hanzo_mcp/tools/common/permissions.py

@@ -6,8 +6,6 @@ from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import Any, TypeVar, final
 
-from hanzo_mcp.tools.common.path_utils import PathUtils
-
 # Define type variables for better type annotations
 T = TypeVar("T")
 P = TypeVar("P")
@@ -71,9 +69,9 @@ class PermissionManager:
         Args:
             path: The path to allow
         """
-        # Normalize path (expand user paths and make absolute)
-        normalized_path = PathUtils.normalize_path(path)
-        resolved_path: Path = Path(normalized_path).resolve()
+        # Expand user path (e.g., ~/ or $HOME)
+        expanded_path = os.path.expanduser(path)
+        resolved_path: Path = Path(expanded_path).resolve()
         self.allowed_paths.add(resolved_path)
 
     def remove_allowed_path(self, path: str) -> None:
@@ -112,9 +110,9 @@ class PermissionManager:
         Returns:
             True if the path is allowed, False otherwise
         """
-        # Normalize path (expand user paths and make absolute)
-        normalized_path = PathUtils.normalize_path(path)
-        resolved_path: Path = Path(normalized_path).resolve()
+        # Expand user path (e.g., ~/ or $HOME)
+        expanded_path = os.path.expanduser(path)
+        resolved_path: Path = Path(expanded_path).resolve()
 
         # Check exclusions first
         if self._is_path_excluded(resolved_path):

hanzo_mcp/tools/filesystem/__init__.py

@@ -77,6 +77,7 @@ def register_filesystem_tools(
     mcp_server: FastMCP,
     document_context: DocumentContext,
     permission_manager: PermissionManager,
+    disable_write_tools: bool = False,
 ) -> None:
     """Register all filesystem tools with the MCP server.
     
@@ -84,6 +85,10 @@ def register_filesystem_tools(
         mcp_server: The FastMCP server instance
         document_context: Document context for tracking file contents
         permission_manager: Permission manager for access control
+        disable_write_tools: Whether to disable write/edit tools (default: False)
     """
-    tools = get_filesystem_tools(document_context, permission_manager)
+    if disable_write_tools:
+        tools = get_read_only_filesystem_tools(document_context, permission_manager)
+    else:
+        tools = get_filesystem_tools(document_context, permission_manager)
     ToolRegistry.register_tools(mcp_server, tools)

hanzo_mcp/tools/filesystem/directory_tree.py

@@ -3,14 +3,12 @@
 This module provides the DirectoryTreeTool for viewing file and directory structures.
 """
 
-import os
 from pathlib import Path
 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.path_utils import PathUtils
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
 
@@ -139,47 +137,17 @@ requested. Only works within allowed directories."""
             if not is_dir:
                 return error_msg
 
-            # Define filtered directories based on common patterns and .gitignore
+            # Define filtered directories
             FILTERED_DIRECTORIES = {
-                # Hidden/dot directories
-                ".git", ".github", ".gitignore", ".hg", ".svn", ".venv", ".env",
-                ".idea", ".vscode", ".vs", ".cache", ".config", ".local",
-                ".pytest_cache", ".ruff_cache", ".mypy_cache", ".pytype",
-                ".coverage", ".tox", ".nox", ".circleci", ".llm-context",
-                # Cache directories
-                "__pycache__", ".ipynb_checkpoints", "htmlcov", ".eggs",
-                # Build artifacts
-                "dist", "build", "target", "out", "site", "coverage", 
-                # Dependency directories
-                "node_modules", "venv", "env", "ENV", "lib", "libs", "vendor",
-                "eggs", "sdist", "wheels", "share"
+                ".git", "node_modules", ".venv", "venv", 
+                "__pycache__", ".pytest_cache", ".idea", 
+                ".vs", ".vscode", "dist", "build", "target",
+                ".ruff_cache",".llm-context"
             }
             
             # Log filtering settings
             await tool_ctx.info(f"Directory tree filtering: include_filtered={include_filtered}")
             
-            # Try to get additional patterns from .gitignore if it exists
-            gitignore_patterns = set()
-            gitignore_path = dir_path / ".gitignore"
-            if gitignore_path.exists() and gitignore_path.is_file():
-                try:
-                    with open(gitignore_path, "r") as f:
-                        for line in f:
-                            line = line.strip()
-                            if line and not line.startswith("#"):
-                                # Strip trailing slashes for directory patterns
-                                if line.endswith("/"):
-                                    line = line[:-1]
-                                # Extract the actual pattern without path
-                                pattern = line.split("/")[-1]
-                                if pattern and "*" not in pattern and "?" not in pattern:
-                                    gitignore_patterns.add(pattern)
-                except Exception as e:
-                    await tool_ctx.warning(f"Error reading .gitignore: {str(e)}")
-            
-            # Add gitignore patterns to filtered directories
-            FILTERED_DIRECTORIES.update(gitignore_patterns)
-                
             # Check if a directory should be filtered
             def should_filter(current_path: Path) -> bool:
                 # Don't filter if it's the explicitly requested path
@@ -187,15 +155,8 @@ requested. Only works within allowed directories."""
                     # Don't filter explicitly requested paths
                     return False
                     
-                # First check standard filtered directories
-                if current_path.name in FILTERED_DIRECTORIES and not include_filtered:
-                    return True
-                    
-                # Also filter hidden directories (dot directories) unless explicitly included
-                if PathUtils.is_dot_directory(current_path) and not include_filtered:
-                    return True
-                    
-                return False
+                # Filter based on directory name if filtering is enabled
+                return current_path.name in FILTERED_DIRECTORIES and not include_filtered
             
             # Track stats for summary
             stats = {

hanzo_mcp/tools/jupyter/__init__.py

@@ -59,6 +59,7 @@ def register_jupyter_tools(
     mcp_server: FastMCP,
     document_context: DocumentContext,
     permission_manager: PermissionManager,
+    disable_write_tools: bool = False,
 ) -> None:
     """Register all Jupyter notebook tools with the MCP server.
     
@@ -66,6 +67,10 @@ def register_jupyter_tools(
         mcp_server: The FastMCP server instance
         document_context: Document context for tracking file contents
         permission_manager: Permission manager for access control
+        disable_write_tools: Whether to disable write/edit tools (default: False)
     """
-    tools = get_jupyter_tools(document_context, permission_manager)
+    if disable_write_tools:
+        tools = get_read_only_jupyter_tools(document_context, permission_manager)
+    else:
+        tools = get_jupyter_tools(document_context, permission_manager)
     ToolRegistry.register_tools(mcp_server, tools)

hanzo_mcp/tools/shell/command_executor.py

@@ -14,8 +14,6 @@ from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import Dict, Optional, final
 
-from hanzo_mcp.tools.common.path_utils import PathUtils
-
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.fastmcp import FastMCP
 
@@ -136,8 +134,8 @@ class CommandExecutor:
             path: The path to set as the current working directory
         """
         session = self.get_session_manager(session_id)
-        normalized_path = PathUtils.normalize_path(path)
-        session.set_working_dir(Path(normalized_path))
+        expanded_path = os.path.expanduser(path)
+        session.set_working_dir(Path(expanded_path))
 
     def get_working_dir(self, session_id: str) -> str:
         """Get the current working directory for the session.
@@ -251,8 +249,11 @@ class CommandExecutor:
                     session_cwd = self.get_working_dir(session_id)
                     target_dir = os.path.join(session_cwd, target_dir)
                 
-                # Normalize path (expand user and make absolute)
-                target_dir = PathUtils.normalize_path(target_dir)
+                # Expand user paths
+                target_dir = os.path.expanduser(target_dir)
+                
+                # Normalize path
+                target_dir = os.path.normpath(target_dir)
                 
                 if os.path.isdir(target_dir):
                     self.set_working_dir(session_id, target_dir)

{hanzo_mcp-0.1.36.dist-info → hanzo_mcp-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.1.36
+Version: 0.3.1
 Summary: MCP implementation of Hanzo capabilities
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT

{hanzo_mcp-0.1.36.dist-info → hanzo_mcp-0.3.1.dist-info}/RECORD

@@ -1,30 +1,36 @@
-hanzo_mcp/__init__.py,sha256=R1BsBtTu0Ll8ASecW2mPKCntuNwFh6Z8vY8U5tjQ6pE,90
-hanzo_mcp/cli.py,sha256=VPGky5w47_7PYYaXnryToaj7By7Sld0vn_bZ2Hxmpy8,7189
-hanzo_mcp/server.py,sha256=OyF-jmPCHXId7DaIk3QcGxnmkSgsnd0GLx3WAtiaOik,6032
-hanzo_mcp/tools/__init__.py,sha256=9bq0emNV_xQk3elWdfIkzgzRU2G1vIsV2k_neV43coc,3333
+hanzo_mcp/__init__.py,sha256=roRFuV1ugS6Zf28PtFGKzOnpJMDFncOz6fR3TlG-LF0,89
+hanzo_mcp/cli.py,sha256=ST428ys32fputErgrmLNJV9oYHbKGwkjrPBJfKh_K_Y,10820
+hanzo_mcp/server.py,sha256=bV4ywWOgm7BwZrbZwv1qoRKbAsMYT08aCGQwuFS8raM,6678
+hanzo_mcp/tools/__init__.py,sha256=9LbWAPfSntDwLaAex3dagsHO4BgZQHKj5E6UX-Gmyb4,3496
 hanzo_mcp/tools/agent/__init__.py,sha256=0eyQqqdAy7WCZEqUfV6xh66bDpQI9neB6iDjWf0_pJI,2189
 hanzo_mcp/tools/agent/agent_tool.py,sha256=qXu62ZRGM0o9mxOiRVFy-ABIZtEJ8z03DqAXshKAieI,19180
+hanzo_mcp/tools/agent/base_provider.py,sha256=dd1J75Q0wl_t_Gcuwc8Ft3PWxeDsmf0B3ybhRsUEgmA,2080
+hanzo_mcp/tools/agent/litellm_provider.py,sha256=6mVOLSNpfjAJKj6aBMflyYU6DRJpEqIxgu8wSzeRmxU,1334
+hanzo_mcp/tools/agent/lmstudio_agent.py,sha256=c4-VIDRXksv39HYpXzqwyF1PisoNd73R3Txa8Mkzibg,14510
+hanzo_mcp/tools/agent/lmstudio_provider.py,sha256=-gX8fxebyWaC7bqmZERR6QQc62Paj62IIDIu_rBu0wM,7876
 hanzo_mcp/tools/agent/prompt.py,sha256=jmYRI4Sm2D3LwEdC2qWakpqupgfGg8CT6grmx4NEDaA,4431
+hanzo_mcp/tools/agent/provider_registry.py,sha256=A-Wd5B5hLBznQV4wWbxE-yyvBPnbuUL2OtSJUz2K_H0,4236
 hanzo_mcp/tools/agent/tool_adapter.py,sha256=g9NKfIET0WOsm0r28xEXsibsprpI1C6ripcM6QwU-rI,2172
-hanzo_mcp/tools/common/__init__.py,sha256=E0rOalOkyLKsjDcmZNjuvKY4Fu0NTr81rYC1G4r51UM,853
+hanzo_mcp/tools/common/__init__.py,sha256=felrGAEqLWOa8fuHjTCS7khqtlA-izz8k865ky7R-f8,797
 hanzo_mcp/tools/common/base.py,sha256=O7Lgft0XiC9Iyi3fYsmoWWrvKDK2Aa-FJLxPgnNJRJY,7341
-hanzo_mcp/tools/common/context.py,sha256=rXK6FvHFnJ0OAYvAKfJUEjY6TKFn_Dj8ErgvCSvGHh4,13254
-hanzo_mcp/tools/common/path_utils.py,sha256=eLmHxvUQimCZceUNg5W9DbUvlA3uRzU6Stal-3XHRf8,1509
-hanzo_mcp/tools/common/permissions.py,sha256=w_D2bIX5E0PmctmNf0tFASYebU-cUuEFICjOOiAI_WM,7703
+hanzo_mcp/tools/common/context.py,sha256=ReIfcm37j5qnLQ8G_-d88ad5uC1OKkjQZKG9HdJPybI,13145
+hanzo_mcp/tools/common/error_handling.py,sha256=rluaHpXV89pjcf8JxgYB6EdqVkcxihb3pyEO2gN-u7w,2789
+hanzo_mcp/tools/common/logging_config.py,sha256=b1swgWV3nuhpVT0TCcbxlOC0gmiRLmbey_t2LOWEMbU,2793
+hanzo_mcp/tools/common/permissions.py,sha256=4YCfA2PJUOl-z_47n5uaRXO8gAZ_shMaPhpi1dilgRE,7594
 hanzo_mcp/tools/common/session.py,sha256=csX5ZhgBjO2bdXXXPpsUPzOCc7Tib-apYe01AP8sh8k,2774
 hanzo_mcp/tools/common/think_tool.py,sha256=I-O6ipM-PUofkNoMMzv37Y_2Yfx9mh7F1upTTsfRN4M,4046
 hanzo_mcp/tools/common/validation.py,sha256=gB3uM_cbPZsH4Ez0hnTgIcdP-AUlHZU02aRmZEpk_6I,3648
 hanzo_mcp/tools/common/version_tool.py,sha256=4bJZhqgtvwQMyVSSZ-xU-NQvr1xfnyDi_4FnOpZvuw0,3406
-hanzo_mcp/tools/filesystem/__init__.py,sha256=-wNhb0IjJgz05n_fRP0wDXfKgJ6fgBp4wrGo62Hpyvc,3265
+hanzo_mcp/tools/filesystem/__init__.py,sha256=Jm5AmLIdRxzcZ4L8ajNJCQYObpmUeoBOzdYdFvDgQIA,3513
 hanzo_mcp/tools/filesystem/base.py,sha256=HAzuMCrS0dKOBZNoLr7y74tdbYyKpi0FGhStuRgkFTU,3917
 hanzo_mcp/tools/filesystem/content_replace.py,sha256=ZwzxyOTASUmzP-jtEnsSR-MKtNFC4R3kQunpV3KOCyg,11049
-hanzo_mcp/tools/filesystem/directory_tree.py,sha256=QgMjvBv9rKVNHEumHgrS0chP91IKo5xg3X5JzSiHbOY,13403
+hanzo_mcp/tools/filesystem/directory_tree.py,sha256=cx-zpOeKP8DDuMt1ls3QhRk9h3RVmMhpPwpqn4wTfP4,11271
 hanzo_mcp/tools/filesystem/edit_file.py,sha256=03ku1_8X_uAUPfqGlR6fv55VEz-0Pifp9DJtkcOTFHY,10980
 hanzo_mcp/tools/filesystem/get_file_info.py,sha256=WR7uMqFcpKboS3FX3jF-MD-0-ROJJcppX7M_GtR0yLs,5392
 hanzo_mcp/tools/filesystem/read_files.py,sha256=0JYJ2kM8FIoksbnnO8V0uY3D2R1uWvR7zb7_oXV0sMM,6968
 hanzo_mcp/tools/filesystem/search_content.py,sha256=2zXke1YHYxg6GKQ_XHb0sXeaSkHI7Jx3P-YAqrpOTNM,10766
 hanzo_mcp/tools/filesystem/write_file.py,sha256=7ZNR1ygECBjT7m62QNkeIEt0OGxNZL2zijX-bASWj0Y,5303
-hanzo_mcp/tools/jupyter/__init__.py,sha256=xFYW8Idb4x1jLWbexN5sqFKSCd1aL820uENzJ7mb6rs,2282
+hanzo_mcp/tools/jupyter/__init__.py,sha256=9mZ55Mq0JMmjOxCxbeFHS8vOqvezzh_uCst02EPB4Ng,2527
 hanzo_mcp/tools/jupyter/base.py,sha256=xtssHrkHx_u_nE12dqtZGcvuJe8kfsbSkMmq-6KQobQ,10412
 hanzo_mcp/tools/jupyter/edit_notebook.py,sha256=_ZNlsCYaO9_SbZouvrLYElvssL6nlElCc2JxNCeMdQo,11986
 hanzo_mcp/tools/jupyter/notebook_operations.py,sha256=PkZXk_PYPkBGxg2RWzqh-rN6VDHjFybImhdUm3xLLoY,23120
@@ -35,13 +41,13 @@ hanzo_mcp/tools/project/base.py,sha256=CniLAsjum5vC3cgvF9AqU-_ZY_0Nf9uaF2L_xV2ob
 hanzo_mcp/tools/project/project_analyze.py,sha256=6GLE_JcSiCy6kKdee0sMI5T2229A-Vpp98s2j_JD6yI,5711
 hanzo_mcp/tools/shell/__init__.py,sha256=lKgh0WXds4tZJ1tIL9MJbyMSzP6A9uZQALjGGBvyYc4,1679
 hanzo_mcp/tools/shell/base.py,sha256=OxKNWMp-fB-vozzWOE_hHvr5M_pFKSMIYfOX0dEOWzA,4836
-hanzo_mcp/tools/shell/command_executor.py,sha256=MqGxHoLB_cDOutdTv59BF5ooiLE-_2Xt-J9UOE-ReFo,32610
+hanzo_mcp/tools/shell/command_executor.py,sha256=5GcJvg54uty9fl_tkGdWTBcHyjxuynQZ_Tv6qOyKgdk,32616
 hanzo_mcp/tools/shell/run_command.py,sha256=r7HBw0lqabgkGnVsDXmLnrTo0SU9g8gLvzpa-9n-cmM,6891
 hanzo_mcp/tools/shell/run_script.py,sha256=CLYnDc0Ze8plkXU6d98RgE4UrBg-fwaMVdcn9Fc6Ixw,7432
 hanzo_mcp/tools/shell/script_tool.py,sha256=s63tawIZBvwgm_kU9P7A3D4v2ulVw7j4l_rpsa_zGuc,8680
-hanzo_mcp-0.1.36.dist-info/licenses/LICENSE,sha256=mf1qZGFsPGskoPgytp9B-RsahfKvXsBpmaAbTLGTt8Y,1063
-hanzo_mcp-0.1.36.dist-info/METADATA,sha256=xVd9e-JGD2c0Rs5GdG7ZMoDu4LcsdS2jwgADGdegj30,7551
-hanzo_mcp-0.1.36.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-hanzo_mcp-0.1.36.dist-info/entry_points.txt,sha256=aRKOKXtuQr-idSr-yH4efnRl2v8te94AcgN3ysqqSYs,49
-hanzo_mcp-0.1.36.dist-info/top_level.txt,sha256=eGFANatA0MHWiVlpS56fTYRIShtibrSom1uXI6XU0GU,10
-hanzo_mcp-0.1.36.dist-info/RECORD,,
+hanzo_mcp-0.3.1.dist-info/licenses/LICENSE,sha256=mf1qZGFsPGskoPgytp9B-RsahfKvXsBpmaAbTLGTt8Y,1063
+hanzo_mcp-0.3.1.dist-info/METADATA,sha256=ay2jJEkPi-ivKlvoCRyCNj57-M0tT36tL4w5nuK_SQ0,7550
+hanzo_mcp-0.3.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+hanzo_mcp-0.3.1.dist-info/entry_points.txt,sha256=aRKOKXtuQr-idSr-yH4efnRl2v8te94AcgN3ysqqSYs,49
+hanzo_mcp-0.3.1.dist-info/top_level.txt,sha256=eGFANatA0MHWiVlpS56fTYRIShtibrSom1uXI6XU0GU,10
+hanzo_mcp-0.3.1.dist-info/RECORD,,

hanzo_mcp/tools/common/path_utils.py

@@ -1,51 +0,0 @@
-"""Path utilities for Hanzo MCP.
-
-This module provides path normalization and validation utilities.
-"""
-
-import os
-from pathlib import Path
-from typing import final
-
-
-@final
-class PathUtils:
-    """Utilities for path handling."""
-
-    @staticmethod
-    def normalize_path(path: str) -> str:
-        """Normalize a path by expanding user paths and making it absolute.
-        
-        Args:
-            path: The path to normalize
-            
-        Returns:
-            The normalized path
-        """
-        # Expand user paths (e.g., ~/ or $HOME)
-        expanded_path = os.path.expanduser(path)
-        
-        # Make the path absolute if it isn't already
-        if not os.path.isabs(expanded_path):
-            expanded_path = os.path.abspath(expanded_path)
-            
-        # Normalize the path (resolve symlinks, etc.)
-        try:
-            normalized_path = os.path.normpath(expanded_path)
-            return normalized_path
-        except Exception:
-            # Return the expanded path if normalization fails
-            return expanded_path
-            
-    @staticmethod
-    def is_dot_directory(path: Path) -> bool:
-        """Check if a path is a dot directory (e.g., .git, .vscode).
-        
-        Args:
-            path: The path to check
-            
-        Returns:
-            True if the path is a dot directory, False otherwise
-        """
-        # Consider any directory starting with "." to be a dot directory
-        return path.is_dir() and path.name.startswith(".")