explorbot 0.1.0 → 0.1.1

package/dist/src/ai/tools.js

@@ -274,7 +274,7 @@ export function createCodeceptJSTools(explorer, task) {
         I.selectOption({"role":"combobox","text":"Category"}, 'Technology')
 
         Do not submit form - use verify() first to check fields were filled correctly, then click() to submit.
-        Do not use: wait functions, amOnPage, reloadPage, saveScreenshot
+        Do not use: wait functions, amOnPage, reloadPage, saveScreenshot        
       `,
             inputSchema: z.object({
                 codeBlock: z.string().describe('Valid CodeceptJS code starting with I. Can contain multiple commands separated by newlines.'),
@@ -335,7 +335,7 @@ export function createCodeceptJSTools(explorer, task) {
                         message: `Form completed successfully with ${lines.length} commands.`,
                         commandsExecuted: lines.length,
                         code: codeBlock,
-                        suggestion: 'Verify the form was filled in correctly using see() tool. Submit if needed by using click() tool.',
+                        suggestion: 'Verify the form was filled in correctly using see() tool. If needed to submit: try click() tool or form() with I.pressKey("Enter").',
                     });
                 }
                 catch (error) {

package/dist/src/commands/add-rule-command.js

@@ -5,8 +5,7 @@ import React from 'react';
 import { tag } from '../utils/logger.js';
 import { BaseCommand } from './base-command.js';
 export class AddRuleCommand extends BaseCommand {
-    name = 'rules:add';
-    aliases = ['add-rule'];
+    name = 'add-rule';
     description = 'Create a rule file for an agent';
     suggestions = ['/add-rule researcher check-tooltips'];
     async execute(args) {

package/dist/src/commands/base-command.js

@@ -1,3 +1,4 @@
+import { Command } from 'commander';
 export class BaseCommand {
     aliases = [];
     options = [];
@@ -10,4 +11,15 @@ export class BaseCommand {
     matches(commandName) {
         return this.name === commandName || this.aliases.includes(commandName);
     }
+    parseArgs(args) {
+        const cmd = new Command();
+        cmd.exitOverride();
+        for (const opt of this.options) {
+            cmd.option(opt.flags, opt.description);
+        }
+        cmd.argument('[args...]');
+        const argv = (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).map((s) => s.replace(/^["']|["']$/g, ''));
+        cmd.parse(argv, { from: 'user' });
+        return { opts: cmd.opts(), args: cmd.args };
+    }
 }

package/dist/src/commands/context-command.js

@@ -8,27 +8,34 @@ export class ContextCommand extends BaseCommand {
     name = 'context';
     description = 'Show page context summary (URL, headings, experience, knowledge, ARIA, HTML, research)';
     suggestions = ['context:aria', 'context:html', 'context:knowledge', 'context:experience', 'context:data'];
+    options = [
+        { flags: '--visual', description: 'Include annotated screenshot' },
+        { flags: '--screenshot', description: 'Include annotated screenshot' },
+        { flags: '--full', description: 'Show full context with HTML' },
+        { flags: '--attached', description: 'Show attached context mode' },
+    ];
     async execute(args) {
         const explorer = this.explorBot.getExplorer();
         const state = explorer.getStateManager().getCurrentState();
         if (!state) {
             throw new Error('No active page to show context for');
         }
-        const isVisual = args.includes('--visual') || args.includes('--screenshot');
-        const { ariaSnapshot } = await explorer.annotateElements();
+        const { opts } = this.parseArgs(args);
+        const isVisual = !!(opts.visual || opts.screenshot);
+        await explorer.annotateElements();
         if (isVisual) {
             const cachedResearch = Researcher.getCachedResearch(state);
             const containers = cachedResearch ? extractValidContainers(cachedResearch) : [];
             await explorer.visuallyAnnotateElements({ containers });
         }
-        const actionResult = await explorer.createAction().capturePageState({ includeScreenshot: isVisual, ariaSnapshot });
+        const actionResult = await explorer.createAction().capturePageState({ includeScreenshot: isVisual });
         const experienceTracker = explorer.getStateManager().getExperienceTracker();
         const knowledgeTracker = this.explorBot.getKnowledgeTracker();
         let mode = 'compact';
-        if (args.includes('--full')) {
+        if (opts.full) {
             mode = 'full';
         }
-        else if (args.includes('--attached')) {
+        else if (opts.attached) {
             mode = 'attached';
         }
         const contextData = {

package/dist/src/commands/drill-command.js

@@ -2,7 +2,6 @@ import { BaseCommand } from './base-command.js';
 export class DrillCommand extends BaseCommand {
     name = 'drill';
     description = 'Drill all components on current page to learn interactions';
-    aliases = ['bosun'];
     suggestions = ['/research - to see UI map first', '/navigate <page> - to go to another page'];
     async execute(args) {
         const knowledgePath = this.parseKnowledgeArg(args);

package/dist/src/commands/explore-command.js

@@ -1,6 +1,8 @@
+import { existsSync, readdirSync } from 'node:fs';
 import figureSet from 'figures';
 import path from 'node:path';
 import { getStyles } from '../ai/planner/styles.js';
+import { ConfigParser } from "../config.js";
 import { getCliName } from "../utils/cli-name.js";
 import { jsonToTable } from '../utils/markdown-parser.js';
 import { tag } from '../utils/logger.js';
@@ -14,12 +16,11 @@ export class ExploreCommand extends BaseCommand {
     testsRun = 0;
     completedPlans = [];
     async execute(args) {
-        const maxTestsMatch = args.match(/--max-tests\s+(\d+)/);
-        if (maxTestsMatch) {
-            this.maxTests = Number.parseInt(maxTestsMatch[1], 10);
-            args = args.replace(/--max-tests\s+\d+/, '').trim();
+        const { opts, args: remaining } = this.parseArgs(args);
+        if (opts.maxTests) {
+            this.maxTests = Number.parseInt(opts.maxTests, 10);
         }
-        const feature = args.trim() || undefined;
+        const feature = remaining.join(' ') || undefined;
         const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
         await this.runAllStyles(mainUrl, feature);
         const mainPlan = this.explorBot.getCurrentPlan();
@@ -56,6 +57,7 @@ export class ExploreCommand extends BaseCommand {
             await this.explorBot.visit(mainUrl);
         const savedPath = this.explorBot.savePlans(this.completedPlans);
         this.printResults(savedPath);
+        this.printRerunSuggestions();
     }
     async runAllStyles(pageUrl, feature, parentPlan, completedPlans) {
         let fresh = true;
@@ -107,6 +109,19 @@ export class ExploreCommand extends BaseCommand {
             tag('info').log(`Re-run tests: ${getCliName()} test ${relativePath} <index>`);
         }
     }
+    printRerunSuggestions() {
+        const testsDir = ConfigParser.getInstance().getTestsDir();
+        if (!existsSync(testsDir))
+            return;
+        const testFiles = readdirSync(testsDir).filter((f) => f.endsWith('.js'));
+        if (testFiles.length === 0)
+            return;
+        for (const file of testFiles) {
+            tag('info').log(`Generated: ${file}`);
+        }
+        tag('info').log(`List tests: ${getCliName()} runs`);
+        tag('info').log(`Re-run with healing: ${getCliName()} rerun <filename> [index]`);
+    }
     isLimitReached() {
         return this.maxTests != null && this.testsRun >= this.maxTests;
     }

package/dist/src/commands/freesail-command.js

@@ -16,7 +16,14 @@ export class FreesailCommand extends BaseCommand {
         { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
     ];
     async execute(args) {
-        const { strategy, scope, maxTests } = parseArgs(args);
+        const { opts } = this.parseArgs(args);
+        let strategy;
+        if (opts.deep)
+            strategy = 'deep';
+        if (opts.shallow)
+            strategy = 'shallow';
+        const scope = opts.scope;
+        const maxTests = opts.maxTests ? Number.parseInt(opts.maxTests, 10) : undefined;
         await this.explorBot.visitInitialState();
         let testsRun = 0;
         await loop(async (ctx) => {
@@ -60,24 +67,3 @@ export class FreesailCommand extends BaseCommand {
         }, { maxAttempts: Number.POSITIVE_INFINITY });
     }
 }
-function parseArgs(args) {
-    const parts = args.trim().split(/\s+/);
-    let strategy;
-    let scope;
-    let maxTests;
-    for (let i = 0; i < parts.length; i++) {
-        if (parts[i] === '--deep')
-            strategy = 'deep';
-        if (parts[i] === '--shallow')
-            strategy = 'shallow';
-        if (parts[i] === '--scope' && parts[i + 1]) {
-            scope = parts[i + 1];
-            i++;
-        }
-        if (parts[i] === '--max-tests' && parts[i + 1]) {
-            maxTests = Number.parseInt(parts[i + 1], 10);
-            i++;
-        }
-    }
-    return { strategy, scope, maxTests };
-}

package/dist/src/commands/index.js

@@ -22,7 +22,9 @@ import { PlanEditCommand } from './plan-edit-command.js';
 import { PlanLoadCommand } from './plan-load-command.js';
 import { PlanReloadCommand } from './plan-reload-command.js';
 import { PlanSaveCommand } from './plan-save-command.js';
+import { RerunCommand } from './rerun-command.js';
 import { ResearchCommand } from './research-command.js';
+import { RunsCommand } from './runs-command.js';
 import { StartCommand } from './start-command.js';
 import { StatusCommand } from "./status-command.js";
 import { TestCommand } from './test-command.js';
@@ -53,6 +55,8 @@ const commandClasses = [
     ContextExperienceCommand,
     ContextDataCommand,
     TestCommand,
+    RunsCommand,
+    RerunCommand,
     StatusCommand,
     DebugCommand,
     ExitCommand,

package/dist/src/commands/init-command.js

@@ -22,11 +22,11 @@ const config = {
 
   ai: {
     // fast model with tool calling capabilities
-    model: openrouter('<your base model here>'),
+    model: openrouter('openai/gpt-oss-20b:nitro'),
     // vision model for screenshot analysis
-    visionModel: openrouter('<your vision model here>'),
+    visionModel: openrouter('meta-llama/llama-4-scout-17b-16e-instruct'),
     // agentic model for decision making
-    agenticModel: openrouter('<your agentic model here>'),
+    agenticModel: openrouter('minimax/minimax-m2.5:nitro'),
   },
 };
 

package/dist/src/commands/path-command.js

@@ -5,7 +5,8 @@ export class PathCommand extends BaseCommand {
     description = 'Display ASCII graph of navigation paths during the session';
     options = [{ flags: '--links', description: 'Show outgoing links from each page' }];
     async execute(args) {
-        const showLinks = args.includes('--links');
+        const { opts } = this.parseArgs(args);
+        const showLinks = !!opts.links;
         const stateManager = this.explorBot.getExplorer().getStateManager();
         const history = stateManager.getStateHistory();
         if (history.length === 0) {

package/dist/src/commands/plan-command.js

@@ -1,3 +1,6 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import figureSet from 'figures';
 import { tag } from '../utils/logger.js';
 import { BaseCommand } from './base-command.js';
 export class PlanCommand extends BaseCommand {
@@ -11,30 +14,49 @@ export class PlanCommand extends BaseCommand {
         { flags: '--focus <feature>', description: 'Focus area for test planning' },
     ];
     async execute(args) {
-        const clear = args.includes('--clear');
-        const fresh = args.includes('--fresh') || clear;
-        const styleMatch = args.match(/--style\s+(\S+)/);
-        const style = styleMatch?.[1];
-        const focusMatch = args.match(/--focus\s+("[^"]+"|'[^']+'|\S+)/);
-        const focusFromFlag = focusMatch?.[1]?.replace(/^["']|["']$/g, '');
-        const focusFromText = args
-            .replace('--clear', '')
-            .replace('--fresh', '')
-            .replace(/--style\s+\S+/, '')
-            .replace(/--focus\s+("[^"]+"|'[^']+'|\S+)/, '')
-            .trim();
-        const focus = focusFromFlag || focusFromText;
-        if (clear) {
+        const { opts, args: remaining } = this.parseArgs(args);
+        const focus = opts.focus || remaining.join(' ') || undefined;
+        if (opts.clear) {
             this.explorBot.clearPlan();
             tag('success').log('Plan cleared');
         }
         if (focus) {
             tag('info').log(`Planning focus: ${focus}`);
         }
-        await this.explorBot.plan(focus || undefined, { fresh, style });
+        await this.explorBot.plan(focus, { fresh: !!(opts.fresh || opts.clear), style: opts.style });
         const plan = this.explorBot.getCurrentPlan();
         if (!plan?.tests.length) {
             throw new Error('No test scenarios in the current plan.');
         }
+        this.printPlanSummary();
+        this.updateSuggestions();
+    }
+    printPlanSummary() {
+        const suite = this.explorBot.getSuite();
+        const plan = this.explorBot.getCurrentPlan();
+        if (suite && suite.automatedTestCount > 0) {
+            const names = suite.getAutomatedTestNames();
+            console.log(`\n${chalk.bold.cyan(`Already implemented (${names.length} tests)`)}`);
+            for (let i = 0; i < names.length; i++) {
+                console.log(`  ${chalk.dim(`${i + 1}.`)} ${chalk.green(figureSet.pointer)} ${names[i]}`);
+            }
+        }
+        if (plan?.tests.length) {
+            console.log(`\n${chalk.bold.cyan(`New test scenarios (${plan.tests.length})`)}`);
+            for (let i = 0; i < plan.tests.length; i++) {
+                const t = plan.tests[i];
+                console.log(`  ${chalk.dim(`${i + 1}.`)} ${chalk.green(figureSet.pointer)} ${t.scenario} ${chalk.dim(`[${t.priority}]`)}`);
+            }
+        }
+    }
+    updateSuggestions() {
+        this.suggestions = ['/test - to launch first test', '/test * - to launch all tests'];
+        const suite = this.explorBot.getSuite();
+        if (suite && suite.automatedTestCount > 0) {
+            for (const f of suite.getAutomatedTestFiles()) {
+                this.suggestions.push(`/rerun ${path.relative(process.cwd(), f)} - re-run automated tests`);
+            }
+        }
+        this.suggestions.push('Edit the plan in file and call /plan:reload to update it');
     }
 }

package/dist/src/commands/rerun-command.js

@@ -0,0 +1,42 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { ConfigParser } from "../config.js";
+import { tag } from "../utils/logger.js";
+import { BaseCommand } from './base-command.js';
+export class RerunCommand extends BaseCommand {
+    name = 'rerun';
+    description = 'Re-run generated tests with AI auto-healing';
+    tuiEnabled = true;
+    async execute(args) {
+        const { args: remaining } = this.parseArgs(args);
+        const filename = remaining[0];
+        const indexArg = remaining[1];
+        if (!filename) {
+            tag('error').log('Usage: /rerun <filename> [index]');
+            return;
+        }
+        let filePath = resolve(filename);
+        if (!existsSync(filePath)) {
+            filePath = resolve(ConfigParser.getInstance().getTestsDir(), filename);
+        }
+        const testIndices = indexArg ? parseTestIndices(indexArg) : undefined;
+        await this.explorBot.agentRerunner().rerun(filePath, { testIndices });
+    }
+}
+function parseTestIndices(input) {
+    if (input === '*' || input === 'all')
+        return [];
+    const indices = new Set();
+    for (const part of input.split(',')) {
+        const trimmed = part.trim();
+        const range = trimmed.match(/^(\d+)-(\d+)$/);
+        if (range) {
+            for (let i = Number.parseInt(range[1]); i <= Number.parseInt(range[2]); i++)
+                indices.add(i - 1);
+        }
+        else {
+            indices.add(Number.parseInt(trimmed) - 1);
+        }
+    }
+    return [...indices].sort((a, b) => a - b);
+}

package/dist/src/commands/research-command.js

@@ -6,11 +6,17 @@ export class ResearchCommand extends BaseCommand {
     name = 'research';
     description = 'Research current page or navigate to URI and research. Use --deep to explore interactive elements by clicking them. Use --data to include page data.';
     suggestions = ['/navigate <page> - to go to another page', '/plan <feature> - to plan testing'];
+    options = [
+        { flags: '--data', description: 'Include page data' },
+        { flags: '--deep', description: 'Explore interactive elements by clicking them' },
+        { flags: '--no-fix', description: 'Skip fixing research issues' },
+    ];
     async execute(args) {
-        const includeData = args.includes('--data');
-        const enableDeep = args.includes('--deep');
-        const noFix = args.includes('--no-fix');
-        const target = args.replace('--data', '').replace('--deep', '').replace('--no-fix', '').trim();
+        const { opts, args: remaining } = this.parseArgs(args);
+        const includeData = !!opts.data;
+        const enableDeep = !!opts.deep;
+        const noFix = !!opts.noFix;
+        const target = remaining.join(' ');
         if (target) {
             await this.explorBot.agentNavigator().visit(target);
         }

package/dist/src/commands/runs-command.js

@@ -0,0 +1,22 @@
+import * as codeceptjs from 'codeceptjs';
+import { ConfigParser } from "../config.js";
+import { dryRunTestFile, loadTestSuites, printTestList } from "../utils/test-files.js";
+import { BaseCommand } from './base-command.js';
+export class RunsCommand extends BaseCommand {
+    name = 'runs';
+    description = 'List generated test files and their scenarios';
+    tuiEnabled = true;
+    async execute(args) {
+        if (!this.explorBot.isExploring) {
+            codeceptjs.container.create({ helpers: {} }, {});
+        }
+        const { args: remaining } = this.parseArgs(args);
+        const filePath = remaining[0];
+        if (filePath) {
+            await dryRunTestFile(filePath);
+            return;
+        }
+        const suites = loadTestSuites(ConfigParser.getInstance().getTestsDir());
+        printTestList(suites);
+    }
+}

package/dist/src/commands/start-command.js

@@ -2,7 +2,6 @@ import { BaseCommand } from './base-command.js';
 import { ExploreCommand } from './explore-command.js';
 export class StartCommand extends BaseCommand {
     name = 'start';
-    aliases = ['sail'];
     description = 'Start web exploration';
     suggestions = ['/navigate <page> - to go to another page', '/research - to analyze', '/plan <feature> - to plan testing'];
     async execute(args) {

package/dist/src/commands/test-command.js

@@ -24,10 +24,10 @@ export class TestCommand extends BaseCommand {
             toExecute.push(...requirePlan().getPendingTests());
         }
         else if (args.match(/^[\d,\-\s]+$/)) {
-            const pending = requirePlan().getPendingTests();
-            const indices = parseTestIndices(args, pending.length);
+            const visible = requirePlan().tests.filter((t) => t.enabled);
+            const indices = parseTestIndices(args, visible.length);
             for (const idx of indices) {
-                toExecute.push(pending[idx]);
+                toExecute.push(visible[idx]);
             }
         }
         else {

package/dist/src/components/App.js

@@ -206,6 +206,14 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
                 setShowPlanEditor(true);
                 return;
             }
+            if (key.upArrow) {
+                setTaskScrollOffset((prev) => Math.max(0, prev - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setTaskScrollOffset((prev) => prev + 1);
+                return;
+            }
         }
         if (!showInput && !showPlanEditor) {
             if (key.upArrow) {

package/dist/src/config.js

@@ -100,6 +100,9 @@ export class ConfigParser {
     getPlansDir() {
         return outputPath('plans');
     }
+    getTestsDir() {
+        return outputPath('tests');
+    }
     // For testing purposes only
     static resetForTesting() {
         if (ConfigParser.instance) {

package/dist/src/explorbot.js

@@ -14,6 +14,7 @@ import { Planner } from "./ai/planner.js";
 import { AIProvider } from "./ai/provider.js";
 import { Quartermaster } from "./ai/quartermaster.js";
 import { Researcher } from "./ai/researcher.js";
+import { Rerunner } from "./ai/rerunner.js";
 import { Tester } from "./ai/tester.js";
 import { createAgentTools } from "./ai/tools.js";
 import { ConfigParser } from "./config.js";
@@ -202,6 +203,21 @@ export class ExplorBot {
             return new Historian(ai, experienceTracker, reporter, explorer.getStateManager());
         }));
     }
+    agentRerunner() {
+        if (!this.agents.rerunner) {
+            this.agents.rerunner = this.createAgent(({ ai, explorer }) => {
+                const researcher = this.agentResearcher();
+                const navigator = this.agentNavigator();
+                const tools = createAgentTools({ explorer, researcher, navigator });
+                return new Rerunner(explorer, ai, tools);
+            });
+            const qm = this.agentQuartermaster();
+            if (qm)
+                this.agents.rerunner.setQuartermaster(qm);
+            this.agents.rerunner.setHistorian(this.agentHistorian());
+        }
+        return this.agents.rerunner;
+    }
     agentBosun() {
         return (this.agents.bosun ||= this.createAgent(({ ai, explorer }) => {
             const researcher = this.agentResearcher();
@@ -243,6 +259,9 @@ export class ExplorBot {
     getCurrentPlan() {
         return this.currentPlan;
     }
+    getSuite() {
+        return this.agentPlanner().getSuite();
+    }
     getPlanFeature() {
         return this.planFeature;
     }

package/dist/src/explorer.js

@@ -244,7 +244,8 @@ class Explorer {
         return action;
     }
     async annotateElements() {
-        return annotatePageElements(this.playwrightHelper.page);
+        const { elements } = await annotatePageElements(this.playwrightHelper.page);
+        return elements;
     }
     async visuallyAnnotateElements(opts) {
         return visuallyAnnotateContainers(this.playwrightHelper.page, opts?.containers || []);

package/dist/src/suite.js

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+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";
+const debugLog = createDebug('explorbot:suite');
+export class Suite {
+    url;
+    _automatedTests = null;
+    _plannedScenarios = null;
+    constructor(url) {
+        this.url = url;
+    }
+    getAutomatedTests() {
+        if (this._automatedTests !== null)
+            return this._automatedTests;
+        this._automatedTests = this.loadAutomatedTests();
+        return this._automatedTests;
+    }
+    getPlannedScenarios() {
+        if (this._plannedScenarios !== null)
+            return this._plannedScenarios;
+        this._plannedScenarios = this.loadPlannedScenarios();
+        return this._plannedScenarios;
+    }
+    getActiveScenarioTitles() {
+        return new Set(this.getAutomatedTests()
+            .filter((t) => !t.pending)
+            .map((t) => t.title.toLowerCase()));
+    }
+    get automatedTestCount() {
+        return this.getAutomatedTests().filter((t) => !t.pending).length;
+    }
+    getAutomatedTestNames() {
+        return this.getAutomatedTests()
+            .filter((t) => !t.pending)
+            .map((t) => t.title);
+    }
+    getAutomatedTestFiles() {
+        return [...new Set(this.getAutomatedTests().map((t) => t.file))];
+    }
+    loadAutomatedTests() {
+        const testsDir = ConfigParser.getInstance().getTestsDir();
+        if (!existsSync(testsDir))
+            return [];
+        const jsFiles = readdirSync(testsDir)
+            .filter((f) => f.endsWith('.js'))
+            .map((f) => path.resolve(testsDir, f));
+        const results = [];
+        for (const filePath of jsFiles) {
+            const parsed = this.parseTestFile(filePath);
+            if (!parsed)
+                continue;
+            if (normalizeUrl(parsed.url) !== normalizeUrl(this.url))
+                continue;
+            results.push(...parsed.tests);
+        }
+        return results;
+    }
+    parseTestFile(filePath) {
+        try {
+            const scanned = Reflection.scanFile(filePath);
+            if (!scanned.suites?.length)
+                return null;
+            const content = readFileSync(filePath, 'utf-8');
+            const suiteRef = Reflection.forSuite(scanned.suites[0]);
+            const beforeHooks = suiteRef.findHook('Before');
+            if (!beforeHooks?.length)
+                return null;
+            const hookBody = content.slice(beforeHooks[0].range.start, beforeHooks[0].range.end);
+            const match = hookBody.match(/I\.amOnPage\(['"]([^'"]+)['"]\)/);
+            if (!match)
+                return null;
+            const lines = content.split('\n');
+            const tests = (scanned.tests || []).map((t) => {
+                const line = lines[t.line - 1] || '';
+                const pending = line.includes('Scenario.skip') || line.includes('Scenario.todo');
+                return { title: t.title, pending, file: filePath };
+            });
+            return { url: match[1], tests };
+        }
+        catch (err) {
+            debugLog('Failed to parse test file %s: %s', filePath, err.message);
+            return null;
+        }
+    }
+    loadPlannedScenarios() {
+        try {
+            const plansDir = ConfigParser.getInstance().getPlansDir();
+            if (!existsSync(plansDir))
+                return [];
+            const mdFiles = readdirSync(plansDir)
+                .filter((f) => f.endsWith('.md'))
+                .map((f) => path.resolve(plansDir, f));
+            const scenarios = [];
+            for (const filePath of mdFiles) {
+                const plan = parsePlanFromMarkdown(filePath);
+                if (!plan.url)
+                    continue;
+                if (normalizeUrl(plan.url) !== normalizeUrl(this.url))
+                    continue;
+                for (const test of plan.tests) {
+                    scenarios.push(test.scenario);
+                }
+            }
+            return scenarios;
+        }
+        catch (err) {
+            debugLog('Failed to load planned scenarios: %s', err.message);
+            return [];
+        }
+    }
+}

package/dist/src/utils/html.js

@@ -424,18 +424,15 @@ export function htmlMinimalUISnapshot(html, htmlConfig) {
             node.attrs = node.attrs.filter((attr) => {
                 const { name, value } = attr;
                 if (name === 'class') {
-                    // Remove classes containing digits
                     attr.value = value
                         .split(' ')
-                        // remove classes containing digits/
                         .filter((className) => !/\d/.test(className))
-                        // remove popular trash classes
                         .filter((className) => !className.match(trashHtmlClasses))
-                        // remove classes with : and __ in them
                         .filter((className) => !className.match(/(:|__)/))
-                        // remove tailwind utility classes
                         .filter((className) => !TAILWIND_CLASS_PATTERNS.some((pattern) => pattern.test(className)))
                         .join(' ');
+                    if (attr.value === '')
+                        return false;
                 }
                 return allowedAttrs.includes(name) || name.startsWith('data-explorbot-');
             });