@ultimat3/cli 20.1.0 → 20.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/cli",
-  "version": "20.1.0",
+  "version": "20.1.1",
   "description": "The `x` binary: new, dev, build, verify, generate, db, mcp, doctor, deploy",
   "license": "MIT",
   "type": "module",
@@ -37,34 +37,34 @@
   },
   "dependencies": {
     "@babel/core": "^7.28.4",
-    "@ultimat3/action": "20.1.0",
-    "@ultimat3/admin": "20.1.0",
-    "@ultimat3/ai": "20.1.0",
-    "@ultimat3/auth": "20.1.0",
-    "@ultimat3/cache": "20.1.0",
-    "@ultimat3/core": "20.1.0",
-    "@ultimat3/db": "20.1.0",
-    "@ultimat3/entity": "20.1.0",
-    "@ultimat3/flags": "20.1.0",
-    "@ultimat3/http": "20.1.0",
-    "@ultimat3/i18n": "20.1.0",
-    "@ultimat3/jobs": "20.1.0",
-    "@ultimat3/mail": "20.1.0",
-    "@ultimat3/manifest": "20.1.0",
-    "@ultimat3/mcp": "20.1.0",
-    "@ultimat3/money": "20.1.0",
-    "@ultimat3/notify": "20.1.0",
-    "@ultimat3/policy": "20.1.0",
-    "@ultimat3/pwa": "20.1.0",
-    "@ultimat3/query": "20.1.0",
-    "@ultimat3/realtime": "20.1.0",
-    "@ultimat3/render": "20.1.0",
-    "@ultimat3/schema": "20.1.0",
-    "@ultimat3/scraping": "20.1.0",
-    "@ultimat3/seo": "20.1.0",
-    "@ultimat3/storage": "20.1.0",
-    "@ultimat3/testing": "20.1.0",
-    "@ultimat3/time": "20.1.0",
+    "@ultimat3/action": "20.1.1",
+    "@ultimat3/admin": "20.1.1",
+    "@ultimat3/ai": "20.1.1",
+    "@ultimat3/auth": "20.1.1",
+    "@ultimat3/cache": "20.1.1",
+    "@ultimat3/core": "20.1.1",
+    "@ultimat3/db": "20.1.1",
+    "@ultimat3/entity": "20.1.1",
+    "@ultimat3/flags": "20.1.1",
+    "@ultimat3/http": "20.1.1",
+    "@ultimat3/i18n": "20.1.1",
+    "@ultimat3/jobs": "20.1.1",
+    "@ultimat3/mail": "20.1.1",
+    "@ultimat3/manifest": "20.1.1",
+    "@ultimat3/mcp": "20.1.1",
+    "@ultimat3/money": "20.1.1",
+    "@ultimat3/notify": "20.1.1",
+    "@ultimat3/policy": "20.1.1",
+    "@ultimat3/pwa": "20.1.1",
+    "@ultimat3/query": "20.1.1",
+    "@ultimat3/realtime": "20.1.1",
+    "@ultimat3/render": "20.1.1",
+    "@ultimat3/schema": "20.1.1",
+    "@ultimat3/scraping": "20.1.1",
+    "@ultimat3/seo": "20.1.1",
+    "@ultimat3/storage": "20.1.1",
+    "@ultimat3/testing": "20.1.1",
+    "@ultimat3/time": "20.1.1",
     "babel-preset-solid": "^1.9.15"
   }
 }

package/src/e2e-driver.ts

@@ -70,7 +70,8 @@ export const e2eFixtures = (page: PageLike, browser: E2eBrowserPage): E2eFixture
  * declaration `driverFixtures()` registered — the ordinary way a driver arrives, last registration
  * wins — so every `test('…', async ({ page }) => …)` in the suite gets a browser. `useE2eDriver`
  * is the other half: it is what makes `hasE2eDriver()` answer true and stops `e2eTest` becoming a
- * `test.skip` a green gate reports over.
+ * `test.skip` — which the gate now reports as a SKIPPED step rather than the green check it
+ * printed until #434, and which a repo whose `x.verify.json` names `e2e` gets red for.
  *
  * `budget`, `signIn` and `deploy` are deliberately NOT registered here. Each needs something a
  * page cannot supply — byte counts off a built `dist/`, an app's own sign-in route, a second build

package/src/messages.ts

@@ -279,6 +279,14 @@ const CATALOG = {
   // The `errors` step's own coverage, in `output`: a scan without a parser reads most fix lines
   // and not all of them, and a step that reports findings alone claims a completeness it lacks.
   'cli.verify.fixCoverage': 'checked {checked} fix line(s), could not read {unreadable}',
+  // Why a skipped step is a dash when the step can say so: the suite exists and not one of its
+  // tests ran. Each test's own name carries the reason it skipped, and `bun test` prints only the
+  // counts — so the line says how many and `x test <type>` prints the names.
+  'cli.verify.allSkipped': 'found {skipped} test(s) and every one skipped itself',
+  // The other shape the same counts can take: a suite that reported no test at all, skipped ones
+  // included. Its own line and not `allSkipped` with a zero, because the repair differs — there is
+  // no skipped test to read a reason off, so the files the step selected hold no test.
+  'cli.verify.ranNothing': 'found no test to run in the file(s) it selected',
   'cli.verify.serial': 'serial',
   'cli.verify.workers': '{workers} workers',
   'cli.env.checked': '{count} declared variable(s), all present and valid',

package/src/output.ts

@@ -4,6 +4,7 @@
 
 import { ERROR_DOCS_URL, renderThrowable, singleLine, stringField } from '@ultimat3/core';
 import { msg } from './messages';
+import type { TestCounts } from './test-counts';
 
 export interface Finding {
   readonly code: string;
@@ -24,6 +25,13 @@ export interface StepResult {
   readonly output?: string;
   /** Worker processes the step used; `1` means it ran serially. Absent for a non-test step. */
   readonly workers?: number;
+  /**
+   * What the step's suite executed. Absent for a step that spawned no test process, which is NOT
+   * the same state as `{ ran: 0 }` — a step with no suite and a suite whose every test skipped
+   * itself both report `skipped`, and this is the only thing that tells a reader which one it is
+   * looking at (#434).
+   */
+  readonly tests?: TestCounts;
 }
 
 export type JsonValue =
@@ -164,10 +172,27 @@ const width = (step: StepResult): string => {
   return `  ${step.workers === 1 ? msg('cli.verify.serial') : msg('cli.verify.workers', { workers: step.workers })}`;
 };
 
+/**
+ * Why a step is a dash, when the step itself can say. `- roadmap` is "there is nothing here to
+ * check"; a step that spawned a suite and executed none of it is a different state, which is what
+ * issue #434 reported as a green check — so a step carrying counts always says which it is, in one
+ * of the two shapes its counts can take. The reason each test skipped lives in that test's own
+ * NAME — `bun test` prints only the counts — so the line points at the suite and `x test <type>`
+ * is what prints the names.
+ */
+const why = (step: StepResult): string => {
+  const tests = step.tests;
+  if (step.skipped !== true || tests === undefined) return '';
+  if (tests.skipped === 0) return `  ${msg('cli.verify.ranNothing')}`;
+  return `  ${msg('cli.verify.allSkipped', { skipped: tests.skipped })}`;
+};
+
 export function renderHuman(result: CommandResult, verbose = false): string {
   const out: string[] = [];
   for (const step of result.steps ?? []) {
-    out.push(`  ${mark(step)} ${step.name.padEnd(18)} ${step.durationMs}ms${width(step)}`);
+    out.push(
+      `  ${mark(step)} ${step.name.padEnd(18)} ${step.durationMs}ms${width(step)}${why(step)}`,
+    );
     for (const finding of step.findings) out.push(renderFinding(finding, '      '));
     // NOT escaped, and that is the one exception: `output` is this process's own captured
     // subprocess stdout — `bun test`'s colour is the reason a human reads it at all, and it is
@@ -196,6 +221,9 @@ export function renderJson(result: CommandResult): string {
     skipped: step.skipped === true,
     findings: step.findings,
     ...(step.workers === undefined ? {} : { workers: step.workers }),
+    // The counts the human line's `why()` renders, as numbers: a `--json` reader deciding whether
+    // a skipped lane is missing a suite or missing a prerequisite needs the same fact CI's log has.
+    ...(step.tests === undefined ? {} : { tests: step.tests }),
     // A FAILED step carries its captured stdout, exactly as the human renderer prints it. CI runs
     // `--json`, and without this the log said only "one or more unit tests failed" with a generic
     // fix line — the failing test's name and its assertion diff existed and were thrown away, so

package/src/templates/scaffold-repo.ts

@@ -295,7 +295,9 @@ const biome = (): string => `{
  *
  * Two remain absent. `e2e` has a scaffolded file and it is an `e2eTest` — `test.skip` until the app
  * registers a browser driver, so the step would run zero tests and fail the ratchet on the
- * scaffold's own placeholder. `contract-diff` needs a committed `x.manifest.json`, which
+ * scaffold's own placeholder. Its absence is visible rather than silent: a suite that executed
+ * nothing reports as a SKIPPED step, not the green check it printed until #434, so the app's own
+ * gate line says `- e2e` and names it in the summary until a driver makes it run. `contract-diff` needs a committed `x.manifest.json`, which
  * `x manifest` writes later. Each joins the list in the commit that makes the app's gate run it.
  */
 const SCAFFOLD_FLOOR: readonly VerifyStepName[] = [

package/src/verify-run.ts

@@ -53,20 +53,29 @@ export async function runVerify(
         findings: [findingOf(error, step.name)],
       }),
     );
+    // A suite that executed nothing did not run, whatever its exit code says: `bun test` exits 0
+    // over an all-skipped file, so the counts are the only channel that can tell the two apart.
+    // ONE definition of "nothing ran", read twice, because the floor decides which of the two
+    // things it means — exactly as it already does for a step whose `applies` said no.
+    const tests = outcome.tests;
+    const nothingRan = tests !== undefined && tests.ran === 0;
+    const required = floorRequires(floor, step.name);
     // A step the floor requires whose suite executed nothing is the same vanished suite as a step
     // with no files at all — the run just had to finish before it could be seen. Appended to the
     // step's own findings so `data.failed`, the counts and every gate reading this table carry it.
-    const vanished =
-      floorRequires(floor, step.name) && outcome.tests !== undefined && outcome.tests.ran === 0
-        ? [skippedSuiteFinding(step.name, outcome.tests.skipped)]
-        : [];
+    const vanished = nothingRan && required ? [skippedSuiteFinding(step.name, tests.skipped)] : [];
     results.push({
       name: step.name,
       ok: outcome.ok && vanished.length === 0,
       durationMs: Math.round(performance.now() - started),
+      // Without a floor to require it, a suite that ran nothing is a SKIP and not a pass (#434):
+      // the `e2e` step printed `✓ e2e 46ms` over its one skipped test, which is the one thing a
+      // step table may never do — a reader cannot tell a lane that ran from a lane that did not.
+      skipped: nothingRan && !required,
       findings: [...outcome.findings, ...vanished],
       ...(outcome.output === undefined ? {} : { output: outcome.output }),
       ...(outcome.workers === undefined ? {} : { workers: outcome.workers }),
+      ...(tests === undefined ? {} : { tests }),
     });
   }
   const failedSteps = results.filter((step) => !step.ok).map((step) => step.name);