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

hanzo_mcp/tools/filesystem/find.py

@@ -1,10 +1,9 @@
 """Unified find tool implementation.
 
-This module provides the FindTool for finding files by name or content using
+This module provides the FindTool for finding text patterns in files using
 multiple search backends in order of preference: rg > ag > ack > grep.
 """
 
-import os
 import re
 import json
 import shutil
@@ -18,26 +17,21 @@ from typing import (
     TypedDict,
     final,
     override,
-    Literal,
 )
 from pathlib import Path
 
 from pydantic import Field
 from mcp.server.fastmcp import Context as MCPContext
 
-from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
+from hanzo_mcp.tools.common.auto_timeout import auto_timeout
 
-try:
-    import ffind
-    FFIND_AVAILABLE = True
-except ImportError:
-    FFIND_AVAILABLE = False
+from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
 # Parameter types
 Pattern = Annotated[
     str,
     Field(
-        description="Pattern to search for (file name pattern or content regex/literal)",
+        description="Pattern to search for (regex or literal)",
         min_length=1,
     ),
 ]
@@ -50,18 +44,10 @@ SearchPath = Annotated[
     ),
 ]
 
-Mode = Annotated[
-    Literal["name", "content", "both"],
-    Field(
-        description="Search mode: 'name' for file names, 'content' for file contents, 'both' for both",
-        default="name",
-    ),
-]
-
 Include = Annotated[
     Optional[str],
     Field(
-        description='File pattern to include (e.g. "*.js", "*.{ts,tsx}")',
+        description='File pattern to include (e.g. "*.js")',
         default=None,
     ),
 ]
@@ -78,22 +64,30 @@ CaseSensitive = Annotated[
     bool,
     Field(
         description="Case sensitive search",
-        default=False,
+        default=True,
     ),
 ]
 
