agmem 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

memvcs/core/test_runner.py

@@ -14,6 +14,7 @@ from datetime import datetime
 
 try:
     import yaml
+
     YAML_AVAILABLE = True
 except ImportError:
     YAML_AVAILABLE = False
@@ -22,6 +23,7 @@ except ImportError:
 @dataclass
 class TestCase:
     """A single test case for memory validation."""
+
     name: str
     query: str
     expected_fact: str
@@ -33,6 +35,7 @@ class TestCase:
 @dataclass
 class TestFailure:
     """Represents a failed test."""
+
     test_name: str
     query: str
     expected: str
@@ -44,6 +47,7 @@ class TestFailure:
 @dataclass
 class TestResult:
     """Result of running memory tests."""
+
     passed: bool
     total_count: int
     passed_count: int
@@ -55,118 +59,122 @@ class TestResult:
 class TestRunner:
     """
     Runner for memory regression tests.
-    
+
     Tests are defined in YAML files in the tests/ directory of the memory repo.
     """
-    
+
     def __init__(self, repo, vector_store=None):
         """
         Initialize test runner.
-        
+
         Args:
             repo: Repository instance
             vector_store: Optional VectorStore for semantic search tests
         """
         self.repo = repo
         self.vector_store = vector_store
-        self.tests_dir = repo.root / 'tests'
-    
+        self.tests_dir = repo.root / "tests"
+
     def load_tests(self) -> List[TestCase]:
         """
         Load all test cases from the tests/ directory.
-        
+
         Returns:
             List of TestCase objects
         """
         tests = []
-        
+
         if not self.tests_dir.exists():
             return tests
-        
-        for test_file in self.tests_dir.glob('**/*.yaml'):
+
+        for test_file in self.tests_dir.glob("**/*.yaml"):
             tests.extend(self._load_test_file(test_file))
-        
-        for test_file in self.tests_dir.glob('**/*.yml'):
+
+        for test_file in self.tests_dir.glob("**/*.yml"):
             tests.extend(self._load_test_file(test_file))
-        
-        for test_file in self.tests_dir.glob('**/*.json'):
+
+        for test_file in self.tests_dir.glob("**/*.json"):
             tests.extend(self._load_json_test_file(test_file))
-        
+
         return tests
-    
+
     def _load_test_file(self, path: Path) -> List[TestCase]:
         """Load tests from a YAML file."""
         if not YAML_AVAILABLE:
             return []
-        
+
         try:
             with open(path) as f:
                 data = yaml.safe_load(f)
-            
-            if not data or 'tests' not in data:
+
+            if not data or "tests" not in data:
                 return []
-            
+
             tests = []
             file_name = path.stem
-            
-            for i, test_data in enumerate(data['tests']):
-                name = test_data.get('name', f"{file_name}_{i}")
-                tests.append(TestCase(
-                    name=name,
-                    query=test_data['query'],
-                    expected_fact=test_data['expected_fact'],
-                    confidence_threshold=test_data.get('confidence_threshold', 0.7),
-                    required=test_data.get('required', False),
-                    tags=test_data.get('tags', [])
-                ))
-            
+
+            for i, test_data in enumerate(data["tests"]):
+                name = test_data.get("name", f"{file_name}_{i}")
+                tests.append(
+                    TestCase(
+                        name=name,
+                        query=test_data["query"],
+                        expected_fact=test_data["expected_fact"],
+                        confidence_threshold=test_data.get("confidence_threshold", 0.7),
+                        required=test_data.get("required", False),
+                        tags=test_data.get("tags", []),
+                    )
+                )
+
             return tests
-        
+
         except Exception as e:
             print(f"Warning: Failed to load test file {path}: {e}")
             return []
-    
+
     def _load_json_test_file(self, path: Path) -> List[TestCase]:
         """Load tests from a JSON file."""
         try:
             with open(path) as f:
                 data = json.load(f)
-            
+
             if not data:
                 return []
-            
+
             # Support both array of tests and object with 'tests' key
             if isinstance(data, list):
                 test_list = data
