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

memvcs/commands/test.py

@@ -11,80 +11,66 @@ from ..core.test_runner import TestRunner, create_test_template
 
 class TestCommand:
     """Run memory regression tests."""
-    
-    name = 'test'
-    help = 'Run memory regression tests to validate knowledge consistency'
-    
+
+    name = "test"
+    help = "Run memory regression tests to validate knowledge consistency"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument("--branch", help="Run tests against a specific branch")
+        parser.add_argument("--tags", nargs="+", help="Filter tests by tags")
         parser.add_argument(
-            '--branch',
-            help='Run tests against a specific branch'
-        )
-        parser.add_argument(
-            '--tags',
-            nargs='+',
-            help='Filter tests by tags'
+            "--init", action="store_true", help="Initialize tests directory with template"
         )
         parser.add_argument(
-            '--init',
-            action='store_true',
-            help='Initialize tests directory with template'
+            "-v", "--verbose", action="store_true", help="Show detailed test output"
         )
-        parser.add_argument(
-            '-v', '--verbose',
-            action='store_true',
-            help='Show detailed test output'
-        )
-        parser.add_argument(
-            '--fail-fast',
-            action='store_true',
-            help='Stop on first failure'
-        )
-    
+        parser.add_argument("--fail-fast", action="store_true", help="Stop on first failure")
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
         if code != 0:
             return code
-        
+
         # Handle --init
         if args.init:
             return TestCommand._init_tests(repo)
-        
+
         # Try to get vector store
         vector_store = None
         try:
             from ..core.vector_store import VectorStore
-            vector_store = VectorStore(repo.root / '.mem')
+
+            vector_store = VectorStore(repo.root / ".mem")
         except ImportError:
             if args.verbose:
                 print("Note: Vector store not available, using text-based tests")
         except Exception as e:
             if args.verbose:
                 print(f"Note: Could not initialize vector store: {e}")
-        
+
         # Create test runner
         runner = TestRunner(repo, vector_store)
-        
+
         # Load and check for tests
         tests = runner.load_tests()
         if not tests:
             print("No tests found.")
             print("Create test files in tests/ directory or run 'agmem test --init'")
             return 0
-        
+
         print(f"Running {len(tests)} tests...")
-        
+
         # Run tests
         if args.branch:
             result = runner.run_for_branch(args.branch)
         else:
             result = runner.run_all(tags=args.tags)
-        
+
         # Print results
         print()
-        
+
         if result.failures:
             print("Failed tests:")
             for failure in result.failures:
@@ -97,11 +83,11 @@ class TestCommand:
                         print(f"    Got: {failure.actual[:100]}...")
                     print(f"    Error: {failure.message}")
                 print()
-        
+
         # Summary
         status = "PASSED" if result.passed else "FAILED"
         critical_failures = [f for f in result.failures if f.is_critical]
-        
+
         print(f"{'='*50}")
         print(f"Results: {result.passed_count}/{result.total_count} tests passed")
         if critical_failures:
@@ -109,24 +95,24 @@ class TestCommand:
         print(f"Duration: {result.duration_ms}ms")
         print(f"Status: {status}")
         print(f"{'='*50}")
-        
+
         return 0 if result.passed else 1
-    
+
     @staticmethod
     def _init_tests(repo) -> int:
         """Initialize tests directory with template."""
-        tests_dir = repo.root / 'tests'
+        tests_dir = repo.root / "tests"
         tests_dir.mkdir(exist_ok=True)
-        
-        template_file = tests_dir / 'example_tests.yaml'
-        
+
+        template_file = tests_dir / "example_tests.yaml"
+
         if template_file.exists():
             print(f"Test template already exists: {template_file}")
             return 0
-        
+
         template_file.write_text(create_test_template())
         print(f"Created test template: {template_file}")
         print("\nEdit this file to add your memory tests.")
         print("Run 'agmem test' to execute them.")
-        
+
         return 0

memvcs/commands/timeline.py

