explorbot 0.4.8 → 0.4.9

package/boat/api-tester/src/cli.ts

@@ -40,7 +40,7 @@ export function createApiCommands(name = 'api'): Command {
       if (runOptions.endpoint && URL.canParse(runOptions.endpoint)) runOptions.baseEndpoint ||= runOptions.endpoint;
       try {
         const config = await parser.loadConfig(runOptions);
-        console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json }));
+        console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), siteConfigPath: parser.getSiteConfigPath(), root: parser.getProjectRoot(), json: options.json }));
       } catch (error) {
         console.error(error instanceof Error ? error.message : 'Unknown error');
         process.exit(1);

package/boat/api-tester/src/config.ts

@@ -18,7 +18,8 @@ import {
   resolveOutputRoot,
   setOutputDir,
 } from '../../../src/config.ts';
-import { type SiteRecord, findGlobalConfig, globalEnvPath, isGlobalConfigPath, registerSite, resolveSiteTarget } from '../../../src/global-config.ts';
+import { type SiteRecord, findGlobalConfig, globalEnvPath, isGlobalConfigPath, loadSiteConfig, registerSite, resolveSiteTarget } from '../../../src/global-config.ts';
+import { deepMerge } from '../../../src/utils/merge.ts';
 
 export type { AIConfig };
 
@@ -58,6 +59,7 @@ export class ApibotConfigParser {
   private config: ApibotConfig | null = null;
   private configPath: string | null = null;
   private site: SiteRecord | null = null;
+  private siteConfigPath: string | null = null;
 
   private constructor() {}
 
@@ -111,20 +113,22 @@ export class ApibotConfigParser {
         };
       }
 
-      this.config = this.mergeWithDefaults(loadedConfig);
-      this.applyEnvSpec(this.config.api);
-      this.applyEnvHeaders(this.config.api);
-      if (options?.baseEndpoint) this.config.api.baseEndpoint = options.baseEndpoint.replace(/\/$/, '');
-      await resolveConfigModels(this.config.ai);
-      resolveLangfuse(this.config.ai);
-      this.configPath = resolvedPath;
+      let config = this.mergeWithDefaults(loadedConfig);
+      this.applyEnvSpec(config.api);
+      this.applyEnvHeaders(config.api);
+      if (options?.baseEndpoint) config.api.baseEndpoint = options.baseEndpoint.replace(/\/$/, '');
+      await resolveConfigModels(config.ai);
+      resolveLangfuse(config.ai);
       this.site = null;
+      this.siteConfigPath = null;
 
       if (isGlobalConfigPath(resolvedPath)) {
-        this.enterGlobalMode(this.config, options?.endpoint);
+        config = await this.enterGlobalMode(config, options?.endpoint);
       }
 
-      this.validateConfig(this.config);
+      this.validateConfig(config);
+      this.config = config;
+      this.configPath = resolvedPath;
       setOutputDir(this.getOutputDir());
 
       return this.config;
@@ -144,6 +148,10 @@ export class ApibotConfigParser {
     return this.configPath;
   }
 
+  getSiteConfigPath(): string | null {
+    return this.siteConfigPath;
+  }
+
   getOutputDir(): string {
     const config = this.getConfig();
     return path.join(this.getProjectRoot(), config.dirs?.output || 'output');
@@ -207,17 +215,29 @@ export class ApibotConfigParser {
     api.headers = { ...api.headers, ...parseHeaders(process.env.EXPLORBOT_API_HEADERS) };
   }
 
-  private enterGlobalMode(config: ApibotConfig, endpoint?: string): void {
+  private async enterGlobalMode(config: ApibotConfig, endpoint?: string): Promise<ApibotConfig> {
     const site = resolveSiteTarget(endpoint);
     this.site = registerSite(site.baseUrl);
 
+    const { path, config: siteConfig } = await loadSiteConfig(this.site.dir, site.baseUrl);
+    this.siteConfigPath = path;
+
+    const overrides: Partial<ApibotConfig> = {};
+    if (siteConfig.ai) overrides.ai = siteConfig.ai;
+    if (siteConfig.api) overrides.api = siteConfig.api;
+
+    const merged = deepMerge(config, overrides);
+    await resolveConfigModels(merged.ai);
+    resolveLangfuse(merged.ai);
+
     let baseEndpoint = site.baseUrl;
     const envUrl = process.env.EXPLORBOT_URL;
     if (envUrl && URL.parse(envUrl)?.origin === site.baseUrl) baseEndpoint = envUrl.replace(/\/$/, '');
 
-    config.dirs = { output: 'output', knowledge: 'knowledge' };
-    config.api = { ...config.api, baseEndpoint };
+    merged.dirs = { output: 'output', knowledge: 'knowledge' };
+    merged.api = { ...merged.api, baseEndpoint };
     materializeKnowledge(this.site.dir);
+    return merged;
   }
 
   private async loadEnvConfig(): Promise<ApibotConfig> {
@@ -310,19 +330,7 @@ export class ApibotConfigParser {
   }
 
   private mergeWithDefaults(config: Partial<ApibotConfig>): ApibotConfig {
-    return this.deepMerge({ dirs: { output: 'output' }, api: {} }, config);
-  }
-
-  private deepMerge(target: any, source: any): any {
-    const result = { ...target };
-    for (const key in source) {
-      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key]) && source[key].constructor === Object) {
-        result[key] = this.deepMerge(result[key] || {}, source[key]);
-      } else {
-        result[key] = source[key];
-      }
-    }
-    return result;
+    return deepMerge({ dirs: { output: 'output' }, api: {} }, config);
   }
 }
 

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

@@ -38,7 +38,7 @@ export function createApiCommands(name = 'api') {
             runOptions.baseEndpoint ||= runOptions.endpoint;
         try {
             const config = await parser.loadConfig(runOptions);
-            console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json }));
+            console.log(ConfigCommand.render(config, { configPath: parser.getConfigPath(), siteConfigPath: parser.getSiteConfigPath(), root: parser.getProjectRoot(), json: options.json }));
         }
         catch (error) {
             console.error(error instanceof Error ? error.message : 'Unknown error');

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

@@ -11,7 +11,8 @@ import path, { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { parseEnv } from 'node:util';
 import { ConfigMissingError, EXPLORBOT_CONFIG_PATHS, createModel, envConfigRequested, materializeKnowledge, missingConfigMessage, resolveConfigModels, resolveLangfuse, resolveModel, resolveOutputRoot, setOutputDir, } from "../../../src/config.js";
-import { findGlobalConfig, globalEnvPath, isGlobalConfigPath, registerSite, resolveSiteTarget } from "../../../src/global-config.js";
+import { findGlobalConfig, globalEnvPath, isGlobalConfigPath, loadSiteConfig, registerSite, resolveSiteTarget } from "../../../src/global-config.js";
+import { deepMerge } from "../../../src/utils/merge.js";
 function isAbsoluteEndpoint(value) {
     return !!value && (value.startsWith('http://') || value.startsWith('https://'));
 }
@@ -30,6 +31,7 @@ export class ApibotConfigParser {
     config = null;
     configPath = null;
     site = null;
+    siteConfigPath = null;
     constructor() { }
     static getInstance() {
         if (!ApibotConfigParser.instance) {
@@ -76,19 +78,21 @@ export class ApibotConfigParser {
                     dirs: loadedConfig.dirs,
                 };
             }
-            this.config = this.mergeWithDefaults(loadedConfig);
-            this.applyEnvSpec(this.config.api);
-            this.applyEnvHeaders(this.config.api);
+            let config = this.mergeWithDefaults(loadedConfig);
+            this.applyEnvSpec(config.api);
+            this.applyEnvHeaders(config.api);
             if (options?.baseEndpoint)
-                this.config.api.baseEndpoint = options.baseEndpoint.replace(/\/$/, '');
-            await resolveConfigModels(this.config.ai);
-            resolveLangfuse(this.config.ai);
-            this.configPath = resolvedPath;
+                config.api.baseEndpoint = options.baseEndpoint.replace(/\/$/, '');
+            await resolveConfigModels(config.ai);
+            resolveLangfuse(config.ai);
             this.site = null;
+            this.siteConfigPath = null;
             if (isGlobalConfigPath(resolvedPath)) {
-                this.enterGlobalMode(this.config, options?.endpoint);
+                config = await this.enterGlobalMode(config, options?.endpoint);
             }
-            this.validateConfig(this.config);
+            this.validateConfig(config);
+            this.config = config;
+            this.configPath = resolvedPath;
             setOutputDir(this.getOutputDir());
             return this.config;
         }
@@ -106,6 +110,9 @@ export class ApibotConfigParser {
     getConfigPath() {
         return this.configPath;
     }
+    getSiteConfigPath() {
+        return this.siteConfigPath;
+    }
     getOutputDir() {
         const config = this.getConfig();
         return path.join(this.getProjectRoot(), config.dirs?.output || 'output');
@@ -168,16 +175,27 @@ export class ApibotConfigParser {
             return;
         api.headers = { ...api.headers, ...parseHeaders(process.env.EXPLORBOT_API_HEADERS) };
     }
-    enterGlobalMode(config, endpoint) {
+    async enterGlobalMode(config, endpoint) {
         const site = resolveSiteTarget(endpoint);
         this.site = registerSite(site.baseUrl);
+        const { path, config: siteConfig } = await loadSiteConfig(this.site.dir, site.baseUrl);
+        this.siteConfigPath = path;
+        const overrides = {};
+        if (siteConfig.ai)
+            overrides.ai = siteConfig.ai;
+        if (siteConfig.api)
+            overrides.api = siteConfig.api;
+        const merged = deepMerge(config, overrides);
+        await resolveConfigModels(merged.ai);
+        resolveLangfuse(merged.ai);
         let baseEndpoint = site.baseUrl;
         const envUrl = process.env.EXPLORBOT_URL;
         if (envUrl && URL.parse(envUrl)?.origin === site.baseUrl)
             baseEndpoint = envUrl.replace(/\/$/, '');
-        config.dirs = { output: 'output', knowledge: 'knowledge' };
-        config.api = { ...config.api, baseEndpoint };
+        merged.dirs = { output: 'output', knowledge: 'knowledge' };
+        merged.api = { ...merged.api, baseEndpoint };
         materializeKnowledge(this.site.dir);
+        return merged;
     }
     async loadEnvConfig() {
         const provider = process.env.EXPLORBOT_AI_PROVIDER;
@@ -261,18 +279,6 @@ export class ApibotConfigParser {
         }
     }
     mergeWithDefaults(config) {
-        return this.deepMerge({ dirs: { output: 'output' }, api: {} }, config);
-    }
-    deepMerge(target, source) {
-        const result = { ...target };
-        for (const key in source) {
-            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key]) && source[key].constructor === Object) {
-                result[key] = this.deepMerge(result[key] || {}, source[key]);
-            }
-            else {
-                result[key] = source[key];
-            }
-        }
-        return result;
+        return deepMerge({ dirs: { output: 'output' }, api: {} }, config);
     }
 }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",

package/dist/src/ai/fisherman/tools.js

@@ -196,13 +196,19 @@ export function createAskApiTool(fisherman, task) {
     return {
         askApi: tool({
             description: dedent `
-        Ask what data already exists, changing nothing.
-        Ask a question about existing records: which ones are there, what they are called, whether a particular one exists.
-        Use it before precondition() to see whether suitable data is already available, and whenever a step needs the exact name or id of a record that is already there.
+        Read the app's data over the API, changing nothing.
+        Answers questions about records: which ones are there, what they are called, whether a particular one exists.
+
+        Use it to:
+        - check whether suitable data already exists, before precondition() creates any
+        - get the exact name or id of a record a step must act on
+        - find out whether an action was stored, when the app reported success but the page does not show the result
+        - find out whether data exists at all, when a list or dropdown is empty
+
         It never creates, edits or deletes anything — precondition() does that.
       `,
             inputSchema: z.object({
-                question: z.string().describe('What to find out about data that already exists'),
+                question: z.string().describe('What to find out about the data'),
             }),
             execute: async ({ question }) => {
                 tag('info').log(`Ask API: ${question}`);

package/dist/src/ai/pilot.js

@@ -922,14 +922,14 @@ export class Pilot {
         const lines = [];
         for (const [assertion, passed] of Object.entries(currentState.verifications ?? {})) {
             if (passed)
-                lines.push(`state verification (passed): ${assertion}`);
+                lines.push(`verify: ${assertion}`);
         }
         for (const exec of testerConversation.getToolExecutions()) {
             if (!EVIDENCE_TOOLS.includes(exec.toolName) || !exec.wasSuccessful)
                 continue;
             const description = exec.input?.assertion || exec.input?.request || truncateJson(exec.input);
-            const result = exec.output?.message || exec.output?.analysis || exec.output?.result;
-            lines.push(`CHECK ${exec.toolName} (executed successfully): ${description}${result ? ` -> ${result}` : ''}`);
+            const analysis = exec.output?.analysis;
+            lines.push(`${exec.toolName}: ${description}${analysis ? ` -> ${analysis}` : ''}`);
         }
         return [...new Set(lines)].join('\n');
     }
@@ -1053,9 +1053,14 @@ export class Pilot {
 
       YOUR Pilot-only tools, both over the API:
 
-      askApi(question) — ask what data already exists. It changes nothing. Use it to check whether
-      suitable data is already there before creating any, and to get the exact name or id of an existing
-      record a step must act on.
+      askApi(question) — read the app's data over the API. It changes nothing. Use when:
+
+      - Before precondition() — check whether suitable data already exists.
+      - A step needs the exact name or id of an existing record.
+      - The app reported success but the page does not show the result — ask whether it was stored.
+      - A list or dropdown is empty — ask whether the data exists at all.
+
+      The page is not the only witness. A record missing from the page may still exist.
 
       precondition(description) — create FRESH disposable test data. Never request users. Use when:
 

package/dist/src/ai/tools.js

@@ -1202,7 +1202,8 @@ async function extractWebElements(error) {
 function formatElementList(matched) {
     if (!matched)
         return 'Could not fetch element details. Repeat the action to get better info.';
-    return matched
+    const keys = matched.map((el) => `${el.text}::${el.visible}::${el.html}`);
+    const list = matched
         .map((el, i) => {
         const lines = [`Element ${i + 1}:`, `Text: "${el.text}"`];
         if (el.visible !== undefined)
@@ -1210,10 +1211,16 @@ function formatElementList(matched) {
         const wrapped = matched.map((_, j) => j).filter((j) => j !== i && matched[j].xpath.startsWith(`${el.xpath}/`));
         if (wrapped.length)
             lines.push(`Wraps: element ${wrapped.map((j) => j + 1).join(', ')}`);
+        const same = keys.map((_, j) => j).filter((j) => j !== i && keys[j] === keys[i]);
+        if (same.length)
+            lines.push(`Identical to element ${same.map((j) => j + 1).join(', ')}`);
         lines.push(`XPath: ${el.xpath}`, `HTML: ${el.html}`);
         return lines.join('\n');
     })
         .join('\n\n');
+    if (new Set(keys).size === matched.length)
+        return list;
+    return `${list}\n\nIdentical matches are not told apart by their number — picking one is a guess. Click the one you mean by appearance with visualClick().`;
 }
 export async function formatMatchedElements(error) {
     return formatElementList(await extractWebElements(error));

package/dist/src/commands/config-command.d.ts

@@ -15,11 +15,13 @@ export declare class ConfigCommand extends BaseCommand {
 }
 interface ConfigSummaryOptions {
     configPath?: string | null;
+    siteConfigPath?: string | null;
     root?: string;
     json?: boolean;
 }
 export interface ConfigData {
     config: string;
+    siteConfig: string;
     url: string;
     browser: string;
     headless: boolean;

package/dist/src/commands/config-command.js

@@ -13,7 +13,7 @@ export class ConfigCommand extends BaseCommand {
     description = 'Show models, config file and paths used by this run';
     async execute() {
         const parser = ConfigParser.getInstance();
-        tag('info').log(ConfigCommand.render(this.explorBot.getConfig(), { configPath: parser.getConfigPath(), root: parser.getProjectRoot() }));
+        tag('info').log(ConfigCommand.render(this.explorBot.getConfig(), { configPath: parser.getConfigPath(), siteConfigPath: parser.getSiteConfigPath(), root: parser.getProjectRoot() }));
     }
     static async summary(options = {}) {
         const parser = ConfigParser.getInstance();
@@ -24,12 +24,15 @@ export class ConfigCommand extends BaseCommand {
                 throw error;
             return load(site.url);
         });
-        return ConfigCommand.render(config, { configPath: parser.getConfigPath(), root: parser.getProjectRoot(), json: options.json });
+        return ConfigCommand.render(config, { configPath: parser.getConfigPath(), siteConfigPath: parser.getSiteConfigPath(), root: parser.getProjectRoot(), json: options.json });
     }
     static data(config, options = {}) {
         let configPath = '';
         if (options.configPath && existsSync(options.configPath))
             configPath = options.configPath;
+        let siteConfigPath = '';
+        if (options.siteConfigPath && existsSync(options.siteConfigPath))
+            siteConfigPath = options.siteConfigPath;
         const dirs = {};
         if (options.root) {
             for (const [name, dir] of Object.entries({ output: 'output', ...config.dirs })) {
@@ -55,6 +58,7 @@ export class ConfigCommand extends BaseCommand {
         }
         return {
             config: configPath,
+            siteConfig: siteConfigPath,
             url: config.playwright?.url || config.web?.url || config.api?.baseEndpoint || '',
             browser: config.playwright?.browser || '',
             headless: !config.playwright?.show,
@@ -75,6 +79,8 @@ export class ConfigCommand extends BaseCommand {
         const lines = [];
         const section = (title, entries) => lines.push(...renderSection(title, entries));
         const general = [['config', data.config || 'EXPLORBOT_* environment variables']];
+        if (data.siteConfig)
+            general.push(['site config', data.siteConfig]);
         if (data.url)
             general.push(['url', data.url]);
         if (data.browser) {

package/dist/src/commands/init-command.js

@@ -6,10 +6,7 @@ import { findGlobalConfig, globalConfigPath, globalDir, globalEnvPath } from "..
 import { getCliName } from "../utils/cli-name.js";
 import { log, tag } from '../utils/logger.js';
 import { relativeToCwd } from "../utils/next-steps.js";
-function defaultConfigTemplate(provider, esm) {
-    let moduleExport = 'module.exports = config;';
-    if (esm)
-        moduleExport = 'export default config;';
+function defaultConfigTemplate(provider) {
     return `// 'provider/model-id' uses a bundled provider.
 // It is also possible to import provider as a module from Vercel AI SDK.
 // https://github.com/testomatio/explorbot/blob/main/docs/basics/providers.md
@@ -34,7 +31,7 @@ ${modelLines(provider)}
   },
 };
 
-${moduleExport}
+export default config;
 `;
 }
 export function envTemplate(provider) {
@@ -128,8 +125,7 @@ export function runInitCommand(options) {
             log('Use --force to overwrite existing file');
             process.exit(1);
         }
-        const esm = extname(outPath) !== '.js' || isModuleProject(dirname(outPath));
-        writeFileSync(outPath, defaultConfigTemplate(provider, esm), 'utf8');
+        writeFileSync(outPath, defaultConfigTemplate(provider), 'utf8');
         log(`Created config file: ${relativeToCwd(outPath)}`);
         const envPath = resolve(process.cwd(), '.env');
         if (!existsSync(envPath)) {
@@ -234,6 +230,8 @@ export function modelLines(provider, only) {
 function globalConfigTemplate(provider) {
     const { envKey } = PROVIDERS[provider];
     return `// Global Explorbot configuration — used by every directory without its own explorbot.config.js.
+// Settings shared by every site. Each site extends them in
+// ~/.explorbot/sites/<host>/explorbot.config.js, written on its first run.
 // Models are written as 'provider/model-id' so they resolve without a local node_modules.
 // The key is read from ${envKey} in ~/.explorbot/.env
 // Model ids are snapshotted from the recommendations of this Explorbot version.
@@ -251,27 +249,9 @@ ${modelLines(provider)}
   },
 };
 
-module.exports = config;
+export default config;
 `;
 }
-function isModuleProject(configDir) {
-    let currentDir = resolve(configDir);
-    while (true) {
-        const packagePath = join(currentDir, 'package.json');
-        if (existsSync(packagePath)) {
-            try {
-                return JSON.parse(readFileSync(packagePath, 'utf8')).type === 'module';
-            }
-            catch {
-                return false;
-            }
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir)
-            return false;
-        currentDir = parentDir;
-    }
-}
 function writeEnvKey(key, value) {
     const envPath = globalEnvPath();
     let content = '# AI provider API keys';

package/dist/src/commands/sites-command.js

@@ -1,4 +1,4 @@
-import { listSites, sitesDir } from '../global-config.js';
+import { findSiteConfig, listSites, sitesDir } from '../global-config.js';
 import { getCliName } from '../utils/cli-name.js';
 import { tag } from '../utils/logger.js';
 import { BaseCommand } from './base-command.js';
@@ -16,6 +16,11 @@ export class SitesCommand extends BaseCommand {
         tag('info').log(`Registered sites (${sites.length}):`);
         for (const site of sites) {
             tag('info').log(`  ${site.folder.padEnd(width)}  ${site.url}  last run ${site.lastRunAt.slice(0, 16).replace('T', ' ')}`);
+            let config = 'inherits global config';
+            const sitePath = findSiteConfig(site.dir);
+            if (sitePath)
+                config = sitePath;
+            tag('info').log(`  ${' '.repeat(width)}  ${config}`);
         }
         tag('info').log('');
         tag('info').log(`Stored in ${sitesDir()}`);

package/dist/src/config.d.ts

@@ -1,4 +1,4 @@
-import { type SiteRecord } from './global-config.js';
+import { EXPLORBOT_CONFIG_PATHS, type SiteRecord } from './global-config.js';
 export declare const PROVIDERS: Record<string, ProviderInfo>;
 export declare const MODEL_ROLES: ModelRole[];
 interface PlaywrightConfig {
@@ -224,7 +224,7 @@ interface ExplorbotConfig {
     dynamicPageRegex?: string;
 }
 type RuleEntry = string | Record<string, string>;
-export declare const EXPLORBOT_CONFIG_PATHS: string[];
+export { EXPLORBOT_CONFIG_PATHS };
 export declare const EXPLORBOT_ENV_VARS: EnvVar[];
 export type { ExplorbotConfig, PlaywrightConfig, AIConfig, HtmlConfig, ActionConfig, AgentConfig, AgentsConfig, HistorianAgentConfig, ResearcherAgentConfig, NavigatorAgentConfig, PlannerAgentConfig, ScoutAgentConfig, RerunnerAgentConfig, HealRecipe, Hook, HookConfig, HooksConfig, PlaywrightHook, CodeceptJSHook, HookPatternMap, RuleEntry, ReporterConfig, ApiConfig, WebConfig, ApiHookFn, };
 export declare class ConfigParser {
@@ -235,6 +235,7 @@ export declare class ConfigParser {
     runtimeTarget: string | null;
     site: SiteRecord | null;
     siteStartPath: string;
+    siteConfigPath: string | null;
     constructor();
     static loadEnv(filePath: string, keepExisting?: boolean): void;
     static recommendedModels(): Record<string, Record<string, string>>;
@@ -252,6 +253,7 @@ export declare class ConfigParser {
     resolveProjectDir(relativeDir: string): string;
     isGlobalMode(): boolean;
     getSite(): SiteRecord | null;
+    getSiteConfigPath(): string | null;
     resolveTargetPath(target?: string): string;
     getStatesDir(): string;
     getPlansDir(): string;
@@ -260,7 +262,7 @@ export declare class ConfigParser {
     static setupTestConfig(): void;
     static getTestDirectories(): string[];
     static cleanupAllTestDirectories(): void;
-    enterGlobalMode(config: ExplorbotConfig, target: string | null): void;
+    enterGlobalMode(config: ExplorbotConfig, target: string | null): Promise<ExplorbotConfig>;
     applyEnvSpec(config: ExplorbotConfig): void;
     buildEnvConfig(baseUrl: string | undefined, outputRoot: string): Promise<ExplorbotConfig>;
     findConfigFile(): string | null;
@@ -271,7 +273,6 @@ export declare class ConfigParser {
     validateConfig(config: ExplorbotConfig): void;
     getNestedValue(obj: any, path: string): any;
     mergeWithDefaults(config: Partial<ExplorbotConfig>): ExplorbotConfig;
-    deepMerge(target: any, source: any): any;
     ensureDirectory(path: string): void;
 }
 export declare function setOutputDir(dir: string): void;

package/dist/src/config.js

@@ -13,8 +13,9 @@ import { pathToFileURL } from 'node:url';
 import { parseEnv } from 'node:util';
 import dedent from 'dedent';
 import matter from 'gray-matter';
-import { findGlobalConfig, globalEnvPath, isGlobalConfigPath, registerSite, resolveSiteTarget } from './global-config.js';
+import { EXPLORBOT_CONFIG_PATHS, findGlobalConfig, globalEnvPath, isGlobalConfigPath, loadSiteConfig, registerSite, resolveSiteTarget } from './global-config.js';
 import { getCliName } from './utils/cli-name.js';
+import { deepMerge } from './utils/merge.js';
 import { log, tag } from './utils/logger.js';
 export const PROVIDERS = {
     openai: { envKey: 'OPENAI_API_KEY', load: async () => (await import('@ai-sdk/openai')).createOpenAI() },
@@ -37,7 +38,7 @@ const config = {
         model: null,
     },
 };
-export const EXPLORBOT_CONFIG_PATHS = ['explorbot.config.js', 'explorbot.config.mjs', 'explorbot.config.ts'];
+export { EXPLORBOT_CONFIG_PATHS };
 export const EXPLORBOT_ENV_VARS = [
     { name: 'EXPLORBOT_AI_PROVIDER', required: true, description: 'Provider name; fills every model role from its recommended models. Turns on config-free mode' },
     { name: 'EXPLORBOT_AI_MODEL', description: 'Pins the main model — a model id for the provider, or a standalone provider/model-id' },
@@ -62,6 +63,7 @@ export class ConfigParser {
     runtimeTarget = null;
     site = null;
     siteStartPath = '/';
+    siteConfigPath = null;
     constructor() { }
     static loadEnv(filePath, keepExisting = false) {
         const resolved = resolve(filePath);
@@ -125,14 +127,16 @@ export class ConfigParser {
                 sourcePath = join(outputRoot, 'explorbot.config.js');
                 log(`Configuration built from EXPLORBOT_* environment variables. Output: ${outputRoot}`);
             }
-            this.config = this.resolveConfig(loadedConfig, options);
-            await resolveConfigModels(this.config.ai);
-            this.runtimeTarget = target;
-            this.configPath = sourcePath;
+            let config = this.resolveConfig(loadedConfig, options);
+            await resolveConfigModels(config.ai);
             this.site = null;
+            this.siteConfigPath = null;
             if (resolvedPath && isGlobalConfigPath(resolvedPath)) {
-                this.enterGlobalMode(this.config, target);
+                config = await this.enterGlobalMode(config, target);
             }
+            this.config = config;
+            this.runtimeTarget = target;
+            this.configPath = sourcePath;
             this.applyEnvSpec(this.config);
             // Restore original directory after successful config load
             if (options?.path && originalCwd !== process.cwd()) {
@@ -186,6 +190,9 @@ export class ConfigParser {
     getSite() {
         return this.site;
     }
+    getSiteConfigPath() {
+        return this.siteConfigPath;
+    }
     resolveTargetPath(target) {
         if (!this.site) {
             const configured = this.config?.playwright?.url || this.config?.web?.url;
@@ -222,6 +229,7 @@ export class ConfigParser {
             ConfigParser.instance.runtimeTarget = null;
             ConfigParser.instance.site = null;
             ConfigParser.instance.siteStartPath = '/';
+            ConfigParser.instance.siteConfigPath = null;
         }
     }
     // For testing purposes only - sets up minimal default config
@@ -269,14 +277,20 @@ export class ConfigParser {
             // Ignore cleanup errors
         }
     }
-    enterGlobalMode(config, target) {
+    async enterGlobalMode(config, target) {
         const site = resolveSiteTarget(target || undefined, config.web?.url || config.playwright?.url);
         this.site = registerSite(site.baseUrl);
         this.siteStartPath = site.path;
-        config.dirs = { knowledge: 'knowledge', experience: 'experience', output: 'output' };
-        config.playwright = { ...config.playwright, browser: config.playwright?.browser || 'chromium', url: site.baseUrl };
+        const { path: sitePath, config: siteConfig } = await loadSiteConfig(this.site.dir, site.baseUrl);
+        this.siteConfigPath = sitePath;
+        const merged = deepMerge(config, siteConfig);
+        await resolveConfigModels(merged.ai);
+        resolveLangfuse(merged.ai);
+        merged.dirs = { knowledge: 'knowledge', experience: 'experience', output: 'output' };
+        merged.playwright = { ...merged.playwright, browser: merged.playwright?.browser || 'chromium', url: site.baseUrl };
         materializeKnowledge(this.site.dir);
         log(`Global mode: ${site.baseUrl} stored in ${this.site.dir}`);
+        return merged;
     }
     applyEnvSpec(config) {
         const spec = process.env.EXPLORBOT_SPEC;
@@ -414,19 +428,7 @@ export class ConfigParser {
                 output: 'output',
             },
         };
-        return this.deepMerge(defaults, config);
-    }
-    deepMerge(target, source) {
-        const result = { ...target };
-        for (const key in source) {
-            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key]) && source[key].constructor === Object) {
-                result[key] = this.deepMerge(result[key] || {}, source[key]);
-            }
-            else {
-                result[key] = source[key];
-            }
-        }
-        return result;
+        return deepMerge(defaults, config);
     }
     ensureDirectory(path) {
         if (!existsSync(path)) {