mirror of
https://github.com/hanzoai/stack.git
synced 2026-11-19 03:06:57 +00:00
538 lines
15 KiB
Python
538 lines
15 KiB
Python
"""Unified find tool implementation.
|
|
|
|
This module provides the FindTool for finding text patterns in files using
|
|
multiple search backends in order of preference: rg > ag > ack > grep.
|
|
"""
|
|
|
|
import re
|
|
import json
|
|
import shutil
|
|
import asyncio
|
|
import fnmatch
|
|
from typing import (
|
|
List,
|
|
Unpack,
|
|
Optional,
|
|
Annotated,
|
|
TypedDict,
|
|
final,
|
|
override,
|
|
)
|
|
from pathlib import Path
|
|
|
|
from pydantic import Field
|
|
from mcp.server.fastmcp import Context as MCPContext
|
|
|
|
from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
|
|
|
|
# Parameter types
|
|
Pattern = Annotated[
|
|
str,
|
|
Field(
|
|
description="Pattern to search for (regex or literal)",
|
|
min_length=1,
|
|
),
|
|
]
|
|
|
|
SearchPath = Annotated[
|
|
str,
|
|
Field(
|
|
description="Path to search in",
|
|
default=".",
|
|
),
|
|
]
|
|
|
|
Include = Annotated[
|
|
Optional[str],
|
|
Field(
|
|
description='File pattern to include (e.g. "*.js")',
|
|
default=None,
|
|
),
|
|
]
|
|
|
|
Exclude = Annotated[
|
|
Optional[str],
|
|
Field(
|
|
description="File pattern to exclude",
|
|
default=None,
|
|
),
|
|
]
|
|
|
|
CaseSensitive = Annotated[
|
|
bool,
|
|
Field(
|
|
description="Case sensitive search",
|
|
default=True,
|
|
),
|
|
]
|
|
|
|
FixedStrings = Annotated[
|
|
bool,
|
|
Field(
|
|
description="Treat pattern as literal string, not regex",
|
|
default=False,
|
|
),
|
|
]
|
|
|
|
ShowContext = Annotated[
|
|
int,
|
|
Field(
|
|
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,
|
|
),
|
|
]
|
|
|
|
|
|
class FindParams(TypedDict, total=False):
|
|
"""Parameters for find tool."""
|
|
|
|
pattern: str
|
|
path: str
|
|
include: Optional[str]
|
|
exclude: Optional[str]
|
|
case_sensitive: bool
|
|
fixed_strings: bool
|
|
show_context: int
|
|
backend: Optional[str]
|
|
|
|
|
|
@final
|
|
class FindTool(FilesystemBaseTool):
|
|
"""Unified find tool with multiple backend support."""
|
|
|
|
def __init__(self, permission_manager):
|
|
"""Initialize the find tool."""
|
|
super().__init__(permission_manager)
|
|
self._backend_order = ["rg", "ag", "ack", "grep"]
|
|
self._available_backends = None
|
|
|
|
@property
|
|
@override
|
|
def name(self) -> str:
|
|
"""Get the tool name."""
|
|
return "find"
|
|
|
|
@property
|
|
@override
|
|
def description(self) -> str:
|
|
"""Get the tool description."""
|
|
backends = self._get_available_backends()
|
|
backend_str = ", ".join(backends) if backends else "fallback grep"
|
|
|
|
return f"""Find pattern in files (like ffind). Available: {backend_str}.
|
|
|
|
Usage:
|
|
find "TODO"
|
|
find "error.*fatal" ./src
|
|
find "config" --include "*.json"
|
|
find "password" --exclude "*.log"
|
|
|
|
Fast, intuitive file content search."""
|
|
|
|
def _get_available_backends(self) -> List[str]:
|
|
"""Get list of available search backends."""
|
|
if self._available_backends is None:
|
|
self._available_backends = []
|
|
for backend in self._backend_order:
|
|
if shutil.which(backend):
|
|
self._available_backends.append(backend)
|
|
return self._available_backends
|
|
|
|
@override
|
|
async def call(
|
|
self,
|
|
ctx: MCPContext,
|
|
**params: Unpack[FindParams],
|
|
) -> str:
|
|
"""Execute find operation."""
|
|
tool_ctx = self.create_tool_context(ctx)
|
|
|
|
# Extract parameters
|
|
pattern = params.get("pattern")
|
|
if not pattern:
|
|
return "Error: pattern is required"
|
|
|
|
path = params.get("path", ".")
|
|
include = params.get("include")
|
|
exclude = params.get("exclude")
|
|
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)
|
|
if path_validation.is_error:
|
|
await tool_ctx.error(path_validation.error_message)
|
|
return f"Error: {path_validation.error_message}"
|
|
|
|
# Check permissions
|
|
allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
|
|
if not allowed:
|
|
return error_msg
|
|
|
|
# Check existence
|
|
exists, error_msg = await self.check_path_exists(path, tool_ctx)
|
|
if not exists:
|
|
return error_msg
|
|
|
|
# Select backend
|
|
available = self._get_available_backends()
|
|
|
|
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:
|
|
# Fallback
|
|
selected_backend = "grep"
|
|
|
|
await tool_ctx.info(
|
|
f"Using {selected_backend} to search for '{pattern}' in {path}"
|
|
)
|
|
|
|
# Execute search
|
|
if selected_backend == "rg":
|
|
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(
|
|
pattern,
|
|
path,
|
|
include,
|
|
exclude,
|
|
case_sensitive,
|
|
fixed_strings,
|
|
show_context,
|
|
tool_ctx,
|
|
)
|
|
elif selected_backend == "ack":
|
|
return await self._run_ack(
|
|
pattern,
|
|
path,
|
|
include,
|
|
exclude,
|
|
case_sensitive,
|
|
fixed_strings,
|
|
show_context,
|
|
tool_ctx,
|
|
)
|
|
else:
|
|
return await self._run_fallback_grep(
|
|
pattern,
|
|
path,
|
|
include,
|
|
exclude,
|
|
case_sensitive,
|
|
fixed_strings,
|
|
show_context,
|
|
tool_ctx,
|
|
)
|
|
|
|
async def _run_ripgrep(
|
|
self,
|
|
pattern,
|
|
path,
|
|
include,
|
|
exclude,
|
|
case_sensitive,
|
|
fixed_strings,
|
|
show_context,
|
|
tool_ctx,
|
|
) -> str:
|
|
"""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}"])
|
|
|
|
cmd.extend([pattern, path])
|
|
|
|
try:
|
|
process = await asyncio.create_subprocess_exec(
|
|
*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
|
|
)
|
|
|
|
stdout, stderr = await process.communicate()
|
|
|
|
if process.returncode not in [0, 1]: # 1 = no matches
|
|
await tool_ctx.error(f"ripgrep failed: {stderr.decode()}")
|
|
return f"Error: {stderr.decode()}"
|
|
|
|
return self._parse_ripgrep_output(stdout.decode())
|
|
|
|
except Exception as e:
|
|
await tool_ctx.error(f"Error running ripgrep: {str(e)}")
|
|
return f"Error running ripgrep: {str(e)}"
|
|
|
|
async def _run_silver_searcher(
|
|
self,
|
|
pattern,
|
|
path,
|
|
include,
|
|
exclude,
|
|
case_sensitive,
|
|
fixed_strings,
|
|
show_context,
|
|
tool_ctx,
|
|
) -> str:
|
|
"""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])
|
|
|
|
cmd.extend([pattern, path])
|
|
|
|
try:
|
|
process = await asyncio.create_subprocess_exec(
|
|
*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
|
|
)
|
|
|
|
stdout, stderr = await process.communicate()
|
|
|
|
if process.returncode not in [0, 1]:
|
|
await tool_ctx.error(f"ag failed: {stderr.decode()}")
|
|
return f"Error: {stderr.decode()}"
|
|
|
|
output = stdout.decode()
|
|
if not output.strip():
|
|
return "No matches found."
|
|
|
|
lines = output.strip().split("\n")
|
|
return f"Found {len(lines)} matches:\n\n" + output
|
|
|
|
except Exception as e:
|
|
await tool_ctx.error(f"Error running ag: {str(e)}")
|
|
return f"Error running ag: {str(e)}"
|
|
|
|
async def _run_ack(
|
|
self,
|
|
pattern,
|
|
path,
|
|
include,
|
|
exclude,
|
|
case_sensitive,
|
|
fixed_strings,
|
|
show_context,
|
|
tool_ctx,
|
|
) -> str:
|
|
"""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",
|
|
]
|
|
)
|
|
|
|
cmd.extend([pattern, path])
|
|
|
|
try:
|
|
process = await asyncio.create_subprocess_exec(
|
|
*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
|
|
)
|
|
|
|
stdout, stderr = await process.communicate()
|
|
|
|
if process.returncode not in [0, 1]:
|
|
await tool_ctx.error(f"ack failed: {stderr.decode()}")
|
|
return f"Error: {stderr.decode()}"
|
|
|
|
output = stdout.decode()
|
|
if not output.strip():
|
|
return "No matches found."
|
|
|
|
lines = output.strip().split("\n")
|
|
return f"Found {len(lines)} matches:\n\n" + output
|
|
|
|
except Exception as e:
|
|
await tool_ctx.error(f"Error running ack: {str(e)}")
|
|
return f"Error running ack: {str(e)}"
|
|
|
|
async def _run_fallback_grep(
|
|
self,
|
|
pattern,
|
|
path,
|
|
include,
|
|
exclude,
|
|
case_sensitive,
|
|
fixed_strings,
|
|
show_context,
|
|
tool_ctx,
|
|
) -> str:
|
|
"""Fallback Python implementation."""
|
|
await tool_ctx.info("Using fallback Python grep implementation")
|
|
|
|
try:
|
|
input_path = Path(path)
|
|
matching_files = []
|
|
|
|
# Get files to search
|
|
if input_path.is_file():
|
|
if self._match_file_pattern(input_path.name, include, exclude):
|
|
matching_files.append(input_path)
|
|
else:
|
|
for entry in input_path.rglob("*"):
|
|
if entry.is_file() and self.is_path_allowed(str(entry)):
|
|
if self._match_file_pattern(entry.name, include, exclude):
|
|
matching_files.append(entry)
|
|
|
|
if not matching_files:
|
|
return "No matching files found."
|
|
|
|
# Compile pattern
|
|
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 = []
|
|
total_matches = 0
|
|
|
|
for file_path in matching_files:
|
|
try:
|
|
with open(file_path, "r", encoding="utf-8") as f:
|
|
lines = f.readlines()
|
|
|
|
for i, line in enumerate(lines, 1):
|
|
if regex.search(line):
|
|
# 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
|
|
|
|
except UnicodeDecodeError:
|
|
pass # Skip binary files
|
|
except Exception as e:
|
|
await tool_ctx.warning(f"Error reading {file_path}: {str(e)}")
|
|
|
|
if not results:
|
|
return "No matches found."
|
|
|
|
return f"Found {total_matches} matches:\n\n" + "\n".join(results)
|
|
|
|
except Exception as e:
|
|
await tool_ctx.error(f"Error in fallback grep: {str(e)}")
|
|
return f"Error in fallback grep: {str(e)}"
|
|
|
|
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):
|
|
return False
|
|
if exclude and fnmatch.fnmatch(filename, exclude):
|
|
return False
|
|
return True
|
|
|
|
def _parse_ripgrep_output(self, output: str) -> str:
|
|
"""Parse ripgrep JSON output."""
|
|
if not output.strip():
|
|
return "No matches found."
|
|
|
|
results = []
|
|
total_matches = 0
|
|
|
|
for line in output.splitlines():
|
|
if not line.strip():
|
|
continue
|
|
|
|
try:
|
|
data = json.loads(line)
|
|
|
|
if data.get("type") == "match":
|
|
match_data = data.get("data", {})
|
|
path = match_data.get("path", {}).get("text", "")
|
|
line_number = match_data.get("line_number", 0)
|
|
line_text = match_data.get("lines", {}).get("text", "").rstrip()
|
|
|
|
results.append(f"{path}:{line_number}:{line_text}")
|
|
total_matches += 1
|
|
|
|
elif data.get("type") == "context":
|
|
context_data = data.get("data", {})
|
|
path = context_data.get("path", {}).get("text", "")
|
|
line_number = context_data.get("line_number", 0)
|
|
line_text = context_data.get("lines", {}).get("text", "").rstrip()
|
|
|
|
results.append(f"{path}:{line_number}-{line_text}")
|
|
|
|
except json.JSONDecodeError:
|
|
pass
|
|
|
|
if not results:
|
|
return "No matches found."
|
|
|
|
return f"Found {total_matches} matches:\n\n" + "\n".join(results)
|
|
|
|
def register(self, mcp_server) -> None:
|
|
"""Register this tool with the MCP server."""
|
|
pass
|