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

hanzo_mcp/tools/common/plugin_loader.py

@@ -1,21 +1,21 @@
 """Plugin loader for custom user tools."""
 
-import importlib.util
-import inspect
-import json
 import os
 import sys
+import json
+import inspect
+import importlib.util
+from typing import Any, Dict, List, Type, Optional
 from pathlib import Path
-from typing import Dict, List, Optional, Type, Any
 from dataclasses import dataclass
 
 from .base import BaseTool
-from .context import ToolContext
 
 
 @dataclass
 class ToolPlugin:
     """Represents a loaded tool plugin."""
+
     name: str
     tool_class: Type[BaseTool]
     source_path: Path
@@ -24,47 +24,47 @@ class ToolPlugin:
 
 class PluginLoader:
     """Loads custom tool plugins from user directories."""
-    
+
     def __init__(self):
         self.plugins: Dict[str, ToolPlugin] = {}
         self.plugin_dirs: List[Path] = []
         self._setup_plugin_directories()
-    
+
     def _setup_plugin_directories(self):
         """Set up standard plugin directories."""
         # User's home directory plugins
         home_plugins = Path.home() / ".hanzo" / "plugins"
         home_plugins.mkdir(parents=True, exist_ok=True)
         self.plugin_dirs.append(home_plugins)
-        
+
         # Project-local plugins
         project_plugins = Path.cwd() / ".hanzo" / "plugins"
         if project_plugins.exists():
             self.plugin_dirs.append(project_plugins)
-        
+
         # Environment variable for additional paths
         if custom_paths := os.environ.get("HANZO_PLUGIN_PATH"):
             for path in custom_paths.split(":"):
                 plugin_dir = Path(path)
                 if plugin_dir.exists():
                     self.plugin_dirs.append(plugin_dir)
-    
+
     def load_plugins(self) -> Dict[str, ToolPlugin]:
         """Load all plugins from configured directories."""
         for plugin_dir in self.plugin_dirs:
             if not plugin_dir.exists():
                 continue
-                
+
             # Look for Python files
             for py_file in plugin_dir.glob("*.py"):
                 if py_file.name.startswith("_"):
                     continue
-                    
+
                 try:
                     self._load_plugin_file(py_file)
                 except Exception as e:
                     print(f"Failed to load plugin {py_file}: {e}")
-            
+
             # Look for plugin packages
             for package_dir in plugin_dir.iterdir():
                 if package_dir.is_dir() and (package_dir / "__init__.py").exists():
@@ -72,88 +72,88 @@ class PluginLoader:
                         self._load_plugin_package(package_dir)
                     except Exception as e:
                         print(f"Failed to load plugin package {package_dir}: {e}")
-        
+
         return self.plugins
-    
+
     def _load_plugin_file(self, file_path: Path):
         """Load a single plugin file."""
         # Load the module
         spec = importlib.util.spec_from_file_location(file_path.stem, file_path)
         if not spec or not spec.loader:
             return
-            
+
         module = importlib.util.module_from_spec(spec)
         sys.modules[file_path.stem] = module
         spec.loader.exec_module(module)
-        
+
         # Find tool classes
-        for name, obj in inspect.getmembers(module):
-            if (inspect.isclass(obj) and 
-                issubclass(obj, BaseTool) and 
-                obj != BaseTool and
-                hasattr(obj, 'name')):
-                
+        for _name, obj in inspect.getmembers(module):
+            if (
+                inspect.isclass(obj)
+                and issubclass(obj, BaseTool)
+                and obj != BaseTool
+                and hasattr(obj, "name")
+            ):
                 # Load metadata if available
                 metadata = None
-                metadata_file = file_path.with_suffix('.json')
+                metadata_file = file_path.with_suffix(".json")
                 if metadata_file.exists():
                     with open(metadata_file) as f:
                         metadata = json.load(f)
-                
+
                 plugin = ToolPlugin(
                     name=obj.name,
                     tool_class=obj,
                     source_path=file_path,
-                    metadata=metadata
+                    metadata=metadata,
                 )
                 self.plugins[obj.name] = plugin
-    
+
     def _load_plugin_package(self, package_dir: Path):
         """Load a plugin package."""
         # Add parent to path temporarily
         parent = str(package_dir.parent)
         if parent not in sys.path:
             sys.path.insert(0, parent)
-        
+
         try:
             # Import the package
             module = importlib.import_module(package_dir.name)
-            
+
             # Look for tools
-            if hasattr(module, 'TOOLS'):
+            if hasattr(module, "TOOLS"):
                 # Package exports TOOLS list
                 for tool_class in module.TOOLS:
                     if issubclass(tool_class, BaseTool):
                         plugin = ToolPlugin(
                             name=tool_class.name,
                             tool_class=tool_class,
-                            source_path=package_dir
+                            source_path=package_dir,
                         )
                         self.plugins[tool_class.name] = plugin
             else:
                 # Search for tool classes
-                for name, obj in inspect.getmembers(module):
-                    if (inspect.isclass(obj) and 
-                        issubclass(obj, BaseTool) and 
-                        obj != BaseTool and
-                        hasattr(obj, 'name')):
-                        
+                for _name, obj in inspect.getmembers(module):
+                    if (
+                        inspect.isclass(obj)
+                        and issubclass(obj, BaseTool)
+                        and obj != BaseTool
+                        and hasattr(obj, "name")
+                    ):
                         plugin = ToolPlugin(
-                            name=obj.name,
-                            tool_class=obj,
-                            source_path=package_dir
+                            name=obj.name, tool_class=obj, source_path=package_dir
                         )
                         self.plugins[obj.name] = plugin
         finally:
             # Remove from path
             if parent in sys.path:
                 sys.path.remove(parent)
-    
+
     def get_tool_class(self, name: str) -> Optional[Type[BaseTool]]:
         """Get a tool class by name."""
         plugin = self.plugins.get(name)
         return plugin.tool_class if plugin else None
-    
+
     def list_plugins(self) -> List[str]:
         """List all loaded plugin names."""
         return list(self.plugins.keys())
@@ -181,7 +181,7 @@ def list_plugin_tools() -> List[str]:
 def create_plugin_template(output_dir: Path, tool_name: str):
     """Create a template for a new plugin tool."""
     output_dir.mkdir(parents=True, exist_ok=True)
-    
+
     # Create tool file
     tool_file = output_dir / f"{tool_name}_tool.py"
     tool_content = f'''"""Custom {tool_name} tool plugin."""
@@ -225,10 +225,10 @@ class {tool_name.title()}Tool(BaseTool):
 # Optional: Export tools explicitly
 TOOLS = [{tool_name.title()}Tool]
 '''
-    
-    with open(tool_file, 'w') as f:
+
+    with open(tool_file, "w") as f:
         f.write(tool_content)
-    
+
     # Create metadata file
     metadata_file = output_dir / f"{tool_name}_tool.json"
     metadata_content = {
@@ -240,12 +240,12 @@ TOOLS = [{tool_name.title()}Tool]
         "dependencies": [],
         "config": {
             # Tool-specific configuration
-        }
+        },
     }
-    
-    with open(metadata_file, 'w') as f:
+
+    with open(metadata_file, "w") as f:
         json.dump(metadata_content, f, indent=2)
-    
+
     # Create README
     readme_file = output_dir / "README.md"
     readme_content = f"""# {tool_name.title()} Tool Plugin
@@ -276,12 +276,12 @@ Edit the `{tool_name}_tool.json` file to:
 
 Modify `{tool_name}_tool.py` to implement your custom functionality.
 """
-    
-    with open(readme_file, 'w') as f:
+
+    with open(readme_file, "w") as f:
         f.write(readme_content)
-    
+
     print(f"Created plugin template in {output_dir}")
     print(f"Files created:")
     print(f"  - {tool_file}")
     print(f"  - {metadata_file}")
-    print(f"  - {readme_file}")
+    print(f"  - {readme_file}")

hanzo_mcp/tools/common/stats.py

@@ -1,23 +1,22 @@
 """Comprehensive system and MCP statistics."""
 
-import os
-import psutil
-import shutil
-from typing import TypedDict, Unpack, final, override
-from datetime import datetime
+from typing import Unpack, TypedDict, final, override
 from pathlib import Path
+from datetime import datetime
 
+import psutil
 from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
+from hanzo_mcp.tools.mcp.mcp_add import McpAddTool
 from hanzo_mcp.tools.common.context import create_tool_context
 from hanzo_mcp.tools.shell.run_background import RunBackgroundTool
-from hanzo_mcp.tools.mcp.mcp_add import McpAddTool
 from hanzo_mcp.tools.database.database_manager import DatabaseManager
 
 
 class StatsParams(TypedDict, total=False):
     """Parameters for stats tool."""
+
     pass
 
 
@@ -27,7 +26,7 @@ class StatsTool(BaseTool):
 
     def __init__(self, db_manager: DatabaseManager = None):
         """Initialize the stats tool.
-        
+
         Args:
             db_manager: Optional database manager for DB stats
         """
@@ -77,50 +76,56 @@ Example:
 
         output = []
         warnings = []
-        
+
         # Header
         output.append("=== Hanzo AI System Statistics ===")
         output.append(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
         output.append("")
-        
+
         # System Resources
         output.append("=== System Resources ===")
-        
+
         # CPU
         cpu_percent = psutil.cpu_percent(interval=1)
         cpu_count = psutil.cpu_count()
         output.append(f"CPU Usage: {cpu_percent}% ({cpu_count} cores)")
         if cpu_percent > 90:
             warnings.append(f"⚠️  HIGH CPU USAGE: {cpu_percent}%")
-        
+
         # Memory
         memory = psutil.virtual_memory()
         memory_used_gb = memory.used / (1024**3)
         memory_total_gb = memory.total / (1024**3)
         memory_percent = memory.percent
-        output.append(f"Memory: {memory_used_gb:.1f}/{memory_total_gb:.1f} GB ({memory_percent}%)")
+        output.append(
+            f"Memory: {memory_used_gb:.1f}/{memory_total_gb:.1f} GB ({memory_percent}%)"
+        )
         if memory_percent > 90:
             warnings.append(f"⚠️  HIGH MEMORY USAGE: {memory_percent}%")
-        
+
         # Disk
-        disk = psutil.disk_usage('/')
+        disk = psutil.disk_usage("/")
         disk_used_gb = disk.used / (1024**3)
         disk_total_gb = disk.total / (1024**3)
         disk_percent = disk.percent
         disk_free_gb = disk.free / (1024**3)
-        output.append(f"Disk: {disk_used_gb:.1f}/{disk_total_gb:.1f} GB ({disk_percent}%)")
+        output.append(
+            f"Disk: {disk_used_gb:.1f}/{disk_total_gb:.1f} GB ({disk_percent}%)"
+        )
         output.append(f"Free Space: {disk_free_gb:.1f} GB")
         if disk_percent > 90:
-            warnings.append(f"⚠️  LOW DISK SPACE: Only {disk_free_gb:.1f} GB free ({100-disk_percent:.1f}% remaining)")
-        
+            warnings.append(
+                f"⚠️  LOW DISK SPACE: Only {disk_free_gb:.1f} GB free ({100 - disk_percent:.1f}% remaining)"
+            )
+
         output.append("")
-        
+
         # Background Processes
         output.append("=== Background Processes ===")
         processes = RunBackgroundTool.get_processes()
         running_count = 0
         total_memory_mb = 0
-        
+
         if processes:
             for proc in processes.values():
                 if proc.is_running():
@@ -129,12 +134,12 @@ Example:
                         ps_proc = psutil.Process(proc.process.pid)
                         memory_mb = ps_proc.memory_info().rss / (1024**2)
                         total_memory_mb += memory_mb
-                    except:
+                    except Exception:
                         pass
-            
+
             output.append(f"Running Processes: {running_count}")
             output.append(f"Total Memory Usage: {total_memory_mb:.1f} MB")
-            
+
             # List top processes by memory
             if running_count > 0:
                 output.append("\nTop Processes:")
@@ -146,31 +151,33 @@ Example:
                             memory_mb = ps_proc.memory_info().rss / (1024**2)
                             cpu = ps_proc.cpu_percent(interval=0.1)
                             proc_list.append((proc.name, memory_mb, cpu, proc_id))
-                        except:
+                        except Exception:
                             proc_list.append((proc.name, 0, 0, proc_id))
-                
+
                 proc_list.sort(key=lambda x: x[1], reverse=True)
                 for name, mem, cpu, pid in proc_list[:5]:
                     output.append(f"  - {name} ({pid}): {mem:.1f} MB, {cpu:.1f}% CPU")
         else:
             output.append("No background processes running")
-        
+
         output.append("")
-        
+
         # Database Usage
         if self.db_manager:
             output.append("=== Database Usage ===")
             db_dir = Path.home() / ".hanzo" / "db"
             total_db_size = 0
-            
+
             if db_dir.exists():
                 for db_file in db_dir.rglob("*.db"):
                     size = db_file.stat().st_size
                     total_db_size += size
-                
-                output.append(f"Total Database Size: {total_db_size / (1024**2):.1f} MB")
+
+                output.append(
+                    f"Total Database Size: {total_db_size / (1024**2):.1f} MB"
+                )
                 output.append(f"Active Projects: {len(self.db_manager.projects)}")
-                
+
                 # List largest databases
                 db_sizes = []
                 for db_file in db_dir.rglob("*.db"):
@@ -179,7 +186,7 @@ Example:
                         project = db_file.parent.parent.name
                         db_type = db_file.stem
                         db_sizes.append((project, db_type, size))
-                
+
                 if db_sizes:
                     db_sizes.sort(key=lambda x: x[2], reverse=True)
                     output.append("\nLargest Databases:")
@@ -187,43 +194,47 @@ Example:
                         output.append(f"  - {project}/{db_type}: {size:.1f} MB")
             else:
                 output.append("No databases found")
-        
+
         output.append("")
-        
+
         # MCP Servers
         output.append("=== MCP Servers ===")
         mcp_servers = McpAddTool.get_servers()
         if mcp_servers:
-            running_mcp = sum(1 for s in mcp_servers.values() if s.get("status") == "running")
+            running_mcp = sum(
+                1 for s in mcp_servers.values() if s.get("status") == "running"
+            )
             total_mcp_tools = sum(len(s.get("tools", [])) for s in mcp_servers.values())
-            
+
             output.append(f"Total Servers: {len(mcp_servers)}")
             output.append(f"Running: {running_mcp}")
             output.append(f"Total Tools Available: {total_mcp_tools}")
         else:
             output.append("No MCP servers configured")
-        
+
         output.append("")
-        
+
         # Hanzo AI Specifics
         output.append("=== Hanzo AI ===")
-        
+
         # Log directory size
         log_dir = Path.home() / ".hanzo" / "logs"
         if log_dir.exists():
             log_size = sum(f.stat().st_size for f in log_dir.rglob("*") if f.is_file())
             log_count = len(list(log_dir.rglob("*.log")))
             output.append(f"Log Files: {log_count} ({log_size / (1024**2):.1f} MB)")
-            
+
             if log_size > 100 * 1024**2:  # > 100MB
-                warnings.append(f"⚠️  Large log directory: {log_size / (1024**2):.1f} MB")
-        
+                warnings.append(
+                    f"⚠️  Large log directory: {log_size / (1024**2):.1f} MB"
+                )
+
         # Config directory
         config_dir = Path.home() / ".hanzo" / "mcp"
         if config_dir.exists():
             config_count = len(list(config_dir.rglob("*.json")))
             output.append(f"Config Files: {config_count}")
-        
+
         # Tool status (if available)
         # TODO: Track tool usage statistics
         output.append("\nTool Categories:")
@@ -232,14 +243,14 @@ Example:
         output.append("  - Database: sql_query, graph_query, vector_search")
         output.append("  - Package Runners: uvx, npx, uvx_background, npx_background")
         output.append("  - MCP Management: mcp_add, mcp_remove, mcp_stats")
-        
+
         # Warnings Section
         if warnings:
             output.append("\n=== ⚠️  WARNINGS ===")
             for warning in warnings:
                 output.append(warning)
             output.append("")
-        
+
         # Recommendations
         output.append("=== Recommendations ===")
         if disk_free_gb < 5:
@@ -250,10 +261,17 @@ Example:
             output.append("- Consider stopping unused background processes")
         if log_size > 50 * 1024**2:
             output.append("- Clean up old log files in ~/.hanzo/logs")
-        
-        if not any([disk_free_gb < 5, memory_percent > 80, running_count > 10, log_size > 50 * 1024**2]):
+
+        if not any(
+            [
+                disk_free_gb < 5,
+                memory_percent > 80,
+                running_count > 10,
+                log_size > 50 * 1024**2,
+            ]
+        ):
             output.append("✅ System resources are healthy")
-        
+
         return "\n".join(output)
 
     def register(self, mcp_server) -> None:

hanzo_mcp/tools/common/test_helpers.py

@@ -0,0 +1,31 @@
+"""Test helper classes for MCP tools testing."""
+
+from typing import Any, Dict, List, Optional
+
+
+class PaginatedResponseWrapper:
+    """Wrapper class for paginated responses to support tests."""
+
+    def __init__(self, items=None, next_cursor=None, has_more=False, total_items=None):
+        """Initialize paginated response."""
+        self.items = items or []
+        self.next_cursor = next_cursor
+        self.has_more = has_more
+        self.total_items = total_items or len(self.items)
+
+    def to_json(self) -> Dict[str, Any]:
+        """Convert to JSON-serializable dict."""
+        return {
+            "items": self.items,
+            "_meta": {
+                "next_cursor": self.next_cursor,
+                "has_more": self.has_more,
+                "total_items": self.total_items,
+            },
+        }
+
+
+# Export a convenience constructor
+def PaginatedResponse(items=None, next_cursor=None, has_more=False, total_items=None):
+    """Create a paginated response for testing."""
+    return PaginatedResponseWrapper(items, next_cursor, has_more, total_items)

hanzo_mcp/tools/common/thinking_tool.py

@@ -3,16 +3,15 @@
 This module provides the ThinkingTool for Claude to engage in structured thinking.
 """
 
-from typing import Annotated, TypedDict, Unpack, final, override
+from typing import Unpack, Annotated, TypedDict, 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.common.base import BaseTool
 from hanzo_mcp.tools.common.context import create_tool_context
 
-
 Thought = Annotated[
     str,
     Field(
@@ -144,8 +143,5 @@ Feature Implementation Planning
         tool_self = self  # Create a reference to self for use in the closure
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def think(
-            thought: Thought,
-            ctx: MCPContext
-        ) -> str:
+        async def think(thought: Thought, ctx: MCPContext) -> str:
             return await tool_self.call(ctx, thought=thought)

hanzo_mcp/tools/common/tool_disable.py

@@ -1,15 +1,14 @@
 """Disable tools dynamically."""
 
-from typing import Annotated, TypedDict, Unpack, final, override
+from typing import Unpack, Annotated, TypedDict, final, override
 
-from mcp.server.fastmcp import Context as MCPContext
 from pydantic import Field
+from mcp.server.fastmcp import Context as MCPContext
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.context import create_tool_context
 from hanzo_mcp.tools.common.tool_enable import ToolEnableTool
 
-
 ToolName = Annotated[
     str,
     Field(
@@ -104,13 +103,13 @@ Use 'tool_enable' to re-enable disabled tools.
 
         # Check current state
         was_enabled = ToolEnableTool.is_tool_enabled(tool_name)
-        
+
         if not was_enabled:
             return f"Tool '{tool_name}' is already disabled."
 
         # Disable the tool
         ToolEnableTool._tool_states[tool_name] = False
-        
+
         # Persist if requested
         if persist:
             ToolEnableTool._save_states()
@@ -124,19 +123,25 @@ Use 'tool_enable' to re-enable disabled tools.
             "The tool is now unavailable for use.",
             f"Use 'tool_enable --tool {tool_name}' to re-enable it.",
         ]
-        
+
         if not persist:
-            output.append("\nNote: This change is temporary and will be lost on restart.")
-        
+            output.append(
+                "\nNote: This change is temporary and will be lost on restart."
+            )
+
         # Warn about commonly used tools
         common_tools = {"grep", "read", "write", "bash", "edit"}
         if tool_name in common_tools:
-            output.append(f"\n⚠️  Warning: '{tool_name}' is a commonly used tool. Disabling it may affect normal operations.")
-        
+            output.append(
+                f"\n⚠️  Warning: '{tool_name}' is a commonly used tool. Disabling it may affect normal operations."
+            )
+
         # Count disabled tools
-        disabled_count = sum(1 for enabled in ToolEnableTool._tool_states.values() if not enabled)
+        disabled_count = sum(
+            1 for enabled in ToolEnableTool._tool_states.values() if not enabled
+        )
         output.append(f"\nTotal disabled tools: {disabled_count}")
-        
+
         return "\n".join(output)
 
     def register(self, mcp_server) -> None: