aegis-memory 1.2.0__py3-none-any.whl

aegis_memory/__init__.py

@@ -0,0 +1,47 @@
+"""
+Aegis Memory - Agent-native memory fabric for AI agents.
+
+Aegis Memory is an open-source, self-hostable memory engine for LLM agents with:
+- Agent-native semantics (namespace, scope, multi-agent ACLs)
+- First-class multi-agent support (cross-agent queries, structured handoffs)
+- Context-engineering patterns (ACE-style voting, deltas, reflections, playbooks)
+- Production-oriented design (FastAPI + Postgres + pgvector)
+
+Quick Start:
+    from aegis_memory import AegisClient
+    
+    client = AegisClient(api_key="your-key", base_url="http://localhost:8000")
+    
+    # Add a memory
+    result = client.add("User prefers dark mode", agent_id="ui-agent")
+    
+    # Query memories  
+    memories = client.query("user preferences", agent_id="ui-agent")
+    
+    # Cross-agent query with access control
+    memories = client.query_cross_agent(
+        "user settings",
+        requesting_agent_id="settings-agent"
+    )
+
+For more examples, see: https://github.com/quantifylabs/aegis-memory/tree/main/examples
+"""
+
+__version__ = "1.2.0"
+
+from aegis_memory.client import (
+    AegisClient,
+    Memory,
+    PlaybookEntry,
+    SessionProgress,
+    Feature,
+)
+
+__all__ = [
+    "AegisClient",
+    "Memory",
+    "PlaybookEntry",
+    "SessionProgress",
+    "Feature",
+    "__version__",
+]

aegis_memory/cli/__init__.py

@@ -0,0 +1,9 @@
+"""
+Aegis Memory CLI
+
+Terminal-first interface for Aegis Memory operations.
+"""
+
+from aegis_memory.cli.main import app
+
+__all__ = ["app"]

aegis_memory/cli/commands/__init__.py

@@ -0,0 +1,29 @@
+"""
+Aegis CLI Commands
+
+All command implementations.
+"""
+
+from aegis_memory.cli.commands.config import app as config_app
+from aegis_memory.cli.commands import (
+    status,
+    stats,
+    memory,
+    vote,
+    progress,
+    features,
+    playbook,
+    export_import,
+)
+
+__all__ = [
+    "config_app",
+    "status",
+    "stats", 
+    "memory",
+    "vote",
+    "progress",
+    "features",
+    "playbook",
+    "export_import",
+]

aegis_memory/cli/commands/config.py

