bonito-cli 0.1.0__py3-none-any.whl

bonito_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Bonito CLI — Unified multi-cloud AI management from your terminal."""
+
+__version__ = "0.1.0"

bonito_cli/__main__.py

@@ -0,0 +1,4 @@
+"""Allow running as `python -m bonito_cli`."""
+from bonito_cli.app import main
+
+main()

bonito_cli/api.py

@@ -0,0 +1,167 @@
+"""Synchronous HTTP API client for the Bonito backend."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Generator, Optional
+
+import httpx
+from rich.console import Console
+
+from .config import get_api_key, get_api_url
+
+console = Console()
+
+
+class APIError(Exception):
+    """Raised when an API request fails."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class BonitoAPI:
+    """Synchronous Bonito API client backed by ``httpx.Client``."""
+
+    def __init__(self) -> None:
+        self.base_url: str = get_api_url()
+        self._client: Optional[httpx.Client] = None
+
+    # ── internal helpers ────────────────────────────────────────
+
+    @property
+    def client(self) -> httpx.Client:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.Client(
+                base_url=self.base_url,
+                timeout=30.0,
+                follow_redirects=True,
+            )
+        return self._client
+
+    def _headers(self) -> Dict[str, str]:
+        headers: Dict[str, str] = {
+            "Content-Type": "application/json",
+            "User-Agent": "bonito-cli/0.1.0",
+        }
+        token = get_api_key()
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        return headers
+
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Any = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        url = endpoint if endpoint.startswith("http") else f"/api{endpoint}"
+        try:
+            resp = self.client.request(
+                method, url, json=data, params=params, headers=self._headers()
+            )
+        except httpx.RequestError as exc:
+            raise APIError(f"Connection failed: {exc}") from exc
+
+        if resp.status_code == 401:
+            raise APIError(
+                "Authentication failed — run [cyan]bonito auth login[/cyan].", 401
+            )
+        if resp.status_code == 204:
+            return {"status": "ok"}
+        if resp.status_code >= 400:
+            try:
+                body = resp.json()
+                detail = body.get(
+                    "detail",
+                    body.get("error", {}).get("message", f"HTTP {resp.status_code}"),
+                )
+            except Exception:
+                detail = f"HTTP {resp.status_code}: {resp.text[:200]}"
+
+            # Parse Pydantic 422 validation errors into friendly messages
+            if resp.status_code == 422 and isinstance(detail, list):
+                parts: list[str] = []
+                for err in detail:
+                    if isinstance(err, dict):
+                        err_type = err.get("type", "")
+                        err_msg = err.get("msg", "Validation error")
+                        loc = err.get("loc", [])
+                        field = str(loc[-1]).replace("_", " ") if loc else "input"
+                        if err_type == "uuid_parsing":
+                            parts.append(
+                                f"Invalid {field} format. "
+                                "Expected a UUID (e.g. a1b2c3d4-e5f6-...)"
+                            )
+                        else:
+                            parts.append(f"{err_msg} (field: {field})")
+                    else:
+                        parts.append(str(err))
+                msg = "; ".join(parts) if parts else "Validation error"
+            elif isinstance(detail, list):
+                msg = "; ".join(str(d) for d in detail)
+            else:
+                msg = str(detail)
+
+            raise APIError(msg, resp.status_code)
+
+        try:
+            return resp.json()
+        except Exception:
+            return {"status": "ok", "text": resp.text}
+
+    # ── public verbs ────────────────────────────────────────────
+
+    def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        return self._request("GET", endpoint, params=params)
+
+    def post(self, endpoint: str, data: Any = None) -> Any:
+        return self._request("POST", endpoint, data=data)
+
+    def put(self, endpoint: str, data: Any = None) -> Any:
+        return self._request("PUT", endpoint, data=data)
+
+    def patch(self, endpoint: str, data: Any = None) -> Any:
+        return self._request("PATCH", endpoint, data=data)
+
+    def delete(self, endpoint: str) -> Any:
+        return self._request("DELETE", endpoint)
+
+    # ── streaming (SSE) ─────────────────────────────────────────
+
+    def stream_post(
+        self,
+        url: str,
+        data: dict,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Generator[dict, None, None]:
+        """Stream a POST request that returns SSE ``data:`` lines."""
+        hdrs = self._headers()
+        if headers:
+            hdrs.update(headers)
+
+        full_url = url if url.startswith("http") else f"{self.base_url}{url}"
+
+        with httpx.stream(
+            "POST", full_url, json=data, headers=hdrs, timeout=120.0
+        ) as resp:
+            if resp.status_code >= 400:
+                raise APIError(
+                    f"HTTP {resp.status_code}: {resp.read().decode()[:200]}",
+                    resp.status_code,
+                )
+            for line in resp.iter_lines():
+                if line.startswith("data: "):
+                    chunk = line[6:]
+                    if chunk.strip() == "[DONE]":
+                        break
+                    try:
+                        yield json.loads(chunk)
+                    except json.JSONDecodeError:
+                        continue
+
+
+# ── module-level singleton ──────────────────────────────────────
+api = BonitoAPI()

bonito_cli/app.py

@@ -0,0 +1,118 @@
+"""Main Bonito CLI application with Typer."""
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.columns import Columns
+import sys
+
+from . import __version__
+from .commands.auth import app as auth_app
+from .commands.providers import app as providers_app
+from .commands.models import app as models_app
+from .commands.chat import app as chat_app
+from .commands.gateway import app as gateway_app
+from .commands.policies import app as policies_app
+from .commands.analytics import app as analytics_app
+from .commands.deployments import app as deployments_app
+
+console = Console()
+
+# ── Bonito fish ASCII art ──────────────────────────────────────
+FISH_ART = (
+    "[bold cyan]        ___...---\"\"\"---...__              [/bold cyan]\n"
+    "[bold cyan]    .-\"\"                   \"\"-._          [/bold cyan]\n"
+    "[bold cyan]   /                            \\         [/bold cyan]\n"
+    "[bold cyan]  |    [bold white]●[/bold white][bold cyan]          __.._          |        [/bold cyan]\n"
+    "[bold cyan]  |           _.-\"    \"-.       /\\        [/bold cyan]\n"
+    "[bold cyan]   \\       .-\"          \"-.  _.' /        [/bold cyan]\n"
+    "[bold cyan]    \"---.-\"  [dim cyan]bonito[/dim cyan]        \"-\"  _/         [/bold cyan]\n"
+    "[bold cyan]        \\    [dim cyan]  CLI [/dim cyan]          _.-\"           [/bold cyan]\n"
+    "[bold cyan]         \"-.__       __.-\"                [/bold cyan]\n"
+    "[bold cyan]              \"\"\"---\"\"\"                    [/bold cyan]"
+)
+
+LOGO_COMPACT = "[bold cyan]  ><(((º>  [/bold cyan][bold white]Bonito CLI[/bold white] [dim]v{version}[/dim]"
+
+
+def _get_banner() -> str:
+    """Get the full CLI banner with fish art."""
+    return (
+        FISH_ART
+        + f"\n  [bold white]Bonito CLI[/bold white] [dim]v{__version__}[/dim]"
+        + "\n  [dim]Unified multi-cloud AI management from your terminal[/dim]\n"
+    )
+
+
+def _get_mini_banner() -> str:
+    """Get compact one-line banner."""
+    return LOGO_COMPACT.format(version=__version__)
+
+
+# ── Main Typer app ─────────────────────────────────────────────
+app = typer.Typer(
+    name="bonito",
+    help="🐟 Bonito CLI — Unified multi-cloud AI management from your terminal",
+    rich_markup_mode="rich",
+    context_settings={"help_option_names": ["-h", "--help"]},
+    no_args_is_help=True,
+)
+
+# ── Subcommand groups ──────────────────────────────────────────
+app.add_typer(auth_app,        name="auth",        help="🔐 Authentication & API keys")
+app.add_typer(providers_app,   name="providers",   help="☁️  Cloud provider management")
+app.add_typer(models_app,      name="models",      help="🤖 AI model catalogue")
+app.add_typer(deployments_app, name="deployments",  help="🚀 Deployment management")
+app.add_typer(chat_app,        name="chat",        help="💬 Interactive AI chat")
+app.add_typer(gateway_app,     name="gateway",     help="🌐 API gateway management")
+app.add_typer(policies_app,    name="policies",    help="🎯 Routing policies")
+app.add_typer(analytics_app,   name="analytics",   help="📊 Usage analytics & costs")
+
+
+# ── Callbacks ──────────────────────────────────────────────────
+def version_callback(value: bool):
+    """Show version and exit."""
+    if value:
+        console.print(_get_banner())
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Show version and exit",
+        callback=version_callback,
+        is_eager=True,
+    ),
+):
+    """
+    [bold cyan]🐟 Bonito CLI[/bold cyan] — Unified multi-cloud AI management from your terminal.
+
+    Bonito gives enterprise AI teams a single CLI to manage models, costs,
+    and workloads across AWS Bedrock, Azure OpenAI, Google Vertex AI, and more.
+
+    [bold]Quick start:[/bold]
+
+        bonito auth login
+        bonito models list
+        bonito chat
+
+    [bold]Get help on any command:[/bold]
+
+        bonito providers --help
+        bonito chat --help
+    """
+    # When invoked with no subcommand and not --version, show help
+    if ctx.invoked_subcommand is None:
+        console.print(_get_banner())
+        console.print(ctx.get_help())
+        raise typer.Exit()
+
+
+if __name__ == "__main__":
+    app()

bonito_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Bonito CLI commands."""

