hanzo-mcp 0.1.36__tar.gz → 0.2.0__tar.gz

{hanzo_mcp-0.1.36 → hanzo_mcp-0.2.0}/PKG-INFO

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

{hanzo_mcp-0.1.36 → hanzo_mcp-0.2.0}/hanzo_mcp/__init__.py

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

{hanzo_mcp-0.1.36 → hanzo_mcp-0.2.0}/hanzo_mcp/cli.py

@@ -8,7 +8,6 @@ from pathlib import Path
 from typing import Any, cast
 
 from hanzo_mcp.server import HanzoServer
-from hanzo_mcp.tools.common.path_utils import PathUtils
 
 
 def main() -> None:
@@ -83,6 +82,14 @@ def main() -> None:
         default=False,
         help="Enable the agent tool (disabled by default)"
     )
+    
+    _ = parser.add_argument(
+        "--disable-write-tools",
+        dest="disable_write_tools",
+        action="store_true",
+        default=False,
+        help="Disable write/edit tools (file writing, editing, notebook editing) to use IDE tools instead. Note: Shell commands can still modify files."
+    )
 
     _ = parser.add_argument(
         "--install",
@@ -103,29 +110,33 @@ def main() -> None:
     agent_max_iterations: int = cast(int, args.agent_max_iterations)
     agent_max_tool_uses: int = cast(int, args.agent_max_tool_uses)
     enable_agent_tool: bool = cast(bool, args.enable_agent_tool)
+    disable_write_tools: bool = cast(bool, args.disable_write_tools)
     allowed_paths: list[str] = (
         cast(list[str], args.allowed_paths) if args.allowed_paths else []
     )
 
     if install:
-        install_claude_desktop_config(name, allowed_paths)
+        install_claude_desktop_config(name, allowed_paths, disable_write_tools)
         return
 
     # If no allowed paths are specified, use the user's home directory
     if not allowed_paths:
         allowed_paths = [str(Path.home())]
-        
-    # Normalize all allowed paths
-    allowed_paths = [PathUtils.normalize_path(path) for path in allowed_paths]
 
-    # If project directory is specified, normalize it and add to allowed paths
+    # If project directory is specified, add it to allowed paths
+    if project_dir and project_dir not in allowed_paths:
+        allowed_paths.append(project_dir)
+
+    # Set project directory as initial working directory if provided
     if project_dir:
-        project_dir = PathUtils.normalize_path(project_dir)
-        if project_dir not in allowed_paths:
-            allowed_paths.append(project_dir)
+        # Expand user paths
+        project_dir = os.path.expanduser(project_dir)
+        # Make absolute
+        if not os.path.isabs(project_dir):
+            project_dir = os.path.abspath(project_dir)
 
     # If no specific project directory, use the first allowed path
-    if not project_dir and allowed_paths:
+    elif allowed_paths:
         project_dir = allowed_paths[0]
 
     # Run the server
@@ -138,20 +149,25 @@ def main() -> None:
         agent_api_key=agent_api_key,
         agent_max_iterations=agent_max_iterations,
         agent_max_tool_uses=agent_max_tool_uses,
-        enable_agent_tool=enable_agent_tool
+        enable_agent_tool=enable_agent_tool,
+        disable_write_tools=disable_write_tools
     )
     # Transport will be automatically cast to Literal['stdio', 'sse'] by the server
     server.run(transport=transport)
 
 
 def install_claude_desktop_config(
-    name: str = "claude-code", allowed_paths: list[str] | None = None
+    name: str = "claude-code", allowed_paths: list[str] | None = None,
+    disable_write_tools: bool = False
 ) -> None:
     """Install the server configuration in Claude Desktop.
 
     Args:
         name: The name to use for the server in the config
         allowed_paths: Optional list of paths to allow
+        disable_write_tools: Whether to disable write/edit tools (file writing, editing, notebook editing)
+                          to use IDE tools instead. Note: Shell commands can still modify files.
+                          (default: False)
     """
     # Find the Claude Desktop config directory
     home: Path = Path.home()
@@ -181,6 +197,10 @@ def install_claude_desktop_config(
     else:
         # Allow home directory by default
         args.extend(["--allow-path", str(home)])
+        
+    # Add disable_write_tools flag if specified
+    if disable_write_tools:
+        args.append("--disable-write-tools")
 
     # Create config object
     config: dict[str, Any] = {

{hanzo_mcp-0.1.36 → hanzo_mcp-0.2.0}/hanzo_mcp/server.py

@@ -6,7 +6,6 @@ from mcp.server.fastmcp import FastMCP
 
 from hanzo_mcp.tools import register_all_tools
 from hanzo_mcp.tools.common.context import DocumentContext
-from hanzo_mcp.tools.common.path_utils import PathUtils
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.project.analysis import ProjectAnalyzer, ProjectManager
 from hanzo_mcp.tools.shell.command_executor import CommandExecutor
@@ -28,6 +27,7 @@ class HanzoServer:
         agent_max_iterations: int = 10,
         agent_max_tool_uses: int = 30,
         enable_agent_tool: bool = False,
+        disable_write_tools: bool = False,
     ):
         """Initialize the Hanzo server.
 
@@ -42,6 +42,7 @@ class HanzoServer:
             agent_max_iterations: Maximum number of iterations for agent (default: 10)
             agent_max_tool_uses: Maximum number of total tool uses for agent (default: 30)
             enable_agent_tool: Whether to enable the agent tool (default: False)
+            disable_write_tools: Whether to disable write/edit tools (default: False)
         """
         self.mcp = mcp_instance if mcp_instance is not None else FastMCP(name)
 
@@ -71,10 +72,8 @@ class HanzoServer:
         # Add allowed paths
         if allowed_paths:
             for path in allowed_paths:
-                # Path should already be normalized from CLI, but normalize here for safety
-                normalized_path = PathUtils.normalize_path(path)
-                self.permission_manager.add_allowed_path(normalized_path)
-                self.document_context.add_allowed_path(normalized_path)
+                self.permission_manager.add_allowed_path(path)
+                self.document_context.add_allowed_path(path)
 
         # Store agent options
         self.agent_model = agent_model
@@ -83,6 +82,7 @@ class HanzoServer:
         self.agent_max_iterations = agent_max_iterations
         self.agent_max_tool_uses = agent_max_tool_uses
         self.enable_agent_tool = enable_agent_tool
+        self.disable_write_tools = disable_write_tools
         
         # Register all tools
         register_all_tools(
@@ -95,6 +95,7 @@ class HanzoServer:
             agent_max_iterations=self.agent_max_iterations,
             agent_max_tool_uses=self.agent_max_tool_uses,
             enable_agent_tool=self.enable_agent_tool,
+            disable_write_tools=self.disable_write_tools,
         )
 
     def run(self, transport: str = "stdio", allowed_paths: list[str] | None = None):
@@ -107,10 +108,8 @@ class HanzoServer:
         # Add allowed paths if provided
         allowed_paths_list = allowed_paths or []
         for path in allowed_paths_list:
-            # Normalize path before adding
-            normalized_path = PathUtils.normalize_path(path)
-            self.permission_manager.add_allowed_path(normalized_path)
-            self.document_context.add_allowed_path(normalized_path)
+            self.permission_manager.add_allowed_path(path)
+            self.document_context.add_allowed_path(path)
 
         # Run the server
         transport_type = cast(Literal["stdio", "sse"], transport)

{hanzo_mcp-0.1.36 → hanzo_mcp-0.2.0}/hanzo_mcp/tools/__init__.py

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

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

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

{hanzo_mcp-0.1.36 → hanzo_mcp-0.2.0}/hanzo_mcp.egg-info/SOURCES.txt

@@ -19,7 +19,6 @@ hanzo_mcp/tools/agent/tool_adapter.py
 hanzo_mcp/tools/common/__init__.py
 hanzo_mcp/tools/common/base.py
 hanzo_mcp/tools/common/context.py
-hanzo_mcp/tools/common/path_utils.py
 hanzo_mcp/tools/common/permissions.py
 hanzo_mcp/tools/common/session.py
 hanzo_mcp/tools/common/think_tool.py
@@ -51,4 +50,5 @@ hanzo_mcp/tools/shell/run_script.py
 hanzo_mcp/tools/shell/script_tool.py
 tests/test_cli.py
 tests/test_server.py
+tests/test_tools_registration.py
 tests/test_validation.py

{hanzo_mcp-0.1.36 → hanzo_mcp-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hanzo-mcp"
-version = "0.1.36"
+version = "0.2.0"
 description = "MCP implementation of Hanzo capabilities"
 readme = "README.md"
 requires-python = ">=3.12"

{hanzo_mcp-0.1.36 → hanzo_mcp-0.2.0}/tests/test_cli.py

@@ -33,6 +33,7 @@ class TestCLI:
             mock_args.agent_max_iterations = 10
             mock_args.agent_max_tool_uses = 30
             mock_args.enable_agent_tool = False
+            mock_args.disable_write_tools = False
             mock_parse_args.return_value = mock_args
 
             # Mock server instance
@@ -53,7 +54,8 @@ class TestCLI:
                 agent_api_key="test_api_key",
                 agent_max_iterations=10,
                 agent_max_tool_uses=30,
-                enable_agent_tool=False
+                enable_agent_tool=False,
+                disable_write_tools=False
             )
             mock_server.run.assert_called_once_with(transport="stdio")
 
@@ -96,6 +98,7 @@ class TestCLI:
             mock_args.agent_max_iterations = 10
             mock_args.agent_max_tool_uses = 30
             mock_args.enable_agent_tool = False
+            mock_args.disable_write_tools = False
             mock_parse_args.return_value = mock_args
 
             # Mock server instance
@@ -114,7 +117,52 @@ class TestCLI:
                 agent_api_key=None,
                 agent_max_iterations=10,
                 agent_max_tool_uses=30,
-                enable_agent_tool=False
+                enable_agent_tool=False,
+                disable_write_tools=False
+            )
+            mock_server.run.assert_called_once_with(transport="stdio")
+            
+    def test_main_with_disable_write_tools(self) -> None:
+        """Test the main function with disable_write_tools=True."""
+        with (
+            patch("argparse.ArgumentParser.parse_args") as mock_parse_args,
+            patch("hanzo_mcp.cli.HanzoServer") as mock_server_class,
+        ):
+            # Mock parsed arguments
+            mock_args = MagicMock()
+            mock_args.name = "test-server"
+            mock_args.transport = "stdio"
+            mock_args.allowed_paths = ["/test/path"]
+            mock_args.project_dir = "/test/project"
+            mock_args.install = False
+            mock_args.agent_model = None
+            mock_args.agent_max_tokens = None
+            mock_args.agent_api_key = None
+            mock_args.agent_max_iterations = 10
+            mock_args.agent_max_tool_uses = 30
+            mock_args.enable_agent_tool = False
+            mock_args.disable_write_tools = True
+            mock_parse_args.return_value = mock_args
+
+            # Mock server instance
+            mock_server = MagicMock()
+            mock_server_class.return_value = mock_server
+
+            # Call main
+            main()
+
+            # Verify server was created with disable_write_tools=True
+            expected_paths = ["/test/path", "/test/project"]
+            mock_server_class.assert_called_once_with(
+                name="test-server",
+                allowed_paths=expected_paths,
+                agent_model=None,
+                agent_max_tokens=None,
+                agent_api_key=None,
+                agent_max_iterations=10,
+                agent_max_tool_uses=30,
+                enable_agent_tool=False,
+                disable_write_tools=True
             )
             mock_server.run.assert_called_once_with(transport="stdio")
 
