maitai-cli 0.1.1__py3-none-any.whl

maitai_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Maitai CLI - Command-line interface for the Maitai Platform Developer API."""
+
+__version__ = "0.1.1"

maitai_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as python -m maitai_cli."""
+
+from maitai_cli.main import main
+
+if __name__ == "__main__":
+    main()

maitai_cli/api.py

@@ -0,0 +1,90 @@
+"""
+API client for the Maitai Platform Developer API (api/v1).
+
+API documentation: docs/internal and docs/external in the maitai-mono repo.
+Base URL: https://api.trymaitai.ai/api/v1
+Authentication: X-Maitai-Api-Key header (create keys in Portal → Settings → API Keys).
+"""
+
+from typing import Any
+
+import httpx
+from maitai_cli.config import get_api_key, get_base_url
+
+
+class APIError(Exception):
+    """Raised when an API request fails."""
+
+    def __init__(self, status_code: int, message: str, details: dict | None = None):
+        self.status_code = status_code
+        self.message = message
+        self.details = details or {}
+        super().__init__(f"{status_code}: {message}")
+
+
+class APIClient:
+    """HTTP client for the Maitai Developer API."""
+
+    def __init__(self, api_key: str | None = None, base_url: str | None = None):
+        self.api_key = api_key or get_api_key()
+        self.base_url = (base_url or get_base_url()).rstrip("/")
+        self._client: httpx.Client | None = None
+
+    def _get_client(self) -> httpx.Client:
+        if self._client is None:
+            headers = {}
+            if self.api_key:
+                headers["X-Maitai-Api-Key"] = self.api_key
+            self._client = httpx.Client(
+                base_url=self.base_url,
+                headers=headers,
+                timeout=30.0,
+            )
+        return self._client
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        if self._client:
+            self._client.close()
+            self._client = None
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict | None = None,
+        json: dict | None = None,
+    ) -> dict[str, Any]:
+        """Make an API request and return the parsed JSON response."""
+        if not self.api_key:
+            raise APIError(
+                401, "Not authenticated. Run 'maitai login' or set MAITAI_API_KEY."
+            )
+        client = self._get_client()
+        path = path if path.startswith("/") else f"/{path}"
+        r = client.request(method, path, params=params, json=json)
+        try:
+            body = r.json()
+        except Exception:
+            body = {}
+        if r.status_code >= 400:
+            err = body.get("error", {})
+            raise APIError(
+                r.status_code,
+                err.get("message", r.text or str(r.status_code)),
+                err.get("details"),
+            )
+        return body
+
+    def get(self, path: str, params: dict | None = None) -> dict[str, Any]:
+        return self._request("GET", path, params=params)
+
+    def post(self, path: str, json: dict | None = None) -> dict[str, Any]:
+        return self._request("POST", path, json=json)
+
+    def put(self, path: str, json: dict | None = None) -> dict[str, Any]:
+        return self._request("PUT", path, json=json)
+
+    def delete(self, path: str) -> dict[str, Any]:
+        return self._request("DELETE", path)

maitai_cli/commands_generated.py

