Files

559 lines
16 KiB
Python

"""Git search tool for searching through git history."""
import os
import re
import subprocess
from typing import Unpack, 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
Pattern = Annotated[
str,
Field(
description="Search pattern (regex supported)",
min_length=1,
),
]
SearchPath = Annotated[
str | None,
Field(
description="Path to search in (defaults to current directory)",
default=None,
),
]
SearchType = Annotated[
str,
Field(
description="Type of git search: 'commits', 'content', 'diff', 'log', 'blame'",
default="content",
),
]
CaseSensitive = Annotated[
bool,
Field(
description="Case sensitive search",
default=False,
),
]
MaxCount = Annotated[
int,
Field(
description="Maximum number of results",
default=100,
),
]
Branch = Annotated[
str | None,
Field(
description="Branch to search (defaults to current branch)",
default=None,
),
]
Author = Annotated[
str | None,
Field(
description="Filter by author (for commits/log)",
default=None,
),
]
Since = Annotated[
str | None,
Field(
description="Search commits since date (e.g., '2 weeks ago', '2024-01-01')",
default=None,
),
]
Until = Annotated[
str | None,
Field(
description="Search commits until date",
default=None,
),
]
FilePattern = Annotated[
str | None,
Field(
description="Limit search to files matching pattern",
default=None,
),
]
class GitSearchParams(TypedDict, total=False):
"""Parameters for git search tool."""
pattern: str
path: str | None
search_type: str
case_sensitive: bool
max_count: int
branch: str | None
author: str | None
since: str | None
until: str | None
file_pattern: str | None
@final
class GitSearchTool(BaseTool):
"""Tool for searching through git history efficiently."""
def __init__(self, permission_manager: PermissionManager):
"""Initialize the git search 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 "git_search"
@property
@override
def description(self) -> str:
"""Get the tool description."""
return """Search through git history using native git commands.
Supports multiple search types:
- 'content': Search file contents in history (git grep)
- 'commits': Search commit messages (git log --grep)
- 'diff': Search changes/patches (git log -G)
- 'log': Search commit logs with filters
- 'blame': Find who changed lines matching pattern
Features:
- Regex pattern support
- Case sensitive/insensitive search
- Filter by author, date range, branch
- Limit to specific file patterns
- Efficient native git performance
Examples:
- Search for "TODO" in all history: pattern="TODO", search_type="content"
- Find commits mentioning "fix": pattern="fix", search_type="commits"
- Find when function was added: pattern="def my_func", search_type="diff"
"""
@override
async def call(
self,
ctx: MCPContext,
**params: Unpack[GitSearchParams],
) -> str:
"""Execute git search.
Args:
ctx: MCP context
**params: Tool parameters
Returns:
Search results
"""
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"
path = params.get("path", os.getcwd())
search_type = params.get("search_type", "content")
case_sensitive = params.get("case_sensitive", False)
max_count = params.get("max_count", 100)
branch = params.get("branch")
author = params.get("author")
since = params.get("since")
until = params.get("until")
file_pattern = params.get("file_pattern")
# Resolve absolute path
abs_path = os.path.abspath(path)
# Check permissions
if not self.permission_manager.has_permission(abs_path):
return f"Permission denied: {abs_path}"
# Check if it's a git repository
if not os.path.exists(os.path.join(abs_path, ".git")):
# Try to find parent git directory
parent = abs_path
while parent != os.path.dirname(parent):
parent = os.path.dirname(parent)
if os.path.exists(os.path.join(parent, ".git")):
abs_path = parent
break
else:
return f"Not a git repository: {path}"
await tool_ctx.info(f"Searching git history in {abs_path}")
try:
if search_type == "content":
return await self._search_content(
abs_path,
pattern,
case_sensitive,
max_count,
branch,
file_pattern,
tool_ctx,
)
elif search_type == "commits":
return await self._search_commits(
abs_path,
pattern,
case_sensitive,
max_count,
branch,
author,
since,
until,
file_pattern,
tool_ctx,
)
elif search_type == "diff":
return await self._search_diff(
abs_path,
pattern,
case_sensitive,
max_count,
branch,
author,
since,
until,
file_pattern,
tool_ctx,
)
elif search_type == "log":
return await self._search_log(
abs_path,
pattern,
max_count,
branch,
author,
since,
until,
file_pattern,
tool_ctx,
)
elif search_type == "blame":
return await self._search_blame(
abs_path, pattern, case_sensitive, file_pattern, tool_ctx
)
else:
return f"Unknown search type: {search_type}"
except subprocess.CalledProcessError as e:
await tool_ctx.error(f"Git command failed: {e}")
return f"Git search failed: {e.stderr if e.stderr else str(e)}"
except Exception as e:
await tool_ctx.error(f"Search failed: {e}")
return f"Error: {str(e)}"
async def _search_content(
self,
repo_path: str,
pattern: str,
case_sensitive: bool,
max_count: int,
branch: str | None,
file_pattern: str | None,
tool_ctx,
) -> str:
"""Search file contents in git history."""
cmd = ["git", "grep", "-n", f"--max-count={max_count}"]
if not case_sensitive:
cmd.append("-i")
if branch:
cmd.append(branch)
else:
cmd.append("--all") # Search all branches
cmd.append(pattern)
if file_pattern:
cmd.extend(["--", file_pattern])
result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
if result.returncode == 0:
lines = result.stdout.strip().split("\n")
if lines and lines[0]:
await tool_ctx.info(f"Found {len(lines)} matches")
return self._format_grep_results(lines, pattern)
else:
return f"No matches found for pattern: {pattern}"
elif result.returncode == 1:
return f"No matches found for pattern: {pattern}"
else:
raise subprocess.CalledProcessError(
result.returncode, cmd, result.stdout, result.stderr
)
async def _search_commits(
self,
repo_path: str,
pattern: str,
case_sensitive: bool,
max_count: int,
branch: str | None,
author: str | None,
since: str | None,
until: str | None,
file_pattern: str | None,
tool_ctx,
) -> str:
"""Search commit messages."""
cmd = ["git", "log", f"--max-count={max_count}", "--oneline"]
grep_flag = "--grep" if case_sensitive else "--grep-ignore-case"
cmd.extend([grep_flag, pattern])
if branch:
cmd.append(branch)
else:
cmd.append("--all")
if author:
cmd.extend(["--author", author])
if since:
cmd.extend(["--since", since])
if until:
cmd.extend(["--until", until])
if file_pattern:
cmd.extend(["--", file_pattern])
result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
if result.returncode == 0:
lines = result.stdout.strip().split("\n")
if lines and lines[0]:
await tool_ctx.info(f"Found {len(lines)} commits")
return (
f"Found {len(lines)} commits matching '{pattern}':\n\n"
+ result.stdout
)
else:
return f"No commits found matching: {pattern}"
else:
raise subprocess.CalledProcessError(
result.returncode, cmd, result.stdout, result.stderr
)
async def _search_diff(
self,
repo_path: str,
pattern: str,
case_sensitive: bool,
max_count: int,
branch: str | None,
author: str | None,
since: str | None,
until: str | None,
file_pattern: str | None,
tool_ctx,
) -> str:
"""Search for pattern in diffs (when code was added/removed)."""
cmd = ["git", "log", f"--max-count={max_count}", "-p"]
# Use -G for diff search (shows commits that added/removed pattern)
search_flag = f"-G{pattern}"
if not case_sensitive:
# For case-insensitive, we need to use -G with regex
import re
case_insensitive_pattern = "".join(
f"[{c.upper()}{c.lower()}]" if c.isalpha() else re.escape(c)
for c in pattern
)
search_flag = f"-G{case_insensitive_pattern}"
cmd.append(search_flag)
if branch:
cmd.append(branch)
else:
cmd.append("--all")
if author:
cmd.extend(["--author", author])
if since:
cmd.extend(["--since", since])
if until:
cmd.extend(["--until", until])
if file_pattern:
cmd.extend(["--", file_pattern])
result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
if result.returncode == 0 and result.stdout.strip():
# Parse and highlight matching lines
output = self._highlight_diff_matches(
result.stdout, pattern, case_sensitive
)
matches = output.count("commit ")
await tool_ctx.info(f"Found {matches} commits with changes")
return f"Found {matches} commits with changes matching '{pattern}':\n\n{output}"
else:
return f"No changes found matching: {pattern}"
async def _search_log(
self,
repo_path: str,
pattern: str | None,
max_count: int,
branch: str | None,
author: str | None,
since: str | None,
until: str | None,
file_pattern: str | None,
tool_ctx,
) -> str:
"""Search git log with filters."""
cmd = ["git", "log", f"--max-count={max_count}", "--oneline"]
if pattern:
# Search in commit message and changes
cmd.extend(["--grep", pattern, f"-G{pattern}"])
if branch:
cmd.append(branch)
else:
cmd.append("--all")
if author:
cmd.extend(["--author", author])
if since:
cmd.extend(["--since", since])
if until:
cmd.extend(["--until", until])
if file_pattern:
cmd.extend(["--", file_pattern])
result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
if result.returncode == 0 and result.stdout.strip():
lines = result.stdout.strip().split("\n")
await tool_ctx.info(f"Found {len(lines)} commits")
return f"Found {len(lines)} commits:\n\n" + result.stdout
else:
return "No commits found matching criteria"
async def _search_blame(
self,
repo_path: str,
pattern: str,
case_sensitive: bool,
file_pattern: str | None,
tool_ctx,
) -> str:
"""Search using git blame to find who changed lines."""
if not file_pattern:
return "Error: file_pattern is required for blame search"
# First, find files matching the pattern
cmd = ["git", "ls-files", file_pattern]
result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
if result.returncode != 0 or not result.stdout.strip():
return f"No files found matching: {file_pattern}"
files = result.stdout.strip().split("\n")
all_matches = []
for file_path in files[:10]: # Limit to 10 files
# Get blame for the file
cmd = ["git", "blame", "-l", file_path]
result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
if result.returncode == 0:
# Search for pattern in blame output
flags = 0 if case_sensitive else re.IGNORECASE
for line in result.stdout.split("\n"):
if re.search(pattern, line, flags):
all_matches.append(f"{file_path}: {line}")
if all_matches:
await tool_ctx.info(f"Found {len(all_matches)} matching lines")
return (
f"Found {len(all_matches)} lines matching '{pattern}':\n\n"
+ "\n".join(all_matches[:50])
) # Limit output
else:
return f"No lines found matching: {pattern}"
def _format_grep_results(self, lines: list[str], pattern: str) -> str:
"""Format git grep results nicely."""
output = []
current_ref = None
for line in lines:
if ":" in line:
parts = line.split(":", 3)
if len(parts) >= 3:
ref = parts[0]
file_path = parts[1]
line_num = parts[2]
content = parts[3] if len(parts) > 3 else ""
if ref != current_ref:
current_ref = ref
output.append(f"\n=== {ref} ===")
output.append(f"{file_path}:{line_num}: {content}")
return f"Found matches for '{pattern}':\n" + "\n".join(output)
def _highlight_diff_matches(
self, diff_output: str, pattern: str, case_sensitive: bool
) -> str:
"""Highlight matching lines in diff output."""
lines = diff_output.split("\n")
output = []
flags = 0 if case_sensitive else re.IGNORECASE
for line in lines:
if line.startswith(("+", "-")) and not line.startswith(("+++", "---")):
if re.search(pattern, line[1:], flags):
output.append(f">>> {line}") # Highlight matching lines
else:
output.append(line)
else:
output.append(line)
return "\n".join(output)
def register(self, mcp_server) -> None:
"""Register this tool with the MCP server."""
pass