explorbot 0.1.32-beta.1 → 0.2.1

package/src/explorbot.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
-import { ActionResult } from './action-result.ts';
+import type { AgentDeps } from './ai/agent.ts';
 import { Captain } from './ai/captain.ts';
 import { Driller } from './ai/driller.ts';
 import { ExperienceCompactor } from './ai/experience-compactor.ts';
@@ -24,10 +24,13 @@ import { ConfigParser } from './config.ts';
 import { ExperienceTracker } from './experience-tracker.ts';
 import Explorer from './explorer.ts';
 import { KnowledgeTracker } from './knowledge-tracker.ts';
-import { WebPageState } from './state-manager.ts';
+import { PlaywrightRecorder } from './playwright-recorder.ts';
+import { Reporter } from './reporter.ts';
+import { StateManager, WebPageState } from './state-manager.ts';
 import { Stats } from './stats.ts';
 import type { Suite } from './suite.ts';
 import { Plan, type Test } from './test-plan.ts';
+import { browserErrorMessage } from './utils/browser-errors.ts';
 import { setVerboseMode, tag } from './utils/logger.ts';
 import { relativeToCwd } from './utils/next-steps.ts';
 import { sanitizeFilename } from './utils/strings.ts';
@@ -42,7 +45,7 @@ export interface ExplorBotOptions {
   show?: boolean;
   headless?: boolean;
   incognito?: boolean;
-  session?: string;
+  session?: string | boolean;
 }
 
 export type UserResolveFunction = (error?: Error, showWelcome?: boolean) => Promise<string | null>;
