deyta-cli 0.1.0__tar.gz

deyta_cli-0.1.0/.gitignore

@@ -0,0 +1,28 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+
+# Virtual environment
+.venv/
+
+# Environment / secrets
+.env
+
+# Deyta CLI runtime state (detached daemon pid/port, logs)
+.deyta/
+
+# Local embedded databases (sqlite_lance backend)
+*.db
+*.db-*
+*.lance/
+khora.lance/
+
+# Dev/test artifacts from running `deyta init` inside this repo.
+# (Downstream projects DO commit their own deyta.toml — this ignore is repo-local.)
+/deyta.toml
+
+# OS
+.DS_Store

deyta_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AllTheData Inc. (Deyta)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

deyta_cli-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: deyta-cli
+Version: 0.1.0
+Summary: A unified command-line tool for Deyta's services, wrapping Khora persistent memory for AI agents.
+Project-URL: Homepage, https://github.com/DeytaHQ/deyta-cli
+Project-URL: Repository, https://github.com/DeytaHQ/deyta-cli
+Project-URL: Issues, https://github.com/DeytaHQ/deyta-cli/issues
+Author-email: "AllTheData Inc. (Deyta)" <dev@deyta.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,cli,embeddings,khora,memory,rag,typer
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: khora[embedded]>=0.19.0
+Requires-Dist: packaging>=24.0
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: tomli-w>=1.0.0
+Requires-Dist: typer>=0.26.7
+Requires-Dist: uvicorn[standard]>=0.34.0
+Description-Content-Type: text/markdown
+
+# Deyta CLI
+
+A unified command-line tool for Deyta's services. Today it wraps
+[Khora](https://github.com/DeytaHQ/khora) (persistent memory for AI agents); the
+command surface is built so future services and a cloud platform slot in without
+breaking existing commands.
+
+## How it works
+
+Khora is an in-process Python library, not a server. The CLI runs a local **daemon**
+(`deyta serve` — a FastAPI app holding one `Khora` instance open) and talks to it over
+HTTP. The CLI itself never imports Khora. The target server is resolved per command:
+
+```
+--host flag  >  DEYTA_HOST env  >  active context  >  http://localhost:8787
+```
+
+That resolution is the local↔cloud seam: switching to a cloud platform later is a new
+context, not new commands.
+
+## Requirements
+
+- Python 3.13+
+- `OPENAI_API_KEY` in the environment (Khora uses it for embeddings and entity extraction)
+- Docker — only for the `postgres` backend (`deyta db up`); the embedded backend needs none
+
+## Install
+
+`deyta` is a CLI, so install it as an isolated **tool** rather than into a project
+environment. This puts the `deyta` command on your PATH and keeps its dependencies
+from colliding with anything else:
+
+```bash
+uv tool install deyta-cli      # recommended
+# or:
+pipx install deyta-cli
+```
+
+Both create a dedicated environment just for Deyta and expose `deyta` everywhere — no
+virtualenv to activate. To upgrade later: `uv tool upgrade deyta-cli` (or
+`pipx upgrade deyta-cli`).
+
+**macOS (Homebrew):**
+
+```bash
+brew tap deytahq/deyta
+brew trust deytahq/deyta    # current Homebrew requires trusting any third-party tap
+brew install deyta
+```
+
+This installs into its own virtualenv (using prebuilt wheels for the native
+dependencies) and puts `deyta` on your PATH. Upgrade with `brew upgrade deyta`.
+
+> The `brew trust` step is a Homebrew default for **all** non-official taps, not
+> something specific to Deyta — without it Homebrew refuses to load the formula.
+
+> Avoid `pip install deyta-cli`. Bare `pip` installs into whatever Python environment
+> happens to be active, so the `deyta` command only works while that environment is
+> activated — and it can clash with other packages. Use `uv tool` / `pipx` for CLIs.
+
+### From source (development)
+
+```bash
+git clone https://github.com/DeytaHQ/deyta-cli && cd deyta-cli
+uv sync                        # creates .venv with all deps
+uv run deyta --help            # run without activating the venv
+```
+
+## Quickstart (embedded, no Docker)
+
+```bash
+deyta init                 # choose "embedded (sqlite_lance, no Docker)"
+deyta up                   # start the whole stack in the background (datastores if postgres, then the daemon)
+
+deyta ns create demo       # create a namespace; becomes active
+deyta ingest ./docs        # walk files, chunk + remember (Rich progress)
+deyta query "your question"
+
+deyta down                 # stop the stack when you're done
+```
+
+`deyta up` is the one-command path; `deyta serve` still exists if you'd rather run the
+daemon in the foreground (and `deyta db up` to manage just the datastores).
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `deyta init` | Scaffold `deyta.toml` (pick backend, ontology defaults) |
+| `deyta serve [--port] [--detach]` | Start the daemon (foreground by default) |
+| `deyta status` / `deyta stop` | Inspect / stop a detached daemon |
+| `deyta up` / `deyta down` | Bring the whole local stack up/down (datastores + server) |
+| `deyta db up\|down\|status\|logs` | Manage Postgres + Neo4j (Docker; postgres backend) |
+| `deyta ns create\|list\|get\|delete\|use` | Manage namespaces (`namespace` is the long form) |
+| `deyta memory remember\|recall\|forget\|ingest` | Khora primitives |
+| `deyta ingest <path>` | Shorthand for `memory ingest` |
+| `deyta query "<text>"` | Shorthand for `memory recall` (`--mode`, `-k`, `--json`, `--context`) |
+| `deyta context use\|list\|current` | Switch between local and (future) cloud |
+| `deyta login` / `logout` | Cloud auth (not yet available) |
+| `deyta version [--no-check]` | Show installed CLI + Khora versions; flag PyPI updates |
+| `deyta update [--yes] [--dry-run]` | Upgrade whichever of the CLI / Khora is outdated |
+
+## Backends
+
+- **embedded** (`sqlite_lance`) — SQLite + LanceDB, fully in-process, zero infra. Default for quickstart.
+- **postgres** — Postgres + pgvector + Neo4j via `deyta db up` (vendored Docker Compose,
+  pinned to `pgvector/pgvector:pg17` and `neo4j:2025.12.1`).
+
+## Configuration & state
+
+- `./deyta.toml` — project config: backend, server port, default ontology, namespace
+  name→UUID aliases, active namespace. Commit this.
+- `./.deyta/` — runtime state for a detached daemon (pid/port, logs). Gitignored.
+- `~/.config/deyta/config.toml` — contexts (local/cloud). `auth.json` holds cloud tokens.
+
+Ontology: `deyta init` writes a generic default `entity_types` / `relationship_types`
+so `deyta ingest` works with no flags; override per run with `--entity-types` /
+`--relationship-types`.
+
+## Releasing
+
+The package builds with hatchling; the `deyta` command comes from the
+`[project.scripts]` entry point in `pyproject.toml`. Pushing a `vX.Y.Z` tag
+publishes to PyPI (via GitHub Actions Trusted Publishing) and bumps the Homebrew
+tap. See [RELEASING.md](RELEASING.md) for the one-time setup and the release steps.

deyta_cli-0.1.0/README.md

@@ -0,0 +1,125 @@
+# Deyta CLI
+
+A unified command-line tool for Deyta's services. Today it wraps
+[Khora](https://github.com/DeytaHQ/khora) (persistent memory for AI agents); the
+command surface is built so future services and a cloud platform slot in without
+breaking existing commands.
+
+## How it works
+
+Khora is an in-process Python library, not a server. The CLI runs a local **daemon**
+(`deyta serve` — a FastAPI app holding one `Khora` instance open) and talks to it over
+HTTP. The CLI itself never imports Khora. The target server is resolved per command:
+
+```
+--host flag  >  DEYTA_HOST env  >  active context  >  http://localhost:8787
+```
+
+That resolution is the local↔cloud seam: switching to a cloud platform later is a new
+context, not new commands.
+
+## Requirements
+
+- Python 3.13+
+- `OPENAI_API_KEY` in the environment (Khora uses it for embeddings and entity extraction)
+- Docker — only for the `postgres` backend (`deyta db up`); the embedded backend needs none
+
+## Install
+
+`deyta` is a CLI, so install it as an isolated **tool** rather than into a project
+environment. This puts the `deyta` command on your PATH and keeps its dependencies
+from colliding with anything else:
+
+```bash
+uv tool install deyta-cli      # recommended
+# or:
+pipx install deyta-cli
+```
+
+Both create a dedicated environment just for Deyta and expose `deyta` everywhere — no
+virtualenv to activate. To upgrade later: `uv tool upgrade deyta-cli` (or
+`pipx upgrade deyta-cli`).
+
+**macOS (Homebrew):**
+
+```bash
+brew tap deytahq/deyta
+brew trust deytahq/deyta    # current Homebrew requires trusting any third-party tap
+brew install deyta
+```
+
+This installs into its own virtualenv (using prebuilt wheels for the native
+dependencies) and puts `deyta` on your PATH. Upgrade with `brew upgrade deyta`.
+
+> The `brew trust` step is a Homebrew default for **all** non-official taps, not
+> something specific to Deyta — without it Homebrew refuses to load the formula.
+
+> Avoid `pip install deyta-cli`. Bare `pip` installs into whatever Python environment
+> happens to be active, so the `deyta` command only works while that environment is
+> activated — and it can clash with other packages. Use `uv tool` / `pipx` for CLIs.
+
+### From source (development)
+
+```bash
+git clone https://github.com/DeytaHQ/deyta-cli && cd deyta-cli
+uv sync                        # creates .venv with all deps
+uv run deyta --help            # run without activating the venv
+```
+
+## Quickstart (embedded, no Docker)
+
+```bash
+deyta init                 # choose "embedded (sqlite_lance, no Docker)"
+deyta up                   # start the whole stack in the background (datastores if postgres, then the daemon)
+
+deyta ns create demo       # create a namespace; becomes active
+deyta ingest ./docs        # walk files, chunk + remember (Rich progress)
+deyta query "your question"
+
+deyta down                 # stop the stack when you're done
+```
+
+`deyta up` is the one-command path; `deyta serve` still exists if you'd rather run the
+daemon in the foreground (and `deyta db up` to manage just the datastores).
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `deyta init` | Scaffold `deyta.toml` (pick backend, ontology defaults) |
+| `deyta serve [--port] [--detach]` | Start the daemon (foreground by default) |
+| `deyta status` / `deyta stop` | Inspect / stop a detached daemon |
+| `deyta up` / `deyta down` | Bring the whole local stack up/down (datastores + server) |
+| `deyta db up\|down\|status\|logs` | Manage Postgres + Neo4j (Docker; postgres backend) |
+| `deyta ns create\|list\|get\|delete\|use` | Manage namespaces (`namespace` is the long form) |
+| `deyta memory remember\|recall\|forget\|ingest` | Khora primitives |
+| `deyta ingest <path>` | Shorthand for `memory ingest` |
+| `deyta query "<text>"` | Shorthand for `memory recall` (`--mode`, `-k`, `--json`, `--context`) |
+| `deyta context use\|list\|current` | Switch between local and (future) cloud |
+| `deyta login` / `logout` | Cloud auth (not yet available) |
+| `deyta version [--no-check]` | Show installed CLI + Khora versions; flag PyPI updates |
+| `deyta update [--yes] [--dry-run]` | Upgrade whichever of the CLI / Khora is outdated |
+
+## Backends
+
+- **embedded** (`sqlite_lance`) — SQLite + LanceDB, fully in-process, zero infra. Default for quickstart.
+- **postgres** — Postgres + pgvector + Neo4j via `deyta db up` (vendored Docker Compose,
+  pinned to `pgvector/pgvector:pg17` and `neo4j:2025.12.1`).
+
+## Configuration & state
+
+- `./deyta.toml` — project config: backend, server port, default ontology, namespace
+  name→UUID aliases, active namespace. Commit this.
+- `./.deyta/` — runtime state for a detached daemon (pid/port, logs). Gitignored.
+- `~/.config/deyta/config.toml` — contexts (local/cloud). `auth.json` holds cloud tokens.
+
+Ontology: `deyta init` writes a generic default `entity_types` / `relationship_types`
+so `deyta ingest` works with no flags; override per run with `--entity-types` /
+`--relationship-types`.
+
+## Releasing
+
+The package builds with hatchling; the `deyta` command comes from the
+`[project.scripts]` entry point in `pyproject.toml`. Pushing a `vX.Y.Z` tag
+publishes to PyPI (via GitHub Actions Trusted Publishing) and bumps the Homebrew
+tap. See [RELEASING.md](RELEASING.md) for the one-time setup and the release steps.

deyta_cli-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "deyta-cli"
+version = "0.1.0"
+description = "A unified command-line tool for Deyta's services, wrapping Khora persistent memory for AI agents."
+readme = "README.md"
+requires-python = ">=3.13"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "AllTheData Inc. (Deyta)", email = "dev@deyta.ai" },
+]
+keywords = ["cli", "khora", "memory", "ai", "agents", "rag", "embeddings", "typer"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "khora[embedded]>=0.19.0",
+    "questionary>=2.1.1",
+    "rich>=15.0.0",
+    "typer>=0.26.7",
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.34.0",
+    "httpx>=0.28.0",
+    "tomli-w>=1.0.0",
+    "packaging>=24.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/DeytaHQ/deyta-cli"
+Repository = "https://github.com/DeytaHQ/deyta-cli"
+Issues = "https://github.com/DeytaHQ/deyta-cli/issues"
+
+[project.scripts]
+deyta = "deyta_cli.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/deyta_cli"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/deyta_cli",
+    "README.md",
+    "LICENSE",
+    "pyproject.toml",
+]

