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

hanzo_mcp/tools/vector/mock_infinity.py

@@ -1,110 +1,109 @@
 """Mock implementation of infinity_embedded for testing on unsupported platforms."""
 
-import json
-import hashlib
 import random
+from typing import Any, Dict, List
 from pathlib import Path
-from typing import Dict, List, Any, Optional
-from datetime import datetime
 
 
 class MockTable:
     """Mock implementation of an Infinity table."""
-    
+
     def __init__(self, name: str, schema: Dict[str, Any]):
         self.name = name
         self.schema = schema
         self.data = []
         self._id_counter = 0
-    
+
     def insert(self, records: List[Dict[str, Any]]):
         """Insert records into the table."""
         for record in records:
             # Add an internal ID if not present
-            if 'id' not in record:
-                record['_internal_id'] = self._id_counter
+            if "id" not in record:
+                record["_internal_id"] = self._id_counter
                 self._id_counter += 1
             self.data.append(record)
-    
+
     def delete(self, condition: str):
         """Delete records matching condition."""
         # Simple implementation - just clear for now
         self.data = [r for r in self.data if not self._eval_condition(r, condition)]
-    
+
     def output(self, columns: List[str]):
         """Start a query chain."""
         return MockQuery(self, columns)
-    
+
     def _eval_condition(self, record: Dict[str, Any], condition: str) -> bool:
         """Evaluate a simple condition."""
         # Very basic implementation
-        if '=' in condition:
-            field, value = condition.split('=', 1)
+        if "=" in condition:
+            field, value = condition.split("=", 1)
             field = field.strip()
             value = value.strip().strip("'\"")
-            return str(record.get(field, '')) == value
+            return str(record.get(field, "")) == value
         return False
 
 
 class MockQuery:
     """Mock query builder."""
-    
+
     def __init__(self, table: MockTable, columns: List[str]):
         self.table = table
         self.columns = columns
         self.filters = []
         self.vector_search = None
         self.limit_value = None
-    
+
     def filter(self, condition: str):
         """Add a filter condition."""
         self.filters.append(condition)
         return self
-    
-    def match_dense(self, column: str, vector: List[float], dtype: str, metric: str, limit: int):
+
+    def match_dense(
+        self, column: str, vector: List[float], dtype: str, metric: str, limit: int
+    ):
         """Add vector search."""
         self.vector_search = {
-            'column': column,
-            'vector': vector,
-            'dtype': dtype,
-            'metric': metric,
-            'limit': limit
+            "column": column,
+            "vector": vector,
+            "dtype": dtype,
+            "metric": metric,
+            "limit": limit,
         }
         self.limit_value = limit
         return self
-    
+
     def to_pl(self):
         """Execute query and return polars-like result."""
         results = self.table.data.copy()
-        
+
         # Apply filters
         for condition in self.filters:
             results = [r for r in results if self.table._eval_condition(r, condition)]
-        
+
         # Apply vector search (mock similarity)
         if self.vector_search:
             # Add mock scores
             for r in results:
-                r['score'] = random.uniform(0.5, 1.0)
+                r["score"] = random.uniform(0.5, 1.0)
             # Sort by score
-            results.sort(key=lambda x: x.get('score', 0), reverse=True)
+            results.sort(key=lambda x: x.get("score", 0), reverse=True)
             # Limit results
             if self.limit_value:
-                results = results[:self.limit_value]
-        
+                results = results[: self.limit_value]
+
         # Return mock polars DataFrame
         return MockDataFrame(results)
 
 
 class MockDataFrame:
     """Mock polars DataFrame."""
-    
+
     def __init__(self, data: List[Dict[str, Any]]):
         self.data = data
-    
+
     def __len__(self):
         return len(self.data)
-    
+
     def iter_rows(self, named: bool = False):
         """Iterate over rows."""
         if named:
@@ -119,17 +118,17 @@ class MockDataFrame:
 
 class MockDatabase:
     """Mock implementation of an Infinity database."""
-    
+
     def __init__(self, name: str):
         self.name = name
         self.tables = {}
-    
+
     def create_table(self, name: str, schema: Dict[str, Any]) -> MockTable:
         """Create a new table."""
         table = MockTable(name, schema)
         self.tables[name] = table
         return table
