hanzo-mcp 0.8.11__py3-none-any.whl → 0.8.14__py3-none-any.whl

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

hanzo_mcp/tools/filesystem/find_files.py

@@ -335,9 +335,7 @@ For database search, use 'sql_search' or 'vector_search'.
                 return f"No files found matching '{pattern}' (using fallback search)"
 
             # Format output
-            output = [
-                f"Found {len(results)} file(s) matching '{pattern}' (using fallback search):"
-            ]
+            output = [f"Found {len(results)} file(s) matching '{pattern}' (using fallback search):"]
             output.append("")
 
             for filepath in sorted(results):
@@ -346,9 +344,7 @@ For database search, use 'sql_search' or 'vector_search'.
             if count >= max_results:
                 output.append(f"\n... (showing first {max_results} results)")
 
-            output.append(
-                "\nNote: Install 'ffind' for faster searching: pip install ffind"
-            )
+            output.append("\nNote: Install 'ffind' for faster searching: pip install ffind")
 
             return "\n".join(output)
 

hanzo_mcp/tools/filesystem/git_search.py

@@ -256,9 +256,7 @@ Examples:
                     tool_ctx,
                 )
             elif search_type == "blame":
-                return await self._search_blame(
-                    abs_path, pattern, case_sensitive, file_pattern, tool_ctx
-                )
+                return await self._search_blame(abs_path, pattern, case_sensitive, file_pattern, tool_ctx)
             else:
                 return f"Unknown search type: {search_type}"
 
@@ -307,9 +305,7 @@ Examples:
         elif result.returncode == 1:
             return f"No matches found for pattern: {pattern}"
         else:
-            raise subprocess.CalledProcessError(
-                result.returncode, cmd, result.stdout, result.stderr
-            )
+            raise subprocess.CalledProcessError(result.returncode, cmd, result.stdout, result.stderr)
 
     async def _search_commits(
         self,
@@ -353,16 +349,11 @@ Examples:
             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:
-            raise subprocess.CalledProcessError(
-                result.returncode, cmd, result.stdout, result.stderr
-            )
+            raise subprocess.CalledProcessError(result.returncode, cmd, result.stdout, result.stderr)
 
     async def _search_diff(
         self,
@@ -387,8 +378,7 @@ Examples:
             import re
 
             case_insensitive_pattern = "".join(
-                f"[{c.upper()}{c.lower()}]" if c.isalpha() else re.escape(c)
-                for c in pattern
+                f"[{c.upper()}{c.lower()}]" if c.isalpha() else re.escape(c) for c in pattern
             )
             search_flag = f"-G{case_insensitive_pattern}"
 
@@ -415,9 +405,7 @@ Examples:
 
         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}"
@@ -505,9 +493,8 @@ Examples:
 
         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])
+            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}"
@@ -534,9 +521,7 @@ Examples:
 
         return f"Found matches for '{pattern}':\n" + "\n".join(output)
 
-    def _highlight_diff_matches(
-        self, diff_output: str, pattern: str, case_sensitive: bool
-    ) -> str:
+    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 = []

hanzo_mcp/tools/filesystem/grep.py

@@ -118,9 +118,7 @@ When you are doing an open ended search that may require multiple rounds of glob
         # Special case for tests: direct file path with include pattern that doesn't match
         if Path(path).is_file() and include_pattern and include_pattern != "*":
             if not fnmatch.fnmatch(Path(path).name, include_pattern):
-                await tool_ctx.info(
-                    f"File does not match pattern '{include_pattern}': {path}"
-                )
+                await tool_ctx.info(f"File does not match pattern '{include_pattern}': {path}")
                 return f"File does not match pattern '{include_pattern}': {path}"
 
         cmd = ["rg", "--json", pattern]
@@ -144,9 +142,7 @@ When you are doing an open ended search that may require multiple rounds of glob
 
             if process.returncode != 0 and process.returncode != 1:
                 # rg returns 1 when no matches are found, which is not an error
-                await tool_ctx.error(
-                    f"ripgrep failed with exit code {process.returncode}: {stderr.decode()}"
-                )
+                await tool_ctx.error(f"ripgrep failed with exit code {process.returncode}: {stderr.decode()}")
                 return f"Error executing ripgrep: {stderr.decode()}"
 
             # Parse the JSON output
@@ -182,9 +178,7 @@ When you are doing an open ended search that may require multiple rounds of glob
                 if data.get("type") == "match":
                     path = data.get("data", {}).get("path", {}).get("text", "")
                     line_number = data.get("data", {}).get("line_number", 0)
-                    line_text = (
-                        data.get("data", {}).get("lines", {}).get("text", "").rstrip()
-                    )
+                    line_text = data.get("data", {}).get("lines", {}).get("text", "").rstrip()
 
                     if path not in file_results:
                         file_results[path] = []
@@ -251,9 +245,7 @@ When you are doing an open ended search that may require multiple rounds of glob
                     await tool_ctx.info(f"Searching single file: {path}")
                 else:
                     # File doesn't match the pattern, return immediately
-                    await tool_ctx.info(
-                        f"File does not match pattern '{include_pattern}': {path}"
-                    )
+                    await tool_ctx.info(f"File does not match pattern '{include_pattern}': {path}")
                     return f"File does not match pattern '{include_pattern}': {path}"
             elif input_path.is_dir():
                 # Directory search - find all files
@@ -290,9 +282,7 @@ When you are doing an open ended search that may require multiple rounds of glob
             if input_path.is_file():
                 await tool_ctx.info(f"Searching file: {path}")
             else:
-                await tool_ctx.info(
-                    f"Searching through {total_files} files in directory"
-                )
+                await tool_ctx.info(f"Searching through {total_files} files in directory")
 
             # Set up for parallel processing
             results: list[str] = []
@@ -314,18 +304,14 @@ When you are doing an open ended search that may require multiple rounds of glob
                             with open(file_path, "r", encoding="utf-8") as f:
                                 for line_num, line in enumerate(f, 1):
                                     if re.search(pattern, line):
-                                        file_results.append(
-                                            f"{file_path}:{line_num}: {line.rstrip()}"
-                                        )
+                                        file_results.append(f"{file_path}:{line_num}: {line.rstrip()}")
                                         matches_found += 1
                             files_processed += 1
                         except UnicodeDecodeError:
                             # Skip binary files
                             files_processed += 1
                         except Exception as e:
-                            await tool_ctx.warning(
-                                f"Error reading {file_path}: {str(e)}"
-                            )
+                            await tool_ctx.warning(f"Error reading {file_path}: {str(e)}")
                 except Exception as e:
                     await tool_ctx.warning(f"Error processing {file_path}: {str(e)}")
 
@@ -429,9 +415,7 @@ When you are doing an open ended search that may require multiple rounds of glob
                     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(
-                    "ripgrep is not installed, using fallback implementation"
-                )
+                await tool_ctx.info("ripgrep is not installed, using fallback implementation")
                 result = await self.fallback_grep(pattern, path, tool_ctx, include)
                 return truncate_response(
                     result,
@@ -462,6 +446,4 @@ When you are doing an open ended search that may require multiple rounds of glob
             include: Include,
         ) -> str:
             # Use 'include' parameter if provided, otherwise fall back to 'file_pattern'
-            return await tool_self.call(
-                ctx, pattern=pattern, path=path, include=include
-            )
+            return await tool_self.call(ctx, pattern=pattern, path=path, include=include)

hanzo_mcp/tools/filesystem/multi_edit.py

@@ -170,15 +170,11 @@ If you want to create a new file, use:
             expected_replacements = edit.get("expected_replacements", 1)
 
             if old_string is None:
-                await tool_ctx.error(
-                    f"Parameter 'old_string' in edit at index {i} is required but was None"
-                )
+                await tool_ctx.error(f"Parameter 'old_string' in edit at index {i} is required but was None")
                 return f"Error: Parameter 'old_string' in edit at index {i} is required but was None"
 
             if new_string is None:
