explorbot 0.1.31 → 0.2.0

package/dist/src/action-result.js

@@ -1,10 +1,11 @@
 import fs from 'node:fs';
-import { join } from 'node:path';
 import { ConfigParser, outputPath } from "./config.js";
-import { compactAriaSnapshot, diffAriaSnapshots } from "./utils/aria.js";
+import { LARGE_ARIA_CHANGE_THRESHOLD, compactAriaSnapshot, diffAriaSnapshots } from "./utils/aria.js";
+import { TTLCache } from "./utils/cache.js";
 import { htmlDiff } from "./utils/html-diff.js";
 import { extractHeadings, extractLinks, extractTargetedHtml, htmlCombinedSnapshot, htmlMinimalUISnapshot, htmlTextSnapshot, minifyHtml } from "./utils/html.js";
 import { createDebug } from "./utils/logger.js";
+import { slugify } from "./utils/strings.js";
 import { extractStatePath, matchesUrl } from "./utils/url-matcher.js";
 const debugLog = createDebug('explorbot:state');
 export class ActionResult {
@@ -26,12 +27,12 @@ export class ActionResult {
     _screenshot = undefined;
     htmlFile = undefined;
     _html = undefined;
+    snapshotCache = new TTLCache();
     logFile = undefined;
-    _browserLogs = undefined;
     ariaSnapshotFile = undefined;
     _ariaSnapshot = undefined;
     _lastExtractedHtml = undefined;
-    notes;
+    notes = [];
     links = [];
     verifications;
     constructor(data) {
@@ -60,20 +61,17 @@ export class ActionResult {
         if (data.ariaSnapshotFile !== undefined) {
             this.ariaSnapshotFile = data.ariaSnapshotFile;
         }
-        // Store HTML and browser logs in private properties if provided
+        // Store HTML in a private property if provided
         if (data.html !== undefined) {
             this._html = data.html;
         }
-        if (data.browserLogs !== undefined) {
-            this._browserLogs = data.browserLogs;
-        }
         if (data.screenshot !== undefined) {
             this._screenshot = data.screenshot;
         }
         if (data.ariaSnapshot !== undefined) {
             this._ariaSnapshot = data.ariaSnapshot;
         }
-        if (!this.fullUrl && this.url && this.url !== '') {
+        if (!this.fullUrl && this.url) {
             this.fullUrl = this.url;
         }
         this.extractHeadings(this.html);
@@ -83,7 +81,7 @@ export class ActionResult {
         else if (this._html) {
             this.links = extractLinks(this._html);
         }
-        if (this.url && this.url !== '') {
+        if (this.url) {
             this.url = extractStatePath(this.url);
         }
     }
@@ -100,6 +98,7 @@ export class ActionResult {
     }
     set html(value) {
         this._html = value;
+        this.snapshotCache.clear();
     }
     get screenshot() {
         if (this._screenshot) {
@@ -110,15 +109,6 @@ export class ActionResult {
         }
         return undefined;
     }
-    get browserLogsContent() {
-        if (this._browserLogs !== undefined) {
-            return this._browserLogs;
-        }
-        if (this.logFile) {
-            return ActionResult.loadBrowserLogsFromFile(this.logFile);
-        }
-        return [];
-    }
     get ariaSnapshot() {
         if (this._ariaSnapshot !== undefined) {
             return this._ariaSnapshot;
@@ -166,13 +156,13 @@ export class ActionResult {
         return null;
     }
     isSameUrl(state) {
-        if (!this.url || this.url === '') {
+        if (!this.url) {
             return false;
         }
         return extractStatePath(state.url) === extractStatePath(this.url);
     }
     isMatchedBy(state) {
-        if (!this.url || this.url === '') {
+        if (!this.url) {
             return false;
         }
         const isRelevant = matchesUrl(extractStatePath(state.url), extractStatePath(this.url));
@@ -206,19 +196,24 @@ export class ActionResult {
     }
     async simplifiedHtml(htmlConfig) {
         const normalizedConfig = this.normalizeHtmlConfig(htmlConfig);
-        return await minifyHtml(htmlMinimalUISnapshot(this.html ?? '', normalizedConfig?.minimal));
+        const cacheKey = `simplified:${JSON.stringify(normalizedConfig?.minimal ?? null)}`;
+        return this.snapshotCache.fetch(cacheKey, () => minifyHtml(htmlMinimalUISnapshot(this.html ?? '', normalizedConfig?.minimal)));
     }
     async combinedHtml(htmlConfig) {
         const normalizedConfig = this.normalizeHtmlConfig(htmlConfig);
-        const combinedHtml = await minifyHtml(htmlCombinedSnapshot(this.html ?? '', normalizedConfig?.combined, { keepPositions: htmlConfig?.keepPositions }));
-        debugLog(`----${this.url}----`);
-        debugLog(`Combined HTML: \n${combinedHtml}`);
-        debugLog('----');
-        return combinedHtml;
+        const cacheKey = `combined:${!!htmlConfig?.keepPositions}:${JSON.stringify(normalizedConfig?.combined ?? null)}`;
+        return this.snapshotCache.fetch(cacheKey, async () => {
+            const combinedHtml = await minifyHtml(htmlCombinedSnapshot(this.html ?? '', normalizedConfig?.combined, { keepPositions: htmlConfig?.keepPositions }));
+            debugLog(`----${this.url}----`);
+            debugLog(`Combined HTML: \n${combinedHtml}`);
+            debugLog('----');
+            return combinedHtml;
+        });
     }
     async textHtml(htmlConfig) {
         const normalizedConfig = this.normalizeHtmlConfig(htmlConfig);
-        return await minifyHtml(htmlTextSnapshot(this.html ?? '', normalizedConfig?.text));
+        const cacheKey = `text:${JSON.stringify(normalizedConfig?.text ?? null)}`;
+        return this.snapshotCache.fetch(cacheKey, () => minifyHtml(htmlTextSnapshot(this.html ?? '', normalizedConfig?.text)));
     }
     getInteractiveARIA() {
         return compactAriaSnapshot(this.ariaSnapshot, false);
@@ -270,26 +265,27 @@ export class ActionResult {
         }
         return new ActionResult(actionResultData);
     }
-    static loadHtmlFromFile(htmlFile) {
+    static loadStateFile(file) {
         try {
-            const filePath = outputPath('states', htmlFile);
-            if (fs.existsSync(filePath)) {
-                return fs.readFileSync(filePath, 'utf8');
-            }
-            return null;
+            const filePath = outputPath('states', file);
+            if (!fs.existsSync(filePath))
+                return null;
+            return fs.readFileSync(filePath, 'utf8');
         }
         catch (error) {
-            console.error('Failed to load HTML from file:', error);
+            console.error('Failed to load state file:', error);
             return null;
         }
     }
+    static loadHtmlFromFile(htmlFile) {
+        return ActionResult.loadStateFile(htmlFile);
+    }
     static loadScreenshotFromFile(screenshotFile) {
         try {
             const filePath = outputPath('states', screenshotFile);
-            if (fs.existsSync(filePath)) {
-                return fs.readFileSync(filePath);
-            }
-            return undefined;
+            if (!fs.existsSync(filePath))
+                return undefined;
+            return fs.readFileSync(filePath);
         }
         catch (error) {
             console.error('Failed to load screenshot from file:', error);
@@ -297,55 +293,38 @@ export class ActionResult {
         }
     }
     static loadBrowserLogsFromFile(logFile) {
-        try {
-            const filePath = outputPath('states', logFile);
-            if (fs.existsSync(filePath)) {
-                const logContent = fs.readFileSync(filePath, 'utf8');
-                return logContent
-                    .split('\n')
-                    .filter((line) => line.trim())
-                    .map((line) => {
-                    const match = line.match(/\[([^\]]+)\] (\w+): (.+)/);
-                    if (match) {
-                        return {
-                            timestamp: match[1],
-                            type: match[2].toLowerCase(),
-                            text: match[3],
-                            level: match[2].toLowerCase(),
-                            message: match[3],
-                        };
-                    }
-                    return { text: line, type: 'log', level: 'log', message: line };
-                });
-            }
-            return [];
-        }
-        catch (error) {
-            console.error('Failed to load browser logs from file:', error);
+        const logContent = ActionResult.loadStateFile(logFile);
+        if (!logContent)
             return [];
-        }
+        return logContent
+            .split('\n')
+            .filter((line) => line.trim())
+            .map((line) => {
+            const match = line.match(/\[([^\]]+)\] (\w+): (.+)/);
+            if (match) {
+                return {
+                    timestamp: match[1],
+                    type: match[2].toLowerCase(),
+                    text: match[3],
+                    level: match[2].toLowerCase(),
+                    message: match[3],
+                };
+            }
+            return { text: line, type: 'log', level: 'log', message: line };
+        });
     }
     static loadAriaSnapshotFromFile(ariaSnapshotFile) {
-        try {
-            const filePath = outputPath('states', ariaSnapshotFile);
-            if (!fs.existsSync(filePath)) {
-                return null;
-            }
-            const content = fs.readFileSync(filePath, 'utf8');
-            const trimmed = content.trim();
-            if (!trimmed) {
-                return null;
-            }
-            return trimmed.endsWith('\n') ? trimmed : `${trimmed}\n`;
-        }
-        catch (error) {
-            console.error('Failed to load aria snapshot from file:', error);
+        const content = ActionResult.loadStateFile(ariaSnapshotFile);
+        if (!content)
             return null;
-        }
+        const trimmed = content.trim();
+        if (!trimmed)
+            return null;
+        return trimmed.endsWith('\n') ? trimmed : `${trimmed}\n`;
     }
     toAiContext() {
         const parts = [];
-        if (this.url && this.url !== '') {
+        if (this.url) {
             parts.push(`<url>${this.url}</url>`);
         }
         if (this.title) {
@@ -380,7 +359,7 @@ export class ActionResult {
         return parts.join('\n');
     }
     get relativeUrl() {
-        if (!this.url || this.url === '')
+        if (!this.url)
             return null;
         try {
             const urlObj = new URL(this.url);
@@ -401,20 +380,11 @@ export class ActionResult {
         const parts = [];
         parts.push(this.relativeUrl || this.url || '/');
         this.extractHeadings(this.html);
-        const headings = ['h1', 'h2'];
-        for (const heading of headings) {
-            const value = this[heading];
-            if (value) {
-                parts.push(`${heading}_${value}`);
-            }
-        }
-        let stateString = parts
-            .map((part) => part.substring(0, 100))
-            .join('_')
-            .replace(/[^a-zA-Z0-9_]/g, '_')
-            .replace(/_+/g, '_')
-            .replace(/^_|_$/g, '')
-            .toLowerCase();
+        if (this.h1)
+            parts.push(`h1_${this.h1}`);
+        if (this.h2)
+            parts.push(`h2_${this.h2}`);
+        let stateString = slugify(parts.map((part) => part.substring(0, 100)).join('_'));
         if (stateString.length > 200) {
             stateString = stateString.substring(0, 200);
             if (stateString.endsWith('_')) {
@@ -423,55 +393,8 @@ export class ActionResult {
         }
         return stateString;
     }
-    saveBrowserLogs() {
-        const logs = this.browserLogsContent;
-        if (!logs || logs.length === 0)
-            return;
-        try {
-            const outputDir = 'output';
-            const stateHash = this.getStateHash();
-            const filename = `${stateHash}.log`;
-            const filePath = join(outputDir, filename);
-            // Ensure output directory exists
-            if (!fs.existsSync(outputDir)) {
-                fs.mkdirSync(outputDir, { recursive: true });
-            }
-            // Format logs for saving
-            const formattedLogs = logs.map((log) => {
-                const timestamp = new Date().toISOString();
-                const level = (log.type || log.level || 'LOG').toUpperCase();
-                const message = log.text || log.message || String(log);
-                return `[${timestamp}] ${level}: ${message}`;
-            });
-            // Save log content to file
-            const logContent = `${formattedLogs.join('\n')}\n`;
-            fs.writeFileSync(filePath, logContent, 'utf8');
-        }
-        catch (error) {
-            // Silently fail to avoid breaking the main flow
-            console.error('Failed to save browser logs:', error);
-        }
-    }
-    saveHtmlOutput() {
-        try {
-            const outputDir = 'output';
-            const stateHash = this.getStateHash();
-            const filename = `${stateHash}.html`;
-            const filePath = join(outputDir, filename);
-            // Ensure output directory exists
-            if (!fs.existsSync(outputDir)) {
-                fs.mkdirSync(outputDir, { recursive: true });
-            }
-            // Save HTML content to file
-            fs.writeFileSync(filePath, this.html, 'utf8');
-        }
-        catch (error) {
-            // Silently fail to avoid breaking the main flow
-            console.error('Failed to save HTML output:', error);
-        }
-    }
     async diff(previousState) {
-        return new Diff(this, previousState);
+        return Diff.create(this, previousState);
     }
     async toToolResult(previousState, locator) {
         const result = {
@@ -497,7 +420,6 @@ export class ActionResult {
             return result;
         }
         const diff = await this.diff(previousState);
-        await diff.calculate();
         const pageDiff = {
             urlChanged,
             previousUrl: previousState.url,
@@ -505,6 +427,7 @@ export class ActionResult {
         };
         if (diff.ariaChanged) {
             pageDiff.ariaChanges = diff.ariaChanged;
+            pageDiff.ariaChangeCount = diff.ariaChangeCount;
         }
         if (diff.htmlParts.length > 0) {
             const htmlConfig = this.normalizeHtmlConfig();
@@ -521,10 +444,7 @@ export class ActionResult {
             }
         }
         if (pageDiff.ariaChanges && this.iframeSnapshots.length > 0) {
-            const addedCount = (pageDiff.ariaChanges.match(/\n {4}- /g) || []).length;
-            const removedMatch = pageDiff.ariaChanges.match(/removed: (\d+) interactive/);
-            const removedCount = removedMatch ? Number.parseInt(removedMatch[1]) : 0;
-            if (addedCount + removedCount >= 50) {
+            if (diff.ariaChangeCount >= LARGE_ARIA_CHANGE_THRESHOLD) {
                 pageDiff.iframes = this.iframeSnapshots.map((snap) => `iframe src="${snap.src}":\n${snap.html}`).join('\n\n');
             }
         }
@@ -559,18 +479,22 @@ export class Diff {
     previous;
     _htmlDiffResult = null;
     _ariaDiffResult = null;
+    _ariaChangeCount = 0;
     _isSameUrl;
-    _urlChanged;
     constructor(current, previous) {
         this.current = current;
         this.previous = previous;
         this._isSameUrl = previous ? current.isSameUrl({ url: previous.url }) : false;
-        this._urlChanged = !this._isSameUrl;
+    }
+    static async create(current, previous) {
+        const diff = new Diff(current, previous);
+        await diff.calculate();
+        return diff;
     }
     hasChanges() {
         if (!this.previous)
             return false;
-        if (this._urlChanged)
+        if (!this._isSameUrl)
             return true;
         const hasHtmlChanges = this._htmlDiffResult && (this._htmlDiffResult.parts.length > 0 || this._htmlDiffResult.added.length > 0 || this._htmlDiffResult.removed.length > 0);
         const hasAriaChanges = this._ariaDiffResult !== null;
@@ -580,7 +504,7 @@ export class Diff {
         return this._isSameUrl;
     }
     urlHasChanged() {
-        return this._urlChanged;
+        return !this._isSameUrl;
     }
     get htmlParts() {
         if (!this._htmlDiffResult)
@@ -590,21 +514,20 @@ export class Diff {
     get ariaChanged() {
         return this._ariaDiffResult;
     }
-    get ariaRemoved() {
-        return this._ariaDiffResult;
+    get ariaChangeCount() {
+        return this._ariaChangeCount;
     }
     get htmlDiff() {
         return this._htmlDiffResult;
     }
-    get ariaDiff() {
-        return this._ariaDiffResult;
-    }
     async calculate() {
         if (!this.previous)
             return;
         if (this._isSameUrl) {
             this._htmlDiffResult = await htmlDiff(this.previous.html, this.current.html, ConfigParser.getInstance().getConfig().html);
         }
-        this._ariaDiffResult = diffAriaSnapshots(this.previous.ariaSnapshot, this.current.ariaSnapshot);
+        const ariaDiff = diffAriaSnapshots(this.previous.ariaSnapshot, this.current.ariaSnapshot);
+        this._ariaDiffResult = ariaDiff.text;
+        this._ariaChangeCount = ariaDiff.count;
     }
 }

package/dist/src/action.d.ts

@@ -0,0 +1,43 @@
+import { ActionResult } from './action-result.js';
+import type { ExplorbotConfig } from './config.js';
+import type { PlaywrightRecorder } from './playwright-recorder.js';
+import type { StateManager } from './state-manager.js';
+declare class Action {
+    actor: CodeceptJS.I;
+    stateManager: StateManager;
+    actionResult: ActionResult | null;
+    config: ExplorbotConfig;
+    action: string | null;
+    lastError: Error | null;
+    playwrightHelper: any;
+    playwrightGroupId: string | null;
+    assertionSteps: Array<{
+        name: string;
+        args: any[];
+    }>;
+    recorder?: PlaywrightRecorder;
+    mainDocumentStatus: number | undefined;
+    constructor(actor: CodeceptJS.I, stateManager: StateManager, recorder?: PlaywrightRecorder);
+    saveScreenshot(): Promise<string | undefined>;
+    capturePageState({ includeScreenshot, codeBlock }?: {
+        includeScreenshot?: boolean;
+        codeBlock?: string;
+    }): Promise<ActionResult>;
+    captureMainDocumentStatus(): Promise<number | undefined>;
+    captureMainDocumentResponse(): () => void;
+    /**
+     * Capture HTML snapshots of all iframes on the page
+     */
+    captureIframeSnapshots(mainHtml: string): Promise<Array<{
+        src: string;
+        html: string;
+        id?: string;
+    }>>;
+    captureBrowserLogs(): Promise<any[]>;
+    execute(code: string): Promise<Action>;
+    attempt(codeBlock: string, originalMessage?: string): Promise<boolean>;
+    getActor(): CodeceptJS.I;
+    getActionResult(): ActionResult | null;
+    waitForPageReadiness(page: any): Promise<void>;
+}
+export default Action;