cli-memory-os 0.1.0__py3-none-any.whl

cli/commands/init.py

@@ -0,0 +1,205 @@
+"""
+Command: memory-os init
+
+Performs first-time setup and onboarding for Memory-OS.
+Provisions the workspace directory structure, creates config.toml,
+spins up Neo4j and Qdrant via docker compose, initializes SQLite,
+pre-warms the embedding model, and launches Composio toolkit OAuth flows.
+"""
+
+import sys
+import uuid
+import time
+import os
+from pathlib import Path
+from infrastructure.workspace import ensure_workspace, get_db_path
+from infrastructure.config import generate_default_config, save_config, load_config
+from infrastructure.docker import check_docker_installed, check_docker_compose_installed, check_docker_running
+from infrastructure.compose import compose_up, wait_for_services
+from infrastructure.health import run_all_checks
+from storage.db import init_db
+from core.embedder import Embedder
+
+
+def get_input(prompt: str, secret: bool = False, default: str = "") -> str:
+    """Prompt the user for input with an optional default value."""
+    import getpass
+    suffix = f" [{default}]" if default else ""
+    full_prompt = f"{prompt}{suffix}: "
+    try:
+        if secret:
+            val = getpass.getpass(full_prompt)
+        else:
+            val = input(full_prompt)
+        return val.strip() or default
+    except (KeyboardInterrupt, EOFError):
+        print("\nInitialization cancelled by user.")
+        sys.exit(1)
+
+
+def execute(args):
+    """Run the init command."""
+    print("==================================================")
+    print("🧠 MEMORY-OS INITIALIZATION WIZARD")
+    print("==================================================")
+
+    # 1. System Dependency Checks
+    print("\n[1/7] Checking system dependencies...")
+    
+    python_ok = sys.version_info >= (3, 12)
+    py_ver = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    if not python_ok:
+        print(f"❌ Python version {py_ver} is not supported. Requires >= 3.12.")
+        sys.exit(1)
+    print(f"  ✓ Python version: {py_ver}")
+
+    docker_ok, docker_ver = check_docker_installed()
+    if not docker_ok:
+        print("----------------------------------")
+        print("Docker is not installed or not in PATH.")
+        print("")
+        print("Please install Docker Desktop and rerun:")
+        print("memory-os init")
+        print("----------------------------------")
+        sys.exit(1)
+    print(f"  ✓ Docker: {docker_ver}")
+
+    compose_ok, compose_ver = check_docker_compose_installed()
+    if not compose_ok:
+        print("----------------------------------")
+        print("Docker Compose is not installed.")
+        print("")
+        print("Please install Docker Compose and rerun:")
+        print("memory-os init")
+        print("----------------------------------")
+        sys.exit(1)
+    print(f"  ✓ Docker Compose: {compose_ver}")
+
+    if not check_docker_running():
+        print("----------------------------------")
+        print("Docker Desktop is not running.")
+        print("")
+        print("Start Docker Desktop and rerun:")
+        print("memory-os init")
+        print("----------------------------------")
+        sys.exit(1)
+    print("  ✓ Docker Daemon: Running")
+
+
+    # 2. Workspace Tree Setup
+    print("\n[2/7] Creating workspace directories...")
+    ensure_workspace("default")
+    print("  ✓ Workspace path initialized at ~/.memory-os")
+
+    # 3. Configure API Credentials & Settings
+    print("\n[3/7] Configuring credentials...")
+    neo4j_password = get_input("Set Neo4j database password", secret=True, default="memory_neo")
+    groq_api_key = get_input("Enter Groq API Key", secret=True)
+    composio_api_key = get_input("Enter Composio API Key", secret=True)
+
+    # Generate auto Composio User UUID
+    composio_user_id = str(uuid.uuid4())
+
+    answers = {
+        "neo4j_password": neo4j_password,
+        "groq_api_key": groq_api_key,
+        "composio_api_key": composio_api_key,
+        "composio_user_id": composio_user_id
+    }
+
+    config_dict = generate_default_config(answers)
+    save_config(config_dict)
+    
+    # Force reload config in current process memory
+    load_config()
+    
+    # Overwrite MEMORY_OS_DB_PATH in environment dynamically to point to the workspace DB
+    os.environ["MEMORY_OS_DB_PATH"] = str(get_db_path("default"))
+
+    print("  ✓ Configuration saved to ~/.memory-os/config.toml")
+
+    # 4. Service Provisioning via Docker Compose
+    print("\n[4/7] Provisioning local services (Neo4j, Qdrant)...")
+    if not compose_up():
+        print("❌ Failed to start docker compose services.")
+        sys.exit(1)
+    print("  ✓ Containers launched. Waiting for services to become healthy...")
+    
+    if not wait_for_services(timeout=60):
+        print("❌ Services failed to start or respond to health checks in time.")
+        sys.exit(1)
+    print("  ✓ Services are healthy.")
+
+    # 5. Schema & Database Initialization
+    print("\n[5/7] Initializing SQLite database...")
+    init_db()
+    print("  ✓ SQLite database schema initialized.")
+
+    # 6. Optional Embedding Model Warming
+    print("\n[6/7] Preparing embedding model...")
+    warm_model = get_input("Download and cache embedding model (all-MiniLM-L6-v2) now? (Y/n)", default="y").lower()
+    if warm_model == "y":
+        print("  Downloading model (this may take a minute)...")
+        try:
+            embedder = Embedder()
+            _ = embedder.model
+            print("  ✓ Embedding model cached successfully.")
+        except Exception as e:
+            print(f"  ⚠️ Warning: Failed to cache model during setup: {e}")
+            print("  Model will be downloaded automatically on the first query.")
+    else:
+        print("  Skipped model download.")
+
+    # 7. Optional Composio Integration OAuth
+    print("\n[7/7] Configuring integration connectors...")
+    setup_connectors = get_input("Configure connectors (GitHub, Gmail, Notion) now? (Y/n)", default="y").lower()
+    if setup_connectors == "y" and composio_api_key:
+        try:
+            from composio import Composio
+            c = Composio(api_key=composio_api_key)
+            session = c.create(user_id=composio_user_id)
+            
+            toolkits_to_connect = [
+                ("github", "GitHub"),
+                ("gmail", "Gmail"),
+                ("notion", "Notion")
+            ]
+            
+            for slug, name in toolkits_to_connect:
+                connect_this = get_input(f"Connect to {name}? (Y/n)", default="y").lower()
+                if connect_this == "y":
+                    print(f"  Initiating OAuth for {name}...")
+                    try:
+                        req = session.authorize(slug)
+                        print(f"  👉 Please open this URL in your browser to complete authentication:\n     {req.redirect_url}")
+                        print("  Waiting up to 30 seconds for completion...")
+                        try:
+                            # Wait for active connection
+                            req.wait_for_connection(timeout=30000)
+                            print(f"  ✓ {name} connected successfully!")
+                        except Exception:
+                            print(f"  ⚠️ Connection verification timed out. You can connect it later or run 'memory-os doctor'.")
+                    except Exception as err:
+                        print(f"  ⚠️ Failed to initiate connection for {name}: {err}")
+        except Exception as e:
+            print(f"  ⚠️ Error setting up Composio session: {e}")
+    else:
+        print("  Skipped connectors configuration.")
+
+    # Verification Report
+    print("\n==================================================")
+    print("🏥 RUNNING INITIAL HEALTH CHECKS")
+    print("==================================================")
+    checks = run_all_checks()
+    for name, passed, detail in checks:
+        icon = "✓" if passed else "✗"
+        print(f"  {icon} {name}: {detail}")
+    
+    print("\n==================================================")
+    print("🎉 MEMORY-OS INITIALIZED SUCCESSFULLY!")
+    print("==================================================")
+    print("You can now run: ")
+    print("  memory-os sync    - to import your documents and emails")
+    print("  memory-os ask     - to query your personal knowledge base")
+    print("  memory-os         - to launch the interactive menu")
+    print("==================================================")

