hanzo-mcp 0.1.21__py3-none-any.whl

hanzo_mcp/__init__.py

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

hanzo_mcp/cli.py

@@ -0,0 +1,155 @@
+"""Command-line interface for the Hanzo MCP server."""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, cast
+
+from hanzo_mcp.server import HanzoDevServer
+
+
+def main() -> None:
+    """Run the CLI for the Hanzo Dev MCP server."""
+    parser = argparse.ArgumentParser(
+        description="MCP server for accessing Hanzo APIs and Platform capabilities"
+    )
+
+    _ = parser.add_argument(
+        "--transport",
+        choices=["stdio", "sse"],
+        default="stdio",
+        help="Transport protocol to use (default: stdio)",
+    )
+
+    _ = parser.add_argument(
+        "--name",
+        default="hanzo",
+        help="Name of the MCP server (default: hanzo)",
+    )
+
+    _ = parser.add_argument(
+        "--allow-path",
+        action="append",
+        dest="allowed_paths",
+        help="Add an allowed path (can be specified multiple times)",
+    )
+
+    _ = parser.add_argument(
+        "--project-dir", dest="project_dir", help="Set the project directory to analyze"
+    )
+
+    _ = parser.add_argument(
+        "--install",
+        action="store_true",
+        help="Install server configuration in Claude Desktop",
+    )
+
+    args = parser.parse_args()
+
+    # Cast args attributes to appropriate types to avoid 'Any' warnings
+    name: str = cast(str, args.name)
+    install: bool = cast(bool, args.install)
+    transport: str = cast(str, args.transport)
+    project_dir: str | None = cast(str | None, args.project_dir)
+    allowed_paths: list[str] = (
+        cast(list[str], args.allowed_paths) if args.allowed_paths else []
+    )
+
+    if install:
+        install_claude_desktop_config(name, allowed_paths)
+        return
+
+    # If no allowed paths are specified, use the current directory
+    if not allowed_paths:
+        allowed_paths = [os.getcwd()]
+
+    # 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)
+
+    # Run the server
+    server = HanzoDevServer(name=name, allowed_paths=allowed_paths)
+    # Transport will be automatically cast to Literal['stdio', 'sse'] by the server
+    server.run(transport=transport)
+
+
+def install_claude_desktop_config(
+    name: str = "hanzo", allowed_paths: list[str] | None = None
+) -> 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
+    """
+    # Find the Claude Desktop config directory
+    home: Path = Path.home()
+
+    if sys.platform == "darwin":  # macOS
+        config_dir: Path = home / "Library" / "Application Support" / "Claude"
+    elif sys.platform == "win32":  # Windows
+        config_dir = Path(os.environ.get("APPDATA", "")) / "Claude"
+    else:  # Linux and others
+        config_dir = home / ".config" / "claude"
+
+    config_file: Path = config_dir / "claude_desktop_config.json"
+
+    # Create directory if it doesn't exist
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    # Get current script path
+    script_path: Path = Path(sys.executable)
+
+    # Create args array
+    args: list[str] = ["-m", "hanzo_mcp.cli"]
+
+    # Add allowed paths if specified
+    if allowed_paths:
+        for path in allowed_paths:
+            args.extend(["--allow-path", path])
+    else:
+        # Allow home directory by default
+        args.extend(["--allow-path", str(home)])
+
+    # Create config object
+    config: dict[str, Any] = {
+        "mcpServers": {name: {"command": str(script_path), "args": args}}
+    }
+
+    # Check if the file already exists
+    if config_file.exists():
+        try:
+            with open(config_file, "r") as f:
+                existing_config: dict[str, Any] = json.load(f)
+
+            # Update the existing config
+            if "mcpServers" not in existing_config:
+                existing_config["mcpServers"] = {}
+
+            existing_config["mcpServers"][name] = config["mcpServers"][name]
+            config = existing_config
+        except Exception as e:
+            print(f"Error reading existing config: {e}")
+            print("Creating new config file.")
+
+    # Write the config file
+    with open(config_file, mode="w") as f:
+        json.dump(config, f, indent=2)
+
+    print(f"Successfully installed {name} in Claude Desktop configuration.")
+    print(f"Config file: {config_file}")
+
+    if allowed_paths:
+        print("\nAllowed paths:")
+        for path in allowed_paths:
+            print(f"- {path}")
+    else:
+        print(f"\nDefault allowed path: {home}")
+    print("\nYou can modify allowed paths in the config file directly.")
+    print("Restart Claude Desktop for changes to take effect.")
+
+
+if __name__ == "__main__":
+    main()

hanzo_mcp/server.py

@@ -0,0 +1,125 @@
+"""MCP server for accessing Hanzo APIs and Platform capabilities."""
+
+from typing import Literal, cast, final
+
+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.permissions import PermissionManager
+from hanzo_mcp.tools.project.analysis import ProjectAnalyzer, ProjectManager
+from hanzo_mcp.tools.shell.command_executor import CommandExecutor
+
+
+@final
+class HanzoDevServer:
+    """MCP server for accessing Hanzo APIs and Platform capabilities."""
+
+    def __init__(
+        self,
+        name: str = "hanzo",
+        allowed_paths: list[str] | None = None,
+        mcp_instance: FastMCP | None = None,
+    ):
+        """Initialize the Hanzo Dev server.
+
+        Args:
+            name: The name of the server
+            allowed_paths: list of paths that the server is allowed to access
+            mcp_instance: Optional FastMCP instance for testing
+        """
+        self.mcp = mcp_instance if mcp_instance is not None else FastMCP(name)
+
+        # Initialize context, permissions, and command executor
+        self.document_context = DocumentContext()
+        self.permission_manager = PermissionManager()
+
+        # Initialize command executor
+        self.command_executor = CommandExecutor(
+            permission_manager=self.permission_manager,
+            verbose=False,  # Set to True for debugging
+        )
+
+        # Initialize project analyzer
+        self.project_analyzer = ProjectAnalyzer(self.command_executor)
+
+        # Initialize project manager
+        self.project_manager = ProjectManager(
+            self.document_context, self.permission_manager, self.project_analyzer
+        )
+
+        # Add allowed paths
+        if allowed_paths:
+            for path in allowed_paths:
+                self.permission_manager.add_allowed_path(path)
+                self.document_context.add_allowed_path(path)
+
+        # Register all tools
+        register_all_tools(
+            mcp_server=self.mcp,
+            document_context=self.document_context,
+            permission_manager=self.permission_manager,
+            project_manager=self.project_manager,
+            project_analyzer=self.project_analyzer,
+        )
+
+    def run(self, transport: str = "stdio", allowed_paths: list[str] | None = None):
+        """Run the MCP server.
+
+        Args:
+            transport: The transport to use (stdio or sse)
+            allowed_paths: list of paths that the server is allowed to access
+        """
+        # Add allowed paths if provided
+        allowed_paths_list = allowed_paths or []
+        for path in allowed_paths_list:
+            self.permission_manager.add_allowed_path(path)
+            self.document_context.add_allowed_path(path)
+
+        # Run the server
+        transport_type = cast(Literal["stdio", "sse"], transport)
+        self.mcp.run(transport=transport_type)
+
+
+def main():
+    """Run the Hanzo MCP server."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="MCP server for accessing Hanzo APIs and Platform capabilities"
+    )
+
+    _ = parser.add_argument(
+        "--name",
+        default="hanzo",
+        help="Name of the MCP server (default: hanzo)",
+    )
+
+    _ = parser.add_argument(
+        "--transport",
+        choices=["stdio", "sse"],
+        default="stdio",
+        help="Transport protocol to use (default: stdio)",
+    )
+
+    _ = parser.add_argument(
+        "--allow-path",
+        action="append",
+        dest="allowed_paths",
+        help="Add an allowed path (can be specified multiple times)",
+    )
+
+    args = parser.parse_args()
+
+    # Type annotations for args to avoid Any warnings
+    name: str = args.name
+    transport: str = args.transport
+    allowed_paths: list[str] | None = args.allowed_paths
+
+    # Create and run the server
+    server = HanzoDevServer(name=name, allowed_paths=allowed_paths)
+    server.run(transport=transport, allowed_paths=allowed_paths or [])
+
+
+if __name__ == "__main__":
+    main()

