explorbot 0.4.9 → 0.5.0

package/dist/src/test-plan.d.ts

@@ -96,6 +96,7 @@ export declare class Test extends Task {
     endTime?: number;
     resetCount: number;
     appliedExperience: AppliedExperience[];
+    preparedData: string[];
     constructor(scenario: string, priority: 'critical' | 'important' | 'high' | 'normal' | 'low', expectedOutcome: string | string[], startUrl: string, plannedSteps?: string[]);
     getVisitedUrls({ localOnly }?: {
         localOnly?: boolean;
@@ -147,6 +148,7 @@ export declare class Plan {
     get allSuccessful(): boolean;
     get allFailed(): boolean;
     updateStatus(): void;
+    static listFiles(plansDir: string): PlanFile[];
     static resolveFile(file: string, plansDir?: string): string | null;
     static loadFromFile(file: string, plansDir?: string): Plan | null;
     static fromMarkdown(filePath: string): Plan;
@@ -178,4 +180,13 @@ interface AppliedExperience {
     url: string;
     content: string;
 }
+export interface PlanFile {
+    name: string;
+    path: string;
+    modifiedAt: number;
+    title: string;
+    url: string;
+    testCount: number;
+    label: string;
+}
 export {};

package/dist/src/test-plan.js

@@ -1,10 +1,12 @@
 import { createHash } from 'node:crypto';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { listSitePlanDirs } from "./global-config.js";
-import { tag } from "./utils/logger.js";
+import { createDebug, pluralize, tag } from "./utils/logger.js";
+import { truncateMiddle } from "./utils/strings.js";
 import { parsePlanFromMarkdown, planToAiContext, savePlanToMarkdown, savePlansToMarkdown } from "./utils/test-plan-markdown.js";
 import { uniqSessionName } from "./utils/unique-names.js";
+import { extractStatePath } from "./utils/url-matcher.js";
 export const TestResult = {
     PASSED: 'passed',
     FAILED: 'failed',
@@ -194,6 +196,7 @@ export class Test extends Task {
     endTime;
     resetCount = 0;
     appliedExperience = [];
+    preparedData = [];
     constructor(scenario, priority, expectedOutcome, startUrl, plannedSteps = []) {
         super(scenario, startUrl);
         this.scenario = scenario;
@@ -397,6 +400,37 @@ export class Plan {
         return this.tests.length > 0 && this.tests.every((test) => test.hasFailed);
     }
     updateStatus() { }
+    static listFiles(plansDir) {
+        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, plansDir) {
         const names = [file];
         if (!file.endsWith('.md'))
@@ -464,3 +498,21 @@ export class Plan {
         return planToAiContext(this, options);
     }
 }
+const debugLog = createDebug('explorbot:test-plan');
+const MAX_PLAN_NAME_WIDTH = 38;
+const MAX_PLAN_URL_WIDTH = 26;
+const planFileCache = new Map();
+function readPlanFile(filePath, modifiedAt) {
+    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/dist/src/utils/aria-ref.js

@@ -1,5 +1,5 @@
 import { WebElement } from "./web-element.js";
-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 = { a: 'link', button: 'button', select: 'combobox', textarea: 'textbox' };
 export function ariaRefSelector(ref) {

package/dist/src/utils/logger.js

@@ -75,8 +75,14 @@ class ConsoleDestination {
             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));
@@ -189,7 +195,7 @@ class SpanDestination {
         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 = stepError && typeof stepError === 'object' && 'message' in stepError && typeof stepError.message === 'string'

package/dist/src/utils/markdown-query.d.ts

@@ -1,48 +1 @@
-import { type Token } 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 declare function parseQuery(input: string): QuerySegment[];
-export declare class MarkdownQuery {
-    source: string;
-    matches: MatchedRange[];
-    constructor(source: string, matches?: MatchedRange[]);
-    query(selector: string): MarkdownQuery;
-    text(): string;
-    get(): string;
-    toJson(): Record<string, string>[];
-    keyValue(): Record<string, string>;
-    setKeyValue(key: string, value: string | null): string;
-    replace(content: string): string;
-    replaceEach(replacer: (match: MarkdownQuery, index: number) => string): string;
-    count(): number;
-    first(): MarkdownQuery;
-    last(): MarkdownQuery;
-    before(): MarkdownQuery;
-    after(): MarkdownQuery;
-    each(): MarkdownQuery[];
-    meta(): Array<{
-        type: string;
-        depth: number | null;
-        text: string;
-    }>;
-}
-export declare function mdq(source: string): MarkdownQuery;
+export * from './mdq/query.js';

package/dist/src/utils/markdown-query.js

@@ -1,444 +1 @@
-import { marked } from 'marked';
-export function parseQuery(input) {
-    const segments = [];
-    let pos = 0;
-    function peek() {
-        return pos < input.length ? input[pos] : '';
-    }
-    function advance() {
-        return input[pos++] || '';
-    }
-    function skipWhitespace() {
-        while (pos < input.length && /\s/.test(input[pos]))
-            pos++;
-    }
-    function readIdentifier() {
-        const start = pos;
-        while (pos < input.length && /[a-zA-Z_\d]/.test(input[pos]))
-            pos++;
-        return input.slice(start, pos);
-    }
-    function readQuotedString() {
-        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) {
-        const start = pos;
-        while (pos < input.length && !chars.includes(input[pos]))
-            pos++;
-        return input.slice(start, pos);
-    }
-    function parseTextMatcher() {
-        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 = {
-            selector: selector,
-            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, matcher) {
-    let result;
-    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) {
-    const separator = line.indexOf(':');
-    if (separator < 1)
-        return null;
-    return line.slice(0, separator).trim().toLowerCase();
-}
-function getTokenText(token) {
-    const t = token;
-    switch (token.type) {
-        case 'heading':
-        case 'paragraph':
-        case 'code':
-        case 'blockquote':
-        case 'list_item':
-            return t.text || '';
-        case 'table':
-            return (t.header || []).map((h) => h.text).join(', ');
-        default:
-            return '';
-    }
-}
-function getHeadingDepth(selector) {
-    const match = selector.match(/^h([1-6])$/);
-    return match ? Number.parseInt(match[1], 10) : null;
-}
-function isSectionSelector(selector) {
-    return /^section\d?$/.test(selector);
-}
-function getSectionDepth(selector) {
-    const match = selector.match(/^section([1-6])$/);
-    return match ? Number.parseInt(match[1], 10) : null;
-}
-function selectorToTokenType(selector) {
-    if (/^h[1-6]$/.test(selector))
-        return 'heading';
-    const map = {
-        heading: 'heading',
-        paragraph: 'paragraph',
-        table: 'table',
-        code: 'code',
-        list: 'list',
-        blockquote: 'blockquote',
-        hr: 'hr',
-        item: 'list_item',
-    };
-    return map[selector] || null;
-}
-function buildTokenIndex(source) {
-    const tokens = marked.lexer(source);
-    const ranges = [];
-    let offset = 0;
-    for (const token of tokens) {
-        const raw = token.raw || '';
-        ranges.push({ token, start: offset, length: raw.length });
-        offset += raw.length;
-    }
-    return ranges;
-}
-function computeSections(candidates, segment) {
-    const sectionDepth = getSectionDepth(segment.selector);
-    const sections = [];
-    for (let i = 0; i < candidates.length; i++) {
-        const range = candidates[i];
-        if (range.token.type !== 'heading')
-            continue;
-        const heading = range.token;
-        if (sectionDepth !== null && heading.depth !== sectionDepth)
-            continue;
-        if (segment.textMatch && !matchText(heading.text, segment.textMatch))
-            continue;
-        const depth = heading.depth;
-        const innerTokens = [];
-        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.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) {
-    const items = [];
-    for (const range of candidates) {
-        if (range.token.type !== 'list')
-            continue;
-        const list = range.token;
-        const listRaw = range.token.raw;
-        let searchFrom = 0;
-        for (const item of list.items) {
-            const itemRaw = item.raw;
-            const idx = listRaw.indexOf(itemRaw, searchFrom);
-            if (idx === -1)
-                continue;
-            items.push({
-                token: item,
-                start: range.start + idx,
-                length: itemRaw.length,
-            });
-            searchFrom = idx + itemRaw.length;
-        }
-    }
-    return items;
-}
-function applyIndexSlice(matches, segment) {
-    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) {
-    let hasSection = false;
-    for (const m of matches) {
-        if (m.innerTokens) {
-            hasSection = true;
-            break;
-        }
-    }
-    if (!hasSection)
-        return matches;
-    const expanded = [];
-    for (const m of matches) {
-        if (m.innerTokens) {
-            expanded.push({ token: m.token, start: m.start, length: (m.token.raw || '').length });
-            expanded.push(...m.innerTokens);
-        }
-        else {
-            expanded.push(m);
-        }
-    }
-    return expanded;
-}
-function executeSegments(candidates, segments) {
-    if (segments.length === 0)
-        return candidates;
-    const segment = segments[0];
-    const remaining = segments.slice(1);
-    if (isSectionSelector(segment.selector)) {
-        const sections = computeSections(candidates, segment);
-        const indexed = applyIndexSlice(sections, segment);
-        if (remaining.length === 0)
-            return indexed;
-        const results = [];
-        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);
-    if (!tokenType)
-        return [];
-    let matches = candidates.filter((r) => r.token.type === tokenType);
-    const depth = getHeadingDepth(segment.selector);
-    if (depth !== null) {
-        matches = matches.filter((r) => r.token.depth === depth);
-    }
-    if (segment.textMatch) {
-        matches = matches.filter((r) => matchText(getTokenText(r.token), segment.textMatch));
-    }
-    return executeSegments(applyIndexSlice(matches, segment), remaining);
-}
-export class MarkdownQuery {
-    source;
-    matches;
-    constructor(source, matches) {
-        this.source = source;
-        this.matches = matches || buildTokenIndex(source);
-    }
-    query(selector) {
-        const segments = parseQuery(selector);
-        const candidates = expandSectionRanges(this.matches);
-        const results = executeSegments(candidates, segments);
-        return new MarkdownQuery(this.source, results);
-    }
-    text() {
-        return this.matches.map((r) => this.source.slice(r.start, r.start + r.length)).join('');
-    }
-    get() {
-        return this.text();
-    }
-    toJson() {
-        const results = [];
-        for (const range of this.matches) {
-            if (range.token.type !== 'table')
-                continue;
-            const table = range.token;
-            const headers = table.header.map((h) => h.text);
-            for (const row of table.rows) {
-                const obj = {};
-                for (let i = 0; i < headers.length; i++) {
-                    obj[headers[i]] = row[i]?.text ?? '';
-                }
-                results.push(obj);
-            }
-        }
-        return results;
-    }
-    keyValue() {
-        const entries = {};
-        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, value) {
-        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) {
-        return this.replaceEach(() => content);
-    }
-    replaceEach(replacer) {
-        const sorted = [...this.matches].sort((a, b) => a.start - b.start);
-        const kept = [];
-        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() {
-        return this.matches.length;
-    }
-    first() {
-        return new MarkdownQuery(this.source, this.matches.slice(0, 1));
-    }
-    last() {
-        return new MarkdownQuery(this.source, this.matches.slice(-1));
-    }
-    before() {
-        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() {
-        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() {
-        return this.matches.map((m) => new MarkdownQuery(this.source, [m]));
-    }
-    meta() {
-        return this.matches.map((range) => {
-            const token = range.token;
-            let depth = null;
-            if (token.type === 'heading')
-                depth = token.depth;
-            return { type: token.type, depth, text: getTokenText(range.token) };
-        });
-    }
-}
-export function mdq(source) {
-    return new MarkdownQuery(source);
-}
+export * from "./mdq/query.js";

package/dist/src/utils/mdq/cli.d.ts

@@ -0,0 +1,6 @@
+export declare function runMdq(argv: string[], readStdin: StdinReader): Promise<CliResult>;
+export type StdinReader = () => Promise<string>;
+export interface CliResult {
+    output: string;
+    code: number;
+}