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

memvcs/commands/add.py

@@ -10,84 +10,82 @@ from ..core.repository import Repository
 
 
 # Default allowed file extensions for memory files
-DEFAULT_ALLOWED_EXTENSIONS = {'.md', '.txt', '.json', '.yaml', '.yml'}
+DEFAULT_ALLOWED_EXTENSIONS = {".md", ".txt", ".json", ".yaml", ".yml"}
 
 # Binary file signatures (magic bytes) to detect binary files
 BINARY_SIGNATURES = [
-    b'\x89PNG',      # PNG
-    b'\xff\xd8\xff', # JPEG
-    b'GIF8',         # GIF
-    b'%PDF',         # PDF
-    b'PK\x03\x04',   # ZIP
-    b'\x1f\x8b',     # GZIP
-    b'BM',           # BMP
-    b'\x00\x00\x01\x00',  # ICO
-    b'RIFF',         # WAV, AVI, etc.
+    b"\x89PNG",  # PNG
+    b"\xff\xd8\xff",  # JPEG
+    b"GIF8",  # GIF
+    b"%PDF",  # PDF
+    b"PK\x03\x04",  # ZIP
+    b"\x1f\x8b",  # GZIP
+    b"BM",  # BMP
+    b"\x00\x00\x01\x00",  # ICO
+    b"RIFF",  # WAV, AVI, etc.
 ]
 
 
 class AddCommand:
     """Add files to the staging area."""
-    
-    name = 'add'
-    help = 'Add memory files to staging area'
-    
+
+    name = "add"
+    help = "Add memory files to staging area"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument("paths", nargs="+", help="Files or directories to stage")
         parser.add_argument(
-            'paths',
-            nargs='+',
-            help='Files or directories to stage'
-        )
-        parser.add_argument(
-            '--all', '-A',
-            action='store_true',
-            help='Stage all changes (including modifications and deletions)'
+            "--all",
+            "-A",
+            action="store_true",
+            help="Stage all changes (including modifications and deletions)",
         )
         parser.add_argument(
-            '--force', '-f',
-            action='store_true',
-            help='Force add even if file type is not recommended'
+            "--force",
+            "-f",
+            action="store_true",
+            help="Force add even if file type is not recommended",
         )
         parser.add_argument(
-            '--allow-binary',
-            action='store_true',
-            help='Allow staging binary files (not recommended)'
+            "--allow-binary",
+            action="store_true",
+            help="Allow staging binary files (not recommended)",
         )
-    
+
     @staticmethod
     def _is_binary_file(filepath: Path) -> bool:
         """Check if a file is binary by looking at magic bytes."""
         try:
-            with open(filepath, 'rb') as f:
+            with open(filepath, "rb") as f:
                 header = f.read(16)
-            
+
             for signature in BINARY_SIGNATURES:
                 if header.startswith(signature):
                     return True
-            
+
             # Also check for null bytes (common in binary files)
-            if b'\x00' in header:
+            if b"\x00" in header:
                 return True
-            
+
             return False
         except Exception:
             return False
-    
+
     @staticmethod
     def _is_allowed_extension(filepath: Path, config: dict) -> bool:
         """Check if file extension is in allowed list."""
-        allowed = config.get('allowed_extensions', list(DEFAULT_ALLOWED_EXTENSIONS))
+        allowed = config.get("allowed_extensions", list(DEFAULT_ALLOWED_EXTENSIONS))
         allowed_set = set(allowed)
-        
+
         ext = filepath.suffix.lower()
         return ext in allowed_set or not ext  # Allow files without extension
-    
+
     @staticmethod
     def _validate_file(filepath: Path, config: dict, force: bool, allow_binary: bool) -> tuple:
         """
         Validate a file for staging.
-        
+
         Returns:
             Tuple of (is_valid, warning_message)
         """
@@ -96,13 +94,16 @@ class AddCommand:
             if allow_binary:
                 return True, f"Warning: {filepath} appears to be binary"
             else:
-                return False, f"Rejected: {filepath} is a binary file. Use --allow-binary to override."
-        
+                return (
+                    False,
+                    f"Rejected: {filepath} is a binary file. Use --allow-binary to override.",
+                )
+
         # Check extension
         if not AddCommand._is_allowed_extension(filepath, config):
