thoughtleaders-cli 0.5.0__py3-none-any.whl

tl_cli/commands/uploads.py

@@ -0,0 +1,84 @@
+"""tl uploads — List and show video uploads."""
+
+import typer
+
+from tl_cli.client.errors import ApiError, handle_api_error
+from tl_cli.client.http import get_client
+from tl_cli.filters import parse_filters
+from tl_cli.output.formatter import detect_format, output, output_single
+
+app = typer.Typer(help="Video uploads (YouTube content from Elasticsearch)")
+
+
+@app.callback(invoke_without_command=True)
+def uploads(ctx: typer.Context) -> None:
+    """Video uploads from YouTube (Elasticsearch)."""
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(list_cmd, args=[], json_output=False, csv_output=False, md_output=False, limit=50, offset=0)
+
+
+@app.command("list")
+def list_cmd(
+    args: list[str] = typer.Argument(None, help="Filters (key:value pairs). Run 'tl describe show uploads' for available filters."),
+    json_output: bool = typer.Option(False, "--json", help="JSON output"),
+    csv_output: bool = typer.Option(False, "--csv", help="CSV output"),
+    md_output: bool = typer.Option(False, "--md", help="Markdown output"),
+    toon_output: bool = typer.Option(False, "--toon", help="TOON output (token-efficient for LLMs)"),
+    limit: int = typer.Option(50, "--limit", "-l", help="Max results"),
+    offset: int = typer.Option(0, "--offset", help="Pagination offset"),
+) -> None:
+    """List video uploads with optional filters.
+
+    Examples:
+        tl uploads list                               # List recent uploads
+        tl uploads list channel:12345 type:longform   # Filter uploads
+    """
+    fmt = detect_format(json_output, csv_output, md_output, toon_output)
+    filters = parse_filters(args or [])
+
+    client = get_client()
+    try:
+        params = {**filters, "limit": str(limit), "offset": str(offset)}
+        data = client.get("/uploads", params=params)
+        for r in data.get("results", []):
+            r["upload_id"] = r.pop("id", None)
+        output(
+            data,
+            fmt,
+            columns=["upload_id", "title", "channel", "views", "publication_date", "content_type"],
+            title="Uploads",
+        )
+    except ApiError as e:
+        handle_api_error(e)
+    finally:
+        client.close()
+
+
+@app.command("show")
+def show_cmd(
+    ids: list[str] = typer.Argument(..., help="One or more upload IDs"),
+    json_output: bool = typer.Option(False, "--json", help="JSON output"),
+    toon_output: bool = typer.Option(False, "--toon", help="TOON output (token-efficient for LLMs)"),
+) -> None:
+    """Show details for one or more uploads by ID.
+
+    IDs can contain colons (e.g. 1174310:0BehkmVa7ak).
+
+    Examples:
+        tl uploads show 0BehkmVa7ak
+        tl uploads show 1174310:0BehkmVa7ak
+        tl uploads show 0BehkmVa7ak dQw4w9WgXcQ
+    """
+    fmt = detect_format(json_output, False, False, toon_output)
+
+    client = get_client()
+    try:
+        for upload_id in ids:
+            data = client.get(f"/uploads/{upload_id}")
+            for r in (data.get("results", []) if isinstance(data.get("results"), list) else []):
+                r["upload_id"] = r.pop("id", None)
+            output_single(data, fmt)
+    except ApiError as e:
+        handle_api_error(e)
+    finally:
+        client.close()

tl_cli/commands/whoami.py

@@ -0,0 +1,206 @@
+"""tl whoami — Show information about the logged-in user."""
+
+import json
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from tl_cli.client.errors import handle_api_error, ApiError
+from tl_cli.client.http import get_client
+from tl_cli.output.formatter import detect_format
+
+app = typer.Typer(help="Show current user, profile, org, and brands (free)")
+
+
+def _render_whoami(data: dict) -> None:
+    """Rich-formatted whoami output."""
+    console = Console()
+    user = data.get("user", {})
+    profile = data.get("profile", {})
+    org = data.get("organization", {})
+    profiles = data.get("associated_profiles", [])
+    brands = data.get("brands", [])
+
+    # --- User ---
+    name = f"{user.get('first_name', '')} {user.get('last_name', '')}".strip()
+    title = Text()
+    title.append(name or user.get("email", ""), style="bold cyan")
+    if name:
+        title.append(f"  {user.get('email', '')}", style="dim")
+
+    flags = profile.get("flags", [])
+    persona = profile.get("persona")
+
+    lines = Text()
+    if persona:
+        lines.append(f"Persona: ", style="dim")
+        lines.append(persona, style="bold")
+        lines.append("\n")
+    if flags:
+        lines.append("Flags:   ", style="dim")
+        lines.append(", ".join(flags), style="green")
+        lines.append("\n")
+    lines.append("Paid:    ", style="dim")
+    lines.append("yes" if profile.get("is_paid") else "no", style="green" if profile.get("is_paid") else "yellow")
+    lines.append("\n")
+    lines.append("Joined:  ", style="dim")
+    lines.append(user.get("date_joined", "")[:10])
+
+    console.print(Panel(lines, title=title, border_style="cyan"))
+
+    # --- Organization ---
+    org_lines = Text()
+    org_lines.append(org.get("name", ""), style="bold")
+    plan = org.get("plan")
+    if plan:
+        org_lines.append(f"  ({plan})", style="dim")
+    org_lines.append("\n")
+    if org.get("is_managed_services"):
+        org_lines.append("Managed services", style="magenta")
+        org_lines.append("\n")
+    start = org.get("contract_start_date")
+    end = org.get("contract_end_date")
+    if start or end:
+        org_lines.append("Contract: ", style="dim")
+        org_lines.append(f"{start or '?'} → {end or '?'}")
+
+    console.print(Panel(org_lines, title="Organization", border_style="blue"))
+
+    # --- Associated Profiles ---
+    if profiles:
+        table = Table(title="Profiles in Organization", border_style="dim", show_lines=False)
+        table.add_column("Name", style="bold")
+        table.add_column("Email")
+        table.add_column("Flags", style="green")
+        for p in profiles:
+            table.add_row(
+                p.get("name", ""),
+                p.get("email", ""),
+                ", ".join(p.get("flags", [])),
+            )
+        console.print(table)
+
+    # --- Brands (grouped by brand, emails comma-separated) ---
+    if brands:
+        grouped: dict[int, dict] = {}
+        for b in brands:
+            bid = b.get("id")
+            if bid not in grouped:
+                grouped[bid] = {"id": bid, "name": b.get("name", ""), "website": b.get("website", ""), "emails": []}
+            email = b.get("profile_email", "")
+            if email and email not in grouped[bid]["emails"]:
+                grouped[bid]["emails"].append(email)
+
+        table = Table(title="Brands in Organization", border_style="dim", show_lines=False)
+        table.add_column("ID", style="dim")
+        table.add_column("Name", style="bold yellow")
+        table.add_column("Website")
+        table.add_column("Profile Emails", style="dim")
+        for g in grouped.values():
+            table.add_row(
+                str(g["id"]),
+                g["name"],
+                g["website"],
+                ", ".join(g["emails"]),
+            )
+        console.print(table)
+
+
+def _render_whoami_md(data: dict) -> None:
+    """Markdown-formatted whoami output."""
+    user = data.get("user", {})
+    profile = data.get("profile", {})
+    org = data.get("organization", {})
+    profiles = data.get("associated_profiles", [])
+    brands = data.get("brands", [])
+
+    name = f"{user.get('first_name', '')} {user.get('last_name', '')}".strip()
+    print(f"# {name or user.get('email', '')}\n")
+    if name:
+        print(f"- **Email:** {user.get('email', '')}")
+    persona = profile.get("persona")
+    if persona:
+        print(f"- **Persona:** {persona}")
+    flags = profile.get("flags", [])
+    if flags:
+        print(f"- **Flags:** {', '.join(flags)}")
+    print(f"- **Paid:** {'yes' if profile.get('is_paid') else 'no'}")
+    print(f"- **Joined:** {user.get('date_joined', '')[:10]}")
+
+    print(f"\n## Organization: {org.get('name', '')}\n")
+    plan = org.get("plan")
+    if plan:
+        print(f"- **Plan:** {plan}")
+    if org.get("is_managed_services"):
+        print("- **Managed services:** yes")
+    start = org.get("contract_start_date")
+    end = org.get("contract_end_date")
+    if start or end:
+        print(f"- **Contract:** {start or '?'} → {end or '?'}")
+
+    if profiles:
+        print("\n## Profiles in Organization\n")
+        print("| Name | Email | Flags |")
+        print("| --- | --- | --- |")
+        for p in profiles:
+            print(f"| {p.get('name', '')} | {p.get('email', '')} | {', '.join(p.get('flags', []))} |")
+
+    if brands:
+        grouped: dict[int, dict] = {}
+        for b in brands:
+            bid = b.get("id")
+            if bid not in grouped:
+                grouped[bid] = {"id": bid, "name": b.get("name", ""), "website": b.get("website", ""), "emails": []}
+            email = b.get("profile_email", "")
+            if email and email not in grouped[bid]["emails"]:
+                grouped[bid]["emails"].append(email)
+
+        print("\n## Brands in Organization\n")
+        print("| ID | Name | Website | Profile Emails |")
+        print("| --- | --- | --- | --- |")
+        for g in grouped.values():
+            print(f"| {g['id']} | {g['name']} | {g['website']} | {', '.join(g['emails'])} |")
+
+
+@app.callback(invoke_without_command=True)
+def whoami(
+    ctx: typer.Context,
+    json_output: bool = typer.Option(False, "--json", help="JSON output"),
+    md_output: bool = typer.Option(False, "--md", help="Markdown output"),
+    toon_output: bool = typer.Option(False, "--toon", help="TOON output (token-efficient for LLMs)"),
+) -> None:
+    """Show information about the logged-in user.
+
+    Displays user details, profile flags, organization, associated
+    profiles, and brands (for buyers).
+
+    Examples:
+        tl whoami                         # Pretty-printed info
+        tl whoami --json                  # Full JSON response
+        tl whoami --md                    # Markdown output
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    fmt = detect_format(json_output, False, md_output, toon_output)
+
+    client = get_client()
+    try:
+        data = client.get("/whoami")
+
+        if fmt == "json":
+            print(json.dumps(data, indent=2, default=str))
+        elif fmt == "toon":
+            from toon_format import encode
+            print(encode(data))
+        elif fmt == "md":
+            _render_whoami_md(data)
+        else:
+            _render_whoami(data)
+    except ApiError as e:
+        handle_api_error(e)
+    finally:
+        client.close()

tl_cli/config.py

@@ -0,0 +1,55 @@
+"""Configuration management for the TL CLI."""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# Default API base URL
+DEFAULT_API_URL = "https://app.thoughtleaders.io"
+
+# Auth0 defaults (CLI-specific application)
+DEFAULT_AUTH0_DOMAIN = "dev-mq73b7zhdhwvgae1.us.auth0.com"
+DEFAULT_AUTH0_CLIENT_ID = "BWTaMBWRP0wxWjPXbSa9FHhbz7RKfURu" # Set when Auth0 app is created, not secret
+DEFAULT_AUTH0_AUDIENCE = "https://app.thoughtleaders.io/mcp" # No relation to the MCP API, just uses the same OAuth0 "audience" config
+DEFAULT_AUTH0_CALLBACK_PORT = 8484  # Fixed port — must match Auth0 allowed callback URLs
+
+# Config directory
+CONFIG_DIR = Path.home() / ".config" / "tl"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+@dataclass
+class Config:
+    """Runtime configuration resolved from env vars, config file, and defaults."""
+
+    api_url: str = field(default_factory=lambda: os.environ.get("TL_API_URL", DEFAULT_API_URL))
+    api_key: str | None = field(default_factory=lambda: os.environ.get("TL_API_KEY"))
+    auth0_domain: str = field(
+        default_factory=lambda: os.environ.get("TL_AUTH0_DOMAIN", DEFAULT_AUTH0_DOMAIN)
+    )
+    auth0_client_id: str = field(
+        default_factory=lambda: os.environ.get("TL_AUTH0_CLIENT_ID", DEFAULT_AUTH0_CLIENT_ID)
+    )
+    auth0_audience: str = field(
+        default_factory=lambda: os.environ.get("TL_AUTH0_AUDIENCE", DEFAULT_AUTH0_AUDIENCE)
+    )
+    llm_key: str | None = field(default_factory=lambda: os.environ.get("TL_LLM_KEY"))
+
+    @property
+    def cli_api_base(self) -> str:
+        return f"{self.api_url.rstrip('/')}/api/cli/v1"
+
+
+# Global flags, set by options on the root command
+debug: bool = False
+
+
+def get_config() -> Config:
+    """Get the current configuration."""
+    return Config()
+
+
+def ensure_config_dir() -> Path:
+    """Ensure the config directory exists and return it."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    return CONFIG_DIR

