xmemcli 0.0.1__py3-none-any.whl

xmemcli/_output.py

@@ -0,0 +1,274 @@
+"""Tagged-union output payload + dispatch shared by every ``xmem`` subcommand.
+
+Why this lives in its own module
+--------------------------------
+
+The CLI has two output personalities that the user-facing surface needs to
+keep strictly separated:
+
+1. **Machine consumption** — any time stdout is *not* attached to a terminal
+   (a pipe, a shell redirect, CI capture, the Playwright runner reading
+   ``result.stdout``), or any time the human explicitly passes ``--json``.
+   In that mode every command MUST emit **exactly one** JSON document on
+   stdout, so a downstream consumer can rely on
+   ``xmem read … | jq .reader_result`` working unconditionally.
+2. **Human consumption** — the operator typed the command into an
+   interactive shell and did **not** pass ``--json``. In that mode the CLI
+   is allowed to format the payload into a short, opinionated, one-line (or
+   nearly-one-line) summary keyed off the *kind* of response.
+
+To keep the dispatch logic in one place and force every new subcommand to
+declare which family of output it produces, the commands no longer print
+directly. They build a :class:`CliOutput` (a discriminated payload tagged
+with an :class:`OutputKind`), and the entry point in ``cli/xmem.py`` decides
+how to render it via :func:`emit`. The pretty-print branch lives in
+``cli/_pretty.py`` so the formatting code can grow without cluttering the
+HTTP and argparse plumbing.
+
+Invariants
+----------
+
+- The default for any non-TTY stdout is JSON. There is no other default.
+- ``--json`` forces JSON even on a TTY — always, unconditionally.
+- Pretty-print is only ever reached when ``stdout.isatty()`` is true AND
+  ``--json`` was not passed. Anything else gets JSON.
+- ``$XMEM_FORCE_TTY_OUTPUT_NOT_JSON`` is a **deliberate, documented escape hatch**
+  for manual E2E runbooks only (see :data:`ENV_FORCE_TTY_OUTPUT_NOT_JSON`). It does
+  not change server behavior, credentials, or API payloads — only how ``emit`` chooses
+  between JSON and pretty text. Agents, CI, and piped scripts must never set it;
+  they use ``--json`` or a real TTY. If unset (the normal case), the non-TTY⇒JSON
+  rule is unchanged.
+- A failed command still emits exactly one JSON document on stdout when JSON
+  mode is in effect — :class:`OutputKind.ERROR` + a non-zero exit code. We
+  do not silently dump human prose to stderr in machine mode.
+- The pretty-print renderers may fall back to JSON if they can't extract a
+  useful summary from the payload; that is intentional and keeps human
+  output truthful rather than guessing.
+
+Wire format
+-----------
+
+The JSON document emitted by :func:`emit` is the CURATED payload built by
+the subcommand (see the ``_curate_*`` helpers in ``cli/xmem.py``) — the
+fields the user asked for, with server internals (SQL, diff plans, raw
+extraction trees) stripped in both output modes. We do NOT wrap it in a
+second envelope keyed by :class:`OutputKind` — adding a layer the consumer
+didn't ask for would make scripts more fragile, not less. The kind is only
+used internally for pretty-print dispatch.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from enum import StrEnum
+from typing import IO, Any, NamedTuple
+
+
+class OutputKind(StrEnum):
+    """Discriminator for what kind of payload a command produced.
+
+    Used purely for pretty-print dispatch. Has no effect on the JSON output —
+    the same enum value can produce wildly different JSON depending on the
+    server payload, and that's fine.
+    """
+
+    #: Synchronous write that completed (``POST …/write``). Curated payload:
+    #: ``write_id`` + ``extracted`` (compact ``Type(name)`` tags).
+    WRITE_SYNC = "write_sync"
+
+    #: Asynchronous write that was queued (``POST …/write_async``). Curated
+    #: payload: ``write_id``; the caller must poll.
+    WRITE_ASYNC = "write_async"
+
+    #: Terminal result of an ``async_write_status`` poll. Curated payload:
+    #: ``write_id`` + ``write_status`` in {``completed``, ``failed``,
+    #: ``not_found``} (+ ``error_detail`` / ``timed_out`` when applicable).
+    WRITE_STATUS = "write_status"
+
+    #: Read in ``mode=single-answer``. Curated payload: ``answer`` (falls
+    #: back to the reader_result subtree when no answer string exists).
+    READ_SINGLE = "read_single"
+
+    #: Read in ``mode=raw-tables``. Curated payload: the reader_result
+    #: subtree (columns + rows). Pretty-print renders as JSON because there
+    #: is no useful one-line summary.
+    READ_RAW = "read_raw"
+
+    #: Read in ``mode=xresponse``. Curated payload: the reader_result
+    #: subtree shaped as an XResponse (objects + relations). Pretty-print
+    #: renders as JSON for the same reason as :attr:`READ_RAW`.
+    READ_XRESPONSE = "read_xresponse"
+
+    #: Output of ``xmemcli org list keys``. Curated payload: a list of
+    #: ``{name, key_prefix, is_active}`` entries (full DTOs with
+    #: ``--verbose``).
+    KEY_LIST = "key_list"
+
+    #: Output of ``xmemcli org list clusters``.
+    CLUSTER_LIST = "cluster_list"
+
+    #: Output of ``xmem auth status``. Curated payload:
+    #: ``{authenticated: bool, key_prefix, email?}`` — whose key the CLI is
+    #: holding, resolved via ``/whoami``.
+    AUTH_STATUS = "auth_status"
+
+    #: Output of ``xmem auth login`` / ``xmem auth logout``.
+    LOGIN = "login"
+
+    #: Output of ``xmem version``.
+    VERSION = "version"
+
+    #: Local-only release health (``xmem status``) — no network.
+    STATUS = "status"
+
+    #: Output of ``xmemcli quota``. Curated payload: usage windows.
+    QUOTA = "quota"
+
+    #: Output of ``xmemcli org list instances`` (and ``instance list`` alias).
+    INSTANCE_LIST = "instance_list"
+
+    #: Output of ``xmem instance get``.
+    INSTANCE_GET = "instance_get"
+
+    #: Output of ``xmem instance create``.
+    INSTANCE_CREATE = "instance_create"
+
+    #: Output of ``xmem instance delete``.
+    INSTANCE_DELETE = "instance_delete"
+
+    #: Output of ``xmem schema update``.
+    SCHEMA_UPDATE = "schema_update"
+
+    #: Output of ``xmem schema dry-run``.
+    SCHEMA_DRY_RUN = "schema_dry_run"
+
+    #: Output of ``xmem schema migrations list`` / ``get``.
+    SCHEMA_MIGRATIONS = "schema_migrations"
+
+    #: Output of ``xmem xmd generate`` / ``enhance`` / ``validate`` / ``schema get``.
+    XMD_SCHEMA = "xmd_schema"
+
+    #: Output of ``xmem xmd enhance`` when a migration plan is included.
+    XMD_ENHANCE = "xmd_enhance"
+
+    #: Output of ``xmem xmd convert``.
+    XMD_CONVERT = "xmd_convert"
+
+    #: Structured help document from ``build_help_document`` (overview, options,
+    #: command topic, or unknown topic). Emitted when ``--json`` is set or stdout
+    #: is not a TTY — same JSON-by-default rule as data commands.
+    HELP = "help"
+
+    #: A failure surfaced as structured output. ``payload`` carries
+    #: ``{"error": str, "status": int|null, "stage": str}`` — see
+    #: :func:`make_error`.
+    ERROR = "error"
+
+
+class CliOutput(NamedTuple):
+    """A command's structured result, ready for either renderer.
+
+    A ``typing.NamedTuple`` (immutable, typed, attribute-accessed) rather than
+    Pydantic or ``@dataclass``: this CLI is stdlib-only and standalone — it runs
+    without a ``pip install`` of the ``xmemory`` library (see ``cli/xmem.py``).
+
+    Construction is cheap; the only invariant is that ``payload`` must be
+    JSON-serialisable (dict / list / str / int / float / bool / None).
+    """
+
+    kind: OutputKind
+    payload: Any
+
+
+def make_error(message: str, *, status: int | None = None, stage: str = "request") -> CliOutput:
+    """Construct an :class:`OutputKind.ERROR` payload.
+
+    ``status`` is the HTTP status code when the failure originated from a
+    server response; ``stage`` is a free-form label naming the step that
+    failed (``"request"``, ``"parse"``, ``"validate"``…). The pretty-print
+    renderer uses ``stage`` to decide how loudly to scream.
+    """
+    return CliOutput(
+        OutputKind.ERROR,
+        {"error": message, "status": status, "stage": stage},
+    )
+
+
+# Deliberate escape hatch for manual harness runs with captured stdout — not for CI/scripts.
+# See README.md ("Output personality"). ``--json`` still wins when passed.
+ENV_FORCE_TTY_OUTPUT_NOT_JSON = "XMEM_FORCE_TTY_OUTPUT_NOT_JSON"
+
+
+def _env_tty_override() -> bool | None:
+    raw = os.environ.get(ENV_FORCE_TTY_OUTPUT_NOT_JSON, "").strip().lower()
+    if not raw:
+        return None
+    if raw in ("1", "true", "yes", "on"):
+        return True
+    return None
+
+
+def stdout_is_tty() -> bool:
+    """``True`` iff stdout is connected to an interactive terminal.
+
+    Wrapped in a function (not captured at module import time) so unit tests
+    can monkey-patch ``sys.stdout`` between cases without surprising us.
+    Returns ``False`` defensively if ``isatty`` raises — some pseudo-streams
+    don't implement it.
+
+    ``$XMEM_FORCE_TTY_OUTPUT_NOT_JSON`` — when set to a truthy value, pretend stdout is a
+    TTY so :func:`emit` uses pretty one-liners on piped/captured stdout. Manual Case 4
+    only; see :data:`ENV_FORCE_TTY_OUTPUT_NOT_JSON`. Does not apply when ``force_json``
+    is true (``--json``).
+    """
+    override = _env_tty_override()
+    if override is not None:
+        return override
+    try:
+        return sys.stdout.isatty()
+    except Exception:
+        return False
+
+
+def emit(
+    out: CliOutput,
+    *,
+    force_json: bool,
+    is_tty: bool | None = None,
+    stream: IO[str] | None = None,
+) -> None:
+    """Render ``out`` to stdout (or ``stream``) using the JSON-by-default rule.
+
+    Parameters
+    ----------
+    out
+        The structured payload produced by a subcommand.
+    force_json
+        ``True`` when ``--json`` was passed. Pretty-print is suppressed
+        unconditionally and the renderer emits exactly one JSON document.
+    is_tty
+        Override for :func:`stdout_is_tty`. Tests can pass an explicit
+        boolean to exercise both branches without monkey-patching.
+    stream
+        Defaults to ``sys.stdout``. Tests pass ``io.StringIO()`` here to
+        capture output deterministically.
+
+    The JSON branch always terminates with a newline so log scrapers and
+    JSON-lines consumers behave identically. The pretty-print branch
+    delegates entirely to ``cli/_pretty.py`` and is only reached when the
+    user is sitting at a terminal AND did not opt into JSON.
+    """
+    out_stream = stream if stream is not None else sys.stdout
+    tty = stdout_is_tty() if is_tty is None else is_tty
+    if force_json or not tty:
+        json.dump(out.payload, out_stream, indent=2, default=str)
+        out_stream.write("\n")
+        return
+    # Lazy import so the JSON path stays import-cheap (the CLI is invoked
+    # hundreds of times per Playwright recording). Absolute import works
+    # because xmem.py runs as a script — its directory is on sys.path[0].
+    from . import _pretty  # noqa: PLC0415
+
+    _pretty.render(out.kind, out.payload, out_stream)

xmemcli/_pretty.py

@@ -0,0 +1,373 @@
+"""Human-friendly renderers for :mod:`_output` payloads.
+
+This module is **only** reached when the operator is sitting at a real
+terminal (``sys.stdout.isatty()``) AND did not pass ``--json``. Every other
+invocation gets strict JSON via :func:`_output.emit` — see that module's
+docstring for the rationale.
+
+The renderers are deliberately small, opinionated, and one-shot: they print
+a single short summary (often a single line) keyed off the
+:class:`~cli._output.OutputKind`. The principle is "give the operator the
+headline they would have wanted to read aloud", not "render the entire
+payload". If the renderer can't extract a useful headline, it falls through
+to a JSON dump of the relevant sub-tree so the user still sees something
+truthful rather than a guess.
+
+Adding a new :class:`~cli._output.OutputKind` requires adding a renderer
+here keyed by the enum value in :data:`_RENDERERS`. The default handler
+emits the JSON payload, which is a safe (if uninspired) fallback.
+"""
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+from typing import IO, Any, Callable
+
+from ._version import CLI_NAME
+
+# Type alias so the dispatch table is self-documenting.
+Renderer = Callable[[Any, IO[str]], None]
+
+
+def render(kind: str | Enum, payload: Any, stream: IO[str]) -> None:
+    """Dispatch to a renderer by :class:`OutputKind`.
+
+    Unknown kinds (or any future kind without a registered renderer) fall
+    through to :func:`_default_handler`, which dumps the payload as JSON.
+    """
+    dispatch_key = kind.value if isinstance(kind, Enum) else kind
+    handler = _RENDERERS.get(dispatch_key, _default_handler)
+    handler(payload, stream)
+
+
+# ── Per-kind renderers ────────────────────────────────────────────────────
+
+
+def _render_write_sync(payload: Any, stream: IO[str]) -> None:
+    """One-liner for a completed synchronous write.
+
+    The headline is "write <id> ok · extracted: <obj-list>" — the curated
+    payload already reduced the extraction tree to compact ``Type(name)``
+    tags (see ``_summarize_extracted`` in ``cli/xmem.py``).
+    """
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    wid = payload.get("write_id", "?")
+    parts = [p for p in (payload.get("extracted") or []) if isinstance(p, str)]
+    extracted = ", ".join(parts) or "(no objects extracted)"
+    stream.write(f"write {wid} ok · extracted: {extracted}\n")
+
+
+def _render_write_async(payload: Any, stream: IO[str]) -> None:
+    """Async write was queued; surface the write_id for follow-up polling."""
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    stream.write(f"write queued: {payload.get('write_id', '?')}\n")
+
+
+def _render_write_status(payload: Any, stream: IO[str]) -> None:
+    """Terminal poll result — short status line, no body."""
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    wid = payload.get("write_id", "?")
+    status = payload.get("write_status", "unknown")
+    stream.write(f"{wid}: {status}\n")
+
+
+def _render_read_single(payload: Any, stream: IO[str]) -> None:
+    """Single-answer read — the answer text *is* the headline.
+
+    The curated payload carries ``answer`` when the reader produced one;
+    otherwise it is the reader_result subtree, which we dump as JSON.
+    Better to show structure than to invent.
+    """
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    answer = payload.get("answer")
+    if isinstance(answer, str) and answer.strip():
+        stream.write(answer.strip() + "\n")
+        return
+    json.dump(payload, stream, indent=2, default=str)
+    stream.write("\n")
+
+
+def _render_read_structured(payload: Any, stream: IO[str]) -> None:
+    """Raw-tables and xresponse reads — there is no useful one-line summary.
+
+    The curated payload IS the rows / xresponse the operator explicitly
+    asked for; dump it as JSON.
+    """
+    json.dump(payload, stream, indent=2, default=str)
+    stream.write("\n")
+
+
+def _render_key_list(payload: Any, stream: IO[str]) -> None:
+    """``xmemcli org list keys`` — table of prefix / name / active.
+
+    Payload is the raw API items list (the envelope ``items`` field).
+    """
+    if not isinstance(payload, list):
+        _default_handler(payload, stream)
+        return
+    if not payload:
+        stream.write("(no keys)\n")
+        return
+    for k in payload:
+        if not isinstance(k, dict):
+            continue
+        prefix = k.get("key_prefix", "????????")
+        name = k.get("name", "(unnamed)")
+        active = k.get("is_active", "?")
+        stream.write(f"{prefix}…  {name}  active={active}\n")
+
+
+def _render_auth_status(payload: Any, stream: IO[str]) -> None:
+    """``xmem auth status`` — one line on whose key the CLI is holding.
+
+    Payload is ``{authenticated, key_prefix, email?}``.
+    """
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    prefix = payload.get("key_prefix") or "????????"
+    if payload.get("authenticated"):
+        email = payload.get("email") or "(unknown)"
+        stream.write(f"authenticated as {email}  (key {prefix}…)\n")
+    elif payload.get("logged_in") is False:
+        stream.write("not logged in\n")
+    else:
+        stream.write(f"not authenticated — key {prefix}… is not recognized (unknown, inactive, or expired)\n")
+
+
+def _render_login(payload: Any, stream: IO[str]) -> None:
+    """``xmem auth login`` / ``logout`` — one line for authorized or other status."""
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    status = payload.get("status", "?")
+    if status == "authorized":
+        email = payload.get("email") or "(unknown account)"
+        prefix = payload.get("key_prefix") or "????????"
+        rc_file = payload.get("rc_file") or ".xmemrc.json"
+        stream.write("API key installed successfully.\n")
+        stream.write(f"  Account:    {email}\n")
+        stream.write(f"  Key prefix: {prefix}…\n")
+        stream.write(f"  Saved to:   {rc_file}\n")
+    elif status == "aborted":
+        stream.write("Login aborted.\n")
+    else:
+        stream.write(f"auth {status}\n")
+
+
+def _render_version(payload: Any, stream: IO[str]) -> None:
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    stream.write(f"{CLI_NAME} {payload.get('version', '?')}\n")
+
+
+def _render_status(payload: Any, stream: IO[str]) -> None:
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    version = payload.get("version", "?")
+    status = payload.get("status", "?")
+    stream.write(f"{CLI_NAME} {version} · {status}\n")
+
+
+def _render_instance_list(payload: Any, stream: IO[str]) -> None:
+    if not isinstance(payload, list):
+        _default_handler(payload, stream)
+        return
+    if not payload:
+        stream.write("(no instances)\n")
+        return
+    for row in payload:
+        if not isinstance(row, dict):
+            continue
+        iid = row.get("id", "?")
+        name = row.get("name", "(unnamed)")
+        stream.write(f"{iid}  {name}\n")
+
+
+def _render_instance_get(payload: Any, stream: IO[str]) -> None:
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    iid = payload.get("id", "?")
+    name = payload.get("name", "(unnamed)")
+    stream.write(f"{iid}  {name}\n")
+
+
+def _render_instance_delete(payload: Any, stream: IO[str]) -> None:
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    iid = payload.get("instance_id", "?")
+    name = payload.get("name", "")
+    if name:
+        stream.write(f"deleted {iid}  {name}\n")
+    else:
+        stream.write(f"deleted {iid}\n")
+
+
+def _render_instance_create(payload: Any, stream: IO[str]) -> None:
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    iid = payload.get("instance_id", "?")
+    name = payload.get("name", "(unnamed)")
+    stream.write(f"created {iid}  {name}\n")
+    url = payload.get("console_url")
+    if isinstance(url, str) and url.strip():
+        stream.write(f"  console: {url.strip()}\n")
+
+
+def _render_xmd_schema(payload: Any, stream: IO[str]) -> None:
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    if payload.get("valid") is True:
+        stream.write("schema valid\n")
+        return
+    if payload.get("data_schema") is not None:
+        stream.write("schema generated\n")
+        return
+    _default_handler(payload, stream)
+
+
+def _render_schema_dry_run(payload: Any, stream: IO[str]) -> None:
+    if isinstance(payload, dict) and payload.get("status") == "ok":
+        n = len(payload.get("statements") or [])
+        stream.write(f"migration dry-run ok ({n} statement{'s' if n != 1 else ''})\n")
+        return
+    _default_handler(payload, stream)
+
+
+def _render_schema_migrations(payload: Any, stream: IO[str]) -> None:
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    if isinstance(payload.get("record"), dict):
+        stream.write(f"migration {payload['record'].get('id', '?')}\n")
+        return
+    items = payload.get("items")
+    if isinstance(items, list):
+        stream.write(f"{len(items)} migration(s)\n")
+        return
+    _default_handler(payload, stream)
+
+
+def _render_xmd_convert(payload: Any, stream: IO[str]) -> None:
+    if isinstance(payload, dict) and isinstance(payload.get("message"), str):
+        stream.write(payload["message"])
+        if not payload["message"].endswith("\n"):
+            stream.write("\n")
+        return
+    _default_handler(payload, stream)
+
+
+def _render_quota(payload: Any, stream: IO[str]) -> None:
+    """``xmem quota get`` — one line per window: used/limit and server window start.
+
+    Reset instant is intentionally omitted — the API returns ``window_start`` only
+    (anchored billing windows are not inferable client-side).
+    """
+    if not isinstance(payload, list):
+        _default_handler(payload, stream)
+        return
+    if not payload:
+        stream.write("(no quotas)\n")
+        return
+    for row in payload:
+        if not isinstance(row, dict):
+            continue
+        window = row.get("quota_window") or "?"
+        used = row.get("used_tokens", "?")
+        limit = row.get("token_limit", "?")
+        started = row.get("window_start") or "?"
+        stream.write(f"{window}: {used}/{limit} used · window started {started}\n")
+
+
+def _render_error(payload: Any, stream: IO[str]) -> None:
+    """Structured error — short red-ish line on stdout for the operator.
+
+    We deliberately write the human error to **stdout**, not stderr, in
+    pretty-print mode. The exit code already tells the shell something went
+    wrong; piping ``xmem read foo 2>&1`` is awkward, and operators are
+    already used to seeing errors inline. Machines never get here — they
+    see the JSON-mode error payload on stdout.
+    """
+    if not isinstance(payload, dict):
+        _default_handler(payload, stream)
+        return
+    msg = payload.get("error") or "(unspecified error)"
+    status = payload.get("status")
+    stage = payload.get("stage") or "request"
+    if stage == "usage":
+        stream.write(f"{msg}\n")
+        return
+    suffix = f" (HTTP {status})" if status else ""
+    stream.write(f"error [{stage}]: {msg}{suffix}\n")
+
+
+def _render_cluster_list(payload: Any, stream: IO[str]) -> None:
+    if not isinstance(payload, list):
+        _default_handler(payload, stream)
+        return
+    if not payload:
+        stream.write("(no clusters)\n")
+        return
+    for row in payload:
+        if not isinstance(row, dict):
+            continue
+        cid = row.get("id", "?")
+        name = row.get("name", "(unnamed)")
+        stream.write(f"{cid}  {name}\n")
+
+
+def _default_handler(payload: Any, stream: IO[str]) -> None:
+    """Fallback when an OutputKind has no specific renderer.
+
+    Used for new kinds that haven't been wired up yet, and for malformed
+    payloads where the typed renderer would have crashed. Always emits the
+    raw JSON so the operator still sees the truth.
+    """
+    json.dump(payload, stream, indent=2, default=str)
+    stream.write("\n")
+
+
+# ── Dispatch table ────────────────────────────────────────────────────────
+
+
+_RENDERERS: dict[str, Renderer] = {
+    "write_sync": _render_write_sync,
+    "write_async": _render_write_async,
+    "write_status": _render_write_status,
+    "read_single": _render_read_single,
+    "read_raw": _render_read_structured,
+    "read_xresponse": _render_read_structured,
+    "key_list": _render_key_list,
+    "auth_status": _render_auth_status,
+    "login": _render_login,
+    "version": _render_version,
+    "status": _render_status,
+    "quota": _render_quota,
+    "cluster_list": _render_cluster_list,
+    "instance_list": _render_instance_list,
+    "instance_get": _render_instance_get,
+    "instance_create": _render_instance_create,
+    "instance_delete": _render_instance_delete,
+    "schema_update": _render_xmd_schema,
+    "schema_dry_run": _render_schema_dry_run,
+    "schema_migrations": _render_schema_migrations,
+    "xmd_schema": _render_xmd_schema,
+    "xmd_enhance": _render_xmd_schema,
+    "xmd_convert": _render_xmd_convert,
+    "error": _render_error,
+}