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

hanzo_mcp/tools/filesystem/search_tool.py

@@ -248,9 +248,7 @@ This is the recommended search tool for comprehensive results."""
     ) -> List[SearchResult]:
         """Run grep search and parse results."""
         try:
-            result = await self.grep_tool.call(
-                tool_ctx.mcp_context, pattern=pattern, path=path, include=include
-            )
+            result = await self.grep_tool.call(tool_ctx.mcp_context, pattern=pattern, path=path, include=include)
 
             results = []
             if "Found" in result and "matches" in result:
@@ -281,9 +279,7 @@ This is the recommended search tool for comprehensive results."""
             await tool_ctx.error(f"Grep search failed: {e}")
             return []
 
-    async def _run_grep_ast_search(
-        self, pattern: str, path: str, tool_ctx, max_results: int
-    ) -> List[SearchResult]:
+    async def _run_grep_ast_search(self, pattern: str, path: str, tool_ctx, max_results: int) -> List[SearchResult]:
         """Run AST-aware search and parse results."""
         try:
             result = await self.grep_ast_tool.call(
@@ -317,11 +313,7 @@ This is the recommended search tool for comprehensive results."""
                                     content=content,
                                     search_type=SearchType.GREP_AST,
                                     score=0.95,  # High score for AST matches
-                                    context=(
-                                        " > ".join(current_context)
-                                        if current_context
-                                        else None
-                                    ),
+                                    context=(" > ".join(current_context) if current_context else None),
                                 )
                             )
 
@@ -339,9 +331,7 @@ This is the recommended search tool for comprehensive results."""
             await tool_ctx.error(f"AST search failed: {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 semantic vector search."""
         if not self.vector_tool:
             return []
@@ -399,9 +389,7 @@ This is the recommended search tool for comprehensive results."""
             await tool_ctx.error(f"Vector search failed: {e}")
             return []
 
-    async def _run_git_search(
-        self, pattern: str, path: str, tool_ctx, max_results: int
-    ) -> List[SearchResult]:
+    async def _run_git_search(self, pattern: str, path: str, tool_ctx, max_results: int) -> List[SearchResult]:
         """Run git history search."""
         try:
             # Search in both content and commits
@@ -440,11 +428,7 @@ This is the recommended search tool for comprehensive results."""
                                     SearchResult(
                                         file_path=parts[0].strip(),
                                         line_number=None,
-                                        content=(
-                                            parts[-1].strip()
-                                            if len(parts) > 2
-                                            else line
-                                        ),
+                                        content=(parts[-1].strip() if len(parts) > 2 else line),
                                         search_type=SearchType.GIT,
                                         score=0.8,  # Good score for git matches
                                     )
@@ -460,9 +444,7 @@ This is the recommended search tool for comprehensive results."""
             await tool_ctx.error(f"Git search failed: {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]:
         """Search for symbol definitions using grep with specific patterns."""
         try:
             # Create patterns for common symbol definitions
@@ -477,11 +459,7 @@ This is the recommended search tool for comprehensive results."""
             # Run grep searches in parallel for each pattern
             tasks = []
             for sp in symbol_patterns:
-                tasks.append(
-                    self.grep_tool.call(
-                        tool_ctx.mcp_context, pattern=sp, path=path, include="*"
-                    )
-                )
+                tasks.append(self.grep_tool.call(tool_ctx.mcp_context, pattern=sp, path=path, include="*"))
 
             grep_results = await asyncio.gather(*tasks, return_exceptions=True)
 
@@ -518,9 +496,7 @@ This is the recommended search tool for comprehensive results."""
             await tool_ctx.error(f"Symbol search failed: {e}")
             return []
 
-    def _deduplicate_results(
-        self, all_results: List[SearchResult]
-    ) -> List[SearchResult]:
+    def _deduplicate_results(self, all_results: List[SearchResult]) -> List[SearchResult]:
         """Deduplicate results, keeping the highest scoring version."""
         seen = {}
 
@@ -547,9 +523,7 @@ This is the recommended search tool for comprehensive results."""
         }
 
         # Sort by score (descending) and then by type priority
-        results.sort(
-            key=lambda r: (r.score, type_priority.get(r.search_type, 0)), reverse=True
-        )
+        results.sort(key=lambda r: (r.score, type_priority.get(r.search_type, 0)), reverse=True)
 
         return results
 
@@ -599,42 +573,26 @@ This is the recommended search tool for comprehensive results."""
         search_names = []
 
         if params.get("enable_grep", True) and pattern_analysis["use_grep"]:
-            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))
             search_names.append("grep")
 
         if params.get("enable_grep_ast", True) and pattern_analysis["use_grep_ast"]:
-            search_tasks.append(
-                self._run_grep_ast_search(pattern, path, tool_ctx, max_results)
-            )
+            search_tasks.append(self._run_grep_ast_search(pattern, path, tool_ctx, max_results))
             search_names.append("grep_ast")
 
-        if (
-            params.get("enable_vector", True)
-            and self.vector_tool
-            and pattern_analysis["use_vector"]
-        ):
-            search_tasks.append(
-                self._run_vector_search(pattern, path, tool_ctx, max_results)
-            )
+        if params.get("enable_vector", True) and self.vector_tool and pattern_analysis["use_vector"]:
+            search_tasks.append(self._run_vector_search(pattern, path, tool_ctx, max_results))
             search_names.append("vector")
 
         if params.get("enable_git", True) and pattern_analysis["use_git"]:
-            search_tasks.append(
-                self._run_git_search(pattern, path, tool_ctx, max_results)
-            )
+            search_tasks.append(self._run_git_search(pattern, path, tool_ctx, max_results))
             search_names.append("git")
 
         if params.get("enable_symbol", True) and pattern_analysis["use_symbol"]:
-            search_tasks.append(
-                self._run_symbol_search(pattern, path, tool_ctx, max_results)
-            )
+            search_tasks.append(self._run_symbol_search(pattern, path, tool_ctx, max_results))
             search_names.append("symbol")
 
-        await tool_ctx.info(
-            f"Running {len(search_tasks)} search types in parallel: {', '.join(search_names)}"
-        )
+        await tool_ctx.info(f"Running {len(search_tasks)} search types in parallel: {', '.join(search_names)}")
 
         # Run all searches in parallel
         search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
@@ -719,9 +677,7 @@ This is the recommended search tool for comprehensive results."""
                 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/symbols_tool.py

@@ -141,9 +141,7 @@ Finds code structures (functions, classes, methods) with full context."""
         # Route to appropriate handler
         if action == "search":
             return await self._handle_search(params, tool_ctx)
-        elif (
-            action == "ast" or action == "grep_ast"
-        ):  # Support both for backward compatibility
+        elif action == "ast" or action == "grep_ast":  # Support both for backward compatibility
             return await self._handle_ast(params, tool_ctx)
         elif action == "index":
             return await self._handle_index(params, tool_ctx)
@@ -218,9 +216,7 @@ Finds code structures (functions, classes, methods) with full context."""
                         output = tc.format()
                     else:
                         # Just show matching lines
-                        output = "\n".join(
-                            [f"{line}: {code.splitlines()[line - 1]}" for line in loi]
-                        )
+                        output = "\n".join([f"{line}: {code.splitlines()[line - 1]}" for line in loi])
 
                     results.append(f"\n{file_path}:\n{output}\n")
                     match_count += len(loi)
@@ -325,9 +321,7 @@ Finds code structures (functions, classes, methods) with full context."""
             return f"No matches found for '{pattern}' in {path}"
 
         output = [f"=== AST-aware Grep Results for '{pattern}' ==="]
-        output.append(
-            f"Total matches: {match_count} in {len([r for r in results if '===' in str(r)]) // 4} files\n"
-        )
+        output.append(f"Total matches: {match_count} in {len([r for r in results if '===' in str(r)]) // 4} files\n")
         output.extend(results)
 
         if match_count >= limit:
@@ -490,16 +484,12 @@ Finds code structures (functions, classes, methods) with full context."""
             for root, _, files in os.walk(path_obj):
                 for file in files:
                     file_path = Path(root) / file
-                    if file_path.suffix in extensions and self.is_path_allowed(
-                        str(file_path)
-                    ):
+                    if file_path.suffix in extensions and self.is_path_allowed(str(file_path)):
                         files_to_process.append(str(file_path))
 
         return files_to_process
 
-    def _extract_symbols(
-        self, tc: TreeContext, file_path: str
-    ) -> Dict[str, List[Dict[str, Any]]]:
+    def _extract_symbols(self, tc: TreeContext, file_path: str) -> Dict[str, List[Dict[str, Any]]]:
         """Extract symbols from a TreeContext (placeholder implementation)."""
         # This would need proper tree-sitter queries to extract symbols
         # For now, return empty structure

hanzo_mcp/tools/filesystem/tree.py

@@ -188,9 +188,7 @@ tree --pattern "*.py" --show-size"""
             if pattern:
                 import fnmatch
 
-                entries = [
-                    e for e in entries if fnmatch.fnmatch(e.name, pattern) or e.is_dir()
-                ]
+                entries = [e for e in entries if fnmatch.fnmatch(e.name, pattern) or e.is_dir()]
 
             # Filter dirs only
             if dirs_only:

hanzo_mcp/tools/filesystem/watch.py

@@ -191,9 +191,7 @@ watch . --recursive --exclude "__pycache__"
             output.append("\nWatch cancelled")
 
         # Summary
-        output.append(
-            f"\nWatch completed after {int(time.time() - start_time)} seconds"
-        )
+        output.append(f"\nWatch completed after {int(time.time() - start_time)} seconds")
         output.append(f"Total changes detected: {len(changes)}")
 
         return "\n".join(output)

hanzo_mcp/tools/filesystem/write.py

@@ -125,9 +125,7 @@ Usage:
             with open(path_obj, "w", encoding="utf-8") as f:
                 f.write(content)
 
-            await tool_ctx.info(
-                f"Successfully wrote file: {file_path} ({len(content)} bytes)"
-            )
+            await tool_ctx.info(f"Successfully wrote file: {file_path} ({len(content)} bytes)")
             return f"Successfully wrote file: {file_path} ({len(content)} bytes)"
         except Exception as e:
             await tool_ctx.error(f"Error writing file: {str(e)}")

hanzo_mcp/tools/jupyter/base.py

@@ -127,9 +127,7 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
         """
         tool_ctx.set_tool_info(self.name)
 
-    async def parse_notebook(
-        self, file_path: Path
-    ) -> tuple[dict[str, Any], list[NotebookCellSource]]:
+    async def parse_notebook(self, file_path: Path) -> tuple[dict[str, Any], list[NotebookCellSource]]:
         """Parse a Jupyter notebook file.
 
         Args:
@@ -143,9 +141,7 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
             notebook = json.loads(content)
 
         # Get notebook language
-        language = (
-            notebook.get("metadata", {}).get("language_info", {}).get("name", "python")
-        )
+        language = notebook.get("metadata", {}).get("language_info", {}).get("name", "python")
         cells = notebook.get("cells", [])
         processed_cells = []
 
@@ -177,9 +173,7 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
                         text = output.get("text", "")
                         if isinstance(text, list):
                             text = "".join(text)
-                        outputs.append(
-                            NotebookCellOutput(output_type="stream", text=text)
-                        )
+                        outputs.append(NotebookCellOutput(output_type="stream", text=text))
 
                     elif output_type in ["execute_result", "display_data"]:
                         # Process text output
@@ -205,11 +199,7 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
                                     media_type="image/jpeg",
                                 )
 
-                        outputs.append(
-                            NotebookCellOutput(
-                                output_type=output_type, text=text, image=image
-                            )
-                        )
+                        outputs.append(NotebookCellOutput(output_type=output_type, text=text, image=image))
 
                     elif output_type == "error":
                         # Format error traceback
@@ -220,17 +210,13 @@ class JupyterBaseTool(FilesystemBaseTool, ABC):
                         # Handle raw text strings and lists of strings
                         if isinstance(traceback, list):
                             # Clean ANSI escape codes and join the list but preserve the formatting
-                            clean_traceback = [
-                                clean_ansi_escapes(line) for line in traceback
-                            ]
+                            clean_traceback = [clean_ansi_escapes(line) for line in traceback]
                             traceback_text = "\n".join(clean_traceback)
                         else:
                             traceback_text = clean_ansi_escapes(str(traceback))
 
                         error_text = f"{ename}: {evalue}\n{traceback_text}"
-                        outputs.append(
-                            NotebookCellOutput(output_type="error", text=error_text)
-                        )
+                        outputs.append(NotebookCellOutput(output_type="error", text=error_text))
 
             # Create cell object
             processed_cell = NotebookCellSource(

hanzo_mcp/tools/jupyter/jupyter.py

@@ -151,9 +151,7 @@ jupyter --action create "new.ipynb"
         else:
             return f"Error: Unknown action '{action}'. Valid actions: read, edit, create, delete, execute"
 
-    async def _handle_read(
-        self, notebook_path: str, params: Dict[str, Any], tool_ctx
-    ) -> str:
+    async def _handle_read(self, notebook_path: str, params: Dict[str, Any], tool_ctx) -> str:
         """Read notebook or specific cell."""
         exists, error_msg = await self.check_path_exists(notebook_path, tool_ctx)
         if not exists:
@@ -188,9 +186,7 @@ jupyter --action create "new.ipynb"
             await tool_ctx.error(f"Failed to read notebook: {str(e)}")
             return f"Error reading notebook: {str(e)}"
 
-    async def _handle_edit(
-        self, notebook_path: str, params: Dict[str, Any], tool_ctx
-    ) -> str:
+    async def _handle_edit(self, notebook_path: str, params: Dict[str, Any], tool_ctx) -> str:
         """Edit notebook cell."""
         exists, error_msg = await self.check_path_exists(notebook_path, tool_ctx)
         if not exists:
@@ -295,9 +291,7 @@ jupyter --action create "new.ipynb"
             await tool_ctx.error(f"Failed to create notebook: {str(e)}")
             return f"Error creating notebook: {str(e)}"
 
-    async def _handle_delete(
-        self, notebook_path: str, params: Dict[str, Any], tool_ctx
-    ) -> str:
+    async def _handle_delete(self, notebook_path: str, params: Dict[str, Any], tool_ctx) -> str:
         """Delete notebook or cell."""
         # If cell specified, delegate to edit with delete mode
         if params.get("cell_id") or params.get("cell_index") is not None:
@@ -316,9 +310,7 @@ jupyter --action create "new.ipynb"
             await tool_ctx.error(f"Failed to delete notebook: {str(e)}")
             return f"Error deleting notebook: {str(e)}"
 
-    async def _handle_execute(
-        self, notebook_path: str, params: Dict[str, Any], tool_ctx
-    ) -> str:
+    async def _handle_execute(self, notebook_path: str, params: Dict[str, Any], tool_ctx) -> str:
         """Execute notebook cells (placeholder for future implementation)."""
         return "Error: Cell execution not yet implemented. Use a Jupyter kernel or server for execution."
 

hanzo_mcp/tools/jupyter/notebook_edit.py

@@ -137,20 +137,14 @@ class NoteBookEditTool(JupyterBaseTool):
 
         # Don't validate new_source for delete mode
         if edit_mode != "delete" and not new_source:
-            await tool_ctx.error(
-                "New source is required for replace or insert operations"
-            )
+            await tool_ctx.error("New source is required for replace or insert operations")
             return "Error: New source is required for replace or insert operations"
 
-        await tool_ctx.info(
-            f"Editing notebook: {notebook_path} (cell: {cell_number}, mode: {edit_mode})"
-        )
+        await tool_ctx.info(f"Editing notebook: {notebook_path} (cell: {cell_number}, mode: {edit_mode})")
 
         # Check if path is allowed
         if not self.is_path_allowed(notebook_path):
-            await tool_ctx.error(
-                f"Access denied - path outside allowed directories: {notebook_path}"
-            )
+            await tool_ctx.error(f"Access denied - path outside allowed directories: {notebook_path}")
             return f"Error: Access denied - path outside allowed directories: {notebook_path}"
 
         try:
@@ -186,23 +180,15 @@ class NoteBookEditTool(JupyterBaseTool):
 
             if edit_mode == "insert":
                 if cell_number > len(cells):
-                    await tool_ctx.error(
-                        f"Cell number {cell_number} is out of bounds for insert (max: {len(cells)})"
-                    )
+                    await tool_ctx.error(f"Cell number {cell_number} is out of bounds for insert (max: {len(cells)})")
                     return f"Error: Cell number {cell_number} is out of bounds for insert (max: {len(cells)})"
             else:  # replace or delete
                 if cell_number >= len(cells):
-                    await tool_ctx.error(
-                        f"Cell number {cell_number} is out of bounds (max: {len(cells) - 1})"
-                    )
+                    await tool_ctx.error(f"Cell number {cell_number} is out of bounds (max: {len(cells) - 1})")
                     return f"Error: Cell number {cell_number} is out of bounds (max: {len(cells) - 1})"
 
             # Get notebook language (needed for context but not directly used in this block)
-            _ = (
-                notebook.get("metadata", {})
-                .get("language_info", {})
-                .get("name", "python")
-            )
+            _ = notebook.get("metadata", {}).get("language_info", {}).get("name", "python")
 
             # Perform the requested operation
             if edit_mode == "replace":
@@ -238,9 +224,7 @@ class NoteBookEditTool(JupyterBaseTool):
 
                 change_description = f"Replaced cell {cell_number}"
                 if cell_type is not None and cell_type != old_type:
-                    change_description += (
-                        f" (changed type from {old_type} to {cell_type})"
-                    )
+                    change_description += f" (changed type from {old_type} to {cell_type})"
 
             elif edit_mode == "insert":
                 # Create new cell
@@ -257,9 +241,7 @@ class NoteBookEditTool(JupyterBaseTool):
 
                 # Insert the cell
                 cells.insert(cell_number, new_cell)
-                change_description = (
-                    f"Inserted new {cell_type} cell at position {cell_number}"
-                )
+                change_description = f"Inserted new {cell_type} cell at position {cell_number}"
 
             else:  # delete
                 # Store deleted cell info for reporting
@@ -268,20 +250,14 @@ class NoteBookEditTool(JupyterBaseTool):
 
                 # Remove the cell
                 del cells[cell_number]
-                change_description = (
-                    f"Deleted {deleted_type} cell at position {cell_number}"
-                )
+                change_description = f"Deleted {deleted_type} cell at position {cell_number}"
 
             # Write the updated notebook back to file
             with open(file_path, "w", encoding="utf-8") as f:
                 json.dump(notebook, f, indent=1)
 
-            await tool_ctx.info(
-                f"Successfully edited notebook: {notebook_path} - {change_description}"
-            )
-            return (
-                f"Successfully edited notebook: {notebook_path} - {change_description}"
-            )
+            await tool_ctx.info(f"Successfully edited notebook: {notebook_path} - {change_description}")
+            return f"Successfully edited notebook: {notebook_path} - {change_description}"
         except Exception as e:
             await tool_ctx.error(f"Error editing notebook: {str(e)}")
             return f"Error editing notebook: {str(e)}"

hanzo_mcp/tools/jupyter/notebook_read.py

@@ -86,9 +86,7 @@ class NotebookReadTool(JupyterBaseTool):
 
         # Check if path is allowed
         if not self.is_path_allowed(notebook_path):
-            await tool_ctx.error(
-                f"Access denied - path outside allowed directories: {notebook_path}"
-            )
+            await tool_ctx.error(f"Access denied - path outside allowed directories: {notebook_path}")
             return f"Error: Access denied - path outside allowed directories: {notebook_path}"
 
         try:
@@ -115,9 +113,7 @@ class NotebookReadTool(JupyterBaseTool):
                 # Format the notebook content as a readable string
                 result = self.format_notebook_cells(processed_cells)
 
-                await tool_ctx.info(
-                    f"Successfully read notebook: {notebook_path} ({len(processed_cells)} cells)"
-                )
+                await tool_ctx.info(f"Successfully read notebook: {notebook_path} ({len(processed_cells)} cells)")
                 return result
             except json.JSONDecodeError:
                 await tool_ctx.error(f"Invalid notebook format: {notebook_path}")

hanzo_mcp/tools/llm/consensus_tool.py

@@ -211,22 +211,14 @@ The tool will:
         )
 
         # Prepare summary of results
-        successful_responses = [
-            (m, r) for m, r in results.items() if not r.startswith("Error:")
-        ]
-        failed_responses = [
-            (m, r) for m, r in results.items() if r.startswith("Error:")
-        ]
+        successful_responses = [(m, r) for m, r in results.items() if not r.startswith("Error:")]
+        failed_responses = [(m, r) for m, r in results.items() if r.startswith("Error:")]
 
         if not successful_responses:
-            return "Error: All model queries failed:\n\n" + "\n".join(
-                [f"{m}: {r}" for m, r in failed_responses]
-            )
+            return "Error: All model queries failed:\n\n" + "\n".join([f"{m}: {r}" for m, r in failed_responses])
 
         # Use aggregation model to synthesize responses
-        consensus = await self._aggregate_responses(
-            successful_responses, prompt, aggregation_model
-        )
+        consensus = await self._aggregate_responses(successful_responses, prompt, aggregation_model)
 
         # Format output
         output = ["=== LLM Consensus Analysis ==="]
@@ -245,9 +237,7 @@ The tool will:
             output.append("\n=== Individual Responses ===")
             for model, response in successful_responses:
                 output.append(f"\n--- {model} ---")
-                output.append(
-                    response[:500] + "..." if len(response) > 500 else response
-                )
+                output.append(response[:500] + "..." if len(response) > 500 else response)
 
         if failed_responses:
             output.append("\n=== Failed Queries ===")
@@ -282,9 +272,7 @@ The tool will:
                 # Create a mock context for the LLM tool
                 mock_ctx = type("MockContext", (), {"client": None})()
 
-                result = await asyncio.wait_for(
-                    self.llm_tool.call(mock_ctx, **params), timeout=timeout
-                )
+                result = await asyncio.wait_for(self.llm_tool.call(mock_ctx, **params), timeout=timeout)
                 return (model, result)
             except asyncio.TimeoutError:
                 return (model, f"Error: Timeout after {timeout} seconds")
@@ -305,9 +293,7 @@ The tool will:
     ) -> str:
         """Use an LLM to aggregate and analyze responses."""
         # Prepare the aggregation prompt
-        response_summary = "\n\n".join(
-            [f"Model: {model}\nResponse: {response}" for model, response in responses]
-        )
+        response_summary = "\n\n".join([f"Model: {model}\nResponse: {response}" for model, response in responses])
 
         aggregation_prompt = f"""You are analyzing responses from multiple AI models to the following prompt:
 
@@ -360,9 +346,7 @@ Be concise but thorough. Focus on providing actionable insights."""
         for model, response in responses:
             output.append(f"- {model}: {len(response)} characters")
 
-        output.append(
-            "\nNote: Advanced consensus analysis unavailable. Showing basic summary only."
-        )
+        output.append("\nNote: Advanced consensus analysis unavailable. Showing basic summary only.")
 
         return "\n".join(output)
 

hanzo_mcp/tools/llm/llm_manage.py

@@ -192,9 +192,7 @@ Providers are automatically detected based on environment variables:
             for provider in available_but_disabled:
                 env_vars = available_providers.get(provider, [])
                 output.append(f"  - {provider}: {', '.join(env_vars)}")
-                output.append(
-                    f"    Use: llm_manage --action enable --provider {provider}"
-                )
+                output.append(f"    Use: llm_manage --action enable --provider {provider}")
             output.append("")
 
         # Show providers without API keys
@@ -356,9 +354,7 @@ Providers are automatically detected based on environment variables:
         except Exception as e:
             return f"Error listing models: {str(e)}"
 
-    async def _test_model(
-        self, ctx: MCPContext, provider: Optional[str], model: Optional[str]
-    ) -> str:
+    async def _test_model(self, ctx: MCPContext, provider: Optional[str], model: Optional[str]) -> str:
         """Test a model to verify it works."""
         if not model and not provider:
             return "Error: Either model or provider is required for test action"