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

hanzo_mcp/tools/mcp/mcp_tool.py

@@ -1,19 +1,28 @@
 """Unified MCP tool for managing MCP servers."""
 
-from typing import Annotated, TypedDict, Unpack, final, override, Optional, Dict, Any, List
-from pathlib import Path
-import json
-import subprocess
 import os
+import json
 import signal
+import subprocess
+from typing import (
+    Any,
+    Dict,
+    List,
+    Unpack,
+    Optional,
+    Annotated,
+    TypedDict,
+    final,
+    override,
+)
+from pathlib import Path
 
-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
 
-
 # Parameter types
 Action = Annotated[
     str,
@@ -82,6 +91,7 @@ AutoStart = Annotated[
 
 class MCPParams(TypedDict, total=False):
     """Parameters for MCP tool."""
+
     action: str
     name: Optional[str]
     command: Optional[str]
@@ -95,29 +105,29 @@ class MCPParams(TypedDict, total=False):
 @final
 class MCPTool(BaseTool):
     """Tool for managing MCP servers."""
-    
+
     # Config file
     CONFIG_FILE = Path.home() / ".hanzo" / "mcp" / "servers.json"
-    
+
     # Running servers tracking
     _running_servers: Dict[str, subprocess.Popen] = {}
-    
+
     def __init__(self):
         """Initialize the MCP management tool."""
         self.config = self._load_config()
-        
+
         # Auto-start servers if configured
         self._auto_start_servers()
-    
+
     def _load_config(self) -> Dict[str, Any]:
         """Load MCP server configuration."""
         if self.CONFIG_FILE.exists():
             try:
-                with open(self.CONFIG_FILE, 'r') as f:
+                with open(self.CONFIG_FILE, "r") as f:
                     return json.load(f)
-            except:
+            except Exception:
                 pass
-        
+
         # Default configuration with some examples
         return {
             "servers": {
@@ -128,51 +138,56 @@ class MCPTool(BaseTool):
                     "env": {},
                     "enabled": False,
                     "auto_start": False,
-                    "description": "MCP filesystem server for /tmp access"
+                    "description": "MCP filesystem server for /tmp access",
                 },
                 "github": {
-                    "command": "npx", 
+                    "command": "npx",
                     "args": ["@modelcontextprotocol/server-github"],
                     "env": {"GITHUB_TOKEN": "${GITHUB_TOKEN}"},
                     "enabled": False,
                     "auto_start": False,
-                    "description": "GitHub API access via MCP"
+                    "description": "GitHub API access via MCP",
                 },
                 "postgres": {
                     "command": "npx",
-                    "args": ["@modelcontextprotocol/server-postgres", "postgresql://localhost/db"],
+                    "args": [
+                        "@modelcontextprotocol/server-postgres",
+                        "postgresql://localhost/db",
+                    ],
                     "env": {},
                     "enabled": False,
                     "auto_start": False,
-                    "description": "PostgreSQL database access"
-                }
+                    "description": "PostgreSQL database access",
+                },
             },
             "global_env": {},
-            "log_dir": str(Path.home() / ".hanzo" / "mcp" / "logs")
+            "log_dir": str(Path.home() / ".hanzo" / "mcp" / "logs"),
         }
-    
+
     def _save_config(self):
         """Save configuration."""
         self.CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.CONFIG_FILE, 'w') as f:
+        with open(self.CONFIG_FILE, "w") as f:
             json.dump(self.config, f, indent=2)
-    
+
     def _auto_start_servers(self):
         """Auto-start servers configured for auto-start."""
         for name, server_config in self.config.get("servers", {}).items():
-            if server_config.get("enabled", False) and server_config.get("auto_start", False):
+            if server_config.get("enabled", False) and server_config.get(
+                "auto_start", False
+            ):
                 self._start_server(name, server_config)
-    
+
     def _start_server(self, name: str, config: Dict[str, Any]) -> bool:
         """Start an MCP server."""
         if name in self._running_servers:
             return False  # Already running
-        
+
         try:
             # Prepare environment
             env = os.environ.copy()
             env.update(self.config.get("global_env", {}))
-            
+
             # Process server-specific env vars
             server_env = config.get("env", {})
             for key, value in server_env.items():
@@ -182,54 +197,56 @@ class MCPTool(BaseTool):
                     if var_name in os.environ:
                         value = os.environ[var_name]
                 env[key] = value
-            
+
             # Prepare command
             cmd = [config["command"]] + config.get("args", [])
-            
+
             # Create log directory
-            log_dir = Path(self.config.get("log_dir", str(Path.home() / ".hanzo" / "mcp" / "logs")))
+            log_dir = Path(
+                self.config.get("log_dir", str(Path.home() / ".hanzo" / "mcp" / "logs"))
+            )
             log_dir.mkdir(parents=True, exist_ok=True)
