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

memvcs/core/objects.py

@@ -18,21 +18,22 @@ def _valid_object_hash(hash_id: str) -> bool:
     """Return True if hash_id is safe for object paths (hex, 4-64 chars)."""
     if not hash_id or len(hash_id) < 4 or len(hash_id) > 64:
         return False
-    return all(c in '0123456789abcdef' for c in hash_id.lower())
+    return all(c in "0123456789abcdef" for c in hash_id.lower())
 
 
 class ObjectStore:
     """Content-addressable object storage system."""
-    
-    def __init__(self, objects_dir: Path):
+
+    def __init__(self, objects_dir: Path, encryptor: Optional[Any] = None):
         self.objects_dir = Path(objects_dir)
+        self._encryptor = encryptor
         self._ensure_directories()
-    
+
     def _ensure_directories(self):
         """Create object storage directories."""
-        for obj_type in ['blob', 'tree', 'commit', 'tag']:
+        for obj_type in ["blob", "tree", "commit", "tag"]:
             (self.objects_dir / obj_type).mkdir(parents=True, exist_ok=True)
-    
+
     def _get_object_path(self, hash_id: str, obj_type: str) -> Path:
         """Get storage path for an object. Validates hash_id to prevent path traversal."""
         if not _valid_object_hash(hash_id):
@@ -40,76 +41,85 @@ class ObjectStore:
         prefix = hash_id[:2]
         suffix = hash_id[2:]
         return self.objects_dir / obj_type / prefix / suffix
-    
+
     def _compute_hash(self, content: bytes, obj_type: str) -> str:
         """Compute SHA-256 hash of content with type header."""
         header = f"{obj_type} {len(content)}\0".encode()
         full_content = header + content
         return hashlib.sha256(full_content).hexdigest()
-    
+
     def store(self, content: bytes, obj_type: str) -> str:
         """
         Store content and return its hash ID.
-        
+
         Args:
             content: Raw bytes to store
             obj_type: Type of object ('blob', 'tree', 'commit', 'tag')
-            
+
         Returns:
             SHA-256 hash ID of stored object
         """
         hash_id = self._compute_hash(content, obj_type)
         obj_path = self._get_object_path(hash_id, obj_type)
-        
+
         # Don't store if already exists (deduplication)
         if obj_path.exists():
             return hash_id
-        
+
         # Create directory if needed
         obj_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        # Compress and store
+
+        # Compress and optionally encrypt
         header = f"{obj_type} {len(content)}\0".encode()
         full_content = header + content
         compressed = zlib.compress(full_content)
-        
+        if self._encryptor:
+            try:
+                compressed = self._encryptor.encrypt_payload(compressed)
+            except ValueError:
+                pass  # no key; store plain compressed (legacy behavior)
         obj_path.write_bytes(compressed)
         return hash_id
-    
+
     def retrieve(self, hash_id: str, obj_type: str) -> Optional[bytes]:
         """
         Retrieve content by hash ID.
-        
+
         Args:
             hash_id: SHA-256 hash of the object
             obj_type: Type of object
-            
+
         Returns:
             Raw bytes content or None if not found
         """
         obj_path = self._get_object_path(hash_id, obj_type)
-        
+
         if not obj_path.exists():
             return None
-        
-        # Decompress and extract content
-        compressed = obj_path.read_bytes()
-        full_content = zlib.decompress(compressed)
-        
+
+        raw = obj_path.read_bytes()
+        # Optionally decrypt (iv+tag minimum 12+16 bytes)
+        if self._encryptor and len(raw) >= 12 + 16:
+            try:
+                raw = self._encryptor.decrypt_payload(raw)
+            except Exception:
+                pass  # legacy plain compressed
+        full_content = zlib.decompress(raw)
+
         # Parse header
-        null_idx = full_content.index(b'\0')
+        null_idx = full_content.index(b"\0")
         header = full_content[:null_idx].decode()
-        content = full_content[null_idx + 1:]
-        
+        content = full_content[null_idx + 1 :]
+
         return content
-    
+
     def exists(self, hash_id: str, obj_type: str) -> bool:
         """Check if an object exists. Returns False for invalid hash (no raise)."""
         if not _valid_object_hash(hash_id):
             return False
         obj_path = self._get_object_path(hash_id, obj_type)
         return obj_path.exists()
-    
+
     def delete(self, hash_id: str, obj_type: str) -> bool:
         """Delete an object. Returns True if deleted, False if not found."""
         obj_path = self._get_object_path(hash_id, obj_type)
@@ -120,13 +130,13 @@ class ObjectStore:
                 obj_path.parent.rmdir()
             return True
         return False
-    
+
     def list_objects(self, obj_type: str) -> List[str]:
         """List all objects of a given type."""
         obj_dir = self.objects_dir / obj_type
         if not obj_dir.exists():
             return []
-        
+
         hashes = []
         for prefix_dir in obj_dir.iterdir():
             if prefix_dir.is_dir():
@@ -134,7 +144,7 @@ class ObjectStore:
                     hash_id = prefix_dir.name + suffix_file.name
                     hashes.append(hash_id)
         return hashes
