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

hanzo_mcp/tools/shell/process_unified.py

@@ -0,0 +1,131 @@
+"""Process management tool."""
+
+import signal
+from typing import Optional, override
+
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.shell.base_process import ProcessManager
+from mcp.server import FastMCP
+
+
+class ProcessTool(BaseTool):
+    """Tool for process management."""
+    
+    name = "process"
+    
+    def __init__(self):
+        """Initialize the process tool."""
+        super().__init__()
+        self.process_manager = ProcessManager()
+    
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Manage background processes. Actions: list (default), kill, logs.
+
+Usage:
+process
+process --action list
+process --action kill --id npx_abc123
+process --action logs --id uvx_def456
+process --action logs --id bash_ghi789 --lines 50"""
+    
+    @override
+    async def run(
+        self,
+        ctx: MCPContext,
+        action: str = "list",
+        id: Optional[str] = None,
+        signal_type: str = "TERM",
+        lines: int = 100,
+    ) -> str:
+        """Manage background processes.
+        
+        Args:
+            ctx: MCP context
+            action: Action to perform (list, kill, logs)
+            id: Process ID (for kill/logs actions)
+            signal_type: Signal type for kill (TERM, KILL, INT)
+            lines: Number of log lines to show
+            
+        Returns:
+            Action result
+        """
+        if action == "list":
+            processes = self.process_manager.list_processes()
+            if not processes:
+                return "No background processes running"
+            
+            output = ["Background processes:"]
+            for proc_id, info in processes.items():
+                status = "running" if info["running"] else f"stopped (exit code: {info.get('return_code', 'unknown')})"
+                output.append(f"- {proc_id}: PID {info['pid']} - {status}")
+                if info.get("log_file"):
+                    output.append(f"  Log: {info['log_file']}")
+            
+            return "\n".join(output)
+        
+        elif action == "kill":
+            if not id:
+                return "Error: Process ID required for kill action"
+            
+            process = self.process_manager.get_process(id)
+            if not process:
+                return f"Process {id} not found"
+            
+            # Map signal names to signal numbers
+            signal_map = {
+                "TERM": signal.SIGTERM,
+                "KILL": signal.SIGKILL,
+                "INT": signal.SIGINT,
+            }
+            
+            sig = signal_map.get(signal_type.upper(), signal.SIGTERM)
+            
+            try:
+                process.send_signal(sig)
+                return f"Sent {signal_type} signal to process {id} (PID: {process.pid})"
+            except Exception as e:
+                return f"Failed to kill process {id}: {e}"
+        
+        elif action == "logs":
+            if not id:
+                return "Error: Process ID required for logs action"
+            
+            log_file = self.process_manager.get_log_file(id)
+            if not log_file or not log_file.exists():
+                return f"No log file found for process {id}"
+            
+            try:
+                with open(log_file, "r") as f:
+                    log_lines = f.readlines()
+                
+                # Get last N lines
+                if len(log_lines) > lines:
+                    log_lines = log_lines[-lines:]
+                
+                output = [f"Logs for process {id} (last {lines} lines):"]
+                output.append("-" * 50)
+                output.extend(line.rstrip() for line in log_lines)
+                
+                return "\n".join(output)
+            except Exception as e:
+                return f"Error reading logs: {e}"
+        
+        else:
+            return f"Unknown action: {action}. Use 'list', 'kill', or 'logs'"
+
+    def register(self, server: FastMCP) -> None:
+        """Register the tool with the MCP server."""
+        server.tool(name=self.name, description=self.description)(self.call)
+    
+    async def call(self, **kwargs) -> str:
+        """Call the tool with arguments."""
+        return await self.run(None, **kwargs)
+
+
+# Create tool instance
+process_tool = ProcessTool()

hanzo_mcp/tools/shell/processes.py

@@ -4,7 +4,7 @@ import psutil
 from datetime import datetime
 from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool

hanzo_mcp/tools/shell/run_background.py

@@ -9,7 +9,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool

hanzo_mcp/tools/shell/run_command.py

@@ -5,9 +5,8 @@ This module provides the RunCommandTool for running shell commands.
 
 from typing import Annotated, Any, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
-from fastmcp.server.dependencies import get_context
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import handle_connection_errors
@@ -345,8 +344,8 @@ Important:
             time_out: TimeOut,
             is_input: IsInput,
             blocking: Blocking,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(
                 ctx,
                 command=command,

hanzo_mcp/tools/shell/run_command_windows.py

@@ -6,9 +6,8 @@ This module provides the RunCommandTool for running shell commands on Windows.
 import os
 from typing import Annotated, Any, final, override
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
-from fastmcp.server.dependencies import get_context
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import handle_connection_errors
@@ -317,8 +316,8 @@ Important:
                     default=True,
                 ),
             ] = True,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(
                 ctx,
                 command=command,

hanzo_mcp/tools/shell/uvx.py

@@ -4,7 +4,7 @@ import subprocess
 import shutil
 from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool

hanzo_mcp/tools/shell/uvx_background.py

@@ -5,7 +5,7 @@ import shutil
 import uuid
 from typing import Annotated, Optional, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool

hanzo_mcp/tools/shell/uvx_unified.py

@@ -0,0 +1,101 @@
+"""UVX tool for both sync and background execution."""
+
+from pathlib import Path
+from typing import Optional, override
+
+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:
+        """Get the tool description."""
+        return """Run Python packages with uvx. Actions: run (default), background.
+
+Usage:
+uvx ruff check .
+uvx --action background mkdocs serve
+uvx black --check src/
+uvx --action background jupyter lab --port 8888"""
+    
+    @override
+    def get_binary_name(self) -> str:
+        """Get the binary name."""
+        return "uvx"
+    
+    @override
+    async def run(
+        self,
+        ctx: MCPContext,
+        package: str,
+        args: str = "",
+        action: str = "run",
+        cwd: Optional[str] = None,
+        python: Optional[str] = None,
+    ) -> str:
+        """Run a uvx command.
+        
+        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
+        """
+        # 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 []
+        
+        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
+            )
+
+    def register(self, server: FastMCP) -> None:
+        """Register the tool with the MCP server."""
+        server.tool(name=self.name, description=self.description)(self.call)
+    
+    async def call(self, **kwargs) -> str:
+        """Call the tool with arguments."""
+        return await self.run(None, **kwargs)
+
+
+# Create tool instance
+uvx_tool = UvxTool()

hanzo_mcp/tools/todo/__init__.py

@@ -4,7 +4,7 @@ This package provides tools for managing todo lists across different Claude Desk
 using in-memory storage to maintain separate task lists for each conversation.
 """
 
