explorbot 0.1.31 → 0.1.32-beta.1

package/dist/src/ai/researcher/research-result.d.ts

@@ -0,0 +1,16 @@
+import type { Locator } from './locators.js';
+import { type ResearchSection } from './parser.js';
+export declare class ResearchResult {
+    text: string;
+    url: string;
+    createdAt: Date;
+    locators: Locator[];
+    constructor(text: string, url: string);
+    parseLocators(): void;
+    get containers(): string[];
+    get containerLocators(): Locator[];
+    updateSection(sectionName: string, locators: Locator[]): void;
+    rebuildSectionInText(section: ResearchSection): void;
+    cleanup(): void;
+    reorderColumns(columns: string[]): string[];
+}

package/dist/src/ai/researcher/sections.d.ts

@@ -0,0 +1,19 @@
+import type { ActionResult } from '../../action-result.js';
+import type Explorer from '../../explorer.js';
+import type { StateManager } from '../../state-manager.js';
+import type { Provider } from '../provider.js';
+import type { Constructor } from './mixin.js';
+export interface SectionMethods {
+    researchBySections(): Promise<string>;
+}
+export declare function WithSections<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        explorer: Explorer;
+        provider: Provider;
+        stateManager: StateManager;
+        actionResult: ActionResult | undefined;
+        researchBySections(): Promise<string>;
+        _detectFocusCss(): Promise<string | null>;
+        _researchSingleSection(name: string, description: string, ariaSnapshot: string, focusCss: string | null): Promise<string>;
+    };
+} & T;

package/dist/src/ai/rules.d.ts

@@ -0,0 +1,15 @@
+export declare const recommendedCodeceptCommands: readonly ["I.click", "I.type", "I.fillField", "I.see", "I.seeElement"];
+export declare const locatorRule: string;
+export declare const fileUploadRule: string;
+export declare const formRequirementsRule: string;
+export declare const protectionRule: string;
+export declare const dataProtectionRules: string;
+export declare const capabilityGroundingRule: string;
+export declare const focusedElementRule: string;
+export declare const unexpectedPopupRule: string;
+export declare const sectionContextRule: string;
+export declare function multipleTabsRule(tabs: Array<{
+    url: string;
+    title: string;
+}>): string;
+export declare const actionRule: string;

package/dist/src/ai/session-analyst.d.ts

@@ -0,0 +1,11 @@
+import type { Test } from '../test-plan.js';
+import type { Agent } from './agent.js';
+import type { Provider } from './provider.js';
+export declare class SessionAnalyst implements Agent {
+    emoji: string;
+    provider: Provider;
+    constructor(provider: Provider);
+    analyze(tests: Test[]): Promise<string>;
+    writeReport(markdown: string): string;
+    serializeTest(test: Test, ref: number): string;
+}

package/dist/src/ai/task-agent.d.ts

@@ -0,0 +1,28 @@
+import type { ActionResult } from '../action-result.js';
+import { type ExperienceTracker } from '../experience-tracker.js';
+import type { KnowledgeTracker } from '../knowledge-tracker.js';
+import { Historian } from './historian.js';
+import type { Navigator } from './navigator.js';
+import type { Provider } from './provider.js';
+import { Quartermaster } from './quartermaster.js';
+export declare function isInteractive(): boolean;
+export declare abstract class TaskAgent {
+    consecutiveFailures: number;
+    consecutiveEmptyResults: number;
+    recentToolCalls: any[];
+    readonly ACTION_TOOLS: string[];
+    _historian: Historian | null;
+    _quartermaster: Quartermaster | null;
+    abstract getNavigator(): Navigator;
+    abstract getExperienceTracker(): ExperienceTracker;
+    abstract getKnowledgeTracker(): KnowledgeTracker;
+    abstract getProvider(): Provider;
+    getKnowledge(actionResult: ActionResult): string;
+    getExperience(actionResult: ActionResult): string;
+    setHistorian(historian: Historian): void;
+    getHistorian(): Historian;
+    setQuartermaster(quartermaster: Quartermaster): void;
+    getQuartermaster(): Quartermaster;
+    trackToolExecutions(toolExecutions: any[]): void;
+    resetFailureCount(): void;
+}

