akta-pro-cli 0.3.0__py3-none-any.whl

akta_pro_cli/__init__.py

@@ -0,0 +1,8 @@
+"""akta.pro CLI — a command-line client for the akta.pro REST API (https://api.akta.pro).
+
+A standalone client (its own `akta-pro-cli` distribution) exposing the `akta-pro`
+console command; a sibling of the akta.pro MCP server over the same `/api/v1`
+endpoints, with no MCP-server code.
+"""
+
+__version__ = "0.3.0"

akta_pro_cli/__main__.py

@@ -0,0 +1,25 @@
+"""Entry point for `akta-pro` and `python -m akta_pro_cli`.
+
+Lazily imports the Typer app so a broken/partial install prints a helpful hint
+instead of an ImportError traceback.
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def main() -> None:
+    try:
+        from akta_pro_cli.app import app
+    except ModuleNotFoundError as exc:  # e.g. a broken install missing typer/rich
+        sys.stderr.write(
+            f"The akta.pro CLI is missing a dependency ({exc.name}).\n"
+            "Reinstall with:  pipx install akta-pro-cli\n"
+        )
+        raise SystemExit(1) from exc
+    app()
+
+
+if __name__ == "__main__":
+    main()

akta_pro_cli/app.py

@@ -0,0 +1,94 @@
+"""Assembles the `akta-pro` Typer application: root callback + command tree."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from akta_pro_cli import __version__
+from akta_pro_cli.client import DEFAULT_BASE_URL
+from akta_pro_cli.commands import (
+    account,
+    alternative,
+    auth,
+    company,
+    config,
+    industry,
+    news,
+    update,
+)
+from akta_pro_cli.console import err, out
+from akta_pro_cli.runtime import AppContext
+
+app = typer.Typer(
+    no_args_is_help=True,
+    add_completion=True,
+    rich_markup_mode="rich",
+    help="akta.pro CLI — company & market intelligence from api.akta.pro.",
+    epilog="Auth: set AKTA_PRO_API_KEY, pass --api-key, or run `akta-pro login`. Docs: https://docs.akta.pro",
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        out.print(f"akta-pro {__version__}")
+        # Best-effort, cached (~daily) hint — interactive only, to stderr so it
+        # never pollutes a scripted `akta-pro --version`. Never blocks or errors.
+        if out.is_terminal:
+            try:
+                from akta_pro_cli.update import cached_latest, is_newer
+
+                latest = cached_latest(timeout=2.0)
+                if latest and is_newer(latest, __version__):
+                    err.print(f"[dim]A newer version v{latest} is available — run `akta-pro update`.[/]")
+            except Exception:
+                pass
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    api_key: Annotated[
+        str | None,
+        typer.Option("--api-key", envvar="AKTA_PRO_API_KEY", show_default=False, help="akta.pro API key (wk_...)."),
+    ] = None,
+    base_url: Annotated[
+        str | None,
+        typer.Option(
+            "--base-url",
+            envvar="AKTA_PRO_API_BASE_URL",
+            show_default=False,
+            help=f"Override the API base URL (default {DEFAULT_BASE_URL}; or persist it via `akta-pro login --base-url …`).",
+        ),
+    ] = None,
+    quiet: Annotated[
+        bool,
+        typer.Option("--quiet", "-q", help="Suppress the credits line on stderr."),
+    ] = False,
+    timeout: Annotated[
+        float,
+        typer.Option("--timeout", help="HTTP request timeout in seconds."),
+    ] = 30.0,
+    version: Annotated[
+        bool | None,
+        typer.Option("--version", callback=_version_callback, is_eager=True, help="Show version and exit."),
+    ] = None,
+) -> None:
+    """Global options. Pass these before the command, e.g. `akta-pro --api-key wk_… company search Canva`."""
+    ctx.obj = AppContext(api_key=api_key, base_url=base_url, quiet=quiet, timeout=timeout)
+
+
+# Command groups
+app.add_typer(company.app, name="company")
+app.add_typer(industry.app, name="industry")
+app.add_typer(news.app, name="news")          # signals, detail, types
+app.add_typer(alternative.reviews_app, name="reviews")
+
+# Top-level commands
+auth.register(app)          # login, logout, whoami
+account.register(app)       # account
+config.register(app)        # config show / base-url
+update.register(app)        # update (self-update / check)
+alternative.register(app)   # headcount, traffic, jobs, posts

akta_pro_cli/client.py

@@ -0,0 +1,102 @@
+"""Standalone synchronous HTTP client for the akta.pro REST API.
+
+Deliberately self-contained (no dependency on `akta_mcp.*`): the server's
+`AktaClient` reads its key from a request-scoped ContextVar set by the OAuth
+middleware and transitively imports the Redis/Postgres token stores, none of
+which a CLI wants. This mirrors the server's error handling and redirect
+behaviour but takes the API key explicitly and runs synchronously.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from . import __version__
+
+DEFAULT_BASE_URL = "https://api.akta.pro/api/v1"
+
+# Sent on every request so the backend can distinguish (and version-track) CLI
+# traffic. Mirrors the MCP's `X-Client-Source: AKTA-MCP`.
+CLIENT_SOURCE = f"AKTA-PRO-CLI/{__version__}"
+
+
+class AktaAPIError(RuntimeError):
+    """An HTTP error from the akta.pro API, preserving the status code and body."""
+
+    def __init__(self, message: str, *, status_code: int, body: dict | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+
+
+_ERROR_MESSAGES = {
+    400: "Bad request — check the parameters.",
+    401: "Authentication failed. Check your API key (`akta-pro login`).",
+    403: (
+        "Access denied — your plan or credit balance does not cover this data "
+        "(alternative signals require Subscription/Enterprise; Funding and M&A "
+        "sections are enterprise-only)."
+    ),
+    404: "Not found.",
+    429: "Rate limit exceeded. Retry with backoff.",
+    500: "akta.pro server error. Please try again later.",
+    502: "akta.pro service unavailable. Please retry.",
+    503: "akta.pro service unavailable. Please retry.",
+}
+
+
+def _sanitize_http_error(exc: httpx.HTTPStatusError) -> AktaAPIError:
+    status = exc.response.status_code
+    msg = _ERROR_MESSAGES.get(status, f"Request failed with status {status}.")
+    try:
+        body = exc.response.json()
+    except ValueError:
+        body = None
+    if isinstance(body, dict):
+        detail = body.get("detail") or body.get("message") or body.get("error")
+        if detail:
+            msg = f"{msg} ({detail})"
+    return AktaAPIError(msg, status_code=status, body=body if isinstance(body, dict) else None)
+
+
+def _clean(params: dict | None) -> dict:
+    # Drop unset optional params so they aren't serialized onto the query string.
+    return {k: v for k, v in (params or {}).items() if v is not None}
+
+
+class AktaClient:
+    """Thin synchronous httpx wrapper that sends `x-api-key` on every GET."""
+
+    def __init__(self, base_url: str, api_key: str, timeout: float = 30.0):
+        self._api_key = api_key
+        # follow_redirects: several akta.pro routes are declared with a trailing slash,
+        # so a slashless path 307-redirects to the canonical one. The redirect is
+        # same-origin, so x-api-key is re-sent.
+        self._http = httpx.Client(base_url=base_url, timeout=timeout, follow_redirects=True)
+
+    def _headers(self) -> dict:
+        return {"x-api-key": self._api_key, "X-Client-Source": CLIENT_SOURCE}
+
+    def get(self, path: str, params: dict | None = None):
+        """GET, returning parsed JSON when the response is JSON, else raw text.
+
+        Text is returned for Akta's server-rendered Markdown endpoints (e.g.
+        `/company/enrichment/markdown`).
+        """
+        resp = self._http.get(path, params=_clean(params), headers=self._headers())
+        try:
+            resp.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            raise _sanitize_http_error(exc) from None
+        if "json" in resp.headers.get("content-type", "").lower():
+            return resp.json()
+        return resp.text
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> AktaClient:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()

akta_pro_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""akta.pro CLI command modules."""

akta_pro_cli/commands/account.py

@@ -0,0 +1,35 @@
+"""`akta-pro account` — the caller's plan tier and credit balance."""
+
+from __future__ import annotations
+
+import typer
+from rich.table import Table
+
+from akta_pro_cli.options import JsonOpt, OutOpt
+from akta_pro_cli.runtime import emit, fetch
+
+
+def _account_table(result: object) -> Table | None:
+    if not isinstance(result, dict):
+        return None
+    table = Table(title="akta.pro account", show_header=False)
+    table.add_column("Field", style="bold")
+    table.add_column("Value")
+    for key in ("package_type", "is_enterprise", "credit_balance", "currency"):
+        if key in result:
+            table.add_row(key.replace("_", " ").title(), str(result[key]))
+    return table
+
+
+def account(ctx: typer.Context, json_out: JsonOpt = False, output: OutOpt = None) -> None:
+    """Show your plan tier (is_enterprise, package_type) and credit balance (free).
+
+    Check this before Subscription/Enterprise-only commands (headcount, traffic,
+    jobs, posts, reviews) to know whether they'll be allowed.
+    """
+    result = fetch(ctx.obj, "/mcp/account")
+    emit(ctx.obj, result, json_out=json_out, output=output, renderer=_account_table)
+
+
+def register(app: typer.Typer) -> None:
+    app.command("account")(account)

