hanzo-mcp 0.7.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/prompts/example_custom_prompt.py

@@ -14,19 +14,20 @@ Focus on:
 
 Be constructive and specific in your feedback."""
 
+
 # You can also create dynamic prompts that take parameters
 def create_custom_analysis_prompt(file_path: str, analysis_type: str = "general"):
     """Create a dynamic analysis prompt for a specific file."""
-    
+
     analysis_types = {
         "general": "Provide a general analysis including structure, purpose, and quality",
         "security": "Focus on security vulnerabilities and best practices",
         "performance": "Analyze performance bottlenecks and optimization opportunities",
-        "refactor": "Suggest refactoring opportunities to improve code maintainability"
+        "refactor": "Suggest refactoring opportunities to improve code maintainability",
     }
-    
+
     analysis_instruction = analysis_types.get(analysis_type, analysis_types["general"])
-    
+
     return f"""Please analyze the file at {file_path}.
 
 {analysis_instruction}
@@ -37,4 +38,4 @@ Your analysis should include:
 3. Specific recommendations with code examples where applicable
 4. Priority ranking of any issues found
 
-Be thorough but concise in your analysis."""
+Be thorough but concise in your analysis."""

hanzo_mcp/prompts/project_todo_reminder.py

@@ -3,7 +3,6 @@ from typing import Any
 # Import TodoStorage to access todo data
 from hanzo_mcp.tools.todo.base import TodoStorage
 
-
 PROJECT_TODO_EMPTY_REMINDER = """<system-reminder>This is a reminder that your todo list is currently empty. DO NOT mention this to me explicitly because i have already aware. If you are working on tasks that would benefit from a todo list please use the todo_write tool to create one. If not, please feel free to ignore.</system-reminder>"""
 
 

hanzo_mcp/prompts/tool_explorer.py

@@ -585,19 +585,22 @@ Tools NOT available in batch (require state/session):
 - think
 - todo_write"""
 
+
 def create_tool_category_prompt(category: str, tools: list[str]):
     """Create a dynamic prompt for a specific tool category."""
-    
+
     tool_descriptions = {
         "filesystem": FILESYSTEM_TOOLS_HELP,
         "agent": AGENT_TOOLS_HELP,
         "shell": SHELL_TOOLS_HELP,
-        "batch": BATCH_TOOL_EXAMPLES
+        "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)
-    
-    return base_prompt
+
+    return base_prompt

hanzo_mcp/server.py

@@ -1,14 +1,14 @@
 """MCP server implementing Hanzo capabilities."""
 
 import atexit
-import logging
 import signal
+import logging
 import threading
-import time
 import warnings
 from typing import Literal, cast, final
 
-# No need for warning suppression here as it's handled in the imports
+# Suppress litellm deprecation warnings about event loop
+warnings.filterwarnings("ignore", message="There is no current event loop", category=DeprecationWarning)
 
 try:
     from fastmcp import FastMCP
@@ -17,11 +17,9 @@ except ImportError:
     from mcp.server import FastMCP
 
 # Import our enhanced server
-from hanzo_mcp.server_enhanced import EnhancedFastMCP
-
-from hanzo_mcp.prompts import register_all_prompts
 from hanzo_mcp.tools import register_all_tools
-
+from hanzo_mcp.prompts import register_all_prompts
+from hanzo_mcp.server_enhanced import EnhancedFastMCP
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.shell.session_storage import SessionStorage
 
@@ -126,7 +124,7 @@ class HanzoMCPServer:
         final_enabled_tools = self.enabled_tools.copy()
         for tool_name in self.disabled_tools:
             final_enabled_tools[tool_name] = False
-        
+
         # Store the final processed tool configuration
         self.enabled_tools = final_enabled_tools
 
@@ -159,8 +157,9 @@ class HanzoMCPServer:
         # Register signal handlers for graceful shutdown
         def signal_handler(signum, frame):
             import sys
+
             # Only log if not stdio transport
-            if hasattr(self, '_transport') and self._transport != 'stdio':
+            if hasattr(self, "_transport") and self._transport != "stdio":
                 logger = logging.getLogger(__name__)
                 logger.info("\nShutting down gracefully...")
             self._cleanup_sessions()
@@ -198,7 +197,7 @@ class HanzoMCPServer:
             cleared_count = SessionStorage.clear_all_sessions()
             if cleared_count > 0:
                 # Only log if not stdio transport
-                if hasattr(self, '_transport') and self._transport != 'stdio':
+                if hasattr(self, "_transport") and self._transport != "stdio":
                     logger = logging.getLogger(__name__)
                     logger.info(f"Cleaned up {cleared_count} tmux sessions on shutdown")
         except Exception:
@@ -214,7 +213,7 @@ class HanzoMCPServer:
         """
         # Store transport for later use
         self._transport = transport
-        
+
         # Add allowed paths if provided
         allowed_paths_list = allowed_paths or []
         for path in allowed_paths_list:
@@ -232,30 +231,27 @@ def create_server(
     name: str = "hanzo-mcp",
     allowed_paths: list[str] | None = None,
     enable_all_tools: bool = False,
-    **kwargs
+    **kwargs,
 ) -> HanzoMCPServer:
     """Create a Hanzo MCP server instance.
-    
+
     Args:
         name: Server name
         allowed_paths: List of allowed file paths
         enable_all_tools: Enable all tools including agent tools
         **kwargs: Additional server configuration
-        
+
     Returns:
         HanzoMCPServer instance
     """
     if enable_all_tools:
-        kwargs['enable_agent_tool'] = True
-        
-    return HanzoMCPServer(
-        name=name,
-        allowed_paths=allowed_paths,
-        **kwargs
-    )
+        kwargs["enable_agent_tool"] = True
+
+    return HanzoMCPServer(name=name, allowed_paths=allowed_paths, **kwargs)
 
 
 def main():
     """Main entry point for the server."""
     from hanzo_mcp.cli import main as cli_main
+
     cli_main()

hanzo_mcp/server_enhanced.py

@@ -4,8 +4,7 @@ This module provides an enhanced FastMCP server that automatically
 applies context normalization to all registered tools.
 """
 
-from typing import Any, Callable
-from functools import wraps
+from typing import Callable
 
 from mcp.server import FastMCP
 
@@ -14,56 +13,50 @@ from hanzo_mcp.tools.common.decorators import with_context_normalization
 
 class EnhancedFastMCP(FastMCP):
     """Enhanced FastMCP server with automatic context normalization.
-    
+
     This server automatically wraps all tool registrations with context
     normalization, ensuring that tools work properly when called externally
     with serialized context parameters.
     """
-    
-    def tool(
-        self,
-        name: str | None = None,
-        description: str | None = None
-    ) -> Callable:
+
+    def tool(self, name: str | None = None, description: str | None = None) -> Callable:
         """Enhanced tool decorator that includes automatic context normalization.
-        
+
         Args:
             name: Tool name (defaults to function name)
             description: Tool description
-            
+
         Returns:
             Decorator function that registers the tool with context normalization
         """
         # Get the original decorator from parent class
-        original_decorator = super().tool(
-            name=name,
-            description=description
-        )
-        
+        original_decorator = super().tool(name=name, description=description)
+
         # Create our enhanced decorator
         def enhanced_decorator(func: Callable) -> Callable:
             # Apply context normalization first
             # Check if function has ctx parameter
             import inspect
+
             sig = inspect.signature(func)
-            if 'ctx' in sig.parameters:
+            if "ctx" in sig.parameters:
                 normalized_func = with_context_normalization(func)
             else:
                 normalized_func = func
-            
+
             # Then apply the original decorator
             return original_decorator(normalized_func)
-        
+
         return enhanced_decorator
 
 
 def create_enhanced_server(name: str = "hanzo") -> EnhancedFastMCP:
     """Create an enhanced MCP server with automatic context normalization.
-    
+
     Args:
         name: Server name
