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

hanzo_mcp/tools/agent/unified_cli_tools.py

@@ -21,10 +21,10 @@ from ...core.model_registry import registry
 
 class UnifiedCLITool(BaseTool, CLIAgent):
     """Unified CLI tool that combines BaseTool and CLIAgent functionality.
-    
+
     MRO: BaseTool first for proper method resolution order.
     """
-    
+
     def __init__(
         self,
         name: str,
@@ -34,7 +34,7 @@ class UnifiedCLITool(BaseTool, CLIAgent):
         permission_manager: Optional[PermissionManager] = None,
     ):
         """Initialize unified CLI tool.
-        
+
         Args:
             name: Tool name
             description: Tool description
@@ -45,47 +45,47 @@ class UnifiedCLITool(BaseTool, CLIAgent):
         # Initialize CLIAgent with config
         config = AgentConfig(model=default_model)
         CLIAgent.__init__(self, config)
-        
+
         # Store tool metadata
         self._name = name
         self._description = description
         self._cli_command = cli_command
         self.permission_manager = permission_manager
-    
+
     @property
     def name(self) -> str:
         return self._name
-    
+
     @property
     def description(self) -> str:
         return self._description
-    
+
     @property
     def cli_command(self) -> str:
         return self._cli_command
-    
+
     def build_command(self, prompt: str, **kwargs: Any) -> List[str]:
         """Build the CLI command with model-specific formatting.
-        
+
         Args:
             prompt: The prompt
             **kwargs: Additional parameters
-            
+
         Returns:
             Command arguments list
         """
         command = [self.cli_command]
-        
+
         # Get model config from registry
         model_config = registry.get(self.config.model)
-        
+
         # Handle different CLI tool formats
         if self.cli_command == "claude":
             if model_config:
                 command.extend(["--model", model_config.full_name])
             # Claude takes prompt via stdin
             return command
-            
+
         elif self.cli_command == "openai":
             # OpenAI CLI format
             command.extend(["api", "chat.completions.create"])
@@ -93,14 +93,14 @@ class UnifiedCLITool(BaseTool, CLIAgent):
                 command.extend(["-m", model_config.full_name])
             command.extend(["-g", "user", prompt])
             return command
-            
+
         elif self.cli_command in ["gemini", "grok"]:
             # Simple format: command --model MODEL prompt
             if model_config:
                 command.extend(["--model", model_config.full_name])
             command.append(prompt)
             return command
-            
+
         elif self.cli_command == "openhands":
             # OpenHands format
             command.extend(["run", prompt])
@@ -109,7 +109,7 @@ class UnifiedCLITool(BaseTool, CLIAgent):
             if self.config.working_dir:
                 command.extend(["--workspace", str(self.config.working_dir)])
             return command
-            
+
         elif self.cli_command == "hanzo":
             # Hanzo dev format
             command.append("dev")
@@ -117,13 +117,13 @@ class UnifiedCLITool(BaseTool, CLIAgent):
                 command.extend(["--model", model_config.full_name])
             command.extend(["--prompt", prompt])
             return command
-            
+
         elif self.cli_command == "cline":
             # Cline format
             command.append(prompt)
             command.append("--no-interactive")
             return command
-            
+
         elif self.cli_command == "aider":
             # Aider format
             if model_config:
@@ -131,24 +131,24 @@ class UnifiedCLITool(BaseTool, CLIAgent):
             command.extend(["--message", prompt])
             command.extend(["--yes", "--no-stream"])
             return command
-            
+
         elif self.cli_command == "ollama":
             # Ollama format for local models
             command.extend(["run", self.config.model.replace("ollama/", "")])
             command.append(prompt)
             return command
-        
+
         # Default format
         command.append(prompt)
         return command
-    
+
     async def call(self, ctx: Context[Any, Any, Any], **params: Any) -> str:
         """Execute the CLI tool via MCP interface.
-        
+
         Args:
             ctx: MCP context
             **params: Tool parameters
-            
+
         Returns:
             Execution result
         """
@@ -159,23 +159,23 @@ class UnifiedCLITool(BaseTool, CLIAgent):
             self.config.working_dir = Path(params["working_dir"])
         if params.get("timeout"):
             self.config.timeout = params["timeout"]
-        
+
         # Execute using base agent
         result = await self.execute(
             params.get("prompt", ""),
             context=ctx,
         )
-        
+
         return result.content
-    
+
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server.
-        
+
         Args:
             mcp_server: The FastMCP server instance
         """
         tool_self = self
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
         async def tool_wrapper(
             prompt: str,
@@ -195,15 +195,15 @@ class UnifiedCLITool(BaseTool, CLIAgent):
 
 def create_cli_tools(permission_manager: Optional[PermissionManager] = None) -> Dict[str, UnifiedCLITool]:
     """Create all CLI tools with unified implementation.
-    
+
     Args:
         permission_manager: Permission manager for access control
-        
+
     Returns:
         Dictionary of tool name to tool instance
     """
     tools = {}
-    
+
     # Define all tools with their configurations
     tool_configs = [
         ("claude", "Execute Claude CLI for AI assistance", "claude", "claude"),
@@ -217,7 +217,7 @@ def create_cli_tools(permission_manager: Optional[PermissionManager] = None) ->
         ("cline", "Execute Cline for autonomous coding", "cline", "claude"),
         ("aider", "Execute Aider for AI pair programming", "aider", "gpt-4-turbo"),
     ]
-    
+
     for name, description, cli_command, default_model in tool_configs:
         tools[name] = UnifiedCLITool(
             name=name,
@@ -226,7 +226,7 @@ def create_cli_tools(permission_manager: Optional[PermissionManager] = None) ->
             default_model=default_model,
             permission_manager=permission_manager,
         )
-    
+
     return tools
 
 
@@ -235,20 +235,20 @@ def register_cli_tools(
     permission_manager: Optional[PermissionManager] = None,
 ) -> List[BaseTool]:
     """Register all CLI tools with the MCP server.
-    
+
     Args:
         mcp_server: The FastMCP server instance
         permission_manager: Permission manager for access control
-        
+
     Returns:
         List of registered CLI tools
     """
     tools = create_cli_tools(permission_manager)
-    
+
     # Register each tool
     for tool in tools.values():
         tool.register(mcp_server)
-    
+
     return list(tools.values())
 
 
@@ -256,4 +256,4 @@ __all__ = [
     "UnifiedCLITool",
     "create_cli_tools",
     "register_cli_tools",
-]
+]

hanzo_mcp/tools/common/batch_tool.py

@@ -177,30 +177,22 @@ Not available: think,write,edit,multi_edit,notebook_edit
 
         # Validate required parameters
         if not description:
-            await tool_ctx.error(
-                "Parameter 'description' is required but was None or empty"
-            )
+            await tool_ctx.error("Parameter 'description' is required but was None or empty")
             return "Error: Parameter 'description' is required but was None or empty"
 
         if not invocations:
-            await tool_ctx.error(
-                "Parameter 'invocations' is required but was None or empty"
-            )
+            await tool_ctx.error("Parameter 'invocations' is required but was None or empty")
             return "Error: Parameter 'invocations' is required but was None or empty"
 
         if not isinstance(invocations, list) or len(invocations) == 0:
             await tool_ctx.error("Parameter 'invocations' must be a non-empty list")
             return "Error: Parameter 'invocations' must be a non-empty list"
 
-        await tool_ctx.info(
-            f"Executing batch operation: {description} ({len(invocations)} invocations)"
-        )
+        await tool_ctx.info(f"Executing batch operation: {description} ({len(invocations)} invocations)")
 
         # Execute all tool invocations in parallel
         tasks: list[asyncio.Future[dict[str, Any]]] = []
-        invocation_map: dict[asyncio.Future[dict[str, Any]], dict[str, Any]] = (
-            {}
-        )  # Map task Future to invocation
+        invocation_map: dict[asyncio.Future[dict[str, Any]], dict[str, Any]] = {}  # Map task Future to invocation
 
         for i, invocation in enumerate(invocations):
             # Extract tool name and input from invocation
@@ -213,9 +205,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 await tool_ctx.error(error_message)
                 # Add direct result for this invocation
                 tasks.append(asyncio.Future())
