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

memvcs/commands/tag.py

@@ -13,42 +13,19 @@ from ..core.repository import Repository
 
 class TagCommand:
     """Manage tags."""
-    
-    name = 'tag'
-    help = 'Create, list, delete or verify a tag'
-    
+
+    name = "tag"
+    help = "Create, list, delete or verify a tag"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
-        parser.add_argument(
-            'name',
-            nargs='?',
-            help='Tag name'
-        )
-        parser.add_argument(
-            'commit',
-            nargs='?',
-            help='Commit to tag (default: HEAD)'
-        )
-        parser.add_argument(
-            '--list', '-l',
-            action='store_true',
-            help='List tags'
-        )
-        parser.add_argument(
-            '--delete', '-d',
-            action='store_true',
-            help='Delete a tag'
-        )
-        parser.add_argument(
-            '-m', '--message',
-            help='Tag message'
-        )
-        parser.add_argument(
-            '--force', '-f',
-            action='store_true',
-            help='Force replace existing tag'
-        )
-    
+        parser.add_argument("name", nargs="?", help="Tag name")
+        parser.add_argument("commit", nargs="?", help="Commit to tag (default: HEAD)")
+        parser.add_argument("--list", "-l", action="store_true", help="List tags")
+        parser.add_argument("--delete", "-d", action="store_true", help="Delete a tag")
+        parser.add_argument("-m", "--message", help="Tag message")
+        parser.add_argument("--force", "-f", action="store_true", help="Force replace existing tag")
+
     @staticmethod
     def execute(args) -> int:
         # Find repository
@@ -56,35 +33,34 @@ class TagCommand:
         if code != 0:
             return code
 
-        
         # List tags
         if args.list or (not args.name and not args.delete):
             tags = repo.refs.list_tags()
-            
+
             if not tags:
                 print("No tags yet.")
                 return 0
-            
+
             for tag in sorted(tags):
                 commit_hash = repo.refs.get_tag_commit(tag)
                 short_hash = commit_hash[:8] if commit_hash else "????????"
                 print(f"{tag}\t{short_hash}")
-            
+
             return 0
-        
+
         # Delete tag
         if args.delete:
             if not args.name:
                 print("Error: Tag name required for deletion")
                 return 1
-            
+
             if repo.refs.delete_tag(args.name):
                 print(f"Deleted tag '{args.name}'")
                 return 0
             else:
                 print(f"Error: Tag '{args.name}' not found")
                 return 1
-        
+
         # Create tag
         if args.name:
             # Check if tag exists
@@ -92,19 +68,19 @@ class TagCommand:
                 print(f"Error: Tag '{args.name}' already exists")
                 print("Use -f to force replace")
                 return 1
-            
+
             # Get commit to tag
-            commit_ref = args.commit or 'HEAD'
+            commit_ref = args.commit or "HEAD"
             commit_hash = repo.resolve_ref(commit_ref)
-            
+
             if not commit_hash:
                 print(f"Error: Unknown revision: {commit_ref}")
                 return 1
-            
+
             # Delete existing tag if forcing
             if args.force and repo.refs.tag_exists(args.name):
                 repo.refs.delete_tag(args.name)
-            
+
             # Create tag
             message = args.message or f"Tag {args.name}"
             if repo.refs.create_tag(args.name, commit_hash, message):
@@ -113,5 +89,5 @@ class TagCommand:
             else:
                 print(f"Error: Could not create tag '{args.name}'")
                 return 1
-        
+
         return 0

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,59 @@
+"""
+agmem verify - Belief consistency checker.
+
+Scans semantic memories for logical contradictions.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.consistency import ConsistencyChecker, ConsistencyResult
+
+
+class VerifyCommand:
+    """Verify belief consistency of semantic memories."""
+
+    name = "verify"
+    help = "Scan semantic memories for logical contradictions"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--consistency",
+            "-c",
+            action="store_true",
+            default=True,
+            help="Check for contradictions (default)",
+        )
+        parser.add_argument(
+            "--llm",
+            action="store_true",
+            help="Use LLM for triple extraction (requires OpenAI)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        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.")
+            return 0
+
+        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 1