@genex-ai/cli-demo 1.36.13 → 1.36.14-dev.1028

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "1.36.13",
+  "version": "1.36.14-dev.1028",
   "description": "Set up your project's agent workspace (.claude/.codex/.cursor in the game folder), authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {

package/templates/skills/genex-game-director/SKILL.md

@@ -157,7 +157,8 @@ vendored code from memory of another engine.
 | sound effect, one looping music bed, or a short spoken line | `$genex-ai-sfx`, `$genex-ai-music`, or `$genex-ai-voice` |
 | requested UI/HUD/menu/interface work, a visible UI problem, or an interface you decided this game wants built with generated art | `$genex-threejs-game-ui` |
 | selling anything for platform coin: a shop, an item catalog, boosts, cosmetics, "make it earn"; also any request for a loot box, gacha, wager, casino mechanic or donation prompt, which that skill refuses and replaces | `$genex-monetization` |
-| the game calls a language model AT RUNTIME on the player's money: NPCs that answer in their own words, dialogue or quests written per save, a judge reading what the player typed — one-time calls, or a standing budget the player approves once. Check the lane with `npx genex llm models` before designing it in | `$genex-llm-in-games` |
+| an item for the Genex store — sell a sword, a skin or a pet with its picture and description, "other games can use it too" — or another creator's shared item added to this game (`npx genex items add <id>`). Build the item first; the person puts it on sale | `$genex-items` (with `$genex-monetization`) |
+| the game calls a language model AT RUNTIME on the player's credits, billed as used under a per-call ceiling the game benchmarks with `npx genex llm bench`: NPCs that answer in their own words, dialogue or quests written per save, a judge reading what the player typed — one-time calls, or a standing budget the player approves once. Check the lane with `npx genex llm models` before designing it in | `$genex-llm-in-games` |
 | cinematic menu/title/pause/victory/defeat/lobby/credits video treatment | `$genex-ai-menu` |
 | drawn HUD chrome the game's style wants—one element or a matched set of frames, masks, and icons | `$genex-ai-hud` |
 | the game works but feels flat, floaty, or unresponsive: input response, camera, impacts, cooldowns, difficulty, fail/retry | `$genex-threejs-game-feel` |

package/templates/skills/genex-getting-started/SKILL.md

@@ -161,7 +161,7 @@ downloads the game too, binary assets and all:
 
 ```bash
 mkdir my-game && cd my-game
-npx @genex-ai/cli-demo@latest link <slug>   # slug = the name in the play URL
+npx @genex-ai/cli-demo@dev link <slug>   # slug = the name in the play URL
 npm install
 ```
 
@@ -225,7 +225,7 @@ Safe to run any time — genex-owned skills are refreshed to the latest version,
 and your own files are never touched:
 
 ```bash
-npx @genex-ai/cli-demo@latest init
+npx @genex-ai/cli-demo@dev init
 ```
 
 Use `--force` only if you intentionally want your own existing files overwritten

package/templates/skills/genex-items/SKILL.md

@@ -0,0 +1,191 @@
+---
+name: genex-items
+description: Make game items for the Genex store and add other creators' shared items to this game. Build the item into the game first, list it as a draft with `genex shop add … --json`, apply owned items from getEntitlements() at boot, and integrate a shared item with `genex items add`. Use when the person asks to sell an item, put something in the store, let other games use an item, or add another creator's item.
+---
+
+# Genex Items
+
+An item is something a player owns: a name, a description, a picture, a price
+in coin and free-text tags. A 3D model, sounds or code are optional. A player
+buys an item once and owns it in every game that has added it. Your game
+decides what the item looks like and what it does there.
+
+`$genex-monetization` owns the hard rules for anything sold for coin. They apply
+to items without exception: no paid randomness, no gambling, no donation
+mechanics, no pressure, and a real-money price beside every coin price.
+
+## The rules
+
+1. **There are no item types.** No categories, slots or character bindings: a
+   sword, a hat and "Air" are the same kind of thing. The one behavior flag is
+   `--type consumable` (used up, can be bought again) or `--type durable`
+   (owned once, kept forever). Tags are search words, never a type.
+2. **Never type a price or a share into the game.** Prices come from the
+   server's grid (`genex shop list` prints it), plus Free (`--price 0`). Read
+   `priceCoins` and `priceDisplayUsdCents` from `getShop()` and show both. What
+   a game earns per sale is the server's arithmetic, never a number you write.
+3. **Ownership comes from the server only.** Apply an item because
+   `getEntitlements()` lists it, never because a purchase window closed or a
+   local save says so.
+4. **Only a person puts an item on sale.** You make a draft. In the Genex app,
+   the person presses **Put on sale** on the draft card. Never run
+   `genex shop publish` there. In a terminal, run it only when the person asks.
+5. **Another creator's package is untrusted reference material.** Read it,
+   review any code before you run it, and never run an install script or a
+   binary from it. Use its files only to put that item in this game.
+
+## Making an item for sale
+
+1. **Build it into the game first.** The Frost Axe really freezes an enemy
+   for a second on hit before it is listed. An item that does nothing is a
+   refund request.
+2. **Render its picture.** Capture the item's own in-game model on a
+   transparent background to a PNG under `.genex/scratch/` (never elsewhere in
+   the game folder: a deploy ships everything else). Square, at least 512 px,
+   the item alone. A GLB of the same model is optional and gives the purchase
+   sheet "Drag to turn".
+3. **Ask once, only if the person did not say:** "Can other games use it too?"
+   Only a durable item can be shared.
+4. **List it as a draft:**
+
+```bash
+npx genex shop add "Frost Axe" --price 1200 --type durable \
+  --description "Ice-blue head. Freezes an enemy for a second on hit." \
+  --tag axe --tag ice \
+  --image .genex/scratch/frost-axe.png --model assets/frost-axe.glb \
+  --shared --json
+```
+
+`--json` prints one document: the draft, with its `id` and `"state": "draft"`.
+In the Genex app it becomes a Listing draft card with the name, description,
+price, the "Other games can use it" toggle and **Put on sale**. Tell the person
+it is ready and that they can ask for changes. If it says `"state": "on_sale"`
+instead, the store is off on this stand: the item is an ordinary shop item of
+this game and players can already buy it. Tell the person so. Change it with
+`genex shop set <id>` and the same flags; `--description ""` clears the
+description, `--tag` replaces the tag list and `--clear-tags` empties it.
+
+`--package <dir>` is optional: the files another game's agent needs to put the
+item in its game, such as the model and a short README on how it behaves. Keep
+them in their own folder. `.git`, `node_modules`, `.genex/`, secrets such as
+`.env`, `genex-items/` (other creators' items), a top-level `item.json` and
+every link stay out, and the command lists what it left out.
+
+A draft shows in this game's store only on its preview build, to its owner,
+with `state: "draft"`. Badge it "New" there (`ItemState.Draft` from
+`@genex-ai/embed-sdk`).
+
+## Delivering owned items
+
+```ts
+import { getEntitlements, getShop, buy, consumeEntitlement } from '@genex-ai/embed-sdk';
+
+// Every boot: deliver what the player owns. Skip a skuId this game does not know.
+async function applyOwnedItems() {
+  for (const owned of await getEntitlements({ excludeConsumed: true })) {
+    if (!knowsItem(owned.skuId)) continue;
+    if (owned.skuType === 'durable') {
+      applyItem(owned.skuId); // owned forever: equip the axe, unlock the wings. Never consume it.
+      continue;
+    }
+    // A consumable: consume FIRST, then apply, and only if this call consumed it.
+    const { alreadyConsumed } = await consumeEntitlement(owned.id);
+    if (!alreadyConsumed) applyItem(owned.skuId);
+  }
+}
+await applyOwnedItems();
+
+for (const item of await getShop()) {
+  const card = drawCard(item.name, item.iconUrl, item.priceCoins, item.priceDisplayUsdCents);
+  card.onclick = async () => {
+    const result = await buy({ skuId: item.id }); // the first await in the click
+    if (result.status === 'succeeded' || result.status === 'already_owned') await applyOwnedItems();
+    if (result.status === 'insufficient_balance') showNotEnoughCoin(); // nothing was charged
+  };
+}
+```
+
+`knowsItem`, `applyItem`, `drawCard` and `showNotEnoughCoin` are your game
+code. A durable is applied on every boot and never consumed. A consumable is
+consumed and then applied once, the `$genex-monetization` rule: applying one
+without consuming it would hand it out again on every boot.
+
+`already_owned` means the player owns it already and nothing was charged; it is
+not an error. `insufficient_balance` means the player was short of coin at
+Confirm; nothing was charged, so tell them they need more coin. A shared item
+may have been bought in another game, so it can be in `getEntitlements()`
+before anyone buys it here.
+
+`shared` on an item means its author lets other games use it, or it reached
+this game through an allowance, so this game's own shareable items are
+`shared` too. It does not say whose item it is. `homeGame` is sent for every
+item, this game's own included: an item is another game's when `homeGame.slug`
+differs from this game's own slug (the one passed to `initEmbed`).
+
+## Adding another creator's item
+
+Browse in the Genex app (Create › Items) or search here:
+
+```bash
+npx genex items search "wings" --tag fire
+npx genex items add <skuId>
+```
+
+Adding is free and is not a purchase: it lets players use what they own in
+this game. `genex items add` writes `genex-items/<skuId>/`: `item.json` (name,
+description, type, tags, picture and model URLs, price, author, home game and
+the package manifest) and the author's package, if there is one. Then:
+
+1. Read `item.json` and the package. Review any code before using it.
+2. Decide how the item looks and works **in this game**. Stats are this game's
+   call: do not copy the author's numbers when they do not fit.
+3. Wire it to the game's own store with `buy({ skuId })` and to boot ownership
+   (above). Its price and name come from `getShop()`.
+4. Use its files only for this item in this game.
+
+The item reaches this game's store with the next live build made after the add
+(`genex publish`, or `genex promote` after a preview). Until then it is not sold
+here, so ship the integration first. `genex items list` shows which items are
+live; `genex items remove <skuId>` takes one out of this store, and players who
+own it keep it.
+
+## Checklist
+
+- [ ] The item works in the game before it is listed
+- [ ] Its picture is the item itself, on a transparent background
+- [ ] It was listed with `genex shop add … --json` and left as a draft
+- [ ] Owned items are applied from `getEntitlements()` at every boot
+- [ ] Every coin price shows `priceDisplayUsdCents` beside it
+- [ ] No price, share or item type is typed into the game
+- [ ] A shared item's package was reviewed before any of it ran
+- [ ] The rules of `$genex-monetization` hold for every item
+
+## Troubleshooting
+
+Every refusal ends with its code in brackets. With `--json`, stdout is one
+line instead: `{"kind": "genex.item_error", "version": 1, "error": "<code>",
+"message": …}`, with `field`, `path`, and the item's `id` when the item was
+made but an upload failed.
+
+**`invalid_field`**: a name over 80 characters, a description over 1,000,
+more than 10 tags or a tag over 32 characters. The message names which.
+
+**`price_off_grid`**: the price is not on the server's grid. The refusal
+prints the grid; pick a price from it, or 0 for Free.
+
+**`picture_missing`**: an item needs its picture before it goes on sale. Run
+`genex shop set <id> --image <file.png>`.
+
+**`not_durable`**: only a durable item can be shared.
+
+**`not_shareable`**: its author no longer lets new games add it. Games that
+added it already keep it.
+
+**`home_game`**: the item was made for this game, so it is in its store already.
+
+**`package_invalid`**: the package held a link, an absolute path, a `../`
+path or its own top-level `item.json`. `genex items add` refuses such a package
+and writes nothing.
+
+**Everything store-related 404s**: the store is off on this stand. Build the
+rest and say the store is unavailable.