hanzo-mcp 0.8.11__py3-none-any.whl → 0.9.0__py3-none-any.whl

hanzo_mcp/tools/filesystem/__init__.py

@@ -9,25 +9,30 @@ from mcp.server import FastMCP
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
 from hanzo_mcp.tools.filesystem.diff import create_diff_tool
 from hanzo_mcp.tools.filesystem.edit import Edit
-from hanzo_mcp.tools.filesystem.grep import Grep
 from hanzo_mcp.tools.filesystem.read import ReadTool
 from hanzo_mcp.tools.filesystem.watch import watch_tool
 from hanzo_mcp.tools.filesystem.write import Write
 from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.filesystem.ast_tool import ASTTool
-from hanzo_mcp.tools.filesystem.find_files import FindFilesTool
+from hanzo_mcp.tools.filesystem.find import FindTool
 from hanzo_mcp.tools.filesystem.git_search import GitSearchTool
 from hanzo_mcp.tools.filesystem.multi_edit import MultiEdit
 from hanzo_mcp.tools.filesystem.rules_tool import RulesTool
-from hanzo_mcp.tools.filesystem.search_tool import SearchTool
-from hanzo_mcp.tools.filesystem.batch_search import BatchSearchTool
 from hanzo_mcp.tools.filesystem.directory_tree import DirectoryTreeTool
 from hanzo_mcp.tools.filesystem.content_replace import ContentReplaceTool
 
