hanzo-mcp 0.8.11__py3-none-any.whl → 0.9.0__py3-none-any.whl

hanzo_mcp/prompts/__init__.py

@@ -52,9 +52,7 @@ def create_project_system_prompt(project_path: str):
         platform, _, os_version = get_os_info()
 
         # Get directory structure
-        directory_structure = get_directory_structure(
-            working_directory, max_depth=3, include_filtered=False
-        )
+        directory_structure = get_directory_structure(working_directory, max_depth=3, include_filtered=False)
 
         # Get git information
         git_info = get_git_info(working_directory)
@@ -78,9 +76,7 @@ def create_project_system_prompt(project_path: str):
     return project_system_prompt
 
 
-def register_all_prompts(
-    mcp_server: FastMCP, projects: list[str] | None = None
-) -> None:
+def register_all_prompts(mcp_server: FastMCP, projects: list[str] | None = None) -> None:
     @mcp_server.prompt(name="Compact current conversation")
     def compact() -> str:
         """

hanzo_mcp/prompts/project_todo_reminder.py

@@ -49,13 +49,9 @@ def format_todo_list_concise(todos: list[dict[str, Any]]) -> str:
         }.get(status, "[?]")
 
         # Create priority indicator
-        priority_indicator = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(
-            priority, "⚪"
-        )
+        priority_indicator = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(priority, "⚪")
 
-        formatted_lines.append(
-            f"{status_indicator} {priority_indicator} {content} (id: {todo_id})"
-        )
+        formatted_lines.append(f"{status_indicator} {priority_indicator} {content} (id: {todo_id})")
 
     return "\n".join(formatted_lines)
 
@@ -105,6 +101,4 @@ def get_project_todo_reminder(session_id: str | None = None) -> str:
 
     # Format the todo list and return the reminder with content
     formatted_todos = format_todo_list_concise(todos)
-    return PROJECT_TODO_REMINDER.format(
-        session_id=session_id, todo_list=formatted_todos
-    )
+    return PROJECT_TODO_REMINDER.format(session_id=session_id, todo_list=formatted_todos)

hanzo_mcp/prompts/tool_explorer.py

@@ -596,9 +596,7 @@ def create_tool_category_prompt(category: str, tools: list[str]):
         "batch": BATCH_TOOL_EXAMPLES,
     }
 
-    base_prompt = tool_descriptions.get(
-        category, f"# {category.title()} Tools\n\nAvailable tools in this category:\n"
-    )
+    base_prompt = tool_descriptions.get(category, f"# {category.title()} Tools\n\nAvailable tools in this category:\n")
 
     if category not in tool_descriptions:
         base_prompt += "\n".join(f"- **{tool}**: [Tool description]" for tool in tools)

hanzo_mcp/prompts/utils.py

@@ -51,9 +51,7 @@ def get_os_info() -> tuple[str, str, str]:
     return system, release, version
 
 
-def get_directory_structure(
-    path: str, max_depth: int = 3, include_filtered: bool = False
-) -> str:
+def get_directory_structure(path: str, max_depth: int = 3, include_filtered: bool = False) -> str:
     """Get a directory structure similar to directory_tree tool.
 
     Args:
@@ -102,9 +100,7 @@ def get_directory_structure(
 
             try:
                 # Sort entries: directories first, then files alphabetically
-                entries = sorted(
-                    current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name)
-                )
+                entries = sorted(current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name))
 
                 for entry in entries:
                     if entry.is_dir():
@@ -147,9 +143,7 @@ def get_directory_structure(
                 # Format based on type
                 if item["type"] == "directory":
                     if "skipped" in item:
-                        lines.append(
-                            f"{indent}{item['name']}/ [skipped - {item['skipped']}]"
-                        )
+                        lines.append(f"{indent}{item['name']}/ [skipped - {item['skipped']}]")
                     else:
                         lines.append(f"{indent}{item['name']}/")
                         # Add children with increased indentation if present
@@ -228,9 +222,7 @@ def get_git_info(path: str) -> dict[str, str | None]:
                     change_type = item.change_type
                     status_lines.append(f"{change_type[0].upper()} {item.a_path}")
                 if len(staged_files) > 25:
-                    status_lines.append(
-                        f"... and {len(staged_files) - 25} more staged files"
-                    )
+                    status_lines.append(f"... and {len(staged_files) - 25} more staged files")
 
             # Check for unstaged changes
             unstaged_files = list(repo.index.diff(None))
@@ -238,9 +230,7 @@ def get_git_info(path: str) -> dict[str, str | None]:
                 for item in unstaged_files[:25]:  # Limit to first 25
                     status_lines.append(f"M {item.a_path}")
                 if len(unstaged_files) > 25:
-                    status_lines.append(
-                        f"... and {len(unstaged_files) - 25} more modified files"
-                    )
+                    status_lines.append(f"... and {len(unstaged_files) - 25} more modified files")
 
             # Check for untracked files
             untracked_files = repo.untracked_files
@@ -248,13 +238,9 @@ def get_git_info(path: str) -> dict[str, str | None]:
                 for file in untracked_files[:25]:  # Limit to first 25
                     status_lines.append(f"?? {file}")
                 if len(untracked_files) > 25:
-                    status_lines.append(
-                        f"... and {len(untracked_files) - 25} more untracked files"
-                    )
+                    status_lines.append(f"... and {len(untracked_files) - 25} more untracked files")
 
-            git_status = (
-                "\n".join(status_lines) if status_lines else "Working tree clean"
-            )
+            git_status = "\n".join(status_lines) if status_lines else "Working tree clean"
 
         except Exception:
             git_status = "Unable to get git status"

hanzo_mcp/server.py

@@ -9,9 +9,7 @@ import threading
 from typing import Literal, cast, final
 
 # Suppress litellm deprecation warnings about event loop
-warnings.filterwarnings(
-    "ignore", message="There is no current event loop", category=DeprecationWarning
-)
+warnings.filterwarnings("ignore", message="There is no current event loop", category=DeprecationWarning)
 
 try:
     from fastmcp import FastMCP
@@ -176,9 +174,7 @@ class HanzoMCPServer:
         signal.signal(signal.SIGINT, signal_handler)
 
         # Start background cleanup thread for periodic cleanup
-        self._cleanup_thread = threading.Thread(
-            target=self._background_cleanup, daemon=True
-        )
+        self._cleanup_thread = threading.Thread(target=self._background_cleanup, daemon=True)
         self._cleanup_thread.start()
 
         self._cleanup_registered = True

hanzo_mcp/tools/__init__.py

@@ -35,6 +35,7 @@ try:  # pragma: no cover
     from hanzo_mcp.tools.todo import register_todo_tools
     from hanzo_mcp.tools.agent import register_agent_tools
     from hanzo_mcp.tools.shell import register_shell_tools
+    from hanzo_mcp.tools.common import register_batch_tool, register_critic_tool, register_thinking_tool
     from hanzo_mcp.tools.editor import (
         NeovimEditTool,
         NeovimCommandTool,
@@ -48,7 +49,6 @@ try:  # pragma: no cover
     from hanzo_mcp.tools.common.mode import activate_mode_from_env
     from hanzo_mcp.tools.common.stats import StatsTool
     from hanzo_mcp.tools.common.tool_list import ToolListTool
-    from hanzo_mcp.tools.common import register_thinking_tool, register_critic_tool, register_batch_tool
     from hanzo_mcp.tools.config.mode_tool import mode_tool
     from hanzo_mcp.tools.common.mode_loader import ModeLoader
     from hanzo_mcp.tools.common.permissions import PermissionManager
@@ -68,14 +68,17 @@ except Exception:
     # Define stub functions for required imports
     def activate_mode_from_env():
         pass
+
     class ModeLoader:
         @staticmethod
         def get_enabled_tools_from_mode(base_enabled_tools=None, force_mode=None):
             return base_enabled_tools or {}
+
         @staticmethod
         def apply_environment_from_mode():
             pass
 
+
 # Try to import LSP tool
 try:
     from hanzo_mcp.tools.lsp import LSPTool, create_lsp_tool
@@ -134,9 +137,7 @@ def register_all_tools(
 
         logger = logging.getLogger(__name__)
         if plugins:
-            logger.info(
-                f"Loaded {len(plugins)} user plugin tools: {', '.join(plugins.keys())}"
-            )
+            logger.info(f"Loaded {len(plugins)} user plugin tools: {', '.join(plugins.keys())}")
     except Exception as e:
         import logging
 
@@ -149,9 +150,7 @@ def register_all_tools(
         # First check for mode activation from environment
         activate_mode_from_env()
 
-        tool_config = ModeLoader.get_enabled_tools_from_mode(
-            base_enabled_tools=enabled_tools, force_mode=force_mode
-        )
+        tool_config = ModeLoader.get_enabled_tools_from_mode(base_enabled_tools=enabled_tools, force_mode=force_mode)
         # Apply mode environment variables
         ModeLoader.apply_environment_from_mode()
     else:
@@ -196,9 +195,7 @@ def register_all_tools(
             search_paths = [str(path) for path in permission_manager.allowed_paths]
             project_manager = ProjectVectorManager(
                 global_db_path=vector_config.get("data_path"),
-                embedding_model=vector_config.get(
-                    "embedding_model", "text-embedding-3-small"
-                ),
+                embedding_model=vector_config.get("embedding_model", "text-embedding-3-small"),
                 dimension=vector_config.get("dimension", 1536),
             )
             # Auto-detect projects from search paths
@@ -225,24 +222,31 @@ def register_all_tools(
     }
 
     if any(jupyter_enabled.values()):
-        jupyter_tools = register_jupyter_tools(
-            mcp_server, permission_manager, enabled_tools=jupyter_enabled
-        )
+        jupyter_tools = register_jupyter_tools(mcp_server, permission_manager, enabled_tools=jupyter_enabled)
         for tool in jupyter_tools:
             all_tools[tool.name] = tool
 
-    # Register shell tools if enabled
-    if is_tool_enabled("run_command", True):
-        shell_tools = register_shell_tools(mcp_server, permission_manager)
+    # Register shell tools with individual configuration
+    shell_enabled = {
+        "run": is_tool_enabled("run", True),
+        "shell": is_tool_enabled("shell", True),
+        "bash": is_tool_enabled("bash", True),
+        "zsh": is_tool_enabled("zsh", True),
+        "npx": is_tool_enabled("npx", True),
+        "uvx": is_tool_enabled("uvx", True),
+        "process": is_tool_enabled("process", True),
+        "open": is_tool_enabled("open", True),
+        # Legacy name support
+        "run_command": is_tool_enabled("run_command", True),
+    }
+    
+    if any(shell_enabled.values()):
+        shell_tools = register_shell_tools(mcp_server, permission_manager, enabled_tools=shell_enabled)
         for tool in shell_tools:
             all_tools[tool.name] = tool
 
     # Register agent tools if enabled
-    agent_enabled = (
-        enable_agent_tool
-        or is_tool_enabled("agent", False)
-        or is_tool_enabled("dispatch_agent", False)
-    )
+    agent_enabled = enable_agent_tool or is_tool_enabled("agent", False) or is_tool_enabled("dispatch_agent", False)
     swarm_enabled = is_tool_enabled("swarm", False)
 
     if agent_enabled or swarm_enabled:
@@ -258,12 +262,7 @@ def register_all_tools(
         )
         # Filter based on what's enabled
         for tool in agent_tools:
-            if (
-                tool.name == "agent"
-                and agent_enabled
-                or tool.name == "swarm"
-                and swarm_enabled
-            ):
+            if tool.name == "agent" and agent_enabled or tool.name == "swarm" and swarm_enabled:
                 all_tools[tool.name] = tool
             elif tool.name in ["claude", "codex", "gemini", "grok", "code_auth"]:
                 # CLI tools and auth are always included when agent tools are enabled

hanzo_mcp/tools/agent/__init__.py

@@ -108,6 +108,7 @@ def register_agent_tools(
                 if memory_backend is not None:
                     p["memory_backend"] = memory_backend
                 return await tool_self.call(ctx, **p)
+
             return tool_self
 
     # Create auth management tool
@@ -127,6 +128,6 @@ def register_agent_tools(
 
     # Register all CLI tools (includes claude, codex, gemini, grok, etc.)
     cli_tools = register_cli_tools(mcp_server, permission_manager)
-    
+
     # Return list of registered tools
     return [agent_tool, network_tool, code_auth_tool] + cli_tools

hanzo_mcp/tools/agent/agent.py

@@ -118,23 +118,17 @@ class AgentParams(TypedDict, total=False):
 class RPCAgent:
     """Long-running RPC agent."""
 
-    def __init__(
-        self, agent_id: str, model: str, system_prompt: str, tools: List[BaseTool]
-    ):
+    def __init__(self, agent_id: str, model: str, system_prompt: str, tools: List[BaseTool]):
         self.agent_id = agent_id
         self.model = model
         self.system_prompt = system_prompt
         self.tools = tools
-        self.messages: List[ChatCompletionMessageParam] = [
-            {"role": "system", "content": system_prompt}
-        ]
+        self.messages: List[ChatCompletionMessageParam] = [{"role": "system", "content": system_prompt}]
         self.created_at = time.time()
         self.last_used = time.time()
         self.call_count = 0
 
-    async def call_method(
-        self, method: str, args: Dict[str, Any], tool_ctx: ToolContext
-    ) -> str:
+    async def call_method(self, method: str, args: Dict[str, Any], tool_ctx: ToolContext) -> str:
         """Call a method on the RPC agent."""
         self.last_used = time.time()
         self.call_count += 1
@@ -189,15 +183,9 @@ class AgentTool(BaseTool):
 
         # Available tools
         self.available_tools: list[BaseTool] = []
-        self.available_tools.extend(
-            get_read_only_filesystem_tools(self.permission_manager)
-        )
-        self.available_tools.extend(
-            get_read_only_jupyter_tools(self.permission_manager)
-        )
-        self.available_tools.append(
-            BatchTool({t.name: t for t in self.available_tools})
-        )
+        self.available_tools.extend(get_read_only_filesystem_tools(self.permission_manager))
+        self.available_tools.extend(get_read_only_jupyter_tools(self.permission_manager))
+        self.available_tools.append(BatchTool({t.name: t for t in self.available_tools}))
 
     @property
     @override
@@ -272,14 +260,10 @@ Modes:
 
         if len(prompt_list) == 1:
             await tool_ctx.info("Launching agent")
-            result = await self._execute_agent(
-                prompt_list[0], params.get("model"), tool_ctx
-            )
+            result = await self._execute_agent(prompt_list[0], params.get("model"), tool_ctx)
         else:
             await tool_ctx.info(f"Launching {len(prompt_list)} agents in parallel")
-            result = await self._execute_multiple_agents(
-                prompt_list, params.get("model"), tool_ctx
-            )
+            result = await self._execute_multiple_agents(prompt_list, params.get("model"), tool_ctx)
 
         execution_time = time.time() - start_time
 
@@ -389,17 +373,13 @@ Use 'agent --action call --agent-id {agent_id} --method <method> --args <args>'
         absolute_path_pattern = r"/(?:[^/\s]+/)*[^/\s]+"
         return bool(re.search(absolute_path_pattern, prompt))
 
-    async def _execute_agent(
-        self, prompt: str, model: Optional[str], tool_ctx: ToolContext
-    ) -> str:
+    async def _execute_agent(self, prompt: str, model: Optional[str], tool_ctx: ToolContext) -> str:
         """Execute a single agent (simplified - would use full logic from agent_tool.py)."""
         # This would integrate the full agent execution logic from agent_tool.py
         # For now, return a placeholder
         return f"Executed agent with prompt: {prompt[:100]}..."
 
-    async def _execute_multiple_agents(
-        self, prompts: List[str], model: Optional[str], tool_ctx: ToolContext
-    ) -> str:
+    async def _execute_multiple_agents(self, prompts: List[str], model: Optional[str], tool_ctx: ToolContext) -> str:
         """Execute multiple agents in parallel."""
         tasks = []
         for prompt in prompts:

hanzo_mcp/tools/agent/agent_tool.py

@@ -103,6 +103,23 @@ from hanzo_mcp.tools.agent.clarification_protocol import (
 
 
 class AgentToolParams(TypedDict, total=False):
+
+    def __init__(self, *args, mode: str = "single", **kwargs):
+        """Initialize agent tool with mode support.
+        
+        Modes:
+        - single: Single agent execution (default)
+        - network: Network of agents (formerly swarm)
+        - dispatch: Dispatch to best agent (legacy compatibility)
+        """
+        super().__init__(*args, **kwargs)
+        self.mode = mode
+        
+        # Handle legacy names
+        if self.name == "dispatch_agent":
+            self.mode = "dispatch"
+        elif self.name in ["network", "swarm"]:
+            self.mode = "network"
     """Parameters for the AgentTool."""
 
     prompts: str | list[str]
@@ -197,9 +214,7 @@ class MCPAgent(Agent):
             adapter = MCPToolAdapter(mcp_tool, ctx)
             self.register_tool(adapter)
 
-    async def run(
-        self, state: MCPAgentState, history: History, network: Network
-    ) -> InferenceResult:
+    async def run(self, state: MCPAgentState, history: History, network: Network) -> InferenceResult:
         """Execute the agent."""
         # Get current prompt
         if state.current_prompt_index >= len(state.prompts):
@@ -324,12 +339,8 @@ Usage notes:
 
         # Set up available tools
         self.available_tools: list[BaseTool] = []
-        self.available_tools.extend(
-            get_read_only_filesystem_tools(self.permission_manager)
-        )
-        self.available_tools.extend(
-            get_read_only_jupyter_tools(self.permission_manager)
-        )
+        self.available_tools.extend(get_read_only_filesystem_tools(self.permission_manager))
+        self.available_tools.extend(get_read_only_jupyter_tools(self.permission_manager))
 
         # Add edit tools
         self.available_tools.append(Edit(self.permission_manager))
@@ -341,9 +352,7 @@ Usage notes:
         self.available_tools.append(ReviewTool())
         self.available_tools.append(IChingTool())
 
-        self.available_tools.append(
-            BatchTool({t.name: t for t in self.available_tools})
-        )
+        self.available_tools.append(BatchTool({t.name: t for t in self.available_tools}))
 
     @override
     async def call(
@@ -399,9 +408,7 @@ Usage notes:
                 times = (concurrency + len(prompt_list) - 1) // len(prompt_list)
                 prompt_list = (prompt_list * times)[:concurrency]
 
-        await tool_ctx.info(
-            f"Launching {len(prompt_list)} agent(s) using hanzo-agents SDK"
-        )
+        await tool_ctx.info(f"Launching {len(prompt_list)} agent(s) using hanzo-agents SDK")
 
         # Determine model and agent type
         model = params.get("model", self.model_override)

hanzo_mcp/tools/agent/claude_desktop_auth.py

@@ -96,9 +96,7 @@ class ClaudeDesktopAuth:
         except Exception:
             return None
 
-    async def login_interactive(
-        self, account: Optional[str] = None, headless: bool = False
-    ) -> Tuple[bool, str]:
+    async def login_interactive(self, account: Optional[str] = None, headless: bool = False) -> Tuple[bool, str]:
         """Login to Claude Desktop interactively.
 
         Args:
@@ -192,9 +190,7 @@ class ClaudeDesktopAuth:
         # For now, return a placeholder
         return False, "Headless login not yet implemented"
 
-    async def _exchange_code_for_session(
-        self, code: str, account: Optional[str]
-    ) -> bool:
+    async def _exchange_code_for_session(self, code: str, account: Optional[str]) -> bool:
         """Exchange auth code for session token."""
         # This would make API calls to exchange the code
         # For now, create a mock session
@@ -357,9 +353,7 @@ class ClaudeDesktopAuth:
         # Generate agent-specific account
         return f"agent_{agent_id}@claude.local"
 
-    async def ensure_agent_auth(
-        self, agent_id: str, force_new: bool = False
-    ) -> Tuple[bool, str]:
+    async def ensure_agent_auth(self, agent_id: str, force_new: bool = False) -> Tuple[bool, str]:
         """Ensure an agent is authenticated with its own account.
 
         Args:

hanzo_mcp/tools/agent/cli_agent_base.py

@@ -97,9 +97,7 @@ class CLIAgentBase(BaseTool):
 
         # Check if installed
         if not self.is_installed():
-            error_msg = (
-                f"{self.provider_name} CLI ({self.command_name}) is not installed. "
-            )
+            error_msg = f"{self.provider_name} CLI ({self.command_name}) is not installed. "
             error_msg += f"Please install it first: https://github.com/anthropics/{self.command_name}"
             await tool_ctx.error(error_msg)
             return f"Error: {error_msg}"
@@ -115,15 +113,11 @@ class CLIAgentBase(BaseTool):
         cli_args = self.get_cli_args(prompt, **kwargs)
 
         # Log command
-        await tool_ctx.info(
-            f"Executing {self.provider_name}: {self.command_name} {' '.join(cli_args[:3])}..."
-        )
+        await tool_ctx.info(f"Executing {self.provider_name}: {self.command_name} {' '.join(cli_args[:3])}...")
 
         try:
             # Create temp file for prompt if needed
-            with tempfile.NamedTemporaryFile(
-                mode="w", suffix=".txt", delete=False
-            ) as f:
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
                 f.write(prompt)
                 prompt_file = f.name
 
@@ -131,12 +125,7 @@ class CLIAgentBase(BaseTool):
             if "--prompt-file" in cli_args:
                 # Replace placeholder with actual file
                 cli_args = [
-                    (
-                        arg.replace("--prompt-file", prompt_file)
-                        if arg == "--prompt-file"
-                        else arg
-                    )
-                    for arg in cli_args
+                    (arg.replace("--prompt-file", prompt_file) if arg == "--prompt-file" else arg) for arg in cli_args
                 ]
 
             # Execute command
@@ -151,13 +140,9 @@ class CLIAgentBase(BaseTool):
 
             # Send prompt via stdin if not using file
             if "--prompt-file" not in cli_args:
-                stdout, stderr = await asyncio.wait_for(
-                    process.communicate(input=prompt.encode()), timeout=timeout
-                )
+                stdout, stderr = await asyncio.wait_for(process.communicate(input=prompt.encode()), timeout=timeout)
             else:
-                stdout, stderr = await asyncio.wait_for(
-                    process.communicate(), timeout=timeout
-                )
+                stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
 
             # Clean up temp file
             try:
@@ -175,9 +160,7 @@ class CLIAgentBase(BaseTool):
             return result
 
         except asyncio.TimeoutError:
-            await tool_ctx.error(
-                f"{self.provider_name} timed out after {timeout} seconds"
-            )
+            await tool_ctx.error(f"{self.provider_name} timed out after {timeout} seconds")
             return f"Error: Command timed out after {timeout} seconds"
         except Exception as e:
             await tool_ctx.error(f"{self.provider_name} error: {str(e)}")