@@ -0,0 +1,111 @@
+"""
+agmem timeline - Show evolution of a specific memory file over time.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.objects import Commit, Tree, Blob
+
+
+class TimelineCommand:
+    """Show evolution of a memory file (blame-style over time)."""
+
+    name = "timeline"
+    help = "Show evolution of a specific memory file over time"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "file",
+            help="File to show timeline for (path relative to current/)",
+        )
+        parser.add_argument(
+            "--limit",
+            "-n",
+            type=int,
+            default=20,
+            help="Max commits to show (default: 20)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        filepath = args.file.replace("current/", "").lstrip("/")
+
+        # Walk commit history
+        head = repo.refs.get_head()
+        commit_hash = (
+            repo.refs.get_branch_commit(head["value"])
+            if head["type"] == "branch"
+            else head.get("value")
+        )
+
+        history = []
+        seen = set()
+        while commit_hash and len(history) < args.limit:
+            if commit_hash in seen:
+                break
+            seen.add(commit_hash)
+
+            commit = Commit.load(repo.object_store, commit_hash)
+            if not commit:
+                break
+
+            tree = repo.get_commit_tree(commit_hash)
+            if not tree:
+                commit_hash = commit.parents[0] if commit.parents else None
+                continue
+
+            blob_hash = None
+            for entry in tree.entries:
+                path = entry.path + "/" + entry.name if entry.path else entry.name
+                if path == filepath:
+                    blob_hash = entry.hash
+                    break
+
+            if blob_hash:
+                blob = Blob.load(repo.object_store, blob_hash)
+                content = blob.content.decode("utf-8", errors="replace") if blob else ""
+                history.append(
+                    {
+                        "commit": commit_hash,
+                        "timestamp": commit.timestamp,
+                        "author": commit.author,
+                        "message": commit.message,
+                        "content": content,
+                    }
+                )
+
+            commit_hash = commit.parents[0] if commit.parents else None
+
+        if not history:
+            print(f"File {filepath} not found in commit history.")
+            return 1
+
+        print(f"Timeline for {filepath}:")
+        print("=" * 60)
+        for i, h in enumerate(history):
+            print(f"\n[{i + 1}] {h['commit'][:8]} {h['timestamp']}")
+            print(f"    {h['author']}")
+            print(f"    {h['message'][:70]}")
+            if i > 0 and history[i - 1]["content"] != h["content"]:
+                prev_content = history[i - 1]["content"].encode()
+                curr_content = h["content"].encode()
+                # Simple line diff
+                prev_lines = prev_content.splitlines()
+                curr_lines = curr_content.splitlines()
+                for j, (a, b) in enumerate(zip(prev_lines, curr_lines)):
+                    if a != b:
+                        print(f"    ... (changed at line {j + 1})")
+                        break
+                else:
+                    if len(prev_lines) != len(curr_lines):
+                        print(f"    ... (lines changed: {len(prev_lines)} -> {len(curr_lines)})")
+            print()
+
+        return 0

memvcs/commands/tree.py

@@ -4,7 +4,7 @@ agmem tree - Show working directory or commit tree visually.
 
 import argparse
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
 from ..commands.base import require_repo
 from ..core.objects import Commit, Tree
@@ -18,7 +18,7 @@ def _build_tree_lines(
     show_hidden: bool = False,
     depth_limit: Optional[int] = None,
     current_depth: int = 0,
-) -> list[str]:
+) -> List[str]:
     """Build tree lines for a directory."""
     lines = []
     if depth_limit is not None and current_depth >= depth_limit:
@@ -27,33 +27,32 @@ def _build_tree_lines(
         entries = sorted(base_path.iterdir(), key=lambda p: (p.is_file(), p.name.lower()))
     except PermissionError:
         return [f"{prefix}└── [permission denied]"]
-    
+
     if not show_hidden:
         entries = [e for e in entries if not e.name.startswith(".")]
-    
+
     for i, entry in enumerate(entries):
         is_last_entry = i == len(entries) - 1
         connector = "└── " if is_last_entry else "├── "
         lines.append(f"{prefix}{connector}{entry.name}")
-        
+
         if entry.is_dir():
             extension = "    " if is_last_entry else "│   "
             sub_prefix = prefix + extension
             lines.extend(
                 _build_tree_lines(
-                    entry, sub_prefix, is_last_entry, show_hidden,
-                    depth_limit, current_depth + 1
+                    entry, sub_prefix, is_last_entry, show_hidden, depth_limit, current_depth + 1
                 )
             )
-    
+
     return lines
 
 
-def _build_tree_from_entries(entries: list) -> list[str]:
+def _build_tree_from_entries(entries: list) -> List[str]:
     """Build tree lines from commit tree entries (flat path/name/hash)."""
     # Build nested dict: {dir: {subdir: {file: hash}}}
     root: dict = {}
-    
+
     for path, name, hash_id in entries:
         parts = (path.split("/") if path else []) + [name]
         current = root
@@ -65,8 +64,8 @@ def _build_tree_from_entries(entries: list) -> list[str]:
                 if part not in current:
                     current[part] = {}
                 current = current[part]
-    
-    def _render(node: dict, prefix: str = "") -> list[str]:
+
+    def _render(node: dict, prefix: str = "") -> List[str]:
         lines = []
         # Directories first, then files; alphabetically within each
         items = sorted(node.items(), key=lambda x: (not isinstance(x[1], dict), x[0].lower()))
@@ -80,16 +79,16 @@ def _build_tree_from_entries(entries: list) -> list[str]:
             else:
                 lines.append(f"{prefix}{conn}{key} ({val[:8]})")
         return lines
-    
+
     return _render(root)
 
 
 class TreeCommand:
     """Show directory tree visually."""
-    
+
     name = "tree"
     help = "Show working directory or commit tree visually"
-    
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
         parser.add_argument(
@@ -99,17 +98,19 @@ class TreeCommand:
             help="Commit/branch to show (default: working directory)",
         )
         parser.add_argument(
-            "-a", "--all",
+            "-a",
+            "--all",
             action="store_true",
             help="Show hidden files",
         )
         parser.add_argument(
-            "-L", "--depth",
+            "-L",
+            "--depth",
             type=int,
             default=None,
             help="Limit depth of tree",
         )
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
@@ -122,19 +123,19 @@ class TreeCommand:
             if not commit_hash:
                 print(f"Error: Unknown revision: {args.ref}")
                 return 1
-            
+
             commit = Commit.load(repo.object_store, commit_hash)
             if not commit:
                 print(f"Error: Commit not found: {args.ref}")
                 return 1
-            
+
             tree = Tree.load(repo.object_store, commit.tree)
             if not tree:
                 print(f"Error: Tree not found for {args.ref}")
                 return 1
-            
+
             entries = [(e.path, e.name, e.hash) for e in tree.entries]
-            
+
             print(f"📁 {args.ref} ({commit_hash[:8]})")
             print("│")
             for line in _build_tree_from_entries(entries):
@@ -145,12 +146,10 @@ class TreeCommand:
             if not current_dir.exists():
                 print("Error: current/ directory not found.")
                 return 1
-            
+
             print(f"📁 current/ (working directory)")
             print("│")
-            for line in _build_tree_lines(
-                current_dir, "", True, args.all, args.depth, 0
-            ):
+            for line in _build_tree_lines(current_dir, "", True, args.all, args.depth, 0):
                 print(line)
-        
+
         return 0

memvcs/commands/verify.py

@@ -0,0 +1,110 @@
+"""
+agmem verify - Belief consistency and cryptographic commit verification.
+
+Scans semantic memories for logical contradictions; optionally verifies commit Merkle/signatures.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.consistency import ConsistencyChecker, ConsistencyResult
+
+
+class VerifyCommand:
+    """Verify belief consistency and/or cryptographic integrity of commits."""
+
+    name = "verify"
+    help = "Scan semantic memories for contradictions; optionally verify commit signatures"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--consistency",
+            "-c",
+            action="store_true",
+            help="Check semantic memories for contradictions",
+        )
+        parser.add_argument(
+            "--crypto",
+            action="store_true",
+            help="Verify Merkle tree and signatures for commits",
+        )
+        parser.add_argument(
+            "--ref",
+            metavar="REF",
+            help="Commit or ref to verify (with --crypto); default HEAD",
+        )
+        parser.add_argument(
+            "--llm",
+            action="store_true",
+            help="Use LLM for triple extraction (requires OpenAI)",
+        )
+
+    @staticmethod
+    def _run_crypto_verify(repo, ref: str = None) -> int:
+        """Run cryptographic verification. Returns 0 if all OK, 1 on failure."""
+        from ..core.crypto_verify import verify_commit, load_public_key
+
+        if ref:
+            commit_hash = repo.resolve_ref(ref)
+            if not commit_hash:
+                print(f"Ref not found: {ref}")
+                return 1
+        else:
+            head = repo.refs.get_head()
+            if head["type"] == "branch":
+                commit_hash = repo.refs.get_branch_commit(head["value"])
+            else:
+                commit_hash = head.get("value")
+            if not commit_hash:
+                print("No commit to verify (empty repo).")
+                return 0
+        pub = load_public_key(repo.mem_dir)
+        ok, err = verify_commit(
+            repo.object_store, commit_hash, public_key_pem=pub, mem_dir=repo.mem_dir
+        )
+        if ok:
+            print(f"Commit {commit_hash[:8]} verified (Merkle + signature OK).")
+            return 0
+        print(f"Commit {commit_hash[:8]} verification failed: {err}")
+        return 1
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        run_consistency = args.consistency
+        run_crypto = args.crypto
+        if not run_consistency and not run_crypto:
+            run_consistency = True
+
+        exit_code = 0
+
+        if run_crypto:
+            if VerifyCommand._run_crypto_verify(repo, args.ref) != 0:
+                exit_code = 1
+
+        if run_consistency:
+            checker = ConsistencyChecker(repo, llm_provider="openai" if args.llm else None)
+            result = checker.check(use_llm=args.llm)
+
+            print(f"Checked {result.files_checked} semantic file(s)")
+            if result.valid:
+                print("No contradictions found.")
+            else:
+                exit_code = 1
+                print(f"\nFound {len(result.contradictions)} contradiction(s):")
+                for i, c in enumerate(result.contradictions, 1):
+                    print(f"\n[{i}] {c.reason}")
+                    print(
+                        f"    {c.triple1.source}:{c.triple1.line}: {c.triple1.subject} {c.triple1.predicate} {c.triple1.obj}"
+                    )
+                    print(
+                        f"    {c.triple2.source}:{c.triple2.line}: {c.triple2.subject} {c.triple2.predicate} {c.triple2.obj}"
+                    )
+                print("\nUse 'agmem repair --strategy confidence' to attempt auto-fix.")
+
+        return exit_code

