makea-cli 0.2.10__tar.gz → 0.2.12__tar.gz

{makea_cli-0.2.10 → makea_cli-0.2.12}/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 0.2.12
+
+Fixes from a live exam of Beeboo (2026-10-10):
+
+- `designer list supplier-link --product <id>` without `--link-type` now reads
+  SAMPLING and PRODUCTION quotes (the backend defaults to sampling, so a
+  confirmed production quote never showed). Each link carries its
+  `link_type`, and a new `quotes` list gives every quote's factory, type,
+  whether it is the awarded production quote, and its bulk tiers with the
+  quantities they cover; a sampling quote's tiers are marked indicative.
+- `designer list production-order`: each order has `this_order`, its own
+  units by colour and size and the colours it does not include. A restock's
+  `items[].quantity` is the run it was raised from, not its own.
+- `designer list note` / `designer search note`: a factory's message names its
+  factory inline (`[Dongguan Heritage, factory] ...`).
+- `designer get tna --product <id>` keeps one product's orders.
+- `designer get costing --product <id>` finds the product's card itself
+  (`--style` still works).
+- `designer get product`, `get lifecycle`, `get tech-pack`,
+  `get tech-pack-history` take the id as the argument or as `--product`.
+- `designer get tech-pack --readable`: section, field label and value, and
+  what is still blank (needs the backend's `view=readable`).
+
+## 0.2.11
+
+- Order reads for a factory (and its Beeboo):
+  - `supplier get order <rfq> [--readable]`: the sample and bulk orders on one
+    RFQ; `--readable` gives each order's state, dates, quantity and what has
+    been paid, with no ids or product payload.
+  - `supplier list milestone --production-order <id>`: the bulk order's
+    milestones, which came back and why, and the proof review's view.
+  - `supplier get payment-summary <rfq>`: whether the buyer has paid the
+    sample, deposit and balance, and the factory's own price on each PO.
+  - `supplier list purchase-order`, `supplier list order-note`.
+- `supplier list production-order` now requires `--rfq` (the backend always
+  did; without it the command failed).
+
 ## 0.2.10
 
 - PM reads for a brand (and Beeboo working for one):

{makea_cli-0.2.10 → makea_cli-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: makea-cli
-Version: 0.2.10
+Version: 0.2.12
 Summary: Makea admin CLI (browser login + Makea admin HTTP API)
 Requires-Python: >=3.10
 Requires-Dist: click<9,>=8.1

makea_cli-0.2.12/makea_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.12"

{makea_cli-0.2.10 → makea_cli-0.2.12}/makea_cli/api_client.py

@@ -15,7 +15,7 @@ from dataclasses import dataclass
 from makea_cli import broker
 from makea_cli.auth_pkce import ensure_fresh_id_token
 from makea_cli.config import api_base_url
-from makea_cli.errors import ApiError, AuthError, UnknownOutcomeError
+from makea_cli.errors import ApiError, AuthError, MakeaCliError, UnknownOutcomeError
 
 
 @dataclass
@@ -1062,6 +1062,43 @@ def supplier_list_production_orders(*, quote_request_id: str | None = None) -> A
     return get_json("/supplier/production_orders", params=params)
 
 
+def supplier_get_orders(quote_request_id: str, *, readable: bool = False) -> Any:
+    """GET /supplier/quote_requests/{id}/orders_view — the sample and bulk orders
+    on one RFQ. ``readable``: each order's state, dates and what was paid, with
+    no ids or product payload (the full view runs past 100KB)."""
+    params = {"view": "readable"} if readable else None
+    return get_json(f"/supplier/quote_requests/{quote_request_id}/orders_view", params=params)
+
+
+def supplier_list_milestones(production_order_id: str) -> Any:
+    """GET /supplier/production_orders/{id}/progress?view=readable — each step's
+    milestones, which one came back and why, and the proof review's view."""
+    return get_json(
+        f"/supplier/production_orders/{production_order_id}/progress",
+        params={"view": "readable"},
+    )
+
+
+def supplier_get_payment_summary(quote_request_id: str) -> Any:
+    """GET /supplier/quote_requests/{id}/payment_summary — whether the buyer has
+    paid each stage, and the factory's own price on its purchase orders."""
+    return get_json(f"/supplier/quote_requests/{quote_request_id}/payment_summary")
+
+
+def supplier_list_purchase_orders() -> Any:
+    """GET /supplier/purchase-orders — purchase orders raised to this factory."""
+    return get_json("/supplier/purchase-orders")
+
+
+def supplier_list_order_notes(
+    *, production_order_id: str | None = None, sampling_order_id: str | None = None
+) -> Any:
+    """GET /supplier/{production|sampling}_orders/{id}/notes — an order's notes."""
+    if production_order_id:
+        return get_json(f"/supplier/production_orders/{production_order_id}/notes")
+    return get_json(f"/supplier/sampling_orders/{sampling_order_id}/notes")
+
+
 def supplier_list_actions() -> Any:
     """GET /supplier/actions — what the platform is waiting on this factory for."""
     return get_json("/supplier/actions")
@@ -1102,9 +1139,13 @@ def designer_list_products() -> Any:
     return get_json("/designer/get_all_products")
 
 
-def designer_get_tech_spec(product_id: str) -> Any:
-    """GET /designer/products/{id}/technical-specifications — the tech pack."""
-    return get_json(f"/designer/products/{product_id}/technical-specifications")
+def designer_get_tech_spec(product_id: str, *, readable: bool = False) -> Any:
+    """GET /designer/products/{id}/technical-specifications — the tech pack.
+
+    ``readable`` asks for ``view=readable``: section, field label, value and the
+    essentials still blank, a tenth of the raw payload."""
+    params = {"view": "readable"} if readable else None
+    return get_json(f"/designer/products/{product_id}/technical-specifications", params=params)
 
 
 def designer_get_spec_history(product_id: str) -> Any:
@@ -1112,12 +1153,94 @@ def designer_get_spec_history(product_id: str) -> Any:
     return get_json(f"/designer/products/{product_id}/specification-change-history")
 
 
+QUOTES_HOW_TO_READ = (
+    "Each quote is SAMPLING or PRODUCTION. A SAMPLING quote's bulk tiers are "
+    "indicative (priced before the sample). The bulk price is the PRODUCTION "
+    "quote's, the awarded one (awarded: true) first, at the tier covering the "
+    "order's quantity. `designer get costing --product <id>` is the server's "
+    "unit cost."
+)
+
+
+def _tier_lines(link: dict[str, Any]) -> list[str]:
+    """Each bulk tier with the quantities it covers: "301-500 pcs: EUR 71.11"."""
+    tiers: list[Any] = []
+    for group in link.get("pricing_groups") or []:
+        if isinstance(group, dict):
+            tiers += group.get("price_tiers") or []
+    tiers = tiers or link.get("production_price_tiers") or []
+    out = []
+    for tier in tiers:
+        if not isinstance(tier, dict) or tier.get("unit_price") in (None, ""):
+            continue
+        lo = tier.get("min_qty") or 1
+        hi = tier.get("max_qty")
+        span = f"{lo}-{hi}" if hi not in (None, "", 0, "0") else f"{lo}+"
+        currency = tier.get("currency") or link.get("currency") or ""
+        out.append(f"{span} pcs: {currency} {tier.get('unit_price')}".replace("  ", " "))
+    return out
+
+
+def _quote_summary(link: dict[str, Any]) -> dict[str, Any]:
+    """One quote in a line or two: whose, which kind, what it costs at which quantity."""
+    kind = str(link.get("link_type") or "SAMPLING").upper()
+    info = link.get("supplier_info") if isinstance(link.get("supplier_info"), dict) else {}
+    sample = link.get("sampling_price")
+    if isinstance(sample, dict) and sample.get("value") not in (None, ""):
+        sample = (
+            f"{sample.get('currency') or link.get('currency') or ''} {sample.get('value')}".strip()
+        )
+    return {
+        "factory": link.get("supplier_name") or info.get("supplier_name") or info.get("name"),
+        "link_id": link.get("link_id"),
+        "type": kind,
+        "awarded": bool(link.get("is_awarded")),
+        "confirmed_at": link.get("confirmed_at"),
+        "bulk_price": (
+            "the bulk price"
+            if kind == "PRODUCTION"
+            else "indicative only, priced before the sample"
+        ),
+        "bulk_tiers": _tier_lines(link),
+        "sample_price": sample if kind == "SAMPLING" else None,
+        "moq": link.get("moq"),
+        "lead_time": link.get("lead_time"),
+        "sample_lead_time": link.get("sample_lead_time") if kind == "SAMPLING" else None,
+        "incoterm": link.get("production_price_incoterm"),
+    }
+
+
 def designer_list_links(product_id: str, *, link_type: str | None = None) -> Any:
-    """GET /designer/product/linked_suppliers — the suppliers quoted onto one product."""
-    params: dict[str, Any] = {"product_id": product_id}
-    if link_type:
-        params["link_type"] = link_type
-    return get_json("/designer/product/linked_suppliers", params=params)
+    """GET /designer/product/linked_suppliers — the quotes on one product.
+
+    The backend answers one link type per call and defaults to SAMPLING, so
+    "omit for both" meant sampling only: a factory's confirmed PRODUCTION
+    quote never showed, and its sampling quote's indicative tiers were read as
+    the bulk price. Without ``link_type`` both are read. Each link says which
+    kind it is, and ``quotes`` puts every quote's tiers with their quantities
+    first."""
+    links: list[dict[str, Any]] = []
+    for kind in [link_type.upper()] if link_type else ["PRODUCTION", "SAMPLING"]:
+        raw = get_json(
+            "/designer/product/linked_suppliers",
+            params={"product_id": product_id, "link_type": kind},
+        )
+        rows = raw.get("supplier_links") if isinstance(raw, dict) else raw
+        for link in rows or []:
+            if isinstance(link, dict):
+                link.setdefault("link_type", kind)
+                links.append(link)
+    quotes = [_quote_summary(link) for link in links]
+    # The awarded production quote first, then other production quotes.
+    quotes.sort(key=lambda q: (q["type"] != "PRODUCTION", not q["awarded"]))
+    return {
+        "success": True,
+        "product_id": product_id,
+        "how_to_read": QUOTES_HOW_TO_READ,
+        "quotes": quotes,
+        "supplier_links": links,
+        "count": len(links),
+    }
 
 
 def designer_list_channels(product_id: str) -> Any:
@@ -1130,7 +1253,11 @@ def designer_search_channel(product_id: str, query: str, *, key: str | None = No
     params: dict[str, Any] = {"q": query}
     if key:
         params["key"] = key
-    return get_json(f"/designer/products/{product_id}/channel_search", params=params)
+    raw = get_json(f"/designer/products/{product_id}/channel_search", params=params)
+    for hit in (raw.get("hits") if isinstance(raw, dict) else None) or []:
+        if isinstance(hit, dict):
+            hit["excerpt"] = _said_by(hit, hit.get("excerpt"))
+    return raw
 
 
 def designer_list_sampling_orders(
@@ -1143,14 +1270,68 @@ def designer_list_sampling_orders(
     return get_json("/designer/sampling_orders/user", params=params)
 
 
+def _this_order(order: dict[str, Any]) -> dict[str, Any]:
+    """What this one order is for: its own colour x size quantities, read off
+    its cart. ``items[].quantity`` on a restock is copied from the run it was
+    raised from and is not this order's quantity; the colours it could take
+    (``available_colors``) are not the colours it has. Facts about one order
+    never describe another (exam 2026-10-10: a 340-unit run's two-colour split
+    was given to a one-colour 120-unit order)."""
+    names = {}
+    for colour in order.get("available_colors") or []:
+        if isinstance(colour, dict) and colour.get("hex_code"):
+            names[str(colour["hex_code"]).upper()] = colour.get("color_name") or colour["hex_code"]
+    by_colour: dict[str, dict[str, int]] = {}
+    total = 0
+    for key, qty in (order.get("cart_items") or {}).items():
+        try:
+            n = int(float(qty or 0))
+        except (TypeError, ValueError):
+            continue
+        if n <= 0:
+            continue
+        size, _, hex_code = str(key).partition(",")
+        colour = names.get(hex_code.strip().upper(), hex_code.strip() or "one colour")
+        by_colour.setdefault(colour, {})[size.strip() or "one size"] = n
+        total += n
+    status = str(order.get("status") or "")
+    kind = str(order.get("order_type") or "PRODUCTION")
+    if not total:
+        return {
+            "units": None,
+            "colours": [],
+            "matrix": {},
+            "summary": f"{kind.title()} order ({status}): no quantities set on this order.",
+        }
+    cells = "; ".join(
+        f"{colour} " + ", ".join(f"{size} {n}" for size, n in sizes.items())
+        for colour, sizes in by_colour.items()
+    )
+    not_ordered = [n for n in names.values() if n not in by_colour]
+    summary = (
+        f"{kind.title()} order ({status}): {total} units, {len(by_colour)} colour(s): {cells}."
+    )
+    if not_ordered:
+        summary += f" Not in this order: {', '.join(not_ordered)}."
+    return {"units": total, "colours": list(by_colour), "matrix": by_colour, "summary": summary}
+
+
 def designer_list_production_orders(
     *, product_order_id: str | None = None, status: str | None = None
 ) -> Any:
-    """GET /designer/production_orders (or the per-product list) — the caller's production orders."""
+    """GET /designer/production_orders (or the per-product list) — the caller's
+    production orders, each with ``this_order``: its own quantities by colour and
+    size, said plainly."""
     if product_order_id:
-        return get_json(f"/designer/product_orders/{product_order_id}/production_orders")
-    params = {"status": status} if status else None
-    return get_json("/designer/production_orders", params=params)
+        raw = get_json(f"/designer/product_orders/{product_order_id}/production_orders")
+    else:
+        params = {"status": status} if status else None
+        raw = get_json("/designer/production_orders", params=params)
+    orders = raw.get("production_orders") if isinstance(raw, dict) else raw
+    for order in orders if isinstance(orders, list) else []:
+        if isinstance(order, dict):
+            order["this_order"] = _this_order(order)
+    return raw
 
 
 def designer_list_shipping_orders() -> Any:
@@ -1359,10 +1540,32 @@ def supplier_list_quote_edit_requests(quote_request_id: str) -> Any:
     return get_json(f"/supplier/quote_requests/{quote_request_id}/quote_edit_requests")
 
 
-def designer_get_tna() -> Any:
+def designer_get_tna(product_id: str | None = None) -> Any:
     """GET /designer/tna_calendar — every pack's five steps and arrival, with
-    the launch it is measured against when the arrival is confirmed."""
-    return get_json("/designer/tna_calendar")
+    the launch it is measured against when the arrival is confirmed.
+
+    ``product_id`` keeps that product's rows only (the calendar is account-wide)."""
+    raw = get_json("/designer/tna_calendar")
+    if not product_id or not isinstance(raw, dict):
+        return raw
+    groups = []
+    for group in raw.get("groups") or []:
+        if not isinstance(group, dict):
+            continue
+        rows = [
+            {k: v for k, v in row.items() if k != "image_url"}
+            for row in group.get("rows") or []
+            if isinstance(row, dict) and row.get("product_id") == product_id
+        ]
+        if rows:
+            groups.append({**group, "rows": rows})
+    return {
+        "success": raw.get("success", True),
+        "today": raw.get("today"),
+        "rules": raw.get("rules"),
+        "product_id": product_id,
+        "groups": groups,
+    }
 
 
 def designer_list_milestones(product_id: str) -> Any:
@@ -1420,36 +1623,55 @@ def designer_list_notes(
                 "at": n.get("created_at"),
                 "from": n.get("created_by_type"),
                 "supplier": n.get("supplier_name"),
-                "text": n.get("content"),
+                "text": _said_by(n, n.get("content")),
                 "replies": len(n.get("replies") or []),
             }
         )
     return {"product_id": product_id, "channel": channel_key, "notes": out}
 
 
+def _said_by(note: dict[str, Any], text: Any) -> Any:
+    """A factory's words with the factory named inline: "[Dongguan Heritage,
+    factory] ...". The role alone let one factory's line be read as another's."""
+    role = str(note.get("created_by_type") or note.get("actor_role") or "").lower()
+    if role not in ("supplier", "factory") or not isinstance(text, str):
+        return text
+    name = str(note.get("supplier_name") or "").strip()
+    return f"[{name}, factory] {text}" if name else f"[factory] {text}"
+
+
 def designer_list_fit_rounds(product_id: str) -> Any:
     """GET /designer/products/{id}/fit_rounds — every fit round on the pack and
     the corrections carried into bulk."""
     return get_json(f"/designer/products/{product_id}/fit_rounds")
 
 
-def designer_get_costing(style_id: str) -> Any:
+def designer_get_costing(style_id: str | None = None, *, product_id: str | None = None) -> Any:
     """One unit of each pack on a product card: factory price, fees, the
-    brand's freight and duty estimates, target, RRP, margin."""
+    brand's freight and duty estimates, target, RRP, margin.
+
+    ``product_id`` finds the product's card itself and keeps that pack."""
+    if not style_id and product_id:
+        product = designer_get_product(product_id, show_details=False)
+        row = product.get("product") if isinstance(product, dict) else None
+        style_id = (row or {}).get("style_id")
+        if not style_id:
+            raise MakeaCliError(f"Product {product_id} is not on a product card (no style_id).")
+    if not style_id:
+        raise MakeaCliError("Pass --product <product id> or --style <style id>.")
     raw = get_json(f"/designer/styles/{style_id}/overview")
-    packs = raw.get("packs") if isinstance(raw, dict) else []
-    return {
-        "style_id": style_id,
-        "packs": [
-            {
-                "product_id": p.get("product_id"),
-                "pack": p.get("pack_label"),
-                "costing": p.get("costing"),
-            }
-            for p in packs or []
-            if isinstance(p, dict)
-        ],
-    }
+    packs = [
+        {
+            "product_id": p.get("product_id"),
+            "pack": p.get("pack_label"),
+            "costing": p.get("costing"),
+        }
+        for p in (raw.get("packs") if isinstance(raw, dict) else None) or []
+        if isinstance(p, dict)
+    ]
+    if product_id:
+        packs = [p for p in packs if p["product_id"] == product_id] or packs
+    return {"style_id": style_id, "packs": packs}
 
 
 def designer_list_actions(*, product_id: str | None = None) -> Any:

{makea_cli-0.2.10 → makea_cli-0.2.12}/makea_cli/commands/brand/cmd.py

@@ -39,6 +39,20 @@ def _json_object(raw: str | None, path: Path | None, what: str) -> dict[str, Any
     return data
 
 
+def _product_id(argument: str | None, option: str | None) -> str:
+    """A product id given either way: ``get product <id>`` or ``--product <id>``."""
+    if argument and option and argument != option:
+        raise typer.BadParameter("give the product id once, as the argument or as --product")
+    value = argument or option
+    if not value:
+        raise typer.BadParameter("pass the product id (as the argument or as --product)")
+    return value
+
+
+_PRODUCT_ARG_HELP = "Product id (or pass --product)."
+_PRODUCT_OPT_HELP = "Same as the argument."
+
+
 def register(app: typer.Typer) -> None:
     # --- reads ------------------------------------------------------------------
 
@@ -63,14 +77,18 @@ def register(app: typer.Typer) -> None:
         help="GET /designer/get_product — one product: status, documents, prices, links.",
     )
     def get_product(
-        product_id: str = typer.Argument(..., help="Product id (== product order reference id)."),
+        product_id: str | None = typer.Argument(
+            None, help="Product id (== product order reference id); or pass --product."
+        ),
+        product: str | None = typer.Option(None, "--product", "-p", help=_PRODUCT_OPT_HELP),
         summary: bool = typer.Option(
             False, "--summary", help="Ask the backend for the short form (show_details=false)."
         ),
     ) -> None:
         """Read one product."""
+        pid = _product_id(product_id, product)
         print_json_or_exit(
-            console, lambda: api_client.designer_get_product(product_id, show_details=not summary)
+            console, lambda: api_client.designer_get_product(pid, show_details=not summary)
         )
 
     @command(
@@ -79,13 +97,23 @@ def register(app: typer.Typer) -> None:
         "get",
         "tech-pack",
         api="GET /designer/products/{product_id}/technical-specifications",
-        help="GET /designer/products/{id}/technical-specifications — the product's tech pack.",
+        help=(
+            "GET /designer/products/{id}/technical-specifications — the product's tech pack; "
+            "--readable gives section, field and value only (a tenth of the size)."
+        ),
     )
     def get_tech_pack(
-        product_id: str = typer.Argument(..., help="Product id."),
+        product_id: str | None = typer.Argument(None, help=_PRODUCT_ARG_HELP),
+        product: str | None = typer.Option(None, "--product", "-p", help=_PRODUCT_OPT_HELP),
+        readable: bool = typer.Option(
+            False, "--readable", help="Section, field label and value; what is still blank."
+        ),
     ) -> None:
         """Read a product's technical specification."""
-        print_json_or_exit(console, lambda: api_client.designer_get_tech_spec(product_id))
+        pid = _product_id(product_id, product)
+        print_json_or_exit(
+            console, lambda: api_client.designer_get_tech_spec(pid, readable=readable)
+        )
 
     @command(
         app,
@@ -99,10 +127,12 @@ def register(app: typer.Typer) -> None:
         ),
     )
     def get_tech_pack_history(
-        product_id: str = typer.Argument(..., help="Product id."),
+        product_id: str | None = typer.Argument(None, help=_PRODUCT_ARG_HELP),
+        product: str | None = typer.Option(None, "--product", "-p", help=_PRODUCT_OPT_HELP),
     ) -> None:
         """Read a product's specification change history."""
-        print_json_or_exit(console, lambda: api_client.designer_get_spec_history(product_id))
+        pid = _product_id(product_id, product)
+        print_json_or_exit(console, lambda: api_client.designer_get_spec_history(pid))
 
     @command(
         app,
@@ -111,8 +141,9 @@ def register(app: typer.Typer) -> None:
         "supplier-link",
         api="GET /designer/product/linked_suppliers",
         help=(
-            "GET /designer/product/linked_suppliers — the suppliers linked to one product, "
-            "with their quotes."
+            "GET /designer/product/linked_suppliers — the quotes on one product, SAMPLING and "
+            "PRODUCTION, each labelled; `quotes` lists every quote's bulk tiers with their "
+            "quantities, the awarded production quote first."
         ),
     )
     def list_links(
@@ -156,8 +187,9 @@ def register(app: typer.Typer) -> None:
         "production-order",
         api="GET /designer/production_orders",
         help=(
-            "GET /designer/production_orders — your 大货 orders; --product narrows to one "
-            "product (GET /designer/product_orders/{id}/production_orders)."
+            "GET /designer/production_orders — your 大货 orders, each with `this_order`: its "
+            "own units by colour and size; --product narrows to one product "
+            "(GET /designer/product_orders/{id}/production_orders)."
         ),
     )
     def list_production_orders(
@@ -193,10 +225,14 @@ def register(app: typer.Typer) -> None:
         help="GET /designer/product_orders/{id}/lifecycle — which stage this product is in.",
     )
     def get_lifecycle(
-        product_order_id: str = typer.Argument(..., help="Product order id."),
+        product_order_id: str | None = typer.Argument(
+            None, help="Product (order) id; or pass --product."
+        ),
+        product: str | None = typer.Option(None, "--product", "-p", help=_PRODUCT_OPT_HELP),
     ) -> None:
         """Read a product's lifecycle state."""
-        print_json_or_exit(console, lambda: api_client.designer_get_lifecycle(product_order_id))
+        pid = _product_id(product_order_id, product)
+        print_json_or_exit(console, lambda: api_client.designer_get_lifecycle(pid))
 
     @command(
         app,
@@ -220,12 +256,17 @@ def register(app: typer.Typer) -> None:
         api="GET /designer/tna_calendar",
         help=(
             "GET /designer/tna_calendar — when each pack arrives and how sure that is "
-            "(done / confirmed / estimated), with its launch day."
+            "(done / confirmed / estimated), with its launch day; --product keeps one "
+            "product's orders."
         ),
     )
-    def get_tna() -> None:
+    def get_tna(
+        product: str | None = typer.Option(
+            None, "--product", "-p", help="Only this product's orders."
+        ),
+    ) -> None:
         """The Time & Action calendar."""
-        print_json_or_exit(console, lambda: api_client.designer_get_tna())
+        print_json_or_exit(console, lambda: api_client.designer_get_tna(product))
 
     @command(
         app,
@@ -291,15 +332,21 @@ def register(app: typer.Typer) -> None:
         "costing",
         api="GET /designer/styles/{style_id}/overview",
         help=(
-            "GET /designer/styles/{id}/overview — what one unit of each pack costs and "
-            "the margin at RRP (freight and duty are the brand's estimates)."
+            "GET /designer/styles/{id}/overview — what one unit of a pack costs and the "
+            "margin at RRP (freight and duty are the brand's estimates). Pass --product "
+            "(the product's own card is found) or --style."
         ),
     )
     def get_costing(
-        style: str = typer.Option(..., "--style", "-s", help="Product card (style) id."),
+        product: str | None = typer.Option(None, "--product", "-p", help="Product id."),
+        style: str | None = typer.Option(None, "--style", "-s", help="Product card (style) id."),
     ) -> None:
         """A product card's unit cost and margin."""
-        print_json_or_exit(console, lambda: api_client.designer_get_costing(style))
+        if not product and not style:
+            raise typer.BadParameter("pass --product <product id> or --style <style id>")
+        print_json_or_exit(
+            console, lambda: api_client.designer_get_costing(style, product_id=product)
+        )
 
     @command(
         app,