@@ -313,4 +361,47 @@ class TestInstallClaudeDesktopConfig:
             # Verify home directory was added as an allowed path
             assert "--allow-path" in server_args
             home_path_index = server_args.index("--allow-path") + 1
-            assert str(tmp_path) in server_args[home_path_index]
+            assert str(tmp_path) in server_args[home_path_index]
+            
+            # Verify --disable-write-tools flag is not present
+            assert "--disable-write-tools" not in server_args
+            
+    def test_install_config_with_disable_write_tools(
+        self, mock_platform: Callable[[str], str], tmp_path: Path
+    ) -> None:
+        """Test installing config with disable_write_tools=True."""
+        # Set platform to macOS
+        mock_platform("darwin")
+
+        # Mock home directory and config path
+        with (
+            patch("pathlib.Path.home", return_value=Path(tmp_path)),
+            patch("sys.executable", "/usr/bin/python3"),
+            patch("json.dump") as mock_json_dump,
+            patch("builtins.open", create=True) as mock_open,
+            patch("pathlib.Path.exists", return_value=False),
+            patch("pathlib.Path.mkdir"),
+        ):
+            # Mock file opening
+            mock_file = MagicMock()
+            mock_open.return_value.__enter__.return_value = mock_file
+
+            # Call the install function with disable_write_tools=True
+            install_claude_desktop_config(
+                "test-server", 
+                allowed_paths=["/test/path"], 
+                disable_write_tools=True
+            )
+
+            # Verify correct config was written
+            mock_json_dump.assert_called_once()
+            config_data = mock_json_dump.call_args[0][0]
+            server_args = config_data["mcpServers"]["test-server"]["args"]
+
+            # Verify allowed path was added
+            assert "--allow-path" in server_args
+            path_index = server_args.index("--allow-path") + 1
+            assert "/test/path" in server_args[path_index]
+            
+            # Verify --disable-write-tools flag is present
+            assert "--disable-write-tools" in server_args

