hanzo-mcp 0.6.12__py3-none-any.whl → 0.7.0__py3-none-any.whl

hanzo_mcp/tools/shell/uvx_background.py

@@ -150,11 +150,56 @@ Use 'processes' to list running processes and 'pkill' to stop them.
 
         # Check if uvx is available
         if not shutil.which("uvx"):
-            return """Error: uvx is not installed. Install it with:
+            await tool_ctx.info("uvx not found, attempting to install...")
+            
+            # Try to auto-install uvx
+            install_cmd = "curl -LsSf https://astral.sh/uv/install.sh | sh"
+            
+            try:
+                # Run installation
+                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!")
+                    
+                    # Add to PATH for current session
+                    import os
+                    home = os.path.expanduser("~")
+                    os.environ["PATH"] = f"{home}/.cargo/bin:{os.environ.get('PATH', '')}"
+                    
+                    # Check again
+                    if not shutil.which("uvx"):
+                        return """Error: uvx installed but not found in PATH. 
+Please add ~/.cargo/bin to your PATH and restart your shell.
+
+Add to ~/.zshrc or ~/.bashrc:
+export PATH="$HOME/.cargo/bin:$PATH"
+"""
+                else:
+                    return f"""Error: Failed to install uvx automatically.
+                    
+Install manually with:
 curl -LsSf https://astral.sh/uv/install.sh | sh
 
 Or on macOS:
-brew install uv"""
+brew install uv
+
+Error details: {install_result.stderr}"""
+                    
+            except subprocess.TimeoutExpired:
+                return """Error: Installation timed out. Install uvx manually with:
+curl -LsSf https://astral.sh/uv/install.sh | sh"""
+            except Exception as e:
+                return f"""Error: Failed to auto-install uvx: {str(e)}
+                
+Install manually with:
+curl -LsSf https://astral.sh/uv/install.sh | sh"""
 
         # Build command
         cmd = ["uvx"]

hanzo_mcp/tools/shell/{uvx_unified.py → uvx_tool.py}

@@ -18,13 +18,15 @@ class UvxTool(BaseBinaryTool):
     @override
     def description(self) -> str:
         """Get the tool description."""
-        return """Run Python packages with uvx. Actions: run (default), background.
+        return """Run Python packages with uvx with automatic backgrounding for long-running processes.
+
+Commands that run for more than 2 minutes will automatically continue in the background.
 
 Usage:
 uvx ruff check .
-uvx --action background mkdocs serve
+uvx mkdocs serve  # Auto-backgrounds after 2 minutes
 uvx black --check src/
-uvx --action background jupyter lab --port 8888"""
+uvx jupyter lab --port 8888  # Auto-backgrounds if needed"""
     
     @override
     def get_binary_name(self) -> str:
@@ -37,22 +39,20 @@ uvx --action background jupyter lab --port 8888"""
         ctx: MCPContext,
         package: str,
         args: str = "",
-        action: str = "run",
         cwd: Optional[str] = None,
         python: Optional[str] = None,
     ) -> str:
-        """Run a uvx command.
+        """Run a uvx command with auto-backgrounding.
         
         Args:
             ctx: MCP context
             package: Python package to run
             args: Additional arguments
-            action: Action to perform (run, background)
             cwd: Working directory
             python: Python version constraint
             
         Returns:
-            Command output or process info
+            Command output or background status
         """
         # Prepare working directory
         work_dir = Path(cwd).resolve() if cwd else Path.cwd()
@@ -65,28 +65,14 @@ uvx --action background jupyter lab --port 8888"""
         # Build full command
         full_args = args.split() if args else []
         
-        if action == "background":
-            result = await self.execute_background(
-                package,
-                cwd=work_dir,
-                flags=flags,
-                args=full_args
-            )
-            return (
-                f"Started uvx process in background\n"
-                f"Process ID: {result['process_id']}\n"
-                f"PID: {result['pid']}\n"
-                f"Log file: {result['log_file']}"
-            )
-        else:
-            # Default to sync execution
-            return await self.execute_sync(
-                package,
-                cwd=work_dir,
-                flags=flags,
-                args=full_args,
-                timeout=300  # 5 minute timeout for uvx
-            )
+        # Always use execute_sync which now has auto-backgrounding
+        return await self.execute_sync(
+            package,
+            cwd=work_dir,
+            flags=flags,
+            args=full_args,
+            timeout=None  # Let auto-backgrounding handle timeout
+        )
 
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
@@ -97,15 +83,13 @@ uvx --action background jupyter lab --port 8888"""
             ctx: MCPContext,
             package: str,
             args: str = "",
-            action: str = "run",
             cwd: Optional[str] = None,
-            python: Optional[str] = None,
+            python: Optional[str] = None
         ) -> str:
             return await tool_self.run(
                 ctx,
                 package=package,
                 args=args,
-                action=action,
                 cwd=cwd,
                 python=python
             )
@@ -116,7 +100,6 @@ uvx --action background jupyter lab --port 8888"""
             ctx,
             package=params["package"],
             args=params.get("args", ""),
-            action=params.get("action", "run"),
             cwd=params.get("cwd"),
             python=params.get("python")
         )

hanzo_mcp/tools/todo/__init__.py

@@ -1,19 +1,17 @@
-"""Todo tools package for Hanzo MCP.
+"""Todo tools package for Hanzo AI.
 
-This package provides tools for managing todo lists across different Claude Desktop sessions,
-using in-memory storage to maintain separate task lists for each conversation.
+This package provides a unified todo management tool for organizing tasks
+within Claude Desktop sessions.
 """
 
 from mcp.server import FastMCP
 
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
-from hanzo_mcp.tools.todo.todo_read import TodoReadTool
-from hanzo_mcp.tools.todo.todo_write import TodoWriteTool
+from hanzo_mcp.tools.todo.todo import TodoTool
 
 # Export all tool classes
 __all__ = [
-    "TodoReadTool",
-    "TodoWriteTool",
+    "TodoTool",
     "get_todo_tools",
     "register_todo_tools",
 ]
@@ -26,8 +24,7 @@ def get_todo_tools() -> list[BaseTool]:
         List of todo tool instances
     """
     return [
-        TodoReadTool(),
-        TodoWriteTool(),
+        TodoTool(),
     ]
 
 
@@ -44,23 +41,21 @@ def register_todo_tools(
     Returns:
         List of registered tools
     """
-    # Define tool mapping
+    # Define tool mapping - single unified todo tool
     tool_classes = {
-        "todo_read": TodoReadTool,
-        "todo_write": TodoWriteTool,
+        "todo": TodoTool,
     }
-    
+
     tools = []
-    
+
     if enabled_tools:
         # Use individual tool configuration
-        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())
+        # Support both old names and new name for backward compatibility
+        if enabled_tools.get("todo", True) or enabled_tools.get("todo_read", True) or enabled_tools.get("todo_write", True):
+            tools.append(TodoTool())
     else:
         # Use all tools (backward compatibility)
         tools = get_todo_tools()
-    
+
     ToolRegistry.register_tools(mcp_server, tools)
     return tools

hanzo_mcp/tools/todo/todo.py

@@ -260,6 +260,27 @@ todo --filter in_progress
             self.write_todos([])
             return f"Cleared all {count} todo(s)"
 
+    @override
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""
-        pass
+        tool_self = self  # Create a reference to self for use in the closure
+
+        @mcp_server.tool(name=self.name, description=self.description)
+        async def todo(
+            action: Action = "list",
+            content: Content = None,
+            id: TodoId = None,
+            status: Status = None,
+            priority: Priority = None,
+            filter: Filter = None,
+            ctx: MCPContext = None,
+        ) -> str:
+            return await tool_self.call(
+                ctx,
+                action=action,
+                content=content,
+                id=id,
+                status=status,
+                priority=priority,
+                filter=filter,
+            )

hanzo_mcp/tools/vector/__init__.py

@@ -1,4 +1,4 @@
-"""Vector database tools for Hanzo MCP.
+"""Vector database tools for Hanzo AI.
 
 This package provides tools for working with local vector databases for semantic search,
 document indexing, and retrieval-augmented generation (RAG) workflows.

hanzo_mcp/tools/vector/infinity_store.py

@@ -1,4 +1,4 @@
-"""Infinity vector database integration for Hanzo MCP."""
+"""Infinity vector database integration for Hanzo AI."""
 
 import json
 import hashlib
@@ -45,7 +45,7 @@ class SymbolSearchResult:
 
 @dataclass
 class UnifiedSearchResult:
-    """Unified search result combining text, vector, and symbol search."""
+    """Search result combining text, vector, and symbol search."""
     type: str  # 'document', 'symbol', 'reference'
     content: str
     file_path: str

hanzo_mcp/tools/vector/project_manager.py

@@ -1,4 +1,4 @@
-"""Project-aware vector database management for Hanzo MCP."""
+"""Project-aware vector database management for Hanzo AI."""
 
 import os
 from pathlib import Path

hanzo_mcp/types.py

@@ -0,0 +1,23 @@
+"""Type definitions for Hanzo MCP tools."""
+
+from typing import Dict, Any, Optional, List
+from dataclasses import dataclass
+
+
+@dataclass
+class MCPResourceDocument:
+    """Resource document returned by MCP tools."""
+    data: Dict[str, Any]
+    metadata: Optional[Dict[str, Any]] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format."""
+        result = {"data": self.data}
+        if self.metadata:
+            result["metadata"] = self.metadata
+        return result
+    
+    def to_json_string(self) -> str:
+        """Convert to JSON string."""
+        import json
+        return json.dumps(self.to_dict(), indent=2)