akta_pro_cli/commands/alternative.py

@@ -0,0 +1,109 @@
+"""Alternative-signal commands: headcount, traffic, jobs, posts, and reviews.
+
+All require Subscription/Enterprise access; Pay-as-you-go returns 403.
+`headcount`/`traffic`/`jobs`/`posts` register at the top level; employee and
+product reviews live under the `akta-pro reviews` group.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from akta_pro_cli.options import CompanyArg, JsonOpt, LimitOpt, OffsetOpt, OutOpt
+from akta_pro_cli.runtime import emit, fetch
+
+reviews_app = typer.Typer(
+    no_args_is_help=True,
+    help="Employee and product reviews (Subscription/Enterprise).",
+)
+
+
+def headcount(ctx: typer.Context, company: CompanyArg, json_out: JsonOpt = False, output: OutOpt = None) -> None:
+    """Headcount trends: total employees, historical growth, function breakdown. 2.5 credits."""
+    emit(ctx.obj, fetch(ctx.obj, "/company/headcount-trends", {"company": company}), json_out=json_out, output=output)
+
+
+def traffic(ctx: typer.Context, company: CompanyArg, json_out: JsonOpt = False, output: OutOpt = None) -> None:
+    """Website traffic: engagement, monthly visits, and channel breakdown. 1.5 credits."""
+    emit(ctx.obj, fetch(ctx.obj, "/company/website-traffic", {"company": company}), json_out=json_out, output=output)
+
+
+def jobs(
+    ctx: typer.Context,
+    company: CompanyArg,
+    limit: LimitOpt = 10,
+    offset: OffsetOpt = 0,
+    json_out: JsonOpt = False,
+    output: OutOpt = None,
+) -> None:
+    """Live job posts: title, location, description, comp, level, skills. 3 credits."""
+    emit(ctx.obj, fetch(ctx.obj, "/company/jobs", {"company": company, "limit": limit, "offset": offset}), json_out=json_out, output=output)
+
+
+def posts(
+    ctx: typer.Context,
+    company: CompanyArg,
+    limit: LimitOpt = 10,
+    offset: OffsetOpt = 0,
+    json_out: JsonOpt = False,
+    output: OutOpt = None,
+) -> None:
+    """Company social posts: content, date, paid/repost flags, engagement. 1.5 credits."""
+    emit(ctx.obj, fetch(ctx.obj, "/company/posts", {"company": company, "limit": limit, "offset": offset}), json_out=json_out, output=output)
+
+
+@reviews_app.command("employees")
+def employee_reviews(
+    ctx: typer.Context,
+    company: CompanyArg,
+    limit: Annotated[int, typer.Option("-n", "--limit", min=1, max=100, help="Max reviews to return (max 100).")] = 10,
+    offset: OffsetOpt = 0,
+    json_out: JsonOpt = False,
+    output: OutOpt = None,
+) -> None:
+    """Employee reviews: overall + dimension ratings (Glassdoor et al.). 1.5 credits / 50."""
+    emit(
+        ctx.obj,
+        fetch(ctx.obj, "/company/employee-reviews", {"company": company, "limit": limit, "offset": offset}),
+        json_out=json_out,
+        output=output,
+    )
+
+
+@reviews_app.command("products")
+def product_reviews(
+    ctx: typer.Context,
+    company: CompanyArg,
+    product_id: Annotated[
+        list[str] | None,
+        typer.Option("--product-id", help="Product ID(s) to fetch reviews for (repeatable). Omit to list the catalog."),
+    ] = None,
+    limit: Annotated[int, typer.Option("-n", "--limit", min=0, max=50, help="Max reviews per product (max 50; only with --product-id).")] = 0,
+    offset: OffsetOpt = 0,
+    json_out: JsonOpt = False,
+    output: OutOpt = None,
+) -> None:
+    """Product catalog and per-product reviews (G2 et al.).
+
+    Call once without --product-id to get the catalog + each product's `id`,
+    then again with those ids. 1.5 credits / 50 reviews.
+    """
+    emit(
+        ctx.obj,
+        fetch(
+            ctx.obj,
+            "/company/product-reviews",
+            {"company": company, "products": product_id or None, "limit": limit or None, "offset": offset or None},
+        ),
+        json_out=json_out,
+        output=output,
+    )
+
+
+def register(app: typer.Typer) -> None:
+    app.command("headcount")(headcount)
+    app.command("traffic")(traffic)
+    app.command("jobs")(jobs)
+    app.command("posts")(posts)

akta_pro_cli/commands/auth.py

@@ -0,0 +1,123 @@
+"""`akta-pro login` / `logout` / `whoami` — API-key credential management (v1).
+
+Browser OAuth (`akta-pro login` without a key) is planned for a later version and
+depends on the akta.pro backend exposing a public/native OAuth client; today the
+CLI authenticates with an `x-api-key` minted at https://playground.akta.pro.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import httpx
+import typer
+
+from akta_pro_cli.client import AktaAPIError, AktaClient
+from akta_pro_cli.config import (
+    clear_credentials,
+    credentials_path,
+    save_credentials,
+    stored_api_key,
+)
+from akta_pro_cli.console import err, out
+from akta_pro_cli.runtime import EXIT_AUTH, EXIT_BAD_INPUT, AppContext, resolve_base_url
+
+
+def _validate_key(base_url: str, key: str) -> tuple[bool, str]:
+    """Probe a free endpoint to check the key. Returns (ok, message)."""
+    client = AktaClient(base_url, key)
+    try:
+        client.get("/company/search", params={"query": "akta"})
+        return True, "key is valid"
+    except AktaAPIError as exc:
+        if exc.status_code in (401, 403):
+            return False, f"key rejected ({exc.status_code})"
+        return True, f"could not fully verify (error {exc.status_code}), key stored anyway"
+    except httpx.HTTPError as exc:
+        return True, f"could not reach akta.pro to verify ({exc})"
+    finally:
+        client.close()
+
+
+def login(
+    ctx: typer.Context,
+    api_key: Annotated[
+        str | None,
+        typer.Option("--api-key", help="akta.pro API key (wk_...). Omit to be prompted.", show_default=False),
+    ] = None,
+    base_url: Annotated[
+        str | None,
+        typer.Option("--base-url", help="API base URL to log into (persisted). Defaults to --base-url/env or api.akta.pro.", show_default=False),
+    ] = None,
+) -> None:
+    """Store an akta.pro API key for future commands.
+
+    Get a key at https://playground.akta.pro (sign up → API Keys). Passing only
+    `--base-url` (no `--api-key`) keeps your already-stored key and just changes
+    the endpoint — no re-prompt. To change only the base URL later you can also
+    use `akta-pro config base-url <url>`.
+    """
+    cfg: AppContext = ctx.obj
+    key = (api_key or cfg.api_key or "").strip()
+    if not key:
+        stored = stored_api_key()
+        if base_url is not None and stored:
+            # Only changing the base URL — keep the stored key, don't re-prompt.
+            key = stored
+        else:
+            key = typer.prompt("Paste your akta.pro API key (wk_...)", hide_input=True).strip()
+    if not key:
+        err.print("[red]No key provided.[/]")
+        raise typer.Exit(code=EXIT_BAD_INPUT)
+
+    # Local --base-url wins; else fall back to global flag/env → stored → default.
+    base_url = base_url or resolve_base_url(cfg)
+    ok, message = _validate_key(base_url, key)
+    if not ok:
+        err.print(f"[red]{message}.[/]")
+        raise typer.Exit(code=EXIT_AUTH)
+
+    path = save_credentials({"api_key": key, "base_url": base_url})
+    err.print(f"[green]✓[/] Logged in ({message}) against {base_url}. Stored at {path}")
+
+
+def logout(ctx: typer.Context) -> None:
+    """Remove the stored akta.pro API key."""
+    if clear_credentials():
+        err.print(f"[green]✓[/] Removed stored credentials ({credentials_path()}).")
+    else:
+        err.print("No stored credentials to remove.")
+
+
+def whoami(ctx: typer.Context) -> None:
+    """Show the active API key (masked), its source, and validate it."""
+    cfg: AppContext = ctx.obj
+    if cfg.api_key:
+        source, key = "flag / AKTA_PRO_API_KEY", cfg.api_key
+    else:
+        key = stored_api_key()
+        source = f"stored ({credentials_path()})" if key else None
+
+    if not key:
+        err.print("[yellow]Not logged in.[/] Run [bold]akta-pro login[/] or set AKTA_PRO_API_KEY.")
+        raise typer.Exit(code=EXIT_AUTH)
+
+    base_url = resolve_base_url(cfg)
+    masked = f"{key[:5]}…{key[-4:]}" if len(key) > 12 else "…"
+    out.print(f"API key : [bold]{masked}[/]  (source: {source})")
+    out.print(f"Base URL: {base_url}")
+
+    ok, message = _validate_key(base_url, key)
+    if ok and message == "key is valid":
+        out.print(f"[green]✓ {message}[/]")
+    elif ok:
+        out.print(f"[yellow]{message}[/]")
+    else:
+        out.print(f"[red]✗ {message}[/]")
+        raise typer.Exit(code=EXIT_AUTH)
+
+
+def register(app: typer.Typer) -> None:
+    app.command("login")(login)
+    app.command("logout")(logout)
+    app.command("whoami")(whoami)

akta_pro_cli/commands/company.py

@@ -0,0 +1,184 @@
+"""`akta-pro company` — search, enrichment (Markdown), and concise overview."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Annotated
+
+import typer
+from rich.table import Table
+
+from akta_pro_cli.console import err
+from akta_pro_cli.options import JsonOpt, OutOpt
+from akta_pro_cli.runtime import EXIT_BAD_INPUT, emit, fetch, probe_is_enterprise
+
+app = typer.Typer(no_args_is_help=True, help="Company search, enrichment, and concise overview.")
+
+
+class Section(str, Enum):
+    """Enrichment sections. `funding_detail` / `mna_and_investment` are
+    enterprise-only: selectable, but auto-skipped for non-enterprise callers
+    (the backend 403s the whole request otherwise)."""
+
+    firmographic = "firmographic"
+    business_model = "business_model"
+    company_assessment = "company_assessment"
+    trust_signal = "trust_signal"
+    company_hierarchy = "company_hierarchy"
+    digital_presence = "digital_presence"
+    financial_estimate = "financial_estimate"
+    location = "location"
+    management_profile = "management_profile"
+    product_offering = "product_offering"
+    strategic_signal = "strategic_signal"
+    customer_profile = "customer_profile"
+    industry = "industry"
+    technology = "technology"
+    funding_detail = "funding_detail"
+    mna_and_investment = "mna_and_investment"
+
+
+# Sections the akta.pro backend gates to Enterprise plans (mirrors the MCP tool).
+ENTERPRISE_SECTIONS = {"funding_detail", "mna_and_investment"}
+
+
+def _search_table(result: object) -> Table | None:
+    rows = result.get("data") if isinstance(result, dict) else None
+    if not rows:
+        return None
+    table = Table(title="Company search results")
+    for col in ("Name", "Website", "Category", "Status", "UUID"):
+        table.add_column(col, overflow="fold")
+    for row in rows:
+        table.add_row(
+            str(row.get("name", "")),
+            str(row.get("website", "")),
+            str(row.get("product_category", "")),
+            str(row.get("company_status", "")),
+            str(row.get("uuid", "")),
+        )
+    return table
+
+
+@app.command("search")
+def search(
+    ctx: typer.Context,
+    query: Annotated[str, typer.Argument(help="Company name or website, e.g. 'Canva' or 'canva.com'.")],
+    json_out: JsonOpt = False,
+    output: OutOpt = None,
+) -> None:
+    """Resolve a company by name or website to its akta.pro identifiers (free).
+
+    Run this first — every other company command needs the `uuid` (or website)
+    returned here.
+    """
+    result = fetch(ctx.obj, "/company/search", {"query": query})
+    emit(ctx.obj, result, json_out=json_out, output=output, renderer=_search_table)
+
+
+@app.command("data")
+def data(
+    ctx: typer.Context,
+    company: Annotated[str, typer.Argument(help="Company website or akta.pro UUID.")],
+    sections: Annotated[
+        list[Section] | None,
+        typer.Option("-s", "--section", help="Section(s) to fetch (repeatable). Required — there is no 'all'."),
+    ] = None,
+    markdown: Annotated[
+        bool,
+        typer.Option("-m", "--markdown", help="Return server-rendered Markdown instead of the default JSON."),
+    ] = False,
+    raw: Annotated[
+        bool,
+        typer.Option("--raw", "--json", help="Emit the raw payload unrendered (raw Markdown with --markdown, else plain JSON)."),
+    ] = False,
+    output: OutOpt = None,
+) -> None:
+    """Enrich a company with the chosen sections.
+
+    Returns structured JSON by default (from `/company/enrichment`); pass
+    `--markdown` for the server-rendered Markdown variant
+    (`/company/enrichment/markdown`). Both build — and bill — identical sections.
+
+    Credits per section: firmographic 2, business_model 2, company_assessment 2,
+    trust_signal 0.5, company_hierarchy 0.5, digital_presence 0.5,
+    financial_estimate 0.5, location 0.5, management_profile 1.5,
+    product_offering 2, strategic_signal 1.5, customer_profile 1, industry 1,
+    technology 2, funding_detail 3 (enterprise), mna_and_investment 5 (enterprise).
+
+    The two enterprise-only sections are auto-skipped (not an error) for
+    non-enterprise callers; a note lists any dropped.
+    """
+    if not sections:
+        err.print(
+            "[red]Choose at least one --section.[/] Options: "
+            + ", ".join(s.value for s in Section)
+        )
+        raise typer.Exit(code=EXIT_BAD_INPUT)
+
+    requested = list(dict.fromkeys(s.value for s in sections))  # de-dupe, keep order
+    enterprise_req = [s for s in requested if s in ENTERPRISE_SECTIONS]
+    skipped: list[str] = []
+    if enterprise_req and not probe_is_enterprise(ctx.obj):
+        requested = [s for s in requested if s not in ENTERPRISE_SECTIONS]
+        skipped = enterprise_req
+    if not requested:
+        err.print(
+            f"[yellow]Only enterprise-only section(s) requested ({', '.join(skipped)}); "
+            "your plan doesn't include them.[/] Pick non-enterprise sections or upgrade."
+        )
+        raise typer.Exit(code=EXIT_BAD_INPUT)
+
+    params = {"company": company, "sections": ",".join(requested)}
+
+    # Default: structured JSON from /company/enrichment. Both endpoints bill the
+    # same sections; only the shape differs (JSON object vs server-rendered MD).
+    if not markdown:
+        result = fetch(ctx.obj, "/company/enrichment", params)
+        if skipped and not ctx.obj.quiet:
+            err.print(
+                f"[yellow]Skipped enterprise-only section(s): {', '.join(skipped)} — "
+                "not in your plan.[/]"
+            )
+        emit(ctx.obj, result, json_out=raw, output=output)
+        return
+
+    result = fetch(ctx.obj, "/company/enrichment/markdown", params)
+    # The Markdown endpoint returns a JSON envelope {data: markdown,
+    # sections_included, credits_consumed, …}, or (fallback) raw Markdown text.
+    # Unwrap to the body, then append credits + sections as an in-body footer
+    # so the info survives rendering, --raw, piping, and -o.
+    envelope = result if isinstance(result, dict) else {}
+    body = envelope.get("data", result) if envelope else result
+    if not isinstance(body, str):
+        body = str(body)
+
+    if skipped:
+        body = (
+            f"> _Skipped enterprise-only section(s): {', '.join(skipped)} — "
+            "not in your plan._\n\n" + body
+        )
+
+    footer_parts: list[str] = []
+    included = envelope.get("sections_included")
+    if included:
+        footer_parts.append(f"Sections included: {', '.join(included)}")
+    credits = envelope.get("credits_consumed")
+    if credits is not None:
+        footer_parts.append(f"Credits consumed: {credits}")
+    if footer_parts:
+        body = f"{body.rstrip()}\n\n---\n_{' · '.join(footer_parts)}_\n"
+
+    emit(ctx.obj, body, json_out=raw, output=output, markdown=True)
+
+
+@app.command("concise")
+def concise(
+    ctx: typer.Context,
+    company: Annotated[str, typer.Argument(help="Company website or akta.pro UUID.")],
+    json_out: JsonOpt = False,
+    output: OutOpt = None,
+) -> None:
+    """Condensed company overview — slimmed JSON with the fluff redacted."""
+    result = fetch(ctx.obj, "/company/enrichment/concise", {"company": company})
+    emit(ctx.obj, result, json_out=json_out, output=output)