@eventmodelers/cli 1.0.36 → 1.0.37

package/stacks/modeling-kit/templates/.claude/skills/examples/references/api-fallback.md

@@ -0,0 +1,118 @@
+# Examples — curl Fallback Calls
+
+Only needed when MCP is not connected. Every call below has an MCP equivalent in the main SKILL.md — always prefer that.
+
+## Step 2 — Resolve the element
+
+Try the resolution strategies in order until one succeeds.
+
+### 2a — UUID
+If `target` looks like a UUID (pattern `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`), fetch it directly:
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$target" \
+  -H "x-user-id: examples-skill"
+```
+
+### 2b — Name search
+If `target` is not a UUID, search by name:
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/events/search?name=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1]))' "$target")" \
+  -H "x-user-id: examples-skill"
+```
+
+Pick the best match (exact title match preferred; case-insensitive). If multiple matches exist, list them and ask the user to pick one.
+
+### 2c — Cell name (spreadsheet-style, e.g. "B3")
+If `target` matches the pattern `[A-Z]+[0-9]+`:
+
+1. Fetch all chapters on the board to find the relevant timeline:
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?type=CHAPTER" \
+  -H "x-user-id: examples-skill"
+```
+
+If multiple chapters exist, ask the user which one to use.
+
+2. Fetch the chapter **fresh** to decode the grid — never use cached chapter data, as cells are updated frequently:
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$CHAPTER_ID" \
+  -H "x-user-id: examples-skill"
+```
+
+From `meta.timelineData`, decode the cell name into a `cellId`:
+- Column letter(s) → 0-based column index (A=0, B=1, … Z=25, AA=26, …)
+- Row digit → 0-based row index (1→0, 2→1, …)
+- Find the matching column in `columns` and the matching row in `rows`.
+- Compute: **`CELL_ID = row.id + "-" + column.id`** (cell IDs are always `<rowId>-<columnId>`).
+
+3. **Always fetch the cell live** to get the current node list — do not rely on the `nodeId` in the chapter's cell data, as it may be stale. No MCP equivalent: `get_nodes` only filters by `type`, not `cellId`:
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes?cellId=$CELL_ID" \
+  -H "x-user-id: examples-skill"
+```
+
+Use the first non-CHAPTER result (filter out CHAPTER type).
+
+If no element is found after all strategies, stop and tell the user what was tried.
+
+Save the resolved node as `TARGET_NODE` (full JSON including `id`, `meta`, `edges`).
+
+## Step 3 — Load linked elements for context
+
+Collect nearby elements to understand the domain context and generate consistent examples. **Never fetch all board nodes.** Only fetch specific nodes you already have IDs for.
+
+### 3a — Nodes from edges
+If `TARGET_NODE.edges` is non-empty, fetch each connected node individually by its ID:
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/<EDGE_NODE_ID>" \
+  -H "x-user-id: examples-skill"
+```
+
+Fetch all edge-connected nodes in parallel (one request per node ID).
+
+### 3b — Nodes from the same column (cell-based resolution only)
+If you resolved `TARGET_NODE` via a cell name (Step 2c), you already have the full chapter `cells` array in memory. Use it — **no extra API call needed**:
+
+- Find all cells that share the same `colId` as `TARGET_NODE`'s cell.
+- Collect their `nodeId` values (skip the target itself and any cell without a `nodeId`).
+- Fetch each of those nodes individually by ID (in parallel):
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/<NODE_ID>" \
+  -H "x-user-id: examples-skill"
+```
+
+## Step 5 — Write the update
+
+Build the payload with Python to avoid shell JSON-escaping issues, then POST it:
+
+```bash
+python3 - <<EOF > /tmp/examples_payload.json
+import json, time, uuid
+payload = [{
+  "id": str(uuid.uuid4()),
+  "eventType": "node:changed",
+  "nodeId": "<TARGET_NODE.id>",
+  "boardId": "<BOARD_ID>",
+  "timestamp": int(time.time() * 1000),
+  "changedAttributes": ["meta.fields"],
+  "meta": {
+    "fields": <updated-fields-array as Python list>
+  }
+}]
+print(json.dumps(payload))
+EOF
+
+curl -s -w "\n%{http_code}" -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
+  -H "Content-Type: application/json" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: examples-skill" \
+  --data-binary @/tmp/examples_payload.json
+```

package/stacks/modeling-kit/templates/.claude/skills/handle-comment/SKILL.md

@@ -5,7 +5,7 @@ description: Place, resolve, or delete a comment on an eventmodelers board node.
 
 # Handle Comment
 
-> **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
+> **Before doing anything else**, invoke the `connect` skill — if not already connected — to resolve `TOKEN`, `BOARD_ID`, `ORG_ID`, and `BASE_URL`. Do not proceed until the connect skill has completed.
 
 Prefer `mcp__eventmodelers__*` tools when available (registered by the `connect` skill) — the curl blocks below are the fallback for sessions without MCP connected.
 
@@ -37,15 +37,7 @@ Route to the matching section below based on `action`.
 mcp__eventmodelers__add_comment { "boardId": "$BOARD_ID", "nodeId": "$NODE_ID", "text": "<text>", "type": "<COMMENT|TASK|QUESTION>", "author": "<author>" }
 ```
 
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID/comments" \
-  -H "Authorization: Bearer $TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{"text":"<text>","type":"<type>","author":"<author>"}'
-```
-
-Response: `201 {"id":"<commentId>"}`
+**Fallback (no MCP):** see `references/api-fallback.md` — "Action: place".
 
 **Batching (when called in bulk, e.g. from `wdyt`):** send one request per comment — there is no batch endpoint for comments. Fire them sequentially, not in a single payload.
 
@@ -67,11 +59,7 @@ Type: <type> | Author: <author>
 mcp__eventmodelers__get_node_comments { "boardId": "$BOARD_ID", "nodeId": "$NODE_ID" }
 ```
 
-**Fallback (no MCP):**
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID/comments" \
-  -H "Authorization: Bearer $TOKEN"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Action: resolve — Step A (resolve comment ID)".
 
 Find the comment whose `text` contains the `text` argument (case-insensitive). If multiple match, list them and ask the user to confirm. If none match, stop: "No comment found matching '<text>' on node `<nodeId>`."
 
@@ -82,11 +70,7 @@ Find the comment whose `text` contains the `text` argument (case-insensitive). I
 mcp__eventmodelers__update_comment { "boardId": "$BOARD_ID", "nodeId": "$NODE_ID", "commentId": "$COMMENT_ID", "action": "resolve" }
 ```
 
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID/comments/$COMMENT_ID/resolve" \
-  -H "Authorization: Bearer $TOKEN"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Action: resolve — Step B (resolve)".
 
 **Report:** `Resolved comment <commentId> on node <nodeId>`
 
@@ -112,10 +96,6 @@ Wait for an explicit "yes". On any other response, stop: "Deletion cancelled."
 mcp__eventmodelers__update_comment { "boardId": "$BOARD_ID", "nodeId": "$NODE_ID", "commentId": "$COMMENT_ID", "action": "delete" }
 ```
 
-**Fallback (no MCP):**
-```bash
-curl -s -X DELETE "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID/comments/$COMMENT_ID" \
-  -H "Authorization: Bearer $TOKEN"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Action: delete — Step C (delete)".
 
 **Report:** `Deleted comment <commentId> from node <nodeId>`

package/stacks/modeling-kit/templates/.claude/skills/handle-comment/references/api-fallback.md

@@ -0,0 +1,35 @@
+# Handle Comment — curl Fallback Calls
+
+Only needed when MCP is not connected. Every call below has an MCP equivalent in the main SKILL.md — always prefer that.
+
+## Action: place
+
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID/comments" \
+  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" \
+  -H "Content-Type: application/json" \
+  -d '{"text":"<text>","type":"<type>","author":"<author>"}'
+```
+
+Response: `201 {"id":"<commentId>"}`
+
+## Action: resolve — Step A (resolve comment ID)
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID/comments" \
+  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID"
+```
+
+## Action: resolve — Step B (resolve)
+
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID/comments/$COMMENT_ID/resolve" \
+  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID"
+```
+
+## Action: delete — Step C (delete)
+
+```bash
+curl -s -X DELETE "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID/comments/$COMMENT_ID" \
+  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID"
+```

package/stacks/modeling-kit/templates/.claude/skills/html-screen/SKILL.md

@@ -40,14 +40,7 @@ If `nodeId` refers to a screen that already has pages (i.e. this is an adjustmen
 mcp__eventmodelers__get_node { "boardId": "<BOARD_ID>", "nodeId": "<NODE_ID>" }
 ```
 
-**Fallback (no MCP):**
-
-```bash
-curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID" \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: agent"
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 2 — Load existing pages".
 
 - If `meta.pages` is a non-empty array, use it as the base. For an edit to an existing page, change only that entry and keep the rest of the array untouched. For "add a page", append a new entry to the end of the array — never merge new content into an existing page.
 - If it's empty or the node doesn't exist yet, design from scratch in Step 3.
@@ -59,6 +52,7 @@ Skip this step entirely when creating a brand-new node (no `nodeId` given) — g
 Write normal, full-size HTML/CSS for each page — as if designing a real webpage, not a tiny thumbnail. The canvas node renders this at a real page width and visually scales it down to fit, so there is no need to shrink font sizes or padding to fit a small box; design at a realistic scale (e.g. 16px body text, generous padding) and let the node handle the shrink.
 
 Guidelines:
+- **Keep it simple — this is a view-only mockup, not a working app.** No JavaScript, no interactivity beyond what a static page can show (enforced server-side, see below). Keep the CSS compact: inline styles or a handful of Bulma classes are enough — don't write a large embedded `<style>` block or reinvent what Bulma already gives you for free.
 - Each page is one complete, standalone HTML fragment — not a `data-step` div nested inside a shared blob. A multi-step flow (e.g. cart → payment → confirmation) is three separate pages in the array, each fully self-contained.
 - Inline styles (`style="..."`) are the simplest way to keep each page self-contained.
 - No `<script>` tags, no inline event handlers (`onclick`, `onload`, ...), no `javascript:` URIs — these are stripped server-side from every page before persisting regardless of what's sent. This is a static visual mockup, not an interactive prototype.
@@ -133,16 +127,7 @@ mcp__eventmodelers__render_screen {
 }
 ```
 
-**Fallback (no MCP):**
-
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/html-screens/$NODE_ID" \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: agent" \
-  -H "Content-Type: application/json" \
-  -d '{"pages": ["<div>...</div>", "<div>...</div>"]}'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 4 — Updating an existing node".
 
 **Creating a new node** (no `nodeId` — one is generated and placed into `chapterId`/`cellName`):
 
@@ -155,21 +140,12 @@ mcp__eventmodelers__create_screen {
   "nodeId": "<generated-uuid>",
   "chapterId": "<CHAPTER_ID>",
   "cellName": "<CELL_NAME>",
-  "pages": ["<div>...</div>"]
+  "pages": ["<div>...</div>"],
+  "fields": [ /* optional — set meta.fields here too (see Step 5) instead of a separate call */ ]
 }
 ```
 
-**Fallback (no MCP):**
-
-```bash
-NODE_ID=$(uuidgen)
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/html-screen-nodes/$NODE_ID" \
-  -H "x-token: $TOKEN" \
-  -H "x-board-id: $BOARD_ID" \
-  -H "x-user-id: agent" \
-  -H "Content-Type: application/json" \
-  -d '{"chapterId": "'"$CHAPTER_ID"'", "cellName": "'"$CELL_NAME"'", "pages": ["<div>...</div>"]}'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 4 — Creating a new node".
 
 Expect `204 No Content` on success from either curl call.
 
@@ -177,6 +153,8 @@ Expect `204 No Content` on success from either curl call.
 
 Every screen — new or updated — needs `meta.fields`: one entry per piece of data the screen displays or captures, each with a `mapping` naming where that data comes from. A screen with only a title and no fields is an empty placeholder from a data-lineage standpoint, even if the mockup itself looks complete.
 
+**For a brand-new screen** (Step 4's `create_screen` call), pass `fields` directly on that call instead of a separate `node:changed` here — one round trip instead of two. This step's separate `submit_node_events` call is still how you set/update fields on an **existing** screen (`render_screen` doesn't take `fields` either).
+
 | Field type | `mapping` | Example |
 |---|---|---|
 | User types a value, sent as a command | `"<CommandTitle>.<fieldName>"` | `"ReserveBike.bikeId"` |
@@ -205,20 +183,7 @@ mcp__eventmodelers__submit_node_events {
 }
 ```
 
-**Fallback (no MCP):**
-```bash
-curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
-  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: agent" \
-  -H "Content-Type: application/json" \
-  -d '[{
-    "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<NODE_ID>",
-    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
-    "changedAttributes": ["meta.fields"],
-    "meta": { "type": "HTML_SCREEN", "fields": [
-      {"name": "status", "type": "String", "example": "confirmed", "mapping": "ActiveReservationView.status", "cardinality": "Single"}
-    ] }
-  }]'
-```
+**Fallback (no MCP):** see `references/api-fallback.md` — "Step 5 — Define field data lineage".
 
 ## Step 6 — Report back
 

package/stacks/modeling-kit/templates/.claude/skills/html-screen/references/api-fallback.md

@@ -0,0 +1,51 @@
+# HTML Screen Designer — curl Fallback Calls
+
+Only needed when MCP is not connected. Every call below has an MCP equivalent in the main SKILL.md — always prefer that.
+
+## Step 2 — Load existing pages
+
+```bash
+curl -s "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/$NODE_ID" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: agent"
+```
+
+## Step 4 — Updating an existing node
+
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/html-screens/$NODE_ID" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: agent" \
+  -H "Content-Type: application/json" \
+  -d '{"pages": ["<div>...</div>", "<div>...</div>"]}'
+```
+
+## Step 4 — Creating a new node
+
+```bash
+NODE_ID=$(uuidgen)
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/html-screen-nodes/$NODE_ID" \
+  -H "x-token: $TOKEN" \
+  -H "x-board-id: $BOARD_ID" \
+  -H "x-user-id: agent" \
+  -H "Content-Type: application/json" \
+  -d '{"chapterId": "'"$CHAPTER_ID"'", "cellName": "'"$CELL_NAME"'", "pages": ["<div>...</div>"]}'
+```
+
+## Step 5 — Define field data lineage
+
+```bash
+curl -s -X POST "$BASE_URL/api/org/$ORG_ID/boards/$BOARD_ID/nodes/events" \
+  -H "x-token: $TOKEN" -H "x-board-id: $BOARD_ID" -H "x-user-id: agent" \
+  -H "Content-Type: application/json" \
+  -d '[{
+    "id": "<event-uuid>", "eventType": "node:changed", "nodeId": "<NODE_ID>",
+    "boardId": "<BOARD_ID>", "timestamp": <NOW_MS>,
+    "changedAttributes": ["meta.fields"],
+    "meta": { "type": "HTML_SCREEN", "fields": [
+      {"name": "status", "type": "String", "example": "confirmed", "mapping": "ActiveReservationView.status", "cardinality": "Single"}
+    ] }
+  }]'
+```