@ethlete/cli 2.1.0-next.8 → 3.0.0-next.16

package/CHANGELOG.md

@@ -1,5 +1,98 @@
 # @ethlete/cli
 
+## 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
+
+- `et update` now writes the new range into every `package.json` in the repo, not only the root one, and refuses a dist tag that points at an older version than the repo is on.
+- `et design [checkout]` serves the design page of any repository that keeps a `.ethlete/design`
+  folder, and `et design check` says why a call does not render.
+
+### Patch Changes
+
+- `et release` now works with Changesets 3 and aborts when there are no pending changesets.
+- `et design` now rules a drawing with its own Tailwind 4 pipeline, so a repository on Tailwind 3, or none at all, can hold design calls.
+- `et design check --call` now reports `NO BROWSER` when neither the checkout nor the package
+  resolves `playwright`, instead of throwing the module loader's own error.
+
 ## 2.1.0-next.8
 
 ### 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.
@@ -174,5 +189,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

@@ -0,0 +1,92 @@
+/**
+ * A value inside a template. An array joins with nothing between, and `null`, `undefined` and
+ * `false` write nothing, so `${rows.map(row)}` and `${isOn && html`…`}` both read as they look.
+ */
+const flatten = (value: unknown): string => {
+  if (Array.isArray(value)) return value.map(flatten).join('');
+  if (value === null || value === undefined || value === false) return '';
+
+  return String(value);
+};
+
+const join = (strings: TemplateStringsArray, values: unknown[]) =>
+  strings.reduce((out, part, index) => out + flatten(values[index - 1]) + part);
+
+/**
+ * Marks a template literal as HTML, so Prettier formats it and an editor highlights it. It escapes
+ * nothing: a drawing writes its own markup, and nothing a call draws comes from outside the
+ * repository.
+ */
+export const html = (strings: TemplateStringsArray, ...values: unknown[]) => join(strings, values);
+
+/** Marks a template literal as CSS, for the same reason `html` does it for markup. */
+export const css = (strings: TemplateStringsArray, ...values: unknown[]) => join(strings, values);
+
+/**
+ * One drawn answer, as the frame renders it: the markup that goes in the frame root, and the CSS
+ * that styles it. A drawing runs no logic, so it is a value the module builds when the frame
+ * imports it, not a component the frame has to instantiate.
+ */
+export type Drawing = {
+  body: string;
+  styles: string;
+};
+
+/** Types a drawing where it is written, so a mistake reads in its own file and not in `call.ts`. */
+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 variant breaks its own frame only.
+ */
+export type CallVariant = {
+  key: string;
+  name: string;
+  /** Left out by a view: a single drawing answers no question, so it argues nothing. */
+  claim?: string;
+  cost?: string;
+  /** Left out while the call is open. The user sets it, never the drawing. */
+  verdict?: 'chosen' | 'rejected';
+  /** The `key` of the round that drew it. Left out by a call that runs no rounds. */
+  round?: string;
+  load: () => Promise<{ default: Drawing }>;
+};
+
+/**
+ * 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;
+  /** What this pass asked, in a few words. */
+  title: string;
+  /** What it answered. Write it once the user has ruled, so the next round reads as a reply. */
+  note: string;
+};
+
+/**
+ * How a call is drawn. A wireframe shows the bare workflow with mocked values, and draws no
+ * logic and no interaction state. A design call draws the real thing.
+ */
+export type CallMode = 'wireframe' | 'design';
+
+/**
+ * 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. */
+  feature?: string;
+  eyebrow: string;
+  headline: string;
+  intro: string;
+  /** 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[];
+  variants: CallVariant[];
+};
+
+export const defineCall = (call: Call): Call => call;

package/design/web/env.d.ts

@@ -0,0 +1,11 @@
+declare module 'virtual:design-explore' {
+  import type { Call } from '@design-explore';
+
+  export const calls: Record<string, () => Promise<{ default: Call }>>;
+  export const defaultCall: string | null;
+}
+
+declare module 'virtual:design-explore/env' {
+  /** Loads the stylesheet the project draws under. A project the config names not draws bare. */
+  export const loadEnv: (project: string) => Promise<unknown>;
+}

package/design/web/frame.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <!--head-->
+    <style>
+      html,
+      body {
+        margin: 0;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./frame.ts"></script>
+  </body>
+</html>

package/design/web/frame.ts

@@ -0,0 +1,44 @@
+import { calls } from 'virtual:design-explore';
+import { loadEnv } from 'virtual:design-explore/env';
+
+const params = new URLSearchParams(location.search);
+const slug = params.get('call') ?? '';
+const key = params.get('variant') ?? '';
+
+await loadEnv(slug.split('/')[0] ?? '');
+
+const root = document.querySelector('#root') as HTMLElement;
+
+const fail = (message: string) => {
+  root.textContent = message;
+  root.setAttribute('style', 'padding:16px;font:14px monospace;color:#f0a0a0;background:#1a1414');
+};
+
+const call = calls[slug];
+if (!call) fail(`design-explore: no call "${slug}"`);
+else {
+  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 variant.load()).default;
+    const style = document.createElement('style');
+
+    style.textContent = loaded.styles;
+    document.head.append(style);
+    root.innerHTML = loaded.body;
+  }
+}
+
+const report = () => {
+  const height = Math.ceil(document.documentElement.getBoundingClientRect().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 },
+);