hanzo-mcp 0.8.8__py3-none-any.whl → 0.8.13__py3-none-any.whl

hanzo_mcp/tools/filesystem/base.py

@@ -21,9 +21,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
     the base functionality in FileSystemTool.
     """
 
-    async def check_path_allowed(
-        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
-    ) -> tuple[bool, str]:
+    async def check_path_allowed(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
         """Check if a path is allowed and log an error if not.
 
         Args:
@@ -40,9 +38,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
             return False, f"{error_prefix}: {message}"
         return True, ""
 
-    async def check_path_exists(
-        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
-    ) -> tuple[bool, str]:
+    async def check_path_exists(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
         """Check if a path exists and log an error if not.
 
         Args:
@@ -60,9 +56,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
             return False, f"{error_prefix}: {message}"
         return True, ""
 
-    async def check_is_file(
-        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
-    ) -> tuple[bool, str]:
+    async def check_is_file(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
         """Check if a path is a file and log an error if not.
 
         Args:
@@ -80,9 +74,7 @@ class FilesystemBaseTool(FileSystemTool, ABC):
             return False, f"{error_prefix}: {message}"
         return True, ""
 
-    async def check_is_directory(
-        self, path: str, tool_ctx: Any, error_prefix: str = "Error"
-    ) -> tuple[bool, str]:
+    async def check_is_directory(self, path: str, tool_ctx: Any, error_prefix: str = "Error") -> tuple[bool, str]:
         """Check if a path is a directory and log an error if not.
 
         Args:

hanzo_mcp/tools/filesystem/batch_search.py

@@ -80,10 +80,7 @@ class BatchSearchResults:
         return {
             "query": self.query,
             "total_results": self.total_results,
-            "results_by_type": {
-                k.value: [r.to_dict() for r in v]
-                for k, v in self.results_by_type.items()
-            },
+            "results_by_type": {k.value: [r.to_dict() for r in v] for k, v in self.results_by_type.items()},
             "combined_results": [r.to_dict() for r in self.combined_results],
             "search_time_ms": self.search_time_ms,
         }
@@ -96,12 +93,8 @@ Queries = Annotated[
 SearchPath = Annotated[str, Field(description="Path to search in", default=".")]
 Include = Annotated[str, Field(description="File pattern to include", default="*")]
 MaxResults = Annotated[int, Field(description="Maximum results per query", default=20)]
-IncludeContext = Annotated[
-    bool, Field(description="Include function/method context", default=True)
-]
-CombineResults = Annotated[
-    bool, Field(description="Combine and deduplicate results", default=True)
-]
+IncludeContext = Annotated[bool, Field(description="Include function/method context", default=True)]
+CombineResults = Annotated[bool, Field(description="Combine and deduplicate results", default=True)]
 
 
 class BatchSearchParams(TypedDict):
@@ -212,9 +205,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
         # If pattern contains natural language, prioritize vector search
         words = pattern.split()
-        if len(words) > 2 and not any(
-            c in pattern for c in ["(", ")", "{", "}", "[", "]"]
-        ):
+        if len(words) > 2 and not any(c in pattern for c in ["(", ")", "{", "}", "[", "]"]):
             use_vector = True
 
         return use_vector, use_ast, use_symbol
@@ -227,9 +218,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
         try:
             # Use the existing grep tool
-            grep_result = await self.grep_tool.call(
-                tool_ctx.mcp_context, pattern=pattern, path=path, include=include
-            )
+            grep_result = await self.grep_tool.call(tool_ctx.mcp_context, pattern=pattern, path=path, include=include)
 
             results = []
             if "Found" in grep_result and "matches" in grep_result:
@@ -265,9 +254,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             await tool_ctx.error(f"Grep search failed: {str(e)}")
             return []
 
-    async def _run_vector_search(
-        self, pattern: str, path: str, tool_ctx, max_results: int
-    ) -> List[SearchResult]:
+    async def _run_vector_search(self, pattern: str, path: str, tool_ctx, max_results: int) -> List[SearchResult]:
         """Run vector search and convert results."""
         if not self.vector_tool:
             return []
@@ -373,11 +360,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                                     content=content,
                                     search_type=SearchType.AST,
                                     score=0.9,  # High score for AST matches
-                                    context=(
-                                        "\n".join(context_lines)
-                                        if context_lines
-                                        else None
-                                    ),
+                                    context=("\n".join(context_lines) if context_lines else None),
                                 )
                                 results.append(result)
 
@@ -396,9 +379,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             await tool_ctx.error(f"AST search failed: {str(e)}")
             return []
 
-    async def _run_symbol_search(
-        self, pattern: str, path: str, tool_ctx, max_results: int
-    ) -> List[SearchResult]:
+    async def _run_symbol_search(self, pattern: str, path: str, tool_ctx, max_results: int) -> List[SearchResult]:
         """Run symbol search using AST analysis."""
         await tool_ctx.info(f"Running symbol search for: {pattern}")
 
@@ -414,9 +395,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                 # Look for source files
                 for ext in [".py", ".js", ".ts", ".java", ".cpp", ".c"]:
                     files_to_check.extend(path_obj.rglob(f"*{ext}"))
-                files_to_check = [
-                    str(f) for f in files_to_check[:50]
-                ]  # Limit for performance
+                files_to_check = [str(f) for f in files_to_check[:50]]  # Limit for performance
 
             # Analyze files for symbols
             for file_path in files_to_check:
@@ -439,11 +418,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                             file_path=symbol.file_path,
                             line_number=symbol.line_start,
                             content=f"{symbol.type} {symbol.name}"
-                            + (
-                                f" - {symbol.docstring[:100]}..."
-                                if symbol.docstring
-                                else ""
-                            ),
+                            + (f" - {symbol.docstring[:100]}..." if symbol.docstring else ""),
                             search_type=SearchType.SYMBOL,
                             score=0.95,  # Very high score for symbol matches
                             symbol_info=symbol,
@@ -464,9 +439,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             await tool_ctx.error(f"Symbol search failed: {str(e)}")
             return []
 
-    async def _add_function_context(
-        self, results: List[SearchResult], tool_ctx
-    ) -> List[SearchResult]:
+    async def _add_function_context(self, results: List[SearchResult], tool_ctx) -> List[SearchResult]:
         """Add function/method context to results where relevant."""
         enhanced_results = []
 
@@ -488,16 +461,10 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                         if file_ast:
                             # Find symbol containing this line
                             for symbol in file_ast.symbols:
-                                if (
-                                    symbol.line_start
-                                    <= result.line_number
-                                    <= symbol.line_end
-                                    and symbol.type
-                                    in [
-                                        "function",
-                                        "method",
-                                    ]
-                                ):
+                                if symbol.line_start <= result.line_number <= symbol.line_end and symbol.type in [
+                                    "function",
+                                    "method",
+                                ]:
                                     enhanced_result = SearchResult(
                                         file_path=result.file_path,
                                         line_number=result.line_number,
@@ -510,17 +477,13 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                                     )
                                     break
                 except Exception as e:
-                    await tool_ctx.warning(
-                        f"Could not add context for {result.file_path}: {str(e)}"
-                    )
+                    await tool_ctx.warning(f"Could not add context for {result.file_path}: {str(e)}")
 
             enhanced_results.append(enhanced_result)
 
         return enhanced_results
 
-    def _combine_and_rank_results(
-        self, results_by_type: Dict[SearchType, List[SearchResult]]
-    ) -> List[SearchResult]:
+    def _combine_and_rank_results(self, results_by_type: Dict[SearchType, List[SearchResult]]) -> List[SearchResult]:
         """Combine results from different search types and rank by relevance."""
         all_results = []
         seen_combinations = set()
@@ -552,8 +515,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
                             # Replace existing if: higher priority type, or same priority but higher score
                             if result_priority > existing_priority or (
-                                result_priority == existing_priority
-                                and result.score > existing.score
+                                result_priority == existing_priority and result.score > existing.score
                             ):
                                 # Replace the entire result to preserve type
                                 idx = all_results.index(existing)
@@ -561,9 +523,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                             else:
                                 # Still merge useful information
                                 existing.context = existing.context or result.context
-                                existing.symbol_info = (
-                                    existing.symbol_info or result.symbol_info
-                                )
+                                existing.symbol_info = existing.symbol_info or result.symbol_info
                             break
 
         # Sort by score (descending) then by search type priority
@@ -574,9 +534,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             SearchType.VECTOR: 1,
         }
 
-        all_results.sort(
-            key=lambda r: (r.score, type_priority[r.search_type]), reverse=True
-        )
+        all_results.sort(key=lambda r: (r.score, type_priority[r.search_type]), reverse=True)
 
         return all_results
 
@@ -612,9 +570,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
         if not exists:
             return error_msg
 
-        await tool_ctx.info(
-            f"Starting batch search with {len(queries)} queries in {path}"
-        )
+        await tool_ctx.info(f"Starting batch search with {len(queries)} queries in {path}")
 
         # Run all queries in parallel
         search_tasks = []
@@ -627,44 +583,26 @@ Perfect for comprehensive code analysis and refactoring tasks."""
             if query_type == "grep":
                 pattern = query.get("pattern")
                 if pattern:
-                    search_tasks.append(
-                        self._run_grep_search(
-                            pattern, path, include, tool_ctx, max_results
-                        )
-                    )
+                    search_tasks.append(self._run_grep_search(pattern, path, include, tool_ctx, max_results))
 
             elif query_type == "grep_ast":
                 pattern = query.get("pattern")
                 if pattern:
-                    search_tasks.append(
-                        self._run_ast_search(
-                            pattern, path, include, tool_ctx, max_results
-                        )
-                    )
+                    search_tasks.append(self._run_ast_search(pattern, path, include, tool_ctx, max_results))
 
             elif query_type == "vector_search" and self.vector_tool:
                 search_query = query.get("query") or query.get("pattern")
                 if search_query:
-                    search_tasks.append(
-                        self._run_vector_search(
-                            search_query, path, tool_ctx, max_results
-                        )
-                    )
+                    search_tasks.append(self._run_vector_search(search_query, path, tool_ctx, max_results))
 
             elif query_type == "git_search":
                 pattern = query.get("pattern")
                 search_type = query.get("search_type", "content")
                 if pattern:
-                    search_tasks.append(
-                        self._run_git_search(
-                            pattern, path, search_type, tool_ctx, max_results
-                        )
-                    )
+                    search_tasks.append(self._run_git_search(pattern, path, search_type, tool_ctx, max_results))
 
             else:
-                await tool_ctx.warning(
-                    f"Unknown or unavailable search type: {query_type}"
-                )
+                await tool_ctx.warning(f"Unknown or unavailable search type: {query_type}")
 
         # Execute all searches in parallel
         search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
@@ -689,9 +627,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
         # Add context if requested
         if include_context:
-            combined_results = await self._add_context_to_results(
-                combined_results, tool_ctx
-            )
+            combined_results = await self._add_context_to_results(combined_results, tool_ctx)
 
         end_time = time.time()
         search_time_ms = (end_time - start_time) * 1000
@@ -700,27 +636,17 @@ Perfect for comprehensive code analysis and refactoring tasks."""
         combined_results.sort(key=lambda r: r.score, reverse=True)
 
         # Limit total results
-        combined_results = combined_results[
-            : max_results * 2
-        ]  # Allow more when combining
+        combined_results = combined_results[: max_results * 2]  # Allow more when combining
 
         # Create batch results object
         batch_results = BatchSearchResults(
             query=f"Batch search with {len(queries)} queries",
             total_results=len(combined_results),
             results_by_type={
-                SearchType.GREP: [
-                    r for r in combined_results if r.search_type == SearchType.GREP
-                ],
-                SearchType.VECTOR: [
-                    r for r in combined_results if r.search_type == SearchType.VECTOR
-                ],
-                SearchType.AST: [
-                    r for r in combined_results if r.search_type == SearchType.AST
-                ],
-                SearchType.GIT: [
-                    r for r in combined_results if r.search_type == SearchType.GIT
-                ],
+                SearchType.GREP: [r for r in combined_results if r.search_type == SearchType.GREP],
+                SearchType.VECTOR: [r for r in combined_results if r.search_type == SearchType.VECTOR],
+                SearchType.AST: [r for r in combined_results if r.search_type == SearchType.AST],
+                SearchType.GIT: [r for r in combined_results if r.search_type == SearchType.GIT],
             },
             combined_results=combined_results,
             search_time_ms=search_time_ms,
@@ -802,16 +728,12 @@ Perfect for comprehensive code analysis and refactoring tasks."""
 
         return combined
 
-    async def _add_context_to_results(
-        self, results: List[SearchResult], tool_ctx
-    ) -> List[SearchResult]:
+    async def _add_context_to_results(self, results: List[SearchResult], tool_ctx) -> List[SearchResult]:
         """Add function/method context to results."""
         # This is a simplified version - you could enhance with full AST context
         return await self._add_function_context(results, tool_ctx)
 
-    def _format_batch_results(
-        self, results: BatchSearchResults, query_info: List[Dict]
-    ) -> str:
+    def _format_batch_results(self, results: BatchSearchResults, query_info: List[Dict]) -> str:
         """Format batch search results for display."""
         output = []
 
@@ -859,9 +781,7 @@ Perfect for comprehensive code analysis and refactoring tasks."""
                     score_str = f"[{result.search_type.value} {result.score:.2f}]"
 
                     if result.line_number:
-                        output.append(
-                            f"  {result.line_number:>4}: {score_str} {result.content}"
-                        )
+                        output.append(f"  {result.line_number:>4}: {score_str} {result.content}")
                     else:
                         output.append(f"       {score_str} {result.content}")
 

hanzo_mcp/tools/filesystem/content_replace.py

@@ -159,15 +159,11 @@ Only works within allowed directories."""
             # Process based on whether path is a file or directory
             if input_path.is_file():
                 # Single file search
-                if file_pattern == "*" or fnmatch.fnmatch(
-                    input_path.name, file_pattern
-                ):
+                if file_pattern == "*" or fnmatch.fnmatch(input_path.name, file_pattern):
                     matching_files.append(input_path)
                     await tool_ctx.info(f"Searching single file: {path}")
                 else:
-                    await tool_ctx.info(
-                        f"File does not match pattern '{file_pattern}': {path}"
-                    )
+                    await tool_ctx.info(f"File does not match pattern '{file_pattern}': {path}")
                     return f"File does not match pattern '{file_pattern}': {path}"
             elif input_path.is_dir():
                 # Directory search - optimized file finding
@@ -186,9 +182,7 @@ Only works within allowed directories."""
                 for entry in input_path.rglob("*"):
                     entry_path = str(entry)
                     if entry_path in allowed_paths and entry.is_file():
-                        if file_pattern == "*" or fnmatch.fnmatch(
-                            entry.name, file_pattern
-                        ):
+                        if file_pattern == "*" or fnmatch.fnmatch(entry.name, file_pattern):
                             matching_files.append(entry)
 
                 await tool_ctx.info(f"Found {len(matching_files)} matching files")
@@ -251,9 +245,7 @@ Only works within allowed directories."""
                 )
                 message = f"Dry run: {replacements_made} replacements of '{pattern}' with '{replacement}' would be made in {files_modified} files:"
             else:
-                await tool_ctx.info(
-                    f"Made {replacements_made} replacements in {files_modified} files"
-                )
+                await tool_ctx.info(f"Made {replacements_made} replacements in {files_modified} files")
                 message = f"Made {replacements_made} replacements of '{pattern}' with '{replacement}' in {files_modified} files:"
 
             return message + "\n\n" + "\n".join(results)

hanzo_mcp/tools/filesystem/diff.py

@@ -166,16 +166,8 @@ diff a.json b.json --ignore-whitespace"""
             output.extend(diff_lines)
 
         # Add summary
-        additions = sum(
-            1
-            for line in diff_lines
-            if line.startswith("+") and not line.startswith("+++")
-        )
-        deletions = sum(
-            1
-            for line in diff_lines
-            if line.startswith("-") and not line.startswith("---")
-        )
+        additions = sum(1 for line in diff_lines if line.startswith("+") and not line.startswith("+++"))
+        deletions = sum(1 for line in diff_lines if line.startswith("-") and not line.startswith("---"))
 
         output.append("")
         output.append("=" * 60)

hanzo_mcp/tools/filesystem/directory_tree.py

@@ -112,9 +112,7 @@ requested. Only works within allowed directories."""
             await tool_ctx.error(path_validation.error_message)
             return f"Error: {path_validation.error_message}"
 
-        await tool_ctx.info(
-            f"Getting directory tree: {path} (depth: {depth}, include_filtered: {include_filtered})"
-        )
+        await tool_ctx.info(f"Getting directory tree: {path} (depth: {depth}, include_filtered: {include_filtered})")
 
         # Check if path is allowed
         allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
@@ -153,9 +151,7 @@ requested. Only works within allowed directories."""
             }
 
             # Log filtering settings
-            await tool_ctx.info(
-                f"Directory tree filtering: include_filtered={include_filtered}"
-            )
+            await tool_ctx.info(f"Directory tree filtering: include_filtered={include_filtered}")
 
             # Check if a directory should be filtered
             def should_filter(current_path: Path) -> bool:
@@ -165,9 +161,7 @@ requested. Only works within allowed directories."""
                     return False
 
                 # Filter based on directory name if filtering is enabled
-                return (
-                    current_path.name in FILTERED_DIRECTORIES and not include_filtered
-                )
+                return current_path.name in FILTERED_DIRECTORIES and not include_filtered
 
             # Track stats for summary
             stats = {
@@ -178,9 +172,7 @@ requested. Only works within allowed directories."""
             }
 
             # Build the tree recursively
-            async def build_tree(
-                current_path: Path, current_depth: int = 0
-            ) -> list[dict[str, Any]]:
+            async def build_tree(current_path: Path, current_depth: int = 0) -> list[dict[str, Any]]:
                 result: list[dict[str, Any]] = []
 
                 # Skip processing if path isn't allowed
@@ -189,9 +181,7 @@ requested. Only works within allowed directories."""
 
                 try:
                     # Sort entries: directories first, then files alphabetically
-                    entries = sorted(
-                        current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name)
-                    )
+                    entries = sorted(current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name))
 
                     for entry in entries:
                         # Skip entries that aren't allowed
