ravmem-cli 1.0.0__tar.gz → 1.1.0__tar.gz

{ravmem_cli-1.0.0/ravmem_cli.egg-info → ravmem_cli-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ravmem-cli
-Version: 1.0.0
+Version: 1.1.0
 Summary: RavMem CLI — lightweight client for the RavMem code knowledge graph server
 Author-email: RavMem <harpreet.singh@ravmem.com>
 License-Expression: MIT
@@ -42,7 +42,11 @@ pip install ravmem-cli
 
 ```bash
 # Point the CLI at your RavMem server
-ravmem remote config --url http://localhost:7432
+ravmem remote config --url http://localhost:7432 --api-key <ADMIN_TOKEN>
+
+# Activate the license (one command: seals the key to this machine, then
+# brings the server live — the key is never stored in a file)
+ravmem license activate RAVMEM-XXXX-XXXX-XXXX-XXXX
 
 # Register a repository
 ravmem remote add /path/to/repo --name my-project --default-branch main

{ravmem_cli-1.0.0 → ravmem_cli-1.1.0}/README.md

@@ -12,7 +12,11 @@ pip install ravmem-cli
 
 ```bash
 # Point the CLI at your RavMem server
-ravmem remote config --url http://localhost:7432
+ravmem remote config --url http://localhost:7432 --api-key <ADMIN_TOKEN>
+
+# Activate the license (one command: seals the key to this machine, then
+# brings the server live — the key is never stored in a file)
+ravmem license activate RAVMEM-XXXX-XXXX-XXXX-XXXX
 
 # Register a repository
 ravmem remote add /path/to/repo --name my-project --default-branch main

{ravmem_cli-1.0.0 → ravmem_cli-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ravmem-cli"
-version = "1.0.0"
+version = "1.1.0"
 description = "RavMem CLI — lightweight client for the RavMem code knowledge graph server"
 readme = "README.md"
 requires-python = ">=3.10"

ravmem_cli-1.1.0/ravmem/cli/_common.py

@@ -0,0 +1,138 @@
+"""Shared helpers for ravmem CLI commands."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+
+def detect_branch(repo_path: Path, explicit: Optional[str]) -> str:
+    if explicit:
+        return explicit
+    try:
+        out = subprocess.run(
+            ["git", "-C", str(repo_path), "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True, text=True, check=True,
+        ).stdout.strip()
+        return out if out and out != "HEAD" else "main"
+    except Exception:
+        return "main"
+
+
+def print_embed_job_summary(job: dict) -> None:
+    """Print a one-line summary for the embed job ``wait_for_indexing`` attaches
+    (as ``job["embed_job"]``) when called with ``wait_for="embed"``/``"both"``.
+    No-op if there is no embed job (``wait_for="graph"``, or the server isn't
+    running with embedding decoupled).
+    """
+    embed_job = job.get("embed_job")
+    if not embed_job:
+        return
+    status = embed_job.get("status", "unknown")
+    job_id = embed_job.get("id", "?")
+    if status == "done":
+        typer.echo(f"✓ Embedding complete (job {job_id}) — semantic search is ready.")
+    elif status == "failed":
+        typer.echo(f"✗ Embedding failed (job {job_id}): {embed_job.get('failure_reason', 'unknown')}", err=True)
+    else:
+        typer.echo(f"Embed job {job_id} ended with status: {status}")
+
+
+def wait_for_indexing(client, project_id: str, branch_name: str, job_id: int, wait_for: str) -> dict:
+    """Poll the graph job to completion, then (per ``wait_for``) also poll the embed job.
+
+    ``wait_for="graph"`` (default) returns as soon as the graph job — the one
+    ``job_id`` returned by index/upload endpoints refers to — finishes. This
+    matches pre-decoupling behavior: search over structure/impact is usable.
+
+    ``wait_for="embed"``/``"both"`` additionally look up the branch's
+    ``last_embed_job`` (via ``get_branch_status``) once the graph job is done
+    and poll that too, since the embed job is a separate job the caller
+    doesn't otherwise have the id for. No-ops (no separate embed job exists)
+    when the server isn't running with embedding decoupled — the graph job's
+    own embedding already finished inline in that case.
+
+    Both polls render a live progress bar (phase + %) instead of streaming
+    each poll request to the console — see ``_poll_job_with_progress``.
+    """
+    job = _poll_job_with_progress(client, job_id, "Indexing")
+    if wait_for == "graph" or job.get("status") != "done":
+        return job
+    try:
+        status = client.get_branch_status(project_id, branch_name)
+    except Exception:
+        return job
+    embed_job = status.get("last_embed_job")
+    if not embed_job or not embed_job.get("id"):
+        return job
+    embed_result = _poll_job_with_progress(client, embed_job["id"], "Embedding")
+    return {**job, "embed_job": embed_result}
+
+
+def _poll_job_with_progress(
+    client, job_id: int, label: str, interval: float = 1.0, timeout: float = 600.0,
+) -> dict:
+    """Poll a job to completion, rendering a live progress bar (phase + %)
+    instead of ``client.poll_job``'s silent loop — which, combined with the
+    default INFO log level, used to stream one raw HTTP request/response log
+    line to the console per poll (every 2s) rather than showing progress.
+
+    Temporarily silences the ``httpx`` logger regardless of the configured
+    log level — a log line printed mid-poll would corrupt the live-updating
+    bar's terminal redraw (rich's ``Progress`` assumes exclusive control of
+    the current line while its context is open).
+    """
+    import logging
+    import time
+    from rich.progress import BarColumn, Progress, TextColumn, TimeElapsedColumn
+
+    httpx_logger = logging.getLogger("httpx")
+    prev_level = httpx_logger.level
+    httpx_logger.setLevel(logging.WARNING)
+    deadline = time.monotonic() + timeout
+    try:
+        with Progress(
+            TextColumn("[bold]{task.description}"),
+            BarColumn(),
+            TextColumn("{task.percentage:>3.0f}%"),
+            TextColumn("[dim]{task.fields[phase]}"),
+            TimeElapsedColumn(),
+            transient=True,
+        ) as progress:
+            task = progress.add_task(label, total=100, phase="")
+            while True:
+                job = client.get_job(job_id)
+                status = job.get("status", "")
+                pct = job.get("progress_pct") or 0
+                phase = job.get("current_phase") or status
+                progress.update(task, completed=pct, phase=phase)
+                if status in ("done", "failed", "cancelled"):
+                    progress.update(task, completed=100 if status == "done" else pct)
+                    return job
+                if time.monotonic() >= deadline:
+                    raise TimeoutError(f"Job {job_id} did not complete within {timeout}s")
+                time.sleep(interval)
+    finally:
+        httpx_logger.setLevel(prev_level)
+
+
+def get_client(remote: Optional[str]):
+    from ravmem.client.api import RavMemClient
+    from ravmem.client.config import load_config
+
+    url = remote
+    api_key = None
+    if not url:
+        cfg = load_config()
+        url = cfg.get("server_url")
+        api_key = cfg.get("api_key")
+    if not url:
+        typer.echo(
+            "No server configured. Run: ravmem remote config --url <URL>",
+            err=True,
+        )
+        raise typer.Exit(1)
+    return RavMemClient(base_url=url, api_key=api_key or None)

{ravmem_cli-1.0.0 → ravmem_cli-1.1.0}/ravmem/cli/_errors.py

@@ -72,11 +72,66 @@ def handle_error(exc: Exception, server_url: str = "") -> None:
                 err=True,
             )
         elif code == 403:
-            typer.echo(
-                "Error: Permission denied - your token does not have the required permission.\n"
-                "  Ask an admin to grant the necessary role.",
-                err=True,
-            )
+            # Distinguish entitlement enforcement errors from plain RBAC denials
+            event_code = ""
+            try:
+                body = exc.response.json()
+                if isinstance(body.get("detail"), dict):
+                    event_code = body["detail"].get("event_code", "")
+                    detail = body["detail"].get("message", detail)
+            except Exception:
+                pass
+            _ENTITLEMENT_HINTS: dict[str, str] = {
+                "ENTITLEMENT_PROJECTS_LIMIT": (
+                    "You have reached the project limit for your plan. "
+                    "Delete an existing project or upgrade your plan."
+                ),
+                "ENTITLEMENT_LOC_LIMIT": (
+                    "You have reached the lines-of-code limit for your plan. "
+                    "Remove a project or upgrade your plan."
+                ),
+                "ENTITLEMENT_KG_NODE_LIMIT": (
+                    "You have reached the knowledge graph node limit for your plan. "
+                    "Deactivate unused nodes or upgrade your plan."
+                ),
+                "ENTITLEMENT_USER_LIMIT": (
+                    "You have reached the user limit for your plan. "
+                    "Remove a user or upgrade your plan to add more seats."
+                ),
+                "ENTITLEMENT_SINGLE_USER_MODE": (
+                    "User management is disabled on this installation (single-user mode). "
+                    "Upgrade your plan to add more users."
+                ),
+                "ENTITLEMENT_CROSSGRAPH_DISABLED": (
+                    "Cross-graph linking is not available on your plan. "
+                    "Upgrade to Pro or higher."
+                ),
+                "ENTITLEMENT_OBSERVABILITY_DISABLED": (
+                    "Full observability/metrics are not available on your plan. "
+                    "Upgrade to Pro or higher."
+                ),
+                "ENTITLEMENT_AUDIT_LOGS_DISABLED": (
+                    "Audit logs are not available on your plan. "
+                    "Upgrade to Team or higher."
+                ),
+                "ENTITLEMENT_OIDC_DISABLED": (
+                    "OIDC authentication is not available on your plan. "
+                    "Contact ravmem for Enterprise licensing."
+                ),
+                "ENTITLEMENT_CONNECTIONS_LIMIT": (
+                    "Too many concurrent connections for your plan. "
+                    "Retry shortly or upgrade your plan."
+                ),
+            }
+            hint = _ENTITLEMENT_HINTS.get(event_code)
+            if hint:
+                typer.echo(f"Error: License limit — {detail}\n  Hint: {hint}", err=True)
+            else:
+                typer.echo(
+                    f"Error: Permission denied - {detail}\n"
+                    "  Ask an admin to grant the necessary role.",
+                    err=True,
+                )
         elif code == 404:
             typer.echo(f"Error: Not found - {detail}", err=True)
         elif code == 409:
@@ -93,7 +148,10 @@ def handle_error(exc: Exception, server_url: str = "") -> None:
         elif code == 503:
             typer.echo(
                 f"Error: Server unavailable - {detail}\n"
-                "  ArcadeDB may be starting up. Check: ravmem health",
+                "  Possible causes:\n"
+                "    - License not activated: run 'ravmem license init'\n"
+                "    - ArcadeDB is still starting up\n"
+                "  Check server status with: ravmem health",
                 err=True,
             )
         else:

{ravmem_cli-1.0.0 → ravmem_cli-1.1.0}/ravmem/cli/analyze.py

@@ -46,16 +46,19 @@ def _get_client(remote: str | None):
 def _print_job_result(job: dict) -> None:
     status = job.get("status", "unknown")
     if status == "done":
-        typer.echo(f"✓ Indexing complete (job {job.get('job_id', '?')}).")
+        typer.echo(f"✓ Indexing complete (job {job.get('id', job.get('job_id', '?'))}).")
     elif status == "failed":
         typer.echo(
-            f"✗ Indexing failed (job {job.get('job_id', '?')}): "
+            f"✗ Indexing failed (job {job.get('id', job.get('job_id', '?'))}): "
             f"{job.get('failure_reason', 'unknown')}",
             err=True,
         )
         raise typer.Exit(1)
     else:
-        typer.echo(f"Job {job.get('job_id', '?')} ended with status: {status}")
+        typer.echo(f"Job {job.get('id', job.get('job_id', '?'))} ended with status: {status}")
+
+    from ravmem.cli._common import print_embed_job_summary
+    print_embed_job_summary(job)
 
 
 def _analyze_upload(
@@ -67,6 +70,7 @@ def _analyze_upload(
     batch_size: int,
     lang_list: list[str],
     wait: bool,
+    wait_for: str = "graph",
 ) -> None:
     """Upload committed files to the server in batches and trigger indexing."""
     from ravmem.cli.git_local import ls_files, rev_parse, LocalGitError
@@ -157,7 +161,8 @@ def _analyze_upload(
 
     if wait:
         typer.echo("Waiting for completion…")
-        job = client.poll_job(job_id)
+        from ravmem.cli._common import wait_for_indexing
+        job = wait_for_indexing(client, project_id, branch_name, job_id, wait_for)
         _print_job_result(job)
 
 
@@ -170,6 +175,7 @@ def _analyze_incremental_upload(
     batch_size: int,
     lang_list: list[str],
     wait: bool,
+    wait_for: str = "graph",
 ) -> None:
     """Upload only the files changed since the last index, plus a deletion list."""
     from ravmem.cli.git_local import diff_name_status, rev_parse, LocalGitError
@@ -194,6 +200,7 @@ def _analyze_incremental_upload(
             batch_size=batch_size,
             lang_list=lang_list,
             wait=wait,
+            wait_for=wait_for,
         )
         return
 
@@ -281,7 +288,8 @@ def _analyze_incremental_upload(
 
     if wait:
         typer.echo("Waiting for completion…")
-        job = client.poll_job(job_id)
+        from ravmem.cli._common import wait_for_indexing
+        job = wait_for_indexing(client, project_id, branch_name, job_id, wait_for)
         _print_job_result(job)
 
 
@@ -294,6 +302,7 @@ def _analyze_server_side(
     wait: bool,
     yes: bool,
     no_auto_sync: bool = False,
+    wait_for: str = "graph",
 ) -> None:
     """Trigger server-side indexing (mount / clone projects)."""
     # Pre-flight divergence check
@@ -340,7 +349,8 @@ def _analyze_server_side(
 
     if wait and job_id is not None:
         typer.echo("Waiting for completion…")
-        job = client.poll_job(job_id)
+        from ravmem.cli._common import wait_for_indexing
+        job = wait_for_indexing(client, project_id, branch_name, job_id, wait_for)
         _print_job_result(job)
 
 
@@ -374,6 +384,13 @@ def analyze_cmd(
         help="Set/update the project's default/parent branch",
     ),
     wait: bool = typer.Option(False, "--wait", "-w", help="Wait for indexing to complete"),
+    wait_for: str = typer.Option(
+        "graph", "--wait-for",
+        help="What --wait waits for: 'graph' (structure/impact ready — default), "
+             "'embed' (semantic search ready), or 'both'. Embedding is decoupled "
+             "into its own job by default on the server, so 'graph' now returns "
+             "~8x faster than the old single-job wait.",
+    ),
     yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompts (CI/scripts)"),
     no_auto_sync: bool = typer.Option(
         False, "--no-auto-sync",
@@ -411,6 +428,10 @@ def analyze_cmd(
       ravmem analyze --project myproject --wait
     """
 
+    if wait_for not in ("graph", "embed", "both"):
+        typer.echo(f"✗ --wait-for must be one of: graph, embed, both (got '{wait_for}')", err=True)
+        raise typer.Exit(1)
+
     repo_path = repo.resolve()
 
     client = _get_client(remote)
@@ -468,6 +489,7 @@ def analyze_cmd(
                     batch_size=batch_size,
                     lang_list=lang_list,
                     wait=wait,
+                    wait_for=wait_for,
                 )
             else:
                 _analyze_upload(
@@ -479,6 +501,7 @@ def analyze_cmd(
                     batch_size=batch_size,
                     lang_list=lang_list,
                     wait=wait,
+                    wait_for=wait_for,
                 )
         else:
             # mount or clone — server-side indexing
@@ -492,6 +515,7 @@ def analyze_cmd(
                 wait=wait,
                 yes=yes,
                 no_auto_sync=no_auto_sync,
+                wait_for=wait_for,
             )
 
     finally:

{ravmem_cli-1.0.0 → ravmem_cli-1.1.0}/ravmem/cli/auth.py

@@ -201,12 +201,13 @@ def list_users(
     table.add_column("Status")
     table.add_column("Created")
     for u in users:
-        status_style = "green" if u.get("status") == "active" else "red"
+        st = u.get("status", "")
+        status_style = "green" if st == "active" else ("dim" if st == "deleted" else "red")
         table.add_row(
             u.get("id", ""),
             u.get("email", ""),
             u.get("name", ""),
-            f"[{status_style}]{u.get('status', '')}[/{status_style}]",
+            f"[{status_style}]{st}[/{status_style}]",
             u.get("created_at", "")[:10],
         )
     console.print(table)
@@ -220,7 +221,11 @@ def delete_user(
     """Delete a user and all their tokens/roles (admin only)."""
 
     if not yes:
-        typer.confirm(f"Are you sure you want to delete user '{user_id}'? This cannot be undone.", abort=True)
+        typer.confirm(
+            f"Soft-delete user '{user_id}'? Their account will be deactivated and all tokens revoked. "
+            "Knowledge graph nodes they authored are preserved.",
+            abort=True,
+        )
 
     client = _get_client()
     try:
@@ -683,3 +688,56 @@ def refresh_token():
     console.print("[bold green]Token refreshed.[/bold green] New API key saved locally.")
     console.print(f"  Token ID: {result.get('id', '?')}")
     console.print(f"  Expires:  {result.get('expires_at') or 'never'}")
+
+
+# ---------------------------------------------------------------------------
+# Password management
+# ---------------------------------------------------------------------------
+
+@app.command("set-password")
+def set_password(
+    user_id: str = typer.Argument(..., help="User ID to set password for"),
+    password: Optional[str] = typer.Option(None, "--password", "-p", help="New password (prompted if omitted)"),
+):
+    """Admin: set a user's password directly (no current password required)."""
+    console = _console()
+    if not password:
+        password = typer.prompt("New password", hide_input=True, confirmation_prompt=True)
+
+    client = _get_client()
+    try:
+        client._request("PATCH", f"/api/auth/users/{user_id}/password", json={"password": password})
+    except RavMemAPIError as exc:
+        _handle_api_error(exc)
+        raise typer.Exit(1)
+    finally:
+        client.close()
+
+    console.print(f"[bold green]Password updated[/bold green] for user [cyan]{user_id}[/cyan].")
+
+
+@app.command("change-password")
+def change_password(
+    current: Optional[str] = typer.Option(None, "--current", help="Current password (prompted if omitted)"),
+    new: Optional[str] = typer.Option(None, "--new", help="New password (prompted if omitted)"),
+):
+    """Self-service: change your own password. All other sessions are revoked on success."""
+    console = _console()
+    if not current:
+        current = typer.prompt("Current password", hide_input=True)
+    if not new:
+        new = typer.prompt("New password", hide_input=True, confirmation_prompt=True)
+
+    client = _get_client()
+    try:
+        result = client._request(
+            "POST", "/api/auth/users/me/password",
+            json={"current_password": current, "new_password": new},
+        )
+    except RavMemAPIError as exc:
+        _handle_api_error(exc)
+        raise typer.Exit(1)
+    finally:
+        client.close()
+
+    console.print("[bold green]Password changed.[/bold green]", result.get("message", ""))

{ravmem_cli-1.0.0 → ravmem_cli-1.1.0}/ravmem/cli/info.py

@@ -75,7 +75,11 @@ def metrics_cmd(
         typer.echo("Cannot reach server. Is it running?", err=True)
         raise typer.Exit(1)
     except httpx.HTTPStatusError as exc:
-        typer.echo(f"Error {exc.response.status_code} from server.", err=True)
+        try:
+            detail = exc.response.json().get("detail") or exc.response.text
+        except Exception:
+            detail = exc.response.text
+        typer.echo(f"Error {exc.response.status_code} from server: {detail}", err=True)
         raise typer.Exit(1)
 
     typer.echo(resp.text)