-                tasks[-1].set_result(
-                    {"invocation": invocation, "result": f"Error: {error_message}"}
-                )
+                tasks[-1].set_result({"invocation": invocation, "result": f"Error: {error_message}"})
                 invocation_map[tasks[-1]] = invocation
                 continue
 
@@ -225,9 +215,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 await tool_ctx.error(error_message)
                 # Add direct result for this invocation
                 tasks.append(asyncio.Future())
-                tasks[-1].set_result(
-                    {"invocation": invocation, "result": f"Error: {error_message}"}
-                )
+                tasks[-1].set_result({"invocation": invocation, "result": f"Error: {error_message}"})
                 invocation_map[tasks[-1]] = invocation
                 continue
 
@@ -237,9 +225,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 await tool_ctx.info(f"Creating task for tool: {tool_name}")
 
                 # Create coroutine for this tool execution
-                async def execute_tool(
-                    tool_obj: BaseTool, tool_name: str, tool_input: dict[str, Any]
-                ):
+                async def execute_tool(tool_obj: BaseTool, tool_name: str, tool_input: dict[str, Any]):
                     try:
                         await tool_ctx.info(f"Executing tool: {tool_name}")
                         result = await tool_obj.call(ctx, **tool_input)
@@ -265,9 +251,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 await tool_ctx.error(error_message)
                 # Add direct result for this invocation
                 tasks.append(asyncio.Future())
-                tasks[-1].set_result(
-                    {"invocation": invocation, "result": f"Error: {error_message}"}
-                )
+                tasks[-1].set_result({"invocation": invocation, "result": f"Error: {error_message}"})
                 invocation_map[tasks[-1]] = invocation
 
         # Wait for all tasks to complete
@@ -284,9 +268,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
                 tool_name: str = invocation.get("tool_name", "unknown")
                 error_message = f"Unexpected error in tool '{tool_name}': {str(e)}"
                 await tool_ctx.error(error_message)
-                results.append(
-                    {"invocation": invocation, "result": f"Error: {error_message}"}
-                )
+                results.append({"invocation": invocation, "result": f"Error: {error_message}"})
 
         # Extract cursor if provided
         cursor = params.get("cursor")
@@ -314,9 +296,7 @@ Not available: think,write,edit,multi_edit,notebook_edit
             )
 
         # Create paginated response with token awareness
-        paginated_response = create_paginated_response(
-            formatted_results, cursor=cursor, use_token_limit=True
-        )
+        paginated_response = create_paginated_response(formatted_results, cursor=cursor, use_token_limit=True)
 
         # Convert paginated response to string format for MCP
         if isinstance(paginated_response, dict) and "items" in paginated_response:
@@ -326,13 +306,9 @@ Not available: think,write,edit,multi_edit,notebook_edit
             # Add header
             result_parts.append(f"=== Batch operation: {description} ===")
             result_parts.append(f"Total invocations: {len(invocations)}")
-            result_parts.append(
-                f"Showing results: {len(paginated_response['items'])} of {len(results)}"
-            )
+            result_parts.append(f"Showing results: {len(paginated_response['items'])} of {len(results)}")
             if paginated_response.get("hasMore"):
-                result_parts.append(
-                    f"More results available - use cursor: {paginated_response.get('nextCursor')}"
-                )
+                result_parts.append(f"More results available - use cursor: {paginated_response.get('nextCursor')}")
             result_parts.append("")
 
             # Format each result
@@ -352,12 +328,8 @@ Not available: think,write,edit,multi_edit,notebook_edit
 
             # If there's a next cursor, we need to preserve it in the response
             # For now, append it as a note at the end
-            if paginated_response.get("hasMore") and paginated_response.get(
-                "nextCursor"
-            ):
-                formatted_output += (
-                    f"\n\n[To continue, use cursor: {paginated_response['nextCursor']}]"
-                )
+            if paginated_response.get("hasMore") and paginated_response.get("nextCursor"):
+                formatted_output += f"\n\n[To continue, use cursor: {paginated_response['nextCursor']}]"
 
             await tool_ctx.info(
                 f"Batch operation '{description}' completed with {len(paginated_response['items'])} results"
@@ -424,6 +396,4 @@ Not available: think,write,edit,multi_edit,notebook_edit
             cursor: Cursor,
             ctx: MCPContext,
         ) -> str:
-            return await tool_self.call(
-                ctx, description=description, invocations=invocations, cursor=cursor
-            )
+            return await tool_self.call(ctx, description=description, invocations=invocations, cursor=cursor)

hanzo_mcp/tools/common/config_tool.py

@@ -87,17 +87,11 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
 
         try:
             if action == "get":
-                return await self._get_config(
-                    scope, setting_path, project_name, project_path
-                )
+                return await self._get_config(scope, setting_path, project_name, project_path)
             elif action == "set":
-                return await self._set_config(
-                    scope, setting_path, value, project_name, project_path
-                )
+                return await self._set_config(scope, setting_path, value, project_name, project_path)
             elif action == "add_server":
-                return await self._add_mcp_server(
-                    server_name, server_config, scope, project_name
-                )
+                return await self._add_mcp_server(server_name, server_config, scope, project_name)
             elif action == "remove_server":
                 return await self._remove_mcp_server(server_name, scope, project_name)
             elif action == "enable_server":
@@ -158,10 +152,7 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
                 "agent": settings.agent.__dict__,
                 "vector_store": settings.vector_store.__dict__,
                 "hub_enabled": settings.hub_enabled,
-                "mcp_servers": {
-                    name: server.__dict__
-                    for name, server in settings.mcp_servers.items()
-                },
+                "mcp_servers": {name: server.__dict__ for name, server in settings.mcp_servers.items()},
                 "current_project": settings.current_project,
                 "projects": list(settings.projects.keys()),
             }
@@ -239,9 +230,7 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
         else:
             return f"Error: MCP server '{server_name}' already exists"
 
-    async def _remove_mcp_server(
-        self, server_name: Optional[str], scope: str, project_name: Optional[str]
-    ) -> str:
+    async def _remove_mcp_server(self, server_name: Optional[str], scope: str, project_name: Optional[str]) -> str:
         """Remove an MCP server."""
         if not server_name:
             return "Error: server_name is required"
@@ -254,9 +243,7 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
         else:
             return f"Error: MCP server '{server_name}' not found"
 
-    async def _enable_mcp_server(
-        self, server_name: Optional[str], scope: str, project_name: Optional[str]
-    ) -> str:
+    async def _enable_mcp_server(self, server_name: Optional[str], scope: str, project_name: Optional[str]) -> str:
         """Enable an MCP server."""
         if not server_name:
             return "Error: server_name is required"
@@ -269,9 +256,7 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
         else:
             return f"Error: MCP server '{server_name}' not found"
 
-    async def _disable_mcp_server(
-        self, server_name: Optional[str], scope: str, project_name: Optional[str]
-    ) -> str:
+    async def _disable_mcp_server(self, server_name: Optional[str], scope: str, project_name: Optional[str]) -> str:
         """Disable an MCP server."""
         if not server_name:
             return "Error: server_name is required"
@@ -297,9 +282,7 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
         else:
             return f"Error: MCP server '{server_name}' not found"
 
-    async def _add_project(
-        self, project_name: Optional[str], project_path: Optional[str]
-    ) -> str:
+    async def _add_project(self, project_name: Optional[str], project_path: Optional[str]) -> str:
         """Add a project configuration."""
         if not project_path:
             return "Error: project_path is required"
@@ -325,9 +308,7 @@ Automatically detects projects based on LLM.md files and manages .hanzo/ directo
         else:
             return f"Error: Project '{project_name}' already exists"
 
-    async def _set_current_project(
-        self, project_name: Optional[str], project_path: Optional[str]
-    ) -> str:
+    async def _set_current_project(self, project_name: Optional[str], project_path: Optional[str]) -> str:
         """Set the current active project."""
         settings = load_settings()
 

hanzo_mcp/tools/common/context.py

@@ -67,9 +67,7 @@ class ToolContext:
         """
         return self._mcp_context.client_id
 
-    async def set_tool_info(
-        self, tool_name: str, execution_id: str | None = None
-    ) -> None:
+    async def set_tool_info(self, tool_name: str, execution_id: str | None = None) -> None:
         """Set information about the currently executing tool.
 
         Args:

hanzo_mcp/tools/common/critic_tool.py

@@ -153,9 +153,7 @@ Recommendations:
 
         # Validate required analysis parameter
         if not analysis:
-            await tool_ctx.error(
-                "Parameter 'analysis' is required but was None or empty"
-            )
+            await tool_ctx.error("Parameter 'analysis' is required but was None or empty")
             return "Error: Parameter 'analysis' is required but was None or empty"
 
         if analysis.strip() == "":

hanzo_mcp/tools/common/decorators.py

@@ -120,9 +120,7 @@ def _is_valid_context(ctx: Any) -> bool:
     )
 
 
-def mcp_tool(
-    server: Any, name: str | None = None, description: str | None = None
-) -> Callable[[F], F]:
+def mcp_tool(server: Any, name: str | None = None, description: str | None = None) -> Callable[[F], F]:
     """Enhanced MCP tool decorator that includes context normalization.
 
     This decorator combines the standard MCP tool registration with
@@ -192,9 +190,7 @@ def create_tool_handler(server: Any, tool: Any) -> Callable[[], None]:
                 # Apply context normalization
                 normalized = with_context_normalization(func)
                 # Apply original decorator
-                return original_tool_decorator(name=name, description=description)(
-                    normalized
-                )
+                return original_tool_decorator(name=name, description=description)(normalized)
 
             return decorator
 

hanzo_mcp/tools/common/enhanced_base.py

@@ -85,9 +85,7 @@ class AutoRegisterTool(BaseTool, ABC):
         params = list(sig.parameters.items())
 
         # Skip 'self' and 'ctx' parameters
-        tool_params = [
-            (name, param) for name, param in params if name not in ("self", "ctx")
-        ]
+        tool_params = [(name, param) for name, param in params if name not in ("self", "ctx")]
 
         # Create the handler function dynamically
         async def handler(ctx: MCPContext, **kwargs: Any) -> Any:
@@ -98,6 +96,4 @@ class AutoRegisterTool(BaseTool, ABC):
         normalized_handler = with_context_normalization(handler)
 
         # Register with the server
-        mcp_server.tool(name=self.name, description=self.description)(
-            normalized_handler
-        )
+        mcp_server.tool(name=self.name, description=self.description)(normalized_handler)

hanzo_mcp/tools/common/fastmcp_pagination.py

@@ -143,9 +143,7 @@ class FastMCPPaginator(Generic[T]):
         cursor_data = CursorData.from_cursor(cursor) if cursor else CursorData()
 
         # Use provided page size or default
-        actual_page_size = min(
-            page_size or cursor_data.page_size or self.page_size, self.max_page_size
-        )
+        actual_page_size = min(page_size or cursor_data.page_size or self.page_size, self.max_page_size)
 
         # Get starting position
         start_idx = cursor_data.offset
@@ -207,9 +205,7 @@ class FastMCPPaginator(Generic[T]):
         cursor_data = CursorData.from_cursor(cursor) if cursor else CursorData()
 
         # Determine page size
-        limit = min(
-            page_size or cursor_data.page_size or self.page_size, self.max_page_size
-        )
+        limit = min(page_size or cursor_data.page_size or self.page_size, self.max_page_size)
 
         # Execute query with cursor position
         results = query_func(
@@ -258,9 +254,7 @@ class TokenAwarePaginator:
         self.max_tokens = max_tokens
         self.paginator = FastMCPPaginator()
 
-    def paginate_by_tokens(
-        self, items: List[Any], cursor: Optional[str] = None, estimate_func=None
-    ) -> Dict[str, Any]:
+    def paginate_by_tokens(self, items: List[Any], cursor: Optional[str] = None, estimate_func=None) -> Dict[str, Any]:
         """Paginate items based on token count.
 
         Args:
@@ -275,9 +269,7 @@ class TokenAwarePaginator:
 
         # Default token estimation
         if not estimate_func:
-            estimate_func = lambda x: estimate_tokens(
-                json.dumps(x) if not isinstance(x, str) else x
-            )
+            estimate_func = lambda x: estimate_tokens(json.dumps(x) if not isinstance(x, str) else x)
 
         # Parse cursor
         cursor_data = CursorData.from_cursor(cursor) if cursor else CursorData()

