explorbot 0.1.30 → 0.1.32-beta.1

package/dist/src/utils/context-formatter.d.ts

@@ -0,0 +1,25 @@
+export interface ContextData {
+    url: string;
+    title?: string;
+    headings: {
+        h1?: string;
+        h2?: string;
+        h3?: string;
+        h4?: string;
+    };
+    experience: Array<{
+        filePath: string;
+        data: any;
+        content: string;
+    }>;
+    knowledge: Array<{
+        filePath: string;
+        url: string;
+        content: string;
+    }>;
+    ariaSnapshot: string | null;
+    combinedHtml?: string;
+    research?: string;
+}
+export type ContextMode = 'attached' | 'compact' | 'full';
+export declare function formatContextSummary(data: ContextData, mode?: ContextMode): string;

package/dist/src/utils/error-page.d.ts

@@ -0,0 +1,12 @@
+import { ActionResult } from '../action-result.js';
+import type { WebPageState } from '../state-manager.js';
+export type PageCondition = 'ok' | 'loading' | 'error';
+export declare function detectPageCondition(actionResult: ActionResult): PageCondition;
+export declare function isErrorPage(actionResult: ActionResult): boolean;
+export declare function getStateErrorPageError(state: WebPageState | null | undefined): ErrorPageError | null;
+export declare class ErrorPageError extends Error {
+    readonly url: string;
+    readonly title?: string;
+    readonly httpStatus?: number;
+    constructor(url: string, title?: string, httpStatus?: number);
+}

package/dist/src/utils/expandable.d.ts

@@ -0,0 +1,4 @@
+export declare const EXPANDABLE_ICON_DESCRIPTIONS: string[];
+export declare const EXPANDABLE_XPATHS: string[];
+export declare function buildExpandableXPath(excludeContainers?: string[]): string;
+export declare function buildExpandableXPathInsideContainers(containers: string[]): string[];

package/dist/src/utils/hooks-runner.d.ts

@@ -0,0 +1,15 @@
+import type { ExplorbotConfig, Hook, HookConfig } from '../config.js';
+import type Explorer from '../explorer.js';
+export declare class HooksRunner {
+    explorer: Explorer;
+    config: ExplorbotConfig;
+    constructor(explorer: Explorer, config: ExplorbotConfig);
+    runBeforeHook(agentName: string, url: string): Promise<void>;
+    runAfterHook(agentName: string, url: string): Promise<void>;
+    runHook(agentName: string, hookType: 'beforeHook' | 'afterHook', url: string): Promise<void>;
+    findMatchingHook(config: HookConfig, url: string): Hook | null;
+    patternSpecificity(pattern: string): number;
+    executeHook(hook: Hook, url: string): Promise<void>;
+    isSingleHook(config: HookConfig): boolean;
+    extractPath(url: string): string;
+}

package/dist/src/utils/html-diff.d.ts

@@ -0,0 +1,19 @@
+import type { HtmlConfig } from '../config.js';
+export interface HtmlDiffPart {
+    container: string;
+    subtree: string;
+    added: string[];
+    removed: string[];
+}
+export interface HtmlDiffResult {
+    parts: HtmlDiffPart[];
+    added: string[];
+    removed: string[];
+    similarity: number;
+    summary: string;
+}
+export declare function computeHtmlFingerprint(html: string): string[];
+/**
+ * Compares two HTML documents and returns differences along with a diff subtree.
+ */
+export declare function htmlDiff(originalHtml: string, modifiedHtml: string, htmlConfig?: HtmlConfig): Promise<HtmlDiffResult>;

package/dist/src/utils/html.d.ts

@@ -0,0 +1,124 @@
+import type * as parse5TreeAdapter from 'parse5/lib/tree-adapters/default';
+import type { HtmlConfig } from '../config.js';
+export declare const EXPLORBOT_ATTRS: {
+    readonly area: "data-explorbot-area";
+    readonly context: "data-explorbot-context";
+    readonly eidx: "data-explorbot-eidx";
+    readonly variant: "data-explorbot-variant";
+};
+export declare const HTML_SELECTORS: {
+    readonly headingLabel: "h1, h2, h3, h4, h5, h6, legend, caption, label, [role=\"heading\"]";
+    readonly interactiveContent: "button, a[href], input, select, textarea, [role=\"button\"], [role=\"link\"], [role=\"option\"], [role=\"menuitem\"], [role=\"switch\"], [role=\"checkbox\"], [role=\"radio\"], [aria-label], [tabindex]";
+    readonly interactiveControl: "button, a[href], input, select, textarea, [role=\"button\"], [role=\"link\"], [role=\"checkbox\"], [role=\"radio\"], [role=\"switch\"], [role=\"tab\"], [role=\"menuitem\"]";
+    readonly labelLike: "h1, h2, h3, h4, h5, h6, legend, caption, label, [role=\"heading\"], [class*=\"title\"], [class*=\"label\"], [class*=\"header\"], [class*=\"name\"]";
+    readonly semanticContextContainer: "section, article, form, fieldset, li, tr, td, th, [role=\"group\"], [role=\"tabpanel\"], [role=\"region\"], [class*=\"card\"], [class*=\"panel\"], [class*=\"item\"], [class*=\"usage\"], [class*=\"group\"]";
+    readonly semanticOverlays: readonly ["[role=\"dialog\"]", "[role=\"listbox\"]", "[role=\"menu\"]", "[role=\"tooltip\"]:not([style*=\"display: none\"]):not([style*=\"visibility: hidden\"])"];
+};
+export declare const HTML_VISIBILITY_LIMITS: {
+    readonly maxViewportOverlayRatio: 0.95;
+    readonly minOpacity: 0.1;
+    readonly minOverlayHeight: 40;
+    readonly minOverlayWidth: 80;
+};
+export declare const HTML_EXTRACTION_LIMITS: {
+    readonly componentScopeHtmlLength: 8000;
+    readonly maxOverlayCount: 3;
+    readonly maxScopeInteractiveCount: 16;
+    readonly overlayHtmlLength: 6000;
+};
+export declare const CODE_EDITOR_MARKERS: readonly ["monaco", "codemirror", "ace", "ace_editor", "code"];
+export declare const HTML_INTERACTIVE_ROLES: Set<string>;
+export declare const HTML_FORM_CONTROL_ROLES: Set<string>;
+export declare const HTML_COMPOSITE_TARGET_ROLES: Set<string>;
+export declare const HTML_COMPOSITE_AREA_HINTS: Set<string>;
+export declare const HTML_FORM_CONTROL_TAGS: Set<string>;
+export declare function inferHtmlRole(data: {
+    attrs: Record<string, string>;
+    role?: string;
+    tag: string;
+    variantHints?: string[];
+}): string;
+export declare const ELEMENT_EXTRACTION_CONFIG: {
+    readonly attrs: {
+        readonly area: "data-explorbot-area";
+        readonly context: "data-explorbot-context";
+        readonly eidx: "data-explorbot-eidx";
+        readonly variant: "data-explorbot-variant";
+    };
+    readonly codeEditorMarkers: readonly ["monaco", "codemirror", "ace", "ace_editor", "code"];
+    readonly maxAreaDepth: 5;
+    readonly maxContextLength: 120;
+    readonly maxOuterHTMLLength: 2000;
+    readonly maxTextLength: 80;
+    readonly minOpacity: 0.1;
+    readonly selectors: {
+        readonly headingLabel: "h1, h2, h3, h4, h5, h6, legend, caption, label, [role=\"heading\"]";
+        readonly labelLike: "h1, h2, h3, h4, h5, h6, legend, caption, label, [role=\"heading\"], [class*=\"title\"], [class*=\"label\"], [class*=\"header\"], [class*=\"name\"]";
+        readonly semanticContextContainer: "section, article, form, fieldset, li, tr, td, th, [role=\"group\"], [role=\"tabpanel\"], [role=\"region\"], [class*=\"card\"], [class*=\"panel\"], [class*=\"item\"], [class*=\"usage\"], [class*=\"group\"]";
+    };
+};
+export type ElementExtractionConfig = typeof ELEMENT_EXTRACTION_CONFIG;
+export type RawElementData = NonNullable<ReturnType<typeof extractElementData>>;
+export type VisibleOverlayExtractionConfig = {
+    interactiveContentSelector: string;
+    limits: typeof HTML_EXTRACTION_LIMITS;
+    overlaySelectors: readonly string[];
+    visibilityLimits: typeof HTML_VISIBILITY_LIMITS;
+};
+export type ComponentScopeExtractionConfig = {
+    eidxAttr: string;
+    interactiveControlSelector: string;
+    limits: typeof HTML_EXTRACTION_LIMITS;
+};
+export declare function extractElementData(el: Element, config?: ElementExtractionConfig): {
+    tag: string;
+    text: string;
+    allAttrs: Record<string, string>;
+    outerHTML: string;
+    x: number;
+    y: number;
+};
+export declare function getElementDataExtractorSource(): string;
+export declare function extractVisibleOverlayHtml(config: VisibleOverlayExtractionConfig): string;
+export declare function extractComponentScopeHtml(eidx: string, config: ComponentScopeExtractionConfig): string;
+export declare function getVisibleOverlayHtmlExtractorSource(): string;
+export declare function getComponentScopeHtmlExtractorSource(): string;
+export declare const TRASH_HTML_CLASSES: RegExp;
+export declare const TAILWIND_CLASS_PATTERNS: RegExp[];
+export declare function sanitizeHtmlDocument(html: string, htmlConfig?: HtmlConfig): parse5TreeAdapter.Document;
+export declare function sanitizeHtmlString(html: string, htmlConfig?: HtmlConfig): string;
+/**
+ * Creates a minimal snapshot keeping only interactive elements and their structure
+ * Based on CodeceptJS HTML library
+ */
+export declare function htmlMinimalUISnapshot(html: string, htmlConfig?: HtmlConfig['minimal']): string;
+export declare function minifyHtml(html: string): Promise<string>;
+/**
+ * Creates a combined snapshot with interactive elements and meaningful text
+ * Preserves original HTML structure
+ */
+export declare function htmlCombinedSnapshot(html: string, htmlConfig?: HtmlConfig['combined'], opts?: {
+    keepPositions?: boolean;
+}): string;
+/**
+ * Creates text-only snapshot with markdown formatting
+ */
+export declare function htmlTextSnapshot(html: string, htmlConfig?: HtmlConfig['text']): string;
+export interface ExtractedLink {
+    title: string;
+    url: string;
+}
+export declare function extractLinks(html: string): ExtractedLink[];
+export declare function extractHeadings(html: string): {
+    h1?: string;
+    h2?: string;
+    h3?: string;
+    h4?: string;
+};
+export declare function codeToMarkdown(code: string): string;
+export declare function isBodyEmpty(html: string): boolean;
+/**
+ * Extract HTML snippet around a targeted element based on locator
+ * Used for accessibility analysis to show what element was being targeted
+ */
+export declare function extractTargetedHtml(html: string, locator: string): string;

package/dist/src/utils/log-filters.d.ts

@@ -0,0 +1,6 @@
+export declare class RecentStepFilter {
+    ttlMs: number;
+    recentStepKeys: Map<string, number>;
+    constructor(ttlMs?: number);
+    shouldSuppress(content: string, now?: number): boolean;
+}

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,35 @@
+import { type Span } from '@opentelemetry/api';
+export type LogType = 'info' | 'success' | 'error' | 'warning' | 'debug' | 'substep' | 'operation' | 'step' | 'multiline' | 'details' | 'html' | 'input';
+export interface TaggedLogEntry {
+    type: LogType;
+    content: string;
+    timestamp?: Date;
+    originalArgs?: any[];
+    namespace?: string;
+    maxLines?: number;
+}
+type LogEntry = TaggedLogEntry;
+export declare const tag: (type: LogType) => {
+    log: (...args: any[]) => void;
+};
+export declare const log: (...args: any[]) => void;
+export declare const logSuccess: (...args: any[]) => void;
+export declare const logError: (...args: any[]) => void;
+export declare const logWarning: (...args: any[]) => void;
+export declare const logSubstep: (...args: any[]) => void;
+export declare const createDebug: (namespace: string) => (...args: any[]) => void;
+export declare const getMethodsOfObject: (obj: any) => string[];
+export declare const startLogCapture: () => void;
+export declare const stopLogCapture: () => string[];
+export declare const setVerboseMode: (enabled: boolean) => void;
+export declare const setPreserveConsoleLogs: (enabled: boolean) => void;
+export declare const isVerboseMode: () => boolean;
+export declare const setDebugMode: (enabled: boolean) => void;
+export declare const isDebugMode: () => boolean;
+export declare const registerLogPane: (addLog: (entry: LogEntry) => void) => void;
+export declare const unregisterLogPane: (addLog: (entry: LogEntry) => void) => void;
+export declare const addTruncateTag: (tagName: string) => void;
+export declare const setStepSpanParent: (span: Span | null) => void;
+export declare const setLogCallback: (addLog: (entry: LogEntry) => void) => void;
+export declare const pluralize: (count: number, singular: string, plural?: string) => string;
+export {};

package/dist/src/utils/loop.d.ts

@@ -0,0 +1,35 @@
+export declare class StopError extends Error {
+    constructor(message?: string);
+}
+export declare class InterruptError extends Error {
+    userInput: string | null;
+    constructor(userInput: string | null);
+}
+export interface LoopContext {
+    stop: () => void;
+    iteration: number;
+    pause: (prompt?: string) => Promise<string | null>;
+    userInput: string | null;
+    setUserInput: (input: string) => void;
+}
+export interface CatchContext {
+    error: Error;
+    stop: () => void;
+    iteration: number;
+}
+export interface LoopOptions {
+    maxAttempts?: number;
+    interruptible?: boolean;
+    interruptPrompt?: string;
+    onInterrupt?: (userInput: string | null, context: LoopContext) => Promise<void> | void;
+    catch?: (context: CatchContext) => Promise<void> | void;
+    observability?: {
+        name?: string;
+        agent?: string;
+        sessionId?: string;
+        tags?: string[];
+        metadata?: Record<string, unknown>;
+    };
+}
+export declare function pause(prompt?: string): Promise<string | null>;
+export declare function loop<T>(handler: (context: LoopContext) => Promise<T>, options?: LoopOptions): Promise<any>;

package/dist/src/utils/markdown-parser.d.ts

@@ -0,0 +1,17 @@
+export interface MarkdownSection {
+    name: string;
+    depth: number;
+    rawMarkdown: string;
+}
+export declare function parseSections(markdown: string, opts?: {
+    minDepth?: number;
+    maxDepth?: number;
+}): MarkdownSection[];
+export declare function extractLabeledCode(markdown: string, labelPattern: RegExp): string | null;
+export declare function tableToJson(markdown: string): Record<string, string>[];
+export declare function jsonToTable(rows: Record<string, string>[], columns?: string[]): string;
+export declare function findTableRaw(markdown: string): string | null;
+export declare function findTableLineRange(markdown: string): {
+    start: number;
+    end: number;
+} | null;

package/dist/src/utils/markdown-query.d.ts

@@ -0,0 +1,40 @@
+import { type Token } from 'marked';
+export type SelectorType = 'section' | 'section1' | 'section2' | 'section3' | 'section4' | 'section5' | 'section6' | 'table' | 'heading' | 'paragraph' | 'list' | 'item' | 'code' | 'blockquote' | 'hr' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+export interface TextMatcher {
+    mode: 'exact' | 'contains' | 'regex';
+    value: string;
+    negated: boolean;
+}
+export interface QuerySegment {
+    selector: SelectorType;
+    textMatch?: TextMatcher;
+    index: number | null;
+    slice: {
+        from?: number;
+        to?: number;
+    } | null;
+}
+export interface MatchedRange {
+    token: Token;
+    start: number;
+    length: number;
+    innerTokens?: MatchedRange[];
+}
+export declare function parseQuery(input: string): QuerySegment[];
+export declare class MarkdownQuery {
+    source: string;
+    matches: MatchedRange[];
+    constructor(source: string, matches?: MatchedRange[]);
+    query(selector: string): MarkdownQuery;
+    text(): string;
+    get(): string;
+    toJson(): Record<string, string>[];
+    replace(content: string): string;
+    count(): number;
+    first(): MarkdownQuery;
+    last(): MarkdownQuery;
+    before(): MarkdownQuery;
+    after(): MarkdownQuery;
+    each(): MarkdownQuery[];
+}
+export declare function mdq(source: string): MarkdownQuery;

