explorbot 0.1.9 → 0.1.11

package/dist/src/explorbot.js

@@ -1,9 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { ActionResult } from "./action-result.js";
-import { ApiClient } from "./api/api-client.js";
-import { RequestStore } from "./api/request-store.js";
-import { loadSpec } from "./api/spec-reader.js";
 import { Bosun } from "./ai/bosun.js";
 import { Captain } from "./ai/captain.js";
 import { ExperienceCompactor } from "./ai/experience-compactor.js";
@@ -14,11 +11,15 @@ import { Pilot } from "./ai/pilot.js";
 import { Planner } from "./ai/planner.js";
 import { AIProvider } from "./ai/provider.js";
 import { Quartermaster } from "./ai/quartermaster.js";
-import { Researcher } from "./ai/researcher.js";
 import { Rerunner } from "./ai/rerunner.js";
+import { Researcher } from "./ai/researcher.js";
 import { Tester } from "./ai/tester.js";
 import { createAgentTools } from "./ai/tools.js";
+import { ApiClient } from "./api/api-client.js";
+import { RequestStore } from "./api/request-store.js";
+import { loadSpec } from "./api/spec-reader.js";
 import { ConfigParser } from "./config.js";
+import { ExperienceTracker } from "./experience-tracker.js";
 import Explorer from "./explorer.js";
 import { KnowledgeTracker } from "./knowledge-tracker.js";
 import { Plan } from "./test-plan.js";
