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

hanzo_mcp/tools/vector/vector.py

@@ -1,16 +1,24 @@
 """Unified vector store tool."""
 
-from typing import Annotated, TypedDict, Unpack, final, override, Optional, List, Dict, Any
+from typing import (
+    Any,
+    Dict,
+    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.permissions import PermissionManager
 from hanzo_mcp.tools.vector.project_manager import ProjectVectorManager
 
-
 # Parameter types
 Action = Annotated[
     str,
@@ -79,6 +87,7 @@ ForceReindex = Annotated[
 
 class VectorParams(TypedDict, total=False):
     """Parameters for vector tool."""
+
     action: str
     query: Optional[str]
     path: Optional[str]
@@ -92,8 +101,12 @@ class VectorParams(TypedDict, total=False):
 @final
 class VectorTool(BaseTool):
     """Unified vector store tool for semantic search."""
-    
-    def __init__(self, permission_manager: PermissionManager, project_manager: ProjectVectorManager):
+
+    def __init__(
+        self,
+        permission_manager: PermissionManager,
+        project_manager: ProjectVectorManager,
+    ):
         """Initialize the vector tool."""
         super().__init__(permission_manager)
         self.project_manager = project_manager
@@ -128,7 +141,7 @@ vector --action clear --path ./old_code
 
         # Extract action
         action = params.get("action", "search")
-        
+
         # Route to appropriate handler
         if action == "search":
             return await self._handle_search(params, tool_ctx)
@@ -146,52 +159,52 @@ vector --action clear --path ./old_code
         query = params.get("query")
         if not query:
             return "Error: query is required for search action"
-        
+
         path = params.get("path", ".")
         limit = params.get("limit", 10)
-        
+
         # Validate path
         allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
         if not allowed:
             return error_msg
-        
+
         try:
             # Determine search scope
             project = self.project_manager.get_project_for_path(path)
             if not project:
                 return "Error: No indexed project found for this path. Run 'vector --action index' first."
-            
+
             # Search
             await tool_ctx.info(f"Searching for: {query}")
             results = project.search(query, k=limit)
-            
+
             if not results:
                 return f"No results found for: {query}"
-            
+
             # Format results
             output = [f"=== Vector Search Results for '{query}' ==="]
             output.append(f"Found {len(results)} matches\n")
-            
+
             for i, result in enumerate(results, 1):
                 score = result.get("score", 0)
                 file_path = result.get("file_path", "unknown")
                 content = result.get("content", "")
                 chunk_type = result.get("metadata", {}).get("type", "content")
-                
+
                 output.append(f"Result {i} - Score: {score:.1%}")
                 output.append(f"File: {file_path}")
                 if chunk_type != "content":
                     output.append(f"Type: {chunk_type}")
                 output.append("-" * 60)
-                
+
                 # Truncate content if too long
                 if len(content) > 300:
                     content = content[:300] + "..."
                 output.append(content)
                 output.append("")
-            
+
             return "\n".join(output)
-            
+
         except Exception as e:
             await tool_ctx.error(f"Search failed: {str(e)}")
             return f"Error during search: {str(e)}"
@@ -203,32 +216,32 @@ vector --action clear --path ./old_code
         exclude = params.get("exclude")
         include_git = params.get("include_git", True)
         force = params.get("force_reindex", False)
-        
+
         # Validate path
         allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
         if not allowed:
             return error_msg
-        
+
         try:
             await tool_ctx.info(f"Indexing {path}...")
-            
+
             # Get or create project
             project = self.project_manager.get_or_create_project(path)
-            
+
             # Index files
             stats = await project.index_directory(
                 path,
                 include_pattern=include,
                 exclude_pattern=exclude,
-                force_reindex=force
+                force_reindex=force,
             )
-            
+
             # Index git history if requested
             if include_git and Path(path).joinpath(".git").exists():
                 await tool_ctx.info("Indexing git history...")
                 git_stats = await project.index_git_history(path)
                 stats["git_commits"] = git_stats.get("commits_indexed", 0)
-            
+
             # Format output
             output = [f"=== Indexing Complete ==="]
             output.append(f"Path: {path}")
@@ -236,10 +249,12 @@ vector --action clear --path ./old_code
             output.append(f"Chunks created: {stats.get('chunks_created', 0)}")
             if stats.get("git_commits"):
                 output.append(f"Git commits indexed: {stats['git_commits']}")
-            output.append(f"Total documents: {project.get_stats().get('total_documents', 0)}")
-            
+            output.append(
+                f"Total documents: {project.get_stats().get('total_documents', 0)}"
+            )
+
             return "\n".join(output)
-            
+
         except Exception as e:
             await tool_ctx.error(f"Indexing failed: {str(e)}")
             return f"Error during indexing: {str(e)}"
@@ -247,31 +262,33 @@ vector --action clear --path ./old_code
     async def _handle_stats(self, params: Dict[str, Any], tool_ctx) -> str:
         """Get vector store statistics."""
         path = params.get("path")
-        
+
         try:
             if path:
                 # Stats for specific project
                 project = self.project_manager.get_project_for_path(path)
                 if not project:
                     return f"No indexed project found for path: {path}"
-                
+
                 stats = project.get_stats()
                 output = [f"=== Vector Store Stats for {project.name} ==="]
             else:
                 # Global stats
                 stats = self.project_manager.get_global_stats()
                 output = ["=== Global Vector Store Stats ==="]
-            
+
             output.append(f"Total documents: {stats.get('total_documents', 0)}")
             output.append(f"Total size: {stats.get('total_size_mb', 0):.1f} MB")
-            
+
             if stats.get("projects"):
                 output.append(f"\nProjects indexed: {len(stats['projects'])}")
                 for proj in stats["projects"]:
-                    output.append(f"  - {proj['name']}: {proj['documents']} docs, {proj['size_mb']:.1f} MB")
-            
+                    output.append(
+                        f"  - {proj['name']}: {proj['documents']} docs, {proj['size_mb']:.1f} MB"
+                    )
+
             return "\n".join(output)
-            
+
         except Exception as e:
             await tool_ctx.error(f"Failed to get stats: {str(e)}")
             return f"Error getting stats: {str(e)}"
@@ -279,33 +296,33 @@ vector --action clear --path ./old_code
     async def _handle_clear(self, params: Dict[str, Any], tool_ctx) -> str:
         """Clear vector store."""
         path = params.get("path")
-        
+
         if not path:
             return "Error: path is required for clear action"
-        
+
         # Validate path
         allowed, error_msg = await self.check_path_allowed(path, tool_ctx)
         if not allowed:
             return error_msg
-        
+
         try:
             project = self.project_manager.get_project_for_path(path)
             if not project:
                 return f"No indexed project found for path: {path}"
-            
+
             # Get stats before clearing
             stats = project.get_stats()
             doc_count = stats.get("total_documents", 0)
-            
+
             # Clear
             project.clear()
-            
+
             return f"Cleared {doc_count} documents from vector store for {project.name}"
-            
+
         except Exception as e:
             await tool_ctx.error(f"Failed to clear: {str(e)}")
             return f"Error clearing vector store: {str(e)}"
 
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server."""
-        pass
+        pass

hanzo_mcp/tools/vector/vector_index.py

@@ -1,22 +1,19 @@
 """Vector indexing tool for adding documents to vector database."""
 
-from typing import Dict, List, Optional, TypedDict, Unpack, final
+from typing import Dict, Unpack, Optional, TypedDict, final
 from pathlib import Path
 
 from mcp.server.fastmcp import Context as MCPContext
-from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
-from hanzo_mcp.tools.common.validation import validate_path_parameter
 
-from .infinity_store import InfinityVectorStore
 from .project_manager import ProjectVectorManager
 
 
 class VectorIndexParams(TypedDict, total=False):
     """Parameters for vector indexing operations."""
-    
+
     file_path: str
     content: Optional[str]
     chunk_size: Optional[int]
@@ -27,22 +24,26 @@ class VectorIndexParams(TypedDict, total=False):
 @final
 class VectorIndexTool(BaseTool):
     """Tool for indexing documents in the vector database."""
-    
-    def __init__(self, permission_manager: PermissionManager, project_manager: ProjectVectorManager):
+
+    def __init__(
+        self,
+        permission_manager: PermissionManager,
+        project_manager: ProjectVectorManager,
+    ):
         """Initialize the vector index tool.
-        
+
         Args:
             permission_manager: Permission manager for access control
             project_manager: Project-aware vector store manager
         """
         self.permission_manager = permission_manager
         self.project_manager = project_manager
-    
+
     @property
     def name(self) -> str:
         """Get the tool name."""
         return "vector_index"
-    
+
     @property
     def description(self) -> str:
         """Get the tool description."""
@@ -54,18 +55,18 @@ database. Files are chunked for optimal search performance.
 
 Projects are detected by finding LLM.md files, with databases stored in .hanzo/db
 directories alongside them. Use this to build searchable knowledge bases per project."""
-    
+
     async def call(
         self,
         ctx: MCPContext,
         **params: Unpack[VectorIndexParams],
     ) -> str:
         """Index content or files in the vector database.
-        
+
         Args:
             ctx: MCP context
             **params: Tool parameters
-            
+
         Returns:
             Indexing result message
         """
@@ -74,34 +75,36 @@ directories alongside them. Use this to build searchable knowledge bases per pro
         chunk_size = params.get("chunk_size", 1000)
         chunk_overlap = params.get("chunk_overlap", 200)
         metadata = params.get("metadata", {})
-        
+
         if not file_path and not content:
             return "Error: Either file_path or content must be provided"
-        
+
         try:
             if file_path:
                 # Validate file access
                 # Use permission manager's existing validation
                 if not self.permission_manager.is_path_allowed(file_path):
                     return f"Error: Access denied to path {file_path}"
-                
+
                 if not Path(file_path).exists():
                     return f"Error: File does not exist: {file_path}"
-                
+
                 # Index file using project-aware manager
-                doc_ids, project_info = self.project_manager.add_file_to_appropriate_store(
-                    file_path=file_path,
-                    chunk_size=chunk_size,
-                    chunk_overlap=chunk_overlap,
-                    metadata=metadata,
+                doc_ids, project_info = (
+                    self.project_manager.add_file_to_appropriate_store(
+                        file_path=file_path,
+                        chunk_size=chunk_size,
+                        chunk_overlap=chunk_overlap,
+                        metadata=metadata,
+                    )
                 )
-                
+
                 file_name = Path(file_path).name
                 if project_info:
                     return f"Successfully indexed {file_name} with {len(doc_ids)} chunks in project '{project_info.name}'"
                 else:
                     return f"Successfully indexed {file_name} with {len(doc_ids)} chunks in global database"
-            
+
             else:
                 # Index content directly in global store (no project context)
                 global_store = self.project_manager._get_global_store()
@@ -109,8 +112,8 @@ directories alongside them. Use this to build searchable knowledge bases per pro
                     content=content,
                     metadata=metadata,
                 )
-                
+
                 return f"Successfully indexed content as document {doc_id} in global database"
-                
+
         except Exception as e:
-            return f"Error indexing content: {str(e)}"
+            return f"Error indexing content: {str(e)}"

hanzo_mcp/tools/vector/vector_search.py

@@ -1,22 +1,19 @@
 """Vector search tool for semantic document retrieval."""
 
-from typing import Dict, List, Optional, TypedDict, Unpack, final
 import json
-import asyncio
+from typing import List, Unpack, Optional, TypedDict, final
 
 from mcp.server.fastmcp import Context as MCPContext
-from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.permissions import PermissionManager
 
-from .infinity_store import InfinityVectorStore
 from .project_manager import ProjectVectorManager
 
 
 class VectorSearchParams(TypedDict, total=False):
     """Parameters for vector search operations."""
-    
+
     query: str
     limit: Optional[int]
     score_threshold: Optional[float]
@@ -29,22 +26,26 @@ class VectorSearchParams(TypedDict, total=False):
 @final
 class VectorSearchTool(BaseTool):
     """Tool for semantic search in the vector database."""
-    
-    def __init__(self, permission_manager: PermissionManager, project_manager: ProjectVectorManager):
+
+    def __init__(
+        self,
+        permission_manager: PermissionManager,
+        project_manager: ProjectVectorManager,
+    ):
         """Initialize the vector search tool.
-        
+
         Args:
             permission_manager: Permission manager for access control
             project_manager: Project-aware vector store manager
         """
         self.permission_manager = permission_manager
         self.project_manager = project_manager
-    
+
     @property
     def name(self) -> str:
         """Get the tool name."""
         return "vector_search"
-    
+
     @property
     def description(self) -> str:
         """Get the tool description."""
@@ -60,32 +61,32 @@ Features:
 - Automatically detects projects via LLM.md files
 
 Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similarity."""
-    
+
     async def call(
         self,
         ctx: MCPContext,
         **params: Unpack[VectorSearchParams],
     ) -> str:
         """Search for similar documents in the vector database.
-        
+
         Args:
             ctx: MCP context
             **params: Tool parameters
-            
+
         Returns:
             Search results formatted as text
         """
         query = params.get("query")
         if not query:
             return "Error: query parameter is required"
-        
+
         limit = params.get("limit", 10)
         score_threshold = params.get("score_threshold", 0.0)
         include_content = params.get("include_content", True)
         file_filter = params.get("file_filter")
         project_filter = params.get("project_filter")
         search_scope = params.get("search_scope", "all")
-        
+
         try:
             # Determine search strategy based on scope
             if search_scope == "all":
@@ -97,7 +98,7 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                     include_global=True,
                     project_filter=project_filter,
                 )
-                
+
                 # Combine and sort all results
                 all_results = []
                 for project_name, results in project_results.items():
@@ -106,11 +107,11 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                         result.document.metadata = result.document.metadata or {}
                         result.document.metadata["search_project"] = project_name
                         all_results.append(result)
-                
+
                 # Sort by score and limit
                 all_results.sort(key=lambda x: x.score, reverse=True)
                 results = all_results[:limit]
-                
+
             elif search_scope == "global":
                 # Search only global store
                 global_store = self.project_manager._get_global_store()
@@ -122,19 +123,21 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                 for result in results:
                     result.document.metadata = result.document.metadata or {}
                     result.document.metadata["search_project"] = "global"
-                    
+
             else:
                 # Search specific project or current context
                 if search_scope != "current":
                     # Search specific project by name
                     project_info = None
-                    for proj_key, proj_info in self.project_manager.projects.items():
+                    for _proj_key, proj_info in self.project_manager.projects.items():
                         if proj_info.name == search_scope:
                             project_info = proj_info
                             break
-                    
+
                     if project_info:
-                        vector_store = self.project_manager.get_vector_store(project_info)
+                        vector_store = self.project_manager.get_vector_store(
+                            project_info
+                        )
                         results = vector_store.search(
                             query=query,
                             limit=limit,
@@ -142,17 +145,24 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                         )
                         for result in results:
                             result.document.metadata = result.document.metadata or {}
-                            result.document.metadata["search_project"] = project_info.name
+                            result.document.metadata["search_project"] = (
+                                project_info.name
+                            )
                     else:
                         return f"Project '{search_scope}' not found"
                 else:
                     # For "current", try to detect from working directory
                     import os
+
                     current_dir = os.getcwd()
-                    project_info = self.project_manager.get_project_for_path(current_dir)
-                    
+                    project_info = self.project_manager.get_project_for_path(
+                        current_dir
+                    )
+
                     if project_info:
-                        vector_store = self.project_manager.get_vector_store(project_info)
+                        vector_store = self.project_manager.get_vector_store(
+                            project_info
+                        )
                         results = vector_store.search(
                             query=query,
                             limit=limit,
@@ -160,7 +170,9 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                         )
                         for result in results:
                             result.document.metadata = result.document.metadata or {}
-                            result.document.metadata["search_project"] = project_info.name
+                            result.document.metadata["search_project"] = (
+                                project_info.name
+                            )
                     else:
                         # Fall back to global store
                         global_store = self.project_manager._get_global_store()
@@ -172,21 +184,23 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                         for result in results:
                             result.document.metadata = result.document.metadata or {}
                             result.document.metadata["search_project"] = "global"
-            
+
             if not results:
                 return f"No results found for query: '{query}'"
-            
+
             # Filter by file if requested
             if file_filter:
-                results = [r for r in results if file_filter in (r.document.file_path or "")]
-            
+                results = [
+                    r for r in results if file_filter in (r.document.file_path or "")
+                ]
+
             # Format results
             output_lines = [f"Found {len(results)} results for query: '{query}'\n"]
-            
+
             for i, result in enumerate(results, 1):
                 doc = result.document
                 score_percent = result.score * 100
-                
+
                 # Header with score and metadata
                 project_name = doc.metadata.get("search_project", "unknown")
                 header = f"Result {i} (Score: {score_percent:.1f}%) - Project: {project_name}"
@@ -194,37 +208,42 @@ Use 'grep' for exact text/pattern matching, 'vector_search' for semantic similar
                     header += f" - {doc.file_path}"
                     if doc.chunk_index is not None:
                         header += f" [Chunk {doc.chunk_index}]"
-                
+
                 output_lines.append(header)
                 output_lines.append("-" * len(header))
-                
+
                 # Add metadata if available
                 if doc.metadata:
-                    relevant_metadata = {k: v for k, v in doc.metadata.items() 
-                                       if k not in ['chunk_number', 'total_chunks', 'search_project']}
+                    relevant_metadata = {
+                        k: v
+                        for k, v in doc.metadata.items()
+                        if k not in ["chunk_number", "total_chunks", "search_project"]
+                    }
                     if relevant_metadata:
-                        output_lines.append(f"Metadata: {json.dumps(relevant_metadata, indent=2)}")
-                
+                        output_lines.append(
+                            f"Metadata: {json.dumps(relevant_metadata, indent=2)}"
+                        )
+
                 # Add content if requested
                 if include_content:
                     content = doc.content
                     if len(content) > 500:
                         content = content[:500] + "..."
                     output_lines.append(f"Content:\n{content}")
-                
+
                 output_lines.append("")  # Empty line between results
-            
+
             return "\n".join(output_lines)
-            
+
         except Exception as e:
             return f"Error searching vector database: {str(e)}"
-    
+
     def register(self, mcp_server) -> None:
         """Register this tool with the MCP server.
-        
+
         Args:
             mcp_server: The FastMCP server instance
         """
         # This is a placeholder - the actual registration would happen
         # through the MCP server's tool registration mechanism
-        pass
+        pass