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

hanzo_mcp/tools/llm/provider_tools.py

@@ -71,9 +71,7 @@ class ProviderToolParams(TypedDict, total=False):
 class BaseProviderTool(BaseTool):
     """Base class for provider-specific LLM tools."""
 
-    def __init__(
-        self, provider: str, default_model: str, model_variants: Dict[str, str]
-    ):
+    def __init__(self, provider: str, default_model: str, model_variants: Dict[str, str]):
         """Initialize provider tool.
 
         Args:

hanzo_mcp/tools/lsp/lsp_tool.py

@@ -297,9 +297,7 @@ class LSPTool(BaseTool):
             self.logger.error(f"Installation error: {e}")
             return False
 
-    async def _ensure_lsp_running(
-        self, language: str, root_uri: str
-    ) -> Optional[LSPServer]:
+    async def _ensure_lsp_running(self, language: str, root_uri: str) -> Optional[LSPServer]:
         """Ensure LSP server is running for language."""
         # Check if already running
         server_key = f"{language}:{root_uri}"
@@ -326,9 +324,7 @@ class LSPTool(BaseTool):
                 cwd=root_uri,
             )
 
-            server = LSPServer(
-                language=language, process=process, config=config, root_uri=root_uri
-            )
+            server = LSPServer(language=language, process=process, config=config, root_uri=root_uri)
 
             # Initialize LSP
             await self._initialize_lsp(server)
@@ -367,9 +363,7 @@ class LSPTool(BaseTool):
         await self._send_request(server, request)
         server.initialized = True
 
-    async def _send_request(
-        self, server: LSPServer, request: Dict[str, Any]
-    ) -> Optional[Dict[str, Any]]:
+    async def _send_request(self, server: LSPServer, request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         """Send JSON-RPC request to LSP server."""
         if not server.process or server.process.returncode is not None:
             return None
@@ -426,11 +420,7 @@ class LSPTool(BaseTool):
             "status",
         ]
         if action not in valid_actions:
-            return MCPResourceDocument(
-                data={
-                    "error": f"Invalid action. Must be one of: {', '.join(valid_actions)}"
-                }
-            )
+            return MCPResourceDocument(data={"error": f"Invalid action. Must be one of: {', '.join(valid_actions)}"})
 
         # Get language from file
         language = self._get_language_from_file(file)
@@ -478,9 +468,7 @@ class LSPTool(BaseTool):
             )
 
         # Execute action
-        result = await self._execute_lsp_action(
-            server, action, file, line, character, new_name
-        )
+        result = await self._execute_lsp_action(server, action, file, line, character, new_name)
 
         return MCPResourceDocument(data=result)
 

hanzo_mcp/tools/mcp/mcp_add.py

@@ -189,9 +189,7 @@ Use 'mcp_stats' to see all added servers and their status.
 
                 full_command = shlex.split(command)
 
-        await tool_ctx.info(
-            f"Adding MCP server '{name}' with command: {' '.join(full_command)}"
-        )
+        await tool_ctx.info(f"Adding MCP server '{name}' with command: {' '.join(full_command)}")
 
         # Create server configuration
         server_config = {

hanzo_mcp/tools/mcp/mcp_stats.py

@@ -68,9 +68,7 @@ Example:
         servers = McpAddTool.get_servers()
 
         if not servers:
-            return (
-                "No MCP servers have been added yet.\n\nUse 'mcp_add' to add servers."
-            )
+            return "No MCP servers have been added yet.\n\nUse 'mcp_add' to add servers."
 
         output = []
         output.append("=== MCP Server Statistics ===")

hanzo_mcp/tools/mcp/mcp_tool.py

@@ -173,9 +173,7 @@ class MCPTool(BaseTool):
     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:
@@ -202,9 +200,7 @@ class MCPTool(BaseTool):
             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
@@ -307,11 +303,11 @@ 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"
+            return (
+                f"Error: Unknown action '{action}'. Valid actions: list, add, remove, enable, disable, restart, config"
+            )
 
     def _handle_list(self) -> str:
         """List all MCP servers."""
@@ -355,9 +351,7 @@ Status: {enabled} enabled, {running} running"""
             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()])
@@ -498,11 +492,7 @@ Status: {enabled} enabled, {running} running"""
                 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
@@ -513,11 +503,7 @@ Status: {enabled} enabled, {running} running"""
                 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 Exception:

hanzo_mcp/tools/memory/__init__.py

@@ -20,6 +20,7 @@ try:
         SummarizeToMemoryTool,
         ManageKnowledgeBasesTool,
     )
+
     MEMORY_TOOLS_AVAILABLE = True
 except ImportError:
     MEMORY_TOOLS_AVAILABLE = False
@@ -49,35 +50,17 @@ def register_memory_tools(
         return []
 
     # 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)

hanzo_mcp/tools/memory/knowledge_tools.py

@@ -140,15 +140,9 @@ recall_facts(queries=["company policies"], scope="global", limit=5)
             if fact.metadata and fact.metadata.get("kb_name"):
                 kb_info = f" (KB: {fact.metadata['kb_name']})"
             formatted.append(f"{i}. {fact.content}{kb_info}")
-            if (
-                fact.metadata and len(fact.metadata) > 2
-            ):  # More than just type and kb_name
+            if fact.metadata and len(fact.metadata) > 2:  # More than just type and kb_name
                 # Show other metadata
-                other_meta = {
-                    k: v
-                    for k, v in fact.metadata.items()
-                    if k not in ["type", "kb_name"]
-                }
+                other_meta = {k: v for k, v in fact.metadata.items() if k not in ["type", "kb_name"]}
                 if other_meta:
                     formatted.append(f"   Metadata: {other_meta}")
 
@@ -167,9 +161,7 @@ recall_facts(queries=["company policies"], scope="global", limit=5)
             scope: str = "project",
             limit: int = 10,
         ) -> str:
-            return await tool_self.call(
-                ctx, queries=queries, kb_name=kb_name, scope=scope, limit=limit
-            )
+            return await tool_self.call(ctx, queries=queries, kb_name=kb_name, scope=scope, limit=limit)
 
 
 @final
@@ -265,9 +257,7 @@ store_facts(facts=["Company founded in 2020"], scope="global", kb_name="company_
             scope: str = "project",
             metadata: Optional[Dict[str, Any]] = None,
         ) -> str:
-            return await tool_self.call(
-                ctx, facts=facts, kb_name=kb_name, scope=scope, metadata=metadata
-            )
+            return await tool_self.call(ctx, facts=facts, kb_name=kb_name, scope=scope, metadata=metadata)
 
 
 @final
@@ -323,11 +313,7 @@ summarize_to_memory(content="Company guidelines...", topic="Guidelines", scope="
 
         # Use the memory service to create a summary
         # This would typically use an LLM to summarize, but for now we'll store as-is
-        summary = (
-            f"Summary of {topic}:\n{content[:500]}..."
-            if len(content) > 500
-            else content
-        )
+        summary = f"Summary of {topic}:\n{content[:500]}..." if len(content) > 500 else content
 
         # Store the summary as a memory
         from hanzo_memory.services.memory import get_memory_service
@@ -358,9 +344,7 @@ summarize_to_memory(content="Company guidelines...", topic="Guidelines", scope="
         if auto_facts:
             # In a real implementation, this would use LLM to extract key facts
             # For now, we'll just note it
-            result += (
-                "\n(Auto-fact extraction would extract key facts from the summary)"
-            )
+            result += "\n(Auto-fact extraction would extract key facts from the summary)"
 
         return result
 
@@ -377,9 +361,7 @@ summarize_to_memory(content="Company guidelines...", topic="Guidelines", scope="
             scope: str = "project",
             auto_facts: bool = True,
         ) -> str:
-            return await tool_self.call(
-                ctx, content=content, topic=topic, scope=scope, auto_facts=auto_facts
-            )
+            return await tool_self.call(ctx, content=content, topic=topic, scope=scope, auto_facts=auto_facts)
 
 
 @final

hanzo_mcp/tools/memory/memory_tools.py

@@ -127,9 +127,7 @@ recall_memories(queries=["coding standards"], scope="global")
         tool_self = self
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def recall_memories(
-            ctx: MCPContext, queries: List[str], limit: int = 10, scope: str = "project"
-        ) -> str:
+        async def recall_memories(ctx: MCPContext, queries: List[str], limit: int = 10, scope: str = "project") -> str:
             return await tool_self.call(ctx, queries=queries, limit=limit, scope=scope)
 
 
@@ -247,9 +245,7 @@ update_memories(updates=[
                 # The hanzo-memory service doesn't have update implemented yet
                 # When it's implemented, we would call:
                 # success = self.service.update_memory(self.user_id, memory_id, content=statement)
-                await tool_ctx.warning(
-                    f"Memory update not fully implemented in hanzo-memory yet: {memory_id}"
-                )
+                await tool_ctx.warning(f"Memory update not fully implemented in hanzo-memory yet: {memory_id}")
                 success_count += 1
 
         return f"Would update {success_count} of {len(updates)} memories (update not fully implemented in hanzo-memory yet)."
@@ -260,9 +256,7 @@ update_memories(updates=[
         tool_self = self
 
         @mcp_server.tool(name=self.name, description=self.description)
-        async def update_memories(
-            ctx: MCPContext, updates: List[Dict[str, str]]
-        ) -> str:
+        async def update_memories(ctx: MCPContext, updates: List[Dict[str, str]]) -> str:
             return await tool_self.call(ctx, updates=updates)
 
 
@@ -398,13 +392,9 @@ manage_memories(
 
                 if memory_id and statement:
                     # Update not fully implemented in hanzo-memory yet
-                    await tool_ctx.warning(
-                        f"Memory update not fully implemented: {memory_id}"
-                    )
+                    await tool_ctx.warning(f"Memory update not fully implemented: {memory_id}")
                     success_count += 1
-            results.append(
-                f"Would update {success_count} memories (update pending implementation)"
-            )
+            results.append(f"Would update {success_count} memories (update pending implementation)")
 
         # Delete memories
         if deletions:
@@ -433,6 +423,4 @@ manage_memories(
             updates: Optional[List[Dict[str, str]]] = None,
             deletions: Optional[List[str]] = None,
         ) -> str:
-            return await tool_self.call(
-                ctx, creations=creations, updates=updates, deletions=deletions
-            )
+            return await tool_self.call(ctx, creations=creations, updates=updates, deletions=deletions)

hanzo_mcp/tools/search/find_tool.py

@@ -257,9 +257,7 @@ class FindTool(BaseTool):
         # Resolve path
         root_path = Path(path).resolve()
         if not root_path.exists():
-            return MCPResourceDocument(
-                data={"error": f"Path does not exist: {path}", "results": []}
-            )
+            return MCPResourceDocument(data={"error": f"Path does not exist: {path}", "results": []})
 
         # Get ignore patterns
         ignore_patterns = set()
@@ -270,9 +268,7 @@ class FindTool(BaseTool):
         min_size_bytes = self._parse_size(min_size) if min_size else None
         max_size_bytes = self._parse_size(max_size) if max_size else None
         modified_after_ts = self._parse_time(modified_after) if modified_after else None
-        modified_before_ts = (
-            self._parse_time(modified_before) if modified_before else None
-        )
+        modified_before_ts = self._parse_time(modified_before) if modified_before else None
 
         # Collect matches
         matches = []
@@ -350,20 +346,14 @@ class FindTool(BaseTool):
         stats = {
             "total_found": total_results,
             "search_time_ms": int((time.time() - start_time) * 1000),
-            "search_method": (
-                "ffind" if FFIND_AVAILABLE and not in_content else "python"
-            ),
+            "search_method": ("ffind" if FFIND_AVAILABLE and not in_content else "python"),
             "root_path": str(root_path),
             "filters_applied": {
                 "pattern": pattern,
                 "type": type,
-                "size": (
-                    {"min": min_size, "max": max_size} if min_size or max_size else None
-                ),
+                "size": ({"min": min_size, "max": max_size} if min_size or max_size else None),
                 "modified": (
-                    {"after": modified_after, "before": modified_before}
-                    if modified_after or modified_before
-                    else None
+                    {"after": modified_after, "before": modified_before} if modified_after or modified_before else None
                 ),
                 "max_depth": max_depth,
                 "gitignore": respect_gitignore,
@@ -594,9 +584,7 @@ class FindTool(BaseTool):
         elif fuzzy:
             pattern_lower = pattern.lower() if not case_sensitive else pattern
             matcher = (
-                lambda name: SequenceMatcher(
-                    None, pattern_lower, name.lower() if not case_sensitive else name
-                ).ratio()
+                lambda name: SequenceMatcher(None, pattern_lower, name.lower() if not case_sensitive else name).ratio()
                 > 0.6
             )
         else:
@@ -608,9 +596,7 @@ class FindTool(BaseTool):
                 matcher = lambda name: fnmatch.fnmatch(name, pattern)
 
         # Walk directory tree
-        for dirpath, dirnames, filenames in os.walk(
-            str(root), followlinks=follow_symlinks
-        ):
+        for dirpath, dirnames, filenames in os.walk(str(root), followlinks=follow_symlinks):
             # Check depth
             if max_depth is not None:
                 depth = len(Path(dirpath).relative_to(root).parts)
@@ -621,11 +607,7 @@ class FindTool(BaseTool):
             # Filter directories to skip
             if respect_gitignore:
                 dirnames[:] = [
-                    d
-                    for d in dirnames
-                    if not self._should_ignore(
-                        os.path.join(dirpath, d), ignore_patterns
-                    )
+                    d for d in dirnames if not self._should_ignore(os.path.join(dirpath, d), ignore_patterns)
                 ]
 
             # Check directories
@@ -662,9 +644,7 @@ class FindTool(BaseTool):
                         match_found = True
                     elif in_content:
                         # Search in file content
-                        match_found = await self._search_in_file(
-                            full_path, pattern, case_sensitive
-                        )
+                        match_found = await self._search_in_file(full_path, pattern, case_sensitive)
                     else:
                         match_found = False
 
@@ -686,9 +666,7 @@ class FindTool(BaseTool):
 
         return matches
 
-    async def _search_in_file(
-        self, file_path: str, pattern: str, case_sensitive: bool
-    ) -> bool:
+    async def _search_in_file(self, file_path: str, pattern: str, case_sensitive: bool) -> bool:
         """Search for pattern in file content."""
         try:
             with open(file_path, "r", encoding="utf-8", errors="ignore") as f: