hanzo-mcp 0.7.7__py3-none-any.whl → 0.8.1__py3-none-any.whl

hanzo_mcp/tools/filesystem/content_replace.py

@@ -4,12 +4,12 @@ This module provides the ContentReplaceTool for replacing text patterns in files
 """
 
 import fnmatch
+from typing import Unpack, Annotated, TypedDict, final, override
 from pathlib import Path
-from typing import Annotated, TypedDict, Unpack, 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.filesystem.base import FilesystemBaseTool
 
@@ -280,7 +280,7 @@ Only works within allowed directories."""
             replacement: Replacement,
             path: SearchPath,
             file_pattern: FilePattern = "*",
-            dry_run: DryRun = False
+            dry_run: DryRun = False,
         ) -> str:
             return await tool_self.call(
                 ctx,

hanzo_mcp/tools/filesystem/diff.py

@@ -1,30 +1,30 @@
 """Diff tool for comparing files."""
 
 import difflib
+from typing import override
 from pathlib import Path
-from typing import Optional, override
 
+from mcp.server import FastMCP
 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:
@@ -36,7 +36,7 @@ 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,
@@ -49,7 +49,7 @@ diff a.json b.json --ignore-whitespace"""
         show_line_numbers: bool = True,
     ) -> str:
         """Compare two files and show differences.
-        
+
         Args:
             ctx: MCP context
             file1: Path to first file
@@ -58,100 +58,104 @@ diff a.json b.json --ignore-whitespace"""
             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:
+            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:
+            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]
-        
+            lines1 = [line.strip() + "\n" for line in lines1]
+            lines2 = [line.strip() + "\n" for line in lines2]
+
         # Generate diff
         if unified:
             #  diff format
-            diff_lines = list(difflib.unified_diff(
-                lines1,
-                lines2,
-                fromfile=str(path1),
-                tofile=str(path2),
-                n=context,
-                lineterm=''
-            ))
+            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=''
-            ))
-        
+            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('@@'):
+                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(',')
+                        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('-'):
+                elif line.startswith("-"):
                     current_line1 += 1
                     output.append(f"{current_line1:4d}- {line[1:]}")
-                elif line.startswith('+'):
+                elif line.startswith("+"):
                     current_line2 += 1
                     output.append(f"{current_line2:4d}+ {line[1:]}")
-                elif line.startswith(' '):
+                elif line.startswith(" "):
                     current_line1 += 1
                     current_line2 += 1
                     output.append(f"{current_line1:4d}  {line[1:]}")
@@ -160,21 +164,29 @@ diff a.json b.json --ignore-whitespace"""
         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('---'))
-        
+        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)
+
+        return "\n".join(output)
 
     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 diff_handler(
             ctx: MCPContext,
@@ -183,7 +195,7 @@ diff a.json b.json --ignore-whitespace"""
             unified: bool = True,
             context: int = 3,
             ignore_whitespace: bool = False,
-            show_line_numbers: bool = True
+            show_line_numbers: bool = True,
         ) -> str:
             """Handle diff tool calls."""
             return await tool_self.run(
@@ -195,7 +207,7 @@ diff a.json b.json --ignore-whitespace"""
                 ignore_whitespace=ignore_whitespace,
                 show_line_numbers=show_line_numbers,
             )
-    
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(
@@ -205,18 +217,18 @@ diff a.json b.json --ignore-whitespace"""
             unified=params.get("unified", True),
             context=params.get("context", 3),
             ignore_whitespace=params.get("ignore_whitespace", False),
-            show_line_numbers=params.get("show_line_numbers", True)
+            show_line_numbers=params.get("show_line_numbers", True),
         )
 
 
 # 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)
+    return DiffTool(permission_manager)

hanzo_mcp/tools/filesystem/directory_tree.py

@@ -3,15 +3,15 @@
 This module provides the DirectoryTreeTool for viewing file and directory structures.
 """
 
+from typing import Any, Unpack, Annotated, TypedDict, final, override
 from pathlib import Path
-from typing import Annotated, Any, TypedDict, Unpack, 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.filesystem.base import FilesystemBaseTool
 from hanzo_mcp.tools.common.truncate import truncate_response
+from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
 DirectoryPath = Annotated[
     str,
@@ -283,9 +283,9 @@ requested. Only works within allowed directories."""
             # Truncate response to stay within token limits
             full_response = formatted_output + summary
             return truncate_response(
-                full_response, 
+                full_response,
                 max_tokens=25000,
-                truncation_message="\n\n[Response truncated due to token limit. Please use a smaller depth, specific subdirectory, or the paginated version of this tool.]"
+                truncation_message="\n\n[Response truncated due to token limit. Please use a smaller depth, specific subdirectory, or the paginated version of this tool.]",
             )
         except Exception as e:
             await tool_ctx.error(f"Error generating directory tree: {str(e)}")
@@ -308,7 +308,7 @@ requested. Only works within allowed directories."""
             ctx: MCPContext,
             path: DirectoryPath,
             depth: Depth = 3,
-            include_filtered: IncludeFiltered = False
+            include_filtered: IncludeFiltered = False,
         ) -> str:
             return await tool_self.call(
                 ctx, path=path, depth=depth, include_filtered=include_filtered

hanzo_mcp/tools/filesystem/directory_tree_paginated.py

@@ -4,18 +4,27 @@ This module provides a paginated version of DirectoryTreeTool that supports
 MCP cursor-based pagination for large directory structures.
 """
 
+from typing import (
+    Any,
+    Dict,
+    List,
+    Unpack,
+    Optional,
+    Annotated,
+    TypedDict,
+    final,
+    override,
+)
 from pathlib import Path
-from typing import Annotated, Any, Dict, List, Optional, TypedDict, Unpack, 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.filesystem.base import FilesystemBaseTool
 from hanzo_mcp.tools.common.pagination import (
     CursorManager,
-    PaginatedResponse,
-    paginate_list
+    paginate_list,
 )
 
 DirectoryPath = Annotated[
@@ -128,7 +137,7 @@ Returns nextCursor if more entries are available."""
         depth = params.get("depth", 3)
         include_filtered = params.get("include_filtered", False)
         page_size = params.get("page_size", 100)
-        cursor = params.get("cursor", None)
+        cursor = params.get("cursor")
 
         # Validate cursor if provided
         if cursor:
@@ -196,9 +205,7 @@ Returns nextCursor if more entries are available."""
 
             # Build the tree and collect entries
             def collect_entries(
-                current_path: Path,
-                current_depth: int = 0,
-                parent_path: str = ""
+                current_path: Path, current_depth: int = 0, parent_path: str = ""
             ) -> None:
                 """Collect entries in a flat list for pagination."""
                 if not self.is_path_allowed(str(current_path)):
@@ -207,8 +214,7 @@ Returns nextCursor if more entries are available."""
                 try:
                     # Sort entries: directories first, then files alphabetically
                     entries = sorted(
-                        current_path.iterdir(),
-                        key=lambda x: (not x.is_dir(), x.name)
+                        current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name)
                     )
 
                     for entry in entries:
@@ -216,7 +222,9 @@ Returns nextCursor if more entries are available."""
                             continue
 
                         # Calculate relative path for display
-                        relative_path = f"{parent_path}/{entry.name}" if parent_path else entry.name
+                        relative_path = (
+                            f"{parent_path}/{entry.name}" if parent_path else entry.name
+                        )
 
                         if entry.is_dir():
                             entry_data: Dict[str, Any] = {
@@ -241,19 +249,17 @@ Returns nextCursor if more entries are available."""
                             all_entries.append(entry_data)
 
                             # Process children recursively
-                            collect_entries(
-                                entry,
-                                current_depth + 1,
-                                relative_path
-                            )
+                            collect_entries(entry, current_depth + 1, relative_path)
                         else:
                             # Add file entry
                             if depth <= 0 or current_depth < depth:
-                                all_entries.append({
-                                    "path": relative_path,
-                                    "type": "file",
-                                    "depth": current_depth,
-                                })
+                                all_entries.append(
+                                    {
+                                        "path": relative_path,
+                                        "type": "file",
+                                        "depth": current_depth,
+                                    }
+                                )
 
                 except Exception as e:
                     await tool_ctx.warning(f"Error processing {current_path}: {str(e)}")
@@ -271,28 +277,34 @@ Returns nextCursor if more entries are available."""
                 indent = "  " * entry["depth"]
                 if entry["type"] == "directory":
                     if "skipped" in entry:
-                        formatted_entries.append({
-                            "entry": f"{indent}{entry['path'].split('/')[-1]}/ [skipped - {entry['skipped']}]",
-                            "type": "directory",
-                            "skipped": entry.get("skipped")
-                        })
+                        formatted_entries.append(
+                            {
+                                "entry": f"{indent}{entry['path'].split('/')[-1]}/ [skipped - {entry['skipped']}]",
+                                "type": "directory",
+                                "skipped": entry.get("skipped"),
+                            }
+                        )
                     else:
-                        formatted_entries.append({
-                            "entry": f"{indent}{entry['path'].split('/')[-1]}/",
-                            "type": "directory"
-                        })
+                        formatted_entries.append(
+                            {
+                                "entry": f"{indent}{entry['path'].split('/')[-1]}/",
+                                "type": "directory",
+                            }
+                        )
                 else:
-                    formatted_entries.append({
-                        "entry": f"{indent}{entry['path'].split('/')[-1]}",
-                        "type": "file"
-                    })
+                    formatted_entries.append(
+                        {
+                            "entry": f"{indent}{entry['path'].split('/')[-1]}",
+                            "type": "file",
+                        }
+                    )
 
             # Build response
             response = {
                 "entries": formatted_entries,
                 "total_collected": len(all_entries),
                 "page_size": page_size,
-                "current_page_count": len(formatted_entries)
+                "current_page_count": len(formatted_entries),
             }
 
             # Add next cursor if available
@@ -335,4 +347,4 @@ Returns nextCursor if more entries are available."""
 
 
 # Create the tool instance
-directory_tree_paginated_tool = DirectoryTreePaginatedTool()
+directory_tree_paginated_tool = DirectoryTreePaginatedTool()

hanzo_mcp/tools/filesystem/edit.py

@@ -3,13 +3,13 @@
 This module provides the Edit tool for making precise text replacements in files.
 """
 
+from typing import Unpack, Annotated, TypedDict, final, override
 from difflib import unified_diff
 from pathlib import Path
-from typing import Annotated, TypedDict, Unpack, 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.filesystem.base import FilesystemBaseTool
 
@@ -266,7 +266,7 @@ Usage:
             file_path: FilePath,
             old_string: OldString,
             new_string: NewString,
-            expected_replacements: ExpectedReplacements = 1
+            expected_replacements: ExpectedReplacements = 1,
         ) -> str:
             return await tool_self.call(
                 ctx,