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

hanzo_mcp/tools/filesystem/content_replace.py

@@ -7,9 +7,8 @@ import fnmatch
 from pathlib import Path
 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.filesystem.base import FilesystemBaseTool
@@ -276,14 +275,13 @@ Only works within allowed directories."""
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def content_replace(
-            ctx: MCPContext,
             pattern: Pattern,
             replacement: Replacement,
             path: SearchPath,
             file_pattern: FilePattern,
             dry_run: DryRun,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(
                 ctx,
                 pattern=pattern,

hanzo_mcp/tools/filesystem/diff.py

@@ -0,0 +1,193 @@
+"""Diff tool for comparing files."""
+
+import difflib
+from pathlib import Path
+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.common.permissions import PermissionManager
+from mcp.server import FastMCP
+
+
+class DiffTool(BaseTool):
+    """Tool for comparing files and showing differences."""
+    
+    name = "diff"
+    
+    def __init__(self, permission_manager: PermissionManager):
+        """Initialize the diff tool.
+        
+        Args:
+            permission_manager: Permission manager for access control
+        """
+        super().__init__()
+        self.permission_manager = permission_manager
+    
+    @property
+    @override
+    def description(self) -> str:
+        """Get the tool description."""
+        return """Compare files and show differences. Supports unified and context diff formats.
+
+Usage:
+diff file1.py file2.py
+diff old_version.js new_version.js --context 5
+diff before.txt after.txt --unified
+diff a.json b.json --ignore-whitespace"""
+    
+    @override
+    async def run(
+        self,
+        ctx: MCPContext,
+        file1: str,
+        file2: str,
+        unified: bool = True,
+        context: int = 3,
+        ignore_whitespace: bool = False,
+        show_line_numbers: bool = True,
+    ) -> str:
+        """Compare two files and show differences.
+        
+        Args:
+            ctx: MCP context
+            file1: Path to first file
+            file2: Path to second file
+            unified: Use unified diff format (default: True)
+            context: Number of context lines to show (default: 3)
+            ignore_whitespace: Ignore whitespace differences (default: False)
+            show_line_numbers: Show line numbers in output (default: True)
+            
+        Returns:
+            Diff output showing differences between files
+        """
+        # Resolve file paths
+        path1 = Path(file1).expanduser().resolve()
+        path2 = Path(file2).expanduser().resolve()
+        
+        # Check permissions
+        if not self.permission_manager.is_path_allowed(str(path1)):
+            raise PermissionError(f"Access denied to path: {path1}")
+        if not self.permission_manager.is_path_allowed(str(path2)):
+            raise PermissionError(f"Access denied to path: {path2}")
+        
+        # Check if files exist
+        if not path1.exists():
+            raise ValueError(f"File not found: {path1}")
+        if not path2.exists():
+            raise ValueError(f"File not found: {path2}")
+        
+        # Read file contents
+        try:
+            with open(path1, 'r', encoding='utf-8') as f:
+                lines1 = f.readlines()
+        except Exception as e:
+            raise RuntimeError(f"Error reading {path1}: {e}")
+        
+        try:
+            with open(path2, 'r', encoding='utf-8') as f:
+                lines2 = f.readlines()
+        except Exception as e:
+            raise RuntimeError(f"Error reading {path2}: {e}")
+        
+        # Optionally normalize whitespace
+        if ignore_whitespace:
+            lines1 = [line.strip() + '\n' for line in lines1]
+            lines2 = [line.strip() + '\n' for line in lines2]
+        
+        # Generate diff
+        if unified:
+            # Unified diff format
+            diff_lines = list(difflib.unified_diff(
+                lines1,
+                lines2,
+                fromfile=str(path1),
+                tofile=str(path2),
+                n=context,
+                lineterm=''
+            ))
+        else:
+            # Context diff format
+            diff_lines = list(difflib.context_diff(
+                lines1,
+                lines2,
+                fromfile=str(path1),
+                tofile=str(path2),
+                n=context,
+                lineterm=''
+            ))
+        
+        if not diff_lines:
+            return f"Files {path1.name} and {path2.name} are identical"
+        
+        # Format output
+        output = []
+        
+        # Add header
+        output.append(f"Comparing: {path1.name} vs {path2.name}")
+        output.append("=" * 60)
+        
+        # Add diff with optional line numbers
+        if show_line_numbers and unified:
+            # Parse unified diff to add line numbers
+            current_line1 = 0
+            current_line2 = 0
+            
+            for line in diff_lines:
+                if line.startswith('@@'):
+                    # Parse hunk header
+                    parts = line.split()
+                    if len(parts) >= 3:
+                        # Extract line numbers
+                        old_info = parts[1].strip('-').split(',')
+                        new_info = parts[2].strip('+').split(',')
+                        current_line1 = int(old_info[0]) - 1
+                        current_line2 = int(new_info[0]) - 1
+                    output.append(line)
+                elif line.startswith('-'):
+                    current_line1 += 1
+                    output.append(f"{current_line1:4d}- {line[1:]}")
+                elif line.startswith('+'):
+                    current_line2 += 1
+                    output.append(f"{current_line2:4d}+ {line[1:]}")
+                elif line.startswith(' '):
+                    current_line1 += 1
+                    current_line2 += 1
+                    output.append(f"{current_line1:4d}  {line[1:]}")
+                else:
+                    output.append(line)
+        else:
+            # Standard diff output
+            output.extend(diff_lines)
+        
+        # Add summary
+        additions = sum(1 for line in diff_lines if line.startswith('+') and not line.startswith('+++'))
+        deletions = sum(1 for line in diff_lines if line.startswith('-') and not line.startswith('---'))
+        
+        output.append("")
+        output.append("=" * 60)
+        output.append(f"Summary: {additions} additions, {deletions} deletions")
+        
+        return '\n'.join(output)
+
+    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 (requires permission manager to be set)
+def create_diff_tool(permission_manager: PermissionManager) -> DiffTool:
+    """Create a diff tool instance.
+    
+    Args:
+        permission_manager: Permission manager for access control
+        
+    Returns:
+        Configured diff tool instance
+    """
+    return DiffTool(permission_manager)

hanzo_mcp/tools/filesystem/directory_tree.py

@@ -6,9 +6,8 @@ This module provides the DirectoryTreeTool for viewing file and directory struct
 from pathlib import Path
 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.filesystem.base import FilesystemBaseTool
@@ -299,12 +298,11 @@ requested. Only works within allowed directories."""
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def directory_tree(
-            ctx: MCPContext,
             path: DirectoryPath,
             depth: Depth,
             include_filtered: IncludeFiltered,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(
                 ctx, path=path, depth=depth, include_filtered=include_filtered
             )

hanzo_mcp/tools/filesystem/edit.py

@@ -7,9 +7,8 @@ from difflib import unified_diff
 from pathlib import Path
 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.filesystem.base import FilesystemBaseTool
@@ -263,13 +262,12 @@ Usage:
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def edit(
-            ctx: MCPContext,
             file_path: FilePath,
             old_string: OldString,
             new_string: NewString,
             expected_replacements: ExpectedReplacements,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(
                 ctx,
                 file_path=file_path,