bookai-cli 0.2.0__tar.gz → 0.5.0__tar.gz

{bookai_cli-0.2.0 → bookai_cli-0.5.0}/.gitignore

@@ -9,6 +9,10 @@ __pycache__/
 *.egg-info/
 /cli/dist/
 /cli/build/
+/dist/
 data/
+# committed eval fixtures, not local dev data
+!tests/data/
 .coverage
 /coverage.json
+/.eval_results/

{bookai_cli-0.2.0 → bookai_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bookai-cli
-Version: 0.2.0
+Version: 0.5.0
 Summary: Command-line client for the bookai group-sales back office API
 Requires-Python: >=3.9
 Requires-Dist: click<9,>=8
@@ -15,8 +15,8 @@ Description-Content-Type: text/markdown
 # bookai-cli
 
 Command-line client for the bookai group-sales back office API — manage venue
-pricing and view confirmed orders from the terminal or a script, instead of
-clicking through the admin web app.
+pricing, offerings and their showings, and view confirmed orders from the
+terminal or a script, instead of clicking through the admin web app.
 
 This is a thin HTTP client: it talks only to the public, authenticated JSON
 API and contains no business logic or backend code.
@@ -131,10 +131,51 @@ bookai pricing set <venue_id> --min-group 10 --max-group 50 --min-price 20 --max
 bookai pricing update <venue_id> <rule_id> --min-group 10 --max-group 50 --min-price 18 --max-price 28
 bookai pricing delete <venue_id> <rule_id>
 
+bookai offerings list
+bookai offerings show <offering_id>
+bookai offerings extend <offering_id> --to 2027-03-31    # run it for longer
+bookai offerings extend <offering_id> --by 3m            # ...or just push the end date out
+
+bookai offerings slots list <offering_id>
+bookai offerings slots add <offering_id> --date 2026-11-19 --time 19:00 --capacity 400
+bookai offerings slots add <offering_id> --date 2026-11-19 --time 19:00 --capacity 400 \
+    --duration 4 --repeat-weekly 3                       # lay out a four-week run in one go
+bookai offerings slots set <offering_id> <slot_id> --time 14:00    # move it, keeping its length
+bookai offerings slots set <offering_id> <slot_id> --capacity 250
+bookai offerings slots rm <offering_id> <slot_id>
+
 bookai orders list
 bookai orders list --page 2
+
+bookai search acme                                    # every record at your venue: guests, deals, setup
+bookai search where do coaches park                   # matches meaning, not just exact words
+bookai search jane@school.org --type offer --type quote
+bookai --json search "school trip" --limit 5          # the API's response, for scripts
 ```
 
+### Showings
+
+`offerings slots` manages the individual showings of a timed offering — the
+dates and times people actually book. `--repeat-weekly` is there because a
+season is usually a repeating shape rather than a list of one-off dates:
+`--repeat-weekly 3` creates the showing plus three weekly copies, four in
+total.
+
+The API keeps you from doing the things that would quietly break bookings, and
+the CLI reports its reason rather than swallowing it:
+
+- a showing with seats already sold can't be removed, and its capacity can't
+  drop below what's sold
+- a showing outside the offering's run is refused, rather than sitting on the
+  calendar looking bookable — extend the run first
+- narrowing a run past showings that already exist is refused for the same
+  reason: they'd stay on the calendar while quietly dropping out of
+  availability
+
+`offerings extend` is exactly that "extend the run first" step. It's a plain
+update of the offering's end date — `--to` for an exact date, `--by 3m` (also
+`6w`, `30d`) to push it out from wherever it currently ends.
+
 `bookai venues create` is the one command that works with no API key at all —
 it's how a brand-new venue's very first account gets created in the first
 place (same as signing up in the browser). It asks for the venue's details

{bookai_cli-0.2.0 → bookai_cli-0.5.0}/README.md

@@ -1,8 +1,8 @@
 # bookai-cli
 
 Command-line client for the bookai group-sales back office API — manage venue
-pricing and view confirmed orders from the terminal or a script, instead of
-clicking through the admin web app.
+pricing, offerings and their showings, and view confirmed orders from the
+terminal or a script, instead of clicking through the admin web app.
 
 This is a thin HTTP client: it talks only to the public, authenticated JSON
 API and contains no business logic or backend code.
@@ -117,10 +117,51 @@ bookai pricing set <venue_id> --min-group 10 --max-group 50 --min-price 20 --max
 bookai pricing update <venue_id> <rule_id> --min-group 10 --max-group 50 --min-price 18 --max-price 28
 bookai pricing delete <venue_id> <rule_id>
 
+bookai offerings list
+bookai offerings show <offering_id>
+bookai offerings extend <offering_id> --to 2027-03-31    # run it for longer
+bookai offerings extend <offering_id> --by 3m            # ...or just push the end date out
+
+bookai offerings slots list <offering_id>
+bookai offerings slots add <offering_id> --date 2026-11-19 --time 19:00 --capacity 400
+bookai offerings slots add <offering_id> --date 2026-11-19 --time 19:00 --capacity 400 \
+    --duration 4 --repeat-weekly 3                       # lay out a four-week run in one go
+bookai offerings slots set <offering_id> <slot_id> --time 14:00    # move it, keeping its length
+bookai offerings slots set <offering_id> <slot_id> --capacity 250
+bookai offerings slots rm <offering_id> <slot_id>
+
 bookai orders list
 bookai orders list --page 2
+
+bookai search acme                                    # every record at your venue: guests, deals, setup
+bookai search where do coaches park                   # matches meaning, not just exact words
+bookai search jane@school.org --type offer --type quote
+bookai --json search "school trip" --limit 5          # the API's response, for scripts
 ```
 
+### Showings
+
+`offerings slots` manages the individual showings of a timed offering — the
+dates and times people actually book. `--repeat-weekly` is there because a
+season is usually a repeating shape rather than a list of one-off dates:
+`--repeat-weekly 3` creates the showing plus three weekly copies, four in
+total.
+
+The API keeps you from doing the things that would quietly break bookings, and
+the CLI reports its reason rather than swallowing it:
+
+- a showing with seats already sold can't be removed, and its capacity can't
+  drop below what's sold
+- a showing outside the offering's run is refused, rather than sitting on the
+  calendar looking bookable — extend the run first
+- narrowing a run past showings that already exist is refused for the same
+  reason: they'd stay on the calendar while quietly dropping out of
+  availability
+
+`offerings extend` is exactly that "extend the run first" step. It's a plain
+update of the offering's end date — `--to` for an exact date, `--by 3m` (also
+`6w`, `30d`) to push it out from wherever it currently ends.
+
 `bookai venues create` is the one command that works with no API key at all —
 it's how a brand-new venue's very first account gets created in the first
 place (same as signing up in the browser). It asks for the venue's details

