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

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

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 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

hanzo_mcp/tools/common/tool_list.py

@@ -0,0 +1,263 @@
+"""List all available tools and their status."""
+
+from typing import Annotated, TypedDict, Unpack, final, override, Optional
+
+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
+
+
+ShowDisabled = Annotated[
+    bool,
+    Field(
+        description="Show only disabled tools",
+        default=False,
+    ),
+]
+
+ShowEnabled = Annotated[
+    bool,
+    Field(
+        description="Show only enabled tools",
+        default=False,
+    ),
+]
+
+Category = Annotated[
+    Optional[str],
+    Field(
+        description="Filter by category (filesystem, shell, database, etc.)",
+        default=None,
+    ),
+]
+
+
+class ToolListParams(TypedDict, total=False):
+    """Parameters for tool list."""
+
+    show_disabled: bool
+    show_enabled: bool
+    category: Optional[str]
+
+
+@final
+class ToolListTool(BaseTool):
+    """Tool for listing all available tools and their status."""
+    
+    # Tool information organized by category
+    TOOL_INFO = {
+        "filesystem": [
+            ("read", "Read contents of files"),
+            ("write", "Write contents to files"),
+            ("edit", "Edit specific parts of files"),
+            ("multi_edit", "Make multiple edits to a file"),
+            ("directory_tree", "Display directory structure"),
+            ("grep", "Search file contents with patterns"),
+            ("grep_ast", "Search code with AST patterns"),
+            ("git_search", "Search git history"),
+            ("batch_search", "Run multiple searches in parallel"),
+            ("find_files", "Find files by name pattern"),
+            ("content_replace", "Replace content across files"),
+        ],
+        "shell": [
+            ("run_command", "Execute shell commands"),
+            ("run_background", "Run commands in background"),
+            ("processes", "List background processes"),
+            ("pkill", "Kill background processes"),
+            ("logs", "View process logs"),
+            ("uvx", "Run Python packages"),
+            ("uvx_background", "Run Python servers"),
+            ("npx", "Run Node.js packages"),
+            ("npx_background", "Run Node.js servers"),
+        ],
+        "database": [
+            ("sql_query", "Execute SQL queries"),
+            ("sql_search", "Search in SQLite databases"),
+            ("sql_stats", "SQLite database statistics"),
+            ("graph_add", "Add nodes/edges to graph"),
+            ("graph_remove", "Remove nodes/edges from graph"),
+            ("graph_query", "Query graph relationships"),
+            ("graph_search", "Search in graph database"),
+            ("graph_stats", "Graph database statistics"),
+        ],
+        "vector": [
+            ("vector_index", "Index files into vector store"),
+            ("vector_search", "Semantic search in vector store"),
+        ],
+        "mcp": [
+            ("mcp_add", "Add MCP servers"),
+            ("mcp_remove", "Remove MCP servers"),
+            ("mcp_stats", "MCP server statistics"),
+        ],
+        "system": [
+            ("stats", "System and resource statistics"),
+            ("tool_enable", "Enable tools"),
+            ("tool_disable", "Disable tools"),
+            ("tool_list", "List all tools (this tool)"),
+        ],
+        "editor": [
+            ("neovim_edit", "Open files in Neovim"),
+            ("neovim_command", "Execute Neovim commands"),
+            ("neovim_session", "Manage Neovim sessions"),
+        ],
+        "llm": [
+            ("llm", "Query any LLM via LiteLLM"),
+            ("consensus", "Get consensus from multiple LLMs"),
+            ("llm_manage", "Manage LLM providers"),
+            ("openai", "Query OpenAI models"),
+            ("anthropic", "Query Anthropic Claude models"),
+            ("gemini", "Query Google Gemini models"),
+            ("groq", "Query Groq fast models"),
+            ("mistral", "Query Mistral models"),
+            ("perplexity", "Query Perplexity with search"),
+        ],
+        "other": [
+            ("think", "Structured thinking space"),
+            ("dispatch_agent", "Delegate tasks to sub-agents"),
+            ("todo_read", "Read todo list"),
+            ("todo_write", "Write todo list"),
+            ("notebook_read", "Read Jupyter notebooks"),
+            ("notebook_edit", "Edit Jupyter notebooks"),
+            ("batch", "Run multiple tools in parallel"),
+        ],
+    }
+
+    def __init__(self):
+        """Initialize the tool list tool."""
+        pass
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "tool_list"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """List all available tools and their current status.
+
+Shows:
+- Tool names and descriptions
+- Whether each tool is enabled or disabled
+- Tools organized by category
+
+Examples:
+- tool_list                    # Show all tools
+- tool_list --show-disabled    # Show only disabled tools
+- tool_list --show-enabled     # Show only enabled tools
+- tool_list --category shell   # Show only shell tools
+
+Use 'tool_enable' and 'tool_disable' to change tool status.
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[ToolListParams],
+    ) -> str:
+        """List all tools.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            List of tools and their status
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        show_disabled = params.get("show_disabled", False)
+        show_enabled = params.get("show_enabled", False)
+        category_filter = params.get("category")
+
+        # Get all tool states
+        all_states = ToolEnableTool.get_all_states()
+        
+        output = []
+        
+        # Header
+        if show_disabled:
+            output.append("=== Disabled Tools ===")
+        elif show_enabled:
+            output.append("=== Enabled Tools ===")
+        else:
+            output.append("=== All Available Tools ===")
+        
+        if category_filter:
+            output.append(f"Category: {category_filter}")
+        
+        output.append("")
+        
+        # Count statistics
+        total_tools = 0
+        disabled_count = 0
+        shown_count = 0
+        
+        # Iterate through categories
+        categories = [category_filter] if category_filter and category_filter in self.TOOL_INFO else self.TOOL_INFO.keys()
+        
+        for category in categories:
+            if category not in self.TOOL_INFO:
+                continue
+                
+            category_tools = self.TOOL_INFO[category]
+            category_shown = []
+            
+            for tool_name, description in category_tools:
+                total_tools += 1
+                is_enabled = ToolEnableTool.is_tool_enabled(tool_name)
+                
+                if not is_enabled:
+                    disabled_count += 1
+                
+                # Apply filters
+                if show_disabled and is_enabled:
+                    continue
+                if show_enabled and not is_enabled:
+                    continue
+                
+                status = "✅" if is_enabled else "❌"
+                category_shown.append((tool_name, description, status))
+                shown_count += 1
+            
+            # Show category if it has tools
+            if category_shown:
+                output.append(f"=== {category.title()} Tools ===")
+                
+                # Find max tool name length for alignment
+                max_name_len = max(len(name) for name, _, _ in category_shown)
+                
+                for tool_name, description, status in category_shown:
+                    output.append(f"{status} {tool_name.ljust(max_name_len)} - {description}")
+                
+                output.append("")
+        
+        # Summary
+        if not show_disabled and not show_enabled:
+            output.append("=== Summary ===")
+            output.append(f"Total tools: {total_tools}")
+            output.append(f"Enabled: {total_tools - disabled_count}")
+            output.append(f"Disabled: {disabled_count}")
+        else:
+            output.append(f"Showing {shown_count} tool(s)")
+        
+        if disabled_count > 0 and not show_disabled:
+            output.append("\nUse 'tool_list --show-disabled' to see disabled tools.")
+            output.append("Use 'tool_enable --tool <name>' to enable a tool.")
+        
+        if show_disabled:
+            output.append("\nUse 'tool_enable --tool <name>' to enable these tools.")
+        
+        return "\n".join(output)
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/database/__init__.py

@@ -0,0 +1,71 @@
+"""Database tools for Hanzo MCP.
+
+This package provides tools for working with embedded SQLite databases
+and graph databases in projects.
+"""
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from fastmcp import FastMCP
+
+# Import database tools
+from .sql_query import SqlQueryTool
+from .sql_search import SqlSearchTool
+from .sql_stats import SqlStatsTool
+from .graph_add import GraphAddTool
+from .graph_remove import GraphRemoveTool
+from .graph_query import GraphQueryTool
+from .graph_search import GraphSearchTool
+from .graph_stats import GraphStatsTool
+from .database_manager import DatabaseManager
+
+__all__ = [
+    "register_database_tools",
+    "DatabaseManager",
+    "SqlQueryTool",
+    "SqlSearchTool", 
+    "SqlStatsTool",
+    "GraphAddTool",
+    "GraphRemoveTool",
+    "GraphQueryTool",
+    "GraphSearchTool",
+    "GraphStatsTool",
+]
+
+
+def register_database_tools(
+    mcp_server: FastMCP,
+    permission_manager: PermissionManager,
+    db_manager: DatabaseManager | None = None,
+) -> list[BaseTool]:
+    """Register database tools with the MCP server.
+    
+    Args:
+        mcp_server: The FastMCP server instance
+        permission_manager: Permission manager for access control
+        db_manager: Optional database manager instance
+        
+    Returns:
+        List of registered tools
+    """
+    # Create database manager if not provided
+    if db_manager is None:
+        db_manager = DatabaseManager(permission_manager)
+    
+    # Create tool instances
+    tools = [
+        SqlQueryTool(permission_manager, db_manager),
+        SqlSearchTool(permission_manager, db_manager),
+        SqlStatsTool(permission_manager, db_manager),
+        GraphAddTool(permission_manager, db_manager),
+        GraphRemoveTool(permission_manager, db_manager),
+        GraphQueryTool(permission_manager, db_manager),
+        GraphSearchTool(permission_manager, db_manager),
+        GraphStatsTool(permission_manager, db_manager),
+    ]
+    
+    # Register with MCP server
+    from hanzo_mcp.tools.common.base import ToolRegistry
+    ToolRegistry.register_tools(mcp_server, tools)
+    
+    return tools