hanzo-mcp 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

hanzo_mcp/__init__.py

@@ -1,3 +1,3 @@
 """Hanzo MCP - Implementation of Hanzo capabilities using MCP."""
 
-__version__ = "0.5.1"
+__version__ = "0.5.2"

hanzo_mcp/tools/__init__.py

@@ -14,13 +14,22 @@ from fastmcp 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.base import BaseTool
-
 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
+from hanzo_mcp.tools.mcp.mcp_add import McpAddTool
+from hanzo_mcp.tools.mcp.mcp_remove import McpRemoveTool
+from hanzo_mcp.tools.mcp.mcp_stats import McpStatsTool
+from hanzo_mcp.tools.editor import NeovimEditTool, NeovimCommandTool, NeovimSessionTool
+from hanzo_mcp.tools.llm import LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
 
 
 def register_all_tools(
@@ -76,8 +85,10 @@ def register_all_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),
+        "git_search": is_tool_enabled("git_search", not disable_search_tools),
         "content_replace": is_tool_enabled("content_replace", not disable_write_tools),
-        "unified_search": is_tool_enabled("unified_search", not disable_search_tools),
+        "batch_search": is_tool_enabled("batch_search", not disable_search_tools),
+        "find_files": is_tool_enabled("find_files", True),
     }
     
     # Vector tools setup (needed for unified search)
@@ -87,8 +98,8 @@ def register_all_tools(
         "vector_search": is_tool_enabled("vector_search", False),
     }
     
-    # Create project manager if vector tools or unified search are enabled
-    if any(vector_enabled.values()) or filesystem_enabled.get("unified_search", False):
+    # Create project manager if vector tools or batch_search are enabled
+    if any(vector_enabled.values()) or filesystem_enabled.get("batch_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]
@@ -175,3 +186,123 @@ def register_all_tools(
     # Register batch tool if enabled (batch tool is typically always enabled)
     if is_tool_enabled("batch", True):
         register_batch_tool(mcp_server, all_tools)
+    
+    # Register database tools if enabled
+    db_manager = None
+    database_enabled = {
+        "sql_query": is_tool_enabled("sql_query", True),
+        "sql_search": is_tool_enabled("sql_search", True),
+        "sql_stats": is_tool_enabled("sql_stats", True),
+        "graph_add": is_tool_enabled("graph_add", True),
+        "graph_remove": is_tool_enabled("graph_remove", True),
+        "graph_query": is_tool_enabled("graph_query", True),
+        "graph_search": is_tool_enabled("graph_search", True),
+        "graph_stats": is_tool_enabled("graph_stats", True),
+    }
+    
+    if any(database_enabled.values()):
+        db_manager = DatabaseManager(permission_manager)
+        database_tools = register_database_tools(
+            mcp_server,
+            permission_manager,
+            db_manager=db_manager,
+        )
+        # Filter based on enabled state
+        for tool in database_tools:
+            if database_enabled.get(tool.name, True):
+                all_tools[tool.name] = tool
+    
+    # Register MCP management tools if enabled
+    mcp_enabled = {
+        "mcp_add": is_tool_enabled("mcp_add", True),
+        "mcp_remove": is_tool_enabled("mcp_remove", True),
+        "mcp_stats": is_tool_enabled("mcp_stats", True),
+    }
+    
+    if mcp_enabled.get("mcp_add", True):
+        tool = McpAddTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if mcp_enabled.get("mcp_remove", True):
+        tool = McpRemoveTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if mcp_enabled.get("mcp_stats", True):
+        tool = McpStatsTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register system tools (always enabled)
+    # Tool enable/disable tools
+    tool_enable = ToolEnableTool()
+    tool_enable.register(mcp_server)
+    all_tools[tool_enable.name] = tool_enable
+    
+    tool_disable = ToolDisableTool()
+    tool_disable.register(mcp_server)
+    all_tools[tool_disable.name] = tool_disable
+    
+    tool_list = ToolListTool()
+    tool_list.register(mcp_server)
+    all_tools[tool_list.name] = tool_list
+    
+    # Stats tool
+    stats_tool = StatsTool(db_manager=db_manager)
+    stats_tool.register(mcp_server)
+    all_tools[stats_tool.name] = stats_tool
+    
+    # Register editor tools if enabled
+    editor_enabled = {
+        "neovim_edit": is_tool_enabled("neovim_edit", True),
+        "neovim_command": is_tool_enabled("neovim_command", True),
+        "neovim_session": is_tool_enabled("neovim_session", True),
+    }
+    
+    if editor_enabled.get("neovim_edit", True):
+        tool = NeovimEditTool(permission_manager)
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if editor_enabled.get("neovim_command", True):
+        tool = NeovimCommandTool(permission_manager)
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if editor_enabled.get("neovim_session", True):
+        tool = NeovimSessionTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register LLM tools if enabled
+    llm_enabled = {
+        "llm": is_tool_enabled("llm", True),
+        "consensus": is_tool_enabled("consensus", True),
+        "llm_manage": is_tool_enabled("llm_manage", True),
+    }
+    
+    if llm_enabled.get("llm", True):
+        tool = LLMTool()
+        if tool.available_providers:  # Only register if API keys found
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+    
+    if llm_enabled.get("consensus", True):
+        tool = ConsensusTool()
+        if tool.llm_tool.available_providers:  # Only register if API keys found
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+    
+    if llm_enabled.get("llm_manage", True):
+        tool = LLMManageTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register provider-specific LLM tools
+    # These are only registered if their API keys are available
+    provider_tools = create_provider_tools()
+    for tool in provider_tools:
+        if is_tool_enabled(tool.name, True):
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool

hanzo_mcp/tools/common/base.py

@@ -170,8 +170,13 @@ class ToolRegistry:
             mcp_server: The FastMCP server instance
             tool: The tool to register
         """
-        # Use the tool's register method which handles all the details
-        tool.register(mcp_server)
+        # Check if tool is enabled before registering
+        # Import here to avoid circular imports
+        from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
+        
+        if ToolEnableTool.is_tool_enabled(tool.name):
+            # Use the tool's register method which handles all the details
+            tool.register(mcp_server)
 
     @staticmethod
     def register_tools(mcp_server: FastMCP, tools: list[BaseTool]) -> None:

hanzo_mcp/tools/common/stats.py

@@ -0,0 +1,261 @@
+"""Comprehensive system and MCP statistics."""
+
+import os
+import psutil
+import shutil
+from typing import TypedDict, Unpack, final, override
+from datetime import datetime
+from pathlib import Path
+
+from fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+from hanzo_mcp.tools.shell.run_background import RunBackgroundTool
+from hanzo_mcp.tools.mcp.mcp_add import McpAddTool
+from hanzo_mcp.tools.database.database_manager import DatabaseManager
+
+
+class StatsParams(TypedDict, total=False):
+    """Parameters for stats tool."""
+    pass
+
+
+@final
+class StatsTool(BaseTool):
+    """Tool for showing comprehensive system and MCP statistics."""
+
+    def __init__(self, db_manager: DatabaseManager = None):
+        """Initialize the stats tool.
+        
+        Args:
+            db_manager: Optional database manager for DB stats
+        """
+        self.db_manager = db_manager
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "stats"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Show comprehensive system and Hanzo MCP statistics.
+
+Displays:
+- System resources (CPU, memory, disk)
+- Running processes
+- Database usage
+- MCP server status
+- Tool usage statistics
+- Warnings for high resource usage
+
+Example:
+- stats
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[StatsParams],
+    ) -> str:
+        """Get comprehensive statistics.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Comprehensive statistics
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        output = []
+        warnings = []
+        
+        # Header
+        output.append("=== Hanzo MCP System Statistics ===")
+        output.append(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        output.append("")
+        
+        # System Resources
+        output.append("=== System Resources ===")
+        
+        # CPU
+        cpu_percent = psutil.cpu_percent(interval=1)
+        cpu_count = psutil.cpu_count()
+        output.append(f"CPU Usage: {cpu_percent}% ({cpu_count} cores)")
+        if cpu_percent > 90:
+            warnings.append(f"⚠️  HIGH CPU USAGE: {cpu_percent}%")
+        
+        # Memory
+        memory = psutil.virtual_memory()
+        memory_used_gb = memory.used / (1024**3)
+        memory_total_gb = memory.total / (1024**3)
+        memory_percent = memory.percent
+        output.append(f"Memory: {memory_used_gb:.1f}/{memory_total_gb:.1f} GB ({memory_percent}%)")
+        if memory_percent > 90:
+            warnings.append(f"⚠️  HIGH MEMORY USAGE: {memory_percent}%")
+        
+        # Disk
+        disk = psutil.disk_usage('/')
+        disk_used_gb = disk.used / (1024**3)
+        disk_total_gb = disk.total / (1024**3)
+        disk_percent = disk.percent
+        disk_free_gb = disk.free / (1024**3)
+        output.append(f"Disk: {disk_used_gb:.1f}/{disk_total_gb:.1f} GB ({disk_percent}%)")
+        output.append(f"Free Space: {disk_free_gb:.1f} GB")
+        if disk_percent > 90:
+            warnings.append(f"⚠️  LOW DISK SPACE: Only {disk_free_gb:.1f} GB free ({100-disk_percent:.1f}% remaining)")
+        
+        output.append("")
+        
+        # Background Processes
+        output.append("=== Background Processes ===")
+        processes = RunBackgroundTool.get_processes()
+        running_count = 0
+        total_memory_mb = 0
+        
+        if processes:
+            for proc in processes.values():
+                if proc.is_running():
+                    running_count += 1
+                    try:
+                        ps_proc = psutil.Process(proc.process.pid)
+                        memory_mb = ps_proc.memory_info().rss / (1024**2)
+                        total_memory_mb += memory_mb
+                    except:
+                        pass
+            
+            output.append(f"Running Processes: {running_count}")
+            output.append(f"Total Memory Usage: {total_memory_mb:.1f} MB")
+            
+            # List top processes by memory
+            if running_count > 0:
+                output.append("\nTop Processes:")
+                proc_list = []
+                for proc_id, proc in processes.items():
+                    if proc.is_running():
+                        try:
+                            ps_proc = psutil.Process(proc.process.pid)
+                            memory_mb = ps_proc.memory_info().rss / (1024**2)
+                            cpu = ps_proc.cpu_percent(interval=0.1)
+                            proc_list.append((proc.name, memory_mb, cpu, proc_id))
+                        except:
+                            proc_list.append((proc.name, 0, 0, proc_id))
+                
+                proc_list.sort(key=lambda x: x[1], reverse=True)
+                for name, mem, cpu, pid in proc_list[:5]:
+                    output.append(f"  - {name} ({pid}): {mem:.1f} MB, {cpu:.1f}% CPU")
+        else:
+            output.append("No background processes running")
+        
+        output.append("")
+        
+        # Database Usage
+        if self.db_manager:
+            output.append("=== Database Usage ===")
+            db_dir = Path.home() / ".hanzo" / "db"
+            total_db_size = 0
+            
+            if db_dir.exists():
+                for db_file in db_dir.rglob("*.db"):
+                    size = db_file.stat().st_size
+                    total_db_size += size
+                
+                output.append(f"Total Database Size: {total_db_size / (1024**2):.1f} MB")
+                output.append(f"Active Projects: {len(self.db_manager.projects)}")
+                
+                # List largest databases
+                db_sizes = []
+                for db_file in db_dir.rglob("*.db"):
+                    size = db_file.stat().st_size / (1024**2)
+                    if size > 0.1:  # Only show DBs > 100KB
+                        project = db_file.parent.parent.name
+                        db_type = db_file.stem
+                        db_sizes.append((project, db_type, size))
+                
+                if db_sizes:
+                    db_sizes.sort(key=lambda x: x[2], reverse=True)
+                    output.append("\nLargest Databases:")
+                    for project, db_type, size in db_sizes[:5]:
+                        output.append(f"  - {project}/{db_type}: {size:.1f} MB")
+            else:
+                output.append("No databases found")
+        
+        output.append("")
+        
+        # MCP Servers
+        output.append("=== MCP Servers ===")
+        mcp_servers = McpAddTool.get_servers()
+        if mcp_servers:
+            running_mcp = sum(1 for s in mcp_servers.values() if s.get("status") == "running")
+            total_mcp_tools = sum(len(s.get("tools", [])) for s in mcp_servers.values())
+            
+            output.append(f"Total Servers: {len(mcp_servers)}")
+            output.append(f"Running: {running_mcp}")
+            output.append(f"Total Tools Available: {total_mcp_tools}")
+        else:
+            output.append("No MCP servers configured")
+        
+        output.append("")
+        
+        # Hanzo MCP Specifics
+        output.append("=== Hanzo MCP ===")
+        
+        # Log directory size
+        log_dir = Path.home() / ".hanzo" / "logs"
+        if log_dir.exists():
+            log_size = sum(f.stat().st_size for f in log_dir.rglob("*") if f.is_file())
+            log_count = len(list(log_dir.rglob("*.log")))
+            output.append(f"Log Files: {log_count} ({log_size / (1024**2):.1f} MB)")
+            
+            if log_size > 100 * 1024**2:  # > 100MB
+                warnings.append(f"⚠️  Large log directory: {log_size / (1024**2):.1f} MB")
+        
+        # Config directory
+        config_dir = Path.home() / ".hanzo" / "mcp"
+        if config_dir.exists():
+            config_count = len(list(config_dir.rglob("*.json")))
+            output.append(f"Config Files: {config_count}")
+        
+        # Tool status (if available)
+        # TODO: Track tool usage statistics
+        output.append("\nTool Categories:")
+        output.append("  - File Operations: grep, find_files, read, write, edit")
+        output.append("  - Shell: bash, run_background, processes, pkill")
+        output.append("  - Database: sql_query, graph_query, vector_search")
+        output.append("  - Package Runners: uvx, npx, uvx_background, npx_background")
+        output.append("  - MCP Management: mcp_add, mcp_remove, mcp_stats")
+        
+        # Warnings Section
+        if warnings:
+            output.append("\n=== ⚠️  WARNINGS ===")
+            for warning in warnings:
+                output.append(warning)
+            output.append("")
+        
+        # Recommendations
+        output.append("=== Recommendations ===")
+        if disk_free_gb < 5:
+            output.append("- Free up disk space (< 5GB remaining)")
+        if memory_percent > 80:
+            output.append("- Close unused applications to free memory")
+        if running_count > 10:
+            output.append("- Consider stopping unused background processes")
+        if log_size > 50 * 1024**2:
+            output.append("- Clean up old log files in ~/.hanzo/logs")
+        
+        if not any([disk_free_gb < 5, memory_percent > 80, running_count > 10, log_size > 50 * 1024**2]):
+            output.append("✅ System resources are healthy")
+        
+        return "\n".join(output)
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/common/tool_disable.py

@@ -0,0 +1,144 @@
+"""Disable tools dynamically."""
+
+from typing import Annotated, TypedDict, Unpack, final, override
+
+from fastmcp import Context as MCPContext
+from pydantic import Field
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
+
+
+ToolName = Annotated[
+    str,
+    Field(
+        description="Name of the tool to disable (e.g., 'grep', 'vector_search')",
+        min_length=1,
+    ),
+]
+
+Persist = Annotated[
+    bool,
+    Field(
+        description="Persist the change to config file",
+        default=True,
+    ),
+]
+
+
+class ToolDisableParams(TypedDict, total=False):
+    """Parameters for tool disable."""
+
+    tool: str
+    persist: bool
+
+
+@final
+class ToolDisableTool(BaseTool):
+    """Tool for disabling other tools dynamically."""
+
+    def __init__(self):
+        """Initialize the tool disable tool."""
+        # Ensure states are loaded
+        if not ToolEnableTool._initialized:
+            ToolEnableTool._load_states()
+            ToolEnableTool._initialized = True
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "tool_disable"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Disable tools to prevent their use.
+
+This allows you to temporarily or permanently disable tools.
+Useful for testing or when a tool is misbehaving.
+Changes are persisted by default.
+
+Critical tools (tool_enable, tool_disable, tool_list) cannot be disabled.
+
+Examples:
+- tool_disable --tool vector_search
+- tool_disable --tool uvx_background
+- tool_disable --tool grep --no-persist
+
+Use 'tool_list' to see all available tools and their status.
+Use 'tool_enable' to re-enable disabled tools.
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[ToolDisableParams],
+    ) -> str:
+        """Disable a tool.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Result of disabling the tool
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        tool_name = params.get("tool")
+        if not tool_name:
+            return "Error: tool name is required"
+
+        persist = params.get("persist", True)
+
+        # Prevent disabling critical tools
+        critical_tools = {"tool_enable", "tool_disable", "tool_list", "stats"}
+        if tool_name in critical_tools:
+            return f"Error: Cannot disable critical tool '{tool_name}'. These tools are required for system management."
+
+        # Check current state
+        was_enabled = ToolEnableTool.is_tool_enabled(tool_name)
+        
+        if not was_enabled:
+            return f"Tool '{tool_name}' is already disabled."
+
+        # Disable the tool
+        ToolEnableTool._tool_states[tool_name] = False
+        
+        # Persist if requested
+        if persist:
+            ToolEnableTool._save_states()
+            await tool_ctx.info(f"Disabled tool '{tool_name}' (persisted)")
+        else:
+            await tool_ctx.info(f"Disabled tool '{tool_name}' (temporary)")
+
+        output = [
+            f"Successfully disabled tool '{tool_name}'",
+            "",
+            "The tool is now unavailable for use.",
+            f"Use 'tool_enable --tool {tool_name}' to re-enable it.",
+        ]
+        
+        if not persist:
+            output.append("\nNote: This change is temporary and will be lost on restart.")
+        
+        # Warn about commonly used tools
+        common_tools = {"grep", "read", "write", "bash", "edit"}
+        if tool_name in common_tools:
+            output.append(f"\n⚠️  Warning: '{tool_name}' is a commonly used tool. Disabling it may affect normal operations.")
+        
+        # Count disabled tools
+        disabled_count = sum(1 for enabled in ToolEnableTool._tool_states.values() if not enabled)
+        output.append(f"\nTotal disabled tools: {disabled_count}")
+        
+        return "\n".join(output)
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass