tewip-ai 0.9.0 → 0.11.0

package/README.md

@@ -166,6 +166,36 @@ that lost its markup) and **5 of 5 harmless changes ignored** (capitals, extra s
 implemented as a link, reordered sections). No designer has judged the output yet, so the roadmap's
 own metric is still open.
 
+## More runners: Robot Framework, JMeter, k6 (new)
+
+Tewip now reads **Robot Framework's output.xml**, **JMeter's .jtl** and a **k6 summary** as well as
+JUnit XML, TRX, NUnit and Playwright's own reports. A load test does not fail test by test, so a
+JMeter report becomes one line per request ("4 of 5 requests failed, an assertion failed") and a k6
+run becomes one record per crossed threshold, with the number that crossed it.
+
+Appium and Selenium need no importer: those suites report through Mocha, pytest or JUnit, which
+Tewip already reads, and their own error messages ("Could not find a connected device", "stale
+element reference") are already understood.
+
+Each reader was checked against real reports published in public repositories, which is how three
+defects were found before release - a Robot timestamp that is not a date, k6's numbers living under
+`values`, and a JMeter line that read "mostly 200" when an assertion had failed.
+
+## Before anyone reads the diff (new)
+
+```bash
+tewip review --diff main...HEAD
+```
+
+Which tests cover this change and **how** (they import the file, they import the package that
+exports it, or their words merely match); which of them have flaked before, so a red run is not
+blamed on your change; what has gone wrong in these areas before; what nothing tests at all; and the
+command to run the telling tests first. From your project's own history, so it costs nothing.
+
+Measured on **16 real commits** from two public projects, where the developers changed source *and*
+its test: given only the source files, Tewip **named the right test in 16 of 16, ranked it first in
+12**.
+
 ## Which flaky tests to quarantine, and what they cost (new)
 
 ```bash

package/TEAM-GUIDE.md

@@ -127,6 +127,7 @@ collects environment failures in one issue, and (optionally) opens a fix pull re
 | `tewip spec "<feature>"` | An epic, its user stories and acceptance criteria, grounded in your code; files them in Jira with `--project PROJ --create` | Before the work is broken down |
 | `tewip report report.xml --gate` | The CI command for GitLab, Jenkins, CircleCI, Azure, Bitbucket and the rest: diagnoses the run, comments on the GitLab merge request, and fails the build only on failures that need a person | Your CI is not GitHub Actions |
 | `tewip watch --cmd "npm test"` | Runs your tests when you save a file and explains each failure straight away | While you are writing code |
+| `tewip review --diff main...HEAD` | Which tests cover your change, which have flaked before, what nothing tests, and what to run first | Before you open a pull request |
 | `tewip flaky --days 30` | Which tests to quarantine, which to fix, what they cost in CI minutes - and when a quarantined one can come back | Monday morning |
 | `tewip note --days 7` | The weekly quality note for a lead, from runs already diagnosed (no model calls, free) | Monday morning |
 | `tewip fix --code report.xml` | Opt-in: proposes the smallest change to application code for a real bug, and keeps it only if the failing test passes and the whole suite still passes | "It is a real bug and I want a starting patch" |
@@ -140,6 +141,8 @@ Notes that save you time:
 - `write` never touches your application code. It only adds new test files, and you review and
   commit them yourself.
 - Everything it writes locally goes to the `.tewip` folder in your project.
+- Work items go to **Jira, Rally, GitHub Issues, Azure Boards or Linear** - set `TEWIP_TRACKER`, or just the credentials
+  of the one you use. GitHub Issues uses your existing `gh` login, so it needs no new secret.
 - Jira works with **Cloud, Server and Data Center**. To read tickets from a tracker anyone can read
   (many open-source ones), `TEWIP_JIRA_URL` alone is enough - no account. Writing needs a token.
 - `tewip jira` shows what it *would* file and creates nothing until you add `--create`. It never

package/dist/cli/tewip.js

@@ -67,6 +67,12 @@ Usage:
                                     the GitLab merge request, tells Slack or Teams only when a
                                     failure needs a person, and with --gate fails the build only on
                                     those failures.
+  tewip review [--diff main...HEAD] [--out review.md]
+                                    Before anyone reads the diff: which tests cover this change,
+                                    which of them have flaked before, what has gone wrong in these
+                                    areas, what nothing tests at all, and the command that runs the
+                                    telling tests first. From this project's own history, so it
+                                    costs nothing.
   tewip watch [--cmd "npm test"] [--report <path>] [--paths src,tests]
                                     Beside your editor: runs your tests when a file changes (or
                                     watches for new reports) and explains each failure as it
@@ -92,7 +98,9 @@ Usage:
   tewip --version                   Print the version.
 
 Reports it reads: Playwright, pytest/unittest, Jest, Vitest, Mocha, node:test, JUnit/TestNG
-(Maven, Gradle), Go (gotestsum), .NET (TRX or JUnit), RSpec, PHPUnit, Rust (nextest).
+(Maven, Gradle), Go (gotestsum), .NET (TRX or JUnit), NUnit 3, RSpec, PHPUnit, Rust (nextest),
+Robot Framework (output.xml), JMeter (.jtl) and k6 (--summary-export). Appium, Selenium and
+WebdriverIO suites report through one of the above, and their own error messages are understood.
 Set OPENAI_API_KEY to let the AI layer decide what the rules leave open.`;
 const flag = (args, name) => {
     const i = args.indexOf(`--${name}`);
@@ -248,6 +256,16 @@ async function main() {
                 process.exitCode = 1;
             return;
         }
+        case 'review': {
+            const { runReview } = await import('../engine/review/review-command.js');
+            await runReview({
+                root: process.cwd(),
+                diff: flag(args, 'diff') ?? 'main...HEAD',
+                out: flag(args, 'out'),
+                name: flag(args, 'name'),
+            });
+            return;
+        }
         case 'watch': {
             const { runWatch } = await import('../engine/watch/watch-command.js');
             await runWatch({

package/dist/engine/autofix/fix-selector.js

@@ -0,0 +1,93 @@
+// ACT + VERIFY for a drifted selector in a Cypress, Selenium or WebdriverIO test.
+//
+// The same loop as every other fix Tewip makes: change one thing in the test file, run that test,
+// keep the change only if it passes, and otherwise put the file back exactly as it was. What is new
+// is where the replacement comes from - the repository, not a page snapshot - which is why these
+// tools can be fixed at all without a trace.
+//
+// It will not touch application code, will not change what the test asserts, and will not offer a
+// replacement it cannot point at in the source or in a commit.
+import { relative, resolve, sep } from 'node:path';
+import { driverLocator } from '../driver-errors.js';
+import { likeItInSource, renamedInGit, tokenOf, writeSelector } from './selector-source.js';
+/**
+ * Where a selector is written in a test: the whole line, so the replacement reads in context.
+ * Cypress and Selenium put the selector in a plain string, so this is simpler than Playwright's
+ * chained calls - and looking for the quoted form keeps it from matching a comment about it.
+ */
+export function findSelectorSites(source, selector) {
+    const quoted = [`'${selector}'`, `"${selector}"`, `\`${selector}\``];
+    const sites = [];
+    source.split('\n').forEach((text, index) => {
+        if (quoted.some((q) => text.includes(q)))
+            sites.push({ line: index + 1, text });
+    });
+    return sites;
+}
+/**
+ * One drifted selector, fixed from what the repository knows. `keep` false checks a suggestion
+ * without leaving it in the file, exactly as the locator fix does.
+ */
+export async function attemptSelectorFix({ record, diagnosis, action, specFile }, deps, { keep = true } = {}) {
+    const title = record.testId.split(' > ').at(-1) ?? record.testId;
+    const result = { testId: record.testId, specFile, status: 'not-eligible', applied: false, log: [] };
+    const stop = (status, why) => ({ ...result, status, log: [...result.log, why] });
+    if (diagnosis.category !== 'LOCATOR_DRIFT' || action.kind !== 'fix-locator') {
+        return stop('not-eligible', `only a renamed element is fixed this way; this one is ${diagnosis.category} (${action.kind})`);
+    }
+    const rel = relative(resolve(deps.allowedRoot), resolve(specFile));
+    if (rel.startsWith('..') || rel.startsWith(sep) || /^[a-zA-Z]:/.test(rel))
+        return stop('outside-sandbox', `refused: ${specFile} is outside ${deps.allowedRoot}`);
+    // What the tool said it was looking for.
+    const selector = driverLocator(record.errorMessage) ?? '';
+    if (!selector)
+        return stop('no-selector', 'the error does not say which selector was not found');
+    result.log.push(`the test looked for ${selector}`);
+    // What the line in the test really holds: Selenium prints "css selector=#x" but writes "#x".
+    const written = /^[a-z ]+=\s*/i.test(selector) ? selector.replace(/^[a-z ]+=\s*/i, '') : selector;
+    const token = tokenOf(selector);
+    if (!token) {
+        return stop('not-identifiable', `${selector} is not an id, class or data attribute, so there is nothing in the source to compare it against. A person should look at the page.`);
+    }
+    // Git first: somebody renamed it, and the commit says to what. The source is the weaker answer.
+    const found = renamedInGit(deps.projectRoot, token) ?? likeItInSource(deps.projectRoot, token, deps.sources);
+    if (!found) {
+        return stop('no-replacement', `nothing in the source or in the history looks like "${token.value}" renamed. Tewip will not invent a selector.`);
+    }
+    const evidence = found.how === 'renamed in git'
+        ? `commit ${found.commit} changed "${token.value}" to "${found.value}" in ${found.file}`
+        : `"${token.value}" is nowhere in the source any more, and ${found.file} now has "${found.value}"`;
+    result.evidence = evidence;
+    result.log.push(evidence);
+    const replacement = writeSelector(token, found.value);
+    const source = deps.readFile(specFile);
+    const sites = findSelectorSites(source, written);
+    const site = sites[0];
+    if (!site)
+        return stop('selector-not-in-test', `${selector} is not written in ${rel}: it comes from a helper or a page object, which a person should change`);
+    result.line = site.line;
+    result.original = site.text;
+    result.replacement = site.text.replace(written, replacement);
+    deps.writeFile(specFile, source.replace(site.text, result.replacement));
+    try {
+        const run = await deps.verify(specFile, title);
+        if (!run.passed) {
+            deps.writeFile(specFile, source);
+            return stop('still-failing', `with ${replacement} the test still failed, so the file was put back: ${run.detail.slice(-200)}`);
+        }
+        result.log.push(`with ${replacement} the test passes`);
+        if (!keep)
+            deps.writeFile(specFile, source);
+        return { ...result, status: 'fixed', applied: keep };
+    }
+    catch (error) {
+        deps.writeFile(specFile, source);
+        throw error;
+    }
+}
+/** The one-line diff a reviewer reads. */
+export function selectorFixDiff(result) {
+    if (!result.original || !result.replacement)
+        return '';
+    return [`--- a/${result.specFile}`, `+++ b/${result.specFile}`, `@@ line ${result.line} @@`, `-${result.original.trim()}`, `+${result.replacement.trim()}`].join('\n');
+}

package/dist/engine/autofix/selector-source.js

@@ -0,0 +1,162 @@
+// Phase 5, for the tools that do not have a page snapshot: Cypress, Selenium and WebdriverIO.
+//
+// Playwright's traces tell Tewip what was on the page, so a drifted locator can be matched against
+// the real elements. A Cypress or Selenium failure in a JUnit report carries none of that - only
+// "Expected to find element: '#submit-btn', but never found it". Inventing a replacement from that
+// would be exactly the kind of guess this project exists not to make.
+//
+// So the answer comes from the repository instead. If a test looks for `#submit-btn` and the app
+// now renders `id="submit-button"`, the new name is in the application source, and git knows which
+// commit renamed it. That is evidence, not a guess - and the fix is still only kept if the test
+// passes afterwards.
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+/** What a CSS or XPath selector is really identifying, when it is something identifiable. */
+export function tokenOf(selector) {
+    // Selenium and WebdriverIO name the strategy first: "css selector=#submit-btn", "id=submit-btn".
+    const strategy = /^(css selector|css|xpath|id|name|class name|link text|partial link text|tag name)\s*=\s*(.+)$/i.exec(selector.trim());
+    const s = (strategy ? strategy[2] : selector).trim();
+    if (strategy) {
+        const method = strategy[1].toLowerCase();
+        if (method === 'id')
+            return { kind: 'id', value: s };
+        if (method === 'class name')
+            return { kind: 'class', value: s.split(/\s+/)[0] };
+        if (method === 'link text' || method === 'partial link text')
+            return { kind: 'text', value: s };
+    }
+    const data = /\[\s*([\w-]*data[\w-]*)\s*[~|^$*]?=\s*["']?([^"'\]]+)["']?\s*\]/i.exec(s);
+    if (data)
+        return { kind: 'data', attribute: data[1], value: data[2] };
+    const id = /^#([\w-]+)$|\[\s*id\s*=\s*["']([^"']+)["']\s*\]|@id\s*=\s*["']([^"']+)["']/i.exec(s);
+    if (id)
+        return { kind: 'id', value: id[1] ?? id[2] ?? id[3] };
+    const cls = /^\.([\w-]+)$|\[\s*class\s*=\s*["']([^"']+)["']\s*\]/i.exec(s);
+    if (cls)
+        return { kind: 'class', value: (cls[1] ?? cls[2]).split(/\s+/)[0] };
+    const text = /text\(\)\s*=\s*["']([^"']+)["']|contains\(\s*(?:text\(\)|\.)\s*,\s*["']([^"']+)["']/i.exec(s);
+    if (text)
+        return { kind: 'text', value: text[1] ?? text[2] };
+    return null;
+}
+/** How close two names are, 0 to 1, by the words in them - "submit-btn" and "submit-button". */
+export function closeness(a, b) {
+    const words = (s) => new Set(s.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
+    const left = words(a);
+    const right = words(b);
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let shared = 0;
+    for (const w of left)
+        if (right.has(w))
+            shared++;
+    // A shared prefix counts too: "submitBtn" and "submitButton" have no word in common.
+    const prefix = commonPrefix(a.toLowerCase(), b.toLowerCase()) / Math.max(a.length, b.length);
+    return Math.max(shared / Math.max(left.size, right.size), prefix);
+}
+function commonPrefix(a, b) {
+    let i = 0;
+    while (i < a.length && i < b.length && a[i] === b[i])
+        i++;
+    return i;
+}
+const git = (root, args) => {
+    try {
+        return execFileSync('git', args, { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, timeout: 60_000 });
+    }
+    catch {
+        return '';
+    }
+};
+/**
+ * The commit that removed this value, and what took its place on the same line. This is the
+ * strongest evidence there is: somebody renamed it, and the diff says to what.
+ */
+export function renamedInGit(root, token, maxCommits = 5) {
+    const shas = git(root, ['log', '-S', token.value, '--format=%H', `-n${maxCommits}`, '--', '.'])
+        .split('\n')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    for (const sha of shas) {
+        const diff = git(root, ['show', '--unified=0', '--format=', sha]);
+        if (!diff)
+            continue;
+        let file = '';
+        const removed = [];
+        const added = [];
+        for (const line of diff.split('\n')) {
+            if (line.startsWith('+++ b/'))
+                file = line.slice(6);
+            else if (line.startsWith('-') && line.includes(token.value))
+                removed.push(line);
+            else if (line.startsWith('+'))
+                added.push(line);
+        }
+        if (removed.length === 0 || added.length === 0)
+            continue;
+        // The best replacement is the attribute value on an added line that most resembles the old one.
+        let best = null;
+        for (const line of added) {
+            for (const value of attributeValues(line, token)) {
+                const score = closeness(token.value, value);
+                if (value !== token.value && score >= 0.5 && (!best || score > best.score)) {
+                    best = { value, file, how: 'renamed in git', commit: sha.slice(0, 8), score };
+                }
+            }
+        }
+        if (best)
+            return best;
+    }
+    return null;
+}
+/** Values of the same kind of attribute written on a line of source. */
+function attributeValues(line, token) {
+    const out = [];
+    const attribute = token.kind === 'data' ? token.attribute ?? 'data-[\\w-]+' : token.kind === 'id' ? 'id' : token.kind === 'class' ? 'class(?:Name)?' : '';
+    if (!attribute)
+        return out;
+    const pattern = new RegExp(`${attribute}\\s*=\\s*["'\`{]?\\s*["']?([\\w\\s-]+)["']?`, 'gi');
+    for (const m of line.matchAll(pattern)) {
+        for (const value of m[1].trim().split(/\s+/))
+            if (value)
+                out.push(value);
+    }
+    return out;
+}
+/**
+ * The closest value of the same kind anywhere in the application source now. Weaker than git,
+ * because nobody wrote down that it is a rename - so it is offered only when it is clearly close.
+ */
+export function likeItInSource(root, token, sources, min = 0.6) {
+    let best = null;
+    for (const file of sources) {
+        let text;
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (text.includes(token.value))
+            return null; // it is still there; this is not a rename
+        for (const line of text.split('\n')) {
+            for (const value of attributeValues(line, token)) {
+                const score = closeness(token.value, value);
+                if (value !== token.value && score >= min && (!best || score > best.score)) {
+                    best = { value, file, how: 'found in the source', score };
+                }
+            }
+        }
+    }
+    return best;
+}
+/** The selector written the way each tool writes it, so the fix reads like the rest of the test. */
+export function writeSelector(token, value) {
+    if (token.kind === 'id')
+        return `#${value}`;
+    if (token.kind === 'class')
+        return `.${value}`;
+    if (token.kind === 'data')
+        return `[${token.attribute}="${value}"]`;
+    return value;
+}

package/dist/engine/import/junit.js

@@ -1,6 +1,8 @@
 // Imports test reports from any language or framework into the agent's records: JUnit XML, which
 // pytest, Jest, Vitest, Mocha, node:test, Maven Surefire, Gradle, gotestsum, PHPUnit, RSpec,
-// cargo-nextest and Cypress write, and .NET's own TRX. Playwright keeps its own importer
+// cargo-nextest and Cypress write; .NET's own TRX; NUnit 3's result file; Robot Framework's
+// output.xml; JMeter's .jtl; and a k6 summary, where a run fails by crossing a threshold rather
+// than test by test. Playwright keeps its own importer
 // (blob.ts), which also reads traces.
 //
 // What these reports can and cannot say: each test's name, outcome, failure message and stack,
@@ -11,6 +13,7 @@ import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { SCHEMA_VERSION } from '../../reporters/types.js';
 import { descendants, parseXml } from './xml.js';
+import { jmeterCases, k6Cases, looksLikeK6, robotCases, robotTime } from './other-formats.js';
 const PASSED = { failed: false, message: '', stack: '' };
 const FAILURE = new Set(['failure', 'error']);
 /** Maven Surefire's records of earlier attempts: flaky* when a later one passed, rerun* when not. */
@@ -138,7 +141,8 @@ function nunitCases(root) {
         };
     });
 }
-const REPORT_FILE = /\.(xml|trx)$/i;
+// .jtl is JMeter's, and a k6 summary is JSON; both are read below.
+const REPORT_FILE = /\.(xml|trx|jtl|json)$/i;
 /** Report files under `path` (a file, or a directory searched recursively). */
 export function junitFiles(path) {
     if (!statSync(path).isDirectory())
@@ -162,7 +166,26 @@ export function importJunit(path, meta) {
     const unread = [];
     let parsedFiles = 0;
     for (const file of junitFiles(path)) {
-        const root = parseXml(readFileSync(file, 'utf8'));
+        const raw = readFileSync(file, 'utf8');
+        // k6 writes JSON, not XML: a performance run fails by crossing a threshold, not test by test.
+        if (/\.json$/i.test(file)) {
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                unread.push(`${file} (not JSON)`);
+                continue;
+            }
+            if (!looksLikeK6(parsed)) {
+                unread.push(`${file} (JSON, but not a k6 summary)`);
+                continue;
+            }
+            parsedFiles++;
+            addCases(k6Cases(parsed));
+            continue;
+        }
+        const root = parseXml(raw);
         let cases;
         if (root.name === 'TestRun') {
             cases = trxCases(root);
@@ -182,6 +205,15 @@ export function importJunit(path, meta) {
             if (start && (!startedAt || start < startedAt))
                 startedAt = start;
         }
+        else if (root.name === 'robot') {
+            cases = robotCases(root);
+            const start = robotTime(root.attrs.generated ?? '');
+            if (start && !startedAt)
+                startedAt = start;
+        }
+        else if (root.name === 'testResults') {
+            cases = jmeterCases(root);
+        }
         else {
             // Not a report Tewip knows. Staying silent here would report a failing run as clean, so the
             // file is remembered and, if nothing at all could be read, the caller is told.
@@ -189,6 +221,9 @@ export function importJunit(path, meta) {
             continue;
         }
         parsedFiles++;
+        addCases(cases);
+    }
+    function addCases(cases) {
         for (const c of cases) {
             attempts[c.testId] = (attempts[c.testId] ?? 0) + c.attempts.length;
             c.attempts.forEach((attempt, retry) => {
@@ -226,7 +261,8 @@ export function importJunit(path, meta) {
     if (unread.length > 0) {
         const list = unread.slice(0, 5).join(', ');
         if (parsedFiles === 0) {
-            throw new Error(`no test report Tewip can read in ${path}: ${list}. It reads JUnit XML (<testsuites>/<testsuite>), NUnit 3 (<test-run>) and .NET TRX (<TestRun>). ` +
+            throw new Error(`no test report Tewip can read in ${path}: ${list}. It reads JUnit XML (<testsuites>/<testsuite>), NUnit 3 (<test-run>), .NET TRX (<TestRun>), ` +
+                'Robot Framework output.xml (<robot>), JMeter .jtl (<testResults>) and a k6 summary (--summary-export). ' +
                 'Most runners can write JUnit XML; for TestNG use the Surefire report, and for NUnit use --result=x.xml.');
         }
         console.error(`[tewip] ignored ${unread.length} file(s) that are not a test report: ${list}`);

package/dist/engine/import/other-formats.js

@@ -0,0 +1,127 @@
+import { descendants } from './xml.js';
+const text = (element) => (element ? element.text.trim() : '');
+/**
+ * Robot Framework writes output.xml by default, and only writes JUnit if asked. A suite holds
+ * tests, a test holds a status with the failure message inside it, and suites nest - so the test's
+ * name is its whole path, the way Robot itself prints it.
+ */
+export function robotCases(root) {
+    const cases = [];
+    const walk = (element, path, source) => {
+        for (const child of element.children) {
+            if (child.name === 'suite') {
+                walk(child, [...path, child.attrs.name ?? ''], child.attrs.source ?? source);
+                continue;
+            }
+            if (child.name !== 'test')
+                continue;
+            const status = child.children.find((c) => c.name === 'status');
+            const failed = (status?.attrs.status ?? '').toUpperCase() === 'FAIL';
+            const start = status?.attrs.starttime ?? status?.attrs.start ?? '';
+            const end = status?.attrs.endtime ?? status?.attrs.end ?? '';
+            // The last keyword that failed says where it went wrong, which the message alone does not.
+            const failedKeyword = descendants(child, 'kw').find((kw) => (kw.children.find((c) => c.name === 'status')?.attrs.status ?? '').toUpperCase() === 'FAIL');
+            const where = failedKeyword?.attrs.name ? `Keyword: ${failedKeyword.attrs.name}` : '';
+            cases.push({
+                testId: [...path, child.attrs.name ?? ''].filter(Boolean).join(' > '),
+                file: source,
+                duration: robotDuration(start, end),
+                attempts: [{ failed, message: failed ? text(status) || 'the test failed' : '', stack: failed ? where : '' }],
+            });
+        }
+    };
+    walk(root, [], root.attrs.source ?? '');
+    return cases;
+}
+/** Robot's timestamp as an ISO one, or '' when it is not the shape Robot writes. */
+export function robotTime(stamp) {
+    const at = robotStamp(stamp);
+    return at > 0 ? new Date(at).toISOString() : '';
+}
+/** Robot's own timestamp shape: 20260923 14:05:01.123 */
+function robotStamp(s) {
+    const m = /^(\d{4})(\d{2})(\d{2}) (\d{2}):(\d{2}):(\d{2})\.(\d{1,3})$/.exec(s.trim());
+    return m ? Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5]), Number(m[6]), Number(m[7])) : 0;
+}
+function robotDuration(start, end) {
+    const from = robotStamp(start);
+    const to = robotStamp(end);
+    return from > 0 && to >= from ? to - from : 0;
+}
+/**
+ * JMeter's .jtl in XML form: one sample per request, s="false" when it failed. A load test has
+ * thousands of samples, so they are grouped by label - nobody wants ten thousand records, they want
+ * "the checkout request failed 412 times, mostly 503".
+ */
+export function jmeterCases(root) {
+    const samples = [...descendants(root, 'httpSample'), ...descendants(root, 'sample')];
+    const byLabel = new Map();
+    for (const sample of samples) {
+        const label = sample.attrs.lb ?? 'sample';
+        const found = byLabel.get(label) ?? { failed: 0, total: 0, time: 0, codes: new Map(), messages: new Set() };
+        found.total++;
+        found.time += Number(sample.attrs.t ?? 0);
+        if ((sample.attrs.s ?? 'true').toLowerCase() === 'false') {
+            found.failed++;
+            const code = `${sample.attrs.rc ?? ''} ${sample.attrs.rm ?? ''}`.trim();
+            if (code)
+                found.codes.set(code, (found.codes.get(code) ?? 0) + 1);
+            const assertion = descendants(sample, 'failureMessage')[0];
+            if (assertion)
+                found.messages.add(text(assertion).slice(0, 200));
+        }
+        byLabel.set(label, found);
+    }
+    return [...byLabel].map(([label, s]) => {
+        const worst = [...s.codes].sort((a, b) => b[1] - a[1])[0];
+        // A 2xx that still counts as failed is an assertion failing, not the server: "mostly 200" would
+        // read as nonsense to whoever opens the report.
+        const why = worst ? (/^2\d\d/.test(worst[0]) ? `, an assertion failed (${worst[1]} times, response ${worst[0]})` : `, mostly ${worst[0]} (${worst[1]} times)`) : '';
+        const message = s.failed === 0 ? '' : `${s.failed} of ${s.total} requests failed${why}${s.messages.size > 0 ? `: ${[...s.messages][0]}` : ''}`;
+        return { testId: `JMeter > ${label}`, file: '', duration: s.time, attempts: [{ failed: s.failed > 0, message, stack: [...s.messages].join('\n').slice(0, 2000) }] };
+    });
+}
+/**
+ * k6 writes a summary as JSON (`k6 run --summary-export=summary.json`). A performance run does not
+ * fail test by test: it fails when a threshold is crossed, and that is what is imported - one
+ * record per crossed threshold, saying by how much.
+ */
+export function k6Cases(json) {
+    const report = json;
+    if (!report?.metrics)
+        return [];
+    const cases = [];
+    for (const [metric, body] of Object.entries(report.metrics)) {
+        const thresholds = body.thresholds;
+        if (!thresholds)
+            continue;
+        for (const [expression, result] of Object.entries(thresholds)) {
+            // k6 writes either a boolean "ok" or an object with it; a crossed threshold is ok === false.
+            const ok = typeof result === 'boolean' ? result : Boolean(result?.ok);
+            const measured = describeMetric((body.values ?? body));
+            cases.push({
+                testId: `k6 > ${metric} > ${expression}`,
+                file: '',
+                duration: 0,
+                attempts: [{ failed: !ok, message: ok ? '' : `the threshold "${expression}" on ${metric} was crossed${measured ? `: ${measured}` : ''}`, stack: measured }],
+            });
+        }
+    }
+    return cases;
+}
+/** The numbers k6 reports for a metric, in one readable line. */
+function describeMetric(body) {
+    const wanted = ['avg', 'min', 'med', 'max', 'p(90)', 'p(95)', 'p(99)', 'rate', 'count', 'value'];
+    return wanted
+        .filter((key) => typeof body[key] === 'number')
+        .map((key) => `${key}=${round(body[key])}`)
+        .join(' ');
+}
+const round = (n) => (Number.isInteger(n) ? String(n) : n.toFixed(2));
+/** Whether a parsed JSON file looks like a k6 summary, so nothing else is read as one. */
+export function looksLikeK6(json) {
+    const report = json;
+    if (!report?.metrics || typeof report.metrics !== 'object')
+        return false;
+    return ['http_req_duration', 'iterations', 'vus', 'checks', 'http_reqs'].some((m) => m in report.metrics);
+}