-                await tool_ctx.error(
-                    f"Parameter 'new_string' in edit at index {i} is required but was None"
-                )
+                await tool_ctx.error(f"Parameter 'new_string' in edit at index {i} is required but was None")
                 return f"Error: Parameter 'new_string' in edit at index {i} is required but was None"
 
             if (
@@ -192,12 +188,8 @@ If you want to create a new file, use:
                 return f"Error: Parameter 'expected_replacements' in edit at index {i} must be a non-negative number"
 
             if old_string == new_string:
-                await tool_ctx.error(
-                    f"Edit at index {i}: old_string and new_string are identical"
-                )
-                return (
-                    f"Error: Edit at index {i}: old_string and new_string are identical"
-                )
+                await tool_ctx.error(f"Edit at index {i}: old_string and new_string are identical")
+                return f"Error: Edit at index {i}: old_string and new_string are identical"
 
         await tool_ctx.info(f"Applying {len(edits)} edits to file: {file_path}")
 
@@ -261,9 +253,7 @@ If you want to create a new file, use:
 
                 # Check if old_string exists in current content
                 if old_string not in current_content:
-                    edit_index = (
-                        i + 1 if not creation_mode else i + 2
-                    )  # Adjust for display
+                    edit_index = i + 1 if not creation_mode else i + 2  # Adjust for display
                     await tool_ctx.error(
                         f"Edit {edit_index}: The specified old_string was not found in the file content"
                     )
@@ -274,9 +264,7 @@ If you want to create a new file, use:
 
                 # Check if the number of occurrences matches expected_replacements
                 if occurrences != expected_replacements:
-                    edit_index = (
-                        i + 1 if not creation_mode else i + 2
-                    )  # Adjust for display
+                    edit_index = i + 1 if not creation_mode else i + 2  # Adjust for display
                     await tool_ctx.error(
                         f"Edit {edit_index}: Found {occurrences} occurrences of the specified old_string, but expected {expected_replacements}"
                     )

hanzo_mcp/tools/filesystem/read.py

@@ -118,18 +118,12 @@ Usage:
             await tool_ctx.error("Parameter 'file_path' is required but was None")
             return "Error: Parameter 'file_path' is required but was None"
 
-        await tool_ctx.info(
-            f"Reading file: {file_path} (offset: {offset}, limit: {limit})"
-        )
+        await tool_ctx.info(f"Reading file: {file_path} (offset: {offset}, limit: {limit})")
 
         # Check if path is allowed
         if not self.is_path_allowed(file_path):
-            await tool_ctx.error(
-                f"Access denied - path outside allowed directories: {file_path}"
-            )
-            return (
-                f"Error: Access denied - path outside allowed directories: {file_path}"
-            )
+            await tool_ctx.error(f"Access denied - path outside allowed directories: {file_path}")
+            return f"Error: Access denied - path outside allowed directories: {file_path}"
 
         try:
             file_path_obj = Path(file_path)
@@ -166,10 +160,7 @@ Usage:
 
                             # Truncate long lines
                             if len(line) > self.MAX_LINE_LENGTH:
-                                line = (
-                                    line[: self.MAX_LINE_LENGTH]
-                                    + self.LINE_TRUNCATION_INDICATOR
-                                )
+                                line = line[: self.MAX_LINE_LENGTH] + self.LINE_TRUNCATION_INDICATOR
 
                             # Add line with line number (1-based)
                             lines.append(f"{i + 1:6d}  {line.rstrip()}")
@@ -196,17 +187,12 @@ Usage:
 
                                 # Truncate long lines
                                 if len(line) > self.MAX_LINE_LENGTH:
-                                    line = (
-                                        line[: self.MAX_LINE_LENGTH]
-                                        + self.LINE_TRUNCATION_INDICATOR
-                                    )
+                                    line = line[: self.MAX_LINE_LENGTH] + self.LINE_TRUNCATION_INDICATOR
 
                                 # Add line with line number (1-based)
                                 lines.append(f"{i + 1:6d}  {line.rstrip()}")
 
-                        await tool_ctx.warning(
-                            f"File read with latin-1 encoding: {file_path}"
-                        )
+                        await tool_ctx.warning(f"File read with latin-1 encoding: {file_path}")
 
                     except Exception:
                         await tool_ctx.error(f"Cannot read binary file: {file_path}")
@@ -236,9 +222,7 @@ 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:
@@ -271,6 +255,4 @@ Usage:
             offset: Offset = 0,
             limit: Limit = 2000,
         ) -> str:
-            return await tool_self.call(
-                ctx, file_path=file_path, offset=offset, limit=limit
-            )
+            return await tool_self.call(ctx, file_path=file_path, offset=offset, limit=limit)

hanzo_mcp/tools/filesystem/rules_tool.py

@@ -142,9 +142,7 @@ understand project-specific requirements and preferences."""
                             found_configs.append(
                                 {
                                     "path": str(config_path),
-                                    "relative_path": str(
-                                        config_path.relative_to(start_path)
-                                    ),
+                                    "relative_path": str(config_path.relative_to(start_path)),
                                     "content": content,
                                     "size": len(content),
                                 }
@@ -152,9 +150,7 @@ understand project-specific requirements and preferences."""
 
                             await tool_ctx.info(f"Found configuration: {config_path}")
                     except Exception as e:
-                        await tool_ctx.warning(
-                            f"Could not read {config_path}: {str(e)}"
-                        )
+                        await tool_ctx.warning(f"Could not read {config_path}: {str(e)}")
 
             # Check if we've reached the root or a git repository root
             if current_path.parent == current_path:
@@ -169,8 +165,7 @@ understand project-specific requirements and preferences."""
                         if (
                             config_path.exists()
                             and config_path.is_file()
-                            and str(config_path)
-                            not in [c["path"] for c in found_configs]
+                            and str(config_path) not in [c["path"] for c in found_configs]
                         ):
                             try:
                                 if self.is_path_allowed(str(config_path)):
@@ -180,21 +175,15 @@ understand project-specific requirements and preferences."""
                                     found_configs.append(
                                         {
                                             "path": str(config_path),
-                                            "relative_path": str(
-                                                config_path.relative_to(start_path)
-                                            ),
+                                            "relative_path": str(config_path.relative_to(start_path)),
                                             "content": content,
                                             "size": len(content),
                                         }
                                     )
 
-                                    await tool_ctx.info(
-                                        f"Found configuration: {config_path}"
-                                    )
+                                    await tool_ctx.info(f"Found configuration: {config_path}")
                             except Exception as e:
-                                await tool_ctx.warning(
-                                    f"Could not read {config_path}: {str(e)}"
-                                )
+                                await tool_ctx.warning(f"Could not read {config_path}: {str(e)}")
                 break
 
             # Move to parent directory