-from fastmcp import FastMCP
+from mcp.server import FastMCP
 
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 from hanzo_mcp.tools.todo.todo_read import TodoReadTool

hanzo_mcp/tools/todo/base.py

@@ -9,7 +9,7 @@ import time
 from abc import ABC
 from typing import Any, final
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.context import ToolContext, create_tool_context

hanzo_mcp/tools/todo/todo.py

@@ -0,0 +1,265 @@
+"""Unified todo tool."""
+
+from typing import Annotated, TypedDict, Unpack, final, override, Optional, List, Dict, Any
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+from mcp.server.fastmcp import Context as MCPContext
+from pydantic import Field
+
+from hanzo_mcp.tools.todo.base import TodoBaseTool
+
+
+# Parameter types
+Action = Annotated[
+    str,
+    Field(
+        description="Action to perform: list (default), add, update, remove, clear",
+        default="list",
+    ),
+]
+
+Content = Annotated[
+    Optional[str],
+    Field(
+        description="Todo content for add/update",
+        default=None,
+    ),
+]
+
+TodoId = Annotated[
+    Optional[str],
+    Field(
+        description="Todo ID for update/remove",
+        default=None,
+    ),
+]
+
+Status = Annotated[
+    Optional[str],
+    Field(
+        description="Status: pending, in_progress, completed",
+        default="pending",
+    ),
+]
+
+Priority = Annotated[
+    Optional[str],
+    Field(
+        description="Priority: high, medium, low",
+        default="medium",
+    ),
+]
+
+Filter = Annotated[
+    Optional[str],
+    Field(
+        description="Filter todos by status for list action",
+        default=None,
+    ),
+]
+
+
+class TodoParams(TypedDict, total=False):
+    """Parameters for todo tool."""
+    action: str
+    content: Optional[str]
+    id: Optional[str]
+    status: Optional[str]
+    priority: Optional[str]
+    filter: Optional[str]
+
+
+@final
+class TodoTool(TodoBaseTool):
+    """Unified todo management tool."""
+
+    @property
+    @override
+    def name(self) -> str:
+        """Get the tool name."""
+        return "todo"
+
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Manage todos. Actions: list (default), add, update, remove, clear.
+
+Usage:
+todo
+todo "Fix the bug in authentication"
+todo --action update --id abc123 --status completed
+todo --action remove --id abc123
+todo --filter in_progress
+"""
+
+    @override
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[TodoParams],
+    ) -> str:
+        """Execute todo operation."""
+        tool_ctx = self.create_tool_context(ctx)
+
+        # Extract action
+        action = params.get("action", "list")
+        
+        # Route to appropriate handler
+        if action == "list":
+            return await self._handle_list(params.get("filter"), tool_ctx)
+        elif action == "add":
+            return await self._handle_add(params, tool_ctx)
+        elif action == "update":
+            return await self._handle_update(params, tool_ctx)
+        elif action == "remove":
+            return await self._handle_remove(params.get("id"), tool_ctx)
+        elif action == "clear":
+            return await self._handle_clear(params.get("filter"), tool_ctx)
+        else:
+            return f"Error: Unknown action '{action}'. Valid actions: list, add, update, remove, clear"
+
+    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:
+            status = todo.get("status", "pending")
+            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']}")
+        
+        # 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', []))}")
+        
+        return "\n".join(output)
+
+    async def _handle_add(self, params: Dict[str, Any], tool_ctx) -> str:
+        """Add new todo."""
+        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,
+            "status": params.get("status", "pending"),
+            "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}"
+
+    async def _handle_update(self, params: Dict[str, Any], tool_ctx) -> str:
+        """Update existing todo."""
+        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"]
+        if params.get("status"):
+            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']})"
+
+    async def _handle_remove(self, todo_id: Optional[str], tool_ctx) -> str:
+        """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)"
+
+    def register(self, mcp_server) -> None:
+        """Register this tool with the MCP server."""
+        pass

hanzo_mcp/tools/todo/todo_read.py

@@ -6,9 +6,8 @@ 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 fastmcp import Context as MCPContext
-from fastmcp import FastMCP
-from fastmcp.server.dependencies import get_context
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.todo.base import TodoBaseTool, TodoStorage
@@ -141,8 +140,7 @@ Usage:
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def todo_read(
-            ctx: MCPContext,
             session_id: SessionId,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(ctx, session_id=session_id)

hanzo_mcp/tools/todo/todo_write.py

@@ -5,9 +5,8 @@ This module provides the TodoWrite tool for creating and managing a structured t
 
 from typing import Annotated, Literal, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
-from fastmcp.server.dependencies import get_context
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.todo.base import TodoBaseTool, TodoStorage
@@ -370,9 +369,8 @@ When in doubt, use this tool. Being proactive with task management demonstrates
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def todo_write(
-            ctx: MCPContext,
             session_id: SessionId,
             todos: Todos,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(ctx, session_id=session_id, todos=todos)

hanzo_mcp/tools/vector/__init__.py

@@ -9,7 +9,7 @@ Supported backends:
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from fastmcp import FastMCP
+from mcp.server import FastMCP
 
 # Try to import vector dependencies
 try:

hanzo_mcp/tools/vector/index_tool.py

@@ -6,7 +6,7 @@ import time
 from pathlib import Path
 from typing import Annotated, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
+from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool