hanzo-mcp 0.8.8__py3-none-any.whl → 0.9.0__py3-none-any.whl

hanzo_mcp/tools/shell/run_command_windows.py

@@ -20,9 +20,7 @@ from hanzo_mcp.tools.shell.command_executor import CommandExecutor
 class RunCommandTool(ShellBaseTool):
     """Tool for executing shell commands."""
 
-    def __init__(
-        self, permission_manager: Any, command_executor: CommandExecutor
-    ) -> None:
+    def __init__(self, permission_manager: Any, command_executor: CommandExecutor) -> None:
         """Initialize the run command tool.
 
         Args:

hanzo_mcp/tools/shell/run_tool.py

@@ -0,0 +1,56 @@
+"""Run tool for command execution with automatic backgrounding."""
+
+from typing import Optional, override
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.shell.zsh_tool import ShellTool
+
+
+class RunTool(ShellTool):
+    """Tool for running commands with automatic backgrounding (alias of shell tool)."""
+
+    name = "run"
+
+    def register(self, server: FastMCP) -> None:
+        """Register the tool with the MCP server."""
+        tool_self = self
+
+        @server.tool(name=self.name, description=self.description)
+        async def run(
+            ctx: MCPContext,
+            command: str,
+            cwd: Optional[str] = None,
+            env: Optional[dict[str, str]] = None,
+            timeout: Optional[int] = None,
+        ) -> str:
+            return await tool_self.run(ctx, command=command, cwd=cwd, env=env, timeout=timeout)
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Execute shell commands with automatic backgrounding for long-running processes.
+
+Automatically selects the best available shell:
+- Zsh if available (with .zshrc)
+- User's preferred shell ($SHELL)  
+- Bash as fallback
+
+Commands that run for more than 2 minutes will automatically continue in the background.
+You can check their status and logs using the 'process' tool.
+
+Usage:
+run "ls -la"
+run "python server.py"  # Auto-backgrounds after 2 minutes
+run "git status && git diff"
+run "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
+
+    @override
+    def get_tool_name(self) -> str:
+        """Get the tool name."""
+        return "run"
+
+
+# Create instance
+run_tool = RunTool()

hanzo_mcp/tools/shell/session_manager.py

@@ -24,9 +24,7 @@ class SessionManager:
     _instance: Self | None = None
     _lock = threading.Lock()
 
-    def __new__(
-        cls, use_singleton: bool = True, session_storage: SessionStorage | None = None
-    ) -> "SessionManager":
+    def __new__(cls, use_singleton: bool = True, session_storage: SessionStorage | None = None) -> "SessionManager":
         """Create SessionManager instance.
 
         Args:
@@ -45,9 +43,7 @@ class SessionManager:
                     cls._instance._initialized = False
         return cls._instance
 
-    def __init__(
-        self, use_singleton: bool = True, session_storage: SessionStorage | None = None
-    ) -> None:
+    def __init__(self, use_singleton: bool = True, session_storage: SessionStorage | None = None) -> None:
         """Initialize the session manager.
 
         Args:

hanzo_mcp/tools/shell/session_storage.py

@@ -152,9 +152,7 @@ class SessionStorageInstance:
         Returns:
             Number of sessions cleaned up
         """
-        max_age = (
-            max_age_seconds if max_age_seconds is not None else self.default_ttl_seconds
-        )
+        max_age = max_age_seconds if max_age_seconds is not None else self.default_ttl_seconds
         current_time = time.time()
         expired_sessions: list[str] = []
 
@@ -201,9 +199,7 @@ class SessionStorageInstance:
         return {
             "total_sessions": len(self._sessions),
             "max_sessions": self.max_sessions,
-            "utilization": (
-                len(self._sessions) / self.max_sessions if self.max_sessions > 0 else 0
-            ),
+            "utilization": (len(self._sessions) / self.max_sessions if self.max_sessions > 0 else 0),
             "default_ttl_seconds": self.default_ttl_seconds,
         }
 

