explorbot 0.4.10 → 0.5.0

package/src/commands/plans-command.ts

@@ -1,10 +1,10 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { statSync } from 'node:fs';
 import path from 'node:path';
-import { Plan } from '../test-plan.js';
+import { Plan, type PlanFile } from '../test-plan.js';
 import { getCliName } from '../utils/cli-name.js';
 import { tag } from '../utils/logger.js';
 import { relativeToCwd } from '../utils/next-steps.js';
-import { BaseCommand } from './base-command.js';
+import { type ArgumentCompletion, BaseCommand } from './base-command.js';
 
 export class PlansCommand extends BaseCommand {
   name = 'plans';
@@ -13,7 +13,7 @@ export class PlansCommand extends BaseCommand {
 
   async execute(args: string): Promise<void> {
     const { opts, args: remaining } = this.parseArgs(args);
-    const files = this.getPlanFiles();
+    const files = Plan.listFiles(this.explorBot.getPlansDir());
     const target = String(opts.fromPlan || remaining[0] || '').trim();
 
     if (!target) {
@@ -25,22 +25,8 @@ export class PlansCommand extends BaseCommand {
     this.printPlanDetails(plan, file);
   }
 
-  private getPlanFiles(): PlanFile[] {
-    const plansDir = this.explorBot.getPlansDir();
-    if (!existsSync(plansDir)) return [];
-
-    return readdirSync(plansDir)
-      .filter((file) => file.endsWith('.md'))
-      .map((file) => {
-        const filePath = path.join(plansDir, file);
-        const stat = statSync(filePath);
-        return {
-          name: file,
-          path: filePath,
-          modifiedAt: stat.mtimeMs,
-        };
-      })
-      .sort((left, right) => right.modifiedAt - left.modifiedAt);
+  completeArguments(): ArgumentCompletion[] {
+    return Plan.listFiles(this.explorBot.getPlansDir()).map((file) => ({ value: file.name, display: file.label }));
   }
 
   private printPlans(files: PlanFile[]): void {
@@ -52,8 +38,7 @@ export class PlansCommand extends BaseCommand {
     tag('info').log('Saved plans:');
     for (let i = 0; i < files.length; i++) {
       const file = files[i];
-      const plan = Plan.fromMarkdown(file.path);
-      tag('info').log(`${i + 1}. ${plan.title} (${plan.tests.length} tests) - ${file.name}`);
+      tag('info').log(`${i + 1}. ${file.title} (${file.testCount} tests) - ${file.name}`);
     }
     tag('info').log('');
     tag('info').log(`View plan tests: ${getCliName()} plans <number>`);
@@ -83,17 +68,16 @@ export class PlansCommand extends BaseCommand {
       throw new Error(`Plan file not found: ${target}`);
     }
 
+    const name = path.basename(plan.filePath);
     const file = {
-      name: path.basename(plan.filePath),
+      name,
       path: plan.filePath,
       modifiedAt: statSync(plan.filePath).mtimeMs,
+      title: plan.title,
+      url: plan.startUrl || '',
+      testCount: plan.tests.length,
+      label: name,
     };
     return { plan, file };
   }
 }
-
-interface PlanFile {
-  name: string;
-  path: string;
-  modifiedAt: number;
-}

package/src/commands/rerun-command.ts

@@ -1,8 +1,9 @@
 import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { basename, resolve } from 'node:path';
 import { ConfigParser } from '../config.ts';
 import { tag } from '../utils/logger.ts';
-import { BaseCommand } from './base-command.js';
+import { listTestFiles } from '../utils/test-files.ts';
+import { type ArgumentCompletion, BaseCommand } from './base-command.js';
 
 export class RerunCommand extends BaseCommand {
   name = 'rerun';
@@ -32,6 +33,10 @@ export class RerunCommand extends BaseCommand {
     const testIndices = indexArg ? parseTestIndices(indexArg) : undefined;
     await this.explorBot.agentRerunner().rerun(filePath, { testIndices });
   }
+
+  completeArguments(): ArgumentCompletion[] {
+    return listTestFiles(ConfigParser.getInstance().getTestsDir()).map((file) => ({ value: basename(file) }));
+  }
 }
 
 function parseTestIndices(input: string): number[] {

package/src/commands/research-command.ts

@@ -1,7 +1,7 @@
 import { join } from 'node:path';
 import { ConfigParser } from '../config.ts';
 import { tag } from '../utils/logger.ts';
-import { BaseCommand, type Suggestion } from './base-command.js';
+import { type ArgumentCompletion, BaseCommand, type Suggestion } from './base-command.js';
 
 export class ResearchCommand extends BaseCommand {
   name = 'research';
@@ -51,4 +51,11 @@ export class ResearchCommand extends BaseCommand {
       this.suggestions = [{ command: 'research <page> --deep', hint: 'analyze page for all expandable elements and interactions' }];
     }
   }
+
+  completeArguments(): ArgumentCompletion[] {
+    return this.explorBot
+      .stateManager()
+      .getKnownUrls()
+      .map((url) => ({ value: url }));
+  }
 }

package/src/commands/test-command.ts

@@ -1,7 +1,7 @@
 import { Stats } from '../stats.js';
-import { Test } from '../test-plan.js';
+import { Plan, Test } from '../test-plan.js';
 import { tag } from '../utils/logger.js';
-import { BaseCommand, type Suggestion } from './base-command.js';
+import { type ArgumentCompletion, BaseCommand, type Suggestion } from './base-command.js';
 
 export class TestCommand extends BaseCommand {
   name = 'test';
@@ -75,6 +75,10 @@ export class TestCommand extends BaseCommand {
     }
     tag('success').log('Test execution finished');
   }
+
+  completeArguments(): ArgumentCompletion[] {
+    return Plan.listFiles(this.explorBot.getPlansDir()).map((file) => ({ value: `--from-plan ${file.name}`, display: file.label }));
+  }
 }
 
 function parseTestIndices(input: string, total: number): number[] {

package/src/components/Autocomplete.tsx

@@ -1,9 +1,14 @@
-import { Box, Text } from 'ink';
+import { Box, Text, useStdout } from 'ink';
 import React from 'react';
+import { truncate } from '../utils/strings.js';
 import { useAutocompleteState } from './autocomplete-store.js';
 
+const MAX_HEIGHT = 7;
+const COLUMN_WIDTH = 24;
+
 const Autocomplete: React.FC = () => {
   const { suggestions, selectedIndex, visible, argumentHint } = useAutocompleteState();
+  const { stdout } = useStdout();
 
   if (!visible) {
     if (!argumentHint) {
@@ -20,24 +25,49 @@ const Autocomplete: React.FC = () => {
   }
 
   const effectiveSelectedIndex = Math.min(selectedIndex, suggestions.length - 1);
-  const maxHeight = 7;
-  const rowsPerColumn = Math.min(Math.max(1, maxHeight - 2), suggestions.length);
+  const rowsPerColumn = Math.min(Math.max(1, MAX_HEIGHT - 2), suggestions.length);
+  const widest = Math.max(...suggestions.map((suggestion) => suggestion.display.length));
+
+  if (widest > COLUMN_WIDTH) {
+    const width = Math.max(COLUMN_WIDTH, (stdout?.columns || 80) - 4);
+    let firstRow = 0;
+    if (effectiveSelectedIndex >= rowsPerColumn) {
+      firstRow = effectiveSelectedIndex - rowsPerColumn + 1;
+    }
+
+    return (
+      <Box position="absolute" top={0} left={0} width="100%" maxHeight={MAX_HEIGHT} overflow="hidden" paddingX={1} paddingY={1} backgroundColor="#2a2a2a" flexDirection="column">
+        {suggestions.slice(firstRow, firstRow + rowsPerColumn).map((suggestion, rowIndex) => {
+          const isSelected = firstRow + rowIndex === effectiveSelectedIndex;
+          let color = 'white';
+          let backgroundColor = '#2a2a2a';
+          if (isSelected) {
+            color = 'black';
+            backgroundColor = '#e6e6e6';
+          }
+
+          return (
+            <Text key={suggestion.value} color={color} backgroundColor={backgroundColor}>
+              {` ${truncate(suggestion.display, width).padEnd(width)} `}
+            </Text>
+          );
+        })}
+      </Box>
+    );
+  }
+
   const columns: (typeof suggestions)[] = [];
   for (let index = 0; index < suggestions.length; index += rowsPerColumn) {
     columns.push(suggestions.slice(index, index + rowsPerColumn));
   }
 
   return (
-    <Box position="absolute" top={0} left={0} width="100%" maxHeight={maxHeight} overflow="hidden" paddingX={1} paddingY={1} backgroundColor="#2a2a2a" flexDirection="row" columnGap={2}>
+    <Box position="absolute" top={0} left={0} width="100%" maxHeight={MAX_HEIGHT} overflow="hidden" paddingX={1} paddingY={1} backgroundColor="#2a2a2a" flexDirection="row" columnGap={2}>
       {columns.map((column, columnIndex) => (
         <Box key={columnIndex} flexDirection="column">
           {column.map((suggestion, rowIndex) => {
             const index = columnIndex * rowsPerColumn + rowIndex;
             const isSelected = index === effectiveSelectedIndex;
-            let display = suggestion.display;
-            if (display.length > 24) {
-              display = `${display.slice(0, 21)}...`;
-            }
             let color = 'white';
             let backgroundColor = '#2a2a2a';
             if (isSelected) {
@@ -48,8 +78,7 @@ const Autocomplete: React.FC = () => {
             return (
               <Box key={suggestion.display} marginBottom={1}>
                 <Text color={color} backgroundColor={backgroundColor}>
-                  {' '}
-                  {display}{' '}
+                  {` ${suggestion.display} `}
                 </Text>
               </Box>
             );

package/src/components/InputReadline.tsx

@@ -43,6 +43,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
   const cursorRef = useRef(cursorPosition);
   const showAutocompleteRef = useRef(showAutocomplete);
   const selectedIndexRef = useRef(selectedIndex);
+  const navigatedRef = useRef(false);
   const historyRef = useRef<string[]>([]);
   const historyIndexRef = useRef(-1);
   const historyDraftRef = useRef('');
@@ -85,6 +86,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
       cursorRef.current = 0;
       showAutocompleteRef.current = false;
       selectedIndexRef.current = 0;
+      navigatedRef.current = false;
       historyIndexRef.current = -1;
       historyDraftRef.current = '';
       setInputState({ value: '', cursor: 0, showAutocomplete: false, selectedIndex: 0 });
@@ -141,6 +143,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
       cursorRef.current = safeCursor;
       showAutocompleteRef.current = nextShowAutocomplete;
       selectedIndexRef.current = 0;
+      navigatedRef.current = false;
       historyIndexRef.current = -1;
       historyDraftRef.current = '';
 
@@ -235,6 +238,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
         if (showAutocompleteRef.current) {
           showAutocompleteRef.current = false;
           selectedIndexRef.current = 0;
+          navigatedRef.current = false;
           setInputState((prev) => ({ ...prev, showAutocomplete: false, selectedIndex: 0 }));
         }
         return;
@@ -247,7 +251,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
         }
         if (commandHandler && showAutocompleteRef.current) {
           const autocomplete = getAutocomplete(inputRef.current, cursorRef.current);
-          if (autocomplete.visible && autocomplete.suggestions.length > 0) {
+          if (autocomplete.visible && autocomplete.suggestions.length > 0 && (!autocomplete.completesArgument || navigatedRef.current)) {
             const chosen = applyAutocomplete(selectedIndexRef.current);
             if (chosen) {
               handleSubmit(chosen);
@@ -381,6 +385,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
         if (autocomplete.visible && autocomplete.suggestions.length > 0) {
           const nextIndex = selectedIndexRef.current > 0 ? selectedIndexRef.current - 1 : autocomplete.suggestions.length - 1;
           selectedIndexRef.current = nextIndex;
+          navigatedRef.current = true;
           setInputState((prev) => ({ ...prev, selectedIndex: nextIndex }));
           return;
         }
@@ -391,6 +396,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
         if (autocomplete.visible && autocomplete.suggestions.length > 0) {
           const nextIndex = selectedIndexRef.current < autocomplete.suggestions.length - 1 ? selectedIndexRef.current + 1 : 0;
           selectedIndexRef.current = nextIndex;
+          navigatedRef.current = true;
           setInputState((prev) => ({ ...prev, selectedIndex: nextIndex }));
           return;
         }
@@ -449,6 +455,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
         inputRef.current = nextValue;
         cursorRef.current = nextValue.length;
         selectedIndexRef.current = 0;
+        navigatedRef.current = false;
         showAutocompleteRef.current = nextShowAutocomplete;
         setInputState({ value: nextValue, cursor: nextValue.length, selectedIndex: 0, showAutocomplete: nextShowAutocomplete });
         return;
@@ -470,6 +477,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
           inputRef.current = nextValue;
           cursorRef.current = nextValue.length;
           selectedIndexRef.current = 0;
+          navigatedRef.current = false;
           showAutocompleteRef.current = nextShowAutocomplete;
           setInputState({ value: nextValue, cursor: nextValue.length, selectedIndex: 0, showAutocomplete: nextShowAutocomplete });
           return;
@@ -481,6 +489,7 @@ const InputReadline: React.FC<InputReadlineProps> = React.memo(({ commandHandler
         inputRef.current = nextValue;
         cursorRef.current = nextValue.length;
         selectedIndexRef.current = 0;
+        navigatedRef.current = false;
         showAutocompleteRef.current = nextShowAutocomplete;
         setInputState({ value: nextValue, cursor: nextValue.length, selectedIndex: 0, showAutocomplete: nextShowAutocomplete });
         return;

package/src/config.ts

@@ -185,6 +185,7 @@ interface AIConfig {
   vision?: boolean;
   visionModel?: any;
   agenticModel?: any;
+  decisionModel?: { provider: string; model: string; tool?: boolean; direct?: boolean };
   retryAttempts?: number;
   retryDelay?: number;
   maxParallelRequests?: number;

package/src/experience-tracker.ts

@@ -262,7 +262,7 @@ export class ExperienceTracker {
         while (content.split('\n').length > maxLines) {
           const sections = mdq(content).query('section2').each();
           if (sections.length <= 1) break;
-          content = sections[sections.length - 1].replace('');
+          content = sections[sections.length - 1].replace('').toString();
         }
         return { ...experience, content };
       });
@@ -286,7 +286,7 @@ export class ExperienceTracker {
       combined = renderAsHowTo(combined);
 
       if (options?.stripCode) {
-        combined = mdq(combined).query('code').replace('');
+        combined = mdq(combined).query('code').replace('').toString();
       }
 
       if (combined.trim()) results.push(combined.trim());
@@ -515,7 +515,8 @@ function renderAsHowTo(content: string): string {
       if (text.startsWith('FLOW:')) return `## HOW to ${text.slice(5).trim()} (multi-step)\n\n`;
       if (text.startsWith('ACTION:')) return `## HOW to ${text.slice(7).trim()} (single-step)\n\n`;
       return heading.text();
-    });
+    })
+    .toString();
 }
 
 export interface ExperienceFile {

package/src/explorbot.ts

@@ -7,6 +7,7 @@ import { Driller } from './ai/driller.ts';
 import { ExperienceCompactor } from './ai/experience-compactor.ts';
 import { Fisherman } from './ai/fisherman.ts';
 import { Historian } from './ai/historian.ts';
+import { Judge } from './ai/judge.ts';
 import { Navigator } from './ai/navigator.ts';
 import { Pilot } from './ai/pilot.ts';
 import { Planner } from './ai/planner.ts';
@@ -80,6 +81,7 @@ export class ExplorBot {
   private _reporter?: Reporter;
   private _requestStore?: RequestStore;
   private _playwrightRecorder?: PlaywrightRecorder;
+  private judgeInstance: Judge | null | undefined;
 
   constructor(options: ExplorBotOptions = {}) {
     this.options = options;
@@ -192,6 +194,11 @@ export class ExplorBot {
     return (this._playwrightRecorder ||= new PlaywrightRecorder());
   }
 
+  judge(): Judge | null {
+    if (this.judgeInstance === undefined) this.judgeInstance = Judge.fromConfig(this.config.ai?.decisionModel);
+    return this.judgeInstance;
+  }
+
   getConfig(): ExplorbotConfig {
     return this.config;
   }
@@ -213,6 +220,7 @@ export class ExplorBot {
       knowledgeTracker: this.knowledgeTracker(),
       requestStore: this.requestStore(),
       playwrightRecorder: this.playwrightRecorder(),
+      judge: this.judge() || undefined,
     });
 
     const agentName = (agent as any).constructor.name.toLowerCase();

package/src/knowledge-tracker.ts

@@ -214,7 +214,7 @@ export class KnowledgeTracker {
 
     return this.knowledgeFiles.map((knowledge) => {
       const content = knowledge.content.trim();
-      const firstLine = mdq(content).meta()[0]?.text.split('\n')[0]?.trim() || '';
+      const firstLine = mdq(content).nodes()[0]?.text.split('\n')[0]?.trim() || '';
       return {
         url: knowledge.url || knowledge.endpoint || '',
         firstLine,

package/src/state-manager.ts

@@ -86,6 +86,7 @@ export class StateManager {
   private currentState: WebPageState | null = null;
   private stateHistory: StateTransition[] = [];
   private allVisitedUrls: Set<string> = new Set();
+  private experienceUrls?: string[];
   private stateChangeListeners: StateChangeListener[] = [];
   private experienceTracker!: ExperienceTracker;
   private knowledgeTracker: KnowledgeTracker;
@@ -359,6 +360,21 @@ export class StateManager {
     return this.allVisitedUrls;
   }
 
+  getKnownUrls(): string[] {
+    this.experienceUrls ||= this.experienceTracker
+      .getAllExperience()
+      .sort((left, right) => right.mtime.getTime() - left.mtime.getTime())
+      .flatMap((experience) => experience.data.url || []);
+    const sessionUrls = this.stateHistory.map((transition) => transition.toState.url).reverse();
+    const urls = new Map<string, string>();
+    for (const url of [...sessionUrls, ...this.experienceUrls]) {
+      const key = normalizeUrl(url);
+      if (urls.has(key)) continue;
+      urls.set(key, url);
+    }
+    return [...urls.values()];
+  }
+
   /**
    * Get how many times we've visited a specific path
    */

package/src/test-plan.ts

@@ -1,13 +1,15 @@
 import { createHash } from 'node:crypto';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 import figures from 'figures';
 import type { ActionResult } from './action-result.ts';
 import { listSitePlanDirs } from './global-config.ts';
 import { WebPageState } from './state-manager.ts';
-import { tag } from './utils/logger.ts';
+import { createDebug, pluralize, tag } from './utils/logger.ts';
+import { truncateMiddle } from './utils/strings.ts';
 import { parsePlanFromMarkdown, planToAiContext, savePlanToMarkdown, savePlansToMarkdown } from './utils/test-plan-markdown.ts';
 import { uniqSessionName } from './utils/unique-names.ts';
+import { extractStatePath } from './utils/url-matcher.ts';
 
 export const TestResult = {
   PASSED: 'passed',
@@ -241,6 +243,7 @@ export class Test extends Task {
   endTime?: number;
   resetCount = 0;
   appliedExperience: AppliedExperience[] = [];
+  preparedData: string[] = [];
 
   constructor(scenario: string, priority: 'critical' | 'important' | 'high' | 'normal' | 'low', expectedOutcome: string | string[], startUrl: string, plannedSteps: string[] = []) {
     super(scenario, startUrl);
@@ -477,6 +480,39 @@ export class Plan {
 
   updateStatus(): void {}
 
+  static listFiles(plansDir: string): PlanFile[] {
+    if (!existsSync(plansDir)) return [];
+
+    const files = readdirSync(plansDir)
+      .filter((file) => file.endsWith('.md'))
+      .map((file) => {
+        const filePath = path.join(plansDir, file);
+        const modifiedAt = statSync(filePath).mtimeMs;
+        const plan = readPlanFile(filePath, modifiedAt);
+        return {
+          name: file,
+          path: filePath,
+          modifiedAt,
+          title: plan.title,
+          url: extractStatePath(plan.startUrl || ''),
+          testCount: plan.tests.length,
+          label: '',
+        };
+      })
+      .sort((left, right) => right.modifiedAt - left.modifiedAt);
+
+    if (files.length === 0) return files;
+
+    const nameWidth = Math.min(MAX_PLAN_NAME_WIDTH, Math.max(...files.map((file) => file.name.length)));
+    const urlWidth = Math.min(MAX_PLAN_URL_WIDTH, Math.max(...files.map((file) => file.url.length)));
+    for (const file of files) {
+      const name = truncateMiddle(file.name, nameWidth).padEnd(nameWidth);
+      const url = truncateMiddle(file.url, urlWidth).padEnd(urlWidth);
+      file.label = `${name}  ${url}  ${file.testCount} ${pluralize(file.testCount, 'test')}`;
+    }
+    return files;
+  }
+
   static resolveFile(file: string, plansDir?: string): string | null {
     const names = [file];
     if (!file.endsWith('.md')) names.push(`${file}.md`);
@@ -579,3 +615,32 @@ interface AppliedExperience {
   url: string;
   content: string;
 }
+
+export interface PlanFile {
+  name: string;
+  path: string;
+  modifiedAt: number;
+  title: string;
+  url: string;
+  testCount: number;
+  label: string;
+}
+
+const debugLog = createDebug('explorbot:test-plan');
+const MAX_PLAN_NAME_WIDTH = 38;
+const MAX_PLAN_URL_WIDTH = 26;
+const planFileCache = new Map<string, { modifiedAt: number; plan: Plan }>();
+
+function readPlanFile(filePath: string, modifiedAt: number): Plan {
+  const cached = planFileCache.get(filePath);
+  if (cached?.modifiedAt === modifiedAt) return cached.plan;
+
+  let plan = new Plan(path.basename(filePath));
+  try {
+    plan = parsePlanFromMarkdown(filePath);
+  } catch (error) {
+    debugLog(`Failed to read plan file ${filePath}:`, error);
+  }
+  planFileCache.set(filePath, { modifiedAt, plan });
+  return plan;
+}

package/src/utils/aria-ref.ts

@@ -1,6 +1,6 @@
 import { WebElement } from './web-element.ts';
 
-const REF_LINE_PATTERN = /^(\s*)-\s+(\w+)\s*(?:"([^"]*)")?.*?\[ref=(e\d+)\]/;
+const REF_LINE_PATTERN = /^(\s*)-\s+(\w+)\s*(?:"([^"]*)")?.*?\[ref=((?:f\d+)?e\d+)\]/;
 const ARIA_REF_PATTERN = /^(f\d+)?e\d+$/i;
 
 const REF_ROLES: Record<string, string> = { a: 'link', button: 'button', select: 'combobox', textarea: 'textbox' };

package/src/utils/logger.ts

@@ -103,7 +103,12 @@ class ConsoleDestination implements LogDestination {
     if (entry.type === 'debug') return;
     if (entry.type === 'html') return;
     if (entry.type === 'operation' && !this.verboseMode) return;
-    if (entry.type === 'step' && !this.verboseMode && this.recentSteps.shouldSuppress(entry.content)) return;
+    if (entry.type === 'step' && !this.verboseMode) {
+      const step = entry.originalArgs?.[0];
+      const error = entry.originalArgs?.[1];
+      if (error || step?.failed === true || step?.status === 'failed') return;
+      if (this.recentSteps.shouldSuppress(entry.content)) return;
+    }
     let content = entry.content;
     if (entry.type === 'multiline' || entry.type === 'details') {
       const cleaned = stripAnsi(dedent(entry.content));