-    
+
     def get_table(self, name: str) -> MockTable:
         """Get an existing table."""
         if name not in self.tables:
@@ -139,19 +138,19 @@ class MockDatabase:
 
 class MockInfinity:
     """Mock implementation of Infinity connection."""
-    
+
     def __init__(self, path: str):
         self.path = Path(path)
         self.databases = {}
         # Ensure directory exists
         self.path.mkdir(parents=True, exist_ok=True)
-    
+
     def get_database(self, name: str) -> MockDatabase:
         """Get or create a database."""
         if name not in self.databases:
             self.databases[name] = MockDatabase(name)
         return self.databases[name]
-    
+
     def disconnect(self):
         """Disconnect from Infinity."""
         pass
@@ -159,4 +158,4 @@ class MockInfinity:
 
 def connect(path: str) -> MockInfinity:
     """Connect to Infinity (mock implementation)."""
-    return MockInfinity(path)
+    return MockInfinity(path)

hanzo_mcp/tools/vector/project_manager.py

@@ -1,19 +1,20 @@
 """Project-aware vector database management for Hanzo AI."""
 
-import os
+import asyncio
+from typing import Any, Dict, List, Tuple, Optional
 from pathlib import Path
-from typing import Dict, List, Optional, Set, Tuple, Any
 from dataclasses import dataclass
-import asyncio
 from concurrent.futures import ThreadPoolExecutor
 
-from .infinity_store import InfinityVectorStore, SearchResult
-from hanzo_mcp.tools.config.index_config import IndexConfig, IndexScope
+from hanzo_mcp.tools.config.index_config import IndexScope, IndexConfig
+
+from .infinity_store import SearchResult, InfinityVectorStore
 
 
 @dataclass
 class ProjectInfo:
     """Information about a detected project."""
+
     root_path: Path
     llm_md_path: Path
     db_path: Path
@@ -22,7 +23,7 @@ class ProjectInfo:
 
 class ProjectVectorManager:
     """Manages project-aware vector databases."""
-    
+
     def __init__(
         self,
         global_db_path: Optional[str] = None,
@@ -30,7 +31,7 @@ class ProjectVectorManager:
         dimension: int = 1536,
     ):
         """Initialize the project vector manager.
-        
+
         Args:
             global_db_path: Path for global vector store (default: ~/.config/hanzo/db)
             embedding_model: Embedding model to use
@@ -38,26 +39,26 @@ class ProjectVectorManager:
         """
         self.embedding_model = embedding_model
         self.dimension = dimension
-        
+
         # Set up index configuration
         self.index_config = IndexConfig()
-        
+
         # Set up global database path
         if global_db_path:
             self.global_db_path = Path(global_db_path)
         else:
             self.global_db_path = self.index_config.get_index_path("vector")
-        
+
         self.global_db_path.mkdir(parents=True, exist_ok=True)
-        
+
         # Cache for project info and vector stores
         self.projects: Dict[str, ProjectInfo] = {}
         self.vector_stores: Dict[str, InfinityVectorStore] = {}
         self._global_store: Optional[InfinityVectorStore] = None
-        
+
         # Thread pool for parallel operations
         self.executor = ThreadPoolExecutor(max_workers=4)
-    
+
     def _get_global_store(self) -> InfinityVectorStore:
         """Get or create the global vector store."""
         if self._global_store is None:
@@ -67,56 +68,56 @@ class ProjectVectorManager:
                 dimension=self.dimension,
             )
         return self._global_store
-    
+
     def detect_projects(self, search_paths: List[str]) -> List[ProjectInfo]:
         """Detect projects by finding LLM.md files.
-        
+
         Args:
             search_paths: List of paths to search for projects
-            
+
         Returns:
             List of detected project information
         """
         projects = []
-        
+
         for search_path in search_paths:
             path = Path(search_path).resolve()
-            
+
             # Search for LLM.md files
             for llm_md_path in path.rglob("LLM.md"):
                 project_root = llm_md_path.parent
                 project_name = project_root.name
-                
+
                 # Create .hanzo/db directory in project
                 db_path = project_root / ".hanzo" / "db"
                 db_path.mkdir(parents=True, exist_ok=True)
-                
+
                 project_info = ProjectInfo(
                     root_path=project_root,
                     llm_md_path=llm_md_path,
                     db_path=db_path,
                     name=project_name,
                 )
-                
+
                 projects.append(project_info)
-                
+
                 # Cache project info
                 project_key = str(project_root)
                 self.projects[project_key] = project_info
-        
+
         return projects
-    
+
     def get_project_for_path(self, file_path: str) -> Optional[ProjectInfo]:
         """Find the project that contains a given file path.
-        
+
         Args:
             file_path: File path to check
-            
+
         Returns:
             Project info if found, None otherwise
         """
         path = Path(file_path).resolve()
-        
+
         # Check each known project
         for project_key, project_info in self.projects.items():
             try:
@@ -126,38 +127,40 @@ class ProjectVectorManager:
             except ValueError:
                 # Path is not within this project
                 continue
-        
+
         # Try to find project by walking up the directory tree
         current_path = path.parent if path.is_file() else path
-        
+
         while current_path != current_path.parent:  # Stop at filesystem root
             llm_md_path = current_path / "LLM.md"
             if llm_md_path.exists():
                 # Found a project, create and cache it
                 db_path = current_path / ".hanzo" / "db"
                 db_path.mkdir(parents=True, exist_ok=True)
-                
+
                 project_info = ProjectInfo(
                     root_path=current_path,
                     llm_md_path=llm_md_path,
                     db_path=db_path,
                     name=current_path.name,
                 )
-                
+
                 project_key = str(current_path)
                 self.projects[project_key] = project_info
                 return project_info
-            
+
             current_path = current_path.parent
-        
+
         return None
-    
-    def get_vector_store(self, project_info: Optional[ProjectInfo] = None) -> InfinityVectorStore:
+
+    def get_vector_store(
+        self, project_info: Optional[ProjectInfo] = None
+    ) -> InfinityVectorStore:
         """Get vector store for a project or global store.
-        
+
         Args:
             project_info: Project to get store for, None for global store
-            
+
         Returns:
             Vector store instance
         """
@@ -169,23 +172,25 @@ class ProjectVectorManager:
                 return self._get_global_store()
         else:
             return self._get_global_store()
-        
+
         # Use project-specific store
         project_key = str(project_info.root_path)
-        
+
         if project_key not in self.vector_stores:
             # Get index path based on configuration
-            index_path = self.index_config.get_index_path("vector", str(project_info.root_path))
+            index_path = self.index_config.get_index_path(
+                "vector", str(project_info.root_path)
+            )
             index_path.mkdir(parents=True, exist_ok=True)
-            
+
             self.vector_stores[project_key] = InfinityVectorStore(
                 data_path=str(index_path),
                 embedding_model=self.embedding_model,
                 dimension=self.dimension,
             )
-        
+
         return self.vector_stores[project_key]
-    
+
     def add_file_to_appropriate_store(
         self,
         file_path: str,
@@ -194,26 +199,26 @@ class ProjectVectorManager:
         metadata: Dict[str, Any] = None,
     ) -> Tuple[List[str], Optional[ProjectInfo]]:
         """Add a file to the appropriate vector store (project or global).
-        
+
         Args:
             file_path: Path to file to add
             chunk_size: Chunk size for text splitting
             chunk_overlap: Overlap between chunks
             metadata: Additional metadata
-            
+
         Returns:
             Tuple of (document IDs, project info or None for global)
         """
         # Check if indexing is enabled
         if not self.index_config.is_indexing_enabled("vector"):
             return [], None
-            
+
         # Find project for this file
         project_info = self.get_project_for_path(file_path)
-        
+
         # Get appropriate vector store based on scope configuration
         vector_store = self.get_vector_store(project_info)
-        
+
         # Add file metadata
         file_metadata = metadata or {}
         if project_info:
@@ -225,7 +230,7 @@ class ProjectVectorManager:
         else:
             file_metadata["project_name"] = "global"
             file_metadata["index_scope"] = "global"
-        
+
         # Add file to store
         doc_ids = vector_store.add_file(
             file_path=file_path,
@@ -233,9 +238,9 @@ class ProjectVectorManager:
             chunk_overlap=chunk_overlap,
             metadata=file_metadata,
         )
-        
+
         return doc_ids, project_info
