agmem 0.1.1__py3-none-any.whl

memvcs/commands/blame.py

@@ -0,0 +1,169 @@
+"""
+agmem blame - Show who changed each line (Git-like) or trace semantic facts.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.repository import Repository
+from ..core.objects import Commit, Tree, Blob
+
+
+class BlameCommand:
+    """Show author and commit for each line of a file, or trace semantic facts."""
+    
+    name = 'blame'
+    help = 'Show who changed each line of a memory file, or trace semantic facts'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            'file',
+            nargs='?',
+            help='File to blame (path relative to current/)'
+        )
+        parser.add_argument(
+            'ref',
+            nargs='?',
+            default='HEAD',
+            help='Commit to blame at (default: HEAD)'
+        )
+        parser.add_argument(
+            '--query', '-q',
+            help='Semantic query to trace (e.g., "Why does agent think X?")'
+        )
+        parser.add_argument(
+            '--limit', '-n',
+            type=int,
+            default=5,
+            help='Number of results to show for semantic blame (default: 5)'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+        
+        # Semantic blame mode
+        if args.query:
+            return BlameCommand._semantic_blame(repo, args.query, args.limit)
+        
+        # File blame mode
+        if not args.file:
+            print("Error: Either --query or a file path is required.")
+            print("Usage: agmem blame <file> [ref]")
+            print("       agmem blame --query \"Why does agent think X?\"")
+            return 1
+        
+        return BlameCommand._file_blame(repo, args.file, args.ref)
+    
+    @staticmethod
+    def _file_blame(repo, filepath: str, ref: str) -> int:
+        """Traditional file-based blame."""
+        commit_hash = repo.resolve_ref(ref)
+        if not commit_hash:
+            print(f"Error: Unknown revision: {ref}")
+            return 1
+        
+        # Get file content at commit
+        tree = repo.get_commit_tree(commit_hash)
+        if not tree:
+            print("Error: Could not load tree.")
+            return 1
+        
+        # Find file in tree (support path like semantic/user-prefs.md)
+        blob_hash = None
+        for entry in tree.entries:
+            path = entry.path + '/' + entry.name if entry.path else entry.name
+            if path == filepath:
+                blob_hash = entry.hash
+                break
+        
+        if not blob_hash:
+            print(f"Error: File not found in {ref}: {filepath}")
+            return 1
+        
+        blob = Blob.load(repo.object_store, blob_hash)
+        if not blob:
+            print("Error: Could not load file content.")
+            return 1
+        
+        lines = blob.content.decode('utf-8', errors='replace').splitlines()
+        commit = Commit.load(repo.object_store, commit_hash)
+        author_short = commit.author.split('<')[0].strip()[:20] if commit else 'unknown'
+        hash_short = commit_hash[:8]
+        
+        for i, line in enumerate(lines, 1):
+            print(f"{hash_short} ({author_short:20} {i:4}) {line}")
+        
+        return 0
+    
+    @staticmethod
+    def _semantic_blame(repo, query: str, limit: int) -> int:
+        """
+        Semantic blame - trace which commit introduced a fact.
+        
+        Searches the vector store and shows provenance for matching chunks.
+        """
+        try:
+            from ..core.vector_store import VectorStore
+        except ImportError:
+            print("Error: Vector search requires sqlite-vec.")
+            print("Install with: pip install agmem[vector]")
+            return 1
+        
+        try:
+            vs = VectorStore(repo.root / '.mem')
+            results = vs.search_with_provenance(query, limit=limit)
+        except Exception as e:
+            print(f"Error: Vector search failed: {e}")
+            print("Try running 'agmem search --rebuild' to rebuild the index.")
+            return 1
+        
+        if not results:
+            print("No matching facts found in memory.")
+            print("Try rebuilding the index with 'agmem search --rebuild'")
+            return 0
+        
+        print(f"Semantic blame for: \"{query}\"")
+        print("=" * 60)
+        
+        for i, result in enumerate(results, 1):
+            path = result['path']
+            content = result['content']
+            similarity = result['similarity']
+            commit_hash = result['commit_hash']
+            author = result['author']
+            indexed_at = result['indexed_at']
+            
+            print(f"\n[{i}] {path}")
+            print(f"    Similarity: {similarity:.2%}")
+            
+            if commit_hash:
+                # Try to get commit details
+                commit = Commit.load(repo.object_store, commit_hash)
+                if commit:
+                    print(f"    Commit: {commit_hash[:8]}")
+                    print(f"    Author: {commit.author}")
+                    print(f"    Date: {commit.timestamp}")
+                    print(f"    Message: {commit.message}")
+                else:
+                    print(f"    Commit: {commit_hash[:8]} (details unavailable)")
+                    if author:
+                        print(f"    Author: {author}")
+            else:
+                print("    Commit: (not tracked)")
+                if indexed_at:
+                    print(f"    Indexed: {indexed_at}")
+            
+            # Show content preview
+            print(f"\n    Content preview:")
+            for line in content.split('\n')[:5]:
+                print(f"      {line[:70]}")
+            if len(content.split('\n')) > 5:
+                print("      ...")
+        
+        print()
+        return 0

memvcs/commands/branch.py

@@ -0,0 +1,110 @@
+"""
+agmem branch - List, create, or delete branches.
+"""
+
+import argparse
+
+from ..commands.base import require_repo
+from ..core.repository import Repository
+
+
+class BranchCommand:
+    """Manage branches."""
+    
+    name = 'branch'
+    help = 'List, create, or delete branches'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            'name',
+            nargs='?',
+            help='Branch name to create or delete'
+        )
+        parser.add_argument(
+            '--delete', '-d',
+            action='store_true',
+            help='Delete a branch'
+        )
+        parser.add_argument(
+            '--force', '-D',
+            action='store_true',
+            help='Force delete a branch (even if not merged)'
+        )
+        parser.add_argument(
+            '--list', '-l',
+            action='store_true',
+            help='List all branches'
+        )
+        parser.add_argument(
+            '--all', '-a',
+            action='store_true',
+            help='List all branches including remote'
+        )
+        parser.add_argument(
+            'start_point',
+            nargs='?',
+            help='Commit to start the new branch from'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        if args.list or (not args.name and not args.delete):
+            return BranchCommand._list_branches(repo)
+
+        if args.delete or args.force:
+            if not args.name:
+                print("Error: Branch name required for deletion")
+                return 1
+            
+            current = repo.refs.get_current_branch()
+            if args.name == current:
+                print(f"Error: Cannot delete current branch '{args.name}'")
+                print("Switch to another branch first.")
+                return 1
+            
+            if repo.refs.delete_branch(args.name):
+                print(f"Deleted branch {args.name}")
+                return 0
+            print(f"Error: Branch '{args.name}' not found")
+            return 1
+
+        if args.name:
+            if repo.refs.branch_exists(args.name):
+                print(f"Error: A branch named '{args.name}' already exists.")
+                return 1
+
+            start_commit = None
+            if args.start_point:
+                start_commit = repo.resolve_ref(args.start_point)
+                if not start_commit:
+                    print(f"Error: Not a valid object name: '{args.start_point}'")
+                    return 1
+
+            if repo.refs.create_branch(args.name, start_commit):
+                print(f"Created branch {args.name}")
+                head = repo.refs.get_head()
+                if head.get("type") == "branch":
+                    print(f"  (based on {head['value']})")
+                return 0
+            print(f"Error: Could not create branch '{args.name}'")
+            return 1
+
+        return 0
+
+    @staticmethod
+    def _list_branches(repo) -> int:
+        """List all branches with current branch marked."""
+        branches = repo.refs.list_branches()
+        current = repo.refs.get_current_branch()
+        if not branches:
+            print("No branches yet.")
+            return 0
+        for branch in branches:
+            prefix = "* " if branch == current else "  "
+            print(f"{prefix}{branch}")
+        return 0

memvcs/commands/checkout.py

@@ -0,0 +1,101 @@
+"""
+agmem checkout - Switch branches or restore files.
+"""
+
+import argparse
+
+from ..commands.base import require_repo
+from ..core.repository import Repository
+
+
+class CheckoutCommand:
+    """Switch branches or restore working tree files."""
+    
+    name = 'checkout'
+    help = 'Switch branches or restore working tree files'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            'ref',
+            help='Branch, tag, or commit to checkout'
+        )
+        parser.add_argument(
+            '-b',
+            action='store_true',
+            help='Create and checkout a new branch'
+        )
+        parser.add_argument(
+            '--force', '-f',
+            action='store_true',
+            help='Force checkout (discard local changes)'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        # Create and checkout new branch
+        if args.b:
+            branch_name = args.ref
+            
+            # Check if branch already exists
+            if repo.refs.branch_exists(branch_name):
+                print(f"Error: A branch named '{branch_name}' already exists.")
+                return 1
+            
+            # Get current HEAD commit
+            head = repo.refs.get_head()
+            if head['type'] == 'branch':
+                current_commit = repo.refs.get_branch_commit(head['value'])
+            else:
+                current_commit = head['value']
+            
+            # Create branch
+            if not repo.refs.create_branch(branch_name, current_commit):
+                print(f"Error: Could not create branch '{branch_name}'")
+                return 1
+            
+            # Switch to new branch
+            try:
+                repo.refs.set_head_branch(branch_name)
+                print(f"Switched to a new branch '{branch_name}'")
+                return 0
+            except Exception as e:
+                print(f"Error switching to branch: {e}")
+                return 1
+        
+        # Regular checkout
+        ref = args.ref
+        
+        # Check if it's a branch
+        is_branch = repo.refs.branch_exists(ref)
+        
+        try:
+            commit_hash = repo.checkout(ref, force=args.force)
+            
+            if is_branch:
+                print(f"Switched to branch '{ref}'")
+            else:
+                # Check if it's a tag
+                if repo.refs.tag_exists(ref):
+                    print(f"Note: checking out '{ref}'.")
+                    print()
+                    print("You are in 'detached HEAD' state. You can look around, make experimental")
+                    print("changes and commit them, and you can discard any commits you make in this")
+                    print("state without impacting any branches by switching back to a branch.")
+                else:
+                    print(f"Note: checking out '{commit_hash[:8]}'.")
+                    print()
+                    print("You are in 'detached HEAD' state.")
+            
+            return 0
+        
+        except ValueError as e:
+            print(f"Error: {e}")
+            return 1
+        except Exception as e:
+            print(f"Error during checkout: {e}")
+            return 1

memvcs/commands/clean.py

@@ -0,0 +1,76 @@
+"""
+agmem clean - Remove untracked files (Git-like).
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.repository import Repository
+
+
+class CleanCommand:
+    """Remove untracked files from working directory."""
+    
+    name = 'clean'
+    help = 'Remove untracked files from working directory'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            '-n', '--dry-run',
+            action='store_true',
+            help='Show what would be removed without removing'
+        )
+        parser.add_argument(
+            '-f', '--force',
+            action='store_true',
+            help='Required to actually remove files'
+        )
+        parser.add_argument(
+            '-d',
+            action='store_true',
+            help='Remove untracked directories too'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        
+        status = repo.get_status()
+        untracked = status.get('untracked', [])
+        
+        if not untracked:
+            print("Nothing to clean.")
+            return 0
+        
+        if args.dry_run:
+            print("Would remove:")
+            for p in untracked:
+                print(f"  {p}")
+            return 0
+        
+        if not args.force:
+            print("Use -f to force removal of untracked files.")
+            return 1
+        
+        removed = 0
+        for rel_path in untracked:
+            full_path = repo.current_dir / rel_path
+            if full_path.exists():
+                if full_path.is_file():
+                    full_path.unlink()
+                    removed += 1
+                    print(f"Removed {rel_path}")
+                elif args.d and full_path.is_dir():
+                    import shutil
+                    shutil.rmtree(full_path)
+                    removed += 1
+                    print(f"Removed {rel_path}/")
+        
+        print(f"Removed {removed} file(s)")
+        return 0

memvcs/commands/clone.py

@@ -0,0 +1,91 @@
+"""
+agmem clone - Clone a remote memory repository.
+"""
+
+import argparse
+import shutil
+from pathlib import Path
+
+from memvcs.core.constants import MEMORY_TYPES
+
+
+class CloneCommand:
+    """Clone a remote agmem repository."""
+
+    name = "clone"
+    help = "Clone a memory repository from a remote (file:// URL)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "url",
+            help="Remote URL (e.g. file:///path/to/remote-repo)",
+        )
+        parser.add_argument(
+            "directory",
+            nargs="?",
+            help="Local directory to clone into (default: infer from remote)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        from memvcs.core.remote import parse_remote_url
+        from memvcs.core.repository import Repository
+
+        url = args.url
+        if not url:
+            print("Error: URL required")
+            return 1
+
+        try:
+            remote_path = parse_remote_url(url)
+        except ValueError as e:
+            print(f"Error: {e}")
+            return 1
+
+        remote_mem = remote_path / ".mem"
+        if not remote_mem.exists():
+            print(f"Error: Not an agmem repository: {remote_path}")
+            return 1
+
+        # Target directory (validate relative paths to avoid path traversal)
+        cwd = Path.cwd().resolve()
+        if args.directory:
+            p = Path(args.directory)
+            target = p.resolve()
+            if not p.is_absolute():
+                try:
+                    target.relative_to(cwd)
+                except ValueError:
+                    print("Error: Target path escapes current directory")
+                    return 1
+        else:
+            target = cwd / remote_path.name
+
+        if target.exists() and any(target.iterdir()):
+            print(f"Error: Directory not empty: {target}")
+            return 1
+
+        target.mkdir(parents=True, exist_ok=True)
+
+        # Copy .mem and current from remote
+        shutil.copytree(remote_mem, target / ".mem")
+        remote_current = remote_path / "current"
+        if remote_current.exists():
+            shutil.copytree(remote_current, target / "current")
+        else:
+            (target / "current").mkdir(parents=True)
+            for mem_type in MEMORY_TYPES:
+                (target / "current" / mem_type).mkdir(exist_ok=True)
+
+        # Set remote origin to source
+        import json
+        config_file = target / ".mem" / "config.json"
+        config = json.loads(config_file.read_text()) if config_file.exists() else {}
+        if "remotes" not in config:
+            config["remotes"] = {}
+        config["remotes"]["origin"] = {"url": url if url.startswith("file://") else f"file://{remote_path}"}
+        config_file.write_text(json.dumps(config, indent=2))
+
+        print(f"Cloned into {target}")
+        return 0