explorbot 0.0.5 → 0.1.1

package/dist/src/ai/rerunner.js

@@ -0,0 +1,472 @@
+import { existsSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { tool } from 'ai';
+import { createBashTool } from 'bash-tool';
+import chalk from 'chalk';
+import { highlight } from 'cli-highlight';
+import * as codeceptjs from 'codeceptjs';
+import heal from 'codeceptjs/lib/heal';
+import aiTracePlugin from 'codeceptjs/lib/plugin/aiTrace';
+import figureSet from 'figures';
+import dedent from 'dedent';
+import { z } from 'zod';
+import { ActionResult } from "../action-result.js";
+import { setActivity } from "../activity.js";
+import { Stats } from "../stats.js";
+import { Task, Test, TestResult } from "../test-plan.js";
+import { createDebug, tag } from "../utils/logger.js";
+import { loop } from "../utils/loop.js";
+import { loadTestSuites, printTestList } from "../utils/test-files.js";
+import { toolExecutionLabel } from "./conversation.js";
+import { locatorRule, actionRule, sectionContextRule } from "./rules.js";
+import { TaskAgent } from "./task-agent.js";
+import { RulesLoader } from "../utils/rules-loader.js";
+import { createCodeceptJSTools } from "./tools.js";
+const debugLog = createDebug('explorbot:rerunner');
+export class Rerunner extends TaskAgent {
+    ACTION_TOOLS = ['click', 'pressKey', 'form'];
+    emoji = '🔄';
+    explorer;
+    provider;
+    agentTools;
+    healedSteps = [];
+    traceDir = '';
+    constructor(explorer, provider, agentTools) {
+        super();
+        this.explorer = explorer;
+        this.provider = provider;
+        this.agentTools = agentTools;
+    }
+    getNavigator() {
+        throw new Error('Rerunner does not use Navigator');
+    }
+    getExperienceTracker() {
+        return this.explorer.getStateManager().getExperienceTracker();
+    }
+    getKnowledgeTracker() {
+        return this.explorer.getKnowledgeTracker();
+    }
+    getProvider() {
+        return this.provider;
+    }
+    get rerunnerConfig() {
+        return this.explorer.getConfig().ai?.agents?.rerunner || {};
+    }
+    get healLimit() {
+        return this.rerunnerConfig.healLimit ?? 3;
+    }
+    get healMaxIterations() {
+        return this.rerunnerConfig.healMaxIterations ?? 3;
+    }
+    listTests(testsDir) {
+        printTestList(loadTestSuites(testsDir));
+    }
+    async rerun(filePath, options) {
+        const absPath = resolve(filePath);
+        if (!existsSync(absPath)) {
+            tag('error').log(`Test file not found: ${absPath}`);
+            return { total: 0, passed: 0, failed: 0, healed: 0 };
+        }
+        tag('info').log(`Re-running tests from: ${relative(process.cwd(), absPath)}`);
+        setActivity('🔄 Re-running tests...', 'action');
+        this.healedSteps = [];
+        this.setupPlugins();
+        const testMap = new Map();
+        const results = [];
+        const onTestBefore = (mochaTest) => {
+            if (!mochaTest.file)
+                mochaTest.file = absPath;
+            const task = new Test(mochaTest.title, 'normal', [], '');
+            task.start();
+            testMap.set(mochaTest.id || mochaTest.title, task);
+            Stats.tests++;
+            console.log(`\n  ${chalk.green(figureSet.pointer)} ${chalk.bold(mochaTest.title)}`);
+        };
+        const onStepStarted = (step) => {
+            if (!step.toCode)
+                return;
+            const code = highlight(step.toCode(), { language: 'javascript' });
+            console.log(chalk.dim(`    ${code}`));
+        };
+        const onStepPassed = (step) => {
+            const task = this.getCurrentTask(testMap);
+            if (!task || !step.toCode)
+                return;
+            task.addStep(step.toCode(), step.duration, 'passed');
+        };
+        const onStepFailed = (step, error) => {
+            const task = this.getCurrentTask(testMap);
+            if (!task || !step.toCode)
+                return;
+            task.addStep(step.toCode(), step.duration, 'failed', error?.message);
+            console.log(chalk.red(`    ${figureSet.cross} ${step.toCode()} — ${error?.message || 'failed'}`));
+        };
+        const onTestPassed = (mochaTest) => {
+            const task = testMap.get(mochaTest.id || mochaTest.title);
+            if (!task)
+                return;
+            task.finish(TestResult.PASSED);
+            results.push({ test: task, mochaState: 'passed' });
+            console.log(chalk.green(`  ${figureSet.tick} passed`));
+        };
+        const onTestFailed = (mochaTest, error) => {
+            const task = testMap.get(mochaTest.id || mochaTest.title);
+            if (!task)
+                return;
+            task.addNote(`Failed: ${error?.message || 'unknown error'}`, TestResult.FAILED);
+            task.finish(TestResult.FAILED);
+            results.push({ test: task, mochaState: 'failed' });
+            console.log(chalk.red(`  ${figureSet.cross} failed: ${error?.message || 'unknown'}`));
+        };
+        const { dispatcher } = codeceptjs.event;
+        dispatcher.on('test.before', onTestBefore);
+        dispatcher.on('step.start', onStepStarted);
+        dispatcher.on('step.passed', onStepPassed);
+        dispatcher.on('step.failed', onStepFailed);
+        dispatcher.on('test.passed', onTestPassed);
+        dispatcher.on('test.failed', onTestFailed);
+        try {
+            codeceptjs.container.createMocha();
+            const mocha = codeceptjs.container.mocha();
+            mocha.reporter(class {
+            });
+            mocha.files = [absPath];
+            mocha.loadFiles();
+            let testIndex = 0;
+            for (const suite of mocha.suite.suites || []) {
+                for (const test of suite.tests || []) {
+                    if (test.pending) {
+                        testIndex++;
+                        continue;
+                    }
+                    if (options?.testIndices?.length && !options.testIndices.includes(testIndex)) {
+                        test.pending = true;
+                        testIndex++;
+                        continue;
+                    }
+                    if (!hasAssertions(test.body)) {
+                        test.pending = true;
+                        tag('substep').log(`Skipping: ${test.title} (no assertions)`);
+                    }
+                    testIndex++;
+                }
+            }
+            await new Promise((resolveRun) => {
+                mocha.run((failures) => {
+                    debugLog('Mocha run finished with %d failures', failures);
+                    resolveRun();
+                });
+            });
+        }
+        catch (error) {
+            tag('error').log(`Rerun error: ${error instanceof Error ? error.message : error}`);
+        }
+        finally {
+            dispatcher.off('test.before', onTestBefore);
+            dispatcher.off('step.start', onStepStarted);
+            dispatcher.off('step.passed', onStepPassed);
+            dispatcher.off('step.failed', onStepFailed);
+            dispatcher.off('test.passed', onTestPassed);
+            dispatcher.off('test.failed', onTestFailed);
+            this.teardownHealing();
+        }
+        if (this.healedSteps.length > 0) {
+            this.getHistorian().rewriteScenarioInFile(absPath, this.healedSteps);
+            tag('info').log(`Healed ${this.healedSteps.length} step(s), original file updated`);
+        }
+        const passed = results.filter((r) => r.mochaState === 'passed').length;
+        const failed = results.filter((r) => r.mochaState === 'failed').length;
+        const result = {
+            total: results.length,
+            passed,
+            failed,
+            healed: this.healedSteps.length,
+        };
+        this.printResults(result);
+        return result;
+    }
+    getCurrentTask(testMap) {
+        const entries = [...testMap.values()];
+        return entries[entries.length - 1];
+    }
+    setupPlugins() {
+        const healMod = heal.default || heal;
+        healMod.connectToEvents();
+        healMod.addRecipe('explorbot-ai-healer', {
+            priority: 10,
+            fn: async (context) => {
+                return this.healStep(context.step, context.error);
+            },
+        });
+        const userRecipes = (this.rerunnerConfig.recipes || {});
+        for (const [name, recipe] of Object.entries(userRecipes)) {
+            healMod.addRecipe(name, recipe);
+        }
+        let currentTest = null;
+        let healTries = 0;
+        let isHealing = false;
+        let caughtError = null;
+        const healLimit = this.healLimit;
+        codeceptjs.event.dispatcher.on('test.before', (test) => {
+            currentTest = test;
+            healTries = 0;
+            caughtError = null;
+        });
+        codeceptjs.event.dispatcher.on('step.after', (step) => {
+            if (isHealing)
+                return;
+            if (healTries >= healLimit)
+                return;
+            if (!healMod.hasCorrespondingRecipes(step))
+                return;
+            codeceptjs.recorder.catchWithoutStop(async (err) => {
+                isHealing = true;
+                if (caughtError === err)
+                    throw err;
+                caughtError = err;
+                codeceptjs.recorder.session.start('heal');
+                debugLog('Healing started for: %s', step.toCode());
+                await healMod.healStep(step, err, { test: currentTest });
+                healTries++;
+                codeceptjs.recorder.add('close healing session', () => {
+                    codeceptjs.recorder.reset();
+                    codeceptjs.recorder.session.restore('heal');
+                    codeceptjs.recorder.ignoreErr(err);
+                });
+                await codeceptjs.recorder.promise();
+                isHealing = false;
+            });
+        });
+        global.container = codeceptjs.container;
+        codeceptjs.recorder.retry({
+            retries: 3,
+            when: (err) => {
+                if (!err?.message)
+                    return false;
+                return err.message.includes('was not found') || err.message.includes('Timeout') || err.message.includes('exceeded');
+            },
+            minTimeout: 2000,
+            maxTimeout: 5000,
+            factor: 1.5,
+        });
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const outputDir = global.output_dir || 'output';
+        this.traceDir = `${outputDir}/rerun_${timestamp}`;
+        const aiTrace = aiTracePlugin.default || aiTracePlugin;
+        aiTrace(this.rerunnerConfig.aiTrace || { output: this.traceDir });
+        import('@testomatio/reporter/codecept')
+            .then((mod) => {
+            const plugin = mod.default || mod;
+            plugin({ enabled: true });
+        })
+            .catch(() => debugLog('Testomatio reporter plugin not available'));
+    }
+    teardownHealing() {
+        const healMod = heal.default || heal;
+        healMod.recipes['explorbot-ai-healer'] = undefined;
+        for (const name of Object.keys(this.rerunnerConfig.recipes || {})) {
+            healMod.recipes[name] = undefined;
+        }
+    }
+    async healStep(step, error) {
+        const failedCode = step.toCode?.() || '';
+        console.log(chalk.yellow(`    ${figureSet.arrowRight} Healing: ${failedCode}`));
+        return async ({ I }) => {
+            const bashTool = await createBashTool({
+                destination: this.traceDir,
+                onBeforeBashCall: ({ command }) => {
+                    if (/>[^>]|>>|\btee\b|\brm\b/.test(command)) {
+                        return { command: 'echo "Read-only" >&2 && exit 1' };
+                    }
+                    return { command };
+                },
+            });
+            const healTask = new Task(`Heal: ${failedCode}`);
+            const codeceptTools = createCodeceptJSTools(this.explorer, healTask);
+            let healed = false;
+            let healedCommand = '';
+            const tools = {
+                bash: bashTool.bash,
+                ...codeceptTools,
+                ...this.agentTools,
+                wait: tool({
+                    description: 'Wait N seconds for page to load. Use when loading indicators are detected.',
+                    inputSchema: z.object({
+                        seconds: z.number().describe('Seconds to wait'),
+                        note: z.string().optional().describe('What are you waiting for'),
+                    }),
+                    execute: async ({ seconds, note }) => {
+                        if (note) {
+                            healTask.addNote(note);
+                            tag('substep').log(note);
+                        }
+                        const action = this.explorer.createAction();
+                        await action.execute(`I.wait(${seconds})`);
+                        const state = this.explorer.getStateManager().getCurrentState();
+                        const ar = state ? ActionResult.fromState(state) : null;
+                        return {
+                            success: true,
+                            message: `Waited ${seconds}s`,
+                            url: state?.url,
+                            title: state?.title,
+                            aria: ar?.getInteractiveARIA(),
+                        };
+                    },
+                }),
+                done: tool({
+                    description: 'Healing succeeded. Report the command that fixed the step.',
+                    inputSchema: z.object({
+                        healedCommand: z.string().describe('The CodeceptJS command that fixed the step'),
+                    }),
+                    execute: async ({ healedCommand: cmd }) => {
+                        healed = true;
+                        healedCommand = cmd;
+                        return { success: true, healedCommand: cmd };
+                    },
+                }),
+                giveUp: tool({
+                    description: 'Cannot heal. The issue is not fixable (missing data, page fundamentally different).',
+                    inputSchema: z.object({
+                        reason: z.string().describe('Why healing is not possible'),
+                    }),
+                    execute: async ({ reason }) => {
+                        console.log(chalk.gray(`    ${figureSet.line} Cannot heal: ${reason}`));
+                        return { success: false, reason };
+                    },
+                }),
+            };
+            const conversation = this.provider.startConversation(this.getHealSystemPrompt(), 'rerunner');
+            conversation.addUserText(this.getHealUserPrompt(failedCode, error));
+            await loop(async ({ stop }) => {
+                if (healed) {
+                    stop();
+                    return;
+                }
+                const result = await this.provider.invokeConversation(conversation, tools, {
+                    maxToolRoundtrips: 5,
+                    toolChoice: 'auto',
+                });
+                if (!result?.toolExecutions?.length) {
+                    stop();
+                    return;
+                }
+                for (const exec of result.toolExecutions) {
+                    const icon = exec.wasSuccessful ? chalk.green(figureSet.tick) : chalk.red(figureSet.cross);
+                    let label = toolExecutionLabel(exec.input) || exec.toolName;
+                    if (exec.toolName === 'bash')
+                        label = `bash [${this.traceDir}]: ${(exec.input?.command || '').substring(0, 100)}`;
+                    tag('substep').log(`${icon} ${label}`);
+                    if (exec.toolName === 'done') {
+                        healed = true;
+                        stop();
+                        return;
+                    }
+                    if (exec.toolName === 'giveUp') {
+                        stop();
+                        throw new Error(exec.input?.reason || 'Healing aborted');
+                    }
+                }
+            }, {
+                maxAttempts: this.healMaxIterations,
+                catch: async ({ error: err, stop }) => {
+                    if (err.message?.includes('Healing aborted'))
+                        throw err;
+                    tag('warning').log(`Healing error: ${err.message}`);
+                    stop();
+                },
+            });
+            if (!healed) {
+                throw new Error(`Could not heal: ${failedCode}`);
+            }
+            this.healedSteps.push({ test: '', original: failedCode, healed: healedCommand });
+            console.log(chalk.green(`    ${figureSet.tick} Healed: ${healedCommand}`));
+        };
+    }
+    getHealSystemPrompt() {
+        const customRules = this.provider.getSystemPromptForAgent('rerunner', this.explorer.getStateManager().getCurrentState()?.url) || '';
+        const currentUrl = this.explorer.getStateManager().getCurrentState()?.url || '';
+        const approach = RulesLoader.loadRules('rerunner', ['healing-approach'], currentUrl);
+        return dedent `
+      <role>
+      You are a senior test automation engineer healing a failed CodeceptJS test step.
+      The failed step did NOT execute. You MUST perform the action it was supposed to do.
+      </role>
+
+      ${approach}
+
+      <tools>
+      - You MUST execute the replacement action — not just diagnose
+      - Use click() for buttons, links — commands array is FALLBACK LOCATORS for the SAME element
+      - Use form() for text input, dropdown selection, file uploads
+      - Use pressKey() for special keys or key combinations
+      - Use wait() when page is loading — returns fresh ARIA automatically
+      - Use research() to understand page structure, sections, and available UI elements
+      - Use xpathCheck() to search large HTML when element can't be found in ARIA
+      - Use see() for visual verification when unsure
+      - Use context() to refresh ARIA/HTML after actions
+      - Use bash to read trace files (cat */trace.md, grep *_console.json, cat *_aria.txt)
+      </tools>
+
+      ${locatorRule}
+
+      ${actionRule}
+
+      ${sectionContextRule}
+
+      ${customRules}
+    `;
+    }
+    getHealUserPrompt(failedCode, error) {
+        const state = this.explorer.getStateManager().getCurrentState();
+        const actionResult = state ? ActionResult.fromState(state) : null;
+        const headings = [];
+        if (state?.h1)
+            headings.push(`H1: ${state.h1}`);
+        if (state?.h2)
+            headings.push(`H2: ${state.h2}`);
+        if (state?.h3)
+            headings.push(`H3: ${state.h3}`);
+        if (state?.h4)
+            headings.push(`H4: ${state.h4}`);
+        return dedent `
+      A test step failed and needs healing.
+
+      <failed_step>
+      Command: ${failedCode}
+      Error: ${error.message}
+      </failed_step>
+
+      <page>
+      URL: ${state?.url || 'unknown'}
+      Title: ${state?.title || 'unknown'}
+      ${headings.join('\n')}
+      </page>
+
+      <page_aria>
+      ${actionResult?.getInteractiveARIA() || 'No ARIA available'}
+      </page_aria>
+
+      Trace directory: ${this.traceDir}
+
+      Diagnose and fix the failed step. You MUST execute the replacement action.
+    `;
+    }
+    printResults(result) {
+        const parts = [];
+        if (result.passed > 0)
+            parts.push(`${result.passed} passed`);
+        if (result.failed > 0)
+            parts.push(`${result.failed} failed`);
+        if (result.healed > 0)
+            parts.push(`${result.healed} healed`);
+        console.log(`\n${chalk.bold(`${result.total}`)} tests — ${parts.join(', ')}`);
+        if (this.traceDir) {
+            console.log(chalk.gray(`Traces: ${this.traceDir}`));
+        }
+    }
+}
+function hasAssertions(body) {
+    if (!body)
+        return false;
+    return /I\.(see|dontSee|seeElement|dontSeeElement|seeInField|seeInSource|dontSeeInSource)\b/.test(body);
+}

package/dist/src/ai/researcher/cache.js

@@ -59,7 +59,7 @@ export function saveResearch(hash, text, combinedHtml) {
     }
     return researchFile;
 }
-export function findSimilarResearch(combinedHtml) {
+function findSimilarMatch(combinedHtml) {
     const statesDir = getStatesDir();
     if (!existsSync(statesDir))
         return Promise.resolve(null);
@@ -76,13 +76,8 @@ export function findSimilarResearch(combinedHtml) {
                 resolve(null);
                 return;
             }
-            debugLog(`Similar research found: ${matchHash} (${similarity}% similar)`);
-            const research = getCachedResearch(matchHash);
-            if (research) {
-                resolve(research);
-                return;
-            }
-            resolve(null);
+            debugLog(`Similar fingerprint found: ${matchHash} (${similarity}% similar)`);
+            resolve({ hash: matchHash, similarity });
         };
         worker.postMessage({
             html: combinedHtml,
@@ -92,3 +87,13 @@ export function findSimilarResearch(combinedHtml) {
         });
     });
 }
+export async function findSimilarResearch(combinedHtml) {
+    const match = await findSimilarMatch(combinedHtml);
+    if (!match)
+        return null;
+    return getCachedResearch(match.hash) || null;
+}
+export async function findSimilarStateHash(combinedHtml) {
+    const match = await findSimilarMatch(combinedHtml);
+    return match?.hash || null;
+}

package/dist/src/ai/researcher/coordinates.js

@@ -115,9 +115,11 @@ export function WithCoordinates(Base) {
                 const text = aiResult.text || '';
                 const rows = mdq(text).query('table').toJson();
                 for (const row of rows) {
-                    const eidx = Number.parseInt(row.eidx, 10);
-                    if (Number.isNaN(eidx))
+                    let eidx = (row.eidx || '').trim();
+                    if (!eidx || eidx === '-')
                         continue;
+                    if (/^\d+$/.test(eidx))
+                        eidx = `e${eidx}`;
                     const val = (v) => (v && v !== '-' ? v : null);
                     elements.set(eidx, {
                         coordinates: val(row.Coordinates),

package/dist/src/ai/researcher/deep-analysis.js

@@ -68,7 +68,7 @@ export function WithDeepAnalysis(Base) {
         From this UI research, identify elements that could reveal hidden UI when clicked
         (dropdown menus, popups, expandable panels, accordion sections, overflow menus, tab switches).
 
-        Available eidx numbers: ${eidxList}
+        Available eidx refs: ${eidxList}
 
         ${researchText}
 
@@ -76,7 +76,7 @@ export function WithDeepAnalysis(Base) {
         - Only pick elements that HIDE content until clicked (menus, dropdowns, accordions, tabs)
         - Skip regular links, data items, and navigation
         - For repeated elements (same expand button on every row), pick only the FIRST one
-        - Respond with comma-separated eidx numbers only, e.g.: 3, 7, 15
+        - Respond with comma-separated eidx refs only, e.g.: e3, e7, e15
       `;
             const model = this.provider.getModelForAgent('researcher');
             const textCall = this.provider.chat([{ role: 'user', content: textPrompt }], model, {
@@ -87,7 +87,7 @@ export function WithDeepAnalysis(Base) {
             const screenshot = this.actionResult?.screenshot;
             if (screenshot && this.provider.hasVision()) {
                 const visionPrompt = dedent `
-          This screenshot has interactive elements labeled with eidx numbers (solid bordered boxes with numbers).
+          This screenshot has interactive elements labeled with eidx refs (solid bordered boxes with labels).
           Identify elements that could reveal hidden UI when clicked.
 
           Look for: overflow/ellipsis menus, chevron dropdowns, hamburger menus,
@@ -96,30 +96,27 @@ export function WithDeepAnalysis(Base) {
           Rules:
           - For repeated icons (same icon on every list row), pick only the FIRST one
           - Skip regular text buttons, links, and navigation items
-          - Respond with comma-separated eidx numbers only, e.g.: 3, 7, 15
+          - Respond with comma-separated eidx refs only, e.g.: e3, e7, e15
         `;
                 visionCall = this.provider.processImage(visionPrompt, screenshot.toString('base64'));
             }
             const [textRes, visionRes] = await Promise.all([textCall, visionCall]);
             const eidxSet = new Set();
+            const parseRefs = (text) => {
+                if (!text)
+                    return [];
+                const matches = text.match(/e?\d+/g) || [];
+                const refs = matches.map((m) => (m.startsWith('e') ? m : `e${m}`));
+                return refs.filter((r) => allElements.has(r));
+            };
             for (const res of [textRes, visionRes]) {
-                if (!res?.text)
-                    continue;
-                const nums = res.text.match(/\d+/g)?.map(Number) || [];
-                for (const n of nums) {
-                    if (allElements.has(n))
-                        eidxSet.add(n);
+                for (const ref of parseRefs(res?.text)) {
+                    eidxSet.add(ref);
                 }
             }
-            const textNums = textRes?.text
-                ?.match(/\d+/g)
-                ?.map(Number)
-                .filter((n) => allElements.has(n)) || [];
-            const visionNums = visionRes?.text
-                ?.match(/\d+/g)
-                ?.map(Number)
-                .filter((n) => allElements.has(n)) || [];
-            debugLog(`Text model picked eidx: [${textNums.join(', ')}], Vision model picked eidx: [${visionNums.join(', ')}]`);
+            const textRefs = parseRefs(textRes?.text);
+            const visionRefs = parseRefs(visionRes?.text);
+            debugLog(`Text model picked eidx: [${textRefs.join(', ')}], Vision model picked eidx: [${visionRefs.join(', ')}]`);
             return [...eidxSet].map((eidx) => allElements.get(eidx));
         }
         _buildClickCommands(el) {

package/dist/src/ai/researcher/locators.js

@@ -126,7 +126,7 @@ export function WithLocators(Base) {
                 for (const fixedSection of fixedSections) {
                     const originalSections = parseResearchSections(result.text);
                     const original = originalSections.find((s) => s.name === fixedSection.name);
-                    if (!original)
+                    if (!original || original.elements.length === 0)
                         continue;
                     if (fixedSection.containerCss && fixedSection.containerCss !== original.containerCss) {
                         debugLog(`Fixed container for "${fixedSection.name}": '${original.containerCss}' → '${fixedSection.containerCss}'`);

package/dist/src/ai/researcher/parser.js

@@ -37,8 +37,9 @@ export function mapRowToElement(row) {
     const name = stripQuotes(colMap.element || '');
     if (!name)
         return null;
-    const eidxRaw = (colMap.eidx || '').trim();
-    const eidxNum = eidxRaw ? Number.parseInt(eidxRaw, 10) : Number.NaN;
+    let eidxRaw = (colMap.eidx || '').trim();
+    if (eidxRaw && /^\d+$/.test(eidxRaw))
+        eidxRaw = `e${eidxRaw}`;
     const aria = parseAriaLocator(colMap.aria || '-');
     return {
         name,
@@ -49,7 +50,7 @@ export function mapRowToElement(row) {
         coordinates: (colMap.coordinates || '-').trim() === '-' ? null : colMap.coordinates.trim(),
         color: (colMap.color || '-').trim() === '-' || (colMap.color || '').trim() === '' ? null : colMap.color.trim(),
         icon: (colMap.icon || '-').trim() === '-' || (colMap.icon || '').trim() === '' ? null : colMap.icon.trim(),
-        eidx: Number.isNaN(eidxNum) ? null : eidxNum,
+        eidx: eidxRaw && eidxRaw !== '-' ? eidxRaw : null,
     };
 }
 export function extractContainerFromBlockquote(sectionMarkdown) {

package/dist/src/ai/researcher/research-result.js

@@ -62,6 +62,8 @@ export class ResearchResult {
         this.rebuildSectionInText(section);
     }
     rebuildSectionInText(section) {
+        if (section.elements.length === 0)
+            return;
         const newTable = rebuildSectionMarkdown(section);
         const escaped = section.name.replace(/"/g, '\\"');
         let sectionQuery = mdq(this.text).query(`section2(~"${escaped}")`);

package/dist/src/ai/researcher.js

@@ -98,8 +98,8 @@ export class Researcher extends ResearcherBase {
             setActivity(`${this.emoji} Researching...`, 'action');
             await this.ensureNavigated(state.url, screenshot && this.provider.hasVision());
             await this.hooksRunner.runBeforeHook('researcher', state.url);
-            const annotatedCount = await this.explorer.annotateElements();
-            debugLog(`Annotated ${annotatedCount} interactive elements with eidx`);
+            const annotatedElements = await this.explorer.annotateElements();
+            debugLog(`Annotated ${annotatedElements.length} interactive elements with eidx`);
             this.actionResult = await this.explorer.createAction().capturePageState({ includeScreenshot: screenshot && this.provider.hasVision() });
             if (isErrorPage(this.actionResult)) {
                 const recovered = await this.waitForPageLoad(screenshot);
@@ -117,7 +117,7 @@ export class Researcher extends ResearcherBase {
             }
             debugLog('Researching web page:', this.actionResult.url);
             const combinedHtml = await this.actionResult.combinedHtml();
-            if (!deep) {
+            if (!deep && !force) {
                 const similar = await findSimilarResearch(combinedHtml);
                 if (similar) {
                     tag('info').log('Similar research found, reusing cached result');

package/dist/src/ai/rules.js

@@ -257,7 +257,7 @@ export const actionRule = dedent `
     I.fillField('Username', 'John', '.login-form'); // fills Username inside .login-form
     I.fillField('Username', 'John'); // fills the field located by name or placeholder or label "Username" with the text "John"
     I.fillField('//user/input', 'John'); // fills the field located by XPath "//user/input" with the text "John"
-  </example>
+  </example>  
 
   ### I.type
 
@@ -294,7 +294,7 @@ export const actionRule = dedent `
   </example>
 
   IMPORTANT: Requires an active/focused element for most keys.
-  Commonly used after I.type() to submit forms or navigate dropdowns.
+  Commonly used after I.type() or I.fillField() to submit forms or navigate dropdowns.
 
   ### I.switchTo