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

memvcs/commands/federated.py

@@ -0,0 +1,59 @@
+"""
+agmem federated - Federated memory collaboration.
+
+Push local summaries to coordinator; pull merged summaries.
+"""
+
+import argparse
+
+from ..commands.base import require_repo
+from ..core.federated import get_federated_config, produce_local_summary, push_updates, pull_merged
+
+
+class FederatedCommand:
+    """Federated memory collaboration with coordinator."""
+
+    name = "federated"
+    help = "Push/pull federated summaries (coordinator must be configured)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "action",
+            choices=["push", "pull"],
+            help="Push local summary or pull merged from coordinator",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        cfg = get_federated_config(repo.root)
+        if not cfg:
+            print(
+                "Federated collaboration not enabled. Set federated.enabled and coordinator_url in config."
+            )
+            return 1
+
+        if args.action == "push":
+            summary = produce_local_summary(
+                repo.root,
+                cfg["memory_types"],
+                use_dp=cfg.get("use_dp", False),
+                dp_epsilon=cfg.get("dp_epsilon") or 0.1,
+                dp_delta=cfg.get("dp_delta") or 1e-5,
+            )
+            msg = push_updates(repo.root, summary)
+            print(msg)
+            return 0 if "Pushed" in msg else 1
+        else:
+            data = pull_merged(repo.root)
+            if data is None:
+                print("Pull failed or coordinator unavailable.")
+                return 1
+            print("Merged summary from coordinator:")
+            for k, v in (data or {}).items():
+                print(f"  {k}: {v}")
+            return 0

memvcs/commands/fsck.py

@@ -66,6 +66,10 @@ class FsckCommand:
         issues_found += ref_issues
         issues_fixed += ref_fixed
 
+        # Cryptographic verification (Merkle + signature)
+        crypto_issues = FsckCommand._check_crypto(repo, args.verbose)
+        issues_found += crypto_issues
+
         # Print summary
         print()
         print("=" * 40)
@@ -195,3 +199,30 @@ class FsckCommand:
             print(f"  Found {issues} ref issues")
 
         return issues, 0
+
+    @staticmethod
+    def _check_crypto(repo, verbose: bool) -> int:
+        """Verify Merkle/signature on branch tips. Returns number of issues."""
+        print("\nChecking commit signatures...")
+        try:
+            from ..core.crypto_verify import verify_commit, load_public_key
+        except ImportError:
+            if verbose:
+                print("  Crypto verification not available")
+            return 0
+        issues = 0
+        pub = load_public_key(repo.mem_dir)
+        for branch in repo.refs.list_branches():
+            ch = repo.refs.get_branch_commit(branch)
+            if not ch:
+                continue
+            ok, err = verify_commit(repo.object_store, ch, public_key_pem=pub, mem_dir=repo.mem_dir)
+            if not ok:
+                issues += 1
+                if verbose:
+                    print(f"  {branch} ({ch[:8]}): {err}")
+        if issues == 0:
+            print("  Commit signatures consistent")
+        else:
+            print(f"  Found {issues} commit(s) with verification issues")
+        return issues

memvcs/commands/garden.py

@@ -38,6 +38,11 @@ class GardenCommand:
             help="LLM provider for summarization (default: none)",
         )
         parser.add_argument("--model", help="LLM model to use (e.g., gpt-3.5-turbo)")
+        parser.add_argument(
+            "--private",
+            action="store_true",
+            help="Use differential privacy (spend epsilon from budget)",
+        )
 
     @staticmethod
     def execute(args) -> int:
@@ -45,12 +50,29 @@ class GardenCommand:
         if code != 0:
             return code
 
+        use_dp = getattr(args, "private", False)
+        dp_epsilon = None
+        dp_delta = None
+        if use_dp:
+            from ..core.privacy_budget import load_budget, spend_epsilon
+
+            spent, max_eps, delta = load_budget(repo.mem_dir)
+            epsilon_cost = 0.1
+            if not spend_epsilon(repo.mem_dir, epsilon_cost):
+                print(f"Privacy budget exceeded (spent {spent:.2f}, max {max_eps}).")
+                return 1
+            dp_epsilon = 0.05
+            dp_delta = delta
+
         # Build config
         config = GardenerConfig(
             threshold=args.threshold,
             auto_commit=not args.no_commit,
             llm_provider=args.llm if args.llm != "none" else None,
             llm_model=args.model,
+            use_dp=use_dp,
+            dp_epsilon=dp_epsilon,
+            dp_delta=dp_delta,
         )
 
         # Create gardener

memvcs/commands/gc.py

@@ -0,0 +1,66 @@
+"""
+agmem gc - Garbage collection.
+
+Remove unreachable objects; optionally repack.
+"""
+
+import argparse
+
+from ..commands.base import require_repo
+from ..core.pack import run_gc, run_repack
+
+
+class GcCommand:
+    """Garbage collect unreachable objects."""
+
+    name = "gc"
+    help = "Remove unreachable objects (garbage collection)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Report what would be removed without deleting",
+        )
+        parser.add_argument(
+            "--prune-days",
+            type=int,
+            default=90,
+            metavar="N",
+            help="Consider reflog entries within N days (default 90)",
+        )
+        parser.add_argument(
+            "--repack",
+            action="store_true",
+            help="After GC, pack reachable loose objects into a pack file",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        gc_prune_days = getattr(args, "prune_days", 90)
+        deleted, freed = run_gc(
+            repo.mem_dir,
+            repo.object_store,
+            gc_prune_days=gc_prune_days,
+            dry_run=args.dry_run,
+        )
+        if args.dry_run:
+            print(f"Would remove {deleted} unreachable object(s) ({freed} bytes).")
+        else:
+            print(f"Removed {deleted} unreachable object(s) ({freed} bytes reclaimed).")
+
+        if getattr(args, "repack", False) and not args.dry_run:
+            packed, repack_freed = run_repack(
+                repo.mem_dir,
+                repo.object_store,
+                gc_prune_days=gc_prune_days,
+                dry_run=False,
+            )
+            if packed > 0:
+                print(f"Packed {packed} object(s) into pack file ({repack_freed} bytes from loose).")
+        return 0

memvcs/commands/merge.py

@@ -23,6 +23,11 @@ class MergeCommand:
             "--no-commit", action="store_true", help="Perform merge but do not commit"
         )
         parser.add_argument("--abort", action="store_true", help="Abort the current merge")
+        parser.add_argument(
+            "--yes",
+            action="store_true",
+            help="Accept conditionally trusted branch commits without prompting",
+        )
 
     @staticmethod
     def execute(args) -> int:
@@ -53,6 +58,24 @@ class MergeCommand:
             print(f"Error: Branch '{args.branch}' not found.")
             return 1
 
+        # Trust check for branch tip (may be from another agent)
+        other_commit_hash = repo.refs.get_branch_commit(args.branch)
+        if other_commit_hash:
+            from ..core.objects import Commit
+            from ..core.trust import find_verifying_key, get_trust_level
+
+            other_commit = Commit.load(repo.object_store, other_commit_hash)
+            if other_commit and other_commit.metadata:
+                key_pem = find_verifying_key(repo.mem_dir, other_commit.metadata)
+                if key_pem is not None:
+                    level = get_trust_level(repo.mem_dir, key_pem)
+                    if level == "untrusted":
+                        print(f"Merge blocked: branch '{args.branch}' signed by untrusted key.")
+                        return 1
+                    if level == "conditional" and not getattr(args, "yes", False):
+                        print("Branch signed by conditionally trusted key. Use --yes to merge.")
+                        return 1
+
         # Perform merge
         engine = MergeEngine(repo)
         result = engine.merge(args.branch, message=args.message)
@@ -61,16 +84,47 @@ class MergeCommand:
             print(f"Merge successful: {result.message}")
             if result.commit_hash:
                 print(f"  Commit: {result.commit_hash[:8]}")
+            try:
+                from ..core.audit import append_audit
+
+                append_audit(
+                    repo.mem_dir, "merge", {"branch": args.branch, "commit": result.commit_hash}
+                )
+            except Exception:
+                pass
             return 0
         else:
             print(f"Merge failed: {result.message}")
 
             if result.conflicts:
+                # Persist conflicts for agmem resolve
+                try:
+                    import json
+
+                    merge_dir = repo.mem_dir / "merge"
+                    merge_dir.mkdir(parents=True, exist_ok=True)
+                    conflicts_data = [
+                        {
+                            "path": c.path,
+                            "message": c.message,
+                            "memory_type": getattr(c, "memory_type", None),
+                            "payload": getattr(c, "payload", None),
+                            "ours_content": c.ours_content,
+                            "theirs_content": c.theirs_content,
+                            "base_content": c.base_content,
+                        }
+                        for c in result.conflicts
+                    ]
+                    (merge_dir / "conflicts.json").write_text(json.dumps(conflicts_data, indent=2))
+                except Exception:
+                    pass
                 print()
                 print("Conflicts:")
                 for conflict in result.conflicts:
                     print(f"  {conflict.path}")
                 print()
-                print("Resolve conflicts and run 'agmem commit' to complete the merge.")
+                print(
+                    "Resolve conflicts with 'agmem resolve' or edit files and run 'agmem commit'."
+                )
 
             return 1

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, mem_dir=repo.mem_dir)
+
+        if not ok:
+            print("Proof generation failed (keyword not in file, or signing key not set for freshness).")
+            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:
@@ -51,6 +56,28 @@ 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)

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

memvcs/commands/timeline.py

@@ -28,6 +28,18 @@ class TimelineCommand:
             default=20,
             help="Max commits to show (default: 20)",
         )
+        parser.add_argument(
+            "--from",
+            dest="from_ts",
+            metavar="ISO",
+            help="Start of time range (ISO 8601, e.g. 2025-01-01)",
+        )
+        parser.add_argument(
+            "--to",
+            dest="to_ts",
+            metavar="ISO",
+            help="End of time range (ISO 8601)",
+        )
 
     @staticmethod
     def execute(args) -> int:
@@ -36,6 +48,17 @@ class TimelineCommand:
             return code
 
         filepath = args.file.replace("current/", "").lstrip("/")
+        from_ts = getattr(args, "from_ts", None)
+        to_ts = getattr(args, "to_ts", None)
+        commits_in_range = None
+        if from_ts and to_ts:
+            try:
+                from ..core.temporal_index import TemporalIndex
+                ti = TemporalIndex(repo.mem_dir, repo.object_store)
+                range_entries = ti.range_query(from_ts, to_ts)
+                commits_in_range = {ch for _, ch in range_entries}
+            except Exception:
+                pass
 
         # Walk commit history
         head = repo.refs.get_head()
@@ -51,6 +74,10 @@ class TimelineCommand:
             if commit_hash in seen:
                 break
             seen.add(commit_hash)
+            if commits_in_range is not None and commit_hash not in commits_in_range:
+                commit = Commit.load(repo.object_store, commit_hash)
+                commit_hash = commit.parents[0] if commit and commit.parents else None
+                continue
 
             commit = Commit.load(repo.object_store, commit_hash)
             if not commit: