explorbot 0.1.10 → 0.1.11

package/dist/src/playwright-recorder.js

@@ -0,0 +1,309 @@
+import { readFile } from 'node:fs/promises';
+// @ts-ignore — package ships a .js re-export without typings for this sub-path
+import * as playwrightUtils from 'playwright-core/lib/utils';
+import { createDebug } from "./utils/logger.js";
+const debugLog = createDebug('explorbot:playwright-recorder');
+const RECORDABLE = {
+    Frame: new Set(['click', 'dblclick', 'fill', 'selectOption', 'press', 'type', 'check', 'uncheck', 'hover', 'tap', 'focus', 'setInputFiles', 'scrollIntoViewIfNeeded', 'dragTo', 'goto', 'setContent']),
+    Page: new Set(['goBack', 'goForward', 'reload', 'keyboardPress', 'keyboardType', 'keyboardDown', 'keyboardUp', 'keyboardInsertText', 'mouseClick', 'mouseDblclick', 'mouseMove', 'mouseDown', 'mouseUp', 'mouseWheel']),
+};
+const PLAYWRIGHT_INCOMPATIBLE = "Playwright output is not compatible with this Playwright version (playwright-core/lib/utils does not expose asLocator). Use output.framework: 'codeceptjs' instead, or pin Playwright to a version shipping lib/utils/isomorphic/locatorGenerators.js.";
+function getAsLocator() {
+    const fn = playwrightUtils?.asLocator;
+    if (typeof fn !== 'function')
+        throw new Error(PLAYWRIGHT_INCOMPATIBLE);
+    return fn;
+}
+export class PlaywrightRecorder {
+    context = null;
+    tracing = null;
+    active = false;
+    nextGroupId = 0;
+    verifications = [];
+    recordVerification(steps) {
+        if (!steps?.length)
+            return;
+        const seen = new Set(this.verifications.map((s) => `${s.name}:${JSON.stringify(s.args)}`));
+        for (const step of steps) {
+            const key = `${step.name}:${JSON.stringify(step.args)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            this.verifications.push(step);
+        }
+    }
+    drainVerifications() {
+        const drained = this.verifications;
+        this.verifications = [];
+        return drained;
+    }
+    async start(browserContext) {
+        if (this.active)
+            return;
+        if (!browserContext?.tracing) {
+            debugLog('start: no tracing on browserContext, recorder inactive');
+            return;
+        }
+        this.context = browserContext;
+        this.tracing = browserContext.tracing;
+        try {
+            await this.tracing.start({});
+            this.active = true;
+            debugLog('tracing started');
+        }
+        catch (err) {
+            debugLog('tracing.start failed:', err);
+        }
+    }
+    async beginAction(title) {
+        if (!this.active)
+            return null;
+        const safe = title.replace(/\s+/g, ' ').slice(0, 80);
+        const groupId = `explorbot#${++this.nextGroupId}:${safe}`;
+        try {
+            await this.tracing.group(groupId);
+            return groupId;
+        }
+        catch (err) {
+            debugLog('tracing.group failed:', err);
+            return null;
+        }
+    }
+    async endAction() {
+        if (!this.active)
+            return;
+        try {
+            await this.tracing.groupEnd();
+        }
+        catch (err) {
+            debugLog('tracing.groupEnd failed:', err);
+        }
+    }
+    async exportChunk() {
+        if (!this.active)
+            return new Map();
+        const channel = this.tracing._channel;
+        if (!channel?.tracingStopChunk || !channel.tracingStartChunk) {
+            debugLog('exportChunk: no _channel access, returning empty');
+            return new Map();
+        }
+        let entries = [];
+        try {
+            const result = await channel.tracingStopChunk({ mode: 'entries' });
+            entries = result?.entries || [];
+        }
+        catch (err) {
+            debugLog('tracingStopChunk failed:', err);
+            return new Map();
+        }
+        const traceEntry = entries.find((e) => e.name === 'trace.trace');
+        let groups = new Map();
+        if (traceEntry) {
+            try {
+                const ndjson = await readFile(traceEntry.value, 'utf8');
+                groups = parseTrace(ndjson);
+            }
+            catch (err) {
+                debugLog('reading trace.trace failed:', err);
+            }
+        }
+        try {
+            await channel.tracingStartChunk({});
+        }
+        catch (err) {
+            debugLog('tracingStartChunk failed after export:', err);
+            this.active = false;
+        }
+        return groups;
+    }
+    async stop() {
+        if (!this.active)
+            return;
+        try {
+            await this.tracing.stop({});
+        }
+        catch (err) {
+            debugLog('tracing.stop failed:', err);
+        }
+        this.active = false;
+    }
+    isActive() {
+        return this.active;
+    }
+}
+function parseTrace(ndjson) {
+    const befores = new Map();
+    const groupTitleByCallId = new Map();
+    for (const line of ndjson.split('\n')) {
+        if (!line)
+            continue;
+        let evt;
+        try {
+            evt = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (evt.type === 'before') {
+            befores.set(evt.callId, {
+                callId: evt.callId,
+                class: evt.class,
+                method: evt.method,
+                params: evt.params || {},
+                parentId: evt.parentId,
+                title: evt.title,
+                failed: false,
+            });
+            if (evt.class === 'Tracing' && evt.method === 'tracingGroup' && typeof evt.title === 'string') {
+                groupTitleByCallId.set(evt.callId, evt.title);
+            }
+            continue;
+        }
+        if (evt.type === 'after') {
+            const rec = befores.get(evt.callId);
+            if (rec && evt.error)
+                rec.failed = true;
+        }
+    }
+    const groups = new Map();
+    for (const title of groupTitleByCallId.values()) {
+        groups.set(title, []);
+    }
+    for (const rec of befores.values()) {
+        if (rec.failed)
+            continue;
+        if (rec.class === 'Tracing')
+            continue;
+        if (!rec.parentId)
+            continue;
+        const groupTitle = groupTitleByCallId.get(rec.parentId);
+        if (!groupTitle)
+            continue;
+        const allowed = RECORDABLE[rec.class];
+        if (!allowed?.has(rec.method))
+            continue;
+        groups.get(groupTitle).push({ class: rec.class, method: rec.method, params: rec.params });
+    }
+    return groups;
+}
+export function renderCall(call) {
+    const asLocator = getAsLocator();
+    const { class: cls, method, params } = call;
+    if (cls === 'Frame') {
+        if (method === 'goto')
+            return `await page.goto(${quote(params.url)});`;
+        if (method === 'setContent')
+            return `await page.setContent(${quote(params.html)});`;
+        const locator = `page.${asLocator('javascript', params.selector || '')}`;
+        if (method === 'click')
+            return `await ${locator}.click();`;
+        if (method === 'dblclick')
+            return `await ${locator}.dblclick();`;
+        if (method === 'fill')
+            return `await ${locator}.fill(${quote(params.value ?? '')});`;
+        if (method === 'press')
+            return `await ${locator}.press(${quote(params.key ?? '')});`;
+        if (method === 'type')
+            return `await ${locator}.type(${quote(params.text ?? '')});`;
+        if (method === 'check')
+            return `await ${locator}.check();`;
+        if (method === 'uncheck')
+            return `await ${locator}.uncheck();`;
+        if (method === 'hover')
+            return `await ${locator}.hover();`;
+        if (method === 'tap')
+            return `await ${locator}.tap();`;
+        if (method === 'focus')
+            return `await ${locator}.focus();`;
+        if (method === 'scrollIntoViewIfNeeded')
+            return `await ${locator}.scrollIntoViewIfNeeded();`;
+        if (method === 'setInputFiles')
+            return `await ${locator}.setInputFiles(${formatFiles(params.localPaths ?? params.files)});`;
+        if (method === 'selectOption')
+            return `await ${locator}.selectOption(${formatSelectOption(params.options)});`;
+        if (method === 'dragTo')
+            return `await ${locator}.dragTo(page.locator(${quote(params.targetSelector ?? '')}));`;
+    }
+    if (cls === 'Page') {
+        if (method === 'goBack')
+            return 'await page.goBack();';
+        if (method === 'goForward')
+            return 'await page.goForward();';
+        if (method === 'reload')
+            return 'await page.reload();';
+        if (method === 'keyboardPress')
+            return `await page.keyboard.press(${quote(params.key ?? '')});`;
+        if (method === 'keyboardType')
+            return `await page.keyboard.type(${quote(params.text ?? '')});`;
+        if (method === 'keyboardDown')
+            return `await page.keyboard.down(${quote(params.key ?? '')});`;
+        if (method === 'keyboardUp')
+            return `await page.keyboard.up(${quote(params.key ?? '')});`;
+        if (method === 'keyboardInsertText')
+            return `await page.keyboard.insertText(${quote(params.text ?? '')});`;
+        if (method === 'mouseClick')
+            return `await page.mouse.click(${params.x ?? 0}, ${params.y ?? 0});`;
+        if (method === 'mouseDblclick')
+            return `await page.mouse.dblclick(${params.x ?? 0}, ${params.y ?? 0});`;
+        if (method === 'mouseMove')
+            return `await page.mouse.move(${params.x ?? 0}, ${params.y ?? 0});`;
+        if (method === 'mouseDown')
+            return 'await page.mouse.down();';
+        if (method === 'mouseUp')
+            return 'await page.mouse.up();';
+        if (method === 'mouseWheel')
+            return `await page.mouse.wheel(${params.deltaX ?? 0}, ${params.deltaY ?? 0});`;
+    }
+    return `// TODO(playwright): ${cls}.${method}(${JSON.stringify(params)})`;
+}
+function quote(value) {
+    return JSON.stringify(String(value ?? ''));
+}
+function formatFiles(files) {
+    if (!files)
+        return '[]';
+    if (Array.isArray(files)) {
+        if (files.length === 1)
+            return quote(files[0]);
+        return `[${files.map((f) => quote(f)).join(', ')}]`;
+    }
+    return quote(files);
+}
+function formatSelectOption(options) {
+    if (!options)
+        return `''`;
+    const list = Array.isArray(options) ? options : [options];
+    const values = list.map((o) => o?.valueOrLabel ?? o?.value ?? o?.label ?? '');
+    if (values.length === 1)
+        return quote(values[0]);
+    return `[${values.map((v) => quote(v)).join(', ')}]`;
+}
+export function renderAssertion(assertion) {
+    const args = assertion.args;
+    if (assertion.name === 'see' && typeof args[0] === 'string') {
+        return `await expect(page).toContainText(${JSON.stringify(args[0])});`;
+    }
+    if (assertion.name === 'dontSee' && typeof args[0] === 'string') {
+        return `await expect(page).not.toContainText(${JSON.stringify(args[0])});`;
+    }
+    if (assertion.name === 'seeElement' && typeof args[0] === 'string') {
+        return `await expect(page.locator(${JSON.stringify(args[0])})).toBeVisible();`;
+    }
+    if (assertion.name === 'dontSeeElement' && typeof args[0] === 'string') {
+        return `await expect(page.locator(${JSON.stringify(args[0])})).toBeHidden();`;
+    }
+    if (assertion.name === 'seeInField' && typeof args[0] === 'string' && args[1] !== undefined) {
+        return `await expect(page.locator(${JSON.stringify(args[0])})).toHaveValue(${JSON.stringify(String(args[1]))});`;
+    }
+    if (assertion.name === 'dontSeeInField' && typeof args[0] === 'string' && args[1] !== undefined) {
+        return `await expect(page.locator(${JSON.stringify(args[0])})).not.toHaveValue(${JSON.stringify(String(args[1]))});`;
+    }
+    if (assertion.name === 'seeInCurrentUrl' && typeof args[0] === 'string') {
+        return `await expect(page).toHaveURL(new RegExp(${JSON.stringify(args[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))}));`;
+    }
+    if (assertion.name === 'dontSeeInCurrentUrl' && typeof args[0] === 'string') {
+        return `await expect(page).not.toHaveURL(new RegExp(${JSON.stringify(args[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))}));`;
+    }
+    return `// TODO(playwright): ${assertion.name}(${assertion.args.map((a) => JSON.stringify(a)).join(', ')})`;
+}
+export { parseTrace };

package/dist/src/test-plan.js

@@ -115,6 +115,10 @@ export class Task {
             .map((item) => `${item.type === 'step' ? '  ' : ''}${item.content}`)
             .join('\n');
     }
+    getRunResult() {
+        const hasPassedNotes = Object.values(this.notes).some((n) => n.status === TestResult.PASSED);
+        return hasPassedNotes ? 'partial' : 'failed';
+    }
 }
 export class Test extends Task {
     scenario;
@@ -133,6 +137,7 @@ export class Test extends Task {
     enabled = true;
     startTime;
     endTime;
+    resetCount = 0;
     constructor(scenario, priority, expectedOutcome, startUrl, plannedSteps = []) {
         super(scenario, startUrl);
         this.scenario = scenario;
@@ -182,6 +187,13 @@ export class Test extends Task {
             return Object.values(this.notes).some((note) => note.message === expectation && note.status === TestResult.PASSED);
         });
     }
+    getRunResult() {
+        if (this.isSuccessful)
+            return 'success';
+        if (this.hasAchievedAny())
+            return 'partial';
+        return super.getRunResult();
+    }
     hasAchievedAll() {
         return this.expected.every((expectation) => {
             return Object.values(this.notes).some((note) => note.message === expectation && note.status === TestResult.PASSED);

package/dist/src/utils/aria.js

@@ -601,9 +601,17 @@ const resolveDisplayName = (node) => {
         return `{${childContent}}`;
     return undefined;
 };
+const SIBLING_COLLAPSE_THRESHOLD = 50;
+const SIBLING_COLLAPSE_KEEP_EACH_SIDE = 5;
 const serializeAriaNodes = (nodes, depth = 0) => {
     const lines = [];
-    for (const node of nodes) {
+    const collapsed = collapseSimilarSiblingRuns(nodes, depth);
+    for (const entry of collapsed) {
+        if (entry.placeholder) {
+            lines.push(entry.placeholder);
+            continue;
+        }
+        const node = entry.node;
         const indent = '  '.repeat(depth);
         let line = `${indent}- ${renderNodeLine(node.role, resolveDisplayName(node), node.attributes, node.value)}`;
         if (node.children.length > 0) {
@@ -616,6 +624,34 @@ const serializeAriaNodes = (nodes, depth = 0) => {
     }
     return lines.join('\n');
 };
+const collapseSimilarSiblingRuns = (nodes, depth) => {
+    const result = [];
+    let i = 0;
+    while (i < nodes.length) {
+        const role = nodes[i].role;
+        let j = i;
+        while (j < nodes.length && nodes[j].role === role)
+            j++;
+        const runLength = j - i;
+        if (runLength > SIBLING_COLLAPSE_THRESHOLD) {
+            for (let k = i; k < i + SIBLING_COLLAPSE_KEEP_EACH_SIDE; k++) {
+                result.push({ node: nodes[k] });
+            }
+            const omitted = runLength - SIBLING_COLLAPSE_KEEP_EACH_SIDE * 2;
+            const indent = '  '.repeat(depth);
+            result.push({ placeholder: `${indent}- ...${omitted} similar "${role}" items omitted...` });
+            for (let k = j - SIBLING_COLLAPSE_KEEP_EACH_SIDE; k < j; k++) {
+                result.push({ node: nodes[k] });
+            }
+        }
+        else {
+            for (let k = i; k < j; k++)
+                result.push({ node: nodes[k] });
+        }
+        i = j;
+    }
+    return result;
+};
 export const compactAriaSnapshot = (snapshot, keepNamed = false) => {
     if (!snapshot)
         return '';

package/dist/src/utils/error-page.js

@@ -1,20 +1,33 @@
 import { isBodyEmpty } from './html.js';
 const HTTP_ERRORS = ['400 Bad Request', '401 Unauthorized', '403 Forbidden', '404 Not Found', '405 Method Not Allowed', '408 Request Timeout', '500 Internal Server Error', '502 Bad Gateway', '503 Service Unavailable', '504 Gateway Timeout'];
 const SMALL_PAGE_THRESHOLD = 500;
-export function isErrorPage(actionResult) {
-    const checkFields = [actionResult.title, actionResult.h1, actionResult.h2].filter(Boolean);
-    for (const field of checkFields) {
+const LOADING_WORD = /\bloading\b/i;
+export function detectPageCondition(actionResult) {
+    const headingFields = [actionResult.title, actionResult.h1, actionResult.h2].filter(Boolean);
+    for (const field of headingFields) {
         for (const error of HTTP_ERRORS) {
             if (field.toLowerCase().includes(error.toLowerCase()))
-                return true;
+                return 'error';
         }
     }
+    const aria = actionResult.ariaSnapshot || '';
+    if (/\bprogressbar\b/i.test(aria))
+        return 'loading';
+    if (/\[busy\]/.test(aria))
+        return 'loading';
+    for (const field of headingFields) {
+        if (LOADING_WORD.test(field))
+            return 'loading';
+    }
     if (!actionResult.html || isBodyEmpty(actionResult.html))
-        return true;
+        return 'loading';
     const bodyMatch = actionResult.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
     if (bodyMatch && bodyMatch[1].trim().length < SMALL_PAGE_THRESHOLD)
-        return true;
-    return false;
+        return 'loading';
+    return 'ok';
+}
+export function isErrorPage(actionResult) {
+    return detectPageCondition(actionResult) === 'error';
 }
 export class ErrorPageError extends Error {
     url;

package/dist/src/utils/next-steps.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import { tag } from './logger.js';
+export function relativeToCwd(absPath) {
+    const rel = path.relative(process.cwd(), absPath);
+    return rel || '.';
+}
+export function printNextSteps(sections) {
+    if (sections.length === 0)
+        return;
+    const blocks = [];
+    for (const section of sections) {
+        const lines = [];
+        const headerPath = section.path ? relativeToCwd(section.path) : '';
+        lines.push(headerPath ? `${section.label}: ${headerPath}` : section.label);
+        const commands = section.commands || [];
+        if (commands.length > 0) {
+            const labeled = commands.filter((c) => c.label);
+            const maxLabel = labeled.length > 0 ? Math.max(...labeled.map((c) => c.label.length)) : 0;
+            for (const cmd of commands) {
+                if (!cmd.label) {
+                    lines.push(`  ${cmd.command}`);
+                    continue;
+                }
+                const padded = `${cmd.label}:`.padEnd(maxLabel + 2);
+                lines.push(`  ${padded} ${cmd.command}`);
+            }
+        }
+        blocks.push(lines.join('\n'));
+    }
+    for (let i = 0; i < blocks.length; i++) {
+        if (i > 0)
+            tag('info').log('');
+        for (const line of blocks[i].split('\n')) {
+            tag('info').log(line);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -83,7 +83,7 @@
     "axe-core": "^4.11.1",
     "bash-tool": "^1.3.15",
     "cli-highlight": "^2.1.11",
-    "codeceptjs": "4.0.0-rc.11",
+    "codeceptjs": "4.0.0-rc.16",
     "commander": "^14.0.1",
     "debug": "^4.4.3",
     "dedent": "^1.6.0",

package/rules/navigator/output.md

@@ -13,6 +13,10 @@ In <explanation> write only one line without heading or bullet list or any other
 Check previous solutions, if there is already successful solution, use it!
 CodeceptJS code must start with "I."
 All lines of code must be CodeceptJS code and start with "I."
+
+Do not mix form filling with navigation in the same code block.
+If the code block fills a form and clicks a submit/confirm control, stop there — do not append I.amOnPage afterwards. Submitting the form already triggers navigation on the server side, and a follow-up I.amOnPage cancels that in-flight navigation and discards the just-submitted state (session, cookies, redirect target).
+If the action does not cause navigation on its own and a separate page visit is required to reach the target, put I.amOnPage in its own code block as a distinct step, not glued onto the form submission block.
 </rules>
 
 <output>
@@ -42,6 +46,11 @@ Use only locators from HTML PAGE that was passed in <page> context.
 <example_output>
 Trying to fill the form on the page
 
+```js
+  I.fillField({ "role": "textbox", "text": "Name" }, 'Value');
+  I.click({ "role": "button", "text": "Submit" });
+```
+
 ```js
   I.fillField('Name', 'Value');
   I.click('Submit');

package/rules/navigator/verification-actions.md

@@ -113,6 +113,8 @@ For input field values, ALWAYS use I.seeInField() — never check value via CSS
 Prefer text locators (label, name, placeholder) for form fields: I.seeInField('Search', 'value') over I.seeInField('input[name="search"]', 'value').
 Only use locators that exist in the provided HTML or ARIA snapshot.
 Verify exact conditions, not approximate matches.
+NEVER use `:has-text(...)` inside a seeElement/dontSeeElement locator. Checking text inside an element is the job of I.see(text, context) — the `:has-text()` form duplicates that capability with a fragile selector.
+NEVER emit two assertions that check the same fact with different shapes. `I.see(text, locator)` and `I.seeElement("<locator>:has-text('text')")` verify the same thing — pick one (prefer I.see). One claim, one assertion.
 </verification_rules>
 
 [DO NEVER USE OTHER CODECEPTJS COMMANDS THAN PROPOSED HERE]

package/src/action-result.ts

@@ -611,7 +611,7 @@ export class ActionResult implements ActionResultData {
         }
       }
       if (processedParts.length > 0) {
-        pageDiff.htmlParts = processedParts;
+        pageDiff.htmlParts = collapseHtmlParts(processedParts);
       }
     }
 
@@ -629,6 +629,31 @@ export class ActionResult implements ActionResultData {
   }
 }
 
+const HTML_PARTS_TOTAL_BUDGET = 8000;
+const HTML_PARTS_COUNT_LIMIT = 8;
+const HTML_PART_SUBTREE_BUDGET = 2000;
+
+function collapseHtmlParts(parts: HtmlDiffPart[]): HtmlDiffPart[] {
+  const total = parts.reduce((sum, p) => sum + p.subtree.length, 0);
+  const fullPageReRender = total > HTML_PARTS_TOTAL_BUDGET || parts.length > HTML_PARTS_COUNT_LIMIT;
+
+  if (fullPageReRender) {
+    return parts.map((part) => ({
+      ...part,
+      subtree: `<html><head></head><body>...collapsed (${part.subtree.length} chars, ${part.added.length} added, ${part.removed.length} removed)...</body></html>`,
+    }));
+  }
+
+  return parts.map((part) => {
+    if (part.subtree.length <= HTML_PART_SUBTREE_BUDGET) return part;
+    const head = part.subtree.slice(0, HTML_PART_SUBTREE_BUDGET);
+    return {
+      ...part,
+      subtree: `${head}...<!-- truncated ${part.subtree.length - HTML_PART_SUBTREE_BUDGET} chars -->`,
+    };
+  });
+}
+
 export class Diff {
   private _htmlDiffResult: HtmlDiffResult | null = null;
   private _ariaDiffResult: string | null = null;