explorbot 0.0.1 → 0.1.0

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

@@ -0,0 +1,301 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Command } from 'commander';
+import { setPreserveConsoleLogs } from '../../../src/utils/logger.ts';
+import { getStyles } from './ai/chief/styles.ts';
+import { ApiBot, type ApibotOptions } from './apibot.ts';
+
+function buildOptions(options: any): ApibotOptions {
+  return {
+    verbose: options.verbose || options.debug,
+    config: options.config,
+    path: options.path,
+  };
+}
+
+function addCommonOptions(cmd: Command): Command {
+  return cmd.option('-v, --verbose', 'Enable verbose logging').option('--debug', 'Enable debug logging').option('-c, --config <path>', 'Path to configuration file').option('-p, --path <path>', 'Working directory path');
+}
+
+function selectTests(tests: any[], index?: string): any[] {
+  if (!index || index === '*' || index === 'all') {
+    return tests.filter((t) => t.status === 'pending');
+  }
+
+  const rangeMatch = index.match(/^(\d+)-(\d+)$/);
+  if (rangeMatch) {
+    const start = Number.parseInt(rangeMatch[1]) - 1;
+    const end = Number.parseInt(rangeMatch[2]);
+    return tests.slice(start, end);
+  }
+
+  if (index.includes(',')) {
+    const indices = index.split(',').map((i) => Number.parseInt(i.trim()) - 1);
+    return indices.map((i) => tests[i]).filter(Boolean);
+  }
+
+  const num = Number.parseInt(index);
+  if (!Number.isNaN(num) && tests[num - 1]) {
+    return [tests[num - 1]];
+  }
+
+  return tests.filter((t) => t.status === 'pending');
+}
+
+export function createApiCommands(name = 'api'): Command {
+  const cmd = new Command(name);
+  cmd.description('AI-powered API testing tool');
+
+  addCommonOptions(cmd.command('plan <endpoint>').description('Generate test plan for an API endpoint').option('--style <style>', 'Planning style: basename of a file in rules/chief/styles/').option('--fresh', 'Start planning from scratch')).action(async (endpoint, options) => {
+    setPreserveConsoleLogs(true);
+    try {
+      const bot = new ApiBot(buildOptions(options));
+      await bot.start();
+
+      await bot.plan(endpoint, { style: options.style, fresh: options.fresh });
+
+      const plan = bot.getCurrentPlan();
+      if (!plan?.tests.length) {
+        console.error('No test scenarios generated.');
+        process.exit(1);
+      }
+
+      console.log(`\nPlan: ${plan.title} (${plan.tests.length} tests)\n`);
+      plan.tests.forEach((test, i) => {
+        console.log(`  ${i + 1}. [${test.priority}] ${test.scenario}`);
+      });
+
+      const savedPath = bot.savePlan();
+      if (savedPath) {
+        console.log(`\nSaved to: ${savedPath}`);
+        console.log('\nRun tests:');
+        console.log(`  ${name} test ${savedPath} 1       # run first test`);
+        console.log(`  ${name} test ${savedPath} 1-3     # run tests 1 to 3`);
+        console.log(`  ${name} test ${savedPath} *       # run all tests`);
+      }
+
+      await bot.stop();
+      process.exit(0);
+    } catch (error) {
+      console.error('Failed:', error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+  addCommonOptions(cmd.command('test <planfile> [index]').description('Execute tests from a plan file. Index: 1, 1-3, *')).action(async (planfile, index, options) => {
+    setPreserveConsoleLogs(true);
+    try {
+      const bot = new ApiBot(buildOptions(options));
+      await bot.start();
+
+      const plan = bot.loadPlan(planfile);
+      console.log(`Plan loaded: "${plan.title}" (${plan.tests.length} tests)`);
+
+      const tests = selectTests(plan.tests, index);
+      console.log(`Running ${tests.length} test(s)\n`);
+
+      let passed = 0;
+      let failed = 0;
+
+      for (const test of tests) {
+        const specDefinition = bot.tryGetEndpointDefinition(test.startUrl);
+        const result = await bot.agentCurler().test(test, {
+          specDefinition,
+          baseEndpoint: bot.getConfig().api.baseEndpoint,
+          searchSpec: (query) => bot.searchSpec(query),
+        });
+        if (result.success) passed++;
+        else failed++;
+      }
+
+      bot.savePlan();
+
+      console.log(`\nResults: ${passed} passed, ${failed} failed out of ${tests.length}`);
+      await bot.stop();
+      process.exit(failed > 0 ? 1 : 0);
+    } catch (error) {
+      console.error('Failed:', error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+  addCommonOptions(cmd.command('explore <endpoint>').description('Full cycle: plan all styles, execute tests, re-plan')).action(async (endpoint, options) => {
+    setPreserveConsoleLogs(true);
+    try {
+      const bot = new ApiBot(buildOptions(options));
+      await bot.start();
+
+      const styles = Object.keys(getStyles());
+      let totalPassed = 0;
+      let totalFailed = 0;
+      let totalTests = 0;
+
+      for (const style of styles) {
+        console.log(`\n=== Style: ${style} ===\n`);
+
+        const plan = await bot.plan(endpoint, { style, fresh: true });
+        if (!plan?.tests.length) {
+          console.log(`No tests generated for style: ${style}`);
+          continue;
+        }
+
+        const pending = plan.getPendingTests();
+        for (const test of pending) {
+          const specDefinition = bot.tryGetEndpointDefinition(test.startUrl);
+          const result = await bot.agentCurler().test(test, {
+            specDefinition,
+            baseEndpoint: bot.getConfig().api.baseEndpoint,
+            searchSpec: (query) => bot.searchSpec(query),
+          });
+          totalTests++;
+          if (result.success) totalPassed++;
+          else totalFailed++;
+        }
+
+        bot.savePlan(`${endpoint.replace(/^\//, '').replace(/[^a-zA-Z0-9]/g, '_')}_${style}.md`);
+      }
+
+      console.log('\n=== Final Results ===');
+      console.log(`Total: ${totalTests} tests, ${totalPassed} passed, ${totalFailed} failed`);
+      await bot.stop();
+      process.exit(totalFailed > 0 ? 1 : 0);
+    } catch (error) {
+      console.error('Failed:', error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  });
+
+  cmd
+    .command('init')
+    .description('Initialize a new apibot project with configuration')
+    .option('-f, --force', 'Overwrite existing config file')
+    .option('-p, --path <path>', 'Working directory for initialization')
+    .action(async (options) => {
+      const originalCwd = process.cwd();
+      if (options.path) {
+        const resolvedPath = path.resolve(options.path);
+        fs.mkdirSync(resolvedPath, { recursive: true });
+        process.chdir(resolvedPath);
+        console.log(`Working in: ${resolvedPath}`);
+      }
+
+      const configPath = path.resolve('apibot.config.ts');
+
+      if (fs.existsSync(configPath) && !options.force) {
+        console.log(`Config file already exists: ${configPath}`);
+        console.log('Use --force to overwrite.');
+        process.exit(1);
+      }
+
+      const rl = await import('node:readline');
+      const iface = rl.createInterface({ input: process.stdin, output: process.stdout });
+      const ask = (q: string, fallback = ''): Promise<string> => new Promise((resolve) => iface.question(q, (a: string) => resolve(a.trim() || fallback)));
+
+      console.log('Apibot — API Testing Tool Setup\n');
+
+      const baseEndpoint = await ask('Base API endpoint (e.g., https://api.example.com/v1): ');
+      if (!baseEndpoint) {
+        console.error('Base endpoint is required.');
+        iface.close();
+        process.exit(1);
+      }
+
+      const spec = await ask('OpenAPI spec file or URL (e.g., openapi.yaml or https://.../ — or press Enter to skip): ');
+      const knowledge = await ask('Describe your API (auth method, data formats, special rules — or press Enter to skip): ');
+
+      iface.close();
+
+      const specLine = spec ? `\n    spec: ['${spec}'],` : '';
+
+      const configContent = `import { openai } from '@ai-sdk/openai';
+
+export default {
+  ai: {
+    model: openai('gpt-4o'),
+  },
+  api: {
+    baseEndpoint: '${baseEndpoint}',${specLine}
+    headers: {
+      // 'Authorization': 'Bearer <token>',
+    },
+    // bootstrap: async ({ headers, baseEndpoint }) => {
+    //   // Run before tests — e.g. obtain auth token
+    //   // Return headers to merge: { Authorization: 'Bearer ...' }
+    // },
+    // teardown: async ({ headers, baseEndpoint }) => {
+    //   // Run after tests — e.g. cleanup test data
+    // },
+  },
+  dirs: {
+    output: 'output',
+    knowledge: 'knowledge',
+  },
+};
+`;
+
+      fs.writeFileSync(configPath, configContent, 'utf8');
+      console.log(`\nCreated: ${configPath}`);
+
+      fs.mkdirSync('output', { recursive: true });
+      fs.mkdirSync('knowledge', { recursive: true });
+
+      if (knowledge) {
+        const knowledgePath = path.resolve('knowledge', 'general.md');
+        fs.writeFileSync(knowledgePath, `---\nendpoint: "*"\n---\n${knowledge}\n`, 'utf8');
+        console.log(`Created: ${knowledgePath}`);
+      }
+
+      console.log('\nNext steps:');
+      console.log('1. Edit apibot.config.ts — set your AI provider and API headers');
+      console.log(`2. Add API knowledge: ${name} know /users "CRUD endpoint for user management"`);
+      console.log(`3. Plan tests: ${name} plan /users`);
+
+      if (process.cwd() !== originalCwd) process.chdir(originalCwd);
+    });
+
+  cmd
+    .command('know <endpoint> [description]')
+    .alias('add-knowledge')
+    .description('Add API knowledge for an endpoint')
+    .option('-c, --config <path>', 'Path to configuration file')
+    .option('-p, --path <path>', 'Working directory path')
+    .action(async (endpoint, description, options) => {
+      if (!description) {
+        const rl = await import('node:readline');
+        const iface = rl.createInterface({ input: process.stdin, output: process.stdout });
+        description = await new Promise<string>((resolve) => iface.question(`Describe ${endpoint}: `, (a: string) => resolve(a.trim())));
+        iface.close();
+      }
+
+      if (!description) {
+        console.error('Description is required.');
+        process.exit(1);
+      }
+
+      let knowledgeDir = 'knowledge';
+      try {
+        const { ApibotConfigParser } = await import('./config.ts');
+        await ApibotConfigParser.getInstance().loadConfig({ config: options.config, path: options.path });
+        knowledgeDir = ApibotConfigParser.getInstance().getKnowledgeDir();
+      } catch {
+        if (options.path) knowledgeDir = path.join(path.resolve(options.path), 'knowledge');
+      }
+
+      fs.mkdirSync(knowledgeDir, { recursive: true });
+
+      const filename = endpoint.replace(/^\//, '').replace(/[^a-zA-Z0-9]/g, '_') || 'general';
+      const filePath = path.join(knowledgeDir, `${filename}.md`);
+
+      const content = `---\nendpoint: "${endpoint}"\n---\n${description}\n`;
+
+      if (fs.existsSync(filePath)) {
+        fs.appendFileSync(filePath, `\n---\n${description}\n`, 'utf8');
+        console.log(`Updated: ${filePath}`);
+      } else {
+        fs.writeFileSync(filePath, content, 'utf8');
+        console.log(`Created: ${filePath}`);
+      }
+    });
+
+  return cmd;
+}

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

@@ -0,0 +1,190 @@
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import path, { resolve } from 'node:path';
+import { parseEnv } from 'node:util';
+import { EXPLORBOT_CONFIG_PATHS, type AIConfig, type ApiConfig as BaseApiConfig, type ApiHookFn } from '../../../src/config.ts';
+
+export type { AIConfig };
+
+type HookFn = ApiHookFn;
+
+interface ApiConfig extends BaseApiConfig {
+  baseEndpoint: string;
+  specs?: string[];
+}
+
+interface ApibotConfig {
+  ai: AIConfig;
+  api: ApiConfig;
+  dirs?: {
+    output: string;
+    knowledge?: string;
+    styles?: string;
+  };
+}
+
+export class ApibotConfigParser {
+  private static instance: ApibotConfigParser;
+  private config: ApibotConfig | null = null;
+  private configPath: string | null = null;
+
+  private constructor() {}
+
+  static getInstance(): ApibotConfigParser {
+    if (!ApibotConfigParser.instance) {
+      ApibotConfigParser.instance = new ApibotConfigParser();
+    }
+    return ApibotConfigParser.instance;
+  }
+
+  static loadEnv(filePath: string): void {
+    const resolved = resolve(filePath);
+    if (!existsSync(resolved)) return;
+    Object.assign(process.env, parseEnv(readFileSync(resolved, 'utf8')));
+  }
+
+  async loadConfig(options?: { config?: string; path?: string }): Promise<ApibotConfig> {
+    if (this.config && !options?.config && !options?.path) return this.config;
+
+    const originalCwd = process.cwd();
+    if (options?.path) {
+      process.chdir(resolve(options.path));
+    }
+
+    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 {
+      const configModule = await this.loadConfigModule(resolvedPath);
+      let loadedConfig = configModule.default || configModule;
+
+      if (!loadedConfig) {
+        throw new Error('Configuration file is empty or invalid');
+      }
+
+      if (loadedConfig.playwright || loadedConfig.web) {
+        loadedConfig = {
+          ai: loadedConfig.ai,
+          api: loadedConfig.api || {},
+          dirs: loadedConfig.dirs,
+        };
+      }
+
+      this.config = this.mergeWithDefaults(loadedConfig);
+      this.configPath = resolvedPath;
+      this.validateConfig(this.config);
+
+      return this.config;
+    } finally {
+      if (options?.path && originalCwd !== process.cwd()) {
+        process.chdir(originalCwd);
+      }
+    }
+  }
+
+  getConfig(): ApibotConfig {
+    if (!this.config) throw new Error('Configuration not loaded. Call loadConfig() first.');
+    return this.config;
+  }
+
+  getConfigPath(): string | null {
+    return this.configPath;
+  }
+
+  getOutputDir(): string {
+    const config = this.getConfig();
+    const configPath = this.getConfigPath();
+    if (!configPath) throw new Error('Config path not found');
+    return path.join(path.dirname(configPath), config.dirs?.output || 'output');
+  }
+
+  getPlansDir(): string {
+    return path.join(this.getOutputDir(), 'plans');
+  }
+
+  getRequestsDir(): string {
+    return path.join(this.getOutputDir(), 'requests');
+  }
+
+  getKnowledgeDir(): string {
+    const config = this.getConfig();
+    const configPath = this.getConfigPath();
+    if (!configPath) throw new Error('Config path not found');
+    return path.join(path.dirname(configPath), config.dirs?.knowledge || 'knowledge');
+  }
+
+  ensureDirectory(dirPath: string): void {
+    if (!existsSync(dirPath)) {
+      mkdirSync(dirPath, { recursive: true });
+    }
+  }
+
+  private findConfigFile(): string | null {
+    const apibotPaths = ['apibot.config.js', 'apibot.config.mjs', 'apibot.config.ts'];
+    for (const p of apibotPaths) {
+      const fullPath = resolve(process.cwd(), p);
+      if (existsSync(fullPath)) return fullPath;
+    }
+
+    for (const p of EXPLORBOT_CONFIG_PATHS) {
+      const fullPath = resolve(process.cwd(), p);
+      if (existsSync(fullPath)) return fullPath;
+    }
+
+    return null;
+  }
+
+  private async loadConfigModule(configPath: string): Promise<any> {
+    const ext = configPath.split('.').pop();
+
+    if (ext === 'ts') {
+      try {
+        return await import(configPath);
+      } catch {
+        const require = (await import('node:module')).createRequire(import.meta.url);
+        return require(configPath);
+      }
+    }
+
+    if (ext === 'js' || ext === 'mjs') {
+      return await import(configPath);
+    }
+
+    const content = readFileSync(configPath, 'utf8');
+    return JSON.parse(content);
+  }
+
+  private validateConfig(config: ApibotConfig): void {
+    if (!config.ai?.model) {
+      throw new Error('Missing required configuration: ai.model');
+    }
+    if (!config.api?.baseEndpoint) {
+      throw new Error('Missing required configuration: api.baseEndpoint');
+    }
+    if (config.api.specs && !config.api.spec) {
+      config.api.spec = config.api.specs;
+    }
+  }
+
+  private mergeWithDefaults(config: Partial<ApibotConfig>): ApibotConfig {
+    return this.deepMerge({ dirs: { output: 'output' } }, 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;
+  }
+}
+
+export type { ApibotConfig, ApiConfig, HookFn };

package/dist/bin/explorbot-cli.js

@@ -9,12 +9,14 @@ import { StatusPane } from '../src/components/StatusPane.js';
 import { ConfigParser } from '../src/config.js';
 import { ExplorBot } from '../src/explorbot.js';
 import { Stats } from '../src/stats.js';
-import { log, setPreserveConsoleLogs } from '../src/utils/logger.js';
-import { parseMarkdownToTerminal } from '../src/utils/markdown-terminal.js';
 import { Plan } from '../src/test-plan.js';
+import { getCliName } from "../src/utils/cli-name.js";
+import { log, setPreserveConsoleLogs } from '../src/utils/logger.js';
 import { jsonToTable } from '../src/utils/markdown-parser.js';
+import { parseMarkdownToTerminal } from '../src/utils/markdown-terminal.js';
 const program = new Command();
-program.name('explorbot').description('AI-powered web exploration tool');
+const cli = getCliName();
+program.name(cli).description('AI-powered web exploration tool');
 function buildExplorBotOptions(from, options) {
     return {
         from,
@@ -100,10 +102,11 @@ addCommonOptions(program.command('explore <path>').description('Start web explor
         await showStatsAndExit(1);
     }
 });
-addCommonOptions(program.command('plan <path> [feature]').description('Generate test plan for a page and exit'))
+addCommonOptions(program.command('plan <path>').description('Generate test plan for a page and exit'))
     .option('-a, --append', 'Add tests to existing plan file')
     .option('--style <style>', 'Planning style: normal, curious, psycho')
-    .action(async (planPath, feature, options) => {
+    .option('--focus <feature>', 'Focus area for test planning')
+    .action(async (planPath, options) => {
     try {
         const explorBot = new ExplorBot(buildExplorBotOptions(planPath, options));
         await explorBot.start();
@@ -115,7 +118,7 @@ addCommonOptions(program.command('plan <path> [feature]').description('Generate
                 explorBot.loadPlan(existingPlanPath);
             }
         }
-        await explorBot.plan(feature || undefined, {
+        await explorBot.plan(options.focus || undefined, {
             fresh: !options.append,
             style: options.style,
         });
@@ -131,9 +134,9 @@ addCommonOptions(program.command('plan <path> [feature]').description('Generate
         const cliSuffix = cliFlags ? ` ${cliFlags}` : '';
         const lines = [];
         lines.push('Run tests:');
-        lines.push(`\`explorbot test ${planFile} 1${cliSuffix}\` → run first test`);
-        lines.push(`\`explorbot test ${planFile} 1-3${cliSuffix}\` → run tests 1 to 3`);
-        lines.push(`\`explorbot test ${planFile} *${cliSuffix}\` → run all tests`);
+        lines.push(`\`${cli} test ${planFile} 1${cliSuffix}\` → run first test`);
+        lines.push(`\`${cli} test ${planFile} 1-3${cliSuffix}\` → run tests 1 to 3`);
+        lines.push(`\`${cli} test ${planFile} *${cliSuffix}\` → run all tests`);
         log(parseMarkdownToTerminal(lines.join('\n')));
         await explorBot.stop();
         await showStatsAndExit(0);
@@ -178,7 +181,7 @@ addCommonOptions(program.command('plan:load <planfile> [index]').description('Lo
                     lines.push(`- ${exp}`);
             }
             lines.push('');
-            lines.push(`Run: \`explorbot test ${planFile} ${idx}\``);
+            lines.push(`Run: \`${cli} test ${planFile} ${idx}\``);
             console.log(parseMarkdownToTerminal(lines.join('\n')));
             return;
         }
@@ -196,11 +199,11 @@ addCommonOptions(program.command('plan:load <planfile> [index]').description('Lo
         }));
         lines.push(jsonToTable(rows, ['#', 'Priority', 'Title', 'Steps', 'Expected']));
         lines.push('View test details:');
-        lines.push(`\`explorbot plan:load ${planFile} <index>\`\n`);
+        lines.push(`\`${cli} plan:load ${planFile} <index>\`\n`);
         lines.push('Run tests:');
-        lines.push(`\`explorbot test ${planFile} 1\` → run first test`);
-        lines.push(`\`explorbot test ${planFile} 1-3\` → run tests 1 to 3`);
-        lines.push(`\`explorbot test ${planFile} *\` → run all tests`);
+        lines.push(`\`${cli} test ${planFile} 1\` → run first test`);
+        lines.push(`\`${cli} test ${planFile} 1-3\` → run tests 1 to 3`);
+        lines.push(`\`${cli} test ${planFile} *\` → run all tests`);
         console.log(parseMarkdownToTerminal(lines.join('\n')));
     }
     catch (error) {
@@ -258,92 +261,12 @@ program
     .option('-f, --force', 'Overwrite existing config file')
     .option('-p, --path <path>', 'Working directory for initialization')
     .action(async (options) => {
-    const configPath = options.configPath || './explorbot.config.js';
-    const force = options.force || false;
-    const customPath = options.path;
-    const originalCwd = process.cwd();
-    if (customPath) {
-        const resolvedPath = path.resolve(customPath);
-        if (!fs.existsSync(resolvedPath)) {
-            fs.mkdirSync(resolvedPath, { recursive: true });
-            log(`Created directory: ${resolvedPath}`);
-        }
-        process.chdir(resolvedPath);
-        log(`Working in directory: ${resolvedPath}`);
-    }
-    const defaultConfig = `import { '<your provider here>' } from '<your provider package here>';
-
-// This example uses OpenRouter (one API key, many providers). Any Vercel AI SDK provider works; see
-// https://github.com/testomatio/explorbot/blob/main/docs/providers.md
-const openrouter = createOpenRouter({
-  apiKey: process.env.OPENROUTER_API_KEY,
-});
-
-const config = {
-  web: {
-    url: 'http://localhost:3000',
-  },
-
-  ai: {
-    model: '<your model here>',
-    visionModel: '<your vision model here>',
-    agenticModel: '<your agentic model here>',
-  },
-
-  reporter: {
-    enabled: true,
-  },
-
-  // api: {
-  //   baseEndpoint: 'http://localhost:3000/api',
-  //   spec: ['http://localhost:3000/api/openapi.json'],
-  //   headers: {
-  //     'Authorization': 'Bearer <token>',
-  //   },
-  // },
-};
-
-export default config;
-`;
-    try {
-        let resolvedPath = path.resolve(configPath);
-        if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
-            resolvedPath = path.join(resolvedPath, 'explorbot.config.js');
-        }
-        else if (!path.extname(resolvedPath)) {
-            resolvedPath = path.join(resolvedPath, 'explorbot.config.js');
-        }
-        const dir = path.dirname(resolvedPath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-            log(`Created directory: ${dir}`);
-        }
-        if (fs.existsSync(resolvedPath) && !force) {
-            log(`Config file already exists: ${resolvedPath}`);
-            log('Use --force to overwrite existing file');
-            process.exit(1);
-        }
-        fs.writeFileSync(resolvedPath, defaultConfig, 'utf8');
-        log(`Created config file: ${resolvedPath}`);
-        log('');
-        log('Next steps:');
-        log('1. Set your API key in the config file or as environment variable');
-        log('2. Customize the configuration as needed');
-        log('3. Run: explorbot start');
-        if (!fs.existsSync('./output')) {
-            fs.mkdirSync('./output', { recursive: true });
-            log('Created directory: ./output');
-        }
-    }
-    catch (error) {
-        log('Failed to create config file:', error);
-        process.exit(1);
-    }
-    finally {
-        if (process.cwd() !== originalCwd) {
-            process.chdir(originalCwd);
-        }
-    }
+    const { runInitCommand } = await import('../src/commands/init-command.js');
+    runInitCommand({
+        configPath: options.configPath,
+        force: options.force,
+        path: options.path,
+    });
 });
 program
     .command('clean [target]')
@@ -680,4 +603,3 @@ program
 import { createApiCommands } from "../boat/api-tester/src/cli.js";
 program.addCommand(createApiCommands('api'));
 program.parse();
-//# sourceMappingURL=explorbot-cli.js.map

package/dist/boat/api-tester/bin/apibot-cli.js

@@ -2,4 +2,3 @@
 import { createApiCommands } from "../src/cli.js";
 const program = createApiCommands('apibot');
 program.parse();
-//# sourceMappingURL=apibot-cli.js.map

package/dist/boat/api-tester/src/ai/chief/styles.js

@@ -10,4 +10,3 @@ export function getStyles() {
 export function getActiveStyle(iteration, override) {
     return RulesLoader.getActiveStyle(getStyles(), iteration, override);
 }
-//# sourceMappingURL=styles.js.map

package/dist/boat/api-tester/src/ai/chief.js

@@ -298,4 +298,3 @@ export class Chief extends ChiefBase {
     `;
     }
 }
-//# sourceMappingURL=chief.js.map