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

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 mcp.server.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/thinking_tool.py

@@ -5,9 +5,8 @@ This module provides the ThinkingTool for Claude to engage in structured thinkin
 
 from typing import Annotated, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
-from fastmcp.server.dependencies import get_context
+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
@@ -146,8 +145,7 @@ Feature Implementation Planning
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def think(
-            ctx: MCPContext,
             thought: Thought,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(ctx, thought=thought)

hanzo_mcp/tools/common/tool_disable.py

@@ -0,0 +1,144 @@
+"""Disable tools dynamically."""
+
+from typing import Annotated, TypedDict, Unpack, final, override
+
+from mcp.server.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

hanzo_mcp/tools/common/tool_enable.py

@@ -0,0 +1,182 @@
+"""Enable tools dynamically."""
+
+import json
+from typing import Annotated, TypedDict, Unpack, final, override
+from pathlib import Path
+
+from mcp.server.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
+
+
+ToolName = Annotated[
+    str,
+    Field(
+        description="Name of the tool to enable (e.g., 'grep', 'vector_search')",
+        min_length=1,
+    ),
+]
+
+Persist = Annotated[
+    bool,
+    Field(
+        description="Persist the change to config file",
+        default=True,
+    ),
+]
+
+
+class ToolEnableParams(TypedDict, total=False):
+    """Parameters for tool enable."""
+
+    tool: str
+    persist: bool
+
+
+@final
+class ToolEnableTool(BaseTool):
+    """Tool for enabling other tools dynamically."""
+    
+    # Class variable to track enabled/disabled tools
+    _tool_states = {}
+    _config_file = Path.home() / ".hanzo" / "mcp" / "tool_states.json"
+    _initialized = False
+
+    def __init__(self):
+        """Initialize the tool enable tool."""
+        if not ToolEnableTool._initialized:
+            self._load_states()
+            ToolEnableTool._initialized = True
+
+    @classmethod
+    def _load_states(cls):
+        """Load tool states from config file."""
+        if cls._config_file.exists():
+            try:
+                with open(cls._config_file, 'r') as f:
+                    cls._tool_states = json.load(f)
+            except Exception:
+                cls._tool_states = {}
+        else:
+            # Default all tools to enabled
+            cls._tool_states = {}
+
+    @classmethod
+    def _save_states(cls):
+        """Save tool states to config file."""
+        cls._config_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(cls._config_file, 'w') as f:
+            json.dump(cls._tool_states, f, indent=2)
+
+    @classmethod
+    def is_tool_enabled(cls, tool_name: str) -> bool:
+        """Check if a tool is enabled.
+        
+        Args:
+            tool_name: Name of the tool
+            
+        Returns:
+            True if enabled (default), False if explicitly disabled
+        """
+        # Load states if not initialized
+        if not cls._initialized:
+            cls._load_states()
+            cls._initialized = True
+        
+        # Default to enabled if not in states
+        return cls._tool_states.get(tool_name, True)
+
+    @classmethod
+    def get_all_states(cls) -> dict:
+        """Get all tool states."""
+        if not cls._initialized:
+            cls._load_states()
+            cls._initialized = True
+        return cls._tool_states.copy()
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "tool_enable"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Enable tools that have been disabled.
+
+This allows you to re-enable tools that were previously disabled.
+Changes are persisted by default.
+
+Examples:
+- tool_enable --tool grep
+- tool_enable --tool vector_search
+- tool_enable --tool uvx_background --no-persist
+
+Use 'tool_list' to see all available tools and their status.
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[ToolEnableParams],
+    ) -> str:
+        """Enable a tool.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Result of enabling 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)
+
+        # Check current state
+        was_enabled = self.is_tool_enabled(tool_name)
+        
+        if was_enabled:
+            return f"Tool '{tool_name}' is already enabled."
+
+        # Enable the tool
+        self._tool_states[tool_name] = True
+        
+        # Persist if requested
+        if persist:
+            self._save_states()
+            await tool_ctx.info(f"Enabled tool '{tool_name}' (persisted)")
+        else:
+            await tool_ctx.info(f"Enabled tool '{tool_name}' (temporary)")
+
+        output = [
+            f"Successfully enabled tool '{tool_name}'",
+            "",
+            "The tool is now available for use.",
+        ]
+        
+        if not persist:
+            output.append("Note: This change is temporary and will be lost on restart.")
+        
+        # Count enabled/disabled tools
+        disabled_count = sum(1 for enabled in self._tool_states.values() if not enabled)
+        if disabled_count > 0:
+            output.append(f"\nCurrently disabled tools: {disabled_count}")
+            output.append("Use 'tool_list --disabled' to see them.")
+        
+        return "\n".join(output)
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass