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

hanzo_mcp/tools/memory/memory_tools.py

@@ -4,7 +4,8 @@ This module provides MCP tools that use the hanzo-memory package as a library.
 The hanzo-memory package provides embedded database and vector search capabilities.
 """
 
-from typing import Any, Dict, List, Optional, override, final
+from typing import Dict, List, Optional, final, override
+
 from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 
@@ -13,23 +14,23 @@ from hanzo_mcp.tools.common.context import create_tool_context
 
 # Import from hanzo-memory package
 try:
-    from hanzo_memory.services.memory import MemoryService, get_memory_service
     from hanzo_memory.models.memory import Memory, MemoryWithScore
+    from hanzo_memory.services.memory import MemoryService, get_memory_service
+
     MEMORY_AVAILABLE = True
 except ImportError:
     MEMORY_AVAILABLE = False
     raise ImportError(
-        "hanzo-memory package is required for memory tools. "
-        "Install it from ~/work/hanzo/ide/pkg/memory"
+        "hanzo-memory package is required for memory tools. Install it from ~/work/hanzo/ide/pkg/memory"
     )
 
 
 class MemoryToolBase(BaseTool):
     """Base class for memory tools using hanzo-memory package."""
-    
+
     def __init__(self, user_id: str = "default", project_id: str = "default", **kwargs):
         """Initialize memory tool.
-        
+
         Args:
             user_id: User ID for memory operations
             project_id: Project ID for memory operations
@@ -44,13 +45,13 @@ class MemoryToolBase(BaseTool):
 @final
 class RecallMemoriesTool(MemoryToolBase):
     """Tool for recalling memories."""
-    
+
     @property
     @override
     def name(self) -> str:
         """Get the tool name."""
         return "recall_memories"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -66,30 +67,30 @@ recall_memories(queries=["user preferences", "previous conversations"])
 recall_memories(queries=["project requirements"], scope="project")
 recall_memories(queries=["coding standards"], scope="global")
 """
-    
+
     @override
     async def call(
         self,
         ctx: MCPContext,
         queries: List[str],
         limit: int = 10,
-        scope: str = "project"
+        scope: str = "project",
     ) -> str:
         """Recall memories matching queries.
-        
+
         Args:
             ctx: MCP context
             queries: Search queries
             limit: Max results per query
-            
+
         Returns:
             Formatted memory results
         """
         tool_ctx = create_tool_context(ctx)
         await tool_ctx.set_tool_info(self.name)
-        
+
         await tool_ctx.info(f"Searching for {len(queries)} queries")
-        
+
         all_results = []
         for query in queries:
             # Use hanzo-memory's search_memories method
@@ -97,10 +98,10 @@ recall_memories(queries=["coding standards"], scope="global")
                 user_id=self.user_id,
                 query=query,
                 project_id=self.project_id,
-                limit=limit
+                limit=limit,
             )
             all_results.extend(results)
-        
+
         # Deduplicate by memory_id
         seen = set()
         unique_results = []
@@ -108,29 +109,26 @@ recall_memories(queries=["coding standards"], scope="global")
             if result.memory_id not in seen:
                 seen.add(result.memory_id)
                 unique_results.append(result)
-        
+
         if not unique_results:
             return "No relevant memories found."
-        
+
         # Format results
         formatted = [f"Found {len(unique_results)} relevant memories:\n"]
         for i, memory in enumerate(unique_results, 1):
-            score = getattr(memory, 'similarity_score', 0.0)
+            score = getattr(memory, "similarity_score", 0.0)
             formatted.append(f"{i}. {memory.content} (relevance: {score:.2f})")
-        
+
         return "\n".join(formatted)
-    
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server."""
         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"
+            ctx: MCPContext, queries: List[str], limit: int = 10, scope: str = "project"
         ) -> str:
             return await tool_self.call(ctx, queries=queries, limit=limit, scope=scope)
 
@@ -138,13 +136,13 @@ recall_memories(queries=["coding standards"], scope="global")
 @final
 class CreateMemoriesTool(MemoryToolBase):
     """Tool for creating memories."""
-    
+
     @property
     @override
     def name(self) -> str:
         """Get the tool name."""
         return "create_memories"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -157,27 +155,23 @@ Each statement is stored as a separate memory.
 Usage:
 create_memories(statements=["User prefers dark mode", "User works in Python"])
 """
-    
+
     @override
-    async def call(
-        self,
-        ctx: MCPContext,
-        statements: List[str]
-    ) -> str:
+    async def call(self, ctx: MCPContext, statements: List[str]) -> str:
         """Create new memories.
-        
+
         Args:
             ctx: MCP context
             statements: Statements to memorize
-            
+
         Returns:
             Success message
         """
         tool_ctx = create_tool_context(ctx)
         await tool_ctx.set_tool_info(self.name)
-        
+
         await tool_ctx.info(f"Creating {len(statements)} memories")
-        
+
         created_memories = []
         for statement in statements:
             # Use hanzo-memory's create_memory method
@@ -185,35 +179,32 @@ create_memories(statements=["User prefers dark mode", "User works in Python"])
                 user_id=self.user_id,
                 project_id=self.project_id,
                 content=statement,
-                metadata={"type": "statement"}
+                metadata={"type": "statement"},
             )
             created_memories.append(memory)
-        
+
         return f"Successfully created {len(created_memories)} new memories."
-    
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server."""
         tool_self = self
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
-        async def create_memories(
-            ctx: MCPContext,
-            statements: List[str]
-        ) -> str:
+        async def create_memories(ctx: MCPContext, statements: List[str]) -> str:
             return await tool_self.call(ctx, statements=statements)
 
 
 @final
 class UpdateMemoriesTool(MemoryToolBase):
     """Tool for updating memories."""
-    
+
     @property
     @override
     def name(self) -> str:
         """Get the tool name."""
         return "update_memories"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -228,52 +219,49 @@ update_memories(updates=[
     {"id": "mem_2", "statement": "User primarily works in TypeScript"}
 ])
 """
-    
+
     @override
-    async def call(
-        self,
-        ctx: MCPContext,
-        updates: List[Dict[str, str]]
-    ) -> str:
+    async def call(self, ctx: MCPContext, updates: List[Dict[str, str]]) -> str:
         """Update memories.
-        
+
         Args:
             ctx: MCP context
             updates: List of {id, statement} dicts
-            
+
         Returns:
             Success message
         """
         tool_ctx = create_tool_context(ctx)
         await tool_ctx.set_tool_info(self.name)
-        
+
         await tool_ctx.info(f"Updating {len(updates)} memories")
-        
+
         # Note: hanzo-memory's update methods are not fully implemented yet
         # For now, we'll track what would be updated
         success_count = 0
         for update in updates:
             memory_id = update.get("id")
             statement = update.get("statement")
-            
+
             if memory_id and statement:
                 # 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)."
-    
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server."""
         tool_self = self
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
         async def update_memories(
-            ctx: MCPContext,
-            updates: List[Dict[str, str]]
+            ctx: MCPContext, updates: List[Dict[str, str]]
         ) -> str:
             return await tool_self.call(ctx, updates=updates)
 
@@ -281,13 +269,13 @@ update_memories(updates=[
 @final
 class DeleteMemoriesTool(MemoryToolBase):
     """Tool for deleting memories."""
-    
+
     @property
     @override
     def name(self) -> str:
         """Get the tool name."""
         return "delete_memories"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -299,59 +287,52 @@ This tool removes memories by their IDs.
 Usage:
 delete_memories(ids=["mem_1", "mem_2"])
 """
-    
+
     @override
-    async def call(
-        self,
-        ctx: MCPContext,
-        ids: List[str]
-    ) -> str:
+    async def call(self, ctx: MCPContext, ids: List[str]) -> str:
         """Delete memories.
-        
+
         Args:
             ctx: MCP context
             ids: Memory IDs to delete
-            
+
         Returns:
             Success message
         """
         tool_ctx = create_tool_context(ctx)
         await tool_ctx.set_tool_info(self.name)
-        
+
         await tool_ctx.info(f"Deleting {len(ids)} memories")
-        
+
         success_count = 0
         for memory_id in ids:
             # Use hanzo-memory's delete_memory method
             success = self.service.delete_memory(self.user_id, memory_id)
             if success:
                 success_count += 1
-        
+
         return f"Successfully deleted {success_count} of {len(ids)} memories."
-    
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server."""
         tool_self = self
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
-        async def delete_memories(
-            ctx: MCPContext,
-            ids: List[str]
-        ) -> str:
+        async def delete_memories(ctx: MCPContext, ids: List[str]) -> str:
             return await tool_self.call(ctx, ids=ids)
 
 
 @final
 class ManageMemoriesTool(MemoryToolBase):
     """Tool for managing memories atomically."""
-    
+
     @property
     @override
     def name(self) -> str:
         """Get the tool name."""
         return "manage_memories"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -368,31 +349,31 @@ manage_memories(
     deletions=["mem_old1", "mem_old2"]
 )
 """
-    
+
     @override
     async def call(
         self,
         ctx: MCPContext,
         creations: Optional[List[str]] = None,
         updates: Optional[List[Dict[str, str]]] = None,
-        deletions: Optional[List[str]] = None
+        deletions: Optional[List[str]] = None,
     ) -> str:
         """Manage memories atomically.
-        
+
         Args:
             ctx: MCP context
             creations: Statements to create
             updates: Memories to update
             deletions: Memory IDs to delete
-            
+
         Returns:
             Summary of operations
         """
         tool_ctx = create_tool_context(ctx)
         await tool_ctx.set_tool_info(self.name)
-        
+
         results = []
-        
+
         # Create memories
         if creations:
             await tool_ctx.info(f"Creating {len(creations)} memories")
@@ -402,11 +383,11 @@ manage_memories(
                     user_id=self.user_id,
                     project_id=self.project_id,
                     content=statement,
-                    metadata={"type": "statement"}
+                    metadata={"type": "statement"},
                 )
                 created.append(memory)
             results.append(f"Created {len(created)} memories")
-        
+
         # Update memories
         if updates:
             await tool_ctx.info(f"Updating {len(updates)} memories")
@@ -414,13 +395,17 @@ manage_memories(
             for update in updates:
                 memory_id = update.get("id")
                 statement = update.get("statement")
-                
+
                 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:
             await tool_ctx.info(f"Deleting {len(deletions)} memories")
@@ -430,27 +415,24 @@ manage_memories(
                 if success:
                     success_count += 1
             results.append(f"Deleted {success_count} memories")
-        
+
         if not results:
             return "No memory operations performed."
-        
+
         return "Memory operations completed: " + ", ".join(results)
-    
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server."""
         tool_self = self
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
         async def manage_memories(
             ctx: MCPContext,
             creations: Optional[List[str]] = None,
             updates: Optional[List[Dict[str, str]]] = None,
-            deletions: Optional[List[str]] = None
+            deletions: Optional[List[str]] = None,
         ) -> str:
             return await tool_self.call(
-                ctx,
-                creations=creations,
-                updates=updates,
-                deletions=deletions
-            )
+                ctx, creations=creations, updates=updates, deletions=deletions
+            )

hanzo_mcp/tools/search/__init__.py

@@ -1,6 +1,11 @@
 """Search tools for finding code, files, and information."""
 
-from .unified_search import UnifiedSearch, create_unified_search_tool
 from .find_tool import FindTool, create_find_tool
+from .unified_search import UnifiedSearch, create_unified_search_tool
 
-__all__ = ["UnifiedSearch", "create_unified_search_tool", "FindTool", "create_find_tool"]
+__all__ = [
+    "UnifiedSearch",
+    "create_unified_search_tool",
+    "FindTool",
+    "create_find_tool",
+]