@adobe/data-ai 0.9.83 → 0.9.84

package/skills/build-systems/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: build-systems
+description: Build a feature's ecs system-database — the real-time tick loop (systems the scheduler runs each frame). For real-time features only.
+input: feature
+output: feature
+---
+
+Create `ecs/system-database/system-database.ts`: `Database.Plugin.create({ extends:
+Database.Plugin.combine(ComputedDatabase.plugin, scheduler), systems })` where the `systems`
+map is declared **inline** (see `features/ecs/systems.md` — inline is required for `db` to be
+typed and for system-name inference; a `systems/` folder is optional, only for extracted
+per-frame body helpers).
+
+- A system is a `SystemDeclaration`: `{ create, schedule?: { before?, after?, during? } }`.
+  `create(db)` runs once (capture queries / index handles / closures); the returned function
+  advances the world one tick. Return `void` for an init-only system (seeding entities).
+- The step math lives in `data/`; each system reads store rows, calls the pure `data/` step,
+  writes back — via `db.store` (writable) for hot per-row work, or `db.transactions.*` for
+  discrete events. Iterate archetypes per `archetypes.md` (tail→head when destroying rows).
+- Order under `schedule` (mirror the `data/` step's internal sequence); drive the loop by
+  combining `scheduler` (rAF), gated by the `schedulerState` resource.
+
+**Only for real-time features** (games, sims) — turn-based features skip this phase entirely.
+Comes after `build-computed`. The how is in the auto-loading `features/ecs/systems.md` rule.

package/skills/build-transactions/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: build-transactions
+description: Build a feature's ecs transaction-database — atomic mutations over the store.
+input: feature
+output: feature
+---
+
+Create `ecs/transaction-database/`: `transaction-database.ts` (extends `IndexDatabase`, adds
+`transactions` from `./transactions/index.js`) plus a `transactions/` folder — one mutation per
+file + barrel. Type the store param `CoreDatabase.Store` (entities/resources/archetypes) or
+`IndexDatabase.Store` (reads an index).
+
+Comes after `index-database` (or `core-database` if no indexes).
+
+The how is in the auto-loading `features/ecs/transactions.md` rule.

package/skills/build-ui/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: build-ui
+description: Build a feature's ui/ layer — presentation bound to the ecs database. The final, top layer.
+input: feature
+output: feature
+---
+
+Create `ui/`: one folder per UI unit —
+`<name>/{<name>.ts (lazy wrapper), <name>-element.ts (container), <name>-presentation.ts (pure render), <name>.css.ts}`.
+The element subscribes to state and delegates to the pure presentation; no business logic here.
+
+Comes last. The how is in the auto-loading `features/ui/index.md` rule (and `element.md`,
+`lazy-element.md`, `presentation.md`).

package/skills/meta-build/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: meta-build
+description: Iteratively build an application or game phase-by-phase in clean subagents, reviewing each phase and refining the build-* skills / rules until each is optimal, then summarizing.
+input: a prompt describing the application or game to build
+options:
+    target = build-application   # build command to exercise: build-application | build-game | build-feature | a single build-<phase>
+    maxIterations = 4            # attempts per phase before moving on
+---
+
+Purpose: exercise and **polish the build-* skills and the rules they reference**, using
+a concrete app/game prompt as the test case. You are improving the *general* guidance,
+not the one-off output.
+
+## Procedure
+
+1. Resolve `target` to its **ordered phases**. A composite target expands to its pipe —
+   `build-feature` → its `/build-*` layer steps; `build-application` / `build-game` →
+   `build-feature` for the base and each peer, then `build-app-entry`. A single
+   `build-<phase>` target is just that one phase.
+
+2. For each phase, in order:
+   a. **Run it in a fresh subagent** with constrained context (`/x-subagent`): give the
+      subagent only the phase skill (`/<phase>`), the app/game prompt, and the files on
+      disk from prior phases — nothing about this loop or earlier attempts, so every
+      re-run differs only by any edits you made to the guidance.
+   b. **Review** the phase output in a subagent with `/review`.
+   c. If `/review` is not OPTIMAL: fix the **root cause in the guidance** — edit the
+      phase skill or a rule it references. Keep every edit **concise and general**:
+      improve it for all apps, never encode anything specific to this prompt. (For a
+      pure `code` slip with sound guidance, just re-run.) Do **not** hand-patch the
+      generated code.
+   d. Re-run from (a), up to `maxIterations` (default 4) attempts. Move to the next
+      phase once it reviews OPTIMAL — or the cap is hit (record that it did not converge).
+   e. Record: the phase, its iteration count, and every skill/rule file you edited.
+
+3. **Final review** (read-only): run `/review` over the whole product. **Change nothing.**
+   Then summarize:
+   - per-phase iteration counts,
+   - which phase skills and which rules were edited, and why,
+   - overall outcome (which phases converged, which hit the cap).
+
+Every phase runs in its own constrained subagent so re-executions during polishing stay
+consistent — the edited skill/rule is the only variable between a phase's attempts.

package/skills/review/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: review
+description: Review built feature/application output against the @adobe/data feature rules; report whether it is optimal and where any fix belongs. Read-only.
+input: a path to built output (a layer, a feature, or a whole app)
+output: a review — OPTIMAL, or a list of issues each tagged code | skill | rule
+---
+
+Read the files under the given path and assess them against the relevant `features/`
+rules (each layer's rule and the cross-cutting rules — `namespace`, `data-modelling`,
+`type-casts`, `cohesion`, …):
+
+- **Correctness** — does it typecheck and follow the layer's required shape?
+- **Adherence** — single public export per file, naming, the scope helpers
+  (`Database.components` / `resources` / `archetypes`), `satisfies` targets, barrels,
+  store-layer typing, etc.
+- **Generality** — no leaked type identities; follows the cross-cutting patterns.
+
+Report either **OPTIMAL**, or a short list of issues. Tag each issue with where the
+root-cause fix belongs:
+
+- `code` — a one-off slip in the generated files (guidance is fine),
+- `skill` — the phase skill's instructions are unclear, wrong, or incomplete,
+- `rule` — a referenced rule is unclear, wrong, or missing guidance.
+
+Do not edit anything — assessment only.

package/skills/structure/SKILL.md

@@ -0,0 +1,7 @@
+---
+name: structure
+description: Use when laying out or reasoning about a feature's file/folder structure and layer dependencies.
+---
+
+See `features/index.md` (and the per-folder `features/` rules) for how features are
+structured and layered.

package/skills/x-alpha/SKILL.md

@@ -0,0 +1,7 @@
+---
+name: x-alpha
+input: void
+output: string
+---
+
+return "alpha";

package/skills/x-beta/SKILL.md

@@ -0,0 +1,7 @@
+---
+name: x-beta
+input: void
+output: string
+---
+
+return "beta";

package/skills/x-double/SKILL.md

@@ -0,0 +1,7 @@
+---
+name: x-double
+input: number
+output: number
+---
+
+return input * 2

package/skills/x-execute/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: x-execute
+description: executes an input optionally with validate first
+input: piped function calls
+options:
+    validate = true
+output: input.output
+---
+
+if options.validate && not /x-validate input {
+  return "Invalid not executed"
+}
+else {
+  return evaluate input
+}
+

package/skills/x-log/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: x-log
+description: logs all named inputs to chat
+input: any
+output: typeof input
+---
+
+write the input to the chat concisely in the following format
+
+    input: <type> = <value>
+
+return input

package/skills/x-pow/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: x-pow
+input:
+    base: number
+    exponent: number
+output: number
+---
+
+return base ^ exponent

package/skills/x-subagent/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: x-subagent
+description: executes the input within a subagent
+input: any
+output: <input.output>
+---
+
+execute the input in a subagent without session context and return the result

package/skills/x-trace/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: x-trace
+description: inserts a /x-log call right after every non log piped function
+input: piped function calls
+output: piped function calls
+---
+
+insert a /x-log call after each piped function call
+
+return the resulting piped function calls
+

package/skills/x-validate/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: x-validate
+description: validates nested or piped function calls to determine if output types match all required input types
+input: piped function calls
+options:
+    log = true
+output: boolean
+---
+
+for each nested or piped function pair {
+    check that the output type matches the required input types of the next
+}
+
+if options.log then {
+    log results to chat
+}
+
+return true if they all validate or false if they don't
+
+# Log
+
+If `options.log`, print the pipeline **in source order**: initial value, then each `/skill` **exactly as many times as it appears** in the expression. **Never** add or omit a `/skill` that is not in the source.
+
+**Between steps:** After a literal or `/skill`, before the next `/skill`, print **one** indented line:
+
+- **OK** — the type leaving the producer toward the next step.
+- **Fail** — only `<output> != <input>` (what the producer emitted vs what the next step requires). **No** separate line for the output type alone; the mismatch line is the whole message between that pair.
+
+Put that line **after** the producer (literal or `/skill`) and **before** the consumer’s `/skill`. Never put the failure summary under the consumer.
+
+After the first rejection, list remaining `/skill` lines from the source; each gets `—` as its only indented line (unreachable).
+
+## Examples
+
+2 | /x-double |> /x-double |> /x-log
+
+2
+  number
+/x-double
+  number
+/x-double
+  number
+/x-log
+
+"foo" | /x-double |> /x-double |> /x-log
+
+"foo"
+  string != number
+/x-double
+  —
+/x-double
+  —
+/x-log
+  —
+
+12 | /x-double |> /x-alpha |> /x-double |> /x-log
+
+12
+  number
+/x-double
+  number
+/x-alpha
+  string != number
+/x-double
+  —
+/x-log
+  —

package/skills/bar/SKILL.md

@@ -1,8 +0,0 @@
----
-name: bar
-description: Sample skill that greets bar. Placeholder demonstrating the @adobe/data-ai skill-bundle wiring; replace with a real architecture skill.
----
-
-# bar
-
-Say "hello bar".

package/skills/foo/SKILL.md

@@ -1,8 +0,0 @@
----
-name: foo
-description: Sample skill that greets foo. Placeholder demonstrating the @adobe/data-ai skill-bundle wiring; replace with a real architecture skill.
----
-
-# foo
-
-Say "hello foo".