agmem 0.1.1__py3-none-any.whl

memvcs/commands/commit.py

@@ -0,0 +1,174 @@
+"""
+agmem commit - Save staged changes as a snapshot.
+"""
+
+import argparse
+from datetime import datetime
+
+from ..commands.base import require_repo
+from ..core.schema import SchemaValidator
+from ..core.hooks import run_pre_commit_hooks
+
+
+class CommitCommand:
+    """Create a commit from staged changes."""
+    
+    name = 'commit'
+    help = 'Save staged changes as a memory snapshot'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            '-m', '--message',
+            required=True,
+            help='Commit message describing the changes'
+        )
+        parser.add_argument(
+            '--author',
+            help='Override default author'
+        )
+        parser.add_argument(
+            '--no-verify',
+            action='store_true',
+            help='Skip pre-commit hooks and schema validation'
+        )
+        parser.add_argument(
+            '--strict',
+            action='store_true',
+            help='Treat schema warnings as errors'
+        )
+        parser.add_argument(
+            '--run-tests',
+            action='store_true',
+            help='Run memory tests before committing'
+        )
+    
+    @staticmethod
+    def _get_blob_hash(file_info) -> str:
+        """Get blob hash from StagedFile or dict (for hooks that pass either)."""
+        if hasattr(file_info, 'blob_hash'):
+            return file_info.blob_hash
+        if isinstance(file_info, dict):
+            return file_info.get('blob_hash') or file_info.get('hash') or ''
+        return ''
+
+    @staticmethod
+    def _validate_staged_files(repo, staged: dict, strict: bool) -> tuple:
+        """
+        Validate staged files for schema compliance.
+        
+        Returns:
+            Tuple of (success, validation_results)
+        """
+        validation_results = {}
+        has_errors = False
+        
+        for filepath, file_info in staged.items():
+            blob_hash = CommitCommand._get_blob_hash(file_info)
+            if not blob_hash:
+                continue
+            
+            # Read content from object store
+            from ..core.objects import Blob
+            blob = Blob.load(repo.object_store, blob_hash)
+            if not blob:
+                continue
+            
+            try:
+                content = blob.content.decode('utf-8')
+            except UnicodeDecodeError:
+                # Skip binary files
+                continue
+            
+            # Validate the file
+            result = SchemaValidator.validate(content, filepath, strict=strict)
+            validation_results[filepath] = result
+            
+            if not result.valid:
+                has_errors = True
+        
+        return not has_errors, validation_results
+    
+    @staticmethod
+    def _print_validation_results(results: dict) -> None:
+        """Print validation results in a readable format."""
+        for filepath, result in results.items():
+            if not result.valid or result.warnings:
+                print(f"\n  {filepath}:")
+                for error in result.errors:
+                    print(f"    ✗ {error.field}: {error.message}")
+                for warning in result.warnings:
+                    print(f"    ⚠ {warning.field}: {warning.message}")
+
+    @staticmethod
+    def _run_hooks_and_validation(repo, staged: dict, args) -> tuple:
+        """Run pre-commit hooks and schema validation. Returns (success, error_code or 0)."""
+        hook_result = run_pre_commit_hooks(repo, staged)
+        if not hook_result.success:
+            print("Pre-commit hook failed:")
+            for error in hook_result.errors:
+                print(f"  ✗ {error}")
+            print("\nUse --no-verify to bypass hooks (not recommended).")
+            return False, 1
+        valid, results = CommitCommand._validate_staged_files(repo, staged, strict=args.strict)
+        if not valid:
+            print("Schema validation failed:")
+            CommitCommand._print_validation_results(results)
+            print("\nFix the errors above or use --no-verify to bypass validation.")
+            return False, 1
+        if any(r.warnings for r in results.values()):
+            print("Schema validation warnings:")
+            CommitCommand._print_validation_results(results)
+        return True, 0
+
+    @staticmethod
+    def _run_memory_tests(repo) -> int:
+        """Run memory tests if available. Returns 1 on failure, 0 on success or skip."""
+        try:
+            from ..core.test_runner import TestRunner
+            test_runner = TestRunner(repo)
+            test_result = test_runner.run_all()
+            if not test_result.passed:
+                print("Memory tests failed:")
+                for failure in test_result.failures:
+                    print(f"  ✗ {failure.test_name}: {failure.message}")
+                print("\nFix failing tests before committing.")
+                return 1
+            print(f"Memory tests passed: {test_result.passed_count}/{test_result.total_count}")
+        except ImportError:
+            print("Warning: Test runner not available. Skipping tests.")
+        return 0
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+        staged = repo.staging.get_staged_files()
+        if not staged:
+            print("Error: No changes staged for commit.")
+            print("Run 'agmem add <file>' to stage changes first.")
+            return 1
+        if not args.no_verify:
+            ok, err = CommitCommand._run_hooks_and_validation(repo, staged, args)
+            if not ok:
+                return err
+        if args.run_tests:
+            if CommitCommand._run_memory_tests(repo) != 0:
+                return 1
+        metadata = {
+            'files_changed': len(staged),
+            'timestamp': datetime.utcnow().isoformat() + 'Z'
+        }
+        if args.author:
+            config = repo.get_config()
+            config['author']['name'] = args.author
+            repo.set_config(config)
+        try:
+            commit_hash = repo.commit(args.message, metadata)
+            print(f"[{repo.refs.get_current_branch() or 'HEAD'} {commit_hash[:8]}] {args.message}")
+            print(f"  {len(staged)} file(s) changed")
+            return 0
+        except Exception as e:
+            print(f"Error creating commit: {e}")
+            return 1

memvcs/commands/daemon.py

@@ -0,0 +1,267 @@
+"""
+agmem daemon - Auto-sync daemon for automatic commits.
+"""
+
+import argparse
+import os
+import sys
+import time
+import signal
+from pathlib import Path
+
+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'
+    
+    @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)'
+        )
+        parser.add_argument(
+            '--debounce',
+            type=int,
+            default=30,
+            help='Seconds to wait after changes before committing (default: 30)'
+        )
+        parser.add_argument(
+            '--pidfile',
+            help='PID file path (default: .mem/daemon.pid)'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+        
+        if args.pidfile:
+            pid_file = Path(args.pidfile).resolve()
+            try:
+                pid_file.relative_to(repo.root.resolve())
+            except ValueError:
+                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':
+            return DaemonCommand._stop(pid_file)
+        elif args.action == 'status':
+            return DaemonCommand._status(pid_file)
+        elif args.action == 'run':
+            return DaemonCommand._run(repo, args.debounce)
+        
+        return 1
+    
+    @staticmethod
+    def _start(repo, pid_file: Path, debounce: int) -> int:
+        """Start daemon in background."""
+        # Check if already running
+        if pid_file.exists():
+            pid = int(pid_file.read_text().strip())
+            try:
+                os.kill(pid, 0)
+                print(f"Daemon already running (PID: {pid})")
+                return 1
+            except OSError:
+                pid_file.unlink()
+        
+        # Fork to background (Unix only)
+        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()
+            if pid > 0:
+                # Parent exits
+                print(f"Daemon started (PID: {pid})")
+                return 0
+        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()
+            if pid > 0:
+                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)
+    
+    @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})")
+            pid_file.unlink()
+            return 0
+        except OSError as e:
+            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})")
+            return 0
+        except OSError:
+            print("Daemon is not running (stale PID file)")
+            pid_file.unlink()
+            return 0
+    
+    @staticmethod
+    def _run(repo, debounce: int, pid_file: Path = None) -> int:
+        """Run daemon in foreground."""
+        try:
+            from watchdog.observers import Observer
+            from watchdog.events import FileSystemEventHandler
+        except ImportError:
+            print("Daemon requires watchdog. Install with: pip install agmem[daemon]")
+            return 1
+        
+        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:
+                    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)
+                        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'):
+                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):
+                    try:
+                        rel_path = memory_file.relative_to(current_dir)
+                    except ValueError:
+                        continue
+                    rel_str = str(rel_path)
+                    if repo._path_under_current_dir(rel_str) is None:
+                        continue
+                    try:
+                        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}
+            )
+            
+            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.write_text(f"Auto-commit failed: {e}")
+            print(f"Warning: Auto-commit failed, wrote CONFLICT.lock: {e}")

memvcs/commands/diff.py

@@ -0,0 +1,157 @@
+"""
+agmem diff - Show changes between commits, commit and working tree, etc.
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.diff import DiffEngine
+from ..core.repository import Repository
+
+
+class DiffCommand:
+    """Show differences between commits."""
+    
+    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(
+            '--cached', '--staged',
+            action='store_true',
+            help='Show changes staged for commit'
+        )
+        parser.add_argument(
+            '--stat',
+            action='store_true',
+            help='Show diffstat instead of full diff'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        engine = DiffEngine(repo.object_store)
+        
+        # Determine what to diff
+        if args.cached:
+            # Diff staged changes against HEAD
+            head_commit = repo.get_head_commit()
+            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'))
+            return 0
+        
+        # Diff between two refs
+        if args.ref1 and args.ref2:
+            commit1 = repo.resolve_ref(args.ref1)
+            commit2 = repo.resolve_ref(args.ref2)
+            
+            if not commit1:
+                print(f"Error: Unknown revision: {args.ref1}")
+                return 1
+            if not commit2:
+                print(f"Error: Unknown revision: {args.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))
+            
+            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('.')]
+                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'))
+            
+            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('.')]
+            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
+        )
+        
+        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'))
+        
+        return 0