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

hanzo_mcp/tools/shell/uvx.py

@@ -0,0 +1,187 @@
+"""Run Python packages with uvx."""
+
+import subprocess
+import shutil
+from typing import Annotated, Optional, TypedDict, Unpack, final, override
+
+from fastmcp import Context as MCPContext
+from pydantic import Field
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+from hanzo_mcp.tools.common.permissions import PermissionManager
+
+
+Package = Annotated[
+    str,
+    Field(
+        description="Package name to run (e.g., 'ruff', 'black', 'pytest')",
+        min_length=1,
+    ),
+]
+
+Args = Annotated[
+    Optional[str],
+    Field(
+        description="Arguments to pass to the package",
+        default=None,
+    ),
+]
+
+PythonVersion = Annotated[
+    Optional[str],
+    Field(
+        description="Python version to use (e.g., '3.11', '3.12')",
+        default=None,
+    ),
+]
+
+Timeout = Annotated[
+    int,
+    Field(
+        description="Timeout in seconds (default 120)",
+        default=120,
+    ),
+]
+
+
+class UvxParams(TypedDict, total=False):
+    """Parameters for uvx tool."""
+
+    package: str
+    args: Optional[str]
+    python_version: Optional[str]
+    timeout: int
+
+
+@final
+class UvxTool(BaseTool):
+    """Tool for running Python packages with uvx."""
+
+    def __init__(self, permission_manager: PermissionManager):
+        """Initialize the uvx tool.
+
+        Args:
+            permission_manager: Permission manager for access control
+        """
+        self.permission_manager = permission_manager
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "uvx"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Run Python packages using uvx (Python package runner).
+
+uvx allows running Python applications in isolated environments without 
+installing them globally. It automatically manages dependencies and Python versions.
+
+Common packages:
+- ruff: Fast Python linter and formatter
+- black: Python code formatter
+- pytest: Testing framework
+- mypy: Static type checker
+- pipx: Install Python apps
+- httpie: HTTP client
+- poetry: Dependency management
+
+Examples:
+- uvx --package ruff --args "check ."
+- uvx --package black --args "--check src/"
+- uvx --package pytest --args "-v tests/"
+- uvx --package httpie --args "GET httpbin.org/get"
+- uvx --package mypy --args "--strict src/"
+
+For long-running servers, use uvx_background instead.
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[UvxParams],
+    ) -> str:
+        """Execute uvx command.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Command output
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        package = params.get("package")
+        if not package:
+            return "Error: package is required"
+
+        args = params.get("args", "")
+        python_version = params.get("python_version")
+        timeout = params.get("timeout", 120)
+
+        # Check if uvx is available
+        if not shutil.which("uvx"):
+            return """Error: uvx is not installed. Install it with:
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+Or on macOS:
+brew install uv"""
+
+        # Build command
+        cmd = ["uvx"]
+        
+        if python_version:
+            cmd.extend(["--python", python_version])
+        
+        cmd.append(package)
+        
+        # Add package arguments
+        if args:
+            # Split args properly (basic parsing)
+            import shlex
+            cmd.extend(shlex.split(args))
+
+        await tool_ctx.info(f"Running: {' '.join(cmd)}")
+
+        try:
+            # Execute command
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                check=True
+            )
+
+            output = []
+            if result.stdout:
+                output.append(result.stdout)
+            if result.stderr:
+                output.append(f"\nSTDERR:\n{result.stderr}")
+
+            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."
+        except subprocess.CalledProcessError as e:
+            error_msg = [f"Error: Command failed with exit code {e.returncode}"]
+            if e.stdout:
+                error_msg.append(f"\nSTDOUT:\n{e.stdout}")
+            if e.stderr:
+                error_msg.append(f"\nSTDERR:\n{e.stderr}")
+            return "\n".join(error_msg)
+        except Exception as e:
+            await tool_ctx.error(f"Unexpected error: {str(e)}")
+            return f"Error running uvx: {str(e)}"
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/shell/uvx_background.py

@@ -0,0 +1,249 @@
+"""Run Python packages in background with uvx."""
+
+import subprocess
+import shutil
+import uuid
+from typing import Annotated, Optional, TypedDict, Unpack, final, override
+
+from fastmcp import Context as MCPContext
+from pydantic import Field
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.common.context import create_tool_context
+from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.shell.run_background import BackgroundProcess, RunBackgroundTool
+
+
+Package = Annotated[
+    str,
+    Field(
+        description="Package name to run (e.g., 'streamlit', 'jupyter-lab', 'mkdocs')",
+        min_length=1,
+    ),
+]
+
+Args = Annotated[
+    Optional[str],
+    Field(
+        description="Arguments to pass to the package",
+        default=None,
+    ),
+]
+
+Name = Annotated[
+    Optional[str],
+    Field(
+        description="Process name for identification",
+        default=None,
+    ),
+]
+
+PythonVersion = Annotated[
+    Optional[str],
+    Field(
+        description="Python version to use (e.g., '3.11', '3.12')",
+        default=None,
+    ),
+]
+
+LogOutput = Annotated[
+    bool,
+    Field(
+        description="Log output to file in ~/.hanzo/logs",
+        default=True,
+    ),
+]
+
+WorkingDir = Annotated[
+    Optional[str],
+    Field(
+        description="Working directory for the process",
+        default=None,
+    ),
+]
+
+
+class UvxBackgroundParams(TypedDict, total=False):
+    """Parameters for uvx background tool."""
+
+    package: str
+    args: Optional[str]
+    name: Optional[str]
+    python_version: Optional[str]
+    log_output: bool
+    working_dir: Optional[str]
+
+
+@final
+class UvxBackgroundTool(BaseTool):
+    """Tool for running Python packages in background with uvx."""
+
+    def __init__(self, permission_manager: PermissionManager):
+        """Initialize the uvx background tool.
+
+        Args:
+            permission_manager: Permission manager for access control
+        """
+        self.permission_manager = permission_manager
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "uvx_background"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Run Python packages in the background using uvx.
+
+Perfect for running servers and long-running Python applications.
+The process continues running even after the command returns.
+
+Common server packages:
+- streamlit: Data app framework
+- jupyter-lab: Jupyter Lab server
+- mkdocs: Documentation server
+- fastapi: FastAPI with uvicorn
+- flask: Flask development server
+- gradio: ML model demos
+- panel: Data app framework
+
+Examples:
+- uvx_background --package streamlit --args "run app.py --port 8501" --name streamlit-app
+- uvx_background --package jupyter-lab --args "--port 8888" --name jupyter
+- uvx_background --package mkdocs --args "serve --dev-addr 0.0.0.0:8000" --name docs
+- uvx_background --package gradio --args "app.py" --name ml-demo
+
+Use 'processes' to list running processes and 'pkill' to stop them.
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[UvxBackgroundParams],
+    ) -> str:
+        """Execute uvx command in background.
+
+        Args:
+            ctx: MCP context
+            **params: Tool parameters
+
+        Returns:
+            Process information
+        """
+        tool_ctx = create_tool_context(ctx)
+        await tool_ctx.set_tool_info(self.name)
+
+        # Extract parameters
+        package = params.get("package")
+        if not package:
+            return "Error: package is required"
+
+        args = params.get("args", "")
+        name = params.get("name", f"uvx-{package}")
+        python_version = params.get("python_version")
+        log_output = params.get("log_output", True)
+        working_dir = params.get("working_dir")
+
+        # Check if uvx is available
+        if not shutil.which("uvx"):
+            return """Error: uvx is not installed. Install it with:
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+Or on macOS:
+brew install uv"""
+
+        # Build command
+        cmd = ["uvx"]
+        
+        if python_version:
+            cmd.extend(["--python", python_version])
+        
+        cmd.append(package)
+        
+        # Add package arguments
+        if args:
+            # Split args properly (basic parsing)
+            import shlex
+            cmd.extend(shlex.split(args))
+
+        # Generate process ID
+        process_id = str(uuid.uuid4())[:8]
+        
+        # Prepare log file if needed
+        log_file = None
+        if log_output:
+            from pathlib import Path
+            log_dir = Path.home() / ".hanzo" / "logs"
+            log_dir.mkdir(parents=True, exist_ok=True)
+            log_file = log_dir / f"{name}_{process_id}.log"
+
+        await tool_ctx.info(f"Starting background process: {' '.join(cmd)}")
+
+        try:
+            # Start process
+            if log_output and log_file:
+                with open(log_file, "w") as f:
+                    process = subprocess.Popen(
+                        cmd,
+                        stdout=f,
+                        stderr=subprocess.STDOUT,
+                        cwd=working_dir,
+                        start_new_session=True
+                    )
+            else:
+                process = subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    cwd=working_dir,
+                    start_new_session=True
+                )
+
+            # Create background process object
+            bg_process = BackgroundProcess(
+                process_id=process_id,
+                command=" ".join(cmd),
+                name=name,
+                process=process,
+                log_file=str(log_file) if log_file else None,
+                working_dir=working_dir
+            )
+
+            # Register with RunBackgroundTool
+            RunBackgroundTool._add_process(bg_process)
+
+            output = [
+                f"Started uvx background process:",
+                f"  ID: {process_id}",
+                f"  Name: {name}",
+                f"  Package: {package}",
+                f"  PID: {process.pid}",
+                f"  Command: {' '.join(cmd)}",
+            ]
+            
+            if working_dir:
+                output.append(f"  Working Dir: {working_dir}")
+            
+            if log_file:
+                output.append(f"  Log: {log_file}")
+            
+            output.extend([
+                "",
+                "Use 'processes' to list running processes.",
+                f"Use 'logs --process-id {process_id}' to view output.",
+                f"Use 'pkill --process-id {process_id}' to stop."
+            ])
+
+            return "\n".join(output)
+
+        except Exception as e:
+            await tool_ctx.error(f"Failed to start process: {str(e)}")
+            return f"Error starting uvx background process: {str(e)}"
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/vector/__init__.py

@@ -17,6 +17,7 @@ try:
     from .project_manager import ProjectVectorManager
     from .vector_index import VectorIndexTool
     from .vector_search import VectorSearchTool
+    from .index_tool import IndexTool
     
     VECTOR_AVAILABLE = True
     
@@ -26,6 +27,7 @@ try:
         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.
         
@@ -35,6 +37,7 @@ try:
             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
@@ -46,20 +49,25 @@ try:
         tool_enabled = enabled_tools or {}
         tools = []
         
-        # Initialize project-aware vector manager
-        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"),
-            dimension=store_config.get("dimension", 1536),
-        )
-        
-        # Auto-detect projects from search paths
-        if search_paths:
-            detected_projects = project_manager.detect_projects(search_paths)
-            print(f"Detected {len(detected_projects)} projects with LLM.md files")
+        # Use provided project manager or create new one
+        if project_manager is None:
+            # Initialize project-aware vector manager
+            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"),
+                dimension=store_config.get("dimension", 1536),
+            )
+            
+            # Auto-detect projects from search paths for new manager
+            if search_paths:
+                detected_projects = project_manager.detect_projects(search_paths)
+                print(f"Detected {len(detected_projects)} projects with LLM.md files")
         
         # Register individual tools if enabled
+        if tool_enabled.get("index", True):
+            tools.append(IndexTool(permission_manager))
+        
         if tool_enabled.get("vector_index", True):
             tools.append(VectorIndexTool(permission_manager, project_manager))
         
@@ -90,6 +98,7 @@ if VECTOR_AVAILABLE:
     __all__.extend([
         "InfinityVectorStore",
         "ProjectVectorManager",
+        "IndexTool",
         "VectorIndexTool", 
         "VectorSearchTool",
     ])