hanzo-mcp 0.1.20__py3-none-any.whl

hanzo_mcp/__init__.py

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

hanzo_mcp/cli.py

@@ -0,0 +1,213 @@
+"""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 HanzoServer
+
+
+def main() -> None:
+    """Run the CLI for the Hanzo MCP server."""
+    parser = argparse.ArgumentParser(
+        description="MCP server implementing Hanzo capabilities"
+    )
+
+    _ = parser.add_argument(
+        "--transport",
+        choices=["stdio", "sse"],
+        default="stdio",
+        help="Transport protocol to use (default: stdio)",
+    )
+
+    _ = parser.add_argument(
+        "--name",
+        default="claude-code",
+        help="Name of the MCP server (default: claude-code)",
+    )
+
+    _ = 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(
+        "--agent-model",
+        dest="agent_model",
+        help="Specify the model name in LiteLLM format (e.g., 'openai/gpt-4o', 'anthropic/claude-3-sonnet')"
+    )
+    
+    _ = parser.add_argument(
+        "--agent-max-tokens",
+        dest="agent_max_tokens",
+        type=int,
+        help="Specify the maximum tokens for agent responses"
+    )
+    
+    _ = parser.add_argument(
+        "--agent-api-key",
+        dest="agent_api_key",
+        help="Specify the API key for the LLM provider (for development/testing only)"
+    )
+    
+    _ = parser.add_argument(
+        "--agent-max-iterations",
+        dest="agent_max_iterations",
+        type=int,
+        default=10,
+        help="Maximum number of iterations for agent (default: 10)"
+    )
+    
+    _ = parser.add_argument(
+        "--agent-max-tool-uses",
+        dest="agent_max_tool_uses",
+        type=int,
+        default=30,
+        help="Maximum number of total tool uses for agent (default: 30)"
+    )
+    
+    _ = parser.add_argument(
+        "--enable-agent-tool",
+        dest="enable_agent_tool",
+        action="store_true",
+        default=False,
+        help="Enable the agent tool (disabled by default)"
+    )
+
+    _ = 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)
+    agent_model: str | None = cast(str | None, args.agent_model)
+    agent_max_tokens: int | None = cast(int | None, args.agent_max_tokens)
+    agent_api_key: str | None = cast(str | None, args.agent_api_key)
+    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)
+    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 = HanzoServer(
+        name=name, 
+        allowed_paths=allowed_paths,
+        agent_model=agent_model,
+        agent_max_tokens=agent_max_tokens,
+        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
+    )
+    # 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
+) -> 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,149 @@
+"""MCP server implementing Hanzo 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 HanzoServer:
+    """MCP server implementing Hanzo capabilities."""
+
+    def __init__(
+        self,
+        name: str = "claude-code",
+        allowed_paths: list[str] | None = None,
+        mcp_instance: FastMCP | None = None,
+        agent_model: str | None = None,
+        agent_max_tokens: int | None = None,
+        agent_api_key: str | None = None,
+        agent_max_iterations: int = 10,
+        agent_max_tool_uses: int = 30,
+        enable_agent_tool: bool = False,
+    ):
+        """Initialize the Hanzo 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
+            agent_model: Optional model name for agent tool in LiteLLM format
+            agent_max_tokens: Optional maximum tokens for agent responses
+            agent_api_key: Optional API key for the LLM provider
+            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)
+        """
+        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)
+
+        # Store agent options
+        self.agent_model = agent_model
+        self.agent_max_tokens = agent_max_tokens
+        self.agent_api_key = agent_api_key
+        self.agent_max_iterations = agent_max_iterations
+        self.agent_max_tool_uses = agent_max_tool_uses
+        self.enable_agent_tool = enable_agent_tool
+        
+        # Register all tools
+        register_all_tools(
+            mcp_server=self.mcp,
+            document_context=self.document_context,
+            permission_manager=self.permission_manager,
+            agent_model=self.agent_model,
+            agent_max_tokens=self.agent_max_tokens,
+            agent_api_key=self.agent_api_key,
+            agent_max_iterations=self.agent_max_iterations,
+            agent_max_tool_uses=self.agent_max_tool_uses,
+            enable_agent_tool=self.enable_agent_tool,
+        )
+
+    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 implementing Hanzo capabilities"
+    )
+
+    _ = parser.add_argument(
+        "--name",
+        default="claude-code",
+        help="Name of the MCP server (default: claude-code)",
+    )
+
+    _ = 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 = HanzoServer(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,81 @@
+"""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. It also includes an "agent" tool that enables Claude
+to delegate tasks to sub-agents for concurrent execution and specialized processing.
+"""
+
+from mcp.server.fastmcp import FastMCP
+
+from hanzo_mcp.tools.agent import register_agent_tools
+from hanzo_mcp.tools.common import register_thinking_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
+from hanzo_mcp.tools.jupyter import register_jupyter_tools
+from hanzo_mcp.tools.project import register_project_tools
+from hanzo_mcp.tools.shell import register_shell_tools
+from hanzo_mcp.tools.shell.command_executor import CommandExecutor
+
+
+def register_all_tools(
+    mcp_server: FastMCP,
+    document_context: DocumentContext,
+    permission_manager: PermissionManager,
+    agent_model: str | None = None,
+    agent_max_tokens: int | None = None,
+    agent_api_key: str | None = None,
+    agent_max_iterations: int = 10,
+    agent_max_tool_uses: int = 30,
+    enable_agent_tool: bool = False,
+) -> None:
+    """Register all Hanzo 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
+        agent_model: Optional model name for agent tool in LiteLLM format
+        agent_max_tokens: Optional maximum tokens for agent responses
+        agent_api_key: Optional API key for the LLM provider
+        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)
+    """
+    # Register all filesystem tools
+    register_filesystem_tools(mcp_server, document_context, permission_manager)
+
+    # Register all jupyter tools
+    register_jupyter_tools(mcp_server, document_context, permission_manager)
+
+    # Register shell tools
+    register_shell_tools(mcp_server, permission_manager)
+
+    # Register project analysis tools
+    register_project_tools(
+        mcp_server, 
+        permission_manager, 
+        document_context, 
+        CommandExecutor(permission_manager)
+    )
+
+    # Register agent tools only if enabled
+    if enable_agent_tool:
+        register_agent_tools(
+            mcp_server, 
+            document_context, 
+            permission_manager,
+            CommandExecutor(permission_manager),
+            agent_model=agent_model,
+            agent_max_tokens=agent_max_tokens,
+            agent_api_key=agent_api_key,
+            agent_max_iterations=agent_max_iterations,
+            agent_max_tool_uses=agent_max_tool_uses
+        )
+    
+    # Initialize and register thinking tool
+    register_thinking_tool(mcp_server)

hanzo_mcp/tools/agent/__init__.py

@@ -0,0 +1,59 @@
+"""Agent tools for Hanzo MCP.
+
+This module provides tools that allow Claude to delegate tasks to sub-agents,
+enabling concurrent execution of multiple operations and specialized processing.
+"""
+
+from mcp.server.fastmcp import FastMCP
+
+from hanzo_mcp.tools.agent.agent_tool import AgentTool
+from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry 
+from hanzo_mcp.tools.common.context import DocumentContext
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.shell.command_executor import CommandExecutor
+
+
+def register_agent_tools(
+    mcp_server: FastMCP,
+    document_context: DocumentContext,
+    permission_manager: PermissionManager,
+    command_executor: CommandExecutor,
+    agent_model: str | None = None,
+    agent_max_tokens: int | None = None,
+    agent_api_key: str | None = None,
+    agent_max_iterations: int = 10,
+    agent_max_tool_uses: int = 30,
+) -> list[BaseTool]:
+    """Register agent 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: Command executor for running shell commands
+        agent_model: Optional model name for agent tool in LiteLLM format
+        agent_max_tokens: Optional maximum tokens for agent responses
+        agent_api_key: Optional API key for the LLM provider
+        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)
+
+    Returns:
+        List of registered tools
+    """
+    # Create agent tool
+    agent_tool = AgentTool(
+        document_context=document_context, 
+        permission_manager=permission_manager,
+        command_executor=command_executor,
+        model=agent_model,
+        api_key=agent_api_key,
+        max_tokens=agent_max_tokens,
+        max_iterations=agent_max_iterations,
+        max_tool_uses=agent_max_tool_uses
+    )
+
+    # Register agent tool
+    ToolRegistry.register_tool(mcp_server, agent_tool)
+
+    # Return list of registered tools
+    return [agent_tool]