@@ -54,7 +57,6 @@ export class ExplorBot {
   private config!: ExplorbotConfig;
   private options: ExplorBotOptions;
   private userResolveFn: UserResolveFunction | null = null;
-  public needsInput = false;
   private currentPlan?: Plan;
   private planFeature?: string;
   lastPlanError: Error | null = null;
@@ -62,6 +64,12 @@ export class ExplorBot {
   private agents: Record<string, any> = {};
   private sessionPlans: Plan[] = [];
   private lastReportedTestCount = 0;
+  private _experienceTracker?: ExperienceTracker;
+  private _knowledgeTracker?: KnowledgeTracker;
+  private _stateManager?: StateManager;
+  private _reporter?: Reporter;
+  private _requestStore?: RequestStore;
+  private _playwrightRecorder?: PlaywrightRecorder;
 
   constructor(options: ExplorBotOptions = {}) {
     this.options = options;
@@ -73,7 +81,7 @@ export class ExplorBot {
   }
 
   get isExploring(): boolean {
-    return this.explorer?.isStarted;
+    return !!this.explorer;
   }
 
   setUserResolve(fn: UserResolveFunction): void {
@@ -81,20 +89,26 @@ export class ExplorBot {
   }
 
   async start(): Promise<void> {
-    if (this.explorer?.isStarted) {
+    if (this.explorer) {
       return;
     }
 
     try {
       await this.startProviderOnly();
-      this.explorer = new Explorer(this.config, this.provider, this.options);
+      const explorerOptions = { ...this.options, session: typeof this.options.session === 'string' ? this.options.session : undefined };
+      this.explorer = new Explorer(this.config, explorerOptions, {
+        stateManager: this.stateManager(),
+        knowledgeTracker: this.knowledgeTracker(),
+        reporter: this.reporter(),
+        requestStore: this.requestStore(),
+        playwrightRecorder: this.playwrightRecorder(),
+      });
       await this.explorer.start();
       if (!this.options.incognito) {
         await this.agentExperienceCompactor().autocompact();
       }
-      if (this.userResolveFn) this.explorer.setUserResolve(this.userResolveFn);
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
+      const message = browserErrorMessage(error);
       console.error('\nFailed to start:', message);
       process.exit(1);
     }
@@ -103,6 +117,7 @@ export class ExplorBot {
   async startProviderOnly(): Promise<void> {
     if (this.provider) return;
     this.config = await this.configParser.loadConfig(this.options);
+    if (this.options.session === true) this.options.session = path.join(this.configParser.getOutputDir(), 'session.json');
     this.provider = new AIProvider(this.config.ai);
     await this.provider.validateConnection();
   }
@@ -121,30 +136,40 @@ export class ExplorBot {
     return this.agentNavigator().visit(url);
   }
 
-  async openFreshTab(): Promise<void> {
-    await this.explorer.openFreshTab();
+  async openTab(): Promise<void> {
+    await this.explorer.openTab();
   }
 
   getCurrentState(): WebPageState | null {
-    return this.explorer?.getStateManager().getCurrentState() ?? null;
+    return this._stateManager?.getCurrentState() ?? null;
   }
 
   getExplorer(): Explorer {
     return this.explorer;
   }
 
-  getKnowledgeTracker(): KnowledgeTracker {
-    if (this.explorer) {
-      return this.explorer.getKnowledgeTracker();
-    }
-    return new KnowledgeTracker();
+  knowledgeTracker(): KnowledgeTracker {
+    return (this._knowledgeTracker ||= new KnowledgeTracker());
   }
 
-  getExperienceTracker(): ExperienceTracker {
-    if (this.explorer) {
-      return this.explorer.getStateManager().getExperienceTracker();
-    }
-    return new ExperienceTracker();
+  experienceTracker(): ExperienceTracker {
+    return (this._experienceTracker ||= new ExperienceTracker(this.knowledgeTracker()));
+  }
+
+  stateManager(): StateManager {
+    return (this._stateManager ||= new StateManager(this.experienceTracker(), this.knowledgeTracker()));
+  }
+
+  reporter(): Reporter {
+    return (this._reporter ||= new Reporter(this.config.reporter, this.stateManager()));
+  }
+
+  requestStore(): RequestStore {
+    return (this._requestStore ||= new RequestStore(this.configParser.getOutputDir()));
+  }
+
+  playwrightRecorder(): PlaywrightRecorder {
+    return (this._playwrightRecorder ||= new PlaywrightRecorder());
   }
 
   getConfig(): ExplorbotConfig {
@@ -154,47 +179,39 @@ export class ExplorBot {
   getOptions(): ExplorBotOptions {
     return this.options;
   }
-  isReady(): boolean {
-    return this.explorer?.isStarted;
-  }
-
-  getConfigParser(): ConfigParser {
-    return this.configParser;
-  }
 
   getProvider(): AIProvider {
     return this.provider;
   }
 
-  createAgent<T>(factory: (deps: { explorer: Explorer; ai: AIProvider; config: ExplorbotConfig }) => T): T {
+  createAgent<T>(factory: (deps: AgentDeps) => T): T {
     const agent = factory({
       explorer: this.explorer,
       ai: this.provider,
       config: this.config,
+      stateManager: this.stateManager(),
+      knowledgeTracker: this.knowledgeTracker(),
+      requestStore: this.requestStore(),
+      playwrightRecorder: this.playwrightRecorder(),
     });
 
-    const agentEmoji = (agent as any).emoji || '';
     const agentName = (agent as any).constructor.name.toLowerCase();
     tag('debug').log(`Created ${agentName} agent`);
 
-    // Agent is stored by the calling method using a string key
-
     return agent;
   }
 
   agentResearcher(): Researcher {
-    return (this.agents.researcher ||= this.createAgent(({ ai, explorer }) => new Researcher(explorer, ai)));
+    return (this.agents.researcher ||= this.createAgent((deps) => new Researcher(deps)));
   }
 
   agentNavigator(): Navigator {
-    return (this.agents.navigator ||= this.createAgent(({ ai, explorer }) => {
-      return new Navigator(explorer, ai, this.agentExperienceCompactor(), explorer.getStateManager().getExperienceTracker());
-    }));
+    return (this.agents.navigator ||= this.createAgent((deps) => new Navigator(deps)));
   }
 
   agentPlanner(): Planner {
     if (!this.agents.planner) {
-      this.agents.planner = this.createAgent(({ ai, explorer }) => new Planner(explorer, ai));
+      this.agents.planner = this.createAgent((deps) => new Planner(deps, this.agentResearcher()));
       const fisherman = this.agentFisherman();
       if (fisherman) this.agents.planner.setFisherman(fisherman);
     }
@@ -202,38 +219,26 @@ export class ExplorBot {
   }
 
   agentPilot(): Pilot {
-    return (this.agents.pilot ||= this.createAgent(({ ai, explorer }) => {
+    return (this.agents.pilot ||= this.createAgent((deps) => {
       const researcher = this.agentResearcher();
       const navigator = this.agentNavigator();
-      const stateManager = explorer.getStateManager();
-      const experienceTracker = stateManager.getExperienceTracker();
-      const getState = () => {
-        const state = stateManager.getCurrentState();
-        return state ? ActionResult.fromState(state) : null;
-      };
-      const tools = createAgentTools({ explorer, researcher, navigator, experienceTracker, getState, supervisor: true });
-      return new Pilot(ai, tools, researcher, explorer, experienceTracker);
+      const tools = createAgentTools({ ...deps, researcher, navigator, supervisor: true });
+      return new Pilot(deps, tools, researcher);
     }));
   }
 
   agentTester(): Tester {
     if (!this.agents.tester) {
-      this.agents.tester = this.createAgent(({ ai, explorer }) => {
+      this.agents.tester = this.createAgent((deps) => {
         const researcher = this.agentResearcher();
         const navigator = this.agentNavigator();
-        const stateManager = explorer.getStateManager();
-        const experienceTracker = stateManager.getExperienceTracker();
-        const getState = () => {
-          const state = stateManager.getCurrentState();
-          return state ? ActionResult.fromState(state) : null;
-        };
-        const tools = createAgentTools({ explorer, researcher, navigator, experienceTracker, getState });
-        return new Tester(explorer, ai, researcher, navigator, tools);
+        const tools = createAgentTools({ ...deps, researcher, navigator });
+        return new Tester(deps, researcher, navigator, tools);
       });
 
       const qm = this.agentQuartermaster();
       if (qm) this.agents.tester.setQuartermaster(qm);
-      this.agents.tester.setHistorian(this.agentHistorian());
+      if (this.isHistorianEnabled()) this.agents.tester.setHistorian(this.agentHistorian());
       this.agents.tester.setPilot(this.agentPilot());
       this.agents.tester.setCaptain(this.agentCaptain());
 
@@ -246,16 +251,12 @@ export class ExplorBot {
   agentCaptain(): Captain {
     if (!this.agents.captain) {
       this.agents.captain = new Captain(this);
-
-      const qm = this.agentQuartermaster();
-      if (qm) this.agents.captain.setQuartermaster(qm);
-      this.agents.captain.setHistorian(this.agentHistorian());
     }
     return this.agents.captain;
   }
 
   agentExperienceCompactor(): ExperienceCompactor {
-    return (this.agents.experienceCompactor ||= new ExperienceCompactor(this.provider, this.getExperienceTracker()));
+    return (this.agents.experienceCompactor ||= new ExperienceCompactor(this.provider, this.experienceTracker()));
   }
 
   agentQuartermaster(): Quartermaster | null {
@@ -266,41 +267,37 @@ export class ExplorBot {
       this.agents.quartermaster = new Quartermaster(this.provider, {
         model: config?.model,
       });
-      this.agents.quartermaster.start(this.explorer.playwrightHelper, this.explorer.getStateManager());
+      this.agents.quartermaster.start(this.explorer, this.stateManager());
     }
     return this.agents.quartermaster;
   }
 
   agentHistorian(): Historian {
-    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(), config, {
-        recorder: explorer.getPlaywrightRecorder(),
-        helper: explorer.playwrightHelper,
+    return (this.agents.historian ||= this.createAgent(({ ai, explorer, config, stateManager, playwrightRecorder }) => {
+      return new Historian(ai, this.experienceTracker(), this.reporter(), stateManager, config, {
+        recorder: playwrightRecorder,
+        explorer,
       });
     }));
   }
 
   agentRerunner(): Rerunner {
     if (!this.agents.rerunner) {
-      this.agents.rerunner = this.createAgent(({ ai, explorer }) => {
+      this.agents.rerunner = this.createAgent((deps) => {
         const researcher = this.agentResearcher();
         const navigator = this.agentNavigator();
-        const tools = createAgentTools({ explorer, researcher, navigator });
-        return new Rerunner(explorer, ai, tools);
+        const tools = createAgentTools({ ...deps, researcher, navigator, withExperience: false });
+        return new Rerunner(deps, tools);
       });
-      const qm = this.agentQuartermaster();
-      if (qm) this.agents.rerunner.setQuartermaster(qm);
-      this.agents.rerunner.setHistorian(this.agentHistorian());
+      if (this.isHistorianEnabled()) this.agents.rerunner.setHistorian(this.agentHistorian());
     }
     return this.agents.rerunner;
   }
 
   agentDriller(): Driller {
-    return (this.agents.driller ||= this.createAgent(({ ai, explorer }) => {
+    return (this.agents.driller ||= this.createAgent((deps) => {
       const navigator = this.agentNavigator();
-      return new Driller(explorer, ai, navigator);
+      return new Driller(deps, navigator);
     }));
   }
 
@@ -317,7 +314,7 @@ export class ExplorBot {
     if (!this.agents.fisherman) {
       const apiConfig = this.config.api;
       const outputDir = this.configParser.getOutputDir();
-      const requestStore = this.explorer.getRequestStore() || new RequestStore(outputDir);
+      const requestStore = this.requestStore();
       const baseEndpoint = apiConfig?.baseEndpoint || this.config.playwright.url;
       const configHeaders = apiConfig?.headers || {};
       const apiClient = new ApiClient(baseEndpoint);
@@ -332,7 +329,11 @@ export class ExplorBot {
         }
       };
 
-      const cookieProvider = () => this.explorer.extractCookies();
+      const cookieProvider = async (): Promise<Record<string, string>> => {
+        const cookies = await this.explorer.withPage((page) => page.context().cookies()).catch(() => []);
+        if (!cookies.length) return {};
+        return { Cookie: cookies.map((c: any) => `${c.name}=${c.value}`).join('; ') };
+      };
 
       this.agents.fisherman = this.createAgent(({ ai }) => {
         return new Fisherman(ai, apiClient, requestStore, specLoader, baseEndpoint, cookieProvider, configHeaders, hasApiConfig);
@@ -366,7 +367,7 @@ export class ExplorBot {
     }
 
     if (!opts.extend && this.currentPlan?.url) {
-      const currentUrl = this.explorer?.getStateManager().getCurrentState()?.url;
+      const currentUrl = this._stateManager?.getCurrentState()?.url;
       if (currentUrl && currentUrl !== this.currentPlan.url) {
         tag('info').log('Different page detected, clearing previous plan');
         this.clearPlan();
@@ -419,7 +420,7 @@ export class ExplorBot {
   }
 
   generatePlanFilename(feature?: string): string {
-    const state = this.explorer?.getStateManager().getCurrentState();
+    const state = this._stateManager?.getCurrentState();
     const urlPath = state?.url || '/';
     const urlPart = sanitizeFilename(urlPath) || 'root';
     const suffix = '.md';
@@ -499,7 +500,7 @@ export class ExplorBot {
       const filePath = this.agentSessionAnalyst().writeReport(markdown);
       tag('info').log(`Session report saved: ${relativeToCwd(filePath)}`);
 
-      const reporter = this.explorer?.getReporter();
+      const reporter = this._reporter;
       if (reporter?.isEnabled()) {
         let description = markdown;
         const modelsTable = Stats.modelsTable(this.provider.getConfiguredModels());
@@ -509,8 +510,12 @@ export class ExplorBot {
 
       this.lastReportedTestCount = tests.length;
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
+      const message = browserErrorMessage(error);
       tag('warning').log(`Session analysis failed: ${message}`);
     }
   }
+
+  private isHistorianEnabled(): boolean {
+    return this.config.ai?.agents?.historian?.enabled !== false;
+  }
 }