@adobe/data-ai 0.9.83 → 0.9.86

package/skills/build-services/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: build-services
+description: Build a feature's services/ layer — async capability contracts (ports to the outside world). Optional.
+input: feature
+output: feature
+---
+
+Skip if this feature doesn't contain or require services.
+
+Create the feature's `services/` layer: one `<name>-service/` namespace folder per async
+contract — an `interface` (validated with `AsyncDataService.IsValid`), async-only members,
+and `create*` factories.
+
+Only if the feature talks to the outside world. Comes after `data/`, before `ecs/`.
+
+The how is in the auto-loading `features/services/index.md` rule (and `namespace.md`).

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
+---
+
+Skip if this feature doesn't contain or require systems.
+Most games that use a canvas will use systems but most applications will not.
+
+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).
+- 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/graph-execute/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: graph-execute
+description: executes a graph of steps
+input: piped function calls
+---
+
+The input is a set of piped function calls where each call is represented by a slash skill invocation.
+
+Each step must be completed independently before moving on to the next.
+
+The output of each phase is generally either a returned result or written to the file system. You can pass some context including any previous result to the next phase, but you must never read the subsequent phases in advance.
+
+Call each of these phases in a subagent so that they are not even aware that future phases will take place.

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".