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

memvcs/commands/daemon.py

@@ -14,34 +14,34 @@ from ..commands.base import require_repo
 
 class DaemonCommand:
     """Control the auto-sync daemon."""
-    
-    name = 'daemon'
-    help = 'Start/stop the auto-sync daemon for automatic commits'
-    
+
+    name = "daemon"
+    help = "Start/stop the auto-sync daemon for automatic commits"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
         parser.add_argument(
-            'action',
-            choices=['start', 'stop', 'status', 'run'],
-            help='Daemon action: start, stop, status, or run (foreground)'
+            "action",
+            choices=["start", "stop", "status", "run"],
+            help="Daemon action: start, stop, status, or run (foreground)",
         )
         parser.add_argument(
-            '--debounce',
+            "--debounce",
             type=int,
             default=30,
-            help='Seconds to wait after changes before committing (default: 30)'
+            help="Seconds to wait after changes before committing (default: 30)",
         )
+        parser.add_argument("--pidfile", help="PID file path (default: .mem/daemon.pid)")
         parser.add_argument(
-            '--pidfile',
-            help='PID file path (default: .mem/daemon.pid)'
+            "--distill", action="store_true", help="Run distillation pipeline nightly (with daemon)"
         )
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
         if code != 0:
             return code
-        
+
         if args.pidfile:
             pid_file = Path(args.pidfile).resolve()
             try:
@@ -50,21 +50,21 @@ class DaemonCommand:
                 print("Error: --pidfile must be under repository root")
                 return 1
         else:
-            pid_file = repo.root / '.mem' / 'daemon.pid'
-        
-        if args.action == 'start':
-            return DaemonCommand._start(repo, pid_file, args.debounce)
-        elif args.action == 'stop':
+            pid_file = repo.root / ".mem" / "daemon.pid"
+
+        if args.action == "start":
+            return DaemonCommand._start(repo, pid_file, args.debounce, args.distill)
+        elif args.action == "stop":
             return DaemonCommand._stop(pid_file)
-        elif args.action == 'status':
+        elif args.action == "status":
             return DaemonCommand._status(pid_file)
-        elif args.action == 'run':
-            return DaemonCommand._run(repo, args.debounce)
-        
+        elif args.action == "run":
+            return DaemonCommand._run(repo, args.debounce, pid_file=pid_file, distill=args.distill)
+
         return 1
-    
+
     @staticmethod
-    def _start(repo, pid_file: Path, debounce: int) -> int:
+    def _start(repo, pid_file: Path, debounce: int, distill: bool = False) -> int:
         """Start daemon in background."""
         # Check if already running
         if pid_file.exists():
@@ -75,13 +75,13 @@ class DaemonCommand:
                 return 1
             except OSError:
                 pid_file.unlink()
-        
+
         # Fork to background (Unix only)
-        if os.name != 'posix':
+        if os.name != "posix":
             print("Background daemon not supported on this platform.")
             print("Use 'agmem daemon run' to run in foreground.")
             return 1
-        
+
         # First fork
         try:
             pid = os.fork()
@@ -92,11 +92,11 @@ class DaemonCommand:
         except OSError as e:
             print(f"Fork failed: {e}")
             return 1
-        
+
         # Decouple from parent
         os.setsid()
         os.umask(0)
-        
+
         # Second fork
         try:
             pid = os.fork()
@@ -104,26 +104,26 @@ class DaemonCommand:
                 sys.exit(0)
         except OSError:
             sys.exit(1)
-        
+
         # Write PID file
         pid_file.write_text(str(os.getpid()))
-        
+
         # Redirect stdio
         sys.stdout.flush()
         sys.stderr.flush()
-        
-        # Run daemon
-        return DaemonCommand._run(repo, debounce, pid_file)
-    
+
+        # Run daemon in background
+        return DaemonCommand._run(repo, debounce, pid_file, distill)
+
     @staticmethod
     def _stop(pid_file: Path) -> int:
         """Stop running daemon."""
         if not pid_file.exists():
             print("No daemon running")
             return 0
-        
+
         pid = int(pid_file.read_text().strip())
-        
+
         try:
             os.kill(pid, signal.SIGTERM)
             print(f"Stopped daemon (PID: {pid})")
@@ -133,16 +133,16 @@ class DaemonCommand:
             print(f"Could not stop daemon: {e}")
             pid_file.unlink()
             return 1
-    
+
     @staticmethod
     def _status(pid_file: Path) -> int:
         """Show daemon status."""
         if not pid_file.exists():
             print("Daemon is not running")
             return 0
-        
+
         pid = int(pid_file.read_text().strip())
-        
+
         try:
             os.kill(pid, 0)
             print(f"Daemon is running (PID: {pid})")
@@ -151,9 +151,9 @@ class DaemonCommand:
             print("Daemon is not running (stale PID file)")
             pid_file.unlink()
             return 0
-    
+
     @staticmethod
-    def _run(repo, debounce: int, pid_file: Path = None) -> int:
+    def _run(repo, debounce: int, pid_file: Path = None, distill: bool = False) -> int:
         """Run daemon in foreground."""
         try:
             from watchdog.observers import Observer
@@ -161,84 +161,92 @@ class DaemonCommand:
         except ImportError:
             print("Daemon requires watchdog. Install with: pip install agmem[daemon]")
             return 1
-        
-        current_dir = repo.root / 'current'
-        
+
+        current_dir = repo.root / "current"
+
         if not current_dir.exists():
             print("No current/ directory to watch")
             return 1
-        
+
         class MemoryFileHandler(FileSystemEventHandler):
             def __init__(self):
                 self.last_change = 0
                 self.pending = False
-            
+
             def on_any_event(self, event):
                 # Ignore .mem and hidden files
-                if '.mem' in event.src_path or '/.' in event.src_path:
+                if ".mem" in event.src_path or "/." in event.src_path:
                     return
-                
+
                 # Ignore directories
                 if event.is_directory:
                     return
-                
+
                 self.last_change = time.time()
                 self.pending = True
-        
+
         handler = MemoryFileHandler()
         observer = Observer()
         observer.schedule(handler, str(current_dir), recursive=True)
         observer.start()
-        
+
         print(f"Watching {current_dir} (debounce: {debounce}s)")
         print("Press Ctrl+C to stop")
-        
+
         # Handle signals
         running = True
-        
+
         def signal_handler(signum, frame):
             nonlocal running
             running = False
-        
+
         signal.signal(signal.SIGTERM, signal_handler)
         signal.signal(signal.SIGINT, signal_handler)
-        
+
         try:
             while running:
                 time.sleep(1)
-                
+
                 if handler.pending:
                     elapsed = time.time() - handler.last_change
                     if elapsed >= debounce:
                         # Auto-commit
                         DaemonCommand._auto_commit(repo)
+                        if distill:
+                            try:
+                                from ..core.distiller import Distiller, DistillerConfig
+
+                                d = Distiller(repo, DistillerConfig(create_safety_branch=False))
+                                d.run()
+                            except Exception:
+                                pass
                         handler.pending = False
         finally:
             observer.stop()
             observer.join()
-            
+
             if pid_file and pid_file.exists():
                 pid_file.unlink()
-        
+
         print("Daemon stopped")
         return 0
-    
+
     @staticmethod
     def _auto_commit(repo):
         """Perform automatic commit."""
         from datetime import datetime
-        
+
         try:
             # Check for changes
             status = repo.get_status()
-            
-            if not status.get('modified') and not status.get('untracked'):
+
+            if not status.get("modified") and not status.get("untracked"):
                 return
-            
+
             # Stage all changes in current/ (validate path stays under current/)
-            current_dir = repo.root / 'current'
-            for memory_file in current_dir.glob('**/*'):
-                if memory_file.is_file() and '.mem' not in str(memory_file):
+            current_dir = repo.root / "current"
+            for memory_file in current_dir.glob("**/*"):
+                if memory_file.is_file() and ".mem" not in str(memory_file):
                     try:
                         rel_path = memory_file.relative_to(current_dir)
                     except ValueError:
@@ -250,18 +258,15 @@ class DaemonCommand:
                         repo.stage_file(rel_str)
                     except Exception:
                         pass
-            
+
             # Commit
-            timestamp = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
-            repo.commit(
-                f"auto: update memory state ({timestamp})",
-                {'auto_commit': True}
-            )
-            
+            timestamp = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+            repo.commit(f"auto: update memory state ({timestamp})", {"auto_commit": True})
+
             print(f"[{timestamp}] Auto-committed changes")
-        
+
         except Exception as e:
             # Write conflict lock if there's an issue
-            conflict_file = repo.root / '.mem' / 'CONFLICT.lock'
+            conflict_file = repo.root / ".mem" / "CONFLICT.lock"
             conflict_file.write_text(f"Auto-commit failed: {e}")
             print(f"Warning: Auto-commit failed, wrote CONFLICT.lock: {e}")

memvcs/commands/decay.py

@@ -0,0 +1,77 @@
+"""
+agmem decay - Memory decay and forgetting.
+
+Archives low-importance, rarely-accessed memories.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.decay import DecayEngine, DecayConfig
+
+
+class DecayCommand:
+    """Memory decay - archive low-importance memories."""
+
+    name = "decay"
+    help = "Archive low-importance, old episodic memories (decay/forgetting)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Preview what would be archived without making changes",
+        )
+        parser.add_argument(
+            "--apply",
+            action="store_true",
+            help="Actually archive the memories",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        config = DecayConfig()
+        repo_config = repo.get_config()
+        decay_cfg = repo_config.get("decay", {})
+        if decay_cfg:
+            config.episodic_half_life_days = decay_cfg.get(
+                "episodic_half_life_days", config.episodic_half_life_days
+            )
+            config.semantic_min_importance = decay_cfg.get(
+                "semantic_min_importance", config.semantic_min_importance
+            )
+            config.access_count_threshold = decay_cfg.get(
+                "access_count_threshold", config.access_count_threshold
+            )
+
+        engine = DecayEngine(repo, config)
+        candidates = engine.get_decay_candidates()
+
+        if not candidates:
+            print("No memories eligible for decay.")
+            return 0
+
+        print(f"Found {len(candidates)} memory(ies) eligible for decay:")
+        for c in candidates[:20]:
+            print(f"  - {c.path} (score: {c.decay_score:.2f}) - {c.reason}")
+        if len(candidates) > 20:
+            print(f"  ... and {len(candidates) - 20} more")
+
+        if args.dry_run:
+            print("\nDry run - no changes made. Use --apply to archive.")
+            return 0
+
+        if not args.apply:
+            print("\nUse --apply to archive these memories.")
+            return 0
+
+        count = engine.apply_decay(candidates)
+        print(f"\nArchived {count} memory(ies) to .mem/forgetting/")
+        print("Use 'agmem resurrect <path>' to restore.")
+        return 0

memvcs/commands/diff.py

@@ -13,33 +13,35 @@ from ..core.repository import Repository
 
 class DiffCommand:
     """Show differences between commits."""
-    
-    name = 'diff'
-    help = 'Show changes between commits, commit and working tree, etc.'
-    
+
+    name = "diff"
+    help = "Show changes between commits, commit and working tree, etc."
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument("ref1", nargs="?", help="First commit/branch to compare")
+        parser.add_argument("ref2", nargs="?", help="Second commit/branch to compare")
         parser.add_argument(
-            'ref1',
-            nargs='?',
-            help='First commit/branch to compare'
+            "--cached", "--staged", action="store_true", help="Show changes staged for commit"
         )
         parser.add_argument(
-            'ref2',
-            nargs='?',
-            help='Second commit/branch to compare'
+            "--stat", action="store_true", help="Show diffstat instead of full diff"
         )
         parser.add_argument(
-            '--cached', '--staged',
-            action='store_true',
-            help='Show changes staged for commit'
+            "--from",
+            "--from-ref",
+            dest="from_ref",
+            metavar="REF",
+            help="Start ref for diff (supports ISO dates)",
         )
         parser.add_argument(
-            '--stat',
-            action='store_true',
-            help='Show diffstat instead of full diff'
+            "--to",
+            "--to-ref",
+            dest="to_ref",
+            metavar="REF",
+            help="End ref for diff (supports ISO dates)",
         )
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
@@ -47,7 +49,7 @@ class DiffCommand:
             return code
 
         engine = DiffEngine(repo.object_store)
-        
+
         # Determine what to diff
         if args.cached:
             # Diff staged changes against HEAD
@@ -55,103 +57,100 @@ class DiffCommand:
             if not head_commit:
                 print("No commits yet. Nothing to diff.")
                 return 0
-            
+
             staged_files = repo.staging.get_staged_files()
             if not staged_files:
                 print("No staged changes.")
                 return 0
-            
+
             # Get staged content
             working_files = {}
             for path, sf in staged_files.items():
                 from ..core.objects import Blob
+
                 blob = Blob.load(repo.object_store, sf.blob_hash)
                 if blob:
                     working_files[path] = blob.content
-            
-            tree_diff = engine.diff_working_dir(
-                head_commit.store(repo.object_store),
-                working_files
-            )
-            
-            print(engine.format_diff(tree_diff, 'HEAD', 'staged'))
+
+            tree_diff = engine.diff_working_dir(head_commit.store(repo.object_store), working_files)
+
+            print(engine.format_diff(tree_diff, "HEAD", "staged"))
             return 0
-        
-        # Diff between two refs
-        if args.ref1 and args.ref2:
-            commit1 = repo.resolve_ref(args.ref1)
-            commit2 = repo.resolve_ref(args.ref2)
-            
+
+        # Diff between two refs (--from/--to override ref1/ref2)
+        ref1 = getattr(args, "from_ref", None) or args.ref1
+        ref2 = getattr(args, "to_ref", None) or args.ref2
+        if ref1 and ref2:
+            commit1 = repo.resolve_ref(ref1)
+            commit2 = repo.resolve_ref(ref2)
+
             if not commit1:
-                print(f"Error: Unknown revision: {args.ref1}")
+                print(f"Error: Unknown revision: {ref1}")
                 return 1
             if not commit2:
-                print(f"Error: Unknown revision: {args.ref2}")
+                print(f"Error: Unknown revision: {ref2}")
                 return 1
-            
+
             tree_diff = engine.diff_commits(commit1, commit2)
-            
+
             if args.stat:
                 print(f" {tree_diff.added_count} file(s) added")
                 print(f" {tree_diff.deleted_count} file(s) deleted")
                 print(f" {tree_diff.modified_count} file(s) modified")
             else:
-                print(engine.format_diff(tree_diff, args.ref1, args.ref2))
-            
+                print(engine.format_diff(tree_diff, ref1, ref2))
+
             return 0
-        
+
         # Diff working tree against a ref
         if args.ref1:
             commit_hash = repo.resolve_ref(args.ref1)
             if not commit_hash:
                 print(f"Error: Unknown revision: {args.ref1}")
                 return 1
-            
+
             # Get working directory files
             working_files = {}
             for root, dirs, files in os.walk(repo.current_dir):
-                dirs[:] = [d for d in dirs if not d.startswith('.')]
+                dirs[:] = [d for d in dirs if not d.startswith(".")]
                 for filename in files:
                     full_path = Path(root) / filename
                     rel_path = str(full_path.relative_to(repo.current_dir))
                     working_files[rel_path] = full_path.read_bytes()
-            
+
             tree_diff = engine.diff_working_dir(commit_hash, working_files)
-            
+
             if args.stat:
                 print(f" {tree_diff.added_count} file(s) added")
                 print(f" {tree_diff.deleted_count} file(s) deleted")
                 print(f" {tree_diff.modified_count} file(s) modified")
             else:
-                print(engine.format_diff(tree_diff, args.ref1, 'working'))
-            
+                print(engine.format_diff(tree_diff, args.ref1, "working"))
+
             return 0
-        
+
         # Default: diff working tree against HEAD
         head_commit = repo.get_head_commit()
         if not head_commit:
             print("No commits yet. Nothing to diff.")
             return 0
-        
+
         # Get working directory files
         working_files = {}
         for root, dirs, files in os.walk(repo.current_dir):
-            dirs[:] = [d for d in dirs if not d.startswith('.')]
+            dirs[:] = [d for d in dirs if not d.startswith(".")]
             for filename in files:
                 full_path = Path(root) / filename
                 rel_path = str(full_path.relative_to(repo.current_dir))
                 working_files[rel_path] = full_path.read_bytes()
-        
-        tree_diff = engine.diff_working_dir(
-            head_commit.store(repo.object_store),
-            working_files
-        )
-        
+
+        tree_diff = engine.diff_working_dir(head_commit.store(repo.object_store), working_files)
+
         if args.stat:
             print(f" {tree_diff.added_count} file(s) added")
             print(f" {tree_diff.deleted_count} file(s) deleted")
             print(f" {tree_diff.modified_count} file(s) modified")
         else:
-            print(engine.format_diff(tree_diff, 'HEAD', 'working'))
-        
+            print(engine.format_diff(tree_diff, "HEAD", "working"))
+
         return 0

memvcs/commands/distill.py

@@ -0,0 +1,74 @@
+"""
+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",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        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