hanzo-mcp 0.6.10__py3-none-any.whl → 0.6.13__py3-none-any.whl

hanzo_mcp/server_enhanced.py

@@ -0,0 +1,69 @@
+"""Enhanced MCP server with automatic context normalization.
+
+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 mcp.server import FastMCP
+
+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:
+        """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
+        )
+        
+        # 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:
+                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)

hanzo_mcp/tools/__init__.py

@@ -1,7 +1,7 @@
-"""Tools package for Hanzo MCP.
+"""Tools package for Hanzo AI.
 
-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 package contains all the tools for the Hanzo AI server.
+It provides a 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
@@ -12,7 +12,7 @@ to delegate tasks to sub-agents for concurrent execution and specialized process
 from mcp.server import FastMCP
 
 from hanzo_mcp.tools.agent import register_agent_tools
-from hanzo_mcp.tools.common import register_batch_tool, register_thinking_tool
+from hanzo_mcp.tools.common import register_batch_tool, register_thinking_tool, register_critic_tool
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
@@ -25,11 +25,13 @@ 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
-from hanzo_mcp.tools.mcp import UnifiedMCPTool, McpAddTool, McpRemoveTool, McpStatsTool
+from hanzo_mcp.tools.mcp import MCPTool, McpAddTool, McpRemoveTool, McpStatsTool
 from hanzo_mcp.tools.editor import NeovimEditTool, NeovimCommandTool, NeovimSessionTool
-from hanzo_mcp.tools.llm import UnifiedLLMTool, LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
-from hanzo_mcp.tools.config.palette_tool import palette_tool
-from hanzo_mcp.tools.common.palette_loader import PaletteLoader
+from hanzo_mcp.tools.llm import LLMTool, LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
+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
 
 
 def register_all_tools(
@@ -46,8 +48,8 @@ def register_all_tools(
     disable_search_tools: bool = False,
     enabled_tools: dict[str, bool] | None = None,
     vector_config: dict | None = None,
-    use_palette: bool = True,
-    force_palette: str | None = None,
+    use_mode: bool = True,
+    force_mode: str | None = None,
 ) -> None:
     """Register all Hanzo tools with the MCP server.
 
@@ -65,20 +67,36 @@ def register_all_tools(
         disable_search_tools: Whether to disable search tools (default: False)
         enabled_tools: Dictionary of individual tool enable/disable states (default: None)
         vector_config: Vector store configuration (default: None)
-        use_palette: Whether to use palette system for tool configuration (default: True)
-        force_palette: Force a specific palette to be active (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)
     """
     # Dictionary to store all registered tools
     all_tools: dict[str, BaseTool] = {}
     
-    # Apply palette configuration if enabled
-    if use_palette:
-        tool_config = PaletteLoader.get_enabled_tools_from_palette(
+    # Load user plugins early
+    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())}")
+    except Exception as e:
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.warning(f"Failed to load user plugins: {e}")
+        plugins = {}
+    
+    # Apply mode configuration if enabled
+    if use_mode:
+        # 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_palette=force_palette
+            force_mode=force_mode
         )
-        # Apply palette environment variables
-        PaletteLoader.apply_palette_environment()
+        # Apply mode environment variables
+        ModeLoader.apply_environment_from_mode()
     else:
         # Use individual tool configuration if provided, otherwise fall back to category-level flags
         tool_config = enabled_tools or {}
@@ -97,15 +115,16 @@ def register_all_tools(
         "multi_edit": is_tool_enabled("multi_edit", not disable_write_tools),
         "directory_tree": is_tool_enabled("directory_tree", True),
         "grep": is_tool_enabled("grep", not disable_search_tools),
-        "grep_ast": is_tool_enabled("grep_ast", not disable_search_tools),
+        "symbols": is_tool_enabled("symbols", not disable_search_tools),
         "git_search": is_tool_enabled("git_search", not disable_search_tools),
         "content_replace": is_tool_enabled("content_replace", not disable_write_tools),
         "batch_search": is_tool_enabled("batch_search", not disable_search_tools),
         "find_files": is_tool_enabled("find_files", True),
-        "unified_search": is_tool_enabled("unified_search", not disable_search_tools),
+        "rules": is_tool_enabled("rules", True),
+        "search": is_tool_enabled("search", not disable_search_tools),
     }
     