memvcs/commands/when.py

@@ -0,0 +1,115 @@
+"""
+agmem when - Find when a specific fact was learned.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.objects import Commit, Tree, Blob
+
+
+class WhenCommand:
+    """Find when a fact was learned in memory history."""
+
+    name = "when"
+    help = "Find when a specific fact was learned"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "fact",
+            nargs="?",
+            help="Fact or text to search for (e.g., 'user prefers dark mode')",
+        )
+        parser.add_argument(
+            "--file",
+            "-f",
+            help="Limit search to specific file (e.g., semantic/preferences.md)",
+        )
+        parser.add_argument(
+            "--limit",
+            "-n",
+            type=int,
+            default=10,
+            help="Max commits to report (default: 10)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        if not args.fact:
+            print("Error: Fact to search for is required.")
+            print('Usage: agmem when "fact to find" [--file path]')
+            return 1
+
+        fact_lower = args.fact.lower()
+        file_filter = args.file.replace("current/", "").lstrip("/") if args.file else None
+
+        # Walk commit history from HEAD
+        head = repo.refs.get_head()
+        commit_hash = (
+            repo.refs.get_branch_commit(head["value"])
+            if head["type"] == "branch"
+            else head.get("value")
+        )
+
+        found = []
+        seen = set()
+        while commit_hash and len(found) < args.limit:
+            if commit_hash in seen:
+                break
+            seen.add(commit_hash)
+
+            commit = Commit.load(repo.object_store, commit_hash)
+            if not commit:
+                break
+
+            tree = repo.get_commit_tree(commit_hash)
+            if not tree:
+                commit_hash = commit.parents[0] if commit.parents else None
+                continue
+
+            # Check each file in tree
+            for entry in tree.entries:
+                path = entry.path + "/" + entry.name if entry.path else entry.name
+                if file_filter and path != file_filter:
+                    continue
+                if entry.obj_type != "blob":
+                    continue
+                blob = Blob.load(repo.object_store, entry.hash)
+                if not blob:
+                    continue
+                try:
+                    content = blob.content.decode("utf-8", errors="replace")
+                except Exception:
+                    continue
+                if fact_lower in content.lower():
+                    found.append(
+                        {
+                            "commit": commit_hash,
+                            "path": path,
+                            "timestamp": commit.timestamp,
+                            "author": commit.author,
+                            "message": commit.message,
+                        }
+                    )
+                    break  # One match per commit
+
+            commit_hash = commit.parents[0] if commit.parents else None
+
+        if not found:
+            scope = f" in {file_filter}" if file_filter else ""
+            print(f'No commits found containing "{args.fact}"{scope}')
+            return 0
+
+        print(f'Fact "{args.fact}" found in {len(found)} commit(s):')
+        print()
+        for i, m in enumerate(found, 1):
+            print(f"[{i}] {m['commit'][:8]} {m['timestamp']} - {m['path']}")
+            print(f"    {m['message'][:60]}")
+            print()
+        return 0