explorbot 0.1.12 → 0.1.15

package/dist/src/components/StatusPane.js

@@ -32,5 +32,10 @@ export const StatusPane = ({ onComplete }) => {
             React.createElement(Box, { marginTop: 1, marginBottom: 1 },
                 React.createElement(Text, { bold: true }, "Usage")),
             React.createElement(Row, { label: "Time", value: Stats.getElapsedTime() }),
-            tokenRows.map(([model, tokens]) => (React.createElement(Row, { key: model, label: model, value: `${Stats.humanizeTokens(tokens.total)} tokens` })))))));
+            tokenRows.map(([model, tokens]) => {
+                const cached = tokens.cached ?? 0;
+                const cachePct = tokens.input > 0 ? Math.round((cached / tokens.input) * 100) : 0;
+                const suffix = cached > 0 ? ` (${Stats.humanizeTokens(cached)} cached, ${cachePct}%)` : '';
+                return React.createElement(Row, { key: model, label: model, value: `${Stats.humanizeTokens(tokens.total)} tokens${suffix}` });
+            })))));
 };

package/dist/src/experience-tracker.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSy
 import { basename, dirname, join } from 'node:path';
 import matter from 'gray-matter';
 import { marked } from 'marked';
+import { isNonReusableCode } from "./ai/historian/utils.js";
 import { ConfigParser } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
 import { createDebug, tag } from './utils/logger.js';