hanzo_mcp/tools/__init__.py

@@ -0,0 +1,62 @@
+"""Tools package for Hanzo MCP.
+
+This package contains all the tools for the Hanzo MCP server.
+It provides a unified interface for registering all tools with an MCP server.
+
+This includes a "think" tool implementation based on Anthropic's research showing
+improved performance for complex tool-based interactions when Claude has a dedicated
+space for structured thinking.
+"""
+
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from hanzo_mcp.tools.common.context import DocumentContext
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.common.thinking import ThinkingTool
+from hanzo_mcp.tools.filesystem.file_operations import FileOperations
+from hanzo_mcp.tools.jupyter.notebook_operations import JupyterNotebookTools
+from hanzo_mcp.tools.project.analysis import ProjectAnalysis, ProjectManager
+from hanzo_mcp.tools.shell.command_executor import CommandExecutor
+
+
+def register_all_tools(
+    mcp_server: FastMCP,
+    document_context: DocumentContext,
+    permission_manager: PermissionManager,
+    project_manager: ProjectManager,
+    project_analyzer: Any,
+) -> None:
+    """Register all Hanzo MCP tools with the MCP server.
+
+    Args:
+        mcp_server: The FastMCP server instance
+        document_context: Document context for tracking file contents
+        permission_manager: Permission manager for access control
+        command_executor: Enhanced command executor for running shell commands
+        project_manager: Project manager for tracking projects
+        project_analyzer: Project analyzer for analyzing project structure and dependencies
+    """
+    # Initialize and register file operations tools
+    # Now includes all filesystem functionality (navigation + file operations)
+    file_ops = FileOperations(document_context, permission_manager)
+    file_ops.register_tools(mcp_server)
+
+    # Initialize and register command execution tools
+    cmd_exec = CommandExecutor(permission_manager)
+    cmd_exec.register_tools(mcp_server)
+
+    # Initialize and register project analysis tools
+    proj_analysis = ProjectAnalysis(
+        project_manager, project_analyzer, permission_manager
+    )
+    proj_analysis.register_tools(mcp_server)
+
+    # Initialize and register Jupyter notebook tools
+    jupyter_tools = JupyterNotebookTools(document_context, permission_manager)
+    jupyter_tools.register_tools(mcp_server)
+
+    # Initialize and register thinking tool
+    thinking_tool = ThinkingTool()
+    thinking_tool.register_tools(mcp_server)

hanzo_mcp/tools/common/__init__.py

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