@@ -0,0 +1,208 @@
+"""
+Aegis CLI Config Command
+
+Configuration management: init, show, set, use profiles.
+"""
+
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+
+from aegis_memory.cli.utils.config import (
+    load_config,
+    save_config,
+    load_credentials,
+    save_credentials,
+    get_config_path,
+    get_credentials_path,
+    get_active_profile,
+    set_nested_value,
+    get_nested_value,
+)
+from aegis_memory.cli.utils.auth import get_client, get_api_key
+from aegis_memory.cli.utils.output import print_success, print_error, print_warning
+
+app = typer.Typer(help="Configuration management")
+console = Console()
+
+
+@app.command()
+def init(
+    non_interactive: bool = typer.Option(False, "--non-interactive", "-y", help="Use defaults without prompting"),
+):
+    """
+    Interactive first-run setup.
+    
+    Creates configuration and credentials files.
+    """
+    console.print("\n[bold]Welcome to Aegis Memory CLI![/bold]\n")
+    
+    config = load_config()
+    credentials = load_credentials()
+    
+    if non_interactive:
+        # Use defaults
+        api_url = "http://localhost:8000"
+        api_key = "dev-key"
+        namespace = "default"
+        agent_id = "cli-user"
+    else:
+        # Interactive prompts
+        api_url = Prompt.ask(
+            "Server URL",
+            default="http://localhost:8000"
+        )
+        
+        api_key = Prompt.ask(
+            "API Key",
+            password=True,
+            default="dev-key"
+        )
+        
+        namespace = Prompt.ask(
+            "Default namespace",
+            default="default"
+        )
+        
+        agent_id = Prompt.ask(
+            "Default agent ID",
+            default="cli-user"
+        )
+    
+    # Update config
+    config["profiles"]["local"] = {
+        "api_url": api_url,
+        "api_key_env": "AEGIS_API_KEY",
+        "default_namespace": namespace,
+        "default_agent_id": agent_id,
+    }
+    config["default_profile"] = "local"
+    
+    # Update credentials
+    if "profiles" not in credentials:
+        credentials["profiles"] = {}
+    credentials["profiles"]["local"] = {"api_key": api_key}
+    
+    # Save
+    save_config(config)
+    save_credentials(credentials)
+    
+    print_success(f"Configuration saved to {get_config_path()}")
+    print_success(f"Credentials saved to {get_credentials_path()}")
+    
+    # Test connection
+    if not non_interactive:
+        if Confirm.ask("\nTest connection?", default=True):
+            _test_connection()
+    else:
+        _test_connection()
+
+
+def _test_connection():
+    """Test connection to server."""
+    try:
+        client = get_client()
+        if client is None:
+            print_error("No API key configured")
+            return
+        
+        response = client.client.get("/health")
+        response.raise_for_status()
+        health = response.json()
+        
+        version = health.get("version", "unknown")
+        status = health.get("status", "unknown")
+        
+        if status == "healthy":
+            print_success(f"Connected to Aegis v{version} ({status})")
+        else:
+            print_warning(f"Connected to Aegis v{version} ({status})")
+            
+    except Exception as e:
+        print_error(f"Connection failed: {str(e)}")
+
+
+@app.command()
+def show():
+    """Show current configuration."""
+    config = load_config()
+    profile_name = config.get("default_profile", "local")
+    profile = get_active_profile(config)
+    
+    console.print(f"\n[bold]Profile:[/bold] {profile_name} (active)")
+    console.print(f"[bold]API URL:[/bold] {profile.get('api_url', 'not set')}")
+    console.print(f"[bold]Namespace:[/bold] {profile.get('default_namespace', 'default')}")
+    console.print(f"[bold]Agent ID:[/bold] {profile.get('default_agent_id', 'cli-user')}")
+    
+    output_config = config.get("output", {})
+    console.print(f"[bold]Output:[/bold] {output_config.get('format', 'table')}")
+    
+    # Show API key status (masked)
+    api_key = get_api_key(config)
+    if api_key:
+        masked = api_key[:4] + "..." + api_key[-4:] if len(api_key) > 8 else "****"
+        console.print(f"[bold]API Key:[/bold] {masked}")
+    else:
+        console.print("[bold]API Key:[/bold] [red]not configured[/red]")
+    
+    console.print(f"\n[dim]Config: {get_config_path()}[/dim]")
+
+
+@app.command("set")
+def set_value(
+    key: str = typer.Argument(..., help="Config key (e.g., profiles.local.api_url)"),
+    value: str = typer.Argument(..., help="Value to set"),
+):
+    """Set a configuration value."""
+    config = load_config()
+    
+    keys = key.split(".")
+    set_nested_value(config, keys, value)
+    save_config(config)
+    
+    print_success(f"Set {key} = {value}")
+
+
+@app.command()
+def use(
+    profile: str = typer.Argument(..., help="Profile name to switch to"),
+):
+    """Switch to a different profile."""
+    config = load_config()
+    
+    if profile not in config.get("profiles", {}):
+        print_error(f"Profile '{profile}' not found")
+        console.print("\nAvailable profiles:")
+        for name in config.get("profiles", {}).keys():
+            console.print(f"  - {name}")
+        raise typer.Exit(1)
+    
+    config["default_profile"] = profile
+    save_config(config)
+    
+    print_success(f"Switched to profile: {profile}")
+
+
+@app.command()
+def profiles():
+    """List all configured profiles."""
+    config = load_config()
+    current = config.get("default_profile", "local")
+    
+    console.print("\n[bold]Configured Profiles[/bold]\n")
+    
+    for name, profile in config.get("profiles", {}).items():
+        marker = "[green]●[/green]" if name == current else "[dim]○[/dim]"
+        console.print(f"  {marker} {name}")
+        console.print(f"      URL: {profile.get('api_url', 'not set')}")
+        console.print(f"      Namespace: {profile.get('default_namespace', 'default')}")
+        console.print()
+
+
+@app.command()
+def path():
+    """Show configuration file paths."""
+    console.print(f"[bold]Config:[/bold] {get_config_path()}")
+    console.print(f"[bold]Credentials:[/bold] {get_credentials_path()}")

aegis_memory/cli/commands/export_import.py

@@ -0,0 +1,205 @@
+"""
+Aegis CLI Export/Import Commands
+
+Data export and import for backup and migration.
+"""
+
+import json
+import sys
+import typer
+from typing import Optional
+from pathlib import Path
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from aegis_memory.cli.utils.auth import get_client, get_default_namespace
+from aegis_memory.cli.utils.output import print_json, print_success, print_error
+from aegis_memory.cli.utils.errors import wrap_errors, require_client, handle_api_error
+
+console = Console()
+
+
+@wrap_errors
+def export(
+    namespace: Optional[str] = typer.Option(None, "--namespace", "-n", help="Filter by namespace (default: all)"),
+    agent: Optional[str] = typer.Option(None, "--agent", "-a", help="Filter by agent ID"),
+    format: str = typer.Option("jsonl", "--format", "-f", help="Format: jsonl or json"),
+    include_embeddings: bool = typer.Option(False, "--include-embeddings", help="Include embedding vectors"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file (default: stdout)"),
+    limit: Optional[int] = typer.Option(None, "--limit", help="Max memories to export"),
+):
+    """
+    Export memories for backup or migration.
+    
+    Examples:
+        aegis export > backup.jsonl
+        aegis export -o backup.jsonl
+        aegis export -n production -f json -o prod-backup.json
+        aegis export --include-embeddings -o full-backup.jsonl
+    """
+    if format not in ("jsonl", "json"):
+        print_error("Format must be 'jsonl' or 'json'")
+        raise typer.Exit(1)
+    
+    client = require_client()
+    
+    # Build request
+    params = {"format": format}
+    if namespace:
+        params["namespace"] = namespace
+    if agent:
+        params["agent_id"] = agent
+    if include_embeddings:
+        params["include_embeddings"] = True
+    if limit:
+        params["limit"] = limit
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        progress.add_task(description="Exporting memories...", total=None)
+        
+        try:
+            response = client.client.post("/memories/export", json=params)
+            response.raise_for_status()
+        except Exception as e:
+            handle_api_error(e, "export")
+    
+    # Handle output
+    if format == "jsonl":
+        # Streaming response
+        content = response.text
+        lines = content.strip().split("\n") if content.strip() else []
+        count = len(lines)
+        
+        if output:
+            output.write_text(content)
+            print_success(f"Exported {count} memories to {output}")
+        else:
+            # Output to stdout
+            console.print(content, end="")
+            if sys.stdout.isatty():
+                console.print(f"\n[dim]Exported {count} memories[/dim]", err=True)
+    else:
+        # JSON response
+        data = response.json()
+        memories = data.get("memories", [])
+        count = len(memories)
+        
+        if output:
+            with open(output, "w") as f:
+                json.dump(data, f, indent=2, default=str)
+            print_success(f"Exported {count} memories to {output}")
+        else:
+            console.print(json.dumps(data, indent=2, default=str))
+            if sys.stdout.isatty():
+                console.print(f"\n[dim]Exported {count} memories[/dim]", err=True)
+
+
+@wrap_errors
+def import_memories(
+    file: Path = typer.Argument(..., help="File to import from"),
+    namespace: Optional[str] = typer.Option(None, "--namespace", "-n", help="Override namespace"),
+    agent: Optional[str] = typer.Option(None, "--agent", "-a", help="Override agent ID"),
+    skip_duplicates: bool = typer.Option(True, "--skip-duplicates/--no-skip-duplicates", help="Skip content duplicates"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Validate without importing"),
+):
+    """
+    Import memories from export file.
+    
+    Examples:
+        aegis import backup.jsonl
+        aegis import backup.json -n staging
+        aegis import backup.jsonl --dry-run
+    """
+    if not file.exists():
+        print_error(f"File not found: {file}")
+        raise typer.Exit(1)
+    
+    client = require_client()
+    
+    # Detect format
+    content = file.read_text()
+    
+    if file.suffix == ".json" or content.strip().startswith("{"):
+        # JSON format
+        try:
+            data = json.loads(content)
+            memories = data.get("memories", [])
+        except json.JSONDecodeError as e:
+            print_error(f"Invalid JSON: {e}")
+            raise typer.Exit(1)
+    else:
+        # JSONL format
+        memories = []
+        for line in content.strip().split("\n"):
+            if line.strip():
+                try:
+                    memories.append(json.loads(line))
+                except json.JSONDecodeError as e:
+                    print_error(f"Invalid JSONL line: {e}")
+                    raise typer.Exit(1)
+    
+    if not memories:
+        print_error("No memories found in file")
+        raise typer.Exit(1)
+    
+    if dry_run:
+        console.print(f"\n[bold]Dry run[/bold] - would import {len(memories)} memories")
+        
+        # Show sample
+        if memories:
+            sample = memories[0]
+            console.print(f"\nSample memory:")
+            console.print(f"  Content: {sample.get('content', '')[:60]}...")
+            console.print(f"  Agent: {namespace or sample.get('agent_id', '-')}")
+            console.print(f"  Namespace: {agent or sample.get('namespace', 'default')}")
+        
+        return
+    
+    # Import memories
+    imported = 0
+    skipped = 0
+    errors = 0
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task(description="Importing...", total=len(memories))
+        
+        for mem in memories:
+            try:
+                # Override namespace/agent if specified
+                mem_namespace = namespace or mem.get("namespace", "default")
+                mem_agent = agent or mem.get("agent_id")
+                
+                result = client.add(
+                    content=mem.get("content", ""),
+                    agent_id=mem_agent,
+                    user_id=mem.get("user_id"),
+                    namespace=mem_namespace,
+                    scope=mem.get("scope"),
+                    metadata=mem.get("metadata"),
+                )
+                
+                if result.deduped_from and skip_duplicates:
+                    skipped += 1
+                else:
+                    imported += 1
+                    
+            except Exception as e:
+                errors += 1
+            
+            progress.update(task, advance=1)
+    
+    # Summary
+    print_success(f"Imported {imported} memories")
+    if skipped:
+        console.print(f"  [dim]Skipped (duplicate): {skipped}[/dim]")
+    if errors:
+        console.print(f"  [yellow]Errors: {errors}[/yellow]")