Files

370 lines
10 KiB
Python

"""Find files using ffind library."""
import os
from typing import Unpack, Optional, Annotated, TypedDict, final, override
from pydantic import Field
from mcp.server.fastmcp import Context as MCPContext
from hanzo_mcp.tools.common.base import BaseTool
from hanzo_mcp.tools.common.context import create_tool_context
from hanzo_mcp.tools.common.permissions import PermissionManager
try:
import ffind
FFIND_AVAILABLE = True
except ImportError:
FFIND_AVAILABLE = False
Pattern = Annotated[
str,
Field(
description="File name pattern to search for (supports wildcards)",
min_length=1,
),
]
Path_ = Annotated[
Optional[str],
Field(
description="Directory to search in (defaults to current directory)",
default=None,
),
]
Recursive = Annotated[
bool,
Field(
description="Search recursively in subdirectories",
default=True,
),
]
IgnoreCase = Annotated[
bool,
Field(
description="Case-insensitive search",
default=True,
),
]
Hidden = Annotated[
bool,
Field(
description="Include hidden files in search",
default=False,
),
]
DirsOnly = Annotated[
bool,
Field(
description="Only find directories",
default=False,
),
]
FilesOnly = Annotated[
bool,
Field(
description="Only find files (not directories)",
default=True,
),
]
MaxResults = Annotated[
int,
Field(
description="Maximum number of results",
default=100,
),
]
class FindFilesParams(TypedDict, total=False):
"""Parameters for find files tool."""
pattern: str
path: Optional[str]
recursive: bool
ignore_case: bool
hidden: bool
dirs_only: bool
files_only: bool
max_results: int
@final
class FindFilesTool(BaseTool):
"""Tool for finding files using ffind."""
def __init__(self, permission_manager: PermissionManager):
"""Initialize the find files tool.
Args:
permission_manager: Permission manager for access control
"""
self.permission_manager = permission_manager
@property
@override
def name(self) -> str:
"""Get the tool name."""
return "find_files"
@property
@override
def description(self) -> str:
"""Get the tool description."""
return """Find files by name pattern using efficient search.
Uses the ffind library for fast file searching with support for:
- Wildcards (* and ?)
- Case-insensitive search
- Hidden files
- Directory vs file filtering
Examples:
- find_files --pattern "*.py" # Find all Python files
- find_files --pattern "test_*" # Find files starting with test_
- find_files --pattern "README.*" # Find README files
- find_files --pattern "*config*" --hidden # Include hidden config files
- find_files --pattern "src" --dirs-only # Find directories named src
For content search, use 'grep' instead.
For database search, use 'sql_search' or 'vector_search'.
"""
@override
async def call(
self,
ctx: MCPContext,
**params: Unpack[FindFilesParams],
) -> str:
"""Find files matching pattern.
Args:
ctx: MCP context
**params: Tool parameters
Returns:
List of matching files
"""
tool_ctx = create_tool_context(ctx)
await tool_ctx.set_tool_info(self.name)
# Extract parameters
pattern = params.get("pattern")
if not pattern:
return "Error: pattern is required"
search_path = params.get("path") or os.getcwd()
recursive = params.get("recursive", True)
ignore_case = params.get("ignore_case", True)
hidden = params.get("hidden", False)
dirs_only = params.get("dirs_only", False)
files_only = params.get("files_only", True)
max_results = params.get("max_results", 100)
# Validate path
search_path = os.path.abspath(search_path)
if not self.permission_manager.has_permission(search_path):
return f"Error: No permission to access {search_path}"
if not os.path.exists(search_path):
return f"Error: Path does not exist: {search_path}"
await tool_ctx.info(f"Searching for '{pattern}' in {search_path}")
# If ffind is not available, fall back to basic implementation
if not FFIND_AVAILABLE:
return await self._find_files_fallback(
pattern,
search_path,
recursive,
ignore_case,
hidden,
dirs_only,
files_only,
max_results,
)
try:
# Use ffind for efficient searching
results = []
count = 0
# Configure ffind options
options = {
"pattern": pattern,
"path": search_path,
"recursive": recursive,
"ignore_case": ignore_case,
"hidden": hidden,
}
# Search with ffind
for filepath in ffind.find(**options):
# Check if it matches our criteria
is_dir = os.path.isdir(filepath)
if dirs_only and not is_dir:
continue
if files_only and is_dir:
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 count >= max_results:
break
if not results:
return f"No files found matching '{pattern}'"
# Format output
output = [f"Found {len(results)} file(s) matching '{pattern}':"]
output.append("")
for filepath in sorted(results):
output.append(filepath)
if 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 search: {str(e)}")
# Fall back to basic implementation
return await self._find_files_fallback(
pattern,
search_path,
recursive,
ignore_case,
hidden,
dirs_only,
files_only,
max_results,
)
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 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)")
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."""
import fnmatch
if ignore_case:
return fnmatch.fnmatch(filename.lower(), pattern)
else:
return fnmatch.fnmatch(filename, pattern)
def register(self, mcp_server) -> None:
"""Register this tool with the MCP server."""
pass