agmem 0.1.1__py3-none-any.whl

memvcs/commands/merge.py

@@ -0,0 +1,88 @@
+"""
+agmem merge - Join two or more development histories together.
+"""
+
+import argparse
+
+from ..commands.base import require_repo
+from ..core.merge import MergeEngine
+from ..core.repository import Repository
+
+
+class MergeCommand:
+    """Merge branches."""
+    
+    name = 'merge'
+    help = 'Join two or more development histories together'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            'branch',
+            help='Branch to merge into current branch'
+        )
+        parser.add_argument(
+            '-m', '--message',
+            help='Merge commit message'
+        )
+        parser.add_argument(
+            '--no-commit',
+            action='store_true',
+            help='Perform merge but do not commit'
+        )
+        parser.add_argument(
+            '--abort',
+            action='store_true',
+            help='Abort the current merge'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        # Abort merge
+        if args.abort:
+            # TODO: Implement merge abort
+            print("Merge abort not yet implemented")
+            return 0
+        
+        # Check if we're on a branch
+        current_branch = repo.refs.get_current_branch()
+        if not current_branch:
+            print("Error: Not currently on any branch.")
+            print("Cannot merge when HEAD is detached.")
+            return 1
+        
+        # Check if trying to merge current branch
+        if args.branch == current_branch:
+            print(f"Error: Cannot merge '{args.branch}' into itself")
+            return 1
+        
+        # Check if branch exists
+        if not repo.refs.branch_exists(args.branch):
+            print(f"Error: Branch '{args.branch}' not found.")
+            return 1
+        
+        # Perform merge
+        engine = MergeEngine(repo)
+        result = engine.merge(args.branch, message=args.message)
+        
+        if result.success:
+            print(f"Merge successful: {result.message}")
+            if result.commit_hash:
+                print(f"  Commit: {result.commit_hash[:8]}")
+            return 0
+        else:
+            print(f"Merge failed: {result.message}")
+            
+            if result.conflicts:
+                print()
+                print("Conflicts:")
+                for conflict in result.conflicts:
+                    print(f"  {conflict.path}")
+                print()
+                print("Resolve conflicts and run 'agmem commit' to complete the merge.")
+            
+            return 1

memvcs/commands/pull.py

@@ -0,0 +1,65 @@
+"""
+agmem pull - Pull memory from remote.
+"""
+
+import argparse
+from pathlib import Path
+
+
+class PullCommand:
+    """Pull memory from remote repository."""
+
+    name = "pull"
+    help = "Pull memory from remote repository"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "remote",
+            nargs="?",
+            default="origin",
+            help="Remote name (default: origin)",
+        )
+        parser.add_argument(
+            "branch",
+            nargs="?",
+            help="Branch to pull (default: all)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        from memvcs.commands.base import require_repo
+        from memvcs.core.remote import Remote
+
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        remote = Remote(repo.root, args.remote)
+        if not remote.get_remote_url():
+            print(f"Error: Remote '{args.remote}' has no URL. Set with: agmem remote add {args.remote} <url>")
+            return 1
+
+        try:
+            msg = remote.fetch(branch=args.branch)
+            print(msg)
+            # Merge fetched refs into current branch
+            current_branch = repo.refs.get_current_branch()
+            if current_branch is not None:
+                remote_ref = f"{args.remote}/{current_branch}"
+                remote_hash = repo.resolve_ref(remote_ref)
+                if remote_hash:
+                    from memvcs.core.merge import MergeEngine
+                    merge_engine = MergeEngine(repo)
+                    try:
+                        result = merge_engine.merge(remote_ref)
+                        if result.success:
+                            print(f"Merged {remote_ref} into {current_branch}.")
+                        else:
+                            print("Merge had conflicts. Resolve and commit.")
+                    except Exception as e:
+                        print(f"Merge note: {e}")
+            return 0
+        except ValueError as e:
+            print(f"Error: {e}")
+            return 1

memvcs/commands/push.py

@@ -0,0 +1,143 @@
+"""
+agmem push - Push memory to remote with auto-rebase support.
+"""
+
+import argparse
+from pathlib import Path
+
+
+class MemoryConflictError(Exception):
+    """Exception raised when push fails due to conflicts."""
+    pass
+
+
+class PushCommand:
+    """Push memory repository to remote with auto-rebase."""
+
+    name = "push"
+    help = "Push memory to remote repository"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "remote",
+            nargs="?",
+            default="origin",
+            help="Remote name (default: origin)",
+        )
+        parser.add_argument(
+            "branch",
+            nargs="?",
+            help="Branch to push (default: current)",
+        )
+        parser.add_argument(
+            "--force", "-f",
+            action="store_true",
+            help="Force push (WARNING: may overwrite remote changes)",
+        )
+        parser.add_argument(
+            "--no-rebase",
+            action="store_true",
+            help="Don't attempt auto-rebase on conflicts",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        from memvcs.commands.base import require_repo
+        from memvcs.core.remote import Remote
+        from memvcs.core.merge import MergeEngine
+
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        remote = Remote(repo.root, args.remote)
+        remote_url = remote.get_remote_url()
+        
+        if not remote_url:
+            print(f"Error: Remote '{args.remote}' has no URL.")
+            print(f"Set with: agmem remote add {args.remote} <url>")
+            return 1
+
+        # Get current branch
+        branch = args.branch or repo.refs.get_current_branch()
+        if not branch:
+            print("Error: Not on a branch and no branch specified")
+            return 1
+
+        # Force push warning
+        if args.force:
+            print("WARNING: Force push may overwrite remote changes!")
+            local_hash = repo.refs.get_branch_commit(branch)
+            try:
+                msg = remote.push(branch=branch)
+                print(msg)
+                return 0
+            except ValueError as e:
+                print(f"Error: {e}")
+                return 1
+
+        # Auto-rebase workflow
+        if not args.no_rebase:
+            # Fetch remote state
+            try:
+                print(f"Fetching from {args.remote}...")
+                remote.fetch()
+            except Exception as e:
+                print(f"Note: Could not fetch remote ({e}), attempting direct push...")
+
+            # Check if we're behind remote
+            local_hash = repo.refs.get_branch_commit(branch)
+            remote_branch = f"{args.remote}/{branch}"
+            remote_hash = repo.resolve_ref(remote_branch)
+
+            if remote_hash and remote_hash != local_hash:
+                # Check if we can fast-forward or need rebase
+                merge_engine = MergeEngine(repo)
+                ancestor = merge_engine.find_common_ancestor(local_hash, remote_hash)
+
+                if ancestor == local_hash:
+                    # We're behind - need to pull first
+                    print("Local is behind remote. Pull first with: agmem pull")
+                    return 1
+
+                elif ancestor != remote_hash:
+                    # Diverged - need to merge/rebase
+                    print("Local and remote have diverged.")
+                    print("Attempting auto-merge...")
+
+                    try:
+                        result = merge_engine.merge(remote_branch)
+
+                        if result.success:
+                            print(f"Auto-merged with {remote_branch}")
+                            # Update local hash after merge
+                            local_hash = repo.refs.get_branch_commit(branch)
+                        else:
+                            print("Auto-merge failed with conflicts:")
+                            for conflict in result.conflicts:
+                                print(f"  - {conflict.path}")
+                            print("\nResolve conflicts, commit, and try again.")
+                            print("Or use --force to overwrite (not recommended).")
+                            raise MemoryConflictError(result.message)
+
+                    except MemoryConflictError:
+                        return 1
+                    except Exception as e:
+                        print(f"Merge failed: {e}")
+                        print("Use --no-rebase to skip auto-merge or --force to overwrite")
+                        return 1
+
+        # Push
+        try:
+            msg = remote.push(branch=branch)
+            print(msg)
+            return 0
+        except ValueError as e:
+            error_msg = str(e)
+            if "non-fast-forward" in error_msg.lower() or "rejected" in error_msg.lower():
+                print("Push rejected: remote has changes you don't have.")
+                print("Run 'agmem pull' first, or use --force to overwrite.")
+                return 1
+            print(f"Error: {e}")
+            return 1

memvcs/commands/reflog.py

@@ -0,0 +1,52 @@
+"""
+agmem reflog - Show reference history (Git-like).
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.repository import Repository
+
+
+class ReflogCommand:
+    """Show reflog - history of HEAD changes."""
+    
+    name = 'reflog'
+    help = 'Show reference log (history of HEAD changes)'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            'ref',
+            nargs='?',
+            default='HEAD',
+            help='Reference to show log for'
+        )
+        parser.add_argument(
+            '-n', '--max-count',
+            type=int,
+            default=20,
+            help='Maximum number of entries'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        
+        entries = repo.refs.get_reflog(args.ref, args.max_count)
+        
+        if not entries:
+            print("No reflog entries found.")
+            return 0
+        
+        for e in entries:
+            h = e['hash'][:8]
+            ts = e.get('timestamp', '')[:19]
+            msg = e.get('message', '')
+            print(f"{h} {ts} {msg}")
+        
+        return 0

memvcs/commands/remote.py

@@ -0,0 +1,51 @@
+"""
+agmem remote - Manage remote URLs.
+"""
+
+import argparse
+from pathlib import Path
+
+
+class RemoteCommand:
+    """Manage remote repository URLs."""
+
+    name = "remote"
+    help = "Manage remote URLs (add, set-url, show)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        subparsers = parser.add_subparsers(dest="remote_action", required=True)
+        add_p = subparsers.add_parser("add", help="Add a remote")
+        add_p.add_argument("name", help="Remote name (e.g. origin)")
+        add_p.add_argument("url", help="Remote URL (e.g. file:///path)")
+        set_p = subparsers.add_parser("set-url", help="Set remote URL")
+        set_p.add_argument("name", help="Remote name")
+        set_p.add_argument("url", help="New URL")
+        subparsers.add_parser("show", help="Show remotes")
+
+    @staticmethod
+    def execute(args) -> int:
+        from memvcs.commands.base import require_repo
+        from memvcs.core.remote import Remote
+
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        remote = Remote(repo.root, getattr(args, "name", "origin"))
+
+        if args.remote_action == "add" or args.remote_action == "set-url":
+            r = Remote(repo.root, args.name)
+            r.set_remote_url(args.url)
+            print(f"Remote '{args.name}' set to {args.url}")
+        elif args.remote_action == "show":
+            import json
+            config = json.loads((repo.root / ".mem" / "config.json").read_text())
+            remotes = config.get("remotes", {})
+            if remotes:
+                for name, info in remotes.items():
+                    print(f"{name}\t{info.get('url', '')}")
+            else:
+                print("No remotes configured.")
+
+        return 0

memvcs/commands/reset.py

@@ -0,0 +1,98 @@
+"""
+agmem reset - Reset current HEAD to the specified state.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.repository import Repository
+
+
+class ResetCommand:
+    """Reset current HEAD to the specified state."""
+    
+    name = 'reset'
+    help = 'Reset current HEAD to the specified state'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            'commit',
+            nargs='?',
+            default='HEAD',
+            help='Commit to reset to (default: HEAD)'
+        )
+        parser.add_argument(
+            '--soft',
+            action='store_true',
+            help='Reset HEAD but keep staged changes'
+        )
+        parser.add_argument(
+            '--mixed',
+            action='store_true',
+            help='Reset HEAD and unstaged changes (default)'
+        )
+        parser.add_argument(
+            '--hard',
+            action='store_true',
+            help='Reset HEAD, index, and working tree'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        # Find repository
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        
+        # Determine mode
+        if args.soft:
+            mode = 'soft'
+        elif args.hard:
+            mode = 'hard'
+        else:
+            mode = 'mixed'
+        
+        # Resolve commit
+        commit_hash = repo.resolve_ref(args.commit)
+        if not commit_hash:
+            print(f"Error: Unknown revision: {args.commit}")
+            return 1
+        
+        # Get current branch
+        current_branch = repo.refs.get_current_branch()
+        
+        try:
+            if mode == 'soft':
+                # Just move HEAD
+                if current_branch:
+                    repo.refs.set_branch_commit(current_branch, commit_hash)
+                else:
+                    repo.refs.set_head_detached(commit_hash)
+                print(f"HEAD is now at {commit_hash[:8]}")
+            
+            elif mode == 'mixed':
+                # Move HEAD and clear staging
+                if current_branch:
+                    repo.refs.set_branch_commit(current_branch, commit_hash)
+                else:
+                    repo.refs.set_head_detached(commit_hash)
+                
+                # Keep staged files but mark them as unstaged
+                # (In a full implementation, we'd restore the tree state)
+                print(f"HEAD is now at {commit_hash[:8]}")
+                print("Staged changes have been unstaged.")
+            
+            elif mode == 'hard':
+                # Move HEAD, clear staging, and restore working tree
+                repo.checkout(commit_hash, force=True)
+                print(f"HEAD is now at {commit_hash[:8]}")
+                print("Working tree has been reset.")
+            
+            return 0
+        
+        except Exception as e:
+            print(f"Error during reset: {e}")
+            return 1

memvcs/commands/search.py

@@ -0,0 +1,163 @@
+"""
+agmem search - Semantic search over memory.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def _is_vector_unavailable_error(exc: Exception) -> bool:
+    """True if the exception indicates vector deps are missing (fall back to text search)."""
+    msg = str(exc).lower()
+    return any(
+        key in msg for key in ("sqlite-vec", "sentence-transformers", "vector search")
+    )
+
+
+def _first_line_containing(content: str, query: str, max_len: int = 200) -> str:
+    """Return the first line that contains query (lowercased), trimmed to max_len, or empty string."""
+    for line in content.splitlines():
+        if query in line.lower():
+            return line.strip()[:max_len]
+    return ""
+
+
+class SearchCommand:
+    """Semantic search over memory files."""
+
+    name = "search"
+    help = "Search memory (semantic with agmem[vector], else plain text)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "query",
+            nargs="?",
+            default="",
+            help="Search query for semantic search",
+        )
+        parser.add_argument(
+            "--limit", "-n",
+            type=int,
+            default=10,
+            help="Maximum results to return (default: 10)",
+        )
+        parser.add_argument(
+            "--rebuild",
+            action="store_true",
+            help="Rebuild vector index from current/ before searching",
+        )
+        parser.add_argument(
+            "--index-only",
+            action="store_true",
+            help="Only build/rebuild index, do not search",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        from memvcs.commands.base import require_repo
+        from memvcs.core.repository import Repository
+
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        try:
+            from memvcs.core.vector_store import VectorStore
+
+            store = VectorStore(repo.mem_dir)
+        except ImportError:
+            return SearchCommand._text_search(repo, args)
+
+        try:
+            if args.rebuild or args.index_only:
+                count = store.rebuild_index(repo.current_dir)
+                print(f"Indexed {count} file(s).")
+                if args.index_only:
+                    return 0
+
+            # Lazy index on first search if index is empty
+            if args.query and not store.db_path.exists():
+                print("Building index on first search...")
+                count = store.index_directory(repo.current_dir)
+                print(f"Indexed {count} file(s).\n")
+
+            if not args.query:
+                if not args.index_only:
+                    print("Usage: agmem search <query> [--limit N] [--rebuild]")
+                return 0
+
+            results = store.search(args.query, limit=args.limit)
+
+            if not results:
+                print(f"No results for '{args.query}'.")
+                print("Try --rebuild to index current/ files.")
+                return 0
+
+            for path, snippet, distance in results:
+                print(f"\n--- {path} (distance: {distance:.4f}) ---")
+                print(snippet)
+                print()
+
+            return 0
+        except Exception as e:
+            if _is_vector_unavailable_error(e):
+                return SearchCommand._text_search(repo, args)
+            print(f"Error: {e}", file=sys.stderr)
+            return 1
+        finally:
+            store.close()
+
+    @staticmethod
+    def _text_search(repo, args) -> int:
+        """Plain text search when vector store is not available."""
+        if args.index_only or args.rebuild:
+            print("Note: Install agmem[vector] for index/rebuild. Using plain text search.")
+        if not args.query:
+            print("Usage: agmem search <query> [--limit N]")
+            return 0
+
+        query_lower = args.query.lower()
+        results = []
+        current_dir = repo.current_dir
+        if not current_dir.exists():
+            print("No current/ directory.")
+            return 0
+
+        for ext in ("*.md", "*.txt"):
+            for f in current_dir.rglob(ext):
+                if not f.is_file():
+                    continue
+                try:
+                    content = f.read_text(encoding="utf-8", errors="replace")
+                except Exception:
+                    continue
+                if query_lower not in content.lower():
+                    continue
+                try:
+                    rel = str(f.relative_to(current_dir))
+                except ValueError:
+                    continue
+                # Snippet: line containing query
+                for line in content.splitlines():
+                    if query_lower in line.lower():
+                        snippet = line.strip()[:200]
+                        break
+                else:
+                    snippet = content[:200].strip()
+                results.append((rel, snippet, 0.0))
+                if len(results) >= args.limit:
+                    break
+            if len(results) >= args.limit:
+                break
+
+        if not results:
+            print(f"No results for '{args.query}'.")
+            return 0
+
+        for path, snippet, _ in results:
+            print(f"\n--- {path} ---")
+            print(snippet)
+            print()
+        return 0