botable-dev 0.3.1__py3-none-any.whl

botable/cli.py

@@ -0,0 +1,781 @@
+"""
+Botable CLI — main Typer application.
+
+All commands are registered here. Heavy logic lives in dedicated modules.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import platform
+import re
+import shutil
+import socket
+import subprocess
+import time
+import webbrowser
+from contextlib import nullcontext
+from typing import Any, Callable, Coroutine, Dict, Optional, TypeVar
+
+import typer
+from rich.console import Console
+
+from botable import __version__
+from botable.ui import banner, success, error, info
+
+app = typer.Typer(
+    name="botable",
+    help="⚡ Generate Telegram bots with AI — from idea to running bot in 3 minutes.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+console = Console()
+
+T = TypeVar("T")
+
+
+# ── shared helpers ───────────────────────────────────────────────────────────
+
+def _require_auth() -> str:
+    """Return the auth token or exit with a helpful error."""
+    from botable.config import get_auth_token
+
+    token = get_auth_token()
+    if not token:
+        error("Not logged in. Run [cyan]botable login --api-key YOUR_KEY[/]")
+        raise typer.Exit(1)
+    return token
+
+
+def _run_async(
+    coro_fn: Callable[[], Coroutine[Any, Any, T]],
+    status_msg: str = "Working…",
+    error_prefix: str = "Operation failed",
+) -> T:
+    """Run an async coroutine with a Rich spinner and consistent error handling.
+
+    Catches httpx errors and extracts backend detail messages.
+    """
+    import httpx
+
+    try:
+        with (console.status(f"[bold cyan]{status_msg}") if status_msg else nullcontext()):
+            return asyncio.run(coro_fn())
+    except httpx.HTTPStatusError as e:
+        from botable.errors import APIError
+        api_err = APIError.from_httpx(e)
+        error(f"{error_prefix}: {api_err.detail}")
+        raise typer.Exit(1)
+    except (httpx.ConnectError, httpx.ConnectTimeout):
+        error(f"{error_prefix}: Cannot reach Botable API. Check your connection.")
+        raise typer.Exit(1)
+    except Exception as e:
+        error(f"{error_prefix}: {e}")
+        raise typer.Exit(1)
+
+
+# ── version ──────────────────────────────────────────────────────────────────
+
+@app.command()
+def version():
+    """Show the Botable CLI version."""
+    from botable.config import get_api_url
+
+    console.print(f"[bold cyan]botable[/] v{__version__}")
+    console.print(f"API URL: {get_api_url()}")
+
+
+# ── init ─────────────────────────────────────────────────────────────────────
+
+@app.command()
+def init(
+    name: str = typer.Argument("my-bot", help="Name of the bot project to create"),
+):
+    """Scaffold a new bot project with botable.toml and .env."""
+    from botable.scaffold import scaffold_project
+
+    banner()
+    try:
+        project_dir = scaffold_project(name)
+        success(f"Project [bold]{name}[/] created at [cyan]{project_dir}[/]")
+        info("Next steps:")
+        console.print("  1. [cyan]cd {name}[/]".format(name=name))
+        console.print('  2. Edit [yellow].env[/] — add your BOT_TOKEN')
+        console.print('  3. [cyan]botable generate "your bot description"[/]')
+    except Exception as e:
+        error(f"Failed to create project: {e}")
+        raise typer.Exit(1)
+
+
+# ── generate ─────────────────────────────────────────────────────────────────
+
+@app.command()
+def generate(
+    description: str = typer.Argument(..., help="Natural language description of the bot to generate"),
+    model: str = typer.Option("gpt-4o-mini", "--model", "-m", help="OpenAI model to use for generation"),
+):
+    """Generate a Telegram bot from a natural language description."""
+    from botable.generate import run_generate
+
+    banner()
+    info(f"Generating bot: [italic]{description}[/]")
+    console.print()
+
+    ok = run_generate(description, model=model)
+    if not ok:
+        raise typer.Exit(1)
+
+
+# ── dev ──────────────────────────────────────────────────────────────────────
+
+@app.command()
+def dev(
+    watch: bool = typer.Option(False, "--watch", "-w", help="Enable hot reload on file changes"),
+):
+    """Run the bot locally with live output."""
+    from botable.runner import run_dev
+
+    banner()
+    exit_code = run_dev(watch=watch)
+    raise typer.Exit(exit_code)
+
+
+# ── deploy ───────────────────────────────────────────────────────────────────
+
+@app.command()
+def deploy(json_output: bool = typer.Option(False, "--json", help="Print deployment result as JSON")):
+    """Deploy bot to Botable cloud."""
+    import io
+    import tarfile
+    from pathlib import Path
+
+    from botable.config import load_project_config
+    from botable.api_client import BotableClient
+    from botable.ui import warn
+
+    if not json_output:
+        banner()
+
+    # ── 1. Validate project ──────────────────────────────────────────
+    config = load_project_config()
+    if config is None:
+        error("No [cyan]botable.toml[/] found. Run [cyan]botable init[/] first.")
+        raise typer.Exit(1)
+
+    project_root = Path(config.get("_project_root", "."))
+    main_py = project_root / "main.py"
+    if not main_py.exists():
+        error("[cyan]main.py[/] not found. Generate your bot first: [cyan]botable generate \"...\"[/]")
+        raise typer.Exit(1)
+
+    # ── 2. Check auth ────────────────────────────────────────────────
+    token = _require_auth()
+
+    # ── 3. Create tarball ────────────────────────────────────────────
+    project_name = config.get("project", {}).get("name", project_root.name)
+    if not json_output:
+        info(f"Deploying [bold]{project_name}[/]…\n")
+
+    FILES_TO_PACK = ["main.py", "requirements.txt", ".env", "botable.toml"]
+    buf = io.BytesIO()
+    packed = []
+
+    with tarfile.open(fileobj=buf, mode="w:gz") as tar:
+        for name in FILES_TO_PACK:
+            fpath = project_root / name
+            if fpath.exists():
+                tar.add(str(fpath), arcname=name)
+                packed.append(name)
+
+    tarball = buf.getvalue()
+    if not json_output:
+        console.print(f"  📦 Packed {len(packed)} files ({len(tarball) // 1024}KB)\n")
+
+    # ── 4. Upload & deploy ───────────────────────────────────────────
+    async def _deploy():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.deploy_project(tarball)
+        finally:
+            await client.close()
+
+    result = _run_async(_deploy, "" if json_output else "Uploading & deploying…", "Deploy failed")
+
+    # ── 5. Show result ───────────────────────────────────────────────
+    data = result.get("data", result)
+    deploy_status = data.get("deployment_status", data.get("state", "unknown"))
+    project_id = (data.get("project_id") or data.get("id") or result.get("project_id")
+                  or config.get("project", {}).get("id"))
+
+    if json_output:
+        typer.echo(json.dumps({
+            "project_id": project_id,
+            "state": deploy_status,
+            "message": data.get("message", result.get("message", "")),
+        }))
+        return
+
+    if deploy_status in ("success", "queued"):
+        success(f"Project [bold]{data.get('project_name', project_name)}[/] deployed!")
+        console.print()
+
+        if deploy_status == "queued":
+            info("Deployment queued — bot will start shortly.")
+        else:
+            info("Bot is running. ✨")
+
+        console.print()
+        console.print("  [dim]View status:[/]  [cyan]botable bots list[/]")
+        console.print("  [dim]Stream logs:[/]  [cyan]botable logs -f[/]")
+    else:
+        warn(f"Deploy returned status: {deploy_status}")
+        console.print(f"  [dim]{data}[/]")
+
+
+
+# ── logs ─────────────────────────────────────────────────────────────────────
+
+@app.command()
+def logs(
+    project_id: str = typer.Argument(None, help="Project ID (defaults to most recent bot)"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Stream logs in real-time"),
+    json_output: bool = typer.Option(False, "--json", help="Print status snapshot as JSON"),
+):
+    """Show a deployed bot's status snapshot (live log streaming is unavailable)."""
+    from botable.api_client import BotableClient
+
+    token = _require_auth()
+
+    async def _get_status():
+        client = BotableClient(api_key=token)
+        try:
+            pid = project_id
+            if not pid:
+                result = await client.list_bots()
+                bots = result.get("data", {}).get("bots", [])
+                if not bots:
+                    return None
+                pid = bots[0]["id"]
+
+            status = await client.get_bot_status(pid)
+            return {"project_id": pid, **status.get("data", status)}
+        finally:
+            await client.close()
+
+    result = _run_async(_get_status, "" if json_output else "Fetching status…", "Failed to get logs")
+
+    if json_output:
+        typer.echo(json.dumps(result))
+        return
+
+    if result is None:
+        info("No deployed bots found. Run [cyan]botable deploy[/] first.")
+        raise typer.Exit(0)
+
+    banner()
+    pid = result.get("project_id", "?")
+    state = result.get("current_state", "unknown")
+    running = result.get("is_running", False)
+
+    status_icon = "🟢" if running else "🔴"
+    console.print(f"  {status_icon} Project [bold]{pid}[/]")
+    console.print(f"     State: [cyan]{state}[/]  |  Running: {'yes' if running else 'no'}")
+    console.print()
+
+    if follow:
+        info("Live log streaming will be available in a future release.")
+        info("For now, use [cyan]botable logs[/] to check current status.")
+    else:
+        status_data = result.get("status", {})
+        if status_data:
+            for k, v in status_data.items():
+                if k not in ("current_state", "is_bot_running", "project_id"):
+                    console.print(f"     [dim]{k}:[/] {v}")
+
+
+# ── login ────────────────────────────────────────────────────────────────────
+
+@app.command()
+def login(
+    api_key: str = typer.Option("", "--api-key", "-k", help="API key for authentication"),
+    api_url: str = typer.Option("", "--api-url", help="Persist the Botable API base URL"),
+    no_browser: bool = typer.Option(False, "--no-browser", help="Do not open the verification page"),
+):
+    """Authenticate with Botable cloud."""
+    import httpx
+    from botable.config import save_global_config, load_global_config, get_api_url
+    from urllib.parse import urlsplit
+
+    def valid_url(value: str) -> bool:
+        parsed = urlsplit(value)
+        return (parsed.scheme in ("http", "https") and bool(parsed.hostname)
+                and not parsed.username and not parsed.password and not parsed.query
+                and not parsed.fragment and parsed.path in ("", "/"))
+
+    if api_url and not valid_url(api_url):
+        error("Invalid API URL. Use an http(s) origin such as https://api-staging.botable.dev")
+        raise typer.Exit(1)
+
+    if api_key or api_url:
+        config = load_global_config()
+        if api_key:
+            config["auth_token"] = api_key
+        if api_url:
+            config["api_url"] = api_url.rstrip("/")
+        save_global_config(config)
+        success("Settings saved to [cyan]~/.config/botable/config.toml[/]")
+        info(f"API URL: {get_api_url()}")
+        return
+
+    base_url = api_url.rstrip("/") if api_url else get_api_url().rstrip("/")
+    hostname = re.sub(r"[^A-Za-z0-9.-]", "-", socket.gethostname())[:65].strip(".-") or "unknown"
+    try:
+        with httpx.Client(base_url=base_url, timeout=10) as client:
+            response = client.post("/api/v1/cli/auth/device", json={"client_name": f"botable CLI on {hostname}"})
+            response.raise_for_status()
+            device = response.json()
+            typer.echo(f"Code: {device['user_code']}")
+            typer.echo(f"Open: {device['verification_uri_complete']}")
+            typer.echo(f"Another browser: {device['verification_uri']} and enter code {device['user_code']}")
+            has_display = os.name == "nt" or (platform.system() == "Darwin" and not os.getenv("SSH_CONNECTION") and not os.getenv("CI")) or bool(os.getenv("DISPLAY") or os.getenv("WAYLAND_DISPLAY"))
+            if not no_browser and has_display:
+                webbrowser.open(device["verification_uri_complete"])
+
+            interval = max(float(device["interval"]), 1)
+            deadline = time.monotonic() + float(device["expires_in"])
+            while time.monotonic() < deadline:
+                time.sleep(min(interval, max(0, deadline - time.monotonic())))
+                response = client.post("/api/v1/cli/auth/token", json={"device_code": device["device_code"]})
+                if response.status_code == 200:
+                    result = response.json()
+                    returned_url = result.get("api_url", "").rstrip("/").removesuffix("/api/v1")
+                    if returned_url and not valid_url(returned_url):
+                        raise ValueError("Invalid API URL returned by server")
+                    config = load_global_config()
+                    config["auth_token"] = result["api_key"]
+                    if returned_url or api_url:
+                        config["api_url"] = (returned_url or api_url).rstrip("/")
+                    save_global_config(config)
+                    typer.echo(f"Logged in as {result['user']['email']} → {get_api_url()}")
+                    return
+                code, message = _device_error(response)
+                if response.status_code == 428 and code == "authorization_pending":
+                    continue
+                if response.status_code == 429:
+                    interval += 5
+                    continue
+                if response.status_code == 403 and code == "access_denied":
+                    error("Login denied.")
+                elif response.status_code == 410 and code == "expired_token":
+                    error("Login code expired.")
+                else:
+                    error(f"Login failed (HTTP {response.status_code}): {message}")
+                raise typer.Exit(1)
+            error("Login code expired.")
+            raise typer.Exit(1)
+    except KeyboardInterrupt:
+        info("Login cancelled.")
+        raise typer.Exit(130)
+    except httpx.HTTPStatusError as exc:
+        _, detail = _device_error(exc.response)
+        error(f"Login failed: {detail}")
+        raise typer.Exit(1)
+    except (httpx.HTTPError, KeyError, ValueError) as exc:
+        error(f"Login failed: {type(exc).__name__}")
+        raise typer.Exit(1)
+
+
+def _device_error(response) -> tuple[str, str]:
+    try:
+        payload = response.json()
+    except ValueError:
+        payload = {}
+    if not isinstance(payload, dict):
+        payload = {}
+    status = payload.get("status")
+    code = status if status in ("authorization_pending", "slow_down", "access_denied", "expired_token") else ""
+    message = payload.get("message") or payload.get("detail") or response.reason_phrase or "Request failed"
+    return code, message if isinstance(message, str) else "Request failed"
+
+
+@app.command()
+def logout():
+    """Remove stored authentication."""
+    from botable.config import save_global_config, load_global_config
+
+    config = load_global_config()
+    if "auth_token" in config:
+        del config["auth_token"]
+        save_global_config(config)
+        success("Logged out — API key removed.")
+    else:
+        info("Not logged in.")
+
+
+mcp_app = typer.Typer(help="Configure coding agent MCP clients")
+app.add_typer(mcp_app, name="mcp")
+
+
+@mcp_app.command("install")
+def mcp_install(
+    target: str = typer.Option("all", "--target", help="claude, codex, or all"),
+    scope: str = typer.Option("user", "--scope", help="Claude scope: user or project"),
+):
+    """Register the Botable MCP server with Claude Code and/or Codex."""
+    from botable.mcp_install import _mcp_command, install_claude, install_codex
+
+    if target not in ("claude", "codex", "all") or scope not in ("user", "project"):
+        error("Use --target claude|codex|all and --scope user|project.")
+        raise typer.Exit(2)
+    if _mcp_command() == "botable-mcp" and not shutil.which("botable-mcp"):
+        typer.echo('Warning: botable-mcp not found; install "botable-dev[mcp]" first.')
+    failed = False
+    missing = False
+    configured = 0
+    for name, install, verify in (
+        ("claude", lambda: install_claude(scope), "claude mcp list"),
+        ("codex", install_codex, "codex mcp list"),
+    ):
+        if target not in (name, "all"):
+            continue
+        try:
+            typer.echo(install())
+            typer.echo(f"Verify: {verify}")
+            configured += 1
+        except FileNotFoundError as exc:
+            error(f"{name} MCP unavailable: {exc}")
+            missing = True
+        except (OSError, ValueError, subprocess.CalledProcessError) as exc:
+            error(f"{name} MCP install failed: {exc}")
+            failed = True
+    if failed or (missing and (target != "all" or not configured)):
+        raise typer.Exit(1)
+
+
+# ── bots ─────────────────────────────────────────────────────────────────────
+
+bots_app = typer.Typer(help="Manage deployed bots")
+app.add_typer(bots_app, name="bots")
+
+
+@bots_app.command("list")
+def bots_list(json_output: bool = typer.Option(False, "--json", help="Print bots as JSON")):
+    """List all deployed bots."""
+    from rich.table import Table
+    from botable.api_client import BotableClient
+
+    token = _require_auth()
+
+    async def _list():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.list_bots()
+        finally:
+            await client.close()
+
+    result = _run_async(_list, "" if json_output else "Fetching bots…", "Failed to list bots")
+
+    if json_output:
+        typer.echo(json.dumps(result.get("data", result).get("bots", [])))
+        return
+
+    banner()
+
+    data = result.get("data", result)
+    bots = data.get("bots", [])
+
+    if not bots:
+        info("No bots found. Create one with [cyan]botable deploy[/]")
+        return
+
+    table = Table(title=f"🤖 Your Bots ({len(bots)})", show_lines=True)
+    table.add_column("Name", style="bold")
+    table.add_column("ID", style="dim", max_width=20)
+    table.add_column("State", style="cyan")
+    table.add_column("Running", justify="center")
+    table.add_column("Deployed", justify="center")
+
+    for bot in bots:
+        running = "🟢" if bot.get("is_running") else "🔴"
+        deployed = "✅" if bot.get("is_deployed") else "—"
+        table.add_row(
+            bot.get("name", "untitled"),
+            str(bot.get("id", "?"))[:20],
+            bot.get("fsm_state", "?"),
+            running,
+            deployed,
+        )
+
+    console.print(table)
+    console.print()
+
+
+@bots_app.command("stop")
+def bots_stop(
+    project_id: str = typer.Argument(..., help="Project ID of the bot to stop"),
+):
+    """Stop a running bot."""
+    from botable.api_client import BotableClient
+
+    token = _require_auth()
+
+    async def _stop():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.stop_bot(project_id)
+        finally:
+            await client.close()
+
+    _run_async(_stop, "Stopping bot…", "Failed to stop bot")
+    success(f"Bot [bold]{project_id}[/] stopped.")
+
+
+@bots_app.command("start")
+def bots_start(
+    project_id: str = typer.Argument(..., help="Project ID of the bot to start"),
+):
+    """Start a stopped bot."""
+    from botable.api_client import BotableClient
+
+    token = _require_auth()
+
+    async def _start():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.start_bot(project_id)
+        finally:
+            await client.close()
+
+    _run_async(_start, "Starting bot…", "Failed to start bot")
+    success(f"Bot [bold]{project_id}[/] started.")
+
+
+@bots_app.command("delete")
+def bots_delete(
+    project_id: str = typer.Argument(..., help="Project ID of the bot to delete"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Delete a bot permanently."""
+    from botable.api_client import BotableClient
+
+    if not force:
+        confirm = typer.confirm(f"⚠️  Are you sure you want to delete {project_id}?")
+        if not confirm:
+            info("Cancelled.")
+            raise typer.Exit(0)
+
+    token = _require_auth()
+
+    async def _delete():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.delete_bot(project_id)
+        finally:
+            await client.close()
+
+    _run_async(_delete, "Deleting bot…", "Failed to delete bot")
+    success(f"Bot [bold]{project_id}[/] deleted.")
+
+
+@bots_app.command("edit")
+def bots_edit(
+    project_id: str = typer.Argument(..., help="Project ID of the bot to edit"),
+    instruction: str = typer.Argument(..., help="Edit instruction in natural language"),
+):
+    """Edit a bot with natural language instructions."""
+    from botable.api_client import BotableClient
+
+    token = _require_auth()
+    banner()
+    info(f"Editing bot [bold]{project_id}[/]: [italic]{instruction}[/]")
+
+    async def _edit():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.edit_bot(project_id, instruction)
+        finally:
+            await client.close()
+
+    result = _run_async(_edit, "Applying edit…", "Failed to edit bot")
+
+    data = result.get("data", result)
+    state = data.get("state", "unknown")
+    success(f"Edit applied. Bot state: [cyan]{state}[/]")
+
+
+# ── api-keys ─────────────────────────────────────────────────────────────
+
+keys_app = typer.Typer(help="Manage API keys")
+app.add_typer(keys_app, name="api-keys")
+
+
+@keys_app.command("list")
+def keys_list():
+    """List all API keys."""
+    from rich.table import Table
+    from botable.api_client import BotableClient
+
+    token = _require_auth()
+
+    async def _list():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.list_api_keys()
+        finally:
+            await client.close()
+
+    result = _run_async(_list, "Fetching API keys…", "Failed to list keys")
+
+    data = result.get("data", result)
+    keys = data.get("keys", [])
+
+    if not keys:
+        info("No API keys found. Create one with [cyan]botable api-keys create \"name\"[/]")
+        return
+
+    table = Table(title=f"🔑 API Keys ({len(keys)})")
+    table.add_column("Name", style="bold")
+    table.add_column("ID", style="dim", max_width=20)
+    table.add_column("Created", style="cyan")
+    table.add_column("Last Used")
+
+    for key in keys:
+        table.add_row(
+            key.get("name", "unnamed"),
+            str(key.get("id", "?"))[:20],
+            key.get("created_at", "?")[:10],
+            (key.get("last_used_at") or "never")[:10],
+        )
+
+    console.print(table)
+
+
+@keys_app.command("create")
+def keys_create(
+    name: str = typer.Argument(..., help="Name for the API key"),
+):
+    """Create a new API key."""
+    from botable.api_client import BotableClient
+
+    token = _require_auth()
+
+    async def _create():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.create_api_key(name)
+        finally:
+            await client.close()
+
+    result = _run_async(_create, "Creating API key…", "Failed to create key")
+
+    data = result.get("data", result)
+    key_value = data.get("key", data.get("api_key", "?"))
+
+    success(f"API key [bold]{name}[/] created!")
+    console.print()
+    console.print(f"  🔑 [bold yellow]{key_value}[/]")
+    console.print()
+    console.print("  [dim]⚠️  Save this key — it won't be shown again![/]")
+
+
+@keys_app.command("revoke")
+def keys_revoke(
+    key_id: str = typer.Argument(..., help="ID of the API key to revoke"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Revoke an API key."""
+    from botable.api_client import BotableClient
+
+    if not force:
+        confirm = typer.confirm(f"⚠️  Revoke API key {key_id}?")
+        if not confirm:
+            info("Cancelled.")
+            raise typer.Exit(0)
+
+    token = _require_auth()
+
+    async def _revoke():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.revoke_api_key(key_id)
+        finally:
+            await client.close()
+
+    _run_async(_revoke, "Revoking API key…", "Failed to revoke key")
+    success(f"API key [bold]{key_id}[/] revoked.")
+
+
+# ── credits ──────────────────────────────────────────────────────────────
+
+@app.command()
+def credits():
+    """Show current credit balance."""
+    from botable.api_client import BotableClient
+
+    token = _require_auth()
+
+    async def _get():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.get_credits()
+        finally:
+            await client.close()
+
+    result = _run_async(_get, "Fetching credits…", "Failed to get credits")
+
+    data = result.get("data", result)
+    balance = data.get("balance", 0)
+    used = data.get("used", 0)
+
+    banner()
+    console.print(f"  💰 Credits: [bold green]{balance}[/]")
+    if used:
+        console.print(f"  📊 Used: [dim]{used}[/]")
+    console.print()
+
+
+# ── templates ────────────────────────────────────────────────────────────
+
+@app.command("templates")
+def templates_list():
+    """List available bot templates."""
+    from rich.table import Table
+    from botable.api_client import BotableClient
+
+    token = _require_auth()
+
+    async def _list():
+        client = BotableClient(api_key=token)
+        try:
+            return await client.list_templates()
+        finally:
+            await client.close()
+
+    result = _run_async(_list, "Fetching templates…", "Failed to list templates")
+
+    data = result.get("data", result)
+    templates = data.get("templates", [])
+
+    if not templates:
+        info("No templates available.")
+        return
+
+    table = Table(title=f"📦 Templates ({len(templates)})")
+    table.add_column("Name", style="bold")
+    table.add_column("Category", style="cyan")
+    table.add_column("Description")
+
+    for tmpl in templates:
+        table.add_row(
+            tmpl.get("name", "?"),
+            tmpl.get("template_type", "general"),
+            (tmpl.get("short_description", "")[:50] + "…") if len(tmpl.get("short_description", "")) > 50 else tmpl.get("short_description", ""),
+        )
+
+    console.print(table)
+    console.print()
+
+
+if __name__ == "__main__":
+    app()