sovaria-cli 0.2.0__py3-none-any.whl

apps/cli/src/commands/shell.py

@@ -0,0 +1,415 @@
+"""Interactive Sovaria shell REPL (`sov shell`)."""
+
+from __future__ import annotations
+
+import cmd
+import shlex
+from pathlib import Path
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api
+from apps.cli.src.utils.auth_store import load_tokens
+from apps.cli.src.utils.display import print_banner, print_error, print_json, print_sql_result, print_success
+from apps.cli.src.utils.project_context import project_status
+
+app = typer.Typer(help="Interactive Sovaria terminal", invoke_without_command=True)
+
+_SHELL_COMMANDS = (
+    "help",
+    "whoami",
+    "status",
+    "scope",
+    "sql",
+    "sim",
+    "keys",
+    "policy",
+    "vector",
+    "billing",
+    "fn",
+    "db",
+    "sessions",
+    "api",
+    "exit",
+    "quit",
+)
+
+_HELP_LINES = """
+Commands:
+  help                         Show this help
+  whoami                       Current authenticated user
+  status                       Local project link + scope
+  scope                        Show resolved org/project/env
+  sql <query>                  Run SQL (Atlas-Rel)
+  sim discover | runs | run <id>
+  keys list                    List project API keys
+  policy list | check --action A --resource R
+  vector collections           List vector collections
+  billing usage                Current billing usage
+  fn list                      List Forge functions
+  fn logs <name>               Recent function logs
+  db migrations list --local   Local migration files
+  sessions                     List your login sessions
+  api GET /path                Raw gateway call
+  exit | quit                  Leave the shell
+
+Tips:
+  • Tab completes command names; ↑/↓ history when readline is available
+  • Scope auto-resolves from sovaria.config.json — run `sov init` first
+  • Multi-word SQL: sql "SELECT * FROM users LIMIT 5"
+"""
+
+
+def _setup_readline() -> None:
+    """Enable tab completion and persistent history when readline exists."""
+    try:
+        import readline
+    except ImportError:
+        return
+
+    def _completer(text: str, state: int) -> str | None:
+        options = [cmd_name for cmd_name in _SHELL_COMMANDS if cmd_name.startswith(text)]
+        if state < len(options):
+            return options[state]
+        return None
+
+    readline.set_completer(_completer)
+    readline.parse_and_bind("tab: complete")
+    history_path = Path.home() / ".sovaria" / "shell_history"
+    history_path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        readline.read_history_file(str(history_path))
+    except OSError:
+        pass
+
+    import atexit
+
+    def _save_history() -> None:
+        try:
+            readline.write_history_file(str(history_path))
+        except OSError:
+            pass
+
+    atexit.register(_save_history)
+
+
+class SovariaShell(cmd.Cmd):
+    intro = ""
+    prompt = "sov> "
+    doc_header = "Sovaria interactive commands"
+
+    def __init__(self, *, profile: str | None = None) -> None:
+        super().__init__()
+        self.profile = profile
+
+    def precmd(self, line: str) -> str:
+        return line.strip()
+
+    def do_help(self, arg: str) -> None:
+        if arg:
+            super().do_help(arg)
+            return
+        typer.echo(_HELP_LINES)
+
+    def do_exit(self, arg: str) -> bool:
+        typer.echo("Bye.")
+        return True
+
+    def do_quit(self, arg: str) -> bool:
+        return self.do_exit(arg)
+
+    def do_whoami(self, arg: str) -> None:
+        try:
+            result = call_api(method="GET", path="/api/v1/auth/me", profile=self.profile)
+            print_json(result)
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def do_status(self, arg: str) -> None:
+        print_json(project_status())
+
+    def do_scope(self, arg: str) -> None:
+        status = project_status()
+        scope = status.get("scope") if isinstance(status, dict) else {}
+        if isinstance(scope, dict):
+            typer.echo(f"org_id     : {scope.get('org_id') or '-'}")
+            typer.echo(f"project_id : {scope.get('project_id') or '-'}")
+            typer.echo(f"env_id     : {scope.get('env_id') or '-'}")
+        else:
+            print_json(status)
+
+    def do_sql(self, arg: str) -> None:
+        if not arg:
+            typer.echo("Usage: sql SELECT ...")
+            return
+        try:
+            result = call_api(
+                method="POST",
+                path="/api/v1/sql/query",
+                profile=self.profile,
+                body={"sql": arg, "txid": 0},
+                require_scope=True,
+            )
+            print_sql_result(result)
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def do_sim(self, arg: str) -> None:
+        parts = shlex.split(arg)
+        if not parts:
+            typer.echo("Usage: sim discover | runs | run <scenario_id>")
+            return
+        sub = parts[0]
+        try:
+            if sub == "discover":
+                print_json(
+                    call_api(
+                        method="POST",
+                        path="/api/v1/sim/discover",
+                        profile=self.profile,
+                        require_scope=True,
+                        body={},
+                    )
+                )
+            elif sub == "runs":
+                limit = "20"
+                if len(parts) >= 3 and parts[1] == "--limit":
+                    limit = parts[2]
+                print_json(
+                    call_api(
+                        method="GET",
+                        path="/api/v1/sim/runs",
+                        profile=self.profile,
+                        require_scope=True,
+                        params={"limit": limit, "offset": "0"},
+                    )
+                )
+            elif sub == "run" and len(parts) >= 2:
+                print_json(
+                    call_api(
+                        method="POST",
+                        path="/api/v1/sim/run",
+                        profile=self.profile,
+                        require_scope=True,
+                        body={"scenario_id": parts[1]},
+                    )
+                )
+            else:
+                typer.echo("Usage: sim discover | runs [--limit N] | run <scenario_id>")
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def do_keys(self, arg: str) -> None:
+        parts = shlex.split(arg)
+        if parts and parts[0] != "list":
+            typer.echo("Usage: keys list")
+            return
+        try:
+            print_json(
+                call_api(
+                    method="GET",
+                    path="/api/v1/apikeys",
+                    profile=self.profile,
+                    require_scope=True,
+                )
+            )
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def do_policy(self, arg: str) -> None:
+        parts = shlex.split(arg)
+        if not parts:
+            typer.echo("Usage: policy list | policy check --action A --resource R")
+            return
+        try:
+            if parts[0] == "list":
+                print_json(
+                    call_api(
+                        method="GET",
+                        path="/api/v1/policies/",
+                        profile=self.profile,
+                        require_scope=True,
+                    )
+                )
+            elif parts[0] == "check":
+                action = ""
+                resource = ""
+                idx = 1
+                while idx < len(parts):
+                    if parts[idx] == "--action" and idx + 1 < len(parts):
+                        action = parts[idx + 1]
+                        idx += 2
+                    elif parts[idx] == "--resource" and idx + 1 < len(parts):
+                        resource = parts[idx + 1]
+                        idx += 2
+                    else:
+                        idx += 1
+                if not action or not resource:
+                    typer.echo("Usage: policy check --action sql:select --resource users")
+                    return
+                status = project_status()
+                scope = status.get("scope") if isinstance(status, dict) else {}
+                org_id = str((scope or {}).get("org_id") or "")
+                project_id = str((scope or {}).get("project_id") or "")
+                print_json(
+                    call_api(
+                        method="POST",
+                        path="/api/v1/policies/check",
+                        profile=self.profile,
+                        body={
+                            "org_id": org_id,
+                            "project_id": project_id,
+                            "action": action,
+                            "resource": resource,
+                            "context": {},
+                        },
+                        require_scope=True,
+                    )
+                )
+            else:
+                typer.echo("Usage: policy list | policy check --action A --resource R")
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def do_vector(self, arg: str) -> None:
+        parts = shlex.split(arg)
+        if not parts or parts[0] != "collections":
+            typer.echo("Usage: vector collections")
+            return
+        try:
+            print_json(
+                call_api(
+                    method="GET",
+                    path="/api/v1/vector/collections",
+                    profile=self.profile,
+                    require_scope=True,
+                )
+            )
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def do_billing(self, arg: str) -> None:
+        parts = shlex.split(arg)
+        if not parts or parts[0] != "usage":
+            typer.echo("Usage: billing usage")
+            return
+        try:
+            print_json(
+                call_api(
+                    method="GET",
+                    path="/api/v1/billing/usage",
+                    profile=self.profile,
+                    require_scope=True,
+                )
+            )
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def do_fn(self, arg: str) -> None:
+        parts = shlex.split(arg)
+        if not parts:
+            typer.echo("Usage: fn list | fn logs <name>")
+            return
+        try:
+            if parts[0] == "list":
+                print_json(
+                    call_api(
+                        method="GET",
+                        path="/api/v1/fn/functions",
+                        profile=self.profile,
+                        require_scope=True,
+                        params={"limit": "50", "offset": "0"},
+                    )
+                )
+            elif parts[0] == "logs" and len(parts) >= 2:
+                from urllib.parse import quote
+
+                name = quote(parts[1], safe="")
+                print_json(
+                    call_api(
+                        method="GET",
+                        path=f"/api/v1/fn/functions/{name}/logs",
+                        profile=self.profile,
+                        require_scope=True,
+                        params={"limit": "20", "offset": "0"},
+                    )
+                )
+            else:
+                typer.echo("Usage: fn list | fn logs <name>")
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def do_db(self, arg: str) -> None:
+        parts = shlex.split(arg)
+        if len(parts) >= 3 and parts[0] == "migrations" and parts[1] == "list" and parts[2] == "--local":
+            from apps.cli.src.utils.migrations import list_local_migrations, load_applied_state
+
+            applied = load_applied_state()
+            for path in list_local_migrations():
+                marker = "✓" if path.name in applied else " "
+                typer.echo(f"  [{marker}] {path.name}")
+            return
+        typer.echo("Usage: db migrations list --local")
+
+    def do_sessions(self, arg: str) -> None:
+        if arg.strip():
+            typer.echo("Usage: sessions")
+            return
+        try:
+            print_json(call_api(method="GET", path="/api/v1/auth/sessions", profile=self.profile))
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def do_api(self, arg: str) -> None:
+        parts = shlex.split(arg)
+        if len(parts) < 2:
+            typer.echo("Usage: api GET /api/v1/...")
+            return
+        method, path = parts[0].upper(), parts[1]
+        try:
+            print_json(
+                call_api(
+                    method=method,
+                    path=path,
+                    profile=self.profile,
+                    require_scope=True,
+                )
+            )
+        except CLIRequestError as exc:
+            print_error(str(exc))
+
+    def default(self, line: str) -> None:
+        if line.startswith("SELECT") or line.startswith("select") or line.startswith("WITH"):
+            self.do_sql(line)
+            return
+        typer.echo(f"Unknown command: {line.split()[0]}. Type `help`.")
+
+
+@app.callback()
+def shell(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Launch an interactive Sovaria REPL with SQL, sim, keys, policy, and more."""
+    if not load_tokens(profile=profile):
+        print_error("Not logged in. Run: sov login")
+        raise typer.Exit(1)
+
+    _setup_readline()
+
+    status = project_status()
+    name = status.get("project_name") if isinstance(status, dict) else None
+    print_banner("Sovaria Shell", name or "Interactive project terminal")
+    if isinstance(status, dict) and status.get("linked"):
+        scope = status.get("scope") or {}
+        typer.echo(
+            f"Linked: {scope.get('org_id', '?')} / {scope.get('project_id', '?')}"
+        )
+        print_success("Scope resolved from sovaria.config.json")
+    else:
+        typer.echo("No local project link. Run `sov init` or `sov project link`.")
+    typer.echo("Type `help` for commands.\n")
+
+    try:
+        SovariaShell(profile=profile).cmdloop()
+    except KeyboardInterrupt:
+        typer.echo("\nBye.")

apps/cli/src/commands/sim.py

@@ -0,0 +1,178 @@
+"""Phase 2 simulation commands (Echo engine)."""
+
+from __future__ import annotations
+
+from urllib.parse import quote
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api, parse_json_arg
+from apps.cli.src.utils.display import print_json
+
+app = typer.Typer(help="Scenario discovery, runs, and comparisons")
+
+
+@app.command("discover")
+def discover(
+    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:
+    """Discover runnable simulation scenarios for the linked project."""
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/sim/discover",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+            body={},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("runs")
+def list_runs(
+    limit: int = typer.Option(20, "--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 simulation runs for the current project."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/sim/runs",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+            params={"limit": str(limit), "offset": str(offset)},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("get")
+def get_run(
+    run_id: str = typer.Argument(..., help="Simulation run ID"),
+    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:
+    """Fetch one simulation run by ID."""
+    try:
+        result = call_api(
+            method="GET",
+            path=f"/api/v1/sim/runs/{quote(run_id, safe='')}",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("compare")
+def compare_runs(
+    target_run_id: str = typer.Argument(..., help="Run to inspect"),
+    baseline_run_id: str = typer.Argument(..., help="Baseline run"),
+    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:
+    """Compare two simulation runs."""
+    try:
+        result = call_api(
+            method="GET",
+            path=(
+                f"/api/v1/sim/runs/{quote(target_run_id, safe='')}/compare/"
+                f"{quote(baseline_run_id, safe='')}"
+            ),
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("run")
+def run_scenario(
+    scenario_id: str = typer.Argument(..., help="Scenario ID from `sov sim discover`"),
+    payload: str | None = typer.Option(None, "--payload", help="JSON object payload"),
+    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:
+    """Execute a discovered simulation scenario."""
+    body = parse_json_arg(payload, label="--payload") if payload else {}
+    if body is not None and not isinstance(body, dict):
+        raise typer.BadParameter("--payload must be a JSON object")
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/sim/run",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+            body={"scenario_id": scenario_id, **(body or {})},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("plan")
+def plan_scenario(
+    scenario_id: str = typer.Argument(..., help="Scenario ID"),
+    payload: str | None = typer.Option(None, "--payload", help="JSON object payload"),
+    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:
+    """Dry-run a scenario and return the execution plan."""
+    body = parse_json_arg(payload, label="--payload") if payload else {}
+    if body is not None and not isinstance(body, dict):
+        raise typer.BadParameter("--payload must be a JSON object")
+    try:
+        result = call_api(
+            method="POST",
+            path="/api/v1/sim/plan",
+            profile=profile,
+            org_id=org_id,
+            project_id=project_id,
+            env_id=env_id,
+            require_scope=True,
+            body={"scenario_id": scenario_id, **(body or {})},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)