package/dist/src/ai/tester.d.ts

@@ -0,0 +1,103 @@
+import { ActionResult } from '../action-result.js';
+import type { ExperienceTracker } from '../experience-tracker.js';
+import type Explorer from '../explorer.js';
+import { type Test } from '../test-plan.js';
+import { HooksRunner } from '../utils/hooks-runner.js';
+import type { Agent } from './agent.js';
+import type { Captain } from './captain.js';
+import type { Conversation } from './conversation.js';
+import { Navigator } from './navigator.js';
+import type { Pilot } from './pilot.js';
+import { Provider } from './provider.js';
+import { Researcher } from './researcher.js';
+import { TaskAgent } from './task-agent.js';
+export declare class Tester extends TaskAgent implements Agent {
+    readonly ACTION_TOOLS: string[];
+    readonly SPECIAL_CONTEXT_ACTION_TOOLS: string[];
+    emoji: string;
+    explorer: Explorer;
+    provider: Provider;
+    currentConversation: Conversation | null;
+    pilot: Pilot | null;
+    captain: Captain | null;
+    MAX_ITERATIONS: number;
+    MAX_EXTENSIONS: number;
+    ASSERTION_TOOLS: string[];
+    researcher: Researcher;
+    navigator: Navigator;
+    agentTools: any;
+    executionLogFile: string | null;
+    previousUrl: string | null;
+    previousStateHash: string | null;
+    pageStateHash: string | null;
+    pageActionResult: ActionResult | null;
+    hooksRunner: HooksRunner;
+    seenUiMapUrls: Set<string>;
+    lastAnalyzedStateHash: string | null;
+    stalledIterations: number;
+    readonly MAX_STALLED_ITERATIONS = 3;
+    constructor(explorer: Explorer, provider: Provider, researcher: Researcher, navigator: Navigator, agentTools?: any);
+    getNavigator(): Navigator;
+    getExperienceTracker(): ExperienceTracker;
+    getKnowledgeTracker(): import("../knowledge-tracker.js").KnowledgeTracker;
+    getProvider(): Provider;
+    setPilot(pilot: Pilot): void;
+    setCaptain(captain: Captain): void;
+    getCurrentState(): ActionResult;
+    get progressCheckInterval(): number;
+    getConversation(): Conversation | null;
+    test(task: Test): Promise<{
+        success: boolean;
+    }>;
+    runTestSession(task: Test, initialState: ActionResult, conversation: Conversation, handlers: TestSessionHandlers): Promise<{
+        success: boolean;
+    }>;
+    shouldAnalyzeProgress(iteration: number, currentState: ActionResult): boolean;
+    shouldStopForStalledExecution(task: Test, previousState: ActionResult, toolExecutions: any[]): boolean;
+    prepareInstructionsForNextStep(task: Test): Promise<string>;
+    reinjectContextIfNeeded(iteration: number, currentState: ActionResult): Promise<string>;
+    promptLogStep(task: Test): Promise<string>;
+    finishTest(task: Test): void;
+    abortStartedTestOnErrorPage(task: Test, actionResult: ActionResult): Promise<{
+        success: boolean;
+    }>;
+    buildStopTestMeta(task: Test): Record<string, string>;
+    getSystemMessage(): string;
+    buildScenarioBlock(task: Test, actionResult: ActionResult): string;
+    getDeletableSessionNames(task: Test): string[];
+    buildAvailableFiles(): string;
+    buildDeletionScope(task: Test): string;
+    createTestFlowTools(task: Test, currentState: ActionResult, conversation: Conversation): {
+        reset: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            reason?: string;
+        }, any, import("@ai-sdk/provider-utils").Context>>;
+        stop: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            reason: any;
+        }, {
+            success: boolean;
+            action: string;
+            message: any;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        finish: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+            verify: any;
+        }, {
+            success: boolean;
+            action: string;
+            message: any;
+        }, import("@ai-sdk/provider-utils").Context>>;
+        record: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<any, {
+            success: boolean;
+            action: string;
+            status: any;
+            message: string;
+            suggestion: string;
+        }, import("@ai-sdk/provider-utils").Context>>;
+    };
+    handleLoopError(task: Test, error: unknown): Promise<'continue' | 'stop'>;
+    shouldStopAfterStalledLoopError(task: Test): boolean;
+    cleanupStartedTest(task: Test): Promise<void>;
+}
+interface TestSessionHandlers {
+    offFailedRequest?: () => void;
+}
+export {};

package/dist/src/ai/tools.d.ts

@@ -0,0 +1,41 @@
+import { ActionResult } from '../action-result.js';
+import type { ExperienceTracker } from '../experience-tracker.js';
+import type Explorer from '../explorer.js';
+import { type Task } from '../test-plan.js';
+import { Navigator } from './navigator.js';
+import { Researcher } from './researcher.js';
+export declare const ASSERTION_TOOLS: readonly ["verify"];
+export declare function createCodeceptJSTools(explorer: Explorer, task: Task): {
+    click: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+        commands: any;
+        explanation: any;
+    }, Record<string, any>, import("@ai-sdk/provider-utils").Context>>;
+    hover: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+        commands: any;
+        explanation: any;
+    }, Record<string, any>, import("@ai-sdk/provider-utils").Context>>;
+    pressKey: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+        key: string;
+        explanation: string;
+        modifier?: string | string[];
+    }, Record<string, any>, import("@ai-sdk/provider-utils").Context>>;
+    form: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+        codeBlock: any;
+        explanation: any;
+    }, Record<string, any>, import("@ai-sdk/provider-utils").Context>>;
+};
+export declare function createSpecialContextTools(explorer: Explorer, context: 'iframe'): {
+    exitIframe?: undefined;
+} | {
+    exitIframe: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
+        reason?: string;
+    }, Record<string, any>, import("@ai-sdk/provider-utils").Context>>;
+};
+export declare function createAgentTools({ explorer, researcher, navigator, experienceTracker, getState, supervisor, }: {
+    explorer: Explorer;
+    researcher: Researcher;
+    navigator: Navigator;
+    experienceTracker?: ExperienceTracker;
+    getState?: () => ActionResult | null;
+    supervisor?: boolean;
+}): any;

package/dist/src/api/api-client.d.ts

@@ -0,0 +1,17 @@
+import { RequestResult } from './request-result.js';
+export declare class ApiClient {
+    baseEndpoint: string;
+    defaultHeaders: Record<string, string>;
+    constructor(baseEndpoint: string, defaultHeaders?: Record<string, string>);
+    setHeaders(headers: Record<string, string>): void;
+    getHeaders(): Record<string, string>;
+    getBaseEndpoint(): string;
+    request(opts: {
+        method: string;
+        path: string;
+        headers?: Record<string, string>;
+        body?: any;
+        queryParams?: Record<string, string>;
+    }): Promise<RequestResult>;
+    static resetCounter(): void;
+}

package/dist/src/api/request-result.d.ts

@@ -0,0 +1,44 @@
+export declare function generateRequestId(method: string, urlPath: string, prefix?: string): string;
+export declare function resetRequestCounter(): void;
+export declare class RequestResult {
+    id: string;
+    method: string;
+    path: string;
+    fullUrl: string;
+    requestHeaders: Record<string, string>;
+    requestBody?: any;
+    status: number;
+    statusText: string;
+    responseHeaders: Record<string, string>;
+    timing: number;
+    timestamp: Date;
+    error?: string;
+    requestFile: string;
+    responseFile: string;
+    _rawResponseBody?: string;
+    constructor(opts: {
+        id: string;
+        method: string;
+        path: string;
+        fullUrl: string;
+        requestHeaders: Record<string, string>;
+        requestBody?: any;
+        status: number;
+        statusText: string;
+        responseHeaders: Record<string, string>;
+        timing: number;
+        timestamp: Date;
+        error?: string;
+    });
+    get rawResponseBody(): string;
+    set rawResponseBodyValue(value: string);
+    get responseBody(): any;
+    save(outputDir: string): void;
+    static load(requestFile: string): RequestResult;
+    toSummary(): string;
+    extractIdAndTitle(): {
+        id?: string | number;
+        title?: string;
+    };
+    toCurlCommand(): string;
+}

package/dist/src/api/request-store.d.ts

@@ -0,0 +1,29 @@
+import { RequestResult } from './request-result.js';
+export declare class RequestStore {
+    capturedRequests: RequestResult[];
+    madeRequests: RequestResult[];
+    failedRequests: RequestResult[];
+    onFailedListeners: Array<(r: RequestResult) => void>;
+    outputDir: string;
+    constructor(outputDir: string);
+    addCapturedRequest(result: RequestResult): void;
+    addFailedRequest(result: RequestResult): void;
+    getFailedRequests(): RequestResult[];
+    onFailedRequest(cb: (r: RequestResult) => void): () => void;
+    addMadeRequest(result: RequestResult): void;
+    addRequest(result: RequestResult): void;
+    getCapturedRequests(): RequestResult[];
+    getMadeRequests(): RequestResult[];
+    getRequests(): RequestResult[];
+    getLastRequest(): RequestResult | undefined;
+    getRequestsByEndpoint(pathPrefix: string): RequestResult[];
+    getRequestsByMethod(method: string): RequestResult[];
+    getRequestsByStatus(status: number): RequestResult[];
+    toEndpointList(): string;
+    extractAuthHeaders(): Record<string, string>;
+    findCapturedRequest(method: string, pathPrefix: string): RequestResult | undefined;
+    toLog(): string;
+    loadFromDisk(): void;
+    getWriteRequestsForScope(scopePath: string): RequestResult[];
+    clear(): void;
+}

package/dist/src/api/spec-reader.d.ts

@@ -0,0 +1,5 @@
+export declare function validateSpecs(specs?: string[]): void;
+export declare function loadSpec(specPaths: string[], outputDir: string): Promise<any>;
+export declare function extractEndpointDefinition(schema: any, endpoint: string, baseEndpoint?: string): string;
+export declare function searchEndpoints(schema: any, query: string, baseEndpoint?: string): string;
+export declare function listAllEndpoints(schema: any, baseEndpoint?: string): string;

package/dist/src/api/xhr-capture.d.ts

@@ -0,0 +1,10 @@
+import type { RequestStore } from './request-store.js';
+export declare class XhrCapture {
+    store: RequestStore;
+    baseOrigin: string;
+    handler: ((response: any) => Promise<void>) | null;
+    constructor(store: RequestStore, baseUrl: string);
+    attach(page: any): void;
+    detach(page: any): void;
+    captureResponse(response: any): Promise<void>;
+}

package/dist/src/browser-server.d.ts

@@ -0,0 +1,10 @@
+declare function getEndpointFilePath(): string;
+declare function readEndpoint(): string | null;
+declare function removeEndpointFile(): void;
+declare function isServerRunning(wsEndpoint: string): Promise<boolean>;
+declare function launchServer(opts: {
+    browser?: string;
+    show?: boolean;
+}): Promise<any>;
+declare function getAliveEndpoint(): Promise<string | null>;
+export { readEndpoint, removeEndpointFile, isServerRunning, launchServer, getEndpointFilePath, getAliveEndpoint };

package/dist/src/command-handler.d.ts

@@ -0,0 +1,68 @@
+import { type BaseCommand } from './commands/index.js';
+import type { ExplorBot } from './explorbot.js';
+export type InputSubmitCallback = (input: string) => Promise<void>;
+export interface InputManager {
+    registerInputPane(addLog: (entry: string) => void, onSubmit: InputSubmitCallback): () => void;
+    getAvailableCommands(): string[];
+    getFilteredCommands(input: string): string[];
+    getAutocomplete(input: string, cursor: number): CommandAutocomplete;
+    setExitOnEmptyInput(enabled: boolean): void;
+}
+export interface ParsedCommand {
+    name: string;
+    args: string[];
+}
+export interface CommandAutocompleteSuggestion {
+    value: string;
+    display: string;
+    description: string;
+    argumentHint?: string;
+}
+export interface CommandAutocomplete {
+    suggestions: CommandAutocompleteSuggestion[];
+    replaceFrom: number;
+    replaceTo: number;
+    visible: boolean;
+    argumentHint?: string;
+}
+export declare class CommandHandler implements InputManager {
+    explorBot: ExplorBot;
+    commands: BaseCommand[];
+    registeredInputPanes: Set<{
+        addLog: (entry: string) => void;
+        onSubmit: InputSubmitCallback;
+    }>;
+    exitOnEmptyInput: boolean;
+    runningCommands: Set<string>;
+    constructor(explorBot: ExplorBot);
+    findCommand(name: string): BaseCommand | undefined;
+    getAvailableCommands(): string[];
+    getAutocomplete(input: string, cursor: number): CommandAutocomplete;
+    getCommandDescriptions(): {
+        name: string;
+        description: string;
+        options: string;
+    }[];
+    executeCommand(input: string): Promise<void>;
+    executeBrowserCommand(input: string): Promise<void>;
+    isCommand(input: string): boolean;
+    registerInputPane(addLog: (entry: string) => void, onSubmit: InputSubmitCallback): () => void;
+    getFilteredCommands(input: string): string[];
+    setExitOnEmptyInput(enabled: boolean): void;
+    submitInput(input: string): Promise<void>;
+    getSlashAutocomplete(input: string, cursor: number): CommandAutocomplete | null;
+    getCodeceptAutocomplete(input: string, cursor: number): CommandAutocomplete | null;
+    getExitAutocomplete(input: string, cursor: number): CommandAutocomplete | null;
+    getSlashCommandEntries(): AutocompleteEntry[];
+    getCodeceptEntries(): AutocompleteEntry[];
+    rankSuggestions(query: string, entries: AutocompleteEntry[]): CommandAutocompleteSuggestion[];
+    getMatchScore(query: string, candidate: string): number;
+}
+type AutocompleteEntry = {
+    aliases: string[];
+    argumentHint?: string;
+    canonical: string;
+    description: string;
+    value: string;
+};
+export {};

package/dist/src/commands/add-rule-command.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class AddRuleCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    static createRuleFile(agentName: string, ruleName: string, opts?: {
+        content?: string;
+        urlPattern?: string;
+    }): string | null;
+}

package/dist/src/commands/base-command.d.ts

@@ -0,0 +1,26 @@
+import type { ExplorBot } from '../explorbot.js';
+export interface CommandOption {
+    flags: string;
+    description: string;
+}
+export interface Suggestion {
+    command?: string;
+    hint: string;
+}
+export declare abstract class BaseCommand {
+    abstract name: string;
+    abstract description: string;
+    aliases: string[];
+    options: CommandOption[];
+    tuiEnabled: boolean;
+    suggestions: Suggestion[];
+    explorBot: ExplorBot;
+    constructor(explorBot: ExplorBot);
+    abstract execute(args: string): Promise<void>;
+    matches(commandName: string): boolean;
+    printSuggestions(): void;
+    parseArgs(args: string): {
+        opts: Record<string, string | boolean>;
+        args: string[];
+    };
+}

package/dist/src/commands/clean-command.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare const CLEAN_TARGETS: Record<string, {
+    description: string;
+    getDir: () => string;
+}>;
+export declare class CleanCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    cleanTarget(name: string): void;
+}

package/dist/src/commands/compact-command.d.ts

@@ -0,0 +1,20 @@
+import type { ExperienceFile } from '../ai/experience-compactor.js';
+import type { ExperienceTracker } from '../experience-tracker.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class CompactCommand extends BaseCommand {
+    name: string;
+    description: string;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    buildDryRunSuggestions(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, files: ExperienceFile[], target?: string): Suggestion[];
+    runFullSweep(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, merge: boolean): Promise<{
+        merged: number;
+        compacted: number;
+    }>;
+    resolveTarget(tracker: ExperienceTracker, target?: string): ExperienceFile[] | null;
+    printDryRun(compactor: ReturnType<typeof this.explorBot.agentExperienceCompactor>, files: ExperienceFile[], target: string | undefined, willMerge: boolean): void;
+}

package/dist/src/commands/context-aria-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextAriaCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/context-command.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class ContextCommand extends BaseCommand {
+    name: string;
+    description: string;
+    suggestions: Suggestion[];
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    execute(args: string): Promise<void>;
+}

package/dist/src/commands/context-data-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextDataCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/context-experience-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextExperienceCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/context-html-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextHtmlCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/context-knowledge-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class ContextKnowledgeCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/debug-command.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './base-command.js';
+export declare class DebugCommand extends BaseCommand {
+    name: string;
+    description: string;
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/drill-command.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class DrillCommand extends BaseCommand {
+    name: string;
+    description: string;
+    aliases: string[];
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    parseKnowledgeArg(args: string): string | undefined;
+    parseMaxArg(args: string): number | undefined;
+}

package/dist/src/commands/exit-command.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './base-command.js';
+export declare class ExitCommand extends BaseCommand {
+    name: string;
+    description: string;
+    aliases: string[];
+    execute(_args: string): Promise<void>;
+}

package/dist/src/commands/experience-command.d.ts

@@ -0,0 +1,15 @@
+import type { ExperienceTocEntry, ExperienceTracker } from '../experience-tracker.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class ExperienceCommand extends BaseCommand {
+    name: string;
+    description: string;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    suggestions: Suggestion[];
+    execute(args: string): Promise<void>;
+    expand(tracker: ExperienceTracker, fileTag: string, sectionIndex: number, urlFilter?: string): void;
+    formatToc(toc: ExperienceTocEntry[], urlFilter?: string, recency?: 'recent' | 'old'): string;
+    stripLeadingHeading(body: string): string;
+}

package/dist/src/commands/explore-command.d.ts

@@ -0,0 +1,51 @@
+import { type Plan, type Test } from '../test-plan.js';
+import { BaseCommand, type Suggestion } from './base-command.js';
+export declare class ExploreCommand extends BaseCommand {
+    name: string;
+    description: string;
+    options: {
+        flags: string;
+        description: string;
+    }[];
+    suggestions: Suggestion[];
+    maxTests?: number;
+    dryRun: boolean;
+    testsRun: number;
+    completedPlans: Plan[];
+    failedSubPages: Set<string>;
+    oldTestRefs: Set<Test>;
+    priorityFilter?: Set<string>;
+    getCurrentPageUrl(): string | undefined;
+    execute(args: string): Promise<void>;
+    originLabel(test: Test): string;
+    printPreview(label: string, tests: Test[]): void;
+    runFreshMode(mainUrl: string | undefined, feature: string | undefined, styles?: string[]): Promise<void>;
+    runReuseMode(mainUrl: string | undefined, feature: string | undefined, cfg: ConfigureSpec): Promise<void>;
+    discoverNewSubPages(mainPlan: Plan, mainUrl: string | undefined, styles: string[] | undefined, knownUrls: Set<string>): Promise<void>;
+    replanAndRun(pageUrl: string | undefined, feature: string | undefined, existingPlan: Plan, styles?: string[]): Promise<void>;
+    runAllStyles(pageUrl?: string, feature?: string, parentPlan?: Plan, completedPlans?: Plan[], styles?: string[]): Promise<void>;
+    rememberCurrentPlan(): void;
+    planWithRetry(feature: string | undefined, opts: {
+        fresh: boolean;
+        style: string;
+        extend?: Plan;
+        completedPlans?: Plan[];
+        noSave?: boolean;
+    }, pageUrl?: string): Promise<void>;
+    parseConfigure(raw: string | undefined): ConfigureSpec;
+    printResults(): void;
+    printNextSteps(savedPlanPath?: string | null): void;
+    isLimitReached(): boolean;
+    runPendingTests(): Promise<void>;
+    runOneTest(test: Test): Promise<void>;
+}
+interface ConfigureSpec {
+    enabled: boolean;
+    newRatio: number;
+    fromPath?: string;
+    styles?: string[];
+    subpages?: 'none' | 'same' | 'new' | 'both';
+    pickBy?: 'priority' | 'random' | 'index';
+    priorities?: string[];
+}
+export {};