@@ -0,0 +1,457 @@
+"""Generated CLI commands from OpenAPI spec. Do not edit by hand."""
+
+from typing import Optional
+
+import typer
+
+from maitai_cli.utils import console, get_client, handle_api_errors, print_json
+
+@handle_api_errors
+def _agents(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List agents"),
+    get_id: Optional[int] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    create_body: Optional[str] = typer.Option(None, "--create", "-c", help="Create (JSON body)"),
+    update_id: Optional[int] = typer.Option(None, "--update", "-u", help="Update by ID"),
+    delete_id: Optional[int] = typer.Option(None, "--delete", "-d", help="Delete by ID"),
+    include_subagents: Optional[bool] = typer.Option(None, "--include-subagents", help="Include sub-agents in the response."),
+    include_actions: Optional[bool] = typer.Option(None, "--include-actions", help="Include agent actions in the response."),
+    detailed: Optional[bool] = typer.Option(None, "--detailed", help="Include full configuration details in results."),
+    page: Optional[int] = typer.Option(None, "--page", help="Page number (1-indexed) for page-based pagination."),
+    page_size: Optional[int] = typer.Option(None, "--page-size", help="Number of items per page."),
+    version: Optional[str] = typer.Option(None, "--version", help="Filter by version string."),
+):
+    """/agents - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if include_subagents is not None:
+        params["include_subagents"] = include_subagents
+    if include_actions is not None:
+        params["include_actions"] = include_actions
+    if detailed is not None:
+        params["detailed"] = detailed
+    if page is not None:
+        params["page"] = page
+    if page_size is not None:
+        params["page_size"] = page_size
+    if version is not None:
+        params["version"] = version
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/agents", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/agents/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    if create_body:
+        import json
+        body = json.loads(create_body)
+        r = client.post("/agents", json=body)
+        print_json(r.get("data"))
+        return
+    if update_id is not None:
+        import json
+        body = json.loads(typer.prompt("JSON body for update") or "{}")
+        r = client.put(f"/agents/{update_id}", json=body)
+        print_json(r.get("data"))
+        return
+    if delete_id is not None:
+        client.delete(f"/agents/{delete_id}")
+        console.print("[green]Deleted.[/green]")
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _applications(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List applications"),
+    get_id: Optional[int] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    create_body: Optional[str] = typer.Option(None, "--create", "-c", help="Create (JSON body)"),
+    update_id: Optional[int] = typer.Option(None, "--update", "-u", help="Update by ID"),
+    delete_id: Optional[int] = typer.Option(None, "--delete", "-d", help="Delete by ID"),
+    detailed: bool = typer.Option(False, "--detailed", help="Include full config"),
+):
+    """/applications - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if detailed is not None:
+        params["detailed"] = detailed
+    if detailed:
+        params["detailed"] = "true"
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/applications", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/applications/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    if create_body:
+        import json
+        body = json.loads(create_body)
+        r = client.post("/applications", json=body)
+        print_json(r.get("data"))
+        return
+    if update_id is not None:
+        import json
+        body = json.loads(typer.prompt("JSON body for update") or "{}")
+        r = client.put(f"/applications/{update_id}", json=body)
+        print_json(r.get("data"))
+        return
+    if delete_id is not None:
+        client.delete(f"/applications/{delete_id}")
+        console.print("[green]Deleted.[/green]")
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _conversation_trees(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List conversation trees"),
+    get_id: Optional[str] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    delete_id: Optional[str] = typer.Option(None, "--delete", "-d", help="Delete by ID"),
+    application_id: Optional[int] = typer.Option(None, "--application-id", help="Filter by application ID."),
+):
+    """/conversation-trees - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if application_id is not None:
+        params["application_id"] = application_id
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/conversation-trees", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/conversation-trees/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    if delete_id is not None:
+        client.delete(f"/conversation-trees/{delete_id}")
+        console.print("[green]Deleted.[/green]")
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _datasets(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List datasets"),
+    get_id: Optional[int] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    create_body: Optional[str] = typer.Option(None, "--create", "-c", help="Create (JSON body)"),
+    update_id: Optional[int] = typer.Option(None, "--update", "-u", help="Update by ID"),
+    delete_id: Optional[int] = typer.Option(None, "--delete", "-d", help="Delete by ID"),
+):
+    """/datasets - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/datasets", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/datasets/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    if create_body:
+        import json
+        body = json.loads(create_body)
+        r = client.post("/datasets", json=body)
+        print_json(r.get("data"))
+        return
+    if update_id is not None:
+        import json
+        body = json.loads(typer.prompt("JSON body for update") or "{}")
+        r = client.put(f"/datasets/{update_id}", json=body)
+        print_json(r.get("data"))
+        return
+    if delete_id is not None:
+        client.delete(f"/datasets/{delete_id}")
+        console.print("[green]Deleted.[/green]")
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _evaluations(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List evaluations"),
+    get_id: Optional[str] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    create_body: Optional[str] = typer.Option(None, "--create", "-c", help="Create (JSON body)"),
+    full: Optional[bool] = typer.Option(None, "--full", help="Include full evaluation details."),
+):
+    """/evaluations - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if full is not None:
+        params["full"] = full
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/evaluations", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/evaluations/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    if create_body:
+        import json
+        body = json.loads(create_body)
+        r = client.post("/evaluations", json=body)
+        print_json(r.get("data"))
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _finetune_runs(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List finetune runs"),
+    get_id: Optional[int] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    create_body: Optional[str] = typer.Option(None, "--create", "-c", help="Create (JSON body)"),
+    status: Optional[str] = typer.Option(None, "--status", help="Filter by status (can be specified multiple times)"),
+):
+    """/finetune-runs - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if status is not None:
+        params["status"] = status
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/finetune-runs", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/finetune-runs/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    if create_body:
+        import json
+        body = json.loads(create_body)
+        r = client.post("/finetune-runs", json=body)
+        print_json(r.get("data"))
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _intent_groups(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List intent groups"),
+    get_id: Optional[int] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    detailed: Optional[bool] = typer.Option(None, "--detailed", help="Include full configuration details in results."),
+    start_date: Optional[int] = typer.Option(None, "--start-date", help="Start of date range as Unix timestamp (millisecond"),
+    end_date: Optional[int] = typer.Option(None, "--end-date", help="End of date range as Unix timestamp (milliseconds)"),
+    include_messages: Optional[bool] = typer.Option(None, "--include-messages", help="Include full message history in results."),
+):
+    """/intent-groups - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if detailed is not None:
+        params["detailed"] = detailed
+    if start_date is not None:
+        params["start_date"] = start_date
+    if end_date is not None:
+        params["end_date"] = end_date
+    if include_messages is not None:
+        params["include_messages"] = include_messages
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/intent-groups", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/intent-groups/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _models(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List models"),
+    model_type: Optional[str] = typer.Option(None, "--model-type", help="Filter by model type (can be specified multiple ti"),
+    available: bool = typer.Option(False, "--available", "-a", help="List available base models"),
+):
+    """/models - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if model_type is not None:
+        params["model_type"] = model_type
+    if available:
+        r = client.get("/models/available")
+        print_json(r.get("data", []))
+        return
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/models", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _requests(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List requests"),
+    get_id: Optional[int] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    application_id: Optional[int] = typer.Option(None, "--application-id", help="Filter by application ID."),
+    intent_id: Optional[int] = typer.Option(None, "--intent-id", help="Filter by intent ID."),
+    start_date: Optional[int] = typer.Option(None, "--start-date", help="Start of date range as Unix timestamp (millisecond"),
+    end_date: Optional[int] = typer.Option(None, "--end-date", help="End of date range as Unix timestamp (milliseconds)"),
+    include_messages: Optional[bool] = typer.Option(None, "--include-messages", help="Include full message history in results."),
+):
+    """/requests - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if application_id is not None:
+        params["application_id"] = application_id
+    if intent_id is not None:
+        params["intent_id"] = intent_id
+    if start_date is not None:
+        params["start_date"] = start_date
+    if end_date is not None:
+        params["end_date"] = end_date
+    if include_messages is not None:
+        params["include_messages"] = include_messages
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/requests", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/requests/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _sentinels(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List sentinels"),
+    get_id: Optional[int] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    create_body: Optional[str] = typer.Option(None, "--create", "-c", help="Create (JSON body)"),
+    update_id: Optional[int] = typer.Option(None, "--update", "-u", help="Update by ID"),
+    delete_id: Optional[int] = typer.Option(None, "--delete", "-d", help="Delete by ID"),
+):
+    """/sentinels - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/sentinels", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/sentinels/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    if create_body:
+        import json
+        body = json.loads(create_body)
+        r = client.post("/sentinels", json=body)
+        print_json(r.get("data"))
+        return
+    if update_id is not None:
+        import json
+        body = json.loads(typer.prompt("JSON body for update") or "{}")
+        r = client.put(f"/sentinels/{update_id}", json=body)
+        print_json(r.get("data"))
+        return
+    if delete_id is not None:
+        client.delete(f"/sentinels/{delete_id}")
+        console.print("[green]Deleted.[/green]")
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _sessions(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List sessions"),
+    get_id: Optional[str] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    application_id: Optional[int] = typer.Option(None, "--application-id", help="Filter by application ID."),
+):
+    """/sessions - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if application_id is not None:
+        params["application_id"] = application_id
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/sessions", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/sessions/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _test_runs(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List test runs"),
+    get_id: Optional[int] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    create_body: Optional[str] = typer.Option(None, "--create", "-c", help="Create (JSON body)"),
+    delete_id: Optional[int] = typer.Option(None, "--delete", "-d", help="Delete by ID"),
+    intent_group_id: Optional[int] = typer.Option(None, "--intent-group-id", help="intent_group_id"),
+):
+    """/test-runs - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if intent_group_id is not None:
+        params["intent_group_id"] = intent_group_id
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/test-runs", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/test-runs/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    if create_body:
+        import json
+        body = json.loads(create_body)
+        r = client.post("/test-runs", json=body)
+        print_json(r.get("data"))
+        return
+    if delete_id is not None:
+        client.delete(f"/test-runs/{delete_id}")
+        console.print("[green]Deleted.[/green]")
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+@handle_api_errors
+def _test_sets(
+    list_cmd: bool = typer.Option(False, "--list", "-l", help="List test sets"),
+    get_id: Optional[int] = typer.Option(None, "--get", "-g", help="Get by ID"),
+    create_body: Optional[str] = typer.Option(None, "--create", "-c", help="Create (JSON body)"),
+    update_id: Optional[int] = typer.Option(None, "--update", "-u", help="Update by ID"),
+    delete_id: Optional[int] = typer.Option(None, "--delete", "-d", help="Delete by ID"),
+    start_date: Optional[int] = typer.Option(None, "--start-date", help="Start of date range as Unix timestamp (millisecond"),
+    end_date: Optional[int] = typer.Option(None, "--end-date", help="End of date range as Unix timestamp (milliseconds)"),
+):
+    """/test-sets - generated from OpenAPI."""
+    client = get_client()
+    params: dict = {}
+    if start_date is not None:
+        params["start_date"] = start_date
+    if end_date is not None:
+        params["end_date"] = end_date
+    if list_cmd or (not get_id and not create_body and not update_id and not delete_id):
+        r = client.get("/test-sets", params=params)
+        print_json(r.get("data", []), r.get("pagination"))
+        return
+    if get_id is not None:
+        r = client.get(f"/test-sets/{get_id}", params=params)
+        print_json(r.get("data"))
+        return
+    if create_body:
+        import json
+        body = json.loads(create_body)
+        r = client.post("/test-sets", json=body)
+        print_json(r.get("data"))
+        return
+    if update_id is not None:
+        import json
+        body = json.loads(typer.prompt("JSON body for update") or "{}")
+        r = client.put(f"/test-sets/{update_id}", json=body)
+        print_json(r.get("data"))
+        return
+    if delete_id is not None:
+        client.delete(f"/test-sets/{delete_id}")
+        console.print("[green]Deleted.[/green]")
+        return
+    typer.echo("Use --list, --get ID, --create '{\"key\":\"val\"}', --update ID, or --delete ID")
+
+def register_commands(typer_app: typer.Typer) -> None:
+    """Register all generated commands with the Typer app."""
+    typer_app.command(name="agents")(_agents)
+    typer_app.command(name="applications")(_applications)
+    typer_app.command(name="conversation-trees")(_conversation_trees)
+    typer_app.command(name="datasets")(_datasets)
+    typer_app.command(name="evaluations")(_evaluations)
+    typer_app.command(name="finetune-runs")(_finetune_runs)
+    typer_app.command(name="intent-groups")(_intent_groups)
+    typer_app.command(name="models")(_models)
+    typer_app.command(name="requests")(_requests)
+    typer_app.command(name="sentinels")(_sentinels)
+    typer_app.command(name="sessions")(_sessions)
+    typer_app.command(name="test-runs")(_test_runs)
+    typer_app.command(name="test-sets")(_test_sets)

maitai_cli/config.py

@@ -0,0 +1,74 @@
+"""Configuration and authentication for the Maitai CLI."""
+
+import os
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".maitai"
+CONFIG_FILE = CONFIG_DIR / "config"
+API_KEY_ENV = "MAITAI_API_KEY"
+BASE_URL_ENV = "MAITAI_BASE_URL"
+DEFAULT_BASE_URL = "https://api.trymaitai.ai/api/v1"
+
+
+def get_config_dir() -> Path:
+    """Return the config directory, creating it if needed."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    return CONFIG_DIR
+
+
+def get_api_key() -> str | None:
+    """Get API key from environment or config file."""
+    key = os.environ.get(API_KEY_ENV)
+    if key:
+        return key.strip()
+    if CONFIG_FILE.exists():
+        try:
+            content = CONFIG_FILE.read_text().strip()
+            for line in content.splitlines():
+                line = line.strip()
+                if line.startswith("api_key="):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+                if line.startswith("MAITAI_API_KEY="):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+        except OSError:
+            pass
+    return None
+
+
+def get_base_url() -> str:
+    """Get base URL from environment or config file."""
+    url = os.environ.get(BASE_URL_ENV)
+    if url:
+        return url.strip().rstrip("/")
+    if CONFIG_FILE.exists():
+        try:
+            content = CONFIG_FILE.read_text().strip()
+            for line in content.splitlines():
+                line = line.strip()
+                if line.startswith("base_url="):
+                    return (
+                        line.split("=", 1)[1].strip().strip('"').strip("'").rstrip("/")
+                    )
+                if line.startswith("MAITAI_BASE_URL="):
+                    return (
+                        line.split("=", 1)[1].strip().strip('"').strip("'").rstrip("/")
+                    )
+        except OSError:
+            pass
+    return DEFAULT_BASE_URL
+
+
+def save_config(api_key: str, base_url: str | None = None) -> None:
+    """Save API key and optional base URL to config file."""
+    get_config_dir()
+    url = base_url or get_base_url()
+    content = f"api_key={api_key}\nbase_url={url}\n"
+    CONFIG_FILE.write_text(content)
+    # Restrict permissions
+    os.chmod(CONFIG_FILE, 0o600)
+
+
+def clear_config() -> None:
+    """Remove stored credentials."""
+    if CONFIG_FILE.exists():
+        CONFIG_FILE.unlink()

maitai_cli/main.py

@@ -0,0 +1,140 @@
+"""
+Maitai CLI - Command-line interface for the Maitai Platform Developer API.
+
+API docs: See docs/internal and docs/external in the maitai-mono repository.
+"""
+
+from typing import Optional
+
+import typer
+
+# Import generated commands and register them
+from maitai_cli.commands_generated import register_commands
+from maitai_cli.config import clear_config, get_api_key, get_base_url, save_config
+from maitai_cli.utils import console, get_client, handle_api_errors, print_json
+from rich.console import Console
+
+app = typer.Typer(
+    name="maitai",
+    help="Maitai Platform Developer API CLI (api/v1). API docs: docs/internal and docs/external in maitai-mono. Create API keys at https://portal.trymaitai.com → Settings → API Keys.",
+    no_args_is_help=True,
+)
+
+# Register generated resource commands
+register_commands(app)
+
+
+# ─── Auth (hand-written) ────────────────────────────────────────────────────
+
+
+@app.command()
+def login(
+    api_key: Optional[str] = typer.Option(
+        None,
+        "--api-key",
+        "-k",
+        help="Maitai API key (or set MAITAI_API_KEY)",
+    ),
+    base_url: Optional[str] = typer.Option(
+        None,
+        "--base-url",
+        "-u",
+        help="API base URL (default: https://api.trymaitai.ai/api/v1)",
+    ),
+):
+    """Authenticate and store your API key for future commands."""
+    key = api_key or get_api_key()
+    if not key:
+        console.print(
+            "[yellow]Provide your API key via --api-key, or set MAITAI_API_KEY.[/yellow]"
+        )
+        console.print(
+            "Create keys at [link=https://portal.trymaitai.com]portal.trymaitai.com[/link] → Settings → API Keys"
+        )
+        raise typer.Exit(1)
+    save_config(key, base_url)
+    console.print("[green]✓ Authenticated. API key saved to ~/.maitai/config[/green]")
+
+
+@app.command()
+def logout():
+    """Remove stored credentials."""
+    clear_config()
+    console.print("[green]✓ Logged out. Credentials removed.[/green]")
+
+
+@app.command()
+def docs():
+    """Show API documentation references."""
+    console.print("[bold]Maitai Developer API (api/v1)[/bold]")
+    console.print()
+    console.print("  [link=https://docs.trymaitai.ai]External docs[/link]")
+    console.print(
+        "  [link=https://docs.trymaitai.ai/api-reference]API Reference[/link]"
+    )
+    console.print(
+        "  [link=https://portal.trymaitai.com]Portal (create API keys)[/link]"
+    )
+    console.print()
+    console.print("[dim]In maitai-mono repo:[/dim]")
+    console.print("  docs/external/openapi.yaml  - OpenAPI spec")
+    console.print("  docs/external/api-reference/ - API reference pages")
+    console.print("  docs/internal/              - Internal design docs")
+
+
+@app.command()
+def whoami():
+    """Show current authentication status."""
+    key = get_api_key()
+    base_url = get_base_url()
+    if not key:
+        console.print("[red]Not authenticated.[/red]")
+        console.print("Run [bold]maitai login[/bold] or set MAITAI_API_KEY.")
+        raise typer.Exit(1)
+    console.print("[green]Authenticated[/green]")
+    console.print(f"  Base URL: {base_url}")
+    console.print(f"  API key: {key[:8]}...{key[-4:]}")
+
+
+# ─── Raw API (hand-written) ──────────────────────────────────────────────────
+
+
+@app.command("api")
+@handle_api_errors
+def raw_api(
+    method: str = typer.Argument("GET", help="HTTP method"),
+    path: str = typer.Argument(..., help="API path (e.g. /applications)"),
+    body: Optional[str] = typer.Option(
+        None, "--body", "-b", help="JSON body for POST/PUT"
+    ),
+):
+    """Make a raw API request. Path is relative to base URL (e.g. /applications)."""
+    import json
+
+    client = get_client()
+    path = path if path.startswith("/") else f"/{path}"
+    json_body = json.loads(body) if body else None
+    if method.upper() == "GET":
+        r = client.get(path)
+    elif method.upper() == "POST":
+        r = client.post(path, json=json_body)
+    elif method.upper() == "PUT":
+        r = client.put(path, json=json_body)
+    elif method.upper() == "DELETE":
+        r = client.delete(path)
+    else:
+        console.print("[red]Unsupported method. Use GET, POST, PUT, or DELETE.[/red]")
+        raise typer.Exit(1)
+    print_json(r)
+
+
+def main():
+    """Entry point."""
+    try:
+        app()
+    except KeyboardInterrupt:
+        raise typer.Exit(130)
+
+
+if __name__ == "__main__":
+    main()

maitai_cli/utils.py

@@ -0,0 +1,46 @@
+"""Shared utilities for Maitai CLI commands."""
+
+import functools
+from typing import Any
+
+import typer
+from maitai_cli.api import APIClient, APIError
+from rich.console import Console
+
+console = Console()
+
+
+def get_client() -> APIClient:
+    """Return an authenticated API client."""
+    return APIClient()
+
+
+def print_json(data: Any, pagination: dict | None = None) -> None:
+    """Pretty-print JSON with optional pagination info."""
+    import json
+
+    from rich.syntax import Syntax
+
+    text = json.dumps(data, indent=2, default=str)
+    if pagination:
+        p = pagination
+        console.print(
+            f"[dim]total={p.get('total', '?')} offset={p.get('offset', 0)} limit={p.get('limit', 25)}[/dim]"
+        )
+    console.print(Syntax(text, "json", theme="monokai", line_numbers=False))
+
+
+def handle_api_errors(f):
+    """Decorator to catch APIError and print a clean message."""
+
+    @functools.wraps(f)
+    def wrapper(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except APIError as e:
+            console.print(f"[red]API Error ({e.status_code}): {e.message}[/red]")
+            if e.status_code == 401:
+                console.print("Run [bold]maitai login[/bold] or set MAITAI_API_KEY.")
+            raise typer.Exit(1)
+
+    return wrapper

maitai_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: maitai-cli
+Version: 0.1.1
+Summary: CLI for the Maitai Platform Developer API (api/v1)
+Author-email: Maitai <support@trymaitai.com>
+License: MIT
+Project-URL: Documentation, https://docs.trymaitai.ai
+Project-URL: API Reference, https://docs.trymaitai.ai/api-reference
+Project-URL: Portal, https://portal.trymaitai.com
+Keywords: maitai,cli,api,ai,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# Maitai CLI
+
+Command-line interface for the [Maitai Platform Developer API](https://docs.trymaitai.ai/api-reference) (api/v1).
+
+Resource commands (`applications`, `agents`, etc.) are **generated from the OpenAPI spec**. When the API changes, run `python scripts/generate_openapi.py` from the repo root to regenerate the CLI.
+
+## Install
+
+```bash
+# From the maitai-mono repo (cli directory)
+pip install .
+
+# Or install in development mode
+pip install -e .
+```
+
+## Authenticate
+
+Create an API key in the [Portal](https://portal.trymaitai.com) under **Settings → API Keys**, then:
+
+```bash
+# Interactive: saves key to ~/.maitai/config
+maitai login --api-key YOUR_MAITAI_API_KEY
+
+# Or use environment variable (no login needed)
+export MAITAI_API_KEY="YOUR_MAITAI_API_KEY"
+```
+
+For a custom base URL (e.g. local dev):
+
+```bash
+maitai login --api-key YOUR_KEY --base-url http://localhost:5000/api/v1
+```
+
+## Usage
+
+```bash
+# Check auth status
+maitai whoami
+
+# List resources
+maitai applications --list
+maitai agents --list
+maitai intent-groups --list
+maitai sessions --list
+maitai sentinels --list
+maitai datasets --list
+maitai test-sets --list
+maitai test-runs --list
+maitai models --list
+maitai models --available
+maitai evaluations --list
+maitai finetune-runs --list
+maitai conversation-trees --list
+
+# Get by ID
+maitai applications --get 42
+maitai agents --get 1
+maitai intent-groups --get 5
+
+# Create application
+maitai applications --create "My App:my-app"
+
+# Delete application
+maitai applications --delete 42
+
+# Raw API calls (any endpoint)
+maitai api GET /applications
+maitai api GET /applications/42
+maitai api POST /applications -b '{"application_name":"Test","application_ref_name":"test"}'
+maitai api PUT /applications/42 -b '{"application_name":"Updated"}'
+maitai api DELETE /applications/42
+```
+
+## API Reference
+
+The CLI wraps the Maitai Developer API. Full documentation:
+
+- **External docs**: [docs.trymaitai.ai](https://docs.trymaitai.ai)
+- **OpenAPI spec**: `docs/external/openapi.yaml` in this repo
+- **Internal docs**: `docs/internal/` in this repo
+
+### Authentication
+
+All requests use the `X-Maitai-Api-Key` header. Create keys at [portal.trymaitai.com](https://portal.trymaitai.com) → Settings → API Keys.
+
+### Base URL
+
+- Production: `https://api.trymaitai.ai/api/v1`
+- Override with `MAITAI_BASE_URL` or `maitai login --base-url`
+
+### Response Format
+
+- Success: `{"data": {...}}`
+- Paginated: `{"data": [...], "pagination": {"total": N, "offset": 0, "limit": 25}}`
+- Error: `{"error": {"status": 401, "message": "..."}}`
+
+<!-- GENERATED_ENDPOINTS_START -->
+## Supported API endpoints
+
+The CLI wraps all api/v1 endpoints. Use `maitai api METHOD path` for any endpoint:
+
+| Method | Path | Operation |
+|--------|------|-----------|
+| GET | `/agents` | listAgents |
+| POST | `/agents` | createAgent |
+| DELETE | `/agents/actions/{action_id}` | deleteAgentAction |
+| GET | `/agents/actions/{action_id}` | getAgentAction |
+| PUT | `/agents/actions/{action_id}` | updateAgentAction |
+| PUT | `/agents/actions/{action_id}/disable` | disableAction |
+| PUT | `/agents/actions/{action_id}/enable` | enableAction |
+| POST | `/agents/actions/{action_id}/publish` | publishActionVersion |
+| GET | `/agents/actions/{action_id}/versions` | listActionVersions |
+| GET | `/agents/tasks/{task_id}/tree` | getAgentTaskTree |
+| DELETE | `/agents/{agent_id}` | deleteAgent |
+| GET | `/agents/{agent_id}` | getAgent |
+| PUT | `/agents/{agent_id}` | updateAgent |
+| GET | `/agents/{agent_id}/actions` | listAgentActions |
+| POST | `/agents/{agent_id}/actions` | createAgentAction |
+| DELETE | `/agents/{agent_id}/form-fields` | deleteFormFields |
+| GET | `/agents/{agent_id}/form-fields` | getFormFields |
+| PUT | `/agents/{agent_id}/form-fields` | updateFormFields |
+| POST | `/agents/{agent_id}/publish` | publishAgentVersion |
+| GET | `/agents/{agent_id}/releases` | listAgentReleases |
+| DELETE | `/agents/{agent_id}/releases/{name}` | deleteAgentRelease |
+| PUT | `/agents/{agent_id}/releases/{name}` | upsertAgentRelease |
+| GET | `/agents/{agent_id}/routing/config` | getRoutingConfig |
+| PUT | `/agents/{agent_id}/routing/config` | updateRoutingConfig |
+| POST | `/agents/{agent_id}/routing/rules` | createRoutingRule |
+| DELETE | `/agents/{agent_id}/routing/rules/{rule_id}` | deleteRoutingRule |
+| PUT | `/agents/{agent_id}/routing/rules/{rule_id}` | updateRoutingRule |
+| GET | `/agents/{agent_id}/sessions` | listAgentSessions |
+| GET | `/agents/{agent_id}/sessions/{session_id}` | getAgentSessionDetail |
+| GET | `/agents/{agent_id}/sessions/{session_id}/timeline` | getAgentSessionTimeline |
+| GET | `/agents/{agent_id}/subagents` | listSubAgents |
+| POST | `/agents/{agent_id}/subagents` | addSubAgent |
+| DELETE | `/agents/{agent_id}/subagents/{child_agent_id}` | removeSubAgent |
+| PUT | `/agents/{agent_id}/subagents/{child_agent_id}/disable` | disableSubAgent |
+| PUT | `/agents/{agent_id}/subagents/{child_agent_id}/enable` | enableSubAgent |
+| GET | `/agents/{agent_id}/tasks/{task_id}/timeline` | getAgentTaskTimeline |
+| GET | `/agents/{agent_id}/versions` | listAgentVersions |
+| GET | `/agents/{agent_id}/versions/{version}` | getAgentVersion |
+| GET | `/applications` | listApplications |
+| POST | `/applications` | createApplication |
+| DELETE | `/applications/{application_id}` | deleteApplication |
+| GET | `/applications/{application_id}` | getApplication |
+| PUT | `/applications/{application_id}` | updateApplication |
+| GET | `/applications/{application_id}/config` | getApplicationConfig |
+| PUT | `/applications/{application_id}/config` | updateApplicationConfig |
+| GET | `/applications/{application_id}/intents` | listApplicationIntents |
+| GET | `/applications/{application_id}/intents/{intent_id}` | getApplicationIntent |
+| GET | `/applications/{application_id}/intents/{intent_id}/config` | getIntentConfig |
+| PUT | `/applications/{application_id}/intents/{intent_id}/config` | updateIntentConfig |
+| GET | `/applications/{application_id}/models` | listApplicationModels |
+| GET | `/applications/{application_id}/sessions` | listApplicationSessions |
+| GET | `/applications/{application_id}/workflow-runs` | listApplicationWorkflowRuns |
+| GET | `/conversation-trees` | listConversationTrees |
+| DELETE | `/conversation-trees/{tree_id}` | deleteConversationTree |
+| GET | `/conversation-trees/{tree_id}` | getConversationTree |
+| GET | `/conversation-trees/{tree_id}/status` | getConversationTreeStatus |
+| GET | `/conversation-trees/{tree_id}/versions` | listConversationTreeVersions |
+| GET | `/datasets` | listDatasets |
+| POST | `/datasets` | createDataset |
+| DELETE | `/datasets/{dataset_id}` | deleteDataset |
+| GET | `/datasets/{dataset_id}` | getDataset |
+| PUT | `/datasets/{dataset_id}` | updateDataset |
+| DELETE | `/datasets/{dataset_id}/requests` | removeRequestsFromDataset |
+| GET | `/datasets/{dataset_id}/requests` | listDatasetRequests |
+| POST | `/datasets/{dataset_id}/requests` | addRequestsToDataset |
+| GET | `/evaluations` | listEvaluations |
+| POST | `/evaluations` | createEvaluation |
+| GET | `/evaluations/{evaluation_run_id}` | getEvaluation |
+| GET | `/evaluations/{evaluation_run_id}/results` | getEvaluationResults |
+| GET | `/finetune-runs` | listFinetuneRuns |
+| POST | `/finetune-runs` | createFinetuneRun |
+| GET | `/finetune-runs/{run_id}` | getFinetuneRun |
+| POST | `/finetune-runs/{run_id}/cancel` | cancelFinetuneRun |
+| GET | `/finetune-runs/{run_id}/metrics` | getFinetuneRunMetrics |
+| GET | `/intent-groups` | listIntentGroups |
+| GET | `/intent-groups/{intent_group_id}` | getIntentGroup |
+| GET | `/intent-groups/{intent_group_id}/compositions` | listIntentGroupCompositions |
+| GET | `/intent-groups/{intent_group_id}/config` | getIntentGroupConfig |
+| PUT | `/intent-groups/{intent_group_id}/config` | updateIntentGroupConfig |
+| GET | `/intent-groups/{intent_group_id}/datasets` | listIntentGroupDatasets |
+| GET | `/intent-groups/{intent_group_id}/intents` | listIntentsByGroup |
+| GET | `/intent-groups/{intent_group_id}/models` | listIntentGroupModels |
+| GET | `/intent-groups/{intent_group_id}/requests` | listIntentGroupRequests |
+| GET | `/intent-groups/{intent_group_id}/sentinels` | listIntentGroupSentinels |
+| GET | `/intent-groups/{intent_group_id}/test-sets` | listIntentGroupTestSets |
+| GET | `/models` | listModels |
+| GET | `/models/available` | listAvailableModels |
+| POST | `/models/{model_id}/disable` | disableModel |
+| POST | `/models/{model_id}/enable` | enableModel |
+| GET | `/requests` | listRequests |
+| GET | `/requests/{request_id}` | getRequest |
+| PUT | `/requests/{request_id}/response` | updateRequestResponse |
+| GET | `/sentinels` | listSentinels |
+| POST | `/sentinels` | createSentinel |
+| DELETE | `/sentinels/{sentinel_id}` | deleteSentinel |
+| GET | `/sentinels/{sentinel_id}` | getSentinel |
+| PUT | `/sentinels/{sentinel_id}` | updateSentinel |
+| GET | `/sessions` | listSessions |
+| GET | `/sessions/{session_id}` | getSession |
+| POST | `/sessions/{session_id}/feedback` | setSessionFeedback |
+| GET | `/sessions/{session_id}/timeline` | getSessionTimeline |
+| GET | `/test-runs` | listTestRuns |
+| POST | `/test-runs` | createTestRun |
+| DELETE | `/test-runs/{test_run_id}` | deleteTestRun |
+| GET | `/test-runs/{test_run_id}` | getTestRun |
+| GET | `/test-runs/{test_run_id}/progress` | getTestRunProgress |
+| GET | `/test-runs/{test_run_id}/requests` | listTestRunRequests |
+| GET | `/test-sets` | listTestSets |
+| POST | `/test-sets` | createTestSet |
+| DELETE | `/test-sets/{test_set_id}` | deleteTestSet |
+| GET | `/test-sets/{test_set_id}` | getTestSet |
+| PUT | `/test-sets/{test_set_id}` | updateTestSet |
+| DELETE | `/test-sets/{test_set_id}/requests` | removeRequestsFromTestSet |
+| GET | `/test-sets/{test_set_id}/requests` | listTestSetRequests |
+| POST | `/test-sets/{test_set_id}/requests` | addRequestsToTestSet |
+
+<!-- GENERATED_ENDPOINTS_END -->
+

maitai_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+maitai_cli/__init__.py,sha256=DP17cdkmaB9BWDyNqe7FsDeMVkU2sjWLv5YKF3UgklE,104
+maitai_cli/__main__.py,sha256=yTPCvg2BT1f-i59uxTzz64OXy7sU8GB2G5wz7fcau5c,118
+maitai_cli/api.py,sha256=voFRukTGhauDocQyHQNr92q_UaqfZ0j7mv5Afr_x564,2953
+maitai_cli/commands_generated.py,sha256=1Jgi13ijzbaqP_D2JEo-xLg0sXIEE02zfnK-9WncQgE,20838
+maitai_cli/config.py,sha256=PcMIwfJkC5tMP9SKMhcbm5eGQWe6RzZx-mIjv2MKTxw,2383
+maitai_cli/main.py,sha256=BuFB5F8XcDYqroW4H4YmnF17Ui4Mv3EolQrwRBJrEXs,4579
+maitai_cli/utils.py,sha256=1gpMjzPwoJRSvMLFE2gz-2TEvYaa3anjirFNGtKuy_4,1289
+maitai_cli-0.1.1.dist-info/METADATA,sha256=Sx9Ty1SBOezuEpSQ-7eXBqrdJsyAZ3AR_zoGhi4fspE,10951
+maitai_cli-0.1.1.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+maitai_cli-0.1.1.dist-info/entry_points.txt,sha256=vxR-KCH2JQAnwJQDJ-i6uMD9O3nPFbQog7u66mY9OvU,47
+maitai_cli-0.1.1.dist-info/top_level.txt,sha256=VDcocArAixYCOLTnI-KZl7AA_17CiuBvrieREKIig9w,11
+maitai_cli-0.1.1.dist-info/RECORD,,

maitai_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

maitai_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+maitai = maitai_cli.main:app

maitai_cli-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+maitai_cli