{hanzo_mcp-0.1.36 → hanzo_mcp-0.2.0}/tests/test_server.py

@@ -35,6 +35,26 @@ class TestHanzoServer:
         assert server_instance.command_executor is not None
         assert server_instance.project_analyzer is not None
         assert server_instance.project_manager is not None
+        
+    def test_initialization_with_disable_write_tools(self) -> None:
+        """Test initializing HanzoServer with disable_write_tools=True."""
+        with patch("mcp.server.fastmcp.FastMCP") as mock_fastmcp, \
+             patch("hanzo_mcp.tools.register_all_tools") as mock_register_all_tools:
+            # Create a mock FastMCP instance
+            mock_mcp = MagicMock()
+            mock_fastmcp.return_value = mock_mcp
+            
+            # Create the server with disable_write_tools=True
+            server = HanzoServer(
+                name="test-server", 
+                mcp_instance=mock_mcp,
+                disable_write_tools=True
+            )
+            
+            # Verify that the disable_write_tools flag was passed to register_all_tools
+            mock_register_all_tools.assert_called_once()
+            args, kwargs = mock_register_all_tools.call_args
+            assert kwargs.get("disable_write_tools") is True
 
     def test_initialization_with_allowed_paths(self) -> None:
         """Test initializing with allowed paths."""

hanzo_mcp-0.2.0/tests/test_tools_registration.py

