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

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

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

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

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

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

@@ -82,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",
@@ -102,12 +110,13 @@ 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
@@ -140,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()
@@ -183,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.35 → hanzo_mcp-0.2.0}/hanzo_mcp/server.py

@@ -27,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.
 
@@ -41,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)
 
@@ -80,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(
@@ -92,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):

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

@@ -12,7 +12,7 @@ to delegate tasks to sub-agents for concurrent execution and specialized process
 from mcp.server.fastmcp import FastMCP
 
 from hanzo_mcp.tools.agent import register_agent_tools
-from hanzo_mcp.tools.common import register_thinking_tool, register_version_tool
+from hanzo_mcp.tools.common import register_think_tool, register_version_tool
 from hanzo_mcp.tools.common.context import DocumentContext
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.filesystem import register_filesystem_tools
@@ -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)
@@ -78,7 +80,7 @@ def register_all_tools(
         )
     
     # Initialize and register thinking tool
-    register_thinking_tool(mcp_server)
+    register_think_tool(mcp_server)
     
     # Register version tool
     register_version_tool(mcp_server)

{hanzo_mcp-0.1.35 → hanzo_mcp-0.2.0}/hanzo_mcp/tools/common/__init__.py

@@ -3,11 +3,11 @@
 from mcp.server.fastmcp import FastMCP
 
 from hanzo_mcp.tools.common.base import ToolRegistry
-from hanzo_mcp.tools.common.thinking_tool import ThinkingTool
+from hanzo_mcp.tools.common.think_tool import ThinkingTool
 from hanzo_mcp.tools.common.version_tool import VersionTool
 
 
-def register_thinking_tool(
+def register_think_tool(
     mcp_server: FastMCP,
 ) -> None:
     """Register all thinking tools with the MCP server. 
@@ -15,8 +15,8 @@ def register_thinking_tool(
     Args:
         mcp_server: The FastMCP server instance
     """
-    thinking_tool = ThinkingTool()
-    ToolRegistry.register_tool(mcp_server, thinking_tool)
+    think_tool = ThinkingTool()
+    ToolRegistry.register_tool(mcp_server, think_tool)
 
 
 def register_version_tool(

{hanzo_mcp-0.1.35 → 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.35 → 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.35 → 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.35
+Version: 0.2.0
 Summary: MCP implementation of Hanzo capabilities
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT

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

@@ -21,7 +21,7 @@ hanzo_mcp/tools/common/base.py
 hanzo_mcp/tools/common/context.py
 hanzo_mcp/tools/common/permissions.py
 hanzo_mcp/tools/common/session.py
-hanzo_mcp/tools/common/thinking_tool.py
+hanzo_mcp/tools/common/think_tool.py
 hanzo_mcp/tools/common/validation.py
 hanzo_mcp/tools/common/version_tool.py
 hanzo_mcp/tools/filesystem/__init__.py
@@ -50,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.35 → hanzo_mcp-0.2.0}/pyproject.toml

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

{hanzo_mcp-0.1.35 → 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.35 → 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