@@ -220,9 +210,7 @@ requested. Only works within allowed directories."""
                                 continue
 
                             # Process children recursively with depth increment
-                            entry_data["children"] = await build_tree(
-                                entry, current_depth + 1
-                            )
+                            entry_data["children"] = await build_tree(entry, current_depth + 1)
                             result.append(entry_data)
                         else:
                             # Files should be at the same level check as directories
@@ -237,9 +225,7 @@ requested. Only works within allowed directories."""
                 return result
 
             # Format the tree as a simple indented structure
-            def format_tree(
-                tree_data: list[dict[str, Any]], level: int = 0
-            ) -> list[str]:
+            def format_tree(tree_data: list[dict[str, Any]], level: int = 0) -> list[str]:
                 lines = []
 
                 for item in tree_data:
@@ -249,9 +235,7 @@ requested. Only works within allowed directories."""
                     # Format based on type
                     if item["type"] == "directory":
                         if "skipped" in item:
-                            lines.append(
-                                f"{indent}{item['name']}/ [skipped - {item['skipped']}]"
-                            )
+                            lines.append(f"{indent}{item['name']}/ [skipped - {item['skipped']}]")
                         else:
                             lines.append(f"{indent}{item['name']}/")
                             # Add children with increased indentation if present
@@ -310,6 +294,4 @@ requested. Only works within allowed directories."""
             depth: Depth = 3,
             include_filtered: IncludeFiltered = False,
         ) -> str:
-            return await tool_self.call(
-                ctx, path=path, depth=depth, include_filtered=include_filtered
-            )
+            return await tool_self.call(ctx, path=path, depth=depth, include_filtered=include_filtered)

hanzo_mcp/tools/filesystem/directory_tree_paginated.py

@@ -152,9 +152,7 @@ Returns nextCursor if more entries are available."""
             await tool_ctx.error(path_validation.error_message)
             return {"error": path_validation.error_message}
 
-        await tool_ctx.info(
-            f"Getting paginated directory tree: {path} (depth: {depth}, page_size: {page_size})"
-        )
+        await tool_ctx.info(f"Getting paginated directory tree: {path} (depth: {depth}, page_size: {page_size})")
 
         # Check if path is allowed
         allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
@@ -196,35 +194,27 @@ Returns nextCursor if more entries are available."""
             def should_filter(current_path: Path) -> bool:
                 if str(current_path.absolute()) == str(dir_path.absolute()):
                     return False
-                return (
-                    current_path.name in FILTERED_DIRECTORIES and not include_filtered
-                )
+                return current_path.name in FILTERED_DIRECTORIES and not include_filtered
 
             # Collect all entries in a flat list for pagination
             all_entries: List[Dict[str, Any]] = []
 
             # Build the tree and collect entries
-            def collect_entries(
-                current_path: Path, current_depth: int = 0, parent_path: str = ""
-            ) -> None:
+            def collect_entries(current_path: Path, current_depth: int = 0, parent_path: str = "") -> None:
                 """Collect entries in a flat list for pagination."""
                 if not self.is_path_allowed(str(current_path)):
                     return
 
                 try:
                     # Sort entries: directories first, then files alphabetically
-                    entries = sorted(
-                        current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name)
-                    )
+                    entries = sorted(current_path.iterdir(), key=lambda x: (not x.is_dir(), x.name))
 
                     for entry in entries:
                         if not self.is_path_allowed(str(entry)):
                             continue
 
                         # Calculate relative path for display
-                        relative_path = (
-                            f"{parent_path}/{entry.name}" if parent_path else entry.name
-                        )
+                        relative_path = f"{parent_path}/{entry.name}" if parent_path else entry.name
 
                         if entry.is_dir():
                             entry_data: Dict[str, Any] = {

hanzo_mcp/tools/filesystem/edit.py

@@ -121,9 +121,7 @@ Usage:
         # Empty old_string is valid when creating a new file
         file_exists = Path(file_path).exists()
         if file_exists and old_string.strip() == "":
-            await tool_ctx.error(
-                "Parameter 'old_string' cannot be empty for existing files"
-            )
+            await tool_ctx.error("Parameter 'old_string' cannot be empty for existing files")
             return "Error: Parameter 'old_string' cannot be empty for existing files"
 
         if (
@@ -131,12 +129,8 @@ Usage:
             or not isinstance(expected_replacements, (int, float))
             or expected_replacements < 0
         ):
-            await tool_ctx.error(
-                "Parameter 'expected_replacements' must be a non-negative number"
-            )
-            return (
-                "Error: Parameter 'expected_replacements' must be a non-negative number"
-            )
+            await tool_ctx.error("Parameter 'expected_replacements' must be a non-negative number")
+            return "Error: Parameter 'expected_replacements' must be a non-negative number"
 
         await tool_ctx.info(f"Editing file: {file_path}")
 
@@ -164,9 +158,7 @@ Usage:
                     f.write(new_string)
 
                 await tool_ctx.info(f"Successfully created file: {file_path}")
-                return (
-                    f"Successfully created file: {file_path} ({len(new_string)} bytes)"
-                )
+                return f"Successfully created file: {file_path} ({len(new_string)} bytes)"
 
             # Check file exists for non-creation operations
             exists, error_msg = await self.check_path_exists(file_path, tool_ctx)
@@ -199,9 +191,7 @@ Usage:
                     modified_content = original_content.replace(old_string, new_string)
                 else:
                     # If we can't find the exact string, report an error
-                    await tool_ctx.error(
-                        "The specified old_string was not found in the file content"
-                    )
+                    await tool_ctx.error("The specified old_string was not found in the file content")
                     return "Error: The specified old_string was not found in the file content. Please check that it matches exactly, including all whitespace and indentation."
 
                 # Generate diff
@@ -226,9 +216,7 @@ Usage:
                     num_backticks += 1
 
                 # Format diff with appropriate number of backticks
-                formatted_diff = (
-                    f"```{num_backticks}diff\n{diff_text}```{num_backticks}\n"
-                )
+                formatted_diff = f"```{num_backticks}diff\n{diff_text}```{num_backticks}\n"
 
                 # Write the file if there are changes
                 if diff_text:

hanzo_mcp/tools/filesystem/find.py

@@ -199,9 +199,7 @@ Fast, intuitive file content search."""
             # Fallback
             selected_backend = "grep"
 
-        await tool_ctx.info(
-            f"Using {selected_backend} to search for '{pattern}' in {path}"
-        )
+        await tool_ctx.info(f"Using {selected_backend} to search for '{pattern}' in {path}")
 
         # Execute search
         if selected_backend == "rg":
@@ -459,9 +457,7 @@ Fast, intuitive file content search."""
                                 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()}"
-                                    )
+                                    context_lines.append(f"{file_path}:{j + 1}{prefix}{lines[j].rstrip()}")
                                 results.extend(context_lines)
                                 results.append("")  # Separator
                             else:
@@ -482,9 +478,7 @@ Fast, intuitive file content search."""
             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:
+    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