agmem 0.1.1__py3-none-any.whl

memvcs/commands/fsck.py

@@ -0,0 +1,203 @@
+"""
+agmem fsck - File system consistency check.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..commands.base import require_repo
+
+
+class FsckCommand:
+    """Check and repair repository consistency."""
+    
+    name = 'fsck'
+    help = 'Check and repair repository consistency (remove dangling vectors)'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be done without making changes'
+        )
+        parser.add_argument(
+            '--verbose', '-v',
+            action='store_true',
+            help='Show detailed output'
+        )
+        parser.add_argument(
+            '--fix',
+            action='store_true',
+            help='Actually remove dangling entries (required to make changes)'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+        
+        print("Running file system consistency check...")
+        
+        issues_found = 0
+        issues_fixed = 0
+        
+        # Check vector store for dangling entries
+        try:
+            from ..core.vector_store import VectorStore
+            vs = VectorStore(repo.root / '.mem')
+            
+            vector_issues, vector_fixed = FsckCommand._check_vectors(
+                repo, vs, args.dry_run, args.verbose, args.fix
+            )
+            issues_found += vector_issues
+            issues_fixed += vector_fixed
+        except ImportError:
+            if args.verbose:
+                print("Vector store not available, skipping vector check")
+        except Exception as e:
+            print(f"Warning: Vector store check failed: {e}")
+        
+        # Check object store integrity
+        obj_issues, obj_fixed = FsckCommand._check_objects(
+            repo, args.dry_run, args.verbose, args.fix
+        )
+        issues_found += obj_issues
+        issues_fixed += obj_fixed
+        
+        # Check refs integrity
+        ref_issues, ref_fixed = FsckCommand._check_refs(
+            repo, args.dry_run, args.verbose, args.fix
+        )
+        issues_found += ref_issues
+        issues_fixed += ref_fixed
+        
+        # Print summary
+        print()
+        print("=" * 40)
+        print("FSCK Summary")
+        print("=" * 40)
+        print(f"Issues found: {issues_found}")
+        
+        if args.fix:
+            print(f"Issues fixed: {issues_fixed}")
+        elif issues_found > 0:
+            print("\nRun with --fix to repair issues")
+        
+        if issues_found == 0:
+            print("Repository is healthy!")
+        
+        return 0 if issues_found == 0 else 1
+    
+    @staticmethod
+    def _check_vectors(repo, vs, dry_run: bool, verbose: bool, fix: bool) -> tuple:
+        """Check for dangling vector entries."""
+        print("\nChecking vector store...")
+        
+        current_dir = repo.root / 'current'
+        entries = vs.get_all_entries()
+        
+        dangling = []
+        
+        for entry in entries:
+            path = entry['path']
+            full_path = current_dir / path
+            
+            if not full_path.exists():
+                dangling.append(entry)
+                if verbose:
+                    print(f"  Dangling: {path} (rowid: {entry['rowid']})")
+        
+        if dangling:
+            print(f"  Found {len(dangling)} dangling vector entries")
+            
+            if fix and not dry_run:
+                fixed = 0
+                for entry in dangling:
+                    if vs.delete_entry(entry['rowid']):
+                        fixed += 1
+                print(f"  Removed {fixed} dangling entries")
+                return len(dangling), fixed
+            elif dry_run:
+                print("  (dry-run: no changes made)")
+        else:
+            print("  Vector store is consistent")
+        
+        return len(dangling), 0
+    
+    @staticmethod
+    def _check_objects(repo, dry_run: bool, verbose: bool, fix: bool) -> tuple:
+        """Check object store integrity."""
+        print("\nChecking object store...")
+        
+        issues = 0
+        
+        # Check if all referenced blobs exist
+        for obj_type in ['blob', 'tree', 'commit', 'tag']:
+            obj_dir = repo.root / '.mem' / 'objects' / obj_type
+            if not obj_dir.exists():
+                continue
+            
+            for prefix_dir in obj_dir.iterdir():
+                if not prefix_dir.is_dir():
+                    continue
+                for obj_file in prefix_dir.iterdir():
+                    try:
+                        # Try to read and decompress
+                        import zlib
+                        compressed = obj_file.read_bytes()
+                        zlib.decompress(compressed)
+                    except Exception as e:
+                        issues += 1
+                        if verbose:
+                            hash_id = prefix_dir.name + obj_file.name
+                            print(f"  Corrupted {obj_type}: {hash_id[:8]}...")
+        
+        if issues == 0:
+            print("  Object store is consistent")
+        else:
+            print(f"  Found {issues} corrupted objects")
+        
+        return issues, 0  # Object repair not implemented
+    
+    @staticmethod
+    def _check_refs(repo, dry_run: bool, verbose: bool, fix: bool) -> tuple:
+        """Check refs integrity."""
+        print("\nChecking refs...")
+        
+        issues = 0
+        
+        # Check if HEAD points to valid commit
+        head = repo.refs.get_head()
+        if head['type'] == 'branch':
+            branch_commit = repo.refs.get_branch_commit(head['value'])
+            if not branch_commit:
+                issues += 1
+                if verbose:
+                    print(f"  HEAD branch '{head['value']}' has no commit")
+            elif not repo.object_store.exists(branch_commit, 'commit'):
+                issues += 1
+                if verbose:
+                    print(f"  HEAD points to missing commit: {branch_commit[:8]}")
+        elif head['type'] == 'detached':
+            if not repo.object_store.exists(head['value'], 'commit'):
+                issues += 1
+                if verbose:
+                    print(f"  Detached HEAD points to missing commit")
+        
+        # Check all branches
+        branches = repo.refs.list_branches()
+        for branch in branches:
+            commit_hash = repo.refs.get_branch_commit(branch)
+            if commit_hash and not repo.object_store.exists(commit_hash, 'commit'):
+                issues += 1
+                if verbose:
+                    print(f"  Branch '{branch}' points to missing commit")
+        
+        if issues == 0:
+            print("  Refs are consistent")
+        else:
+            print(f"  Found {issues} ref issues")
+        
+        return issues, 0

memvcs/commands/garden.py

@@ -0,0 +1,107 @@
+"""
+agmem garden - Run the Gardener to synthesize episodic memories into insights.
+"""
+
+import argparse
+
+from ..commands.base import require_repo
+from ..core.gardener import Gardener, GardenerConfig
+
+
+class GardenCommand:
+    """Run the Gardener reflection loop."""
+    
+    name = 'garden'
+    help = 'Synthesize episodic memories into semantic insights'
+    
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            '--force',
+            action='store_true',
+            help='Run even if episode threshold not met'
+        )
+        parser.add_argument(
+            '--threshold',
+            type=int,
+            default=50,
+            help='Number of episodes before auto-triggering (default: 50)'
+        )
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be done without making changes'
+        )
+        parser.add_argument(
+            '--no-commit',
+            action='store_true',
+            help='Do not auto-commit generated insights'
+        )
+        parser.add_argument(
+            '--llm',
+            choices=['openai', 'none'],
+            default='none',
+            help='LLM provider for summarization (default: none)'
+        )
+        parser.add_argument(
+            '--model',
+            help='LLM model to use (e.g., gpt-3.5-turbo)'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+        
+        # Build config
+        config = GardenerConfig(
+            threshold=args.threshold,
+            auto_commit=not args.no_commit,
+            llm_provider=args.llm if args.llm != 'none' else None,
+            llm_model=args.model
+        )
+        
+        # Create gardener
+        gardener = Gardener(repo, config)
+        
+        # Show status
+        episode_count = gardener.get_episode_count()
+        print(f"Episodic files: {episode_count}/{config.threshold}")
+        
+        if args.dry_run:
+            if gardener.should_run() or args.force:
+                episodes = gardener.load_episodes()
+                clusters = gardener.cluster_episodes(episodes)
+                
+                print(f"\nWould process {len(episodes)} episodes into {len(clusters)} clusters:")
+                for cluster in clusters:
+                    print(f"  - {cluster.topic}: {len(cluster.episodes)} episodes")
+                
+                print("\nRun without --dry-run to execute.")
+            else:
+                print("\nThreshold not met. Use --force to run anyway.")
+            return 0
+        
+        # Run gardener
+        if not gardener.should_run() and not args.force:
+            print("\nThreshold not met. Use --force to run anyway.")
+            return 0
+        
+        print("\nRunning Gardener...")
+        result = gardener.run(force=args.force)
+        
+        if result.success:
+            print(f"\nGardener completed:")
+            print(f"  Clusters found: {result.clusters_found}")
+            print(f"  Insights generated: {result.insights_generated}")
+            print(f"  Episodes archived: {result.episodes_archived}")
+            
+            if result.commit_hash:
+                print(f"  Commit: {result.commit_hash[:8]}")
+            
+            print(f"\n{result.message}")
+            return 0
+        else:
+            print(f"Gardener failed: {result.message}")
+            return 1

memvcs/commands/graph.py

@@ -0,0 +1,151 @@
+"""
+agmem graph - Visualize the knowledge graph.
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+from ..commands.base import require_repo
+
+
+class GraphCommand:
+    """Visualize connections between 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(
+            '--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)'
+        )
+        parser.add_argument(
+            '--threshold',
+            type=float,
+            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'
+        )
+    
+    @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')
+            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
+        )
+        
+        if args.serve:
+            return GraphCommand._serve_graph(repo, graph_data)
+        
+        if args.format == 'summary':
+            GraphCommand._print_summary(graph_data, builder)
+        
+        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':
+            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():
+            if count > 0:
+                print(f"  {mtype}: {count}")
+        
+        print("\nBy Edge Type:")
+        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:
+            print(f"\nIsolated files (no connections): {len(isolated)}")
+            for path in isolated[:5]:
+                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."""
+        try:
+            import uvicorn
+            from ..integrations.web_ui.server import create_app
+        except ImportError:
+            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

@@ -0,0 +1,61 @@
+"""
+agmem init - Initialize a new memory repository.
+"""
+
+import argparse
+from pathlib import Path
+
+from ..core.repository import Repository
+
+
+class InitCommand:
+    """Initialize a new agmem 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)'
+        )
+        parser.add_argument(
+            '--author-name',
+            default='Agent',
+            help='Default author name'
+        )
+        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
+            )
+            
+            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
+        except Exception as e:
+            print(f"Error initializing repository: {e}")
+            return 1

memvcs/commands/log.py

@@ -0,0 +1,103 @@
+"""
+agmem log - Show commit history.
+"""
+
+import argparse
+from datetime import datetime
+
+from ..commands.base import require_repo
+from ..core.repository import Repository
+
+
+class LogCommand:
+    """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'
+        )
+        parser.add_argument(
+            '--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(
+            'ref',
+            nargs='?',
+            help='Start from this reference (branch, tag, or commit)'
+        )
+    
+    @staticmethod
+    def execute(args) -> int:
+        repo, code = require_repo()
+        if code != 0:
+            return code
+
+        # 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']}")
+        elif args.graph:
+            # Simple ASCII graph
+            for i, commit in enumerate(commits):
+                prefix = "* " if i == 0 else "| "
+                print(f"{prefix}{commit['short_hash']} {commit['message']}")
+                if i < len(commits) - 1:
+                    print("|")
+        else:
+            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']:
+                        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 = ts[:-1]
+                    dt = datetime.fromisoformat(ts)
+                    date_str = dt.strftime('%a %b %d %H:%M:%S %Y')
+                    print(f"Date:   {date_str}")
+                except:
+                    print(f"Date:   {commit['timestamp']}")
+                
+                # Message
+                print()
+                print(f"    {commit['message']}")
+        
+        return 0

