explorbot 0.1.0 → 0.1.1

package/src/utils/rules-loader.ts

@@ -65,29 +65,47 @@ export class RulesLoader {
     return { name, approach: styles[name] };
   }
 
-  static extractStyles(agentName: string, targetDir: string): string[] {
-    const sourceDir = join(BUILT_IN_DIR, agentName, 'styles');
-    if (!existsSync(sourceDir)) throw new Error(`No built-in styles found for agent: ${agentName}`);
+  static extractRules(agentName: string, targetDir: string): string[] {
+    const sourceDir = join(BUILT_IN_DIR, agentName);
+    if (!existsSync(sourceDir)) throw new Error(`No built-in rules found for agent: ${agentName}`);
 
+    const extracted: string[] = [];
+    copyMarkdownTree(sourceDir, targetDir, '', extracted);
+    return extracted;
+  }
+}
+
+function copyMarkdownTree(sourceDir: string, targetDir: string, relative: string, extracted: string[]): void {
+  const entries = readdirSync(sourceDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+
+  let dirCreated = false;
+  const ensureTargetDir = () => {
+    if (dirCreated) return;
     mkdirSync(targetDir, { recursive: true });
+    dirCreated = true;
+  };
 
-    const files = readdirSync(sourceDir)
-      .filter((f) => f.endsWith('.md'))
-      .sort();
-    const extracted: string[] = [];
+  for (const entry of entries) {
+    const sourcePath = join(sourceDir, entry.name);
+    const targetPath = join(targetDir, entry.name);
+    const relPath = relative ? `${relative}/${entry.name}` : entry.name;
 
-    for (const file of files) {
-      const target = join(targetDir, file);
-      if (existsSync(target)) {
-        tag('info').log(`Skipping ${file} (already exists)`);
-        continue;
-      }
-      writeFileSync(target, readFileSync(join(sourceDir, file), 'utf8'));
-      extracted.push(file);
-      tag('success').log(`Extracted ${file}`);
+    if (entry.isDirectory()) {
+      copyMarkdownTree(sourcePath, targetPath, relPath, extracted);
+      continue;
     }
 
-    return extracted;
+    if (!entry.name.endsWith('.md')) continue;
+
+    if (existsSync(targetPath)) {
+      tag('info').log(`Skipping ${relPath} (already exists)`);
+      continue;
+    }
+
+    ensureTargetDir();
+    writeFileSync(targetPath, readFileSync(sourcePath, 'utf8'));
+    extracted.push(relPath);
+    tag('success').log(`Extracted ${relPath}`);
   }
 }
 

package/src/utils/test-files.ts

@@ -0,0 +1,122 @@
+import { existsSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { highlight } from 'cli-highlight';
+import * as codeceptjs from 'codeceptjs';
+import store from 'codeceptjs/lib/store';
+import stepsListener from 'codeceptjs/lib/listener/steps';
+import storeListener from 'codeceptjs/lib/listener/store';
+import figureSet from 'figures';
+import { ConfigParser } from '../config.ts';
+
+export function loadTestSuites(testsDir: string): any[] {
+  if (!existsSync(testsDir)) return [];
+
+  const jsFiles = readdirSync(testsDir)
+    .filter((f) => f.endsWith('.js'))
+    .map((f) => path.resolve(testsDir, f));
+
+  if (jsFiles.length === 0) return [];
+
+  codeceptjs.container.createMocha();
+  const mocha = codeceptjs.container.mocha();
+  mocha.files = jsFiles;
+  mocha.loadFiles();
+
+  return mocha.suite.suites || [];
+}
+
+export function printTestList(suites: any[]): void {
+  if (suites.length === 0) {
+    console.log(chalk.yellow('No test files found. Run /explore first.'));
+    return;
+  }
+
+  let totalActive = 0;
+  let totalSkipped = 0;
+  let index = 0;
+
+  for (const suite of suites) {
+    const file = path.relative(process.cwd(), suite.file || '');
+    const active = suite.tests.filter((t: any) => !t.pending).length;
+    const skipped = suite.tests.filter((t: any) => t.pending).length;
+    totalActive += active;
+    totalSkipped += skipped;
+
+    console.log(`\n${chalk.bold.cyan(suite.title)}`);
+    console.log(chalk.gray(file));
+
+    for (const test of suite.tests) {
+      const idx = chalk.dim(`${++index}.`);
+      if (test.pending) {
+        console.log(chalk.gray(`  ${idx} ${figureSet.line} ${test.title} (skipped)`));
+      } else {
+        console.log(`  ${idx} ${chalk.green(figureSet.pointer)} ${test.title}`);
+      }
+    }
+  }
+
+  console.log(`\n${chalk.bold(`${totalActive + totalSkipped}`)} scenarios (${chalk.green(`${totalActive} active`)}, ${chalk.gray(`${totalSkipped} skipped`)})`);
+}
+
+export async function dryRunTestFile(filePath: string): Promise<void> {
+  const absPath = path.resolve(filePath);
+  if (!existsSync(absPath)) {
+    console.log(chalk.yellow(`File not found: ${absPath}`));
+    return;
+  }
+
+  const config = ConfigParser.getInstance().getConfig();
+  const configPath = ConfigParser.getInstance().getConfigPath();
+  const projectRoot = configPath ? path.dirname(configPath) : process.cwd();
+
+  const codeceptConfig = {
+    helpers: {
+      Playwright: { browser: config.playwright.browser, url: config.playwright.url },
+    },
+  };
+
+  (global as any).output_dir = path.join(projectRoot, 'output', 'states');
+  (global as any).codecept_dir = projectRoot;
+
+  codeceptjs.container.create(codeceptConfig, {});
+  await codeceptjs.recorder.start();
+  await codeceptjs.container.started(null);
+
+  store.dryRun = true;
+  (global as any).container = codeceptjs.container;
+  storeListener();
+  stepsListener();
+
+  codeceptjs.container.createMocha();
+  const mocha = codeceptjs.container.mocha();
+  mocha.reporter(class {});
+  mocha.files = [absPath];
+  mocha.loadFiles();
+
+  let currentSuite = '';
+
+  codeceptjs.event.dispatcher.on('suite.before', (suite: any) => {
+    if (suite.title && suite.title !== currentSuite) {
+      currentSuite = suite.title;
+      console.log(`\n${chalk.bold.cyan(suite.title)}`);
+      console.log(chalk.gray(path.relative(process.cwd(), suite.file || absPath)));
+    }
+  });
+
+  codeceptjs.event.dispatcher.on('test.before', (t: any) => {
+    console.log(`\n  ${chalk.green(figureSet.pointer)} ${chalk.bold(t.title)}`);
+  });
+
+  codeceptjs.event.dispatcher.on('step.start', (step: any) => {
+    const code = highlight(step.toCode(), { language: 'javascript' });
+    console.log(chalk.dim(`    ${code}`));
+  });
+
+  await new Promise<void>((resolve) => {
+    const runner = mocha.run(() => resolve());
+    runner.on('pending', (t: any) => {
+      console.log(chalk.gray(`  ${figureSet.line} ${t.title} (skipped)`));
+    });
+  });
+}