deyta_cli-0.1.0/src/deyta_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

deyta_cli-0.1.0/src/deyta_cli/cli.py

@@ -0,0 +1,65 @@
+"""Deyta CLI — unified entry point for Deyta's services.
+
+Command altitudes:
+  - platform/runtime (top-level, never service-prefixed): init, serve, status, stop,
+    up, down, login, logout, context.
+  - data plane (flat in MVP): namespace/ns, memory, plus ingest/query shorthands.
+
+The CLI is a thin HTTP client; all Khora work happens in the `deyta serve` daemon.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .commands import auth, context, db, init, memory, namespace, serve, update, version
+from .commands import aliases
+
+app = typer.Typer(
+    help="Deyta — unified CLI for Deyta's services (memory powered by Khora).",
+    no_args_is_help=True,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    host: str = typer.Option(
+        None,
+        "--host",
+        help="Target server URL. Overrides DEYTA_HOST and the active context.",
+        envvar="DEYTA_HOST",
+    ),
+) -> None:
+    """Resolve the target host once and stash it for every command."""
+    ctx.obj = {"host": host}
+
+
+# ---- platform / runtime ---------------------------------------------------- #
+app.command("init")(init.init)
+app.command("serve")(serve.serve)
+app.command("status")(serve.status)
+app.command("stop")(serve.stop)
+app.command("up")(serve.up)
+app.command("down")(serve.down)
+app.command("login")(auth.login)
+app.command("logout")(auth.logout)
+app.command("version")(version.version)
+app.command("update")(update.update)
+app.add_typer(context.app, name="context")
+
+# ---- datastores (Docker) --------------------------------------------------- #
+app.add_typer(db.app, name="db")
+
+# ---- data plane ------------------------------------------------------------ #
+app.add_typer(namespace.app, name="namespace")
+app.add_typer(namespace.app, name="ns")  # alias
+app.add_typer(memory.app, name="memory")
+
+# ---- top-level shorthands -------------------------------------------------- #
+app.command("ingest")(aliases.ingest)
+app.command("query")(aliases.query)
+
+
+if __name__ == "__main__":
+    app()

deyta_cli-0.1.0/src/deyta_cli/client.py

@@ -0,0 +1,108 @@
+"""Thin HTTP client to a Deyta daemon (local ``deyta serve`` or, later, cloud).
+
+The CLI never imports Khora. Every command builds a request, hands it to this
+client, and renders the response. The base URL is resolved once (``--host`` >
+``DEYTA_HOST`` > current context > localhost), so pointing the same commands at a
+cloud platform is purely a matter of which context is active.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from typing import Any
+
+import httpx
+
+from . import config
+
+
+class DeytaClientError(Exception):
+    """User-facing client error (connection refused, HTTP error, etc.)."""
+
+
+class DeytaClient:
+    def __init__(self, host: str | None = None, *, timeout: float = 300.0) -> None:
+        self.host = config.resolve_host(host).rstrip("/")
+        self._timeout = timeout
+        token = config.auth_token(config.current_context()["name"])
+        self._headers = {"Authorization": f"Bearer {token}"} if token else {}
+
+    # ---- low-level -------------------------------------------------------- #
+    def _request(self, method: str, path: str, **kwargs: Any) -> Any:
+        url = f"{self.host}{path}"
+        try:
+            with httpx.Client(timeout=self._timeout, headers=self._headers) as c:
+                resp = c.request(method, url, **kwargs)
+        except httpx.ConnectError as exc:
+            raise DeytaClientError(
+                f"No Deyta server at {self.host}. Run `deyta serve` first."
+            ) from exc
+        except httpx.HTTPError as exc:
+            raise DeytaClientError(f"Request to {url} failed: {exc}") from exc
+        if resp.status_code >= 400:
+            raise DeytaClientError(_error_detail(resp))
+        return resp.json() if resp.content else None
+
+    # ---- health ----------------------------------------------------------- #
+    def health(self) -> dict[str, Any]:
+        return self._request("GET", "/health")
+
+    def is_up(self) -> bool:
+        try:
+            self.health()
+            return True
+        except DeytaClientError:
+            return False
+
+    # ---- namespaces ------------------------------------------------------- #
+    def create_namespace(self, name: str) -> dict[str, Any]:
+        return self._request("POST", "/namespaces", json={"name": name})
+
+    def list_namespaces(self) -> list[dict[str, Any]]:
+        return self._request("GET", "/namespaces")["namespaces"]
+
+    def get_namespace(self, namespace_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/namespaces/{namespace_id}")
+
+    def delete_namespace(self, namespace_id: str) -> dict[str, Any]:
+        return self._request("DELETE", f"/namespaces/{namespace_id}")
+
+    # ---- memory ----------------------------------------------------------- #
+    def remember(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", "/remember", json=payload)
+
+    def recall(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", "/recall", json=payload)
+
+    def forget(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", "/forget", json=payload)
+
+    def ingest(self, payload: dict[str, Any]) -> Iterator[dict[str, Any]]:
+        """Stream ingest progress as Server-Sent Events.
+
+        Yields ``{"type": "progress", "processed", "total"}`` events followed by a
+        single ``{"type": "result", ...}`` (or ``{"type": "error", ...}``) event.
+        """
+        url = f"{self.host}/ingest"
+        try:
+            with httpx.Client(timeout=None, headers=self._headers) as c:
+                with c.stream("POST", url, json=payload) as resp:
+                    if resp.status_code >= 400:
+                        resp.read()
+                        raise DeytaClientError(_error_detail(resp))
+                    for line in resp.iter_lines():
+                        if line.startswith("data: "):
+                            yield json.loads(line[len("data: ") :])
+        except httpx.ConnectError as exc:
+            raise DeytaClientError(
+                f"No Deyta server at {self.host}. Run `deyta serve` first."
+            ) from exc
+
+
+def _error_detail(resp: httpx.Response) -> str:
+    try:
+        body = resp.json()
+        return str(body.get("detail", body))
+    except (json.JSONDecodeError, ValueError):
+        return f"HTTP {resp.status_code}: {resp.text[:200]}"

deyta_cli-0.1.0/src/deyta_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Typer command groups for the Deyta CLI."""

deyta_cli-0.1.0/src/deyta_cli/commands/_common.py

@@ -0,0 +1,84 @@
+"""Shared helpers for command implementations."""
+
+from __future__ import annotations
+
+import typer
+
+from .. import config, docker, render
+from ..client import DeytaClient
+
+
+def get_host(ctx: typer.Context) -> str | None:
+    obj = ctx.obj or {}
+    return obj.get("host")
+
+
+def get_client(ctx: typer.Context) -> DeytaClient:
+    return DeytaClient(get_host(ctx))
+
+
+def require_project(ctx: typer.Context) -> config.ProjectConfig:
+    """Load ``deyta.toml`` or exit with guidance."""
+    cfg = config.load_project_config()
+    if cfg is None:
+        render.error("No deyta.toml found. Run `deyta init` first.")
+        raise typer.Exit(1)
+    return cfg
+
+
+def resolve_namespace(cfg: config.ProjectConfig, ns_opt: str | None) -> str:
+    """Resolve a ``--namespace`` option (or the active namespace) to a UUID."""
+    target = ns_opt or cfg.active
+    if not target:
+        render.error(
+            "No namespace selected. Create one with `deyta ns create <name>` "
+            "and `deyta ns use <name>`, or pass --namespace."
+        )
+        raise typer.Exit(1)
+    return cfg.resolve_namespace(target)
+
+
+def resolve_ontology(
+    cfg: config.ProjectConfig,
+    entity_types: str | None,
+    relationship_types: str | None,
+) -> tuple[list[str], list[str]]:
+    """Flags override the project default ontology; otherwise fall back to config."""
+    ents = _split(entity_types) if entity_types else cfg.entity_types
+    rels = _split(relationship_types) if relationship_types else cfg.relationship_types
+    return ents, rels
+
+
+def _split(csv: str) -> list[str]:
+    return [item.strip() for item in csv.split(",") if item.strip()]
+
+
+def bring_up_datastores() -> None:
+    """Start Postgres + Neo4j and wait until healthy, with live progress.
+
+    Exits with a clear message on Docker errors or if they don't come up in time.
+    """
+    try:
+        render.info("Starting datastores (Postgres + Neo4j)…")
+        docker.up(detach=True)
+    except docker.DockerError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+
+    with render.console.status("[bold]Waiting for datastores…[/]", spinner="dots") as status:
+
+        def tick(states: dict[str, str]) -> None:
+            parts = "  ".join(f"{svc}=[bold]{st}[/]" for svc, st in states.items())
+            status.update(
+                f"[bold]Waiting for datastores to be ready[/] "
+                f"— Neo4j can take ~30s  {parts}"
+            )
+
+        healthy = docker.wait_healthy(on_tick=tick)
+
+    if not healthy:
+        render.error(
+            "Datastores didn't become healthy in time. Check `deyta db status` / `deyta db logs`."
+        )
+        raise typer.Exit(1)
+    render.success("Datastores healthy (postgres :5434, neo4j bolt :7688).")