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

cli/__init__.py

@@ -0,0 +1 @@
+# cli package

cli/commands/__init__.py

@@ -0,0 +1 @@
+# cli.commands package

cli/commands/benchmark.py

@@ -0,0 +1,151 @@
+"""
+Command: memory-os benchmark
+
+Runs performance latency diagnostics across search indexes, embedding model,
+graph lookups, LLM invocation, and RAG pipelines.
+"""
+
+import time
+import sys
+from infrastructure.health import check_neo4j, check_qdrant, check_groq_api, check_memory_usage
+from core.embedder import Embedder
+
+
+def execute(args):
+    """Run the benchmark command."""
+    from storage.db import init_db
+    try:
+        init_db()
+    except Exception:
+        pass
+
+    print("──────────────────────────────────────────────────")
+    print("  Memory-OS Performance Benchmark")
+    print("──────────────────────────────────────────────────")
+    print("  Running latency measurements (please wait)...")
+
+    # Metrics dictionary
+    latencies = {
+        "Keyword Search": "N/A",
+        "Semantic Search": "N/A",
+        "Hybrid Search": "N/A",
+        "Graph Lookup": "N/A",
+        "Embedding Time": "N/A",
+        "LLM Time": "N/A",
+        "Average RAG Pipeline": "N/A",
+        "Memory Usage": "N/A",
+        "Vector Count": "0",
+    }
+
+    # 1. Memory Usage
+    _, mem_detail = check_memory_usage()
+    latencies["Memory Usage"] = mem_detail
+
+    # 2. Embedding Time
+    try:
+        start = time.perf_counter()
+        embedder = Embedder()
+        embedder.embed_documents(["This is a test snippet to benchmark the local embedding model latency."])
+        duration = time.perf_counter() - start
+        latencies["Embedding Time"] = f"{duration*1000:.1f} ms"
+    except Exception as e:
+        latencies["Embedding Time"] = f"Error: {e}"
+
+    # 3. SQLite Keyword Search
+    try:
+        from storage.db import get_connection
+        conn = get_connection()
+        cursor = conn.cursor()
+        
+        # Test full text search query on SQLite
+        start = time.perf_counter()
+        cursor.execute("SELECT id FROM document_chunks WHERE chunk_text LIKE '%python%' LIMIT 5")
+        cursor.fetchall()
+        duration = time.perf_counter() - start
+        latencies["Keyword Search"] = f"{duration*1000:.2f} ms"
+        conn.close()
+    except Exception as e:
+        latencies["Keyword Search"] = f"Error: {e}"
+
+    # 4. Qdrant Semantic Search
+    qdrant_ok, _ = check_qdrant()
+    if qdrant_ok:
+        try:
+            from core.vector_store import run_semantic_search, get_vector_index_stats
+            # Vector count
+            stats = get_vector_index_stats()
+            latencies["Vector Count"] = f"{stats.get('vectors', 0):,}"
+            
+            # Semantic Query
+            start = time.perf_counter()
+            run_semantic_search("python", limit=5)
+            duration = time.perf_counter() - start
+            latencies["Semantic Search"] = f"{duration*1000:.2f} ms"
+        except Exception as e:
+            latencies["Semantic Search"] = f"Error: {e}"
+    else:
+        latencies["Semantic Search"] = "Offline (Qdrant down)"
+
+    # 5. Hybrid Search
+    if qdrant_ok:
+        try:
+            from core.vector_store import hybrid_search
+            start = time.perf_counter()
+            hybrid_search("python")
+            duration = time.perf_counter() - start
+            latencies["Hybrid Search"] = f"{duration*1000:.2f} ms"
+        except Exception as e:
+            latencies["Hybrid Search"] = f"Error: {e}"
+    else:
+        latencies["Hybrid Search"] = "Offline (Qdrant down)"
+
+    # 6. Graph Lookup
+    try:
+        from storage.graph import GraphStore
+        graph = GraphStore()
+        
+        # Get arbitrary repo to query
+        from storage.db import get_connection
+        conn = get_connection()
+        cursor = conn.cursor()
+        cursor.execute("SELECT repo_name FROM repositories LIMIT 1")
+        row = cursor.fetchone()
+        conn.close()
+        
+        repo_to_query = row[0] if row else "unknown-repo"
+        
+        start = time.perf_counter()
+        graph.get_node_relationships("Repository", repo_to_query)
+        duration = time.perf_counter() - start
+        latencies["Graph Lookup"] = f"{duration*1000:.2f} ms"
+    except Exception as e:
+        latencies["Graph Lookup"] = f"Error: {e}"
+
+    # 7. LLM time & RAG Pipeline
+    groq_ok, _ = check_groq_api()
+    if groq_ok:
+        try:
+            from core.llm import run_hybrid_rag
+            start = time.perf_counter()
+            res = run_hybrid_rag("List repositories using Python")
+            duration = time.perf_counter() - start
+            latencies["Average RAG Pipeline"] = f"{duration:.2f} s"
+            
+            # Estimate LLM time
+            # Assuming LLM call took most of RAG duration (minus search overhead)
+            latencies["LLM Time"] = f"{duration * 0.85:.2f} s"
+        except Exception as e:
+            latencies["Average RAG Pipeline"] = f"Error: {e}"
+            latencies["LLM Time"] = "Error"
+    else:
+        latencies["Average RAG Pipeline"] = "Offline (Groq key missing)"
+        latencies["LLM Time"] = "Offline"
+
+    # Display results
+    print("──────────────────────────────────────────────────")
+    print("  Benchmark Metrics")
+    print("──────────────────────────────────────────────────")
+    for name, score in latencies.items():
+        padding = " " * (25 - len(name))
+        print(f"  {name}{padding}: {score}")
+    print("──────────────────────────────────────────────────")

cli/commands/config_cmd.py

@@ -0,0 +1,57 @@
+"""
+Command: memory-os config show|get|set|reset
+
+Enables querying and modification of key-value configuration pairs.
+"""
+
+import sys
+from infrastructure.config import (
+    get_config,
+    get_dotted,
+    set_dotted,
+    save_config,
+    DEFAULTS
+)
+
+
+def execute(args):
+    """Run the config command."""
+    action = args.config_action
+
+    if action == "show":
+        config = get_config()
+        print("─────────────────────────────")
+        print("  Memory-OS Configuration")
+        print("─────────────────────────────")
+        for key, val in config.items():
+            if isinstance(val, dict):
+                print(f"[{key}]")
+                for k, v in val.items():
+                    print(f"  {k} = {v}")
+            else:
+                print(f"{key} = {val}")
+        print("─────────────────────────────")
+
+    elif action == "get":
+        val = get_dotted(args.key)
+        if val is None:
+            print(f"❌ Configuration key '{args.key}' not found.")
+            sys.exit(1)
+        print(val)
+
+    elif action == "set":
+        success, err = set_dotted(args.key, args.value)
+        if not success:
+            print(f"❌ Failed to set configuration: {err}")
+            sys.exit(1)
+        print(f"✓ Configuration updated: {args.key} = {args.value}")
+
+    elif action == "reset":
+        confirm = input("⚠️ Are you sure you want to reset ALL configurations to default values? (y/N): ").strip().lower()
+        if confirm == "y":
+            save_config(DEFAULTS)
+            print("✓ Configuration reset to defaults successfully.")
+        else:
+            print("Reset cancelled.")
+    else:
+        print("Usage: memory-os config show|get|set|reset")

cli/commands/doctor.py

@@ -0,0 +1,61 @@
+"""
+Command: memory-os doctor
+
+Diagnoses system health and connectivity across all services.
+"""
+
+
+def execute(args):
+    """Run the doctor command."""
+    from storage.db import init_db
+    try:
+        init_db()
+    except Exception:
+        pass
+
+    from infrastructure.health import run_all_checks
+
+    print("─────────────────────────────")
+    print("  memory-os doctor")
+    print("─────────────────────────────")
+
+    checks = run_all_checks()
+
+    max_name_len = max(len(name) for name, _, _ in checks)
+
+    for name, passed, detail in checks:
+        icon = "✓" if passed else "✗"
+        padding = " " * (max_name_len - len(name) + 2)
+        print(f"  {name}{padding}{icon} {detail}")
+
+    print("─────────────────────────────")
+
+    failed = [(name, detail) for name, passed, detail in checks if not passed]
+    if failed:
+        print(f"\n  {len(failed)} issue(s) detected.")
+        print("\n─────────────────────────────")
+        print("  Actionable Recommendations")
+        print("─────────────────────────────")
+        recommendations = {
+            "Docker": "Install Docker Desktop from https://www.docker.com/",
+            "Docker Compose": "Ensure Docker Compose is installed ('docker compose version').",
+            "Neo4j": "Run:\n  memory-os start",
+            "Qdrant": "Run:\n  memory-os start",
+            "Groq": "memory-os config set groq.api_key <key>",
+            "Composio": "memory-os config set composio.api_key <key>",
+            "SQLite": "Workspace not initialized. Run memory-os init.",
+            "Github": "Authenticate GitHub connector: run 'memory-os init'",
+            "Gmail": "Authenticate Gmail connector: run 'memory-os init'",
+            "Notion": "Authenticate Notion connector: run 'memory-os init'",
+            "Workspace": "Workspace not initialized.\nRun: memory-os init",
+            "Embedding Model": "Download embedding model: run 'memory-os init'",
+            "Config Validation": "Reset config.toml file: run 'memory-os config reset'",
+            "Active Plugins": "No plugins are authenticated. Run 'memory-os init' to set up connector logins.",
+        }
+        for name, detail in failed:
+            rec = recommendations.get(name, "Check log file logs/memory_os.log for errors.")
+            print(f"  * {name}: {rec} (Detail: {detail})")
+        print("─────────────────────────────")
+    else:
+        print("\n  All checks passed.")
+

