unofficial-ravensburger-playhub-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

package/README.md

@@ -0,0 +1,215 @@
+# Lorcana Event Finder (MCP Server)
+
+An **MCP (Model Context Protocol) server** that lets AI assistants look up **Disney Lorcana TCG** events, stores, and tournament data. It talks to the official Ravensburger Play API so you can ask things like “Where can I play Lorcana near Seattle?” or “What events are coming up in Austin?” from Cursor, Claude Desktop, Claude Code, or any MCP client.
+
+## What you need
+
+- **Node.js** 18+ (for `node --test` and ESM)
+- **npm** (comes with Node)
+
+No API keys or configuration are required. Event and store search work out of the box.
+
+## Quick start
+
+**From npm (no clone):**
+
+```bash
+npx -y unofficial-ravensburger-playhub-mcp
+```
+
+**From source:**
+
+```bash
+git clone https://github.com/zammitt/unofficial-ravensburger-playhub-mcp.git
+cd unofficial-ravensburger-playhub-mcp
+npm install
+npm run build
+npm start
+```
+
+The server runs over stdio. Add it as an MCP server in your client (e.g. Cursor) to use the tools.
+
+## Using with Cursor
+
+**Option A — npx (easiest):** No clone or build. In **Settings → MCP**, add:
+
+```json
+{
+  "mcpServers": {
+    "unofficial-ravensburger-playhub-mcp": {
+      "command": "npx",
+      "args": ["-y", "unofficial-ravensburger-playhub-mcp"]
+    }
+  }
+}
+```
+
+**Option B — from a local clone:** Build first (`npm run build`), then point at the built script:
+
+```json
+{
+  "mcpServers": {
+    "unofficial-ravensburger-playhub-mcp": {
+      "command": "node",
+      "args": ["/path/to/unofficial-ravensburger-playhub-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+After that, the Lorcana Event Finder tools are available to the AI in Cursor.
+
+## Using with Claude
+
+Add the server to **Claude Desktop** by editing your MCP config file:
+
+- **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+- **Linux:** `~/.config/Claude/claude_desktop_config.json`
+
+**Option A — npx (easiest):** No clone or build. Add or merge into the `mcpServers` object:
+
+```json
+{
+  "mcpServers": {
+    "unofficial-ravensburger-playhub-mcp": {
+      "command": "npx",
+      "args": ["-y", "unofficial-ravensburger-playhub-mcp"]
+    }
+  }
+}
+```
+
+**Option B — from a local clone:** Build first (`npm run build`), then point at the built script:
+
+```json
+{
+  "mcpServers": {
+    "unofficial-ravensburger-playhub-mcp": {
+      "command": "node",
+      "args": ["/path/to/unofficial-ravensburger-playhub-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+Restart Claude Desktop after changing the config. The Lorcana Event Finder tools will then be available to Claude.
+
+## Using with Claude Code
+
+**Claude Code** (the IDE) can use this server via the CLI or by editing config. Options must come *before* the server name; `--` separates the name from the command.
+
+**Option A — CLI with npx (easiest):** No clone or build. Run in your project or from any directory:
+
+```bash
+claude mcp add --transport stdio unofficial-ravensburger-playhub-mcp -- npx -y unofficial-ravensburger-playhub-mcp
+```
+
+Use `--scope user` to make it available in all projects:
+
+```bash
+claude mcp add --transport stdio --scope user unofficial-ravensburger-playhub-mcp -- npx -y unofficial-ravensburger-playhub-mcp
+```
+
+**Option B — CLI from a local clone:** Build first (`npm run build`), then:
+
+```bash
+claude mcp add --transport stdio unofficial-ravensburger-playhub-mcp -- node /path/to/unofficial-ravensburger-playhub-mcp/dist/index.js
+```
+
+**Option C — Config file:** Add the same `mcpServers` entry as in the Cursor/Claude Desktop sections to:
+
+- **Project scope:** `.mcp.json` in your project root (share with the team), or  
+- **User scope:** `~/.claude.json` (in the `mcpServers` object).
+
+Example for `.mcp.json` or `~/.claude.json`:
+
+```json
+{
+  "mcpServers": {
+    "unofficial-ravensburger-playhub-mcp": {
+      "command": "npx",
+      "args": ["-y", "unofficial-ravensburger-playhub-mcp"]
+    }
+  }
+}
+```
+
+**Windows (native, not WSL):** For npx-based servers, use the `cmd /c` wrapper:
+
+```bash
+claude mcp add --transport stdio unofficial-ravensburger-playhub-mcp -- cmd /c npx -y unofficial-ravensburger-playhub-mcp
+```
+
+Check that the server is listed with `claude mcp list`; in Claude Code you can run `/mcp` to see status.
+
+### LLM-friendly design
+
+Tool descriptions include **when to use** each tool (e.g. city name → `search_events_by_city`, coordinates → `search_events`). Call **list_capabilities** first if the assistant is unsure which tool to use. **list_filters** returns exact format/category names for event search parameters.
+
+## MCP tools
+
+The server exposes tools that are easy for LLMs to choose and call: descriptions include **when to use** each tool, and optional parameters are clearly documented. Call **list_capabilities** first if unsure which tool to use.
+
+| Tool | When to use |
+|------|-------------|
+| **list_capabilities** | Call first when unsure which tool to use (e.g. search_events vs search_events_by_city). Returns a short guide. |
+| **list_filters** | Before searching events by format or category; returns exact names for the `formats` and `categories` parameters. |
+| **search_events** | When you have latitude/longitude (e.g. from a map or device). |
+| **search_events_by_city** | When the user says a city name (e.g. "events in Seattle" or "Austin, TX"). Geocoded. |
+| **get_event_details** | Full details for one event; use when you have an event ID (e.g. from a search). |
+| **get_event_registrations** | Who is signed up for an event; needs event ID. |
+| **get_tournament_round_standings** | Standings/leaderboard for a tournament round; needs round ID. |
+| **search_stores** | Stores or venues; optional name search and/or lat/long + radius. |
+| **search_stores_by_city** | Stores near a city name (e.g. "stores in Seattle"). |
+
+## Development
+
+```bash
+npm install
+npm run build   # compile TypeScript to dist/
+npm test        # run all tests from dist/ (unit + integration); run build first
+npm run test:coverage   # run tests with coverage report (c8)
+```
+
+- **`npm run dev`** – Run the server with `tsx` (no build step) for quick iteration.
+- **`npm start`** – Run the compiled server: `node dist/index.js`.
+
+### Project structure
+
+| Path | Purpose |
+|------|---------|
+| **`src/index.ts`** | MCP server entry point: create server, register tools, run stdio transport. |
+| **`src/lib/`** | Core library: `types.ts`, `api.ts`, `formatters.ts` (Ravensburger API client, types, human-readable formatters). |
+| **`src/tools/`** | MCP tool handlers: `events.ts`, `stores.ts`, `filters.ts`. |
+| **`src/test/`** | Unit tests (api, formatters) and integration tests (MCP server + tools). |
+
+### Tests
+
+- **Unit tests** – `api.test.ts` (API client: filter maps, fetch with mocked `fetch`, `loadFilterOptions`), `formatters.test.ts` (formatStore, formatEvent, formatStandingEntry, formatRegistrationEntry), `registrations.test.ts`, `standings.test.ts`. No network required for unit tests.
+- **Integration tests** – `mcp-tools.integration.test.ts` spawns the MCP server and calls each tool (required-only, optional params, pagination). They hit the real Ravensburger Play API and Nominatim for geocoding, so **network access is required** and tests may be slower or flaky if the APIs are slow or down.
+
+Coverage is reported for `dist/` (excluding `dist/test/`). Run `npm run test:coverage` to see statement/branch/function coverage for the app code.
+
+## API and data
+
+Data comes from the **Ravensburger Play API** (events, stores, formats, categories, registrations, tournament rounds/standings). City-based search uses **Nominatim** (OpenStreetMap) for geocoding. Neither API requires keys.
+
+## Security & privacy
+
+- No API keys or secrets are stored in this repo or by the server.
+- All tools use public Ravensburger and Nominatim endpoints with no authentication.
+
+## Publishing to npm
+
+1. **Create an npm account** (if needed): [npmjs.com/signup](https://www.npmjs.com/signup).
+2. **Enable 2FA (required to publish):** npm requires two-factor authentication to publish. In [Account Settings → Two-Factor Authentication](https://www.npmjs.com/settings/~yourusername/account), turn on 2FA (auth-only or auth-and-writes). You’ll be prompted for the code when you run `npm publish`.
+3. **Log in from the CLI:** `npm login` (username, password, OTP when prompted).
+4. **Check the package name:** Ensure `unofficial-ravensburger-playhub-mcp` is not taken: [npmjs.com/package/unofficial-ravensburger-playhub-mcp](https://www.npmjs.com/package/unofficial-ravensburger-playhub-mcp). If it is taken, change `name` in `package.json` (and optionally scope it, e.g. `@yourusername/unofficial-ravensburger-playhub-mcp`).
+5. **Dry run:** `npm publish --dry-run` to see what would be uploaded (no publish).
+6. **Publish:** `npm publish`. You’ll be prompted for your 2FA code. The `prepublishOnly` script runs `npm run build` first, so `dist/` is built automatically.
+7. **Later releases:** Bump `version` in `package.json` (e.g. `1.0.1`), then run `npm publish` again.
+
+## License
+
+[Unlicense](https://unlicense.org) — public domain. No copyright, no warranty, no liability. Use at your own risk.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadFilterOptions } from "./lib/api.js";
+import { registerEventTools } from "./tools/events.js";
+import { registerFilterTools } from "./tools/filters.js";
+import { registerStoreTools } from "./tools/stores.js";
+const isEntryModule = process.argv[1] != null &&
+    resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url));
+const server = new McpServer({
+    name: "lorcana-event-finder",
+    version: "1.0.0",
+});
+registerEventTools(server);
+registerStoreTools(server);
+registerFilterTools(server);
+async function main() {
+    await loadFilterOptions();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Lorcana Event Finder MCP server running on stdio");
+}
+if (isEntryModule) {
+    main().catch((error) => {
+        console.error("Fatal error:", error);
+        process.exit(1);
+    });
+}

package/dist/lib/api.d.ts

@@ -0,0 +1,23 @@
+/**
+ * API client for Ravensburger Play (events, stores, formats, categories, standings, registrations).
+ */
+import type { Event, EventCategory, EventsResponse, GameplayFormat, RegistrationsResponse, StandingsResponse, StoresResponse } from "./types.js";
+/** Event statuses supported by the API. */
+export declare const STATUSES: readonly ["upcoming", "inProgress", "past"];
+/** Load and cache formats and categories from the API (called at server startup). */
+export declare function loadFilterOptions(): Promise<void>;
+/** Update the in-memory format/category maps (e.g. after list_filters refresh). */
+export declare function updateFilterMaps(formats: GameplayFormat[], categories: EventCategory[]): void;
+export declare function fetchGameplayFormats(): Promise<GameplayFormat[]>;
+export declare function fetchCategories(): Promise<EventCategory[]>;
+export declare function fetchEvents(params: Record<string, string | string[]>): Promise<EventsResponse>;
+export declare function fetchEventDetails(eventId: number): Promise<Event>;
+export declare function fetchEventRegistrations(eventId: number, page?: number, pageSize?: number): Promise<RegistrationsResponse>;
+export declare function fetchTournamentRoundStandings(roundId: number, page?: number, pageSize?: number): Promise<StandingsResponse>;
+export declare function fetchStores(params: Record<string, string>): Promise<StoresResponse>;
+/** Resolve format display names to API IDs. */
+export declare function resolveFormatIds(formatNames: string[]): string[];
+/** Resolve category display names to API IDs. */
+export declare function resolveCategoryIds(categoryNames: string[]): string[];
+/** Reverse lookup: category template ID to display name. */
+export declare function getCategoryName(templateId: string): string;

package/dist/lib/api.js

@@ -0,0 +1,171 @@
+/**
+ * API client for Ravensburger Play (events, stores, formats, categories, standings, registrations).
+ */
+const API_BASE = "https://api.cloudflare.ravensburgerplay.com/hydraproxy/api/v2";
+/** Event statuses supported by the API. */
+export const STATUSES = ["upcoming", "inProgress", "past"];
+// Dynamic lookup maps - populated at startup and refreshed by list_filters
+let FORMAT_MAP = new Map(); // name -> id
+let CATEGORY_MAP = new Map(); // name -> id
+/** Load and cache formats and categories from the API (called at server startup). */
+export async function loadFilterOptions() {
+    try {
+        const [formats, categories] = await Promise.all([
+            fetchGameplayFormats(),
+            fetchCategories(),
+        ]);
+        updateFilterMaps(formats, categories);
+        console.error(`Loaded ${FORMAT_MAP.size} formats and ${CATEGORY_MAP.size} categories from API`);
+    }
+    catch (error) {
+        console.error("Warning: Failed to load filter options from API:", error);
+    }
+}
+/** Update the in-memory format/category maps (e.g. after list_filters refresh). */
+export function updateFilterMaps(formats, categories) {
+    FORMAT_MAP = new Map(formats.map((f) => [f.name, f.id]));
+    CATEGORY_MAP = new Map(categories.map((c) => [c.name, c.id]));
+}
+export async function fetchGameplayFormats() {
+    const url = `${API_BASE}/gameplay-formats/?game_slug=disney-lorcana`;
+    const response = await fetch(url, {
+        headers: { Referer: "https://tcg.ravensburgerplay.com/" },
+    });
+    if (!response.ok)
+        throw new Error("Failed to fetch formats");
+    return response.json();
+}
+export async function fetchCategories() {
+    const url = `${API_BASE}/event-configuration-templates/?game_slug=disney-lorcana`;
+    const response = await fetch(url, {
+        headers: { Referer: "https://tcg.ravensburgerplay.com/" },
+    });
+    if (!response.ok)
+        throw new Error("Failed to fetch categories");
+    return response.json();
+}
+export async function fetchEvents(params) {
+    const url = new URL(`${API_BASE}/events/`);
+    for (const [key, value] of Object.entries(params)) {
+        if (Array.isArray(value)) {
+            value.forEach((v) => url.searchParams.append(key, v));
+        }
+        else if (value !== undefined && value !== "") {
+            url.searchParams.append(key, value);
+        }
+    }
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            Referer: "https://tcg.ravensburgerplay.com/",
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API request failed: ${response.status} ${response.statusText} - ${text}`);
+    }
+    return response.json();
+}
+export async function fetchEventDetails(eventId) {
+    const url = `${API_BASE}/events/${eventId}/`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            Referer: "https://tcg.ravensburgerplay.com/",
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API request failed: ${response.status} ${response.statusText} - ${text}`);
+    }
+    return response.json();
+}
+export async function fetchEventRegistrations(eventId, page = 1, pageSize = 25) {
+    const url = new URL(`${API_BASE}/events/${eventId}/registrations/`);
+    url.searchParams.set("page", page.toString());
+    url.searchParams.set("page_size", pageSize.toString());
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            Referer: "https://tcg.ravensburgerplay.com/",
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API request failed: ${response.status} ${response.statusText} - ${text}`);
+    }
+    return response.json();
+}
+export async function fetchTournamentRoundStandings(roundId, page = 1, pageSize = 25) {
+    const url = new URL(`${API_BASE}/tournament-rounds/${roundId}/standings/paginated/`);
+    url.searchParams.set("page", page.toString());
+    url.searchParams.set("page_size", pageSize.toString());
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            Referer: "https://tcg.ravensburgerplay.com/",
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API request failed: ${response.status} ${response.statusText} - ${text}`);
+    }
+    return response.json();
+}
+export async function fetchStores(params) {
+    const url = new URL(`${API_BASE}/game-stores/`);
+    url.searchParams.append("game_id", "1");
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== "") {
+            url.searchParams.append(key, value);
+        }
+    }
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            Referer: "https://tcg.ravensburgerplay.com/",
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API request failed: ${response.status} ${response.statusText} - ${text}`);
+    }
+    return response.json();
+}
+/** Resolve format display names to API IDs. */
+export function resolveFormatIds(formatNames) {
+    const ids = [];
+    for (const name of formatNames) {
+        const id = FORMAT_MAP.get(name);
+        if (id)
+            ids.push(id);
+        else
+            console.error(`Warning: Unknown format "${name}"`);
+    }
+    return ids;
+}
+/** Resolve category display names to API IDs. */
+export function resolveCategoryIds(categoryNames) {
+    const ids = [];
+    for (const name of categoryNames) {
+        const id = CATEGORY_MAP.get(name);
+        if (id)
+            ids.push(id);
+        else
+            console.error(`Warning: Unknown category "${name}"`);
+    }
+    return ids;
+}
+/** Reverse lookup: category template ID to display name. */
+export function getCategoryName(templateId) {
+    for (const [name, id] of CATEGORY_MAP.entries()) {
+        if (id === templateId)
+            return name;
+    }
+    return templateId;
+}

package/dist/lib/formatters.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Human-readable formatters for events, stores, standings, and registrations.
+ */
+import type { Event, GameStore, RegistrationEntry, StandingEntry } from "./types.js";
+export declare function formatStore(gameStore: GameStore): string;
+export declare function formatStandingEntry(entry: StandingEntry, index: number): string;
+export declare function formatRegistrationEntry(entry: RegistrationEntry, index: number): string;
+export declare function formatEvent(event: Event): string;

package/dist/lib/formatters.js

@@ -0,0 +1,134 @@
+/**
+ * Human-readable formatters for events, stores, standings, and registrations.
+ */
+import { getCategoryName } from "./api.js";
+export function formatStore(gameStore) {
+    const store = gameStore.store;
+    const lines = [`**${store.name}** (Store ID: ${store.id})`];
+    if (store.full_address) {
+        lines.push(`📍 ${store.full_address}`);
+    }
+    if (store.phone_number) {
+        lines.push(`📞 ${store.phone_number}`);
+    }
+    if (store.email) {
+        lines.push(`📧 ${store.email}`);
+    }
+    if (store.website) {
+        lines.push(`🌐 ${store.website}`);
+    }
+    if (gameStore.store_types_pretty && gameStore.store_types_pretty.length > 0) {
+        lines.push(`🏷️ Types: ${gameStore.store_types_pretty.join(", ")}`);
+    }
+    if (store.bio) {
+        lines.push(`\n${store.bio}`);
+    }
+    const socials = [];
+    if (store.discord_url)
+        socials.push(`Discord: ${store.discord_url}`);
+    if (store.facebook_url)
+        socials.push(`Facebook: ${store.facebook_url}`);
+    if (store.instagram_handle)
+        socials.push(`Instagram: @${store.instagram_handle}`);
+    if (store.twitter_handle)
+        socials.push(`Twitter: @${store.twitter_handle}`);
+    if (socials.length > 0) {
+        lines.push(`\n${socials.join(" | ")}`);
+    }
+    return lines.join("\n");
+}
+export function formatStandingEntry(entry, index) {
+    const rank = entry.rank ?? entry.placement ?? index + 1;
+    const name = entry.player_name ?? entry.display_name ?? entry.username ?? "—";
+    const lines = [`${rank}. ${name}`];
+    if (entry.wins !== undefined || entry.losses !== undefined) {
+        lines.push(`   Record: ${entry.wins ?? 0}-${entry.losses ?? 0}`);
+    }
+    if (entry.match_points !== undefined) {
+        lines.push(`   Match points: ${entry.match_points}`);
+    }
+    if (entry.opponent_match_win_pct !== undefined) {
+        lines.push(`   OMWP: ${(Number(entry.opponent_match_win_pct) * 100).toFixed(1)}%`);
+    }
+    if (entry.game_win_pct !== undefined) {
+        lines.push(`   GWP: ${(Number(entry.game_win_pct) * 100).toFixed(1)}%`);
+    }
+    return lines.join("\n");
+}
+export function formatRegistrationEntry(entry, index) {
+    const name = entry.display_name ??
+        entry.username ??
+        (entry.user &&
+            (entry.user.display_name ??
+                entry.user.username ??
+                [entry.user.first_name, entry.user.last_name].filter(Boolean).join(" "))) ??
+        "—";
+    const lines = [`${index + 1}. ${name}`];
+    if (entry.status) {
+        lines.push(`   Status: ${entry.status}`);
+    }
+    if (entry.registered_at) {
+        try {
+            const d = new Date(entry.registered_at);
+            lines.push(`   Registered: ${d.toLocaleString()}`);
+        }
+        catch {
+            lines.push(`   Registered: ${entry.registered_at}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function formatEvent(event) {
+    const lines = [`**${event.name}** (ID: ${event.id})`];
+    if (event.start_datetime) {
+        const startDate = new Date(event.start_datetime);
+        lines.push(`📅 ${startDate.toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" })} at ${startDate.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" })}`);
+    }
+    if (event.gameplay_format?.name) {
+        lines.push(`🎮 Format: ${event.gameplay_format.name}`);
+    }
+    if (event.event_configuration_template) {
+        lines.push(`📁 Category: ${getCategoryName(event.event_configuration_template)}`);
+    }
+    if (event.store?.name) {
+        lines.push(`🏪 Store: ${event.store.name}`);
+    }
+    if (event.full_address) {
+        lines.push(`📍 ${event.full_address}`);
+    }
+    if (event.distance_in_miles != null) {
+        lines.push(`🚗 Distance: ${event.distance_in_miles.toFixed(1)} miles`);
+    }
+    if (event.cost_in_cents !== undefined) {
+        if (event.cost_in_cents > 0) {
+            const cost = event.cost_in_cents / 100;
+            lines.push(`💰 Entry: ${event.currency || "USD"} $${cost.toFixed(2)}`);
+        }
+        else {
+            lines.push(`💰 Entry: Free`);
+        }
+    }
+    if (event.capacity) {
+        const registered = event.registered_user_count || 0;
+        lines.push(`👥 Participants: ${registered}/${event.capacity}`);
+    }
+    else if (event.registered_user_count !== undefined) {
+        lines.push(`👥 Registered: ${event.registered_user_count}`);
+    }
+    if (event.display_status) {
+        lines.push(`📊 Status: ${event.display_status}`);
+    }
+    if (event.settings?.event_lifecycle_status) {
+        lines.push(`🎟️ Registration: ${event.settings.event_lifecycle_status.replace(/_/g, " ").toLowerCase()}`);
+    }
+    if (event.is_headlining_event) {
+        lines.push(`⭐ Featured Event`);
+    }
+    if (event.event_is_online) {
+        lines.push(`🌐 Online Event`);
+    }
+    if (event.description) {
+        lines.push(`\n${event.description}`);
+    }
+    return lines.join("\n");
+}