testchimp-runner-core 0.0.35 → 0.0.36

package/src/llm-facade.ts

@@ -1,821 +0,0 @@
-import { PROMPTS } from './prompts';
-import { PageInfo } from './utils/page-info-utils';
-import { StepOperation } from './types';
-import { DEFAULT_MODEL, DEFAULT_SIMPLER_MODEL, VISION_MODEL } from './model-constants';
-import { LLMProvider, LLMRequest, LLMResponse } from './llm-provider';
-
-// LLM Response interfaces
-export interface LLMScenarioBreakdownResponse {
-  steps: string[];
-}
-
-export interface LLMPlaywrightCommandResponse {
-  command: string;
-  reasoning?: string;
-}
-
-export interface LLMTestNameResponse {
-  testName: string;
-}
-
-export interface RepairSuggestionResponse {
-  shouldContinue: boolean;
-  reason: string;
-  action: {
-    operation: StepOperation;
-    stepIndex?: number;
-    newStep?: {
-      description: string;
-      code: string;
-    };
-    insertAfterIndex?: number;
-  };
-}
-
-export interface RepairConfidenceResponse {
-  confidence: number;
-  advice: string;
-}
-
-export interface GoalCompletionResponse {
-  isComplete: boolean;
-  reason: string;
-  nextSubGoal?: string;
-}
-
-export interface ScreenshotNeedResponse {
-  needsScreenshot: boolean;
-  reason: string;
-  alternativeApproach?: string;
-}
-
-export interface VisionDiagnosticResponse {
-  visualAnalysis: string; // What the supervisor sees in the screenshot
-  rootCause: string; // Why previous attempts failed
-  specificInstructions: string; // Exact instructions for the worker agent
-  recommendedApproach: string; // What strategy to use (selector-based, state-based, etc.)
-  elementsFound: string[]; // What elements are actually visible
-  elementsNotFound: string[]; // What elements were expected but not visible
-}
-
-export interface ScenarioStep {
-  stepNumber: number;
-  description: string;
-  playwrightCommand?: string;
-  success?: boolean;
-  error?: string;
-  retryCount?: number;
-  attempts?: Array<{
-    attemptNumber: number;
-    command?: string;
-    success: boolean;
-    error?: string;
-    timestamp: number;
-  }>;
-}
-
-export class LLMFacade {
-  public llmProvider: LLMProvider;  // Expose for orchestrator direct access
-  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
-  private tokenUsageCallback?: (inputTokens: number, outputTokens: number, includesImage: boolean) => void;
-
-  constructor(llmProvider: LLMProvider) {
-    this.llmProvider = llmProvider;
-    this.log('LLMFacade initialized with pluggable LLM provider');
-  }
-  
-  /**
-   * Set token usage callback for tracking
-   */
-  setTokenUsageCallback(callback: (inputTokens: number, outputTokens: number, includesImage: boolean) => void): void {
-    this.tokenUsageCallback = callback;
-  }
-
-  /**
-   * Set a logger callback for capturing execution logs
-   */
-  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
-    this.logger = logger;
-    this.llmProvider.setLogger?.(logger);
-  }
-
-  /**
-   * Log a message using the configured logger
-   */
-  private log(message: string, level: 'log' | 'error' | 'warn' = 'log'): void {
-    if (this.logger) {
-      this.logger(message, level);
-    }
-    // Console fallback for debug visibility
-    if (level === 'error') {
-      console.error(message);
-    } else if (level === 'warn') {
-      console.warn(message);
-    } else {
-      console.log(message);
-    }
-  }
-
-  private async callLLM(request: LLMRequest): Promise<LLMResponse> {
-    try {
-      const response = await this.llmProvider.callLLM(request);
-      
-      // Report token usage if callback is set
-      if (response.usage && this.tokenUsageCallback) {
-        this.tokenUsageCallback(
-          response.usage.inputTokens,
-          response.usage.outputTokens,
-          !!request.imageUrl
-        );
-      }
-      
-      return response;
-    } catch (error: any) {
-      // Let provider handle its own error messages, just re-throw
-      this.log(`LLM call failed: ${error}`, 'error');
-      throw error;
-    }
-  }
-
-  /**
-   * Generate a test name from scenario description
-   */
-  async generateTestName(scenario: string, model: string = DEFAULT_SIMPLER_MODEL): Promise<string> {
-    this.log('Generating test name with LLM...');
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.TEST_NAME_GENERATION.SYSTEM,
-      userPrompt: PROMPTS.TEST_NAME_GENERATION.USER(scenario)
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      const testNameResponse = JSON.parse(response.answer) as LLMTestNameResponse;
-      return testNameResponse.testName;
-    } catch (error) {
-      this.log(`Failed to generate test name: ${error}`, 'error');
-      // Fallback to a simple generated name
-      return `Test: ${scenario.substring(0, 50)}...`;
-    }
-  }
-
-  /**
-   * Generate hashtags for semantic grouping
-   */
-  async generateHashtags(scenario: string, model: string = DEFAULT_SIMPLER_MODEL): Promise<string[]> {
-    this.log('Generating hashtags with LLM...');
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.HASHTAG_GENERATION.SYSTEM,
-      userPrompt: PROMPTS.HASHTAG_GENERATION.USER(scenario)
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      const hashtagResponse = JSON.parse(response.answer) as { hashtags: string[] };
-      return hashtagResponse.hashtags || [];
-    } catch (error) {
-      this.log(`Failed to generate hashtags: ${error}`, 'error');
-      // Fallback to empty array
-      return [];
-    }
-  }
-
-  /**
-   * Check if a goal has been completed based on actions taken and current page state
-   */
-  async checkGoalCompletion(
-    goalDescription: string, 
-    completedActions: string[], 
-    pageInfo: any, 
-    model: string = DEFAULT_MODEL
-  ): Promise<GoalCompletionResponse> {
-    this.log('Checking goal completion with LLM...');
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.GOAL_COMPLETION_CHECK.SYSTEM,
-      userPrompt: PROMPTS.GOAL_COMPLETION_CHECK.USER(goalDescription, completedActions, pageInfo)
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      return JSON.parse(response.answer) as GoalCompletionResponse;
-    } catch (error) {
-      this.log(`Failed to check goal completion: ${error}`, 'error');
-      // Conservative fallback - assume not complete if we can't determine
-      return {
-        isComplete: false,
-        reason: 'Error checking completion status'
-      };
-    }
-  }
-
-  /**
-   * Check goal completion with visual verification (uses vision model)
-   */
-  async checkGoalCompletionWithVision(
-    goalDescription: string,
-    completedActions: string[],
-    pageInfo: any,
-    imageDataUrl: string,
-    model: string = VISION_MODEL
-  ): Promise<GoalCompletionResponse> {
-    this.log(`👔 Checking goal completion with vision (${model})...`);
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: `You are checking if a test automation goal has been completed by analyzing both DOM state and visual appearance.
-
-CRITICAL: For action goals (login, submit, click, navigate), check if the PRIMARY ACTION and its SIDE EFFECTS are complete:
-- "Login" = Fill fields AND click button AND verify navigation/page change
-- "Submit form" = Fill fields AND click submit AND verify submission (success message/page change)
-- "Click X" = Click X AND verify expected page change or UI update
-
-For verification goals (verify, check, confirm), verify the VISUAL PRESENCE of expected elements.`,
-      userPrompt: `GOAL: ${goalDescription}
-
-ACTIONS COMPLETED:
-${completedActions.map((action, i) => `${i + 1}. ${action}`).join('\n')}
-
-CURRENT PAGE STATE:
-URL: ${pageInfo.url}
-Title: ${pageInfo.title}
-Interactive Elements:
-${pageInfo.formattedElements}
-
-Based on the screenshot AND page state, is this goal COMPLETE?
-
-Respond ONLY with valid JSON:
-{
-  "isComplete": true/false,
-  "reason": "Brief explanation based on what you SEE in the screenshot and DOM",
-  "nextSubGoal": "If incomplete, what specific next action is needed?"
-}`,
-      imageUrl: imageDataUrl
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      const parsed = JSON.parse(response.answer) as GoalCompletionResponse;
-      this.log(`👔 Vision goal check result: ${parsed.isComplete ? 'COMPLETE ✅' : 'INCOMPLETE ❌'}`);
-      return parsed;
-    } catch (error) {
-      this.log(`Failed to check goal completion with vision: ${error}`, 'error');
-      // Conservative fallback - assume not complete if we can't determine
-      return {
-        isComplete: false,
-        reason: 'Error checking completion status with vision'
-      };
-    }
-  }
-
-  /**
-   * Ask LLM if a screenshot would help debug the current failure
-   */
-  async assessScreenshotNeed(
-    stepDescription: string,
-    errorMessage: string,
-    attemptCount: number,
-    pageInfo: any,
-    model: string = DEFAULT_SIMPLER_MODEL
-  ): Promise<ScreenshotNeedResponse> {
-    this.log('Assessing screenshot need with LLM...');
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.SCREENSHOT_NEED_ASSESSMENT.SYSTEM,
-      userPrompt: PROMPTS.SCREENSHOT_NEED_ASSESSMENT.USER(stepDescription, errorMessage, attemptCount, pageInfo)
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      return JSON.parse(response.answer) as ScreenshotNeedResponse;
-    } catch (error) {
-      this.log(`Failed to assess screenshot need: ${error}`, 'error');
-      // Conservative fallback - don't use expensive screenshot unless we're sure
-      return {
-        needsScreenshot: false,
-        reason: 'Error assessing need, defaulting to no screenshot'
-      };
-    }
-  }
-
-  /**
-   * Get diagnostic analysis from screenshot (supervisor role)
-   */
-  async getVisionDiagnostics(
-    stepDescription: string,
-    pageInfo: any,
-    previousSteps: any[],
-    lastError: string | undefined,
-    imageDataUrl: string,
-    model: string = VISION_MODEL
-  ): Promise<VisionDiagnosticResponse> {
-    this.log('👔 SUPERVISOR: Analyzing screenshot for diagnostic insights...');
-    
-    const previousCommands = previousSteps
-      .map(s => s.playwrightCommand)
-      .filter(Boolean)
-      .join('\n');
-    
-    const attemptHistory = previousSteps.length > 0
-      ? `Previous attempts context: ${previousSteps.length} commands executed`
-      : '';
-    
-    const errorContext = lastError
-      ? `Last Error: ${lastError}`
-      : '';
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.VISION_DIAGNOSTIC_ANALYSIS.SYSTEM,
-      userPrompt: PROMPTS.VISION_DIAGNOSTIC_ANALYSIS.USER(
-        stepDescription,
-        pageInfo,
-        previousCommands,
-        attemptHistory,
-        errorContext
-      ),
-      imageUrl: imageDataUrl
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      const diagnostics = JSON.parse(response.answer) as VisionDiagnosticResponse;
-      
-      // Log supervisor's findings
-      this.log(`👔 SUPERVISOR ANALYSIS:`);
-      this.log(`   📸 Visual: ${diagnostics.visualAnalysis}`);
-      this.log(`   🔍 Root cause: ${diagnostics.rootCause}`);
-      this.log(`   📋 Instructions: ${diagnostics.specificInstructions}`);
-      this.log(`   💡 Approach: ${diagnostics.recommendedApproach}`);
-      if (diagnostics.elementsFound?.length > 0) {
-        this.log(`   ✅ Elements found: ${diagnostics.elementsFound.join(', ')}`);
-      }
-      if (diagnostics.elementsNotFound?.length > 0) {
-        this.log(`   ❌ Elements NOT found: ${diagnostics.elementsNotFound.join(', ')}`);
-      }
-      
-      return diagnostics;
-    } catch (error) {
-      this.log(`Failed to get vision diagnostics: ${error}`, 'error');
-      throw new Error(`Vision diagnostic analysis failed: ${error}`);
-    }
-  }
-
-  /**
-   * Generate command based on supervisor's instructions
-   */
-  async generateCommandFromSupervisorInstructions(
-    stepDescription: string,
-    supervisorDiagnostics: VisionDiagnosticResponse,
-    pageInfo: any,
-    model: string = DEFAULT_MODEL
-  ): Promise<string> {
-    this.log('🔨 WORKER: Generating command based on supervisor instructions...');
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.PLAYWRIGHT_COMMAND_WITH_SUPERVISOR.SYSTEM,
-      userPrompt: PROMPTS.PLAYWRIGHT_COMMAND_WITH_SUPERVISOR.USER(
-        stepDescription,
-        supervisorDiagnostics.specificInstructions,
-        supervisorDiagnostics.visualAnalysis,
-        supervisorDiagnostics.elementsFound || [],
-        supervisorDiagnostics.elementsNotFound || [],
-        pageInfo
-      )
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      const commandResponse = JSON.parse(response.answer) as LLMPlaywrightCommandResponse;
-      
-      if (commandResponse.reasoning) {
-        this.log(`🔨 WORKER reasoning: ${commandResponse.reasoning}`);
-      }
-      
-      return commandResponse.command;
-    } catch (error) {
-      this.log(`Failed to generate command from supervisor instructions: ${error}`, 'error');
-      throw new Error(`Command generation from supervisor instructions failed: ${error}`);
-    }
-  }
-
-  /**
-   * Generate Playwright command with vision (uses vision model)
-   */
-  async generatePlaywrightCommandWithVision(
-    stepDescription: string,
-    pageInfo: any,
-    previousSteps: any[],
-    lastError: string | undefined,
-    imageDataUrl: string, // Full data URL: data:image/png;base64,...
-    model: string = VISION_MODEL
-  ): Promise<string> {
-    this.log(`⚠️ USING VISION MODE (${model})...`);
-    
-    const previousCommands = previousSteps
-      .map(s => s.playwrightCommand)
-      .filter(Boolean)
-      .join('\n');
-    
-    const attemptHistory = previousSteps.length > 0
-      ? `Previous attempts context: ${previousSteps.length} commands executed`
-      : '';
-    
-    const errorContext = lastError
-      ? `Last Error: ${lastError}`
-      : '';
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.PLAYWRIGHT_COMMAND_WITH_VISION.SYSTEM,
-      userPrompt: PROMPTS.PLAYWRIGHT_COMMAND_WITH_VISION.USER(
-        stepDescription,
-        pageInfo,
-        previousCommands,
-        attemptHistory,
-        errorContext
-      ),
-      imageUrl: imageDataUrl // Full data URL constructed by client
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      const commandResponse = JSON.parse(response.answer) as LLMPlaywrightCommandResponse & { 
-        visualInsights?: string;
-        failureRootCause?: string;
-        recommendedAlternative?: string;
-      };
-      
-      // Log diagnostic insights from vision analysis
-      if (commandResponse.visualInsights) {
-        this.log(`📸 Visual insights: ${commandResponse.visualInsights}`);
-      }
-      
-      if (commandResponse.failureRootCause) {
-        this.log(`🔍 Root cause analysis: ${commandResponse.failureRootCause}`);
-      }
-      
-      if (commandResponse.recommendedAlternative) {
-        this.log(`💡 Recommended alternative: ${commandResponse.recommendedAlternative}`);
-      }
-      
-      if (commandResponse.reasoning) {
-        this.log(`🧠 Vision-based reasoning: ${commandResponse.reasoning}`);
-      }
-      
-      return commandResponse.command;
-    } catch (error) {
-      this.log(`Failed to generate command with vision: ${error}`, 'error');
-      throw new Error(`Vision-enhanced command generation failed: ${error}`);
-    }
-  }
-
-  /**
-   * Break down scenario into steps
-   */
-  async breakdownScenario(scenario: string, model: string = DEFAULT_SIMPLER_MODEL): Promise<ScenarioStep[]> {
-    this.log('Breaking down scenario with LLM...');
-    this.log(`📝 INPUT SCENARIO: ${scenario}`);
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.SCENARIO_BREAKDOWN.SYSTEM,
-      userPrompt: PROMPTS.SCENARIO_BREAKDOWN.USER(scenario)
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      this.log(`🤖 RAW LLM RESPONSE: ${response.answer}`);
-      
-      const breakdownResponse = JSON.parse(response.answer) as LLMScenarioBreakdownResponse;
-      this.log(`📋 PARSED BREAKDOWN: ${JSON.stringify(breakdownResponse, null, 2)}`);
-      
-      // Validate and clean up steps
-      const cleanedSteps = breakdownResponse.steps
-        .map(step => step.trim())
-        .filter(step => step.length > 0)
-        .slice(0, 10); // Limit to 10 steps max
-      
-      this.log(`✅ CLEANED STEPS: ${JSON.stringify(cleanedSteps, null, 2)}`);
-      
-      return cleanedSteps.map((desc, index) => ({
-        stepNumber: index + 1,
-        description: desc,
-      }));
-    } catch (error) {
-      this.log(`❌ Failed to breakdown scenario: ${error}`, 'error');
-      // Fallback to simple breakdown by newlines (preserves URLs)
-      const stepDescriptions = scenario.split('\n').map(s => s.trim()).filter(s => s.length > 0);
-      this.log(`🔄 FALLBACK STEPS: ${JSON.stringify(stepDescriptions, null, 2)}`);
-      return stepDescriptions.map((desc, index) => ({
-        stepNumber: index + 1,
-        description: desc,
-      }));
-    }
-  }
-
-  /**
-   * Generate Playwright command for a step
-   */
-  async generatePlaywrightCommand(
-    stepDescription: string,
-    pageInfo: PageInfo,
-    previousSteps: ScenarioStep[],
-    lastError?: string,
-    currentStep?: ScenarioStep,
-    model: string = DEFAULT_MODEL
-  ): Promise<string | null> {
-    this.log('Generating Playwright command with LLM...');
-    
-    const previousCommands = previousSteps
-      .filter(s => s.playwrightCommand && s.success)
-      .map(s => `// Step ${s.stepNumber}: ${s.description}\n${s.playwrightCommand}`)
-      .join('\n');
-
-    // Build comprehensive attempt history for current step
-    const attemptHistory = this.buildAttemptHistory(currentStep);
-    
-    // Provide raw error context for LLM analysis
-    const errorContext = this.buildErrorContext(lastError, currentStep);
-
-    const prompt = PROMPTS.PLAYWRIGHT_COMMAND.USER(
-      stepDescription,
-      pageInfo,
-      previousCommands,
-      attemptHistory,
-      errorContext
-    );
-
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.PLAYWRIGHT_COMMAND.SYSTEM,
-      userPrompt: prompt
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      const commandResponse = JSON.parse(response.answer) as LLMPlaywrightCommandResponse;
-      return commandResponse.command;
-    } catch (error) {
-      this.log(`Failed to generate Playwright command: ${error}`, 'error');
-      return null;
-    }
-  }
-
-  /**
-   * Parse script into steps for AI repair
-   */
-  async parseScriptIntoSteps(script: string, model: string = DEFAULT_SIMPLER_MODEL): Promise<Array<{ description: string; code: string; success?: boolean; error?: string }>> {
-    this.log('Parsing script into steps with LLM...');
-    
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.SCRIPT_PARSING.SYSTEM,
-      userPrompt: PROMPTS.SCRIPT_PARSING.USER(script)
-    };
-
-    try {
-      const response = await this.callLLM(request);
-      this.log(`Raw LLM parsing response (first 500 chars): ${response.answer.substring(0, 500)}`);
-      
-      const parsed = JSON.parse(response.answer);
-      this.log(`Parsed JSON structure: ${JSON.stringify(parsed, null, 2).substring(0, 1000)}`);
-      
-      // Expect JSON object with steps array
-      if (parsed.steps && Array.isArray(parsed.steps)) {
-        this.log(`LLM parsing successful, got ${parsed.steps.length} steps`);
-        return parsed.steps;
-      } else {
-        this.log(`Unexpected LLM response format - expected {steps: [...]}: ${JSON.stringify(parsed)}`, 'error');
-        return [];
-      }
-    } catch (error) {
-      this.log(`Failed to parse LLM response as JSON: ${error}`, 'error');
-      return [];
-    }
-  }
-
-  /**
-   * Get repair suggestion for a failing step
-   */
-  async getRepairSuggestion(
-    stepDescription: string,
-    stepCode: string,
-    errorMessage: string,
-    pageInfo: PageInfo,
-    failureHistory: string,
-    recentRepairs: string,
-    model: string = DEFAULT_MODEL
-  ): Promise<RepairSuggestionResponse> {
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.REPAIR_SUGGESTION.SYSTEM,
-      userPrompt: PROMPTS.REPAIR_SUGGESTION.USER(
-        stepDescription,
-        stepCode,
-        errorMessage,
-        pageInfo,
-        failureHistory,
-        recentRepairs,
-      )
-    };
-
-    const response = await this.callLLM(request);
-    this.log(`🤖 LLM Repair Response: ${response.answer}`);
-    const parsed = JSON.parse(response.answer) as any;
-    this.log(`🤖 Parsed Repair Action: ${JSON.stringify(parsed)}`);
-    
-    // Convert string operation to enum
-    if (parsed.action && parsed.action.operation) {
-      switch (parsed.action.operation) {
-        case 'MODIFY':
-          parsed.action.operation = StepOperation.MODIFY;
-          break;
-        case 'INSERT':
-          parsed.action.operation = StepOperation.INSERT;
-          break;
-        case 'REMOVE':
-          parsed.action.operation = StepOperation.REMOVE;
-          break;
-        default:
-          parsed.action.operation = StepOperation.MODIFY;
-      }
-    }
-    
-    return parsed as RepairSuggestionResponse;
-  }
-
-  /**
-   * Assess repair confidence and generate advice
-   */
-  async assessRepairConfidence(
-    originalScript: string,
-    updatedScript: string,
-    model: string = DEFAULT_SIMPLER_MODEL
-  ): Promise<RepairConfidenceResponse> {
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.REPAIR_CONFIDENCE.SYSTEM,
-      userPrompt: PROMPTS.REPAIR_CONFIDENCE.USER(originalScript, updatedScript)
-    };
-
-    const response = await this.callLLM(request);
-    return JSON.parse(response.answer) as RepairConfidenceResponse;
-  }
-
-  /**
-   * Generate final script with repair advice
-   */
-  async generateFinalScript(
-    originalScript: string,
-    updatedScript: string,
-    newRepairAdvice: string,
-    model: string = DEFAULT_SIMPLER_MODEL
-  ): Promise<string> {
-    const request: LLMRequest = {
-      model,
-      systemPrompt: PROMPTS.FINAL_SCRIPT.SYSTEM,
-      userPrompt: PROMPTS.FINAL_SCRIPT.USER(originalScript, updatedScript, newRepairAdvice)
-    };
-
-    const response = await this.callLLM(request);
-    try {
-      const parsed = JSON.parse(response.answer);
-      return parsed.script || updatedScript;
-    } catch (error) {
-      this.log(`Failed to parse final script response: ${error}`, 'error');
-      return updatedScript;
-    }
-  }
-
-  /**
-   * Build attempt history for current step
-   */
-  private buildAttemptHistory(currentStep?: ScenarioStep): string {
-    if (!currentStep || !currentStep.attempts || currentStep.attempts.length === 0) {
-      return 'This is the first attempt for this step.';
-    }
-
-    const attempts = currentStep.attempts.map((attempt, index) => {
-      const status = attempt.success ? '✅ SUCCESS' : '❌ FAILED';
-      return `Attempt ${attempt.attemptNumber} (${status}):
-  Command: ${attempt.command || 'No command generated'}
-  ${attempt.error ? `Error: ${attempt.error}` : 'No error'}
-  Timestamp: ${new Date(attempt.timestamp).toISOString()}`;
-    }).join('\n\n');
-
-    return `Current step attempt history:
-${attempts}
-
-LEARNING FROM FAILURES:
-- Analyze what went wrong in each attempt
-- Try completely different approaches for failed attempts
-- If a selector failed, try alternative selectors
-- If timing failed, add proper waits
-- If element not found, try different strategies`;
-  }
-
-  /**
-   * Build error context for LLM analysis
-   */
-  private buildErrorContext(lastError?: string, currentStep?: ScenarioStep): string {
-    if (!lastError && (!currentStep || !currentStep.error)) {
-      return '';
-    }
-
-    const errors = [];
-    if (lastError) errors.push(lastError);
-    if (currentStep?.error) errors.push(currentStep.error);
-
-    const errorText = errors.join(' | ');
-    
-    // Detect if we're repeatedly looking for elements that don't exist
-    const attemptedCommands = currentStep?.attempts
-      ?.map(a => a.command)
-      .filter(Boolean) || [];
-    
-    const lookingForNonExistent = attemptedCommands.some(cmd => 
-      cmd?.includes('getByText') || 
-      cmd?.includes('toBeVisible') ||
-      cmd?.includes('waitFor')
-    ) && errors.some(err => 
-      err.includes('not found') || 
-      err.includes('Timeout') ||
-      err.includes('Expected: visible')
-    );
-    
-    let hallucinationWarning = '';
-    if (lookingForNonExistent && attemptedCommands.length >= 2) {
-      hallucinationWarning = `
-⚠️ HALLUCINATION ALERT:
-You've made ${attemptedCommands.length} attempts trying to find/verify elements that don't exist.
-STOP looking for these elements. They are NOT in the DOM.
-Instead:
-- Check if the goal is ALREADY COMPLETE (action succeeded = goal done)
-- Use alternative verification (state changes, network, page load)
-- Move on if the primary action succeeded
-`;
-    }
-    
-    return `ERROR CONTEXT:
-Last Error: ${errorText}
-${hallucinationWarning}
-ANALYZE THE ERROR AND ADAPT:
-- Study the error message to understand what went wrong
-- If element "not found" after 2+ attempts, it probably doesn't exist - stop looking for it
-- Try a completely different approach than what failed
-- Consider alternative selectors, timing, or interaction methods
-- Never repeat the exact same command that failed`;
-  }
-
-  /**
-   * Cleanup generated script - remove redundancies and make minor adjustments
-   */
-  async cleanupScript(script: string, model?: string): Promise<{ script: string; changes: string[]; skipped?: string }> {
-    try {
-      const response = await this.llmProvider.callLLM({
-        model: model || DEFAULT_MODEL,
-        systemPrompt: PROMPTS.SCRIPT_CLEANUP.SYSTEM,
-        userPrompt: PROMPTS.SCRIPT_CLEANUP.USER(script)
-      });
-
-      // Parse JSON response
-      const jsonMatch = response.answer.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) {
-        console.log('[LLMFacade] Cleanup response not in JSON format, returning original script');
-        return { script, changes: [], skipped: 'Response not in JSON format' };
-      }
-
-      const parsed = JSON.parse(jsonMatch[0]);
-      
-      // Validate response
-      if (!parsed.script) {
-        console.log('[LLMFacade] Cleanup response missing script field, returning original');
-        return { script, changes: [], skipped: 'Invalid response format' };
-      }
-
-      console.log(`[LLMFacade] Script cleanup completed. Changes: ${parsed.changes?.length || 0}`);
-      if (parsed.changes && parsed.changes.length > 0) {
-        parsed.changes.forEach((change: string, i: number) => {
-          console.log(`[LLMFacade]   ${i + 1}. ${change}`);
-        });
-      }
-
-      return {
-        script: parsed.script,
-        changes: parsed.changes || [],
-        skipped: parsed.skipped
-      };
-    } catch (error: any) {
-      console.error('[LLMFacade] Script cleanup failed:', error.message);
-      // Return original script on error
-      return { script, changes: [], skipped: `Error: ${error.message}` };
-    }
-  }
-}