hanzo-mcp 0.7.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/tools/shell/uvx.py

@@ -1,17 +1,16 @@
 """Run Python packages with uvx."""
 
-import subprocess
 import shutil
-from typing import Annotated, Optional, TypedDict, Unpack, final, override
+import subprocess
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
+from mcp.server.fastmcp import Context as MCPContext
 
 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(
@@ -130,28 +129,27 @@ For long-running servers, use uvx_background instead.
         # Check if uvx is available
         if not shutil.which("uvx"):
             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
+                    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', '')}"
-                    
+                    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. 
@@ -170,7 +168,7 @@ Or on macOS:
 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"""
@@ -182,16 +180,17 @@ curl -LsSf https://astral.sh/uv/install.sh | sh"""
 
         # 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)}")
@@ -199,11 +198,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
+                cmd, capture_output=True, text=True, timeout=timeout, check=True
             )
 
             output = []
@@ -212,7 +207,11 @@ 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

@@ -1,19 +1,18 @@
 """Run Python packages in background with uvx."""
 
-import subprocess
-import shutil
 import uuid
-from typing import Annotated, Optional, TypedDict, Unpack, final, override
+import shutil
+import subprocess
+from typing import Unpack, Optional, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
+from mcp.server.fastmcp import Context as MCPContext
 
 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(
@@ -151,28 +150,27 @@ Use 'processes' to list running processes and 'pkill' to stop them.
         # Check if uvx is available
         if not shutil.which("uvx"):
             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
+                    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', '')}"
-                    
+                    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. 
@@ -191,7 +189,7 @@ Or on macOS:
 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"""
@@ -203,25 +201,27 @@ curl -LsSf https://astral.sh/uv/install.sh | sh"""
 
         # 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"
@@ -237,7 +237,7 @@ curl -LsSf https://astral.sh/uv/install.sh | sh"""
                         stdout=f,
                         stderr=subprocess.STDOUT,
                         cwd=working_dir,
-                        start_new_session=True
+                        start_new_session=True,
                     )
             else:
                 process = subprocess.Popen(
@@ -245,7 +245,7 @@ curl -LsSf https://astral.sh/uv/install.sh | sh"""
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.DEVNULL,
                     cwd=working_dir,
-                    start_new_session=True
+                    start_new_session=True,
                 )
 
             # Create background process object
@@ -255,7 +255,7 @@ curl -LsSf https://astral.sh/uv/install.sh | sh"""
                 name=name,
                 process=process,
                 log_file=str(log_file) if log_file else None,
-                working_dir=working_dir
+                working_dir=working_dir,
             )
 
             # Register with RunBackgroundTool
@@ -269,19 +269,21 @@ curl -LsSf https://astral.sh/uv/install.sh | sh"""
                 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."
-            ])
+
+            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)
 

hanzo_mcp/tools/shell/uvx_tool.py

@@ -1,19 +1,19 @@
 """UVX tool for both sync and background execution."""
 
-from pathlib import Path
 from typing import Optional, override
+from pathlib import Path
 
+from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.shell.base_process import BaseBinaryTool
-from mcp.server import FastMCP
 
 
 class UvxTool(BaseBinaryTool):
     """Tool for running uvx commands."""
-    
+
     name = "uvx"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -27,12 +27,12 @@ uvx ruff check .
 uvx mkdocs serve  # Auto-backgrounds after 2 minutes
 uvx black --check src/
 uvx jupyter lab --port 8888  # Auto-backgrounds if needed"""
-    
+
     @override
     def get_binary_name(self) -> str:
         """Get the binary name."""
         return "uvx"
-    
+
     @override
     async def run(
         self,
@@ -43,57 +43,53 @@ uvx jupyter lab --port 8888  # Auto-backgrounds if needed"""
         python: Optional[str] = None,
     ) -> str:
         """Run a uvx command with auto-backgrounding.
-        
+
         Args:
             ctx: MCP context
             package: Python package to run
             args: Additional arguments
             cwd: Working directory
             python: Python version constraint
-            
+
         Returns:
             Command output or background status
         """
         # Prepare working directory
         work_dir = Path(cwd).resolve() if cwd else Path.cwd()
-        
+
         # Prepare flags
         flags = []
         if python:
             flags.extend(["--python", python])
-        
+
         # Build full command
         full_args = args.split() if args else []