memvcs/commands/mcp.py

@@ -0,0 +1,59 @@
+"""
+agmem mcp - Run MCP server for Cursor/Claude integration.
+"""
+
+import argparse
+import sys
+
+
+class McpCommand:
+    """Run the agmem MCP server for Cursor/Claude."""
+
+    name = "mcp"
+    help = "Run MCP server for Cursor/Claude memory integration"
+
+    @staticmethod
+    def add_arguments(parser: argparse.ArgumentParser):
+        parser.add_argument(
+            "--transport",
+            choices=["stdio", "streamable-http"],
+            default="stdio",
+            help="Transport: stdio (default for Cursor/Claude) or streamable-http",
+        )
+        parser.add_argument(
+            "--port",
+            type=int,
+            default=8000,
+            help="Port for streamable-http (default: 8000)",
+        )
+
+    @staticmethod
+    def execute(args) -> int:
+        try:
+            from memvcs.integrations.mcp_server import _create_mcp_server
+
+            mcp = _create_mcp_server()
+        except ImportError as e:
+            print(
+                "Error: MCP support requires 'mcp' package (Python 3.10+). "
+                "Install with: pip install agmem[mcp]",
+                file=sys.stderr,
+            )
+            return 1
+
+        try:
+            if args.transport == "streamable-http":
+                mcp.run(transport="streamable-http", port=args.port)
+            else:
+                mcp.run(transport="stdio")
+        except TypeError:
+            # Some MCP versions may not support port kwarg
+            if args.transport == "streamable-http":
+                mcp.run(transport="streamable-http")
+            else:
+                mcp.run(transport="stdio")
+        except Exception as e:
+            print(f"Error running MCP server: {e}", file=sys.stderr)
+            return 1
+
+        return 0