hanzo-mcp 0.1.21__tar.gz → 0.1.25__tar.gz

{hanzo_mcp-0.1.21 → hanzo_mcp-0.1.25}/PKG-INFO

@@ -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.21 → hanzo_mcp-0.1.25}/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-0.1.21 → hanzo_mcp-0.1.25}/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-0.1.21 → hanzo_mcp-0.1.25}/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-0.1.25/hanzo_mcp/tools/common/__init__.py

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

{hanzo_mcp-0.1.21 → hanzo_mcp-0.1.25}/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-0.1.25/hanzo_mcp/tools/common/permissions.py

@@ -0,0 +1,313 @@
+"""Permission system for the Hanzo MCP server."""
+
+import json
+import os
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Any, TypeVar, final
+
+# Define type variables for better type annotations
+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.
+
+    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 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: 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] = []
+
+        # 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.
+
+        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] = [
+            ".ssh",
+            ".gnupg",
+            ".config",
+            "node_modules",
+            "__pycache__",
+            ".venv",
+            "venv",
+            "env",
+            ".idea",
+            ".vscode",
+            ".DS_Store",
+        ]
+        self.excluded_patterns.extend(sensitive_dirs)
+
+        # Sensitive file patterns
+        sensitive_patterns: list[str] = [
+            ".env",
+            "*.key",
+            "*.pem",
+            "*.crt",
+            "*password*",
+            "*secret*",
+            "*.sqlite",
+            "*.db",
+            "*.sqlite3",
+            "*.log",
+        ]
+        self.excluded_patterns.extend(sensitive_patterns)
+
+    def add_allowed_path(self, path: str) -> None:
+        """Add a new path to the allowed paths.
+
+        Args:
+            path: The file system path to add to the allowed list.
+        """
+        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 file system path to remove from the allowed list.
+        """
+        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:
+        """Add a path to the exclusion list.
+
+        Args:
+            path: The file system path to explicitly exclude from operations.
+        """
+        resolved_path: Path = normalize_path(path)
+        self.excluded_paths.add(resolved_path)
+
+    def add_exclusion_pattern(self, pattern: str) -> None:
+        """Add a new exclusion pattern.
+
+        Args:
+            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:
+        """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 file system path to check.
+
+        Returns:
+            True if the path is allowed for operations, False otherwise.
+        """
+        resolved_path: Path = normalize_path(path)
+
+        # First, check if the path matches any excluded paths or patterns.
+        if self._is_path_excluded(resolved_path):
+            return False
+
+        # 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:
+                continue
+
+        return False
+
+    def _is_path_excluded(self, path: Path) -> bool:
+        """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 normalized path to check.
+
+        Returns:
+            True if the path is excluded, False otherwise.
+        """
+        # Direct match: Check if the path is in the explicitly excluded paths set.
+        if path in self.excluded_paths:
+            return True
+
+        # Convert the path to a string for pattern matching.
+        path_str: str = str(path)
+
+        # 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:
+            # 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 exactly matches the pattern.
+                if pattern in path_parts:
+                    return True
+
+        return False
+
+    def to_json(self) -> str:
+        """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 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 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 containing the permission manager configuration.
+
+        Returns:
+            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", []):
+            manager.add_allowed_path(path)
+
+        for path in data.get("excluded_paths", []):
+            manager.exclude_path(path)
+
+        manager.excluded_patterns = data.get("excluded_patterns", [])
+        return manager
+
+
+class PermissibleOperation:
+    """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,
+        permission_manager: PermissionManager,
+        operation: str,
+        get_path_fn: Callable[[list[Any], dict[str, Any]], str] | None = None,
+    ) -> None:
+        """Initialize the PermissibleOperation decorator.
+
+        Args:
+            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
+
+    def __call__(
+        self, func: Callable[..., Awaitable[T]]
+    ) -> Callable[..., Awaitable[T]]:
+        """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 asynchronous function to decorate.
+
+        Returns:
+            An asynchronous function that includes permission checks prior to calling the original function.
+        """
+        async def wrapper(*args: Any, **kwargs: Any) -> T:
+            # Extract the file system path using the provided get_path_fn if available.
+            if self.get_path_fn:
+                path = self.get_path_fn(list(args), kwargs)
+            else:
+                # 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)}. Expected a string.")
+
+            # 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}"
+                )
+
+            # Execute the original function if the permission check passes.
+            return await func(*args, **kwargs)
+
+        return wrapper

{hanzo_mcp-0.1.21 → hanzo_mcp-0.1.25}/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-0.1.21 → hanzo_mcp-0.1.25}/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-0.1.21 → hanzo_mcp-0.1.25}/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-0.1.21 → hanzo_mcp-0.1.25}/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-0.1.21 → hanzo_mcp-0.1.25}/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-0.1.25/hanzo_mcp/tools/project/__init__.py

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

{hanzo_mcp-0.1.21 → hanzo_mcp-0.1.25}/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-0.1.25/hanzo_mcp/tools/shell/__init__.py

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

{hanzo_mcp-0.1.21 → hanzo_mcp-0.1.25}/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 → hanzo_mcp-0.1.25}/hanzo_mcp.egg-info/PKG-INFO

@@ -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.21 → hanzo_mcp-0.1.25}/hanzo_mcp.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ hanzo_mcp.egg-info/dependency_links.txt
 hanzo_mcp.egg-info/entry_points.txt
 hanzo_mcp.egg-info/requires.txt
 hanzo_mcp.egg-info/top_level.txt
+hanzo_mcp.egg-info/zip-safe
 hanzo_mcp/tools/__init__.py
 hanzo_mcp/tools/common/__init__.py
 hanzo_mcp/tools/common/context.py

hanzo_mcp-0.1.25/hanzo_mcp.egg-info/zip-safe

@@ -0,0 +1 @@
+

{hanzo_mcp-0.1.21 → hanzo_mcp-0.1.25}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hanzo-mcp"
-version = "0.1.21"
+version = "0.1.25"
 description = "MCP server for accessing Hanzo APIs and Platform capabilities"
 readme = "README.md"
 requires-python = ">=3.13"
 license = { text = "MIT" }
-authors = [{ name = "Hanzo Dev", email = "dev@hanzo.ai" }]
+authors = [{ name = "Hanzo", email = "dev@hanzo.ai" }]
 classifiers = [
   "Programming Language :: Python :: 3",
   "License :: OSI Approved :: MIT License",
@@ -31,10 +31,16 @@ performance = ["ujson>=5.7.0", "orjson>=3.9.0"]
 [project.scripts]
 hanzo-mcp = "hanzo_mcp.cli:main"
 
+[tool.setuptools]
+zip-safe = true
+
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["hanzo_mcp*"]
 
+[tool.bdist_wheel]
+universal = true
+
 [tool.basedpyright]
 include = ["hanzo_mcp"]
 exclude = [

{hanzo_mcp-0.1.21 → hanzo_mcp-0.1.25}/tests/test_cli.py

@@ -18,7 +18,7 @@ class TestCLI:
         """Test the main function running the server."""
         with (
             patch("argparse.ArgumentParser.parse_args") as mock_parse_args,
-            patch("hanzo_mcp.cli.HanzoDevServer") as mock_server_class,
+            patch("hanzo_mcp.cli.HanzoMCPServer") as mock_server_class,
         ):
             # Mock parsed arguments
             mock_args = MagicMock()
@@ -67,7 +67,7 @@ class TestCLI:
         """Test the main function without specified allowed paths."""
         with (
             patch("argparse.ArgumentParser.parse_args") as mock_parse_args,
-            patch("hanzo_mcp.cli.HanzoDevServer") as mock_server_class,
+            patch("hanzo_mcp.cli.HanzoMCPServer") as mock_server_class,
             patch("os.getcwd", return_value="/current/dir"),
         ):
             # Mock parsed arguments

{hanzo_mcp-0.1.21 → hanzo_mcp-0.1.25}/tests/test_server.py

@@ -5,28 +5,28 @@ from typing import Tuple
 
 import pytest
 
-from hanzo_mcp.server import HanzoDevServer
+from hanzo_mcp.server import HanzoMCPServer
 
 
-class TestHanzoDevServer:
-    """Test the HanzoDevServer class."""
+class TestHanzoMCPServer:
+    """Test the HanzoMCPServer class."""
 
     @pytest.fixture
-    def server(self) -> Tuple[HanzoDevServer, MagicMock]:
-        """Create a HanzoDevServer instance for testing."""
+    def server(self) -> Tuple[HanzoMCPServer, MagicMock]:
+        """Create a HanzoMCPServer instance for testing."""
         with patch("mcp.server.fastmcp.FastMCP") as mock_fastmcp:
             # Create a mock FastMCP instance
             mock_mcp = MagicMock()
             mock_fastmcp.return_value = mock_mcp
 
             # Create the server with the mock MCP
-            server = HanzoDevServer(name="test-server", mcp_instance=mock_mcp)
+            server = HanzoMCPServer(name="test-server", mcp_instance=mock_mcp)
 
             # Return both the server and the mock MCP
             yield server, mock_mcp
 
-    def test_initialization(self, server: Tuple[HanzoDevServer, MagicMock]) -> None:
-        """Test initializing HanzoDevServer."""
+    def test_initialization(self, server: Tuple[HanzoMCPServer, MagicMock]) -> None:
+        """Test initializing HanzoMCPServer."""
         server_instance, mock_mcp = server
 
         # Verify components were initialized
@@ -54,7 +54,7 @@ class TestHanzoDevServer:
             doc_context = MagicMock()
 
             # Create the server
-            server = HanzoDevServer(name="test-server", mcp_instance=mock_mcp)
+            server = HanzoMCPServer(name="test-server", mcp_instance=mock_mcp)
 
             # Inject our mocks
             server.permission_manager = perm_manager
@@ -89,7 +89,7 @@ class TestHanzoDevServer:
             mock_register.assert_called_once()
 
     @pytest.mark.skip(reason="Cannot run stdio server in a test environment")
-    def test_run(self, server: Tuple[HanzoDevServer, MagicMock]) -> None:
+    def test_run(self, server: Tuple[HanzoMCPServer, MagicMock]) -> None:
         """Test running the server."""
         server_instance, mock_mcp = server
 
@@ -111,7 +111,7 @@ class TestHanzoDevServer:
 
     @pytest.mark.skip(reason="Cannot run stdio server in a test environment")
     def test_run_with_allowed_paths(
-        self, server: Tuple[HanzoDevServer, MagicMock]
+        self, server: Tuple[HanzoMCPServer, MagicMock]
     ) -> None:
         """Test running the server with additional allowed paths."""
         server_instance, mock_mcp = server
@@ -145,7 +145,7 @@ def test_main() -> None:
     """Test the main function."""
     with (
         patch("argparse.ArgumentParser.parse_args") as mock_parse_args,
-        patch("hanzo_mcp.server.HanzoDevServer") as mock_server_class,
+        patch("hanzo_mcp.server.HanzoMCPServer") as mock_server_class,
     ):
         # Mock parsed arguments
         mock_args = MagicMock()

{hanzo_mcp-0.1.21 → hanzo_mcp-0.1.25}/tests/test_validation.py

@@ -1,4 +1,4 @@
-"""Tests for parameter validation in Hanzo Dev MCP tools."""
+"""Tests for parameter validation in Hanzo MCP tools."""
 
 from hanzo_mcp.tools.common.validation import (
     validate_parameter,

hanzo_mcp-0.1.21/hanzo_mcp/tools/common/__init__.py

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

hanzo_mcp-0.1.21/hanzo_mcp/tools/common/permissions.py

@@ -1,253 +0,0 @@
-"""Permission system for the Hanzo Dev MCP server."""
-
-import json
-import os
-from collections.abc import Awaitable, Callable
-from pathlib import Path
-from typing import Any, TypeVar, final
-
-# Define type variables for better type annotations
-T = TypeVar("T")
-P = TypeVar("P")
-
-
-@final
-class PermissionManager:
-    """Manages permissions for file and command operations."""
-
-    def __init__(self) -> None:
-        """Initialize the permission manager."""
-        # Allowed paths
-        self.allowed_paths: set[Path] = set(
-            [Path("/tmp").resolve(), Path("/var").resolve()]
-        )
-
-        # Excluded paths
-        self.excluded_paths: set[Path] = set()
-        self.excluded_patterns: list[str] = []
-
-        # Default excluded patterns
-        self._add_default_exclusions()
-
-    def _add_default_exclusions(self) -> None:
-        """Add default exclusions for sensitive files and directories."""
-        # Sensitive directories
-        sensitive_dirs: list[str] = [
-            # ".git" is now allowed by default
-            ".ssh",
-            ".gnupg",
-            ".config",
-            "node_modules",
-            "__pycache__",
-            ".venv",
-            "venv",
-            "env",
-            ".idea",
-            ".vscode",
-            ".DS_Store",
-        ]
-        self.excluded_patterns.extend(sensitive_dirs)
-
-        # Sensitive file patterns
-        sensitive_patterns: list[str] = [
-            ".env",
-            "*.key",
-            "*.pem",
-            "*.crt",
-            "*password*",
-            "*secret*",
-            "*.sqlite",
-            "*.db",
-            "*.sqlite3",
-            "*.log",
-        ]
-        self.excluded_patterns.extend(sensitive_patterns)
-
-    def add_allowed_path(self, path: str) -> None:
-        """Add a path to the allowed paths.
-
-        Args:
-            path: The path to allow
-        """
-        resolved_path: Path = Path(path).resolve()
-        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
-        """
-        resolved_path: Path = Path(path).resolve()
-        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.
-
-        Args:
-            path: The path to exclude
-        """
-        resolved_path: Path = Path(path).resolve()
-        self.excluded_paths.add(resolved_path)
-
-    def add_exclusion_pattern(self, pattern: str) -> None:
-        """Add an exclusion pattern.
-
-        Args:
-            pattern: The pattern to exclude
-        """
-        self.excluded_patterns.append(pattern)
-
-    def is_path_allowed(self, path: str) -> bool:
-        """Check if a path is allowed.
-
-        Args:
-            path: The path to check
-
-        Returns:
-            True if the path is allowed, False otherwise
-        """
-        resolved_path: Path = Path(path).resolve()
-
-        # Check exclusions first
-        if self._is_path_excluded(resolved_path):
-            return False
-
-        # Check if the path is within any allowed path
-        for allowed_path in self.allowed_paths:
-            try:
-                resolved_path.relative_to(allowed_path)
-                return True
-            except ValueError:
-                continue
-
-        return False
-
-    def _is_path_excluded(self, path: Path) -> bool:
-        """Check if a path is excluded.
-
-        Args:
-            path: The path to check
-
-        Returns:
-            True if the path is excluded, False otherwise
-        """
-
-        # Check exact excluded paths
-        if path in self.excluded_paths:
-            return True
-
-        # Check excluded patterns
-        path_str: str = str(path)
-
-        # Get path parts to check for exact directory/file name matches
-        path_parts = path_str.split(os.sep)
-
-        for pattern in self.excluded_patterns:
-            # Handle wildcard patterns (e.g., "*.log")
-            if pattern.startswith("*"):
-                if path_str.endswith(pattern[1:]):
-                    return True
-            else:
-                # For non-wildcard patterns, check if any path component matches exactly
-                if pattern in path_parts:
-                    return True
-
-        return False
-
-    def to_json(self) -> str:
-        """Convert the permission manager to a JSON string.
-
-        Returns:
-            A JSON string representation 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.
-
-        Args:
-            json_str: The JSON string
-
-        Returns:
-            A new PermissionManager instance
-        """
-        data: dict[str, Any] = json.loads(json_str)
-
-        manager = cls()
-
-        for path in data.get("allowed_paths", []):
-            manager.add_allowed_path(path)
-
-        for path in data.get("excluded_paths", []):
-            manager.exclude_path(path)
-
-        manager.excluded_patterns = data.get("excluded_patterns", [])
-
-        return manager
-
-
-class PermissibleOperation:
-    """A decorator for operations that require permission."""
-
-    def __init__(
-        self,
-        permission_manager: PermissionManager,
-        operation: str,
-        get_path_fn: Callable[[list[Any], dict[str, Any]], str] | None = None,
-    ) -> None:
-        """Initialize the permissible operation.
-
-        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
-        """
-        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
-        )
-
-    def __call__(
-        self, func: Callable[..., Awaitable[T]]
-    ) -> Callable[..., Awaitable[T]]:
-        """Decorate the function.
-
-        Args:
-            func: The function to decorate
-
-        Returns:
-            The decorated function
-        """
-
-        async def wrapper(*args: Any, **kwargs: Any) -> T:
-            # Extract the path
-            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
-                path = args[0] if args else next(iter(kwargs.values()), None)
-
-            if not isinstance(path, str):
-                raise ValueError(f"Invalid path type: {type(path)}")
-
-            # Check permission
-            if not self.permission_manager.is_path_allowed(path):
-                raise PermissionError(
-                    f"Operation '{self.operation}' not allowed for path: {path}"
-                )
-
-            # Call the function
-            return await func(*args, **kwargs)
-
-        return wrapper

hanzo_mcp-0.1.21/hanzo_mcp/tools/project/__init__.py

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

hanzo_mcp-0.1.21/hanzo_mcp/tools/shell/__init__.py

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