-            
+
             # Start process
             log_file = log_dir / f"{name}.log"
-            with open(log_file, 'a') as log:
+            with open(log_file, "a") as log:
                 process = subprocess.Popen(
                     cmd,
                     env=env,
                     stdout=log,
                     stderr=subprocess.STDOUT,
-                    preexec_fn=os.setsid if os.name != 'nt' else None
+                    preexec_fn=os.setsid if os.name != "nt" else None,
                 )
-            
+
             self._running_servers[name] = process
             return True
-            
-        except Exception as e:
+
+        except Exception:
             return False
-    
+
     def _stop_server(self, name: str) -> bool:
         """Stop an MCP server."""
         if name not in self._running_servers:
             return False
-        
+
         process = self._running_servers[name]
         try:
-            if os.name == 'nt':
+            if os.name == "nt":
                 process.terminate()
             else:
                 os.killpg(os.getpgid(process.pid), signal.SIGTERM)
-            
+
             process.wait(timeout=5)
-        except:
+        except Exception:
             # Force kill if needed
             try:
-                if os.name == 'nt':
+                if os.name == "nt":
                     process.kill()
                 else:
                     os.killpg(os.getpgid(process.pid), signal.SIGKILL)
-            except:
+            except Exception:
                 pass
-        
+
         del self._running_servers[name]
         return True
 
@@ -246,7 +263,7 @@ class MCPTool(BaseTool):
         servers = self.config.get("servers", {})
         enabled = sum(1 for s in servers.values() if s.get("enabled", False))
         running = len(self._running_servers)
-        
+
         return f"""Manage MCP servers. Actions: list (default), add, remove, enable, disable, restart, config.
 
 Usage:
@@ -266,16 +283,16 @@ Status: {enabled} enabled, {running} running"""
         # Create tool context only if we have a proper MCP context
         tool_ctx = None
         try:
-            if hasattr(ctx, 'client') and ctx.client and hasattr(ctx.client, 'server'):
+            if hasattr(ctx, "client") and ctx.client and hasattr(ctx.client, "server"):
                 tool_ctx = create_tool_context(ctx)
                 if tool_ctx:
                     await tool_ctx.set_tool_info(self.name)
-        except:
+        except Exception:
             pass
-        
+
         # Extract action
         action = params.get("action", "list")
-        
+
         # Route to appropriate handler
         if action == "list":
             return self._handle_list()
@@ -290,30 +307,34 @@ Status: {enabled} enabled, {running} running"""
         elif action == "restart":
             return self._handle_restart(params.get("name"))
         elif action == "config":
-            return self._handle_config(params.get("config_key"), params.get("config_value"))
+            return self._handle_config(
+                params.get("config_key"), params.get("config_value")
+            )
         else:
             return f"Error: Unknown action '{action}'. Valid actions: list, add, remove, enable, disable, restart, config"
 
     def _handle_list(self) -> str:
         """List all MCP servers."""
         servers = self.config.get("servers", {})
-        
+
         if not servers:
             return "No MCP servers configured. Use 'mcp --action add' to add one."
-        
+
         output = ["=== MCP Servers ==="]
-        output.append(f"Total: {len(servers)} | Enabled: {sum(1 for s in servers.values() if s.get('enabled', False))} | Running: {len(self._running_servers)}")
+        output.append(
+            f"Total: {len(servers)} | Enabled: {sum(1 for s in servers.values() if s.get('enabled', False))} | Running: {len(self._running_servers)}"
+        )
         output.append("")
-        
+
         for name, config in sorted(servers.items()):
             status_parts = []
-            
+
             # Check if enabled
             if config.get("enabled", False):
                 status_parts.append("✅ Enabled")
             else:
                 status_parts.append("❌ Disabled")
-            
+
             # Check if running
             if name in self._running_servers:
                 process = self._running_servers[name]
@@ -324,41 +345,43 @@ Status: {enabled} enabled, {running} running"""
                     del self._running_servers[name]
             else:
                 status_parts.append("⚫ Not running")
-            
+
             # Auto-start status
             if config.get("auto_start", False):
                 status_parts.append("🚀 Auto-start")
-            
+
             status = " | ".join(status_parts)
-            
+
             output.append(f"{name}: {status}")
             if config.get("description"):
                 output.append(f"  Description: {config['description']}")
-            output.append(f"  Command: {config['command']} {' '.join(config.get('args', []))}")
-            
+            output.append(
+                f"  Command: {config['command']} {' '.join(config.get('args', []))}"
+            )
+
             if config.get("env"):
-                env_str = ", ".join([f"{k}={v}" for k, v in config['env'].items()])
+                env_str = ", ".join([f"{k}={v}" for k, v in config["env"].items()])
                 output.append(f"  Environment: {env_str}")
-        
+
         output.append("\nUse 'mcp --action enable --name <server>' to enable a server")
         output.append("Use 'mcp --action add' to add a new server")
-        
+
         return "\n".join(output)
 
     def _handle_add(self, params: Dict[str, Any]) -> str:
         """Add a new MCP server."""
         name = params.get("name")
         command = params.get("command")
-        
+
         if not name:
             return "Error: name is required for add action"
         if not command:
             return "Error: command is required for add action"
-        
+
         servers = self.config.get("servers", {})
         if name in servers:
             return f"Error: Server '{name}' already exists. Use a different name or remove it first."
-        
+
         # Create server config
         server_config = {
             "command": command,
@@ -366,91 +389,91 @@ Status: {enabled} enabled, {running} running"""
             "env": params.get("env", {}),
             "enabled": False,
             "auto_start": params.get("auto_start", True),
-            "description": params.get("description", "")
+            "description": params.get("description", ""),
         }
-        
+
         servers[name] = server_config
         self.config["servers"] = servers
         self._save_config()
-        
+
         return f"Successfully added MCP server '{name}'. Use 'mcp --action enable --name {name}' to enable it."
 
     def _handle_remove(self, name: Optional[str]) -> str:
         """Remove an MCP server."""
         if not name:
             return "Error: name is required for remove action"
-        
+
         servers = self.config.get("servers", {})
         if name not in servers:
             return f"Error: Server '{name}' not found"
-        
+
         # Stop if running
         if name in self._running_servers:
             self._stop_server(name)
-        
+
         del servers[name]
         self.config["servers"] = servers
         self._save_config()
-        
+
         return f"Successfully removed MCP server '{name}'"
 
     def _handle_enable(self, name: Optional[str]) -> str:
         """Enable an MCP server."""
         if not name:
             return "Error: name is required for enable action"
-        
+
         servers = self.config.get("servers", {})
         if name not in servers:
             return f"Error: Server '{name}' not found"
-        
+
         servers[name]["enabled"] = True
         self.config["servers"] = servers
         self._save_config()
-        
+
         # Start if auto-start is enabled
         if servers[name].get("auto_start", False):
             if self._start_server(name, servers[name]):
                 return f"Successfully enabled and started MCP server '{name}'"
             else:
                 return f"Enabled MCP server '{name}' but failed to start it. Check the configuration."
-        
+
         return f"Successfully enabled MCP server '{name}'"
 
     def _handle_disable(self, name: Optional[str]) -> str:
         """Disable an MCP server."""
         if not name:
             return "Error: name is required for disable action"
-        
+
         servers = self.config.get("servers", {})
         if name not in servers:
             return f"Error: Server '{name}' not found"
-        
+
         # Stop if running
         if name in self._running_servers:
             self._stop_server(name)
-        
+
         servers[name]["enabled"] = False
         self.config["servers"] = servers
         self._save_config()
-        
+
         return f"Successfully disabled MCP server '{name}'"
 
     def _handle_restart(self, name: Optional[str]) -> str:
         """Restart an MCP server."""
         if not name:
             return "Error: name is required for restart action"
-        
+
         servers = self.config.get("servers", {})
         if name not in servers:
             return f"Error: Server '{name}' not found"
-        
+
         if not servers[name].get("enabled", False):
             return f"Error: Server '{name}' is not enabled"
-        
+
         # Stop if running
         if name in self._running_servers:
             self._stop_server(name)
-        
+
         # Start again
         if self._start_server(name, servers[name]):
             return f"Successfully restarted MCP server '{name}'"
@@ -462,10 +485,10 @@ Status: {enabled} enabled, {running} running"""
         if not key:
             # Show all config
             return json.dumps(self.config, indent=2)
-        
+
         # Parse nested keys (e.g., "servers.github.auto_start")
-        keys = key.split('.')
-        
+        keys = key.split(".")
+
         if value is None:
             # Get value
             current = self.config
@@ -474,8 +497,12 @@ Status: {enabled} enabled, {running} running"""
                     current = current[k]
                 else:
                     return f"Configuration key '{key}' not found"
-            
-            return json.dumps(current, indent=2) if isinstance(current, (dict, list)) else str(current)
+
+            return (
+                json.dumps(current, indent=2)
+                if isinstance(current, (dict, list))
+                else str(current)
+            )
         else:
             # Set value
             # Navigate to parent
@@ -484,20 +511,24 @@ Status: {enabled} enabled, {running} running"""
                 if k not in current:
                     current[k] = {}
                 current = current[k]
-            
+
             # Parse value if it looks like JSON
-            if isinstance(value, str) and value.startswith('{') or value.startswith('['):
+            if (
+                isinstance(value, str)
+                and value.startswith("{")
+                or value.startswith("[")
+            ):
                 try:
                     value = json.loads(value)
-                except:
+                except Exception:
                     pass
-            
+
             # Set the value
             current[keys[-1]] = value
             self._save_config()
-            
+
             return f"Successfully set {key} = {json.dumps(value) if isinstance(value, (dict, list)) else value}"
 
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""
-        pass
+        pass

hanzo_mcp/tools/memory/__init__.py

@@ -2,21 +2,21 @@
 
 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.memory.memory_tools import (
-    RecallMemoriesTool,
     CreateMemoriesTool,
-    UpdateMemoriesTool,
     DeleteMemoriesTool,
     ManageMemoriesTool,
+    RecallMemoriesTool,
+    UpdateMemoriesTool,
 )
 from hanzo_mcp.tools.memory.knowledge_tools import (
-    RecallFactsTool,
     StoreFactsTool,
+    RecallFactsTool,
     SummarizeToMemoryTool,
     ManageKnowledgeBasesTool,
 )
-from hanzo_mcp.tools.common.base import BaseTool, ToolRegistry
-from hanzo_mcp.tools.common.permissions import PermissionManager
 
 
 def register_memory_tools(
@@ -24,33 +24,51 @@ def register_memory_tools(
     permission_manager: PermissionManager,
     user_id: str = "default",
     project_id: str = "default",
-    **memory_config
+    **memory_config,
 ) -> list[BaseTool]:
     """Register memory tools with the MCP server.
-    
+
     Args:
         mcp_server: The FastMCP server instance
         permission_manager: Permission manager for access control
         user_id: User ID for memory operations
         project_id: Project ID for memory operations
         **memory_config: Additional memory store configuration
-        
+
     Returns:
         List of registered tools
     """
     # Create memory tools
-    recall_tool = RecallMemoriesTool(user_id=user_id, project_id=project_id, **memory_config)
-    create_tool = CreateMemoriesTool(user_id=user_id, project_id=project_id, **memory_config)
-    update_tool = UpdateMemoriesTool(user_id=user_id, project_id=project_id, **memory_config)
-    delete_tool = DeleteMemoriesTool(user_id=user_id, project_id=project_id, **memory_config)
-    manage_tool = ManageMemoriesTool(user_id=user_id, project_id=project_id, **memory_config)
-    
+    recall_tool = RecallMemoriesTool(
+        user_id=user_id, project_id=project_id, **memory_config
+    )
+    create_tool = CreateMemoriesTool(
+        user_id=user_id, project_id=project_id, **memory_config
+    )
+    update_tool = UpdateMemoriesTool(
+        user_id=user_id, project_id=project_id, **memory_config
+    )
+    delete_tool = DeleteMemoriesTool(
+        user_id=user_id, project_id=project_id, **memory_config
+    )
+    manage_tool = ManageMemoriesTool(
+        user_id=user_id, project_id=project_id, **memory_config
+    )
+
     # Create knowledge tools
-    recall_facts_tool = RecallFactsTool(user_id=user_id, project_id=project_id, **memory_config)
-    store_facts_tool = StoreFactsTool(user_id=user_id, project_id=project_id, **memory_config)
-    summarize_tool = SummarizeToMemoryTool(user_id=user_id, project_id=project_id, **memory_config)
-    manage_kb_tool = ManageKnowledgeBasesTool(user_id=user_id, project_id=project_id, **memory_config)
-    
+    recall_facts_tool = RecallFactsTool(
+        user_id=user_id, project_id=project_id, **memory_config
+    )
+    store_facts_tool = StoreFactsTool(
+        user_id=user_id, project_id=project_id, **memory_config
+    )
+    summarize_tool = SummarizeToMemoryTool(
+        user_id=user_id, project_id=project_id, **memory_config
+    )
+    manage_kb_tool = ManageKnowledgeBasesTool(
+        user_id=user_id, project_id=project_id, **memory_config
+    )
+
     # Register tools
     ToolRegistry.register_tool(mcp_server, recall_tool)
     ToolRegistry.register_tool(mcp_server, create_tool)
@@ -61,7 +79,7 @@ def register_memory_tools(
     ToolRegistry.register_tool(mcp_server, store_facts_tool)
     ToolRegistry.register_tool(mcp_server, summarize_tool)
     ToolRegistry.register_tool(mcp_server, manage_kb_tool)
-    
+
     # Return list of registered tools
     return [
         recall_tool,
@@ -73,4 +91,4 @@ def register_memory_tools(
         store_facts_tool,
         summarize_tool,
         manage_kb_tool,
-    ]
+    ]