hanzo-mcp 0.5.0__py3-none-any.whl → 0.5.2__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.2"

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

@@ -14,13 +14,22 @@ from fastmcp import FastMCP
 from hanzo_mcp.tools.agent import register_agent_tools
 from hanzo_mcp.tools.common import register_batch_tool, register_thinking_tool
 from hanzo_mcp.tools.common.base import BaseTool
-
 from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
+from hanzo_mcp.tools.common.tool_disable import ToolDisableTool
+from hanzo_mcp.tools.common.tool_list import ToolListTool
+from hanzo_mcp.tools.common.stats import StatsTool
 from hanzo_mcp.tools.filesystem import register_filesystem_tools
 from hanzo_mcp.tools.jupyter import register_jupyter_tools
 from hanzo_mcp.tools.shell import register_shell_tools
 from hanzo_mcp.tools.todo import register_todo_tools
 from hanzo_mcp.tools.vector import register_vector_tools
+from hanzo_mcp.tools.database import register_database_tools, DatabaseManager
+from hanzo_mcp.tools.mcp.mcp_add import McpAddTool
+from hanzo_mcp.tools.mcp.mcp_remove import McpRemoveTool
+from hanzo_mcp.tools.mcp.mcp_stats import McpStatsTool
+from hanzo_mcp.tools.editor import NeovimEditTool, NeovimCommandTool, NeovimSessionTool
+from hanzo_mcp.tools.llm import LLMTool, ConsensusTool, LLMManageTool, create_provider_tools
 
 
 def register_all_tools(
@@ -76,13 +85,38 @@ def register_all_tools(
         "directory_tree": is_tool_enabled("directory_tree", True),
         "grep": is_tool_enabled("grep", not disable_search_tools),
         "grep_ast": is_tool_enabled("grep_ast", not disable_search_tools),
+        "git_search": is_tool_enabled("git_search", not disable_search_tools),
         "content_replace": is_tool_enabled("content_replace", not disable_write_tools),
+        "batch_search": is_tool_enabled("batch_search", not disable_search_tools),
+        "find_files": is_tool_enabled("find_files", True),
+    }
+    
+    # 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 batch_search are enabled
+    if any(vector_enabled.values()) or filesystem_enabled.get("batch_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 +171,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
@@ -160,3 +186,123 @@ def register_all_tools(
     # Register batch tool if enabled (batch tool is typically always enabled)
     if is_tool_enabled("batch", True):
         register_batch_tool(mcp_server, all_tools)
+    
+    # Register database tools if enabled
+    db_manager = None
+    database_enabled = {
+        "sql_query": is_tool_enabled("sql_query", True),
+        "sql_search": is_tool_enabled("sql_search", True),
+        "sql_stats": is_tool_enabled("sql_stats", True),
+        "graph_add": is_tool_enabled("graph_add", True),
+        "graph_remove": is_tool_enabled("graph_remove", True),
+        "graph_query": is_tool_enabled("graph_query", True),
+        "graph_search": is_tool_enabled("graph_search", True),
+        "graph_stats": is_tool_enabled("graph_stats", True),
+    }
+    
+    if any(database_enabled.values()):
+        db_manager = DatabaseManager(permission_manager)
+        database_tools = register_database_tools(
+            mcp_server,
+            permission_manager,
+            db_manager=db_manager,
+        )
+        # Filter based on enabled state
+        for tool in database_tools:
+            if database_enabled.get(tool.name, True):
+                all_tools[tool.name] = tool
+    
+    # Register MCP management tools if enabled
+    mcp_enabled = {
+        "mcp_add": is_tool_enabled("mcp_add", True),
+        "mcp_remove": is_tool_enabled("mcp_remove", True),
+        "mcp_stats": is_tool_enabled("mcp_stats", True),
+    }
+    
+    if mcp_enabled.get("mcp_add", True):
+        tool = McpAddTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if mcp_enabled.get("mcp_remove", True):
+        tool = McpRemoveTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if mcp_enabled.get("mcp_stats", True):
+        tool = McpStatsTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register system tools (always enabled)
+    # Tool enable/disable tools
+    tool_enable = ToolEnableTool()
+    tool_enable.register(mcp_server)
+    all_tools[tool_enable.name] = tool_enable
+    
+    tool_disable = ToolDisableTool()
+    tool_disable.register(mcp_server)
+    all_tools[tool_disable.name] = tool_disable
+    
+    tool_list = ToolListTool()
+    tool_list.register(mcp_server)
+    all_tools[tool_list.name] = tool_list
+    
+    # Stats tool
+    stats_tool = StatsTool(db_manager=db_manager)
+    stats_tool.register(mcp_server)
+    all_tools[stats_tool.name] = stats_tool
+    
+    # Register editor tools if enabled
+    editor_enabled = {
+        "neovim_edit": is_tool_enabled("neovim_edit", True),
+        "neovim_command": is_tool_enabled("neovim_command", True),
+        "neovim_session": is_tool_enabled("neovim_session", True),
+    }
+    
+    if editor_enabled.get("neovim_edit", True):
+        tool = NeovimEditTool(permission_manager)
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if editor_enabled.get("neovim_command", True):
+        tool = NeovimCommandTool(permission_manager)
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    if editor_enabled.get("neovim_session", True):
+        tool = NeovimSessionTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register LLM tools if enabled
+    llm_enabled = {
+        "llm": is_tool_enabled("llm", True),
+        "consensus": is_tool_enabled("consensus", True),
+        "llm_manage": is_tool_enabled("llm_manage", True),
+    }
+    
+    if llm_enabled.get("llm", True):
+        tool = LLMTool()
+        if tool.available_providers:  # Only register if API keys found
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+    
+    if llm_enabled.get("consensus", True):
+        tool = ConsensusTool()
+        if tool.llm_tool.available_providers:  # Only register if API keys found
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool
+    
+    if llm_enabled.get("llm_manage", True):
+        tool = LLMManageTool()
+        tool.register(mcp_server)
+        all_tools[tool.name] = tool
+    
+    # Register provider-specific LLM tools
+    # These are only registered if their API keys are available
+    provider_tools = create_provider_tools()
+    for tool in provider_tools:
+        if is_tool_enabled(tool.name, True):
+            tool.register(mcp_server)
+            all_tools[tool.name] = tool

hanzo_mcp/tools/common/base.py

@@ -170,8 +170,13 @@ class ToolRegistry:
             mcp_server: The FastMCP server instance
             tool: The tool to register
         """
-        # Use the tool's register method which handles all the details
-        tool.register(mcp_server)
+        # Check if tool is enabled before registering
+        # Import here to avoid circular imports
+        from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
+        
+        if ToolEnableTool.is_tool_enabled(tool.name):
+            # Use the tool's register method which handles all the details
+            tool.register(mcp_server)
 
     @staticmethod
     def register_tools(mcp_server: FastMCP, tools: list[BaseTool]) -> None: