explorbot 0.1.13 → 0.1.16

package/src/commands/explore-command.ts

@@ -1,6 +1,7 @@
 import figureSet from 'figures';
 import { getStyles } from '../ai/planner/styles.js';
 import { outputPath } from '../config.js';
+import { normalizeUrl } from '../state-manager.js';
 import { Stats } from '../stats.js';
 import type { Plan } from '../test-plan.js';
 import { getCliName } from '../utils/cli-name.ts';
@@ -11,6 +12,8 @@ import { type NextStepSection, printNextSteps, relativeToCwd } from '../utils/ne
 import { safeFilename } from '../utils/strings.ts';
 import { BaseCommand, type Suggestion } from './base-command.js';
 
+const MAX_SUB_PAGE_ATTEMPTS = 30;
+
 export class ExploreCommand extends BaseCommand {
   name = 'explore';
   description = 'Start web exploration';
@@ -27,6 +30,7 @@ export class ExploreCommand extends BaseCommand {
   maxTests?: number;
   private testsRun = 0;
   private completedPlans: Plan[] = [];
+  private failedSubPages = new Set<string>();
 
   async execute(args: string): Promise<void> {
     const { opts, args: remaining } = this.parseArgs(args);
@@ -46,10 +50,12 @@ export class ExploreCommand extends BaseCommand {
 
     if (!feature && !this.isLimitReached()) {
       const planner = this.explorBot.agentPlanner();
-      while (true) {
+      let attempts = 0;
+      while (attempts < MAX_SUB_PAGE_ATTEMPTS) {
+        attempts++;
         if (this.isLimitReached()) break;
 
-        const candidates = planner.collectSubPageCandidates(mainPlan, mainUrl || '/');
+        const candidates = planner.collectSubPageCandidates(mainPlan, mainUrl || '/').filter((c) => !this.failedSubPages.has(normalizeUrl(c.url)));
         if (candidates.length === 0) break;
 
         const pick = await planner.pickNextSubPage(candidates);
@@ -64,6 +70,7 @@ export class ExploreCommand extends BaseCommand {
             this.completedPlans.push(subPlan);
           }
         } catch (err) {
+          this.failedSubPages.add(normalizeUrl(pick.url));
           tag('warning').log(`Sub-page exploration failed: ${err instanceof Error ? err.message : err}`);
         }
       }

package/src/components/StatusPane.tsx

@@ -52,9 +52,12 @@ export const StatusPane: React.FC<{ onComplete?: () => void }> = ({ onComplete }
             <Text bold>Usage</Text>
           </Box>
           <Row label="Time" value={Stats.getElapsedTime()} />
-          {tokenRows.map(([model, tokens]) => (
-            <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 <Row key={model} label={model} value={`${Stats.humanizeTokens(tokens.total)} tokens${suffix}`} />;
+          })}
         </>
       )}
     </Box>

package/src/experience-tracker.ts

@@ -3,6 +3,7 @@ import { basename, dirname, join } from 'node:path';
 import matter from 'gray-matter';
 import { type Tokens, marked } from 'marked';
 import type { ActionResult } from './action-result.js';
+import { isNonReusableCode } from './ai/historian/utils.ts';
 import { ConfigParser } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
 import type { WebPageState } from './state-manager.js';
@@ -166,6 +167,10 @@ export class ExperienceTracker {
   writeAction(state: ActionResult, action: ActionInput): void {
     if (this.disabled || this.isWritingDisabled(state)) 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();
@@ -189,6 +194,10 @@ export class ExperienceTracker {
   writeFlow(state: ActionResult, body: string, relatedUrls?: string[]): void {
     if (this.disabled || this.isWritingDisabled(state)) return;
     if (!body?.trim()) return;
+    if (isNonReusableCode(body)) {
+      debugLog('Skipping flow body with non-reusable code');
+      return;
+    }
 
     this.ensureExperienceFile(state);
     const stateHash = state.getStateHash();

package/src/explorer.ts

@@ -549,10 +549,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: any) => {

package/src/reporter.ts

@@ -110,7 +110,7 @@ export class Reporter {
       const timeoutMs = Number(process.env.TESTOMATIO_TIMEOUT_MS || '15000');
       const timeoutPromise = new Promise<'timeout'>((resolve) => setTimeout(() => resolve('timeout'), timeoutMs));
 
-      const result = await Promise.race([this.client.createRun().then(() => 'success' as const), timeoutPromise]);
+      const result = await Promise.race([this.client.createRun({ configuration: { exploratory: true } }).then(() => 'success' as const), timeoutPromise]);
 
       if (result === 'timeout') {
         debugLog('Reporter run creation timed out');
@@ -145,6 +145,7 @@ export class Reporter {
         message: note.message,
         status: note.status,
         screenshot: note.screenshot,
+        log: note.log,
       }))
       .sort((a, b) => a.startTime - b.startTime);
 
@@ -180,9 +181,18 @@ 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);
@@ -196,6 +206,39 @@ export class Reporter {
     return steps;
   }
 
+  private buildVerificationStep(test: Test, lastScreenshotFile?: string): Step | undefined {
+    const v = test.verification;
+    if (!v) return undefined;
+
+    const subSteps: Step[] = [];
+    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: 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: Test, meta?: ReporterMeta): Promise<void> {
     await this.startRun();
 

package/src/stats.ts

@@ -4,6 +4,7 @@ interface TokenUsage {
   input: number;
   output: number;
   total: number;
+  cached?: number;
 }
 
 export type ExplorbotMode = 'explore' | 'test' | 'freesail' | 'tui';
@@ -20,11 +21,12 @@ export class Stats {
 
   static recordTokens(_agent: string, model: string, usage: TokenUsage): void {
     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(): string {

package/src/test-plan.ts

@@ -26,6 +26,7 @@ export interface Note {
   startTime: number;
   endTime: number;
   screenshot?: string;
+  log?: string;
 }
 
 export class ActiveNote {
@@ -34,6 +35,7 @@ export class ActiveNote {
   message: string;
   status?: TestResultType;
   screenshot?: string;
+  log?: string;
 
   constructor(task: Task, message: string, status?: TestResultType) {
     this.task = task;
@@ -73,6 +75,7 @@ export class Task {
   steps: Record<string, StepData>;
   states: WebPageState[];
   startUrl: string;
+  verification?: Verification;
   protected timestampCounter = 0;
   private activeNote?: ActiveNote;
 
@@ -102,6 +105,7 @@ export class Task {
       startTime: activeNote.getStartTime(),
       endTime,
       screenshot: activeNote.screenshot,
+      log: activeNote.log,
     };
     this.activeNote = undefined;
   }
@@ -118,13 +122,28 @@ export class Task {
       .join('\n');
   }
 
-  addNote(message: string, status: TestResultType = null, screenshot?: string): void {
-    const isDuplicate = Object.values(this.notes).some((note) => note.message === message && note.status === status);
+  addNote(message: string, status: TestResultType = null, screenshot?: string, log?: string): void {
+    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: UrlNoteState, prevState?: { title?: string; h1?: string; h2?: string }): void {
+    const fullUrl = state.fullUrl || state.url;
+    if (!fullUrl) return;
+
+    let label: string | undefined;
+    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: WebPageState): void {
@@ -136,6 +155,28 @@ export class Task {
     this.steps[timestamp] = { text, duration, status, error, log, artifacts, noteStartTime: this.activeNote?.getStartTime() };
   }
 
+  setActiveNoteScreenshot(screenshotFile?: string): void {
+    if (!this.activeNote || !screenshotFile) return;
+    this.activeNote.screenshot = screenshotFile;
+  }
+
+  setVerification(message: string, status: TestResultType, state?: UrlNoteState): void {
+    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: string): void {
+    if (!detail) return;
+    this.verification ||= { message: '', status: null, details: [] };
+    this.verification.details.push(detail);
+  }
+
   getLog(): Array<{ type: 'step' | 'note' | 'artifact'; content: string; timestamp: number }> {
     const merged: Record<string, { type: 'step' | 'note' | 'artifact'; content: string }> = {};
 
@@ -442,3 +483,21 @@ export class Plan {
     return planToAiContext(this, options);
   }
 }
+
+interface Verification {
+  message: string;
+  status: TestResultType;
+  screenshot?: string;
+  url?: string;
+  pageLabel?: string;
+  details: string[];
+}
+
+interface UrlNoteState {
+  url?: string;
+  fullUrl?: string;
+  title?: string;
+  h1?: string;
+  h2?: string;
+  screenshotFile?: string;
+}