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

memvcs/commands/log.py

@@ -11,39 +11,24 @@ from ..core.repository import Repository
 
 class LogCommand:
     """Show commit history."""
-    
-    name = 'log'
-    help = 'Show commit history'
-    
+
+    name = "log"
+    help = "Show commit history"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
         parser.add_argument(
-            '--max-count', '-n',
-            type=int,
-            default=10,
-            help='Maximum number of commits to show'
-        )
-        parser.add_argument(
-            '--oneline',
-            action='store_true',
-            help='Show one commit per line'
+            "--max-count", "-n", type=int, default=10, help="Maximum number of commits to show"
         )
+        parser.add_argument("--oneline", action="store_true", help="Show one commit per line")
         parser.add_argument(
-            '--graph',
-            action='store_true',
-            help='Show ASCII graph of branch/merge history'
+            "--graph", action="store_true", help="Show ASCII graph of branch/merge history"
         )
+        parser.add_argument("--all", action="store_true", help="Show all branches")
         parser.add_argument(
-            '--all',
-            action='store_true',
-            help='Show all branches'
+            "ref", nargs="?", help="Start from this reference (branch, tag, or commit)"
         )
-        parser.add_argument(
-            'ref',
-            nargs='?',
-            help='Start from this reference (branch, tag, or commit)'
-        )
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
@@ -52,11 +37,11 @@ class LogCommand:
 
         # Get commits
         commits = repo.get_log(max_count=args.max_count)
-        
+
         if not commits:
             print("No commits yet.")
             return 0
-        
+
         if args.oneline:
             for commit in commits:
                 print(f"{commit['short_hash']} {commit['message']}")
@@ -71,33 +56,33 @@ class LogCommand:
             for i, commit in enumerate(commits):
                 if i > 0:
                     print()
-                
+
                 # Commit header
                 print(f"\033[33mcommit {commit['hash']}\033[0m")
-                
+
                 # Show branch info if this is HEAD
                 head = repo.refs.get_head()
-                if head['type'] == 'branch':
-                    head_commit = repo.refs.get_branch_commit(head['value'])
-                    if head_commit == commit['hash']:
+                if head["type"] == "branch":
+                    head_commit = repo.refs.get_branch_commit(head["value"])
+                    if head_commit == commit["hash"]:
                         print(f"\033[36mHEAD -> {head['value']}\033[0m")
-                
+
                 # Author and date
                 print(f"Author: {commit['author']}")
-                
+
                 # Format timestamp
                 try:
-                    ts = commit['timestamp']
-                    if ts.endswith('Z'):
+                    ts = commit["timestamp"]
+                    if ts.endswith("Z"):
                         ts = ts[:-1]
                     dt = datetime.fromisoformat(ts)
-                    date_str = dt.strftime('%a %b %d %H:%M:%S %Y')
+                    date_str = dt.strftime("%a %b %d %H:%M:%S %Y")
                     print(f"Date:   {date_str}")
-                except:
+                except Exception:
                     print(f"Date:   {commit['timestamp']}")
-                
+
                 # Message
                 print()
                 print(f"    {commit['message']}")
-        
+
         return 0

memvcs/commands/merge.py

@@ -11,31 +11,19 @@ from ..core.repository import Repository
 
 class MergeCommand:
     """Merge branches."""
-    
-    name = 'merge'
-    help = 'Join two or more development histories together'
-    
+
+    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(
-            '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'
+            "--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()
@@ -47,28 +35,28 @@ class MergeCommand:
             # 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:
@@ -76,7 +64,7 @@ class MergeCommand:
             return 0
         else:
             print(f"Merge failed: {result.message}")
-            
+
             if result.conflicts:
                 print()
                 print("Conflicts:")
@@ -84,5 +72,5 @@ class MergeCommand:
                     print(f"  {conflict.path}")
                 print()
                 print("Resolve conflicts and run 'agmem commit' to complete the merge.")
-            
+
             return 1

memvcs/commands/pack.py

@@ -0,0 +1,129 @@
+"""
+agmem pack - Context window budget manager.
+
+Packs recalled memories into token budget for LLM injection.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.access_index import AccessIndex
+from ..retrieval import RecallEngine
+from ..retrieval.pack import PackEngine
+
+
+class PackCommand:
+    """Context window budget manager."""
+
+    name = "pack"
+    help = "Pack recalled memories into token budget for LLM context"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--context",
+            "-c",
+            default="",
+            help="Current task description for recall",
+        )
+        parser.add_argument(
+            "--budget",
+            "-b",
+            type=int,
+            default=4000,
+            help="Max tokens (default: 4000)",
+        )
+        parser.add_argument(
+            "--strategy",
+            "-s",
+            choices=["relevance", "recency", "importance", "balanced"],
+            default="relevance",
+            help="Packing strategy (default: relevance)",
+        )
+        parser.add_argument(
+            "--exclude",
+            "-e",
+            action="append",
+            default=[],
+            help="Paths to exclude; repeatable",
+        )
+        parser.add_argument(
+            "--model",
+            "-m",
+            default="gpt-4o-mini",
+            help="Model for token counting (default: gpt-4o-mini)",
+        )
+        parser.add_argument(
+            "--format",
+            "-f",
+            choices=["text", "json"],
+            default="text",
+            help="Output format (default: text)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        vector_store = None
+        try:
+            from ..core.vector_store import VectorStore
+
+            vs = VectorStore(repo.mem_dir)
+            vs._get_connection()  # ensure sqlite-vec is usable; may raise
+            vector_store = vs
+        except Exception:
+            pass
+
+        access_index = AccessIndex(repo.mem_dir)
+        recall_engine = RecallEngine(
+            repo=repo,
+            vector_store=vector_store,
+            access_index=access_index,
+            use_cache=True,
+        )
+
+        strategy = "hybrid" if args.strategy == "balanced" else args.strategy
+        pack_engine = PackEngine(
+            recall_engine=recall_engine,
+            model=args.model,
+            summarization_cascade=False,
+        )
+
+        result = pack_engine.pack(
+            context=args.context,
+            budget=args.budget,
+            strategy=strategy,
+            exclude=args.exclude,
+        )
+
+        if args.format == "json":
+            import json
+
+            print(
+                json.dumps(
+                    {
+                        "content": result.content,
+                        "total_tokens": result.total_tokens,
+                        "budget": result.budget,
+                        "items_used": result.items_used,
+                        "items_total": result.items_total,
+                    },
+                    indent=2,
+                )
+            )
+        else:
+            print(result.content)
+            print(
+                f"\n# Pack stats: {result.total_tokens}/{result.budget} tokens, "
+                f"{result.items_used}/{result.items_total} items",
+                file=sys.stderr,
+            )
+
+        if vector_store and hasattr(vector_store, "close"):
+            vector_store.close()
+        return 0

memvcs/commands/pull.py

@@ -37,7 +37,9 @@ class PullCommand:
 
         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>")
+            print(
+                f"Error: Remote '{args.remote}' has no URL. Set with: agmem remote add {args.remote} <url>"
+            )
             return 1
 
         try:
@@ -50,6 +52,7 @@ class PullCommand:
                 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)

memvcs/commands/push.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 class MemoryConflictError(Exception):
     """Exception raised when push fails due to conflicts."""
+
     pass
 
 
@@ -31,7 +32,8 @@ class PushCommand:
             help="Branch to push (default: current)",
         )
         parser.add_argument(
-            "--force", "-f",
+            "--force",
+            "-f",
             action="store_true",
             help="Force push (WARNING: may overwrite remote changes)",
         )
@@ -53,7 +55,7 @@ class PushCommand:
 
         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>")

memvcs/commands/recall.py

@@ -0,0 +1,145 @@
+"""
+agmem recall - Context-aware retrieval with pluggable strategies.
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.access_index import AccessIndex
+from ..retrieval import RecallEngine
+
+
+def _is_vector_unavailable_error(exc: Exception) -> bool:
+    """True if exception indicates vector deps are missing."""
+    msg = str(exc).lower()
+    return any(
+        key in msg
+        for key in ("sqlite-vec", "sentence-transformers", "vector search", "agmem[vector]")
+    )
+
+
+class RecallCommand:
+    """Context-aware recall with pluggable strategies."""
+
+    name = "recall"
+    help = "Recall curated memories for the current task (context-aware retrieval)"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--context",
+            "-c",
+            default="",
+            help="Current task description (used for embedding similarity)",
+        )
+        parser.add_argument(
+            "--strategy",
+            "-s",
+            choices=["recency", "importance", "similarity", "hybrid"],
+            default="hybrid",
+            help="Recall strategy (default: hybrid)",
+        )
+        parser.add_argument(
+            "--limit",
+            "-n",
+            type=int,
+            default=10,
+            help="Max chunks to return (default: 10)",
+        )
+        parser.add_argument(
+            "--exclude",
+            "-e",
+            action="append",
+            default=[],
+            help="Tags/paths to exclude (e.g., experiment/*); repeatable",
+        )
+        parser.add_argument(
+            "--no-cache",
+            action="store_true",
+            help="Disable recall cache",
+        )
+        parser.add_argument(
+            "--format",
+            "-f",
+            choices=["json", "text"],
+            default="json",
+            help="Output format (default: json)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        vector_store = None
+        try:
+            from ..core.vector_store import VectorStore
+
+            vector_store = VectorStore(repo.mem_dir)
+        except ImportError:
+            if args.strategy in ("similarity", "hybrid"):
+                print(
+                    "Error: Strategy '{}' requires agmem[vector]. "
+                    "Install with: pip install agmem[vector]".format(args.strategy),
+                    file=sys.stderr,
+                )
+                return 1
+            if args.strategy == "hybrid":
+                args.strategy = "recency"
+                print("Note: Falling back to recency (vector store not available)")
+
+        access_index = AccessIndex(repo.mem_dir)
+        engine = RecallEngine(
+            repo=repo,
+            vector_store=vector_store,
+            access_index=access_index,
+            use_cache=not args.no_cache,
+        )
+
+        try:
+            results = engine.recall(
+                context=args.context,
+                limit=args.limit,
+                strategy=args.strategy,
+                exclude=args.exclude,
+            )
+        except Exception as e:
+            if _is_vector_unavailable_error(e):
+                if args.strategy in ("similarity", "hybrid"):
+                    print(
+                        "Error: Vector search unavailable. Try --strategy recency or importance.",
+                        file=sys.stderr,
+                    )
+                    return 1
+                engine = RecallEngine(
+                    repo=repo,
+                    vector_store=None,
+                    access_index=access_index,
+                    use_cache=not args.no_cache,
+                )
+                results = engine.recall(
+                    context=args.context,
+                    limit=args.limit,
+                    strategy="recency",
+                    exclude=args.exclude,
+                )
+            else:
+                raise
+
+        if args.format == "json":
+            output = [r.to_dict() for r in results]
+            print(json.dumps(output, indent=2))
+        else:
+            for r in results:
+                print(f"\n--- {r.path} (score: {r.relevance_score:.4f}) ---")
+                print(r.content[:500] + ("..." if len(r.content) > 500 else ""))
+                if r.importance is not None:
+                    print(f"(importance: {r.importance})")
+
+        if vector_store and hasattr(vector_store, "close"):
+            vector_store.close()
+        return 0

memvcs/commands/reflog.py

@@ -11,42 +11,33 @@ from ..core.repository import Repository
 
 class ReflogCommand:
     """Show reflog - history of HEAD changes."""
-    
-    name = 'reflog'
-    help = 'Show reference log (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(
-            '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'
+            "-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', '')
+            h = e["hash"][:8]
+            ts = e.get("timestamp", "")[:19]
+            msg = e.get("message", "")
             print(f"{h} {ts} {msg}")
-        
+
         return 0

memvcs/commands/remote.py

@@ -40,6 +40,7 @@ class RemoteCommand:
             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:

memvcs/commands/repair.py

@@ -0,0 +1,66 @@
+"""
+agmem repair - Auto-fix belief contradictions.
+
+Repairs semantic memory contradictions using configurable strategy.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+from ..core.consistency import ConsistencyChecker, ConsistencyResult
+
+
+class RepairCommand:
+    """Repair belief contradictions in semantic memories."""
+
+    name = "repair"
+    help = "Auto-fix contradictions using confidence scores"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--strategy",
+            "-s",
+            choices=["confidence", "recency", "llm"],
+            default="confidence",
+            help="Repair strategy (default: confidence)",
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show what would be fixed without making changes",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        checker = ConsistencyChecker(repo, llm_provider="openai")
+        result = checker.repair(strategy=args.strategy)
+
+        if result.valid:
+            print("No contradictions to repair.")
+            return 0
+
+        if args.dry_run:
+            print(f"Would repair {len(result.contradictions)} contradiction(s):")
+            for c in result.contradictions:
+                print(
+                    f"  - {c.triple1.source}:{c.triple1.line} vs {c.triple2.source}:{c.triple2.line}"
+                )
+            print("\nRun without --dry-run to apply repairs.")
+            return 0
+
+        # Repair: keep higher-confidence triple, flag the other
+        # For now we only report - full repair would modify files
+        print(f"Found {len(result.contradictions)} contradiction(s).")
+        print("Manual repair required - edit the semantic files to resolve.")
+        for c in result.contradictions:
+            keep = c.triple1 if c.triple1.confidence >= c.triple2.confidence else c.triple2
+            drop = c.triple2 if keep is c.triple1 else c.triple1
+            print(f"  Keep: {keep.source}:{keep.line} (confidence {keep.confidence})")
+            print(f"  Review: {drop.source}:{drop.line} (confidence {drop.confidence})")
+        return 1