{bookai_cli-0.2.0 → bookai_cli-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bookai-cli"
-version = "0.2.0"
+dynamic = ["version"]
 description = "Command-line client for the bookai group-sales back office API"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -24,5 +24,11 @@ dev = [
 [project.scripts]
 bookai = "groupsales_cli.__main__:cli"
 
+# Single source of truth for the version: `bookai --version` reads
+# groupsales_cli.__version__, and this reads the same line, so the two cannot drift
+# apart again (they did: pyproject said 0.3.0 while the CLI reported 0.2.0).
+[tool.hatch.version]
+path = "src/groupsales_cli/__init__.py"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/groupsales_cli"]

bookai_cli-0.5.0/src/groupsales_cli/__init__.py

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

{bookai_cli-0.2.0 → bookai_cli-0.5.0}/src/groupsales_cli/__main__.py

@@ -7,7 +7,9 @@ from groupsales_cli.client import DEFAULT_BASE_URL, ENV_URLS
 from groupsales_cli.commands.auth import login, logout, whoami
 from groupsales_cli.commands.contacts import contacts
 from groupsales_cli.commands.orders import orders
+from groupsales_cli.commands.offerings import offerings
 from groupsales_cli.commands.pricing import pricing
+from groupsales_cli.commands.search import search
 from groupsales_cli.commands.venues import venues
 
 
@@ -62,8 +64,10 @@ cli.add_command(logout)
 cli.add_command(whoami)
 cli.add_command(venues)
 cli.add_command(contacts)
+cli.add_command(offerings)
 cli.add_command(pricing)
 cli.add_command(orders)
+cli.add_command(search)
 
 
 if __name__ == "__main__":

{bookai_cli-0.2.0 → bookai_cli-0.5.0}/src/groupsales_cli/client.py

@@ -59,6 +59,9 @@ class Client:
     def put(self, path: str, json: dict):
         return self.request("PUT", path, json=json)
 
+    def patch(self, path: str, json: dict):
+        return self.request("PATCH", path, json=json)
+
     def delete(self, path: str):
         return self.request("DELETE", path)
 

bookai_cli-0.5.0/src/groupsales_cli/commands/offerings.py

@@ -0,0 +1,211 @@
+"""Offerings and their showings.
+
+Thin wrappers over /admin/offerings — every rule (what a valid run is, whether a showing
+can be removed, whether it falls inside the sellable window) lives in the API, so the CLI
+and the back office can't disagree about it.
+
+`extend` is the one place the CLI is deliberately friendlier than the endpoint it calls:
+extending a run is just `valid_to` changing, so it PATCHes the offering like anything else,
+but "extend" is how people say it and `--by 3m` is how they think about it.
+"""
+
+from datetime import date, datetime, timedelta
+
+import click
+
+from groupsales_cli.client import build_client
+from groupsales_cli.output import render
+
+_OFFERING_COLUMNS = ["id", "name", "category", "admission_type", "status",
+                     "valid_from", "valid_to", "base_price_per_person"]
+_SLOT_COLUMNS = ["id", "start_datetime", "end_datetime", "capacity", "sold", "available"]
+
+
+def _parse_day(value: str) -> date:
+    try:
+        return date.fromisoformat(value)
+    except ValueError:
+        raise click.BadParameter(f"{value!r} is not a date — use YYYY-MM-DD")
+
+
+def _shift(day: date, by: str) -> date:
+    """"3m", "6w", "30d" from a date. Months are 30 days here, deliberately: the exact
+    landing date matters less than saying "about three months", and a caller who needs an
+    exact day passes --to instead."""
+    amount, unit = by[:-1], by[-1:].lower()
+    if not amount.isdigit() or unit not in {"d", "w", "m"}:
+        raise click.BadParameter(f"{by!r} should look like 30d, 6w or 3m")
+    days = {"d": 1, "w": 7, "m": 30}[unit] * int(amount)
+    return day + timedelta(days=days)
+
+
+@click.group()
+def offerings():
+    """Manage offerings and their showings."""
+
+
+@offerings.command("list")
+@click.pass_context
+def list_offerings(ctx: click.Context):
+    """List this venue's offerings."""
+    client = build_client(ctx)
+    data = client.get("/admin/offerings")
+    render([d["offering"] for d in data], ctx.obj["json"],
+           title="Offerings", columns=_OFFERING_COLUMNS)
+
+
+@offerings.command("show")
+@click.argument("offering_id")
+@click.pass_context
+def show_offering(ctx: click.Context, offering_id: str):
+    """Show one offering, with its showings and pricing tiers."""
+    client = build_client(ctx)
+    data = client.get(f"/admin/offerings/{offering_id}")
+    render(data["offering"], ctx.obj["json"], columns=_OFFERING_COLUMNS)
+    if not ctx.obj["json"]:
+        render(data.get("slots", []), False, title="Showings", columns=_SLOT_COLUMNS)
+
+
+@offerings.command("extend")
+@click.argument("offering_id")
+@click.option("--to", "to_date", default=None, help="New end date, YYYY-MM-DD.")
+@click.option("--by", default=None, help="Extend past the current end date, e.g. 3m, 6w, 30d.")
+@click.pass_context
+def extend_offering(ctx: click.Context, offering_id: str, to_date: str | None, by: str | None):
+    """Extend how long an offering runs for.
+
+    Nothing more than setting valid_to, which is why it PATCHes the offering rather than
+    calling some dedicated endpoint — but it's the single most common edit, so it gets a
+    verb. The API refuses to narrow a run past showings that already exist.
+    """
+    if bool(to_date) == bool(by):
+        raise click.UsageError("give exactly one of --to or --by")
+    client = build_client(ctx)
+
+    if to_date:
+        new_end = _parse_day(to_date)
+    else:
+        current = client.get(f"/admin/offerings/{offering_id}")["offering"]["valid_to"]
+        new_end = _shift(_parse_day(current), by)
+
+    data = client.patch(f"/admin/offerings/{offering_id}", json={"valid_to": str(new_end)})
+    if not ctx.obj["json"]:
+        click.echo(f"{data['offering']['name']} now runs until {data['offering']['valid_to']}")
+    render(data["offering"], ctx.obj["json"], columns=_OFFERING_COLUMNS)
+
+
+@offerings.group()
+def slots():
+    """Manage an offering's showings."""
+
+
+@slots.command("list")
+@click.argument("offering_id")
+@click.pass_context
+def list_slots(ctx: click.Context, offering_id: str):
+    """List an offering's showings."""
+    client = build_client(ctx)
+    data = client.get(f"/admin/offerings/{offering_id}/slots")
+    render(data, ctx.obj["json"], title=f"Showings -- {offering_id}", columns=_SLOT_COLUMNS)
+
+
+@slots.command("add")
+@click.argument("offering_id")
+@click.option("--date", "day", required=True, help="Date of the first showing, YYYY-MM-DD.")
+@click.option("--time", "start", required=True, help="Start time, HH:MM (24h).")
+@click.option("--duration", type=float, default=3.0, show_default=True, help="Length in hours.")
+@click.option("--capacity", type=int, required=True, help="Seats available on each showing.")
+@click.option("--repeat-weekly", type=int, default=0, show_default=True,
+              help="Extra weekly copies — 3 gives four showings in total.")
+@click.pass_context
+def add_slot(ctx: click.Context, offering_id: str, day: str, start: str,
+             duration: float, capacity: int, repeat_weekly: int):
+    """Add a showing, optionally repeating it weekly.
+
+    A season is usually a repeating shape rather than a list of one-off dates, so
+    --repeat-weekly lays the whole run down in one call.
+    """
+    try:
+        starts_at = datetime.combine(_parse_day(day), datetime.strptime(start, "%H:%M").time())
+    except ValueError:
+        raise click.BadParameter(f"{start!r} is not a time — use HH:MM, e.g. 19:00")
+
+    body = {
+        "slots": [{
+            "start_datetime": starts_at.isoformat() + "+00:00",
+            "end_datetime": (starts_at + timedelta(hours=duration)).isoformat() + "+00:00",
+            "capacity": capacity,
+        }],
+        "repeat_weekly": repeat_weekly,
+    }
+    client = build_client(ctx)
+    created = client.post(f"/admin/offerings/{offering_id}/slots", json=body)
+    if not created and not ctx.obj["json"]:
+        click.echo("Nothing added — those showings are already on the calendar.")
+        return
+    render(created, ctx.obj["json"], title=f"Added {len(created)} showing(s)", columns=_SLOT_COLUMNS)
+
+
+@slots.command("set")
+@click.argument("offering_id")
+@click.argument("slot_id")
+@click.option("--date", "day", default=None, help="Move it to this date, YYYY-MM-DD.")
+@click.option("--time", "start", default=None, help="Move it to this start time, HH:MM.")
+@click.option("--duration", type=float, default=None, help="New length in hours.")
+@click.option("--capacity", type=int, default=None, help="New seat count.")
+@click.pass_context
+def set_slot(ctx: click.Context, offering_id: str, slot_id: str, day: str | None,
+             start: str | None, duration: float | None, capacity: int | None):
+    """Move a showing or change its capacity.
+
+    The API refuses a capacity below what has already sold — those seats belong to real
+    bookings.
+    """
+    if not any([day, start, duration, capacity]):
+        raise click.UsageError("nothing to change — pass --date, --time, --duration or --capacity")
+
+    client = build_client(ctx)
+    body: dict = {}
+    if capacity is not None:
+        body["capacity"] = capacity
+
+    if day or start or duration is not None:
+        current = next((s for s in client.get(f"/admin/offerings/{offering_id}/slots")
+                        if s["id"] == slot_id), None)
+        if current is None:
+            raise click.ClickException(f"Showing {slot_id} not found on {offering_id}")
+        begins = datetime.fromisoformat(current["start_datetime"])
+        ends = datetime.fromisoformat(current["end_datetime"])
+        length = timedelta(hours=duration) if duration is not None else ends - begins
+        if day:
+            begins = begins.replace(**_ymd(_parse_day(day)))
+        if start:
+            try:
+                clock = datetime.strptime(start, "%H:%M").time()
+            except ValueError:
+                raise click.BadParameter(f"{start!r} is not a time — use HH:MM, e.g. 19:00")
+            begins = begins.replace(hour=clock.hour, minute=clock.minute)
+        body["start_datetime"] = begins.isoformat()
+        body["end_datetime"] = (begins + length).isoformat()
+
+    data = client.patch(f"/admin/offerings/{offering_id}/slots/{slot_id}", json=body)
+    render(data, ctx.obj["json"], columns=_SLOT_COLUMNS)
+
+
+def _ymd(day: date) -> dict:
+    return {"year": day.year, "month": day.month, "day": day.day}
+
+
+@slots.command("rm")
+@click.argument("offering_id")
+@click.argument("slot_id")
+@click.option("--yes", is_flag=True, help="Skip the confirmation prompt.")
+@click.pass_context
+def remove_slot(ctx: click.Context, offering_id: str, slot_id: str, yes: bool):
+    """Remove a showing. Refused by the API once seats have sold against it."""
+    if not yes:
+        click.confirm(f"Remove showing {slot_id} from {offering_id}?", abort=True)
+    client = build_client(ctx)
+    client.delete(f"/admin/offerings/{offering_id}/slots/{slot_id}")
+    if not ctx.obj["json"]:
+        click.echo(f"Removed {slot_id}.")

{bookai_cli-0.2.0 → bookai_cli-0.5.0}/src/groupsales_cli/commands/pricing.py

@@ -8,7 +8,7 @@ _RULE_OPTIONS = [
     click.option("--max-group", type=int, required=True, help="Maximum group size this rule applies to."),
     click.option("--min-price", type=float, required=True, help="Price floor per person."),
     click.option("--max-price", type=float, required=True, help="Price ceiling per person."),
-    click.option("--event-id", default=None, help="Scope this rule to one event instead of the whole venue."),
+    click.option("--offering-id", default=None, help="Scope this rule to one offering instead of the whole venue."),
     click.option("--source", default="app", show_default=True, help="Origin tag, e.g. a 3P vendor name."),
     click.option("--external-id", default=None, help="3P upsert key -- ignored while --source is 'app'."),
 ]
@@ -20,19 +20,19 @@ def _add_rule_options(f):
     return f
 
 
-def _rule_body(min_group, max_group, min_price, max_price, event_id, source, external_id) -> dict:
+def _rule_body(min_group, max_group, min_price, max_price, offering_id, source, external_id) -> dict:
     return {
         "min_group": min_group,
         "max_group": max_group,
         "min_price": min_price,
         "max_price": max_price,
-        "event_id": event_id,
+        "offering_id": offering_id,
         "source": source,
         "external_id": external_id,
     }
 
 
-_RULE_COLUMNS = ["id", "min_group", "max_group", "min_price", "max_price", "event_id", "source", "external_id"]
+_RULE_COLUMNS = ["id", "min_group", "max_group", "min_price", "max_price", "offering_id", "source", "external_id"]
 
 
 @click.group()
@@ -66,10 +66,10 @@ def get_pricing(ctx: click.Context, venue_id: str, rule_id: str):
 @_add_rule_options
 @click.pass_context
 def set_pricing(ctx: click.Context, venue_id: str, min_group, max_group, min_price, max_price,
-                 event_id, source, external_id):
+                 offering_id, source, external_id):
     """Create a new pricing rule."""
     client = build_client(ctx)
-    body = _rule_body(min_group, max_group, min_price, max_price, event_id, source, external_id)
+    body = _rule_body(min_group, max_group, min_price, max_price, offering_id, source, external_id)
     data = client.post(f"/admin/venues/{venue_id}/pricing", json=body)
     render(data, ctx.obj["json"], columns=_RULE_COLUMNS)
 
@@ -80,10 +80,10 @@ def set_pricing(ctx: click.Context, venue_id: str, min_group, max_group, min_pri
 @_add_rule_options
 @click.pass_context
 def update_pricing(ctx: click.Context, venue_id: str, rule_id: str, min_group, max_group, min_price, max_price,
-                    event_id, source, external_id):
+                    offering_id, source, external_id):
     """Replace an existing pricing rule."""
     client = build_client(ctx)
-    body = _rule_body(min_group, max_group, min_price, max_price, event_id, source, external_id)
+    body = _rule_body(min_group, max_group, min_price, max_price, offering_id, source, external_id)
     data = client.put(f"/admin/venues/{venue_id}/pricing/{rule_id}", json=body)
     render(data, ctx.obj["json"], columns=_RULE_COLUMNS)
 

bookai_cli-0.5.0/src/groupsales_cli/commands/search.py

@@ -0,0 +1,49 @@
+import click
+
+from groupsales_cli.client import build_client
+from groupsales_cli.output import render
+
+RECORD_TYPES = (
+    "conversation", "offer", "quote", "order", "offering",
+    "rule", "pricing_tier", "payment_policy", "contact",
+)
+
+
+@click.command()
+@click.argument("query", nargs=-1, required=True)
+@click.option("--type", "types", multiple=True, type=click.Choice(RECORD_TYPES),
+              help="Only this kind of record. Repeat for several.")
+@click.option("--limit", type=click.IntRange(1, 50), default=20, show_default=True)
+@click.pass_context
+def search(ctx: click.Context, query: tuple[str, ...], types: tuple[str, ...], limit: int):
+    """Search every record at your venue: conversations, offers, quotes, orders,
+    offerings, policies, pricing tiers, payment terms and contacts.
+
+    Matches exact words (names, emails, ids) and meaning, so
+    `bookai search where do coaches park` finds a guest asking about bus parking.
+    """
+    client = build_client(ctx)
+    params = {"q": " ".join(query), "limit": limit}
+    if types:
+        params["types"] = ",".join(types)
+    data = client.get("/admin/search", params=params)
+    if ctx.obj["json"]:
+        render(data, True)
+        return
+    # The back office UI is served from the same origin as the API, so a result's
+    # deep link opens straight in the browser. One block per result rather than a
+    # table: snippets and links don't survive being folded into narrow columns.
+    base_url = ctx.obj["base_url"].rstrip("/")
+    results = data["results"]
+    if not results:
+        click.echo(f"No results for “{data['query']}”.")
+        return
+    for r in results:
+        kind = r["record_type"].replace("_", " ")
+        click.echo(click.style(f"{kind:<14}", fg="cyan") + click.style(r["title"], bold=True))
+        if r.get("subtitle"):
+            click.echo(f"{'':<14}{r['subtitle']}")
+        if r.get("snippet"):
+            click.echo(f"{'':<14}“{r['snippet']}”")
+        click.echo(f"{'':<14}{base_url}{r['deep_link']}")
+        click.echo()

bookai_cli-0.5.0/tests/test_offerings.py

@@ -0,0 +1,188 @@
+import json
+
+from groupsales_cli.__main__ import cli
+
+BASE_URL = "https://test.example"
+_BASE_ARGS = ["--api-key", "k", "--base-url", BASE_URL]
+
+_OFFERING = {
+    "id": "gala-ocean", "name": "Private Gala", "category": "gala", "admission_type": "timed",
+    "status": "active", "valid_from": "2026-09-01", "valid_to": "2026-12-31",
+    "base_price_per_person": 80.0, "venue_id": "amnh", "description": "",
+}
+_SLOT = {
+    "id": "s1", "offering_id": "gala-ocean", "capacity": 400, "sold": 0, "available": 400,
+    "start_datetime": "2026-11-14T19:00:00+00:00", "end_datetime": "2026-11-14T23:00:00+00:00",
+}
+
+
+def test_offerings_list_unwraps_the_offering_from_each_detail(runner, respx_mock):
+    """The endpoint returns {offering, slots, pricing_tiers} per row; the table shows the
+    offering. Asserted on --json because the rendered table truncates long ids."""
+    respx_mock.get(f"{BASE_URL}/admin/offerings").respond(json=[{"offering": _OFFERING, "slots": []}])
+    result = runner.invoke(cli, [*_BASE_ARGS, "--json", "offerings", "list"])
+    assert result.exit_code == 0, result.output
+    assert json.loads(result.output) == [_OFFERING]
+
+
+def test_offerings_show_includes_its_showings(runner, respx_mock):
+    respx_mock.get(f"{BASE_URL}/admin/offerings/gala-ocean").respond(
+        json={"offering": _OFFERING, "slots": [_SLOT], "pricing_tiers": []})
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "show", "gala-ocean"])
+    assert result.exit_code == 0, result.output
+    assert "Showings" in result.output and "s1" in result.output
+
+
+# ── extend ─────────────────────────────────────────────────────────────────────
+
+def test_extend_to_an_exact_date_patches_valid_to(runner, respx_mock):
+    """Extending a run is valid_to changing — so it PATCHes the offering, no special
+    endpoint."""
+    route = respx_mock.patch(f"{BASE_URL}/admin/offerings/gala-ocean").respond(
+        json={"offering": {**_OFFERING, "valid_to": "2027-03-31"}, "slots": []})
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "extend", "gala-ocean",
+                                 "--to", "2027-03-31"])
+    assert result.exit_code == 0, result.output
+    assert route.called
+    assert json.loads(route.calls.last.request.content) == {"valid_to": "2027-03-31"}
+    assert "runs until 2027-03-31" in result.output
+
+
+def test_extend_by_a_period_reads_the_current_end_date_first(runner, respx_mock):
+    respx_mock.get(f"{BASE_URL}/admin/offerings/gala-ocean").respond(
+        json={"offering": _OFFERING, "slots": []})
+    route = respx_mock.patch(f"{BASE_URL}/admin/offerings/gala-ocean").respond(
+        json={"offering": {**_OFFERING, "valid_to": "2027-03-31"}, "slots": []})
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "extend", "gala-ocean", "--by", "3m"])
+    assert result.exit_code == 0, result.output
+    # 2026-12-31 + 90 days
+    assert json.loads(route.calls.last.request.content) == {"valid_to": "2027-03-31"}
+
+
+def test_extend_needs_exactly_one_of_to_or_by(runner, respx_mock):
+    neither = runner.invoke(cli, [*_BASE_ARGS, "offerings", "extend", "gala-ocean"])
+    both = runner.invoke(cli, [*_BASE_ARGS, "offerings", "extend", "gala-ocean",
+                               "--to", "2027-01-01", "--by", "3m"])
+    assert neither.exit_code != 0 and both.exit_code != 0
+    assert "exactly one of --to or --by" in neither.output
+
+
+def test_extend_rejects_a_nonsense_period(runner, respx_mock):
+    respx_mock.get(f"{BASE_URL}/admin/offerings/gala-ocean").respond(
+        json={"offering": _OFFERING, "slots": []})
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "extend", "gala-ocean", "--by", "soon"])
+    assert result.exit_code != 0
+    assert "30d, 6w or 3m" in result.output
+
+
+def test_narrowing_a_run_surfaces_the_api_refusal(runner, respx_mock):
+    """The API refuses to strand existing showings; the CLI must relay that, not swallow it."""
+    respx_mock.patch(f"{BASE_URL}/admin/offerings/gala-ocean").respond(
+        status_code=409, json={"detail": "2 existing showing(s) would fall outside the run"})
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "extend", "gala-ocean",
+                                 "--to", "2026-09-05"])
+    assert result.exit_code != 0
+    assert "would fall outside the run" in result.output
+
+
+# ── slots ──────────────────────────────────────────────────────────────────────
+
+def test_slots_list(runner, respx_mock):
+    respx_mock.get(f"{BASE_URL}/admin/offerings/gala-ocean/slots").respond(json=[_SLOT])
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "slots", "list", "gala-ocean"])
+    assert result.exit_code == 0, result.output
+    assert "s1" in result.output
+
+
+def test_slots_add_builds_the_window_from_date_time_and_duration(runner, respx_mock):
+    route = respx_mock.post(f"{BASE_URL}/admin/offerings/gala-ocean/slots").respond(
+        status_code=201, json=[_SLOT])
+    result = runner.invoke(cli, [
+        *_BASE_ARGS, "offerings", "slots", "add", "gala-ocean",
+        "--date", "2026-11-14", "--time", "19:00", "--duration", "4", "--capacity", "400",
+    ])
+    assert result.exit_code == 0, result.output
+    body = json.loads(route.calls.last.request.content)
+    assert body["slots"] == [{
+        "start_datetime": "2026-11-14T19:00:00+00:00",
+        "end_datetime": "2026-11-14T23:00:00+00:00",
+        "capacity": 400,
+    }]
+    assert body["repeat_weekly"] == 0
+
+
+def test_slots_add_passes_the_repeat_through(runner, respx_mock):
+    route = respx_mock.post(f"{BASE_URL}/admin/offerings/gala-ocean/slots").respond(
+        status_code=201, json=[_SLOT] * 4)
+    result = runner.invoke(cli, [
+        *_BASE_ARGS, "offerings", "slots", "add", "gala-ocean",
+        "--date", "2026-11-14", "--time", "19:00", "--capacity", "400", "--repeat-weekly", "3",
+    ])
+    assert result.exit_code == 0, result.output
+    assert json.loads(route.calls.last.request.content)["repeat_weekly"] == 3
+    assert "Added 4 showing(s)" in result.output
+
+
+def test_slots_add_says_so_when_everything_already_existed(runner, respx_mock):
+    respx_mock.post(f"{BASE_URL}/admin/offerings/gala-ocean/slots").respond(status_code=201, json=[])
+    result = runner.invoke(cli, [
+        *_BASE_ARGS, "offerings", "slots", "add", "gala-ocean",
+        "--date", "2026-11-14", "--time", "19:00", "--capacity", "400",
+    ])
+    assert result.exit_code == 0, result.output
+    assert "already on the calendar" in result.output
+
+
+def test_slots_add_rejects_a_bad_time(runner, respx_mock):
+    result = runner.invoke(cli, [
+        *_BASE_ARGS, "offerings", "slots", "add", "gala-ocean",
+        "--date", "2026-11-14", "--time", "7pm", "--capacity", "400",
+    ])
+    assert result.exit_code != 0
+    assert "use HH:MM" in result.output
+
+
+def test_slots_set_capacity_only_does_not_need_the_current_showing(runner, respx_mock):
+    route = respx_mock.patch(f"{BASE_URL}/admin/offerings/gala-ocean/slots/s1").respond(
+        json={**_SLOT, "capacity": 120, "available": 120})
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "slots", "set", "gala-ocean", "s1",
+                                 "--capacity", "120"])
+    assert result.exit_code == 0, result.output
+    assert json.loads(route.calls.last.request.content) == {"capacity": 120}
+
+
+def test_slots_set_time_keeps_the_existing_duration(runner, respx_mock):
+    """Moving a 4-hour showing to a new time must keep it 4 hours long."""
+    respx_mock.get(f"{BASE_URL}/admin/offerings/gala-ocean/slots").respond(json=[_SLOT])
+    route = respx_mock.patch(f"{BASE_URL}/admin/offerings/gala-ocean/slots/s1").respond(json=_SLOT)
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "slots", "set", "gala-ocean", "s1",
+                                 "--time", "14:00"])
+    assert result.exit_code == 0, result.output
+    body = json.loads(route.calls.last.request.content)
+    assert body["start_datetime"].endswith("14:00:00+00:00")
+    assert body["end_datetime"].endswith("18:00:00+00:00")
+
+
+def test_slots_set_needs_something_to_change(runner, respx_mock):
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "slots", "set", "gala-ocean", "s1"])
+    assert result.exit_code != 0
+    assert "nothing to change" in result.output
+
+
+def test_slots_rm_asks_first(runner, respx_mock):
+    route = respx_mock.delete(f"{BASE_URL}/admin/offerings/gala-ocean/slots/s1").respond(status_code=204)
+    declined = runner.invoke(cli, [*_BASE_ARGS, "offerings", "slots", "rm", "gala-ocean", "s1"],
+                             input="n\n")
+    assert declined.exit_code != 0 and not route.called
+
+    accepted = runner.invoke(cli, [*_BASE_ARGS, "offerings", "slots", "rm", "gala-ocean", "s1", "--yes"])
+    assert accepted.exit_code == 0, accepted.output
+    assert route.called
+
+
+def test_slots_rm_relays_the_refusal_when_seats_are_sold(runner, respx_mock):
+    respx_mock.delete(f"{BASE_URL}/admin/offerings/gala-ocean/slots/s1").respond(
+        status_code=409, json={"detail": "20 seat(s) already sold on this showing"})
+    result = runner.invoke(cli, [*_BASE_ARGS, "offerings", "slots", "rm", "gala-ocean", "s1", "--yes"])
+    assert result.exit_code != 0
+    assert "already sold" in result.output

