@ethlete/cli 2.1.0-next.9 → 3.0.0-next.17

package/CHANGELOG.md

@@ -1,5 +1,89 @@
 # @ethlete/cli
 
+## 3.0.0-next.17
+
+### Minor Changes
+
+- Add `et api seed` and `et api fixtures`, which copy `.ethlete/seeds/<api>/` into the API container and run the seeds its `seeds.json` names. A clone now gitignores only its own `/.ethlete/<api>/`.
+
+## 3.0.0-next.16
+
+### Major Changes
+
+- Breaking: `release()` takes `{ args, root?, invocation? }` and resolves to an exit code instead of exiting. `et release` tags after the release commit and takes `--message` and `--help`; `et update` names the `.npmrc` whose token was refused.
+
+### Minor Changes
+
+- New `et migrations` lists the recommended and optional migrations an app has not run, and `et migrations run <package>:<name>` runs one and records it in `.ethlete/migrations.json`.
+- `et update` runs only `required` migrations and points at the recommended and optional ones it left.
+- `et migrations` shows the number of affected files next to each migration whose manifest entry names a `scan` generator.
+- Peer dependencies are ranges (`^22.1.0` for Angular, `^7.8.0` for RxJS, ...) instead of the workspace's exact versions. `et update` says when another dist tag holds a newer major, also when the repo is up to date.
+
+### Patch Changes
+
+- `et release` and `et update` now reject values on boolean flags and empty `--tag=`/`--to=`, and version comparison ignores build metadata.
+- `et update --from` rejects a version that is not one, such as `core@v5.0.0`, instead of running every migration of the package.
+- The call title bar no longer covers the top of a drawing: the drawing starts below it, and it fades out while the drawing scrolls down and back in on scroll up.
+
+## 2.1.0-next.15
+
+### Minor Changes
+
+- `et update --ai` ends an interactive agent session by itself once the agent writes the task's `.finished` file, then commits the task and starts the next one. `/exit` still works.
+
+## 2.1.0-next.14
+
+### Minor Changes
+
+- `et update` commits each step by itself - the version bump, each codemod, the agent rules sync and each finished `--ai` task - and never a file that was dirty before the run; `--no-commit` turns this off.
+- `et update --ai` without `updateAgentCommand` lists the agent CLIs on `PATH` and saves the one you pick, as an interactive session or a headless run.
+
+### Patch Changes
+
+- The Claude Code choices in `et update --ai` start the agent in auto mode, so it can run its checks without asking.
+- `et update --ai` tells you, for each task and in the agent's last message, to type `/exit` so the next task starts.
+
+## 2.1.0-next.13
+
+### Patch Changes
+
+- `et update` hands the migrations to the newly installed `et` when the update moves `@ethlete/cli`, so steps a newer CLI added, such as the agent rules sync, run in that same update.
+- `et update` follows the dist tag that holds the newest version of the installed prerelease line, so a package that changesets published to `latest`, such as `@ethlete/agent-rules`, no longer stays on the older `next` version.
+
+## 2.1.0-next.12
+
+### Patch Changes
+
+- `et api clear` keeps a checkout git cannot read, and `et api up` and `setup` no longer fail on output over 1 MB.
+- `et api clear` also keeps a checkout with stashes or detached-HEAD commits, `checkout` never reads a branch as a flag or path, `-h` shows help, and a port held on loopback or IPv6 counts as taken.
+- `ethlete api` no longer leaves an `ethlete-api-*` directory in the temp folder after each podman run.
+- GitLab token checks refuse redirects, `auth.json` is narrowed before the token is written, `release` matches its flags exactly, and `doctor` reports a broken legacy config file.
+- `et design check` closes the browser when the page fails, and `et design serve` resolves calls on Windows.
+- `et doctor` reports an `ethlete.apis.js` that throws while it loads instead of crashing.
+- `release --force` stages only the files `changeset version` changed instead of running `git add .`, so unrelated uncommitted changes stay out of the "Release versions" commit.
+- `et update` passes the agent prompt through environment variables, sends `.npmrc` registry tokens, keeps CRLF line endings, skips git-ignored manifests, and rejects migration names or instructions outside the package.
+- `et update` prefers the lockfile over the calling `npx`, runs package managers on Windows, and points every run to `--continue` while an update is unfinished.
+
+## 2.1.0-next.11
+
+### Minor Changes
+
+- `et update` runs `ethlete-agents sync` after the install when it moved `@ethlete/agent-rules` and the repo has an `ethlete-agents.config.json`, so the regenerated rules and skills match the tasks the update writes.
+
+### Patch Changes
+
+- `et update --ai` stops before any change when `updateAgentCommand` is missing, hands the agent a real prompt, reports each task, and works on the tasks an earlier run left.
+- `et update` gitignores its task list, so a later run no longer needs `--force`, and `--continue` keeps the `--from` versions and the codemods an earlier run applied.
+- Fix `et update` for a real consumer: the `et` bin runs, `--continue` skips applied codemods, `--check` reports an unfinished run, lookups use the repo's registry, task links point at the right docs site, and failed syncs are reported.
+- `yarn et update` on yarn 1 installs from the registry the repo's `.npmrc` or `.yarnrc` names, not the default registry yarn exports to scripts.
+- `et update` drops deleted tasks from `tasks.md` even when nothing is pending, prints "none" for an empty dry-run migration list, and aligns the `--continue` plan.
+
+## 2.1.0-next.10
+
+### Patch Changes
+
+- A design call now lists its drawings as `variants` in `variant-<key>.ts` files, and `et design check` takes `--variant`; the old `options` key and `--option` flag are gone.
+
 ## 2.1.0-next.9
 
 ### Minor Changes

package/README.md

@@ -5,7 +5,7 @@ Repo tooling - installs the `et` binary.
 ## Installation
 
 ```bash
-yarn add --dev @ethlete/cli
+yarn add --dev @ethlete/cli@next
 ```
 
 ## `et release`
@@ -14,7 +14,9 @@ yarn add --dev @ethlete/cli
 yarn et release
 ```
 
-Turns pending changesets into a tagged, pushed release commit (version → tag → commit → push).
+Turns pending changesets into a tagged, pushed release commit (version → commit → tag → push). A
+failed commit stops the run before any tag exists. Pass `--message "chore(release): Release versions"`
+when a commit-msg hook rejects the default `Release versions`; `et release --help` lists the flags.
 
 ## `et auth`
 
@@ -47,23 +49,36 @@ yarn et update --tag latest               # leave the prerelease line
 yarn et update core --to 5.0.0-next.55    # an exact version for the package you name
 yarn et update --continue                 # finish a run that stopped
 yarn et update --ai                       # hand every agent-assisted task to an agent
+yarn et update --no-commit                # leave every change uncommitted
 ```
 
 The target follows the dist tag the installed version is on, so a repo on a `-next` prerelease stays
-on `next`. The working tree must be clean, because the codemods rewrite files; `--force` skips that
+on `next`, and a repo on `latest` is told per package when a newer major waits on `next`. The working
+tree must be clean, because the codemods rewrite files; `--force` skips that
 check.
 
 The install runs before the migrations are read, because the migrations of a version ship inside that
 version. A run that stops leaves `.ethlete/update/pending.json` behind, and `--continue` picks it up -
 starting over would skip every migration the stopped run had not reached.
 
+When the update moved `@ethlete/agent-rules`, it runs `ethlete-agents sync` before the codemods, so the
+rules and skills match the tasks it writes. `--continue` skips the codemods that already applied, and
+every other run exits 1 and points to `--continue` while a stopped run is unfinished.
+
 Everything a codemod cannot decide is written to `.ethlete/update`: `tasks.md` for you, `tasks.json`
 for an agent, and one file per task holding the instructions the package ships. A task is `manual` (it
 needs a decision), `assisted` (written as a prompt for an agent) or `unsupported` (a codemod this repo
 has no Nx to run, with the command to run it by hand).
 
-`--ai` hands each assisted task to the command in `updateAgentCommand` in
-`ethlete.config.local.json`, one run per task. No agent is detected automatically.
+`--ai` hands each open assisted task to the command in `updateAgentCommand` in
+`ethlete.config.local.json` (for example `claude --permission-mode auto`), one run per task,
+and reports each run. It also works on the tasks an earlier run left. When the key is missing, `--ai`
+lists the agent CLIs on `PATH` and saves the command you pick.
+
+Each step is committed by itself: the version bump with the lockfile, each codemod that changed files,
+the agent rules sync, and each agent task that ends done. A commit takes only the paths its step
+changed, and a step that touched a file you had changed before the run is left uncommitted.
+`--no-commit` commits nothing.
 
 A package declares its migrations in `migrations.json` at its own root, pointed at from `package.json`
 with `"ethlete": { "migrations": "./migrations.json" }`. The full format is on the docs site.
@@ -89,10 +104,18 @@ yarn et api clone hub           # clone the API into .ethlete/hub
 yarn et api clear hub           # remove that clone again
 yarn et api clear --all         # remove every managed clone
 yarn et api setup hub           # run the API's own setupCommand, which writes its .env
+yarn et api seed hub            # list the seeds in .ethlete/seeds/hub/seeds.json
+yarn et api seed hub demo,shop  # run two of them, in that order
+yarn et api fixtures hub demo   # load the fixtures, then run the demo seed
 ```
 
 Every command takes a comma-separated list of names, and acts on each API in turn.
 
+`seed` and `fixtures` read `.ethlete/seeds/<name>/seeds.json`, copy that folder into the API
+container at `$SEED_DIR`, and run the shell lines of each seed you name there. The folder is
+committed, so gitignore each managed checkout as `/.ethlete/<name>/`, never `.ethlete/` as a whole.
+An `exec` entry named `seed` or `fixtures` runs instead.
+
 `clone`, `checkout`, `pull`, `setup` and `clear` act on the checkout itself, so they work before the
 API has an `.env` and need no container engine. `pull` refuses to run on a checkout with uncommitted
 changes unless you pass `--force`. `--force` resets the branch to its remote and throws away local
@@ -174,5 +197,5 @@ fallback with a warning. Add `ethlete.config.local.json` to your `.gitignore`.
 
 Full command reference on the docs site:
 
-- [Overview & usage](https://ethlete-sdk-docs.web.app/cli/)
-- [Updating the SDK](https://ethlete-sdk-docs.web.app/cli/update)
+- [Overview & usage](https://ethlete-sdk-docs-next.web.app/cli/)
+- [Updating the SDK](https://ethlete-sdk-docs-next.web.app/cli/update)

package/design/define-call.ts

@@ -37,9 +37,9 @@ export const drawing = (drawn: Drawing): Drawing => drawn;
 
 /**
  * One drawn answer to a call. `load` resolves the module whose default export is the
- * drawing that answers it, so a broken option breaks its own frame only.
+ * drawing that answers it, so a broken variant breaks its own frame only.
  */
-export type CallOption = {
+export type CallVariant = {
   key: string;
   name: string;
   /** Left out by a view: a single drawing answers no question, so it argues nothing. */
@@ -53,8 +53,8 @@ export type CallOption = {
 };
 
 /**
- * One pass over a call: the options drawn together, and what came out of them. A round
- * whose options all carry a verdict is settled, and the page folds it down to its winner.
+ * One pass over a call: the variants drawn together, and what came out of them. A round
+ * whose variants all carry a verdict is settled, and the page folds it down to its winner.
  */
 export type CallRound = {
   key: string;
@@ -71,8 +71,8 @@ export type CallRound = {
 export type CallMode = 'wireframe' | 'design';
 
 /**
- * One open question of an exploration, with every option drawn at the same geometry.
- * A call with one option and no claim is a view: one reference picture, drawn full width.
+ * One open question of an exploration, with every variant drawn at the same geometry.
+ * A call with one variant and no claim is a view: one reference picture, drawn full width.
  */
 export type Call = {
   /** The feature this call belongs to, for example 'the hour strip'. Left out by a loose call. */
@@ -80,13 +80,13 @@ export type Call = {
   eyebrow: string;
   headline: string;
   intro: string;
-  /** The width every option frame gets, in px. The geometry the thing ships in. */
+  /** The width every variant frame gets, in px. The geometry the thing ships in. */
   frameWidth: number;
   /** Left out by a call that draws the real thing, which is what `design` means. */
   mode?: CallMode;
   /** Left out by a short call. With rounds, the intro says only what the call is about. */
   rounds?: CallRound[];
-  options: CallOption[];
+  variants: CallVariant[];
 };
 
 export const defineCall = (call: Call): Call => call;

package/design/web/frame.ts

@@ -3,7 +3,7 @@ import { loadEnv } from 'virtual:design-explore/env';
 
 const params = new URLSearchParams(location.search);
 const slug = params.get('call') ?? '';
-const key = params.get('option') ?? '';
+const key = params.get('variant') ?? '';
 
 await loadEnv(slug.split('/')[0] ?? '');
 
@@ -17,10 +17,10 @@ const fail = (message: string) => {
 const call = calls[slug];
 if (!call) fail(`design-explore: no call "${slug}"`);
 else {
-  const option = (await call()).default.options.find((o) => o.key === key);
-  if (!option) fail(`design-explore: call "${slug}" has no option "${key}"`);
+  const variant = (await call()).default.variants.find((o) => o.key === key);
+  if (!variant) fail(`design-explore: call "${slug}" has no variant "${key}"`);
   else {
-    const loaded = (await option.load()).default;
+    const loaded = (await variant.load()).default;
     const style = document.createElement('style');
 
     style.textContent = loaded.styles;
@@ -31,8 +31,14 @@ else {
 
 const report = () => {
   const height = Math.ceil(document.documentElement.getBoundingClientRect().height);
-  parent.postMessage({ type: 'design-explore:height', option: key, height }, '*');
+  parent.postMessage({ type: 'design-explore:height', variant: key, height }, '*');
 };
 
 new ResizeObserver(report).observe(document.documentElement);
 report();
+
+addEventListener(
+  'scroll',
+  () => parent.postMessage({ type: 'design-explore:scroll', variant: key, y: Math.round(scrollY) }, '*'),
+  { passive: true },
+);

package/design/web/host.css

@@ -203,7 +203,7 @@ main {
   color: var(--h-ink);
 }
 
-/* A folded option keeps its name on the page, so the thread of the round is still readable. */
+/* A folded variant keeps its name on the page, so the thread of the round is still readable. */
 .folded {
   display: flex;
   max-width: 68ch;
@@ -270,7 +270,7 @@ header p {
 }
 
 /*
- * A track is as wide as the frame it holds, so the options wrap to the next band when the window
+ * A track is as wide as the frame it holds, so the variants wrap to the next band when the window
  * runs out of room. Row flow is what lets them wrap: each column takes four rows, so the next one
  * starts beside it and only a full band pushes to a new line.
  */
@@ -386,7 +386,7 @@ header p {
   transform-origin: top left;
 }
 
-/* The contact sheet draws every option at once, so one screen holds the whole call. */
+/* The contact sheet draws every variant at once, so one screen holds the whole call. */
 .grid.sheet {
   --thumb-width: calc(var(--frame-width) * var(--de-scale));
 
@@ -441,7 +441,7 @@ header p {
   outline-offset: 4px;
 }
 
-/* A rejected option stays readable, and comes back to full strength under the pointer. */
+/* A rejected variant stays readable, and comes back to full strength under the pointer. */
 .column[data-verdict='rejected'] {
   opacity: 0.45;
   transition: opacity 0.15s;

package/design/web/host.ts

@@ -1,4 +1,4 @@
-import type { Call, CallOption, CallRound } from '@design-explore';
+import type { Call, CallVariant, CallRound } from '@design-explore';
 import { calls, defaultCall } from 'virtual:design-explore';
 import './host.css';
 
@@ -33,21 +33,21 @@ const listLink = (name: string, list: string[], key: string) => {
 const toggleOpen = (key: string) => listLink('open', [...opened], key);
 const togglePick = (key: string) => listLink('pick', picked, key);
 
-type Band = { key: string | null; number: number; round: CallRound | null; options: CallOption[] };
+type Band = { key: string | null; number: number; round: CallRound | null; variants: CallVariant[] };
 
 /**
- * The options are the call. A band exists because an option names it, never because `rounds`
- * declares it, so an option added without its round entry still gets a band, a heading and a
+ * The variants are the call. A band exists because a variant names it, never because `rounds`
+ * declares it, so a variant added without its round entry still gets a band, a heading and a
  * menu row - all three say the bare key until somebody writes the prose.
  */
 const bandsOf = (call: Call): Band[] => {
   const declared = new Map((call.rounds ?? []).map((round) => [round.key, round]));
   const bands = new Map<string, Band>();
 
-  for (const option of call.options) {
-    const key = option.round ?? '';
-    const band = bands.get(key) ?? { key: key || null, number: 0, round: declared.get(key) ?? null, options: [] };
-    band.options.push(option);
+  for (const variant of call.variants) {
+    const key = variant.round ?? '';
+    const band = bands.get(key) ?? { key: key || null, number: 0, round: declared.get(key) ?? null, variants: [] };
+    band.variants.push(variant);
     bands.set(key, band);
   }
 
@@ -57,7 +57,7 @@ const bandsOf = (call: Call): Band[] => {
   return [...bands.values()];
 };
 
-/** Prose that no option claims is stale prose, and it is the one thing the options cannot show. */
+/** Prose that no variant claims is stale prose, and it is the one thing the variants cannot show. */
 const problemsOf = (call: Call, bands: Band[]) => {
   const keys = (call.rounds ?? []).map((round) => round.key);
   const drawn = new Set(bands.map((band) => band.key));
@@ -66,7 +66,7 @@ const problemsOf = (call: Call, bands: Band[]) => {
     ...[...new Set(keys.filter((key, index) => keys.indexOf(key) !== index))].map(
       (key) => `two rounds share the key "${key}"`,
     ),
-    ...keys.filter((key) => !drawn.has(key)).map((key) => `round "${key}" has no options`),
+    ...keys.filter((key) => !drawn.has(key)).map((key) => `round "${key}" has no variants`),
   ];
 };
 
@@ -77,10 +77,10 @@ const problemsOf = (call: Call, bands: Band[]) => {
  */
 const chainOf = (bands: Band[]) => {
   const named = bands.filter((band) => band.key);
-  const ruled = named.length > 1 && named.every((band) => band.options.every((option) => option.verdict));
+  const ruled = named.length > 1 && named.every((band) => band.variants.every((variant) => variant.verdict));
   const chain = named
-    .map((band) => band.options.find((option) => option.verdict === 'chosen'))
-    .filter((option): option is CallOption => !!option);
+    .map((band) => band.variants.find((variant) => variant.verdict === 'chosen'))
+    .filter((variant): variant is CallVariant => !!variant);
 
   return ruled && chain.length > 0 ? chain : [];
 };
@@ -133,54 +133,54 @@ if (!load) {
   const bands = bandsOf(call);
   const chain = chainOf(bands);
   const result = chain.at(-1);
-  const isView = call.options.length === 1 && !call.options[0]?.claim;
+  const isView = call.variants.length === 1 && !call.variants[0]?.claim;
   const geometry = `--frame-width:${call.frameWidth}px`;
 
-  const frame = (option: CallOption) => `
+  const frame = (variant: CallVariant) => `
     <iframe
-      src="frame.html?call=${encodeURIComponent(slug)}&option=${encodeURIComponent(option.key)}"
-      data-option="${esc(option.key)}"
-      title="${esc(option.name)}"
+      src="frame.html?call=${encodeURIComponent(slug)}&variant=${encodeURIComponent(variant.key)}"
+      data-variant="${esc(variant.key)}"
+      title="${esc(variant.name)}"
       style="width:${call.frameWidth}px"
     ></iframe>`;
 
-  const column = (option: CallOption) => `
-    <div class="column" data-verdict="${option.verdict ?? 'open'}" ${picked.includes(option.key) ? 'data-picked' : ''}>
+  const column = (variant: CallVariant) => `
+    <div class="column" data-verdict="${variant.verdict ?? 'open'}" ${picked.includes(variant.key) ? 'data-picked' : ''}>
       ${
         isView
           ? ''
           : `<h3>
-        <a href="${togglePick(option.key)}">${esc(option.name)}</a>
-        <span class="tag">${option.verdict ?? 'open'}</span>
+        <a href="${togglePick(variant.key)}">${esc(variant.name)}</a>
+        <span class="tag">${variant.verdict ?? 'open'}</span>
       </h3>`
       }
-      <div class="stage">${frame(option)}</div>
-      ${option.claim ? `<p class="claim">${esc(option.claim)}</p>` : ''}
-      ${option.cost ? `<p class="cost">${esc(option.cost)}</p>` : ''}
+      <div class="stage">${frame(variant)}</div>
+      ${variant.claim ? `<p class="claim">${esc(variant.claim)}</p>` : ''}
+      ${variant.cost ? `<p class="cost">${esc(variant.cost)}</p>` : ''}
     </div>`;
 
-  const grid = (options: CallOption[]) =>
-    options.length === 0
+  const grid = (variants: CallVariant[]) =>
+    variants.length === 0
       ? ''
-      : `<div class="grid" style="${geometry}" ${isView ? 'data-view' : ''}>${options.map(column).join('')}</div>`;
+      : `<div class="grid" style="${geometry}" ${isView ? 'data-view' : ''}>${variants.map(column).join('')}</div>`;
 
-  const rows = (options: CallOption[]) =>
-    options.length === 0
+  const rows = (variants: CallVariant[]) =>
+    variants.length === 0
       ? ''
-      : `<ul class="folded">${options
+      : `<ul class="folded">${variants
           .map(
-            (option) =>
-              `<li data-verdict="${option.verdict ?? 'open'}"><a href="${togglePick(option.key)}">${esc(
-                option.name,
-              )}</a><span class="tag">${option.verdict ?? 'open'}</span></li>`,
+            (variant) =>
+              `<li data-verdict="${variant.verdict ?? 'open'}"><a href="${togglePick(variant.key)}">${esc(
+                variant.name,
+              )}</a><span class="tag">${variant.verdict ?? 'open'}</span></li>`,
           )
           .join('')}</ul>`;
 
-  const band = ({ key, number, round, options }: Band) => {
-    const settled = options.every((option) => option.verdict);
+  const band = ({ key, number, round, variants }: Band) => {
+    const settled = variants.every((variant) => variant.verdict);
     const open = !key || !settled || opened.has(key);
-    const drawn = open ? options : chain.length > 0 ? [] : options.filter((option) => option.verdict === 'chosen');
-    const folded = options.filter((option) => !drawn.includes(option));
+    const drawn = open ? variants : chain.length > 0 ? [] : variants.filter((variant) => variant.verdict === 'chosen');
+    const folded = variants.filter((variant) => !drawn.includes(variant));
 
     const head = !key
       ? ''
@@ -191,7 +191,7 @@ if (!load) {
           ${
             settled
               ? `<a class="fold" href="${toggleOpen(key)}">${
-                  open ? `Fold ${options.length} options away` : `Show all ${options.length} options`
+                  open ? `Fold ${variants.length} variants away` : `Show all ${variants.length} variants`
                 }</a>`
               : ''
           }
@@ -208,11 +208,11 @@ if (!load) {
   /** Each step is the one before it plus a change, so the arrow is the order they were drawn in. */
   const trail = () =>
     chain
-      .map((option) => {
-        const band = bands.find((entry) => entry.options.includes(option));
-        const target = band?.key ? `${toggleOpen(band.key)}#round-${band.key}` : togglePick(option.key);
-        return `<a href="${esc(target)}" ${option === result ? 'aria-current="step"' : ''}>${esc(
-          option.key.toUpperCase(),
+      .map((variant) => {
+        const band = bands.find((entry) => entry.variants.includes(variant));
+        const target = band?.key ? `${toggleOpen(band.key)}#round-${band.key}` : togglePick(variant.key);
+        return `<a href="${esc(target)}" ${variant === result ? 'aria-current="step"' : ''}>${esc(
+          variant.key.toUpperCase(),
         )}</a>`;
       })
       .join('<span class="arrow">→</span>');
@@ -236,21 +236,21 @@ if (!load) {
         </section>`;
 
   const tray = () => {
-    const options = picked
-      .map((key) => call.options.find((option) => option.key === key))
-      .filter((option): option is CallOption => !!option);
-    if (options.length === 0) return '';
+    const variants = picked
+      .map((key) => call.variants.find((variant) => variant.key === key))
+      .filter((variant): variant is CallVariant => !!variant);
+    if (variants.length === 0) return '';
 
-    const two = options.length === 2;
+    const two = variants.length === 2;
 
     return `
       <section class="round tray">
         <div class="round-head">
-          <span class="eyebrow">Compare · ${options.length}</span>
-          <h2>${options.map((option) => esc(option.name)).join('  ·  ')}</h2>
+          <span class="eyebrow">Compare · ${variants.length}</span>
+          <h2>${variants.map((variant) => esc(variant.name)).join('  ·  ')}</h2>
           <div class="switch">
-            ${options
-              .map((option, index) => `<button data-step="${index}">${esc(option.key.toUpperCase())}</button>`)
+            ${variants
+              .map((variant, index) => `<button data-step="${index}">${esc(variant.key.toUpperCase())}</button>`)
               .join('')}
             <span class="hint">${
               two ? 'click or space to blink · arrows to wipe' : 'click or space for the next one'
@@ -259,7 +259,7 @@ if (!load) {
           <a class="fold" href="${link({ pick: null })}">Clear the comparison</a>
         </div>
         <div class="overlay" data-two="${two}" style="width:${call.frameWidth}px">
-          ${options.map(frame).join('')}
+          ${variants.map(frame).join('')}
           <div class="seam"></div>
         </div>
       </section>`;
@@ -267,14 +267,14 @@ if (!load) {
 
   const sheet = () => `
     <div class="grid sheet" style="${geometry};--de-scale:${SHEET_SCALE}">
-      ${call.options
+      ${call.variants
         .map(
-          (option) => `
-        <a class="thumb" href="${togglePick(option.key)}" data-verdict="${option.verdict ?? 'open'}" ${
-          picked.includes(option.key) ? 'data-picked' : ''
+          (variant) => `
+        <a class="thumb" href="${togglePick(variant.key)}" data-verdict="${variant.verdict ?? 'open'}" ${
+          picked.includes(variant.key) ? 'data-picked' : ''
         }>
-          <div class="thumb-frame">${frame(option)}</div>
-          <span class="thumb-name">${esc(option.name)}</span>
+          <div class="thumb-frame">${frame(variant)}</div>
+          <span class="thumb-name">${esc(variant.name)}</span>
         </a>`,
         )
         .join('')}
@@ -286,7 +286,7 @@ if (!load) {
       : `<div class="views">
           <a href="${link({ view: null })}" ${view === 'rounds' ? 'aria-current="page"' : ''}>rounds</a>
           <a href="${link({ view: 'sheet' })}" ${view === 'sheet' ? 'aria-current="page"' : ''}>all ${
-            call.options.length
+            call.variants.length
           }</a>
         </div>`;
 
@@ -345,8 +345,8 @@ const heights = new Map<string, number>();
 
 /** The overlay is as tall as its tallest pick, so no frame is cut and none of them move. */
 const size = () => {
-  for (const frame of document.querySelectorAll<HTMLIFrameElement>('iframe[data-option]')) {
-    const height = heights.get(frame.dataset.option ?? '');
+  for (const frame of document.querySelectorAll<HTMLIFrameElement>('iframe[data-variant]')) {
+    const height = heights.get(frame.dataset.variant ?? '');
     if (!height) continue;
 
     frame.style.height = `${height}px`;
@@ -359,17 +359,17 @@ const size = () => {
   if (!overlay) return;
 
   const tallest = [...overlay.querySelectorAll<HTMLIFrameElement>('iframe')]
-    .map((frame) => heights.get(frame.dataset.option ?? '') ?? 0)
+    .map((frame) => heights.get(frame.dataset.variant ?? '') ?? 0)
     .reduce((a, b) => Math.max(a, b), 0);
 
   if (tallest > 0) overlay.style.height = `${tallest}px`;
 };
 
 addEventListener('message', (event) => {
-  const data = event.data as { type?: string; option?: string; height?: number };
-  if (data?.type !== 'design-explore:height' || !data.height || !data.option) return;
+  const data = event.data as { type?: string; variant?: string; height?: number };
+  if (data?.type !== 'design-explore:height' || !data.height || !data.variant) return;
 
-  heights.set(data.option, data.height);
+  heights.set(data.variant, data.height);
   size();
 
   if (restoring) scrollTo(0, target);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/cli",
-  "version": "2.1.0-next.9",
+  "version": "3.0.0-next.17",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -14,8 +14,8 @@
     "vite": "8.1.5"
   },
   "peerDependencies": {
-    "playwright": "1.61.1",
-    "tslib": "2.8.1"
+    "playwright": "^1.50.0",
+    "tslib": "^2.3.0"
   },
   "peerDependenciesMeta": {
     "playwright": {

package/src/index.d.ts

@@ -1 +1,2 @@
+#!/usr/bin/env node
 export * from './lib';

package/src/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
@@ -38,6 +39,11 @@ const USAGE_ROWS = [
         args: ' [packages...]',
         lines: ['Move the @ethlete/* packages to a newer version and run the', 'migrations those versions ship'],
     },
+    {
+        subcommand: 'migrations',
+        args: ' [run <package>:<name>]',
+        lines: ['List the recommended and optional migrations this repo has', 'not run yet, or run one of them'],
+    },
 ];
 const usage = (root) => {
     const rows = USAGE_ROWS.map((row) => (Object.assign(Object.assign({}, row), { command: `${(0, lib_1.repoInvocation)({ root, subcommand: row.subcommand })}${row.args}` })));
@@ -52,10 +58,11 @@ const usage = (root) => {
 const cli = (args) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
     switch (args[0]) {
         case 'release':
-            // `release` reads its flags from a list that was split on "=" before this switch existed.
-            // Keep that shape here so its own parsing is untouched.
-            yield (0, lib_1.release)(args.join('=').split('='));
-            return 0;
+            return (0, lib_1.release)({
+                root: process.cwd(),
+                args: args.slice(1),
+                invocation: (0, lib_1.repoInvocation)({ root: process.cwd(), subcommand: 'release' }),
+            });
         case 'api':
             return (0, lib_1.apiCommand)({
                 root: process.cwd(),
@@ -80,6 +87,13 @@ const cli = (args) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
                 argv: args.slice(1),
                 invocation: (0, lib_1.repoInvocation)({ root: process.cwd(), subcommand: 'update' }),
             });
+        case 'migrations':
+            return (0, lib_1.migrationsCommand)({
+                root: process.cwd(),
+                argv: args.slice(1),
+                invocation: (0, lib_1.repoInvocation)({ root: process.cwd(), subcommand: 'migrations' }),
+                updateInvocation: (0, lib_1.repoInvocation)({ root: process.cwd(), subcommand: 'update' }),
+            });
         case 'doctor':
             // Every fix it names is an `et api` command, so it needs that script rather than its own.
             return (0, lib_1.doctorCommand)({