hanzo_mcp/tools/common/forgiving_edit.py

@@ -42,9 +42,7 @@ class ForgivingEditHelper:
         return "\n".join(lines)
 
     @staticmethod
-    def find_fuzzy_match(
-        haystack: str, needle: str, threshold: float = 0.85
-    ) -> Optional[Tuple[int, int, str]]:
+    def find_fuzzy_match(haystack: str, needle: str, threshold: float = 0.85) -> Optional[Tuple[int, int, str]]:
         """Find a fuzzy match for the needle in the haystack.
 
         Args:
@@ -81,13 +79,9 @@ class ForgivingEditHelper:
 
             # Find end position by counting lines in needle
             needle_lines = norm_needle.count("\n") + 1
-            end_pos = sum(
-                len(line) + 1 for line in original_lines[: lines_before + needle_lines]
-            )
+            end_pos = sum(len(line) + 1 for line in original_lines[: lines_before + needle_lines])
 
-            matched = "\n".join(
-                original_lines[lines_before : lines_before + needle_lines]
-            )
+            matched = "\n".join(original_lines[lines_before : lines_before + needle_lines])
             return (start_pos, end_pos - 1, matched)
 
         # Try fuzzy matching on lines
@@ -119,9 +113,7 @@ class ForgivingEditHelper:
                 candidate_norm = ForgivingEditHelper.normalize_whitespace(candidate)
                 needle_norm = ForgivingEditHelper.normalize_whitespace(needle)
 
-                ratio = difflib.SequenceMatcher(
-                    None, candidate_norm, needle_norm
-                ).ratio()
+                ratio = difflib.SequenceMatcher(None, candidate_norm, needle_norm).ratio()
 
                 if ratio >= threshold:
                     start_pos = sum(len(l) + 1 for l in haystack_lines[:i])
@@ -130,9 +122,7 @@ class ForgivingEditHelper:
         return None
 
     @staticmethod
-    def suggest_matches(
-        haystack: str, needle: str, max_suggestions: int = 3
-    ) -> List[Tuple[float, str]]:
+    def suggest_matches(haystack: str, needle: str, max_suggestions: int = 3) -> List[Tuple[float, str]]:
         """Suggest possible matches when exact match fails.
 
         Args:
@@ -154,9 +144,7 @@ class ForgivingEditHelper:
             for line in haystack.split("\n"):
                 if line.strip():  # Skip empty lines
                     line_norm = ForgivingEditHelper.normalize_whitespace(line)
-                    ratio = difflib.SequenceMatcher(
-                        None, line_norm, needle_norm
-                    ).ratio()
+                    ratio = difflib.SequenceMatcher(None, line_norm, needle_norm).ratio()
                     if ratio > 0.5:  # Only reasonably similar lines
                         suggestions.append((ratio, line))
 
@@ -170,9 +158,7 @@ class ForgivingEditHelper:
                 candidate = "\n".join(candidate_lines)
                 candidate_norm = ForgivingEditHelper.normalize_whitespace(candidate)
 
-                ratio = difflib.SequenceMatcher(
-                    None, candidate_norm, needle_norm
-                ).ratio()
+                ratio = difflib.SequenceMatcher(None, candidate_norm, needle_norm).ratio()
                 if ratio > 0.5:
                     suggestions.append((ratio, candidate))
 
@@ -181,9 +167,7 @@ class ForgivingEditHelper:
         return suggestions[:max_suggestions]
 
     @staticmethod
-    def create_edit_suggestion(
-        file_content: str, old_string: str, new_string: str
-    ) -> dict:
+    def create_edit_suggestion(file_content: str, old_string: str, new_string: str) -> dict:
         """Create a helpful edit suggestion when match fails.
 
         Args:
@@ -212,10 +196,7 @@ class ForgivingEditHelper:
         if suggestions:
             return {
                 "error": "Could not find exact or fuzzy match",
-                "suggestions": [
-                    {"similarity": f"{score:.0%}", "text": text}
-                    for score, text in suggestions
-                ],
+                "suggestions": [{"similarity": f"{score:.0%}", "text": text} for score, text in suggestions],
                 "hint": "Try using one of these suggestions as old_string",
             }