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

hanzo_mcp/__init__.py

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

hanzo_mcp/config/settings.py

@@ -280,6 +280,67 @@ def get_project_config_path(project_dir: Optional[str] = None) -> Optional[Path]
     return None
 
 
+def ensure_project_hanzo_dir(project_dir: str) -> Path:
+    """Ensure .hanzo directory exists in project and return its path."""
+    project_path = Path(project_dir)
+    hanzo_dir = project_path / ".hanzo"
+    hanzo_dir.mkdir(exist_ok=True)
+    
+    # Create default structure
+    (hanzo_dir / "db").mkdir(exist_ok=True)  # Vector database
+    
+    # Create default project config if it doesn't exist
+    config_path = hanzo_dir / "mcp-settings.json"
+    if not config_path.exists():
+        default_project_config = {
+            "name": project_path.name,
+            "root_path": str(project_path),
+            "rules": [
+                "Follow project-specific coding standards",
+                "Test all changes before committing",
+                "Update documentation for new features"
+            ],
+            "workflows": {
+                "development": {
+                    "steps": ["edit", "test", "commit"],
+                    "tools": ["read", "write", "edit", "run_command"]
+                },
+                "documentation": {
+                    "steps": ["read", "analyze", "write"],
+                    "tools": ["read", "write", "vector_search"]
+                }
+            },
+            "tasks": [],
+            "enabled_tools": {},
+            "disabled_tools": [],
+            "mcp_servers": []
+        }
+        
+        with open(config_path, 'w') as f:
+            json.dump(default_project_config, f, indent=2)
+    
+    return hanzo_dir
+
+
+def detect_project_from_path(file_path: str) -> Optional[Dict[str, str]]:
+    """Detect project information from a file path by looking for LLM.md."""
+    path = Path(file_path).resolve()
+    current_path = path.parent if path.is_file() else path
+    
+    while current_path != current_path.parent:  # Stop at filesystem root
+        llm_md_path = current_path / "LLM.md"
+        if llm_md_path.exists():
+            return {
+                "name": current_path.name,
+                "root_path": str(current_path),
+                "llm_md_path": str(llm_md_path),
+                "hanzo_dir": str(ensure_project_hanzo_dir(str(current_path)))
+            }
+        current_path = current_path.parent
+    
+    return None
+
+
 def load_settings(
     project_dir: Optional[str] = None,
     config_overrides: Optional[Dict[str, Any]] = None

hanzo_mcp/tools/__init__.py

@@ -77,12 +77,35 @@ def register_all_tools(
         "grep": is_tool_enabled("grep", not disable_search_tools),
         "grep_ast": is_tool_enabled("grep_ast", 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),
     }
     
+    # Vector tools setup (needed for unified search)
+    project_manager = None
+    vector_enabled = {
+        "vector_index": is_tool_enabled("vector_index", False),
+        "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):
+        if vector_config:
+            from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
+            search_paths = [str(path) for path in permission_manager.allowed_paths]
+            project_manager = ProjectVectorManager(
+                global_db_path=vector_config.get("data_path"),
+                embedding_model=vector_config.get("embedding_model", "text-embedding-3-small"),
+                dimension=vector_config.get("dimension", 1536),
+            )
+            # Auto-detect projects from search paths
+            detected_projects = project_manager.detect_projects(search_paths)
+            print(f"Detected {len(detected_projects)} projects with LLM.md files")
+    
     filesystem_tools = register_filesystem_tools(
         mcp_server, 
         permission_manager, 
         enabled_tools=filesystem_enabled,
+        project_manager=project_manager,
     )
     for tool in filesystem_tools:
         all_tools[tool.name] = tool
@@ -137,22 +160,14 @@ def register_all_tools(
         for tool in thinking_tool:
             all_tools[tool.name] = tool
 
-    # Register vector tools if enabled
-    vector_enabled = {
-        "vector_index": is_tool_enabled("vector_index", False),
-        "vector_search": is_tool_enabled("vector_search", False),
-    }
-    
-    if any(vector_enabled.values()) and vector_config:
-        # Get allowed paths for project detection
-        search_paths = [str(path) for path in permission_manager.allowed_paths]
-        
+    # Register vector tools if enabled (reuse project_manager if available)
+    if any(vector_enabled.values()) and project_manager:
         vector_tools = register_vector_tools(
             mcp_server, 
             permission_manager, 
             vector_config=vector_config,
             enabled_tools=vector_enabled,
-            search_paths=search_paths,
+            project_manager=project_manager,
         )
         for tool in vector_tools:
             all_tools[tool.name] = tool

hanzo_mcp/tools/common/config_tool.py

@@ -0,0 +1,396 @@
+"""Configuration management tool for dynamic settings updates."""
+
+from typing import Dict, List, Optional, TypedDict, Unpack, Any, final
+import json
+from pathlib import Path
+
+from fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.config.settings import (
+    HanzoMCPSettings, 
+    MCPServerConfig, 
+    ProjectConfig, 
+    load_settings, 
+    save_settings,
+    detect_project_from_path,
+    ensure_project_hanzo_dir
+)
+
+
+class ConfigToolParams(TypedDict, total=False):
+    """Parameters for configuration management operations."""
+    
+    action: str  # get, set, add_server, remove_server, add_project, etc.
+    scope: Optional[str]  # global, project, current
+    setting_path: Optional[str]  # dot-notation path like "agent.enabled" 
+    value: Optional[Any]  # new value to set
+    server_name: Optional[str]  # for MCP server operations
+    server_config: Optional[Dict[str, Any]]  # for adding servers
+    project_name: Optional[str]  # for project operations
+    project_path: Optional[str]  # for project path detection
+
+
+@final
+class ConfigTool(BaseTool):
+    """Tool for managing Hanzo MCP configuration dynamically."""
+    
+    def __init__(self, permission_manager: PermissionManager):
+        """Initialize the configuration tool.
+        
+        Args:
+            permission_manager: Permission manager for access control
+        """
+        self.permission_manager = permission_manager
+    
+    @property
+    def name(self) -> str:
+        """Get the tool name."""
+        return "config"
+    
+    @property
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Dynamically manage Hanzo MCP configuration settings through conversation.
+
+Can get/set global settings, project-specific settings, manage MCP servers, configure tools,
+and handle project workflows. Supports dot-notation for nested settings like 'agent.enabled'.
+
+Perfect for AI-driven configuration where users can say things like:
+- "Enable the agent tool for this project"  
+- "Add a new MCP server for file operations"
+- "Disable write tools globally but enable them for the current project"
+- "Show me the current project configuration"
+
+Automatically detects projects based on LLM.md files and manages .hanzo/ directories."""
+    
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[ConfigToolParams],
+    ) -> str:
+        """Manage configuration settings.
+        
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+            
+        Returns:
+            Configuration operation result
+        """
+        action = params.get("action", "get")
+        scope = params.get("scope", "global")
+        setting_path = params.get("setting_path")
+        value = params.get("value")
+        server_name = params.get("server_name")
+        server_config = params.get("server_config")
+        project_name = params.get("project_name")
+        project_path = params.get("project_path")
+        
+        try:
+            if action == "get":
+                return await self._get_config(scope, setting_path, project_name, project_path)
+            elif action == "set":
+                return await self._set_config(scope, setting_path, value, project_name, project_path)
+            elif action == "add_server":
+                return await self._add_mcp_server(server_name, server_config, scope, project_name)
+            elif action == "remove_server":
+                return await self._remove_mcp_server(server_name, scope, project_name)
+            elif action == "enable_server":
+                return await self._enable_mcp_server(server_name, scope, project_name)
+            elif action == "disable_server":
+                return await self._disable_mcp_server(server_name, scope, project_name)
+            elif action == "trust_server":
+                return await self._trust_mcp_server(server_name)
+            elif action == "add_project":
+                return await self._add_project(project_name, project_path)
+            elif action == "set_current_project":
+                return await self._set_current_project(project_name, project_path)
+            elif action == "list_servers":
+                return await self._list_mcp_servers(scope, project_name)
+            elif action == "list_projects":
+                return await self._list_projects()
+            elif action == "detect_project":
+                return await self._detect_project(project_path)
+            else:
+                return f"Error: Unknown action '{action}'. Available actions: get, set, add_server, remove_server, enable_server, disable_server, trust_server, add_project, set_current_project, list_servers, list_projects, detect_project"
+                
+        except Exception as e:
+            return f"Error managing configuration: {str(e)}"
+    
+    async def _get_config(self, scope: str, setting_path: Optional[str], project_name: Optional[str], project_path: Optional[str]) -> str:
+        """Get configuration value(s)."""
+        # Load appropriate settings
+        if scope == "project" or project_name or project_path:
+            if project_path:
+                project_info = detect_project_from_path(project_path)
+                if project_info:
+                    settings = load_settings(project_info["root_path"])
+                else:
+                    return f"No project detected at path: {project_path}"
+            else:
+                settings = load_settings()
+        else:
+            settings = load_settings()
+        
+        if not setting_path:
+            # Return full config summary
+            if scope == "project" and settings.current_project:
+                project = settings.get_current_project()
+                if project:
+                    return f"Current Project Configuration ({project.name}):\\n{json.dumps(project.__dict__, indent=2)}"
+            
+            # Return global config summary
+            summary = {
+                "server": settings.server.__dict__,
+                "enabled_tools": settings.get_enabled_tools(),
+                "disabled_tools": settings.get_disabled_tools(),
+                "agent": settings.agent.__dict__,
+                "vector_store": settings.vector_store.__dict__,
+                "hub_enabled": settings.hub_enabled,
+                "mcp_servers": {name: server.__dict__ for name, server in settings.mcp_servers.items()},
+                "current_project": settings.current_project,
+                "projects": list(settings.projects.keys()),
+            }
+            return f"Configuration Summary:\\n{json.dumps(summary, indent=2)}"
+        
+        # Get specific setting
+        value = self._get_nested_value(settings.__dict__, setting_path)
+        if value is not None:
+            return f"{setting_path}: {json.dumps(value, indent=2)}"
+        else:
+            return f"Setting '{setting_path}' not found"
+    
+    async def _set_config(self, scope: str, setting_path: Optional[str], value: Any, project_name: Optional[str], project_path: Optional[str]) -> str:
+        """Set configuration value."""
+        if not setting_path:
+            return "Error: setting_path is required for set action"
+        
+        # Load settings
+        project_dir = None
+        if scope == "project" or project_name or project_path:
+            if project_path:
+                project_info = detect_project_from_path(project_path)
+                if project_info:
+                    project_dir = project_info["root_path"]
+                else:
+                    return f"No project detected at path: {project_path}"
+        
+        settings = load_settings(project_dir)
+        
+        # Set the value
+        if self._set_nested_value(settings.__dict__, setting_path, value):
+            # Save settings
+            if scope == "project" or project_dir:
+                save_settings(settings, global_config=False)
+            else:
+                save_settings(settings, global_config=True)
+            return f"Successfully set {setting_path} = {json.dumps(value)}"
+        else:
+            return f"Error: Could not set '{setting_path}'"
+    
+    async def _add_mcp_server(self, server_name: Optional[str], server_config: Optional[Dict[str, Any]], scope: str, project_name: Optional[str]) -> str:
+        """Add a new MCP server."""
+        if not server_name or not server_config:
+            return "Error: server_name and server_config are required"
+        
+        settings = load_settings()
+        
+        # Create server config
+        mcp_server = MCPServerConfig(
+            name=server_name,
+            command=server_config.get("command", ""),
+            args=server_config.get("args", []),
+            enabled=server_config.get("enabled", True),
+            trusted=server_config.get("trusted", False),
+            description=server_config.get("description", ""),
+            capabilities=server_config.get("capabilities", []),
+        )
+        
+        if settings.add_mcp_server(mcp_server):
+            save_settings(settings)
+            return f"Successfully added MCP server '{server_name}'"
+        else:
+            return f"Error: MCP server '{server_name}' already exists"
+    
+    async def _remove_mcp_server(self, server_name: Optional[str], scope: str, project_name: Optional[str]) -> str:
+        """Remove an MCP server."""
+        if not server_name:
+            return "Error: server_name is required"
+        
+        settings = load_settings()
+        
+        if settings.remove_mcp_server(server_name):
+            save_settings(settings)
+            return f"Successfully removed MCP server '{server_name}'"
+        else:
+            return f"Error: MCP server '{server_name}' not found"
+    
+    async def _enable_mcp_server(self, server_name: Optional[str], scope: str, project_name: Optional[str]) -> str:
+        """Enable an MCP server."""
+        if not server_name:
+            return "Error: server_name is required"
+        
+        settings = load_settings()
+        
+        if settings.enable_mcp_server(server_name):
+            save_settings(settings)
+            return f"Successfully enabled MCP server '{server_name}'"
+        else:
+            return f"Error: MCP server '{server_name}' not found"
+    
+    async def _disable_mcp_server(self, server_name: Optional[str], scope: str, project_name: Optional[str]) -> str:
+        """Disable an MCP server."""
+        if not server_name:
+            return "Error: server_name is required"
+        
+        settings = load_settings()
+        
+        if settings.disable_mcp_server(server_name):
+            save_settings(settings)
+            return f"Successfully disabled MCP server '{server_name}'"
+        else:
+            return f"Error: MCP server '{server_name}' not found"
+    
+    async def _trust_mcp_server(self, server_name: Optional[str]) -> str:
+        """Trust an MCP server."""
+        if not server_name:
+            return "Error: server_name is required"
+        
+        settings = load_settings()
+        
+        if settings.trust_mcp_server(server_name):
+            save_settings(settings)
+            return f"Successfully trusted MCP server '{server_name}'"
+        else:
+            return f"Error: MCP server '{server_name}' not found"
+    
+    async def _add_project(self, project_name: Optional[str], project_path: Optional[str]) -> str:
+        """Add a project configuration."""
+        if not project_path:
+            return "Error: project_path is required"
+        
+        # Detect or create project
+        project_info = detect_project_from_path(project_path)
+        if not project_info:
+            return f"No LLM.md found in project path: {project_path}"
+        
+        if not project_name:
+            project_name = project_info["name"]
+        
+        settings = load_settings()
+        
+        project_config = ProjectConfig(
+            name=project_name,
+            root_path=project_info["root_path"],
+        )
+        
+        if settings.add_project(project_config):
+            save_settings(settings)
+            return f"Successfully added project '{project_name}' at {project_info['root_path']}"
+        else:
+            return f"Error: Project '{project_name}' already exists"
+    
+    async def _set_current_project(self, project_name: Optional[str], project_path: Optional[str]) -> str:
+        """Set the current active project."""
+        settings = load_settings()
+        
+        if project_path:
+            project_info = detect_project_from_path(project_path)
+            if project_info:
+                project_name = project_info["name"]
+                # Auto-add project if not exists
+                if project_name not in settings.projects:
+                    await self._add_project(project_name, project_path)
+                    settings = load_settings()  # Reload after adding
+        
+        if not project_name:
+            return "Error: project_name or project_path is required"
+        
+        if settings.set_current_project(project_name):
+            save_settings(settings)
+            return f"Successfully set current project to '{project_name}'"
+        else:
+            return f"Error: Project '{project_name}' not found"
+    
+    async def _list_mcp_servers(self, scope: str, project_name: Optional[str]) -> str:
+        """List MCP servers."""
+        settings = load_settings()
+        
+        if not settings.mcp_servers:
+            return "No MCP servers configured"
+        
+        servers_info = []
+        for name, server in settings.mcp_servers.items():
+            status = "enabled" if server.enabled else "disabled"
+            trust = "trusted" if server.trusted else "untrusted"
+            servers_info.append(f"- {name}: {server.command} ({status}, {trust})")
+        
+        return f"MCP Servers:\\n" + "\\n".join(servers_info)
+    
+    async def _list_projects(self) -> str:
+        """List projects."""
+        settings = load_settings()
+        
+        if not settings.projects:
+            return "No projects configured"
+        
+        projects_info = []
+        for name, project in settings.projects.items():
+            current = " (current)" if name == settings.current_project else ""
+            projects_info.append(f"- {name}: {project.root_path}{current}")
+        
+        return f"Projects:\\n" + "\\n".join(projects_info)
+    
+    async def _detect_project(self, project_path: Optional[str]) -> str:
+        """Detect project from path."""
+        if not project_path:
+            import os
+            project_path = os.getcwd()
+        
+        project_info = detect_project_from_path(project_path)
+        if project_info:
+            return f"Project detected:\\n{json.dumps(project_info, indent=2)}"
+        else:
+            return f"No project detected at path: {project_path}"
+    
+    def _get_nested_value(self, obj: Dict[str, Any], path: str) -> Any:
+        """Get nested value using dot notation."""
+        keys = path.split(".")
+        current = obj
+        
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            elif hasattr(current, key):
+                current = getattr(current, key)
+            else:
+                return None
+        
+        return current
+    
+    def _set_nested_value(self, obj: Dict[str, Any], path: str, value: Any) -> bool:
+        """Set nested value using dot notation."""
+        keys = path.split(".")
+        current = obj
+        
+        # Navigate to parent
+        for key in keys[:-1]:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            elif hasattr(current, key):
+                current = getattr(current, key)
+            else:
+                return False
+        
+        # Set final value
+        final_key = keys[-1]
+        if isinstance(current, dict):
+            current[final_key] = value
+            return True
+        elif hasattr(current, final_key):
+            setattr(current, final_key, value)
+            return True
+        
+        return False

hanzo_mcp/tools/filesystem/__init__.py

@@ -17,6 +17,7 @@ from hanzo_mcp.tools.filesystem.grep_ast_tool import GrepAstTool
 from hanzo_mcp.tools.filesystem.multi_edit import MultiEdit
 from hanzo_mcp.tools.filesystem.read import ReadTool
 from hanzo_mcp.tools.filesystem.write import Write
+from hanzo_mcp.tools.filesystem.unified_search import UnifiedSearchTool
 
 # Export all tool classes
 __all__ = [
@@ -28,6 +29,7 @@ __all__ = [
     "Grep",
     "ContentReplaceTool",
     "GrepAstTool",
+    "UnifiedSearchTool",
     "get_filesystem_tools",
     "register_filesystem_tools",
 ]
@@ -79,6 +81,7 @@ def register_filesystem_tools(
     disable_write_tools: bool = False,
     disable_search_tools: bool = False,
     enabled_tools: dict[str, bool] | None = None,
+    project_manager=None,
 ) -> list[BaseTool]:
     """Register filesystem tools with the MCP server.
 
@@ -88,6 +91,7 @@ def register_filesystem_tools(
         disable_write_tools: Whether to disable write tools (default: False)
         disable_search_tools: Whether to disable search tools (default: False)
         enabled_tools: Dictionary of individual tool enable states (default: None)
+        project_manager: Optional project manager for unified search (default: None)
 
     Returns:
         List of registered tools
@@ -102,6 +106,7 @@ def register_filesystem_tools(
         "grep": Grep,
         "grep_ast": GrepAstTool,
         "content_replace": ContentReplaceTool,
+        "unified_search": UnifiedSearchTool,
     }
     
     tools = []
@@ -111,7 +116,11 @@ def register_filesystem_tools(
         for tool_name, enabled in enabled_tools.items():
             if enabled and tool_name in tool_classes:
                 tool_class = tool_classes[tool_name]
-                tools.append(tool_class(permission_manager))
+                if tool_name == "unified_search":
+                    # Unified search requires project_manager
+                    tools.append(tool_class(permission_manager, project_manager))
+                else:
+                    tools.append(tool_class(permission_manager))
     else:
         # Use category-level configuration (backward compatibility)
         if disable_write_tools and disable_search_tools: