explorbot 0.1.9 → 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/reporter.js

@@ -1,20 +1,34 @@
 import { Client } from '@testomatio/reporter';
 import { outputPath } from './config.js';
+import { Stats } from './stats.js';
 import { createDebug } from './utils/logger.js';
 const debugLog = createDebug('explorbot:reporter');
 export class Reporter {
     client;
     isRunStarted = false;
     reporterEnabled;
-    constructor(config) {
+    stateManager;
+    constructor(config, stateManager) {
         this.reporterEnabled = Reporter.resolveEnabled(config);
+        this.stateManager = stateManager;
         if (this.reporterEnabled && (!process.env.TESTOMATIO || config?.html)) {
             this.configureHtmlPipe();
         }
-        this.client = new Client({ apiKey: process.env.TESTOMATIO || '' });
         const pipe = process.env.TESTOMATIO && config?.html ? 'both' : process.env.TESTOMATIO ? 'testomatio' : 'html';
         debugLog('Reporter initialized', { enabled: this.reporterEnabled, pipe });
     }
+    buildTitle() {
+        if (process.env.TESTOMATIO_TITLE)
+            return process.env.TESTOMATIO_TITLE;
+        const url = this.stateManager?.getCurrentState()?.url;
+        const parts = ['Explorbot session'];
+        if (url)
+            parts.push(url);
+        if (Stats.focus)
+            parts.push(`focus: "${Stats.focus}"`);
+        parts.push(`at ${new Date().toISOString().slice(0, 16)}`);
+        return parts.join(' ');
+    }
     static resolveEnabled(config) {
         if (config?.enabled === true)
             return true;
@@ -35,6 +49,7 @@ export class Reporter {
             return;
         }
         try {
+            this.client = new Client({ apiKey: process.env.TESTOMATIO || '', title: this.buildTitle() });
             const timeoutMs = Number(process.env.TESTOMATIO_TIMEOUT_MS || '15000');
             const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve('timeout'), timeoutMs));
             const result = await Promise.race([this.client.createRun().then(() => 'success'), timeoutPromise]);

package/dist/src/stats.js

@@ -3,6 +3,8 @@ export class Stats {
     static researches = 0;
     static tests = 0;
     static plans = 0;
+    static mode;
+    static focus;
     static models = {};
     static recordTokens(_agent, model, usage) {
         if (!Stats.models[model]) {

package/dist/src/suite.js

@@ -3,8 +3,8 @@ import path from 'node:path';
 import { Reflection } from '@codeceptjs/reflection';
 import { ConfigParser } from "./config.js";
 import { normalizeUrl } from "./state-manager.js";
-import { parsePlanFromMarkdown } from "./utils/test-plan-markdown.js";
 import { createDebug } from "./utils/logger.js";
+import { parsePlanFromMarkdown } from "./utils/test-plan-markdown.js";
 const debugLog = createDebug('explorbot:suite');
 export class Suite {
     url;

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,18 +1,41 @@
 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;
+    title;
+    constructor(url, title) {
+        super(`Error page detected at ${url}${title ? ` (${title})` : ''}`);
+        this.url = url;
+        this.title = title;
+        this.name = 'ErrorPageError';
+    }
 }

package/dist/src/utils/logger.js

@@ -4,9 +4,9 @@ import { context, trace } from '@opentelemetry/api';
 import chalk from 'chalk';
 import debug from 'debug';
 import dedent from 'dedent';
+import stripAnsi from 'strip-ansi';
 import { ConfigParser } from '../config.js';
 import { Observability } from "../observability.js";
-import stripAnsi from 'strip-ansi';
 import { parseMarkdownToTerminal } from "./markdown-terminal.js";
 class DebugFilter {
     patterns = [];

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/dist/src/utils/rules-loader.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { tag } from "./logger.js";

package/dist/src/utils/test-files.js

@@ -3,9 +3,9 @@ import path from 'node:path';
 import chalk from 'chalk';
 import { highlight } from 'cli-highlight';
 import * as codeceptjs from 'codeceptjs';
-import store from 'codeceptjs/lib/store';
 import stepsListener from 'codeceptjs/lib/listener/steps';
 import storeListener from 'codeceptjs/lib/listener/store';
+import store from 'codeceptjs/lib/store';
 import figureSet from 'figures';
 import { ConfigParser } from "../config.js";
 export function loadTestSuites(testsDir) {

package/dist/src/utils/url-matcher.js

@@ -1,4 +1,54 @@
 import micromatch from 'micromatch';
+import { ConfigParser } from '../config.js';
+export function isDynamicSegment(segment) {
+    try {
+        const configRegex = ConfigParser.getInstance().getConfig().dynamicPageRegex;
+        if (configRegex)
+            return new RegExp(configRegex, 'i').test(segment);
+    }
+    catch {
+        /* config not loaded yet */
+    }
+    // numeric: /users/123
+    if (/^\d+$/.test(segment))
+        return true;
+    // UUID: /items/550e8400-e29b-41d4-a716-446655440000
+    if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(segment))
+        return true;
+    // ULID: /items/01ARZ3NDEKTSV4RRFFQ69G5FAV
+    if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(segment))
+        return true;
+    // hex ID (4+ chars): /suite/70dae98a
+    if (/^[a-f0-9]{4,}$/i.test(segment))
+        return true;
+    // hex-prefixed slug (8+ hex before dash): /suite/95ef0c94-mobile
+    if (/^[a-f0-9]{8,}-/i.test(segment))
+        return true;
+    // short mixed alphanumeric (digits + letters, ≤8 chars, no dash): /item/x7f2
+    if (segment.length <= 8 && !segment.includes('-') && /\d/.test(segment) && /[a-z]/i.test(segment))
+        return true;
+    return false;
+}
+export function hasDynamicUrlSegment(url) {
+    return url.split('/').some((seg) => seg.length > 0 && isDynamicSegment(seg));
+}
+export function generalizeSegment(segment) {
+    if (/^\d+$/.test(segment))
+        return '\\d+';
+    if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(segment))
+        return '[a-f0-9-]+';
+    if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(segment))
+        return '[0-9A-HJKMNP-TV-Z]+';
+    if (/^[a-f0-9]+$/i.test(segment))
+        return '[a-f0-9]+';
+    return '[^/]+';
+}
+export function generalizeUrl(url) {
+    return url
+        .split('/')
+        .map((seg) => (seg.length > 0 && isDynamicSegment(seg) ? generalizeSegment(seg) : seg))
+        .join('/');
+}
 export function matchesUrl(pattern, path) {
     if (pattern === '*')
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.9",
+  "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');