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

infrastructure/compose.py

@@ -0,0 +1,136 @@
+"""
+Infrastructure: Docker Compose orchestration.
+
+Wraps docker compose commands. Environment variables (ports, paths,
+passwords) are exported by config.py before these functions are called,
+so docker-compose.yml can reference them via ${VAR} syntax.
+"""
+
+import os
+import subprocess
+import time
+import json
+import logging
+
+logger = logging.getLogger("infrastructure.compose")
+
+
+def _get_compose_file() -> str:
+    """Return path to the project's docker-compose.yml."""
+    return os.path.join(os.path.dirname(os.path.dirname(__file__)), "docker-compose.yml")
+
+
+def _run_compose(args: list[str], project_dir: str | None = None) -> subprocess.CompletedProcess:
+    """Run a docker compose command with the project compose file."""
+    from infrastructure.workspace import get_neo4j_path, get_qdrant_path
+
+    compose_file = _get_compose_file()
+    cmd = ["docker", "compose", "-f", compose_file] + args
+
+    env = os.environ.copy()
+    env["MEMORY_OS_NEO4J_PATH"] = str(get_neo4j_path())
+    env["MEMORY_OS_QDRANT_PATH"] = str(get_qdrant_path())
+
+    return subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        timeout=120,
+        env=env,
+        cwd=project_dir,
+    )
+
+
+
+def compose_up(project_dir: str | None = None) -> bool:
+    """Start services with docker compose up -d."""
+    result = _run_compose(["up", "-d"], project_dir)
+    if result.returncode != 0:
+        logger.error(f"docker compose up failed: {result.stderr}")
+        return False
+    return True
+
+
+def compose_down(project_dir: str | None = None) -> bool:
+    """Stop and remove containers with docker compose down."""
+    result = _run_compose(["down"], project_dir)
+    if result.returncode != 0:
+        logger.error(f"docker compose down failed: {result.stderr}")
+        return False
+    return True
+
+
+def compose_stop(project_dir: str | None = None) -> bool:
+    """Stop containers without removing them (preserves data)."""
+    result = _run_compose(["stop"], project_dir)
+    if result.returncode != 0:
+        logger.error(f"docker compose stop failed: {result.stderr}")
+        return False
+    return True
+
+
+def compose_status(project_dir: str | None = None) -> list[dict]:
+    """Get container status via docker compose ps --format json."""
+    result = _run_compose(["ps", "--format", "json"], project_dir)
+    if result.returncode != 0:
+        return []
+    try:
+        # docker compose ps --format json may return one JSON object per line
+        containers = []
+        for line in result.stdout.strip().splitlines():
+            line = line.strip()
+            if line:
+                containers.append(json.loads(line))
+        return containers
+    except (json.JSONDecodeError, ValueError):
+        return []
+
+
+def wait_for_services(timeout: int = 60) -> bool:
+    """Poll Neo4j and Qdrant health endpoints until ready or timeout.
+
+    Returns True if all services are healthy within the timeout.
+    """
+    import urllib.request
+    import urllib.error
+
+    neo4j_port = os.getenv("NEO4J_HTTP_PORT", "7474")
+    qdrant_port = os.getenv("QDRANT_PORT", "6333")
+
+    neo4j_url = f"http://localhost:{neo4j_port}"
+    qdrant_url = f"http://localhost:{qdrant_port}/healthz"
+
+    start = time.time()
+    neo4j_ready = False
+    qdrant_ready = False
+
+    while time.time() - start < timeout:
+        # Check Qdrant
+        if not qdrant_ready:
+            try:
+                req = urllib.request.urlopen(qdrant_url, timeout=3)
+                if req.status == 200:
+                    qdrant_ready = True
+            except Exception:
+                pass
+
+        # Check Neo4j
+        if not neo4j_ready:
+            try:
+                req = urllib.request.urlopen(neo4j_url, timeout=3)
+                if req.status == 200:
+                    neo4j_ready = True
+            except Exception:
+                pass
+
+        if neo4j_ready and qdrant_ready:
+            return True
+
+        time.sleep(2)
+
+    logger.warning(
+        f"Service health timeout after {timeout}s. "
+        f"Neo4j={'ready' if neo4j_ready else 'not ready'}, "
+        f"Qdrant={'ready' if qdrant_ready else 'not ready'}"
+    )
+    return False

infrastructure/config.py