-        
+
     Returns:
         Enhanced FastMCP server instance
     """
-    return EnhancedFastMCP(name)
+    return EnhancedFastMCP(name)

hanzo_mcp/tools/__init__.py

@@ -11,39 +11,50 @@ to delegate tasks to sub-agents for concurrent execution and specialized process
 
 from mcp.server import FastMCP
 
+from hanzo_mcp.tools.todo import register_todo_tools
 from hanzo_mcp.tools.agent import register_agent_tools
-from hanzo_mcp.tools.common import register_batch_tool, register_thinking_tool, register_critic_tool
+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.vector import register_vector_tools
+from hanzo_mcp.tools.jupyter import register_jupyter_tools
+from hanzo_mcp.tools.database import DatabaseManager, register_database_tools
+from hanzo_mcp.tools.filesystem import register_filesystem_tools
 from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.stats import StatsTool
+from hanzo_mcp.tools.common.tool_list import ToolListTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
 from hanzo_mcp.tools.common.tool_disable import ToolDisableTool
-from hanzo_mcp.tools.common.tool_list import ToolListTool
-from hanzo_mcp.tools.common.stats import StatsTool
-from hanzo_mcp.tools.filesystem import register_filesystem_tools
-from hanzo_mcp.tools.jupyter import register_jupyter_tools
-from hanzo_mcp.tools.shell import register_shell_tools
-from hanzo_mcp.tools.todo import register_todo_tools
-from hanzo_mcp.tools.vector import register_vector_tools
-from hanzo_mcp.tools.database import register_database_tools, DatabaseManager
 
 # Try to import memory tools, but don't fail if hanzo-memory is not installed
 try:
     from hanzo_mcp.tools.memory import register_memory_tools
+
     MEMORY_TOOLS_AVAILABLE = True
 except ImportError:
     MEMORY_TOOLS_AVAILABLE = False
     register_memory_tools = None
-from hanzo_mcp.tools.mcp import MCPTool, McpAddTool, McpRemoveTool, McpStatsTool
+from hanzo_mcp.tools.llm import (
+    LLMTool,
+    ConsensusTool,
+    LLMManageTool,
+    create_provider_tools,
+)
+from hanzo_mcp.tools.mcp import MCPTool, McpAddTool, McpStatsTool, McpRemoveTool
 from hanzo_mcp.tools.editor import NeovimEditTool, NeovimCommandTool, NeovimSessionTool
-from hanzo_mcp.tools.llm import LLMTool, LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
+from hanzo_mcp.tools.common.mode import activate_mode_from_env
 from hanzo_mcp.tools.config.mode_tool import mode_tool
 from hanzo_mcp.tools.common.mode_loader import ModeLoader
-from hanzo_mcp.tools.common.mode import activate_mode_from_env
 from hanzo_mcp.tools.common.plugin_loader import load_user_plugins
 
 # Try to import LSP tool
 try:
     from hanzo_mcp.tools.lsp import LSPTool, create_lsp_tool
+
     LSP_TOOL_AVAILABLE = True
 except ImportError:
     LSP_TOOL_AVAILABLE = False
@@ -84,7 +95,7 @@ def register_all_tools(
         vector_config: Vector store configuration (default: None)
         use_mode: Whether to use mode system for tool configuration (default: True)
         force_mode: Force a specific mode to be active (default: None)
-    
+
     Returns:
         List of registered BaseTool instances
     """
