hanzo-mcp 0.7.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/tools/filesystem/git_search.py

@@ -1,18 +1,17 @@
 """Git search tool for searching through git history."""
 
 import os
-import subprocess
 import re
-from typing import Annotated, TypedDict, Unpack, final, override
+import subprocess
+from typing import Unpack, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
 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(
@@ -188,7 +187,7 @@ Examples:
 
         # 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}"
@@ -210,23 +209,51 @@ Examples:
         try:
             if search_type == "content":
                 return await self._search_content(
-                    abs_path, pattern, case_sensitive, max_count, 
-                    branch, file_pattern, tool_ctx
+                    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
+                    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
+                    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
+                    abs_path,
+                    pattern,
+                    max_count,
+                    branch,
+                    author,
+                    since,
+                    until,
+                    file_pattern,
+                    tool_ctx,
                 )
             elif search_type == "blame":
                 return await self._search_blame(
@@ -243,32 +270,35 @@ Examples:
             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
+        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
-        )
-        
+
+        result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+
         if result.returncode == 0:
-            lines = result.stdout.strip().split('\n')
+            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)
@@ -282,43 +312,51 @@ Examples:
             )
 
     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
+        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
-        )
-        
+
+        result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+
         if result.returncode == 0:
-            lines = result.stdout.strip().split('\n')
+            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
+                return (
+                    f"Found {len(lines)} commits matching '{pattern}':\n\n"
+                    + result.stdout
+                )
             else:
                 return f"No commits found matching: {pattern}"
         else:
@@ -327,51 +365,59 @@ Examples:
             )
 
     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
+        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
-        )
-        
+
+        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)
+            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}"
@@ -379,83 +425,90 @@ Examples:
             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
+        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
-        )
-        
+
+        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')
+            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
+        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
-        )
-        
+        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')
+
+        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
-            )
-            
+            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'):
+                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
+            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}"
 
@@ -463,43 +516,43 @@ Examples:
         """Format git grep results nicely."""
         output = []
         current_ref = None
-        
+
         for line in lines:
-            if ':' in line:
-                parts = line.split(':', 3)
+            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')
+        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 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
+        pass

hanzo_mcp/tools/filesystem/grep.py

@@ -3,18 +3,18 @@
 This module provides the Grep tool for finding text patterns in files using ripgrep.
 """
 
-import asyncio
-import fnmatch
-import json
 import re
+import json
 import shlex
 import shutil
+import asyncio
+import fnmatch
+from typing import Unpack, Annotated, TypedDict, final, override
 from pathlib import Path
-from typing import Annotated, TypedDict, Unpack, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.context import ToolContext
 from hanzo_mcp.tools.common.truncate import truncate_response
@@ -426,7 +426,7 @@ When you are doing an open ended search that may require multiple rounds of glob
                 return truncate_response(
                     result,
                     max_tokens=25000,
-                    truncation_message="\n\n[Grep results truncated due to token limit. Use more specific patterns or paths to reduce output.]"
+                    truncation_message="\n\n[Grep results truncated due to token limit. Use more specific patterns or paths to reduce output.]",
                 )
             else:
                 await tool_ctx.info(
@@ -436,7 +436,7 @@ When you are doing an open ended search that may require multiple rounds of glob
                 return truncate_response(
                     result,
                     max_tokens=25000,
-                    truncation_message="\n\n[Grep results truncated due to token limit. Use more specific patterns or paths to reduce output.]"
+                    truncation_message="\n\n[Grep results truncated due to token limit. Use more specific patterns or paths to reduce output.]",
                 )
         except Exception as e:
             await tool_ctx.error(f"Error in grep tool: {str(e)}")

hanzo_mcp/tools/filesystem/multi_edit.py

@@ -3,13 +3,13 @@
 This module provides the MultiEdit tool for making multiple precise text replacements in files.
 """
 
+from typing import Unpack, Annotated, TypedDict, final, override
 from difflib import unified_diff
 from pathlib import Path
-from typing import Annotated, TypedDict, Unpack, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
@@ -348,11 +348,7 @@ If you want to create a new file, use:
         tool_self = self  # Create a reference to self for use in the closure
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def multi_edit(
-            file_path: FilePath,
-            edits: Edits,
-            ctx: MCPContext
-        ) -> str:
+        async def multi_edit(file_path: FilePath, edits: Edits, ctx: MCPContext) -> str:
             return await tool_self.call(
                 ctx,
                 file_path=file_path,

hanzo_mcp/tools/filesystem/read.py

@@ -3,15 +3,15 @@
 This module provides the ReadTool for reading the contents of files.
 """
 
+from typing import Unpack, Annotated, TypedDict, final, override
 from pathlib import Path
-from typing import Annotated, TypedDict, Unpack, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
-from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 from hanzo_mcp.tools.common.truncate import truncate_response
+from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
 FilePath = Annotated[
     str,
@@ -220,12 +220,12 @@ Usage:
                     result += f"\n... (output truncated, showing {limit} of {limit + truncated_lines}+ lines)"
 
                 await tool_ctx.info(f"Successfully read file: {file_path}")
-                
+
                 # Apply token limit to prevent excessive output
                 return truncate_response(
                     result,
                     max_tokens=25000,
-                    truncation_message="\n\n[File content truncated due to token limit. Use offset/limit parameters to read specific sections.]"
+                    truncation_message="\n\n[File content truncated due to token limit. Use offset/limit parameters to read specific sections.]",
                 )
 
             except Exception as e:
@@ -236,15 +236,17 @@ 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:
+    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
         """
@@ -267,7 +269,7 @@ Usage:
             ctx: MCPContext,
             file_path: FilePath,
             offset: Offset = 0,
-            limit: Limit = 2000
+            limit: Limit = 2000,
         ) -> str:
             return await tool_self.call(
                 ctx, file_path=file_path, offset=offset, limit=limit