explorbot 0.4.9 → 0.5.0

package/src/test-plan.ts

@@ -1,13 +1,15 @@
 import { createHash } from 'node:crypto';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 import figures from 'figures';
 import type { ActionResult } from './action-result.ts';
 import { listSitePlanDirs } from './global-config.ts';
 import { WebPageState } from './state-manager.ts';
-import { tag } from './utils/logger.ts';
+import { createDebug, pluralize, tag } from './utils/logger.ts';
+import { truncateMiddle } from './utils/strings.ts';
 import { parsePlanFromMarkdown, planToAiContext, savePlanToMarkdown, savePlansToMarkdown } from './utils/test-plan-markdown.ts';
 import { uniqSessionName } from './utils/unique-names.ts';
+import { extractStatePath } from './utils/url-matcher.ts';
 
 export const TestResult = {
   PASSED: 'passed',
@@ -241,6 +243,7 @@ export class Test extends Task {
   endTime?: number;
   resetCount = 0;
   appliedExperience: AppliedExperience[] = [];
+  preparedData: string[] = [];
 
   constructor(scenario: string, priority: 'critical' | 'important' | 'high' | 'normal' | 'low', expectedOutcome: string | string[], startUrl: string, plannedSteps: string[] = []) {
     super(scenario, startUrl);
@@ -477,6 +480,39 @@ export class Plan {
 
   updateStatus(): void {}
 
+  static listFiles(plansDir: string): PlanFile[] {
+    if (!existsSync(plansDir)) return [];
+
+    const files = readdirSync(plansDir)
+      .filter((file) => file.endsWith('.md'))
+      .map((file) => {
+        const filePath = path.join(plansDir, file);
+        const modifiedAt = statSync(filePath).mtimeMs;
+        const plan = readPlanFile(filePath, modifiedAt);
+        return {
+          name: file,
+          path: filePath,
+          modifiedAt,
+          title: plan.title,
+          url: extractStatePath(plan.startUrl || ''),
+          testCount: plan.tests.length,
+          label: '',
+        };
+      })
+      .sort((left, right) => right.modifiedAt - left.modifiedAt);
+
+    if (files.length === 0) return files;
+
+    const nameWidth = Math.min(MAX_PLAN_NAME_WIDTH, Math.max(...files.map((file) => file.name.length)));
+    const urlWidth = Math.min(MAX_PLAN_URL_WIDTH, Math.max(...files.map((file) => file.url.length)));
+    for (const file of files) {
+      const name = truncateMiddle(file.name, nameWidth).padEnd(nameWidth);
+      const url = truncateMiddle(file.url, urlWidth).padEnd(urlWidth);
+      file.label = `${name}  ${url}  ${file.testCount} ${pluralize(file.testCount, 'test')}`;
+    }
+    return files;
+  }
+
   static resolveFile(file: string, plansDir?: string): string | null {
     const names = [file];
     if (!file.endsWith('.md')) names.push(`${file}.md`);
@@ -579,3 +615,32 @@ interface AppliedExperience {
   url: string;
   content: string;
 }
+
+export interface PlanFile {
+  name: string;
+  path: string;
+  modifiedAt: number;
+  title: string;
+  url: string;
+  testCount: number;
+  label: string;
+}
+
+const debugLog = createDebug('explorbot:test-plan');
+const MAX_PLAN_NAME_WIDTH = 38;
+const MAX_PLAN_URL_WIDTH = 26;
+const planFileCache = new Map<string, { modifiedAt: number; plan: Plan }>();
+
+function readPlanFile(filePath: string, modifiedAt: number): Plan {
+  const cached = planFileCache.get(filePath);
+  if (cached?.modifiedAt === modifiedAt) return cached.plan;
+
+  let plan = new Plan(path.basename(filePath));
+  try {
+    plan = parsePlanFromMarkdown(filePath);
+  } catch (error) {
+    debugLog(`Failed to read plan file ${filePath}:`, error);
+  }
+  planFileCache.set(filePath, { modifiedAt, plan });
+  return plan;
+}

package/src/utils/aria-ref.ts

@@ -1,6 +1,6 @@
 import { WebElement } from './web-element.ts';
 
-const REF_LINE_PATTERN = /^(\s*)-\s+(\w+)\s*(?:"([^"]*)")?.*?\[ref=(e\d+)\]/;
+const REF_LINE_PATTERN = /^(\s*)-\s+(\w+)\s*(?:"([^"]*)")?.*?\[ref=((?:f\d+)?e\d+)\]/;
 const ARIA_REF_PATTERN = /^(f\d+)?e\d+$/i;
 
 const REF_ROLES: Record<string, string> = { a: 'link', button: 'button', select: 'combobox', textarea: 'textbox' };

package/src/utils/logger.ts

@@ -103,7 +103,12 @@ class ConsoleDestination implements LogDestination {
     if (entry.type === 'debug') return;
     if (entry.type === 'html') return;
     if (entry.type === 'operation' && !this.verboseMode) return;
-    if (entry.type === 'step' && !this.verboseMode && this.recentSteps.shouldSuppress(entry.content)) return;
+    if (entry.type === 'step' && !this.verboseMode) {
+      const step = entry.originalArgs?.[0];
+      const error = entry.originalArgs?.[1];
+      if (error || step?.failed === true || step?.status === 'failed') return;
+      if (this.recentSteps.shouldSuppress(entry.content)) return;
+    }
     let content = entry.content;
     if (entry.type === 'multiline' || entry.type === 'details') {
       const cleaned = stripAnsi(dedent(entry.content));
@@ -215,7 +220,7 @@ class SpanDestination implements LogDestination {
     if (!step?.toCode) {
       return;
     }
-    const stepName = step?.name ? `I.${step.name}` : 'I.step';
+    const stepName = step?.title ? `I.${step.title}` : 'I.step';
     const stepInput = typeof step?.toCode === 'function' ? step.toCode() : entry.content;
     const errorFromStep = step?.error;
     const errorMessage =

package/src/utils/markdown-query.ts

@@ -1,519 +1 @@
-import { type Token, type Tokens, marked } from 'marked';
-
-export type SelectorType = 'section' | 'section1' | 'section2' | 'section3' | 'section4' | 'section5' | 'section6' | 'table' | 'heading' | 'paragraph' | 'list' | 'item' | 'code' | 'blockquote' | 'hr' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
-
-export interface TextMatcher {
-  mode: 'exact' | 'contains' | 'regex';
-  value: string;
-  negated: boolean;
-}
-
-export interface QuerySegment {
-  selector: SelectorType;
-  textMatch?: TextMatcher;
-  index: number | null;
-  slice: { from?: number; to?: number } | null;
-}
-
-export interface MatchedRange {
-  token: Token;
-  start: number;
-  length: number;
-  innerTokens?: MatchedRange[];
-}
-
-export function parseQuery(input: string): QuerySegment[] {
-  const segments: QuerySegment[] = [];
-  let pos = 0;
-
-  function peek(): string {
-    return pos < input.length ? input[pos] : '';
-  }
-
-  function advance(): string {
-    return input[pos++] || '';
-  }
-
-  function skipWhitespace() {
-    while (pos < input.length && /\s/.test(input[pos])) pos++;
-  }
-
-  function readIdentifier(): string {
-    const start = pos;
-    while (pos < input.length && /[a-zA-Z_\d]/.test(input[pos])) pos++;
-    return input.slice(start, pos);
-  }
-
-  function readQuotedString(): string {
-    const quote = advance();
-    let result = '';
-    while (pos < input.length && input[pos] !== quote) {
-      if (input[pos] === '\\') {
-        pos++;
-        result += input[pos] || '';
-      } else {
-        result += input[pos];
-      }
-      pos++;
-    }
-    if (pos < input.length) pos++;
-    return result;
-  }
-
-  function readUntilAny(chars: string): string {
-    const start = pos;
-    while (pos < input.length && !chars.includes(input[pos])) pos++;
-    return input.slice(start, pos);
-  }
-
-  function parseTextMatcher(): TextMatcher {
-    let negated = false;
-    if (peek() === '!') {
-      negated = true;
-      advance();
-    }
-
-    if (peek() === '~') {
-      advance();
-      const value = readQuotedString();
-      return { mode: 'contains', value, negated };
-    }
-
-    if (peek() === '/') {
-      advance();
-      let value = '';
-      while (pos < input.length && input[pos] !== '/') {
-        value += input[pos];
-        pos++;
-      }
-      if (pos < input.length) pos++;
-      while (pos < input.length && /[gimsuy]/.test(input[pos])) pos++;
-      return { mode: 'regex', value, negated };
-    }
-
-    const value = readQuotedString();
-    return { mode: 'exact', value, negated };
-  }
-
-  while (pos < input.length) {
-    skipWhitespace();
-    if (pos >= input.length) break;
-
-    const selector = readIdentifier();
-    if (!selector) {
-      pos++;
-      continue;
-    }
-
-    const segment: QuerySegment = {
-      selector: selector as SelectorType,
-      index: null,
-      slice: null,
-    };
-
-    if (peek() === '(') {
-      advance();
-      segment.textMatch = parseTextMatcher();
-      if (peek() === ')') advance();
-    }
-
-    while (peek() === '[') {
-      advance();
-      const content = readUntilAny(']');
-      if (/^-?\d*(:-?\d*)?$/.test(content) && content !== '') {
-        if (content.includes(':')) {
-          const colonIdx = content.indexOf(':');
-          const fromStr = content.slice(0, colonIdx);
-          const toStr = content.slice(colonIdx + 1);
-          segment.slice = {
-            from: fromStr ? Number.parseInt(fromStr, 10) : undefined,
-            to: toStr ? Number.parseInt(toStr, 10) : undefined,
-          };
-        } else {
-          segment.index = Number.parseInt(content, 10);
-        }
-      }
-      if (peek() === ']') advance();
-    }
-
-    segments.push(segment);
-  }
-
-  return segments;
-}
-
-function matchText(text: string, matcher: TextMatcher): boolean {
-  let result: boolean;
-
-  switch (matcher.mode) {
-    case 'exact':
-      result = text === matcher.value;
-      break;
-    case 'contains':
-      result = text.includes(matcher.value);
-      break;
-    case 'regex':
-      result = new RegExp(matcher.value, 'i').test(text);
-      break;
-    default:
-      result = false;
-  }
-
-  return matcher.negated ? !result : result;
-}
-
-function entryKey(line: string): string | null {
-  const separator = line.indexOf(':');
-  if (separator < 1) return null;
-  return line.slice(0, separator).trim().toLowerCase();
-}
-
-function getTokenText(token: Token): string {
-  const t = token as any;
-  switch (token.type) {
-    case 'heading':
-    case 'paragraph':
-    case 'code':
-    case 'blockquote':
-    case 'list_item':
-      return t.text || '';
-    case 'table':
-      return (t.header || []).map((h: any) => h.text).join(', ');
-    default:
-      return '';
-  }
-}
-
-function getHeadingDepth(selector: string): number | null {
-  const match = selector.match(/^h([1-6])$/);
-  return match ? Number.parseInt(match[1], 10) : null;
-}
-
-function isSectionSelector(selector: string): boolean {
-  return /^section\d?$/.test(selector);
-}
-
-function getSectionDepth(selector: string): number | null {
-  const match = selector.match(/^section([1-6])$/);
-  return match ? Number.parseInt(match[1], 10) : null;
-}
-
-function selectorToTokenType(selector: string): string | null {
-  if (/^h[1-6]$/.test(selector)) return 'heading';
-  const map: Record<string, string> = {
-    heading: 'heading',
-    paragraph: 'paragraph',
-    table: 'table',
-    code: 'code',
-    list: 'list',
-    blockquote: 'blockquote',
-    hr: 'hr',
-    item: 'list_item',
-  };
-  return map[selector] || null;
-}
-
-function buildTokenIndex(source: string): MatchedRange[] {
-  const tokens = marked.lexer(source);
-  const ranges: MatchedRange[] = [];
-  let offset = 0;
-
-  for (const token of tokens) {
-    const raw = (token as any).raw || '';
-    ranges.push({ token, start: offset, length: raw.length });
-    offset += raw.length;
-  }
-
-  return ranges;
-}
-
-function computeSections(candidates: MatchedRange[], segment: QuerySegment): MatchedRange[] {
-  const sectionDepth = getSectionDepth(segment.selector as string);
-  const sections: MatchedRange[] = [];
-
-  for (let i = 0; i < candidates.length; i++) {
-    const range = candidates[i];
-    if (range.token.type !== 'heading') continue;
-
-    const heading = range.token as Tokens.Heading;
-    if (sectionDepth !== null && heading.depth !== sectionDepth) continue;
-    if (segment.textMatch && !matchText(heading.text, segment.textMatch)) continue;
-
-    const depth = heading.depth;
-    const innerTokens: MatchedRange[] = [];
-    let endOffset = range.start + range.length;
-
-    for (let j = i + 1; j < candidates.length; j++) {
-      const nextRange = candidates[j];
-      if (nextRange.token.type === 'heading' && (nextRange.token as Tokens.Heading).depth <= depth) break;
-      innerTokens.push(nextRange);
-      endOffset = nextRange.start + nextRange.length;
-    }
-
-    sections.push({
-      token: range.token,
-      start: range.start,
-      length: endOffset - range.start,
-      innerTokens,
-    });
-  }
-
-  return sections;
-}
-
-function extractListItems(candidates: MatchedRange[]): MatchedRange[] {
-  const items: MatchedRange[] = [];
-
-  for (const range of candidates) {
-    if (range.token.type !== 'list') continue;
-
-    const list = range.token as Tokens.List;
-    const listRaw = (range.token as any).raw as string;
-    let searchFrom = 0;
-
-    for (const item of list.items) {
-      const itemRaw = (item as any).raw as string;
-      const idx = listRaw.indexOf(itemRaw, searchFrom);
-      if (idx === -1) continue;
-
-      items.push({
-        token: item as unknown as Token,
-        start: range.start + idx,
-        length: itemRaw.length,
-      });
-
-      searchFrom = idx + itemRaw.length;
-    }
-  }
-
-  return items;
-}
-
-function applyIndexSlice(matches: MatchedRange[], segment: QuerySegment): MatchedRange[] {
-  if (segment.index !== null) {
-    const idx = segment.index < 0 ? matches.length + segment.index : segment.index;
-    return idx >= 0 && idx < matches.length ? [matches[idx]] : [];
-  }
-
-  if (segment.slice) {
-    const { from, to } = segment.slice;
-    return matches.slice(from, to);
-  }
-
-  return matches;
-}
-
-function expandSectionRanges(matches: MatchedRange[]): MatchedRange[] {
-  let hasSection = false;
-  for (const m of matches) {
-    if (m.innerTokens) {
-      hasSection = true;
-      break;
-    }
-  }
-  if (!hasSection) return matches;
-
-  const expanded: MatchedRange[] = [];
-  for (const m of matches) {
-    if (m.innerTokens) {
-      expanded.push({ token: m.token, start: m.start, length: ((m.token as any).raw || '').length });
-      expanded.push(...m.innerTokens);
-    } else {
-      expanded.push(m);
-    }
-  }
-  return expanded;
-}
-
-function executeSegments(candidates: MatchedRange[], segments: QuerySegment[]): MatchedRange[] {
-  if (segments.length === 0) return candidates;
-
-  const segment = segments[0];
-  const remaining = segments.slice(1);
-
-  if (isSectionSelector(segment.selector as string)) {
-    const sections = computeSections(candidates, segment);
-    const indexed = applyIndexSlice(sections, segment);
-
-    if (remaining.length === 0) return indexed;
-
-    const results: MatchedRange[] = [];
-    for (const section of indexed) {
-      results.push(...executeSegments(section.innerTokens || [], remaining));
-    }
-    return results;
-  }
-
-  if (segment.selector === 'item') {
-    let items = extractListItems(candidates);
-    if (segment.textMatch) {
-      items = items.filter((r) => matchText(getTokenText(r.token), segment.textMatch!));
-    }
-    return executeSegments(applyIndexSlice(items, segment), remaining);
-  }
-
-  const tokenType = selectorToTokenType(segment.selector as string);
-  if (!tokenType) return [];
-
-  let matches = candidates.filter((r) => r.token.type === tokenType);
-
-  const depth = getHeadingDepth(segment.selector as string);
-  if (depth !== null) {
-    matches = matches.filter((r) => (r.token as any).depth === depth);
-  }
-
-  if (segment.textMatch) {
-    matches = matches.filter((r) => matchText(getTokenText(r.token), segment.textMatch!));
-  }
-
-  return executeSegments(applyIndexSlice(matches, segment), remaining);
-}
-
-export class MarkdownQuery {
-  private source: string;
-  private matches: MatchedRange[];
-
-  constructor(source: string, matches?: MatchedRange[]) {
-    this.source = source;
-    this.matches = matches || buildTokenIndex(source);
-  }
-
-  query(selector: string): MarkdownQuery {
-    const segments = parseQuery(selector);
-    const candidates = expandSectionRanges(this.matches);
-    const results = executeSegments(candidates, segments);
-    return new MarkdownQuery(this.source, results);
-  }
-
-  text(): string {
-    return this.matches.map((r) => this.source.slice(r.start, r.start + r.length)).join('');
-  }
-
-  get(): string {
-    return this.text();
-  }
-
-  toJson(): Record<string, string>[] {
-    const results: Record<string, string>[] = [];
-
-    for (const range of this.matches) {
-      if (range.token.type !== 'table') continue;
-
-      const table = range.token as Tokens.Table;
-      const headers = table.header.map((h) => h.text);
-      for (const row of table.rows) {
-        const obj: Record<string, string> = {};
-        for (let i = 0; i < headers.length; i++) {
-          obj[headers[i]] = row[i]?.text ?? '';
-        }
-        results.push(obj);
-      }
-    }
-
-    return results;
-  }
-
-  keyValue(): Record<string, string> {
-    const entries: Record<string, string> = {};
-
-    for (const range of this.matches) {
-      for (const line of getTokenText(range.token).split('\n')) {
-        const key = entryKey(line);
-        if (!key) continue;
-        const value = line.slice(line.indexOf(':') + 1).trim();
-        if (value) entries[key] = value;
-      }
-    }
-
-    return entries;
-  }
-
-  setKeyValue(key: string, value: string | null): string {
-    return this.replaceEach((match) => {
-      const token = match.matches[0].token;
-      const lines = getTokenText(token)
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean);
-
-      const index = lines.findIndex((line) => entryKey(line) === key.toLowerCase());
-      if (index < 0 && value) lines.push(`${key}: ${value}`);
-      if (index >= 0 && value) lines[index] = `${key}: ${value}`;
-      if (index >= 0 && !value) lines.splice(index, 1);
-
-      if (token.type !== 'blockquote') return lines.join('\n');
-      return lines.map((line) => `> ${line}`).join('\n');
-    });
-  }
-
-  replace(content: string): string {
-    return this.replaceEach(() => content);
-  }
-
-  replaceEach(replacer: (match: MarkdownQuery, index: number) => string): string {
-    const sorted = [...this.matches].sort((a, b) => a.start - b.start);
-
-    const kept: MatchedRange[] = [];
-    let lastEnd = -1;
-    for (const range of sorted) {
-      if (range.start < lastEnd) continue;
-      kept.push(range);
-      lastEnd = range.start + range.length;
-    }
-
-    const replacements = kept.map((range, index) => replacer(new MarkdownQuery(this.source, [range]), index));
-    let result = this.source;
-    for (let i = kept.length - 1; i >= 0; i--) {
-      const range = kept[i];
-      result = result.slice(0, range.start) + replacements[i] + result.slice(range.start + range.length);
-    }
-
-    return result;
-  }
-
-  count(): number {
-    return this.matches.length;
-  }
-
-  first(): MarkdownQuery {
-    return new MarkdownQuery(this.source, this.matches.slice(0, 1));
-  }
-
-  last(): MarkdownQuery {
-    return new MarkdownQuery(this.source, this.matches.slice(-1));
-  }
-
-  before(): MarkdownQuery {
-    if (this.matches.length === 0) return new MarkdownQuery(this.source, []);
-    const cutoff = this.matches[0].start;
-    const allTokens = buildTokenIndex(this.source);
-    const beforeTokens = allTokens.filter((r) => r.start + r.length <= cutoff);
-    return new MarkdownQuery(this.source, beforeTokens);
-  }
-
-  after(): MarkdownQuery {
-    if (this.matches.length === 0) return new MarkdownQuery(this.source, []);
-    const lastMatch = this.matches[this.matches.length - 1];
-    const cutoff = lastMatch.start + lastMatch.length;
-    const allTokens = buildTokenIndex(this.source);
-    const afterTokens = allTokens.filter((r) => r.start >= cutoff);
-    return new MarkdownQuery(this.source, afterTokens);
-  }
-
-  each(): MarkdownQuery[] {
-    return this.matches.map((m) => new MarkdownQuery(this.source, [m]));
-  }
-
-  meta(): Array<{ type: string; depth: number | null; text: string }> {
-    return this.matches.map((range) => {
-      const token = range.token as any;
-      let depth: number | null = null;
-      if (token.type === 'heading') depth = token.depth;
-      return { type: token.type, depth, text: getTokenText(range.token) };
-    });
-  }
-}
-
-export function mdq(source: string): MarkdownQuery {
-  return new MarkdownQuery(source);
-}
+export * from './mdq/query.ts';