hanzo-mcp 0.1.25__py3-none-any.whl → 0.1.30__py3-none-any.whl

hanzo_mcp/__init__.py

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

hanzo_mcp/cli.py

@@ -7,13 +7,13 @@ import sys
 from pathlib import Path
 from typing import Any, cast
 
-from hanzo_mcp.server import HanzoMCPServer
+from hanzo_mcp.server import HanzoServer
 
 
 def main() -> None:
     """Run the CLI for the Hanzo MCP server."""
     parser = argparse.ArgumentParser(
-        description="MCP server for accessing Hanzo APIs and Platform capabilities"
+        description="MCP server implementing Hanzo capabilities"
     )
 
     _ = parser.add_argument(
@@ -25,20 +25,63 @@ def main() -> None:
 
     _ = parser.add_argument(
         "--name",
-        default="hanzo",
-        help="Name of the MCP server (default: hanzo)",
+        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)",
+        help="Add an allowed path (can be specified multiple times, defaults to user's home directory)",
     )
 
     _ = 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",
@@ -53,6 +96,12 @@ def main() -> None:
     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 []
     )
@@ -61,22 +110,44 @@ def main() -> None:
         install_claude_desktop_config(name, allowed_paths)
         return
 
-    # If no allowed paths are specified, use the current directory
+    # If no allowed paths are specified, use the user's home directory
     if not allowed_paths:
-        allowed_paths = [os.getcwd()]
+        allowed_paths = [str(Path.home())]
 
     # 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:
+        # 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
+    elif allowed_paths:
+        project_dir = allowed_paths[0]
+
     # Run the server
-    server = HanzoMCPServer(name=name, allowed_paths=allowed_paths)
+    server = HanzoServer(
+        name=name, 
+        allowed_paths=allowed_paths,
+        project_dir=project_dir,  # Pass project_dir for initial working directory
+        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 = "hanzo", allowed_paths: list[str] | None = None
+    name: str = "claude-code", allowed_paths: list[str] | None = None
 ) -> None:
     """Install the server configuration in Claude Desktop.
 

hanzo_mcp/server.py

@@ -1,4 +1,4 @@
-"""MCP server for accessing Hanzo APIs and Platform capabilities."""
+"""MCP server implementing Hanzo capabilities."""
 
 from typing import Literal, cast, final
 
@@ -12,21 +12,35 @@ from hanzo_mcp.tools.shell.command_executor import CommandExecutor
 
 
 @final
-class HanzoMCPServer:
-    """MCP server for accessing Hanzo APIs and Platform capabilities."""
+class HanzoServer:
+    """MCP server implementing Hanzo capabilities."""
 
     def __init__(
         self,
-        name: str = "hanzo",
+        name: str = "claude-code",
         allowed_paths: list[str] | None = None,
+        project_dir: 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
+            project_dir: Optional project directory to use as initial working directory
             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)
 
@@ -39,6 +53,11 @@ class HanzoMCPServer:
             permission_manager=self.permission_manager,
             verbose=False,  # Set to True for debugging
         )
+        
+        # If project_dir is specified, set it as initial working directory for all sessions
+        if project_dir:
+            initial_session_id = name  # Use server name as default session ID
+            self.command_executor.set_working_dir(initial_session_id, project_dir)
 
         # Initialize project analyzer
         self.project_analyzer = ProjectAnalyzer(self.command_executor)
@@ -54,13 +73,25 @@ class HanzoMCPServer:
                 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,
-            project_manager=self.project_manager,
-            project_analyzer=self.project_analyzer,
+            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):
@@ -86,13 +117,13 @@ def main():
     import argparse
 
     parser = argparse.ArgumentParser(
-        description="MCP server for accessing Hanzo APIs and Platform capabilities"
+        description="MCP server implementing Hanzo capabilities"
     )
 
     _ = parser.add_argument(
         "--name",
-        default="hanzo",
-        help="Name of the MCP server (default: hanzo)",
+        default="claude-code",
+        help="Name of the MCP server (default: claude-code)",
     )
 
     _ = parser.add_argument(
@@ -117,7 +148,7 @@ def main():
     allowed_paths: list[str] | None = args.allowed_paths
 
     # Create and run the server
-    server = HanzoMCPServer(name=name, allowed_paths=allowed_paths)
+    server = HanzoServer(name=name, allowed_paths=allowed_paths)
     server.run(transport=transport, allowed_paths=allowed_paths or [])
 
 

hanzo_mcp/tools/__init__.py

@@ -5,19 +5,20 @@ 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.
+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 typing import Any
-
 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.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.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
 
 
@@ -25,38 +26,56 @@ def register_all_tools(
     mcp_server: FastMCP,
     document_context: DocumentContext,
     permission_manager: PermissionManager,
-    project_manager: ProjectManager,
-    project_analyzer: Any,
+    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 MCP tools with the MCP server.
+    """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
-        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
+        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)
     """
-    # 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)
+    # 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)
 
-    # Initialize and register Jupyter notebook tools
-    jupyter_tools = JupyterNotebookTools(document_context, permission_manager)
-    jupyter_tools.register_tools(mcp_server)
+    # 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
-    thinking_tool = ThinkingTool()
-    thinking_tool.register_tools(mcp_server)
+    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]