softr-vibe-coding 1.9.0 → 1.10.1

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this skill are documented here. Versions follow [Semantic
 
 Entries from 1.3.1 onward are generated automatically from git commit subjects between version bumps (see `.github/workflows/publish.yml`). Entries before 1.3.1 were backfilled by hand from the existing commit history.
 
+## [1.10.1] - 2026-06-12
+- Document useFieldOptions companion-useRecords requirement — the hook only populates once an active useRecords in the same block has loaded the table schema; without it options settles to [] with isLoading false (bites write-only/helper blocks hardest). Add the required companion query to the example, correct the return shape to { options, isLoading } with options { id, label, color }, note the cross-table helper-block pattern, and add a prefer-live-fall-back-to-hardcoded recommendation; bump to 1.10.1
+
+## [1.10.0] - 2026-06-04
+- Bundle get-airtable-base CLI script for full base metadata export; document in SKILL.md, airtable.md, fields.md
+
 ## [1.9.0] - 2026-06-04
 - Bundle get-softr-database CLI script for schema export; document in SKILL.md, softr-database.md, fields.md
 - Bump publish workflow to Node 24-based action majors — actions/checkout@v4 -> @v6, actions/setup-node@v4 -> @v6 (clears the Node 20 deprecation; GitHub forces Node 20 actions to Node 24 on 2026-06-16). No version bump, so this run skips publish.

package/SKILL.md

@@ -87,7 +87,8 @@ When the user describes their block, figure out which of these areas apply and a
 - **Data source type**: Is it Airtable, Softr Database, REST API, or another source? This determines the data fetching approach. **Load the relevant data source guide** from the [datasources/](datasources/) directory before writing code.
 - **Data source fields**: For Airtable/Softr Database, you need actual field IDs. For REST APIs, you access the raw API response directly. If the user doesn't know field IDs:
   - For **Softr Database**, the cleanest path is the **Softr Database MCP server** — ask whether they have it installed (`claude mcp list` shows it as `softr` or similar). If yes, query schema directly with the MCP tools instead of asking for paste-ins. If no, the next-best option is the bundled **`get-softr-database` CLI script** — tell the user to run `python3 ~/.claude/skills/softr-vibe-coding/tools/get-softr-database.py <database_id>` (it prompts for their Softr API key and exports the full schema to `~/Desktop/softr-database-<id>-<timestamp>.json` — Python stdlib only, nothing to install) and paste the resulting JSON into chat. As a final fallback, ask them to paste the `tablespace-with-tables` network response (DevTools -> Network -> filter that string while on Studio's Data tab) — same JSON content, different acquisition path. Optionally tell them they can install the MCP once with `claude mcp add --transport http softr https://mcp.softr.io/mcp` for future sessions. Full MCP details in [references/softr-database-mcp.md](references/softr-database-mcp.md); CLI script details in [datasources/softr-database.md](datasources/softr-database.md#bundled-cli-script-get-softr-database); fallback paste-in workflows in [datasources/fields.md](datasources/fields.md#field-inspector-block).
-  - For **Airtable** and other sources where empty `q.select({})` works, suggest the Field Inspector block.
+  - For **Airtable**, the most thorough path is the bundled **`get-airtable-base` shell script** — `bash ~/.claude/skills/softr-vibe-coding/tools/get-airtable-base` (requires `jq` — `brew install jq` on macOS). It prompts for Base ID + PAT, then exports the full schema (every table, every field with both `fld...` IDs and column names, relationships, webhooks, interfaces) to a timestamped Desktop folder. The user pastes `02-schema.json` or the combined `00-bundle.json` into chat. For lighter inspection (just a few fields, runtime-only), suggest the Field Inspector block — empty `q.select({})` works for Airtable. CLI script details in [datasources/airtable.md](datasources/airtable.md#bundled-cli-script-get-airtable-base).
+  - For other non-Softr-DB sources where empty `q.select({})` works, suggest the Field Inspector block.
 - **Brand colors**: Already resolved in Step 1 (Detect the brand source). Don't re-ask. The brand source is one of:
   - **Project's `./DESIGN.md`** (recommended for client work — produced by the `building-design-md` skill)
   - **User's quick override** (paste of primary + accent + font)

package/datasources/airtable.md

@@ -55,6 +55,62 @@ The asymmetry matters because reads silently degrade while writes silently disab
 
 3. **Avoid renaming columns mid-project** -- use Airtable's Description field for clarification instead.
 
+## Bundled CLI script: `get-airtable-base`
+
+A Bash CLI bundled with this skill that exports an Airtable base's full metadata to a timestamped folder on your Desktop. Pulls schema, relationships, sync detection, webhooks, interfaces, and shares — everything the Airtable Web API exposes for a single base.
+
+**Script location after `npx softr-vibe-coding@latest init`:**
+
+```
+~/.claude/skills/softr-vibe-coding/tools/get-airtable-base
+```
+
+**Requirements:** `jq` (`brew install jq` on macOS), `curl` (preinstalled on macOS/Linux), Bash.
+
+**Run it:**
+
+```bash
+bash ~/.claude/skills/softr-vibe-coding/tools/get-airtable-base
+```
+
+The script prompts interactively for:
+
+- **Base ID** (e.g. `appXXXXXXXXXXXXXX` — find it in the Airtable URL or the API docs page for the base).
+- **Personal Access Token** (input hidden — needs `schema.bases:read` scope minimum, plus `webhook:manage` for webhooks, and optionally `enterpriseAccount:read` for shares).
+
+**Output folder:** `~/Desktop/airtable-base-<BASE_ID>-<UTC-timestamp>/` containing:
+
+| File | Contents |
+|---|---|
+| `00-bundle.json` | Combined bundle of all the below for easy sharing in one paste |
+| `01-base-info.json` | Collaborators, interfaces, invite links |
+| `02-schema.json` | Full schema: every table, every field (with both `fld...` IDs and column names), every view, `visibleFieldIds` per view |
+| `03-shares.json` | Enterprise-only shares — skipped on non-Enterprise plans |
+| `04-webhooks.json` | Registered webhooks |
+| `05-whoami.json` | Token identity and scopes — confirms which user/PAT was used and what it can access |
+| `06-relationships.json` | Derived from `02-schema.json`: sync destinations, cross-table links, lookup/rollup/count/formula field maps |
+
+After completion, the script opens the folder in Finder (macOS).
+
+**Optional alias** for a shorter command. Add to your `~/.zshrc` or `~/.bashrc`:
+
+```bash
+alias get-airtable-base='bash ~/.claude/skills/softr-vibe-coding/tools/get-airtable-base'
+```
+
+After `source ~/.zshrc`, run `get-airtable-base` from anywhere.
+
+**Getting a PAT:** https://airtable.com/create/tokens → Create token → grant `schema.bases:read` (add `data.records:read` only if you want to also read records via the Web API outside Softr). Scope to the specific base(s) the script should access.
+
+**When to use this:**
+
+- **Documenting field IDs alongside column names** in `q.select()` — the mitigation in [Maintainability gotcha](#maintainability-gotcha) above. Grep the `02-schema.json` for an `fld...` ID to find every block affected by a column rename.
+- **Bisecting a broken Action** when a column rename has silently disabled it — the freshest `02-schema.json` is the source of truth to grep against.
+- **Auditing relationships** (lookups, rollups, formulas, cross-table links, sync sources) — `06-relationships.json` summarizes everything the schema reveals about derived/referenced fields.
+- **Sharing schema with an AI assistant** — paste `00-bundle.json` (or just `02-schema.json` if smaller) into chat to give the assistant accurate, current schema context.
+
+This script reads only **metadata**, never records. To inspect record contents inside a Vibe Coding block, use the Field Inspector pattern in [fields.md](fields.md#field-inspector-block).
+
 ## Supported Fields
 
 | Field Type           | Writable  | Notes |

package/datasources/fields.md

@@ -107,6 +107,8 @@ export default function Block() {
 }
 ```
 
+**For Airtable specifically, the bundled `get-airtable-base` script is a more comprehensive alternative** — it exports the full base schema (every table, every field with `fld...` IDs and column names, relationships, webhooks, interfaces) to a Desktop folder via the Airtable Web API. Run with `bash ~/.claude/skills/softr-vibe-coding/tools/get-airtable-base` (requires `jq` — `brew install jq` on macOS). Best when you want a portable schema snapshot, are documenting field IDs alongside column names per the [airtable.md maintainability mitigation](airtable.md#maintainability-gotcha), or need to audit lookup/rollup/sync relationships. Full usage in [airtable.md](airtable.md#bundled-cli-script-get-airtable-base).
+
 **For Softr Database, find field IDs via:**
 
 1. **Softr Database MCP server (recommended for AI-assisted workflows)** -- if you're collaborating with an AI assistant (Claude Code, Claude Desktop, Cursor, ChatGPT, Mistral) to write Vibe Coding blocks, the official Softr MCP server is the cleanest path. The AI calls schema/list-fields tools directly against your workspace and reads back every field's `id`, `name`, `type`, and dropdown option UUIDs -- no copy-paste, no transcription errors. Full setup, scopes, and scope limitations (Softr DB only -- does NOT cover Airtable / external sources) in [../references/softr-database-mcp.md](../references/softr-database-mcp.md).

package/datasources/reading.md

@@ -108,23 +108,43 @@ var options = (result.data && result.data.pages) ? result.data.pages.flatMap(fun
 Returns the current option list for any `singleSelect` / `multipleSelects` field — without hardcoding option IDs in your block. Useful when the schema's option list changes (renames, additions, reorders) and you don't want to redeploy the block every time.
 
 ```jsx
-import { useFieldOptions, q } from "@/lib/datasource";
+import { useFieldOptions, useRecords, q } from "@/lib/datasource";
+
+var specSelect = q.select({ status: "Status" });
+
+// REQUIRED: a companion records query in the SAME block loads the table schema that
+// useFieldOptions reads from. Without it, useFieldOptions settles to `{ options: [] }`
+// (isLoading false, length 0) even though the field has choices. count: 1 is enough.
+useRecords({ select: specSelect, count: 1 });
 
 var statusOptions = useFieldOptions({
-  select: q.select({ status: "Status" }),
+  select: specSelect,
   field: "status",   // the ALIAS from q.select(), NOT the raw field ID
 });
 
-// statusOptions.options → [{ id: "sel...", label: "Active" }, { id: "sel...", label: "Inactive" }]
-// Each item has `id` (the option's UUID, used in mutate payloads) and `label` (display string).
+// statusOptions → { options: [...], isLoading: bool }
+// statusOptions.options → [{ id: "sel...", label: "Active", color: "greenLight1" }, ...]
+//   id    — the option's UUID, used in mutate payloads
+//   label — display string
+//   color — Airtable swatch color name (optional; handy for tinting chips)
 ```
 
+**⚠️ Gotcha — requires a companion `useRecords` (verified 2026-06-12).** `useFieldOptions`
+only populates once an active `useRecords` in the same block has loaded that table's schema.
+This bites hardest in **write-only / invisible helper blocks** (the natural home for an
+option-publishing helper) because they otherwise never query records — so `options` stays
+`[]` forever with `isLoading: false`, which looks like "the field has no choices." The fix is
+a throwaway `useRecords({ select, count: 1 })` alongside the `useFieldOptions` call(s); the
+same `select` object can be shared by both. Reuse one `select` for many fields and call
+`useFieldOptions` once per field (alias). Symptom to recognise: hook returns
+`{ options: [], isLoading: false }` while the block is correctly bound to the data source.
+
 **When to use this vs. hardcoding:**
 
-- **Use `useFieldOptions`** when option IDs / labels could change post-deploy — selects with rapidly-evolving lists, user-editable choices, or any case where re-pasting blocks for an option rename is annoying.
-- **Hardcode** when the option set is stable and frequently referenced (e.g. a status enum that drives a state machine), so the IDs live in source and rename-safety is enforced by greppable constants.
+- **Use `useFieldOptions`** when option IDs / labels could change post-deploy — selects with rapidly-evolving lists, user-editable choices, or any case where re-pasting blocks for an option rename is annoying. Cross-table case: to render a select field from table B inside a block bound to table A (e.g. an intake form bound to Jobs that needs the Wigs `Color` options), put the `useRecords` + `useFieldOptions` in a hidden helper block bound to table B and publish the options to a `window` global (see [helper-blocks.md](../references/helper-blocks.md)).
+- **Hardcode** when the option set is stable and frequently referenced (e.g. a status enum that drives a state machine), so the IDs live in source and rename-safety is enforced by greppable constants. A robust middle ground: prefer the live options, fall back to a hardcoded list per field so the UI still renders if the helper hasn't published yet.
 
-`useFieldOptions` is the read-side equivalent of using `useLinkedRecords` for foreign records — it abstracts away the field's option store. Items are shaped `{ id, label }` (note: `label`, not `title` like `useLinkedRecords`).
+`useFieldOptions` is the read-side equivalent of using `useLinkedRecords` for foreign records — it abstracts away the field's option store. Items are shaped `{ id, label, color }` (note: `label`, not `title` like `useLinkedRecords`).
 
 ## Filtering
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "softr-vibe-coding",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "Claude Code skill for generating production-ready Softr Vibe Coding blocks (JSX). Installs into ~/.claude/skills/ and auto-updates on each Claude Code session.",
   "bin": {
     "softr-vibe-coding": "./bin/cli.js"

package/tools/get-airtable-base

@@ -0,0 +1,303 @@
+#!/bin/bash
+#
+# get-airtable-base
+# Pulls all available metadata for a single Airtable base via the Web API
+# and saves it to a timestamped folder on the Desktop.
+#
+
+set -euo pipefail
+
+# ---------- Colors ----------
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+GRAY='\033[0;90m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+# ---------- Pre-flight ----------
+if ! command -v jq &>/dev/null; then
+  echo -e "${RED}Error: jq is not installed.${NC}"
+  echo "Install it with: brew install jq"
+  exit 1
+fi
+
+if ! command -v curl &>/dev/null; then
+  echo -e "${RED}Error: curl is not installed.${NC}"
+  exit 1
+fi
+
+# ---------- Banner ----------
+echo ""
+echo -e "${BOLD}${BLUE}╔════════════════════════════════════════╗${NC}"
+echo -e "${BOLD}${BLUE}║     Airtable Base Metadata Fetcher     ║${NC}"
+echo -e "${BOLD}${BLUE}╚════════════════════════════════════════╝${NC}"
+echo ""
+
+# ---------- Prompts ----------
+read -r -p "$(echo -e "${BOLD}Base ID${NC} (e.g. appXXXXXXXXXXXXXX): ")" BASE_ID
+if [[ -z "$BASE_ID" ]]; then
+  echo -e "${RED}Error: Base ID is required.${NC}"
+  exit 1
+fi
+if [[ ! "$BASE_ID" =~ ^app[a-zA-Z0-9]{14}$ ]]; then
+  echo -e "${YELLOW}Warning: '$BASE_ID' doesn't look like a standard Base ID (app + 14 chars). Continuing anyway...${NC}"
+fi
+
+read -r -s -p "$(echo -e "${BOLD}Personal Access Token${NC} (input hidden): ")" TOKEN
+echo ""
+if [[ -z "$TOKEN" ]]; then
+  echo -e "${RED}Error: PAT is required.${NC}"
+  exit 1
+fi
+
+# ---------- Output folder ----------
+TIMESTAMP=$(date -u +%Y-%m-%dT%H-%M-%SZ)
+OUTPUT_DIR="$HOME/Desktop/airtable-base-$BASE_ID-$TIMESTAMP"
+mkdir -p "$OUTPUT_DIR"
+
+echo ""
+echo -e "${GRAY}Output: $OUTPUT_DIR${NC}"
+echo ""
+
+AUTH=(-H "Authorization: Bearer $TOKEN")
+API="https://api.airtable.com/v0"
+
+# ---------- Helper ----------
+# fetch URL OUTFILE LABEL [optional]
+# Writes response to OUTFILE (jq-pretty). Returns 0 on HTTP 2xx, 1 otherwise.
+fetch() {
+  local url="$1"
+  local outfile="$2"
+  local label="$3"
+  local optional="${4:-false}"
+
+  local tmp http_code body
+  tmp=$(mktemp)
+  http_code=$(curl -s -o "$tmp" -w "%{http_code}" "${AUTH[@]}" "$url" || echo "000")
+
+  if [[ "$http_code" =~ ^2 ]]; then
+    if jq '.' "$tmp" >"$outfile" 2>/dev/null; then
+      local size
+      size=$(wc -c <"$outfile" | tr -d ' ')
+      echo -e "  ${GREEN}✓${NC} $label ${GRAY}(${size} bytes)${NC}"
+      rm -f "$tmp"
+      return 0
+    else
+      echo -e "  ${RED}✗${NC} $label ${GRAY}(invalid JSON response)${NC}"
+      mv "$tmp" "$outfile.raw"
+      return 1
+    fi
+  else
+    body=$(cat "$tmp")
+    rm -f "$tmp"
+    if [[ "$optional" == "true" ]]; then
+      echo -e "  ${YELLOW}-${NC} $label ${GRAY}(HTTP $http_code — skipped)${NC}"
+    else
+      echo -e "  ${RED}✗${NC} $label ${GRAY}(HTTP $http_code)${NC}"
+      echo -e "${GRAY}    $body${NC}" | head -c 300
+      echo ""
+    fi
+    return 1
+  fi
+}
+
+# ---------- Phase 1: Identity & access ----------
+echo -e "${BOLD}Phase 1: Validating token...${NC}"
+
+fetch "$API/meta/whoami" \
+  "$OUTPUT_DIR/05-whoami.json" \
+  "Token identity (whoami)" || {
+    echo -e "${RED}Cannot continue — token is invalid or revoked.${NC}"
+    exit 1
+  }
+
+if [[ -f "$OUTPUT_DIR/05-whoami.json" ]]; then
+  scopes=$(jq -r '.scopes // [] | join(", ")' "$OUTPUT_DIR/05-whoami.json" 2>/dev/null || echo "(unknown)")
+  user_id=$(jq -r '.id // "(unknown)"' "$OUTPUT_DIR/05-whoami.json" 2>/dev/null || echo "(unknown)")
+  echo -e "${GRAY}    User: $user_id${NC}"
+  echo -e "${GRAY}    Scopes: $scopes${NC}"
+fi
+
+# ---------- Phase 2: Base schema + metadata ----------
+echo ""
+echo -e "${BOLD}Phase 2: Fetching base metadata...${NC}"
+
+fetch "$API/meta/bases/$BASE_ID?include=collaborators&include=interfaces&include=inviteLinks" \
+  "$OUTPUT_DIR/01-base-info.json" \
+  "Base info (collaborators, interfaces, invite links)" \
+  true || true
+
+fetch "$API/meta/bases/$BASE_ID/tables?include[]=visibleFieldIds" \
+  "$OUTPUT_DIR/02-schema.json" \
+  "Schema (tables, fields, views with visibleFieldIds)" || {
+    echo -e "${RED}Cannot continue without schema. Exiting.${NC}"
+    exit 1
+  }
+
+fetch "$API/meta/bases/$BASE_ID/shares" \
+  "$OUTPUT_DIR/03-shares.json" \
+  "Shares (Enterprise-only)" \
+  true || true
+
+fetch "$API/bases/$BASE_ID/webhooks" \
+  "$OUTPUT_DIR/04-webhooks.json" \
+  "Webhooks" \
+  true || true
+
+# ---------- Phase 3: Schema-derived relationships & sync detection ----------
+echo ""
+echo -e "${BOLD}Phase 3: Analyzing schema for relationships & sync...${NC}"
+
+if [[ -f "$OUTPUT_DIR/02-schema.json" ]]; then
+  jq '
+    {
+      sync_destinations: [
+        .tables[] | select([.fields[].type] | any(. == "externalSyncSource")) | {
+          tableId: .id,
+          tableName: .name,
+          syncedFields: [.fields[] | select(.type == "externalSyncSource") | {id, name}]
+        }
+      ],
+      cross_table_links: [
+        .tables[] as $t |
+        $t.fields[] | select(.type == "multipleRecordLinks") | {
+          fromTableId: $t.id,
+          fromTableName: $t.name,
+          fromFieldId: .id,
+          fromFieldName: .name,
+          toTableId: (.options.linkedTableId // null),
+          inverseFieldId: (.options.inverseLinkFieldId // null),
+          isReversed: (.options.isReversed // null),
+          prefersSingleRecordLink: (.options.prefersSingleRecordLink // null)
+        }
+      ],
+      lookup_fields: [
+        .tables[] as $t |
+        $t.fields[] | select(.type == "multipleLookupValues") | {
+          tableId: $t.id,
+          tableName: $t.name,
+          fieldId: .id,
+          fieldName: .name,
+          viaLinkFieldId: (.options.recordLinkFieldId // null),
+          targetFieldId: (.options.fieldIdInLinkedTable // null)
+        }
+      ],
+      rollup_fields: [
+        .tables[] as $t |
+        $t.fields[] | select(.type == "rollup") | {
+          tableId: $t.id,
+          tableName: $t.name,
+          fieldId: .id,
+          fieldName: .name,
+          viaLinkFieldId: (.options.recordLinkFieldId // null),
+          sourceFieldId: (.options.fieldIdInLinkedTable // null),
+          formula: (.options.reductionConditional // null)
+        }
+      ],
+      count_fields: [
+        .tables[] as $t |
+        $t.fields[] | select(.type == "count") | {
+          tableId: $t.id,
+          tableName: $t.name,
+          fieldId: .id,
+          fieldName: .name,
+          viaLinkFieldId: (.options.recordLinkFieldId // null)
+        }
+      ],
+      formula_fields: [
+        .tables[] as $t |
+        $t.fields[] | select(.type == "formula") | {
+          tableId: $t.id,
+          tableName: $t.name,
+          fieldId: .id,
+          fieldName: .name,
+          formula: (.options.formula // null),
+          referencedFieldIds: (.options.referencedFieldIds // [])
+        }
+      ]
+    }
+  ' "$OUTPUT_DIR/02-schema.json" > "$OUTPUT_DIR/06-relationships.json" 2>/dev/null
+
+  if [[ -f "$OUTPUT_DIR/06-relationships.json" ]]; then
+    sync_count=$(jq '.sync_destinations | length' "$OUTPUT_DIR/06-relationships.json")
+    link_count=$(jq '.cross_table_links | length' "$OUTPUT_DIR/06-relationships.json")
+    lookup_count=$(jq '.lookup_fields | length' "$OUTPUT_DIR/06-relationships.json")
+    rollup_count=$(jq '.rollup_fields | length' "$OUTPUT_DIR/06-relationships.json")
+    count_count=$(jq '.count_fields | length' "$OUTPUT_DIR/06-relationships.json")
+    formula_count=$(jq '.formula_fields | length' "$OUTPUT_DIR/06-relationships.json")
+    echo -e "  ${GREEN}✓${NC} Sync destinations: ${BOLD}$sync_count${NC}"
+    echo -e "  ${GREEN}✓${NC} Cross-table links: ${BOLD}$link_count${NC}"
+    echo -e "  ${GREEN}✓${NC} Lookup fields:     ${BOLD}$lookup_count${NC}"
+    echo -e "  ${GREEN}✓${NC} Rollup fields:     ${BOLD}$rollup_count${NC}"
+    echo -e "  ${GREEN}✓${NC} Count fields:      ${BOLD}$count_count${NC}"
+    echo -e "  ${GREEN}✓${NC} Formula fields:    ${BOLD}$formula_count${NC}"
+  fi
+fi
+
+# ---------- Phase 4: Combined bundle ----------
+echo ""
+echo -e "${BOLD}Phase 4: Building combined bundle...${NC}"
+
+# Ensure jq --slurpfile has something to read for endpoints that were skipped/failed.
+for f in 01-base-info.json 02-schema.json 03-shares.json 04-webhooks.json 05-whoami.json 06-relationships.json; do
+  [[ -f "$OUTPUT_DIR/$f" ]] || echo 'null' > "$OUTPUT_DIR/$f"
+done
+
+jq -n \
+  --slurpfile whoami "$OUTPUT_DIR/05-whoami.json" \
+  --slurpfile base "$OUTPUT_DIR/01-base-info.json" \
+  --slurpfile schema "$OUTPUT_DIR/02-schema.json" \
+  --slurpfile shares "$OUTPUT_DIR/03-shares.json" \
+  --slurpfile webhooks "$OUTPUT_DIR/04-webhooks.json" \
+  --slurpfile rels "$OUTPUT_DIR/06-relationships.json" \
+  '{
+     whoami: ($whoami[0] // null),
+     base_info: ($base[0] // null),
+     schema: ($schema[0] // null),
+     shares: ($shares[0] // null),
+     webhooks: ($webhooks[0] // null),
+     relationships: ($rels[0] // null)
+   }' > "$OUTPUT_DIR/00-bundle.json" 2>/dev/null || {
+     echo -e "  ${YELLOW}Could not build full bundle.${NC}"
+   }
+
+if [[ -f "$OUTPUT_DIR/00-bundle.json" ]]; then
+  size=$(wc -c <"$OUTPUT_DIR/00-bundle.json" | tr -d ' ')
+  echo -e "  ${GREEN}✓${NC} 00-bundle.json ${GRAY}(${size} bytes)${NC}"
+fi
+
+# ---------- Summary ----------
+echo ""
+echo -e "${BOLD}${GREEN}Done.${NC}"
+echo ""
+echo -e "${BOLD}Summary:${NC}"
+
+if [[ -f "$OUTPUT_DIR/02-schema.json" ]]; then
+  TABLE_COUNT=$(jq '.tables | length' "$OUTPUT_DIR/02-schema.json")
+  FIELD_COUNT=$(jq '[.tables[].fields | length] | add' "$OUTPUT_DIR/02-schema.json")
+  VIEW_COUNT=$(jq '[.tables[].views | length] | add' "$OUTPUT_DIR/02-schema.json")
+  echo -e "  Tables:     ${BOLD}$TABLE_COUNT${NC}"
+  echo -e "  Fields:     ${BOLD}$FIELD_COUNT${NC}"
+  echo -e "  Views:      ${BOLD}$VIEW_COUNT${NC}"
+fi
+
+if [[ -f "$OUTPUT_DIR/01-base-info.json" ]]; then
+  INT_COUNT=$(jq '.interfaces // {} | keys | length' "$OUTPUT_DIR/01-base-info.json" 2>/dev/null || echo 0)
+  [[ "$INT_COUNT" -gt 0 ]] && echo -e "  Interfaces: ${BOLD}$INT_COUNT${NC}"
+fi
+
+if [[ -f "$OUTPUT_DIR/04-webhooks.json" ]]; then
+  WH_COUNT=$(jq '.webhooks // [] | length' "$OUTPUT_DIR/04-webhooks.json" 2>/dev/null || echo 0)
+  [[ "$WH_COUNT" -gt 0 ]] && echo -e "  Webhooks:   ${BOLD}$WH_COUNT${NC}"
+fi
+
+echo ""
+echo -e "${GRAY}Folder: $OUTPUT_DIR${NC}"
+echo ""
+
+# Open in Finder
+if command -v open &>/dev/null; then
+  open "$OUTPUT_DIR"
+fi