@@ -0,0 +1,180 @@
+"""Tests for the tools registration process."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from hanzo_mcp.tools import register_all_tools
+from hanzo_mcp.tools.common.context import DocumentContext
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.filesystem import (
+    ReadFilesTool, 
+    WriteFileTool, 
+    EditFileTool,
+    DirectoryTreeTool,
+    GetFileInfoTool,
+    SearchContentTool,
+    ContentReplaceTool
+)
+from hanzo_mcp.tools.jupyter import (
+    ReadNotebookTool,
+    EditNotebookTool
+)
+
+
+class TestToolsRegistration:
+    """Test the tools registration process."""
+
+    @pytest.fixture
+    def mcp_server(self):
+        """Create a mock MCP server."""
+        server = MagicMock()
+        return server
+
+    @pytest.fixture
+    def document_context(self):
+        """Create a document context."""
+        return DocumentContext()
+
+    @pytest.fixture
+    def permission_manager(self):
+        """Create a permission manager."""
+        return PermissionManager()
+
+    def test_register_all_tools_default(
+        self, mcp_server, document_context, permission_manager
+    ):
+        """Test registering all tools with default settings."""
+        # Mock the tool registry to capture registered tools
+        registered_tools = []
+        
+        with patch("hanzo_mcp.tools.ToolRegistry.register_tools") as mock_register:
+            mock_register.side_effect = lambda _, tools: registered_tools.extend(tools)
+            
+            # Register all tools with default settings
+            register_all_tools(
+                mcp_server=mcp_server,
+                document_context=document_context,
+                permission_manager=permission_manager
+            )
+            
+            # Check that all filesystem tools are registered
+            fs_tool_types = [type(tool) for tool in registered_tools 
+                            if isinstance(tool, (ReadFilesTool, WriteFileTool, EditFileTool, 
+                                               DirectoryTreeTool, GetFileInfoTool, 
+                                               SearchContentTool, ContentReplaceTool))]
+            
+            assert ReadFilesTool in fs_tool_types
+            assert WriteFileTool in fs_tool_types
+            assert EditFileTool in fs_tool_types
+            
+            # Check that all Jupyter tools are registered
+            jupyter_tool_types = [type(tool) for tool in registered_tools 
+                                if isinstance(tool, (ReadNotebookTool, EditNotebookTool))]
+            
+            assert ReadNotebookTool in jupyter_tool_types
+            assert EditNotebookTool in jupyter_tool_types
+
+    def test_register_all_tools_disable_write_tools(
+        self, mcp_server, document_context, permission_manager
+    ):
+        """Test registering all tools with disable_write_tools=True."""
+        # Mock the tool registry to capture registered tools
+        registered_tools = []
+        
+        with patch("hanzo_mcp.tools.ToolRegistry.register_tools") as mock_register:
+            mock_register.side_effect = lambda _, tools: registered_tools.extend(tools)
+            
+            # Register all tools with disable_write_tools=True
+            register_all_tools(
+                mcp_server=mcp_server,
+                document_context=document_context,
+                permission_manager=permission_manager,
+                disable_write_tools=True
+            )
+            
+            # Check that only read-only filesystem tools are registered
+            fs_tool_types = [type(tool) for tool in registered_tools]
+            
+            # Read-only tools should be present
+            assert ReadFilesTool in fs_tool_types
+            assert DirectoryTreeTool in fs_tool_types
+            assert GetFileInfoTool in fs_tool_types
+            assert SearchContentTool in fs_tool_types
+            
+            # Write tools should not be present
+            assert WriteFileTool not in fs_tool_types
+            assert EditFileTool not in fs_tool_types
+            assert ContentReplaceTool not in fs_tool_types
+            
+            # Check that only read-only Jupyter tools are registered
+            jupyter_tool_types = [type(tool) for tool in registered_tools]
+            
+            # Read-only tools should be present
+            assert ReadNotebookTool in jupyter_tool_types
+            
+            # Write tools should not be present
+            assert EditNotebookTool not in jupyter_tool_types
+            
+    def test_register_filesystem_tools_with_disabled_write(
+        self, mcp_server, document_context, permission_manager
+    ):
+        """Test registering filesystem tools with disable_write_tools=True."""
+        from hanzo_mcp.tools.filesystem import register_filesystem_tools
+        
+        # Mock the tool registry to capture registered tools
+        registered_tools = []
+        
+        with patch("hanzo_mcp.tools.filesystem.ToolRegistry.register_tools") as mock_register:
+            mock_register.side_effect = lambda _, tools: registered_tools.extend(tools)
+            
+            # Register filesystem tools with disable_write_tools=True
+            register_filesystem_tools(
+                mcp_server=mcp_server,
+                document_context=document_context,
+                permission_manager=permission_manager,
+                disable_write_tools=True
+            )
+            
+            # Check that only read-only tools are registered
+            tool_types = [type(tool) for tool in registered_tools]
+            
+            # Read-only tools should be present
+            assert ReadFilesTool in tool_types
+            assert DirectoryTreeTool in tool_types
+            assert GetFileInfoTool in tool_types
+            assert SearchContentTool in tool_types
+            
+            # Write tools should not be present
+            assert WriteFileTool not in tool_types
+            assert EditFileTool not in tool_types
+            assert ContentReplaceTool not in tool_types
+            
+    def test_register_jupyter_tools_with_disabled_write(
+        self, mcp_server, document_context, permission_manager
+    ):
+        """Test registering Jupyter tools with disable_write_tools=True."""
+        from hanzo_mcp.tools.jupyter import register_jupyter_tools
+        
+        # Mock the tool registry to capture registered tools
+        registered_tools = []
+        
+        with patch("hanzo_mcp.tools.jupyter.ToolRegistry.register_tools") as mock_register:
+            mock_register.side_effect = lambda _, tools: registered_tools.extend(tools)
+            
+            # Register Jupyter tools with disable_write_tools=True
+            register_jupyter_tools(
+                mcp_server=mcp_server,
+                document_context=document_context,
+                permission_manager=permission_manager,
+                disable_write_tools=True
+            )
+            
+            # Check that only read-only tools are registered
+            tool_types = [type(tool) for tool in registered_tools]
+            
+            # Read-only tools should be present
+            assert ReadNotebookTool in tool_types
+            
+            # Write tools should not be present
+            assert EditNotebookTool not in tool_types

hanzo_mcp-0.1.36/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(".")