@@ -34,6 +35,8 @@ export class ExplorBot {
     needsInput = false;
     currentPlan;
     planFeature;
+    lastPlanError = null;
+    lastSavedPlanPath = null;
     agents = {};
     constructor(options = {}) {
         this.options = options;
@@ -54,13 +57,11 @@ export class ExplorBot {
             return;
         }
         try {
-            this.config = await this.configParser.loadConfig(this.options);
-            this.provider = new AIProvider(this.config.ai);
-            await this.provider.validateConnection();
+            await this.startProviderOnly();
             this.explorer = new Explorer(this.config, this.provider, this.options);
             await this.explorer.start();
             if (!this.options.incognito) {
-                await this.agentExperienceCompactor().compactAllExperiences();
+                await this.agentExperienceCompactor().autocompact();
             }
             if (this.userResolveFn)
                 this.explorer.setUserResolve(this.userResolveFn);
@@ -71,9 +72,16 @@ export class ExplorBot {
             process.exit(1);
         }
     }
+    async startProviderOnly() {
+        if (this.provider)
+            return;
+        this.config = await this.configParser.loadConfig(this.options);
+        this.provider = new AIProvider(this.config.ai);
+        await this.provider.validateConnection();
+    }
     async stop() {
         this.agents.quartermaster?.stop();
-        await this.explorer.stop();
+        await this.explorer?.stop();
     }
     async visitInitialState() {
         const url = this.options.from || '/';
@@ -97,6 +105,12 @@ export class ExplorBot {
         }
         return new KnowledgeTracker();
     }
+    getExperienceTracker() {
+        if (this.explorer) {
+            return this.explorer.getStateManager().getExperienceTracker();
+        }
+        return new ExperienceTracker();
+    }
     getConfig() {
         return this.config;
     }
@@ -186,10 +200,7 @@ export class ExplorBot {
         return this.agents.captain;
     }
     agentExperienceCompactor() {
-        return (this.agents.experienceCompactor ||= this.createAgent(({ ai, explorer }) => {
-            const experienceTracker = explorer.getStateManager().getExperienceTracker();
-            return new ExperienceCompactor(ai, experienceTracker);
-        }));
+        return (this.agents.experienceCompactor ||= new ExperienceCompactor(this.provider, this.getExperienceTracker()));
     }
     agentQuartermaster() {
         const config = this.config.ai?.agents?.quartermaster;
@@ -204,10 +215,10 @@ export class ExplorBot {
         return this.agents.quartermaster;
     }
     agentHistorian() {
-        return (this.agents.historian ||= this.createAgent(({ ai, explorer }) => {
+        return (this.agents.historian ||= this.createAgent(({ ai, explorer, config }) => {
             const experienceTracker = explorer.getStateManager().getExperienceTracker();
             const reporter = explorer.getReporter();
-            return new Historian(ai, experienceTracker, reporter, explorer.getStateManager());
+            return new Historian(ai, experienceTracker, reporter, explorer.getStateManager(), config, explorer.getPlaywrightRecorder());
         }));
     }
     agentRerunner() {
@@ -293,21 +304,18 @@ export class ExplorBot {
         if (this.currentPlan) {
             planner.setPlan(this.currentPlan);
         }
+        this.lastPlanError = null;
         try {
             this.currentPlan = await planner.plan(feature, opts.style, opts.extend, opts.completedPlans);
         }
         catch (err) {
-            tag('warning').log(`Planning failed: ${err instanceof Error ? err.message : err}`);
+            this.lastPlanError = err instanceof Error ? err : new Error(String(err));
+            tag('warning').log(`Planning failed: ${this.lastPlanError.message}`);
             if (!this.currentPlan)
                 return undefined;
             return this.currentPlan;
         }
-        const savedPath = this.savePlan();
-        if (savedPath) {
-            const relativePath = path.relative(process.cwd(), savedPath);
-            tag('info').log(`Plan saved to: ${relativePath}`);
-            tag('info').log(`Edit the plan file and run /plan:load ${relativePath} to reload it`);
-        }
+        this.savePlan();
         return this.currentPlan;
     }
     getPlansDir() {
@@ -329,6 +337,7 @@ export class ExplorBot {
         const planFilename = filename || this.generatePlanFilename();
         const planPath = path.join(plansDir, planFilename);
         Plan.saveMultipleToMarkdown(plans, planPath);
+        this.lastSavedPlanPath = planPath;
         return planPath;
     }
     generatePlanFilename() {

package/dist/src/explorer.js

@@ -8,12 +8,13 @@ import { createTest } from 'codeceptjs/lib/mocha/test';
 import { ActionResult } from "./action-result.js";
 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 { KnowledgeTracker } from './knowledge-tracker.js';
+import { PlaywrightRecorder } from "./playwright-recorder.js";
 import { Reporter } from "./reporter.js";
 import { StateManager } from './state-manager.js';
-import { RequestStore } from "./api/request-store.js";
-import { XhrCapture } from "./api/xhr-capture.js";
 import { createDebug, log, tag } from './utils/logger.js';
 import { WebElement, extractElementData } from "./utils/web-element.js";
 const debugLog = createDebug('explorbot:explorer');
@@ -35,6 +36,7 @@ class Explorer {
     _activeTest = null;
     xhrCapture = null;
     requestStore = null;
+    playwrightRecorder = new PlaywrightRecorder();
     constructor(config, aiProvider, options) {
         this.config = config;
         this.aiProvider = aiProvider;
@@ -42,7 +44,7 @@ class Explorer {
         this.initializeContainer();
         this.stateManager = new StateManager({ incognito: this.options?.incognito });
         this.knowledgeTracker = new KnowledgeTracker();
-        this.reporter = new Reporter(config.reporter);
+        this.reporter = new Reporter(config.reporter, this.stateManager);
     }
     initializeContainer() {
         try {
@@ -89,7 +91,7 @@ class Explorer {
             tag('substep').log(debugInfo);
         }
         const PlaywrightConfig = {
-            timeout: 1000,
+            timeout: 3000,
             highlightElement: true,
             waitForAction: 500,
             ...playwrightConfig,
@@ -188,6 +190,7 @@ class Explorer {
         const hasSession = this.options?.session && existsSync(this.options.session);
         const contextOptions = hasSession ? { storageState: this.options.session } : undefined;
         await this.playwrightHelper._createContextPage(contextOptions);
+        await this.playwrightRecorder.start(this.playwrightHelper.browserContext);
         this.setupXhrCapture();
         if (hasSession) {
             tag('info').log(`Session restored from ${path.relative(process.cwd(), this.options.session)}`);
@@ -216,7 +219,10 @@ class Explorer {
         await this.playwrightHelper._startBrowser();
     }
     createAction() {
-        return new Action(this.actor, this.stateManager);
+        return new Action(this.actor, this.stateManager, this.playwrightRecorder);
+    }
+    getPlaywrightRecorder() {
+        return this.playwrightRecorder;
     }
     async visit(url) {
         await this.closeOtherTabs();
@@ -411,6 +417,7 @@ class Explorer {
         if (this.xhrCapture && this.playwrightHelper?.page) {
             this.xhrCapture.detach(this.playwrightHelper.page);
         }
+        await this.playwrightRecorder.stop();
         if (this.options?.session && this.playwrightHelper?.browserContext) {
             const dir = path.dirname(this.options.session);
             if (!existsSync(dir))

package/dist/src/observability.js

@@ -1,125 +1,76 @@
-import { randomBytes } from 'node:crypto';
-import { context, trace } from '@opentelemetry/api';
+import { trace } from '@opentelemetry/api';
 let current = null;
-let depth = 0;
 export const Observability = {
     async run(name, metadata, fn) {
-        const started = Observability.startTrace(name, metadata);
-        try {
-            if (!started) {
-                const parentSpan = current?.span;
-                if (!parentSpan || !current)
-                    return await fn();
-                const tracer = trace.getTracer('ai');
-                const childSpan = tracer.startSpan(name, undefined, trace.setSpan(context.active(), parentSpan));
-                const savedSpan = current.span;
-                const savedName = current.name;
-                current.span = childSpan;
-                current.name = name;
-                return await context.with(trace.setSpan(context.active(), childSpan), async () => {
-                    try {
-                        return await fn();
-                    }
-                    finally {
-                        childSpan.end();
-                        current.span = savedSpan;
-                        current.name = savedName;
-                    }
-                });
-            }
-            const tracer = trace.getTracer('ai');
-            const spanContext = {
-                traceId: current?.traceId || randomBytes(16).toString('hex'),
-                spanId: randomBytes(8).toString('hex'),
-                traceFlags: 1,
-            };
-            const rootContext = trace.setSpanContext(context.active(), spanContext);
-            const initSpan = tracer.startSpan(name, undefined, rootContext);
-            initSpan.setAttribute('langfuse.trace.name', name);
-            initSpan.setAttribute('langfuse.trace.id', current?.traceId || '');
-            if (current?.metadata?.sessionId) {
-                initSpan.setAttribute('langfuse.trace.session_id', String(current.metadata.sessionId));
-            }
-            if (current?.metadata?.userId) {
-                initSpan.setAttribute('langfuse.trace.user_id', String(current.metadata.userId));
-            }
-            if (current?.metadata?.tags && Array.isArray(current.metadata.tags)) {
-                initSpan.setAttribute('langfuse.trace.tags', current.metadata.tags);
-            }
-            if (current?.metadata?.input) {
-                initSpan.setAttribute('langfuse.trace.input', JSON.stringify(current.metadata.input));
-            }
-            initSpan.end();
-            const span = tracer.startSpan(name, undefined, rootContext);
-            current.span = span;
-            return await context.with(trace.setSpan(rootContext, span), async () => {
+        const tracer = trace.getTracer('ai');
+        if (current) {
+            return await tracer.startActiveSpan(name, {}, async (span) => {
+                const saved = current;
+                current = {
+                    metadata: { ...saved.metadata, ...metadata },
+                    name,
+                    span,
+                };
                 try {
                     return await fn();
                 }
                 finally {
                     span.end();
-                    current.span = undefined;
+                    current = saved;
                 }
             });
         }
-        finally {
-            Observability.endTrace(started);
-        }
-    },
-    startTrace(name, metadata) {
-        if (current) {
-            depth += 1;
-            return false;
-        }
-        const langfuseTraceId = metadata.langfuseTraceId || randomBytes(16).toString('hex');
-        current = {
-            metadata: {
-                ...metadata,
-                langfuseTraceId,
-            },
-            traceId: langfuseTraceId,
-            updateParent: true,
-            name,
-        };
-        depth = 1;
-        return true;
-    },
-    endTrace(started) {
-        if (!current) {
-            return;
-        }
-        if (!started) {
-            depth -= 1;
-            return;
-        }
-        depth -= 1;
-        if (depth <= 0) {
-            current = null;
-            depth = 0;
-        }
+        const attributes = buildRootSpanAttributes(name, metadata);
+        return await tracer.startActiveSpan(name, { attributes }, async (span) => {
+            current = { metadata, name, span };
+            try {
+                return await fn();
+            }
+            finally {
+                span.end();
+                current = null;
+            }
+        });
     },
     getTelemetry() {
         if (!current) {
             return undefined;
         }
-        const telemetry = {
+        const metadata = {};
+        if (current.metadata.sessionId)
+            metadata.sessionId = current.metadata.sessionId;
+        if (current.metadata.userId)
+            metadata.userId = current.metadata.userId;
+        if (Array.isArray(current.metadata.tags))
+            metadata.tags = current.metadata.tags;
+        return {
             isEnabled: true,
             functionId: current.name,
-            metadata: {
-                ...current.metadata,
-                langfuseTraceId: current.traceId,
-                langfuseUpdateParent: current.updateParent,
-            },
+            metadata,
         };
-        if (current.updateParent) {
-            current.updateParent = false;
-        }
-        return telemetry;
     },
     isTracing() {
         return Boolean(current);
     },
     getSpan() {
-        return current?.span;
+        return current?.span ?? trace.getActiveSpan();
     },
 };
+function buildRootSpanAttributes(name, metadata) {
+    const attributes = {
+        'langfuse.trace.name': name,
+    };
+    if (metadata.sessionId) {
+        attributes['session.id'] = String(metadata.sessionId);
+    }
+    if (metadata.userId) {
+        attributes['user.id'] = String(metadata.userId);
+    }
+    if (Array.isArray(metadata.tags)) {
+        attributes['langfuse.trace.tags'] = metadata.tags;
+    }
+    if (metadata.input !== undefined) {
+        attributes['langfuse.trace.input'] = JSON.stringify(metadata.input);
+    }
+    return attributes;
+}