-    # Vector tools setup (needed for unified search)
+    # Vector tools setup (needed for search)
     project_manager = None
     vector_enabled = {
         "vector_index": is_tool_enabled("vector_index", False),
@@ -113,7 +132,7 @@ 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("unified_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]
@@ -124,7 +143,9 @@ def register_all_tools(
             )
             # Auto-detect projects from search paths
             detected_projects = project_manager.detect_projects(search_paths)
-            print(f"Detected {len(detected_projects)} projects with LLM.md files")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.info(f"Detected {len(detected_projects)} projects with LLM.md files")
     
     filesystem_tools = register_filesystem_tools(
         mcp_server, 
@@ -153,7 +174,7 @@ def register_all_tools(
             all_tools[tool.name] = tool
 
     # Register agent tools if enabled
-    agent_enabled = enable_agent_tool 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)
     if agent_enabled:
         agent_tools = register_agent_tools(
             mcp_server,
@@ -170,12 +191,15 @@ def register_all_tools(
 
     # Register todo tools if enabled
     todo_enabled = {
+        "todo": is_tool_enabled("todo", True),
+        # Backward compatibility - if old names are used, enable the unified tool
         "todo_read": is_tool_enabled("todo_read", True),
         "todo_write": is_tool_enabled("todo_write", True),
     }
     
+    # Enable unified todo if any of the todo tools are enabled
     if any(todo_enabled.values()):
-        todo_tools = register_todo_tools(mcp_server, enabled_tools=todo_enabled)
+        todo_tools = register_todo_tools(mcp_server, enabled_tools={"todo": True})
         for tool in todo_tools:
             all_tools[tool.name] = tool
 
@@ -184,6 +208,12 @@ def register_all_tools(
         thinking_tool = register_thinking_tool(mcp_server)
         for tool in thinking_tool:
             all_tools[tool.name] = tool
+    
+    # Register critic tool if enabled
+    if is_tool_enabled("critic", True):
+        critic_tools = register_critic_tool(mcp_server)
+        for tool in critic_tools:
+            all_tools[tool.name] = tool
 
     # Register vector tools if enabled (reuse project_manager if available)
     if any(vector_enabled.values()) and project_manager:
@@ -228,7 +258,7 @@ def register_all_tools(
     
     # Register unified MCP tool if enabled
     if is_tool_enabled("mcp", True):
-        tool = UnifiedMCPTool()
+        tool = MCPTool()
         tool.register(mcp_server)
         all_tools[tool.name] = tool
     
@@ -273,9 +303,9 @@ def register_all_tools(
     stats_tool.register(mcp_server)
     all_tools[stats_tool.name] = stats_tool
     
-    # Palette tool (always enabled for managing tool sets)
-    palette_tool.register(mcp_server)
-    all_tools[palette_tool.name] = palette_tool
+    # Mode tool (always enabled for managing tool sets)
+    mode_tool.register(mcp_server)
+    all_tools[mode_tool.name] = mode_tool
     
     # Register editor tools if enabled
     editor_enabled = {
@@ -301,11 +331,18 @@ def register_all_tools(
     
     # Register unified LLM tool if enabled
     if is_tool_enabled("llm", True):
-        tool = UnifiedLLMTool()
+        tool = LLMTool()
         if tool.available_providers:  # Only register if API keys found
             tool.register(mcp_server)
             all_tools[tool.name] = tool
     
+    # Register consensus tool if enabled (enabled by default)
+    if is_tool_enabled("consensus", True):
+        tool = ConsensusTool()
+        if tool.llm_tool.available_providers:
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+
     # Register legacy LLM tools if explicitly enabled (disabled by default)
     legacy_llm_enabled = {
         "llm_legacy": is_tool_enabled("llm_legacy", False),
@@ -337,3 +374,14 @@ def register_all_tools(
             if is_tool_enabled(tool.name, False):
                 tool.register(mcp_server)
                 all_tools[tool.name] = tool
+    
+    # Register user plugins last (so they can override built-in tools)
+    for plugin_name, plugin in plugins.items():
+        if is_tool_enabled(plugin_name, True):
+            try:
+                tool = plugin.tool_class()
+                tool.register(mcp_server)
+                all_tools[tool.name] = tool
+                logger.info(f"Registered plugin tool: {plugin_name}")
+            except Exception as e:
+                logger.error(f"Failed to register plugin tool {plugin_name}: {e}")

hanzo_mcp/tools/agent/__init__.py

@@ -1,4 +1,4 @@
-"""Agent tools for Hanzo MCP.
+"""Agent tools for Hanzo AI.
 
 This module provides tools that allow Claude to delegate tasks to sub-agents,
 enabling concurrent execution of multiple operations and specialized processing.

hanzo_mcp/tools/agent/agent_tool.py

@@ -1,4 +1,4 @@
-"""Agent tool implementation for Hanzo MCP.
+"""Agent tool implementation for Hanzo AI.
 
 This module implements the AgentTool that allows Claude to delegate tasks to sub-agents,
 enabling concurrent execution of multiple operations and specialized processing.
@@ -75,7 +75,7 @@ class AgentTool(BaseTool):
         Returns:
             Tool name
         """
-        return "dispatch_agent"
+        return "agent"
 
     @property
     @override

hanzo_mcp/tools/common/__init__.py

@@ -1,10 +1,11 @@
-"""Common utilities for Hanzo MCP tools."""
+"""Common utilities for Hanzo AI tools."""
 
 from mcp.server import FastMCP
 
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 from hanzo_mcp.tools.common.batch_tool import BatchTool
 from hanzo_mcp.tools.common.thinking_tool import ThinkingTool
+from hanzo_mcp.tools.common.critic_tool import CriticTool
 
 
 def register_thinking_tool(
@@ -20,6 +21,19 @@ def register_thinking_tool(
     return [thinking_tool]
 
 
+def register_critic_tool(
+    mcp_server: FastMCP,
+) -> list[BaseTool]:
+    """Register critic tool with the MCP server.
+
+    Args:
+        mcp_server: The FastMCP server instance
+    """
+    critic_tool = CriticTool()
+    ToolRegistry.register_tool(mcp_server, critic_tool)
+    return [critic_tool]
+
+
 def register_batch_tool(mcp_server: FastMCP, tools: dict[str, BaseTool]) -> None:
     """Register batch tool with the MCP server.
 

hanzo_mcp/tools/common/base.py

@@ -1,7 +1,7 @@
-"""Base classes for Hanzo MCP tools.
+"""Base classes for Hanzo AI tools.
 
 This module provides abstract base classes that define interfaces and common functionality
-for all tools used in Hanzo MCP. These abstractions help ensure consistent tool
+for all tools used in Hanzo AI. These abstractions help ensure consistent tool
 behavior and provide a foundation for tool registration and management.
 """
 
@@ -62,7 +62,7 @@ def handle_connection_errors(
 
 
 class BaseTool(ABC):
-    """Abstract base class for all Hanzo MCP tools.
+    """Abstract base class for all Hanzo AI tools.
 
     This class defines the core interface that all tools must implement, ensuring
     consistency in how tools are registered, documented, and called.
@@ -156,7 +156,7 @@ class FileSystemTool(BaseTool, ABC):
 
 @final
 class ToolRegistry:
-    """Registry for Hanzo MCP tools.
+    """Registry for Hanzo AI tools.
 
     Provides functionality for registering tool implementations with an MCP server,
     handling the conversion between tool classes and MCP tool functions.

hanzo_mcp/tools/common/batch_tool.py

@@ -1,4 +1,4 @@
-"""Batch tool implementation for Hanzo MCP.
+"""Batch tool implementation for Hanzo AI.
 
 This module provides the BatchTool that allows for executing multiple tools in
 parallel or serial depending on their characteristics.

hanzo_mcp/tools/common/config_tool.py

@@ -34,7 +34,7 @@ class ConfigToolParams(TypedDict, total=False):
 
 @final
 class ConfigTool(BaseTool):
-    """Tool for managing Hanzo MCP configuration dynamically."""
+    """Tool for managing Hanzo AI configuration dynamically."""
     
     def __init__(self, permission_manager: PermissionManager):
         """Initialize the configuration tool.
@@ -52,7 +52,7 @@ class ConfigTool(BaseTool):
     @property
     def description(self) -> str:
         """Get the tool description."""
-        return """Dynamically manage Hanzo MCP configuration settings through conversation.
+        return """Dynamically manage Hanzo AI configuration settings through conversation.
 
 Can get/set global settings, project-specific settings, manage MCP servers, configure tools,
 and handle project workflows. Supports dot-notation for nested settings like 'agent.enabled'.

hanzo_mcp/tools/common/context.py

@@ -1,4 +1,4 @@
-"""Enhanced Context for Hanzo MCP tools.
+"""Enhanced Context for Hanzo AI tools.
 
 This module provides an enhanced Context class that wraps the MCP Context
 and adds additional functionality specific to Hanzo tools.
@@ -17,7 +17,7 @@ from mcp.server.lowlevel.helper_types import ReadResourceContents
 
 @final
 class ToolContext:
-    """Enhanced context for Hanzo MCP tools.
+    """Enhanced context for Hanzo AI tools.
 
     This class wraps the MCP Context and adds additional functionality
     for tracking tool execution, progress reporting, and resource access.

hanzo_mcp/tools/common/context_fix.py

@@ -0,0 +1,26 @@
+"""Context handling fix for MCP tools.
+
+This module provides backward compatibility by re-exporting the
+context normalization utilities from the decorators module.
+
+DEPRECATED: Use hanzo_mcp.tools.common.decorators directly.
+"""
+
+# Re-export for backward compatibility
+from hanzo_mcp.tools.common.decorators import (
+    MockContext,
+    with_context_normalization,
+    _is_valid_context as is_valid_context,
+)
+
+# Backward compatibility function
+def normalize_context(ctx):
+    """Normalize context - backward compatibility wrapper.
+    
+    DEPRECATED: Use decorators.with_context_normalization instead.
+    """
+    if is_valid_context(ctx):
+        return ctx
+    return MockContext()
+
+__all__ = ['MockContext', 'normalize_context', 'with_context_normalization']

hanzo_mcp/tools/common/critic_tool.py

@@ -0,0 +1,196 @@
+"""Critic tool implementation.
+
+This module provides the CriticTool for Claude to engage in critical analysis and code review.
+"""
+
+from typing import Annotated, TypedDict, Unpack, final, override
+
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
+from pydantic import Field
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+
+
+Analysis = Annotated[
+    str,
+    Field(
+        description="The critical analysis to perform - code review, error detection, or improvement suggestions",
+        min_length=1,
+    ),
+]
+
+
+class CriticToolParams(TypedDict):
+    """Parameters for the CriticTool.
+
+    Attributes:
+        analysis: The critical analysis to perform
+    """
+
+    analysis: Analysis
+
+
+@final
+class CriticTool(BaseTool):
+    """Tool for Claude to engage in critical analysis and play devil's advocate."""
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name.
+
+        Returns:
+            Tool name
+        """
+        return "critic"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description.
+
+        Returns:
+            Tool description
+        """
+        return """Use this tool to perform critical analysis, play devil's advocate, and ensure high standards. 
+This tool forces a critical thinking mode that reviews all code for errors, improvements, and edge cases.
+It ensures tests are run, tests pass, and maintains high quality standards.
+
+This is your inner critic that:
+- Always questions assumptions
+- Looks for potential bugs and edge cases
+- Ensures proper error handling
+- Verifies test coverage
+- Checks for performance issues
+- Reviews security implications
+- Suggests improvements and refactoring
+- Ensures code follows best practices
+- Questions design decisions
+- Looks for missing documentation
+
+Common use cases:
+1. Before finalizing any code changes - review for bugs, edge cases, and improvements
+2. After implementing a feature - critically analyze if it truly solves the problem
+3. When tests pass too easily - question if tests are comprehensive enough
+4. Before marking a task complete - ensure all quality standards are met
+5. When something seems too simple - look for hidden complexity or missing requirements
+6. After fixing a bug - analyze if the fix addresses root cause or just symptoms
+
+<critic_example>
+Code Review Analysis:
+- Implementation Issues:
+  * No error handling for network failures in API calls
+  * Missing validation for user input boundaries
+  * Race condition possible in concurrent updates
+  * Memory leak potential in event listener registration
+  
+- Test Coverage Gaps:
+  * No tests for error scenarios
+  * Missing edge case: empty array input
+  * No performance benchmarks for large datasets
+  * Integration tests don't cover authentication failures
+  
+- Security Concerns:
+  * SQL injection vulnerability in query construction
+  * Missing rate limiting on public endpoints
+  * Sensitive data logged in debug mode
+  
+- Performance Issues:
+  * O(n²) algorithm where O(n log n) is possible
+  * Database queries in a loop (N+1 problem)
+  * No caching for expensive computations
+  
+- Code Quality:
+  * Functions too long and doing multiple things
+  * Inconsistent naming conventions
+  * Missing type annotations
+  * No documentation for complex algorithms
+  
+- Design Flaws:
+  * Tight coupling between modules
+  * Hard-coded configuration values
+  * No abstraction for external dependencies
+  * Violates single responsibility principle
+
+Recommendations:
+1. Add comprehensive error handling with retry logic
+2. Implement input validation with clear error messages
+3. Use database transactions to prevent race conditions
+4. Add memory cleanup in component unmount
+5. Parameterize SQL queries to prevent injection
+6. Implement rate limiting middleware
+7. Use environment variables for sensitive config
+8. Refactor algorithm to use sorting approach
+9. Batch database queries
+10. Add memoization for expensive calculations
+</critic_example>"""
+
+    def __init__(self) -> None:
+        """Initialize the critic tool."""
+        pass
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[CriticToolParams],
+    ) -> str:
+        """Execute the tool with the given parameters.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Tool result
+        """
+        tool_ctx = create_tool_context(ctx)
+        tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        analysis = params.get("analysis")
+
+        # Validate required analysis parameter
+        if not analysis:
+            await tool_ctx.error(
+                "Parameter 'analysis' is required but was None or empty"
+            )
+            return "Error: Parameter 'analysis' is required but was None or empty"
+
+        if analysis.strip() == "":
+            await tool_ctx.error("Parameter 'analysis' cannot be empty")
+            return "Error: Parameter 'analysis' cannot be empty"
+
+        # Log the critical analysis
+        await tool_ctx.info("Critical analysis recorded")
+
+        # Return confirmation with reminder to act on the analysis
+        return """Critical analysis complete. Remember to:
+1. Address all identified issues before proceeding
+2. Run comprehensive tests to verify fixes
+3. Ensure all tests pass with proper coverage
+4. Document any design decisions or trade-offs
+5. Consider the analysis points in your implementation
+
+Continue with improvements based on this critical review."""
+
+    @override
+    def register(self, mcp_server: FastMCP) -> None:
+        """Register this critic tool with the MCP server.
+
+        Creates a wrapper function with explicitly defined parameters that match
+        the tool's parameter schema and registers it with the MCP server.
+
+        Args:
+            mcp_server: The FastMCP server instance
+        """
+        tool_self = self  # Create a reference to self for use in the closure
+
+        @mcp_server.tool(name=self.name, description=self.description)
+        async def critic(
+            analysis: Analysis,
+            ctx: MCPContext
+        ) -> str:
+            return await tool_self.call(ctx, analysis=analysis)