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

hanzo_mcp/tools/common/tool_list.py

@@ -0,0 +1,260 @@
+"""List all available tools and their status."""
+
+from typing import Annotated, TypedDict, Unpack, final, override, Optional
+
+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
+
+
+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"),
+            ("tree", "Directory tree visualization (Unix-style)"),
+            ("find", "Find text in files (rg/ag/ack/grep)"),
+            ("symbols", "Code symbols search with tree-sitter"),
+            ("search", "Unified search (parallel grep/symbols/vector/git)"),
+            ("git_search", "Search git history"),
+            ("glob", "Find files by name pattern"),
+            ("content_replace", "Replace content across files"),
+        ],
+        "shell": [
+            ("run_command", "Execute shell commands (--background option)"),
+            ("processes", "List background processes"),
+            ("pkill", "Kill background processes"),
+            ("logs", "View process logs"),
+            ("uvx", "Run Python packages (--background option)"),
+            ("npx", "Run Node.js packages (--background option)"),
+        ],
+        "database": [
+            ("sql", "SQLite operations (query/search/schema/stats)"),
+            ("graph", "Graph database (query/add/remove/search/stats)"),
+            ("vector", "Semantic search (search/index/stats/clear)"),
+        ],
+        "ai": [
+            ("llm", "LLM interface (query/consensus/list/models/enable/disable)"),
+            ("agent", "AI agents (run/start/call/stop/list with A2A support)"),
+            ("mcp", "MCP servers (list/add/remove/enable/disable/restart)"),
+        ],
+        "config": [
+            ("config", "Git-style configuration (get/set/list/toggle)"),
+            ("tool_enable", "Enable tools"),
+            ("tool_disable", "Disable tools"),
+            ("tool_list", "List all tools (this tool)"),
+        ],
+        "productivity": [
+            ("todo", "Todo management (list/add/update/remove/clear)"),
+            ("jupyter", "Jupyter notebooks (read/edit/create/delete/execute)"),
+            ("think", "Structured thinking space"),
+        ],
+        "system": [
+            ("stats", "System and resource statistics"),
+            ("batch", "Run multiple tools in parallel"),
+        ],
+        "legacy": [
+            ("directory_tree", "Legacy: Use 'tree' instead"),
+            ("grep", "Legacy: Use 'find' instead"),
+            ("grep_ast", "Legacy: Use 'symbols' instead"),
+            ("batch_search", "Legacy: Use 'search' instead"),
+            ("find_files", "Legacy: Use 'glob' instead"),
+            ("run_background", "Legacy: Use 'run_command --background'"),
+            ("uvx_background", "Legacy: Use 'uvx --background'"),
+            ("npx_background", "Legacy: Use 'npx --background'"),
+            ("sql_query", "Legacy: Use 'sql' instead"),
+            ("sql_search", "Legacy: Use 'sql --action search'"),
+            ("sql_stats", "Legacy: Use 'sql --action stats'"),
+            ("graph_add", "Legacy: Use 'graph --action add'"),
+            ("graph_remove", "Legacy: Use 'graph --action remove'"),
+            ("graph_query", "Legacy: Use 'graph' instead"),
+            ("graph_search", "Legacy: Use 'graph --action search'"),
+            ("graph_stats", "Legacy: Use 'graph --action stats'"),
+            ("vector_index", "Legacy: Use 'vector --action index'"),
+            ("vector_search", "Legacy: Use 'vector' instead"),
+            ("dispatch_agent", "Legacy: Use 'agent' instead"),
+            ("todo_read", "Legacy: Use 'todo' instead"),
+            ("todo_write", "Legacy: Use 'todo --action add/update'"),
+            ("notebook_read", "Legacy: Use 'jupyter' instead"),
+            ("notebook_edit", "Legacy: Use 'jupyter --action edit'"),
+        ],
+    }
+
+    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/config/__init__.py

