thoughtleaders-cli 0.6.33__tar.gz → 0.6.35__tar.gz

{thoughtleaders_cli-0.6.33 → thoughtleaders_cli-0.6.35}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tl-cli",
-  "version": "0.6.33",
+  "version": "0.6.35",
   "description": "ThoughtLeaders CLI — query sponsorship deals, channels, brands, uploads, and intelligence from the terminal",
   "author": {
     "name": "ThoughtLeaders",

{thoughtleaders_cli-0.6.33 → thoughtleaders_cli-0.6.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thoughtleaders-cli
-Version: 0.6.33
+Version: 0.6.35
 Summary: ThoughtLeaders CLI — query sponsorship data, channels, brands, and intelligence
 Project-URL: Homepage, https://thoughtleaders.io
 Project-URL: Repository, https://github.com/ThoughtLeaders-io/thoughtleaders-cli

{thoughtleaders_cli-0.6.33 → thoughtleaders_cli-0.6.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thoughtleaders-cli"
-version = "0.6.33"
+version = "0.6.35"
 description = "ThoughtLeaders CLI — query sponsorship data, channels, brands, and intelligence"
 readme = "README.md"
 license = "MIT"

{thoughtleaders_cli-0.6.33 → thoughtleaders_cli-0.6.35}/src/tl_cli/__init__.py

@@ -1,3 +1,3 @@
 """ThoughtLeaders CLI — query sponsorship data, channels, brands, and intelligence."""
 
-__version__ = "0.6.33"
+__version__ = "0.6.35"

{thoughtleaders_cli-0.6.33 → thoughtleaders_cli-0.6.35}/src/tl_cli/commands/credits.py

@@ -19,6 +19,7 @@ from decimal import Decimal, InvalidOperation
 
 import typer
 from rich.console import Console
+from rich.prompt import Prompt
 from rich.table import Table
 
 from tl_cli.client.errors import ApiError, handle_api_error
@@ -59,14 +60,13 @@ def pricing_cmd(
 @app.command("buy")
 def buy_cmd(
     amount_usd: str = typer.Option(..., "--amount-usd", help="Amount to top up, in USD."),
-    no_browser: bool = typer.Option(False, "--no-browser", help="Don't open a browser, just print the checkout URL."),
     poll: bool = typer.Option(True, "--poll/--no-poll", help="Poll balance after opening the checkout page."),
 ) -> None:
     """Start a credit top-up.
 
-    Calls the server to create a pending purchase, opens the web checkout
-    URL, and (by default) polls `tl balance` until the credits land or you
-    Ctrl-C out.
+    Calls the server to create a pending purchase, prints the checkout URL,
+    then asks whether to open it in a browser. Polls `tl balance` (unless
+    `--no-poll`) until the credits land or you Ctrl-C out.
     """
     try:
         Decimal(amount_usd)
@@ -96,13 +96,17 @@ def buy_cmd(
     console.print(
         f"\n[bold]Started top-up:[/bold] ${result['usd_amount']} → {credits} credits"
     )
-    console.print(f"Checkout: {checkout_url}")
-
-    if checkout_url and not no_browser:
-        try:
-            webbrowser.open(checkout_url)
-        except Exception:
-            pass
+    if checkout_url:
+        console.print(f"[bold]Checkout URL:[/bold] {checkout_url}\n")
+        console.print("How would you like to continue?")
+        console.print("  [cyan]1[/cyan] — Open the URL in a browser on this machine (default)")
+        console.print("  [cyan]2[/cyan] — I'll open it manually")
+        choice = Prompt.ask("Choose", choices=["1", "2"], default="1", console=console)
+        if choice == "1":
+            try:
+                webbrowser.open(checkout_url)
+            except Exception:
+                console.print("[yellow]Could not launch a browser. Open the URL above manually.[/yellow]")
 
     if not poll or initial_balance is None:
         console.print("[dim]Run `tl balance` to confirm once payment completes.[/dim]")

{thoughtleaders_cli-0.6.33 → thoughtleaders_cli-0.6.35}/src/tl_cli/commands/doctor.py

@@ -2,9 +2,12 @@
 
 import platform
 import shutil
+import statistics
+import time
 
 import typer
 from rich.console import Console
+from rich.table import Table
 
 from tl_cli import __version__
 from tl_cli.auth.token_store import load_tokens
@@ -12,6 +15,18 @@ from tl_cli.client.errors import ApiError
 from tl_cli.client.http import get_client
 from tl_cli.config import get_config
 
+# Free, side-effect-free GET endpoints we time. Picked to cover the auth
+# path (whoami, balance), public-no-auth path (pricing), and the bigger
+# payloads (describe, changelog). All cost zero credits.
+_LATENCY_ENDPOINTS: tuple[str, ...] = (
+    "/balance",
+    "/whoami",
+    "/pricing",
+    "/describe",
+    "/changelog",
+)
+_LATENCY_ITERATIONS = 3
+
 # Helper tools that AI agents using `tl --json` output frequently reach for.
 # Not required, but life is much better with them.
 _RECOMMENDED_TOOLS: tuple[tuple[str, str, dict[str, str]], ...] = (
@@ -57,6 +72,66 @@ app = typer.Typer(help="Health check (auth, connectivity, version)")
 console = Console()
 
 
+def _collect_latency_samples(client, samples_by_endpoint: dict[str, list[float]]) -> None:
+    """Hit each free endpoint up to _LATENCY_ITERATIONS times and record
+    wall-clock latencies. Endpoints that 404 (older server) are dropped
+    silently — they just don't appear in the table.
+    """
+    for path in _LATENCY_ENDPOINTS:
+        # The initial /balance call already produced one sample; top it up
+        # so every endpoint has the same call count.
+        already = len(samples_by_endpoint.get(path, []))
+        for _ in range(max(0, _LATENCY_ITERATIONS - already)):
+            t0 = time.perf_counter()
+            try:
+                client.get(path)
+            except ApiError as exc:
+                if exc.status_code == 404:
+                    # Endpoint missing on this server — stop probing it.
+                    break
+                # Other errors (5xx, 401 after refresh) still produced a
+                # round-trip, so the latency is meaningful — record it.
+            except Exception:
+                # Network failure mid-probe — bail on this endpoint.
+                break
+            samples_by_endpoint.setdefault(path, []).append((time.perf_counter() - t0) * 1000)
+
+
+def _print_latency_table(samples_by_endpoint: dict[str, list[float]]) -> None:
+    """Render per-endpoint and overall latency stats."""
+    rows = [(path, samples) for path, samples in samples_by_endpoint.items() if samples]
+    if not rows:
+        return
+
+    table = Table(title="API latency (ms)", show_lines=False)
+    table.add_column("Endpoint")
+    table.add_column("Calls", justify="right")
+    table.add_column("Min", justify="right")
+    table.add_column("Median", justify="right")
+    table.add_column("Max", justify="right")
+    for path, samples in rows:
+        table.add_row(
+            path,
+            str(len(samples)),
+            f"{min(samples):.0f}",
+            f"{statistics.median(samples):.0f}",
+            f"{max(samples):.0f}",
+        )
+    console.print()
+    console.print(table)
+
+    all_samples = [s for _, samples in rows for s in samples]
+    if len(all_samples) >= 2:
+        # Nearest-rank p95 — good enough for a health-check sample of ~15.
+        ranked = sorted(all_samples)
+        p95 = ranked[min(len(ranked) - 1, int(round(0.95 * len(ranked))) - 1)]
+        console.print(
+            f"  Overall: median={statistics.median(all_samples):.0f}ms  "
+            f"p95={p95:.0f}ms  max={max(all_samples):.0f}ms  "
+            f"n={len(all_samples)}"
+        )
+
+
 @app.callback(invoke_without_command=True)
 def doctor(ctx: typer.Context) -> None:
     """Check CLI health: version, auth status, API connectivity, credits."""
@@ -78,20 +153,31 @@ def doctor(ctx: typer.Context) -> None:
     else:
         console.print(f"  Auth:   [green]ok[/green] ({tokens.email})")
 
-    # Connectivity + balance
+    # Connectivity + balance + latency timing. The first /balance call
+    # doubles as the connectivity probe; subsequent calls feed the
+    # latency stats table that's printed at the end of the report.
+    samples_by_endpoint: dict[str, list[float]] = {}
     if tokens and not tokens.is_expired:
         client = get_client()
         try:
-            data = client.get("/balance")
-            balance_val = data.get("balance", "?")
-            console.print(f"  API:    [green]connected[/green]")
-            console.print(f"  Credits: {balance_val}")
-        except ApiError as e:
-            console.print(f"  API:    [red]error ({e.status_code})[/red]")
-            all_ok = False
-        except Exception as e:
-            console.print(f"  API:    [red]unreachable[/red]")
-            all_ok = False
+            try:
+                t0 = time.perf_counter()
+                data = client.get("/balance")
+                samples_by_endpoint.setdefault("/balance", []).append((time.perf_counter() - t0) * 1000)
+                balance_val = data.get("balance", "?")
+                console.print(f"  API:    [green]connected[/green]")
+                console.print(f"  Credits: {balance_val}")
+            except ApiError as e:
+                console.print(f"  API:    [red]error ({e.status_code})[/red]")
+                all_ok = False
+            except Exception:
+                console.print(f"  API:    [red]unreachable[/red]")
+                all_ok = False
+
+            # Pad /balance to N calls and time the remaining free endpoints.
+            # The table itself is printed at the bottom, just above the verdict.
+            if samples_by_endpoint.get("/balance"):
+                _collect_latency_samples(client, samples_by_endpoint)
         finally:
             client.close()
     else:
@@ -127,6 +213,8 @@ def doctor(ctx: typer.Context) -> None:
             if hint:
                 console.print(f"    Install: {hint}")
 
+    _print_latency_table(samples_by_endpoint)
+
     console.print()
     if all_ok:
         console.print("[green]Everything looks good.[/green]")