hanzo-mcp 0.7.7__py3-none-any.whl → 0.8.1__py3-none-any.whl

hanzo_mcp/tools/filesystem/watch.py

@@ -1,26 +1,25 @@
 """Watch files for changes."""
 
+import time
 import asyncio
-import os
-from pathlib import Path
 from typing import override
-import time
+from pathlib import Path
 from datetime import datetime
 
+from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
-from mcp.server import FastMCP
 
 
 class WatchTool(BaseTool):
     """Tool for watching files for changes."""
 
     name = "watch"
-    
+
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
-        
+
         @server.tool(name=self.name, description=self.description)
         async def watch_handler(
             ctx: MCPContext,
@@ -29,7 +28,7 @@ class WatchTool(BaseTool):
             interval: int = 1,
             recursive: bool = True,
             exclude: str = "",
-            duration: int = 30
+            duration: int = 30,
         ) -> str:
             """Handle watch tool calls."""
             return await self.run(
@@ -41,7 +40,7 @@ class WatchTool(BaseTool):
                 exclude=exclude,
                 duration=duration,
             )
-    
+
     async def call(self, ctx: MCPContext, **params) -> str:
         """Call the tool with arguments."""
         return await self.run(
@@ -51,7 +50,7 @@ class WatchTool(BaseTool):
             interval=params.get("interval", 1),
             recursive=params.get("recursive", True),
             exclude=params.get("exclude", ""),
-            duration=params.get("duration", 30)
+            duration=params.get("duration", 30),
         )
 
     @property
@@ -68,8 +67,8 @@ watch . --recursive --exclude "__pycache__"
 
     @override
     async def run(
-        self, 
-        ctx: MCPContext, 
+        self,
+        ctx: MCPContext,
         path: str,
         pattern: str = "*",
         interval: int = 1,
@@ -78,7 +77,7 @@ watch . --recursive --exclude "__pycache__"
         duration: int = 30,
     ) -> str:
         """Watch files for changes.
-        
+
         Args:
             ctx: MCP context
             path: Path to watch (file or directory)
@@ -87,23 +86,23 @@ watch . --recursive --exclude "__pycache__"
             recursive: Watch subdirectories (default: True)
             exclude: Patterns to exclude (comma-separated)
             duration: Max watch duration in seconds (default: 30)
-            
+
         Returns:
             Report of file changes
         """
         watch_path = Path(path).expanduser().resolve()
-        
+
         if not watch_path.exists():
             raise ValueError(f"Path does not exist: {watch_path}")
-        
+
         # Parse exclude patterns
         exclude_patterns = [p.strip() for p in exclude.split(",") if p.strip()]
-        
+
         # Track file states
         file_states = {}
         changes = []
         start_time = time.time()
-        
+
         def should_exclude(file_path: Path) -> bool:
             """Check if file should be excluded."""
             for pattern in exclude_patterns:
@@ -112,17 +111,17 @@ watch . --recursive --exclude "__pycache__"
                 if file_path.match(pattern):
                     return True
             return False
-        
+
         def get_files() -> dict[Path, float]:
             """Get all matching files with their modification times."""
             files = {}
-            
+
             if watch_path.is_file():
                 # Watching a single file
                 if not should_exclude(watch_path):
                     try:
                         files[watch_path] = watch_path.stat().st_mtime
-                    except:
+                    except Exception:
                         pass
             else:
                 # Watching a directory
@@ -130,33 +129,33 @@ watch . --recursive --exclude "__pycache__"
                     paths = watch_path.rglob(pattern)
                 else:
                     paths = watch_path.glob(pattern)
-                
+
                 for file_path in paths:
                     if file_path.is_file() and not should_exclude(file_path):
                         try:
                             files[file_path] = file_path.stat().st_mtime
-                        except:
+                        except Exception:
                             pass
-            
+
             return files
-        
+
         # Initial scan
         file_states = get_files()
         initial_count = len(file_states)
-        
+
         output = [f"Watching {watch_path} (pattern: {pattern})"]
         output.append(f"Found {initial_count} files to monitor")
         if exclude_patterns:
             output.append(f"Excluding: {', '.join(exclude_patterns)}")
         output.append(f"Monitoring for {duration} seconds...\n")
-        
+
         # Monitor for changes
         try:
             while (time.time() - start_time) < duration:
                 await asyncio.sleep(interval)
-                
+
                 current_files = get_files()
-                
+
                 # Check for new files
                 for file_path, mtime in current_files.items():
                     if file_path not in file_states:
@@ -164,7 +163,7 @@ watch . --recursive --exclude "__pycache__"
                         change = f"[{timestamp}] CREATED: {file_path.relative_to(watch_path.parent)}"
                         changes.append(change)
                         output.append(change)
-                
+
                 # Check for deleted files
                 for file_path in list(file_states.keys()):
                     if file_path not in current_files:
@@ -173,7 +172,7 @@ watch . --recursive --exclude "__pycache__"
                         changes.append(change)
                         output.append(change)
                         del file_states[file_path]
-                
+
                 # Check for modified files
                 for file_path, mtime in current_files.items():
                     if file_path in file_states and mtime != file_states[file_path]:
@@ -182,21 +181,23 @@ watch . --recursive --exclude "__pycache__"
                         changes.append(change)
                         output.append(change)
                         file_states[file_path] = mtime
-                
+
                 # Update file states for new files
                 for file_path, mtime in current_files.items():
                     if file_path not in file_states:
                         file_states[file_path] = mtime
-                
+
         except asyncio.CancelledError:
             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)
 
 
 # Create tool instance
-watch_tool = WatchTool()
+watch_tool = WatchTool()

hanzo_mcp/tools/filesystem/write.py

@@ -3,12 +3,12 @@
 This module provides the Write tool for creating or overwriting files.
 """
 
+from typing import Unpack, Annotated, TypedDict, final, override
 from pathlib import Path
-from typing import Annotated, TypedDict, Unpack, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
@@ -146,9 +146,5 @@ Usage:
         tool_self = self  # Create a reference to self for use in the closure
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def write(
-            file_path: FilePath,
-            content: Content,
-            ctx: MCPContext
-        ) -> str:
+        async def write(file_path: FilePath, content: Content, ctx: MCPContext) -> str:
             return await tool_self.call(ctx, file_path=file_path, content=content)

hanzo_mcp/tools/jupyter/__init__.py

@@ -7,8 +7,8 @@ including reading and editing notebook cells.
 from mcp.server import FastMCP
 
 from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
-from hanzo_mcp.tools.common.permissions import PermissionManager
 from hanzo_mcp.tools.jupyter.jupyter import JupyterTool
+from hanzo_mcp.tools.common.permissions import PermissionManager
 
 # Export all tool classes
 __all__ = [
@@ -68,10 +68,10 @@ def register_jupyter_tools(
         "notebook_read": JupyterTool,
         "notebook_edit": JupyterTool,
     }
-    
+
     tools = []
     added_classes = set()  # Track which tool classes have been added
-    
+
     if enabled_tools:
         # Use individual tool configuration
         for tool_name, enabled in enabled_tools.items():
@@ -84,6 +84,6 @@ def register_jupyter_tools(
     else:
         # Use all tools (backward compatibility)
         tools = get_jupyter_tools(permission_manager)
-    
+
     ToolRegistry.register_tools(mcp_server, tools)
     return tools

hanzo_mcp/tools/jupyter/base.py

@@ -4,17 +4,16 @@ This module provides common functionality for Jupyter notebook tools, including
 cell processing, and output formatting.
 """
 
-from abc import ABC
-import json
 import re
-from pathlib import Path
+import json
+from abc import ABC
 from typing import Any, final
+from pathlib import Path
 
 from mcp.server.fastmcp import Context as MCPContext
 
-from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 from hanzo_mcp.tools.common.context import ToolContext, create_tool_context
-
+from hanzo_mcp.tools.filesystem.base import FilesystemBaseTool
 
 # Pattern to match ANSI escape sequences
 ANSI_ESCAPE_PATTERN = re.compile(r"\x1B\[[0-9;]*[a-zA-Z]")

hanzo_mcp/tools/jupyter/jupyter.py

@@ -1,16 +1,23 @@
 """Unified Jupyter notebook tool."""
 
-from typing import Annotated, TypedDict, Unpack, final, override, Optional, List, Dict, Any
-import json
-import nbformat
+from typing import (
+    Any,
+    Dict,
+    Unpack,
+    Optional,
+    Annotated,
+    TypedDict,
+    final,
+    override,
+)
 from pathlib import Path
 
-from mcp.server.fastmcp import Context as MCPContext
+import nbformat
 from pydantic import Field
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.jupyter.base import JupyterBaseTool
 
-
 # Parameter types
 Action = Annotated[
     str,
@@ -70,6 +77,7 @@ EditMode = Annotated[
 
 class NotebookParams(TypedDict, total=False):
     """Parameters for notebook tool."""
+
     action: str
     notebook_path: str
     cell_id: Optional[str]
@@ -114,7 +122,7 @@ jupyter --action create "new.ipynb"
         # Extract parameters
         action = params.get("action", "read")
         notebook_path = params.get("notebook_path")
-        
+
         if not notebook_path:
             return "Error: notebook_path is required"
 
@@ -143,7 +151,9 @@ 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:
@@ -151,34 +161,36 @@ jupyter --action create "new.ipynb"
 
         try:
             nb = self.read_notebook(notebook_path)
-            
+
             # Check if specific cell requested
             cell_id = params.get("cell_id")
             cell_index = params.get("cell_index")
-            
+
             if cell_id:
                 # Find cell by ID
                 for i, cell in enumerate(nb.cells):
                     if cell.get("id") == cell_id:
                         return self._format_cell(cell, i)
                 return f"Error: Cell with ID '{cell_id}' not found"
-            
+
             elif cell_index is not None:
                 # Get cell by index
                 if 0 <= cell_index < len(nb.cells):
                     return self._format_cell(nb.cells[cell_index], cell_index)
                 else:
                     return f"Error: Cell index {cell_index} out of range (notebook has {len(nb.cells)} cells)"
-            
+
             else:
                 # Return all cells
                 return self.format_notebook(nb)
-                
+
         except Exception as e:
             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:
@@ -186,7 +198,7 @@ jupyter --action create "new.ipynb"
 
         source = params.get("source")
         edit_mode = params.get("edit_mode", "replace")
-        
+
         # Only require source for non-delete operations
         if edit_mode != "delete" and not source:
             return "Error: source is required for edit action"
@@ -196,19 +208,23 @@ jupyter --action create "new.ipynb"
 
         try:
             nb = self.read_notebook(notebook_path)
-            
+
             if edit_mode == "insert":
                 # Insert new cell
-                new_cell = nbformat.v4.new_code_cell(source) if cell_type != "markdown" else nbformat.v4.new_markdown_cell(source)
-                
+                new_cell = (
+                    nbformat.v4.new_code_cell(source)
+                    if cell_type != "markdown"
+                    else nbformat.v4.new_markdown_cell(source)
+                )
+
                 if cell_index is not None:
                     nb.cells.insert(cell_index, new_cell)
                 else:
                     nb.cells.append(new_cell)
-                
+
                 self.write_notebook(nb, notebook_path)
-                return f"Successfully inserted new cell at index {cell_index if cell_index is not None else len(nb.cells)-1}"
-            
+                return f"Successfully inserted new cell at index {cell_index if cell_index is not None else len(nb.cells) - 1}"
+
             elif edit_mode == "delete":
                 # Delete cell
                 if cell_id:
@@ -218,7 +234,7 @@ jupyter --action create "new.ipynb"
                             self.write_notebook(nb, notebook_path)
                             return f"Successfully deleted cell with ID '{cell_id}'"
                     return f"Error: Cell with ID '{cell_id}' not found"
-                
+
                 elif cell_index is not None:
                     if 0 <= cell_index < len(nb.cells):
                         nb.cells.pop(cell_index)
@@ -228,7 +244,7 @@ jupyter --action create "new.ipynb"
                         return f"Error: Cell index {cell_index} out of range"
                 else:
                     return "Error: cell_id or cell_index required for delete"
-            
+
             else:  # replace
                 # Replace cell content
                 if cell_id:
@@ -240,7 +256,7 @@ jupyter --action create "new.ipynb"
                             self.write_notebook(nb, notebook_path)
                             return f"Successfully updated cell with ID '{cell_id}'"
                     return f"Error: Cell with ID '{cell_id}' not found"
-                
+
                 elif cell_index is not None:
                     if 0 <= cell_index < len(nb.cells):
                         nb.cells[cell_index]["source"] = source
@@ -252,7 +268,7 @@ jupyter --action create "new.ipynb"
                         return f"Error: Cell index {cell_index} out of range"
                 else:
                     return "Error: cell_id or cell_index required for replace"
-                    
+
         except Exception as e:
             await tool_ctx.error(f"Failed to edit notebook: {str(e)}")
             return f"Error editing notebook: {str(e)}"
@@ -267,25 +283,27 @@ jupyter --action create "new.ipynb"
         try:
             # Create new notebook
             nb = nbformat.v4.new_notebook()
-            
+
             # Ensure parent directory exists
             path.parent.mkdir(parents=True, exist_ok=True)
-            
+
             # Write notebook
             self.write_notebook(nb, notebook_path)
             return f"Successfully created notebook at {notebook_path}"
-            
+
         except Exception as e:
             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:
             params["edit_mode"] = "delete"
             return await self._handle_edit(notebook_path, params, tool_ctx)
-        
+
         # Otherwise, delete entire notebook
         exists, error_msg = await self.check_path_exists(notebook_path, tool_ctx)
         if not exists:
@@ -298,7 +316,9 @@ 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."
 
@@ -313,19 +333,19 @@ jupyter --action create "new.ipynb"
         if isinstance(source, list):
             source = "".join(source)
         output.append(source)
-        
+
         if cell.get("cell_type") == "code" and cell.get("outputs"):
             output.append("\nOutputs:")
             for out in cell.get("outputs", []):
                 out_type = out.get("output_type", "")
-                
+
                 if out_type == "stream":
                     text = out.get("text", "")
                     if isinstance(text, list):
                         text = "".join(text)
                     name = out.get("name", "stdout")
                     output.append(f"[{name}]: {text}")
-                    
+
                 elif out_type == "execute_result":
                     exec_count = out.get("execution_count", "?")
                     data = out.get("data", {})
@@ -337,7 +357,7 @@ jupyter --action create "new.ipynb"
                         output.append(f"[Out {exec_count}]: {text_data}")
                     else:
                         output.append(f"[Out {exec_count}]: {data}")
-                        
+
                 elif out_type == "error":
                     ename = out.get("ename", "Error")
                     evalue = out.get("evalue", "")
@@ -348,50 +368,50 @@ jupyter --action create "new.ipynb"
                         output.append("Traceback:")
                         for line in traceback:
                             output.append(f"  {line}")
-        
+
         return "\n".join(output)
 
     def read_notebook(self, notebook_path: str) -> Any:
         """Read a notebook from disk using nbformat.
-        
+
         Args:
             notebook_path: Path to the notebook file
-            
+
         Returns:
             Notebook object
         """
-        with open(notebook_path, 'r') as f:
+        with open(notebook_path, "r") as f:
             return nbformat.read(f, as_version=4)
-    
+
     def write_notebook(self, nb: Any, notebook_path: str) -> None:
         """Write a notebook to disk using nbformat.
-        
+
         Args:
             nb: Notebook object to write
             notebook_path: Path to write the notebook to
         """
-        with open(notebook_path, 'w') as f:
+        with open(notebook_path, "w") as f:
             nbformat.write(nb, f)
-    
+
     def format_notebook(self, nb: Any) -> str:
         """Format an entire notebook for display.
-        
+
         Args:
             nb: Notebook object
-            
+
         Returns:
             Formatted string representation of the notebook
         """
         output = []
         output.append(f"Notebook with {len(nb.cells)} cells")
         output.append("=" * 50)
-        
+
         for i, cell in enumerate(nb.cells):
             output.append("")
             output.append(self._format_cell(cell, i))
-        
+
         return "\n".join(output)
 
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""
-        pass
+        pass

hanzo_mcp/tools/jupyter/notebook_edit.py

@@ -4,12 +4,12 @@ This module provides the NoteBookEditTool for editing Jupyter notebook files.
 """
 
 import json
+from typing import Any, Unpack, Literal, Annotated, TypedDict, final, override
 from pathlib import Path
-from typing import Annotated, Any, Literal, TypedDict, Unpack, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.jupyter.base import JupyterBaseTool
 
@@ -305,7 +305,7 @@ class NoteBookEditTool(JupyterBaseTool):
             new_source: NewSource,
             cell_type: CellType,
             edit_mode: EditMode,
-            ctx: MCPContext
+            ctx: MCPContext,
         ) -> str:
             return await tool_self.call(
                 ctx,

hanzo_mcp/tools/jupyter/notebook_read.py

@@ -4,12 +4,12 @@ This module provides the NotebookReadTool for reading Jupyter notebook files.
 """
 
 import json
+from typing import Unpack, Annotated, TypedDict, final, override
 from pathlib import Path
-from typing import Annotated, TypedDict, Unpack, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
-from mcp.server import FastMCP
 from pydantic import Field
+from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.jupyter.base import JupyterBaseTool
 
@@ -143,8 +143,5 @@ class NotebookReadTool(JupyterBaseTool):
         tool_self = self  # Create a reference to self for use in the closure
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def notebook_read(
-            notebook_path: NotebookPath,
-            ctx: MCPContext
-        ) -> str:
+        async def notebook_read(notebook_path: NotebookPath, ctx: MCPContext) -> str:
             return await tool_self.call(ctx, notebook_path=notebook_path)

hanzo_mcp/tools/llm/__init__.py

@@ -1,19 +1,17 @@
 """LLM tools for Hanzo AI."""
 
-from hanzo_mcp.tools.llm.llm_tool import LLMTool
-
 # Legacy imports for backwards compatibility
 from hanzo_mcp.tools.llm.llm_tool import LLMTool
-from hanzo_mcp.tools.llm.consensus_tool import ConsensusTool
 from hanzo_mcp.tools.llm.llm_manage import LLMManageTool
+from hanzo_mcp.tools.llm.consensus_tool import ConsensusTool
 from hanzo_mcp.tools.llm.provider_tools import (
-    create_provider_tools,
-    OpenAITool,
-    AnthropicTool,
-    GeminiTool,
     GroqTool,
+    GeminiTool,
+    OpenAITool,
     MistralTool,
+    AnthropicTool,
     PerplexityTool,
+    create_provider_tools,
 )
 
 __all__ = [