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

hanzo_mcp/tools/filesystem/__init__.py

@@ -4,107 +4,147 @@ This package provides tools for interacting with the filesystem, including readi
 and editing files, directory navigation, and content searching.
 """
 
-from mcp.server.fastmcp import FastMCP
+from fastmcp import FastMCP
 
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
-from hanzo_mcp.tools.common.context import DocumentContext
+
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.filesystem.content_replace import ContentReplaceTool
 from hanzo_mcp.tools.filesystem.directory_tree import DirectoryTreeTool
-from hanzo_mcp.tools.filesystem.edit_file import EditFileTool
-from hanzo_mcp.tools.filesystem.get_file_info import GetFileInfoTool
-from hanzo_mcp.tools.filesystem.read_files import ReadFilesTool
-from hanzo_mcp.tools.filesystem.search_content import SearchContentTool
-from hanzo_mcp.tools.filesystem.write_file import WriteFileTool
+from hanzo_mcp.tools.filesystem.edit import Edit
+from hanzo_mcp.tools.filesystem.grep import Grep
+from hanzo_mcp.tools.filesystem.grep_ast_tool import GrepAstTool
+from hanzo_mcp.tools.filesystem.multi_edit import MultiEdit
+from hanzo_mcp.tools.filesystem.read import ReadTool
+from hanzo_mcp.tools.filesystem.write import Write
+from hanzo_mcp.tools.filesystem.unified_search import UnifiedSearchTool
 
 # Export all tool classes
 __all__ = [
-    "ReadFilesTool",
-    "WriteFileTool",
-    "EditFileTool",
+    "ReadTool",
+    "Write",
+    "Edit",
+    "MultiEdit",
     "DirectoryTreeTool",
-    "GetFileInfoTool",
-    "SearchContentTool",
+    "Grep",
     "ContentReplaceTool",
+    "GrepAstTool",
+    "UnifiedSearchTool",
     "get_filesystem_tools",
     "register_filesystem_tools",
 ]
 
+
 def get_read_only_filesystem_tools(
-            document_context: DocumentContext, permission_manager: PermissionManager,
-            disable_search_tools: bool = False
+    permission_manager: PermissionManager,
 ) -> list[BaseTool]:
     """Create instances of read-only filesystem tools.
-    
+
     Args:
-        document_context: Document context for tracking file contents
         permission_manager: Permission manager for access control
-        disable_search_tools: Whether to disable search tools (default: False)
 
     Returns:
         List of read-only filesystem tool instances
     """
-    tools = [
-        ReadFilesTool(document_context, permission_manager),
-        DirectoryTreeTool(document_context, permission_manager),
-        GetFileInfoTool(document_context, permission_manager),
+    return [
+        ReadTool(permission_manager),
+        DirectoryTreeTool(permission_manager),
+        Grep(permission_manager),
+        GrepAstTool(permission_manager),
     ]
-    
-    if not disable_search_tools:
-        tools.append(SearchContentTool(document_context, permission_manager))
-        
-    return tools
 
 
-def get_filesystem_tools(
-    document_context: DocumentContext, permission_manager: PermissionManager,
-    disable_search_tools: bool = False
-) -> list[BaseTool]:
+def get_filesystem_tools(permission_manager: PermissionManager) -> list[BaseTool]:
     """Create instances of all filesystem tools.
-    
+
     Args:
-        document_context: Document context for tracking file contents
         permission_manager: Permission manager for access control
-        disable_search_tools: Whether to disable search tools (default: False)
-        
+
     Returns:
         List of filesystem tool instances
     """
-    tools = [
-        ReadFilesTool(document_context, permission_manager),
-        WriteFileTool(document_context, permission_manager),
-        EditFileTool(document_context, permission_manager),
-        DirectoryTreeTool(document_context, permission_manager),
-        GetFileInfoTool(document_context, permission_manager),
+    return [
+        ReadTool(permission_manager),
+        Write(permission_manager),
+        Edit(permission_manager),
+        MultiEdit(permission_manager),
+        DirectoryTreeTool(permission_manager),
+        Grep(permission_manager),
+        ContentReplaceTool(permission_manager),
+        GrepAstTool(permission_manager),
     ]
-    
-    if not disable_search_tools:
-        tools.extend([
-            SearchContentTool(document_context, permission_manager),
-            ContentReplaceTool(document_context, permission_manager),
-        ])
-        
-    return tools
 
 
 def register_filesystem_tools(
     mcp_server: FastMCP,
-    document_context: DocumentContext,
     permission_manager: PermissionManager,
     disable_write_tools: bool = False,
     disable_search_tools: bool = False,
-) -> None:
-    """Register all filesystem tools with the MCP server.
-    
+    enabled_tools: dict[str, bool] | None = None,
+    project_manager=None,
+) -> list[BaseTool]:
+    """Register filesystem tools with the MCP server.
+
     Args:
         mcp_server: The FastMCP server instance
-        document_context: Document context for tracking file contents
         permission_manager: Permission manager for access control
-        disable_write_tools: Whether to disable write/edit tools (default: False)
+        disable_write_tools: Whether to disable write tools (default: False)
         disable_search_tools: Whether to disable search tools (default: False)
+        enabled_tools: Dictionary of individual tool enable states (default: None)
+        project_manager: Optional project manager for unified search (default: None)
+
+    Returns:
+        List of registered tools
     """