-            ext = filepath.suffix or '(no extension)'
-            allowed = config.get('allowed_extensions', list(DEFAULT_ALLOWED_EXTENSIONS))
-            
+            ext = filepath.suffix or "(no extension)"
+            allowed = config.get("allowed_extensions", list(DEFAULT_ALLOWED_EXTENSIONS))
+
             if force:
                 return True, f"Warning: {filepath} has extension '{ext}' which may not be optimal"
             else:
@@ -111,9 +112,9 @@ class AddCommand:
                     f"  Recommended: {', '.join(sorted(allowed))}\n"
                     f"  Use --force to override."
                 )
-        
+
         return True, None
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
@@ -123,19 +124,19 @@ class AddCommand:
         staged_count = 0
         rejected_count = 0
         config = repo.get_config()
-        
+
         for path_str in args.paths:
             path = Path(path_str)
-            
+
             # Handle '.' to stage all
-            if path_str == '.':
+            if path_str == ".":
                 staged, rejected = AddCommand._stage_directory_with_validation(
                     repo, None, config, args.force, args.allow_binary
                 )
                 staged_count += staged
                 rejected_count += rejected
                 continue
-            
+
             # Resolve path relative to current/
             if path.is_absolute():
                 try:
@@ -156,85 +157,91 @@ class AddCommand:
                 else:
                     print(f"Error: Path not found: {path}")
                     continue
-            
+
             full_path = repo.current_dir / rel_path
-            
+
             if not full_path.exists():
                 print(f"Error: Path not found: {path}")
                 continue
-            
+
             if full_path.is_file():
                 # Validate file
                 is_valid, message = AddCommand._validate_file(
                     full_path, config, args.force, args.allow_binary
                 )
-                
+
                 if not is_valid:
                     print(message)
                     rejected_count += 1
                     continue
-                
+
                 if message:  # Warning
                     print(message)
-                
+
                 try:
                     blob_hash = repo.stage_file(str(rel_path))
                     print(f"  staged: {rel_path}")
                     staged_count += 1
                 except Exception as e:
                     print(f"Error staging {rel_path}: {e}")
-            
+
             elif full_path.is_dir():
                 staged, rejected = AddCommand._stage_directory_with_validation(
                     repo, str(rel_path), config, args.force, args.allow_binary
                 )
                 staged_count += staged
                 rejected_count += rejected
-        
+
         if staged_count > 0 or rejected_count > 0:
             print(f"\nStaged {staged_count} file(s)")
             if rejected_count > 0:
                 print(f"Rejected {rejected_count} file(s) - use --force to override")
             if staged_count > 0:
                 print("Run 'agmem commit -m \"message\"' to save snapshot")
+                try:
+                    from ..core.audit import append_audit
+
+                    append_audit(repo.mem_dir, "add", {"staged_count": staged_count})
+                except Exception:
+                    pass
         else:
             print("No files staged")
-        
+
         return 0
-    
+
     @staticmethod
-    def _stage_directory_with_validation(repo, subdir: str, config: dict, force: bool, allow_binary: bool) -> tuple:
+    def _stage_directory_with_validation(
+        repo, subdir: str, config: dict, force: bool, allow_binary: bool
+    ) -> tuple:
         """
         Stage a directory with file validation.
-        
+
         Returns:
             Tuple of (staged_count, rejected_count)
         """
         staged_count = 0
         rejected_count = 0
-        
+
         if subdir:
             dir_path = repo.current_dir / subdir
         else:
             dir_path = repo.current_dir
-        
+
         if not dir_path.exists():
             return 0, 0
-        
-        for file_path in dir_path.rglob('*'):
+
+        for file_path in dir_path.rglob("*"):
             if not file_path.is_file():
                 continue
-            
+
             # Skip hidden files and .mem directory
             rel_to_current = file_path.relative_to(repo.current_dir)
-            if any(part.startswith('.') for part in rel_to_current.parts):
+            if any(part.startswith(".") for part in rel_to_current.parts):
                 continue
-            
+
             # Validate file
-            is_valid, message = AddCommand._validate_file(
-                file_path, config, force, allow_binary
-            )
-            
+            is_valid, message = AddCommand._validate_file(file_path, config, force, allow_binary)
+
             if not is_valid:
                 if not force:
                     # Only print first few rejections to avoid spam
@@ -244,15 +251,15 @@ class AddCommand:
                         print("  ... (more files rejected)")
                 rejected_count += 1
                 continue
-            
+
             if message:  # Warning
                 print(message)
-            
+
             try:
                 repo.stage_file(str(rel_to_current))
                 print(f"  staged: {rel_to_current}")
                 staged_count += 1
             except Exception as e:
                 print(f"Error staging {rel_to_current}: {e}")
-        
+
         return staged_count, rejected_count

memvcs/commands/audit.py

@@ -0,0 +1,59 @@
+"""
+agmem audit - Tamper-evident audit trail.
+
+Read and verify the append-only audit log.
+"""
+
+import argparse
+
+from ..commands.base import require_repo
+from ..core.audit import read_audit, verify_audit
+
+
+class AuditCommand:
+    """Show and verify the tamper-evident audit log."""
+
+    name = "audit"
+    help = "Show and verify the tamper-evident audit log"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "-n",
+            "--max",
+            type=int,
+            default=50,
+            metavar="N",
+            help="Show at most N entries (default 50)",
+        )
+        parser.add_argument(
+            "--verify",
+            action="store_true",
+            help="Verify the audit chain and report first tampering point",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        if args.verify:
+            valid, first_bad = verify_audit(repo.mem_dir)
+            if valid:
+                print("Audit log chain is valid.")
+                return 0
+            print(f"Audit log chain invalid at entry index {first_bad}.")
+            return 1
+
+        entries = read_audit(repo.mem_dir, max_entries=args.max)
+        if not entries:
+            print("No audit entries.")
+            return 0
+        for e in entries:
+            ts = e.get("timestamp", "")
+            op = e.get("operation", "")
+            details = e.get("details", {})
+            detail_str = " ".join(f"{k}={v}" for k, v in sorted(details.items()) if v is not None)
+            print(f"{ts}  {op}  {detail_str}")
+        return 0

memvcs/commands/blame.py

@@ -12,53 +12,46 @@ 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'
-    
+
+    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(
-            'file',
-            nargs='?',
-            help='File to blame (path relative to current/)'
-        )
-        parser.add_argument(
-            'ref',
-            nargs='?',
-            default='HEAD',
-            help='Commit to blame at (default: HEAD)'
+            "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?")'
+            "--query", "-q", help='Semantic query to trace (e.g., "Why does agent think X?")'
         )
         parser.add_argument(
-            '--limit', '-n',
+            "--limit",
+            "-n",
             type=int,
             default=5,
-            help='Number of results to show for semantic blame (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?\"")
+            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."""
@@ -66,45 +59,45 @@ class BlameCommand:
         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
+            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()
+
+        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'
+        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:
@@ -113,34 +106,34 @@ class BlameCommand:
             print("Error: Vector search requires sqlite-vec.")
             print("Install with: pip install agmem[vector]")
             return 1
-        
+
         try:
-            vs = VectorStore(repo.root / '.mem')
+            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(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']
-            
+            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)
@@ -157,13 +150,13 @@ class BlameCommand:
                 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]:
+            for line in content.split("\n")[:5]:
                 print(f"      {line[:70]}")
-            if len(content.split('\n')) > 5:
+            if len(content.split("\n")) > 5:
                 print("      ...")
-        
+
         print()
         return 0

memvcs/commands/branch.py

@@ -10,43 +10,23 @@ from ..core.repository import Repository
 
 class BranchCommand:
     """Manage branches."""
-    
-    name = 'branch'
-    help = 'List, create, or delete 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(
-            'name',
-            nargs='?',
-            help='Branch name to create or delete'
-        )
-        parser.add_argument(
-            '--delete', '-d',
-            action='store_true',
-            help='Delete a branch'
+            "--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(
-            '--force', '-D',
-            action='store_true',
-            help='Force delete a branch (even if not merged)'
+            "--all", "-a", action="store_true", help="List all branches including remote"
         )
-        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'
-        )
-    
+        parser.add_argument("start_point", nargs="?", help="Commit to start the new branch from")
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
@@ -60,13 +40,13 @@ class BranchCommand:
             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