-    
+
     async def search_all_projects(
         self,
         query: str,
@@ -245,49 +250,53 @@ class ProjectVectorManager:
         project_filter: Optional[List[str]] = None,
     ) -> Dict[str, List[SearchResult]]:
         """Search across all projects in parallel.
-        
+
         Args:
             query: Search query
             limit_per_project: Maximum results per project
             score_threshold: Minimum similarity score
             include_global: Whether to include global store
             project_filter: List of project names to search (None for all)
-            
+
         Returns:
             Dictionary mapping project names to search results
         """
         search_tasks = []
         project_names = []
-        
+
         # Add global store if requested
         if include_global:
             global_store = self._get_global_store()
             search_tasks.append(
                 asyncio.get_event_loop().run_in_executor(
                     self.executor,
-                    lambda: global_store.search(query, limit_per_project, score_threshold)
+                    lambda: global_store.search(
+                        query, limit_per_project, score_threshold
+                    ),
                 )
             )
             project_names.append("global")
-        
+
         # Add project stores
-        for project_key, project_info in self.projects.items():
+        for _project_key, project_info in self.projects.items():
             # Apply project filter
             if project_filter and project_info.name not in project_filter:
                 continue
-            
+
             vector_store = self.get_vector_store(project_info)
             search_tasks.append(
                 asyncio.get_event_loop().run_in_executor(
                     self.executor,
-                    lambda vs=vector_store: vs.search(query, limit_per_project, score_threshold)
+                    lambda vs=vector_store: vs.search(
+                        query, limit_per_project, score_threshold
+                    ),
                 )
             )
             project_names.append(project_info.name)
-        
+
         # Execute all searches in parallel
         results = await asyncio.gather(*search_tasks, return_exceptions=True)
-        
+
         # Combine results
         combined_results = {}
         for i, result in enumerate(results):
@@ -295,14 +304,15 @@ class ProjectVectorManager:
             if isinstance(result, Exception):
                 # Log error but continue
                 import logging
+
                 logger = logging.getLogger(__name__)
                 logger.error(f"Error searching project {project_name}: {result}")
                 combined_results[project_name] = []
             else:
                 combined_results[project_name] = result
-        
+
         return combined_results
-    
+
     def search_project_by_path(
         self,
         file_path: str,
@@ -311,33 +321,33 @@ class ProjectVectorManager:
         score_threshold: float = 0.0,
     ) -> List[SearchResult]:
         """Search the project containing a specific file path.
-        
+
         Args:
             file_path: File path to determine project
             query: Search query
             limit: Maximum results
             score_threshold: Minimum similarity score
-            
+
         Returns:
             Search results from the appropriate project store
         """
         project_info = self.get_project_for_path(file_path)
         vector_store = self.get_vector_store(project_info)
-        
+
         return vector_store.search(
             query=query,
             limit=limit,
             score_threshold=score_threshold,
         )
-    
+
     def get_project_stats(self) -> Dict[str, Dict[str, Any]]:
         """Get statistics for all projects.
-        
+
         Returns:
             Dictionary mapping project names to stats
         """
         stats = {}
-        
+
         # Global store stats
         try:
             global_store = self._get_global_store()
@@ -348,9 +358,9 @@ class ProjectVectorManager:
             }
         except Exception as e:
             stats["global"] = {"error": str(e)}
-        
+
         # Project store stats
-        for project_key, project_info in self.projects.items():
+        for _project_key, project_info in self.projects.items():
             try:
                 vector_store = self.get_vector_store(project_info)
                 project_files = vector_store.list_files()
@@ -362,24 +372,24 @@ class ProjectVectorManager:
                 }
             except Exception as e:
                 stats[project_info.name] = {"error": str(e)}
-        
+
         return stats
-    
+
     def cleanup(self):
         """Close all vector stores and cleanup resources."""
         # Close all project stores
         for vector_store in self.vector_stores.values():
             try:
                 vector_store.close()
-            except:
+            except Exception:
                 pass
-        
+
         # Close global store
         if self._global_store:
             try:
                 self._global_store.close()
-            except:
+            except Exception:
                 pass
-        
+
         # Shutdown executor
-        self.executor.shutdown(wait=False)
+        self.executor.shutdown(wait=False)