explorbot 0.4.10 → 0.5.0

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

@@ -7,6 +7,7 @@ import type { StateManager } from '../state-manager.js';
 import { HooksRunner } from '../utils/hooks-runner.js';
 import type { AgentDeps, ToolDeps } from './agent.js';
 import { Historian } from './historian.js';
+import type { Judge } from './judge.js';
 import type { Navigator } from './navigator.js';
 import type { Provider } from './provider.js';
 import { Quartermaster } from './quartermaster.js';
@@ -17,6 +18,7 @@ export declare abstract class TaskAgent {
     config: ExplorbotConfig;
     stateManager: StateManager;
     knowledgeTracker: KnowledgeTracker;
+    judge?: Judge;
     hooksRunner: HooksRunner;
     consecutiveFailures: number;
     consecutiveEmptyResults: number;

package/dist/src/ai/task-agent.js

@@ -16,6 +16,7 @@ export class TaskAgent {
     config;
     stateManager;
     knowledgeTracker;
+    judge;
     hooksRunner;
     consecutiveFailures = 0;
     consecutiveEmptyResults = 0;
@@ -31,6 +32,7 @@ export class TaskAgent {
         this.config = deps.config;
         this.stateManager = deps.stateManager;
         this.knowledgeTracker = deps.knowledgeTracker;
+        this.judge = deps.judge;
         this.hooksRunner = new HooksRunner(deps.explorer, deps.config);
     }
     setHistorian(historian) {
@@ -40,7 +42,7 @@ export class TaskAgent {
         this._quartermaster = quartermaster;
     }
     get toolDeps() {
-        return { explorer: this.explorer, stateManager: this.stateManager, ai: this.provider };
+        return { explorer: this.explorer, stateManager: this.stateManager, ai: this.provider, judge: this.judge };
     }
     getExperienceTracker() {
         return this.stateManager.getExperienceTracker();

package/dist/src/ai/tester.js

@@ -112,8 +112,8 @@ export class Tester extends TaskAgent {
         let initialState = ActionResult.fromState(state);
         const currentUrl = state.fullUrl || state.url;
         let startOnCurrentPage = opts.startOnCurrentPage;
-        if (isErrorPage(initialState) && !startOnCurrentPage && task.startUrl && normalizeUrl(currentUrl) !== normalizeUrl(task.startUrl)) {
-            debugLog(`Recovering from error page at ${currentUrl} by navigating to ${task.startUrl}`);
+        if (!startOnCurrentPage && task.startUrl && normalizeUrl(currentUrl) !== normalizeUrl(task.startUrl)) {
+            debugLog(`Opening test start URL ${task.startUrl} before building context (was at ${currentUrl})`);
             try {
                 await this.explorer.visit(task.startUrl);
                 state = this.stateManager.getCurrentState();
@@ -123,7 +123,7 @@ export class Tester extends TaskAgent {
                 startOnCurrentPage = true;
             }
             catch (error) {
-                debugLog(`Could not recover from error page: ${compactErrorMessage(error)}`);
+                debugLog(`Could not open test start URL: ${compactErrorMessage(error)}`);
             }
         }
         if (isErrorPage(initialState)) {
@@ -135,13 +135,6 @@ export class Tester extends TaskAgent {
         const conversation = this.provider.startConversation(this.getSystemMessage(), 'tester');
         conversation.markLastMessageCacheable();
         this.currentConversation = conversation;
-        const scenarioBlock = this.buildScenarioBlock(task, initialState);
-        conversation.addUserText(scenarioBlock);
-        conversation.markLastMessageCacheable();
-        conversation.protectPrefix(conversation.messages.length);
-        const pageContext = await this.reinjectContextIfNeeded(1, initialState);
-        if (pageContext)
-            conversation.addUserText(pageContext);
         return await Observability.run(`test: ${task.scenario}`, {
             sessionId: task.sessionName,
             tags: ['tester'],
@@ -154,16 +147,15 @@ export class Tester extends TaskAgent {
     }
     async runTestSession(task, initialState, conversation, handlers, opts) {
         const { offFailedRequest } = handlers;
+        let plan = '';
         if (this.pilot) {
             try {
-                const plan = await this.pilot.planTest(task, initialState);
+                await this.researcher.research(initialState).catch(this.skipResearch);
+                plan = await this.pilot.planTest(task, initialState);
                 if (task.hasFinished) {
                     offFailedRequest?.();
                     return { success: task.isSuccessful };
                 }
-                if (plan) {
-                    conversation.addUserText(`Pilot's test plan:\n${plan}\n\nFollow this plan while executing the test.`);
-                }
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -183,7 +175,7 @@ export class Tester extends TaskAgent {
         }
         if (opts.startOnCurrentPage)
             debugLog(`Starting on the page already open at ${task.startUrl}`);
-        if (!opts.startOnCurrentPage) {
+        if (!opts.startOnCurrentPage || task.preparedData.length > 0) {
             debugLog(`Navigating to ${task.startUrl}`);
             try {
                 await this.explorer.visit(task.startUrl);
@@ -208,6 +200,15 @@ export class Tester extends TaskAgent {
         }
         const currentUrl = startState?.url || task.startUrl || '';
         await this.hooksRunner.runBeforeHook('tester', currentUrl);
+        const testerState = this.getCurrentState();
+        conversation.addUserText(this.buildScenarioBlock(task, testerState));
+        conversation.markLastMessageCacheable();
+        conversation.protectPrefix(conversation.messages.length);
+        const pageContext = await this.reinjectContextIfNeeded(1, testerState);
+        if (pageContext)
+            conversation.addUserText(pageContext);
+        if (plan)
+            conversation.addUserText(`Pilot's test plan:\n${plan}\n\nFollow this plan while executing the test.`);
         const offStateChange = this.stateManager.onStateChange((event) => {
             if (task.hasFinished)
                 return;
@@ -836,6 +837,9 @@ export class Tester extends TaskAgent {
     `;
     }
     buildDeletionScope(task) {
+        if (task.preparedData.length > 0) {
+            return `When deleting items, ONLY delete the data prepared for this test: ${task.preparedData.join('; ')}.`;
+        }
         const deletableItems = this.getDeletableSessionNames(task);
         if (deletableItems.length > 0) {
             return `When deleting items, ONLY delete items whose title contains one of these session names: ${deletableItems.join(', ')}. These were created by previous tests.`;

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

@@ -3,6 +3,7 @@ import type { ExecutedStep } from '../action.js';
 import { type ExperienceTracker } from '../experience-tracker.js';
 import { type Task } from '../test-plan.js';
 import type { ToolDeps } from './agent.js';
+import { type Judge } from './judge.js';
 import { Navigator } from './navigator.js';
 import { Researcher } from './researcher.js';
 interface AgentToolDeps extends ToolDeps {
@@ -12,7 +13,7 @@ interface AgentToolDeps extends ToolDeps {
     withExperience?: boolean;
 }
 export declare const ASSERTION_TOOLS: readonly ["verify"];
-export declare function createCodeceptJSTools({ explorer, stateManager }: ToolDeps, task: Task): {
+export declare function createCodeceptJSTools({ explorer, stateManager, judge }: ToolDeps, task: Task): {
     click: import("@ai-sdk/provider-utils").ExecutableTool<import("ai").Tool<{
         commands: any;
         explanation: any;
@@ -55,7 +56,7 @@ export declare function createLearnExperienceTool({ getExperienceTracker, getSta
 } | {
     error: string;
 }, import("@ai-sdk/provider-utils").Context>>;
-export declare function createAgentTools({ explorer, stateManager, ai, researcher, navigator, supervisor, withExperience }: AgentToolDeps): any;
+export declare function createAgentTools({ explorer, stateManager, ai, judge, researcher, navigator, supervisor, withExperience }: AgentToolDeps): any;
 export declare function commitNote(activeNote: any, result: TestResult, toolResult: any, action: any): Promise<void>;
 export declare function successToolResult(action: string, data?: Record<string, any>, source?: {
     playwrightGroupId?: string | null;
@@ -64,7 +65,7 @@ export declare function successToolResult(action: string, data?: Record<string,
 export declare function isMajorPageChange(pageDiff: PageDiff): boolean;
 export declare function hasFailedRequest(pageDiff: PageDiff): boolean;
 export declare function formatExecutedSteps(steps: ExecutedStep[], requestedCount?: number): string;
-export declare function failedToolResult(action: string, message: string, data?: Record<string, any>, error?: Error | null): Promise<Record<string, any>>;
+export declare function failedToolResult(action: string, message: string, data?: Record<string, any>, error?: Error | null, judge?: Judge, intent?: string): Promise<Record<string, any>>;
 export declare function withdrawVisionTools(tools: Record<string, any>): void;
 export declare function clickFailureSuggestion(attempts: Array<{
     error?: string;

package/dist/src/ai/tools.js

@@ -13,11 +13,13 @@ import { createDebug, tag } from '../utils/logger.js';
 import { pause } from '../utils/loop.js';
 import { compactErrorMessage, normalizeInlineText, truncate } from "../utils/strings.js";
 import { WebElement } from "../utils/web-element.js";
+import { createJudgeTool } from "./judge-tool.js";
+import { JUDGE_PAGE_CAP, UNDECIDED } from "./judge.js";
 import { sectionContextRule } from "./rules.js";
 import { isInteractive } from "./task-agent.js";
 const debugLog = createDebug('explorbot:tools');
 export const ASSERTION_TOOLS = ['verify'];
-export function createCodeceptJSTools({ explorer, stateManager }, task) {
+export function createCodeceptJSTools({ explorer, stateManager, judge }, task) {
     return {
         click: tool({
             description: dedent `
@@ -125,7 +127,7 @@ export function createCodeceptJSTools({ explorer, stateManager }, task) {
                     ...toolResult,
                     attempts,
                     suggestion,
-                }, ambiguityError || action.lastError);
+                }, ambiguityError || action.lastError, judge, explanation);
             },
         }),
         hover: tool({
@@ -189,7 +191,7 @@ export function createCodeceptJSTools({ explorer, stateManager }, task) {
                     ...toolResult,
                     attempts,
                     suggestion: 'Use xpathCheck() to locate the row/card/tree node, or visualClick() if the hover target is only visually identifiable.',
-                }, action.lastError);
+                }, action.lastError, judge, explanation);
             },
         }),
         pressKey: tool({
@@ -312,7 +314,7 @@ export function createCodeceptJSTools({ explorer, stateManager }, task) {
         - Performing multiple form actions in a single batch
         - Complex interactions requiring sequential commands
         - Reaching items further down a list (I.scrollTo)
-        - Reloading the page to prove a change outlived it (I.reloadPage)
+        - Reloading the page to prove a change outlived it (I.refreshPage)
 
         Example - filling a form with context (PREFERRED):
         I.fillField('Username', 'John', '.login-form')
@@ -363,7 +365,7 @@ export function createCodeceptJSTools({ explorer, stateManager }, task) {
                             code: codeBlock,
                             attempts: action.executedSteps,
                             suggestion: formSuggestion,
-                        }, action.lastError);
+                        }, action.lastError, judge, explanation);
                     }
                     if (!hasObservablePageChange(toolResult)) {
                         activeNote.commit(TestResult.FAILED);
@@ -498,7 +500,7 @@ export function createLearnExperienceTool({ getExperienceTracker, getState }) {
         },
     });
 }
-export function createAgentTools({ explorer, stateManager, ai, researcher, navigator, supervisor, withExperience }) {
+export function createAgentTools({ explorer, stateManager, ai, judge, researcher, navigator, supervisor, withExperience }) {
     const tools = {
         see: tool({
             description: dedent `
@@ -619,6 +621,12 @@ export function createAgentTools({ explorer, stateManager, ai, researcher, navig
                         }, { assertionSteps: result.assertionSteps });
                     }
                     if (result.inexpressible) {
+                        if (result.judged?.approved) {
+                            return failedToolResult('verify', `No assertion could express this claim, but the page appears to confirm it: ${assertion}`, {
+                                inexpressible: true,
+                                suggestion: 'This is a judgement about the page, not an assertion that ran in the browser — a hint, not proof. Restate the claim in terms of what is visible or of a control state to get a real assertion.',
+                            });
+                        }
                         return failedToolResult('verify', `No assertion could express this claim: ${assertion}`, {
                             inexpressible: true,
                             suggestion: 'This is not evidence the page is wrong — the claim could not be turned into an assertion. Restate it in terms of what is visible or of a control state, or check it with see().',
@@ -994,6 +1002,19 @@ export function createAgentTools({ explorer, stateManager, ai, researcher, navig
             },
         });
     }
+    const buildJudgeState = async () => {
+        const activeTest = explorer.activeTest;
+        const state = stateManager.getCurrentState();
+        const result = state ? ActionResult.fromState(state) : null;
+        return {
+            task: activeTest?.scenario || '',
+            page: cap(result?.getCompactARIA(), JUDGE_PAGE_CAP),
+            recentActions: Object.values(activeTest?.steps || {})
+                .slice(-JUDGE_RECENT_ACTIONS_LIMIT)
+                .map((step) => step.text),
+        };
+    };
+    Object.assign(tools, createJudgeTool({ explorer, stateManager, ai, judge }, buildJudgeState));
     withdrawVisionTools(tools);
     return tools;
 }
@@ -1003,6 +1024,7 @@ const NAVIGATED_SUGGESTION = 'The action left the page. Elements are never compa
 const ARIA_OUTPUT_CAP = 4000;
 const HTML_OUTPUT_CAP = 6000;
 const ANALYSIS_OUTPUT_CAP = 2000;
+const JUDGE_RECENT_ACTIONS_LIMIT = 8;
 function cap(text, max) {
     if (!text)
         return '';
@@ -1115,7 +1137,7 @@ function hasObservablePageChange(data) {
         return true;
     return Array.isArray(data.pageDiff.htmlParts) && data.pageDiff.htmlParts.length > 0;
 }
-export async function failedToolResult(action, message, data, error) {
+export async function failedToolResult(action, message, data, error, judge, intent) {
     const result = { success: false, action, message, ...data };
     if (data?.pageDiff) {
         result.suggestion = data.suggestion ? `${data.suggestion} ${PAGE_DIFF_SUGGESTION}` : PAGE_DIFF_SUGGESTION;
@@ -1126,6 +1148,12 @@ export async function failedToolResult(action, message, data, error) {
         result.suggestion = getMultipleElementsSuggestion();
         result.multipleElementsDetected = true;
         result.elements = formatElementList(matched);
+        const labels = (matched || []).map((element) => `${element.text || 'no text'} — ${element.html}`);
+        const pick = await judge?.decide('Which listed element does the intent name?', [...labels, UNDECIDED], { intent });
+        if (!pick?.value)
+            return result;
+        const index = labels.indexOf(pick.value) + 1;
+        result.suggestion = `Element ${index} is the one meant. Repeat the action with step.opts({ elementIndex: ${index} }) as the last argument.`;
         return result;
     }
     const notFoundSuggestion = getNotFoundSuggestion(message);

package/dist/src/api/request-result.js

@@ -162,7 +162,8 @@ export class RequestResult {
         if (Array.isArray(data))
             return {};
         const id = data.id ?? data._id ?? data.uuid;
-        const title = data.name ?? data.title ?? data.label;
+        const attributes = data.attributes || {};
+        const title = data.name ?? data.title ?? data.label ?? attributes.name ?? attributes.title ?? attributes.label;
         const result = {};
         if (id !== undefined)
             result.id = id;

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

@@ -24,6 +24,7 @@ export interface CommandAutocomplete {
     replaceTo: number;
     visible: boolean;
     argumentHint?: string;
+    completesArgument?: boolean;
 }
 export declare class CommandHandler implements InputManager {
     explorBot: ExplorBot;

package/dist/src/command-handler.js

@@ -207,6 +207,28 @@ export class CommandHandler {
         const parsed = parseCommand(query);
         const exactCommand = parsed ? this.findCommand(parsed.name) : undefined;
         const hasArguments = commandEnd !== -1 && input.slice(commandEnd + 1).trim().length > 0;
+        const argumentHint = !insideCommand && exactCommand && !hasArguments && exactCommand.options.length > 0 ? exactCommand.options.map((option) => option.flags).join(' ') : undefined;
+        if (!insideCommand && exactCommand) {
+            const argumentQuery = input.slice(commandEnd + 1).trim();
+            const argumentEntries = exactCommand
+                .completeArguments()
+                .filter((completion) => completion.value !== argumentQuery)
+                .map((completion) => ({
+                aliases: [],
+                canonical: completion.value,
+                description: '',
+                value: completion.display || completion.value,
+            }));
+            const argumentSuggestions = this.rankSuggestions(argumentQuery, argumentEntries);
+            return {
+                suggestions: argumentSuggestions,
+                replaceFrom: commandEnd + 1,
+                replaceTo: input.length,
+                visible: argumentSuggestions.length > 0,
+                argumentHint,
+                completesArgument: true,
+            };
+        }
         const commandEntries = this.getSlashCommandEntries();
         let suggestions = [];
         if (insideCommand) {
@@ -222,9 +244,8 @@ export class CommandHandler {
                 suggestions = this.rankSuggestions(query, commandEntries);
             }
         }
-        const argumentHint = !insideCommand && exactCommand && !hasArguments && exactCommand.options.length > 0 ? exactCommand.options.map((option) => option.flags).join(' ') : undefined;
         return {
-            suggestions,
+            suggestions: suggestions.map((suggestion) => ({ ...suggestion, value: `${suggestion.value} ` })),
             replaceFrom: 0,
             replaceTo,
             visible: insideCommand && suggestions.length > 0,
@@ -305,7 +326,7 @@ export class CommandHandler {
     rankSuggestions(query, entries) {
         if (!query) {
             return entries.slice(0, 20).map((entry) => ({
-                value: entry.value,
+                value: entry.canonical,
                 display: entry.value,
                 description: entry.description,
                 argumentHint: entry.argumentHint,

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

@@ -18,9 +18,14 @@ export declare abstract class BaseCommand<T = ExplorBot> {
     constructor(explorBot: T);
     abstract execute(args: string): Promise<void>;
     matches(commandName: string): boolean;
+    completeArguments(): ArgumentCompletion[];
     printSuggestions(): void;
     parseArgs(args: string): {
         opts: Record<string, string | boolean>;
         args: string[];
     };
 }
+export interface ArgumentCompletion {
+    value: string;
+    display?: string;
+}

package/dist/src/commands/base-command.js

@@ -15,6 +15,9 @@ export class BaseCommand {
     matches(commandName) {
         return this.name === commandName || this.aliases.includes(commandName);
     }
+    completeArguments() {
+        return [];
+    }
     printSuggestions() {
         if (this.suggestions.length === 0)
             return;

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

@@ -1,5 +1,5 @@
 import { type Plan, type Test } from '../test-plan.js';
-import { BaseCommand, type Suggestion } from './base-command.js';
+import { type ArgumentCompletion, BaseCommand, type Suggestion } from './base-command.js';
 export declare const DEADLINE_RESERVE_MS: number;
 export declare const DEADLINE_TEST_ALLOWANCE_MS: number;
 export declare class ExploreCommand extends BaseCommand {
@@ -22,6 +22,7 @@ export declare class ExploreCommand extends BaseCommand {
     priorityFilter?: Set<string>;
     getCurrentPageUrl(): string | undefined;
     execute(args: string): Promise<void>;
+    completeArguments(): ArgumentCompletion[];
     originLabel(test: Test): string;
     printPreview(label: string, tests: Test[]): void;
     runFreshMode(mainUrl: string | undefined, feature: string | undefined, styles?: string[]): Promise<void>;

package/dist/src/commands/explore-command.js

@@ -17,7 +17,7 @@ export const DEADLINE_RESERVE_MS = 3 * 60_000;
 export const DEADLINE_TEST_ALLOWANCE_MS = 5 * 60_000;
 export class ExploreCommand extends BaseCommand {
     name = 'explore';
-    description = 'Start web exploration';
+    description = 'Start web exploration on the current page, or on the URL given as the first argument';
     options = [
         { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
         { flags: '--max-duration <minutes>', description: 'Wall-clock budget in minutes; wraps up the session before the limit is hit' },
@@ -55,6 +55,11 @@ export class ExploreCommand extends BaseCommand {
         if (this.hardDeadlineAt == null && this.maxDurationMinutes != null) {
             this.hardDeadlineAt = Date.now() + this.maxDurationMinutes * 60_000 - DEADLINE_RESERVE_MS;
         }
+        const [target] = remaining;
+        if (target?.startsWith('/') || target?.startsWith('http://') || target?.startsWith('https://')) {
+            remaining.shift();
+            await this.explorBot.visit(target);
+        }
         const feature = opts.focus || remaining.join(' ') || undefined;
         const cfg = this.parseConfigure(opts.configure);
         if (cfg.priorities)
@@ -96,6 +101,12 @@ export class ExploreCommand extends BaseCommand {
                 await this.explorBot.printSessionAnalysis();
         }
     }
+    completeArguments() {
+        return this.explorBot
+            .stateManager()
+            .getKnownUrls()
+            .map((url) => ({ value: url }));
+    }
     originLabel(test) {
         return this.oldTestRefs.has(test) ? 'OLD' : 'NEW';
     }

package/dist/src/commands/freesail-command.js

@@ -1,5 +1,6 @@
 import { Planner } from '../ai/planner.js';
 import { Researcher } from '../ai/researcher.js';
+import { normalizeUrl } from '../state-manager.js';
 import { Stats } from '../stats.js';
 import { tag } from '../utils/logger.js';
 import { loop } from '../utils/loop.js';
@@ -65,11 +66,16 @@ export class FreesailCommand extends BaseCommand {
             const suggestion = await navigator.freeSail({ strategy, scope, visitedUrls });
             if (!suggestion) {
                 tag('info').log('No navigation suggestion available');
-                return;
+                ctx.stop();
             }
             if (scope && !suggestion.target.startsWith(scope)) {
                 tag('warning').log(`Suggestion ${suggestion.target} is outside scope ${scope}, skipping`);
-                return;
+                ctx.stop();
+            }
+            const currentUrl = stateManager.getCurrentState()?.url;
+            if (currentUrl && normalizeUrl(suggestion.target) === normalizeUrl(currentUrl)) {
+                tag('info').log(`No new navigation target available after ${currentUrl}; stopping exploration`);
+                ctx.stop();
             }
             tag('info').log(`Navigating to: ${suggestion.target} - ${suggestion.reason}`);
             await this.explorBot.openTab();

package/dist/src/commands/init-command.js

@@ -145,7 +145,7 @@ export function runInitCommand(options) {
         log('2. Set AI models config file');
         log('3. Set web application URL in the config file');
         log('4. Add initial knowledge (how to authorize to the application, etc.)');
-        tag('substep').log(chalk.yellow(`${getCliName()} learn * 'to authorize use these credentials: admin@example.com / secret123'`));
+        tag('substep').log(chalk.yellow(`${getCliName()} learn '*' 'to authorize use these credentials: admin@example.com / secret123'`));
         tag('substep').log('You can use ${env.LOGIN} and ${env.PASSWORD} to reference environment variables.');
         log('5. Launch application on a relative URL');
         tag('substep').log(chalk.yellow(`${getCliName()} start /dashboard`));

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

@@ -1,7 +1,8 @@
-import { BaseCommand, type Suggestion } from './base-command.js';
+import { type ArgumentCompletion, BaseCommand, type Suggestion } from './base-command.js';
 export declare class NavigateCommand extends BaseCommand {
     name: string;
     description: string;
     suggestions: Suggestion[];
     execute(args: string): Promise<void>;
+    completeArguments(): ArgumentCompletion[];
 }

package/dist/src/commands/navigate-command.js

@@ -15,4 +15,10 @@ export class NavigateCommand extends BaseCommand {
         await this.explorBot.visit(destination);
         tag('success').log(`Navigation requested: ${destination}`);
     }
+    completeArguments() {
+        return this.explorBot
+            .stateManager()
+            .getKnownUrls()
+            .map((url) => ({ value: url }));
+    }
 }

package/dist/src/commands/plan-load-command.d.ts

@@ -1,7 +1,8 @@
-import { BaseCommand, type Suggestion } from './base-command.js';
+import { type ArgumentCompletion, BaseCommand, type Suggestion } from './base-command.js';
 export declare class PlanLoadCommand extends BaseCommand {
     name: string;
     description: string;
     suggestions: Suggestion[];
     execute(args: string): Promise<void>;
+    completeArguments(): ArgumentCompletion[];
 }

package/dist/src/commands/plan-load-command.js

@@ -1,3 +1,4 @@
+import { Plan } from '../test-plan.js';
 import { tag } from '../utils/logger.js';
 import { BaseCommand } from './base-command.js';
 export class PlanLoadCommand extends BaseCommand {
@@ -15,4 +16,7 @@ export class PlanLoadCommand extends BaseCommand {
         const plan = this.explorBot.loadPlan(filename);
         tag('success').log(`Plan loaded: ${plan.title} with ${plan.tests.length} tests`);
     }
+    completeArguments() {
+        return Plan.listFiles(this.explorBot.getPlansDir()).map((file) => ({ value: file.name, display: file.label }));
+    }
 }

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

@@ -1,5 +1,5 @@
-import { Plan } from '../test-plan.js';
-import { BaseCommand } from './base-command.js';
+import { Plan, type PlanFile } from '../test-plan.js';
+import { type ArgumentCompletion, BaseCommand } from './base-command.js';
 export declare class PlansCommand extends BaseCommand {
     name: string;
     description: string;
@@ -8,7 +8,7 @@ export declare class PlansCommand extends BaseCommand {
         description: string;
     }[];
     execute(args: string): Promise<void>;
-    getPlanFiles(): PlanFile[];
+    completeArguments(): ArgumentCompletion[];
     printPlans(files: PlanFile[]): void;
     printPlanDetails(plan: Plan, file: PlanFile): void;
     resolvePlanFile(target: string, files: PlanFile[]): {
@@ -16,9 +16,3 @@ export declare class PlansCommand extends BaseCommand {
         file: PlanFile;
     };
 }
-interface PlanFile {
-    name: string;
-    path: string;
-    modifiedAt: number;
-}
-export {};

package/dist/src/commands/plans-command.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { statSync } from 'node:fs';
 import path from 'node:path';
 import { Plan } from '../test-plan.js';
 import { getCliName } from '../utils/cli-name.js';
@@ -11,7 +11,7 @@ export class PlansCommand extends BaseCommand {
     options = [{ flags: '--from-plan <file>', description: 'Plan file to show' }];
     async execute(args) {
         const { opts, args: remaining } = this.parseArgs(args);
-        const files = this.getPlanFiles();
+        const files = Plan.listFiles(this.explorBot.getPlansDir());
         const target = String(opts.fromPlan || remaining[0] || '').trim();
         if (!target) {
             this.printPlans(files);
@@ -20,22 +20,8 @@ export class PlansCommand extends BaseCommand {
         const { plan, file } = this.resolvePlanFile(target, files);
         this.printPlanDetails(plan, file);
     }
-    getPlanFiles() {
-        const plansDir = this.explorBot.getPlansDir();
-        if (!existsSync(plansDir))
-            return [];
-        return readdirSync(plansDir)
-            .filter((file) => file.endsWith('.md'))
-            .map((file) => {
-            const filePath = path.join(plansDir, file);
-            const stat = statSync(filePath);
-            return {
-                name: file,
-                path: filePath,
-                modifiedAt: stat.mtimeMs,
-            };
-        })
-            .sort((left, right) => right.modifiedAt - left.modifiedAt);
+    completeArguments() {
+        return Plan.listFiles(this.explorBot.getPlansDir()).map((file) => ({ value: file.name, display: file.label }));
     }
     printPlans(files) {
         if (files.length === 0) {
@@ -45,8 +31,7 @@ export class PlansCommand extends BaseCommand {
         tag('info').log('Saved plans:');
         for (let i = 0; i < files.length; i++) {
             const file = files[i];
-            const plan = Plan.fromMarkdown(file.path);
-            tag('info').log(`${i + 1}. ${plan.title} (${plan.tests.length} tests) - ${file.name}`);
+            tag('info').log(`${i + 1}. ${file.title} (${file.testCount} tests) - ${file.name}`);
         }
         tag('info').log('');
         tag('info').log(`View plan tests: ${getCliName()} plans <number>`);
@@ -73,10 +58,15 @@ export class PlansCommand extends BaseCommand {
         if (!plan?.filePath) {
             throw new Error(`Plan file not found: ${target}`);
         }
+        const name = path.basename(plan.filePath);
         const file = {
-            name: path.basename(plan.filePath),
+            name,
             path: plan.filePath,
             modifiedAt: statSync(plan.filePath).mtimeMs,
+            title: plan.title,
+            url: plan.startUrl || '',
+            testCount: plan.tests.length,
+            label: name,
         };
         return { plan, file };
     }

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

@@ -1,7 +1,8 @@
-import { BaseCommand } from './base-command.js';
+import { type ArgumentCompletion, BaseCommand } from './base-command.js';
 export declare class RerunCommand extends BaseCommand {
     name: string;
     description: string;
     tuiEnabled: boolean;
     execute(args: string): Promise<void>;
+    completeArguments(): ArgumentCompletion[];
 }

package/dist/src/commands/rerun-command.js

@@ -1,7 +1,8 @@
 import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { basename, resolve } from 'node:path';
 import { ConfigParser } from "../config.js";
 import { tag } from "../utils/logger.js";
+import { listTestFiles } from "../utils/test-files.js";
 import { BaseCommand } from './base-command.js';
 export class RerunCommand extends BaseCommand {
     name = 'rerun';
@@ -26,6 +27,9 @@ export class RerunCommand extends BaseCommand {
         const testIndices = indexArg ? parseTestIndices(indexArg) : undefined;
         await this.explorBot.agentRerunner().rerun(filePath, { testIndices });
     }
+    completeArguments() {
+        return listTestFiles(ConfigParser.getInstance().getTestsDir()).map((file) => ({ value: basename(file) }));
+    }
 }
 function parseTestIndices(input) {
     if (input === '*' || input === 'all')

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

@@ -1,4 +1,4 @@
-import { BaseCommand, type Suggestion } from './base-command.js';
+import { type ArgumentCompletion, BaseCommand, type Suggestion } from './base-command.js';
 export declare class ResearchCommand extends BaseCommand {
     name: string;
     description: string;
@@ -8,4 +8,5 @@ export declare class ResearchCommand extends BaseCommand {
         description: string;
     }[];
     execute(args: string): Promise<void>;
+    completeArguments(): ArgumentCompletion[];
 }