hanzo_mcp/tools/shell/streaming_command.py

@@ -117,9 +117,7 @@ class StreamingCommandTool(BaseProcessTool):
                 try:
                     with open(meta_file, "r") as f:
                         meta = json.load(f)
-                    last_accessed = datetime.fromisoformat(
-                        meta.get("last_accessed", "")
-                    )
+                    last_accessed = datetime.fromisoformat(meta.get("last_accessed", ""))
                     if last_accessed < cutoff:
                         shutil.rmtree(session_dir)
                 except Exception:
@@ -240,9 +238,7 @@ class StreamingCommandTool(BaseProcessTool):
             }
 
         # Execute new command
-        return await self._execute_new_command(
-            command, working_dir, timeout, chunk_size
-        )
+        return await self._execute_new_command(command, working_dir, timeout, chunk_size)
 
     async def _execute_new_command(
         self,
@@ -296,18 +292,12 @@ class StreamingCommandTool(BaseProcessTool):
                         f.flush()  # Ensure immediate write
 
             # Start streaming tasks
-            stdout_task = asyncio.create_task(
-                stream_to_file(process.stdout, output_file)
-            )
-            stderr_task = asyncio.create_task(
-                stream_to_file(process.stderr, error_file)
-            )
+            stdout_task = asyncio.create_task(stream_to_file(process.stdout, output_file))
+            stderr_task = asyncio.create_task(stream_to_file(process.stderr, error_file))
 
             # Wait for initial output or timeout
             start_time = time.time()
-            initial_timeout = min(
-                timeout or 5, 5
-            )  # Wait max 5 seconds for initial output
+            initial_timeout = min(timeout or 5, 5)  # Wait max 5 seconds for initial output
 
             while time.time() - start_time < initial_timeout:
                 if output_file.stat().st_size > 0 or error_file.stat().st_size > 0:
@@ -487,9 +477,7 @@ class StreamingCommandTool(BaseProcessTool):
         """Get list of recent commands for hints."""
         commands = []
 
-        for cmd_dir in sorted(
-            self.commands_dir.iterdir(), key=lambda p: p.stat().st_mtime, reverse=True
-        )[:limit]:
+        for cmd_dir in sorted(self.commands_dir.iterdir(), key=lambda p: p.stat().st_mtime, reverse=True)[:limit]:
             try:
                 with open(cmd_dir / "metadata.json", "r") as f:
                     meta = json.load(f)
@@ -502,11 +490,7 @@ class StreamingCommandTool(BaseProcessTool):
                 commands.append(
                     {
                         "id": meta["command_id"][:8],
-                        "command": (
-                            meta["command"][:50] + "..."
-                            if len(meta["command"]) > 50
-                            else meta["command"]
-                        ),
+                        "command": (meta["command"][:50] + "..." if len(meta["command"]) > 50 else meta["command"]),
                         "status": meta.get("status", "unknown"),
                         "output_size": output_size,
                         "time": meta.get("start_time", ""),

hanzo_mcp/tools/shell/uvx.py

@@ -135,9 +135,7 @@ For long-running servers, use uvx_background instead.
 
             try:
                 # Run installation
-                install_result = subprocess.run(
-                    install_cmd, shell=True, capture_output=True, text=True, timeout=60
-                )
+                install_result = subprocess.run(install_cmd, shell=True, capture_output=True, text=True, timeout=60)
 
                 if install_result.returncode == 0:
                     await tool_ctx.info("uvx installed successfully!")
@@ -146,9 +144,7 @@ For long-running servers, use uvx_background instead.
                     import os
 
                     home = os.path.expanduser("~")
-                    os.environ["PATH"] = (
-                        f"{home}/.cargo/bin:{os.environ.get('PATH', '')}"
-                    )
+                    os.environ["PATH"] = f"{home}/.cargo/bin:{os.environ.get('PATH', '')}"
 
                     # Check again
                     if not shutil.which("uvx"):
@@ -197,9 +193,7 @@ curl -LsSf https://astral.sh/uv/install.sh | sh"""
 
         try:
             # Execute command
-            result = subprocess.run(
-                cmd, capture_output=True, text=True, timeout=timeout, check=True
-            )
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, check=True)
 
             output = []
             if result.stdout:
@@ -207,11 +201,7 @@ curl -LsSf https://astral.sh/uv/install.sh | sh"""
             if result.stderr:
                 output.append(f"\nSTDERR:\n{result.stderr}")
 
-            return (
-                "\n".join(output)
-                if output
-                else "Command completed successfully with no output."
-            )
+            return "\n".join(output) if output else "Command completed successfully with no output."
 
         except subprocess.TimeoutExpired:
             return f"Error: Command timed out after {timeout} seconds. Use uvx_background for long-running processes."

hanzo_mcp/tools/shell/uvx_background.py

@@ -156,9 +156,7 @@ Use 'processes' to list running processes and 'pkill' to stop them.
 
             try:
                 # Run installation
-                install_result = subprocess.run(
-                    install_cmd, shell=True, capture_output=True, text=True, timeout=60
-                )
+                install_result = subprocess.run(install_cmd, shell=True, capture_output=True, text=True, timeout=60)
 
                 if install_result.returncode == 0:
                     await tool_ctx.info("uvx installed successfully!")
@@ -167,9 +165,7 @@ Use 'processes' to list running processes and 'pkill' to stop them.
                     import os
 
                     home = os.path.expanduser("~")
-                    os.environ["PATH"] = (
-                        f"{home}/.cargo/bin:{os.environ.get('PATH', '')}"
-                    )
+                    os.environ["PATH"] = f"{home}/.cargo/bin:{os.environ.get('PATH', '')}"
 
                     # Check again
                     if not shutil.which("uvx"):

hanzo_mcp/tools/shell/uvx_tool.py

@@ -86,9 +86,7 @@ uvx jupyter lab --port 8888  # Auto-backgrounds if needed"""
             cwd: Optional[str] = None,
             python: Optional[str] = None,
         ) -> str:
-            return await tool_self.run(
-                ctx, package=package, args=args, cwd=cwd, python=python
-            )
+            return await tool_self.run(ctx, package=package, args=args, cwd=cwd, python=python)
 
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""

hanzo_mcp/tools/shell/zsh_tool.py

@@ -29,9 +29,7 @@ class ZshTool(BaseScriptTool):
             env: Optional[dict[str, str]] = None,
             timeout: Optional[int] = None,
         ) -> str:
