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

memvcs/commands/distill.py

@@ -0,0 +1,90 @@
+"""
+agmem distill - Episodic-to-semantic distillation pipeline.
+
+Converts session logs into compact facts (memory consolidation).
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.distiller import Distiller, DistillerConfig, DistillerResult
+
+
+class DistillCommand:
+    """Episodic-to-semantic distillation."""
+
+    name = "distill"
+    help = "Convert episodic logs into semantic facts (memory consolidation)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--source",
+            "-s",
+            default="episodic",
+            help="Source directory (default: episodic)",
+        )
+        parser.add_argument(
+            "--target",
+            "-t",
+            default="semantic/consolidated",
+            help="Target directory (default: semantic/consolidated)",
+        )
+        parser.add_argument(
+            "--model",
+            "-m",
+            help="LLM model for extraction (e.g., gpt-4)",
+        )
+        parser.add_argument(
+            "--no-branch",
+            action="store_true",
+            help="Do not create safety branch",
+        )
+        parser.add_argument(
+            "--private",
+            action="store_true",
+            help="Use differential privacy (spend epsilon from budget)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        if getattr(args, "private", False):
+            from ..core.privacy_budget import load_budget, spend_epsilon
+
+            spent, max_eps, _ = 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
+            if spent + epsilon_cost > max_eps * 0.8:
+                print(f"Privacy budget low: {spent + epsilon_cost:.2f}/{max_eps}")
+
+        config = DistillerConfig(
+            source_dir=args.source,
+            target_dir=args.target,
+            create_safety_branch=not args.no_branch,
+        )
+        distiller = Distiller(repo, config)
+
+        result = distiller.run(
+            source=args.source,
+            target=args.target,
+            model=args.model,
+        )
+
+        print(f"Distiller completed:")
+        print(f"  Clusters processed: {result.clusters_processed}")
+        print(f"  Facts extracted: {result.facts_extracted}")
+        print(f"  Episodes archived: {result.episodes_archived}")
+        if result.branch_created:
+            print(f"  Branch created: {result.branch_created}")
+        if result.commit_hash:
+            print(f"  Commit: {result.commit_hash[:8]}")
+        print(f"\n{result.message}")
+
+        return 0 if result.success else 1

memvcs/commands/federated.py

@@ -0,0 +1,53 @@
+"""
+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"])
+            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

@@ -10,44 +10,39 @@ from ..commands.base import require_repo
 
 class FsckCommand:
     """Check and repair repository consistency."""
-    
-    name = 'fsck'
-    help = 'Check and repair repository consistency (remove dangling vectors)'
-    
+
+    name = "fsck"
+    help = "Check and repair repository consistency (remove dangling vectors)"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
         parser.add_argument(
-            '--dry-run',
-            action='store_true',
-            help='Show what would be done without making changes'
-        )
-        parser.add_argument(
-            '--verbose', '-v',
-            action='store_true',
-            help='Show detailed output'
+            "--dry-run", action="store_true", help="Show what would be done without making changes"
         )
+        parser.add_argument("--verbose", "-v", action="store_true", help="Show detailed output")
         parser.add_argument(
-            '--fix',
-            action='store_true',
-            help='Actually remove dangling entries (required to make changes)'
+            "--fix",
+            action="store_true",
+            help="Actually remove dangling entries (required to make changes)",
         )
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
         if code != 0:
             return code
-        
+
         print("Running file system consistency check...")
-        
+
         issues_found = 0
         issues_fixed = 0
-        
+
         # Check vector store for dangling entries
         try:
             from ..core.vector_store import VectorStore
-            vs = VectorStore(repo.root / '.mem')
-            
+
+            vs = VectorStore(repo.root / ".mem")
+
             vector_issues, vector_fixed = FsckCommand._check_vectors(
                 repo, vs, args.dry_run, args.verbose, args.fix
             )
@@ -58,64 +53,66 @@ class FsckCommand:
                 print("Vector store not available, skipping vector check")
         except Exception as e:
             print(f"Warning: Vector store check failed: {e}")
-        
+
         # Check object store integrity
         obj_issues, obj_fixed = FsckCommand._check_objects(
             repo, args.dry_run, args.verbose, args.fix
         )
         issues_found += obj_issues
         issues_fixed += obj_fixed
-        
+
         # Check refs integrity
-        ref_issues, ref_fixed = FsckCommand._check_refs(
-            repo, args.dry_run, args.verbose, args.fix
-        )
+        ref_issues, ref_fixed = FsckCommand._check_refs(repo, args.dry_run, args.verbose, args.fix)
         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)
         print("FSCK Summary")
         print("=" * 40)
         print(f"Issues found: {issues_found}")
-        
+
         if args.fix:
             print(f"Issues fixed: {issues_fixed}")
         elif issues_found > 0:
             print("\nRun with --fix to repair issues")
-        
+
         if issues_found == 0:
             print("Repository is healthy!")
-        
+
         return 0 if issues_found == 0 else 1
-    
+
     @staticmethod
     def _check_vectors(repo, vs, dry_run: bool, verbose: bool, fix: bool) -> tuple:
         """Check for dangling vector entries."""
         print("\nChecking vector store...")
-        
-        current_dir = repo.root / 'current'
+
+        current_dir = repo.root / "current"
         entries = vs.get_all_entries()
-        
+
         dangling = []
-        
+
         for entry in entries:
-            path = entry['path']
+            path = entry["path"]
             full_path = current_dir / path
-            
+
             if not full_path.exists():
                 dangling.append(entry)
                 if verbose:
                     print(f"  Dangling: {path} (rowid: {entry['rowid']})")
-        
+
         if dangling:
             print(f"  Found {len(dangling)} dangling vector entries")
-            
+
             if fix and not dry_run:
                 fixed = 0
                 for entry in dangling:
-                    if vs.delete_entry(entry['rowid']):
+                    if vs.delete_entry(entry["rowid"]):
                         fixed += 1
                 print(f"  Removed {fixed} dangling entries")
                 return len(dangling), fixed
@@ -123,22 +120,22 @@ class FsckCommand:
                 print("  (dry-run: no changes made)")
         else:
             print("  Vector store is consistent")
-        
+
         return len(dangling), 0
-    
+
     @staticmethod
     def _check_objects(repo, dry_run: bool, verbose: bool, fix: bool) -> tuple:
         """Check object store integrity."""
         print("\nChecking object store...")
-        
+
         issues = 0
-        
+
         # Check if all referenced blobs exist
-        for obj_type in ['blob', 'tree', 'commit', 'tag']:
-            obj_dir = repo.root / '.mem' / 'objects' / obj_type
+        for obj_type in ["blob", "tree", "commit", "tag"]:
+            obj_dir = repo.root / ".mem" / "objects" / obj_type
             if not obj_dir.exists():
                 continue
-            
+
             for prefix_dir in obj_dir.iterdir():
                 if not prefix_dir.is_dir():
                     continue
@@ -146,6 +143,7 @@ class FsckCommand:
                     try:
                         # Try to read and decompress
                         import zlib
+
                         compressed = obj_file.read_bytes()
                         zlib.decompress(compressed)
                     except Exception as e:
@@ -153,51 +151,78 @@ class FsckCommand:
                         if verbose:
                             hash_id = prefix_dir.name + obj_file.name
                             print(f"  Corrupted {obj_type}: {hash_id[:8]}...")
-        
+
         if issues == 0:
             print("  Object store is consistent")
         else:
             print(f"  Found {issues} corrupted objects")
-        
+
         return issues, 0  # Object repair not implemented
-    
+
     @staticmethod
     def _check_refs(repo, dry_run: bool, verbose: bool, fix: bool) -> tuple:
         """Check refs integrity."""
         print("\nChecking refs...")
-        
+
         issues = 0
-        
+
         # Check if HEAD points to valid commit
         head = repo.refs.get_head()
-        if head['type'] == 'branch':
-            branch_commit = repo.refs.get_branch_commit(head['value'])
+        if head["type"] == "branch":
+            branch_commit = repo.refs.get_branch_commit(head["value"])
             if not branch_commit:
                 issues += 1
                 if verbose:
                     print(f"  HEAD branch '{head['value']}' has no commit")
-            elif not repo.object_store.exists(branch_commit, 'commit'):
+            elif not repo.object_store.exists(branch_commit, "commit"):
                 issues += 1
                 if verbose:
                     print(f"  HEAD points to missing commit: {branch_commit[:8]}")
-        elif head['type'] == 'detached':
-            if not repo.object_store.exists(head['value'], 'commit'):
+        elif head["type"] == "detached":
+            if not repo.object_store.exists(head["value"], "commit"):
                 issues += 1
                 if verbose:
                     print(f"  Detached HEAD points to missing commit")
-        
+
         # Check all branches
         branches = repo.refs.list_branches()
         for branch in branches:
             commit_hash = repo.refs.get_branch_commit(branch)
-            if commit_hash and not repo.object_store.exists(commit_hash, 'commit'):
+            if commit_hash and not repo.object_store.exists(commit_hash, "commit"):
                 issues += 1
                 if verbose:
                     print(f"  Branch '{branch}' points to missing commit")
-        
+
         if issues == 0:
             print("  Refs are consistent")
         else:
             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

@@ -10,96 +10,101 @@ from ..core.gardener import Gardener, GardenerConfig
 
 class GardenCommand:
     """Run the Gardener reflection loop."""
-    
-    name = 'garden'
-    help = 'Synthesize episodic memories into semantic insights'
-    
+
+    name = "garden"
+    help = "Synthesize episodic memories into semantic insights"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
         parser.add_argument(
-            '--force',
-            action='store_true',
-            help='Run even if episode threshold not met'
+            "--force", action="store_true", help="Run even if episode threshold not met"
         )
         parser.add_argument(
-            '--threshold',
+            "--threshold",
             type=int,
             default=50,
-            help='Number of episodes before auto-triggering (default: 50)'
+            help="Number of episodes before auto-triggering (default: 50)",
         )
         parser.add_argument(
-            '--dry-run',
-            action='store_true',
-            help='Show what would be done without making changes'
+            "--dry-run", action="store_true", help="Show what would be done without making changes"
         )
         parser.add_argument(
-            '--no-commit',
-            action='store_true',
-            help='Do not auto-commit generated insights'
+            "--no-commit", action="store_true", help="Do not auto-commit generated insights"
         )
         parser.add_argument(
-            '--llm',
-            choices=['openai', 'none'],
-            default='none',
-            help='LLM provider for summarization (default: none)'
+            "--llm",
+            choices=["openai", "none"],
+            default="none",
+            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(
-            '--model',
-            help='LLM model to use (e.g., gpt-3.5-turbo)'
+            "--private",
+            action="store_true",
+            help="Use differential privacy (spend epsilon from budget)",
         )
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
         if code != 0:
             return code
-        
+
+        if getattr(args, "private", False):
+            from ..core.privacy_budget import load_budget, spend_epsilon
+
+            spent, max_eps, _ = 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
+
         # 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
+            llm_provider=args.llm if args.llm != "none" else None,
+            llm_model=args.model,
         )
-        
+
         # Create gardener
         gardener = Gardener(repo, config)
-        
+
         # Show status
         episode_count = gardener.get_episode_count()
         print(f"Episodic files: {episode_count}/{config.threshold}")
-        
+
         if args.dry_run:
             if gardener.should_run() or args.force:
                 episodes = gardener.load_episodes()
                 clusters = gardener.cluster_episodes(episodes)
-                
+
                 print(f"\nWould process {len(episodes)} episodes into {len(clusters)} clusters:")
                 for cluster in clusters:
                     print(f"  - {cluster.topic}: {len(cluster.episodes)} episodes")
-                
+
                 print("\nRun without --dry-run to execute.")
             else:
                 print("\nThreshold not met. Use --force to run anyway.")
             return 0
-        
+
         # Run gardener
         if not gardener.should_run() and not args.force:
             print("\nThreshold not met. Use --force to run anyway.")
             return 0
-        
+
         print("\nRunning Gardener...")
         result = gardener.run(force=args.force)
-        
+
         if result.success:
             print(f"\nGardener completed:")
             print(f"  Clusters found: {result.clusters_found}")
             print(f"  Insights generated: {result.insights_generated}")
             print(f"  Episodes archived: {result.episodes_archived}")
-            
+
             if result.commit_hash:
                 print(f"  Commit: {result.commit_hash[:8]}")
-            
+
             print(f"\n{result.message}")
             return 0
         else:

memvcs/commands/gc.py

@@ -0,0 +1,51 @@
+"""
+agmem gc - Garbage collection.
+
+Remove unreachable objects; optionally repack.
+"""
+
+import argparse
+
+from ..commands.base import require_repo
+from ..core.pack import run_gc
+
+
+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)",
+        )
+
+    @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).")
+        return 0