@@ -0,0 +1,280 @@
+"""
+Infrastructure: Configuration management.
+
+Implements config priority chain:
+    CLI Flags -> config.toml -> .env -> Defaults
+
+Config is loaded once at startup and exported to os.environ so existing
+modules (llm.py, graph.py, vector_store.py) work without changes.
+"""
+
+import os
+import tomllib
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Default configuration values
+DEFAULTS = {
+    "workspace": "~/.memory-os",
+    "active_profile": "default",
+    "composio": {
+        "api_key": "",
+        "user_id": "",
+    },
+    "groq": {
+        "api_key": "",
+        "model": "llama-3.3-70b-versatile",
+    },
+    "neo4j": {
+        "uri": "bolt://localhost:7687",
+        "user": "neo4j",
+        "password": "",
+        "port_http": 7474,
+        "port_bolt": 7687,
+    },
+    "qdrant": {
+        "url": "http://localhost:6333",
+        "port": 6333,
+    },
+    "embeddings": {
+        "model": "all-MiniLM-L6-v2",
+    },
+}
+
+_config = None
+
+
+def _get_config_path() -> Path:
+    """Return the path to the config.toml file."""
+    workspace_root = Path(os.path.expanduser(
+        os.getenv("MEMORY_OS_WORKSPACE", "~/.memory-os")
+    ))
+    return workspace_root / "config.toml"
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    """Recursively merge override into base, returning a new dict."""
+    merged = dict(base)
+    for key, value in override.items():
+        if key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
+            merged[key] = _deep_merge(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def load_config(cli_overrides: dict | None = None) -> dict:
+    """Load configuration using the priority chain.
+
+    Priority (highest to lowest):
+        1. cli_overrides dict
+        2. ~/.memory-os/config.toml
+        3. .env file (loaded into os.environ)
+        4. DEFAULTS
+
+    After merging, key values are exported to os.environ so that
+    existing modules pick them up transparently.
+    """
+    global _config
+
+    # Start with defaults
+    config = dict(DEFAULTS)
+    for k, v in DEFAULTS.items():
+        if isinstance(v, dict):
+            config[k] = dict(v)
+
+    # Layer 3: Load .env (lowest priority, loaded into os.environ)
+    load_dotenv(override=False)
+
+    # Layer 2: Load config.toml if it exists
+    config_path = _get_config_path()
+    if config_path.exists():
+        with open(config_path, "rb") as f:
+            toml_config = tomllib.load(f)
+        config = _deep_merge(config, toml_config)
+
+    # Layer 1: CLI overrides (highest priority)
+    if cli_overrides:
+        config = _deep_merge(config, cli_overrides)
+
+    # Export key values to os.environ for backwards compatibility
+    _export_to_environ(config)
+
+    _config = config
+    return config
+
+
+def _export_to_environ(config: dict):
+    """Export configuration values to os.environ.
+
+    This ensures existing modules that read os.getenv() continue
+    to work without modification.
+    """
+    # Groq
+    groq = config.get("groq", {})
+    if groq.get("api_key"):
+        os.environ.setdefault("GROQ_API_KEY", groq["api_key"])
+    if groq.get("model"):
+        os.environ.setdefault("GROQ_MODEL", groq["model"])
+
+    # Composio
+    composio = config.get("composio", {})
+    if composio.get("api_key"):
+        os.environ.setdefault("COMPOSIO_API_KEY", composio["api_key"])
+
+    # Neo4j
+    neo4j = config.get("neo4j", {})
+    if neo4j.get("uri"):
+        os.environ.setdefault("NEO4J_URI", neo4j["uri"])
+    if neo4j.get("user"):
+        os.environ.setdefault("NEO4J_USER", neo4j["user"])
+    if neo4j.get("password"):
+        os.environ.setdefault("NEO4J_PASSWORD", neo4j["password"])
+    # Port env vars for docker-compose
+    os.environ.setdefault("NEO4J_HTTP_PORT", str(neo4j.get("port_http", 7474)))
+    os.environ.setdefault("NEO4J_BOLT_PORT", str(neo4j.get("port_bolt", 7687)))
+
+    # Qdrant
+    qdrant = config.get("qdrant", {})
+    if qdrant.get("url"):
+        os.environ.setdefault("QDRANT_URL", qdrant["url"])
+    os.environ.setdefault("QDRANT_PORT", str(qdrant.get("port", 6333)))
+
+
+def get_config() -> dict:
+    """Return the currently loaded config, loading it if necessary."""
+    global _config
+    if _config is None:
+        load_config()
+    return _config
+
+
+def get(section: str, key: str, default=None):
+    """Read a specific config value. Example: get('groq', 'model')"""
+    config = get_config()
+    section_dict = config.get(section, {})
+    if isinstance(section_dict, dict):
+        return section_dict.get(key, default)
+    return default
+
+
+def save_config(config_dict: dict):
+    """Write configuration to ~/.memory-os/config.toml."""
+    import tomllib  # read-only; we write manually for now
+    config_path = _get_config_path()
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    lines = []
+    for key, value in config_dict.items():
+        if isinstance(value, dict):
+            lines.append(f"\n[{key}]")
+            for k, v in value.items():
+                lines.append(f'{k} = {_toml_value(v)}')
+        else:
+            lines.append(f'{key} = {_toml_value(value)}')
+
+    config_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def set_value(section: str, key: str, value):
+    """Update a single config key and save."""
+    config = get_config()
+    if section not in config:
+        config[section] = {}
+    config[section][key] = value
+    save_config(config)
+
+
+def get_dotted(key: str, default=None):
+    """Fetch value from config dictionary using dotted path, e.g., 'groq.model' or 'workspace'."""
+    config = get_config()
+    parts = key.split(".")
+    
+    current = config
+    for part in parts:
+        if isinstance(current, dict) and part in current:
+            current = current[part]
+        else:
+            return default
+    return current
+
+
+def set_dotted(key: str, value) -> tuple[bool, str]:
+    """Set value in config dictionary using dotted path, e.g., 'groq.model' or 'workspace'.
+    Performs type and schema validations. Returns (success, error_message).
+    """
+    config = get_config()
+    parts = key.split(".")
+    
+    if len(parts) == 1:
+        t_key = parts[0]
+        if t_key not in DEFAULTS:
+            return False, f"Invalid configuration key '{t_key}'"
+        if t_key == "workspace" and not value:
+            return False, "Workspace path cannot be empty"
+        config[t_key] = value
+    elif len(parts) == 2:
+        section, prop = parts[0], parts[1]
+        if section not in DEFAULTS or prop not in DEFAULTS[section]:
+            return False, f"Invalid configuration key '{key}'"
+            
+        default_val = DEFAULTS[section][prop]
+        if isinstance(default_val, int):
+            try:
+                value = int(value)
+                if value <= 0:
+                    raise ValueError()
+            except ValueError:
+                return False, f"Configuration key '{key}' must be a positive integer"
+        elif isinstance(default_val, bool):
+            if str(value).lower() in ("true", "1", "yes", "y"):
+                value = True
+            elif str(value).lower() in ("false", "0", "no", "n"):
+                value = False
+            else:
+                return False, f"Configuration key '{key}' must be a boolean value"
+                
+        if section not in config:
+            config[section] = {}
+        config[section][prop] = value
+    else:
+        return False, f"Configuration key depth '{key}' not supported"
+
+    save_config(config)
+    return True, ""
+
+
+
+def generate_default_config(answers: dict) -> dict:
+    """Create initial config from prompted values during init.
+
+    ``answers`` should contain keys like 'groq_api_key',
+    'composio_api_key', 'neo4j_password', 'composio_user_id'.
+    """
+    import copy
+    config = copy.deepcopy(DEFAULTS)
+
+    if answers.get("groq_api_key"):
+        config["groq"]["api_key"] = answers["groq_api_key"]
+    if answers.get("composio_api_key"):
+        config["composio"]["api_key"] = answers["composio_api_key"]
+    if answers.get("composio_user_id"):
+        config["composio"]["user_id"] = answers["composio_user_id"]
+    if answers.get("neo4j_password"):
+        config["neo4j"]["password"] = answers["neo4j_password"]
+
+    return config
+
+
+def _toml_value(value) -> str:
+    """Format a Python value as a TOML literal."""
+    if isinstance(value, str):
+        return f'"{value}"'
+    elif isinstance(value, bool):
+        return "true" if value else "false"
+    elif isinstance(value, int):
+        return str(value)
+    elif isinstance(value, float):
+        return str(value)
+    else:
+        return f'"{value}"'

infrastructure/docker.py

@@ -0,0 +1,61 @@
+"""
+Infrastructure: Docker availability checks.
+
+Verifies that Docker and Docker Compose are installed and running.
+"""
+
+import subprocess
+import logging
+
+logger = logging.getLogger("infrastructure.docker")
+
+
+def check_docker_installed() -> tuple[bool, str]:
+    """Check if Docker is installed. Returns (available, version_string)."""
+    try:
+        result = subprocess.run(
+            ["docker", "--version"],
+            capture_output=True, text=True, timeout=10
+        )
+        if result.returncode == 0:
+            version = result.stdout.strip()
+            return True, version
+        return False, ""
+    except FileNotFoundError:
+        return False, ""
+    except Exception as e:
+        logger.error(f"Docker check failed: {e}")
+        return False, ""
+
+
+def check_docker_compose_installed() -> tuple[bool, str]:
+    """Check if Docker Compose is installed. Returns (available, version_string)."""
+    try:
+        result = subprocess.run(
+            ["docker", "compose", "version"],
+            capture_output=True, text=True, timeout=10
+        )
+        if result.returncode == 0:
+            version = result.stdout.strip()
+            return True, version
+        return False, ""
+    except FileNotFoundError:
+        return False, ""
+    except Exception as e:
+        logger.error(f"Docker Compose check failed: {e}")
+        return False, ""
+
+
+def check_docker_running() -> bool:
+    """Verify that the Docker daemon is active."""
+    try:
+        result = subprocess.run(
+            ["docker", "info"],
+            capture_output=True, text=True, timeout=10
+        )
+        return result.returncode == 0
+    except FileNotFoundError:
+        return False
+    except Exception as e:
+        logger.error(f"Docker daemon check failed: {e}")
+        return False