{bookai_cli-0.2.0 → bookai_cli-0.5.0}/tests/test_pricing.py

@@ -5,7 +5,7 @@ _BASE_ARGS = ["--api-key", "k", "--base-url", BASE_URL]
 
 _RULE = {
     "id": "r1", "venue_id": "amnh", "min_group": 5, "max_group": 20,
-    "min_price": 10.0, "max_price": 20.0, "event_id": None, "source": "app", "external_id": None,
+    "min_price": 10.0, "max_price": 20.0, "offering_id": None, "source": "app", "external_id": None,
 }
 
 

bookai_cli-0.5.0/tests/test_search.py

@@ -0,0 +1,55 @@
+from groupsales_cli.__main__ import cli
+
+BASE_URL = "https://test.example"
+
+RESULTS = {
+    "version": 1, "query": "coaches park", "types": [],
+    "results": [{
+        "record_type": "conversation", "record_id": "s1", "title": "brave-otter-12",
+        "subtitle": "Dana Lee · 12 messages", "snippet": "Where can the coaches park?",
+        "deep_link": "/conversations/s1", "facets": {}, "updated_at": None, "score": 0.03,
+    }],
+}
+
+
+def test_search_joins_words_and_prints_a_browser_link(runner, respx_mock):
+    route = respx_mock.get(f"{BASE_URL}/admin/search", params={"q": "coaches park", "limit": "20"}).respond(json=RESULTS)
+    result = runner.invoke(cli, ["--api-key", "k", "--base-url", BASE_URL, "search", "coaches", "park"])
+    assert result.exit_code == 0, result.output
+    assert route.called
+    assert "brave-otter-12" in result.output
+    assert "Where can the coaches park?" in result.output
+    assert "https://test.example/conversations/s1" in result.output
+
+
+def test_search_passes_types_and_limit(runner, respx_mock):
+    route = respx_mock.get(
+        f"{BASE_URL}/admin/search", params={"q": "acme", "limit": "5", "types": "offer,quote"}
+    ).respond(json={**RESULTS, "query": "acme", "results": []})
+    result = runner.invoke(cli, ["--api-key", "k", "--base-url", BASE_URL, "search", "acme",
+                                 "--type", "offer", "--type", "quote", "--limit", "5"])
+    assert result.exit_code == 0, result.output
+    assert route.called
+    assert "No results for “acme”." in result.output
+
+
+def test_search_json_returns_the_api_response_unchanged(runner, respx_mock):
+    respx_mock.get(f"{BASE_URL}/admin/search").respond(json=RESULTS)
+    result = runner.invoke(cli, ["--api-key", "k", "--base-url", BASE_URL, "--json", "search", "coaches"])
+    assert result.exit_code == 0
+    assert '"deep_link": "/conversations/s1"' in result.output
+
+
+def test_search_rejects_an_unknown_type(runner):
+    result = runner.invoke(cli, ["--api-key", "k", "--base-url", BASE_URL, "search", "x", "--type", "invoices"])
+    assert result.exit_code != 0
+    assert "invoices" in result.output
+
+
+def test_search_surfaces_the_api_error(runner, respx_mock):
+    respx_mock.get(f"{BASE_URL}/admin/search").respond(
+        status_code=503, json={"detail": "Search is still being set up. Try again in a minute."}
+    )
+    result = runner.invoke(cli, ["--api-key", "k", "--base-url", BASE_URL, "search", "coaches"])
+    assert result.exit_code != 0
+    assert "still being set up" in result.output

bookai_cli-0.2.0/src/groupsales_cli/__init__.py

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