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

memvcs/commands/reset.py

@@ -11,34 +11,25 @@ from ..core.repository import Repository
 
 class ResetCommand:
     """Reset current HEAD to the specified state."""
-    
-    name = 'reset'
-    help = '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)'
+            "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'
+            "--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)'
+            "--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'
+            "--hard", action="store_true", help="Reset HEAD, index, and working tree"
         )
-    
+
     @staticmethod
     def execute(args) -> int:
         # Find repository
@@ -46,53 +37,52 @@ class ResetCommand:
         if code != 0:
             return code
 
-        
         # Determine mode
         if args.soft:
-            mode = 'soft'
+            mode = "soft"
         elif args.hard:
-            mode = 'hard'
+            mode = "hard"
         else:
-            mode = 'mixed'
-        
+            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':
+            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':
+
+            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':
+
+            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/resurrect.py

@@ -0,0 +1,82 @@
+"""
+agmem resurrect - Restore archived (decayed) memories.
+"""
+
+import argparse
+import shutil
+from pathlib import Path
+
+from ..commands.base import require_repo
+
+
+class ResurrectCommand:
+    """Restore memories from .mem/forgetting/."""
+
+    name = "resurrect"
+    help = "Restore archived (decayed) memories from forgetting/"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "path",
+            nargs="?",
+            help="Path or pattern to restore (e.g., semantic/user-prefs.md)",
+        )
+        parser.add_argument(
+            "--list",
+            "-l",
+            action="store_true",
+            help="List archived memories",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        forgetting_dir = repo.mem_dir / "forgetting"
+        if not forgetting_dir.exists():
+            print("No forgotten memories found.")
+            return 0
+
+        if args.list:
+            for sub in sorted(forgetting_dir.iterdir()):
+                if sub.is_dir():
+                    print(f"\n{sub.name}:")
+                    for f in sorted(sub.glob("*")):
+                        if f.is_file():
+                            print(f"  - {f.name}")
+            return 0
+
+        if not args.path:
+            print("Error: Path to restore is required.")
+            print("Usage: agmem resurrect <path>")
+            print("       agmem resurrect --list")
+            return 1
+
+        # Find archived file
+        pattern = args.path.replace("/", "_")
+        found = []
+        for sub in forgetting_dir.iterdir():
+            if sub.is_dir():
+                for f in sub.glob("*"):
+                    if f.is_file() and (pattern in f.name or f.name == args.path):
+                        found.append(f)
+
+        if not found:
+            print(f"No archived memory matching '{args.path}' found.")
+            print("Use 'agmem resurrect --list' to see available archives.")
+            return 1
+
+        for archived in found:
+            # Restore to current/
+            orig_path = (
+                archived.name.replace("_", "/", 1) if "_" in archived.name else archived.name
+            )
+            dest = repo.current_dir / orig_path
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(str(archived), str(dest))
+            print(f"Restored {archived.name} -> {orig_path}")
+
+        return 0

memvcs/commands/search.py

@@ -10,9 +10,7 @@ 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")
-    )
+    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:
@@ -38,7 +36,8 @@ class SearchCommand:
             help="Search query for semantic search",
         )
         parser.add_argument(
-            "--limit", "-n",
+            "--limit",
+            "-n",
             type=int,
             default=10,
             help="Maximum results to return (default: 10)",

memvcs/commands/serve.py

@@ -16,7 +16,8 @@ class ServeCommand:
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
         parser.add_argument(
-            "--port", "-p",
+            "--port",
+            "-p",
             type=int,
             default=8765,
             help="Port to bind (default: 8765)",

memvcs/commands/show.py

@@ -4,6 +4,7 @@ agmem show - Show various types of objects.
 
 import argparse
 import json
+import sys
 from pathlib import Path
 
 from ..commands.base import require_repo
@@ -13,28 +14,27 @@ from ..core.repository import Repository
 
 class ShowCommand:
     """Show various types of objects."""
-    
-    name = 'show'
-    help = '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(
-            'object',
-            help='Object to show (commit, tree, blob, branch)'
+            "--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")
         parser.add_argument(
-            '--type', '-t',
-            choices=['commit', 'tree', 'blob', 'auto'],
-            default='auto',
-            help='Type of object to show'
+            "--at",
+            metavar="TIMESTAMP",
+            help="View file at specific time (ISO 8601, e.g., 2025-12-01T14:00:00)",
         )
-        parser.add_argument(
-            '--raw',
-            action='store_true',
-            help='Show raw object content'
-        )
-    
+
     @staticmethod
     def execute(args) -> int:
         # Find repository
@@ -42,11 +42,41 @@ class ShowCommand:
         if code != 0:
             return code
 
-        
         obj_ref = args.object
         obj_hash = None
         obj_type = args.type
-        
+
+        # --at: show file at timestamp
+        if args.at:
+            commit_hash = repo.resolve_ref(args.at)
+            if not commit_hash:
+                print(f"Error: No commit found at {args.at}", file=sys.stderr)
+                return 1
+            # Treat object as file path under current/
+            file_path = obj_ref.replace("current/", "").lstrip("/")
+            tree = repo.get_commit_tree(commit_hash)
+            if not tree:
+                print(
+                    f"Error: Tree not found for commit at {args.at}", file=__import__("sys").stderr
+                )
+                return 1
+            # Find blob for path (tree has flat entries with path)
+            blob_hash = None
+            for entry in tree.entries:
+                full_path = (
+                    (entry.path + "/" + entry.name).lstrip("/") if entry.path else entry.name
+                )
+                if full_path == file_path:
+                    blob_hash = entry.hash
+                    break
+            if not blob_hash:
+                print(f"Error: File {file_path} not found at {args.at}", file=sys.stderr)
+                return 1
+            blob = Blob.load(repo.object_store, blob_hash)
+            if blob:
+                print(blob.content.decode("utf-8", errors="replace"))
+            return 0
+
         # Try to resolve as reference
         resolved = repo.resolve_ref(obj_ref)
         if resolved:
@@ -54,34 +84,34 @@ class ShowCommand:
         else:
             # Assume it's a hash
             obj_hash = obj_ref
-        
+
         # Try to determine type if auto
-        if obj_type == 'auto':
+        if obj_type == "auto":
             # Try commit first
             commit = Commit.load(repo.object_store, obj_hash)
             if commit:
-                obj_type = 'commit'
+                obj_type = "commit"
             else:
                 # Try tree
                 tree = Tree.load(repo.object_store, obj_hash)
                 if tree:
-                    obj_type = 'tree'
+                    obj_type = "tree"
                 else:
                     # Try blob
                     blob = Blob.load(repo.object_store, obj_hash)
                     if blob:
-                        obj_type = 'blob'
+                        obj_type = "blob"
                     else:
                         print(f"Error: Object not found: {obj_ref}")
                         return 1
-        
+
         # Display based on type
-        if obj_type == 'commit':
+        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}")
@@ -91,35 +121,35 @@ class ShowCommand:
             print(f"tree {commit.tree}")
             if commit.parents:
                 print(f"parent {' '.join(commit.parents)}")
-        
-        elif obj_type == 'tree':
+
+        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
+                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':
+
+        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'))
+                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')
+                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

@@ -11,52 +11,51 @@ from ..core.repository import Repository
 
 class StashCommand:
     """Stash working directory changes."""
-    
-    name = 'stash'
-    help = 'Stash changes for later (save work in progress)'
-    
+
+    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')
-        
+        subparsers = parser.add_subparsers(dest="stash_action", help="Stash action")
+
         # Default: list (when no subcommand given)
-        parser.set_defaults(stash_action='list')
-        
+        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')
-        
+        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')
-        
+        subparsers.add_parser("pop", help="Apply and remove most recent stash")
+
         # stash list (default)
-        subparsers.add_parser('list', help='List stashes')
-        
+        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')
-    
+        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)
+        action = getattr(args, "stash_action", None)
         if action is None:
-            action = 'list'
-        
-        if action == 'push':
-            stash_hash = repo.stash_create(getattr(args, 'message', '') or '')
+            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':
+
+        elif action == "pop":
             stash_hash = repo.stash_pop(0)
             if stash_hash:
                 print(f"Restored stashed changes")
@@ -64,25 +63,26 @@ class StashCommand:
             else:
                 print("No stash entries found.")
                 return 1
-        
-        elif action == 'list':
+
+        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]
+                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}')
+
+        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:
@@ -93,5 +93,5 @@ class StashCommand:
                         fp.write_bytes(blob.content)
                 print("Applied stash (changes in working directory)")
             return 0
-        
+
         return 1

memvcs/commands/status.py

@@ -10,23 +10,15 @@ from ..core.repository import Repository
 
 class StatusCommand:
     """Show the working tree status."""
-    
-    name = 'status'
-    help = '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'
-        )
-    
+        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()
@@ -34,35 +26,35 @@ class StatusCommand:
             return code
 
         status = repo.get_status()
-        
+
         # Show branch info
-        branch = status.get('branch')
-        head = status.get('head', {})
-        
+        branch = status.get("branch")
+        head = status.get("head", {})
+
         if args.short:
             # Short format: XY filename
-            for f in status.get('staged', []):
+            for f in status.get("staged", []):
                 print(f"A  {f}")
-            for f in status.get('modified', []):
+            for f in status.get("modified", []):
                 print(f" M {f}")
-            for f in status.get('deleted', []):
+            for f in status.get("deleted", []):
                 print(f" D {f}")
-            for f in status.get('untracked', []):
+            for f in status.get("untracked", []):
                 print(f"?? {f}")
         else:
             # Long format
             if branch:
                 print(f"On branch {branch}")
-            elif head.get('type') == 'commit':
+            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', [])
+            staged = status.get("staged", [])
             if staged:
                 print(f"\nChanges to be committed:")
                 print(f'  (use "agmem reset HEAD <file>..." to unstage)')
@@ -70,9 +62,9 @@ class StatusCommand:
                 for f in staged:
                     print(f"        new file:   {f}")
                 print()
-            
+
             # Modified but not staged
-            modified = status.get('modified', [])
+            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)')
@@ -80,9 +72,9 @@ class StatusCommand:
                 for f in modified:
                     print(f"        modified:   {f}")
                 print()
-            
+
             # Deleted but not staged
-            deleted = status.get('deleted', [])
+            deleted = status.get("deleted", [])
             if deleted:
                 print(f"Deleted files:")
                 print(f'  (use "agmem add <file>..." to stage deletion)')
@@ -90,9 +82,9 @@ class StatusCommand:
                 for f in deleted:
                     print(f"        deleted:    {f}")
                 print()
-            
+
             # Untracked files
-            untracked = status.get('untracked', [])
+            untracked = status.get("untracked", [])
             if untracked:
                 print(f"Untracked files:")
                 print(f'  (use "agmem add <file>..." to include in what will be committed)')
@@ -100,7 +92,7 @@ class StatusCommand:
                 for f in untracked:
                     print(f"        {f}")
                 print()
-            
+
             # Summary
             total_changes = len(staged) + len(modified) + len(deleted) + len(untracked)
             if total_changes == 0:
@@ -108,5 +100,5 @@ class StatusCommand:
                     print("nothing to commit, working tree clean")
                 else:
                     print('nothing to commit (create/copy files and use "agmem add" to track)')
-        
+
         return 0