explorbot 0.1.0 → 0.1.1

package/src/commands/explore-command.ts

@@ -1,6 +1,8 @@
+import { existsSync, readdirSync } from 'node:fs';
 import figureSet from 'figures';
 import path from 'node:path';
 import { getStyles } from '../ai/planner/styles.js';
+import { ConfigParser } from '../config.ts';
 import { getCliName } from '../utils/cli-name.ts';
 import type { Plan } from '../test-plan.js';
 import { jsonToTable } from '../utils/markdown-parser.js';
@@ -18,13 +20,12 @@ export class ExploreCommand extends BaseCommand {
   private completedPlans: Plan[] = [];
 
   async execute(args: string): Promise<void> {
-    const maxTestsMatch = args.match(/--max-tests\s+(\d+)/);
-    if (maxTestsMatch) {
-      this.maxTests = Number.parseInt(maxTestsMatch[1], 10);
-      args = args.replace(/--max-tests\s+\d+/, '').trim();
+    const { opts, args: remaining } = this.parseArgs(args);
+    if (opts.maxTests) {
+      this.maxTests = Number.parseInt(opts.maxTests as string, 10);
     }
 
-    const feature = args.trim() || undefined;
+    const feature = remaining.join(' ') || undefined;
     const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
 
     await this.runAllStyles(mainUrl, feature);
@@ -61,6 +62,7 @@ export class ExploreCommand extends BaseCommand {
     if (mainUrl) await this.explorBot.visit(mainUrl);
     const savedPath = this.explorBot.savePlans(this.completedPlans);
     this.printResults(savedPath);
+    this.printRerunSuggestions();
   }
 
   private async runAllStyles(pageUrl?: string, feature?: string, parentPlan?: Plan, completedPlans?: Plan[]): Promise<void> {
@@ -113,6 +115,20 @@ export class ExploreCommand extends BaseCommand {
     }
   }
 
+  private printRerunSuggestions(): void {
+    const testsDir = ConfigParser.getInstance().getTestsDir();
+    if (!existsSync(testsDir)) return;
+
+    const testFiles = readdirSync(testsDir).filter((f) => f.endsWith('.js'));
+    if (testFiles.length === 0) return;
+
+    for (const file of testFiles) {
+      tag('info').log(`Generated: ${file}`);
+    }
+    tag('info').log(`List tests: ${getCliName()} runs`);
+    tag('info').log(`Re-run with healing: ${getCliName()} rerun <filename> [index]`);
+  }
+
   private isLimitReached(): boolean {
     return this.maxTests != null && this.testsRun >= this.maxTests;
   }

package/src/commands/freesail-command.ts

@@ -18,7 +18,12 @@ export class FreesailCommand extends BaseCommand {
   ];
 
   async execute(args: string): Promise<void> {
-    const { strategy, scope, maxTests } = parseArgs(args);
+    const { opts } = this.parseArgs(args);
+    let strategy: 'deep' | 'shallow' | undefined;
+    if (opts.deep) strategy = 'deep';
+    if (opts.shallow) strategy = 'shallow';
+    const scope = opts.scope as string | undefined;
+    const maxTests = opts.maxTests ? Number.parseInt(opts.maxTests as string, 10) : undefined;
 
     await this.explorBot.visitInitialState();
 
@@ -71,25 +76,3 @@ export class FreesailCommand extends BaseCommand {
     );
   }
 }
-
-function parseArgs(args: string): { strategy: 'deep' | 'shallow' | undefined; scope: string | undefined; maxTests: number | undefined } {
-  const parts = args.trim().split(/\s+/);
-  let strategy: 'deep' | 'shallow' | undefined;
-  let scope: string | undefined;
-  let maxTests: number | undefined;
-
-  for (let i = 0; i < parts.length; i++) {
-    if (parts[i] === '--deep') strategy = 'deep';
-    if (parts[i] === '--shallow') strategy = 'shallow';
-    if (parts[i] === '--scope' && parts[i + 1]) {
-      scope = parts[i + 1];
-      i++;
-    }
-    if (parts[i] === '--max-tests' && parts[i + 1]) {
-      maxTests = Number.parseInt(parts[i + 1], 10);
-      i++;
-    }
-  }
-
-  return { strategy, scope, maxTests };
-}

package/src/commands/index.ts

@@ -24,7 +24,9 @@ import { PlanEditCommand } from './plan-edit-command.js';
 import { PlanLoadCommand } from './plan-load-command.js';
 import { PlanReloadCommand } from './plan-reload-command.js';
 import { PlanSaveCommand } from './plan-save-command.js';
+import { RerunCommand } from './rerun-command.js';
 import { ResearchCommand } from './research-command.js';
+import { RunsCommand } from './runs-command.js';
 import { StartCommand } from './start-command.js';
 import { StatusCommand } from './status-command.tsx';
 import { TestCommand } from './test-command.js';
@@ -59,6 +61,8 @@ const commandClasses: CommandClass[] = [
   ContextExperienceCommand,
   ContextDataCommand,
   TestCommand,
+  RunsCommand,
+  RerunCommand,
   StatusCommand,
   DebugCommand,
   ExitCommand,

package/src/commands/init-command.ts

@@ -23,11 +23,11 @@ const config = {
 
   ai: {
     // fast model with tool calling capabilities
-    model: openrouter('<your base model here>'),
+    model: openrouter('openai/gpt-oss-20b:nitro'),
     // vision model for screenshot analysis
-    visionModel: openrouter('<your vision model here>'),
+    visionModel: openrouter('meta-llama/llama-4-scout-17b-16e-instruct'),
     // agentic model for decision making
-    agenticModel: openrouter('<your agentic model here>'),
+    agenticModel: openrouter('minimax/minimax-m2.5:nitro'),
   },
 };
 

package/src/commands/path-command.ts

@@ -14,7 +14,8 @@ export class PathCommand extends BaseCommand {
   options = [{ flags: '--links', description: 'Show outgoing links from each page' }];
 
   async execute(args: string): Promise<void> {
-    const showLinks = args.includes('--links');
+    const { opts } = this.parseArgs(args);
+    const showLinks = !!opts.links;
     const stateManager = this.explorBot.getExplorer().getStateManager();
     const history = stateManager.getStateHistory();
 

package/src/commands/plan-command.ts

@@ -1,3 +1,6 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import figureSet from 'figures';
 import { tag } from '../utils/logger.js';
 import { BaseCommand } from './base-command.js';
 
@@ -13,21 +16,10 @@ export class PlanCommand extends BaseCommand {
   ];
 
   async execute(args: string): Promise<void> {
-    const clear = args.includes('--clear');
-    const fresh = args.includes('--fresh') || clear;
-    const styleMatch = args.match(/--style\s+(\S+)/);
-    const style = styleMatch?.[1];
-    const focusMatch = args.match(/--focus\s+("[^"]+"|'[^']+'|\S+)/);
-    const focusFromFlag = focusMatch?.[1]?.replace(/^["']|["']$/g, '');
-    const focusFromText = args
-      .replace('--clear', '')
-      .replace('--fresh', '')
-      .replace(/--style\s+\S+/, '')
-      .replace(/--focus\s+("[^"]+"|'[^']+'|\S+)/, '')
-      .trim();
-    const focus = focusFromFlag || focusFromText;
-
-    if (clear) {
+    const { opts, args: remaining } = this.parseArgs(args);
+    const focus = (opts.focus as string) || remaining.join(' ') || undefined;
+
+    if (opts.clear) {
       this.explorBot.clearPlan();
       tag('success').log('Plan cleared');
     }
@@ -36,11 +28,48 @@ export class PlanCommand extends BaseCommand {
       tag('info').log(`Planning focus: ${focus}`);
     }
 
-    await this.explorBot.plan(focus || undefined, { fresh, style });
+    await this.explorBot.plan(focus, { fresh: !!(opts.fresh || opts.clear), style: opts.style as string });
 
     const plan = this.explorBot.getCurrentPlan();
     if (!plan?.tests.length) {
       throw new Error('No test scenarios in the current plan.');
     }
+
+    this.printPlanSummary();
+    this.updateSuggestions();
+  }
+
+  private printPlanSummary(): void {
+    const suite = this.explorBot.getSuite();
+    const plan = this.explorBot.getCurrentPlan();
+
+    if (suite && suite.automatedTestCount > 0) {
+      const names = suite.getAutomatedTestNames();
+      console.log(`\n${chalk.bold.cyan(`Already implemented (${names.length} tests)`)}`);
+      for (let i = 0; i < names.length; i++) {
+        console.log(`  ${chalk.dim(`${i + 1}.`)} ${chalk.green(figureSet.pointer)} ${names[i]}`);
+      }
+    }
+
+    if (plan?.tests.length) {
+      console.log(`\n${chalk.bold.cyan(`New test scenarios (${plan.tests.length})`)}`);
+      for (let i = 0; i < plan.tests.length; i++) {
+        const t = plan.tests[i];
+        console.log(`  ${chalk.dim(`${i + 1}.`)} ${chalk.green(figureSet.pointer)} ${t.scenario} ${chalk.dim(`[${t.priority}]`)}`);
+      }
+    }
+  }
+
+  private updateSuggestions(): void {
+    this.suggestions = ['/test - to launch first test', '/test * - to launch all tests'];
+
+    const suite = this.explorBot.getSuite();
+    if (suite && suite.automatedTestCount > 0) {
+      for (const f of suite.getAutomatedTestFiles()) {
+        this.suggestions.push(`/rerun ${path.relative(process.cwd(), f)} - re-run automated tests`);
+      }
+    }
+
+    this.suggestions.push('Edit the plan in file and call /plan:reload to update it');
   }
 }

package/src/commands/rerun-command.ts

@@ -0,0 +1,46 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { ConfigParser } from '../config.ts';
+import { tag } from '../utils/logger.ts';
+import { BaseCommand } from './base-command.js';
+
+export class RerunCommand extends BaseCommand {
+  name = 'rerun';
+  description = 'Re-run generated tests with AI auto-healing';
+  tuiEnabled = true;
+
+  async execute(args: string): Promise<void> {
+    const { args: remaining } = this.parseArgs(args);
+    const filename = remaining[0];
+    const indexArg = remaining[1];
+
+    if (!filename) {
+      tag('error').log('Usage: /rerun <filename> [index]');
+      return;
+    }
+
+    let filePath = resolve(filename);
+    if (!existsSync(filePath)) {
+      filePath = resolve(ConfigParser.getInstance().getTestsDir(), filename);
+    }
+
+    const testIndices = indexArg ? parseTestIndices(indexArg) : undefined;
+    await this.explorBot.agentRerunner().rerun(filePath, { testIndices });
+  }
+}
+
+function parseTestIndices(input: string): number[] {
+  if (input === '*' || input === 'all') return [];
+
+  const indices = new Set<number>();
+  for (const part of input.split(',')) {
+    const trimmed = part.trim();
+    const range = trimmed.match(/^(\d+)-(\d+)$/);
+    if (range) {
+      for (let i = Number.parseInt(range[1]); i <= Number.parseInt(range[2]); i++) indices.add(i - 1);
+    } else {
+      indices.add(Number.parseInt(trimmed) - 1);
+    }
+  }
+  return [...indices].sort((a, b) => a - b);
+}

package/src/commands/research-command.ts

@@ -7,12 +7,18 @@ export class ResearchCommand extends BaseCommand {
   name = 'research';
   description = 'Research current page or navigate to URI and research. Use --deep to explore interactive elements by clicking them. Use --data to include page data.';
   suggestions = ['/navigate <page> - to go to another page', '/plan <feature> - to plan testing'];
+  options = [
+    { flags: '--data', description: 'Include page data' },
+    { flags: '--deep', description: 'Explore interactive elements by clicking them' },
+    { flags: '--no-fix', description: 'Skip fixing research issues' },
+  ];
 
   async execute(args: string): Promise<void> {
-    const includeData = args.includes('--data');
-    const enableDeep = args.includes('--deep');
-    const noFix = args.includes('--no-fix');
-    const target = args.replace('--data', '').replace('--deep', '').replace('--no-fix', '').trim();
+    const { opts, args: remaining } = this.parseArgs(args);
+    const includeData = !!opts.data;
+    const enableDeep = !!opts.deep;
+    const noFix = !!opts.noFix;
+    const target = remaining.join(' ');
 
     if (target) {
       await this.explorBot.agentNavigator().visit(target);

package/src/commands/runs-command.ts

@@ -0,0 +1,27 @@
+import * as codeceptjs from 'codeceptjs';
+import { ConfigParser } from '../config.ts';
+import { dryRunTestFile, loadTestSuites, printTestList } from '../utils/test-files.ts';
+import { BaseCommand } from './base-command.js';
+
+export class RunsCommand extends BaseCommand {
+  name = 'runs';
+  description = 'List generated test files and their scenarios';
+  tuiEnabled = true;
+
+  async execute(args: string): Promise<void> {
+    if (!this.explorBot.isExploring) {
+      codeceptjs.container.create({ helpers: {} }, {});
+    }
+
+    const { args: remaining } = this.parseArgs(args);
+    const filePath = remaining[0];
+
+    if (filePath) {
+      await dryRunTestFile(filePath);
+      return;
+    }
+
+    const suites = loadTestSuites(ConfigParser.getInstance().getTestsDir());
+    printTestList(suites);
+  }
+}

package/src/commands/start-command.ts

@@ -3,7 +3,6 @@ import { ExploreCommand } from './explore-command.js';
 
 export class StartCommand extends BaseCommand {
   name = 'start';
-  aliases = ['sail'];
   description = 'Start web exploration';
   suggestions = ['/navigate <page> - to go to another page', '/research - to analyze', '/plan <feature> - to plan testing'];
 

package/src/commands/test-command.ts

@@ -25,10 +25,10 @@ export class TestCommand extends BaseCommand {
     } else if (args === '*' || args === 'all') {
       toExecute.push(...requirePlan().getPendingTests());
     } else if (args.match(/^[\d,\-\s]+$/)) {
-      const pending = requirePlan().getPendingTests();
-      const indices = parseTestIndices(args, pending.length);
+      const visible = requirePlan().tests.filter((t) => t.enabled);
+      const indices = parseTestIndices(args, visible.length);
       for (const idx of indices) {
-        toExecute.push(pending[idx]);
+        toExecute.push(visible[idx]);
       }
     } else {
       const matching = plan?.getPendingTests().filter((test) => test.scenario.toLowerCase().includes(args.toLowerCase())) || [];

package/src/components/App.tsx

@@ -242,6 +242,14 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
         setShowPlanEditor(true);
         return;
       }
+      if (key.upArrow) {
+        setTaskScrollOffset((prev) => Math.max(0, prev - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setTaskScrollOffset((prev) => prev + 1);
+        return;
+      }
     }
 
     if (!showInput && !showPlanEditor) {

package/src/config.ts

@@ -85,6 +85,22 @@ interface NavigatorAgentConfig extends AgentConfig {
   maxAttempts?: number;
 }
 
+type HealFn = (ctx: { I: any }) => Promise<void> | void;
+
+interface HealRecipe {
+  priority?: number;
+  steps?: string[];
+  fn: (context: { step: any; error: Error; prevSteps?: any[] }) => HealFn | Promise<HealFn | null> | null;
+}
+
+interface RerunnerAgentConfig extends AgentConfig {
+  healLimit?: number;
+  ariaSnapshotLimit?: number;
+  retryFailedStep?: Record<string, any>;
+  screenshotOnFail?: Record<string, any>;
+  recipes?: Record<string, HealRecipe>;
+}
+
 interface PlannerAgentConfig extends AgentConfig {
   styles?: string[];
   stylesDir?: string;
@@ -103,6 +119,7 @@ interface AgentsConfig {
   fisherman?: AgentConfig;
   chief?: AgentConfig;
   curler?: AgentConfig;
+  rerunner?: RerunnerAgentConfig;
 }
 
 interface AIConfig {
@@ -214,6 +231,8 @@ export type {
   ResearcherAgentConfig,
   NavigatorAgentConfig,
   PlannerAgentConfig,
+  RerunnerAgentConfig,
+  HealRecipe,
   Hook,
   HookConfig,
   HooksConfig,
@@ -328,6 +347,10 @@ export class ConfigParser {
     return outputPath('plans');
   }
 
+  public getTestsDir(): string {
+    return outputPath('tests');
+  }
+
   // For testing purposes only
   public static resetForTesting(): void {
     if (ConfigParser.instance) {

package/src/explorbot.ts

@@ -14,11 +14,13 @@ import { Planner } from './ai/planner.ts';
 import { AIProvider } from './ai/provider.ts';
 import { Quartermaster } from './ai/quartermaster.ts';
 import { Researcher } from './ai/researcher.ts';
+import { Rerunner } from './ai/rerunner.ts';
 import { Tester } from './ai/tester.ts';
 import { createAgentTools } from './ai/tools.ts';
 import type { ExplorbotConfig } from './config.js';
 import { ConfigParser } from './config.ts';
 import Explorer from './explorer.ts';
+import type { Suite } from './suite.ts';
 import { KnowledgeTracker } from './knowledge-tracker.ts';
 import { WebPageState } from './state-manager.ts';
 import { Plan } from './test-plan.ts';
@@ -245,6 +247,21 @@ export class ExplorBot {
     }));
   }
 
+  agentRerunner(): Rerunner {
+    if (!this.agents.rerunner) {
+      this.agents.rerunner = this.createAgent(({ ai, explorer }) => {
+        const researcher = this.agentResearcher();
+        const navigator = this.agentNavigator();
+        const tools = createAgentTools({ explorer, researcher, navigator });
+        return new Rerunner(explorer, ai, tools);
+      });
+      const qm = this.agentQuartermaster();
+      if (qm) this.agents.rerunner.setQuartermaster(qm);
+      this.agents.rerunner.setHistorian(this.agentHistorian());
+    }
+    return this.agents.rerunner;
+  }
+
   agentBosun(): Bosun {
     return (this.agents.bosun ||= this.createAgent(({ ai, explorer }) => {
       const researcher = this.agentResearcher();
@@ -291,6 +308,10 @@ export class ExplorBot {
     return this.currentPlan;
   }
 
+  getSuite(): Suite | null {
+    return this.agentPlanner().getSuite();
+  }
+
   getPlanFeature(): string | undefined {
     return this.planFeature;
   }

package/src/explorer.ts

@@ -309,8 +309,9 @@ class Explorer {
     return action;
   }
 
-  async annotateElements(): Promise<{ ariaSnapshot: string; elements: WebElement[] }> {
-    return annotatePageElements(this.playwrightHelper.page);
+  async annotateElements(): Promise<WebElement[]> {
+    const { elements } = await annotatePageElements(this.playwrightHelper.page);
+    return elements;
   }
 
   async visuallyAnnotateElements(opts?: { containers?: Array<{ css: string; label: string }> }): Promise<number> {

package/src/suite.ts

@@ -0,0 +1,135 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { Reflection } from '@codeceptjs/reflection';
+import { ConfigParser } from './config.ts';
+import { normalizeUrl } from './state-manager.ts';
+import { parsePlanFromMarkdown } from './utils/test-plan-markdown.ts';
+import { createDebug } from './utils/logger.ts';
+
+const debugLog = createDebug('explorbot:suite');
+
+export class Suite {
+  readonly url: string;
+  private _automatedTests: AutomatedTest[] | null = null;
+  private _plannedScenarios: string[] | null = null;
+
+  constructor(url: string) {
+    this.url = url;
+  }
+
+  getAutomatedTests(): AutomatedTest[] {
+    if (this._automatedTests !== null) return this._automatedTests;
+    this._automatedTests = this.loadAutomatedTests();
+    return this._automatedTests;
+  }
+
+  getPlannedScenarios(): string[] {
+    if (this._plannedScenarios !== null) return this._plannedScenarios;
+    this._plannedScenarios = this.loadPlannedScenarios();
+    return this._plannedScenarios;
+  }
+
+  getActiveScenarioTitles(): Set<string> {
+    return new Set(
+      this.getAutomatedTests()
+        .filter((t) => !t.pending)
+        .map((t) => t.title.toLowerCase())
+    );
+  }
+
+  get automatedTestCount(): number {
+    return this.getAutomatedTests().filter((t) => !t.pending).length;
+  }
+
+  getAutomatedTestNames(): string[] {
+    return this.getAutomatedTests()
+      .filter((t) => !t.pending)
+      .map((t) => t.title);
+  }
+
+  getAutomatedTestFiles(): string[] {
+    return [...new Set(this.getAutomatedTests().map((t) => t.file))];
+  }
+
+  private loadAutomatedTests(): AutomatedTest[] {
+    const testsDir = ConfigParser.getInstance().getTestsDir();
+    if (!existsSync(testsDir)) return [];
+
+    const jsFiles = readdirSync(testsDir)
+      .filter((f) => f.endsWith('.js'))
+      .map((f) => path.resolve(testsDir, f));
+
+    const results: AutomatedTest[] = [];
+
+    for (const filePath of jsFiles) {
+      const parsed = this.parseTestFile(filePath);
+      if (!parsed) continue;
+      if (normalizeUrl(parsed.url) !== normalizeUrl(this.url)) continue;
+      results.push(...parsed.tests);
+    }
+
+    return results;
+  }
+
+  private parseTestFile(filePath: string): { url: string; tests: AutomatedTest[] } | null {
+    try {
+      const scanned = Reflection.scanFile(filePath);
+      if (!scanned.suites?.length) return null;
+
+      const content = readFileSync(filePath, 'utf-8');
+
+      const suiteRef = Reflection.forSuite(scanned.suites[0]);
+      const beforeHooks = suiteRef.findHook('Before');
+      if (!beforeHooks?.length) return null;
+
+      const hookBody = content.slice(beforeHooks[0].range.start, beforeHooks[0].range.end);
+      const match = hookBody.match(/I\.amOnPage\(['"]([^'"]+)['"]\)/);
+      if (!match) return null;
+
+      const lines = content.split('\n');
+      const tests = (scanned.tests || []).map((t: any) => {
+        const line = lines[t.line - 1] || '';
+        const pending = line.includes('Scenario.skip') || line.includes('Scenario.todo');
+        return { title: t.title, pending, file: filePath };
+      });
+
+      return { url: match[1], tests };
+    } catch (err: any) {
+      debugLog('Failed to parse test file %s: %s', filePath, err.message);
+      return null;
+    }
+  }
+
+  private loadPlannedScenarios(): string[] {
+    try {
+      const plansDir = ConfigParser.getInstance().getPlansDir();
+      if (!existsSync(plansDir)) return [];
+
+      const mdFiles = readdirSync(plansDir)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => path.resolve(plansDir, f));
+
+      const scenarios: string[] = [];
+
+      for (const filePath of mdFiles) {
+        const plan = parsePlanFromMarkdown(filePath);
+        if (!plan.url) continue;
+        if (normalizeUrl(plan.url) !== normalizeUrl(this.url)) continue;
+        for (const test of plan.tests) {
+          scenarios.push(test.scenario);
+        }
+      }
+
+      return scenarios;
+    } catch (err: any) {
+      debugLog('Failed to load planned scenarios: %s', err.message);
+      return [];
+    }
+  }
+}
+
+interface AutomatedTest {
+  title: string;
+  pending: boolean;
+  file: string;
+}

package/src/utils/html.ts

@@ -486,18 +486,14 @@ export function htmlMinimalUISnapshot(html: string, htmlConfig?: HtmlConfig['min
       node.attrs = node.attrs.filter((attr) => {
         const { name, value } = attr;
         if (name === 'class') {
-          // Remove classes containing digits
           attr.value = value
             .split(' ')
-            // remove classes containing digits/
             .filter((className) => !/\d/.test(className))
-            // remove popular trash classes
             .filter((className) => !className.match(trashHtmlClasses))
-            // remove classes with : and __ in them
             .filter((className) => !className.match(/(:|__)/))
-            // remove tailwind utility classes
             .filter((className) => !TAILWIND_CLASS_PATTERNS.some((pattern) => pattern.test(className)))
             .join(' ');
+          if (attr.value === '') return false;
         }
 
         return allowedAttrs.includes(name) || name.startsWith('data-explorbot-');