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

memvcs/commands/prove.py

@@ -0,0 +1,66 @@
+"""
+agmem prove - Generate zero-knowledge proofs (stub).
+
+Prove properties of memory (keyword, freshness) without revealing content.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.zk_proofs import prove_keyword_containment, prove_memory_freshness
+
+
+class ProveCommand:
+    """Generate zk proofs for memory properties."""
+
+    name = "prove"
+    help = "Prove a property of memory without revealing content (zk stub)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--memory", "-m", required=True, help="Memory file path (under current/)"
+        )
+        parser.add_argument(
+            "--property",
+            "-p",
+            choices=["keyword", "freshness"],
+            required=True,
+            help="Property to prove",
+        )
+        parser.add_argument("--value", "-v", help="Value (e.g. keyword or ISO date)")
+        parser.add_argument("--output", "-o", help="Output proof file path")
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        path = repo.current_dir / args.memory
+        if not path.exists():
+            print(f"Memory file not found: {args.memory}")
+            return 1
+
+        out = args.output or "proof.bin"
+        out_path = Path(out)
+        if not out_path.is_absolute():
+            out_path = repo.root / out_path
+
+        if args.property == "keyword":
+            if not args.value:
+                print("--value required for keyword (the keyword)")
+                return 1
+            ok = prove_keyword_containment(path, args.value, out_path)
+        else:
+            if not args.value:
+                print("--value required for freshness (ISO date)")
+                return 1
+            ok = prove_memory_freshness(path, args.value, out_path)
+
+        if not ok:
+            print("Proof generation not yet implemented (zk backend required).")
+            return 1
+        print(f"Proof written to {out_path}")
+        return 0

memvcs/commands/pull.py

@@ -25,6 +25,11 @@ class PullCommand:
             nargs="?",
             help="Branch to pull (default: all)",
         )
+        parser.add_argument(
+            "--yes",
+            action="store_true",
+            help="Accept conditionally trusted remote commits without prompting",
+        )
 
     @staticmethod
     def execute(args) -> int:
@@ -37,7 +42,9 @@ class PullCommand:
 
         remote = Remote(repo.root, args.remote)
         if not remote.get_remote_url():
-            print(f"Error: Remote '{args.remote}' has no URL. Set with: agmem remote add {args.remote} <url>")
+            print(
+                f"Error: Remote '{args.remote}' has no URL. Set with: agmem remote add {args.remote} <url>"
+            )
             return 1
 
         try:
@@ -49,7 +56,30 @@ class PullCommand:
                 remote_ref = f"{args.remote}/{current_branch}"
                 remote_hash = repo.resolve_ref(remote_ref)
                 if remote_hash:
+                    from memvcs.core.crypto_verify import verify_commit_optional
+
+                    verify_commit_optional(
+                        repo.object_store, remote_hash, mem_dir=repo.mem_dir, strict=False
+                    )
+                    # Trust check: block or require confirmation for untrusted/conditional
+                    from memvcs.core.objects import Commit
+                    from memvcs.core.trust import find_verifying_key, get_trust_level
+
+                    remote_commit = Commit.load(repo.object_store, remote_hash)
+                    if remote_commit and remote_commit.metadata:
+                        key_pem = find_verifying_key(repo.mem_dir, remote_commit.metadata)
+                        if key_pem is not None:
+                            level = get_trust_level(repo.mem_dir, key_pem)
+                            if level == "untrusted":
+                                print(f"Pull blocked: remote commit signed by untrusted key.")
+                                return 1
+                            if level == "conditional" and not getattr(args, "yes", False):
+                                print(
+                                    "Remote commit from conditionally trusted key. Use --yes to merge."
+                                )
+                                return 1
                     from memvcs.core.merge import MergeEngine
+
                     merge_engine = MergeEngine(repo)
                     try:
                         result = merge_engine.merge(remote_ref)

memvcs/commands/push.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 class MemoryConflictError(Exception):
     """Exception raised when push fails due to conflicts."""
+
     pass
 
 
@@ -31,7 +32,8 @@ class PushCommand:
             help="Branch to push (default: current)",
         )
         parser.add_argument(
-            "--force", "-f",
+            "--force",
+            "-f",
             action="store_true",
             help="Force push (WARNING: may overwrite remote changes)",
         )
@@ -53,7 +55,7 @@ class PushCommand:
 
         remote = Remote(repo.root, args.remote)
         remote_url = remote.get_remote_url()
-        
+
         if not remote_url:
             print(f"Error: Remote '{args.remote}' has no URL.")
             print(f"Set with: agmem remote add {args.remote} <url>")

memvcs/commands/recall.py

@@ -0,0 +1,145 @@
+"""
+agmem recall - Context-aware retrieval with pluggable strategies.
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.access_index import AccessIndex
+from ..retrieval import RecallEngine
+
+
+def _is_vector_unavailable_error(exc: Exception) -> bool:
+    """True if exception indicates vector deps are missing."""
+    msg = str(exc).lower()
+    return any(
+        key in msg
+        for key in ("sqlite-vec", "sentence-transformers", "vector search", "agmem[vector]")
+    )
+
+
+class RecallCommand:
+    """Context-aware recall with pluggable strategies."""
+
+    name = "recall"
+    help = "Recall curated memories for the current task (context-aware retrieval)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--context",
+            "-c",
+            default="",
+            help="Current task description (used for embedding similarity)",
+        )
+        parser.add_argument(
+            "--strategy",
+            "-s",
+            choices=["recency", "importance", "similarity", "hybrid"],
+            default="hybrid",
+            help="Recall strategy (default: hybrid)",
+        )
+        parser.add_argument(
+            "--limit",
+            "-n",
+            type=int,
+            default=10,
+            help="Max chunks to return (default: 10)",
+        )
+        parser.add_argument(
+            "--exclude",
+            "-e",
+            action="append",
+            default=[],
+            help="Tags/paths to exclude (e.g., experiment/*); repeatable",
+        )
+        parser.add_argument(
+            "--no-cache",
+            action="store_true",
+            help="Disable recall cache",
+        )
+        parser.add_argument(
+            "--format",
+            "-f",
+            choices=["json", "text"],
+            default="json",
+            help="Output format (default: json)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        vector_store = None
+        try:
+            from ..core.vector_store import VectorStore
+
+            vector_store = VectorStore(repo.mem_dir)
+        except ImportError:
+            if args.strategy in ("similarity", "hybrid"):
+                print(
+                    "Error: Strategy '{}' requires agmem[vector]. "
+                    "Install with: pip install agmem[vector]".format(args.strategy),
+                    file=sys.stderr,
+                )
+                return 1
+            if args.strategy == "hybrid":
+                args.strategy = "recency"
+                print("Note: Falling back to recency (vector store not available)")
+
+        access_index = AccessIndex(repo.mem_dir)
+        engine = RecallEngine(
+            repo=repo,
+            vector_store=vector_store,
+            access_index=access_index,
+            use_cache=not args.no_cache,
+        )
+
+        try:
+            results = engine.recall(
+                context=args.context,
+                limit=args.limit,
+                strategy=args.strategy,
+                exclude=args.exclude,
+            )
+        except Exception as e:
+            if _is_vector_unavailable_error(e):
+                if args.strategy in ("similarity", "hybrid"):
+                    print(
+                        "Error: Vector search unavailable. Try --strategy recency or importance.",
+                        file=sys.stderr,
+                    )
+                    return 1
+                engine = RecallEngine(
+                    repo=repo,
+                    vector_store=None,
+                    access_index=access_index,
+                    use_cache=not args.no_cache,
+                )
+                results = engine.recall(
+                    context=args.context,
+                    limit=args.limit,
+                    strategy="recency",
+                    exclude=args.exclude,
+                )
+            else:
+                raise
+
+        if args.format == "json":
+            output = [r.to_dict() for r in results]
+            print(json.dumps(output, indent=2))
+        else:
+            for r in results:
+                print(f"\n--- {r.path} (score: {r.relevance_score:.4f}) ---")
+                print(r.content[:500] + ("..." if len(r.content) > 500 else ""))
+                if r.importance is not None:
+                    print(f"(importance: {r.importance})")
+
+        if vector_store and hasattr(vector_store, "close"):
+            vector_store.close()
+        return 0

memvcs/commands/reflog.py

@@ -11,42 +11,33 @@ from ..core.repository import Repository
 
 class ReflogCommand:
     """Show reflog - history of HEAD changes."""
-    
-    name = 'reflog'
-    help = 'Show reference log (history of HEAD changes)'
-    
+
+    name = "reflog"
+    help = "Show reference log (history of HEAD changes)"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument("ref", nargs="?", default="HEAD", help="Reference to show log for")
         parser.add_argument(
-            'ref',
-            nargs='?',
-            default='HEAD',
-            help='Reference to show log for'
-        )
-        parser.add_argument(
-            '-n', '--max-count',
-            type=int,
-            default=20,
-            help='Maximum number of entries'
+            "-n", "--max-count", type=int, default=20, help="Maximum number of entries"
         )
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
         if code != 0:
             return code
 
-        
         entries = repo.refs.get_reflog(args.ref, args.max_count)
-        
+
         if not entries:
             print("No reflog entries found.")
             return 0
-        
+
         for e in entries:
-            h = e['hash'][:8]
-            ts = e.get('timestamp', '')[:19]
-            msg = e.get('message', '')
+            h = e["hash"][:8]
+            ts = e.get("timestamp", "")[:19]
+            msg = e.get("message", "")
             print(f"{h} {ts} {msg}")
-        
+
         return 0

memvcs/commands/remote.py

@@ -40,6 +40,7 @@ class RemoteCommand:
             print(f"Remote '{args.name}' set to {args.url}")
         elif args.remote_action == "show":
             import json
+
             config = json.loads((repo.root / ".mem" / "config.json").read_text())
             remotes = config.get("remotes", {})
             if remotes:

memvcs/commands/repair.py

@@ -0,0 +1,66 @@
+"""
+agmem repair - Auto-fix belief contradictions.
+
+Repairs semantic memory contradictions using configurable strategy.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.consistency import ConsistencyChecker, ConsistencyResult
+
+
+class RepairCommand:
+    """Repair belief contradictions in semantic memories."""
+
+    name = "repair"
+    help = "Auto-fix contradictions using confidence scores"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--strategy",
+            "-s",
+            choices=["confidence", "recency", "llm"],
+            default="confidence",
+            help="Repair strategy (default: confidence)",
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show what would be fixed without making changes",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        checker = ConsistencyChecker(repo, llm_provider="openai")
+        result = checker.repair(strategy=args.strategy)
+
+        if result.valid:
+            print("No contradictions to repair.")
+            return 0
+
+        if args.dry_run:
+            print(f"Would repair {len(result.contradictions)} contradiction(s):")
+            for c in result.contradictions:
+                print(
+                    f"  - {c.triple1.source}:{c.triple1.line} vs {c.triple2.source}:{c.triple2.line}"
+                )
+            print("\nRun without --dry-run to apply repairs.")
+            return 0
+
+        # Repair: keep higher-confidence triple, flag the other
+        # For now we only report - full repair would modify files
+        print(f"Found {len(result.contradictions)} contradiction(s).")
+        print("Manual repair required - edit the semantic files to resolve.")
+        for c in result.contradictions:
+            keep = c.triple1 if c.triple1.confidence >= c.triple2.confidence else c.triple2
+            drop = c.triple2 if keep is c.triple1 else c.triple1
+            print(f"  Keep: {keep.source}:{keep.line} (confidence {keep.confidence})")
+            print(f"  Review: {drop.source}:{drop.line} (confidence {drop.confidence})")
+        return 1

memvcs/commands/reset.py

@@ -11,34 +11,25 @@ from ..core.repository import Repository
 
 class ResetCommand:
     """Reset current HEAD to the specified state."""
-    
-    name = 'reset'
-    help = 'Reset current HEAD to the specified state'
-    
+
+    name = "reset"
+    help = "Reset current HEAD to the specified state"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
         parser.add_argument(
-            'commit',
-            nargs='?',
-            default='HEAD',
-            help='Commit to reset to (default: HEAD)'
+            "commit", nargs="?", default="HEAD", help="Commit to reset to (default: HEAD)"
         )
         parser.add_argument(
-            '--soft',
-            action='store_true',
-            help='Reset HEAD but keep staged changes'
+            "--soft", action="store_true", help="Reset HEAD but keep staged changes"
         )
         parser.add_argument(
-            '--mixed',
-            action='store_true',
-            help='Reset HEAD and unstaged changes (default)'
+            "--mixed", action="store_true", help="Reset HEAD and unstaged changes (default)"
         )
         parser.add_argument(
-            '--hard',
-            action='store_true',
-            help='Reset HEAD, index, and working tree'
+            "--hard", action="store_true", help="Reset HEAD, index, and working tree"
         )
-    
+
     @staticmethod
     def execute(args) -> int:
         # Find repository
@@ -46,53 +37,52 @@ class ResetCommand:
         if code != 0:
             return code
 
-        
         # Determine mode
         if args.soft:
-            mode = 'soft'
+            mode = "soft"
         elif args.hard:
-            mode = 'hard'
+            mode = "hard"
         else:
-            mode = 'mixed'
-        
+            mode = "mixed"
+
         # Resolve commit
         commit_hash = repo.resolve_ref(args.commit)
         if not commit_hash:
             print(f"Error: Unknown revision: {args.commit}")
             return 1
-        
+
         # Get current branch
         current_branch = repo.refs.get_current_branch()
-        
+
         try:
-            if mode == 'soft':
+            if mode == "soft":
                 # Just move HEAD
                 if current_branch:
                     repo.refs.set_branch_commit(current_branch, commit_hash)
                 else:
                     repo.refs.set_head_detached(commit_hash)
                 print(f"HEAD is now at {commit_hash[:8]}")
-            
-            elif mode == 'mixed':
+
+            elif mode == "mixed":
                 # Move HEAD and clear staging
                 if current_branch:
                     repo.refs.set_branch_commit(current_branch, commit_hash)
                 else:
                     repo.refs.set_head_detached(commit_hash)
-                
+
                 # Keep staged files but mark them as unstaged
                 # (In a full implementation, we'd restore the tree state)
                 print(f"HEAD is now at {commit_hash[:8]}")
                 print("Staged changes have been unstaged.")
-            
-            elif mode == 'hard':
+
+            elif mode == "hard":
                 # Move HEAD, clear staging, and restore working tree
                 repo.checkout(commit_hash, force=True)
                 print(f"HEAD is now at {commit_hash[:8]}")
                 print("Working tree has been reset.")
-            
+
             return 0
-        
+
         except Exception as e:
             print(f"Error during reset: {e}")
             return 1

memvcs/commands/resolve.py

@@ -0,0 +1,130 @@
+"""
+agmem resolve - Structured conflict resolution.
+
+Resolve merge conflicts with ours/theirs/both choices; record in audit.
+"""
+
+import argparse
+import json
+from pathlib import Path
+from typing import Optional
+
+from ..commands.base import require_repo
+
+
+def _path_under_current(path_str: str, current_dir: Path) -> Optional[Path]:
+    """Resolve path under current_dir; return None if it escapes (path traversal)."""
+    try:
+        full = (current_dir / path_str).resolve()
+        full.relative_to(current_dir.resolve())
+        return full
+    except (ValueError, RuntimeError):
+        return None
+
+
+def _resolved_content(choice: str, ours: str, theirs: str) -> str:
+    """Return content for choice: ours, theirs, or both (merged)."""
+    if choice == "ours":
+        return ours
+    if choice == "theirs":
+        return theirs
+    return ours.rstrip() + "\n\n--- merged ---\n\n" + theirs
+
+
+class ResolveCommand:
+    """Resolve merge conflicts interactively (ours/theirs/both)."""
+
+    name = "resolve"
+    help = "Resolve merge conflicts (ours / theirs / both)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "path",
+            nargs="?",
+            help="Conflict path to resolve (or resolve all if omitted)",
+        )
+        parser.add_argument(
+            "--ours",
+            action="store_true",
+            help="Resolve with our version",
+        )
+        parser.add_argument(
+            "--theirs",
+            action="store_true",
+            help="Resolve with their version",
+        )
+        parser.add_argument(
+            "--both",
+            action="store_true",
+            help="Keep both (append theirs after ours with separator)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        merge_dir = repo.mem_dir / "merge"
+        conflicts_file = merge_dir / "conflicts.json"
+        if not conflicts_file.exists():
+            print("No unresolved conflicts.")
+            return 0
+
+        try:
+            conflicts = json.loads(conflicts_file.read_text())
+        except Exception:
+            print("Could not read conflicts file.")
+            return 1
+
+        if not conflicts:
+            print("No unresolved conflicts.")
+            conflicts_file.unlink(missing_ok=True)
+            return 0
+
+        choice = None
+        if args.ours:
+            choice = "ours"
+        elif args.theirs:
+            choice = "theirs"
+        elif args.both:
+            choice = "both"
+
+        resolved = 0
+        remaining = []
+        for c in conflicts:
+            path = c.get("path", "")
+            if args.path and path != args.path:
+                remaining.append(c)
+                continue
+            if choice is None:
+                print(f"Conflict: {path}")
+                print("  Use: agmem resolve <path> --ours | --theirs | --both")
+                remaining.append(c)
+                continue
+            ours_content = c.get("ours_content") or ""
+            theirs_content = c.get("theirs_content") or ""
+            full_path = _path_under_current(path, repo.current_dir)
+            if full_path is None:
+                print(f"Error: Conflict path escapes repository: {path}")
+                remaining.append(c)
+                continue
+            content = _resolved_content(choice, ours_content, theirs_content)
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+            full_path.write_text(content, encoding="utf-8")
+            resolved += 1
+            try:
+                from ..core.audit import append_audit
+
+                append_audit(repo.mem_dir, "resolve", {"path": path, "choice": choice})
+            except Exception:
+                pass
+
+        if remaining:
+            conflicts_file.write_text(json.dumps(remaining, indent=2))
+        else:
+            conflicts_file.unlink(missing_ok=True)
+        if resolved:
+            print(f"Resolved {resolved} conflict(s). Stage and commit to complete.")
+        return 0