tl_cli/filters.py

@@ -0,0 +1,88 @@
+"""Parse key:value filter pairs from CLI arguments.
+
+This module only handles parsing — it does not know which filters are valid
+for which resource. Each command module validates its own filters.
+
+Examples:
+    parse_filters(["status:sold", 'brand:"Nike"', "created-at:2026-01"])
+    → {"status": "sold", "brand": "Nike", "created-at": "2026-01"}
+"""
+
+import datetime
+import re
+import sys
+
+DATE_FILTER_KEYS = {
+    # uploads (publication_date lower bound)
+    "since",
+    # sponsorships date filters — see RESOURCES['sponsorships'].filters.
+    # For each field, <prefix>:<date> filters within that date/period,
+    # and <prefix>-start/-end:<date> give inclusive lower/upper bounds.
+    "created-at", "created-at-start", "created-at-end",
+    "publish-date", "publish-date-start", "publish-date-end",
+    "purchase-date", "purchase-date-start", "purchase-date-end",
+    "send-date", "send-date-start", "send-date-end",
+}
+
+DATE_KEYWORDS = {
+    "today": lambda: datetime.date.today(),
+    "yesterday": lambda: datetime.date.today() - datetime.timedelta(days=1),
+    "tomorrow": lambda: datetime.date.today() + datetime.timedelta(days=1),
+}
+
+
+def parse_filters(args: list[str]) -> dict[str, str]:
+    """Parse a list of key:value filter strings into a dict.
+
+    Supports:
+        key:value           → {"key": "value"}
+        key:"quoted value"  → {"key": "quoted value"}
+        key:'quoted value'  → {"key": "quoted value"}
+        key:                → {"key": ""}   (empty value — endpoint decides semantics,
+                                             e.g. `owner-sales:` → no owner assigned)
+
+    Returns a dict of filter_name → filter_value. Prints an error and exits
+    if a filter is malformed.
+    """
+    filters: dict[str, str] = {}
+
+    for arg in args:
+        match = re.match(r'^([a-zA-Z_-]+):(.*)$', arg)
+        if not match:
+            print(f"Error: invalid filter '{arg}'. Expected format: key:value", file=sys.stderr)
+            raise SystemExit(1)
+
+        key = match.group(1)
+        value = match.group(2)
+
+        # Strip surrounding quotes
+        if (value.startswith('"') and value.endswith('"')) or (
+            value.startswith("'") and value.endswith("'")
+        ):
+            value = value[1:-1]
+
+        if key in DATE_FILTER_KEYS:
+            resolved = DATE_KEYWORDS.get(value.lower())
+            if resolved:
+                value = resolved().isoformat()
+
+        filters[key] = value
+
+    return filters
+
+
+def split_id_and_filters(args: list[str]) -> tuple[str | None, dict[str, str]]:
+    """Split args into an optional leading ID and remaining filters.
+
+    If the first arg doesn't contain ':', it's treated as an ID.
+    Everything else is parsed as filters.
+
+    Returns (id_or_none, filters_dict).
+    """
+    if not args:
+        return None, {}
+
+    if ":" not in args[0]:
+        return args[0], parse_filters(args[1:])
+
+    return None, parse_filters(args)