-            elif 'tests' in data:
-                test_list = data['tests']
+            elif "tests" in data:
+                test_list = data["tests"]
             else:
                 return []
-            
+
             tests = []
             file_name = path.stem
-            
+
             for i, test_data in enumerate(test_list):
-                name = test_data.get('name', f"{file_name}_{i}")
-                tests.append(TestCase(
-                    name=name,
-                    query=test_data['query'],
-                    expected_fact=test_data['expected_fact'],
-                    confidence_threshold=test_data.get('confidence_threshold', 0.7),
-                    required=test_data.get('required', False),
-                    tags=test_data.get('tags', [])
-                ))
-            
+                name = test_data.get("name", f"{file_name}_{i}")
+                tests.append(
+                    TestCase(
+                        name=name,
+                        query=test_data["query"],
+                        expected_fact=test_data["expected_fact"],
+                        confidence_threshold=test_data.get("confidence_threshold", 0.7),
+                        required=test_data.get("required", False),
+                        tags=test_data.get("tags", []),
+                    )
+                )
+
             return tests
-        
+
         except Exception as e:
             print(f"Warning: Failed to load test file {path}: {e}")
             return []
-    
+
     def run_test(self, test: TestCase) -> Optional[TestFailure]:
         """
         Run a single test case.
-        
+
         Returns:
             TestFailure if test failed, None if passed
         """
@@ -176,12 +184,12 @@ class TestRunner:
         else:
             # Fall back to simple text matching
             return self._run_text_test(test)
-    
+
     def _run_semantic_test(self, test: TestCase) -> Optional[TestFailure]:
         """Run test using semantic search."""
         try:
             results = self.vector_store.search(test.query, k=5)
-            
+
             if not results:
                 return TestFailure(
                     test_name=test.name,
@@ -189,30 +197,30 @@ class TestRunner:
                     expected=test.expected_fact,
                     actual=None,
                     message="No results found for query",
-                    is_critical=test.required
+                    is_critical=test.required,
                 )
-            
+
             # Check if any result contains the expected fact
             for result in results:
-                content = result.get('content', '')
-                similarity = result.get('similarity', 0)
-                
+                content = result.get("content", "")
+                similarity = result.get("similarity", 0)
+
                 if similarity >= test.confidence_threshold:
                     # Use simple string matching as judge
                     if self._fact_matches(test.expected_fact, content):
                         return None  # Test passed
-            
+
             # No matching result found
             best_result = results[0] if results else {}
             return TestFailure(
                 test_name=test.name,
                 query=test.query,
                 expected=test.expected_fact,
-                actual=best_result.get('content', '')[:200],
+                actual=best_result.get("content", "")[:200],
                 message=f"Expected fact not found in top results (best similarity: {best_result.get('similarity', 0):.2f})",
-                is_critical=test.required
+                is_critical=test.required,
             )
-        
+
         except Exception as e:
             return TestFailure(
                 test_name=test.name,
@@ -220,14 +228,14 @@ class TestRunner:
                 expected=test.expected_fact,
                 actual=None,
                 message=f"Error running semantic test: {e}",
-                is_critical=test.required
+                is_critical=test.required,
             )
-    
+
     def _run_text_test(self, test: TestCase) -> Optional[TestFailure]:
         """Run test using simple text search through memory files."""
         try:
-            current_dir = self.repo.root / 'current'
-            
+            current_dir = self.repo.root / "current"
+
             if not current_dir.exists():
                 return TestFailure(
                     test_name=test.name,
@@ -235,27 +243,27 @@ class TestRunner:
                     expected=test.expected_fact,
                     actual=None,
                     message="No current/ directory found",
-                    is_critical=test.required
+                    is_critical=test.required,
                 )
-            
+
             # Search through all memory files
-            for memory_file in current_dir.glob('**/*.md'):
+            for memory_file in current_dir.glob("**/*.md"):
                 try:
                     content = memory_file.read_text()
                     if self._fact_matches(test.expected_fact, content):
                         return None  # Test passed
                 except Exception:
                     continue
-            
+
             return TestFailure(
                 test_name=test.name,
                 query=test.query,
                 expected=test.expected_fact,
                 actual=None,
                 message="Expected fact not found in any memory file",
-                is_critical=test.required
+                is_critical=test.required,
             )
-        
+
         except Exception as e:
             return TestFailure(
                 test_name=test.name,
@@ -263,83 +271,83 @@ class TestRunner:
                 expected=test.expected_fact,
                 actual=None,
                 message=f"Error running text test: {e}",
-                is_critical=test.required
+                is_critical=test.required,
             )
-    
+
     def _fact_matches(self, expected: str, content: str) -> bool:
         """
         Check if expected fact is present in content.
-        
+
         Uses case-insensitive substring matching.
         For more sophisticated matching, this could use an LLM judge.
         """
         expected_lower = expected.lower()
         content_lower = content.lower()
-        
+
         # Direct substring match
         if expected_lower in content_lower:
             return True
-        
+
         # Check if all key words are present
         key_words = expected_lower.split()
         if len(key_words) > 2:
             matches = sum(1 for word in key_words if word in content_lower)
             if matches >= len(key_words) * 0.8:  # 80% of words match
                 return True
-        
+
         return False
-    
+
     def run_all(self, tags: Optional[List[str]] = None) -> TestResult:
         """
         Run all tests.
-        
+
         Args:
             tags: Optional list of tags to filter tests
-            
+
         Returns:
             TestResult with overall results
         """
         start_time = datetime.now()
         tests = self.load_tests()
-        
+
         # Filter by tags if specified
         if tags:
             tests = [t for t in tests if any(tag in t.tags for tag in tags)]
-        
+
         failures = []
         passed_count = 0
-        
+
         for test in tests:
             failure = self.run_test(test)
             if failure:
                 failures.append(failure)
             else:
                 passed_count += 1
-        
+
         duration = (datetime.now() - start_time).total_seconds() * 1000
-        
+
         # Check if any critical tests failed
         critical_failures = [f for f in failures if f.is_critical]
         passed = len(critical_failures) == 0
-        
+
         return TestResult(
             passed=passed,
             total_count=len(tests),
             passed_count=passed_count,
             failed_count=len(failures),
             failures=failures,
-            duration_ms=int(duration)
+            duration_ms=int(duration),
         )
-    
+
     def run_for_branch(self, branch: str) -> TestResult:
         """
         Run tests against a specific branch.
-        
+
         Creates a temporary vector store with only the branch's data.
-        
+
         Args:
             branch: Branch name to test
-            
+
         Returns:
             TestResult
         """

memvcs/core/vector_store.py

@@ -6,11 +6,11 @@ Requires: pip install agmem[vector]
 """
 
 import logging
+import struct
+from pathlib import Path
 from typing import List, Optional, Tuple
 
 from .constants import MEMORY_TYPES
-import struct
-from pathlib import Path
 
 logger = logging.getLogger("agmem.vector_store")
 
@@ -75,7 +75,8 @@ class VectorStore:
     def _ensure_tables(self):
         """Create vector and metadata tables if they don't exist."""
         conn = self._get_connection()
-        conn.execute("""
+        conn.execute(
+            """
             CREATE TABLE IF NOT EXISTS memory_meta (
                 rowid INTEGER PRIMARY KEY,
                 path TEXT NOT NULL,
@@ -85,18 +86,21 @@ class VectorStore:
                 author TEXT,
                 indexed_at TEXT
             )
-        """)
+        """
+        )
         # Try to add new columns to existing tables (for upgrades)
-        for col in ['commit_hash TEXT', 'author TEXT', 'indexed_at TEXT']:
+        for col in ["commit_hash TEXT", "author TEXT", "indexed_at TEXT"]:
             try:
                 conn.execute(f"ALTER TABLE memory_meta ADD COLUMN {col}")
             except Exception:
                 pass  # Column already exists
         try:
-            conn.execute(f"""
+            conn.execute(
+                f"""
                 CREATE VIRTUAL TABLE IF NOT EXISTS vec_memory
                 USING vec0(embedding float[{EMBEDDING_DIM}])
-            """)
+            """
+            )
         except Exception as e:
             # vec0 might already exist with different schema
             logger.debug("vec_memory creation: %s", e)
@@ -114,11 +118,11 @@ class VectorStore:
         content: str,
         blob_hash: Optional[str] = None,
         commit_hash: Optional[str] = None,
-        author: Optional[str] = None
+        author: Optional[str] = None,
     ) -> None:
         """
         Index a memory file for semantic search.
-        
+
         Args:
             path: File path relative to current/
             content: File content to index
@@ -127,13 +131,13 @@ class VectorStore:
             author: Optional author string for provenance tracking
         """
         from datetime import datetime
-        
+
         self._ensure_tables()
         conn = self._get_connection()
 
         embedding = self._embed(content)
         emb_bytes = _serialize_f32(embedding)
-        indexed_at = datetime.utcnow().isoformat() + 'Z'
+        indexed_at = datetime.utcnow().isoformat() + "Z"
 
         with conn:
             conn.execute(
@@ -203,13 +207,13 @@ class VectorStore:
             results.append((path, snippet, float(distance)))
 
         return results
-    
+
     def search_with_provenance(
         self, query: str, limit: int = 10, min_score: Optional[float] = None
     ) -> List[dict]:
         """
         Semantic search with provenance metadata.
-        
+
         Returns list of dicts with: path, content, distance, commit_hash, author, indexed_at
         """
         self._ensure_tables()
@@ -235,51 +239,53 @@ class VectorStore:
             if min_score is not None and distance > min_score:
                 continue
             snippet = content[:500] + ("..." if len(content) > 500 else "")
-            results.append({
-                'path': path,
-                'content': snippet,
-                'distance': float(distance),
-                'similarity': 1.0 - float(distance),  # Convert to similarity score
-                'commit_hash': commit_hash,
-                'author': author,
-                'indexed_at': indexed_at,
-                'blob_hash': blob_hash
-            })
+            results.append(
+                {
+                    "path": path,
+                    "content": snippet,
+                    "distance": float(distance),
+                    "similarity": 1.0 - float(distance),  # Convert to similarity score
+                    "commit_hash": commit_hash,
+                    "author": author,
+                    "indexed_at": indexed_at,
+                    "blob_hash": blob_hash,
+                }
+            )
 
         return results
-    
+
     def get_all_entries(self) -> List[dict]:
         """
         Get all indexed entries with their metadata.
-        
+
         Used for fsck operations to check for dangling vectors.
         """
         self._ensure_tables()
         conn = self._get_connection()
-        
+
         rows = conn.execute(
             """
             SELECT rowid, path, blob_hash, commit_hash, author, indexed_at
             FROM memory_meta
             """
         ).fetchall()
-        
+
         return [
             {
-                'rowid': rowid,
-                'path': path,
-                'blob_hash': blob_hash,
-                'commit_hash': commit_hash,
-                'author': author,
-                'indexed_at': indexed_at
+                "rowid": rowid,
+                "path": path,
+                "blob_hash": blob_hash,
+                "commit_hash": commit_hash,
+                "author": author,
+                "indexed_at": indexed_at,
             }
             for rowid, path, blob_hash, commit_hash, author, indexed_at in rows
         ]
-    
+
     def delete_entry(self, rowid: int) -> bool:
         """
         Delete an entry by rowid.
-        
+
         Used by fsck to remove dangling vectors.
         """
         conn = self._get_connection()

memvcs/integrations/mcp_server.py

@@ -219,9 +219,7 @@ def _create_mcp_server():
                     fp = Path(root) / f
                     rel = str(fp.relative_to(repo.current_dir))
                     working_files[rel] = fp.read_bytes()
-            tree_diff = engine.diff_working_dir(
-                head_commit.store(repo.object_store), working_files
-            )
+            tree_diff = engine.diff_working_dir(head_commit.store(repo.object_store), working_files)
             return engine.format_diff(tree_diff, "HEAD", "working")
         else:
             base_ref = base or "HEAD~1"