-    
+
     def get_size(self, hash_id: str, obj_type: str) -> int:
         """Get the compressed size of an object."""
         obj_path = self._get_object_path(hash_id, obj_type)
@@ -146,16 +156,17 @@ class ObjectStore:
 @dataclass
 class Blob:
     """Blob object for storing raw memory content."""
+
     content: bytes
-    
+
     def store(self, store: ObjectStore) -> str:
         """Store this blob and return its hash."""
-        return store.store(self.content, 'blob')
-    
+        return store.store(self.content, "blob")
+
     @staticmethod
-    def load(store: ObjectStore, hash_id: str) -> Optional['Blob']:
+    def load(store: ObjectStore, hash_id: str) -> Optional["Blob"]:
         """Load a blob from storage."""
-        content = store.retrieve(hash_id, 'blob')
+        content = store.retrieve(hash_id, "blob")
         if content is not None:
             return Blob(content=content)
         return None
@@ -164,6 +175,7 @@ class Blob:
 @dataclass
 class TreeEntry:
     """Entry in a tree object."""
+
     mode: str  # '100644' for file, '040000' for directory
     obj_type: str  # 'blob' or 'tree'
     hash: str
@@ -174,52 +186,47 @@ class TreeEntry:
 @dataclass
 class Tree:
     """Tree object for storing directory structure."""
+
     entries: List[TreeEntry]
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for serialization."""
         return {
-            'type': 'tree',
-            'entries': [
-                {
-                    'mode': e.mode,
-                    'type': e.obj_type,
-                    'hash': e.hash,
-                    'name': e.name,
-                    'path': e.path
-                }
+            "type": "tree",
+            "entries": [
+                {"mode": e.mode, "type": e.obj_type, "hash": e.hash, "name": e.name, "path": e.path}
                 for e in self.entries
-            ]
+            ],
         }
-    
+
     def to_bytes(self) -> bytes:
         """Serialize to bytes."""
         return json.dumps(self.to_dict(), sort_keys=True).encode()
-    
+
     def store(self, store: ObjectStore) -> str:
         """Store this tree and return its hash."""
-        return store.store(self.to_bytes(), 'tree')
-    
+        return store.store(self.to_bytes(), "tree")
+
     @staticmethod
-    def load(store: ObjectStore, hash_id: str) -> Optional['Tree']:
+    def load(store: ObjectStore, hash_id: str) -> Optional["Tree"]:
         """Load a tree from storage."""
-        content = store.retrieve(hash_id, 'tree')
+        content = store.retrieve(hash_id, "tree")
         if content is None:
             return None
-        
+
         data = json.loads(content)
         entries = [
             TreeEntry(
-                mode=e['mode'],
-                obj_type=e['type'],
-                hash=e['hash'],
-                name=e['name'],
-                path=e.get('path', '')
+                mode=e["mode"],
+                obj_type=e["type"],
+                hash=e["hash"],
+                name=e["name"],
+                path=e.get("path", ""),
             )
-            for e in data.get('entries', [])
+            for e in data.get("entries", [])
         ]
         return Tree(entries=entries)
-    
+
     def get_entry(self, name: str) -> Optional[TreeEntry]:
         """Get an entry by name."""
         for entry in self.entries:
@@ -231,50 +238,51 @@ class Tree:
 @dataclass
 class Commit:
     """Commit object for storing memory snapshots."""
+
     tree: str  # Hash of tree object
     parents: List[str]  # Hashes of parent commits
     author: str
     timestamp: str
     message: str
     metadata: Dict[str, Any]  # Additional metadata
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for serialization."""
         return {
-            'type': 'commit',
-            'tree': self.tree,
-            'parents': self.parents,
-            'author': self.author,
-            'timestamp': self.timestamp,
-            'message': self.message,
-            'metadata': self.metadata
+            "type": "commit",
+            "tree": self.tree,
+            "parents": self.parents,
+            "author": self.author,
+            "timestamp": self.timestamp,
+            "message": self.message,
+            "metadata": self.metadata,
         }
-    
+
     def to_bytes(self) -> bytes:
         """Serialize to bytes."""
         return json.dumps(self.to_dict(), sort_keys=True).encode()
-    
+
     def store(self, store: ObjectStore) -> str:
         """Store this commit and return its hash."""
-        return store.store(self.to_bytes(), 'commit')
-    
+        return store.store(self.to_bytes(), "commit")
+
     @staticmethod
-    def load(store: ObjectStore, hash_id: str) -> Optional['Commit']:
+    def load(store: ObjectStore, hash_id: str) -> Optional["Commit"]:
         """Load a commit from storage."""
-        content = store.retrieve(hash_id, 'commit')
+        content = store.retrieve(hash_id, "commit")
         if content is None:
             return None
-        
+
         data = json.loads(content)
         return Commit(
-            tree=data['tree'],
-            parents=data.get('parents', []),
-            author=data['author'],
-            timestamp=data['timestamp'],
-            message=data['message'],
-            metadata=data.get('metadata', {})
+            tree=data["tree"],
+            parents=data.get("parents", []),
+            author=data["author"],
+            timestamp=data["timestamp"],
+            message=data["message"],
+            metadata=data.get("metadata", {}),
         )
-    
+
     def short_hash(self, store: ObjectStore) -> str:
         """Get short hash for display."""
         full_hash = self.store(store)
@@ -284,40 +292,41 @@ class Commit:
 @dataclass
 class Tag:
     """Tag object for marking specific commits."""
+
     name: str
     commit_hash: str
     message: str
     timestamp: str
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for serialization."""
         return {
-            'type': 'tag',
-            'name': self.name,
-            'commit_hash': self.commit_hash,
-            'message': self.message,
-            'timestamp': self.timestamp
+            "type": "tag",
+            "name": self.name,
+            "commit_hash": self.commit_hash,
+            "message": self.message,
+            "timestamp": self.timestamp,
         }
-    
+
     def to_bytes(self) -> bytes:
         """Serialize to bytes."""
         return json.dumps(self.to_dict(), sort_keys=True).encode()
-    
+
     def store(self, store: ObjectStore) -> str:
         """Store this tag and return its hash."""
-        return store.store(self.to_bytes(), 'tag')
-    
+        return store.store(self.to_bytes(), "tag")
+
     @staticmethod
-    def load(store: ObjectStore, hash_id: str) -> Optional['Tag']:
+    def load(store: ObjectStore, hash_id: str) -> Optional["Tag"]:
         """Load a tag from storage."""
-        content = store.retrieve(hash_id, 'tag')
+        content = store.retrieve(hash_id, "tag")
         if content is None:
             return None
-        
+
         data = json.loads(content)
         return Tag(
-            name=data['name'],
-            commit_hash=data['commit_hash'],
-            message=data['message'],
-            timestamp=data['timestamp']
+            name=data["name"],
+            commit_hash=data["commit_hash"],
+            message=data["message"],
+            timestamp=data["timestamp"],
         )

memvcs/core/pack.py

@@ -0,0 +1,92 @@
+"""
+Pack files and garbage collection for agmem.
+
+Pack: collect loose objects into single file + index. GC: delete unreachable objects, repack.
+"""
+
+import json
+import zlib
+from pathlib import Path
+from typing import Set, Dict, List, Optional, Tuple
+
+from .objects import ObjectStore
+from .refs import RefsManager
+
+
+def _pack_dir(objects_dir: Path) -> Path:
+    return objects_dir / "pack"
+
+
+def list_loose_objects(objects_dir: Path) -> Set[str]:
+    """List all loose object hashes (blob, tree, commit, tag)."""
+    hashes = set()
+    for obj_type in ["blob", "tree", "commit", "tag"]:
+        type_dir = objects_dir / obj_type
+        if not type_dir.exists():
+            continue
+        for prefix_dir in type_dir.iterdir():
+            if not prefix_dir.is_dir():
+                continue
+            for f in prefix_dir.iterdir():
+                hash_id = prefix_dir.name + f.name
+                hashes.add(hash_id)
+    return hashes
+
+
+def reachable_from_refs(mem_dir: Path, store: ObjectStore, gc_prune_days: int = 90) -> Set[str]:
+    """Collect all object hashes reachable from branches, tags, and reflog (within prune window)."""
+    refs = RefsManager(mem_dir)
+    reachable = set()
+    # Branch tips
+    for b in refs.list_branches():
+        ch = refs.get_branch_commit(b)
+        if ch:
+            reachable.update(_collect_from_commit(store, ch))
+    # Tags
+    for t in refs.list_tags():
+        ch = refs.get_tag_commit(t)
+        if ch:
+            reachable.update(_collect_from_commit(store, ch))
+    # Reflog (simplified: just HEAD recent)
+    try:
+        log = refs.get_reflog("HEAD", max_count=1000)
+        for e in log:
+            h = e.get("hash")
+            if h:
+                reachable.update(_collect_from_commit(store, h))
+    except Exception:
+        pass
+    return reachable
+
+
+def _collect_from_commit(store: ObjectStore, commit_hash: str) -> Set[str]:
+    """Collect all object hashes reachable from a commit."""
+    from .remote import _collect_objects_from_commit
+
+    return _collect_objects_from_commit(store, commit_hash)
+
+
+def run_gc(
+    mem_dir: Path, store: ObjectStore, gc_prune_days: int = 90, dry_run: bool = False
+) -> Tuple[int, int]:
+    """
+    Garbage collect: delete unreachable loose objects.
+    Returns (deleted_count, bytes_freed). dry_run: only report, do not delete.
+    """
+    loose = list_loose_objects(mem_dir / "objects")
+    reachable = reachable_from_refs(mem_dir, store, gc_prune_days)
+    to_delete = loose - reachable
+    freed = 0
+    for hash_id in to_delete:
+        # Resolve type from path
+        for obj_type in ["blob", "tree", "commit", "tag"]:
+            p = store.objects_dir / obj_type / hash_id[:2] / hash_id[2:]
+            if p.exists():
+                if not dry_run:
+                    size = p.stat().st_size
+                    p.unlink()
+                    freed += size
+                else:
+                    freed += p.stat().st_size
+                break
+    return (len(to_delete), freed)