@@ -145,6 +146,10 @@ export class ExperienceTracker {
             return;
         if (!action.code?.trim())
             return;
+        if (isNonReusableCode(action.code)) {
+            debugLog('Skipping action with non-reusable code: %s', action.code);
+            return;
+        }
         this.ensureExperienceFile(state);
         const stateHash = state.getStateHash();
         const { content, data } = this.readExperienceFile(stateHash);
@@ -166,6 +171,10 @@ export class ExperienceTracker {
             return;
         if (!body?.trim())
             return;
+        if (isNonReusableCode(body)) {
+            debugLog('Skipping flow body with non-reusable code');
+            return;
+        }
         this.ensureExperienceFile(state);
         const stateHash = state.getStateHash();
         const { content, data } = this.readExperienceFile(stateHash);

package/dist/src/explorbot.js

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { ActionResult } from "./action-result.js";
-import { Bosun } from "./ai/bosun.js";
 import { Captain } from "./ai/captain.js";
+import { Driller } from "./ai/driller.js";
 import { ExperienceCompactor } from "./ai/experience-compactor.js";
 import { Fisherman } from "./ai/fisherman.js";
 import { Historian } from "./ai/historian.js";
@@ -13,6 +13,7 @@ import { AIProvider } from "./ai/provider.js";
 import { Quartermaster } from "./ai/quartermaster.js";
 import { Rerunner } from "./ai/rerunner.js";
 import { Researcher } from "./ai/researcher.js";
+import { SessionAnalyst } from "./ai/session-analyst.js";
 import { Tester } from "./ai/tester.js";
 import { createAgentTools } from "./ai/tools.js";
 import { ApiClient } from "./api/api-client.js";
@@ -24,6 +25,7 @@ import Explorer from "./explorer.js";
 import { KnowledgeTracker } from "./knowledge-tracker.js";
 import { Plan } from "./test-plan.js";
 import { setVerboseMode, tag } from "./utils/logger.js";
+import { relativeToCwd } from "./utils/next-steps.js";
 import { sanitizeFilename } from "./utils/strings.js";
 export class ExplorBot {
     configParser;
@@ -38,6 +40,8 @@ export class ExplorBot {
     lastPlanError = null;
     lastSavedPlanPath = null;
     agents = {};
+    sessionPlans = [];
+    lastReportedTestCount = 0;
     constructor(options = {}) {
         this.options = options;
         this.configParser = ConfigParser.getInstance();
@@ -239,14 +243,15 @@ export class ExplorBot {
         }
         return this.agents.rerunner;
     }
-    agentBosun() {
-        return (this.agents.bosun ||= this.createAgent(({ ai, explorer }) => {
-            const researcher = this.agentResearcher();
+    agentDriller() {
+        return (this.agents.driller ||= this.createAgent(({ ai, explorer }) => {
             const navigator = this.agentNavigator();
-            const tools = createAgentTools({ explorer, researcher, navigator });
-            return new Bosun(explorer, ai, researcher, navigator, tools);
+            return new Driller(explorer, ai, navigator);
         }));
     }
+    agentSessionAnalyst() {
+        return (this.agents.sessionAnalyst ||= this.createAgent(({ ai }) => new SessionAnalyst(ai)));
+    }
     agentFisherman() {
         const fishermanConfig = this.config.ai?.agents?.fisherman;
         const hasApiConfig = !!this.config.api;
@@ -309,7 +314,7 @@ export class ExplorBot {
         }
         this.lastPlanError = null;
         try {
-            this.currentPlan = await planner.plan(feature, opts.style, opts.extend, opts.completedPlans);
+            this.setCurrentPlan(await planner.plan(feature, opts.style, opts.extend, opts.completedPlans));
         }
         catch (err) {
             this.lastPlanError = err instanceof Error ? err : new Error(String(err));
@@ -376,10 +381,45 @@ export class ExplorBot {
         if (!existsSync(planPath)) {
             throw new Error(`Plan file not found: ${planPath}`);
         }
-        this.currentPlan = Plan.fromMarkdown(planPath);
+        this.setCurrentPlan(Plan.fromMarkdown(planPath));
         return this.currentPlan;
     }
     setCurrentPlan(plan) {
         this.currentPlan = plan;
+        if (plan && !this.sessionPlans.includes(plan)) {
+            this.sessionPlans.push(plan);
+        }
+    }
+    getSessionTests() {
+        return this.sessionPlans.flatMap((p) => p.tests.filter((t) => t.startTime != null));
+    }
+    async printSessionAnalysis() {
+        const analystConfig = this.config.ai?.agents?.analyst;
+        if (analystConfig?.enabled === false)
+            return;
+        const tests = this.getSessionTests();
+        if (tests.length === 0)
+            return;
+        if (tests.length === this.lastReportedTestCount)
+            return;
+        try {
+            const markdown = await this.agentSessionAnalyst().analyze(tests);
+            if (!markdown) {
+                this.lastReportedTestCount = tests.length;
+                return;
+            }
+            tag('multiline').log(markdown);
+            const filePath = this.agentSessionAnalyst().writeReport(markdown);
+            tag('info').log(`Session report saved: ${relativeToCwd(filePath)}`);
+            const reporter = this.explorer?.getReporter();
+            if (reporter?.isEnabled()) {
+                await reporter.setRunDescription(markdown);
+            }
+            this.lastReportedTestCount = tests.length;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            tag('warning').log(`Session analysis failed: ${message}`);
+        }
     }
 }

package/dist/src/explorer.js

@@ -10,13 +10,14 @@ import Action from './action.js';
 import { visuallyAnnotateContainers } from "./ai/researcher/coordinates.js";
 import { RequestStore } from "./api/request-store.js";
 import { XhrCapture } from "./api/xhr-capture.js";
-import { ConfigParser, outputPath } from './config.js';
+import { ConfigParser } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
 import { PlaywrightRecorder } from "./playwright-recorder.js";
 import { Reporter } from "./reporter.js";
 import { StateManager } from './state-manager.js';
+import { ELEMENT_EXTRACTION_CONFIG, getElementDataExtractorSource } from "./utils/html.js";
 import { createDebug, log, tag } from './utils/logger.js';
-import { WebElement, extractElementData } from "./utils/web-element.js";
+import { WebElement } from "./utils/web-element.js";
 const debugLog = createDebug('explorbot:explorer');
 const FATAL_BROWSER_ERRORS = /Frame was detached|Target closed|Execution context was destroyed|Protocol error|Session closed/i;
 const RECOVERABLE_NAVIGATION_ERRORS = /net::ERR_ABORTED|page\.screenshot.*Timeout|waiting for fonts to load/i;
@@ -270,11 +271,11 @@ class Explorer {
     async getEidxInContainer(containerCss) {
         const page = this.playwrightHelper.page;
         try {
-            const selector = containerCss ? `${containerCss} [data-explorbot-eidx]` : '[data-explorbot-eidx]';
+            const selector = containerCss ? `${containerCss} [${ELEMENT_EXTRACTION_CONFIG.attrs.eidx}]` : `[${ELEMENT_EXTRACTION_CONFIG.attrs.eidx}]`;
             const elements = await page.locator(selector).all();
             const result = [];
             for (const el of elements) {
-                const attr = await el.getAttribute('data-explorbot-eidx');
+                const attr = await el.getAttribute(ELEMENT_EXTRACTION_CONFIG.attrs.eidx);
                 if (attr)
                     result.push(attr);
             }
@@ -293,7 +294,7 @@ class Explorer {
             const page = this.playwrightHelper.page;
             const base = container ? page.locator(container) : page;
             const el = locator.startsWith('//') ? base.locator(`xpath=${locator}`) : base.locator(locator);
-            return await el.first().getAttribute('data-explorbot-eidx');
+            return await el.first().getAttribute(ELEMENT_EXTRACTION_CONFIG.attrs.eidx);
         }
         catch (error) {
             if (this.isFatalBrowserError(error)) {
@@ -466,10 +467,7 @@ class Explorer {
             if (!this.stateManager.getCurrentState())
                 return;
             const lastScreenshot = ActionResult.fromState(this.stateManager.getCurrentState()).screenshotFile;
-            if (!lastScreenshot)
-                return;
-            const screenshotPath = outputPath('states', lastScreenshot);
-            test.addArtifact(screenshotPath);
+            test.setActiveNoteScreenshot(lastScreenshot);
         };
         const dialogHandler = (dialog) => {
             const dialogType = dialog.type();
@@ -644,21 +642,21 @@ export async function annotatePageElements(page) {
     const elements = [];
     for (const [role, entries] of byRole) {
         try {
-            const rawList = await page.getByRole(role).evaluateAll((domElements, [data, extractFnStr]) => {
+            const rawList = await page.getByRole(role).evaluateAll((domElements, [data, extractFnStr, config]) => {
                 const extract = new Function(`return ${extractFnStr}`)();
                 const results = [];
                 let ariaIdx = 0;
                 for (const el of domElements) {
                     if (ariaIdx >= data.length)
                         break;
-                    el.setAttribute('data-explorbot-eidx', data[ariaIdx].ref);
-                    const elData = extract(el);
+                    el.setAttribute(config.attrs.eidx, data[ariaIdx].ref);
+                    const elData = extract(el, config);
                     if (elData)
                         results.push(elData);
                     ariaIdx++;
                 }
                 return results;
-            }, [entries, extractElementData.toString()]);
+            }, [entries, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]);
             for (const raw of rawList) {
                 elements.push(WebElement.fromRawData(raw, role));
             }

package/dist/src/reporter.js

@@ -14,8 +14,19 @@ export class Reporter {
         if (this.reporterEnabled && (!process.env.TESTOMATIO || config?.html)) {
             this.configureHtmlPipe();
         }
-        const pipe = process.env.TESTOMATIO && config?.html ? 'both' : process.env.TESTOMATIO ? 'testomatio' : 'html';
-        debugLog('Reporter initialized', { enabled: this.reporterEnabled, pipe });
+        if (this.reporterEnabled && config?.markdown) {
+            this.configureMarkdownPipe();
+        }
+        if (this.reporterEnabled) {
+            this.configureRunGroup(config?.runGroup);
+        }
+        debugLog('Reporter initialized', {
+            enabled: this.reporterEnabled,
+            testomatio: Boolean(process.env.TESTOMATIO),
+            html: Boolean(process.env.TESTOMATIO_HTML_REPORT_SAVE),
+            markdown: Boolean(process.env.TESTOMATIO_MARKDOWN_REPORT_SAVE),
+            runGroup: process.env.TESTOMATIO_RUNGROUP_TITLE || null,
+        });
     }
     buildTitle() {
         if (process.env.TESTOMATIO_TITLE)
@@ -39,7 +50,31 @@ export class Reporter {
     configureHtmlPipe() {
         process.env.TESTOMATIO_HTML_REPORT_SAVE = '1';
         process.env.TESTOMATIO_HTML_REPORT_FOLDER = outputPath('reports');
-        debugLog('HTML report pipe configured', { folder: process.env.TESTOMATIO_HTML_REPORT_FOLDER });
+        process.env.TESTOMATIO_HTML_FILENAME = `${Stats.sessionLabel()}.html`;
+        debugLog('HTML report pipe configured', {
+            folder: process.env.TESTOMATIO_HTML_REPORT_FOLDER,
+            filename: process.env.TESTOMATIO_HTML_FILENAME,
+        });
+    }
+    configureMarkdownPipe() {
+        process.env.TESTOMATIO_MARKDOWN_REPORT_SAVE = '1';
+        process.env.TESTOMATIO_MARKDOWN_REPORT_FOLDER = outputPath('reports');
+        process.env.TESTOMATIO_MARKDOWN_FILENAME = `${Stats.sessionLabel()}-tests.md`;
+        debugLog('Markdown report pipe configured', {
+            folder: process.env.TESTOMATIO_MARKDOWN_REPORT_FOLDER,
+            filename: process.env.TESTOMATIO_MARKDOWN_FILENAME,
+        });
+    }
+    configureRunGroup(runGroup) {
+        if (process.env.TESTOMATIO_RUNGROUP_TITLE)
+            return;
+        if (runGroup === null)
+            return;
+        if (runGroup) {
+            process.env.TESTOMATIO_RUNGROUP_TITLE = runGroup;
+            return;
+        }
+        process.env.TESTOMATIO_RUNGROUP_TITLE = `Explorbot ${new Date().toISOString().slice(0, 10)}`;
     }
     async startRun() {
         if (this.isRunStarted) {
@@ -52,7 +87,7 @@ export class Reporter {
             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]);
+            const result = await Promise.race([this.client.createRun({ configuration: { exploratory: true } }).then(() => 'success'), timeoutPromise]);
             if (result === 'timeout') {
                 debugLog('Reporter run creation timed out');
                 return;
@@ -82,6 +117,7 @@ export class Reporter {
             message: note.message,
             status: note.status,
             screenshot: note.screenshot,
+            log: note.log,
         }))
             .sort((a, b) => a.startTime - b.startTime);
         const stepEntries = Object.entries(test.steps)
@@ -113,8 +149,16 @@ export class Reporter {
             if (noteEntry.screenshot) {
                 step.artifacts = [outputPath('states', noteEntry.screenshot)];
             }
+            if (noteEntry.log) {
+                step.log = noteEntry.log;
+            }
             steps.push(step);
         }
+        const verificationStep = this.buildVerificationStep(test, lastScreenshotFile);
+        if (verificationStep) {
+            steps.push(verificationStep);
+            return steps;
+        }
         if (lastScreenshotFile && steps.length > 0) {
             const lastStep = steps[steps.length - 1];
             const screenshotPath = outputPath('states', lastScreenshotFile);
@@ -127,6 +171,37 @@ export class Reporter {
         }
         return steps;
     }
+    buildVerificationStep(test, lastScreenshotFile) {
+        const v = test.verification;
+        if (!v)
+            return undefined;
+        const subSteps = [];
+        if (v.message)
+            subSteps.push({ category: 'framework', title: v.message, duration: 0 });
+        if (v.url) {
+            subSteps.push({
+                category: 'framework',
+                title: v.pageLabel ? `Navigated to ${v.pageLabel}` : 'Final page',
+                log: v.url,
+                duration: 0,
+            });
+        }
+        for (const detail of v.details) {
+            subSteps.push({ category: 'framework', title: detail, duration: 0 });
+        }
+        const screenshotFile = v.screenshot || lastScreenshotFile;
+        const step = {
+            category: 'user',
+            title: 'Verification',
+            duration: 0,
+            status: v.status || 'none',
+            steps: subSteps.length > 0 ? subSteps : undefined,
+        };
+        if (screenshotFile) {
+            step.artifacts = [outputPath('states', screenshotFile)];
+        }
+        return step;
+    }
     async reportTest(test, meta) {
         await this.startRun();
         if (!this.isRunStarted) {
@@ -190,6 +265,32 @@ export class Reporter {
     isEnabled() {
         return this.isRunStarted;
     }
+    async setRunDescription(text) {
+        if (!this.isRunStarted)
+            return;
+        if (!process.env.TESTOMATIO)
+            return;
+        const runId = this.client.runId;
+        if (!runId)
+            return;
+        const baseUrl = process.env.TESTOMATIO_URL || 'https://app.testomat.io';
+        const url = `${baseUrl}/api/reporter/${runId}`;
+        try {
+            const response = await fetch(url, {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ api_key: process.env.TESTOMATIO, description: text }),
+            });
+            if (!response.ok) {
+                debugLog('Run description update failed:', response.status, response.statusText);
+                return;
+            }
+            debugLog('Run description updated');
+        }
+        catch (error) {
+            debugLog('Failed to update run description:', error);
+        }
+    }
     extractLastNoteMessage(test) {
         const notes = Object.values(test.notes);
         if (notes.length === 0)

package/dist/src/state-manager.js

@@ -70,8 +70,8 @@ export class StateManager {
     }
     /**
      * Extract state path from full URL
-     * Removes domain, port, protocol, and query params
-     * Keeps path and hash: /path/to/page#section
+     * Removes domain, port, protocol
+     * Keeps path, query, and hash: /path/to/page?tab=users#section
      */
     /**
      * Update current state from ActionResult and record transition if state changed
@@ -418,7 +418,8 @@ export class StateManager {
 export function normalizeUrl(url) {
     try {
         const parsed = new URL(url, 'http://localhost');
-        return parsed.pathname.replace(/^\/+|\/+$/g, '');
+        const path = parsed.pathname.replace(/^\/+|\/+$/g, '');
+        return `${path}${parsed.search}${parsed.hash}`;
     }
     catch {
         return url.replace(/^\/+|\/+$/g, '');

package/dist/src/stats.js

@@ -1,5 +1,7 @@
+import { uniqExplorationName } from "./utils/unique-names.js";
 export class Stats {
     static startTime = Date.now();
+    static sessionName = uniqExplorationName();
     static researches = 0;
     static tests = 0;
     static plans = 0;
@@ -8,11 +10,12 @@ export class Stats {
     static models = {};
     static recordTokens(_agent, model, usage) {
         if (!Stats.models[model]) {
-            Stats.models[model] = { input: 0, output: 0, total: 0 };
+            Stats.models[model] = { input: 0, output: 0, total: 0, cached: 0 };
         }
         Stats.models[model].input += usage.input;
         Stats.models[model].output += usage.output;
         Stats.models[model].total += usage.total;
+        Stats.models[model].cached = (Stats.models[model].cached ?? 0) + (usage.cached ?? 0);
     }
     static getElapsedTime() {
         const elapsed = Date.now() - Stats.startTime;
@@ -42,4 +45,7 @@ export class Stats {
         const totalTokens = Object.values(Stats.models).reduce((sum, m) => sum + m.total, 0);
         return totalTokens > 0;
     }
+    static sessionLabel() {
+        return `${Stats.mode || 'session'}-${Stats.sessionName}`;
+    }
 }

package/dist/src/test-plan.js

@@ -17,6 +17,7 @@ export class ActiveNote {
     message;
     status;
     screenshot;
+    log;
     constructor(task, message, status) {
         this.task = task;
         this.startTime = performance.now();
@@ -41,6 +42,7 @@ export class Task {
     steps;
     states;
     startUrl;
+    verification;
     timestampCounter = 0;
     activeNote;
     constructor(description, startUrl = '') {
@@ -67,6 +69,7 @@ export class Task {
             startTime: activeNote.getStartTime(),
             endTime,
             screenshot: activeNote.screenshot,
+            log: activeNote.log,
         };
         this.activeNote = undefined;
     }
@@ -80,13 +83,30 @@ export class Task {
             .map((n) => `- ${n}`)
             .join('\n');
     }
-    addNote(message, status = null, screenshot) {
-        const isDuplicate = Object.values(this.notes).some((note) => note.message === message && note.status === status);
+    addNote(message, status = null, screenshot, log) {
+        const isDuplicate = Object.values(this.notes).some((note) => note.message === message && note.status === status && note.log === log);
         if (isDuplicate)
             return;
         const now = performance.now();
         const timestamp = `${now}_${this.timestampCounter++}`;
-        this.notes[timestamp] = { message, status, startTime: now, endTime: now, screenshot };
+        this.notes[timestamp] = { message, status, startTime: now, endTime: now, screenshot, log };
+    }
+    addUrlNote(state, prevState) {
+        const fullUrl = state.fullUrl || state.url;
+        if (!fullUrl)
+            return;
+        let label;
+        if (state.title && state.title !== prevState?.title)
+            label = state.title;
+        else if (state.h1 && state.h1 !== prevState?.h1)
+            label = state.h1;
+        else if (state.h2 && state.h2 !== prevState?.h2)
+            label = state.h2;
+        else
+            label = state.title || state.h1 || state.h2;
+        if (!label)
+            return;
+        this.addNote(`Navigated to ${label}`, TestResult.PASSED, state.screenshotFile, fullUrl);
     }
     addState(state) {
         this.states.push(state);
@@ -95,6 +115,30 @@ export class Task {
         const timestamp = `${performance.now()}_${this.timestampCounter++}`;
         this.steps[timestamp] = { text, duration, status, error, log, artifacts, noteStartTime: this.activeNote?.getStartTime() };
     }
+    setActiveNoteScreenshot(screenshotFile) {
+        if (!this.activeNote || !screenshotFile)
+            return;
+        this.activeNote.screenshot = screenshotFile;
+    }
+    setVerification(message, status, state) {
+        this.verification ||= { message: '', status: null, details: [] };
+        this.verification.message = message;
+        this.verification.status = status;
+        if (!state)
+            return;
+        if (state.screenshotFile)
+            this.verification.screenshot = state.screenshotFile;
+        const fullUrl = state.fullUrl || state.url;
+        if (fullUrl)
+            this.verification.url = fullUrl;
+        this.verification.pageLabel = state.title || state.h1 || state.h2 || undefined;
+    }
+    addVerificationDetail(detail) {
+        if (!detail)
+            return;
+        this.verification ||= { message: '', status: null, details: [] };
+        this.verification.details.push(detail);
+    }
     getLog() {
         const merged = {};
         for (const [key, stepData] of Object.entries(this.steps)) {