explorbot 0.1.32-beta.1 → 0.2.1

package/boat/doc-collector/src/docbot.ts

@@ -10,7 +10,8 @@ import { type DocbotConfig, DocbotConfigParser } from './config.ts';
 import { type DocumentedPage, type SkippedPage, renderPageDocumentation, renderSpecIndex } from './docs-renderer.ts';
 import { getDocPageKey, shouldCrawlDocPath } from './path-filter.ts';
 import { extractResearchNavigationTargets } from './research-navigation.ts';
-import { type DocumentationScreenshot, captureDocumentationScreenshots } from './screenshots.ts';
+import { type DocumentationScreenshot, captureDocumentationScreenshots, captureInteractionScreenshot } from './screenshots.ts';
+import { renderMermaidBody } from './state-diagram.ts';
 
 class DocBot {
   private explorBot: ExplorBot;
@@ -42,7 +43,7 @@ class DocBot {
       config: this.options.docsConfig,
       path: this.options.path,
     });
-    this.documentarian = new Documentarian(this.explorBot.getProvider(), this.config, this.explorBot.getExplorer());
+    this.documentarian = new Documentarian(this.explorBot.getProvider(), this.config, this.explorBot.getExplorer(), this.explorBot.stateManager());
     this.ensureDirectory(this.configParser.getOutputDir());
     this.ensureDirectory(this.getPagesDir());
   }
@@ -75,7 +76,7 @@ class DocBot {
         continue;
       }
 
-      const stateManager = this.explorBot.getExplorer().getStateManager();
+      const stateManager = this.explorBot.stateManager();
       if (stateManager.hasVisitedState(target)) {
         continue;
       }
@@ -111,7 +112,17 @@ class DocBot {
           screenshot: this.shouldUseScreenshots(),
           force: true,
         });
-        const documentation = await this.documentarian.document(state, research);
+        const pagePath = this.getPageFilePath(state.url);
+        const documentation = await this.documentarian.document(state, research, async (interactionState, transition) => {
+          if (!this.shouldUseScreenshots()) {
+            return null;
+          }
+          return captureInteractionScreenshot(this.explorBot.getExplorer(), interactionState, transition, {
+            pageFilePath: pagePath,
+            screenshotsDir: this.getScreenshotsDir(),
+            config: this.config,
+          });
+        });
         const lowSignalReason = this.getLowSignalReason(documentation, research);
         if (lowSignalReason) {
           skipped.push({
@@ -134,6 +145,7 @@ class DocBot {
           mightActions: documentation.might.map((item) => item.action),
           interactionActions: (documentation.interactions || []).map((item) => item.action),
           qualityNotes: documentation.qualityNotes || [],
+          interactions: documentation.interactions || [],
           filePath,
         });
         documented.add(pageKey);
@@ -159,12 +171,13 @@ class DocBot {
       }
     }
 
-    const indexPath = this.saveIndex(effectiveStartPath, pages, skipped, effectiveMaxPages);
+    const { indexPath, diagramPath } = this.saveIndex(effectiveStartPath, pages, skipped, effectiveMaxPages);
 
     return {
       pages,
       skipped,
       indexPath,
+      diagramPath,
       outputDir: this.configParser.getOutputDir(),
     };
   }
@@ -385,6 +398,10 @@ class DocBot {
       return null;
     }
 
+    if ((documentation.interactions || []).length > 0) {
+      return null;
+    }
+
     const interactiveCount = this.countInteractiveElements(research);
     if (interactiveCount >= minInteractiveElements) {
       return null;
@@ -417,10 +434,13 @@ class DocBot {
     });
   }
 
-  private saveIndex(startPath: string, pages: DocumentedPage[], skipped: SkippedPage[], maxPages: number): string {
-    const indexPath = path.join(this.configParser.getOutputDir(), 'spec.md');
-    writeFileSync(indexPath, renderSpecIndex(this.configParser.getOutputDir(), startPath, pages, skipped, maxPages), 'utf8');
-    return indexPath;
+  private saveIndex(startPath: string, pages: DocumentedPage[], skipped: SkippedPage[], maxPages: number): { indexPath: string; diagramPath: string } {
+    const outputDir = this.configParser.getOutputDir();
+    const indexPath = path.join(outputDir, 'index.md');
+    writeFileSync(indexPath, renderSpecIndex(outputDir, startPath, pages, skipped, maxPages), 'utf8');
+    const diagramPath = path.join(outputDir, 'state-diagram.mmd');
+    writeFileSync(diagramPath, renderMermaidBody(outputDir, pages), 'utf8');
+    return { indexPath, diagramPath };
   }
 
   private getPagesDir(): string {
@@ -461,6 +481,7 @@ interface CollectionResult {
   pages: DocumentedPage[];
   skipped: SkippedPage[];
   indexPath: string;
+  diagramPath: string;
   outputDir: string;
 }
 

package/boat/doc-collector/src/docs-renderer.ts

@@ -1,7 +1,9 @@
 import path from 'node:path';
-import type { WebPageState } from '../../../src/state-manager.ts';
+import { type WebPageState } from '../../../src/state-manager.ts';
 import type { PageDocumentation, StateTransition } from './ai/documentarian.ts';
 import type { DocumentationScreenshot } from './screenshots.ts';
+import { buildStateGraph, renderMermaidFromGraph, renderStateMapFromGraph, type DocumentedPage, type SkippedPage } from './state-diagram.ts';
+import { normalizeInlineText } from '../../../src/utils/strings.ts';
 
 function renderPageDocumentation(state: WebPageState, documentation: PageDocumentation, screenshots: DocumentationScreenshot[] = []): string {
   const lines: string[] = [];
@@ -48,6 +50,10 @@ function renderPageDocumentation(state: WebPageState, documentation: PageDocumen
         }
         lines.push('');
       }
+      if (transition.screenshot) {
+        lines.push(`![${normalizeInlineText(transition.screenshot.title)}](${transition.screenshot.relativePath})`);
+        lines.push('');
+      }
     }
   }
 
