hanzo-mcp 0.8.3__py3-none-any.whl → 0.8.4__py3-none-any.whl

hanzo_mcp/__init__.py

@@ -28,4 +28,4 @@ if os.environ.get("HANZO_MCP_TRANSPORT") == "stdio":
     except ImportError:
         pass
 
-__version__ = "0.7.7"
+__version__ = "0.8.4"

hanzo_mcp/cli.py

@@ -1,4 +1,10 @@
-"""Command-line interface for the Hanzo AI server."""
+"""Command-line interface for the Hanzo AI server.
+
+This module intentionally defers heavy imports (like the server and its
+dependencies) until after we determine the transport and configure logging.
+This prevents any stdout/stderr noise from imports that would corrupt the
+MCP stdio transport used by Claude Desktop and other MCP clients.
+"""
 
 import os
 import sys
@@ -9,52 +15,62 @@ import argparse
 from typing import Any, cast
 from pathlib import Path
 
-from hanzo_mcp.server import HanzoMCPServer
-
 
 def main() -> None:
     """Run the CLI for the Hanzo AI server."""
-
-    # Pre-parse arguments to check transport type early
-    import sys
-
+    # Pre-parse arguments to check transport type early, BEFORE importing server
     early_parser = argparse.ArgumentParser(add_help=False)
     early_parser.add_argument("--transport", choices=["stdio", "sse"], default="stdio")
     early_args, _ = early_parser.parse_known_args()
 
     # Configure logging VERY early based on transport
+    suppress_stdout = False
+    original_stdout = sys.stdout
     if early_args.transport == "stdio":
-        # Set environment variable for server to detect stdio mode
-        import os
-
+        # Set environment variable for server to detect stdio mode as early as possible
         os.environ["HANZO_MCP_TRANSPORT"] = "stdio"
+        # Aggressively quiet common dependency loggers/warnings in stdio mode
+        os.environ.setdefault("PYTHONWARNINGS", "ignore")
+        os.environ.setdefault("LITELLM_LOG", "ERROR")
+        os.environ.setdefault("LITELLM_LOGGING_LEVEL", "ERROR")
+        os.environ.setdefault("FASTMCP_LOG_LEVEL", "ERROR")
 
-        # For stdio transport, disable ALL logging immediately
-        from fastmcp.utilities.logging import configure_logging
+        # Suppress FastMCP logging (if available) and all standard logging
+        try:
+            from fastmcp.utilities.logging import configure_logging  # type: ignore
 
-        # Set to ERROR to suppress INFO/WARNING messages from FastMCP
-        configure_logging(level="ERROR")
+            configure_logging(level="ERROR")
+        except Exception:
+            pass
 
-        # Also configure standard logging to ERROR level
         logging.basicConfig(
             level=logging.ERROR,  # Only show errors
             handlers=[],  # No handlers for stdio to prevent protocol corruption
         )
 
         # Redirect stderr to devnull for stdio transport to prevent any output
-        import sys
-
         sys.stderr = open(os.devnull, "w")
 
-    from hanzo_mcp import __version__
+        # Suppress stdout during potentially noisy imports unless user requested help/version
+        if not any(flag in sys.argv for flag in ("--version", "-h", "--help")):
+            sys.stdout = open(os.devnull, "w")
+            suppress_stdout = True
+
+    # Import the server only AFTER transport/logging have been configured to avoid import-time noise
+    from hanzo_mcp.server import HanzoMCPServer
+
+    # Avoid importing hanzo_mcp package just to get version (it can have side-effects).
+    try:
+        from importlib.metadata import version as _pkg_version  # py3.8+
+        _version = _pkg_version("hanzo-mcp")
+    except Exception:
+        _version = "unknown"
 
     parser = argparse.ArgumentParser(
         description="MCP server implementing Hanzo AI capabilities"
     )
 
-    parser.add_argument(
-        "--version", action="version", version=f"hanzo-mcp {__version__}"
-    )
+    parser.add_argument("--version", action="version", version=f"hanzo-mcp {_version}")
 
     _ = parser.add_argument(
         "--transport",
@@ -199,6 +215,14 @@ def main() -> None:
 
     args = parser.parse_args()
 
+    # Restore stdout after parsing, before any explicit output or server start
+    if suppress_stdout:
+        try:
+            sys.stdout.close()  # Close devnull handle
+        except Exception:
+            pass
+        sys.stdout = original_stdout
+
     # Cast args attributes to appropriate types to avoid 'Any' warnings
     name: str = cast(str, args.name)
     install: bool = cast(bool, args.install)

hanzo_mcp/core/base_agent.py

@@ -10,13 +10,12 @@ import os
 import asyncio
 import logging
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Protocol, TypeVar, Generic, runtime_checkable
-from dataclasses import dataclass, field
-from datetime import datetime
+from typing import Any, Dict, List, Generic, TypeVar, Optional, Protocol, runtime_checkable
 from pathlib import Path
+from datetime import datetime
+from dataclasses import field, dataclass
 
-from .model_registry import registry, ModelConfig
-
+from .model_registry import ModelConfig, registry
 
 logger = logging.getLogger(__name__)
 

hanzo_mcp/core/model_registry.py

@@ -8,9 +8,9 @@ Thread-safe singleton implementation.
 from __future__ import annotations
 
 import threading
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Set, Any
 from enum import Enum
+from typing import Any, Set, Dict, List, Optional
+from dataclasses import field, dataclass
 
 
 class ModelProvider(Enum):

hanzo_mcp/tools/agent/__init__.py

@@ -8,25 +8,25 @@ from mcp.server import FastMCP
 
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 
-# Import the main implementations (using hanzo-agents SDK)
-from hanzo_mcp.tools.agent.agent_tool import AgentTool
-from hanzo_mcp.tools.agent.swarm_tool import SwarmTool
-from hanzo_mcp.tools.agent.network_tool import NetworkTool
-from hanzo_mcp.tools.common.permissions import PermissionManager
 # Import unified CLI tools (single source of truth)
 from hanzo_mcp.tools.agent.cli_tools import (
-    ClaudeCLITool,
-    ClaudeCodeCLITool,  # cc alias
+    GrokCLITool,
+    AiderCLITool,
+    ClineCLITool,
     CodexCLITool,
+    ClaudeCLITool,
     GeminiCLITool,
-    GrokCLITool,
+    HanzoDevCLITool,
     OpenHandsCLITool,
+    ClaudeCodeCLITool,  # cc alias
     OpenHandsShortCLITool,  # oh alias
-    HanzoDevCLITool,
-    ClineCLITool,
-    AiderCLITool,
     register_cli_tools,
 )
+
+# Import the main implementations (using hanzo-agents SDK)
+from hanzo_mcp.tools.agent.agent_tool import AgentTool
+from hanzo_mcp.tools.agent.network_tool import NetworkTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.agent.code_auth_tool import CodeAuthTool
 
 
@@ -67,16 +67,48 @@ def register_agent_tools(
         max_tool_uses=agent_max_tool_uses,
     )
 
-    # Create swarm tool
-    swarm_tool = SwarmTool(
-        permission_manager=permission_manager,
-        model=agent_model,
-        api_key=agent_api_key,
-        base_url=agent_base_url,
-        max_tokens=agent_max_tokens,
-        agent_max_iterations=agent_max_iterations,
-        agent_max_tool_uses=agent_max_tool_uses,
-    )
+    # Register a swarm alias that forwards to AgentTool with default concurrency
+    class SwarmAliasTool(BaseTool):
+        name = "swarm"
+        description = (
+            "Alias for agent with concurrency. swarm == agent:5 by default.\n"
+            "Use 'swarm' for parallel multi-agent runs; 'swarm:N' for N agents."
+        )
+
+        def __init__(self, agent_tool: AgentTool):
+            self._agent = agent_tool
+
+        async def call(self, ctx, **params):  # type: ignore[override]
+            # Default to 5 agents unless explicitly provided
+            params = dict(params)
+            params.setdefault("concurrency", 5)
+            return await self._agent.call(ctx, **params)
+
+        def register(self, mcp_server: FastMCP):  # type: ignore[override]
+            tool_self = self
+
+            @mcp_server.tool(name=self.name, description=self.description)
+            async def swarm(
+                ctx,
+                prompts: str | list[str],  # forwarded
+                concurrency: int | None = None,
+                model: str | None = None,
+                use_memory: bool | None = None,
+                memory_backend: str | None = None,
+            ) -> str:
+                p = {
+                    "prompts": prompts,
+                }
+                if concurrency is not None:
+                    p["concurrency"] = concurrency
+                if model is not None:
+                    p["model"] = model
+                if use_memory is not None:
+                    p["use_memory"] = use_memory
+                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
     code_auth_tool = CodeAuthTool()
@@ -89,7 +121,7 @@ def register_agent_tools(
 
     # Register core agent tools
     ToolRegistry.register_tool(mcp_server, agent_tool)
-    ToolRegistry.register_tool(mcp_server, swarm_tool)
+    ToolRegistry.register_tool(mcp_server, SwarmAliasTool(agent_tool))
     ToolRegistry.register_tool(mcp_server, network_tool)
     ToolRegistry.register_tool(mcp_server, code_auth_tool)
 
@@ -97,9 +129,4 @@ def register_agent_tools(
     cli_tools = register_cli_tools(mcp_server, permission_manager)
     
     # Return list of registered tools
-    return [
-        agent_tool,
-        swarm_tool,
-        network_tool,
-        code_auth_tool,
-    ] + cli_tools
+    return [agent_tool, network_tool, code_auth_tool] + cli_tools

hanzo_mcp/tools/agent/agent_tool.py

@@ -109,6 +109,7 @@ class AgentToolParams(TypedDict, total=False):
     model: Optional[str]
     use_memory: Optional[bool]
     memory_backend: Optional[str]
+    concurrency: Optional[int]
 
 
 class MCPAgentState(State):
@@ -387,7 +388,17 @@ Usage notes:
             await tool_ctx.error("hanzo-agents SDK is required but not available")
             return "Error: hanzo-agents SDK is required for agent tool functionality. Please install it with: pip install hanzo-agents"
 
-        # Use hanzo-agents SDK
+        # Determine concurrency (parallel agents)
+        concurrency = params.get("concurrency")
+        if concurrency is not None and isinstance(concurrency, int) and concurrency > 0:
+            # Expand prompt list to match concurrency
+            if len(prompt_list) == 1:
+                prompt_list = prompt_list * concurrency
+            elif len(prompt_list) < concurrency:
+                # Repeat prompts to reach concurrency
+                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"
         )

hanzo_mcp/tools/agent/cli_tools.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import os
 import asyncio
-from typing import Any, Optional, Dict, List, Unpack, Annotated, TypedDict, override, final
+from typing import Any, Dict, List, Unpack, Optional, Annotated, TypedDict, final, override
 from pathlib import Path
 
 from pydantic import Field
@@ -19,7 +19,6 @@ from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.context import create_tool_context
 from hanzo_mcp.tools.common.permissions import PermissionManager
 
-
 # Parameter types for CLI tools
 Prompt = Annotated[
     str,

hanzo_mcp/tools/agent/network_tool.py

@@ -177,37 +177,17 @@ class NetworkTool(BaseTool):
                             results["error"] = f"Local execution failed: {str(e)}"
                             return json.dumps(results, indent=2)
 
-            # Fallback to agent-based execution
-            # This would use hanzo-agents or the existing swarm implementation
-            if not results["success"] or mode in ["distributed", "hybrid"]:
-                # Import swarm tool as fallback
-                from hanzo_mcp.tools.agent.swarm_tool import SwarmTool
-
-                # Create temporary swarm tool
-                swarm = SwarmTool(
-                    permission_manager=self.permission_manager, model=model_pref
-                )
-
-                # Convert network params to swarm params
-                swarm_params = {
-                    "prompts": [task] if not agents_list else agents_list,
-                    "consensus": routing == "consensus",
-                    "parallel": routing == "parallel",
-                }
-
-                # Execute via swarm
-                swarm_result = await swarm.call(ctx, **swarm_params)
-                swarm_data = json.loads(swarm_result)
-
-                # Merge results
-                if swarm_data.get("success"):
-                    results["agents_used"].extend(
-                        [r["agent"] for r in swarm_data.get("results", [])]
-                    )
-                    results["results"].extend(swarm_data.get("results", []))
+                # Agent-based execution with concurrency
+                if not results["success"] or mode in ["distributed", "hybrid"]:
+                    from hanzo_mcp.tools.agent.agent_tool import AgentTool
+                    agent = AgentTool(permission_manager=self.permission_manager, model=model_pref)
+                    concurrency = max(1, len(agents_list)) if agents_list else 5 if routing == "parallel" else 1
+                    agent_params = {"prompts": task, "concurrency": concurrency}
+                    agent_result = await agent.call(ctx, **agent_params)
+                    # Wrap agent_result as a simple result list
+                    results["agents_used"].append("agent")
+                    results["results"].append({"agent": "agent", "response": agent_result})
                     results["success"] = True
-                else:
-                    results["error"] = swarm_data.get("error", "Unknown error")
 
         except Exception as e:
             results["error"] = str(e)
@@ -260,28 +240,4 @@ class NetworkTool(BaseTool):
         return tool
 
 
-# Alias swarm to use network tool with local-only mode
-@final
-class LocalSwarmTool(NetworkTool):
-    """Local-only version of the network tool (swarm compatibility).
-
-    This provides backward compatibility with the swarm tool
-    while using local compute resources only.
-    """
-
-    name = "swarm"
-    description = "Run agent swarms locally using hanzo-miner compute"
-
-    def __init__(self, permission_manager: PermissionManager, **kwargs):
-        """Initialize as local-only network."""
-        super().__init__(
-            permission_manager=permission_manager, default_mode="local", **kwargs
-        )
-
-    @override
-    async def call(self, ctx: MCPContext, **params: Unpack[NetworkToolParams]) -> str:
-        """Execute with local-only mode."""
-        # Force local mode
-        params["mode"] = "local"
-        params["require_local"] = True
-        return await super().call(ctx, **params)
+# Remove swarm compatibility tool; swarm is an alias of agent with concurrency

hanzo_mcp/tools/agent/unified_cli_tools.py

@@ -7,16 +7,16 @@ following Python best practices and eliminating all duplication.
 from __future__ import annotations
 
 import os
-from typing import Any, Optional, List, Dict
+from typing import Any, Dict, List, Optional
 from pathlib import Path
 
 from mcp.server import FastMCP
 from mcp.server.fastmcp import Context
 
-from ...core.model_registry import registry
-from ...core.base_agent import CLIAgent, AgentConfig
 from ..common.base import BaseTool
+from ...core.base_agent import CLIAgent, AgentConfig
 from ..common.permissions import PermissionManager
+from ...core.model_registry import registry
 
 
 class UnifiedCLITool(BaseTool, CLIAgent):

hanzo_mcp/tools/config/config_tool.py

@@ -9,10 +9,10 @@ from pathlib import Path
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
+from hanzo_mcp.config import load_settings, save_settings
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.config.index_config import IndexScope, IndexConfig
-from hanzo_mcp.config import load_settings, save_settings
 
 # Parameter types
 Action = Annotated[

hanzo_mcp/tools/llm/llm_unified.py

@@ -223,7 +223,7 @@ class UnifiedLLMTool(BaseTool):
             try:
                 with open(self.CONFIG_FILE, "r") as f:
                     return json.load(f)
-            except:
+            except Exception:
                 pass
 
         # Default config
@@ -276,7 +276,7 @@ Available: {', '.join(available) if available else 'None'}"""
                 tool_ctx = create_tool_context(ctx)
                 if tool_ctx:
                     await tool_ctx.set_tool_info(self.name)
-        except:
+        except Exception:
             # Running in test mode without MCP context
             pass
 

hanzo_mcp/tools/shell/__init__.py

@@ -9,6 +9,7 @@ from hanzo_mcp.tools.shell.open import open_tool
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 from hanzo_mcp.tools.shell.npx_tool import npx_tool
 from hanzo_mcp.tools.shell.uvx_tool import uvx_tool
+from hanzo_mcp.tools.shell.zsh_tool import zsh_tool, shell_tool
 
 # Import tools
 from hanzo_mcp.tools.shell.bash_tool import bash_tool
@@ -37,14 +38,19 @@ def get_shell_tools(
     """
     # Set permission manager for tools that need it
     bash_tool.permission_manager = permission_manager
+    zsh_tool.permission_manager = permission_manager
+    shell_tool.permission_manager = permission_manager
     npx_tool.permission_manager = permission_manager
     uvx_tool.permission_manager = permission_manager
 
     # Note: StreamingCommandTool is abstract and shouldn't be instantiated directly
     # It's used as a base class for other streaming tools
 
+    # Return shell_tool first (smart default), then specific shells
     return [
-        bash_tool,
+        shell_tool,  # Smart shell (prefers zsh if available)
+        zsh_tool,    # Explicit zsh
+        bash_tool,   # Explicit bash
         npx_tool,
         uvx_tool,
         process_tool,

hanzo_mcp/tools/shell/bash_tool.py

@@ -59,29 +59,20 @@ bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
 
     @override
     def get_interpreter(self) -> str:
-        """Get the shell interpreter."""
+        """Get the bash interpreter."""
         if platform.system() == "Windows":
-            return "cmd.exe"
-
-        # Check for user's preferred shell from environment
-        shell = os.environ.get("SHELL", "/bin/bash")
-
-        # Extract just the shell name from the path
-        shell_name = os.path.basename(shell)
-
-        # Check if it's a supported shell and the config file exists
-        if shell_name == "zsh":
-            # Check for .zshrc
-            zshrc_path = Path.home() / ".zshrc"
-            if zshrc_path.exists():
-                return shell  # Use full path to zsh
-        elif shell_name == "fish":
-            # Check for fish config
-            fish_config = Path.home() / ".config" / "fish" / "config.fish"
-            if fish_config.exists():
-                return shell  # Use full path to fish
-
-        # Default to bash if no special shell config found
+            # Try to find bash on Windows (Git Bash, WSL, etc.)
+            bash_paths = [
+                "C:\\Program Files\\Git\\bin\\bash.exe",
+                "C:\\cygwin64\\bin\\bash.exe",
+                "C:\\msys64\\usr\\bin\\bash.exe",
+            ]
+            for path in bash_paths:
+                if Path(path).exists():
+                    return path
+            return "cmd.exe"  # Fall back to cmd if no bash found
+        
+        # On Unix-like systems, always use bash
         return "bash"
 
     @override
@@ -94,12 +85,7 @@ bash "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
     @override
     def get_tool_name(self) -> str:
         """Get the tool name."""
-        if platform.system() == "Windows":
-            return "shell"
-
-        # Return the actual shell being used
-        interpreter = self.get_interpreter()
-        return os.path.basename(interpreter)
+        return "bash"
 
     @override
     async def run(