@@ -0,0 +1,10 @@
+"""Configuration tools for Hanzo MCP."""
+
+from hanzo_mcp.tools.config.config_tool import ConfigTool
+from hanzo_mcp.tools.config.index_config import IndexConfig, IndexScope
+
+__all__ = [
+    "ConfigTool",
+    "IndexConfig", 
+    "IndexScope",
+]

hanzo_mcp/tools/config/config_tool.py

@@ -0,0 +1,212 @@
+"""Configuration tool for Hanzo MCP.
+
+Git-style config tool for managing settings.
+"""
+
+from typing import Annotated, TypedDict, Unpack, final, override, Optional, Dict, Any
+from pathlib import Path
+import json
+
+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.permissions import PermissionManager
+from hanzo_mcp.tools.config.index_config import IndexConfig, IndexScope
+
+
+# Parameter types
+Action = Annotated[
+    str,
+    Field(
+        description="Action: get (default), set, list, toggle",
+        default="get",
+    ),
+]
+
+Key = Annotated[
+    Optional[str],
+    Field(
+        description="Configuration key (e.g., index.scope, vector.enabled)",
+        default=None,
+    ),
+]
+
+Value = Annotated[
+    Optional[str],
+    Field(
+        description="Configuration value",
+        default=None,
+    ),
+]
+
+Scope = Annotated[
+    str,
+    Field(
+        description="Config scope: local (project) or global",
+        default="local",
+    ),
+]
+
+ConfigPath = Annotated[
+    Optional[str],
+    Field(
+        description="Path for project-specific config",
+        default=None,
+    ),
+]
+
+
+class ConfigParams(TypedDict, total=False):
+    """Parameters for config tool."""
+    action: str
+    key: Optional[str]
+    value: Optional[str]
+    scope: str
+    path: Optional[str]
+
+
+@final
+class ConfigTool(BaseTool):
+    """Git-style configuration management tool."""
+    
+    def __init__(self, permission_manager: PermissionManager):
+        """Initialize config tool."""
+        super().__init__(permission_manager)
+        self.index_config = IndexConfig()
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "config"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Git-style configuration. Actions: get (default), set, list, toggle.
+
+Usage:
+config index.scope
+config --action set index.scope project
+config --action list
+config --action toggle index.scope --path ./project"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[ConfigParams],
+    ) -> str:
+        """Execute config operation."""
+        tool_ctx = self.create_tool_context(ctx)
+        
+        # Extract parameters
+        action = params.get("action", "get")
+        key = params.get("key")
+        value = params.get("value")
+        scope = params.get("scope", "local")
+        path = params.get("path")
+        
+        # Route to handler
+        if action == "get":
+            return await self._handle_get(key, scope, path, tool_ctx)
+        elif action == "set":
+            return await self._handle_set(key, value, scope, path, tool_ctx)
+        elif action == "list":
+            return await self._handle_list(scope, path, tool_ctx)
+        elif action == "toggle":
+            return await self._handle_toggle(key, scope, path, tool_ctx)
+        else:
+            return f"Error: Unknown action '{action}'. Valid actions: get, set, list, toggle"
+
+    async def _handle_get(self, key: Optional[str], scope: str, path: Optional[str], tool_ctx) -> str:
+        """Get configuration value."""
+        if not key:
+            return "Error: key required for get action"
+            
+        # Handle index scope
+        if key == "index.scope":
+            current_scope = self.index_config.get_scope(path)
+            return f"index.scope={current_scope.value}"
+            
+        # Handle tool-specific settings
+        if "." in key:
+            tool, setting = key.split(".", 1)
+            if setting == "enabled":
+                enabled = self.index_config.is_indexing_enabled(tool)
+                return f"{key}={enabled}"
+                
+        return f"Unknown key: {key}"
+
+    async def _handle_set(self, key: Optional[str], value: Optional[str], scope: str, path: Optional[str], tool_ctx) -> str:
+        """Set configuration value."""
+        if not key:
+            return "Error: key required for set action"
+        if not value:
+            return "Error: value required for set action"
+            
+        # Handle index scope
+        if key == "index.scope":
+            try:
+                new_scope = IndexScope(value)
+                self.index_config.set_scope(new_scope, path if scope == "local" else None)
+                return f"Set {key}={value} ({'project' if path else 'global'})"
+            except ValueError:
+                return f"Error: Invalid scope value '{value}'. Valid: project, global, auto"
+                
+        # Handle tool-specific settings
+        if "." in key:
+            tool, setting = key.split(".", 1)
+            if setting == "enabled":
+                enabled = value.lower() in ["true", "yes", "1", "on"]
+                self.index_config.set_indexing_enabled(tool, enabled)
+                return f"Set {key}={enabled}"
+                
+        return f"Unknown key: {key}"
+
+    async def _handle_list(self, scope: str, path: Optional[str], tool_ctx) -> str:
+        """List all configuration."""
+        status = self.index_config.get_status()
+        
+        output = ["=== Configuration ==="]
+        output.append(f"\nDefault scope: {status['default_scope']}")
+        
+        if path:
+            current_scope = self.index_config.get_scope(path)
+            output.append(f"Current path scope: {current_scope.value}")
+            
+        output.append(f"\nProjects with custom config: {status['project_count']}")
+        
+        output.append("\nTool settings:")
+        for tool, settings in status["tools"].items():
+            output.append(f"  {tool}:")
+            output.append(f"    enabled: {settings['enabled']}")
+            output.append(f"    per_project: {settings['per_project']}")
+            
+        return "\n".join(output)
+
+    async def _handle_toggle(self, key: Optional[str], scope: str, path: Optional[str], tool_ctx) -> str:
+        """Toggle configuration value."""
+        if not key:
+            return "Error: key required for toggle action"
+            
+        # Handle index scope toggle
+        if key == "index.scope":
+            new_scope = self.index_config.toggle_scope(path if scope == "local" else None)
+            return f"Toggled index.scope to {new_scope.value}"
+            
+        # Handle tool enable/disable toggle
+        if "." in key:
+            tool, setting = key.split(".", 1)
+            if setting == "enabled":
+                current = self.index_config.is_indexing_enabled(tool)
+                self.index_config.set_indexing_enabled(tool, not current)
+                return f"Toggled {key} to {not current}"
+                
+        return f"Cannot toggle key: {key}"
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/config/index_config.py

@@ -0,0 +1,176 @@
+"""Index configuration for per-project vs global indexing.
+
+This module manages indexing configuration for different scopes.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any, Optional
+from enum import Enum
+
+
+class IndexScope(Enum):
+    """Indexing scope options."""
+    PROJECT = "project"  # Per-project indexing
+    GLOBAL = "global"    # Global indexing
+    AUTO = "auto"        # Auto-detect based on git root
+
+
+class IndexConfig:
+    """Manages indexing configuration."""
+    
+    def __init__(self, config_dir: Optional[Path] = None):
+        """Initialize index configuration."""
+        self.config_dir = config_dir or Path.home() / ".hanzo" / "mcp"
+        self.config_file = self.config_dir / "index_config.json"
+        self._config = self._load_config()
+        
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from disk."""
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, "r") as f:
+                    return json.load(f)
+            except:
+                pass
+        
+        # Default configuration
+        return {
+            "default_scope": IndexScope.AUTO.value,
+            "project_configs": {},
+            "global_index_paths": [],
+            "index_settings": {
+                "vector": {
+                    "enabled": True,
+                    "auto_index": True,
+                    "include_git_history": True,
+                },
+                "symbols": {
+                    "enabled": True,
+                    "auto_index": False,
+                },
+                "sql": {
+                    "enabled": True,
+                    "per_project": True,
+                },
+                "graph": {
+                    "enabled": True,
+                    "per_project": True,
+                }
+            }
+        }
+    
+    def save_config(self) -> None:
+        """Save configuration to disk."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        with open(self.config_file, "w") as f:
+            json.dump(self._config, f, indent=2)
+    
+    def get_scope(self, path: Optional[str] = None) -> IndexScope:
+        """Get indexing scope for a path."""
+        if not path:
+            return IndexScope(self._config["default_scope"])
+            
+        # Check project-specific config
+        project_root = self._find_project_root(path)
+        if project_root:
+            project_config = self._config["project_configs"].get(str(project_root))
+            if project_config and "scope" in project_config:
+                return IndexScope(project_config["scope"])
+        
+        # Use default
+        scope = IndexScope(self._config["default_scope"])
+        
+        # Handle auto mode
+        if scope == IndexScope.AUTO:
+            if project_root:
+                return IndexScope.PROJECT
+            else:
+                return IndexScope.GLOBAL
+                
+        return scope
+    
+    def set_scope(self, scope: IndexScope, path: Optional[str] = None) -> None:
+        """Set indexing scope."""
+        if path:
+            # Set for specific project
+            project_root = self._find_project_root(path)
+            if project_root:
+                if str(project_root) not in self._config["project_configs"]:
+                    self._config["project_configs"][str(project_root)] = {}
+                self._config["project_configs"][str(project_root)]["scope"] = scope.value
+        else:
+            # Set global default
+            self._config["default_scope"] = scope.value
+            
+        self.save_config()
+    
+    def get_index_path(self, tool: str, path: Optional[str] = None) -> Path:
+        """Get index path for a tool and location."""
+        scope = self.get_scope(path)
+        
+        if scope == IndexScope.PROJECT and path:
+            project_root = self._find_project_root(path)
+            if project_root:
+                return Path(project_root) / ".hanzo" / "index" / tool
+        
+        # Global index
+        return self.config_dir / "index" / tool
+    
+    def is_indexing_enabled(self, tool: str) -> bool:
+        """Check if indexing is enabled for a tool."""
+        return self._config["index_settings"].get(tool, {}).get("enabled", True)
+    
+    def set_indexing_enabled(self, tool: str, enabled: bool) -> None:
+        """Enable/disable indexing for a tool."""
+        if tool not in self._config["index_settings"]:
+            self._config["index_settings"][tool] = {}
+        self._config["index_settings"][tool]["enabled"] = enabled
+        self.save_config()
+    
+    def toggle_scope(self, path: Optional[str] = None) -> IndexScope:
+        """Toggle between project and global scope."""
+        current = self.get_scope(path)
+        
+        if current == IndexScope.PROJECT:
+            new_scope = IndexScope.GLOBAL
+        elif current == IndexScope.GLOBAL:
+            new_scope = IndexScope.PROJECT
+        else:  # AUTO
+            # Determine what auto resolves to and toggle
+            if path and self._find_project_root(path):
+                new_scope = IndexScope.GLOBAL
+            else:
+                new_scope = IndexScope.PROJECT
+        
+        self.set_scope(new_scope, path)
+        return new_scope
+    
+    def _find_project_root(self, path: str) -> Optional[Path]:
+        """Find project root (git root or similar)."""
+        current = Path(path).resolve()
+        
+        # Walk up looking for markers
+        markers = [".git", ".hg", "pyproject.toml", "package.json", "Cargo.toml"]
+        
+        while current != current.parent:
+            for marker in markers:
+                if (current / marker).exists():
+                    return current
+            current = current.parent
+            
+        return None
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get current configuration status."""
+        return {
+            "default_scope": self._config["default_scope"],
+            "project_count": len(self._config["project_configs"]),
+            "tools": {
+                tool: {
+                    "enabled": settings.get("enabled", True),
+                    "per_project": settings.get("per_project", True),
+                }
+                for tool, settings in self._config["index_settings"].items()
+            }
+        }