sovaria-cli 0.2.0__py3-none-any.whl

apps/cli/src/commands/chrono.py

@@ -0,0 +1,248 @@
+"""Chrono timeline engine commands."""
+
+from __future__ import annotations
+
+from urllib.parse import quote
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api, print_json
+
+app = typer.Typer(help="Chrono timeline and snapshot operations")
+
+
+@app.command("commit")
+def commit(
+    timeline: str = typer.Option("main", "--timeline"),
+    message: str = typer.Option(..., "--message"),
+    author: str = typer.Option(..., "--author"),
+    event_type: str = typer.Option("update", "--event-type"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Create a new chronon commit."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/chrono/commit",
+            profile=profile,
+            body={
+                "timeline": timeline,
+                "message": message,
+                "author": author,
+                "event_type": event_type,
+            },
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("timeline-list")
+def timeline_list(profile: str | None = typer.Option(None, "--profile")) -> None:
+    """List timelines."""
+    try:
+        result = call_api(method="GET", path="/api/v1/chrono/timelines", profile=profile)
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("timeline-spawn")
+def timeline_spawn(
+    name: str = typer.Argument(...),
+    source_hex_id: str | None = typer.Option(None, "--source-hex-id"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Spawn a new timeline from a source head."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/chrono/timelines/spawn",
+            profile=profile,
+            body={"name": name, "source_hex_id": source_hex_id},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("timeline-delete")
+def timeline_delete(
+    name: str = typer.Argument(...),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Delete a timeline."""
+    try:
+        result = call_api(
+            method="DELETE",
+            path=f"/api/v1/chrono/timelines/{quote(name, safe='')}",
+            profile=profile,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("timeline-jump")
+def timeline_jump(
+    name: str = typer.Argument(...),
+    target_hex: str = typer.Option(..., "--target-hex"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Force-jump a timeline to a specific head."""
+    try:
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/chrono/timelines/{quote(name, safe='')}/jump",
+            profile=profile,
+            body={"target_hex": target_hex},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("timeline-history")
+def timeline_history(
+    name: str = typer.Argument(...),
+    limit: int = typer.Option(50, "--limit"),
+    offset: int = typer.Option(0, "--offset"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Show timeline history."""
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/chrono/timelines/{quote(name, safe='')}/history",
+            profile=profile,
+            params={"limit": str(limit), "offset": str(offset)},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("topology")
+def topology(
+    timeline: str = typer.Option("main", "--timeline"),
+    limit: int = typer.Option(50, "--limit"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Show timeline topology graph."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/chrono/timelines/topology",
+            profile=profile,
+            params={"timeline": timeline, "limit": str(limit)},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("converge")
+def converge(
+    target: str = typer.Option(..., "--target"),
+    source: str = typer.Option(..., "--source"),
+    author: str = typer.Option(..., "--author"),
+    message: str = typer.Option(..., "--message"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Converge source timeline into target."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/chrono/timelines/converge",
+            profile=profile,
+            body={
+                "target": target,
+                "source": source,
+                "author": author,
+                "message": message,
+            },
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("variance")
+def variance(
+    old_chronon_hex: str = typer.Option(..., "--old"),
+    new_chronon_hex: str = typer.Option(..., "--new"),
+    domain_filter: str | None = typer.Option(None, "--domain-filter"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Calculate variance between chronons."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/chrono/variance",
+            profile=profile,
+            body={
+                "old_chronon_hex": old_chronon_hex,
+                "new_chronon_hex": new_chronon_hex,
+                "domain_filter": domain_filter,
+            },
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("snapshot-create")
+def snapshot_create(
+    message: str = typer.Option(..., "--message"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Create a Chrono snapshot."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/chrono/snapshots/create",
+            profile=profile,
+            body={"message": message},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("snapshot-list")
+def snapshot_list(profile: str | None = typer.Option(None, "--profile")) -> None:
+    """List Chrono snapshots."""
+    try:
+        result = call_api(method="GET", path="/api/v1/chrono/snapshots", profile=profile)
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("snapshot-restore")
+def snapshot_restore(
+    snapshot_id: int = typer.Argument(...),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Restore a snapshot by id."""
+    try:
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/chrono/snapshots/{snapshot_id}/restore",
+            profile=profile,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))

apps/cli/src/commands/context.py

@@ -0,0 +1,99 @@
+"""
+apps.cli.src.commands.context — Show current user/org context.
+
+Phase 1 §9 Sprint 3.2: `sov context` prints who you are and what
+resources you have access to, by querying the Axis context endpoint
+through the Gateway.
+"""
+
+from __future__ import annotations
+
+import httpx
+import typer
+
+from apps.cli.src.utils.auth_store import load_tokens
+from apps.cli.src.utils.config import get_api_url
+
+app = typer.Typer()
+
+
+@app.command("whoami")
+def whoami(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Print the currently authenticated user."""
+    tokens = load_tokens(profile=profile)
+    if not tokens:
+        typer.echo("Not logged in. Run: sov login", err=True)
+        raise typer.Exit(1)
+
+    api_url = get_api_url(profile)
+    try:
+        resp = httpx.get(
+            f"{api_url}/api/v1/auth/me",
+            headers={"Authorization": f"Bearer {tokens['access_token']}"},
+            timeout=10,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        typer.echo(f"user_id : {data.get('user_id', '-')}")
+        typer.echo(f"email   : {data.get('email', '-')}")
+        typer.echo(f"roles   : {', '.join(data.get('roles', []))}")
+        typer.echo(f"lane    : {data.get('actor_lane', '-')}")
+        typer.echo(f"subject : {data.get('auth_subject_type', '-')}")
+    except httpx.HTTPStatusError as exc:
+        if exc.response.status_code == 401:
+            typer.echo("Session expired - run: sov login", err=True)
+        else:
+            typer.echo(f"Error: {exc.response.text}", err=True)
+        raise typer.Exit(1) from exc
+
+
+@app.command("context")
+def context(
+    resource_id: str = typer.Argument(..., help="Node ID of the resource (ORG / PROJECT / ENV)"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """
+    Show the access roles the current user has on a specific resource.
+
+    Example:
+        sov context proj-abc123
+    """
+    tokens = load_tokens(profile=profile)
+    if not tokens:
+        typer.echo("Not logged in. Run: sov login", err=True)
+        raise typer.Exit(1)
+
+    api_url = get_api_url(profile)
+    try:
+        # First resolve user_id from the access token by calling whoami.
+        me = httpx.get(
+            f"{api_url}/api/v1/auth/me",
+            headers={"Authorization": f"Bearer {tokens['access_token']}"},
+            timeout=10,
+        )
+        me.raise_for_status()
+        me_data = me.json()
+        user_id = me_data.get("user_id") or me_data.get("sub") or me_data.get("id")
+        if not user_id:
+            typer.echo("Could not determine user ID from /auth/me response", err=True)
+            raise typer.Exit(1)
+
+        resp = httpx.get(
+            f"{api_url}/api/v1/context/{user_id}/{resource_id}",
+            headers={"Authorization": f"Bearer {tokens['access_token']}"},
+            timeout=10,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        roles = data.get("roles", [])
+        if roles:
+            typer.echo(f"You have the following roles on {resource_id}:")
+            for role in roles:
+                typer.echo(f"  • {role}")
+        else:
+            typer.echo(f"No access to resource {resource_id}")
+    except httpx.HTTPStatusError as exc:
+        typer.echo(f"Error: {exc.response.text}", err=True)
+        raise typer.Exit(1) from exc

apps/cli/src/commands/data.py

@@ -0,0 +1,272 @@
+"""Data engine commands (Atlas-Doc + Atlas-Rel)."""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api, parse_json_arg, print_json
+
+app = typer.Typer(help="Atlas-Doc and Atlas-Rel operations")
+
+
+def _safe_doc_path(collection: str, document_id: str) -> str:
+    return f"{quote(collection.strip('/'), safe='/')}/{quote(document_id, safe='')}"
+
+
+@app.command("doc-put")
+def doc_put(
+    collection: str = typer.Argument(..., help="Collection path"),
+    document_id: str = typer.Argument(..., help="Document key"),
+    data: str = typer.Argument(..., help="JSON object document body"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Write a plain JSON document."""
+    try:
+        payload = parse_json_arg(data, label="data")
+        if not isinstance(payload, dict):
+            raise CLIRequestError("data must be a JSON object")
+        path = _safe_doc_path(collection, document_id)
+        result = call_api(
+            method="POST",
+            path=f"/api/v1/data/doc/{path}",
+            profile=profile,
+            body={"data": payload},
+            require_scope=False,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("doc-get")
+def doc_get(
+    collection: str = typer.Argument(...),
+    document_id: str = typer.Argument(...),
+    txid: int = typer.Option(0, "--txid", help="Optional historical txid"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Read a plain JSON document."""
+    try:
+        path = _safe_doc_path(collection, document_id)
+        params = {"txid": str(txid)} if txid > 0 else None
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/data/doc/{path}",
+            profile=profile,
+            params=params,
+            require_scope=False,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("doc-delete")
+def doc_delete(
+    collection: str = typer.Argument(...),
+    document_id: str = typer.Argument(...),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Delete a document."""
+    try:
+        path = _safe_doc_path(collection, document_id)
+        result = call_api(
+            method="DELETE",
+            path=f"/api/v1/data/doc/{path}",
+            profile=profile,
+            require_scope=False,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("doc-scan")
+def doc_scan(
+    prefix: str | None = typer.Option(None, "--prefix"),
+    start_key: str | None = typer.Option(None, "--start-key"),
+    end_key: str | None = typer.Option(None, "--end-key"),
+    limit: int = typer.Option(100, "--limit"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Scan Atlas-Doc by prefix/range."""
+    body: dict[str, Any] = {"limit": limit}
+    if prefix is not None:
+        body["prefix"] = prefix
+    if start_key is not None:
+        body["start_key"] = start_key
+    if end_key is not None:
+        body["end_key"] = end_key
+
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/query/scan",
+            profile=profile,
+            body=body,
+            require_scope=False,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("sql")
+def sql_query(
+    sql: str = typer.Argument(..., help="SQL statement"),
+    txid: int = typer.Option(0, "--txid"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Run SQL query through Atlas-Rel."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/sql/query",
+            profile=profile,
+            body={"sql": sql, "txid": txid},
+            require_scope=True,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(print_json(result))
+
+
+@app.command("table-create")
+def table_create(
+    table_name: str = typer.Argument(...),
+    columns: str = typer.Argument(..., help="JSON array of column definitions"),
+    foreign_keys: str | None = typer.Option(None, "--foreign-keys", help="JSON array"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Create a relational table."""
+    try:
+        parsed_columns = parse_json_arg(columns, label="columns")
+        parsed_fk = parse_json_arg(foreign_keys, label="--foreign-keys") if foreign_keys else []
+        if not isinstance(parsed_columns, list):
+            raise CLIRequestError("columns must be a JSON array")
+        if parsed_fk is not None and not isinstance(parsed_fk, list):
+            raise CLIRequestError("--foreign-keys must be a JSON array")
+
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/create",
+            profile=profile,
+            body={
+                "table_name": table_name,
+                "columns": parsed_columns,
+                "foreign_keys": parsed_fk or [],
+            },
+            require_scope=True,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    typer.echo(print_json(result))
+
+
+@app.command("table-drop")
+def table_drop(
+    table_name: str = typer.Argument(...),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """Drop a relational table."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/data/rel/drop",
+            profile=profile,
+            body={"table_name": table_name},
+            require_scope=True,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    typer.echo(print_json(result))
+
+
+@app.command("table-migrations")
+def table_migrations(
+    table_name: str | None = typer.Option(None, "--table"),
+    limit: int = typer.Option(100, "--limit"),
+    offset: int = typer.Option(0, "--offset"),
+    profile: str | None = typer.Option(None, "--profile"),
+    org_id: str | None = typer.Option(None, "--org"),
+    project_id: str | None = typer.Option(None, "--project"),
+    env_id: str | None = typer.Option(None, "--env"),
+) -> None:
+    """List migration log entries."""
+    params = {
+        "limit": str(limit),
+        "offset": str(offset),
+    }
+    if table_name:
+        params["table_name"] = table_name
+
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/data/rel/migrations",
+            profile=profile,
+            params=params,
+            require_scope=True,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+
+    typer.echo(print_json(result))