hanzo-mcp 0.1.21__py3-none-any.whl → 0.1.25__py3-none-any.whl

hanzo_mcp/__init__.py

@@ -1,3 +1,3 @@
 """Hanzo MCP - Implementation of Hanzo Platform capabilities using MCP."""
 
-__version__ = "0.1.8"
+__version__ = "0.1.22"

hanzo_mcp/cli.py

@@ -7,11 +7,11 @@ import sys
 from pathlib import Path
 from typing import Any, cast
 
-from hanzo_mcp.server import HanzoDevServer
+from hanzo_mcp.server import HanzoMCPServer
 
 
 def main() -> None:
-    """Run the CLI for the Hanzo Dev MCP server."""
+    """Run the CLI for the Hanzo MCP server."""
     parser = argparse.ArgumentParser(
         description="MCP server for accessing Hanzo APIs and Platform capabilities"
     )
@@ -70,7 +70,7 @@ def main() -> None:
         allowed_paths.append(project_dir)
 
     # Run the server
-    server = HanzoDevServer(name=name, allowed_paths=allowed_paths)
+    server = HanzoMCPServer(name=name, allowed_paths=allowed_paths)
     # Transport will be automatically cast to Literal['stdio', 'sse'] by the server
     server.run(transport=transport)
 

hanzo_mcp/server.py

@@ -12,7 +12,7 @@ from hanzo_mcp.tools.shell.command_executor import CommandExecutor
 
 
 @final
-class HanzoDevServer:
+class HanzoMCPServer:
     """MCP server for accessing Hanzo APIs and Platform capabilities."""
 
     def __init__(
@@ -21,7 +21,7 @@ class HanzoDevServer:
         allowed_paths: list[str] | None = None,
         mcp_instance: FastMCP | None = None,
     ):
-        """Initialize the Hanzo Dev server.
+        """Initialize the Hanzo server.
 
         Args:
             name: The name of the server
@@ -117,7 +117,7 @@ def main():
     allowed_paths: list[str] | None = args.allowed_paths
 
     # Create and run the server
-    server = HanzoDevServer(name=name, allowed_paths=allowed_paths)
+    server = HanzoMCPServer(name=name, allowed_paths=allowed_paths)
     server.run(transport=transport, allowed_paths=allowed_paths or [])
 
 

hanzo_mcp/tools/common/__init__.py

@@ -1 +1 @@
-"""Common utilities for Hanzo Dev MCP tools."""
+"""Common utilities for Hanzo MCP tools."""

hanzo_mcp/tools/common/context.py

@@ -1,4 +1,4 @@
-"""Enhanced Context for Hanzo Dev MCP tools.
+"""Enhanced Context for Hanzo MCP tools.
 
 This module provides an enhanced Context class that wraps the MCP Context
 and adds additional functionality specific to Claude Code tools.
@@ -17,7 +17,7 @@ from mcp.server.lowlevel.helper_types import ReadResourceContents
 
 @final
 class ToolContext:
-    """Enhanced context for Hanzo Dev MCP tools.
+    """Enhanced context for Hanzo MCP tools.
 
     This class wraps the MCP Context and adds additional functionality
     for tracking tool execution, progress reporting, and resource access.

hanzo_mcp/tools/common/permissions.py

@@ -1,4 +1,4 @@
-"""Permission system for the Hanzo Dev MCP server."""
+"""Permission system for the Hanzo MCP server."""
 
 import json
 import os
@@ -11,29 +11,65 @@ T = TypeVar("T")
 P = TypeVar("P")
 
 
+def normalize_path(path: str) -> Path:
+    """Normalize a path with proper user directory expansion.
+
+    This utility function handles path normalization with proper handling of
+    tilde (~) for home directory expansion and ensures consistent path handling
+    across the application.
+
+    Args:
+        path: The path to normalize (can include ~ for home directory)
+
+    Returns:
+        A normalized Path object with user directories expanded and resolved to
+        its absolute canonical form.
+    """
+    # Expand the user directory, handling the tilde (~) if present.
+    expanded_path = os.path.expanduser(path)
+    # Resolve the expanded path to its absolute form.
+    resolved_path = Path(expanded_path).resolve()
+    return resolved_path
+
+
 @final
 class PermissionManager:
-    """Manages permissions for file and command operations."""
+    """Manages permissions for file and command operations.
+
+    This class is responsible for tracking allowed file system paths as well as
+    paths and patterns that should be excluded from permitted operations.
+    """
 
     def __init__(self) -> None:
-        """Initialize the permission manager."""
-        # Allowed paths
+        """Initialize the permission manager with default allowed and excluded paths.
+
+        Allowed paths are those where operations (read, write, execute, etc.) are permitted,
+        while excluded paths and patterns represent paths and file patterns that are sensitive
+        and should be disallowed.
+        """
+        # Allowed paths: operations are permitted on these paths.
         self.allowed_paths: set[Path] = set(
             [Path("/tmp").resolve(), Path("/var").resolve()]
         )
 
-        # Excluded paths
+        # Excluded paths: specific paths that are explicitly disallowed.
         self.excluded_paths: set[Path] = set()
+
+        # Excluded patterns: patterns for sensitive directories and file names.
         self.excluded_patterns: list[str] = []
 
-        # Default excluded patterns
+        # Add default exclusions for sensitive files and directories.
         self._add_default_exclusions()
 
     def _add_default_exclusions(self) -> None:
-        """Add default exclusions for sensitive files and directories."""
-        # Sensitive directories
+        """Add default exclusions for sensitive files and directories.
+
+        This method populates the excluded_patterns list with common sensitive
+        directories (e.g., .ssh, .gnupg) and file patterns (e.g., *.key, *.log)
+        that should be excluded from allowed operations.
+        """
+        # Sensitive directories (Note: .git is allowed by default)
         sensitive_dirs: list[str] = [
-            # ".git" is now allowed by default
             ".ssh",
             ".gnupg",
             ".config",
@@ -64,59 +100,64 @@ class PermissionManager:
         self.excluded_patterns.extend(sensitive_patterns)
 
     def add_allowed_path(self, path: str) -> None:
-        """Add a path to the allowed paths.
+        """Add a new path to the allowed paths.
 
         Args:
-            path: The path to allow
+            path: The file system path to add to the allowed list.
         """
-        resolved_path: Path = Path(path).resolve()
+        resolved_path: Path = normalize_path(path)
         self.allowed_paths.add(resolved_path)
 
     def remove_allowed_path(self, path: str) -> None:
         """Remove a path from the allowed paths.
 
         Args:
-            path: The path to remove
+            path: The file system path to remove from the allowed list.
         """
-        resolved_path: Path = Path(path).resolve()
+        resolved_path: Path = normalize_path(path)
         if resolved_path in self.allowed_paths:
             self.allowed_paths.remove(resolved_path)
 
     def exclude_path(self, path: str) -> None:
-        """Exclude a path from allowed operations.
+        """Add a path to the exclusion list.
 
         Args:
-            path: The path to exclude
+            path: The file system path to explicitly exclude from operations.
         """
-        resolved_path: Path = Path(path).resolve()
+        resolved_path: Path = normalize_path(path)
         self.excluded_paths.add(resolved_path)
 
     def add_exclusion_pattern(self, pattern: str) -> None:
-        """Add an exclusion pattern.
+        """Add a new exclusion pattern.
 
         Args:
-            pattern: The pattern to exclude
+            pattern: A string pattern that matches file or directory names to exclude.
         """
         self.excluded_patterns.append(pattern)
 
     def is_path_allowed(self, path: str) -> bool:
-        """Check if a path is allowed.
+        """Determine if a given path is allowed for operations.
+
+        The method normalizes the input path and then checks it against the list
+        of excluded paths and patterns. If the path is not excluded and is a
+        subpath of one of the allowed base paths, the method returns True.
 
         Args:
-            path: The path to check
+            path: The file system path to check.
 
         Returns:
-            True if the path is allowed, False otherwise
+            True if the path is allowed for operations, False otherwise.
         """
-        resolved_path: Path = Path(path).resolve()
+        resolved_path: Path = normalize_path(path)
 
-        # Check exclusions first
+        # First, check if the path matches any excluded paths or patterns.
         if self._is_path_excluded(resolved_path):
             return False
 
-        # Check if the path is within any allowed path
+        # Check if the normalized path is within any allowed path.
         for allowed_path in self.allowed_paths:
             try:
+                # relative_to will succeed if resolved_path is a subpath of allowed_path.
                 resolved_path.relative_to(allowed_path)
                 return True
             except ValueError:
@@ -125,63 +166,74 @@ class PermissionManager:
         return False
 
     def _is_path_excluded(self, path: Path) -> bool:
-        """Check if a path is excluded.
+        """Determine if a normalized path should be excluded.
+
+        The method checks two conditions:
+          1. If the path exactly matches an entry in the excluded_paths set.
+          2. If the path string contains any of the excluded patterns, either as a
+             suffix for wildcard patterns (e.g., "*.log") or as an exact match
+             within any of the path's components.
 
         Args:
-            path: The path to check
+            path: The normalized path to check.
 
         Returns:
-            True if the path is excluded, False otherwise
+            True if the path is excluded, False otherwise.
         """
-
-        # Check exact excluded paths
+        # Direct match: Check if the path is in the explicitly excluded paths set.
         if path in self.excluded_paths:
             return True
 
-        # Check excluded patterns
+        # Convert the path to a string for pattern matching.
         path_str: str = str(path)
 
-        # Get path parts to check for exact directory/file name matches
+        # Split the path into its individual components (directories and file name).
         path_parts = path_str.split(os.sep)
 
+        # Iterate over each exclusion pattern to see if it matches.
         for pattern in self.excluded_patterns:
-            # Handle wildcard patterns (e.g., "*.log")
+            # If the pattern starts with a wildcard, perform a suffix match.
             if pattern.startswith("*"):
                 if path_str.endswith(pattern[1:]):
                     return True
             else:
-                # For non-wildcard patterns, check if any path component matches exactly
+                # For non-wildcard patterns, check if any path component exactly matches the pattern.
                 if pattern in path_parts:
                     return True
 
         return False
 
     def to_json(self) -> str:
-        """Convert the permission manager to a JSON string.
+        """Serialize the permission manager's configuration to a JSON string.
+
+        The JSON representation includes the allowed paths, excluded paths, and
+        excluded patterns, which can be used to restore the configuration later.
 
         Returns:
-            A JSON string representation of the permission manager
+            A JSON string representing the current state of the permission manager.
         """
         data: dict[str, Any] = {
             "allowed_paths": [str(p) for p in self.allowed_paths],
             "excluded_paths": [str(p) for p in self.excluded_paths],
             "excluded_patterns": self.excluded_patterns,
         }
-
         return json.dumps(data)
 
     @classmethod
     def from_json(cls, json_str: str) -> "PermissionManager":
-        """Create a permission manager from a JSON string.
+        """Create a PermissionManager instance from a JSON string.
+
+        The JSON string should represent a configuration with allowed paths,
+        excluded paths, and exclusion patterns. This method rehydrates the state
+        accordingly.
 
         Args:
-            json_str: The JSON string
+            json_str: The JSON string containing the permission manager configuration.
 
         Returns:
-            A new PermissionManager instance
+            A new PermissionManager instance with configuration loaded from the JSON string.
         """
         data: dict[str, Any] = json.loads(json_str)
-
         manager = cls()
 
         for path in data.get("allowed_paths", []):
@@ -191,12 +243,16 @@ class PermissionManager:
             manager.exclude_path(path)
 
         manager.excluded_patterns = data.get("excluded_patterns", [])
-
         return manager
 
 
 class PermissibleOperation:
-    """A decorator for operations that require permission."""
+    """A decorator for operations that require permission checks.
+
+    This decorator uses a PermissionManager instance to enforce that a given
+    operation (e.g., read, write, execute) is permitted on a provided file system
+    path before allowing the decorated function to execute.
+    """
 
     def __init__(
         self,
@@ -204,50 +260,54 @@ class PermissibleOperation:
         operation: str,
         get_path_fn: Callable[[list[Any], dict[str, Any]], str] | None = None,
     ) -> None:
-        """Initialize the permissible operation.
+        """Initialize the PermissibleOperation decorator.
 
         Args:
-            permission_manager: The permission manager
-            operation: The operation type (read, write, execute, etc.)
-            get_path_fn: Optional function to extract the path from args and kwargs
+            permission_manager: The PermissionManager instance used for permission checks.
+            operation: A string representing the operation type (e.g., 'read', 'write').
+            get_path_fn: Optional function to extract the file system path from the function's
+                         arguments. If not provided, defaults to using the first positional argument
+                         or the first value from keyword arguments.
         """
         self.permission_manager: PermissionManager = permission_manager
         self.operation: str = operation
-        self.get_path_fn: Callable[[list[Any], dict[str, Any]], str] | None = (
-            get_path_fn
-        )
+        self.get_path_fn: Callable[[list[Any], dict[str, Any]], str] | None = get_path_fn
 
     def __call__(
         self, func: Callable[..., Awaitable[T]]
     ) -> Callable[..., Awaitable[T]]:
-        """Decorate the function.
+        """Decorate the function to enforce permission checks before execution.
+
+        This method wraps the original asynchronous function, extracting a file system path
+        from its arguments and using the PermissionManager to verify if the specified operation
+        is allowed on that path. If permission is denied, a PermissionError is raised.
 
         Args:
-            func: The function to decorate
+            func: The asynchronous function to decorate.
 
         Returns:
-            The decorated function
+            An asynchronous function that includes permission checks prior to calling the original function.
         """
-
         async def wrapper(*args: Any, **kwargs: Any) -> T:
-            # Extract the path
+            # Extract the file system path using the provided get_path_fn if available.
             if self.get_path_fn:
-                # Pass args as a list and kwargs as a dict to the path function
                 path = self.get_path_fn(list(args), kwargs)
             else:
-                # Default to first argument
+                # Default extraction: use the first positional argument if available,
+                # otherwise use the first keyword argument value.
                 path = args[0] if args else next(iter(kwargs.values()), None)
 
+            # Ensure that the extracted path is a string.
             if not isinstance(path, str):
-                raise ValueError(f"Invalid path type: {type(path)}")
+                raise ValueError(f"Invalid path type: {type(path)}. Expected a string.")
 
-            # Check permission
+            # Check if the operation is allowed on the specified path.
             if not self.permission_manager.is_path_allowed(path):
                 raise PermissionError(
                     f"Operation '{self.operation}' not allowed for path: {path}"
                 )
 
-            # Call the function
+            # Execute the original function if the permission check passes.
             return await func(*args, **kwargs)
 
         return wrapper

hanzo_mcp/tools/common/validation.py

@@ -1,4 +1,4 @@
-"""Parameter validation utilities for Hanzo Dev MCP tools.
+"""Parameter validation utilities for Hanzo MCP tools.
 
 This module provides utilities for validating parameters in tool functions.
 """

hanzo_mcp/tools/filesystem/__init__.py

@@ -1,4 +1,4 @@
-"""Filesystem tools for Hanzo Dev MCP.
+"""Filesystem tools for Hanzo MCP.
 
 This module provides comprehensive tools for interacting with the filesystem,
 including reading, writing, editing files, directory operations, and searching.

hanzo_mcp/tools/filesystem/file_operations.py

@@ -1,4 +1,4 @@
-"""Filesystem operations tools for Hanzo Dev MCP.
+"""Filesystem operations tools for Hanzo MCP.
 
 This module provides comprehensive tools for interacting with the filesystem,
 including reading, writing, editing files, directory operations, and searching.
@@ -20,7 +20,7 @@ from hanzo_mcp.tools.common.validation import validate_path_parameter
 
 @final
 class FileOperations:
-    """File and filesystem operations tools for Hanzo Dev MCP."""
+    """File and filesystem operations tools for Hanzo MCP."""
 
     def __init__(
         self, document_context: DocumentContext, permission_manager: PermissionManager

hanzo_mcp/tools/jupyter/__init__.py

@@ -1,4 +1,4 @@
-"""Jupyter notebook tools for Hanzo Dev MCP.
+"""Jupyter notebook tools for Hanzo MCP.
 
 This module provides tools for reading and editing Jupyter notebooks (.ipynb files).
 """

hanzo_mcp/tools/jupyter/notebook_operations.py

@@ -1,4 +1,4 @@
-"""Jupyter notebook operations tools for Hanzo Dev MCP.
+"""Jupyter notebook operations tools for Hanzo MCP.
 
 This module provides tools for reading and editing Jupyter notebook (.ipynb) files.
 It supports reading notebook cells with their outputs and modifying notebook contents.

hanzo_mcp/tools/project/__init__.py

@@ -1 +1 @@
-"""Project analysis and management tools for Hanzo Dev MCP."""
+"""Project analysis and management tools for Hanzo MCP."""

hanzo_mcp/tools/project/analysis.py

@@ -1,4 +1,4 @@
-"""Project analysis tools for Hanzo Dev MCP.
+"""Project analysis tools for Hanzo MCP.
 
 This module provides tools for analyzing project structure and dependencies.
 """
@@ -84,7 +84,7 @@ print(json.dumps(result))
 
         # Execute script
         result = await self.command_executor.execute_script_from_file(
-            script=script, language="python", cwd=project_dir, timeout=30.0
+            script=script, language="python", cwd=project_dir, timeout=600.0
         )
         code, stdout, stderr = result.return_code, result.stdout, result.stderr
 
@@ -204,7 +204,7 @@ try {
 
         # Execute script
         result = await self.command_executor.execute_script_from_file(
-            script=script, language="javascript", cwd=project_dir, timeout=30.0
+            script=script, language="javascript", cwd=project_dir, timeout=600.0
         )
         code, stdout, stderr = result.return_code, result.stdout, result.stderr
 
@@ -286,7 +286,7 @@ print(json.dumps(result))
 
         # Execute script
         result = await self.command_executor.execute_script_from_file(
-            script=script, language="python", cwd=project_dir, timeout=30.0
+            script=script, language="python", cwd=project_dir, timeout=600.0
         )
         code, stdout, stderr = result.return_code, result.stdout, result.stderr
 
@@ -795,7 +795,7 @@ class ProjectManager:
 
 @final
 class ProjectAnalysis:
-    """Project analysis tools for Hanzo Dev MCP."""
+    """Project analysis tools for Hanzo MCP."""
 
     def __init__(
         self,

hanzo_mcp/tools/shell/__init__.py

@@ -1 +1 @@
-"""Shell and command execution tools for Hanzo Dev MCP."""
+"""Shell and command execution tools for Hanzo MCP."""

hanzo_mcp/tools/shell/command_executor.py

@@ -1,4 +1,4 @@
-"""Command executor tools for Hanzo Dev MCP.
+"""Command executor tools for Hanzo MCP.
 
 This module provides tools for executing shell commands and scripts with
 comprehensive error handling, permissions checking, and progress tracking.
@@ -86,7 +86,7 @@ class CommandResult:
 
 @final
 class CommandExecutor:
-    """Command executor tools for Hanzo Dev MCP.
+    """Command executor tools for Hanzo MCP.
 
     This class provides tools for executing shell commands and scripts with
     comprehensive error handling, permissions checking, and progress tracking.
@@ -193,7 +193,7 @@ class CommandExecutor:
         command: str,
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 60.0,
+        timeout: float | None = 600.0,
         use_login_shell: bool = True,
     ) -> CommandResult:
         """Execute a shell command with safety checks.
@@ -320,7 +320,7 @@ class CommandExecutor:
         interpreter: str = "bash",
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 60.0,
+        timeout: float | None = 600.0,
         use_login_shell: bool = True,
     ) -> CommandResult:
         """Execute a script with the specified interpreter.
@@ -368,7 +368,7 @@ class CommandExecutor:
         script: str,
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 60.0,
+        timeout: float | None = 600.0,
         use_login_shell: bool = True,
     ) -> CommandResult:
         """Execute a script by passing it to stdin of the interpreter.
@@ -458,7 +458,7 @@ class CommandExecutor:
         script: str,
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 60.0,
+        timeout: float | None = 600.0,
     ) -> CommandResult:
         """Special handler for Fish shell scripts.
 
@@ -533,7 +533,7 @@ class CommandExecutor:
         language: str,
         cwd: str | None = None,
         env: dict[str, str] | None = None,
-        timeout: float | None = 60.0,
+        timeout: float | None = 600.0,
         args: list[str] | None = None,
         use_login_shell: bool = True,
     ) -> CommandResult:
@@ -773,7 +773,7 @@ class CommandExecutor:
 
             # Execute the command
             result: CommandResult = await self.execute_command(
-                command, cwd=cwd, timeout=30.0, use_login_shell=use_login_shell
+                command, cwd=cwd, timeout=600.0, use_login_shell=use_login_shell
             )
 
             # Report result
@@ -869,7 +869,7 @@ class CommandExecutor:
                 script=script,
                 interpreter=interpreter,
                 cwd=cwd,  # cwd is now a required parameter
-                timeout=30.0,
+                timeout=600.0,
                 use_login_shell=use_login_shell,
             )
 
@@ -974,7 +974,7 @@ class CommandExecutor:
                 script=script,
                 language=language,
                 cwd=cwd,  # cwd is now a required parameter
-                timeout=30.0,
+                timeout=600.0,
                 args=args,
                 use_login_shell=use_login_shell,
             )

{hanzo_mcp-0.1.21.dist-info → hanzo_mcp-0.1.25.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.1.21
+Version: 0.1.25
 Summary: MCP server for accessing Hanzo APIs and Platform capabilities
-Author-email: Hanzo Dev <dev@hanzo.ai>
+Author-email: Hanzo <dev@hanzo.ai>
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

hanzo_mcp-0.1.25.dist-info/RECORD

@@ -0,0 +1,24 @@
+hanzo_mcp/__init__.py,sha256=MVDDvQWI8u1vdS9ynXjVvUoex3vbcRufg-NmZVPO1og,99
+hanzo_mcp/cli.py,sha256=4hj3qRecA6tafsCeKSVDhT1TP4YNfZxWxeMQ8z8P4m0,4743
+hanzo_mcp/server.py,sha256=Dk3IdFGAeu2qKZLeOlgE1rHjeCzRjiCkccDLsxXAXAg,4035
+hanzo_mcp/tools/__init__.py,sha256=IsjWWWAIQW4e490k3RI2YLQ46ZvDfcttqZ0SCcC6aps,2507
+hanzo_mcp/tools/common/__init__.py,sha256=p14VhL-SwjJxWKmAWB7Sze5ovJlNKVK_NAUplbuECTY,44
+hanzo_mcp/tools/common/context.py,sha256=pv_oJ5aJM6YyOiKjAKU0LHZCQZQEvKRvh_9zOiQMSIw,12941
+hanzo_mcp/tools/common/permissions.py,sha256=WL-cj2RTmjrwPlcwaQtOV5W-nZeKg2P8sboJHQ6b5fM,11710
+hanzo_mcp/tools/common/thinking.py,sha256=0PRBTm8i8u0KBKfNaDasNSCn_R9kmFrAS3retEj_0J4,2630
+hanzo_mcp/tools/common/validation.py,sha256=gB3uM_cbPZsH4Ez0hnTgIcdP-AUlHZU02aRmZEpk_6I,3648
+hanzo_mcp/tools/filesystem/__init__.py,sha256=_J-n7elOW4zgVpnIm8nMV4AupmYudTF9gdkn1S40RAI,299
+hanzo_mcp/tools/filesystem/file_operations.py,sha256=9SY8A5GzcH8u_yMCzDvWFoWSRRBlJj-i3HfcPuk5md8,46174
+hanzo_mcp/tools/jupyter/__init__.py,sha256=H8t37ams4utRgVl-7RFi1lQFSdTJP6DdpkCVo3qVifI,245
+hanzo_mcp/tools/jupyter/notebook_operations.py,sha256=Vzu4anFoGKHcdGuIk20mtiZVTyKx9HIhe3HKYocq0w8,23335
+hanzo_mcp/tools/project/__init__.py,sha256=4V60vR_ZP1eEuMtH-JR1ADi5sIKHbeh93fPu5ANPhQ4,59
+hanzo_mcp/tools/project/analysis.py,sha256=P0plRYwY6trb6ZGkJEA1bPOpdEayRd1hEKwU2EBBuOI,30361
+hanzo_mcp/tools/shell/__init__.py,sha256=m9dH7LhiDpYU1AD6lwKPGD0E_a7MId2rAb9sGoJNeLM,55
+hanzo_mcp/tools/shell/command_executor.py,sha256=4iBf3FmSljG6QEOXUjrO_4isUv9aWCTQKfE08PbQLlk,37401
+hanzo_mcp-0.1.25.dist-info/licenses/LICENSE,sha256=dvWmlLGUAkNE8EJVn-UQ-F08hxW5jtjUWNe51OaH7IE,1077
+hanzo_mcp-0.1.25.dist-info/METADATA,sha256=IRoZBImDFuOQh9pHq_gYlrupLTnu9s55TiDTcI4QfSk,7090
+hanzo_mcp-0.1.25.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+hanzo_mcp-0.1.25.dist-info/entry_points.txt,sha256=aRKOKXtuQr-idSr-yH4efnRl2v8te94AcgN3ysqqSYs,49
+hanzo_mcp-0.1.25.dist-info/top_level.txt,sha256=eGFANatA0MHWiVlpS56fTYRIShtibrSom1uXI6XU0GU,10
+hanzo_mcp-0.1.25.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+hanzo_mcp-0.1.25.dist-info/RECORD,,

{hanzo_mcp-0.1.21.dist-info → hanzo_mcp-0.1.25.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

hanzo_mcp-0.1.25.dist-info/zip-safe

@@ -0,0 +1 @@
+

hanzo_mcp-0.1.21.dist-info/RECORD

@@ -1,23 +0,0 @@
-hanzo_mcp/__init__.py,sha256=b9ZjldZaFEU7nk4qZ6WCjl0fChLTeK18USOW84f7DXQ,98
-hanzo_mcp/cli.py,sha256=vDB-5trIp-tfKwRXosWVZGBNTZAo_B7wTCoF-NVaLKc,4747
-hanzo_mcp/server.py,sha256=p7-0B99gSfC5ieyOGt7xJ233ddCw1FY9dZDujaHarLU,4039
-hanzo_mcp/tools/__init__.py,sha256=IsjWWWAIQW4e490k3RI2YLQ46ZvDfcttqZ0SCcC6aps,2507
-hanzo_mcp/tools/common/__init__.py,sha256=mUlTy1Py8zV-DBEhkds-DoB2zHOxDZnbnOo3WFHP7ro,48
-hanzo_mcp/tools/common/context.py,sha256=BuuuHDQqzmO8LaWPcdgj8Md4FHT2gGuWIo8mN7fMIOY,12949
-hanzo_mcp/tools/common/permissions.py,sha256=HHH3MM-4dTufJ0HYv6M5yDJHJJBGjcXVnUi4lCWmfRI,7388
-hanzo_mcp/tools/common/thinking.py,sha256=0PRBTm8i8u0KBKfNaDasNSCn_R9kmFrAS3retEj_0J4,2630
-hanzo_mcp/tools/common/validation.py,sha256=S8zj38jjAXSB4bmZAydXDCsh_j6hHGEs71SgK-oeeYI,3652
-hanzo_mcp/tools/filesystem/__init__.py,sha256=IBrOsd_8yDo8RIuujB4rNQmr-JmXuddxyhOv-0PUeig,303
-hanzo_mcp/tools/filesystem/file_operations.py,sha256=6LeSoemvaz-oIP0K7GL_vySgA-i8QqN0tI9O_HalSIQ,46182
-hanzo_mcp/tools/jupyter/__init__.py,sha256=XuRoN_02X6ChW_OVGoPIydkQTOlvMtL5hPWRzGW3LVU,249
-hanzo_mcp/tools/jupyter/notebook_operations.py,sha256=AzZXyrgxR55KU09s3B1D50wAdsozHWQZFMCFXsnoe3A,23339
-hanzo_mcp/tools/project/__init__.py,sha256=el-n7xVnHgk6wXqVhFtFCoEfdq11aDAo9DucIJdXBVw,63
-hanzo_mcp/tools/project/analysis.py,sha256=eQ1WgeFNf_d9g_LWdo1f3x5-c4PLzRXK2_j-JN8wM9w,30366
-hanzo_mcp/tools/shell/__init__.py,sha256=myuuFc03I1xGq3VxmLddkSlvvaQIddA3WoIKds8ABFo,59
-hanzo_mcp/tools/shell/command_executor.py,sha256=HyhAwG-aLw13f0Z-K4sCAWqt7qRWEiixnv8tmTTyJW8,37401
-hanzo_mcp-0.1.21.dist-info/licenses/LICENSE,sha256=dvWmlLGUAkNE8EJVn-UQ-F08hxW5jtjUWNe51OaH7IE,1077
-hanzo_mcp-0.1.21.dist-info/METADATA,sha256=34AG2iCwxvRc2SXiGT8jqCgjH6Q8eiXM4YhfAE6OMSY,7094
-hanzo_mcp-0.1.21.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-hanzo_mcp-0.1.21.dist-info/entry_points.txt,sha256=aRKOKXtuQr-idSr-yH4efnRl2v8te94AcgN3ysqqSYs,49
-hanzo_mcp-0.1.21.dist-info/top_level.txt,sha256=eGFANatA0MHWiVlpS56fTYRIShtibrSom1uXI6XU0GU,10
-hanzo_mcp-0.1.21.dist-info/RECORD,,