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

hanzo_mcp/tools/filesystem/content_replace.py

@@ -5,33 +5,92 @@ This module provides the ContentReplaceTool for replacing text patterns in files
 
 import fnmatch
 from pathlib import Path
-from typing import Any, final, override
+from typing import Annotated, TypedDict, Unpack, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server.fastmcp import FastMCP
+from fastmcp import Context as MCPContext
+from fastmcp import FastMCP
+from fastmcp.server.dependencies import get_context
+from pydantic import Field
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
+Pattern = Annotated[
+    str,
+    Field(
+        description="Text pattern to search for in files",
+        min_length=1,
+    ),
+]
+
+Replacement = Annotated[
+    str,
+    Field(
+        description="Text to replace the pattern with (can be empty string)",
+    ),
+]
+
+SearchPath = Annotated[
+    str,
+    Field(
+        description="Path to file or directory to search in",
+        min_length=1,
+    ),
+]
+
+FilePattern = Annotated[
+    str,
+    Field(
+        description="File name pattern to match (default: all files)",
+        default="*",
+    ),
+]
+
+DryRun = Annotated[
+    bool,
+    Field(
+        description="If True, only preview changes without modifying files",
+        default=False,
+    ),
+]
+
+
+class ContentReplaceToolParams(TypedDict):
+    """Parameters for the ContentReplaceTool.
+
+    Attributes:
+        pattern: Text pattern to search for in files
+        replacement: Text to replace the pattern with (can be empty string)
+        path: Path to file or directory to search in
+        file_pattern: File name pattern to match (default: all files)
+        dry_run: If True, only preview changes without modifying files
+    """
+
+    pattern: Pattern
+    replacement: Replacement
+    path: SearchPath
+    file_pattern: FilePattern
+    dry_run: DryRun
+
 
 @final
 class ContentReplaceTool(FilesystemBaseTool):
     """Tool for replacing text patterns in files."""
-    
+
     @property
     @override
     def name(self) -> str:
         """Get the tool name.
-        
+
         Returns:
             Tool name
         """
         return "content_replace"
-        
+
     @property
     @override
     def description(self) -> str:
         """Get the tool description.
-        
+
         Returns:
             Tool description
         """
@@ -41,97 +100,30 @@ Searches for text patterns across all files in the specified directory
 that match the file pattern and replaces them with the specified text.
 Can be run in dry-run mode to preview changes without applying them.
 Only works within allowed directories."""
-        
-    @property
-    @override
-    def parameters(self) -> dict[str, Any]:
-        """Get the parameter specifications for the tool.
-        
-        Returns:
-            Parameter specifications
-        """
-        return {
-            "properties": {
-                "pattern": {
-                    "title": "Pattern",
-                    "type": "string"
-                },
-                "replacement": {
-                    "title": "Replacement",
-                    "type": "string"
-                },
-                "path": {
-                    "title": "Path",
-                    "type": "string"
-                },
-                "file_pattern": {
-                    "default": "*",
-                    "title": "File Pattern",
-                    "type": "string"
-                },
-                "dry_run": {
-                    "default": False,
-                    "title": "Dry Run",
-                    "type": "boolean"
-                }
-            },
-            "required": ["pattern", "replacement", "path"],
-            "title": "content_replaceArguments",
-            "type": "object"
-        }
-        
-    @property
-    @override
-    def required(self) -> list[str]:
-        """Get the list of required parameter names.
-        
-        Returns:
-            List of required parameter names
-        """
-        return ["pattern", "replacement", "path"]
-        
+
     @override
-    async def call(self, ctx: MCPContext, **params: Any) -> str:
+    async def call(
+        self,
+        ctx: MCPContext,
+        **params: Unpack[ContentReplaceToolParams],
+    ) -> str:
         """Execute the tool with the given parameters.
-        
+
         Args:
             ctx: MCP context
             **params: Tool parameters
-            
+
         Returns:
             Tool result
         """
         tool_ctx = self.create_tool_context(ctx)
-        
+
         # Extract parameters
-        pattern = params.get("pattern")
-        replacement = params.get("replacement")
-        path = params.get("path")
+        pattern: Pattern = params["pattern"]
+        replacement: Replacement = params["replacement"]
+        path: SearchPath = params["path"]
         file_pattern = params.get("file_pattern", "*")  # Default to all files
         dry_run = params.get("dry_run", False)  # Default to False
-        
-        # Validate required parameters
-        if not pattern:
-            await tool_ctx.error("Parameter 'pattern' is required but was None")
-            return "Error: Parameter 'pattern' is required but was None"
-
-        if pattern.strip() == "":
-            await tool_ctx.error("Parameter 'pattern' cannot be empty")
-            return "Error: Parameter 'pattern' cannot be empty"
-
-        if replacement is None:
-            await tool_ctx.error("Parameter 'replacement' is required but was None")
-            return "Error: Parameter 'replacement' is required but was None"
-
-        if not path:
-            await tool_ctx.error("Parameter 'path' is required but was None")
-            return "Error: Parameter 'path' is required but was None"
-
-        if path.strip() == "":
-            await tool_ctx.error("Parameter 'path' cannot be empty")
-            return "Error: Parameter 'path' cannot be empty"
-
-        # Note: replacement can be an empty string as sometimes you want to delete the pattern
 
         path_validation = self.validate_path(path)
         if path_validation.is_error:
@@ -168,32 +160,38 @@ Only works within allowed directories."""
             # Process based on whether path is a file or directory
             if input_path.is_file():
                 # Single file search
-                if file_pattern == "*" or fnmatch.fnmatch(input_path.name, file_pattern):
+                if file_pattern == "*" or fnmatch.fnmatch(
+                    input_path.name, file_pattern
+                ):
                     matching_files.append(input_path)
                     await tool_ctx.info(f"Searching single file: {path}")
                 else:
-                    await tool_ctx.info(f"File does not match pattern '{file_pattern}': {path}")
+                    await tool_ctx.info(
+                        f"File does not match pattern '{file_pattern}': {path}"
+                    )
                     return f"File does not match pattern '{file_pattern}': {path}"
             elif input_path.is_dir():
                 # Directory search - optimized file finding
                 await tool_ctx.info(f"Finding files in directory: {path}")
-                
+
                 # Keep track of allowed paths for filtering
                 allowed_paths: set[str] = set()
-                
+
                 # Collect all allowed paths first for faster filtering
                 for entry in input_path.rglob("*"):
                     entry_path = str(entry)
                     if self.is_path_allowed(entry_path):
                         allowed_paths.add(entry_path)
-                
+
                 # Find matching files efficiently
                 for entry in input_path.rglob("*"):
                     entry_path = str(entry)
                     if entry_path in allowed_paths and entry.is_file():
-                        if file_pattern == "*" or fnmatch.fnmatch(entry.name, file_pattern):
+                        if file_pattern == "*" or fnmatch.fnmatch(
+                            entry.name, file_pattern
+                        ):
                             matching_files.append(entry)
-                
+
                 await tool_ctx.info(f"Found {len(matching_files)} matching files")
             else:
                 # This shouldn't happen since we already checked for existence
@@ -236,17 +234,11 @@ Only works within allowed directories."""
                             with open(file_path, "w", encoding="utf-8") as f:
                                 f.write(new_content)
 
-                            # Update document context
-                            self.document_context.update_document(
-                                str(file_path), new_content
-                            )
                 except UnicodeDecodeError:
                     # Skip binary files
                     continue
                 except Exception as e:
-                    await tool_ctx.warning(
-                        f"Error processing {file_path}: {str(e)}"
-                    )
+                    await tool_ctx.warning(f"Error processing {file_path}: {str(e)}")
 
             # Final progress report
             await tool_ctx.report_progress(total_files, total_files)
@@ -269,19 +261,34 @@ Only works within allowed directories."""
         except Exception as e:
             await tool_ctx.error(f"Error replacing content: {str(e)}")
             return f"Error replacing content: {str(e)}"
-            
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register this content replace tool with the MCP server.
-        
+
         Creates a wrapper function with explicitly defined parameters that match
         the tool's parameter schema and registers it with the MCP server.
-        
+
         Args:
             mcp_server: The FastMCP server instance
         """
         tool_self = self  # Create a reference to self for use in the closure
-        
-        @mcp_server.tool(name=self.name, description=self.mcp_description)
-        async def content_replace(ctx: MCPContext, pattern: str, replacement: str, path: str, file_pattern: str = "*", dry_run: bool = False) -> str:
-             return await tool_self.call(ctx, pattern=pattern, replacement=replacement, path=path, file_pattern=file_pattern, dry_run=dry_run)
+
+        @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,
+        ) -> str:
+            ctx = get_context()
+            return await tool_self.call(
+                ctx,
+                pattern=pattern,
+                replacement=replacement,
+                path=path,
+                file_pattern=file_pattern,
+                dry_run=dry_run,
+            )