hanzo-mcp 0.8.8__py3-none-any.whl → 0.9.0__py3-none-any.whl

hanzo_mcp/tools/vector/git_ingester.py

@@ -153,16 +153,12 @@ class GitIngester:
         )
         return result.stdout.strip()
 
-    def _get_repository_files(
-        self, repo_path: Path, patterns: Optional[List[str]] = None
-    ) -> List[Path]:
+    def _get_repository_files(self, repo_path: Path, patterns: Optional[List[str]] = None) -> List[Path]:
         """Get list of files in repository matching patterns."""
         # Use git ls-files to respect .gitignore
         cmd = ["git", "ls-files"]
 
-        result = subprocess.run(
-            cmd, cwd=repo_path, capture_output=True, text=True, check=True
-        )
+        result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True, check=True)
 
         files = []
         for line in result.stdout.strip().split("\n"):
@@ -178,9 +174,7 @@ class GitIngester:
 
         return files
 
-    def _get_commit_history(
-        self, repo_path: Path, branch: str = "HEAD", max_commits: int = 1000
-    ) -> List[GitCommit]:
+    def _get_commit_history(self, repo_path: Path, branch: str = "HEAD", max_commits: int = 1000) -> List[GitCommit]:
         """Get commit history for the repository."""
         # Get commit list with basic info
         result = subprocess.run(
@@ -222,9 +216,7 @@ class GitIngester:
 
         return commits
 
-    def _get_commit_files(
-        self, repo_path: Path, commit_hash: str
-    ) -> List[Dict[str, str]]:
+    def _get_commit_files(self, repo_path: Path, commit_hash: str) -> List[Dict[str, str]]:
         """Get list of files changed in a commit."""
         result = subprocess.run(
             ["git", "show", "--name-status", "--format=", commit_hash],
@@ -275,21 +267,15 @@ class GitIngester:
             if history:
                 metadata["first_commit"] = history[-1]["hash"]
                 metadata["last_commit"] = history[0]["hash"]
-                metadata["last_modified"] = datetime.fromtimestamp(
-                    history[0]["timestamp"]
-                ).isoformat()
+                metadata["last_modified"] = datetime.fromtimestamp(history[0]["timestamp"]).isoformat()
 
         # Add blame information if requested
         if include_blame:
             blame_data = self._get_file_blame(repo_path, relative_path)
-            metadata["unique_authors"] = len(
-                set(b["author"] for b in blame_data.values())
-            )
+            metadata["unique_authors"] = len(set(b["author"] for b in blame_data.values()))
 
         # Index the file content
-        doc_ids = self.vector_store.add_file(
-            str(file_path), chunk_size=1000, chunk_overlap=200, metadata=metadata
-        )
+        doc_ids = self.vector_store.add_file(str(file_path), chunk_size=1000, chunk_overlap=200, metadata=metadata)
         results["files_indexed"] += 1
 
         # Perform AST analysis for supported languages
@@ -309,9 +295,7 @@ class GitIngester:
             except Exception as e:
                 logger.warning(f"AST analysis failed for {file_path}: {e}")
 
-    def _get_file_history(
-        self, repo_path: Path, file_path: Path
-    ) -> List[Dict[str, Any]]:
+    def _get_file_history(self, repo_path: Path, file_path: Path) -> List[Dict[str, Any]]:
         """Get commit history for a specific file."""
         result = subprocess.run(
             [
@@ -346,9 +330,7 @@ class GitIngester:
 
         return history
 
-    def _get_file_blame(
-        self, repo_path: Path, file_path: Path
-    ) -> Dict[int, Dict[str, Any]]:
+    def _get_file_blame(self, repo_path: Path, file_path: Path) -> Dict[int, Dict[str, Any]]:
         """Get blame information for a file."""
         result = subprocess.run(
             ["git", "blame", "--line-porcelain", "--", str(file_path)],
@@ -448,9 +430,7 @@ Message: {commit.message}
             text=True,
         )
 
-        remote_url = (
-            remote_result.stdout.strip() if remote_result.returncode == 0 else None
-        )
+        remote_url = remote_result.stdout.strip() if remote_result.returncode == 0 else None
 
         # Create repository summary document
         repo_doc = f"""Repository: {repo_path.name}

hanzo_mcp/tools/vector/index_tool.py

@@ -151,13 +151,9 @@ Usage:
             if not force:
                 stats = await vector_store.get_stats()
                 if stats and stats.get("document_count", 0) > 0:
-                    await tool_ctx.info(
-                        "Project already indexed, use --force to re-index"
-                    )
+                    await tool_ctx.info("Project already indexed, use --force to re-index")
                     if show_stats:
-                        return self._format_stats(
-                            stats, abs_path, time.time() - start_time
-                        )
+                        return self._format_stats(stats, abs_path, time.time() - start_time)
                     return "Project is already indexed. Use --force to re-index."
 
             # Prepare file patterns
@@ -268,9 +264,7 @@ Usage:
                     except Exception as e:
                         errors.append(f"{file_path}: {str(e)}")
 
-            await tool_ctx.info(
-                f"Indexed {indexed_files} files ({total_size / 1024 / 1024:.1f} MB)"
-            )
+            await tool_ctx.info(f"Indexed {indexed_files} files ({total_size / 1024 / 1024:.1f} MB)")
 
             # Index git history if requested
             git_stats = {}

hanzo_mcp/tools/vector/infinity_store.py

@@ -11,9 +11,10 @@ try:
 
     INFINITY_AVAILABLE = True
 except ImportError:
-    # infinity_embedded not available, functionality will be limited
-    INFINITY_AVAILABLE = False
-    infinity_embedded = None  # type: ignore
+    # Use mock implementation when infinity_embedded is not available
+    from . import mock_infinity as infinity_embedded
+
+    INFINITY_AVAILABLE = True  # Mock is always available
 
 from .ast_analyzer import Symbol, FileAST, ASTAnalyzer, create_symbol_embedding_text
 
@@ -78,9 +79,7 @@ class InfinityVectorStore:
             dimension: Vector dimension (must match embedding model)
         """
         if not INFINITY_AVAILABLE:
-            raise ImportError(
-                "infinity_embedded is required for vector store functionality"
-            )
+            raise ImportError("infinity_embedded is required for vector store functionality")
 
         # Set up data path
         if data_path:
@@ -171,17 +170,13 @@ class InfinityVectorStore:
                     "source_file": {"type": "varchar"},
                     "target_file": {"type": "varchar"},
                     "symbol_name": {"type": "varchar"},
-                    "reference_type": {
-                        "type": "varchar"
-                    },  # import, call, inheritance, etc.
+                    "reference_type": {"type": "varchar"},  # import, call, inheritance, etc.
                     "line_number": {"type": "integer"},
                     "metadata": {"type": "varchar"},  # JSON string
                 },
             )
 
-    def _generate_doc_id(
-        self, content: str, file_path: str = "", chunk_index: int = 0
-    ) -> str:
+    def _generate_doc_id(self, content: str, file_path: str = "", chunk_index: int = 0) -> str:
         """Generate a unique document ID."""
         content_hash = hashlib.sha256(content.encode()).hexdigest()[:16]
         path_hash = hashlib.sha256(file_path.encode()).hexdigest()[:8]
@@ -533,11 +528,7 @@ class InfinityVectorStore:
             FileAST object if file found, None otherwise
         """
         try:
-            results = (
-                self.ast_table.output(["*"])
-                .filter(f"file_path = '{file_path}'")
-                .to_pl()
-            )
+            results = self.ast_table.output(["*"]).filter(f"file_path = '{file_path}'").to_pl()
 
             if len(results) == 0:
                 return None
@@ -576,11 +567,7 @@ class InfinityVectorStore:
             List of reference information
         """
         try:
-            results = (
-                self.references_table.output(["*"])
-                .filter(f"target_file = '{file_path}'")
-                .to_pl()
-            )
+            results = self.references_table.output(["*"]).filter(f"target_file = '{file_path}'").to_pl()
 
             references = []
             for row in results.iter_rows(named=True):
@@ -695,11 +682,7 @@ class InfinityVectorStore:
         """
         try:
             # Get count first
-            results = (
-                self.documents_table.output(["id"])
-                .filter(f"file_path = '{file_path}'")
-                .to_pl()
-            )
+            results = self.documents_table.output(["id"]).filter(f"file_path = '{file_path}'").to_pl()
             count = len(results)
 
             # Delete all documents for this file
@@ -725,9 +708,7 @@ class InfinityVectorStore:
                         metadata = json.loads(row["metadata"])
                         files[file_path] = {
                             "file_path": file_path,
-                            "file_name": metadata.get(
-                                "file_name", Path(file_path).name
-                            ),
+                            "file_name": metadata.get("file_name", Path(file_path).name),
                             "file_size": metadata.get("file_size", 0),
                             "total_chunks": metadata.get("total_chunks", 1),
                         }

hanzo_mcp/tools/vector/mock_infinity.py

@@ -0,0 +1,159 @@
+"""Mock implementation of infinity_embedded for testing on unsupported platforms."""
+
+import random
+from typing import Any, Dict, List
+from pathlib import Path
+
+
+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
+                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)
+            field = field.strip()
+            value = value.strip().strip("'\"")
+            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):
+        """Add vector search."""
+        self.vector_search = {
+            "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)
+            # Sort by score
+            results.sort(key=lambda x: x.get("score", 0), reverse=True)
+            # Limit results
+            if 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:
+            return iter(self.data)
+        else:
+            # Return tuples
+            if not self.data:
+                return iter([])
+            keys = list(self.data[0].keys())
+            return iter([tuple(row.get(k) for k in keys) for row in self.data])
+
+
+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:
+            raise KeyError(f"Table {name} not found")
+        return self.tables[name]
+
+
+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
+
+
+def connect(path: str) -> MockInfinity:
+    """Connect to Infinity (mock implementation)."""
+    return MockInfinity(path)