bonito_cli/commands/analytics.py

@@ -0,0 +1,337 @@
+"""Analytics and usage insights commands."""
+
+from __future__ import annotations
+
+import json as _json
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from ..api import api, APIError
+from ..utils.auth import ensure_authenticated
+from ..utils.display import (
+    format_cost,
+    format_tokens,
+    get_output_format,
+    print_dict_as_table,
+    print_error,
+    print_info,
+    print_table,
+)
+
+console = Console()
+app = typer.Typer(help="📊 Usage analytics & costs")
+
+
+# ── overview ────────────────────────────────────────────────────
+
+
+@app.command("overview")
+def overview(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """
+    Show the analytics dashboard overview.
+
+    Displays key metrics, top models, and recent activity.
+    """
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Fetching analytics…[/cyan]"):
+            data = api.get("/analytics/overview")
+
+        if fmt == "json":
+            console.print_json(_json.dumps(data, default=str))
+            return
+
+        # Key metrics
+        m = data.get("metrics", data)
+        metrics_text = (
+            f"[bold green]Requests:[/bold green]     {m.get('total_requests', 0):,}\n"
+            f"[bold green]Cost:[/bold green]         ${m.get('total_cost', 0):.2f}\n"
+            f"[bold green]Tokens:[/bold green]       {format_tokens(m.get('total_tokens', 0))}\n"
+            f"[bold green]Success rate:[/bold green] {m.get('success_rate', 0):.1f}%\n"
+            f"[bold green]Avg latency:[/bold green]  {m.get('avg_latency_ms', 0):.0f}ms"
+        )
+        console.print(Panel(metrics_text, title="📊 Key Metrics (30 days)", border_style="green"))
+
+        # Top models
+        top = data.get("top_models", [])
+        if top:
+            rows = [
+                {
+                    "Model": tm.get("id", tm.get("model", "—")),
+                    "Requests": f"{tm.get('requests', 0):,}",
+                    "Cost": format_cost(tm.get("cost", 0)),
+                }
+                for tm in top[:5]
+            ]
+            print_table(rows, title="🔥 Top Models")
+
+        # Recent activity
+        recent = data.get("recent_activity", {})
+        if recent:
+            ra = {
+                "Requests (24h)": f"{recent.get('requests_24h', 0):,}",
+                "Cost (24h)": format_cost(recent.get("cost_24h", 0)),
+                "Peak hour": recent.get("peak_hour", "—"),
+            }
+            print_dict_as_table(ra, title="📈 Recent Activity")
+
+    except APIError as exc:
+        print_error(f"Failed to get overview: {exc}")
+
+
+# ── usage ───────────────────────────────────────────────────────
+
+
+@app.command("usage")
+def usage(
+    period: str = typer.Option("week", "--period", "-p", help="day / week / month"),
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """
+    Show detailed usage analytics.
+
+    Examples:
+        bonito analytics usage
+        bonito analytics usage --period month
+    """
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    if period not in ("day", "week", "month"):
+        print_error("--period must be day, week, or month")
+        return
+
+    try:
+        with console.status("[cyan]Fetching usage data…[/cyan]"):
+            data = api.get("/analytics/usage", params={"period": period})
+
+        if fmt == "json":
+            console.print_json(_json.dumps(data, default=str))
+            return
+
+        summary = data.get("summary", data)
+        info = {
+            "Period": period.title(),
+            "Total Requests": f"{summary.get('total_requests', 0):,}",
+            "Total Tokens": format_tokens(summary.get("total_tokens", 0)),
+            "Total Cost": format_cost(summary.get("total_cost", 0)),
+            "Unique Models": summary.get("unique_models", "—"),
+        }
+        print_dict_as_table(info, title=f"📈 Usage ({period.title()})")
+
+        ts = data.get("time_series", [])
+        if ts:
+            rows = [
+                {
+                    "Date": p.get("date", "—"),
+                    "Requests": f"{p.get('requests', 0):,}",
+                    "Tokens": format_tokens(p.get("tokens", 0)),
+                    "Cost": format_cost(p.get("cost", 0)),
+                }
+                for p in ts[-10:]
+            ]
+            print_table(rows, title="Time Series")
+
+    except APIError as exc:
+        print_error(f"Failed to get usage: {exc}")
+
+
+# ── costs ───────────────────────────────────────────────────────
+
+
+@app.command("costs")
+def costs(
+    period: Optional[str] = typer.Option(None, "--period", help="daily / weekly / monthly"),
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """
+    Show cost analytics and breakdown.
+
+    Examples:
+        bonito analytics costs
+        bonito analytics costs --period monthly
+    """
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    try:
+        params = {"period": period} if period else None
+        with console.status("[cyan]Fetching cost data…[/cyan]"):
+            data = api.get("/analytics/costs", params=params)
+
+        if fmt == "json":
+            console.print_json(_json.dumps(data, default=str))
+            return
+
+        summary = data.get("summary", data)
+        total = summary.get("total_cost", 0)
+        console.print(f"\n[bold green]💰 Total cost:[/bold green] ${total:.2f}")
+
+        # By model
+        breakdown = data.get("breakdown", {})
+        by_model = breakdown.get("by_model", [])
+        if by_model:
+            rows = [
+                {
+                    "Model": mc.get("model", "—"),
+                    "Cost": format_cost(mc.get("cost", 0)),
+                    "Requests": f"{mc.get('requests', 0):,}",
+                    "Tokens": format_tokens(mc.get("tokens", 0)),
+                    "Share": f"{(mc.get('cost', 0) / total * 100):.1f}%" if total else "0%",
+                }
+                for mc in by_model
+            ]
+            print_table(rows, title="💸 Cost by Model")
+
+        # By provider
+        by_prov = breakdown.get("by_provider", [])
+        if by_prov:
+            rows = [
+                {
+                    "Provider": pc.get("provider", "—"),
+                    "Cost": format_cost(pc.get("cost", 0)),
+                    "Share": f"{(pc.get('cost', 0) / total * 100):.1f}%" if total else "0%",
+                }
+                for pc in by_prov
+            ]
+            print_table(rows, title="☁️  Cost by Provider")
+
+        # Trends
+        trends = data.get("trends", {})
+        if trends:
+            ti = {
+                "This Period": format_cost(trends.get("current_period", 0)),
+                "Previous": format_cost(trends.get("previous_period", 0)),
+                "Change": f"{trends.get('change_percent', 0):+.1f}%",
+                "Projected Monthly": format_cost(trends.get("projected_monthly", 0)),
+            }
+            print_dict_as_table(ti, title="📊 Trends")
+
+        # Suggestions
+        suggestions = data.get("optimization_suggestions", [])
+        if suggestions:
+            console.print("\n[bold yellow]💡 Optimisation tips:[/bold yellow]")
+            for s in suggestions:
+                console.print(f"  • {s.get('message', s)}")
+
+    except APIError as exc:
+        print_error(f"Failed to get cost data: {exc}")
+
+
+# ── trends ──────────────────────────────────────────────────────
+
+
+@app.command("trends")
+def trends(
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """Show usage and performance trend analysis."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Analysing trends…[/cyan]"):
+            data = api.get("/analytics/trends")
+
+        if fmt == "json":
+            console.print_json(_json.dumps(data, default=str))
+            return
+
+        console.print("\n[bold cyan]📈 Trend Analysis[/bold cyan]\n")
+
+        ut = data.get("usage_trends", {})
+        if ut:
+            info = {
+                "Requests": f"{ut.get('requests_trend', 0):+.1f}% vs last month",
+                "Tokens": f"{ut.get('tokens_trend', 0):+.1f}% vs last month",
+                "Growth": f"{ut.get('growth_rate', 0):.1f}% monthly",
+            }
+            print_dict_as_table(info, title="Usage Trends")
+
+        mt = data.get("model_trends", [])
+        if mt:
+            rows = []
+            for t in mt:
+                arrow = "📈" if t.get("change_percent", 0) > 0 else "📉"
+                rows.append({
+                    "Model": t.get("model", "—"),
+                    "Trend": f"{arrow} {abs(t.get('change_percent', 0)):.1f}%",
+                    "Share": f"{t.get('current_share', 0):.1f}%",
+                })
+            print_table(rows, title="🤖 Model Adoption")
+
+        pt = data.get("performance_trends", {})
+        if pt:
+            pi = {
+                "Latency": f"{pt.get('latency_trend', 0):+.1f}%",
+                "Success rate": f"{pt.get('success_rate_trend', 0):+.1f}%",
+                "Error rate": f"{pt.get('error_rate_trend', 0):+.1f}%",
+            }
+            print_dict_as_table(pi, title="⚡ Performance")
+
+        insights = data.get("insights", [])
+        if insights:
+            console.print("\n[bold blue]🔍 Insights:[/bold blue]")
+            for i in insights:
+                console.print(f"  • {i.get('message', i)}")
+
+    except APIError as exc:
+        print_error(f"Failed to get trends: {exc}")
+
+
+# ── digest ──────────────────────────────────────────────────────
+
+
+@app.command("digest")
+def digest(
+    json_output: bool = typer.Option(False, "--json"),
+):
+    """Generate a weekly analytics digest report."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Generating digest…[/cyan]"):
+            data = api.get("/analytics/digest")
+
+        if fmt == "json":
+            console.print_json(_json.dumps(data, default=str))
+            return
+
+        console.print(f"\n[bold cyan]📋 Weekly Digest[/bold cyan]")
+        console.print(f"[dim]{data.get('period', 'Last 7 days')}[/dim]\n")
+
+        s = data.get("executive_summary", {})
+        if s:
+            text = (
+                f"[bold green]Requests:[/bold green]     {s.get('total_requests', 0):,}"
+                f"  ({s.get('requests_change', 0):+.1f}%)\n"
+                f"[bold green]Cost:[/bold green]         ${s.get('total_cost', 0):.2f}"
+                f"  ({s.get('cost_change', 0):+.1f}%)\n"
+                f"[bold green]Success rate:[/bold green] {s.get('success_rate', 0):.1f}%\n"
+                f"[bold green]Avg latency:[/bold green]  {s.get('avg_latency', 0):.0f}ms"
+            )
+            console.print(Panel(text, title="Week at a Glance", border_style="green"))
+
+        tp = data.get("top_performers", {})
+        if tp:
+            console.print("[bold]🏆 Top Performers:[/bold]")
+            console.print(f"  Most used:         [cyan]{tp.get('most_used_model', '—')}[/cyan]")
+            console.print(f"  Fastest:           [cyan]{tp.get('fastest_model', '—')}[/cyan]")
+            console.print(f"  Most cost-effective:[cyan]{tp.get('most_cost_effective', '—')}[/cyan]")
+
+        recs = data.get("recommendations", [])
+        if recs:
+            console.print("\n[bold blue]💡 Recommendations:[/bold blue]")
+            for r in recs:
+                console.print(f"  • {r.get('message', r)}")
+
+    except APIError as exc:
+        print_error(f"Failed to generate digest: {exc}")