cli/commands/logs.py

@@ -0,0 +1,38 @@
+"""
+Command: memory-os logs [--tail N]
+
+Tails the active log file to inspect system traces, errors, and indexing events.
+"""
+
+from pathlib import Path
+from infrastructure.workspace import get_logs_path
+
+
+def execute(args):
+    """Run the logs command."""
+    tail_count = args.tail
+    
+    # Resolve log file path
+    try:
+        log_file = get_logs_path() / "memory_os.log"
+    except Exception:
+        log_file = Path("logs/memory_os.log")
+
+    if not log_file.exists():
+        print(f"No log file found at '{log_file.resolve()}'. Run commands to generate logs.")
+        return
+
+    print(f"─────────────────────────────")
+    print(f"  Memory-OS Log Tail (Last {tail_count} lines)")
+    print(f"  File: {log_file.resolve()}")
+    print(f"─────────────────────────────")
+
+    try:
+        with open(log_file, "r", encoding="utf-8", errors="ignore") as f:
+            lines = f.readlines()
+            tail_lines = lines[-tail_count:]
+            for line in tail_lines:
+                print(line.rstrip())
+    except Exception as e:
+        print(f"❌ Failed to read log file: {e}")
+    print(f"─────────────────────────────")

cli/commands/monitor.py

@@ -0,0 +1,63 @@
+"""
+Command: memory-os monitor
+
+Displays system observability and performance latency diagnostics.
+"""
+
+from infrastructure.observability import get_performance_summary
+
+
+def execute(args):
+    """Run the status command."""
+    from storage.db import init_db
+    try:
+        init_db()
+    except Exception:
+        pass
+
+    print("──────────────────────────────────────────────────")
+    print("  Memory-OS Observability Dashboard")
+    print("──────────────────────────────────────────────────")
+    
+    summary = get_performance_summary()
+    
+    # Format and present results
+    print("  Sync Performance:")
+    print(f"    Total Sync Runs:      {summary['sync_count']}")
+    print(f"    Last Sync Duration:   {summary['last_sync_duration']:.2f}s")
+    print(f"    Avg Sync Duration:    {summary['avg_sync_duration']:.2f}s")
+    
+    print("\n  Data Insertion & indexing Latencies:")
+    if summary['avg_chunk_latency'] > 0:
+        print(f"    Avg Embedding Time:   {summary['avg_chunk_latency']*1000:.1f}ms / chunk")
+    else:
+        print("    Avg Embedding Time:   N/A (no events recorded)")
+        
+    if summary['avg_vector_latency'] > 0:
+        print(f"    Qdrant Upload Time:   {summary['avg_vector_latency']*1000:.1f}ms / vector")
+    else:
+        print("    Qdrant Upload Time:   N/A")
+        
+    if summary['avg_neo4j_sync'] > 0:
+        print(f"    Neo4j Graph Sync:     {summary['avg_neo4j_sync']:.2f}s (Total Nodes: {summary['total_nodes_synced']}, Rels: {summary['total_rels_synced']})")
+    else:
+        print("    Neo4j Graph Sync:     N/A")
+        
+    print("\n  LLM & RAG Query Latencies:")
+    print(f"    Total LLM Queries:    {summary['llm_call_count']}")
+    if summary['avg_llm_duration'] > 0:
+        print(f"    Avg LLM Call Time:    {summary['avg_llm_duration']:.2f}s")
+    else:
+        print("    Avg LLM Call Time:    N/A")
+        
+    if summary['avg_retrieval_duration'] > 0:
+        print(f"    Avg Retrieval Time:   {summary['avg_retrieval_duration']*1000:.1f}ms (hybrid)")
+    else:
+        print("    Avg Retrieval Time:   N/A")
+        
+    if summary['avg_rag_duration'] > 0:
+        print(f"    Average RAG Time:     {summary['avg_rag_duration']:.2f}s")
+    else:
+        print("    Average RAG Time:     N/A")
+
+    print("──────────────────────────────────────────────────")

cli/commands/plugins.py

@@ -0,0 +1,37 @@
+"""
+Command: memory-os plugins
+
+Displays installed and available connector plugins.
+"""
+
+from connectors.registry import discover_connectors
+
+
+def execute(args):
+    """Run the plugins command."""
+    print("─────────────────────────────")
+    print("  Memory-OS Connector Plugins")
+    print("─────────────────────────────")
+
+    # Discover active/installed connectors
+    installed = discover_connectors()
+    
+    print("  Installed (Active):")
+    for conn in installed:
+        print(f"    ✓ {conn.name} ({conn.slug})")
+
+    # Available but disabled / not-yet-integrated plugins
+    disabled = [
+        ("Slack", "slack"),
+        ("Jira", "jira"),
+        ("Google Drive", "google-drive")
+    ]
+    
+    print("\n  Disabled (Available):")
+    for name, slug in disabled:
+        print(f"    - {name} ({slug})")
+
+    print("─────────────────────────────")
+    print("  To enable, run: memory-os config set composio.api_key <key>")
+    print("  Then authenticate during: memory-os init")
+    print("─────────────────────────────")

cli/commands/start.py

@@ -0,0 +1,24 @@
+"""
+Command: memory-os start
+
+Starts the Docker services (Neo4j and Qdrant) via docker compose
+and waits for them to become healthy.
+"""
+
+import sys
+from infrastructure.compose import compose_up, wait_for_services
+
+
+def execute(args):
+    """Run the start command."""
+    print("Starting Memory-OS local services (Neo4j, Qdrant)...")
+    if not compose_up():
+        print("❌ Failed to run docker compose up.")
+        sys.exit(1)
+        
+    print("Waiting for services to become healthy...")
+    if not wait_for_services(timeout=60):
+        print("❌ Services failed to start or respond to health checks in time.")
+        sys.exit(1)
+        
+    print("✓ Services started successfully and are healthy.")

cli/commands/status.py

@@ -0,0 +1,92 @@
+"""
+Command: memory-os status
+
+Shows workspace and service status information.
+"""
+
+
+def execute(args):
+    """Run the status command."""
+    import logging
+    from infrastructure.workspace import get_active_profile, get_db_path
+
+    active = get_active_profile()
+    db_file = get_db_path(active)
+
+    # If the workspace database doesn't exist, show not initialized
+    if not db_file.exists():
+        print("----------------------------------")
+        print("Workspace not initialized.")
+        print("")
+        print("Run:")
+        print("memory-os init")
+        print("----------------------------------")
+        return
+
+    # Call init_db to ensure schema exists
+    try:
+        from storage.db import init_db
+        init_db()
+    except Exception as e:
+        logging.getLogger("cli.status").exception("Failed to initialize database schema")
+        print("----------------------------------")
+        print("Workspace not initialized.")
+        print("")
+        print("Run:")
+        print("memory-os init")
+        print("----------------------------------")
+        return
+
+    from storage.db import (
+        get_repo_count,
+        get_email_count,
+        get_repository_document_count,
+        get_document_chunk_count,
+    )
+    from core.vector_store import get_vector_index_stats
+
+    try:
+        repos = get_repo_count()
+        docs = get_repository_document_count()
+        emails = get_email_count()
+        chunks = get_document_chunk_count()
+        stats = get_vector_index_stats()
+        vectors = stats.get('vectors', 0)
+        embedding_model = stats.get('embedding_model', 'N/A')
+    except Exception as e:
+        logging.getLogger("cli.status").exception("SQLite OperationalError in status")
+        print("----------------------------------")
+        print("Workspace has not been initialized.")
+        print("")
+        print("Run:")
+        print("memory-os init")
+        print("----------------------------------")
+        return
+
+    # Check if empty (repos=0, docs=0, emails=0, vectors=0)
+    if repos == 0 and docs == 0 and emails == 0 and vectors == 0:
+        print("----------------------------------")
+        print(f"Workspace Profile : {active}")
+        print("")
+        print(f"Repositories : 0")
+        print(f"Documents    : 0")
+        print(f"Emails       : 0")
+        print(f"Vectors      : 0")
+        print("")
+        print("Workspace is initialized but contains no indexed data.")
+        print("")
+        print("Run:")
+        print("memory-os sync")
+        print("----------------------------------")
+    else:
+        print("─────────────────────────────")
+        print("  memory-os status")
+        print("─────────────────────────────")
+        print(f"  Repositories     {repos}")
+        print(f"  Documents        {docs}")
+        print(f"  Emails           {emails}")
+        print(f"  Chunks           {chunks}")
+        print(f"  Vectors          {vectors}")
+        print(f"  Embedding Model  {embedding_model}")
+        print("─────────────────────────────")
+

cli/commands/stop.py

@@ -0,0 +1,19 @@
+"""
+Command: memory-os stop
+
+Stops the Docker services (Neo4j and Qdrant) via docker compose stop.
+Keeps data volumes intact.
+"""
+
+import sys
+from infrastructure.compose import compose_stop
+
+
+def execute(args):
+    """Run the stop command."""
+    print("Stopping Memory-OS local services (Neo4j, Qdrant)...")
+    if not compose_stop():
+        print("❌ Failed to run docker compose stop.")
+        sys.exit(1)
+        
+    print("✓ Services stopped successfully. Data remains intact.")

cli/commands/version.py

@@ -0,0 +1,25 @@
+"""
+Command: memory-os version
+
+Shows Memory-OS version, Python version, and Docker version.
+"""
+
+import sys
+
+
+def execute(args):
+    """Run the version command."""
+    from infrastructure.docker import check_docker_installed
+    from infrastructure.health import _get_version
+
+    version = _get_version()
+    python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+
+    docker_available, docker_version = check_docker_installed()
+
+    print(f"Memory-OS  {version}")
+    print(f"Python     {python_version}")
+    if docker_available:
+        print(f"Docker     {docker_version}")
+    else:
+        print("Docker     not installed")

cli/commands/workspace.py

@@ -0,0 +1,154 @@
+"""
+Command: memory-os workspace create|switch|list|delete|info
+
+Provides management of active workspaces and profile structures.
+"""
+
+import sys
+import shutil
+import os
+from datetime import datetime
+from pathlib import Path
+from infrastructure.workspace import (
+    get_active_profile,
+    list_profiles,
+    create_profile,
+    delete_profile,
+    set_active_profile,
+    get_workspace_size,
+    get_profile_path,
+    get_db_path
+)
+
+
+def execute(args):
+    """Run the workspace command."""
+    action = args.workspace_action
+
+    if action == "list":
+        profiles = list_profiles()
+        active = get_active_profile()
+        print("─────────────────────────────")
+        print("  Memory-OS Workspace Profiles")
+        print("─────────────────────────────")
+        for p in profiles:
+            prefix = "* " if p == active else "  "
+            print(f"{prefix}{p}")
+        print("─────────────────────────────")
+
+    elif action == "create":
+        name = args.name
+        try:
+            create_profile(name)
+            print(f"✓ Workspace profile '{name}' created successfully.")
+        except Exception as e:
+            print(f"❌ Failed to create workspace profile: {e}")
+            sys.exit(1)
+
+    elif action == "switch":
+        name = args.name
+        try:
+            set_active_profile(name)
+            print(f"✓ Switched active workspace profile to '{name}'.")
+        except Exception as e:
+            print(f"❌ Failed to switch workspace profile: {e}")
+            sys.exit(1)
+
+    elif action == "delete":
+        name = args.name
+        active = get_active_profile()
+        if name == active:
+            print(f"❌ Cannot delete the currently active workspace profile '{name}'. Switch first.")
+            sys.exit(1)
+
+        confirm = input(f"⚠️ Are you sure you want to delete workspace profile '{name}' and ALL its databases? (y/N): ").strip().lower()
+        if confirm == "y":
+            try:
+                delete_profile(name)
+                print(f"✓ Workspace profile '{name}' deleted successfully.")
+            except Exception as e:
+                print(f"❌ Failed to delete workspace profile: {e}")
+                sys.exit(1)
+        else:
+            print("Deletion cancelled.")
+
+    elif action == "info":
+        active = get_active_profile()
+        path = get_profile_path(active)
+        db_file = get_db_path(active)
+
+        # Retrieve counts
+        repos = 0
+        vectors = 0
+        nodes = 0
+        last_sync = "Never"
+
+        try:
+            from storage.db import get_repo_count
+            repos = get_repo_count()
+        except Exception:
+            pass
+
+        try:
+            from core.vector_store import get_vector_index_stats
+            vectors = get_vector_index_stats().get("vectors", 0)
+        except Exception:
+            pass
+
+        try:
+            from storage.graph import GraphStore
+            graph = GraphStore()
+            if graph.is_fallback:
+                from storage.db import get_connection
+                conn = get_connection()
+                cursor = conn.cursor()
+                cursor.execute("SELECT COUNT(*) FROM graph_nodes")
+                nodes = cursor.fetchone()[0]
+                conn.close()
+            else:
+                with graph.driver.session() as session:
+                    nodes = session.run("MATCH (n) RETURN count(n) AS c").single()["c"]
+        except Exception:
+            pass
+
+        # Calculate last sync timestamp from DB file modification or max chunk created_at
+        if db_file.exists():
+            try:
+                from storage.db import get_connection
+                conn = get_connection()
+                cursor = conn.cursor()
+                cursor.execute("SELECT MAX(created_at) FROM document_chunks")
+                row = cursor.fetchone()
+                if row and row[0]:
+                    last_sync = row[0][:19].replace("T", " ")
+                else:
+                    mtime = os.path.getmtime(db_file)
+                    last_sync = datetime.fromtimestamp(mtime).strftime('%Y-%m-%d %H:%M:%S')
+                conn.close()
+            except Exception:
+                import os
+                from datetime import datetime
+                mtime = os.path.getmtime(db_file)
+                last_sync = datetime.fromtimestamp(mtime).strftime('%Y-%m-%d %H:%M:%S')
+
+        size_bytes = get_workspace_size(active)
+        if size_bytes < 1024 * 1024:
+            size_str = f"{size_bytes / 1024:.0f} KB"
+        elif size_bytes < 1024 * 1024 * 1024:
+            size_str = f"{size_bytes / (1024 * 1024):.1f} MB"
+        else:
+            size_str = f"{size_bytes / (1024 * 1024 * 1024):.2f} GB"
+
+        print("──────────────────────────────────────────────────")
+        print(f"  Memory-OS Workspace Info: {active}")
+        print("──────────────────────────────────────────────────")
+        print(f"  Profile Location:  {path.resolve()}")
+        print(f"  Repositories:      {repos}")
+        print(f"  Vectors:           {vectors}")
+        print(f"  Graph Nodes:       {nodes}")
+        print(f"  Disk Storage Size: {size_str}")
+        print(f"  Last Sync Time:    {last_sync}")
+        print("──────────────────────────────────────────────────")
+
+    else:
+        print("Usage: memory-os workspace create|switch|list|delete|info")