tl_cli/hints.py

@@ -0,0 +1,53 @@
+"""Detail-view CTA hints, personalized via whoami."""
+
+from tl_cli.client.http import TLClient
+
+
+def detail_hint(
+    client: TLClient,
+    *,
+    brand: str | None = None,
+    channel: str | None = None,
+) -> str | None:
+    """Build a CTA hint for a detail view.
+
+    - Sponsorship detail: both brand and channel come from the record.
+    - Channel detail: channel from the record, brand = user's org (if buyer).
+    - Brand detail: brand from the record, channel = user's org (if seller).
+
+    Returns None when both sides can't be determined.
+    """
+    _u = "[underline]"
+    _uu = "[/underline]"
+    email = f"{_u}info@thoughtleaders.io{_uu}"
+
+    if brand and channel:
+        return (
+            f"We can make the sponsorship between {_u}{brand}{_uu} and {_u}{channel}{_uu} work!"
+            f" Contact us at {email}"
+        )
+
+    # Need the counterparty from whoami
+    try:
+        data = client.get("/whoami")
+    except Exception:
+        return None
+
+    flags = data.get("profile", {}).get("flags", [])
+    org = data.get("organization", {}).get("name")
+    if not org:
+        return None
+
+    if channel and not brand and "advertiser" in flags:
+        return (
+            f"We can make the sponsorship between {_u}{org}{_uu} and {_u}{channel}{_uu} work!"
+            f" Contact us at {email}"
+        )
+
+    if brand and not channel and "publisher" in flags:
+        return (
+            f"We can make the sponsorship between {_u}{brand}{_uu} and {_u}{org}{_uu} work!"
+            f" Contact us at {email}"
+        )
+
+    return None