agmem 0.1.1__py3-none-any.whl

memvcs/commands/serve.py

@@ -0,0 +1,54 @@
+"""
+agmem serve - Start web UI server for browsing history.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+
+class ServeCommand:
+    """Start the agmem web UI server."""
+
+    name = "serve"
+    help = "Start web UI for browsing memory history"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--port", "-p",
+            type=int,
+            default=8765,
+            help="Port to bind (default: 8765)",
+        )
+        parser.add_argument(
+            "--host",
+            default="127.0.0.1",
+            help="Host to bind (default: 127.0.0.1)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        try:
+            import uvicorn
+        except ImportError:
+            print(
+                "Error: Web UI requires fastapi and uvicorn. "
+                "Install with: pip install agmem[web]",
+                file=sys.stderr,
+            )
+            return 1
+
+        from memvcs.commands.base import require_repo
+        from memvcs.core.repository import Repository
+
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        from memvcs.integrations.web_ui.server import create_app
+
+        app = create_app(repo.root)
+        print(f"agmem Web UI: http://{args.host}:{args.port}")
+        uvicorn.run(app, host=args.host, port=args.port)
+        return 0

memvcs/commands/show.py

@@ -0,0 +1,125 @@
+"""
+agmem show - Show various types of objects.
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.objects import Blob, Commit, Tree
+from ..core.repository import Repository
+
+
+class ShowCommand:
+    """Show various types of objects."""
+    
+    name = 'show'
+    help = 'Show various types of objects'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            'object',
+            help='Object to show (commit, tree, blob, branch)'
+        )
+        parser.add_argument(
+            '--type', '-t',
+            choices=['commit', 'tree', 'blob', 'auto'],
+            default='auto',
+            help='Type of object to show'
+        )
+        parser.add_argument(
+            '--raw',
+            action='store_true',
+            help='Show raw object content'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        # Find repository
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        
+        obj_ref = args.object
+        obj_hash = None
+        obj_type = args.type
+        
+        # Try to resolve as reference
+        resolved = repo.resolve_ref(obj_ref)
+        if resolved:
+            obj_hash = resolved
+        else:
+            # Assume it's a hash
+            obj_hash = obj_ref
+        
+        # Try to determine type if auto
+        if obj_type == 'auto':
+            # Try commit first
+            commit = Commit.load(repo.object_store, obj_hash)
+            if commit:
+                obj_type = 'commit'
+            else:
+                # Try tree
+                tree = Tree.load(repo.object_store, obj_hash)
+                if tree:
+                    obj_type = 'tree'
+                else:
+                    # Try blob
+                    blob = Blob.load(repo.object_store, obj_hash)
+                    if blob:
+                        obj_type = 'blob'
+                    else:
+                        print(f"Error: Object not found: {obj_ref}")
+                        return 1
+        
+        # Display based on type
+        if obj_type == 'commit':
+            commit = Commit.load(repo.object_store, obj_hash)
+            if not commit:
+                print(f"Error: Commit not found: {obj_ref}")
+                return 1
+            
+            print(f"commit {obj_hash}")
+            print(f"Author: {commit.author}")
+            print(f"Date:   {commit.timestamp}")
+            print()
+            print(f"    {commit.message}")
+            print()
+            print(f"tree {commit.tree}")
+            if commit.parents:
+                print(f"parent {' '.join(commit.parents)}")
+        
+        elif obj_type == 'tree':
+            tree = Tree.load(repo.object_store, obj_hash)
+            if not tree:
+                print(f"Error: Tree not found: {obj_ref}")
+                return 1
+            
+            print(f"tree {obj_hash}")
+            print()
+            for entry in sorted(tree.entries, key=lambda e: e.name):
+                path = entry.path + '/' + entry.name if entry.path else entry.name
+                print(f"{entry.mode} {entry.type} {entry.hash[:8]}\t{path}")
+        
+        elif obj_type == 'blob':
+            blob = Blob.load(repo.object_store, obj_hash)
+            if not blob:
+                print(f"Error: Blob not found: {obj_ref}")
+                return 1
+            
+            if args.raw:
+                print(blob.content.decode('utf-8', errors='replace'))
+            else:
+                print(f"blob {obj_hash}")
+                print(f"Size: {len(blob.content)} bytes")
+                print()
+                content = blob.content.decode('utf-8', errors='replace')
+                if len(content) > 1000:
+                    print(content[:1000] + "\n... (truncated)")
+                else:
+                    print(content)
+        
+        return 0

memvcs/commands/stash.py

@@ -0,0 +1,97 @@
+"""
+agmem stash - Stash changes for later (Git-like).
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.repository import Repository
+
+
+class StashCommand:
+    """Stash working directory changes."""
+    
+    name = 'stash'
+    help = 'Stash changes for later (save work in progress)'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        subparsers = parser.add_subparsers(dest='stash_action', help='Stash action')
+        
+        # Default: list (when no subcommand given)
+        parser.set_defaults(stash_action='list')
+        
+        # stash (push)
+        push_p = subparsers.add_parser('push', help='Stash current changes')
+        push_p.add_argument('-m', '--message', default='', help='Stash message')
+        
+        # stash pop
+        subparsers.add_parser('pop', help='Apply and remove most recent stash')
+        
+        # stash list (default)
+        subparsers.add_parser('list', help='List stashes')
+        
+        # stash apply
+        apply_p = subparsers.add_parser('apply', help='Apply stash without removing')
+        apply_p.add_argument('stash_ref', nargs='?', default='stash@{0}', help='Stash reference')
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        
+        action = getattr(args, 'stash_action', None)
+        if action is None:
+            action = 'list'
+        
+        if action == 'push':
+            stash_hash = repo.stash_create(getattr(args, 'message', '') or '')
+            if stash_hash:
+                print(f"Stashed changes (stash@{0})")
+                return 0
+            else:
+                print("No local changes to stash.")
+                return 0
+        
+        elif action == 'pop':
+            stash_hash = repo.stash_pop(0)
+            if stash_hash:
+                print(f"Restored stashed changes")
+                return 0
+            else:
+                print("No stash entries found.")
+                return 1
+        
+        elif action == 'list':
+            stashes = repo.refs.stash_list()
+            if not stashes:
+                print("No stash entries found.")
+                return 0
+            for i, s in enumerate(stashes):
+                msg = s.get('message', 'WIP')
+                h = s.get('hash', '')[:8]
+                print(f"stash@{{{i}}}: {h} {msg}")
+            return 0
+        
+        elif action == 'apply':
+            ref = getattr(args, 'stash_ref', 'stash@{0}')
+            commit_hash = repo.resolve_ref(ref)
+            if not commit_hash:
+                print(f"Error: Stash not found: {ref}")
+                return 1
+            from ..core.objects import Tree, Blob
+            tree = repo.get_commit_tree(commit_hash)
+            if tree:
+                for entry in tree.entries:
+                    blob = Blob.load(repo.object_store, entry.hash)
+                    if blob:
+                        fp = repo.current_dir / entry.path / entry.name
+                        fp.parent.mkdir(parents=True, exist_ok=True)
+                        fp.write_bytes(blob.content)
+                print("Applied stash (changes in working directory)")
+            return 0
+        
+        return 1

memvcs/commands/status.py

@@ -0,0 +1,112 @@
+"""
+agmem status - Show working tree status.
+"""
+
+import argparse
+
+from ..commands.base import require_repo
+from ..core.repository import Repository
+
+
+class StatusCommand:
+    """Show the working tree status."""
+    
+    name = 'status'
+    help = 'Show the working tree status'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            '--short', '-s',
+            action='store_true',
+            help='Show short format'
+        )
+        parser.add_argument(
+            '--branch', '-b',
+            action='store_true',
+            help='Show branch information'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        status = repo.get_status()
+        
+        # Show branch info
+        branch = status.get('branch')
+        head = status.get('head', {})
+        
+        if args.short:
+            # Short format: XY filename
+            for f in status.get('staged', []):
+                print(f"A  {f}")
+            for f in status.get('modified', []):
+                print(f" M {f}")
+            for f in status.get('deleted', []):
+                print(f" D {f}")
+            for f in status.get('untracked', []):
+                print(f"?? {f}")
+        else:
+            # Long format
+            if branch:
+                print(f"On branch {branch}")
+            elif head.get('type') == 'commit':
+                print(f"HEAD detached at {head['value'][:8]}")
+            
+            # Check for commits
+            head_commit = repo.get_head_commit()
+            if not head_commit:
+                print("\nNo commits yet")
+            
+            # Staged changes
+            staged = status.get('staged', [])
+            if staged:
+                print(f"\nChanges to be committed:")
+                print(f'  (use "agmem reset HEAD <file>..." to unstage)')
+                print()
+                for f in staged:
+                    print(f"        new file:   {f}")
+                print()
+            
+            # Modified but not staged
+            modified = status.get('modified', [])
+            if modified:
+                print(f"Changes not staged for commit:")
+                print(f'  (use "agmem add <file>..." to update what will be committed)')
+                print()
+                for f in modified:
+                    print(f"        modified:   {f}")
+                print()
+            
+            # Deleted but not staged
+            deleted = status.get('deleted', [])
+            if deleted:
+                print(f"Deleted files:")
+                print(f'  (use "agmem add <file>..." to stage deletion)')
+                print()
+                for f in deleted:
+                    print(f"        deleted:    {f}")
+                print()
+            
+            # Untracked files
+            untracked = status.get('untracked', [])
+            if untracked:
+                print(f"Untracked files:")
+                print(f'  (use "agmem add <file>..." to include in what will be committed)')
+                print()
+                for f in untracked:
+                    print(f"        {f}")
+                print()
+            
+            # Summary
+            total_changes = len(staged) + len(modified) + len(deleted) + len(untracked)
+            if total_changes == 0:
+                if head_commit:
+                    print("nothing to commit, working tree clean")
+                else:
+                    print('nothing to commit (create/copy files and use "agmem add" to track)')
+        
+        return 0

memvcs/commands/tag.py

@@ -0,0 +1,117 @@
+"""
+agmem tag - Create, list, delete or verify a tag.
+"""
+
+import argparse
+from datetime import datetime
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.objects import Tag
+from ..core.repository import Repository
+
+
+class TagCommand:
+    """Manage tags."""
+    
+    name = 'tag'
+    help = 'Create, list, delete or verify a tag'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            'name',
+            nargs='?',
+            help='Tag name'
+        )
+        parser.add_argument(
+            'commit',
+            nargs='?',
+            help='Commit to tag (default: HEAD)'
+        )
+        parser.add_argument(
+            '--list', '-l',
+            action='store_true',
+            help='List tags'
+        )
+        parser.add_argument(
+            '--delete', '-d',
+            action='store_true',
+            help='Delete a tag'
+        )
+        parser.add_argument(
+            '-m', '--message',
+            help='Tag message'
+        )
+        parser.add_argument(
+            '--force', '-f',
+            action='store_true',
+            help='Force replace existing tag'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        # Find repository
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        
+        # List tags
+        if args.list or (not args.name and not args.delete):
+            tags = repo.refs.list_tags()
+            
+            if not tags:
+                print("No tags yet.")
+                return 0
+            
+            for tag in sorted(tags):
+                commit_hash = repo.refs.get_tag_commit(tag)
+                short_hash = commit_hash[:8] if commit_hash else "????????"
+                print(f"{tag}\t{short_hash}")
+            
+            return 0
+        
+        # Delete tag
+        if args.delete:
+            if not args.name:
+                print("Error: Tag name required for deletion")
+                return 1
+            
+            if repo.refs.delete_tag(args.name):
+                print(f"Deleted tag '{args.name}'")
+                return 0
+            else:
+                print(f"Error: Tag '{args.name}' not found")
+                return 1
+        
+        # Create tag
+        if args.name:
+            # Check if tag exists
+            if repo.refs.tag_exists(args.name) and not args.force:
+                print(f"Error: Tag '{args.name}' already exists")
+                print("Use -f to force replace")
+                return 1
+            
+            # Get commit to tag
+            commit_ref = args.commit or 'HEAD'
+            commit_hash = repo.resolve_ref(commit_ref)
+            
+            if not commit_hash:
+                print(f"Error: Unknown revision: {commit_ref}")
+                return 1
+            
+            # Delete existing tag if forcing
+            if args.force and repo.refs.tag_exists(args.name):
+                repo.refs.delete_tag(args.name)
+            
+            # Create tag
+            message = args.message or f"Tag {args.name}"
+            if repo.refs.create_tag(args.name, commit_hash, message):
+                print(f"Created tag '{args.name}' at {commit_hash[:8]}")
+                return 0
+            else:
+                print(f"Error: Could not create tag '{args.name}'")
+                return 1
+        
+        return 0

memvcs/commands/test.py

@@ -0,0 +1,132 @@
+"""
+agmem test - Run memory regression tests.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.test_runner import TestRunner, create_test_template
+
+
+class TestCommand:
+    """Run memory regression tests."""
+    
+    name = 'test'
+    help = 'Run memory regression tests to validate knowledge consistency'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            '--branch',
+            help='Run tests against a specific branch'
+        )
+        parser.add_argument(
+            '--tags',
+            nargs='+',
+            help='Filter tests by tags'
+        )
+        parser.add_argument(
+            '--init',
+            action='store_true',
+            help='Initialize tests directory with template'
+        )
+        parser.add_argument(
+            '-v', '--verbose',
+            action='store_true',
+            help='Show detailed test output'
+        )
+        parser.add_argument(
+            '--fail-fast',
+            action='store_true',
+            help='Stop on first failure'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+        
+        # Handle --init
+        if args.init:
+            return TestCommand._init_tests(repo)
+        
+        # Try to get vector store
+        vector_store = None
+        try:
+            from ..core.vector_store import VectorStore
+            vector_store = VectorStore(repo.root / '.mem')
+        except ImportError:
+            if args.verbose:
+                print("Note: Vector store not available, using text-based tests")
+        except Exception as e:
+            if args.verbose:
+                print(f"Note: Could not initialize vector store: {e}")
+        
+        # Create test runner
+        runner = TestRunner(repo, vector_store)
+        
+        # Load and check for tests
+        tests = runner.load_tests()
+        if not tests:
+            print("No tests found.")
+            print("Create test files in tests/ directory or run 'agmem test --init'")
+            return 0
+        
+        print(f"Running {len(tests)} tests...")
+        
+        # Run tests
+        if args.branch:
+            result = runner.run_for_branch(args.branch)
+        else:
+            result = runner.run_all(tags=args.tags)
+        
+        # Print results
+        print()
+        
+        if result.failures:
+            print("Failed tests:")
+            for failure in result.failures:
+                critical_marker = " [CRITICAL]" if failure.is_critical else ""
+                print(f"  ✗ {failure.test_name}{critical_marker}")
+                if args.verbose:
+                    print(f"    Query: {failure.query}")
+                    print(f"    Expected: {failure.expected}")
+                    if failure.actual:
+                        print(f"    Got: {failure.actual[:100]}...")
+                    print(f"    Error: {failure.message}")
+                print()
+        
+        # Summary
+        status = "PASSED" if result.passed else "FAILED"
+        critical_failures = [f for f in result.failures if f.is_critical]
+        
+        print(f"{'='*50}")
+        print(f"Results: {result.passed_count}/{result.total_count} tests passed")
+        if critical_failures:
+            print(f"Critical failures: {len(critical_failures)}")
+        print(f"Duration: {result.duration_ms}ms")
+        print(f"Status: {status}")
+        print(f"{'='*50}")
+        
+        return 0 if result.passed else 1
+    
+    @staticmethod
+    def _init_tests(repo) -> int:
+        """Initialize tests directory with template."""
+        tests_dir = repo.root / 'tests'
+        tests_dir.mkdir(exist_ok=True)
+        
+        template_file = tests_dir / 'example_tests.yaml'
+        
+        if template_file.exists():
+            print(f"Test template already exists: {template_file}")
+            return 0
+        
+        template_file.write_text(create_test_template())
+        print(f"Created test template: {template_file}")
+        print("\nEdit this file to add your memory tests.")
+        print("Run 'agmem test' to execute them.")
+        
+        return 0