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

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()
+            }
+        }

hanzo_mcp/tools/config/palette_tool.py

@@ -0,0 +1,166 @@
+"""Tool for managing development tool palettes."""
+
+from typing import Optional, override
+
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.palette import PaletteRegistry, register_default_palettes
+from mcp.server import FastMCP
+
+
+class PaletteTool(BaseTool):
+    """Tool for managing tool palettes."""
+    
+    name = "palette"
+    
+    def __init__(self):
+        """Initialize the palette tool."""
+        super().__init__()
+        # Register default palettes on initialization
+        register_default_palettes()
+    
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Manage tool palettes. Actions: list (default), activate, show, current.
+
+Usage:
+palette
+palette --action list
+palette --action activate python
+palette --action show javascript
+palette --action current"""
+    
+    @override
+    async def run(
+        self,
+        ctx: MCPContext,
+        action: str = "list",
+        name: Optional[str] = None,
+    ) -> str:
+        """Manage tool palettes.
+        
+        Args:
+            ctx: MCP context
+            action: Action to perform (list, activate, show, current)
+            name: Palette name (for activate/show actions)
+            
+        Returns:
+            Action result
+        """
+        if action == "list":
+            palettes = PaletteRegistry.list()
+            if not palettes:
+                return "No palettes registered"
+            
+            output = ["Available tool palettes:"]
+            active = PaletteRegistry.get_active()
+            
+            for palette in sorted(palettes, key=lambda p: p.name):
+                marker = " (active)" if active and active.name == palette.name else ""
+                author = f" by {palette.author}" if palette.author else ""
+                output.append(f"\n{palette.name}{marker}:")
+                output.append(f"  {palette.description}{author}")
+                output.append(f"  Tools: {len(palette.tools)} enabled")
+            
+            return "\n".join(output)
+        
+        elif action == "activate":
+            if not name:
+                return "Error: Palette name required for activate action"
+            
+            try:
+                PaletteRegistry.set_active(name)
+                palette = PaletteRegistry.get(name)
+                
+                output = [f"Activated palette: {palette.name}"]
+                if palette.author:
+                    output.append(f"Author: {palette.author}")
+                output.append(f"Description: {palette.description}")
+                output.append(f"\nEnabled tools ({len(palette.tools)}):")
+                
+                # Group tools by category
+                core_tools = []
+                package_tools = []
+                other_tools = []
+                
+                for tool in sorted(palette.tools):
+                    if tool in ["read", "write", "edit", "grep", "tree", "find", "bash"]:
+                        core_tools.append(tool)
+                    elif tool in ["npx", "uvx", "pip", "cargo", "gem"]:
+                        package_tools.append(tool)
+                    else:
+                        other_tools.append(tool)
+                
+                if core_tools:
+                    output.append(f"  Core: {', '.join(core_tools)}")
+                if package_tools:
+                    output.append(f"  Package managers: {', '.join(package_tools)}")
+                if other_tools:
+                    output.append(f"  Specialized: {', '.join(other_tools)}")
+                
+                if palette.environment:
+                    output.append("\nEnvironment variables:")
+                    for key, value in palette.environment.items():
+                        output.append(f"  {key}={value}")
+                
+                output.append("\nNote: Restart MCP session for changes to take full effect")
+                
+                return "\n".join(output)
+                
+            except ValueError as e:
+                return str(e)
+        
+        elif action == "show":
+            if not name:
+                return "Error: Palette name required for show action"
+            
+            palette = PaletteRegistry.get(name)
+            if not palette:
+                return f"Palette '{name}' not found"
+            
+            output = [f"Palette: {palette.name}"]
+            if palette.author:
+                output.append(f"Author: {palette.author}")
+            output.append(f"Description: {palette.description}")
+            output.append(f"\nTools ({len(palette.tools)}):")
+            
+            for tool in sorted(palette.tools):
+                output.append(f"  - {tool}")
+            
+            if palette.environment:
+                output.append("\nEnvironment:")
+                for key, value in palette.environment.items():
+                    output.append(f"  {key}={value}")
+            
+            return "\n".join(output)
+        
+        elif action == "current":
+            active = PaletteRegistry.get_active()
+            if not active:
+                return "No palette currently active\nUse 'palette --action activate <name>' to activate one"
+            
+            output = [f"Current palette: {active.name}"]
+            if active.author:
+                output.append(f"Author: {active.author}")
+            output.append(f"Description: {active.description}")
+            output.append(f"Enabled tools: {len(active.tools)}")
+            
+            return "\n".join(output)
+        
+        else:
+            return f"Unknown action: {action}. Use 'list', 'activate', 'show', or 'current'"
+
+    def register(self, server: FastMCP) -> None:
+        """Register the tool with the MCP server."""
+        server.tool(name=self.name, description=self.description)(self.call)
+    
+    async def call(self, **kwargs) -> str:
+        """Call the tool with arguments."""
+        return await self.run(None, **kwargs)
+
+
+# Create tool instance
+palette_tool = PaletteTool()

hanzo_mcp/tools/database/__init__.py

@@ -6,7 +6,7 @@ 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
+from mcp.server import FastMCP
 
 # Import database tools
 from .sql_query import SqlQueryTool