explorbot 0.5.9 → 0.6.0

package/src/utils/logger.ts

@@ -4,8 +4,8 @@ import { type Span, context, trace } from '@opentelemetry/api';
 import chalk from 'chalk';
 import debug from 'debug';
 import dedent from 'dedent';
-import { marked } from 'marked';
 import stripAnsi from 'strip-ansi';
+import wrapAnsi from 'wrap-ansi';
 import { ConfigParser } from '../config.js';
 import { Observability } from '../observability.ts';
 import { RecentStepFilter } from './log-filters.ts';
@@ -81,6 +81,11 @@ class ConsoleDestination implements LogDestination {
   private forceEnabled = false;
   private quiet = false;
   private recentSteps = new RecentStepFilter();
+  private width: number;
+
+  constructor() {
+    this.width = process.stdout.columns || 80;
+  }
 
   isEnabled(): boolean {
     if (this.quiet) return false;
@@ -113,8 +118,8 @@ class ConsoleDestination implements LogDestination {
     if (entry.type === 'multiline' || entry.type === 'details') {
       const cleaned = stripAnsi(dedent(entry.content));
       const parsed = parseMarkdownToTerminal(cleaned);
-      content = parsed;
-      content = `${chalk.gray(content)}\n`;
+
+      content = `${chalk.dim('\n ┌'.padEnd(this.width, '─'))}\n${this.prefixLines(parsed, ' │ ', chalk.dim, false)}\n`;
     } else if (entry.type === 'success') {
       content = `${chalk.green(content)}\n`;
     } else if (entry.type === 'error') {
@@ -122,14 +127,32 @@ class ConsoleDestination implements LogDestination {
     } else if (entry.type === 'warning') {
       content = chalk.yellow(content);
     } else if (entry.type === 'step') {
-      content = chalk.gray(`   ${content}`);
+      content = this.prefixLines(content, '   ', chalk.gray);
     } else if (entry.type === 'operation') {
-      content = chalk.gray(`   · ${content}`);
+      content = this.prefixLines(content, '   · ', chalk.gray);
     } else if (entry.type === 'substep') {
-      content = chalk.gray(`   > ${content}`);
+      content = this.prefixLines(content, '   > ', chalk.gray);
     }
     console.log(content);
   }
+
+  private prefixLines(content: string, prefix: string, style: (s: string) => string, strip = true): string {
+    const prefixWidth = stripAnsi(prefix).length;
+    const available = Math.max(20, this.width - prefixWidth);
+    const lines = content
+      .split('\n')
+      .filter((line) => stripAnsi(line).trim() !== '')
+      .flatMap((line) => {
+        const text = strip ? stripAnsi(line) : line;
+        const wrapped = wrapAnsi(text, available, { hard: true });
+        return wrapped.split('\n').map((part) => style(`${prefix}${part}`));
+      });
+    if (lines.length > 10) {
+      const remaining = lines.length - 10;
+      return [...lines.slice(0, 10), chalk.gray(` │ --- +${remaining} lines ---`)].join('\n');
+    }
+    return lines.join('\n');
+  }
 }
 
 class DebugDestination implements LogDestination {
@@ -160,16 +183,11 @@ class DebugDestination implements LogDestination {
 class FileDestination implements LogDestination {
   private initialized = false;
   private logFilePath: string | null = null;
-  private verboseMode = true;
 
   isEnabled(): boolean {
     return true;
   }
 
-  setVerboseMode(enabled: boolean): void {
-    this.verboseMode = enabled;
-  }
-
   write(entry: TaggedLogEntry): void {
     if (entry.type === 'html') return;
     if (entry.type === 'multiline') return;
@@ -404,7 +422,7 @@ class Logger {
   private truncateTagContent(content: string, tagName: string): string {
     const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     const tagRegex = new RegExp(`<${escapedTag}>([\\s\\S]*?)<\\/${escapedTag}>`, 'g');
-    return content.replace(tagRegex, (match, innerContent) => {
+    return content.replace(tagRegex, (_, innerContent) => {
       const trimmed = innerContent.trim();
       const totalLength = trimmed.length;
       if (totalLength <= 100) {

package/src/utils/markdown-terminal.ts

@@ -24,10 +24,9 @@ if (renderer) {
     const originalListitem = renderer.listitem;
     renderer.listitem = function (text: any) {
       if (typeof text === 'object') {
-        const item = text;
         const parser = this.parser;
         const originalParse = parser.parse.bind(parser);
-        parser.parse = (tokens: any, loose?: boolean) => parser.parseInline(tokens);
+        parser.parse = (tokens: any) => parser.parseInline(tokens);
         const result = originalListitem.call(this, text);
         parser.parse = originalParse;
         return result;

package/src/utils/next-steps.ts

@@ -1,4 +1,6 @@
 import path from 'node:path';
+import chalk from 'chalk';
+import figures from 'figures';
 import { tag } from './logger.js';
 
 export interface NextStepCommand {
@@ -20,27 +22,27 @@ export function relativeToCwd(absPath: string): string {
 export function printNextSteps(sections: NextStepSection[]): void {
   if (sections.length === 0) return;
 
-  const blocks: string[] = [];
+  const lines: string[] = [''];
+  let isDefault = true;
   for (const section of sections) {
-    const lines: string[] = [];
     const headerPath = section.path ? relativeToCwd(section.path) : '';
-    lines.push(headerPath ? `${section.label}: ${headerPath}` : section.label);
-
-    const commands = section.commands || [];
-    if (commands.length > 0) {
-      const labeled = commands.filter((c) => c.label);
-      const maxLabel = labeled.length > 0 ? Math.max(...labeled.map((c) => c.label.length)) : 0;
-      for (const cmd of commands) {
-        if (!cmd.label) {
-          lines.push(`  ${cmd.command}`);
-          continue;
-        }
-        const padded = `${cmd.label}:`.padEnd(maxLabel + 2);
-        lines.push(`  ${padded} ${cmd.command}`);
+    lines.push(headerPath ? `${chalk.bold(section.label)}  ${chalk.gray(headerPath)}` : `${chalk.bold(section.label)}`);
+
+    for (const cmd of section.commands || []) {
+      if (cmd.label) lines.push(BLANK);
+      if (isDefault) {
+        if (cmd.label) lines.push(chalk.bold.yellow(`${figures.pointer} ${cmd.label}`));
+        lines.push(chalk.bold(`    ${cmd.command}`));
+        isDefault = false;
+        continue;
       }
+      if (cmd.label) lines.push(chalk.dim(`  ${cmd.label}`));
+      lines.push(`  ${cmd.command}`);
     }
-    blocks.push(lines.join('\n'));
+    lines.push(BLANK);
   }
 
-  tag('multiline').log(blocks.join('\n\n'), { maxLines: 18 });
+  tag('info').log(lines.join('\n'));
 }
+
+const BLANK = ' ';

package/src/utils/page-readiness.ts

@@ -1,11 +1,33 @@
-export async function waitForPageReadiness(page: any, options: PageReadinessOptions = {}): Promise<void> {
-  if (!page) return;
+export async function waitForPageReadiness(page: any, options: PageReadinessOptions = {}): Promise<boolean> {
+  if (!page) return false;
 
   const timeout = options.timeout ?? 6000;
   await page.waitForLoadState?.('domcontentloaded', { timeout })?.catch(() => {});
 
   await Promise.race([waitForNetworkIdle(page, timeout), waitForDomQuiet(page, timeout), waitForVisibleSpinnersHidden(page, options.spinnerSelectors || [], timeout), sleep(timeout)]).catch(() => {});
-  await waitForPageBodyContent(page, timeout);
+  return waitForPageBodyContent(page, timeout);
+}
+
+export function waitForDomChange(page: any, timeout: number): Promise<boolean> {
+  if (!page?.evaluate) return Promise.resolve(false);
+
+  return page
+    .evaluate(
+      (ms: number) =>
+        new Promise<boolean>((resolve) => {
+          const observer = new MutationObserver(() => {
+            observer.disconnect();
+            resolve(true);
+          });
+          observer.observe(document, { subtree: true, childList: true, attributes: true, characterData: true });
+          setTimeout(() => {
+            observer.disconnect();
+            resolve(false);
+          }, ms);
+        }),
+      timeout
+    )
+    .catch(() => true);
 }
 
 const DOM_QUIET_MS = 350;
@@ -56,20 +78,24 @@ async function waitForVisibleSpinnersHidden(page: any, selectors: string[], time
   return Promise.all(visibleSpinners.map((locator) => locator.waitFor({ state: 'hidden', timeout }).catch(() => {}))).then(() => {});
 }
 
-function waitForPageBodyContent(page: any, timeout: number): Promise<void> {
-  if (!page?.waitForFunction) return Promise.resolve();
+function waitForPageBodyContent(page: any, timeout: number): Promise<boolean> {
+  if (!page?.waitForFunction) return Promise.resolve(true);
 
   return page
     .waitForFunction(
       () => {
         const body = document.body;
         if (!body) return false;
-        return body.children.length > 0 || body.textContent?.trim().length > 0;
+        if (body.innerText.trim().length > 0) return true;
+        return !!body.querySelector('input, button, select, textarea, img, svg, canvas, iframe, video');
       },
       undefined,
       { timeout }
     )
-    .catch(() => {});
+    .then(
+      () => true,
+      () => false
+    );
 }
 
 export function sleep(ms: number): Promise<void> {

package/src/utils/test-plan-markdown.ts

@@ -3,6 +3,7 @@ import { type Note, Plan, Test } from '../test-plan.ts';
 import { mdq } from './markdown-query.ts';
 
 const NOISE_PREFIXES = ['Test started', 'Finish requested:', 'Session name:'];
+const CURRENT_PAGE = 'Current page';
 
 function isNoiseNote(message: string): boolean {
   return NOISE_PREFIXES.some((prefix) => message.startsWith(prefix));
@@ -118,7 +119,10 @@ export function parsePlanFromMarkdown(filePath: string): Plan {
 }
 
 export function parsePlansFromMarkdown(filePath: string): Plan[] {
-  const content = readFileSync(filePath, 'utf-8');
+  return parsePlansFromMarkdownText(readFileSync(filePath, 'utf-8'));
+}
+
+export function parsePlansFromMarkdownText(content: string): Plan[] {
   const lines = content.split('\n');
 
   const plans: Plan[] = [];
@@ -193,7 +197,7 @@ export function parsePlansFromMarkdown(filePath: string): Plan[] {
     }
 
     if (currentTest && inRequirements && line && !line.startsWith('##')) {
-      currentTest.startUrl = line;
+      if (line !== CURRENT_PAGE) currentTest.startUrl = line;
       continue;
     }
 
@@ -217,7 +221,7 @@ export function parsePlansFromMarkdown(filePath: string): Plan[] {
     if (suiteStart === -1) continue;
     const nextSuite = content.indexOf('<!-- suite -->', suiteStart + 1);
     const suiteContent = nextSuite === -1 ? content.slice(suiteStart) : content.slice(suiteStart, nextSuite);
-    const firstItem = mdq(suiteContent).query('section[0] item[0]').text().trim();
+    const firstItem = mdq(suiteContent).query('section[0] item[0]').nodes()[0]?.text.trim() || '';
     const urlMatch = firstItem.match(/^URL:\s*(.+)/);
     if (urlMatch) {
       plan.url = urlMatch[1].replace(/\*\*|`|\*|_|~~?/g, '').trim();
@@ -230,6 +234,34 @@ export function parsePlansFromMarkdown(filePath: string): Plan[] {
   return plans;
 }
 
+export function findPlanMarkdownProblems(markdown: string): string[] {
+  const doc = mdq(markdown);
+  const problems: string[] = [];
+  const headings = doc.query('h1').nodes();
+  if (!doc.query('comment(/^suite/)').exists() || headings.length === 0) {
+    problems.push('Missing <!-- suite --> comment followed by the plan name heading');
+  }
+
+  const scenarioCount = Math.max(headings.length - 1, 0);
+  const testComments = doc.query('comment(/^test/)').count();
+  if (testComments !== scenarioCount) {
+    problems.push(`Found ${scenarioCount} scenario headings but ${testComments} <!-- test --> comments`);
+  }
+
+  for (const section of doc.query('section1').each().slice(1)) {
+    const title = section.query('heading').nodes()[0]?.text;
+    if (!section.query('section2("Steps") item').exists()) problems.push(`Scenario "${title}" has no ## Steps items`);
+    if (!section.query('section2("Expected") item').exists()) problems.push(`Scenario "${title}" has no ## Expected items`);
+  }
+  return problems;
+}
+
+export function readPlanMarkdownComment(markdown: string, key: string): string | null {
+  const body = mdq(markdown).query(`comment(/^${key}:/)`).nodes()[0]?.text;
+  if (!body) return null;
+  return body.slice(key.length + 1).trim() || null;
+}
+
 function formatPlanSuite(plan: Plan): string {
   let content = `<!-- suite -->\n# ${plan.title}\n\n`;
 
@@ -245,7 +277,7 @@ function formatPlanSuite(plan: Plan): string {
     content += `<!-- test\npriority: ${test.priority}\n-->\n`;
     content += `# ${test.scenario}\n\n`;
     content += '## Requirements\n';
-    content += `${test.startUrl || 'Current page'}\n\n`;
+    content += `${test.startUrl || CURRENT_PAGE}\n\n`;
 
     if (test.plannedSteps.length > 0) {
       content += '## Steps\n';

package/src/utils/url-matcher.ts

@@ -44,6 +44,12 @@ export function isSamePageFamily(urlA: string, urlB: string): boolean {
   return true;
 }
 
+export function isSamePageIgnoringQuery(urlA: string, urlB: string): boolean {
+  const a = new URL(urlA, 'http://localhost');
+  const b = new URL(urlB, 'http://localhost');
+  return a.pathname === b.pathname && a.hash === b.hash;
+}
+
 export function generalizeSegment(segment: string): string {
   if (/^\d+$/.test(segment)) return '\\d+';
   if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(segment)) return '[a-f0-9-]+';