explorbot 0.1.31 → 0.2.0

package/dist/src/ai/driller.d.ts

@@ -0,0 +1,157 @@
+import { ActionResult } from '../action-result.js';
+import type { ExperienceTracker } from '../experience-tracker.js';
+import type Explorer from '../explorer.js';
+import type { KnowledgeTracker } from '../knowledge-tracker.js';
+import { Plan, Test } from '../test-plan.js';
+import { HooksRunner } from '../utils/hooks-runner.js';
+import { WebElement } from '../utils/web-element.js';
+import type { Agent } from './agent.js';
+import type { Navigator } from './navigator.js';
+import type { Provider } from './provider.js';
+import { TaskAgent } from './task-agent.js';
+interface ComponentInfo {
+    id: string;
+    name: string;
+    role: string;
+    locator: string;
+    preferredCode: string;
+    eidx: string;
+    description: string;
+    html: string;
+    text: string;
+    tag: string;
+    classes: string[];
+    attrs: Record<string, string>;
+    context: string;
+    variant: string;
+    placeholder: string;
+    disabled: boolean;
+    ariaMatches: string[];
+}
+interface InteractionResult {
+    componentId: string;
+    component: string;
+    action: string;
+    result: 'success' | 'failed' | 'unknown';
+    description: string;
+    code?: string;
+}
+interface ComponentTest extends Test {
+    component?: ComponentInfo;
+    interactions?: InteractionResult[];
+}
+interface DrillOptions {
+    knowledgePath?: string;
+    maxComponents?: number;
+    interactive?: boolean;
+}
+export declare class Driller extends TaskAgent implements Agent {
+    readonly ACTION_TOOLS: string[];
+    emoji: string;
+    explorer: Explorer;
+    provider: Provider;
+    navigator: Navigator;
+    hooksRunner: HooksRunner;
+    currentPlan?: Plan;
+    allResults: InteractionResult[];
+    verifiedAction: {
+        componentId: string;
+        toolName: string;
+        code?: string;
+        canonicalCode?: string;
+    } | null;
+    pendingNestedContext: string | null;
+    MAX_COMPONENT_ITERATIONS: number;
+    constructor(explorer: Explorer, provider: Provider, navigator: Navigator);
+    getNavigator(): Navigator;
+    getExperienceTracker(): ExperienceTracker;
+    getKnowledgeTracker(): KnowledgeTracker;
+    getProvider(): Provider;
+    getSystemMessage(component?: ComponentInfo): string;
+    drill(opts?: DrillOptions): Promise<Plan>;
+    captureAnnotatedState(): Promise<ActionResult>;
+    collectComponents(state: ActionResult, maxComponents: number): Promise<ComponentInfo[]>;
+    toComponentInfo(element: WebElement, ariaNodes: Array<Record<string, unknown>>): ComponentInfo;
+    drillComponent(test: ComponentTest, originalState: ActionResult, interactive: boolean): Promise<void>;
+    buildComponentPrompt(originalState: ActionResult, component: ComponentInfo): Promise<string>;
+    buildContextUpdate(currentState: ActionResult, component: ComponentInfo): Promise<string>;
+    createDrillFlowTools(originalState: ActionResult, test: ComponentTest, interactive: boolean): {
+        drill_record: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            action: any;
+            result: any;
+            code: any;
+        }, {
+            success: boolean;
+            message: string;
+            recorded?: undefined;
+        } | {
+            success: boolean;
+            recorded: string;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        drill_done: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            summary: any;
+        }, {
+            success: boolean;
+            message: string;
+            summary?: undefined;
+            recorded?: undefined;
+        } | {
+            success: boolean;
+            summary: any;
+            recorded: number;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        drill_skip: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            reason: any;
+        }, {
+            success: boolean;
+            message: string;
+            skipped?: undefined;
+        } | {
+            success: boolean;
+            skipped: string;
+            message?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        drill_restore: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            reason: any;
+        }, {
+            success: boolean;
+            url: string;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        drill_ask: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            question: any;
+        }, {
+            success: boolean;
+            message: string;
+            skipped?: undefined;
+            userSuggestion?: undefined;
+            instruction?: undefined;
+        } | {
+            success: boolean;
+            skipped: boolean;
+            message?: undefined;
+            userSuggestion?: undefined;
+            instruction?: undefined;
+        } | {
+            success: boolean;
+            userSuggestion: string;
+            instruction: string;
+            message?: undefined;
+            skipped?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+    };
+    restoreOriginalState(originalState: ActionResult, reason: string): Promise<void>;
+    saveToExperience(state: ActionResult, results: InteractionResult[]): Promise<void>;
+    createVerifiedActionTools(baseTools: Record<string, any>, component: ComponentInfo): Record<string, any>;
+    hasVerifiedAction(componentId: string): boolean;
+    detectNestedOverlayContext(component: ComponentInfo, result: any): Promise<string | null>;
+    getVisibleOverlayHtml(): Promise<string>;
+    getComponentScopeHtml(component: ComponentInfo, originalState: ActionResult): Promise<string>;
+    saveToKnowledge(knowledgePath: string, state: ActionResult, results: InteractionResult[]): Promise<void>;
+    generateKnowledgeContent(state: ActionResult, interactions: InteractionResult[]): string;
+    logSummary(): void;
+}
+export declare function buildCanonicalClickCode(component: ComponentInfo): string;
+export declare function formatExperienceTitle(interaction: InteractionResult): string;
+export {};

package/dist/src/ai/driller.js

@@ -11,7 +11,7 @@ import { EXPLORBOT_ATTRS, HTML_COMPOSITE_AREA_HINTS, HTML_COMPOSITE_TARGET_ROLES
 import { createDebug, tag } from "../utils/logger.js";
 import { loop, pause } from "../utils/loop.js";
 import { WebElement } from "../utils/web-element.js";
-import { locatorRule } from "./rules.js";
+import { drillLocatorRule } from "./rules.js";
 import { TaskAgent, isInteractive } from "./task-agent.js";
 import { createCodeceptJSTools } from "./tools.js";
 const debugLog = createDebug('explorbot:driller');
@@ -23,7 +23,6 @@ export class Driller extends TaskAgent {
     navigator;
     hooksRunner;
     currentPlan;
-    currentConversation = null;
     allResults = [];
     verifiedAction = null;
     pendingNestedContext = null;
@@ -245,7 +244,6 @@ export class Driller extends TaskAgent {
         this.verifiedAction = null;
         this.pendingNestedContext = null;
         const conversation = this.provider.startConversation(this.getSystemMessage(component), 'driller');
-        this.currentConversation = conversation;
         conversation.addUserText(await this.buildComponentPrompt(originalState, component));
         let finished = false;
         const actionTools = this.createVerifiedActionTools(createCodeceptJSTools(this.explorer, test), component);
@@ -506,10 +504,10 @@ export class Driller extends TaskAgent {
         const targetUrl = originalState.fullUrl || originalState.url;
         const action = this.explorer.createAction();
         if (currentState?.url !== originalState.url) {
-            await action.attempt(`I.amOnPage(${JSON.stringify(targetUrl)})`, `${reason} (restore URL)`, false);
+            await action.attempt(`I.amOnPage(${JSON.stringify(targetUrl)})`, `${reason} (restore URL)`);
             return;
         }
-        await action.attempt('I.pressKey("Escape")', `${reason} (restore state)`, false);
+        await action.attempt('I.pressKey("Escape")', `${reason} (restore state)`);
     }
     async saveToExperience(state, results) {
         const experienceTracker = this.getExperienceTracker();
@@ -667,12 +665,6 @@ export class Driller extends TaskAgent {
             tag('step').log(`  ${status} ${componentTest.component?.name || test.scenario}`);
         }
     }
-    getCurrentPlan() {
-        return this.currentPlan;
-    }
-    getConversation() {
-        return this.currentConversation;
-    }
 }
 function formatAriaNode(node) {
     const role = typeof node.role === 'string' ? node.role : 'unknown';
@@ -1105,4 +1097,3 @@ function isInteractiveElement(element) {
         return true;
     return false;
 }
-const drillLocatorRule = locatorRule.replace(/<context_simplification>[\s\S]*?<\/context_simplification>/, '').trim();

package/dist/src/ai/experience-compactor.d.ts

@@ -0,0 +1,53 @@
+import { type ExperienceFile, type ExperienceTracker } from '../experience-tracker.js';
+import type { Agent } from './agent.js';
+import type { Provider } from './provider.js';
+export declare const COMPACT_MAX_LENGTH = 5000;
+interface MergeGroup {
+    pattern: string;
+    files: ExperienceFile[];
+}
+export declare class ExperienceCompactor implements Agent {
+    emoji: string;
+    provider: Provider;
+    experienceTracker: ExperienceTracker;
+    constructor(provider: Provider, experienceTracker: ExperienceTracker);
+    compactExperience(experience: string): Promise<string>;
+    stripNonUsefulEntries(content: string): string;
+    isRecent(file: ExperienceFile): boolean;
+    reviewExperienceQuality(content: string, context: {
+        url?: string;
+        title?: string;
+    }): Promise<string>;
+    compactAllExperiences(): Promise<{
+        merged: number;
+        compacted: number;
+    }>;
+    autocompact(): Promise<{
+        merged: number;
+        compacted: number;
+    }>;
+    generalizeDynamicUrls(): number;
+    compactFiles(files: ExperienceFile[], options?: {
+        skipSmall?: boolean;
+    }): Promise<number>;
+    mergeSimilarExperiences(options?: {
+        onlyDynamic?: boolean;
+    }): Promise<number>;
+    identifyMergeGroups(files: ExperienceFile[]): Promise<MergeGroup[]>;
+    askAiForMergeDecisions(urls: string[]): Promise<{
+        urls: string[];
+        pattern: string;
+    }[]>;
+    buildMergePrompt(urls: string[]): string;
+    mergeExperienceGroup(group: MergeGroup): Promise<void>;
+    getSystemPrompt(): string;
+    buildCompactionPrompt(content: string): string;
+    buildReviewPrompt(sections: Array<{
+        title: string;
+        raw: string;
+    }>, context: {
+        url?: string;
+        title?: string;
+    }): string;
+}
+export {};

package/dist/src/ai/experience-compactor.js

@@ -1,25 +1,26 @@
 import { unlinkSync } from 'node:fs';
+import { basename } from 'node:path';
 import dedent from 'dedent';
-import { marked } from 'marked';
 import { z } from 'zod';
 import { RECENT_WINDOW_DAYS } from '../experience-tracker.js';
 import { Observability } from '../observability.js';
 import { createDebug, log, tag } from '../utils/logger.js';
 import { mdq } from '../utils/markdown-query.js';
+import { isNonReusableCode } from '../utils/step-analyzer.js';
 import { generalizeUrl, hasDynamicUrlSegment } from '../utils/url-matcher.js';
 const debugLog = createDebug('explorbot:experience-compactor');
+export const COMPACT_MAX_LENGTH = 5000;
 export class ExperienceCompactor {
     emoji = '🗜️';
     provider;
     experienceTracker;
-    MAX_LENGTH = 5000;
     constructor(provider, experienceTracker) {
         this.provider = provider;
         this.experienceTracker = experienceTracker;
     }
     async compactExperience(experience) {
         const stripped = this.stripNonUsefulEntries(experience);
-        if (stripped.length < this.MAX_LENGTH) {
+        if (stripped.length < COMPACT_MAX_LENGTH) {
             return stripped;
         }
         const prompt = this.buildCompactionPrompt(stripped);
@@ -101,7 +102,7 @@ export class ExperienceCompactor {
             const generalized = generalizeUrl(url);
             if (generalized === url)
                 continue;
-            const stateHash = file.filePath.split('/').pop()?.replace('.md', '') || '';
+            const stateHash = basename(file.filePath, '.md');
             const newData = { ...file.data, url: `~${generalized}~`, mergedFrom: [url] };
             this.experienceTracker.writeExperienceFile(stateHash, file.content, newData);
             tag('substep').log(`Generalized URL: ${url} → ~${generalized}~`);
@@ -110,7 +111,7 @@ export class ExperienceCompactor {
         return count;
     }
     async compactFiles(files, options) {
-        const workingSet = options?.skipSmall ? files.filter((f) => f.content.length >= this.MAX_LENGTH) : files;
+        const workingSet = options?.skipSmall ? files.filter((f) => f.content.length >= COMPACT_MAX_LENGTH) : files;
         let compactedCount = 0;
         const total = workingSet.length;
         const aiReviewCount = workingSet.filter((f) => this.isRecent(f)).length;
@@ -119,7 +120,7 @@ export class ExperienceCompactor {
         }
         for (let i = 0; i < workingSet.length; i++) {
             const experience = workingSet[i];
-            const shortName = experience.filePath.split('/').pop() || experience.filePath;
+            const shortName = basename(experience.filePath);
             const willReview = this.isRecent(experience);
             if (total > 1 && willReview) {
                 tag('substep').log(`[${i + 1}/${total}] reviewing ${shortName}`);
@@ -128,9 +129,9 @@ export class ExperienceCompactor {
             if (willReview) {
                 content = await this.reviewExperienceQuality(content, experience.data);
             }
-            if (content.length >= this.MAX_LENGTH) {
+            if (content.length >= COMPACT_MAX_LENGTH) {
                 if (total > 1)
-                    tag('substep').log(`[${i + 1}/${total}] compacting ${shortName} (over ${this.MAX_LENGTH} chars)`);
+                    tag('substep').log(`[${i + 1}/${total}] compacting ${shortName} (over ${COMPACT_MAX_LENGTH} chars)`);
                 const prompt = this.buildCompactionPrompt(content);
                 const model = this.provider.getModelForAgent('experience-compactor');
                 const response = await this.provider.chat([
@@ -141,7 +142,7 @@ export class ExperienceCompactor {
             }
             if (content === experience.content)
                 continue;
-            const stateHash = experience.filePath.split('/').pop()?.replace('.md', '') || '';
+            const stateHash = basename(experience.filePath, '.md');
             this.experienceTracker.writeExperienceFile(stateHash, content, experience.data);
             debugLog('Experience file compacted:', experience.filePath);
             compactedCount++;
@@ -250,7 +251,7 @@ export class ExperienceCompactor {
     async mergeExperienceGroup(group) {
         const [targetFile, ...sourceFiles] = group.files;
         const combinedContent = group.files.map((f) => f.content).join('\n\n---\n\n');
-        const targetStateHash = targetFile.filePath.split('/').pop()?.replace('.md', '') || '';
+        const targetStateHash = basename(targetFile.filePath, '.md');
         const newFrontmatter = {
             ...targetFile.data,
             url: group.pattern,
@@ -283,7 +284,7 @@ export class ExperienceCompactor {
       <rules>
       - Use markdown h2 headers only (##) - NO XML tags or wrappers in output
       - Merge similar flows to remove duplicates
-      - Keep output under ${this.MAX_LENGTH} characters
+      - Keep output under ${COMPACT_MAX_LENGTH} characters
       - Be explicit and short - no proposals or explanations
 
       KEEP only:
@@ -368,27 +369,9 @@ export class ExperienceCompactor {
     }
 }
 function listSections(content) {
-    const tokens = marked.lexer(content);
-    const sections = [];
-    let currentHeading = null;
-    let currentRaw = '';
-    const flush = () => {
-        if (currentHeading !== null)
-            sections.push({ title: currentHeading, raw: currentRaw });
-    };
-    for (const token of tokens) {
-        const raw = token.raw || '';
-        if (token.type === 'heading' && token.depth === 2) {
-            flush();
-            currentHeading = token.text.trim();
-            currentRaw = raw;
-            continue;
-        }
-        if (currentHeading !== null)
-            currentRaw += raw;
-    }
-    flush();
-    return sections;
+    const sections = mdq(content).query('section2').each();
+    const metas = mdq(content).query('section2').meta();
+    return sections.map((q, i) => ({ title: metas[i].text.trim(), raw: q.text() }));
 }
 function dropEmptySections(content) {
     let result = content;
@@ -408,7 +391,7 @@ function dropNonReusableSections(content) {
     const sections = [...mdq(result).query('section2(~"FLOW:")').each(), ...mdq(result).query('section2(~"ACTION:")').each()];
     for (const section of sections) {
         const raw = section.text();
-        if (!/\bI\.clickXY\s*\(/.test(raw))
+        if (!isNonReusableCode(raw))
             continue;
         result = result.replace(raw, '');
     }

package/dist/src/ai/fisherman-tools.d.ts

@@ -0,0 +1,90 @@
+import type { ApiClient } from '../api/api-client.js';
+import type { RequestStore } from '../api/request-store.js';
+export declare function createFishermanTools(apiClient: ApiClient, requestStore: RequestStore, opts: {
+    spec?: any;
+    baseEndpoint?: string;
+}): {
+    tools: {
+        getEndpointSpec: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            method: any;
+            path: any;
+        }, {
+            source: string;
+            method: string;
+            path: string;
+            status: number;
+            requestBody: any;
+            definition?: undefined;
+            error?: undefined;
+        } | {
+            source: string;
+            definition: string;
+            method?: undefined;
+            path?: undefined;
+            status?: undefined;
+            requestBody?: undefined;
+            error?: undefined;
+        } | {
+            source: string;
+            error: any;
+            method?: undefined;
+            path?: undefined;
+            status?: undefined;
+            requestBody?: undefined;
+            definition?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        request: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<any, {
+            success: boolean;
+            error: string;
+            status?: undefined;
+            statusText?: undefined;
+            errorPreview?: undefined;
+        } | {
+            success: boolean;
+            status: number;
+            statusText: string;
+            errorPreview: string;
+            error?: undefined;
+        } | {
+            success: boolean;
+            status: number;
+            error?: undefined;
+            statusText?: undefined;
+            errorPreview?: undefined;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        finish: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            summary: string;
+            created: {
+                type: string;
+                id?: string | number;
+                title?: string;
+            }[];
+            failed?: {
+                type: string;
+                reason: string;
+            }[];
+        }, {
+            finished: boolean;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        stop: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            reason: any;
+        }, {
+            stopped: boolean;
+        }, import("@ai-sdk/provider-utils").Context>>;
+    };
+    getResult: () => FishermanResult;
+    isFinished: () => boolean;
+};
+export interface FishermanResult {
+    success: boolean;
+    summary: string;
+    created: Array<{
+        type: string;
+        id?: string | number;
+        title?: string;
+    }>;
+    failed: Array<{
+        type: string;
+        reason: string;
+    }>;
+}

package/dist/src/ai/fisherman-tools.js

@@ -136,7 +136,7 @@ function extractKeyFields(body, result = {}, depth = 0) {
         return result;
     }
     for (const [key, value] of Object.entries(body)) {
-        if (value === null || value === undefined)
+        if (value == null)
             continue;
         if (typeof value === 'object') {
             extractKeyFields(value, result, depth + 1);

package/dist/src/ai/fisherman.d.ts

@@ -0,0 +1,29 @@
+import type { ApiClient } from '../api/api-client.js';
+import type { RequestStore } from '../api/request-store.js';
+import type { Agent } from './agent.js';
+import { type FishermanResult } from './fisherman-tools.js';
+import type { Provider } from './provider.js';
+export declare class Fisherman implements Agent {
+    emoji: string;
+    provider: Provider;
+    apiClient: ApiClient;
+    requestStore: RequestStore;
+    specLoader: () => Promise<any | null>;
+    cookieProvider: () => Promise<Record<string, string>>;
+    configHeaders: Record<string, string>;
+    sessionName?: string;
+    baseEndpoint: string;
+    spec: any | null;
+    mode: 'replicate' | 'achieve' | 'disabled';
+    hasApiConfig: boolean;
+    constructor(provider: Provider, apiClient: ApiClient, requestStore: RequestStore, specLoader: () => Promise<any | null>, baseEndpoint: string, cookieProvider: () => Promise<Record<string, string>>, configHeaders?: Record<string, string>, hasApiConfig?: boolean);
+    isAvailable(): boolean;
+    ensureReady(scopeUrl?: string): Promise<void>;
+    getEndpointList(scopeUrl?: string): string;
+    prepareData(instructions: string, scopeUrl?: string, sessionName?: string): Promise<FishermanResult>;
+    detectMode(scopeUrl?: string): Promise<void>;
+    refreshAuth(): Promise<void>;
+    buildEndpointList(scopeUrl?: string): string;
+    buildSystemPrompt(endpointList: string, toolNames: string[], scopeUrl?: string): string;
+    buildTaskPrompt(instructions: string): string;
+}

package/dist/src/ai/fisherman.js

@@ -34,9 +34,6 @@ export class Fisherman {
     isAvailable() {
         return this.mode !== 'disabled';
     }
-    getMode() {
-        return this.mode;
-    }
     async ensureReady(scopeUrl) {
         await this.detectMode(scopeUrl);
         this.spec ??= await this.specLoader();

package/dist/src/ai/historian/codeceptjs.d.ts

@@ -0,0 +1,17 @@
+import type { StateManager } from '../../state-manager.js';
+import type { Plan } from '../../test-plan.js';
+import type { Conversation } from '../conversation.js';
+import type { Constructor } from './mixin.js';
+export interface CodeceptJSMethods {
+    toCode(conversation: Conversation, scenario: string): string;
+    saveCodeceptPlanToFile(plan: Plan): string;
+}
+export declare function WithCodeceptJS<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        savedFiles: Set<string>;
+        stateManager?: StateManager;
+        toCode(conversation: Conversation, scenario: string): string;
+        saveCodeceptPlanToFile(plan: Plan): string;
+        getKnowledgeLines(url: string, indent?: string): string[];
+    };
+} & T;

package/dist/src/ai/historian/codeceptjs.js

@@ -2,7 +2,6 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ActionResult } from "../../action-result.js";
 import { ConfigParser } from "../../config.js";
-import { KnowledgeTracker } from "../../knowledge-tracker.js";
 import { tag } from "../../utils/logger.js";
 import { relativeToCwd } from "../../utils/next-steps.js";
 import { safeFilename } from "../../utils/strings.js";
@@ -87,7 +86,9 @@ export function WithCodeceptJS(Base) {
             return filePath;
         }
         getKnowledgeLines(url, indent = '  ') {
-            const knowledgeTracker = new KnowledgeTracker();
+            const knowledgeTracker = this.stateManager?.getKnowledgeTracker();
+            if (!knowledgeTracker)
+                return [];
             const state = new ActionResult({ url });
             const { wait, waitForElement, code } = knowledgeTracker.getStateParameters(state, ['wait', 'waitForElement', 'code']);
             const lines = [];

package/dist/src/ai/historian/experience.d.ts

@@ -0,0 +1,40 @@
+import { ActionResult } from '../../action-result.js';
+import { ExperienceTracker, type SessionStep } from '../../experience-tracker.js';
+import type { Reporter } from '../../reporter.js';
+import type { StateManager } from '../../state-manager.js';
+import { type Task, Test } from '../../test-plan.js';
+import type { Conversation, ToolExecution } from '../conversation.js';
+import type { Provider } from '../provider.js';
+import { type Constructor } from './mixin.js';
+export interface ExperienceMethods {
+    saveSession(task: Task, initialState: ActionResult, conversation: Conversation): Promise<void>;
+}
+export declare function WithExperience<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        provider: Provider;
+        experienceTracker: ExperienceTracker;
+        reporter: Reporter | undefined;
+        stateManager: StateManager | undefined;
+        isPlaywrightFramework: () => boolean;
+        toCode: (conversation: Conversation, scenario: string) => string;
+        toPlaywrightCode: (conversation: Conversation, scenario: string) => Promise<string>;
+        stopScreencast: () => Promise<void>;
+        saveSession(task: Task, initialState: ActionResult, conversation: Conversation): Promise<void>;
+        reportSession(test: Test, steps: SessionStep[]): Promise<void>;
+        extractSteps(toolExecutions: ToolExecution[]): Promise<SessionStep[]>;
+        hasRelevantFlowExperience(state: ActionResult): boolean;
+        extractPassedCodeceptSteps(task: Task): SessionStep[];
+        curateFlow(steps: SessionStep[], task: Task, initialState: ActionResult): Promise<string>;
+        renderFlowFromSuccessfulSteps(steps: SessionStep[], task: Task): string;
+        detectRetryPatterns(toolExecutions: ToolExecution[], initialState: ActionResult): Promise<void>;
+        analyzeDiscoveries(stepsWithDiffs: Array<{
+            step: SessionStep;
+            ariaDiff: string | null;
+        }>): Promise<void>;
+        buildDiscoveryPrompt(stepsWithDiffs: Array<{
+            step: SessionStep;
+            ariaDiff: string | null;
+        }>): string;
+        extractVisitedUrls(toolExecutions: ToolExecution[], initialUrl: string): string[];
+    };
+} & T;

package/dist/src/ai/historian/mixin.d.ts

@@ -0,0 +1,2 @@
+export type Constructor<T = object> = new (...args: any[]) => T;
+export declare const debugLog: (...args: any[]) => void;

package/dist/src/ai/historian/playwright.d.ts

@@ -0,0 +1,22 @@
+import type { StateManager } from '../../state-manager.js';
+import { type PlaywrightRecorder } from '../../playwright-recorder.js';
+import type { Plan } from '../../test-plan.js';
+import type { Conversation } from '../conversation.js';
+import type { Constructor } from './mixin.js';
+export interface PlaywrightMethods {
+    toPlaywrightCode(conversation: Conversation, scenario: string): Promise<string>;
+    savePlaywrightPlanToFile(plan: Plan): string;
+}
+export declare function WithPlaywright<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        playwright: {
+            recorder: PlaywrightRecorder;
+            helper: any;
+        } | undefined;
+        savedFiles: Set<string>;
+        stateManager?: StateManager;
+        toPlaywrightCode(conversation: Conversation, scenario: string): Promise<string>;
+        savePlaywrightPlanToFile(plan: Plan): string;
+        getPlaywrightKnowledgeLines(url: string, indent?: string): string[];
+    };
+} & T;

package/dist/src/ai/historian/playwright.js

@@ -2,7 +2,6 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ActionResult } from "../../action-result.js";
 import { ConfigParser } from "../../config.js";
-import { KnowledgeTracker } from "../../knowledge-tracker.js";
 import { renderAssertion, renderCall } from "../../playwright-recorder.js";
 import { tag } from "../../utils/logger.js";
 import { relativeToCwd } from "../../utils/next-steps.js";
@@ -124,7 +123,9 @@ export function WithPlaywright(Base) {
             return filePath;
         }
         getPlaywrightKnowledgeLines(url, indent = '    ') {
-            const knowledgeTracker = new KnowledgeTracker();
+            const knowledgeTracker = this.stateManager?.getKnowledgeTracker();
+            if (!knowledgeTracker)
+                return [];
             const state = new ActionResult({ url });
             const { wait, waitForElement } = knowledgeTracker.getStateParameters(state, ['wait', 'waitForElement']);
             const lines = [];