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

memvcs/commands/graph.py

@@ -11,109 +11,102 @@ from ..commands.base import require_repo
 
 class GraphCommand:
     """Visualize connections between memory files."""
-    
-    name = 'graph'
-    help = 'Visualize the knowledge graph of memory files'
-    
+
+    name = "graph"
+    help = "Visualize the knowledge graph of memory files"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument("--output", "-o", help="Output file for graph data (JSON)")
         parser.add_argument(
-            '--output', '-o',
-            help='Output file for graph data (JSON)'
-        )
-        parser.add_argument(
-            '--format',
-            choices=['json', 'd3', 'summary'],
-            default='summary',
-            help='Output format (default: summary)'
+            "--format",
+            choices=["json", "d3", "summary"],
+            default="summary",
+            help="Output format (default: summary)",
         )
         parser.add_argument(
-            '--no-similarity',
-            action='store_true',
-            help='Skip similarity-based edges (faster)'
+            "--no-similarity", action="store_true", help="Skip similarity-based edges (faster)"
         )
         parser.add_argument(
-            '--threshold',
+            "--threshold",
             type=float,
             default=0.7,
-            help='Similarity threshold for edges (default: 0.7)'
+            help="Similarity threshold for edges (default: 0.7)",
         )
         parser.add_argument(
-            '--serve',
-            action='store_true',
-            help='Start web server to view interactive graph'
+            "--serve", action="store_true", help="Start web server to view interactive graph"
         )
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
         if code != 0:
             return code
-        
+
         # Try to get vector store for similarity
         vector_store = None
         if not args.no_similarity:
             try:
                 from ..core.vector_store import VectorStore
-                vector_store = VectorStore(repo.root / '.mem')
+
+                vector_store = VectorStore(repo.root / ".mem")
             except ImportError:
                 print("Note: Vector store not available, skipping similarity edges")
-        
+
         # Build graph
         from ..core.knowledge_graph import KnowledgeGraphBuilder
-        
+
         builder = KnowledgeGraphBuilder(repo, vector_store)
-        
+
         print("Building knowledge graph...")
         graph_data = builder.build_graph(
-            include_similarity=not args.no_similarity,
-            similarity_threshold=args.threshold
+            include_similarity=not args.no_similarity, similarity_threshold=args.threshold
         )
-        
+
         if args.serve:
             return GraphCommand._serve_graph(repo, graph_data)
-        
-        if args.format == 'summary':
+
+        if args.format == "summary":
             GraphCommand._print_summary(graph_data, builder)
-        
-        elif args.format == 'json':
+
+        elif args.format == "json":
             output = graph_data.to_json()
             if args.output:
                 Path(args.output).write_text(output)
                 print(f"Graph data written to: {args.output}")
             else:
                 print(output)
-        
-        elif args.format == 'd3':
+
+        elif args.format == "d3":
             output = builder.export_for_d3()
             if args.output:
                 Path(args.output).write_text(output)
                 print(f"D3 graph data written to: {args.output}")
             else:
                 print(output)
-        
+
         return 0
-    
+
     @staticmethod
     def _print_summary(graph_data, builder):
         """Print a text summary of the graph."""
         meta = graph_data.metadata
-        
+
         print("\nKnowledge Graph Summary")
         print("=" * 40)
         print(f"Total files: {meta['total_nodes']}")
         print(f"Total connections: {meta['total_edges']}")
-        
+
         print("\nBy Memory Type:")
-        for mtype, count in meta['memory_types'].items():
+        for mtype, count in meta["memory_types"].items():
             if count > 0:
                 print(f"  {mtype}: {count}")
-        
+
         print("\nBy Edge Type:")
-        for etype, count in meta['edge_types'].items():
+        for etype, count in meta["edge_types"].items():
             if count > 0:
                 print(f"  {etype}: {count}")
-        
+
         # Find isolated nodes
         isolated = builder.find_isolated_nodes()
         if isolated:
@@ -122,16 +115,16 @@ class GraphCommand:
                 print(f"  - {path}")
             if len(isolated) > 5:
                 print(f"  ... and {len(isolated) - 5} more")
-        
+
         # Find potential contradictions
         contradictions = builder.find_potential_contradictions()
         if contradictions:
             print(f"\nPotential contradictions: {len(contradictions)}")
             for path1, path2, sim in contradictions[:3]:
                 print(f"  - {path1} <-> {path2} (similarity: {sim:.2%})")
-        
+
         print("\nUse --format d3 --output graph.json to export for visualization")
-    
+
     @staticmethod
     def _serve_graph(repo, graph_data):
         """Start web server to view interactive graph."""
@@ -142,10 +135,10 @@ class GraphCommand:
             print("Error: Web server requires fastapi and uvicorn.")
             print("Install with: pip install agmem[web]")
             return 1
-        
+
         print("Starting graph visualization server...")
         print("Open http://localhost:8080/graph in your browser")
-        
+
         app = create_app(repo.root)
         uvicorn.run(app, host="127.0.0.1", port=8080)
         return 0

memvcs/commands/init.py

@@ -10,49 +10,41 @@ from ..core.repository import Repository
 
 class InitCommand:
     """Initialize a new agmem repository."""
-    
-    name = 'init'
-    help = 'Initialize a new memory repository'
-    
+
+    name = "init"
+    help = "Initialize a new memory repository"
+
     @staticmethod
     def add_arguments(parser: argparse.ArgumentParser):
         parser.add_argument(
-            'path',
-            nargs='?',
-            default='.',
-            help='Directory to initialize repository in (default: current directory)'
+            "path",
+            nargs="?",
+            default=".",
+            help="Directory to initialize repository in (default: current directory)",
         )
+        parser.add_argument("--author-name", default="Agent", help="Default author name")
         parser.add_argument(
-            '--author-name',
-            default='Agent',
-            help='Default author name'
+            "--author-email", default="agent@example.com", help="Default author email"
         )
-        parser.add_argument(
-            '--author-email',
-            default='agent@example.com',
-            help='Default author email'
-        )
-    
+
     @staticmethod
     def execute(args) -> int:
         path = Path(args.path).resolve()
-        
+
         try:
             repo = Repository.init(
-                path=path,
-                author_name=args.author_name,
-                author_email=args.author_email
+                path=path, author_name=args.author_name, author_email=args.author_email
             )
-            
+
             print(f"Initialized empty agmem repository in {repo.mem_dir}")
             print(f"Author: {args.author_name} <{args.author_email}>")
             print(f"\nNext steps:")
             print(f"  1. Add memory files to {repo.current_dir}/")
             print(f"  2. Run 'agmem add <file>' to stage changes")
             print(f"  3. Run 'agmem commit -m \"message\"' to save snapshot")
-            
+
             return 0
-        
+
         except ValueError as e:
             print(f"Error: {e}")
             return 1

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,24 @@ 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'
+            "--no-commit", action="store_true", help="Perform merge but do not commit"
         )
+        parser.add_argument("--abort", action="store_true", help="Abort the current merge")
         parser.add_argument(
-            '-m', '--message',
-            help='Merge commit message'
+            "--yes",
+            action="store_true",
+            help="Accept conditionally trusted branch commits without prompting",
         )
-        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'
-        )
-    
+
     @staticmethod
     def execute(args) -> int:
         repo, code = require_repo()
@@ -47,42 +40,91 @@ 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
-        
+
+        # Trust check for branch tip (may be from another agent)
+        other_commit_hash = repo.refs.get_branch_commit(args.branch)
+        if other_commit_hash:
+            from ..core.objects import Commit
+            from ..core.trust import find_verifying_key, get_trust_level
+
+            other_commit = Commit.load(repo.object_store, other_commit_hash)
+            if other_commit and other_commit.metadata:
+                key_pem = find_verifying_key(repo.mem_dir, other_commit.metadata)
+                if key_pem is not None:
+                    level = get_trust_level(repo.mem_dir, key_pem)
+                    if level == "untrusted":
+                        print(f"Merge blocked: branch '{args.branch}' signed by untrusted key.")
+                        return 1
+                    if level == "conditional" and not getattr(args, "yes", False):
+                        print("Branch signed by conditionally trusted key. Use --yes to merge.")
+                        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:
                 print(f"  Commit: {result.commit_hash[:8]}")
+            try:
+                from ..core.audit import append_audit
+
+                append_audit(
+                    repo.mem_dir, "merge", {"branch": args.branch, "commit": result.commit_hash}
+                )
+            except Exception:
+                pass
             return 0
         else:
             print(f"Merge failed: {result.message}")
-            
+
             if result.conflicts:
+                # Persist conflicts for agmem resolve
+                try:
+                    import json
+
+                    merge_dir = repo.mem_dir / "merge"
+                    merge_dir.mkdir(parents=True, exist_ok=True)
+                    conflicts_data = [
+                        {
+                            "path": c.path,
+                            "message": c.message,
+                            "memory_type": getattr(c, "memory_type", None),
+                            "payload": getattr(c, "payload", None),
+                            "ours_content": c.ours_content,
+                            "theirs_content": c.theirs_content,
+                            "base_content": c.base_content,
+                        }
+                        for c in result.conflicts
+                    ]
+                    (merge_dir / "conflicts.json").write_text(json.dumps(conflicts_data, indent=2))
+                except Exception:
+                    pass
                 print()
                 print("Conflicts:")
                 for conflict in result.conflicts:
                     print(f"  {conflict.path}")
                 print()
-                print("Resolve conflicts and run 'agmem commit' to complete the merge.")
-            
+                print(
+                    "Resolve conflicts with 'agmem resolve' or edit files and run 'agmem commit'."
+                )
+
             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