@@ -95,11 +106,15 @@ def register_all_tools(
     try:
         plugins = load_user_plugins()
         import logging
+
         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
+
         logger = logging.getLogger(__name__)
         logger.warning(f"Failed to load user plugins: {e}")
         plugins = {}
@@ -110,8 +125,7 @@ def register_all_tools(
         activate_mode_from_env()
 
         tool_config = ModeLoader.get_enabled_tools_from_mode(
-            base_enabled_tools=enabled_tools,
-            force_mode=force_mode
+            base_enabled_tools=enabled_tools, force_mode=force_mode
         )
         # Apply mode environment variables
         ModeLoader.apply_environment_from_mode()
@@ -146,18 +160,26 @@ def register_all_tools(
     }
 
     # Create project manager if vector tools, batch_search, or unified_search are enabled
-    if any(vector_enabled.values()) or filesystem_enabled.get("batch_search", False) or filesystem_enabled.get("search", False):
+    if (
+        any(vector_enabled.values())
+        or filesystem_enabled.get("batch_search", False)
+        or filesystem_enabled.get("search", False)
+    ):
         if vector_config:
             from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
+
             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
             detected_projects = project_manager.detect_projects(search_paths)
             import logging
+
             logger = logging.getLogger(__name__)
             logger.info(f"Detected {len(detected_projects)} projects with LLM.md files")
 
@@ -178,7 +200,9 @@ 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
 
@@ -189,7 +213,11 @@ def register_all_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:
@@ -205,9 +233,12 @@ def register_all_tools(
         )
         # Filter based on what's enabled
         for tool in agent_tools:
-            if tool.name == "agent" and agent_enabled:
-                all_tools[tool.name] = tool
-            elif 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
@@ -415,10 +446,7 @@ def register_all_tools(
     if any(memory_enabled.values()) and MEMORY_TOOLS_AVAILABLE:
         try:
             memory_tools = register_memory_tools(
-                mcp_server,
-                permission_manager,
-                user_id="default",
-                project_id="default"
+                mcp_server, permission_manager, user_id="default", project_id="default"
             )
             # Filter based on enabled state
             for tool in memory_tools:
@@ -446,6 +474,6 @@ def register_all_tools(
                 logger.info(f"Registered plugin tool: {plugin_name}")
             except Exception as e:
                 logger.error(f"Failed to register plugin tool {plugin_name}: {e}")
-    
+
     # Return all registered tools
     return list(all_tools.values())

hanzo_mcp/tools/agent/__init__.py

@@ -4,22 +4,20 @@ This module provides tools that allow Claude to delegate tasks to sub-agents,
 enabling concurrent execution of multiple operations and specialized processing.
 """
 
-import os
 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.claude_cli_tool import ClaudeCLITool
-from hanzo_mcp.tools.agent.codex_cli_tool import CodexCLITool
-from hanzo_mcp.tools.agent.gemini_cli_tool import GeminiCLITool
+from hanzo_mcp.tools.agent.network_tool import NetworkTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.agent.grok_cli_tool import GrokCLITool
 from hanzo_mcp.tools.agent.code_auth_tool import CodeAuthTool
-from hanzo_mcp.tools.agent.network_tool import NetworkTool, LocalSwarmTool
-from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
-
-from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.agent.codex_cli_tool import CodexCLITool
+from hanzo_mcp.tools.agent.claude_cli_tool import ClaudeCLITool
+from hanzo_mcp.tools.agent.gemini_cli_tool import GeminiCLITool
 
 
 def register_agent_tools(
@@ -58,7 +56,7 @@ def register_agent_tools(
         max_iterations=agent_max_iterations,
         max_tool_uses=agent_max_tool_uses,
     )
-    
+
     # Create swarm tool
     swarm_tool = SwarmTool(
         permission_manager=permission_manager,
@@ -69,36 +67,35 @@ def register_agent_tools(
         agent_max_iterations=agent_max_iterations,
         agent_max_tool_uses=agent_max_tool_uses,
     )
-    
-    
+
     # Create CLI agent tools
     claude_cli_tool = ClaudeCLITool(
         permission_manager=permission_manager,
         model=agent_model,  # Can override default Sonnet
     )
-    
+
     codex_cli_tool = CodexCLITool(
         permission_manager=permission_manager,
         model=agent_model if agent_model and "gpt" in agent_model else None,
     )
-    
+
     gemini_cli_tool = GeminiCLITool(
         permission_manager=permission_manager,
         model=agent_model if agent_model and "gemini" in agent_model else None,
     )
-    
+
     grok_cli_tool = GrokCLITool(
         permission_manager=permission_manager,
         model=agent_model if agent_model and "grok" in agent_model else None,
     )
-    
+
     # Create auth management tool
     code_auth_tool = CodeAuthTool()
-    
+
     # Create network tool
     network_tool = NetworkTool(
         permission_manager=permission_manager,
-        default_mode="hybrid"  # Prefer local, fallback to cloud
+        default_mode="hybrid",  # Prefer local, fallback to cloud
     )
 
     # Register tools
@@ -113,7 +110,7 @@ def register_agent_tools(
 
     # Return list of registered tools
     return [
-        agent_tool, 
+        agent_tool,
         swarm_tool,
         network_tool,
         claude_cli_tool,