-    if disable_write_tools:
-        tools = get_read_only_filesystem_tools(document_context, permission_manager, disable_search_tools)
+    # Define tool mapping
+    tool_classes = {
+        "read": ReadTool,
+        "write": Write,
+        "edit": Edit,
+        "multi_edit": MultiEdit,
+        "directory_tree": DirectoryTreeTool,
+        "grep": Grep,
+        "grep_ast": GrepAstTool,
+        "content_replace": ContentReplaceTool,
+        "unified_search": UnifiedSearchTool,
+    }
+    
+    tools = []
+    
+    if enabled_tools:
+        # Use individual tool configuration
+        for tool_name, enabled in enabled_tools.items():
+            if enabled and tool_name in tool_classes:
+                tool_class = tool_classes[tool_name]
+                if tool_name == "unified_search":
+                    # Unified search requires project_manager
+                    tools.append(tool_class(permission_manager, project_manager))
+                else:
+                    tools.append(tool_class(permission_manager))
     else:
-        tools = get_filesystem_tools(document_context, permission_manager, disable_search_tools)
+        # Use category-level configuration (backward compatibility)
+        if disable_write_tools and disable_search_tools:
+            # Only read and directory tools
+            tools = [
+                ReadTool(permission_manager),
+                DirectoryTreeTool(permission_manager),
+            ]
+        elif disable_write_tools:
+            # Read-only tools including search
+            tools = get_read_only_filesystem_tools(permission_manager)
+        elif disable_search_tools:
+            # Write tools but no search
+            tools = [
+                ReadTool(permission_manager),
+                Write(permission_manager),
+                Edit(permission_manager),
+                MultiEdit(permission_manager),
+                DirectoryTreeTool(permission_manager),
+                ContentReplaceTool(permission_manager),
+            ]
+        else:
+            # All tools
+            tools = get_filesystem_tools(permission_manager)
+    
     ToolRegistry.register_tools(mcp_server, tools)
+    return tools

hanzo_mcp/tools/filesystem/base.py

@@ -8,27 +8,29 @@ from abc import ABC
 from pathlib import Path
 from typing import Any
 
-from mcp.server.fastmcp import Context as MCPContext
+from fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import FileSystemTool
 from hanzo_mcp.tools.common.context import ToolContext, create_tool_context
 
 
-class FilesystemBaseTool(FileSystemTool,ABC):
+class FilesystemBaseTool(FileSystemTool, ABC):
     """Enhanced base class for all filesystem tools.
-    
+
     Provides additional utilities specific to filesystem operations beyond
     the base functionality in FileSystemTool.
     """
-    
-    async def check_path_allowed(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
+
+    async def check_path_allowed(
+        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
+    ) -> tuple[bool, str]:
         """Check if a path is allowed and log an error if not.
-        
+
         Args:
             path: Path to check
             tool_ctx: Tool context for logging
             error_prefix: Prefix for error messages
-            
+
         Returns:
             tuple of (is_allowed, error_message)
         """
@@ -37,15 +39,17 @@ class FilesystemBaseTool(FileSystemTool,ABC):
             await tool_ctx.error(message)
             return False, f"{error_prefix}: {message}"
         return True, ""
-        
-    async def check_path_exists(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
+
+    async def check_path_exists(
+        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
+    ) -> tuple[bool, str]:
         """Check if a path exists and log an error if not.
-        
+
         Args:
             path: Path to check
             tool_ctx: Tool context for logging
             error_prefix: Prefix for error messages
-            
+
         Returns:
             tuple of (exists, error_message)
         """
@@ -55,15 +59,17 @@ class FilesystemBaseTool(FileSystemTool,ABC):
             await tool_ctx.error(message)
             return False, f"{error_prefix}: {message}"
         return True, ""
-        
-    async def check_is_file(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
+
+    async def check_is_file(
+        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
+    ) -> tuple[bool, str]:
         """Check if a path is a file and log an error if not.
-        
+
         Args:
             path: Path to check
             tool_ctx: Tool context for logging
             error_prefix: Prefix for error messages
-            
+
         Returns:
             tuple of (is_file, error_message)
         """
@@ -73,15 +79,17 @@ class FilesystemBaseTool(FileSystemTool,ABC):
             await tool_ctx.error(message)
             return False, f"{error_prefix}: {message}"
         return True, ""
-        
-    async def check_is_directory(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
+
+    async def check_is_directory(
+        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
+    ) -> tuple[bool, str]:
         """Check if a path is a directory and log an error if not.
-        
+
         Args:
             path: Path to check
             tool_ctx: Tool context for logging
             error_prefix: Prefix for error messages
-            
+
         Returns:
             tuple of (is_directory, error_message)
         """
@@ -91,22 +99,22 @@ class FilesystemBaseTool(FileSystemTool,ABC):
             await tool_ctx.error(message)
             return False, f"{error_prefix}: {message}"
         return True, ""
-        
+
     def create_tool_context(self, ctx: MCPContext) -> ToolContext:
         """Create a tool context with the tool name.
-        
+
         Args:
             ctx: MCP context
-            
+
         Returns:
             Tool context
         """
         tool_ctx = create_tool_context(ctx)
         return tool_ctx
-        
+
     def set_tool_context_info(self, tool_ctx: ToolContext) -> None:
         """Set the tool info on the context.
-        
+
         Args:
             tool_ctx: Tool context
         """

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,
+            )