deyta-cli 0.1.0__py3-none-any.whl

deyta_cli/commands/memory.py

@@ -0,0 +1,233 @@
+"""`deyta memory …` — Khora's primitives: remember / recall / forget / ingest.
+
+The core logic lives in module-level ``run_*`` functions so the top-level shorthands
+(`deyta ingest`, `deyta query`) can reuse them verbatim.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn
+
+from .. import ingest_walk, render
+from ..client import DeytaClientError
+from ._common import get_client, require_project, resolve_namespace, resolve_ontology
+
+app = typer.Typer(help="Memory operations (Khora).", no_args_is_help=True)
+
+
+# --------------------------------------------------------------------------- #
+# Core logic (reused by the top-level aliases)
+# --------------------------------------------------------------------------- #
+def run_remember(
+    ctx: typer.Context,
+    text: str,
+    namespace: str | None,
+    title: str,
+    source: str,
+    entity_types: str | None,
+    relationship_types: str | None,
+) -> None:
+    cfg = require_project(ctx)
+    nsid = resolve_namespace(cfg, namespace)
+    ents, rels = resolve_ontology(cfg, entity_types, relationship_types)
+    client = get_client(ctx)
+    try:
+        result = client.remember(
+            {
+                "content": text,
+                "namespace": nsid,
+                "title": title,
+                "source": source,
+                "entity_types": ents,
+                "relationship_types": rels,
+            }
+        )
+    except DeytaClientError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    render.success(
+        f"Remembered → document {result.get('document_id')} "
+        f"({result.get('chunks_created', 0)} chunks, "
+        f"{result.get('entities_extracted', 0)} entities)"
+    )
+
+
+def run_recall(
+    ctx: typer.Context,
+    query: str,
+    namespace: str | None,
+    mode: str,
+    limit: int,
+    min_similarity: float,
+    since: str | None,
+    until: str | None,
+    as_json: bool,
+    as_context: bool,
+) -> None:
+    cfg = require_project(ctx)
+    nsid = resolve_namespace(cfg, namespace)
+    client = get_client(ctx)
+    try:
+        result = client.recall(
+            {
+                "query": query,
+                "namespace": nsid,
+                "mode": mode,
+                "limit": limit,
+                "min_similarity": min_similarity,
+                "start_time": since,
+                "end_time": until,
+                "context": as_context,
+            }
+        )
+    except DeytaClientError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    if as_json:
+        render.console.print_json(json.dumps(result))
+    elif as_context:
+        render.console.print(result.get("context_text", ""))
+    else:
+        render.recall_result(result)
+
+
+def run_ingest(
+    ctx: typer.Context,
+    path: Path,
+    namespace: str | None,
+    recursive: bool,
+    include: str | None,
+    entity_types: str | None,
+    relationship_types: str | None,
+    dry_run: bool,
+) -> None:
+    cfg = require_project(ctx)
+    nsid = resolve_namespace(cfg, namespace)
+    ents, rels = resolve_ontology(cfg, entity_types, relationship_types)
+    try:
+        files = ingest_walk.discover(path, recursive=recursive, include=include)
+    except FileNotFoundError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    root = path if path.is_dir() else path.parent
+    documents = ingest_walk.build_documents(files, root=root)
+    if not documents:
+        render.error(f"No ingestible text files found under {path}.")
+        raise typer.Exit(1)
+
+    if dry_run:
+        render.info(f"[bold]{len(documents)}[/] document(s) would be ingested into {nsid}:")
+        for d in documents:
+            render.info(f"  • {d['source']}")
+        return
+
+    client = get_client(ctx)
+    payload = {
+        "documents": documents,
+        "namespace": nsid,
+        "entity_types": ents,
+        "relationship_types": rels,
+    }
+    with Progress(
+        TextColumn("[bold blue]Ingesting"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TextColumn("{task.completed}/{task.total} docs"),
+        console=render.console,
+    ) as progress:
+        task = progress.add_task("ingest", total=len(documents))
+        try:
+            for event in client.ingest(payload):
+                kind = event.get("type")
+                if kind == "progress":
+                    progress.update(task, completed=event.get("processed", 0), total=event.get("total"))
+                elif kind == "error":
+                    progress.stop()
+                    render.error(event.get("detail", "ingest failed"))
+                    raise typer.Exit(1)
+                elif kind == "result":
+                    progress.update(task, completed=event.get("total", len(documents)))
+                    render.batch_summary(event)
+        except DeytaClientError as exc:
+            progress.stop()
+            render.error(str(exc))
+            raise typer.Exit(1) from exc
+
+
+# --------------------------------------------------------------------------- #
+# `deyta memory …` commands
+# --------------------------------------------------------------------------- #
+_NS = typer.Option(None, "--namespace", "-n", help="Namespace name or id (default: active).")
+_ENT = typer.Option(None, "--entity-types", help="Comma-separated; overrides config default.")
+_REL = typer.Option(None, "--relationship-types", help="Comma-separated; overrides config default.")
+
+
+@app.command("remember")
+def memory_remember(
+    ctx: typer.Context,
+    text: str = typer.Argument(..., help="Text to remember."),
+    namespace: str = _NS,
+    title: str = typer.Option("", "--title"),
+    source: str = typer.Option("", "--source"),
+    entity_types: str = _ENT,
+    relationship_types: str = _REL,
+) -> None:
+    """Remember a single piece of text."""
+    run_remember(ctx, text, namespace, title, source, entity_types, relationship_types)
+
+
+@app.command("recall")
+def memory_recall(
+    ctx: typer.Context,
+    query: str = typer.Argument(..., help="Query text."),
+    namespace: str = _NS,
+    mode: str = typer.Option("hybrid", "--mode", help="hybrid|vector|graph|keyword|all"),
+    limit: int = typer.Option(10, "--limit", "-k"),
+    min_similarity: float = typer.Option(0.0, "--min-similarity"),
+    since: str = typer.Option(None, "--since", help="ISO timestamp lower bound."),
+    until: str = typer.Option(None, "--until", help="ISO timestamp upper bound."),
+    as_json: bool = typer.Option(False, "--json", help="Emit raw JSON."),
+    as_context: bool = typer.Option(False, "--context", help="Emit LLM-ready context text."),
+) -> None:
+    """Recall from memory (semantic / graph / keyword / hybrid)."""
+    run_recall(ctx, query, namespace, mode, limit, min_similarity, since, until, as_json, as_context)
+
+
+@app.command("forget")
+def memory_forget(
+    ctx: typer.Context,
+    document_id: str = typer.Argument(..., help="Document id to forget."),
+    namespace: str = _NS,
+) -> None:
+    """Forget a document (cascades through its provenance)."""
+    cfg = require_project(ctx)
+    nsid = resolve_namespace(cfg, namespace)
+    client = get_client(ctx)
+    try:
+        result = client.forget({"document_id": document_id, "namespace": nsid})
+    except DeytaClientError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    if result.get("forgotten"):
+        render.success(f"Forgot document {document_id}.")
+    else:
+        render.info(f"Document {document_id} not found.")
+
+
+@app.command("ingest")
+def memory_ingest(
+    ctx: typer.Context,
+    path: Path = typer.Argument(..., help="File or directory to ingest."),
+    namespace: str = _NS,
+    recursive: bool = typer.Option(True, "--recursive/--no-recursive"),
+    include: str = typer.Option(None, "--include", help="Glob (e.g. '**/*.md')."),
+    entity_types: str = _ENT,
+    relationship_types: str = _REL,
+    dry_run: bool = typer.Option(False, "--dry-run"),
+) -> None:
+    """Ingest files from a path (bulk remember)."""
+    run_ingest(ctx, path, namespace, recursive, include, entity_types, relationship_types, dry_run)

deyta_cli/commands/namespace.py

@@ -0,0 +1,117 @@
+"""`deyta namespace …` (alias `ns`) — manage namespaces.
+
+Khora keys namespaces by UUID; friendly names are a CLI concern, stored as a
+name->UUID map in deyta.toml (and echoed into Khora's config_overrides server-side).
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .. import render
+from ..client import DeytaClientError
+from ._common import get_client, require_project
+
+app = typer.Typer(help="Manage namespaces.", no_args_is_help=True)
+
+
+@app.command("create")
+def ns_create(ctx: typer.Context, name: str = typer.Argument(..., help="Friendly name.")) -> None:
+    """Create a namespace and remember its name locally."""
+    cfg = require_project(ctx)
+    if name in cfg.namespaces:
+        render.error(f"Namespace {name!r} already exists locally.")
+        raise typer.Exit(1)
+    client = get_client(ctx)
+    try:
+        result = client.create_namespace(name)
+    except DeytaClientError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    nsid = result["namespace_id"]
+    cfg.add_namespace(name, nsid)
+    if cfg.active is None:
+        cfg.active = name
+    cfg.save()
+    render.success(f"Created namespace {name!r}  [dim]({nsid})[/]")
+
+
+@app.command("list")
+def ns_list(ctx: typer.Context) -> None:
+    """List namespaces known to the server."""
+    cfg = require_project(ctx)
+    client = get_client(ctx)
+    try:
+        namespaces = client.list_namespaces()
+    except DeytaClientError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    # Backfill names from the local alias map for any the server didn't store.
+    id_to_name = {v: k for k, v in cfg.namespaces.items()}
+    for ns in namespaces:
+        ns["name"] = ns.get("name") or id_to_name.get(ns.get("namespace_id"))
+    render.namespaces_table(namespaces, cfg.active)
+
+
+@app.command("get")
+def ns_get(ctx: typer.Context, name_or_id: str = typer.Argument(...)) -> None:
+    """Show one namespace."""
+    cfg = require_project(ctx)
+    client = get_client(ctx)
+    nsid = cfg.resolve_namespace(name_or_id)
+    try:
+        ns = client.get_namespace(nsid)
+    except DeytaClientError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    render.console.print(ns)
+
+
+@app.command("delete")
+def ns_delete(
+    ctx: typer.Context,
+    name_or_id: str = typer.Argument(...),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    """Deactivate a namespace (Khora soft-delete) and drop its local alias."""
+    cfg = require_project(ctx)
+    if not yes:
+        import questionary
+
+        if not questionary.confirm(f"Delete namespace {name_or_id!r}?", default=False).ask():
+            raise typer.Exit(0)
+    client = get_client(ctx)
+    nsid = cfg.resolve_namespace(name_or_id)
+    try:
+        client.delete_namespace(nsid)
+    except DeytaClientError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    cfg.remove_namespace(name_or_id)
+    cfg.save()
+    render.success(f"Deleted namespace {name_or_id!r}.")
+
+
+@app.command("use")
+def ns_use(ctx: typer.Context, name: str = typer.Argument(...)) -> None:
+    """Set the active namespace (so commands don't need --namespace)."""
+    cfg = require_project(ctx)
+    if name not in cfg.namespaces:
+        # Not in the local alias map — the server may still know it (e.g. the
+        # namespace was created against a different deyta.toml). Look it up and
+        # backfill the alias so future resolution works offline.
+        client = get_client(ctx)
+        try:
+            namespaces = client.list_namespaces()
+        except DeytaClientError as exc:
+            render.error(str(exc))
+            raise typer.Exit(1) from exc
+        match = next((ns for ns in namespaces if ns.get("name") == name), None)
+        if match is None:
+            known = ", ".join(sorted(n for ns in namespaces if (n := ns.get("name")))) or "(none)"
+            render.error(f"Unknown namespace {name!r}. Known on server: {known}")
+            raise typer.Exit(1)
+        cfg.add_namespace(name, match["namespace_id"])
+    cfg.active = name
+    cfg.save()
+    render.success(f"Active namespace is now {name!r}.")

deyta_cli/commands/serve.py

@@ -0,0 +1,102 @@
+"""Daemon + whole-stack lifecycle: serve / status / stop / up / down."""
+
+from __future__ import annotations
+
+import time
+
+import typer
+
+from .. import config, docker, render
+from ..client import DeytaClient, DeytaClientError
+from ..server import runner
+from ._common import bring_up_datastores, get_host, require_project
+
+
+def serve(
+    ctx: typer.Context,
+    port: int = typer.Option(None, "--port", "-p", help="Port to bind (default from deyta.toml)."),
+    detach: bool = typer.Option(False, "--detach", "-d", help="Run in the background."),
+) -> None:
+    """Start the Deyta daemon (FastAPI wrapping Khora)."""
+    cfg = require_project(ctx)
+    bind_port = port or cfg.port
+    if detach:
+        pid = runner.serve_detached(cfg, bind_port)
+        if _wait_until_up(bind_port):
+            render.success(
+                f"Deyta server started (pid {pid}) on http://localhost:{bind_port}"
+            )
+        else:
+            render.error("Server did not become healthy; check .deyta/server.log")
+            raise typer.Exit(1)
+    else:
+        render.info(f"Deyta server on http://localhost:{bind_port}  (Ctrl-C to stop)")
+        runner.serve_foreground(cfg, bind_port)
+
+
+def status(ctx: typer.Context) -> None:
+    """Show whether the daemon is running and how it's configured."""
+    client = DeytaClient(get_host(ctx))
+    try:
+        health = client.health()
+    except DeytaClientError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    render.health_panel(health, client.host)
+
+
+def stop(ctx: typer.Context) -> None:
+    """Stop a detached daemon started with `deyta serve --detach`."""
+    cfg = require_project(ctx)
+    try:
+        stopped = runner.stop_detached(cfg)
+    except RuntimeError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    if stopped:
+        render.success("Deyta server stopped.")
+    else:
+        render.info("No detached Deyta server recorded for this project.")
+
+
+def up(
+    ctx: typer.Context,
+    detach: bool = typer.Option(True, "--detach/--no-detach", "-d", help="Background the server."),
+) -> None:
+    """Bring up the whole local stack (datastores if postgres, then the server)."""
+    cfg = require_project(ctx)
+    if cfg.backend == config.BACKEND_POSTGRES:
+        bring_up_datastores()
+    render.info("Starting server…")
+    pid = runner.serve_detached(cfg, cfg.port)
+    if _wait_until_up(cfg.port):
+        render.success(f"Stack up (server pid {pid}) on http://localhost:{cfg.port}")
+    else:
+        render.error("Server did not become healthy; check .deyta/server.log")
+        raise typer.Exit(1)
+
+
+def down(ctx: typer.Context) -> None:
+    """Tear down the whole local stack."""
+    cfg = require_project(ctx)
+    try:
+        stopped = runner.stop_detached(cfg)
+    except RuntimeError as exc:
+        render.error(str(exc))
+        raise typer.Exit(1) from exc
+    render.info("Server stopped." if stopped else "No detached server running.")
+    if cfg.backend == config.BACKEND_POSTGRES:
+        try:
+            docker.down()
+            render.info("Datastores stopped.")
+        except docker.DockerError as exc:
+            render.error(str(exc))
+
+
+def _wait_until_up(port: int, attempts: int = 60) -> bool:
+    client = DeytaClient(f"http://localhost:{port}")
+    for _ in range(attempts):
+        if client.is_up():
+            return True
+        time.sleep(0.5)
+    return False

deyta_cli/commands/update.py

@@ -0,0 +1,66 @@
+"""`deyta update` — upgrade whichever of the CLI / Khora has a newer release."""
+
+from __future__ import annotations
+
+import subprocess
+
+import typer
+
+from .. import render, versions
+
+
+def update(
+    ctx: typer.Context,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt."),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Show what would be upgraded without running it."
+    ),
+) -> None:
+    """Upgrade the Deyta CLI and/or Khora to the latest published versions."""
+    with render.console.status("[bold]Checking PyPI for newer releases…[/]", spinner="dots"):
+        statuses = versions.gather(check_remote=True)
+    render.versions_report(statuses)
+
+    outdated = [s for s in statuses if s.outdated]
+    if not outdated:
+        render.success("Everything is already up to date.")
+        return
+
+    installer = versions.detect_installer()
+    if installer is versions.Installer.EDITABLE:
+        render.info(
+            "\nThis is an editable/dev install. Update it from the source checkout:\n"
+            "  [bold]git pull && uv sync[/]"
+        )
+        return
+
+    commands = versions.upgrade_commands(installer, [s.name for s in outdated])
+    if not commands:
+        render.error(
+            "Couldn't determine how to upgrade this installation. "
+            "Upgrade `deyta-cli` (and `khora`) with your package manager manually."
+        )
+        raise typer.Exit(1)
+
+    names = " and ".join(s.label for s in outdated)
+    render.info(f"\nWill upgrade {names} via [bold]{installer.value}[/]:")
+    for cmd in commands:
+        render.info(f"  [dim]$[/] {' '.join(cmd)}")
+
+    if dry_run:
+        return
+
+    if not yes:
+        import questionary
+
+        if not questionary.confirm("Proceed with the upgrade?", default=True).ask():
+            render.info("Aborted.")
+            return
+
+    for cmd in commands:
+        result = subprocess.run(cmd)
+        if result.returncode != 0:
+            render.error(f"Upgrade command failed: {' '.join(cmd)}")
+            raise typer.Exit(result.returncode)
+
+    render.success(f"Upgraded {names}. Run `deyta version` to confirm.")

deyta_cli/commands/version.py

@@ -0,0 +1,36 @@
+"""`deyta version` — show installed CLI/Khora versions and flag updates."""
+
+from __future__ import annotations
+
+import typer
+
+from .. import render, versions
+
+
+def version(
+    ctx: typer.Context,
+    check: bool = typer.Option(
+        True,
+        "--check/--no-check",
+        help="Check PyPI for newer releases (network). Use --no-check to stay offline.",
+    ),
+) -> None:
+    """Show installed Deyta CLI and Khora versions, and whether updates exist."""
+    if check:
+        with render.console.status("[bold]Checking PyPI for newer releases…[/]", spinner="dots"):
+            statuses = versions.gather(check_remote=True)
+    else:
+        statuses = versions.gather(check_remote=False)
+
+    render.banner()
+    render.versions_report(statuses)
+
+    outdated = [s for s in statuses if s.outdated]
+    if outdated:
+        names = " and ".join(s.label for s in outdated)
+        render.info(
+            f"\n[yellow]Update available[/] for {names}. "
+            f"Run [bold]deyta update[/] to upgrade."
+        )
+    elif check:
+        render.success("Everything is up to date.")