-            return await tool_self.run(
-                ctx, command=command, cwd=cwd, env=env, timeout=timeout
-            )
+            return await tool_self.run(ctx, command=command, cwd=cwd, env=env, timeout=timeout)
 
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
@@ -79,12 +77,12 @@ zsh "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
                     return path
             # Fall back to bash if no zsh found
             return "bash"
-        
+
         # On Unix-like systems, check for zsh
         zsh_path = shutil.which("zsh")
         if zsh_path:
             return zsh_path
-        
+
         # Fall back to bash if zsh not found
         return "bash"
 
@@ -124,14 +122,12 @@ zsh "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
         # Check if zsh is available
         if not shutil.which("zsh") and platform.system() != "Windows":
             return "Error: Zsh is not installed. Please install zsh first."
-        
+
         # Prepare working directory
         work_dir = Path(cwd).resolve() if cwd else Path.cwd()
 
         # Use execute_sync which has auto-backgrounding
-        output = await self.execute_sync(
-            command, cwd=work_dir, env=env, timeout=timeout
-        )
+        output = await self.execute_sync(command, cwd=work_dir, env=env, timeout=timeout)
         return output if output else "Command completed successfully (no output)"
 
 
@@ -152,12 +148,12 @@ class ShellTool(BaseScriptTool):
             # Also check if .zshrc exists
             if (Path.home() / ".zshrc").exists():
                 return "zsh"