+# Import unified search tool (which includes legacy Grep as alias)
+from hanzo_mcp.tools.filesystem.search import (
+    UnifiedSearchTool,
+    Grep,  # Legacy alias for backward compatibility
+    create_unified_search_tool,
+    create_grep_tool,
+)
+
 # Import new search tools
 try:
     from hanzo_mcp.tools.search import (
-        FindTool,
+        FindTool as SearchFindTool,  # Rename to avoid conflict with filesystem FindTool
         UnifiedSearch,
         create_find_tool,
         create_unified_search_tool,
@@ -44,14 +49,15 @@ __all__ = [
     "Edit",
     "MultiEdit",
     "DirectoryTreeTool",
-    "Grep",
+    "Grep",  # Legacy alias for UnifiedSearchTool
+    "UnifiedSearchTool",  # New unified search tool
     "ContentReplaceTool",
     "ASTTool",
     "GitSearchTool",
-    "BatchSearchTool",
-    "FindFilesTool",
+    "FindTool",
     "RulesTool",
-    "SearchTool",
+    "create_unified_search_tool",
+    "create_grep_tool",
     "get_filesystem_tools",
     "register_filesystem_tools",
 ]
@@ -76,15 +82,14 @@ def get_read_only_filesystem_tools(
         Grep(permission_manager),
         ASTTool(permission_manager),
         GitSearchTool(permission_manager),
-        FindFilesTool(permission_manager),
+        FindTool(permission_manager),
         RulesTool(permission_manager),
         watch_tool,
         create_diff_tool(permission_manager),
     ]
 
-    # Add search if project manager is available
-    if project_manager:
-        tools.append(SearchTool(permission_manager, project_manager))
+    # Add unified search tool (replaces old SearchTool and BatchSearchTool)
+    tools.append(UnifiedSearchTool(permission_manager, project_manager))
 
     # Add new search tools if available
     if UNIFIED_SEARCH_AVAILABLE:
@@ -93,9 +98,7 @@ def get_read_only_filesystem_tools(
     return tools
 
 
-def get_filesystem_tools(
-    permission_manager: PermissionManager, project_manager=None
-) -> list[BaseTool]:
+def get_filesystem_tools(permission_manager: PermissionManager, project_manager=None) -> list[BaseTool]:
     """Create instances of all filesystem tools.
 
     Args:
@@ -115,15 +118,14 @@ def get_filesystem_tools(
         ContentReplaceTool(permission_manager),
         ASTTool(permission_manager),
         GitSearchTool(permission_manager),
-        FindFilesTool(permission_manager),
+        FindTool(permission_manager),
         RulesTool(permission_manager),
         watch_tool,
         create_diff_tool(permission_manager),
     ]
 
-    # Add search if project manager is available
-    if project_manager:
-        tools.append(SearchTool(permission_manager, project_manager))
+    # Add unified search tool (replaces old SearchTool and BatchSearchTool)
+    tools.append(UnifiedSearchTool(permission_manager, project_manager))
 
     # Add new search tools if available
     if UNIFIED_SEARCH_AVAILABLE:
@@ -160,14 +162,13 @@ def register_filesystem_tools(
         "edit": Edit,
         "multi_edit": MultiEdit,
         "directory_tree": DirectoryTreeTool,
-        "grep": Grep,
+        "grep": Grep,  # Legacy alias for UnifiedSearchTool
+        "search": UnifiedSearchTool,  # New unified search tool (replaces SearchTool and BatchSearchTool)
         "ast": ASTTool,  # AST-based code structure search with tree-sitter
         "git_search": GitSearchTool,
         "content_replace": ContentReplaceTool,
-        "batch_search": BatchSearchTool,
-        "find_files": FindFilesTool,
+        "find": FindTool,
         "rules": RulesTool,
-        "search": SearchTool,
         "watch": lambda pm: watch_tool,  # Singleton instance
         "diff": create_diff_tool,
     }
@@ -184,8 +185,8 @@ def register_filesystem_tools(
         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 in ["batch_search", "search"]:
-                    # Batch search and search require project_manager
+                if tool_name == "search":
+                    # Unified search tool requires project_manager
                     tools.append(tool_class(permission_manager, project_manager))
                 elif tool_name == "watch":
                     # Watch tool is a singleton
@@ -226,6 +227,7 @@ def register_filesystem_tools(
     try:
         ast_tool = next((t for t in tools if getattr(t, "name", "") == "ast"), None)
         if ast_tool is not None:
+
             class _SymbolsAlias(ASTTool):  # type: ignore[misc]
                 @property
                 def name(self) -> str:  # type: ignore[override]

hanzo_mcp/tools/filesystem/ast_multi_edit.py

@@ -129,9 +129,7 @@ class ASTMultiEdit(BaseTool):
 
         return parser.parse(bytes(content, "utf-8"))
 
-    def _find_references(
-        self, symbol: str, file_path: str, project_root: Optional[str] = None
-    ) -> List[ASTMatch]:
+    def _find_references(self, symbol: str, file_path: str, project_root: Optional[str] = None) -> List[ASTMatch]:
         """Find all references to a symbol across the project."""
         matches = []
 
@@ -149,9 +147,7 @@ class ASTMultiEdit(BaseTool):
 
         return matches
 
-    def _get_reference_patterns(
-        self, symbol: str, file_path: str
-    ) -> List[Dict[str, Any]]:
+    def _get_reference_patterns(self, symbol: str, file_path: str) -> List[Dict[str, Any]]:
         """Get language-specific patterns for finding references."""
         ext = Path(file_path).suffix.lower()
         lang = self.languages.get(ext, "generic")
@@ -262,9 +258,7 @@ class ASTMultiEdit(BaseTool):
                     matches.extend(self._query_ast(tree, pattern, file_path, content))
                 else:
                     # Fallback to text search
-                    matches.extend(
-                        self._text_search(content, pattern["query"], file_path)
-                    )
+                    matches.extend(self._text_search(content, pattern["query"], file_path))
 
             except Exception:
                 continue
@@ -313,9 +307,7 @@ class ASTMultiEdit(BaseTool):
 
         return matches
 
-    def _get_parent_context(
-        self, node: tree_sitter.Node, content: str
-    ) -> Optional[str]:
+    def _get_parent_context(self, node: tree_sitter.Node, content: str) -> Optional[str]:
         """Get parent context for better understanding."""
         parent = node.parent
         if parent:
@@ -335,9 +327,7 @@ class ASTMultiEdit(BaseTool):
 
         return None
 
-    def _text_search(
-        self, content: str, pattern: str, file_path: str
-    ) -> List[ASTMatch]:
+    def _text_search(self, content: str, pattern: str, file_path: str) -> List[ASTMatch]:
         """Fallback text search."""
         matches = []
         lines = content.split("\n")
@@ -412,18 +402,14 @@ class ASTMultiEdit(BaseTool):
 
         return str(path.parent)
 
-    def _group_matches_by_file(
-        self, matches: List[ASTMatch]
-    ) -> Dict[str, List[ASTMatch]]:
+    def _group_matches_by_file(self, matches: List[ASTMatch]) -> Dict[str, List[ASTMatch]]:
         """Group matches by file for efficient editing."""
         grouped = defaultdict(list)
         for match in matches:
             grouped[match.file_path].append(match)
         return grouped
 
-    def _create_unique_context(
-        self, content: str, match: ASTMatch, context_lines: int
-    ) -> str:
+    def _create_unique_context(self, content: str, match: ASTMatch, context_lines: int) -> str:
         """Create unique context for edit identification."""
         lines = content.split("\n")
 
@@ -499,27 +485,20 @@ class ASTMultiEdit(BaseTool):
                         pattern = {"query": edit_op.old_string, "type": "text"}
                         matches = self._query_ast(tree, pattern, file_path, content)
                     else:
-                        matches = self._text_search(
-                            content, edit_op.old_string, file_path
-                        )
+                        matches = self._text_search(content, edit_op.old_string, file_path)
 
                 # Filter by node types if specified
                 if edit_op.node_types:
                     matches = [m for m in matches if m.node_type in edit_op.node_types]
 
                 # Check expected count
-                if (
-                    edit_op.expect_count is not None
-                    and len(matches) != edit_op.expect_count
-                ):
+                if edit_op.expect_count is not None and len(matches) != edit_op.expect_count:
                     results["errors"].append(
                         {
                             "edit": edit_op.old_string,
                             "expected": edit_op.expect_count,
                             "found": len(matches),
-                            "locations": [
-                                f"{m.file_path}:{m.line_start}" for m in matches[:5]
-                            ],
+                            "locations": [f"{m.file_path}:{m.line_start}" for m in matches[:5]],
                         }
                     )
                     continue
@@ -547,9 +526,7 @@ class ASTMultiEdit(BaseTool):
                 success = await self._apply_file_changes(file_path, changes)
                 if success:
                     results["edits_applied"] += len(changes)
-                    results["changes"].append(
-                        {"file": file_path, "edits": len(changes)}
-                    )
+                    results["changes"].append({"file": file_path, "edits": len(changes)})
             except Exception as e:
                 results["errors"].append({"file": file_path, "error": str(e)})
 
@@ -564,9 +541,7 @@ class ASTMultiEdit(BaseTool):
             grouped[match.file_path].append((edit_op, match))
         return grouped
 
-    async def _apply_file_changes(
-        self, file_path: str, changes: List[Tuple[EditOperation, ASTMatch]]
-    ) -> bool:
+    async def _apply_file_changes(self, file_path: str, changes: List[Tuple[EditOperation, ASTMatch]]) -> bool:
         """Apply changes to a single file."""
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
@@ -600,9 +575,7 @@ class ASTMultiEdit(BaseTool):
 
         return True
 
-    def _generate_preview(
-        self, matches: List[Tuple[EditOperation, ASTMatch]], page_size: int
-    ) -> List[Dict[str, Any]]:
+    def _generate_preview(self, matches: List[Tuple[EditOperation, ASTMatch]], page_size: int) -> List[Dict[str, Any]]:
         """Generate preview of changes."""
         preview = []
 
@@ -625,9 +598,7 @@ class ASTMultiEdit(BaseTool):
 
         return preview
 
-    def _fallback_to_basic_edit(
-        self, file_path: str, edits: List[Dict[str, Any]]
-    ) -> MCPResourceDocument:
+    def _fallback_to_basic_edit(self, file_path: str, edits: List[Dict[str, Any]]) -> MCPResourceDocument:
         """Fallback to basic multi-edit when treesitter not available."""
         # Delegate to existing multi_edit tool
         from hanzo_mcp.tools.filesystem.multi_edit import MultiEdit

hanzo_mcp/tools/filesystem/ast_tool.py

@@ -117,6 +117,9 @@ Searches code structure intelligently, understanding syntax and providing semant
         # Extract parameters
         pattern: Pattern = params["pattern"]
         path: SearchPath = params["path"]
+        
+        # Expand path (handles ~, $HOME, etc.)
+        path = self.expand_path(path)
         ignore_case = params.get("ignore_case", False)
         line_number = params.get("line_number", False)
 

hanzo_mcp/tools/filesystem/base.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import FileSystemTool
+from hanzo_mcp.tools.common.path_utils import resolve_path
 from hanzo_mcp.tools.common.context import ToolContext, create_tool_context
 
 
@@ -21,9 +22,22 @@ class FilesystemBaseTool(FileSystemTool, ABC):
     the base functionality in FileSystemTool.
     """
 
-    async def check_path_allowed(
-        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
-    ) -> tuple[bool, str]:
+    @staticmethod
+    def expand_path(path: str) -> str:
+        """Expand user home directory (~) and environment variables in a path.
+        
+        This method uses the centralized resolve_path function to ensure
+        consistent path resolution across all tools.
+
+        Args:
+            path: The path to expand
+
+        Returns:
+            The fully resolved absolute path
+        """
+        return resolve_path(path)
+
+    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:
@@ -40,9 +54,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
             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:
@@ -60,9 +72,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
             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:
@@ -80,9 +90,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
             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:

hanzo_mcp/tools/filesystem/content_replace.py

@@ -121,6 +121,9 @@ Only works within allowed directories."""
         pattern: Pattern = params["pattern"]
         replacement: Replacement = params["replacement"]
         path: SearchPath = params["path"]
+        
+        # Expand path (handles ~, $HOME, etc.)
+        path = self.expand_path(path)
         file_pattern = params.get("file_pattern", "*")  # Default to all files
         dry_run = params.get("dry_run", False)  # Default to False
 
@@ -159,15 +162,11 @@ 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
@@ -186,9 +185,7 @@ Only works within allowed directories."""
                 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")
@@ -251,9 +248,7 @@ Only works within allowed directories."""
                 )
                 message = f"Dry run: {replacements_made} replacements of '{pattern}' with '{replacement}' would be made in {files_modified} files:"
             else:
-                await tool_ctx.info(
-                    f"Made {replacements_made} replacements in {files_modified} files"
-                )
+                await tool_ctx.info(f"Made {replacements_made} replacements in {files_modified} files")
                 message = f"Made {replacements_made} replacements of '{pattern}' with '{replacement}' in {files_modified} files:"
 
             return message + "\n\n" + "\n".join(results)

hanzo_mcp/tools/filesystem/diff.py

@@ -166,16 +166,8 @@ diff a.json b.json --ignore-whitespace"""
             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)