-Recursive = Annotated[
+FixedStrings = Annotated[
     bool,
     Field(
-        description="Search recursively in subdirectories",
-        default=True,
+        description="Treat pattern as literal string, not regex",
+        default=False,
     ),
 ]
 
-MaxResults = Annotated[
-    Optional[int],
+ShowContext = Annotated[
+    int,
     Field(
-        description="Maximum number of results to return",
+        description="Lines of context to show around matches",
+        default=0,
+    ),
+]
+
+Backend = Annotated[
+    Optional[str],
+    Field(
+        description="Force specific backend: rg, ag, ack, grep",
         default=None,
     ),
 ]
@@ -104,17 +98,17 @@ class FindParams(TypedDict, total=False):
 
     pattern: str
     path: str
-    mode: Literal["name", "content", "both"]
     include: Optional[str]
     exclude: Optional[str]
     case_sensitive: bool
-    recursive: bool
-    max_results: Optional[int]
+    fixed_strings: bool
+    show_context: int
+    backend: Optional[str]
 
 
 @final
 class FindTool(FilesystemBaseTool):
-    """Unified find tool for searching by file name or content."""
+    """Unified find tool with multiple backend support."""
 
     def __init__(self, permission_manager):
         """Initialize the find tool."""
@@ -133,24 +127,17 @@ class FindTool(FilesystemBaseTool):
     def description(self) -> str:
         """Get the tool description."""
         backends = self._get_available_backends()
-        backend_str = ", ".join(backends) if backends else "fallback search"
+        backend_str = ", ".join(backends) if backends else "fallback grep"
 
-        return f"""Find files by name, content, or both. Available backends: {backend_str}.
+        return f"""Find pattern in files (like ffind). Available: {backend_str}.
 
-Examples:
-# Find by file name (default mode)
-find "*.py" 
-find "test_*" ./src
-find "README.*" --case-sensitive
+Usage:
+find "TODO"
+find "error.*fatal" ./src
+find "config" --include "*.json"
+find "password" --exclude "*.log"
 
-# Find by content 
-find "TODO" --mode content
-find "error.*fatal" ./src --mode content
-
-# Find both name and content
-find "config" --mode both --include "*.json"
-
-Supports wildcards for names, regex for content."""
+Fast, intuitive file content search."""
 
     def _get_available_backends(self) -> List[str]:
         """Get list of available search backends."""
@@ -162,6 +149,9 @@ Supports wildcards for names, regex for content."""
         return self._available_backends
 
     @override
+    @auto_timeout("find")
+
+
     async def call(
         self,
         ctx: MCPContext,
@@ -176,15 +166,12 @@ Supports wildcards for names, regex for content."""
             return "Error: pattern is required"
 
         path = params.get("path", ".")
-        mode = params.get("mode", "name")
         include = params.get("include")
         exclude = params.get("exclude")
-        case_sensitive = params.get("case_sensitive", False)
-        recursive = params.get("recursive", True)
-        max_results = params.get("max_results")
-
-        # Expand path (handles ~, $HOME, etc.)
-        path = self.expand_path(path)
+        case_sensitive = params.get("case_sensitive", True)
+        fixed_strings = params.get("fixed_strings", False)
+        show_context = params.get("show_context", 0)
+        backend = params.get("backend")
 
         # Validate path
         path_validation = self.validate_path(path)
@@ -202,154 +189,93 @@ Supports wildcards for names, regex for content."""
         if not exists:
             return error_msg
 
-        await tool_ctx.info(f"Searching for '{pattern}' in {path} (mode: {mode})")
+        # Select backend
+        available = self._get_available_backends()
 
-        # Route to appropriate search method
-        if mode == "name":
-            return await self._find_by_name(
-                pattern, path, include, exclude, case_sensitive, recursive, max_results, tool_ctx
-            )
-        elif mode == "content":
-            return await self._find_by_content(
-                pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
-            )
-        elif mode == "both":
-            return await self._find_both(
-                pattern, path, include, exclude, case_sensitive, recursive, max_results, tool_ctx
-            )
+        if backend:
+            # User specified backend
+            if backend not in available and backend != "grep":
+                return f"Error: Backend '{backend}' not available. Available: {', '.join(available + ['grep'])}"
+            selected_backend = backend
+        elif available:
+            # Use first available
+            selected_backend = available[0]
         else:
-            return f"Error: Invalid mode '{mode}'. Use 'name', 'content', or 'both'."
-
-    async def _find_by_name(
-        self, pattern, path, include, exclude, case_sensitive, recursive, max_results, tool_ctx
-    ) -> str:
-        """Find files by name pattern."""
-        search_path = path or os.getcwd()
-        
-        # If ffind is not available, fall back to basic implementation
-        if not FFIND_AVAILABLE:
-            return await self._find_files_fallback(
-                pattern, search_path, recursive, not case_sensitive, False, False, True, max_results or 100
-            )
-
-        try:
-            # Use ffind for efficient searching
-            results = []
-            count = 0
-
-            # Configure ffind options
-            options = {
-                "pattern": pattern,
-                "path": search_path,
-                "recursive": recursive,
-                "ignore_case": not case_sensitive,
-                "hidden": False,
-            }
-
-            # Search with ffind
-            for filepath in ffind.find(**options):
-                # Check if it matches our include/exclude criteria
-                filename = os.path.basename(filepath)
-                if not self._match_file_pattern(filename, include, exclude):
-                    continue
-
-                # Make path relative for cleaner output
-                try:
-                    rel_path = os.path.relpath(filepath, search_path)
-                except ValueError:
-                    rel_path = filepath
-
-                results.append(rel_path)
-                count += 1
-
-                if max_results and count >= max_results:
-                    break
-
-            if not results:
-                return f"No files found matching '{pattern}'"
+            # Fallback
+            selected_backend = "grep"
 
-            # Format output
-            output = [f"Found {len(results)} file(s) matching '{pattern}':"]
-            output.append("")
+        await tool_ctx.info(f"Using {selected_backend} to search for '{pattern}' in {path}")
 
-            for filepath in sorted(results):
-                output.append(filepath)
-
-            if max_results and count >= max_results:
-                output.append(f"\n... (showing first {max_results} results)")
-
-            return "\n".join(output)
-
-        except Exception as e:
-            await tool_ctx.error(f"Error during name search: {str(e)}")
-            # Fall back to basic implementation
-            return await self._find_files_fallback(
-                pattern, search_path, recursive, not case_sensitive, False, False, True, max_results or 100
-            )
-
-    async def _find_by_content(
-        self, pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
-    ) -> str:
-        """Find files by content pattern."""
-        # Select backend for content search
-        available = self._get_available_backends()
-        selected_backend = available[0] if available else "grep"
-
-        await tool_ctx.info(f"Using {selected_backend} for content search")
-
-        # Execute content search
+        # Execute search
         if selected_backend == "rg":
-            return await self._run_ripgrep_content(
-                pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
+            return await self._run_ripgrep(
+                pattern,
+                path,
+                include,
+                exclude,
+                case_sensitive,
+                fixed_strings,
+                show_context,
+                tool_ctx,
             )
         elif selected_backend == "ag":
-            return await self._run_silver_searcher_content(
-                pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
+            return await self._run_silver_searcher(
+                pattern,
+                path,
+                include,
+                exclude,
+                case_sensitive,
+                fixed_strings,
+                show_context,
+                tool_ctx,
             )
         elif selected_backend == "ack":
-            return await self._run_ack_content(
-                pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
+            return await self._run_ack(
+                pattern,
+                path,
+                include,
+                exclude,
+                case_sensitive,
+                fixed_strings,
+                show_context,
+                tool_ctx,
             )
         else:
-            return await self._run_fallback_grep_content(
-                pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
+            return await self._run_fallback_grep(
+                pattern,
+                path,
+                include,
+                exclude,
+                case_sensitive,
+                fixed_strings,
+                show_context,
+                tool_ctx,
             )
 
-    async def _find_both(
-        self, pattern, path, include, exclude, case_sensitive, recursive, max_results, tool_ctx
-    ) -> str:
-        """Find files by both name and content."""
-        # Run both searches
-        name_results = await self._find_by_name(
-            pattern, path, include, exclude, case_sensitive, recursive, max_results, tool_ctx
-        )
-        content_results = await self._find_by_content(
-            pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
-        )
-
-        # Combine results
-        output = ["=== NAME MATCHES ==="]
-        output.append(name_results)
-        output.append("")
-        output.append("=== CONTENT MATCHES ===")
-        output.append(content_results)
-
-        return "\n".join(output)
-
-    async def _run_ripgrep_content(
-        self, pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
+    async def _run_ripgrep(
+        self,
+        pattern,
+        path,
+        include,
+        exclude,
+        case_sensitive,
+        fixed_strings,
+        show_context,
+        tool_ctx,
     ) -> str:
-        """Run ripgrep backend for content search."""
+        """Run ripgrep backend."""
         cmd = ["rg", "--json"]
 
         if not case_sensitive:
             cmd.append("-i")
+        if fixed_strings:
+            cmd.append("-F")
+        if show_context > 0:
+            cmd.extend(["-C", str(show_context)])
         if include:
             cmd.extend(["-g", include])
         if exclude:
             cmd.extend(["-g", f"!{exclude}"])
-        if max_results:
-            cmd.extend(["-m", str(max_results)])
 
         cmd.extend([pattern, path])
 
@@ -370,20 +296,30 @@ Supports wildcards for names, regex for content."""
             await tool_ctx.error(f"Error running ripgrep: {str(e)}")
             return f"Error running ripgrep: {str(e)}"
 
-    async def _run_silver_searcher_content(
-        self, pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
+    async def _run_silver_searcher(
+        self,
+        pattern,
+        path,
+        include,
+        exclude,
+        case_sensitive,
+        fixed_strings,
+        show_context,
+        tool_ctx,
     ) -> str:
-        """Run silver searcher (ag) backend for content search."""
+        """Run silver searcher (ag) backend."""
         cmd = ["ag", "--nocolor", "--nogroup"]
 
         if not case_sensitive:
             cmd.append("-i")
+        if fixed_strings:
+            cmd.append("-F")
+        if show_context > 0:
+            cmd.extend(["-C", str(show_context)])
         if include:
             cmd.extend(["-G", include])
         if exclude:
             cmd.extend(["--ignore", exclude])
-        if max_results:
-            cmd.extend(["-m", str(max_results)])
 
         cmd.extend([pattern, path])
 
@@ -409,23 +345,35 @@ Supports wildcards for names, regex for content."""
             await tool_ctx.error(f"Error running ag: {str(e)}")
             return f"Error running ag: {str(e)}"
 
-    async def _run_ack_content(
-        self, pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
+    async def _run_ack(
+        self,
+        pattern,
+        path,
+        include,
+        exclude,
+        case_sensitive,
+        fixed_strings,
+        show_context,
+        tool_ctx,
     ) -> str:
-        """Run ack backend for content search."""
+        """Run ack backend."""
         cmd = ["ack", "--nocolor", "--nogroup"]
 
         if not case_sensitive:
             cmd.append("-i")
+        if fixed_strings:
+            cmd.append("-Q")
+        if show_context > 0:
+            cmd.extend(["-C", str(show_context)])
         if include:
             # ack uses different syntax for file patterns
-            cmd.extend([
-                "--type-add",
-                f"custom:ext:{include.replace('*.', '')}",
-                "--type=custom",
-            ])
-        if max_results:
-            cmd.extend(["-m", str(max_results)])
+            cmd.extend(
+                [
+                    "--type-add",
+                    f"custom:ext:{include.replace('*.', '')}",
+                    "--type=custom",
+                ]
+            )
 
         cmd.extend([pattern, path])
 
@@ -451,10 +399,18 @@ Supports wildcards for names, regex for content."""
             await tool_ctx.error(f"Error running ack: {str(e)}")
             return f"Error running ack: {str(e)}"
 
-    async def _run_fallback_grep_content(
-        self, pattern, path, include, exclude, case_sensitive, max_results, tool_ctx
+    async def _run_fallback_grep(
+        self,
+        pattern,
+        path,
+        include,
+        exclude,
+        case_sensitive,
+        fixed_strings,
+        show_context,
+        tool_ctx,
     ) -> str:
-        """Fallback Python implementation for content search."""
+        """Fallback Python implementation."""
         await tool_ctx.info("Using fallback Python grep implementation")
 
         try:
@@ -475,11 +431,17 @@ Supports wildcards for names, regex for content."""
                 return "No matching files found."
 
             # Compile pattern
-            flags = 0 if case_sensitive else re.IGNORECASE
-            try:
-                regex = re.compile(pattern, flags)
-            except re.error as e:
-                return f"Error: Invalid regex pattern: {e}"
+            if fixed_strings:
+                pattern_re = re.escape(pattern)
+            else:
+                pattern_re = pattern
+
+            if not case_sensitive:
+                flags = re.IGNORECASE
+            else:
+                flags = 0
+
+            regex = re.compile(pattern_re, flags)
 
             # Search files
             results = []
@@ -492,20 +454,26 @@ Supports wildcards for names, regex for content."""
 
                     for i, line in enumerate(lines, 1):
                         if regex.search(line):
-                            results.append(f"{file_path}:{i}:{line.rstrip()}")
+                            # Format result with context if requested
+                            if show_context > 0:
+                                start = max(0, i - show_context - 1)
+                                end = min(len(lines), i + show_context)
+
+                                context_lines = []
+                                for j in range(start, end):
+                                    prefix = ":" if j + 1 == i else "-"
+                                    context_lines.append(f"{file_path}:{j + 1}{prefix}{lines[j].rstrip()}")
+                                results.extend(context_lines)
+                                results.append("")  # Separator
+                            else:
+                                results.append(f"{file_path}:{i}:{line.rstrip()}")
                             total_matches += 1
-                            
-                            if max_results and total_matches >= max_results:
-                                break
 
                 except UnicodeDecodeError:
                     pass  # Skip binary files
                 except Exception as e:
                     await tool_ctx.warning(f"Error reading {file_path}: {str(e)}")
 
-                if max_results and total_matches >= max_results:
-                    break
-
             if not results:
                 return "No matches found."
 
@@ -515,108 +483,6 @@ Supports wildcards for names, regex for content."""
             await tool_ctx.error(f"Error in fallback grep: {str(e)}")
             return f"Error in fallback grep: {str(e)}"
 
-    async def _find_files_fallback(
-        self,
-        pattern: str,
-        search_path: str,
-        recursive: bool,
-        ignore_case: bool,
-        hidden: bool,
-        dirs_only: bool,
-        files_only: bool,
-        max_results: int,
-    ) -> str:
-        """Fallback implementation for file name search when ffind is not available."""
-        results = []
-        count = 0
-
-        # Convert pattern for case-insensitive matching
-        if ignore_case:
-            pattern = pattern.lower()
-
-        try:
-            if recursive:
-                # Walk directory tree
-                for root, dirs, files in os.walk(search_path):
-                    # Skip hidden directories if not requested
-                    if not hidden:
-                        dirs[:] = [d for d in dirs if not d.startswith(".")]
-
-                    # Check directories
-                    if not files_only:
-                        for dirname in dirs:
-                            if self._match_pattern(dirname, pattern, ignore_case):
-                                filepath = os.path.join(root, dirname)
-                                rel_path = os.path.relpath(filepath, search_path)
-                                results.append(rel_path + "/")
-                                count += 1
-                                if count >= max_results:
-                                    break
-
-                    # Check files
-                    if not dirs_only:
-                        for filename in files:
-                            if not hidden and filename.startswith("."):
-                                continue
-
-                            if self._match_pattern(filename, pattern, ignore_case):
-                                filepath = os.path.join(root, filename)
-                                rel_path = os.path.relpath(filepath, search_path)
-                                results.append(rel_path)
-                                count += 1
-                                if count >= max_results:
-                                    break
-
-                    if count >= max_results:
-                        break
-            else:
-                # Only search in the specified directory
-                for entry in os.listdir(search_path):
-                    if not hidden and entry.startswith("."):
-                        continue
-
-                    filepath = os.path.join(search_path, entry)
-                    is_dir = os.path.isdir(filepath)
-
-                    if dirs_only and not is_dir:
-                        continue
-                    if files_only and is_dir:
-                        continue
-
-                    if self._match_pattern(entry, pattern, ignore_case):
-                        results.append(entry + "/" if is_dir else entry)
-                        count += 1
-                        if count >= max_results:
-                            break
-
-            if not results:
-                return f"No files found matching '{pattern}' (using fallback search)"
-
-            # Format output
-            output = [f"Found {len(results)} file(s) matching '{pattern}' (using fallback search):"]
-            output.append("")
-
-            for filepath in sorted(results):
-                output.append(filepath)
-
-            if count >= max_results:
-                output.append(f"\n... (showing first {max_results} results)")
-
-            if not FFIND_AVAILABLE:
-                output.append("\nNote: Install 'ffind' for faster searching: pip install ffind")
-
-            return "\n".join(output)
-
-        except Exception as e:
-            return f"Error searching for files: {str(e)}"
-
-    def _match_pattern(self, filename: str, pattern: str, ignore_case: bool) -> bool:
-        """Check if filename matches pattern."""
-        if ignore_case:
-            return fnmatch.fnmatch(filename.lower(), pattern)
-        else:
-            return fnmatch.fnmatch(filename, pattern)
-
     def _match_file_pattern(self, filename: str, include: Optional[str], exclude: Optional[str]) -> bool:
         """Check if filename matches include/exclude patterns."""
         if include and not fnmatch.fnmatch(filename, include):
@@ -667,4 +533,4 @@ Supports wildcards for names, regex for content."""
 
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""
-        pass
+        pass