cli/commands/export.py

@@ -0,0 +1,106 @@
+"""
+Command: memory-os export <file>
+
+Exports the current active workspace profile databases, configurations,
+and metadata into a single compressed zip archive.
+"""
+
+import sys
+import os
+import json
+import zipfile
+from pathlib import Path
+from datetime import datetime
+
+from infrastructure.workspace import (
+    get_active_profile,
+    get_profile_path,
+    get_db_path,
+    get_qdrant_path,
+    get_neo4j_path,
+    get_workspace_size
+)
+from infrastructure.config import _get_config_path, get
+
+
+def execute(args):
+    """Run the export command."""
+    export_path = Path(args.file)
+    print(f"Exporting active workspace profile to '{export_path}'...")
+
+    active_profile = get_active_profile()
+    profile_path = get_profile_path(active_profile)
+    db_path = get_db_path(active_profile)
+    qdrant_path = get_qdrant_path(active_profile)
+    neo4j_path = get_neo4j_path(active_profile)
+    config_path = _get_config_path()
+
+    if not profile_path.exists():
+        print(f"❌ Active workspace profile '{active_profile}' does not exist.")
+        sys.exit(1)
+
+    # 1. Gather Metadata
+    embedding_model = get("embeddings", "model", "all-MiniLM-L6-v2")
+    metadata = {
+        "version": "1.0",
+        "exported_at": datetime.now().isoformat(),
+        "active_profile": active_profile,
+        "embedding_model": embedding_model,
+        "storage_size_bytes": get_workspace_size(active_profile),
+    }
+
+    try:
+        # Resolve export file parent directory exists
+        if export_path.parent:
+            export_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with zipfile.ZipFile(export_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+            # A. Metadata File
+            zipf.writestr("metadata.json", json.dumps(metadata, indent=2))
+            print("  ✓ Packed metadata.json")
+
+            # B. Configuration File
+            if config_path.exists():
+                zipf.write(config_path, arcname="config.toml")
+                print("  ✓ Packed config.toml")
+
+            # C. SQLite Database
+            if db_path.exists():
+                zipf.write(db_path, arcname="workspace.db")
+                print("  ✓ Packed SQLite database")
+
+            # D. Qdrant storage folder recursively
+            if qdrant_path.exists():
+                qdrant_files_count = 0
+                for root, _, files in os.walk(qdrant_path):
+                    for file in files:
+                        file_path = Path(root) / file
+                        arcname = Path("qdrant") / file_path.relative_to(qdrant_path)
+                        zipf.write(file_path, arcname=arcname)
+                        qdrant_files_count += 1
+                print(f"  ✓ Packed {qdrant_files_count} Qdrant index files")
+
+            # E. Neo4j storage folder recursively
+            if neo4j_path.exists():
+                neo4j_files_count = 0
+                for root, _, files in os.walk(neo4j_path):
+                    for file in files:
+                        file_path = Path(root) / file
+                        arcname = Path("neo4j") / file_path.relative_to(neo4j_path)
+                        zipf.write(file_path, arcname=arcname)
+                        neo4j_files_count += 1
+                print(f"  ✓ Packed {neo4j_files_count} Neo4j graph database files")
+
+        print("──────────────────────────────────────────────────")
+        print(f"🎉 Workspace profile '{active_profile}' exported successfully!")
+        print(f"File: {export_path.resolve()}")
+        print("──────────────────────────────────────────────────")
+
+    except Exception as e:
+        print(f"❌ Failed to export workspace: {e}")
+        if export_path.exists():
+            try:
+                export_path.unlink()
+            except OSError:
+                pass
+        sys.exit(1)

cli/commands/import_cmd.py

@@ -0,0 +1,143 @@
+"""
+Command: memory-os import <file>
+
+Safely unpacks and restores a previously exported workspace archive
+into the active workspace profile.
+"""
+
+import sys
+import os
+import json
+import zipfile
+import shutil
+from pathlib import Path
+
+from infrastructure.workspace import (
+    get_active_profile,
+    get_profile_path,
+    get_db_path,
+    get_qdrant_path,
+    get_neo4j_path
+)
+from infrastructure.config import _get_config_path, get, load_config
+from infrastructure.compose import compose_stop, compose_up, wait_for_services
+
+
+def execute(args):
+    """Run the import command."""
+    import_path = Path(args.file)
+    if not import_path.exists():
+        print(f"❌ Import file '{import_path}' does not exist.")
+        sys.exit(1)
+
+    print(f"Verifying compatibility of '{import_path}'...")
+
+    try:
+        with zipfile.ZipFile(import_path, "r") as zipf:
+            # 1. Read and Validate Metadata
+            if "metadata.json" not in zipf.namelist():
+                print("❌ Invalid archive: missing 'metadata.json'.")
+                sys.exit(1)
+
+            metadata_content = zipf.read("metadata.json").decode("utf-8")
+            metadata = json.loads(metadata_content)
+
+            archive_version = metadata.get("version", "0.0")
+            if float(archive_version) > 1.0:
+                print(f"❌ Incompatible archive version: {archive_version} (supported <= 1.0).")
+                sys.exit(1)
+
+            current_model = get("embeddings", "model", "all-MiniLM-L6-v2")
+            archive_model = metadata.get("embedding_model")
+            if archive_model and archive_model != current_model:
+                print(f"⚠️ Warning: Embedding model mismatch.")
+                print(f"  Archive uses:  {archive_model}")
+                print(f"  Current config: {current_model}")
+                print("  Importing may cause vector similarity search discrepancy.")
+
+            # 2. Confirmation Prompt
+            active_profile = get_active_profile()
+            print(f"\n⚠️ WARNING: Importing will completely OVERWRITE data in the active workspace profile '{active_profile}'.")
+            confirm = input(f"Are you sure you want to proceed? (y/N): ").strip().lower()
+            if confirm != "y":
+                print("Import cancelled.")
+                return
+
+            print("\nStopping local services to release database locks...")
+            compose_stop()
+
+            # 3. Clean up active profile paths
+            profile_path = get_profile_path(active_profile)
+            db_path = get_db_path(active_profile)
+            qdrant_path = get_qdrant_path(active_profile)
+            neo4j_path = get_neo4j_path(active_profile)
+            config_path = _get_config_path()
+
+            print("Cleaning existing database folders...")
+            if db_path.exists():
+                db_path.unlink()
+            if qdrant_path.exists():
+                shutil.rmtree(qdrant_path)
+                qdrant_path.mkdir(parents=True, exist_ok=True)
+            if neo4j_path.exists():
+                shutil.rmtree(neo4j_path)
+                neo4j_path.mkdir(parents=True, exist_ok=True)
+
+            # 4. Unpack files
+            print("Unpacking files from archive...")
+            
+            # config.toml
+            if "config.toml" in zipf.namelist() and config_path:
+                with open(config_path, "wb") as f:
+                    f.write(zipf.read("config.toml"))
+                print("  ✓ Restored config.toml")
+
+            # workspace.db
+            if "workspace.db" in zipf.namelist() and db_path:
+                with open(db_path, "wb") as f:
+                    f.write(zipf.read("workspace.db"))
+                print("  ✓ Restored SQLite database")
+
+            # Qdrant files
+            qdrant_restored = 0
+            for name in zipf.namelist():
+                if name.startswith("qdrant/"):
+                    target_file = qdrant_path / name[7:]
+                    target_file.parent.mkdir(parents=True, exist_ok=True)
+                    with open(target_file, "wb") as f:
+                        f.write(zipf.read(name))
+                    qdrant_restored += 1
+            if qdrant_restored > 0:
+                print(f"  ✓ Restored {qdrant_restored} Qdrant index files")
+
+            # Neo4j files
+            neo4j_restored = 0
+            for name in zipf.namelist():
+                if name.startswith("neo4j/"):
+                    target_file = neo4j_path / name[6:]
+                    target_file.parent.mkdir(parents=True, exist_ok=True)
+                    with open(target_file, "wb") as f:
+                        f.write(zipf.read(name))
+                    neo4j_restored += 1
+            if neo4j_restored > 0:
+                print(f"  ✓ Restored {neo4j_restored} Neo4j database files")
+
+            # 5. Restart Services
+            print("\nStarting local services...")
+            load_config()  # reload config from file
+            if compose_up():
+                print("Waiting for database health checks...")
+                if wait_for_services(timeout=60):
+                    print("✓ Database services started and healthy.")
+                else:
+                    print("⚠️ Services are starting, but health checks timed out. Run 'memory-os doctor' to check.")
+            else:
+                print("❌ Failed to start docker compose services.")
+
+            print("──────────────────────────────────────────────────")
+            print("🎉 Workspace imported and restored successfully!")
+            print("──────────────────────────────────────────────────")
+
+    except Exception as e:
+        print(f"❌ Import failed: {e}")
+        sys.exit(1)