@molecule/api-ai-tools 1.8.3 → 1.9.1

package/dist/utilities.js

@@ -6,8 +6,9 @@
  */
 import { posix } from 'path';
 import { commandSegments, locatedCommandSegments } from './command-position.js';
+import { classifyRunFailure } from './failure-kind.js';
 import { commandRunsNoTests } from './no-test-run.js';
-import { isDiagnosisRun, scopedRerunCommand, suiteCommandTarget, suiteRunInTheWay, withoutHeredocs, } from './suite-overlap.js';
+import { isDiagnosisRun, scopedRerunCommand, suiteCommandTarget, suiteRunInTheWay, withoutHeredocs, withSuiteConfig, } from './suite-overlap.js';
 /**
  * Shell-safe quoting using single quotes. Unlike JSON.stringify (double quotes),
  * single-quoted strings prevent command substitution ($(), backticks) and variable expansion.
@@ -1785,6 +1786,32 @@ function normalizedSignature(s) {
         .replace(/\b\d{5,}\b/g, '<n>')
         .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, '<id>'));
 }
+/**
+ * The per-test budget a failure block's own message names, in ms, or null. Only the runner's
+ * budget kill (`Test timeout of 15000ms exceeded`) is read: a locator wait's own
+ * `Timeout 5000ms exceeded` is the config's action timeout, not the budget a test body has to fit
+ * its repeated work into.
+ *
+ * @param block - One failure block, as {@link failureBlocks} splits them.
+ * @returns The budget in ms, or null.
+ */
+function failureBudgetMs(block) {
+    const m = /\bTest timeout of (\d+)ms exceeded\b/.exec(block.replace(ANSI_SGR, ''));
+    return m ? Number(m[1]) : null;
+}
+/**
+ * The cause signature with the budget it normalized away put back: `Test timeout of <n> exceeded`
+ * becomes `Test timeout of 15000ms exceeded`. Every other `<n>` stays — those are the values that
+ * differ between tests of one cause, while the budget is the one that does not, and it is what
+ * turns "a timeout" into "15 creates in 15 s" (xr-molecule-flash-m110 +20:44).
+ *
+ * @param message - The normalized signature.
+ * @param budgetMs - The budget the cause's first block printed.
+ * @returns The signature to print.
+ */
+function signatureWithBudget(message, budgetMs) {
+    return message.replace(/Test timeout of <n> exceeded/, `Test timeout of ${budgetMs}ms exceeded`);
+}
 /**
  * What separates one cause from another in a `playwright test` log: the error CLASS plus the
  * normalized message — the error line, the thing it waited for or asserted on, and the values
@@ -2233,18 +2260,31 @@ function groupFailures(log, excluded) {
         if (group)
             group.tests.push(test);
         // The FIRST block with this signature carries the evidence: a later block of the same cause
-        // says the same thing, and the first is the one the note's own line refers to.
+        // says the same thing, and the first is the one the note's own line refers to. Its LAYER
+        // rides along too: a cause that never reached the app is not an app-code fix
+        // (`failure-kind.ts`).
         else
             byMessage.set(message, {
                 tests: [test],
                 evidence: failureEvidence(failureBody(block), message),
+                budgetMs: failureBudgetMs(block),
+                kind: classifyRunFailure(block)?.kind ?? 'assertion',
             });
     }
     const causes = [];
     for (const [message, group] of byMessage) {
         const tests = distinctTests(group.tests);
         if (tests.length > 0)
-            causes.push({ message, seconds: null, tests, evidence: group.evidence });
+            causes.push({
+                message,
+                seconds: null,
+                tests,
+                evidence: group.evidence,
+                // A duration group carries no block, so nothing says the transport failed: a cause with
+                // no layer of its own is read as an assertion (unknown is never `connection`).
+                kind: group.kind,
+                ...(group.budgetMs === null ? {} : { budgetMs: group.budgetMs }),
+            });
     }
     // The failures with no body of their own — a `list` log with no error blocks in it, from a run
     // not started in the background — are grouped by how long they took: a band is opened by its
@@ -2269,7 +2309,13 @@ function groupFailures(log, excluded) {
             byDuration.push({ seconds: t.seconds, tests: [t] });
     }
     for (const g of byDuration)
-        causes.push({ message: null, seconds: g.seconds, tests: g.tests, evidence: [] });
+        causes.push({
+            message: null,
+            seconds: g.seconds,
+            tests: g.tests,
+            evidence: [],
+            kind: 'assertion',
+        });
     const ignored = distinctTests(named).filter((t) => matchingExcludedTitles(t.title, excluded).length > 0);
     return {
         causes: causes.sort((a, b) => b.tests.length - a.tests.length),
@@ -2277,6 +2323,46 @@ function groupFailures(log, excluded) {
         flaky: flakyTests,
     };
 }
+/**
+ * The error every test of a Playwright run reports when the run loaded no base URL: `page.goto('/')`
+ * has nothing to resolve against, so the browser refuses the navigation before any page loads.
+ * xr-molecule-flash-m113 (+20:34) got ten of these and a list that called them ten causes.
+ */
+const NO_BASE_URL_ERROR = /Cannot navigate to invalid URL/i;
+/**
+ * The one-line note for a run whose EVERY failure is {@link NO_BASE_URL_ERROR}: a configuration
+ * failure, not a result about the app.
+ *
+ * A list of causes is the wrong shape here — there is one cause, and it is not in the app: the
+ * command loaded no base URL. The line names the config the run should have loaded (the caller
+ * passes the one the platform recorded for this suite) and hands over the exact narrowed command
+ * with it, so the next run measures the app instead of spending another six minutes on the same
+ * configuration mistake (xr-molecule-flash-m113 ran four such runs, 07:06:17 → 07:12:03).
+ *
+ * @param causes - The run's failures, all carrying the same error.
+ * @param run - How the run was started, when the caller knows it.
+ * @param excluded - The test titles the request carves out (inverted out of the re-run).
+ * @returns The one-line sentence.
+ */
+function noBaseUrlConfigNote(causes, run, excluded) {
+    const total = causes.reduce((n, c) => n + c.tests.length, 0);
+    const locations = [...new Set(causes.flatMap((c) => c.tests.map((t) => t.where)).filter(Boolean))];
+    const config = run?.config ?? null;
+    // The command is only worth handing over WITH the config: the same command without it is the
+    // run that just failed this way. Where the caller does not know the config, the line says what
+    // to find instead of repeating the mistake.
+    const rerun = run && config ? rerunOfRunningSuite(run, locations, excluded) : null;
+    const command = rerun ?? (run && config ? withSuiteConfig(run.command, config) : null);
+    return (`Every one of these ${total} failures is the same configuration failure, not a result about ` +
+        `the app: the run loaded no base URL, so every \`page.goto\` was refused with ` +
+        `\`Cannot navigate to invalid URL\` before a page opened. Nothing here is a defect to fix. ` +
+        (config
+            ? `\`${config}\` is the config that sets \`use.baseURL\`, and the run before this one loaded ` +
+                `it; this command left it out. `
+            : 'The app’s own Playwright config (the one that sets `use.baseURL`) has to be passed ' +
+                'with `--config`; this command names none. ') +
+        (command ? `Send exactly this: \`${command}\`` : ''));
+}
 /**
  * The one-line-per-cause summary of a finished run's failures, or null when the run named fewer
  * than two of them.
@@ -2293,11 +2379,15 @@ function groupFailures(log, excluded) {
  * exactly those tests ({@link rerunOfRunningSuite}) instead of leaving the executor to re-run the
  * whole suite.
  *
+ * A run whose failures are ALL {@link NO_BASE_URL_ERROR} is not a set of causes at all: it is one
+ * configuration failure, said in one line ({@link noBaseUrlConfigNote}) rather than a list that
+ * reads as ten defects in the app.
+ *
  * @param log - The finished run's output.
  * @param excluded - The test titles the request carves out, if the caller knows them.
  * @param run - How the run was started, when the caller knows it: the narrowed re-run is built
- *   from `command`/`cwd`, and `log` (the path the output was written to) is what the "left out"
- *   sentence greps when more causes exist than the result has room for.
+ *   from `command`/`cwd`/`config`, and `log` (the path the output was written to) is what the
+ *   "left out" sentence greps when more causes exist than the result has room for.
  * @returns The note, or null.
  */
 export function failureCausesNote(log, excluded = [], run) {
@@ -2305,6 +2395,10 @@ export function failureCausesNote(log, excluded = [], run) {
     const total = causes.reduce((n, c) => n + c.tests.length, 0);
     if (total < 2)
         return null;
+    // One cause that is not in the app: every failure is the browser refusing a navigation with no
+    // base URL. The list shape is what m113 read as ten causes, so it is never printed for this.
+    if (causes.every((c) => c.message !== null && NO_BASE_URL_ERROR.test(c.message)))
+        return noBaseUrlConfigNote(causes, run, excluded);
     // The narrowed run, so the next fix round costs two tests instead of the whole suite
     // (xr-molecule-flash-m101 +12:13 re-ran all 139, ~4 minutes, to check two). The command is the
     // run's own invocation narrowed by the ONE composer the mid-run note also uses
@@ -2314,8 +2408,21 @@ export function failureCausesNote(log, excluded = [], run) {
     const rerun = run ? rerunOfRunningSuite(run, locations, excluded) : null;
     const ignoredTitles = [...new Set(ignored.map((t) => t.title || t.where).filter(Boolean))];
     const flakyTitles = [...new Set(flaky.map((t) => t.where || t.title).filter(Boolean))];
+    // A cause that never reached the app is not a cause the app's code can fix: the transport
+    // failed, so the one action is a re-run (xr-molecule-flash-m110 +18:42 — a 20 s connection
+    // timeout was read as an assertion and answered with a CORS middleware). Every cause being one
+    // is its own sentence: nothing the app produced was measured, so there is no fix round at all.
+    const connections = causes.filter((cause) => cause.kind === 'connection');
+    if (causes.length > 0 && connections.length === causes.length) {
+        const at = [...new Set(connections.flatMap((c) => c.tests.map((t) => t.where)).filter(Boolean))];
+        return (`${total} failure${total === 1 ? '' : 's'} in this run, and every one is a CONNECTION error — ` +
+            `the requests never reached the app, so nothing here is an app-code cause${at.length ? `: ${at.join(', ')}` : ''}. ` +
+            `Send the same file${at.length === 1 ? '' : 's'} once more as ${at.length === 1 ? 'it is' : 'they are'}; ` +
+            "if the failure repeats, read the app's own log (`read_logs`) — a connection error is never a " +
+            'handler shape, a header or CORS.');
+    }
     const header = `${total} failure${total === 1 ? '' : 's'} in this run, grouped by cause — fix every cause ` +
-        `below before the next deploy:\n`;
+        `below${connections.length > 0 ? ' the app’s code can produce, and re-send the connection error once as it is' : ' before the next deploy'}:\n`;
     // The flaky sentence sits before the ignored one: the ignored sentence is the LAST thing the
     // note says, and callers assert on that ending.
     const tail = (rerun ? ` Re-run just these once they are fixed: \`${rerun}\`` : '') +
@@ -2323,7 +2430,13 @@ export function failureCausesNote(log, excluded = [], run) {
             ? ' Flaky (failed once, passed on the config retry — the runner counts these as flaky, not ' +
                 `as failures): ${flakyTitles.join(', ')}.`
             : '') +
-        (ignoredTitles.length ? ` Ignored (excluded by the request): ${ignoredTitles.join(', ')}.` : '');
+        (ignoredTitles.length
+            ? ` Ignored (excluded by the request): ${ignoredTitles.join(', ')}.`
+            : '') +
+        (connections.length > 0
+            ? ` The connection error is not app code: send that file once more as it is, and if it repeats, ` +
+                "read the app's own log (`read_logs`) — it never reached the app."
+            : '');
     // This list is the part of the result that SURVIVES the platform's tool-output cut: the stdout
     // above it is cut in the MIDDLE at {@link TOOL_RESULT_CHARS}, which is why the recap must fit
     // whole ({@link FAILURE_CAUSES_CHARS}) instead of being capped at a line count that left 3 of
@@ -2359,14 +2472,15 @@ function failureCauseLine(cause, index) {
     const tests = cause.tests.slice(0, FAILURE_CAUSE_TESTS_LISTED).map((t) => t.where || t.title);
     const more = cause.tests.length > tests.length ? `, … and ${cause.tests.length - tests.length} more` : '';
     const signature = cause.message !== null
-        ? `\`${cause.message}\``
+        ? `\`${cause.budgetMs === undefined ? cause.message : signatureWithBudget(cause.message, cause.budgetMs)}\``
         : `each after ~${cause.seconds}s (a shared duration, not a proven cause)`;
     const files = new Set(cause.tests.map((t) => specFile(t.where)).filter(Boolean)).size;
     // A line the signature already carries (a timeout's `waiting for` locator, say) is not printed
     // twice; the rest are the values the normalised signature replaced with `<n>`.
     const body = cause.evidence.filter((line) => cause.message === null || !cause.message.includes(line));
     const shortened = body.map((line) => line.length > FAILURE_EVIDENCE_CHARS ? `${line.slice(0, FAILURE_EVIDENCE_CHARS - 1)}…` : line);
-    return (`  ${index + 1}. ${signature} — ${cause.tests.length} test${cause.tests.length === 1 ? '' : 's'} ` +
+    return (`  ${index + 1}. ${cause.kind === 'connection' ? 'CONNECTION error, not the app’s — ' : ''}${signature} — ` +
+        `${cause.tests.length} test${cause.tests.length === 1 ? '' : 's'} ` +
         `in ${files} file${files === 1 ? '' : 's'}: ${tests.join(', ')}${more}` +
         (shortened.length ? `\n     ${shortened.join(' · ')}` : ''));
 }
@@ -2430,8 +2544,8 @@ function omittedCausesRecap(omitted, run, excluded) {
  * the same app and database, and that is exactly what is refused while the run walks
  * ({@link suiteRunInTheWay}).
  *
- * @param run - The run in flight: the command it was started with, as it was run, and the
- *   directory that command ran in.
+ * @param run - The run in flight: the command it was started with, as it was run, the directory
+ *   that command ran in, and the config it loaded when the caller knows it.
  * @param locations - The failing `file:line`s to re-run, as the run's log printed them.
  * @param excluded - The test titles the request carves out: the re-run inverts them out
  *   (`--grep-invert`) so it cannot report them again.
@@ -2440,7 +2554,7 @@ function omittedCausesRecap(omitted, run, excluded) {
 export function rerunOfRunningSuite(run, locations, excluded = []) {
     if (locations.length === 0)
         return null;
-    const scoped = scopedRerunCommand(run.command, locations, excluded);
+    const scoped = scopedRerunCommand(run.command, locations, excluded, run.config);
     if (scoped === run.command)
         return null;
     if (!run.cwd || commandSegments(withoutHeredocs(run.command)).some((s) => s.program === 'cd'))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@molecule/api-ai-tools",
-  "version": "1.8.3",
+  "version": "1.9.1",
   "description": "Shared AI agent tools with backend abstraction for sandbox and local execution",
   "type": "module",
   "main": "dist/index.js",