@@ -109,6 +115,18 @@ function renderSpecIndex(outputDir: string, startPath: string, pages: Documented
   lines.push(`Pages skipped: ${skipped.length}`);
   lines.push(`Max pages: ${maxPages}`);
   lines.push('');
+  const graph = buildStateGraph(outputDir, pages);
+  lines.push('## State Transitions');
+  lines.push('');
+  lines.push(`\`\`\`mermaid\n${renderMermaidFromGraph(graph)}\n\`\`\``);
+  lines.push('');
+  const stateMap = renderStateMapFromGraph(graph);
+  if (stateMap) {
+    lines.push('### State Index');
+    lines.push('');
+    lines.push(stateMap);
+    lines.push('');
+  }
   lines.push('## Pages');
   lines.push('');
 
@@ -227,28 +245,5 @@ function ensureSentence(text: string): string {
   return `${trimmed}.`;
 }
 
-function normalizeInlineText(text: string): string {
-  return text.normalize('NFKC').replace(/\s+/g, ' ').trim();
-}
-
-interface DocumentedPage {
-  url: string;
-  title: string;
-  summary: string;
-  canCount: number;
-  mightCount: number;
-  interactionCount: number;
-  canActions: string[];
-  mightActions: string[];
-  interactionActions: string[];
-  qualityNotes: string[];
-  filePath: string;
-}
-
-interface SkippedPage {
-  url: string;
-  reason: string;
-}
-
 export { renderPageDocumentation, renderSpecIndex, ensureSentence, normalizeAction };
 export type { DocumentedPage, SkippedPage, StateTransition };

package/boat/doc-collector/src/screenshots.ts

@@ -3,13 +3,15 @@ import path from 'node:path';
 import { parseResearchSections } from '../../../src/ai/researcher/parser.ts';
 import type Explorer from '../../../src/explorer.ts';
 import type { WebPageState } from '../../../src/state-manager.ts';
+import { detectFocusArea } from '../../../src/utils/aria.ts';
 import { safeFilename, sanitizeFilename } from '../../../src/utils/strings.ts';
+import type { DocStateTransition } from './ai/tools.ts';
 import type { DocbotConfig } from './config.ts';
 
 const DEFAULT_MAX_SECTION_SCREENSHOTS = 8;
 
 export async function captureDocumentationScreenshots(explorer: Explorer, state: WebPageState, research: string, options: DocumentationScreenshotOptions): Promise<DocumentationScreenshot[]> {
-  const page = explorer.playwrightHelper?.page;
+  const page = explorer.page;
   if (!page) {
     return [];
   }
@@ -59,6 +61,36 @@ export function getScreenshotSections(research: string): ScreenshotSection[] {
   return sections;
 }
 
+export async function captureInteractionScreenshot(explorer: Explorer, state: WebPageState, transition: DocStateTransition, options: DocumentationScreenshotOptions): Promise<DocumentationScreenshot | null> {
+  const page = explorer.page;
+  if (!page) {
+    return null;
+  }
+
+  mkdirSync(options.screenshotsDir, { recursive: true });
+  const pageName = sanitizeFilename(state.url || 'page') || 'page';
+  const stateName = sanitizeFilename(transition.targetState?.label || transition.action) || 'state';
+  const filePath = path.join(options.screenshotsDir, safeFilename(`${pageName}_${stateName}`, '.png'));
+  const focus = detectFocusArea(state.ariaSnapshot || null);
+
+  try {
+    if (focus.detected) {
+      await page.locator('[role="dialog"], [role="alertdialog"], [aria-modal="true"]').last().screenshot({ path: filePath });
+    } else {
+      await page.screenshot({ path: filePath });
+    }
+  } catch {
+    return null;
+  }
+
+  return {
+    title: transition.targetState?.label || transition.action,
+    path: filePath,
+    relativePath: toMarkdownPath(options.pageFilePath, filePath),
+    kind: 'state',
+  };
+}
+
 async function captureFullPageScreenshot(page: any, pageName: string, options: DocumentationScreenshotOptions): Promise<DocumentationScreenshot | null> {
   const filePath = path.join(options.screenshotsDir, safeFilename(`${pageName}_page`, '.png'));
   try {
@@ -110,7 +142,7 @@ export interface DocumentationScreenshot {
   title: string;
   path: string;
   relativePath: string;
-  kind: 'page' | 'section';
+  kind: 'page' | 'section' | 'state';
   selector?: string;
 }
 

package/boat/doc-collector/src/state-diagram.ts

@@ -0,0 +1,281 @@
+import path from 'node:path';
+import { normalizeUrl } from '../../../src/state-manager.ts';
+import { normalizeInlineText } from '../../../src/utils/strings.ts';
+import type { StateTransition } from './ai/documentarian.ts';
+
+function buildStateGraph(outputDir: string, pages: DocumentedPage[]): StateGraph {
+  const pageIds = new Map<string, string>();
+  const pageNodes: StateNode[] = [];
+  const adjacency = new Map<string, Set<string>>();
+  const classAssignment = new Map<StateClass, string[]>([
+    ['page', []],
+    ['dialog', []],
+    ['section', []],
+  ]);
+
+  for (const [index, page] of pages.entries()) {
+    const id = `page${index}`;
+    pageIds.set(normalizeUrl(page.url), id);
+    adjacency.set(id, new Set());
+    classAssignment.get('page')?.push(id);
+    pageNodes.push({ id, kind: 'page', label: page.title || page.url, subLabel: page.url, filePath: page.filePath });
+  }
+
+  const stateKeys = new Map<string, string>();
+  const transientByPage = new Map<string, StateNode[]>();
+  const clicks: StateClick[] = [];
+  const edges: StateEdge[] = [];
+  const drawnBack = new Set<string>();
+  let stateIndex = 0;
+
+  for (const [pageIndex, page] of pages.entries()) {
+    const sourceId = `page${pageIndex}`;
+    for (const transition of page.interactions || []) {
+      const targetState = transition.targetState;
+      if (!targetState) {
+        continue;
+      }
+
+      const normalizedTarget = normalizeUrl(targetState.url);
+      const isPageTarget = targetState.kind === 'page';
+      let pageTargetId: string | undefined;
+      if (isPageTarget) {
+        pageTargetId = pageIds.get(normalizedTarget);
+      }
+      let targetId: string | undefined;
+      if (pageTargetId && pageTargetId !== sourceId) {
+        targetId = pageTargetId;
+      }
+
+      if (!targetId) {
+        const stateKey = `${sourceId}:${targetState.kind}:${normalizeInlineText(targetState.label)}:${normalizedTarget}`;
+        targetId = stateKeys.get(stateKey);
+        if (!targetId) {
+          targetId = `state${stateIndex++}`;
+          stateKeys.set(stateKey, targetId);
+          adjacency.set(targetId, new Set());
+          classAssignment.get(classForKind(targetState.kind))?.push(targetId);
+          const list = transientByPage.get(sourceId) ?? [];
+          list.push({ id: targetId, kind: targetState.kind, label: targetState.label, subLabel: targetState.kind, parentPageId: sourceId });
+          transientByPage.set(sourceId, list);
+          if (transition.screenshot) {
+            const screenshotPath = path.resolve(path.dirname(page.filePath), transition.screenshot.relativePath);
+            clicks.push({ node: targetId, target: path.relative(outputDir, screenshotPath).replaceAll('\\', '/'), tooltip: 'Open state screenshot' });
+          }
+        }
+      }
+
+      if (!targetId) {
+        continue;
+      }
+
+      const pairKey = `${sourceId}>${targetId}`;
+      if (adjacency.get(targetId)?.has(sourceId)) {
+        if (drawnBack.has(pairKey)) {
+          continue;
+        }
+        drawnBack.add(pairKey);
+        edges.push({ source: sourceId, target: targetId, action: transition.action, isBack: true });
+        continue;
+      }
+
+      if (adjacency.get(sourceId)?.has(targetId) || createsCycle(sourceId, targetId, adjacency)) {
+        continue;
+      }
+      adjacency.get(sourceId)?.add(targetId);
+      edges.push({ source: sourceId, target: targetId, action: transition.action, isBack: false });
+    }
+  }
+
+  const pageClicks: StateClick[] = [];
+  for (const pageNode of pageNodes) {
+    const filePath = pageNode.filePath;
+    if (!filePath) {
+      continue;
+    }
+    const relativeFile = path.relative(outputDir, filePath).replaceAll('\\', '/');
+    pageClicks.push({ node: pageNode.id, target: relativeFile, tooltip: `Open ${pageNode.label}` });
+  }
+
+  return { pages: pageNodes, transientByPage, edges, clicks: [...pageClicks, ...clicks], classAssignment };
+}
+
+function renderMermaidBody(outputDir: string, pages: DocumentedPage[]): string {
+  return renderMermaidFromGraph(buildStateGraph(outputDir, pages));
+}
+
+function renderMermaidFromGraph(graph: StateGraph): string {
+  const lines: string[] = ['flowchart TD'];
+  if (graph.pages.length === 0) {
+    lines.push('  empty["No documented states"]');
+    return lines.join('\n');
+  }
+
+  for (const page of graph.pages) {
+    lines.push(`  ${renderNodeLine(page)}`);
+    const children = graph.transientByPage.get(page.id);
+    if (!children || children.length === 0) {
+      continue;
+    }
+    lines.push(`  subgraph sg_${page.id} ["${escapeMermaidLabel(page.label)} — transient states"]`);
+    for (const child of children) {
+      lines.push(`    ${renderNodeLine(child)}`);
+    }
+    lines.push('  end');
+  }
+
+  for (const edge of graph.edges) {
+    let arrow = '-->';
+    if (edge.isBack) {
+      arrow = '-.->';
+    }
+    lines.push(`  ${edge.source} ${arrow}|"${escapeMermaidLabel(edge.action)}"| ${edge.target}`);
+  }
+
+  lines.push('  classDef page fill:#dbeafe,stroke:#2563eb,color:#0f172a;');
+  lines.push('  classDef dialog fill:#ffedd5,stroke:#ea580c,color:#0f172a;');
+  lines.push('  classDef section fill:#f3e8ff,stroke:#9333ea,color:#0f172a;');
+  for (const [className, ids] of graph.classAssignment) {
+    if (ids.length === 0) {
+      continue;
+    }
+    lines.push(`  class ${ids.join(',')} ${className};`);
+  }
+
+  for (const click of graph.clicks) {
+    lines.push(`  click ${click.node} "${click.target}" "${escapeMermaidLabel(click.tooltip)}"`);
+  }
+
+  return lines.join('\n');
+}
+
+function renderStateMapFromGraph(graph: StateGraph): string {
+  if (graph.pages.length === 0) {
+    return '';
+  }
+  const clickByNode = new Map(graph.clicks.map((click) => [click.node, click]));
+  const rows = ['| State | Type | Open |', '| --- | --- | --- |'];
+  for (const pageNode of graph.pages) {
+    const pageClick = clickByNode.get(pageNode.id);
+    let openCell = '—';
+    if (pageClick) {
+      openCell = `[open page](${pageClick.target})`;
+    }
+    rows.push(`| ${escapeTable(pageNode.label)} | page | ${openCell} |`);
+    for (const child of graph.transientByPage.get(pageNode.id) ?? []) {
+      const childClick = clickByNode.get(child.id);
+      let childCell = '—';
+      if (childClick) {
+        childCell = `[view screenshot](${childClick.target})`;
+      }
+      rows.push(`| ${escapeTable(child.label)} | ${child.kind} | ${childCell} |`);
+    }
+  }
+  return rows.join('\n');
+}
+
+function renderNodeLine(node: StateNode): string {
+  const label = `${escapeMermaidLabel(node.label)}<br/>${escapeMermaidLabel(node.subLabel)}`;
+  if (node.kind === 'dialog' || node.kind === 'modal') {
+    return `${node.id}{{"${label}"}}`;
+  }
+  if (node.kind === 'section') {
+    return `${node.id}("${label}")`;
+  }
+  return `${node.id}["${label}"]`;
+}
+
+function createsCycle(sourceId: string, targetId: string, adjacency: Map<string, Set<string>>): boolean {
+  if (sourceId === targetId) {
+    return true;
+  }
+
+  const pending = [targetId];
+  const visited = new Set<string>();
+  while (pending.length > 0) {
+    const nodeId = pending.pop();
+    if (!nodeId || visited.has(nodeId)) {
+      continue;
+    }
+    if (nodeId === sourceId) {
+      return true;
+    }
+    visited.add(nodeId);
+    pending.push(...(adjacency.get(nodeId) || []));
+  }
+  return false;
+}
+
+function escapeMermaidLabel(value: string): string {
+  return normalizeInlineText(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('|', '&#124;');
+}
+
+function escapeTable(value: string): string {
+  return normalizeInlineText(value).replaceAll('|', '\\|');
+}
+
+function classForKind(kind: StateKind): StateClass {
+  if (kind === 'section') {
+    return 'section';
+  }
+  if (kind === 'page') {
+    return 'page';
+  }
+  return 'dialog';
+}
+
+interface DocumentedPage {
+  url: string;
+  title: string;
+  summary: string;
+  canCount: number;
+  mightCount: number;
+  interactionCount: number;
+  canActions: string[];
+  mightActions: string[];
+  interactionActions: string[];
+  qualityNotes: string[];
+  interactions?: StateTransition[];
+  filePath: string;
+}
+
+interface SkippedPage {
+  url: string;
+  reason: string;
+}
+
+type StateKind = 'page' | 'dialog' | 'modal' | 'section';
+type StateClass = 'page' | 'dialog' | 'section';
+
+interface StateNode {
+  id: string;
+  kind: StateKind;
+  label: string;
+  subLabel: string;
+  filePath?: string;
+  parentPageId?: string;
+}
+
+interface StateEdge {
+  source: string;
+  target: string;
+  action: string;
+  isBack: boolean;
+}
+
+interface StateClick {
+  node: string;
+  target: string;
+  tooltip: string;
+}
+
+interface StateGraph {
+  pages: StateNode[];
+  transientByPage: Map<string, StateNode[]>;
+  edges: StateEdge[];
+  clicks: StateClick[];
+  classAssignment: Map<StateClass, string[]>;
+}
+
+export { buildStateGraph, renderMermaidBody, renderMermaidFromGraph, renderStateMapFromGraph };
+export type { DocumentedPage, SkippedPage, StateGraph, StateNode, StateEdge, StateClick };

package/dist/bin/explorbot-cli.js

@@ -9,7 +9,7 @@ import { render } from 'ink';
 import React from 'react';
 import { App } from '../src/components/App.js';
 import { StatusPane } from '../src/components/StatusPane.js';
-import { ConfigParser } from '../src/config.js';
+import { ConfigParser, EXPLORBOT_ENV_VARS, PROVIDERS } from '../src/config.js';
 import { ExplorBot } from '../src/explorbot.js';
 import { Stats } from '../src/stats.js';
 import { Plan } from '../src/test-plan.js';
@@ -27,7 +27,6 @@ if (!process.env.EXPLORBOT_NO_BANNER) {
     console.log(`⛵ ${chalk.yellow.bold(`Explorbot v${pkgVersion}`)} ${chalk.dim('Autonomous Testing Agent')}`);
 }
 function buildExplorBotOptions(from, options) {
-    const sessionFile = options.session === true ? path.join(path.resolve(options.path || process.cwd()), 'output', 'session.json') : options.session;
     return {
         from,
         verbose: options.verbose || options.debug,
@@ -36,7 +35,7 @@ function buildExplorBotOptions(from, options) {
         show: options.show,
         headless: options.headless,
         incognito: options.incognito,
-        session: sessionFile,
+        session: options.session,
     };
 }
 function addCommonOptions(cmd) {
@@ -454,16 +453,16 @@ program
         await ConfigParser.getInstance().loadConfig({
             path: options.path || process.cwd(),
         });
+        const { KnowledgeTracker } = await import('../src/knowledge-tracker.js');
+        const tracker = new KnowledgeTracker();
         if (url && description) {
-            const { KnowledgeTracker } = await import('../src/knowledge-tracker.js');
-            const tracker = new KnowledgeTracker();
             const result = tracker.addKnowledge(url, description);
             const action = result.isNewFile ? 'Created' : 'Updated';
             console.log(`Knowledge ${action} in: ${result.filename}`);
             return;
         }
         const AddKnowledge = (await import('../src/components/AddKnowledge.js')).default;
-        render(React.createElement(AddKnowledge, { initialUrl: url || '' }), {
+        render(React.createElement(AddKnowledge, { initialUrl: url || '', knowledgeTracker: tracker }), {
             exitOnCtrlC: false,
             patchConsole: false,
         });
@@ -623,7 +622,7 @@ program
             path: options.path,
             config: options.config,
             headless: true,
-            session: options.session === true ? 'output/session.json' : options.session,
+            session: options.session,
         };
         const explorBot = new ExplorBot(mainOptions);
         await explorBot.start();
@@ -652,10 +651,10 @@ addCommonOptions(program.command('shell <url> <command>').description('Execute a
         const explorBot = new ExplorBot(buildExplorBotOptions(url, options));
         await explorBot.start();
         await explorBot.agentNavigator().visit(url);
-        const action = explorBot.getExplorer().createAction();
+        const action = explorBot.getExplorer().action();
         await action.execute(command);
         log('Command executed successfully');
-        const state = explorBot.getExplorer().getStateManager().getCurrentState();
+        const state = explorBot.stateManager().getCurrentState();
         if (state)
             log(`URL: ${state.url}`);
         await explorBot.stop();
@@ -793,4 +792,25 @@ import { createApiCommands } from "../boat/api-tester/src/cli.js";
 import { createDocsCommands } from "../boat/doc-collector/src/cli.js";
 program.addCommand(createApiCommands('api'));
 program.addCommand(createDocsCommands('docs'));
+const envHelp = () => {
+    const width = Math.max(...EXPLORBOT_ENV_VARS.map((v) => v.name.length));
+    const rows = EXPLORBOT_ENV_VARS.map((v) => `  ${v.name.padEnd(width)}  ${v.description}`).join('\n');
+    return `
+Environment variables (config-free one-liner mode):
+  Set EXPLORBOT_AI_PROVIDER to run without an explorbot.config.js. A config file always wins.
+
+${rows}
+
+  Providers: ${Object.keys(PROVIDERS).join(', ')}
+  Example:
+    EXPLORBOT_URL=https://app.example.com EXPLORBOT_AI_PROVIDER=openrouter \\
+      ${cli} explore /login --max-tests 3
+`;
+};
+const addEnvHelp = (cmd) => {
+    cmd.addHelpText('after', envHelp);
+    for (const sub of cmd.commands)
+        addEnvHelp(sub);
+};
+addEnvHelp(program);
 program.parse();

package/dist/boat/api-tester/src/config.js

@@ -9,7 +9,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import path, { resolve } from 'node:path';
 import { parseEnv } from 'node:util';
-import { EXPLORBOT_CONFIG_PATHS } from "../../../src/config.js";
+import { EXPLORBOT_CONFIG_PATHS, createModel, materializeKnowledge, resolveModel, resolveOutputRoot } from "../../../src/config.js";
 export class ApibotConfigParser {
     static instance;
     config = null;
@@ -37,9 +37,13 @@ export class ApibotConfigParser {
         ApibotConfigParser.loadEnv('.env');
         const resolvedPath = options?.config || this.findConfigFile();
         if (!resolvedPath) {
-            if (options?.path)
-                process.chdir(originalCwd);
-            throw new Error('No configuration file found. Create apibot.config.js or apibot.config.ts');
+            try {
+                return await this.loadEnvConfig();
+            }
+            finally {
+                if (options?.path && originalCwd !== process.cwd())
+                    process.chdir(originalCwd);
+            }
         }
         try {
             const configModule = await this.loadConfigModule(resolvedPath);
@@ -98,6 +102,41 @@ export class ApibotConfigParser {
             mkdirSync(dirPath, { recursive: true });
         }
     }
+    async loadEnvConfig() {
+        const provider = process.env.EXPLORBOT_AI_PROVIDER;
+        const modelSpec = process.env.EXPLORBOT_AI_MODEL;
+        if (!provider && !modelSpec) {
+            throw new Error('No configuration file found. Create apibot.config.js or set EXPLORBOT_URL and EXPLORBOT_AI_PROVIDER environment variables');
+        }
+        if (modelSpec && !provider && !modelSpec.includes('/')) {
+            throw new Error('EXPLORBOT_AI_MODEL needs a provider — set EXPLORBOT_AI_PROVIDER, or write it as "provider/model-id"');
+        }
+        const baseEndpoint = process.env.EXPLORBOT_URL;
+        if (!baseEndpoint) {
+            throw new Error('No API endpoint to test. Set EXPLORBOT_URL to the API base endpoint');
+        }
+        const outputRoot = resolveOutputRoot();
+        materializeKnowledge(outputRoot);
+        const api = { baseEndpoint };
+        if (process.env.EXPLORBOT_API_SPEC) {
+            api.spec = [process.env.EXPLORBOT_API_SPEC];
+        }
+        let model;
+        if (provider && modelSpec)
+            model = await createModel(provider, modelSpec);
+        if (provider && !modelSpec)
+            model = await resolveModel(provider, 'model');
+        if (!provider)
+            model = await resolveModel(modelSpec, 'model');
+        this.config = {
+            ai: { model },
+            api,
+            dirs: { output: '.', knowledge: 'knowledge' },
+        };
+        this.configPath = path.join(outputRoot, 'apibot.config.js');
+        this.validateConfig(this.config);
+        return this.config;
+    }
     findConfigFile() {
         const apibotPaths = ['apibot.config.js', 'apibot.config.mjs', 'apibot.config.ts'];
         for (const p of apibotPaths) {