package/dist/src/utils/markdown-terminal.d.ts

@@ -0,0 +1 @@
+export declare function parseMarkdownToTerminal(markdown: string): string;

package/dist/src/utils/next-steps.d.ts

@@ -0,0 +1,11 @@
+export interface NextStepCommand {
+    label: string;
+    command: string;
+}
+export interface NextStepSection {
+    label: string;
+    path?: string;
+    commands?: NextStepCommand[];
+}
+export declare function relativeToCwd(absPath: string): string;
+export declare function printNextSteps(sections: NextStepSection[]): void;

package/dist/src/utils/page-readiness.d.ts

@@ -0,0 +1,6 @@
+export declare function waitForPageReadiness(page: any, options?: PageReadinessOptions): Promise<void>;
+interface PageReadinessOptions {
+    timeout?: number;
+    spinnerSelectors?: string[];
+}
+export {};

package/dist/src/utils/research-parser.d.ts

@@ -0,0 +1 @@
+export { RESEARCH_COLUMN_ORDER, type ResearchElement, type ResearchSection, extractContainerFromBlockquote, extractValidContainers, formatResearchSummary, mapRowToElement, parseResearchSections, rebuildSectionMarkdown, } from '../ai/researcher/parser.js';

package/dist/src/utils/retry.d.ts

@@ -0,0 +1,8 @@
+export interface RetryOptions {
+    maxAttempts?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+    retryCondition?: (error: Error) => boolean;
+}
+export declare function withRetry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/src/utils/rules-loader.d.ts

@@ -0,0 +1,12 @@
+export declare class RulesLoader {
+    static loadRules(agentName: string, rulesConfig: RuleEntry[], currentUrl: string): string;
+    static loadStyles(agentName: string, styleNames: string[]): Record<string, string>;
+    static listStyleNames(agentName: string): string[];
+    static getActiveStyle(styles: Record<string, string>, iteration: number, override?: string): {
+        name: string;
+        approach: string;
+    };
+    static extractRules(agentName: string, targetDir: string): string[];
+}
+type RuleEntry = string | Record<string, string>;
+export type { RuleEntry };

package/dist/src/utils/secrets.d.ts

@@ -0,0 +1,4 @@
+export declare function registerSecret(value: string): void;
+export declare function redactSecrets(text: string): string;
+export declare function clearRegisteredSecrets(): void;
+export declare function isSecretName(name: string): boolean;

package/dist/src/utils/secrets.js

@@ -0,0 +1,28 @@
+const MIN_SECRET_LENGTH = 4;
+const secretValues = new Set();
+export function registerSecret(value) {
+    if (!value)
+        return;
+    if (value.length < MIN_SECRET_LENGTH)
+        return;
+    secretValues.add(value);
+}
+export function redactSecrets(text) {
+    if (!text)
+        return text;
+    let result = text;
+    for (const value of secretValues) {
+        if (!result.includes(value))
+            continue;
+        result = result.split(value).join('***REDACTED***');
+    }
+    return result;
+}
+export function clearRegisteredSecrets() {
+    secretValues.clear();
+}
+const SECRET_NAME_TOKENS = ['password', 'passwd', 'secret', 'token', 'apikey', 'api_key', 'credential', 'private_key', 'privatekey', 'access_key'];
+export function isSecretName(name) {
+    const lower = name.toLowerCase();
+    return SECRET_NAME_TOKENS.some((token) => lower.includes(token));
+}

package/dist/src/utils/step-analyzer.d.ts

@@ -0,0 +1,11 @@
+import type { SessionStep } from '../experience-tracker.js';
+import type { StepData } from '../test-plan.js';
+export declare const CODECEPT_TOOLS: readonly ["click", "hover", "pressKey", "form"];
+export type CodeceptToolName = (typeof CODECEPT_TOOLS)[number];
+export declare function isCodeceptToolName(toolName: string): toolName is CodeceptToolName;
+export declare function getCodeceptToolName(commandName: string): CodeceptToolName | null;
+export declare function getCodeceptToolNameFromCode(code: string): CodeceptToolName | null;
+export declare function stripComments(code: string): string;
+export declare function isNonReusableCode(code: string): boolean;
+export declare function toReusableSessionStep(step: StepData): SessionStep | null;
+export declare function mergeUniqueStepsByCode(primary: SessionStep[], secondary: SessionStep[]): SessionStep[];

package/dist/src/utils/strings.d.ts

@@ -0,0 +1,3 @@
+export declare function truncateJson(input: any): string;
+export declare function sanitizeFilename(name: string): string;
+export declare function safeFilename(name: string, ext?: string, maxBytes?: number): string;

package/dist/src/utils/test-files.d.ts

@@ -0,0 +1,3 @@
+export declare function loadTestSuites(testsDir: string): any[];
+export declare function printTestList(suites: any[]): void;
+export declare function dryRunTestFile(filePath: string): Promise<void>;

package/dist/src/utils/test-plan-markdown.d.ts

@@ -0,0 +1,9 @@
+import { Plan } from '../test-plan.js';
+export declare function planToCompactAiContext(plan: Plan): string;
+export declare function parsePlanFromMarkdown(filePath: string): Plan;
+export declare function parsePlansFromMarkdown(filePath: string): Plan[];
+export declare function savePlanToMarkdown(plan: Plan, filePath: string): void;
+export declare function savePlansToMarkdown(plans: Plan[], filePath: string): void;
+export declare function planToAiContext(plan: Plan, options?: {
+    skipSteps?: boolean;
+}): string;

package/dist/src/utils/throttle.d.ts

@@ -0,0 +1,2 @@
+export declare function throttle<T>(fn: () => Promise<T> | T, intervalSeconds?: number): Promise<T | undefined>;
+export declare function __clearThrottleCacheForTests(): void;

package/dist/src/utils/unique-names.d.ts

@@ -0,0 +1,2 @@
+export declare function uniqSessionName(): string;
+export declare function uniqExplorationName(): string;

package/dist/src/utils/url-matcher.d.ts

@@ -0,0 +1,6 @@
+export declare function isDynamicSegment(segment: string): boolean;
+export declare function hasDynamicUrlSegment(url: string): boolean;
+export declare function generalizeSegment(segment: string): string;
+export declare function generalizeUrl(url: string): string;
+export declare function matchesUrl(pattern: string, path: string): boolean;
+export declare function extractStatePath(url: string): string;

package/dist/src/utils/web-element.d.ts

@@ -0,0 +1,44 @@
+import { type RawElementData } from './html.js';
+import { type XPathMatch } from './xpath.js';
+export { extractElementData } from './html.js';
+export declare class WebElement {
+    tag: string;
+    role: string;
+    xpath: string;
+    clickXPath: string;
+    attrs: Record<string, string>;
+    text: string;
+    outerHTML: string;
+    x: number;
+    y: number;
+    constructor(data: {
+        tag: string;
+        role?: string;
+        xpath: string;
+        clickXPath: string;
+        attrs: Record<string, string>;
+        text: string;
+        outerHTML?: string;
+        x: number;
+        y: number;
+    });
+    get description(): string;
+    get keyAttrs(): string;
+    get coordinates(): string;
+    get eidx(): string | null;
+    get isNavigationLink(): boolean;
+    get filteredClasses(): string[];
+    get areaHints(): string[];
+    get contextLabel(): string;
+    get variantHints(): string[];
+    static fromRawData(d: RawElementData, role?: string): WebElement;
+    static fromXPathMatch(m: XPathMatch): WebElement;
+    static fromPlaywrightLocator(locator: any): Promise<WebElement | null>;
+    static fromEidx(page: any, eidx: string): Promise<WebElement | null>;
+    static fromEidxList(page: any, eidxList: string[]): Promise<WebElement[]>;
+    static findByXPath(html: string, xpath: string): Promise<{
+        totalFound: number;
+        elements: WebElement[];
+        error?: string;
+    }>;
+}

package/dist/src/utils/xpath.d.ts

@@ -0,0 +1,17 @@
+export interface XPathMatch {
+    tag: string;
+    outerHTML: string;
+    text: string;
+    absoluteXPath: string;
+    allAttrs: Record<string, string>;
+}
+export interface XPathResult {
+    totalFound: number;
+    matches: XPathMatch[];
+    error?: string;
+}
+export declare const isDynamicId: (id: string) => boolean;
+export declare const isGenericClass: (cls: string) => boolean;
+export declare function buildClickableXPath(el: XPathMatch): string;
+export declare function cssToAncestorXPath(css: string): string | null;
+export declare function evaluateXPath(html: string, xpath: string): Promise<XPathResult>;

package/package.json

@@ -1,39 +1,30 @@
 {
   "name": "explorbot",
-  "version": "0.1.30",
+  "version": "0.1.32-beta.1",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
   "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
   "exports": {
     ".": {
-      "bun": "./src/index.tsx",
+      "types": "./dist/src/index.d.ts",
+      "bun": "./src/index.ts",
       "import": "./dist/src/index.js"
     }
   },
   "bin": {
     "explorbot": "./dist/bin/explorbot-cli.js"
   },
-  "files": [
-    "dist/",
-    "src/**/*.ts",
-    "src/**/*.tsx",
-    "bin/**/*.ts",
-    "boat/api-tester/src/**/*.ts",
-    "boat/doc-collector/src/**/*.ts",
-    "boat/doc-collector/bin/**/*.ts",
-    "boat/doc-collector/package.json",
-    "rules/",
-    "assets/sample-files/"
-  ],
+  "files": ["dist/", "src/**/*.ts", "src/**/*.tsx", "bin/**/*.ts", "boat/api-tester/src/**/*.ts", "boat/doc-collector/src/**/*.ts", "boat/doc-collector/bin/**/*.ts", "boat/doc-collector/package.json", "rules/", "assets/sample-files/"],
   "scripts": {
-    "build": "bun run src/index.tsx build && bun run build:bin",
+    "build": "bun run build:bin",
     "build:bin": "bun build bin/explorbot-cli.ts --outdir bin --target node --external commander --format esm",
     "build:npm": "bash scripts/build-npm.sh",
     "prepublishOnly": "npm run build:npm",
-    "dev": "bun run src/index.tsx",
-    "start": "node dist/index.js",
-    "init": "bun run src/index.tsx init",
+    "dev": "bun run bin/explorbot-cli.ts start",
+    "start": "node dist/bin/explorbot-cli.js",
+    "init": "bun run bin/explorbot-cli.ts init",
     "test": "codeceptjs run",
     "test:headless": "codeceptjs run --headless",
     "test:ui": "bun test tests/ui",
@@ -52,13 +43,7 @@
     "check:fix": "biome check --write .",
     "langfuse:export": "bun run .claude/skills/explorbot-debug/langfuse-export.ts"
   },
-  "keywords": [
-    "cli",
-    "react",
-    "ink",
-    "codeceptjs",
-    "playwright"
-  ],
+  "keywords": ["cli", "react", "ink", "codeceptjs", "playwright"],
   "repository": {
     "type": "git",
     "url": "https://github.com/testomatio/explorbot"
@@ -74,7 +59,7 @@
     "@faker-js/faker": "^10.4.0",
     "@inkjs/ui": "^2.0.0",
     "@langfuse/otel": "^4.5.1",
-    "@openrouter/ai-sdk-provider": "^2.3.3",
+    "@openrouter/ai-sdk-provider": "^3.0.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/auto-instrumentations-node": "^0.67.3",
     "@opentelemetry/instrumentation": "^0.208.0",