-        
+
         # Check for user's preferred shell
         user_shell = os.environ.get("SHELL", "")
         if user_shell and Path(user_shell).exists():
             return user_shell
-        
+
         # Default to bash
         return "bash"
 
@@ -173,9 +169,7 @@ class ShellTool(BaseScriptTool):
             env: Optional[dict[str, str]] = None,
             timeout: Optional[int] = None,
         ) -> str:
-            return await tool_self.run(
-                ctx, command=command, cwd=cwd, env=env, timeout=timeout
-            )
+            return await tool_self.run(ctx, command=command, cwd=cwd, env=env, timeout=timeout)
 
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
@@ -249,12 +243,10 @@ shell "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
 
         # Add shell info to output if verbose
         shell_name = os.path.basename(self._best_shell)
-        
+
         # Use execute_sync which has auto-backgrounding
-        output = await self.execute_sync(
-            command, cwd=work_dir, env=env, timeout=timeout
-        )
-        
+        output = await self.execute_sync(command, cwd=work_dir, env=env, timeout=timeout)
+
         if output:
             return output
         else:
@@ -263,4 +255,4 @@ shell "npm run dev" --cwd ./frontend  # Auto-backgrounds if needed"""
 
 # Create tool instances
 zsh_tool = ZshTool()
-shell_tool = ShellTool()  # Smart shell that prefers zsh
+shell_tool = ShellTool()  # Smart shell that prefers zsh

hanzo_mcp/tools/todo/todo.py

@@ -161,9 +161,7 @@ todo --filter in_progress
                     priority_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(
                         todo.get("priority", "medium"), "⚪"
                     )
-                    output.append(
-                        f"{priority_icon} [{todo['id'][:8]}] {todo['content']}"
-                    )
+                    output.append(f"{priority_icon} [{todo['id'][:8]}] {todo['content']}")
 
         # Summary
         output.append(

hanzo_mcp/tools/vector/__init__.py

@@ -4,15 +4,26 @@ This package provides tools for working with local vector databases for semantic
 document indexing, and retrieval-augmented generation (RAG) workflows.
 
 Supported backends:
-- Infinity database (default) - High-performance local vector database
+- LanceDB (primary) - High-performance embedded vector database
+- Hanzo-node (optional) - Distributed vector processing node
+- Infinity database (legacy) - High-performance local vector database
 """
 
 from mcp.server import FastMCP
 
-from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 from hanzo_mcp.tools.common.permissions import PermissionManager
 
-# Try to import vector dependencies
+# Try to import unified vector tools first
+try:
+    from .unified_vector import UnifiedVectorTool
+    from .node_tool import NodeTool
+    
+    UNIFIED_TOOLS_AVAILABLE = True
+except ImportError:
+    UNIFIED_TOOLS_AVAILABLE = False
+
+# Try to import legacy vector dependencies
 try:
     from .index_tool import IndexTool
     from .vector_index import VectorIndexTool
@@ -20,35 +31,73 @@ try:
     from .infinity_store import InfinityVectorStore
     from .project_manager import ProjectVectorManager
 
-    VECTOR_AVAILABLE = True
-
-    def register_vector_tools(
-        mcp_server: FastMCP,
-        permission_manager: PermissionManager,
-        vector_config: dict | None = None,
-        enabled_tools: dict[str, bool] | None = None,
-        search_paths: list[str] | None = None,
-        project_manager: "ProjectVectorManager | None" = None,
-    ) -> list[BaseTool]:
-        """Register vector database tools with the MCP server.
-
-        Args:
-            mcp_server: The FastMCP server instance
-            permission_manager: Permission manager for access control
-            vector_config: Vector store configuration
-            enabled_tools: Dictionary of individual tool enable states
-            search_paths: Paths to search for projects (default: None, uses allowed paths)
-            project_manager: Optional existing project manager to reuse
-
-        Returns:
-            List of registered tools
-        """
+    LEGACY_VECTOR_AVAILABLE = True
+except ImportError:
+    LEGACY_VECTOR_AVAILABLE = False
+
+
+def register_vector_tools(
+    mcp_server: FastMCP,
+    permission_manager: PermissionManager | None = None,
+    vector_config: dict | None = None,
+    enabled_tools: dict[str, bool] | None = None,
+    search_paths: list[str] | None = None,
+    project_manager: "ProjectVectorManager | None" = None,
+    user_id: str = "default",
+    project_id: str = "default",
+    use_unified: bool = True,
+) -> list[BaseTool]:
+    """Register vector database tools with the MCP server.
+
+    Args:
+        mcp_server: The FastMCP server instance
+        permission_manager: Permission manager for access control (optional for unified tools)
+        vector_config: Vector store configuration
+        enabled_tools: Dictionary of individual tool enable states
+        search_paths: Paths to search for projects (default: None, uses allowed paths)
+        project_manager: Optional existing project manager to reuse
+        user_id: User ID for unified tools
+        project_id: Project ID for unified tools
+        use_unified: Whether to use unified tools (default: True)
+
+    Returns:
+        List of registered tools
+    """
+    tools = []
+    
+    # Prefer unified tools if available and enabled
+    if use_unified and UNIFIED_TOOLS_AVAILABLE:
+        tool_enabled = enabled_tools or {}
+        
+        # Register unified vector tool (consolidates vector_search, vector_index, memory ops)
+        if tool_enabled.get("vector", True):
+            unified_vector = UnifiedVectorTool(user_id=user_id, project_id=project_id)
+            ToolRegistry.register_tool(mcp_server, unified_vector)
+            tools.append(unified_vector)
+            
+        # Register node management tool
+        if tool_enabled.get("node", True):
+            node_tool = NodeTool()
+            ToolRegistry.register_tool(mcp_server, node_tool)
+            tools.append(node_tool)
+            
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"Registered {len(tools)} unified vector tools")
+        
+    # Fall back to legacy tools if unified not available or disabled
+    elif not use_unified and LEGACY_VECTOR_AVAILABLE:
         if not vector_config or not vector_config.get("enabled", False):
             return []
 
+        if not permission_manager:
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.warning("Permission manager required for legacy vector tools")
+            return []
+
         # Check individual tool enablement
         tool_enabled = enabled_tools or {}
-        tools = []
 
         # Use provided project manager or create new one
         if project_manager is None:
@@ -56,9 +105,7 @@ try:
             store_config = vector_config.copy()
             project_manager = ProjectVectorManager(
                 global_db_path=store_config.get("data_path"),
-                embedding_model=store_config.get(
-                    "embedding_model", "text-embedding-3-small"
-                ),
+                embedding_model=store_config.get("embedding_model", "text-embedding-3-small"),
                 dimension=store_config.get("dimension", 1536),
             )
 
@@ -68,9 +115,7 @@ try:
                 import logging
 
                 logger = logging.getLogger(__name__)
-                logger.info(
-                    f"Detected {len(detected_projects)} projects with LLM.md files"
-                )
+                logger.info(f"Detected {len(detected_projects)} projects with LLM.md files")
 
         # Register individual tools if enabled
         if tool_enabled.get("index", True):
@@ -83,32 +128,34 @@ try:
             tools.append(VectorSearchTool(permission_manager, project_manager))
 
         # Register with MCP server
-        from hanzo_mcp.tools.common.base import ToolRegistry
-
         ToolRegistry.register_tools(mcp_server, tools)
-
-        return tools
-
-except ImportError:
-    VECTOR_AVAILABLE = False
-
-    def register_vector_tools(*args, **kwargs) -> list[BaseTool]:
-        """Vector tools not available - missing dependencies."""
+        
+    else:
         import logging
-
         logger = logging.getLogger(__name__)
-        logger.warning(
-            "Vector tools not available. Install infinity-embedded: pip install infinity-embedded"
-        )
-        return []
+        if not UNIFIED_TOOLS_AVAILABLE and not LEGACY_VECTOR_AVAILABLE:
+            logger.warning("No vector tools available. Install hanzo-memory package or infinity-embedded.")
+        elif not use_unified:
+            logger.info("Unified vector tools disabled, legacy tools not available")
+
+    return tools
 
 
 __all__ = [
     "register_vector_tools",
-    "VECTOR_AVAILABLE",
+    "UNIFIED_TOOLS_AVAILABLE",
+    "LEGACY_VECTOR_AVAILABLE",
 ]
 
-if VECTOR_AVAILABLE:
+if UNIFIED_TOOLS_AVAILABLE:
+    __all__.extend(
+        [
+            "UnifiedVectorTool",
+            "NodeTool",
+        ]
+    )
+
+if LEGACY_VECTOR_AVAILABLE:
     __all__.extend(
         [
             "InfinityVectorStore",

hanzo_mcp/tools/vector/ast_analyzer.py

@@ -130,9 +130,7 @@ class ASTAnalyzer:
                 return self._analyze_python_file(file_path, content, file_hash)
             else:
                 # Generic analysis for other languages
-                return self._analyze_generic_file(
-                    file_path, content, file_hash, language
-                )
+                return self._analyze_generic_file(file_path, content, file_hash, language)
 
         except Exception as e:
             import logging
@@ -177,9 +175,7 @@ class ASTAnalyzer:
 
         return language_map.get(extension)
 
-    def _analyze_python_file(
-        self, file_path: str, content: str, file_hash: str
-    ) -> FileAST:
+    def _analyze_python_file(self, file_path: str, content: str, file_hash: str) -> FileAST:
         """Analyze Python file using both AST and tree-sitter."""
         symbols = []
         ast_nodes = []
@@ -228,9 +224,7 @@ class ASTAnalyzer:
             dependencies=dependencies,
         )
 
-    def _analyze_generic_file(
-        self, file_path: str, content: str, file_hash: str, language: str
-    ) -> FileAST:
+    def _analyze_generic_file(self, file_path: str, content: str, file_hash: str, language: str) -> FileAST:
         """Generic analysis for non-Python files."""
         # For now, just basic line-based analysis
         # Could be enhanced with language-specific parsers
@@ -248,11 +242,7 @@ class ASTAnalyzer:
 
             # Basic function detection (works for many C-style languages)
             if language in ["javascript", "typescript", "java", "cpp", "c"]:
-                if (
-                    "function " in line
-                    or line.startswith("def ")
-                    or " function(" in line
-                ):
+                if "function " in line or line.startswith("def ") or " function(" in line:
                     # Extract function name
                     parts = line.split()
                     for j, part in enumerate(parts):
@@ -399,9 +389,7 @@ class PythonSymbolExtractor(ast.NodeVisitor):
 
         # Extract base classes
         bases = [self._get_name(base) for base in node.bases]
-        signature = (
-            f"class {node.name}({', '.join(bases)})" if bases else f"class {node.name}"
-        )
+        signature = f"class {node.name}({', '.join(bases)})" if bases else f"class {node.name}"
 
         symbol = Symbol(
             name=node.name,
@@ -441,9 +429,7 @@ class PythonSymbolExtractor(ast.NodeVisitor):
 
         for alias in node.names:
             if alias.name != "*":
-                import_item = (
-                    f"{node.module}.{alias.name}" if node.module else alias.name
-                )
+                import_item = f"{node.module}.{alias.name}" if node.module else alias.name
                 self.imports.append(import_item)
 
     def visit_Assign(self, node):