-        
+
         # 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
+            timeout=None,  # Let auto-backgrounding handle timeout
         )
 
     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 uvx(
             ctx: MCPContext,
             package: str,
             args: str = "",
             cwd: Optional[str] = None,
-            python: Optional[str] = None
+            python: Optional[str] = None,
         ) -> str:
             return await tool_self.run(
-                ctx,
-                package=package,
-                args=args,
-                cwd=cwd,
-                python=python
+                ctx, package=package, args=args, cwd=cwd, python=python
             )
-    
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(
@@ -101,9 +97,9 @@ uvx jupyter lab --port 8888  # Auto-backgrounds if needed"""
             package=params["package"],
             args=params.get("args", ""),
             cwd=params.get("cwd"),
-            python=params.get("python")
+            python=params.get("python"),
         )
 
 
 # Create tool instance
-uvx_tool = UvxTool()
+uvx_tool = UvxTool()

hanzo_mcp/tools/todo/__init__.py

@@ -6,8 +6,8 @@ within Claude Desktop sessions.
 
 from mcp.server import FastMCP
 
-from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 from hanzo_mcp.tools.todo.todo import TodoTool
+from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 
 # Export all tool classes
 __all__ = [
@@ -51,7 +51,11 @@ def register_todo_tools(
     if enabled_tools:
         # Use individual tool configuration
         # 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):
+        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)

hanzo_mcp/tools/todo/todo.py

@@ -1,17 +1,23 @@
 """Unified todo tool."""
 
-from typing import Annotated, TypedDict, Unpack, final, override, Optional, List, Dict, Any
-import json
 import uuid
+from typing import (
+    Any,
+    Dict,
+    Unpack,
+    Optional,
+    Annotated,
+    TypedDict,
+    final,
+    override,
+)
 from datetime import datetime
-from pathlib import Path
 
-from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.todo.base import TodoBaseTool
 
-
 # Parameter types
 Action = Annotated[
     str,
@@ -64,6 +70,7 @@ Filter = Annotated[
 
 class TodoParams(TypedDict, total=False):
     """Parameters for todo tool."""
+
     action: str
     content: Optional[str]
     id: Optional[str]
@@ -107,7 +114,7 @@ todo --filter in_progress
 
         # Extract action
         action = params.get("action", "list")
-        
+
         # Route to appropriate handler
         if action == "list":
             return await self._handle_list(params.get("filter"), tool_ctx)
@@ -125,16 +132,16 @@ todo --filter in_progress
     async def _handle_list(self, filter_status: Optional[str], tool_ctx) -> str:
         """List todos."""
         todos = self.read_todos()
-        
+
         if not todos:
             return "No todos found. Use 'todo \"Your task here\"' to add one."
-        
+
         # Apply filter if specified
         if filter_status:
             todos = [t for t in todos if t.get("status") == filter_status]
             if not todos:
                 return f"No todos with status '{filter_status}'"
-        
+
         # Group by status
         by_status = {}
         for todo in todos:
@@ -142,21 +149,27 @@ todo --filter in_progress
             if status not in by_status:
                 by_status[status] = []
             by_status[status].append(todo)
-        
+
         # Format output
         output = ["=== Todo List ==="]
-        
+
         # Show in order: in_progress, pending, completed
         for status in ["in_progress", "pending", "completed"]:
             if status in by_status:
                 output.append(f"\n{status.replace('_', ' ').title()}:")
                 for todo in by_status[status]:
-                    priority_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(todo.get("priority", "medium"), "⚪")
-                    output.append(f"{priority_icon} [{todo['id'][:8]}] {todo['content']}")
-        
+                    priority_icon = {"high": "🔴", "medium": "🟡", "low": "🟢"}.get(
+                        todo.get("priority", "medium"), "⚪"
+                    )
+                    output.append(
+                        f"{priority_icon} [{todo['id'][:8]}] {todo['content']}"
+                    )
+
         # Summary
-        output.append(f"\nTotal: {len(todos)} | In Progress: {len(by_status.get('in_progress', []))} | Pending: {len(by_status.get('pending', []))} | Completed: {len(by_status.get('completed', []))}")
-        
+        output.append(
+            f"\nTotal: {len(todos)} | In Progress: {len(by_status.get('in_progress', []))} | Pending: {len(by_status.get('pending', []))} | Completed: {len(by_status.get('completed', []))}"
+        )
+
         return "\n".join(output)
 
     async def _handle_add(self, params: Dict[str, Any], tool_ctx) -> str:
@@ -164,9 +177,9 @@ todo --filter in_progress
         content = params.get("content")
         if not content:
             return "Error: content is required for add action"
-        
+
         todos = self.read_todos()
-        
+
         new_todo = {
             "id": str(uuid.uuid4()),
             "content": content,
@@ -174,10 +187,10 @@ todo --filter in_progress
             "priority": params.get("priority", "medium"),
             "created_at": datetime.now().isoformat(),
         }
-        
+
         todos.append(new_todo)
         self.write_todos(todos)
-        
+
         await tool_ctx.info(f"Added todo: {content}")
         return f"Added todo [{new_todo['id'][:8]}]: {content}"
 
@@ -186,19 +199,19 @@ todo --filter in_progress
         todo_id = params.get("id")
         if not todo_id:
             return "Error: id is required for update action"
-        
+
         todos = self.read_todos()
-        
+
         # Find todo (support partial ID match)
         todo_found = None
         for todo in todos:
             if todo["id"].startswith(todo_id):
                 todo_found = todo
                 break
-        
+
         if not todo_found:
             return f"Error: Todo with ID '{todo_id}' not found"
-        
+
         # Update fields
         if params.get("content"):
             todo_found["content"] = params["content"]
@@ -206,11 +219,11 @@ todo --filter in_progress
             todo_found["status"] = params["status"]
         if params.get("priority"):
             todo_found["priority"] = params["priority"]
-        
+
         todo_found["updated_at"] = datetime.now().isoformat()
-        
+
         self.write_todos(todos)
-        
+
         await tool_ctx.info(f"Updated todo: {todo_found['content']}")
         return f"Updated todo [{todo_found['id'][:8]}]: {todo_found['content']} (status: {todo_found['status']})"
 
@@ -218,44 +231,44 @@ todo --filter in_progress
         """Remove todo."""
         if not todo_id:
             return "Error: id is required for remove action"
-        
+
         todos = self.read_todos()
-        
+
         # Find and remove (support partial ID match)
         removed = None
         for i, todo in enumerate(todos):
             if todo["id"].startswith(todo_id):
                 removed = todos.pop(i)
                 break
-        
+
         if not removed:
             return f"Error: Todo with ID '{todo_id}' not found"
-        
+
         self.write_todos(todos)
-        
+
         await tool_ctx.info(f"Removed todo: {removed['content']}")
         return f"Removed todo [{removed['id'][:8]}]: {removed['content']}"
 
     async def _handle_clear(self, filter_status: Optional[str], tool_ctx) -> str:
         """Clear todos."""
         todos = self.read_todos()
-        
+
         if filter_status:
             # Clear only todos with specific status
             original_count = len(todos)
             todos = [t for t in todos if t.get("status") != filter_status]
             removed_count = original_count - len(todos)
-            
+
             if removed_count == 0:
                 return f"No todos with status '{filter_status}' to clear"
-            
+
             self.write_todos(todos)
             return f"Cleared {removed_count} todo(s) with status '{filter_status}'"
         else:
             # Clear all
             if not todos:
                 return "No todos to clear"
-            
+
             count = len(todos)
             self.write_todos([])
             return f"Cleared all {count} todo(s)"
@@ -283,4 +296,4 @@ todo --filter in_progress
                 status=status,
                 priority=priority,
                 filter=filter,
-            )
+            )

hanzo_mcp/tools/todo/todo_read.py

@@ -4,13 +4,13 @@ This module provides the TodoRead tool for reading the current todo list for a s
 """
 
 import json
-from typing import Annotated, TypedDict, Unpack, final, override
+from typing import Unpack, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
-from hanzo_mcp.tools.todo.base import TodoBaseTool, TodoStorage
+from hanzo_mcp.tools.todo.base import TodoStorage, TodoBaseTool
 
 SessionId = Annotated[
     str | int | float,
@@ -139,8 +139,5 @@ Usage:
         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_read(
-            session_id: SessionId,
-            ctx: MCPContext
-        ) -> str:
+        async def todo_read(session_id: SessionId, ctx: MCPContext) -> str:
             return await tool_self.call(ctx, session_id=session_id)