hanzo-mcp 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

hanzo_mcp/tools/filesystem/git_search.py

@@ -0,0 +1,505 @@
+"""Git search tool for searching through git history."""
+
+import os
+import subprocess
+import re
+from typing import Annotated, TypedDict, Unpack, final, override
+
+from mcp.server.fastmcp import Context as MCPContext
+from pydantic import Field
+
+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

hanzo_mcp/tools/filesystem/grep.py

@@ -12,8 +12,8 @@ import shutil
 from pathlib import Path
 from typing import Annotated, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.common.context import ToolContext

hanzo_mcp/tools/filesystem/multi_edit.py

@@ -7,9 +7,8 @@ from difflib import unified_diff
 from pathlib import Path
 from typing import Annotated, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
-from fastmcp.server.dependencies import get_context
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
@@ -350,11 +349,10 @@ If you want to create a new file, use:
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def multi_edit(
-            ctx: MCPContext,
             file_path: FilePath,
             edits: Edits,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(
                 ctx,
                 file_path=file_path,

hanzo_mcp/tools/filesystem/read.py

@@ -6,9 +6,8 @@ This module provides the ReadTool for reading the contents of files.
 from pathlib import Path
 from typing import Annotated, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
-from fastmcp.server.dependencies import get_context
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from pydantic import Field
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
@@ -230,6 +229,20 @@ Usage:
             await tool_ctx.error(f"Error reading file: {str(e)}")
             return f"Error: {str(e)}"
 
+    async def run(self, ctx: MCPContext, file_path: str, offset: int = 0, limit: int = 2000) -> str:
+        """Run method for backwards compatibility with test scripts.
+        
+        Args:
+            ctx: MCP context
+            file_path: Path to file to read
+            offset: Line offset to start reading
+            limit: Maximum lines to read
+            
+        Returns:
+            File contents
+        """
+        return await self.call(ctx, file_path=file_path, offset=offset, limit=limit)
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server.
@@ -244,12 +257,11 @@ Usage:
 
         @mcp_server.tool(name=self.name, description=self.description)
         async def read(
-            ctx: MCPContext,
             file_path: FilePath,
             offset: Offset,
             limit: Limit,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(
                 ctx, file_path=file_path, offset=offset, limit=limit
             )

hanzo_mcp/tools/filesystem/{grep_ast_tool.py → symbols.py}

@@ -1,16 +1,16 @@
-"""Grep AST tool implementation.
+"""Symbols tool implementation.
 
-This module provides the GrepAstTool for searching through source code files with AST context,
-seeing matching lines with useful context showing how they fit into the code structure.
+This module provides the SymbolsTool for searching, indexing, and querying code symbols
+using tree-sitter AST parsing. It can find function definitions, class declarations,
+and other code structures with full context.
 """
 
 import os
 from pathlib import Path
 from typing import Annotated, TypedDict, Unpack, final, override
 
-from fastmcp import Context as MCPContext
-from fastmcp import FastMCP
-from fastmcp.server.dependencies import get_context
+from mcp.server.fastmcp import Context as MCPContext
+from mcp.server import FastMCP
 from grep_ast.grep_ast import TreeContext
 from pydantic import Field
 
@@ -66,8 +66,8 @@ class GrepAstToolParams(TypedDict):
 
 
 @final
-class GrepAstTool(FilesystemBaseTool):
-    """Tool for searching through source code files with AST context."""
+class SymbolsTool(FilesystemBaseTool):
+    """Tool for searching and querying code symbols using tree-sitter AST parsing."""
 
     @property
     @override
@@ -77,7 +77,7 @@ class GrepAstTool(FilesystemBaseTool):
         Returns:
             Tool name
         """
-        return "grep_ast"
+        return "symbols"
 
     @property
     @override
@@ -87,23 +87,14 @@ class GrepAstTool(FilesystemBaseTool):
         Returns:
             Tool description
         """
-        return """Search through source code files and see matching lines with useful AST (Abstract Syntax Tree) context. This tool helps you understand code structure by showing how matched lines fit into functions, classes, and other code blocks.
+        return """Code symbols search with tree-sitter AST. Actions: search (default), index, query.
 
-Unlike traditional search tools like `search_content` that only show matching lines, `grep_ast` leverages the AST to reveal the structural context around matches, making it easier to understand the code organization.
+Usage:
+symbols "function_name" ./src
+symbols --action index --path ./src
+symbols --action query --type function --path ./src
 
-When to use this tool:
-1. When you need to understand where a pattern appears within larger code structures
-2. When searching for function or class definitions that match a pattern
-3. When you want to see not just the matching line but its surrounding context in the code
-4. When exploring unfamiliar codebases and need structural context
-5. When examining how a specific pattern is used across different parts of the codebase
-
-This tool is superior to regular grep/search_content when you need to understand code structure, not just find text matches.
-
-Example usage:
-```
-grep_ast(pattern="function_name", path="/path/to/file.py", ignore_case=False, line_number=True)
-```"""
+Finds code structures (functions, classes, methods) with full context."""
 
     @override
     async def call(
@@ -233,14 +224,13 @@ grep_ast(pattern="function_name", path="/path/to/file.py", ignore_case=False, li
         tool_self = self  # Create a reference to self for use in the closure
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def grep_ast(
-            ctx: MCPContext,
+        async def symbols(
             pattern: Pattern,
             path: SearchPath,
             ignore_case: IgnoreCase,
             line_number: LineNumber,
+            ctx: MCPContext
         ) -> str:
-            ctx = get_context()
             return await tool_self.call(
                 ctx,
                 pattern=pattern,