testchimp-runner-core 0.0.34 → 0.0.36

package/src/execution-service.ts

@@ -1,1413 +0,0 @@
-import { PlaywrightMCPService as PlaywrightService } from './playwright-mcp-service';
-import { 
-  PlaywrightExecutionRequest, 
-  PlaywrightExecutionResponse, 
-  ScriptResult,
-  ScriptExecutionRequest,
-  ScriptExecutionResponse,
-  ScriptStep,
-  ExecutionMode,
-  StepOperation,
-  StepRepairAction
-} from './types';
-import { RepairSuggestionResponse, RepairConfidenceResponse } from './llm-facade';
-import { getEnhancedPageInfo, PageInfo } from './utils/page-info-utils';
-import { initializeBrowser, captureOptimizedScreenshot } from './utils/browser-utils';
-import { LLMFacade } from './llm-facade';
-import { AuthConfig } from './auth-config';
-import { addTestChimpComment } from './script-utils';
-import { CreditUsageService } from './credit-usage-service';
-import { DEFAULT_MODEL, VISION_MODEL } from './model-constants';
-import { LLMProvider } from './llm-provider';
-import { ProgressReporter } from './progress-reporter';
-import { BackendProxyLLMProvider } from './providers/backend-proxy-llm-provider';
-
-/**
- * Service for orchestrating Playwright script execution
- */
-export class ExecutionService {
-  private playwrightService: PlaywrightService;
-  private llmFacade: LLMFacade;
-  private llmProvider: LLMProvider;
-  private progressReporter?: ProgressReporter;
-  private creditUsageService: CreditUsageService;
-  private maxConcurrentExecutions: number;
-  private activeExecutions: Set<Promise<any>> = new Set();
-  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
-
-  constructor(
-    authConfig?: AuthConfig,
-    backendUrl?: string,
-    maxConcurrentExecutions: number = 10,
-    llmProvider?: LLMProvider,
-    progressReporter?: ProgressReporter
-  ) {
-    this.playwrightService = new PlaywrightService();
-    
-    // Use provided LLM provider or default to backend proxy (backward compatible)
-    this.llmProvider = llmProvider || new BackendProxyLLMProvider(authConfig, backendUrl);
-    this.llmFacade = new LLMFacade(this.llmProvider);
-    
-    this.progressReporter = progressReporter;
-    this.creditUsageService = new CreditUsageService(authConfig, backendUrl);
-    this.maxConcurrentExecutions = maxConcurrentExecutions;
-  }
-
-  /**
-   * Set a logger callback for capturing execution logs
-   */
-  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
-    this.logger = 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);
-    }
-    // No console fallback - logs are routed to consumer
-  }
-
-  /**
-   * Initialize the execution service
-   */
-  async initialize(): Promise<void> {
-    await this.playwrightService.initialize();
-  }
-
-  /**
-   * Set authentication configuration for the service
-   * Note: This recreates the LLM provider with new auth config
-   */
-  setAuthConfig(authConfig: AuthConfig): void {
-    // Recreate LLM provider with new auth config
-    this.llmProvider = new BackendProxyLLMProvider(authConfig, undefined);
-    this.llmFacade = new LLMFacade(this.llmProvider);
-    this.creditUsageService.setAuthConfig(authConfig);
-  }
-
-
-  /**
-   * Execute a script with optional AI repair capabilities
-   */
-  async executeScript(request: ScriptExecutionRequest): Promise<ScriptExecutionResponse> {
-    // Wait for available slot if at max concurrency
-    while (this.activeExecutions.size >= this.maxConcurrentExecutions) {
-      await Promise.race(this.activeExecutions);
-    }
-
-    // Create execution promise and track it
-    const executionPromise = this.executeScriptInternal(request);
-    this.activeExecutions.add(executionPromise);
-
-    try {
-      const result = await executionPromise;
-      return result;
-    } finally {
-      this.activeExecutions.delete(executionPromise);
-    }
-  }
-
-  /**
-   * Internal script execution method
-   */
-  private async executeScriptInternal(request: ScriptExecutionRequest): Promise<ScriptExecutionResponse> {
-    const startTime = Date.now();
-    const model = request.model || DEFAULT_MODEL;
-    
-    try {
-      if (request.mode === ExecutionMode.RUN_EXACTLY) {
-        return await this.runExactly(request, startTime);
-      } else {
-        return await this.runWithAIRepair(request, startTime, model);
-      }
-    } catch (error) {
-      return {
-        runStatus: 'failed',
-        executionTime: Date.now() - startTime,
-        error: error instanceof Error ? error.message : 'Unknown error'
-      };
-    }
-  }
-
-  /**
-   * Execute a complete Playwright test suite as a single job
-   */
-  async executeTestSuite(request: PlaywrightExecutionRequest): Promise<PlaywrightExecutionResponse> {
-    try {
-      // Parse Playwright configuration
-      const config = this.parsePlaywrightConfig(request.playwrightConfig);
-
-      // Execute the entire job (prescript + script + postscript) as one unit
-      const jobResult = await this.playwrightService.executeJob(
-        request.prescript,
-        request.script,
-        request.postscript,
-        config
-      );
-
-      return {
-        success: jobResult.success,
-        results: jobResult.results,
-        executionTime: jobResult.executionTime,
-        error: jobResult.error
-      };
-
-    } catch (error) {
-      return {
-        success: false,
-        results: {
-          script: { success: false, output: '', error: '', executionTime: 0 }
-        },
-        executionTime: 0,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Parse Playwright configuration from string
-   */
-  private parsePlaywrightConfig(configString: string): any {
-    try {
-      // Try to parse as JSON first
-      const config = JSON.parse(configString);
-      return {
-        browserType: config.browserType || 'chromium',
-        headless: config.headless === true,
-        viewport: config.viewport || { width: 1280, height: 720 },
-        options: config.options || {}
-      };
-    } catch {
-      // If not JSON, try to extract basic config from JavaScript
-      try {
-        // Simple regex-based extraction for common config patterns
-        const headlessMatch = configString.match(/headless:\s*(true|false)/);
-        const viewportMatch = configString.match(/viewport:\s*\{\s*width:\s*(\d+),\s*height:\s*(\d+)\s*\}/);
-        const browserMatch = configString.match(/browserType:\s*['"`](chromium|firefox|webkit)['"`]/);
-        
-        return {
-          browserType: browserMatch ? browserMatch[1] : 'chromium',
-          headless: headlessMatch ? headlessMatch[1] === 'true' : true,
-          viewport: viewportMatch ? 
-            { width: parseInt(viewportMatch[1]), height: parseInt(viewportMatch[2]) } : 
-            { width: 1280, height: 720 },
-          options: {}
-        };
-      } catch {
-        // Return default config if parsing fails
-        return {
-          browserType: 'chromium',
-          headless: false,
-          viewport: { width: 1280, height: 720 },
-          options: {}
-        };
-      }
-    }
-  }
-
-  /**
-   * Close the execution service
-   */
-  async close(): Promise<void> {
-    await this.playwrightService.close();
-  }
-
-  /**
-   * Check if the service is ready
-   */
-  isReady(): boolean {
-    return this.playwrightService.isReady();
-  }
-
-  private async runExactly(request: ScriptExecutionRequest, startTime: number, model?: string): Promise<ScriptExecutionResponse> {
-    // deflakeRunCount: number of deflake attempts (0 means no deflaking, just one attempt)
-    const deflakeRunCount = request.deflakeRunCount !== undefined ? request.deflakeRunCount : 0;
-    const totalAttempts = deflakeRunCount + 1; // Original run + deflake attempts
-    let lastError: Error | null = null;
-    
-    this.log(`runExactly: deflakeRunCount = ${deflakeRunCount}, totalAttempts = ${totalAttempts}`);
-
-    // Script content should be provided by the caller (TestChimpService)
-    // The TestChimpService handles file reading through the appropriate FileHandler
-    if (!request.script) {
-      throw new Error('Script content is required for execution. The TestChimpService should read the file and provide script content.');
-    }
-
-    // Check if we should use existing browser or create new one
-    const useExistingBrowser = !!(request.existingBrowser && request.existingContext && request.existingPage);
-    
-    if (useExistingBrowser) {
-      this.log('Using existing browser/page provided by caller - single attempt only (no internal deflaking)');
-      // Single attempt with existing browser (caller handles deflaking by creating fresh browsers)
-      const browser = request.existingBrowser;
-      const context = request.existingContext;
-      const page = request.existingPage;
-      
-      try {
-        // LIFECYCLE: Call beforeStartTest if provided
-        if (this.progressReporter?.beforeStartTest) {
-          await this.progressReporter.beforeStartTest(page, browser, context);
-        }
-        
-        // Execute the script as-is
-        await this.executeScriptContent(request.script, page);
-        
-        // LIFECYCLE: Call afterEndTest on success
-        if (this.progressReporter?.afterEndTest) {
-          await this.progressReporter.afterEndTest('passed', undefined, page);
-        }
-        
-        // Don't close browser - caller owns it
-        
-        return {
-          runStatus: 'success',
-          numDeflakeRuns: 0,
-          executionTime: Date.now() - startTime
-        };
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error('Script execution failed');
-        this.log(`Execution failed: ${lastError.message}`);
-        
-        // LIFECYCLE: Call afterEndTest on failure
-        if (this.progressReporter?.afterEndTest) {
-          try {
-            await this.progressReporter.afterEndTest('failed', lastError.message, page);
-          } catch (callbackError) {
-            this.log(`afterEndTest callback failed: ${callbackError}`, 'warn');
-          }
-        }
-        
-        return {
-          runStatus: 'failed',
-          numDeflakeRuns: 0,
-          executionTime: Date.now() - startTime,
-          error: lastError.message
-        };
-      }
-    }
-
-    // Create our own browser (original behavior)
-    for (let attempt = 1; attempt <= totalAttempts; attempt++) {
-      this.log(`Attempting deflake run ${attempt}/${totalAttempts}`);
-      const { browser, context, page } = await this.initializeBrowser(request.playwrightConfig, request.headless, request.playwrightConfigFilePath);
-
-      try {
-        // LIFECYCLE: Call beforeStartTest if provided
-        if (this.progressReporter?.beforeStartTest) {
-          await this.progressReporter.beforeStartTest(page, browser, context);
-        }
-        
-        // Execute the script as-is
-        await this.executeScriptContent(request.script, page);
-        
-        // LIFECYCLE: Call afterEndTest on success
-        if (this.progressReporter?.afterEndTest) {
-          await this.progressReporter.afterEndTest('passed', undefined, page);
-        }
-        
-        await browser.close();
-        
-        // Success! Return immediately
-        return {
-          runStatus: 'success',
-          numDeflakeRuns: attempt - 1, // Count only deflaking runs (exclude original run)
-          executionTime: Date.now() - startTime
-        };
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error('Script execution failed');
-        this.log(`Initial run failed: ${lastError.message}`);
-        
-        // LIFECYCLE: Call afterEndTest on failure
-        if (this.progressReporter?.afterEndTest) {
-          try {
-            await this.progressReporter.afterEndTest('failed', lastError.message, page);
-          } catch (callbackError) {
-            this.log(`afterEndTest callback failed: ${callbackError}`, 'warn');
-          }
-        }
-        
-        try {
-          await browser.close();
-        } catch (closeError) {
-          // Browser might already be closed
-        }
-
-        // If this is not the last attempt, continue to next attempt
-        if (attempt < totalAttempts) {
-          this.log(`Deflaking attempt ${attempt} failed, trying again... (${attempt + 1}/${totalAttempts})`);
-          continue;
-        }
-      }
-    }
-
-    // All attempts failed
-    return {
-      runStatus: 'failed',
-      numDeflakeRuns: deflakeRunCount, // Count only deflaking runs (exclude original run)
-      executionTime: Date.now() - startTime,
-      error: lastError?.message || 'All deflaking attempts failed'
-    };
-  }
-
-  private async runWithAIRepair(request: ScriptExecutionRequest, startTime: number, model: string): Promise<ScriptExecutionResponse> {
-    const repairFlexibility = request.repairFlexibility || 3;
-    const attemptRunExactlyFirst = request.attemptRunExactlyFirst || false;
-
-    // Script content is required UNLESS pre-parsed steps are provided
-    if (!request.script && (!request.steps || request.steps.length === 0)) {
-      throw new Error('Script content is required for AI repair. The TestChimpService should read the file and provide script content.');
-    }
-
-    // Check if we should use existing browser
-    const useExistingBrowser = !!(request.existingBrowser && request.existingContext && request.existingPage);
-
-    // Optionally try runExactly first (with deflaking if specified)
-    if (attemptRunExactlyFirst) {
-      const deflakeCount = request.deflakeRunCount || 0;
-      this.log(`Attempting runExactly first with ${deflakeCount} deflake attempts...`);
-      const runExactlyResult = await this.runExactly({
-        ...request,
-        mode: ExecutionMode.RUN_EXACTLY,
-        deflakeRunCount: deflakeCount
-      }, startTime, model);
-      
-      if (runExactlyResult.runStatus === 'success') {
-        this.log('runExactly succeeded, returning without AI repair');
-        return runExactlyResult;
-      }
-      
-      this.log('runExactly failed, proceeding with AI repair...');
-    }
-
-    // Start AI repair process
-    this.log('Starting AI repair process...');
-
-    try {
-        let repairBrowser, repairContext, repairPage, steps, updatedSteps;
-        
-        if (useExistingBrowser) {
-          // Use existing browser
-          this.log('Using existing browser for AI repair...');
-          repairBrowser = request.existingBrowser;
-          repairContext = request.existingContext;
-          repairPage = request.existingPage;
-          
-          // Use pre-parsed steps if provided (preserves step IDs from canonical tree),
-          // otherwise parse script into steps
-          if (request.steps && request.steps.length > 0) {
-            this.log(`Using ${request.steps.length} pre-parsed steps (IDs preserved)`);
-            steps = request.steps;
-          } else {
-            this.log('Parsing script into steps...');
-            if (!request.script) {
-              throw new Error('Script is required when steps are not provided');
-            }
-            steps = await this.parseScriptIntoSteps(request.script, model);
-          }
-          
-          // LIFECYCLE: Call beforeStartTest if provided
-          if (this.progressReporter?.beforeStartTest) {
-            await this.progressReporter.beforeStartTest(repairPage, repairBrowser, repairContext);
-          }
-          
-          this.log('Starting AI repair with parsed steps...');
-          updatedSteps = await this.repairStepsWithAI(steps, repairPage, repairFlexibility, model, request.jobId);
-        } else {
-          // Use pre-parsed steps if provided, otherwise parse script
-          if (request.steps && request.steps.length > 0) {
-            this.log(`Using ${request.steps.length} pre-parsed steps (IDs preserved)`);
-            this.log('Initializing repair browser...');
-            steps = request.steps;
-            const browserInstance = await this.initializeBrowser(request.playwrightConfig, request.headless, request.playwrightConfigFilePath);
-            repairBrowser = browserInstance.browser;
-            repairContext = browserInstance.context;
-            repairPage = browserInstance.page;
-          } else {
-            // Start browser initialization and script parsing in parallel for faster startup
-            this.log('Initializing repair browser and parsing script...');
-            if (!request.script) {
-              throw new Error('Script is required when steps are not provided');
-            }
-            const results = await Promise.all([
-              this.parseScriptIntoSteps(request.script, model),
-              this.initializeBrowser(request.playwrightConfig, request.headless, request.playwrightConfigFilePath) // Use request.headless (defaults to false/headed)
-            ]);
-            
-            steps = results[0];
-            repairBrowser = results[1].browser;
-            repairContext = results[1].context;
-            repairPage = results[1].page;
-          }
-          
-          // LIFECYCLE: Call beforeStartTest if provided
-          if (this.progressReporter?.beforeStartTest) {
-            await this.progressReporter.beforeStartTest(repairPage, repairBrowser, repairContext);
-          }
-          
-          this.log('Starting AI repair with parsed steps...');
-          updatedSteps = await this.repairStepsWithAI(steps, repairPage, repairFlexibility, model, request.jobId);
-        }
-        
-        // Always generate the updated script
-        const updatedScript = this.generateUpdatedScript(updatedSteps);
-        
-        // Check if repair was successful by seeing if we completed all steps
-        const allStepsSuccessful = updatedSteps.length > 0 && updatedSteps.every(step => step.success);
-        
-        // Check if we have any successful repairs (partial success)
-        const hasSuccessfulRepairs = updatedSteps.some(step => step.success);
-        
-        // Debug: Log step success status
-        this.log('Step success status: ' + updatedSteps.map((step, index) => `Step ${index + 1}: ${step.success ? 'SUCCESS' : 'FAILED'}`).join(', '));
-        this.log(`All steps successful: ${allStepsSuccessful}`);
-        this.log(`Has successful repairs: ${hasSuccessfulRepairs}`);
-        
-        // Debug: Log individual step details
-        updatedSteps.forEach((step, index) => {
-          this.log(`Step ${index + 1} details: success=${step.success}, description="${step.description}"`);
-        });
-        
-        // Update file if we have any successful repairs (partial or complete)
-        if (hasSuccessfulRepairs) {
-          const confidenceResponse = await this.llmFacade.assessRepairConfidence(request.script!, updatedScript, model);
-          const finalScript = await this.llmFacade.generateFinalScript(request.script!, updatedScript, confidenceResponse.advice, model);
-          
-          // Ensure the final script has the correct TestChimp comment format with repair advice
-          const scriptWithRepairAdvice = addTestChimpComment(finalScript, confidenceResponse.advice);
-          
-          // Report credit usage for successful AI repair
-          this.creditUsageService.reportAIRepairCredit().catch(error => {
-            this.log(`Failed to report credit usage for AI repair: ${error}`, 'warn');
-          });
-          
-          // LIFECYCLE: Call afterEndTest (partial or complete success)
-          if (this.progressReporter?.afterEndTest) {
-            try {
-              await this.progressReporter.afterEndTest(
-                allStepsSuccessful ? 'passed' : 'failed',
-                allStepsSuccessful ? undefined : 'Partial repair success',
-                repairPage
-              );
-            } catch (callbackError) {
-              this.log(`afterEndTest callback failed: ${callbackError}`, 'warn');
-            }
-          }
-          
-          // Only close browser if we created it (not provided by caller)
-          if (!useExistingBrowser) {
-            await repairBrowser.close();
-          }
-          
-          return {
-            runStatus: 'failed', // Original script failed
-            repairStatus: allStepsSuccessful ? 'success' : 'partial', // Complete or partial repair success
-            repairConfidence: confidenceResponse.confidence,
-            repairAdvice: confidenceResponse.advice,
-            updatedScript: scriptWithRepairAdvice, // Return the drop-in replacement script with proper TestChimp comment
-            numDeflakeRuns: 0, // Deflaking is handled by caller before calling runWithAIRepair
-            executionTime: Date.now() - startTime
-          };
-        } else {
-          // No successful repairs at all
-          
-          // LIFECYCLE: Call afterEndTest (complete failure)
-          if (this.progressReporter?.afterEndTest) {
-            try {
-              await this.progressReporter.afterEndTest('failed', 'AI repair could not fix any steps', repairPage);
-            } catch (callbackError) {
-              this.log(`afterEndTest callback failed: ${callbackError}`, 'warn');
-            }
-          }
-          
-          // Only close browser if we created it (not provided by caller)
-          if (!useExistingBrowser) {
-            await repairBrowser.close();
-          }
-          
-          return {
-            runStatus: 'failed', // Original script failed
-            repairStatus: 'failed',
-            repairConfidence: 0,
-            repairAdvice: 'AI repair could not fix any steps',
-            updatedScript: request.script!, // Return original script since no repairs were successful
-            numDeflakeRuns: 0, // Deflaking is handled by caller before calling runWithAIRepair
-            executionTime: Date.now() - startTime,
-            error: 'AI repair could not fix any steps'
-          };
-        }
-    } catch (error) {
-      return {
-        runStatus: 'failed',
-        repairStatus: 'failed',
-        numDeflakeRuns: 0, // Deflaking is handled by caller before calling runWithAIRepair
-        executionTime: Date.now() - startTime,
-        error: error instanceof Error ? error.message : 'Script execution failed'
-      };
-    }
-  }
-
-  private async parseScriptIntoSteps(script: string, model: string): Promise<(ScriptStep & { success?: boolean; error?: string })[]> {
-    // First try LLM-based parsing
-    try {
-      this.log('Attempting LLM-based script parsing...');
-      const result = await this.llmFacade.parseScriptIntoSteps(script, model);
-      this.log(`LLM parsing successful, got ${result.length} steps`);
-      return result;
-    } catch (error) {
-      this.log(`LLM parsing failed, falling back to code parsing: ${error}`);
-      const fallbackResult = this.parseScriptIntoStepsFallback(script);
-      this.log(`Fallback parsing successful, got ${fallbackResult.length} steps`);
-      return fallbackResult;
-    }
-  }
-
-
-  private parseScriptIntoStepsFallback(script: string): (ScriptStep & { success?: boolean; error?: string })[] {
-    const lines = script.split('\n');
-    const steps: (ScriptStep & { success?: boolean; error?: string })[] = [];
-    let currentStep: ScriptStep | null = null;
-    let currentCode: string[] = [];
-
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-      
-      // Check for step comment
-      if (trimmedLine.startsWith('// Step ')) {
-        // Save previous step if exists and has code
-        if (currentStep) {
-          const code = currentCode.join('\n').trim();
-          const cleanedCode = this.cleanStepCode(code);
-          if (cleanedCode) {
-            currentStep.code = cleanedCode;
-            steps.push(currentStep);
-          }
-        }
-        
-        // Start new step
-        const description = trimmedLine.replace(/^\/\/\s*Step\s*\d+:\s*/, '').replace(/\s*\[FAILED\]\s*$/, '').trim();
-        currentStep = { description, code: '' };
-        currentCode = [];
-      } else if (trimmedLine && !trimmedLine.startsWith('import') && !trimmedLine.startsWith('test(') && !trimmedLine.startsWith('});')) {
-        // Add code line to current step
-        if (currentStep) {
-          currentCode.push(line);
-        }
-      }
-    }
-
-    // Add the last step if it has code
-    if (currentStep) {
-      const code = currentCode.join('\n').trim();
-      const cleanedCode = this.cleanStepCode(code);
-      if (cleanedCode) {
-        currentStep.code = cleanedCode;
-        steps.push(currentStep);
-      }
-    }
-
-    return steps;
-  }
-
-  private async repairStepsWithAI(
-    steps: (ScriptStep & { success?: boolean; error?: string })[], 
-    page: any, 
-    repairFlexibility: number,
-    model: string,
-    jobId?: string
-  ): Promise<(ScriptStep & { success?: boolean; error?: string })[]> {
-    let updatedSteps = [...steps];
-    const maxTries = 3;
-    const recentRepairs: Array<{
-      stepNumber: number;
-      operation: string;
-      originalDescription?: string;
-      newDescription?: string;
-      originalCode?: string;
-      newCode?: string;
-    }> = [];
-
-    // Create a shared execution context that accumulates all executed code for variable tracking
-    let executionContext = '';
-    const contextVariables = new Map<string, any>();
-
-    let i = 0;
-    while (i < updatedSteps.length) {
-      const step = updatedSteps[i];
-      this.log(`Loop iteration: i=${i}, step description="${step.description}", total steps=${updatedSteps.length}`);
-      
-      try {
-        // LIFECYCLE: Call beforeStepStart if provided
-        if (this.progressReporter?.beforeStepStart) {
-          await this.progressReporter.beforeStepStart(
-            {
-              stepId: step.id, // Preserve original step ID if provided
-              stepNumber: i + 1,
-              description: step.description,
-              code: step.code
-            },
-            page
-          );
-        }
-        
-        // Try to execute the step directly without context replay
-        this.log(`Attempting Step ${i + 1}: ${step.description}`);
-        this.log(`  Code: ${step.code}`);
-        await this.executeStepCode(step.code, page);
-        step.success = true;
-        this.log(`Step ${i + 1} executed successfully: ${step.description}`);
-        this.log(`Step ${i + 1} success status set to: ${step.success}`);
-        
-        // Report successful step execution
-        this.log(`DEBUG: About to check callback - progressReporter=${!!this.progressReporter}, onStepProgress=${!!this.progressReporter?.onStepProgress}, jobId=${jobId}`);
-        if (this.progressReporter?.onStepProgress && jobId) {
-          this.log(`DEBUG: Firing onStepProgress callback for step ${i + 1}, stepId=${step.id}`);
-          await this.progressReporter.onStepProgress({
-            jobId,
-            stepId: step.id, // Preserve original step ID if provided
-            stepNumber: i + 1,
-            description: step.description,
-            code: step.code,
-            status: 'SUCCESS_STEP_EXECUTION' as any,
-            wasRepaired: false
-          });
-          this.log(`DEBUG: onStepProgress callback completed for step ${i + 1}`);
-        } else {
-          this.log(`DEBUG: Skipping callback - conditions not met`);
-        }
-        
-        // Add this step's code to the execution context for future steps (for variable tracking)
-        executionContext += step.code + '\n';
-        i++; // Move to next step
-      } catch (error) {
-        this.log(`Step ${i + 1} failed: ${step.description}`);
-        this.log(`  Failed code: ${step.code}`);
-        this.log(`  Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        if (error instanceof Error && error.stack) {
-          this.log(`  Stack trace: ${error.stack}`);
-        }
-        step.success = false;
-        step.error = this.safeSerializeError(error);
-
-        // Try multiple repair attempts
-        const repairHistory: Array<{
-          attempt: number;
-          action: StepRepairAction;
-          error: string;
-          pageInfo: PageInfo;
-        }> = [];
-
-        let repairSuccess = false;
-        const originalDescription = step.description;
-        const originalCode = step.code;
-        let usedVisionMode = false;
-        
-        for (let attempt = 1; attempt <= maxTries; attempt++) {
-          this.log(`Step ${i + 1} repair attempt ${attempt}/${maxTries}`);
-          
-          // Get current page state for AI repair
-          const pageInfo = await this.getEnhancedPageInfo(page);
-          
-          // Build failure history for LLM context
-          const failureHistory = this.buildFailureHistory(repairHistory, step, error);
-          
-          // Build recent repairs context for LLM
-          const recentRepairsContext = this.buildRecentRepairsContext(recentRepairs);
-          
-          let repairSuggestion;
-          
-          // VISION-BASED FALLBACK: After 2 regular repair attempts, consider vision diagnostics on final attempt
-          if (attempt === maxTries - 1 && repairHistory.length >= 2 && !usedVisionMode) {
-            // Ask LLM if screenshot would help for repair diagnostics
-            this.log(`  🤔 After ${repairHistory.length} failed repairs: Asking LLM if screenshot would help (last resort)...`);
-            
-            const screenshotNeed = await this.llmFacade.assessScreenshotNeed(
-              step.description,
-              step.error || 'Unknown error',
-              repairHistory.length + 1,
-              pageInfo,
-              model
-            );
-            
-            this.log(`  💭 LLM assessment: ${screenshotNeed.needsScreenshot ? 'SCREENSHOT NEEDED' : 'NO SCREENSHOT'} - ${screenshotNeed.reason}`);
-            
-            if (screenshotNeed.needsScreenshot) {
-              // Two-step supervisor pattern for vision-based repair:
-              // 1. Supervisor analyzes screenshot and provides diagnostic insights
-              // 2. Get repair suggestion with enhanced context from vision analysis
-              
-              this.log(`  📸 Taking screenshot for supervisor analysis...`);
-              
-              // Capture optimized screenshot using utility method
-              const imageDataUrl = await captureOptimizedScreenshot(
-                page,
-                { timeout: 10000 }, // Uses default quality 60
-                (msg) => this.log(msg)
-              );
-              
-              this.log(`  👔 STEP 1: Supervisor analyzing screenshot (${VISION_MODEL})...`);
-              const supervisorDiagnostics = await this.llmFacade.getVisionDiagnostics(
-                step.description,
-                pageInfo,
-                [], // No previous steps context for repair
-                step.error,
-                imageDataUrl,
-                VISION_MODEL
-              );
-              
-              // DEBUG: Log vision diagnostics
-              this.log(`  📸 Visual insights: ${supervisorDiagnostics.visualAnalysis}`);
-              this.log(`  🔍 Root cause: ${supervisorDiagnostics.rootCause}`);
-              this.log(`  💡 Recommended approach: ${supervisorDiagnostics.recommendedApproach}`);
-              if (supervisorDiagnostics.elementsFound.length > 0) {
-                this.log(`  ✅ Elements found: ${supervisorDiagnostics.elementsFound.join(', ')}`);
-              }
-              if (supervisorDiagnostics.elementsNotFound.length > 0) {
-                this.log(`  ❌ Elements not found: ${supervisorDiagnostics.elementsNotFound.join(', ')}`);
-              }
-              
-              // Get repair suggestion with vision-enhanced context
-              this.log(`  🔨 STEP 2: Getting repair suggestion with vision insights...`);
-              const visionEnhancedFailureHistory = `${failureHistory}
-
-VISION-BASED DIAGNOSTIC INSIGHTS:
-Visual Analysis: ${supervisorDiagnostics.visualAnalysis}
-Root Cause: ${supervisorDiagnostics.rootCause}
-Recommended Approach: ${supervisorDiagnostics.recommendedApproach}
-Elements Found: ${supervisorDiagnostics.elementsFound.join(', ') || 'None'}
-Elements Not Found: ${supervisorDiagnostics.elementsNotFound.join(', ') || 'None'}
-
-Use these vision insights to inform your repair strategy.`;
-              
-              repairSuggestion = await this.llmFacade.getRepairSuggestion(
-                step.description,
-                step.code,
-                step.error || 'Unknown error',
-                pageInfo,
-                visionEnhancedFailureHistory,
-                recentRepairsContext,
-                model
-              );
-              
-              usedVisionMode = true;
-            } else {
-              // Regular repair without vision
-              if (screenshotNeed.alternativeApproach) {
-                this.log(`  💡 Alternative approach: ${screenshotNeed.alternativeApproach}`);
-              }
-              repairSuggestion = await this.llmFacade.getRepairSuggestion(
-                step.description,
-                step.code,
-                step.error || 'Unknown error',
-                pageInfo,
-                failureHistory,
-                recentRepairsContext,
-                model
-              );
-            }
-          } else {
-            // Regular repair attempt (first 2 attempts or already used vision)
-            repairSuggestion = await this.llmFacade.getRepairSuggestion(
-              step.description,
-              step.code,
-              step.error || 'Unknown error',
-              pageInfo,
-              failureHistory,
-              recentRepairsContext,
-              model
-            );
-          }
-
-          if (!repairSuggestion.shouldContinue) {
-            this.log(`AI decided to stop repair at attempt ${attempt}: ${repairSuggestion.reason}`);
-            break;
-          }
-
-          // Apply the repair action
-          try {
-            // Set the step index and insertAfterIndex on the client side based on current step being processed
-            const repairAction = {
-              ...repairSuggestion.action,
-              stepIndex: i, // Client-side step index management
-              insertAfterIndex: repairSuggestion.action.operation === StepOperation.INSERT ? i - 1 : undefined // For INSERT, insert before current step
-            };
-            
-            this.log(`🔧 Applying repair action: ${repairAction.operation} on step ${repairAction.stepIndex}`);
-            this.log(`🔧 Steps array before repair: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-            
-            const result = await this.applyRepairActionInContext(repairAction, updatedSteps, i, page, executionContext, contextVariables);
-            
-            if (result.success) {
-              repairSuccess = true;
-              this.log(`🔧 Steps array after repair: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-              
-              // Mark the appropriate step(s) as successful based on operation type
-              if (repairAction.operation === StepOperation.MODIFY) {
-                // For MODIFY: mark the modified step as successful
-                step.success = true;
-                step.error = undefined;
-                updatedSteps[i].success = true;
-                updatedSteps[i].error = undefined;
-                this.log(`Step ${i + 1} marked as successful after MODIFY repair`);
-                
-                // Report repaired step
-                if (this.progressReporter?.onStepProgress && jobId) {
-                  this.log(`DEBUG: Reporting repaired step ${i + 1}:`);
-                  this.log(`  description: ${updatedSteps[i].description}`);
-                  this.log(`  code: ${updatedSteps[i].code}`);
-                  await this.progressReporter.onStepProgress({
-                    jobId,
-                    stepId: updatedSteps[i].id, // Preserve original step ID if provided
-                    stepNumber: i + 1,
-                    description: updatedSteps[i].description,
-                    code: updatedSteps[i].code,
-                    status: 'SUCCESS_STEP_EXECUTION' as any,
-                    wasRepaired: true
-                  });
-                }
-              } else if (repairAction.operation === StepOperation.INSERT) {
-                // For INSERT: mark the newly inserted step as successful
-                const insertIndex = repairAction.insertAfterIndex !== undefined ? repairAction.insertAfterIndex + 1 : i + 1;
-                if (updatedSteps[insertIndex]) {
-                  updatedSteps[insertIndex].success = true;
-                  updatedSteps[insertIndex].error = undefined;
-                  
-                  // Report inserted step
-                  if (this.progressReporter?.onStepProgress && jobId) {
-                    await this.progressReporter.onStepProgress({
-                      jobId,
-                      stepId: updatedSteps[insertIndex].id, // Preserve original step ID if provided
-                      stepNumber: insertIndex + 1,
-                      description: updatedSteps[insertIndex].description,
-                      code: updatedSteps[insertIndex].code,
-                      status: 'SUCCESS_STEP_EXECUTION' as any,
-                      wasRepaired: true
-                    });
-                  }
-                }
-              } else if (repairAction.operation === StepOperation.REMOVE) {
-                // For REMOVE: no step to mark as successful since we removed it
-                // The step is already removed from the array
-              }
-              
-              const commandInfo = repairAction.operation === StepOperation.MODIFY ? 
-                `MODIFY: "${repairAction.newStep?.code || 'N/A'}"` :
-                repairAction.operation === StepOperation.INSERT ? 
-                `INSERT: "${repairAction.newStep?.code || 'N/A'}"` :
-                repairAction.operation === StepOperation.REMOVE ? 
-                `REMOVE: step at index ${repairAction.stepIndex}` :
-                repairAction.operation;
-              this.log(`Step ${i + 1} repair action ${commandInfo} executed successfully on attempt ${attempt}${usedVisionMode ? ' (vision-aided)' : ''}`);
-              
-              // Update execution context based on the repair action
-              if (repairAction.operation === StepOperation.MODIFY && repairAction.newStep) {
-                // Update the step in the execution context for variable tracking
-                executionContext = executionContext.replace(originalCode, repairAction.newStep.code);
-              } else if (repairAction.operation === StepOperation.INSERT && repairAction.newStep) {
-                // Insert the new step code into execution context for variable tracking
-                executionContext += repairAction.newStep.code + '\n';
-              } else if (repairAction.operation === StepOperation.REMOVE) {
-                // Remove the step code from execution context for variable tracking
-                executionContext = executionContext.replace(originalCode, '');
-              }
-              
-              // Record this successful repair
-              recentRepairs.push({
-                stepNumber: i + 1,
-                operation: repairAction.operation,
-                originalDescription: repairAction.operation === StepOperation.REMOVE ? originalDescription : undefined,
-                newDescription: repairAction.newStep?.description,
-                originalCode: repairAction.operation === StepOperation.REMOVE ? originalCode : undefined,
-                newCode: repairAction.newStep?.code
-              });
-              
-              // Keep only the last 3 repairs for context
-              if (recentRepairs.length > 3) {
-                recentRepairs.shift();
-              }
-              
-              // Update step index based on operation
-              if (repairAction.operation === StepOperation.INSERT) {
-                // For INSERT: inserted step is already executed
-                this.log(`INSERT operation: current i=${i}, insertAfterIndex=${repairAction.insertAfterIndex}`);
-                this.log(`INSERT: Steps array length before: ${updatedSteps.length}`);
-                this.log(`INSERT: Steps before operation: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-                
-                if (repairAction.insertAfterIndex !== undefined && repairAction.insertAfterIndex < i) {
-                  // If inserting before current position, current step moved down by 1
-                  this.log(`INSERT before current position: incrementing i from ${i} to ${i + 1}`);
-                  i++; // Move to the original step that was pushed to the next position
-                } else {
-                  // If inserting at or after current position, stay at current step
-                  this.log(`INSERT at/after current position: keeping i at ${i}`);
-                }
-                
-                this.log(`INSERT: Steps array length after: ${updatedSteps.length}`);
-                this.log(`INSERT: Steps after operation: ${updatedSteps.map((s, idx) => `${idx}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-              } else if (repairAction.operation === StepOperation.REMOVE) {
-                // For REMOVE: stay at same index since the next step moved to current position
-                // Don't increment i because the array shifted left
-              } else {
-                // For MODIFY: move to next step since modified step was executed
-                i++; // Move to next step for MODIFY
-              }
-              
-              // Add the repaired step's code to execution context for variable tracking
-              executionContext += step.code + '\n';
-              
-              break;
-            } else {
-              throw new Error(result.error || 'Repair action failed');
-            }
-          } catch (repairError) {
-            const repairErrorMessage = repairError instanceof Error ? repairError.message : 'Repair failed';
-            const commandInfo = repairSuggestion.action.operation === StepOperation.MODIFY ? 
-              `MODIFY: "${repairSuggestion.action.newStep?.code || 'N/A'}"` :
-              repairSuggestion.action.operation === StepOperation.INSERT ? 
-              `INSERT: "${repairSuggestion.action.newStep?.code || 'N/A'}"` :
-              repairSuggestion.action.operation === StepOperation.REMOVE ? 
-              `REMOVE: step at index ${repairSuggestion.action.stepIndex}` :
-              repairSuggestion.action.operation;
-            this.log(`Step ${i + 1} repair attempt ${attempt} failed (${commandInfo}): ${repairErrorMessage}`);
-            if (repairError instanceof Error && repairError.stack) {
-              this.log(`  Repair stack trace: ${repairError.stack}`);
-            }
-            
-            // Record this attempt in history
-            repairHistory.push({
-              attempt,
-              action: repairSuggestion.action,
-              error: repairErrorMessage,
-              pageInfo
-            });
-            
-            step.error = repairErrorMessage;
-          }
-        }
-
-        if (!repairSuccess) {
-          this.log(`Step ${i + 1} failed after ${maxTries} repair attempts`);
-          break;
-        }
-      }
-    }
-
-    return updatedSteps;
-  }
-
-  private async executeStepCode(code: string, page: any): Promise<void> {
-    // Keep default timeout (5 seconds) for fast feedback on wrong selectors
-    // Navigation operations should use explicit longer timeouts in generated code
-    page.setDefaultTimeout(5000);
-    
-    try {
-      // Clean and validate the code before execution
-      const cleanedCode = this.cleanStepCode(code);
-      
-      if (!cleanedCode || cleanedCode.trim().length === 0) {
-        throw new Error('Step code is empty or contains only comments');
-      }
-      
-      // Dynamically import expect
-      const { expect } = require('@playwright/test');
-      
-      // Create an async function that has access to page, expect, and other Playwright globals
-      const executeCode = new Function('page', 'expect', `return (async () => { ${cleanedCode} })()`);
-      const result = executeCode(page, expect);
-      await result;
-    } finally {
-      // Ensure timeout remains consistent
-      page.setDefaultTimeout(5000);
-    }
-  }
-
-  /**
-   * Validate step code has executable content (preserves comments)
-   */
-  private cleanStepCode(code: string): string {
-    if (!code || code.trim().length === 0) {
-      return '';
-    }
-    
-    // Check if there are any executable statements (including those with comments)
-    const hasExecutableCode = /[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(|await\s+|return\s+|if\s*\(|for\s*\(|while\s*\(|switch\s*\(|try\s*\{|catch\s*\(/.test(code);
-    
-    if (!hasExecutableCode) {
-      return '';
-    }
-    
-    return code; // Return the original code without removing comments
-  }
-
-  private async executeStepInContext(
-    code: string, 
-    page: any, 
-    executionContext: string, 
-    contextVariables: Map<string, any>
-  ): Promise<void> {
-    // Detect if code contains navigation or load state operations that need longer timeout
-    const needsLongerTimeout = code.includes('waitForLoadState') || 
-                                code.includes('goto(') || 
-                                code.includes('waitForURL') ||
-                                code.includes('waitForNavigation');
-    
-    // Use appropriate timeout based on operation type
-    const timeout = needsLongerTimeout ? 30000 : 5000;
-    page.setDefaultTimeout(timeout);
-    
-    try {
-      // Execute only the current step code, but make context variables available
-      const fullCode = code;
-    
-      // Dynamically import expect
-      const { expect } = require('@playwright/test');
-    
-    // Create a function that has access to page, expect, and the context variables
-    const executeCode = new Function(
-      'page', 
-      'expect', 
-      'contextVariables',
-      `return (async () => { 
-        // Make context variables available in the execution scope
-        for (const [key, value] of contextVariables) {
-          globalThis[key] = value;
-        }
-        
-        ${fullCode}
-        
-        // Capture any new variables that might have been created
-        const newVars = {};
-        for (const key in globalThis) {
-          if (!contextVariables.has(key) && typeof globalThis[key] !== 'function' && key !== 'page' && key !== 'expect') {
-            newVars[key] = globalThis[key];
-          }
-        }
-        return newVars;
-      })()`
-    );
-    
-      const newVars = await executeCode(page, expect, contextVariables);
-      
-      // Update the context variables with any new variables created
-      for (const [key, value] of Object.entries(newVars)) {
-        contextVariables.set(key, value);
-      }
-    } finally {
-      // Reset to default timeout for element operations
-      page.setDefaultTimeout(5000);
-    }
-  }
-
-  private async executeScriptContent(script: string, page: any): Promise<void> {
-    // Extract the test function content
-    const testMatch = script.match(/test\([^,]+,\s*async\s*\(\s*\{\s*page[^}]*\}\s*\)\s*=>\s*\{([\s\S]*)\}\s*\);/);
-    if (!testMatch) {
-      throw new Error('Could not extract test function from script');
-    }
-
-    const testBody = testMatch[1];
-    
-    // Dynamically import expect
-    const { expect } = require('@playwright/test');
-    
-    // Execute the entire test body as one async function
-    const executeTest = new Function('page', 'expect', `return (async () => { ${testBody} })()`);
-    await executeTest(page, expect);
-  }
-
-  private async getEnhancedPageInfo(page: any): Promise<PageInfo> {
-    try {
-      return await getEnhancedPageInfo(page);
-    } catch (error) {
-      return {
-        url: page.url(),
-        title: 'Unknown',
-        ariaSnapshot: null,
-        interactiveElements: [],
-        formattedElements: 'Unable to extract'
-      };
-    }
-  }
-
-  private buildFailureHistory(
-    repairHistory: Array<{ attempt: number; action: StepRepairAction; error: string; pageInfo: PageInfo }>,
-    originalStep: ScriptStep,
-    originalError: any
-  ): string {
-    if (repairHistory.length === 0) {
-      return `Original failure: ${this.safeSerializeError(originalError)}`;
-    }
-
-    let history = `Original failure: ${this.safeSerializeError(originalError)}\n\n`;
-    history += `Previous repair attempts:\n`;
-    
-    repairHistory.forEach((attempt, index) => {
-      history += `Attempt ${attempt.attempt}:\n`;
-      history += `  Operation: ${attempt.action.operation}\n`;
-      if (attempt.action.newStep) {
-        history += `  Description: ${attempt.action.newStep.description}\n`;
-        history += `  Code: ${attempt.action.newStep.code}\n`;
-      }
-      history += `  Error: ${attempt.error}\n`;
-      if (index < repairHistory.length - 1) {
-        history += `\n`;
-      }
-    });
-
-    return history;
-  }
-
-  private buildRecentRepairsContext(
-    recentRepairs: Array<{
-      stepNumber: number;
-      operation: string;
-      originalDescription?: string;
-      newDescription?: string;
-      originalCode?: string;
-      newCode?: string;
-    }>
-  ): string {
-    if (recentRepairs.length === 0) {
-      return 'No recent repairs to consider.';
-    }
-
-    let context = 'Recent successful repairs that may affect this step:\n\n';
-    
-    recentRepairs.forEach((repair, index) => {
-      context += `Step ${repair.stepNumber} was successfully repaired:\n`;
-      context += `  Operation: ${repair.operation}\n`;
-      
-      if (repair.operation === 'REMOVE') {
-        context += `  Removed: "${repair.originalDescription}"\n`;
-        context += `  Code removed:\n    ${repair.originalCode?.replace(/\n/g, '\n    ')}\n`;
-      } else if (repair.operation === 'INSERT') {
-        context += `  Inserted: "${repair.newDescription}"\n`;
-        context += `  Code inserted:\n    ${repair.newCode?.replace(/\n/g, '\n    ')}\n`;
-      } else {
-        context += `  Original: "${repair.originalDescription}"\n`;
-        context += `  Repaired: "${repair.newDescription}"\n`;
-        context += `  Code changed from:\n    ${repair.originalCode?.replace(/\n/g, '\n    ')}\n`;
-        context += `  To:\n    ${repair.newCode?.replace(/\n/g, '\n    ')}\n`;
-      }
-      
-      if (index < recentRepairs.length - 1) {
-        context += `\n`;
-      }
-    });
-
-    context += '\nConsider how these changes might affect the current step and adjust accordingly.';
-    return context;
-  }
-
-  private async applyRepairActionInContext(
-    action: StepRepairAction,
-    steps: (ScriptStep & { success?: boolean; error?: string })[],
-    currentIndex: number,
-    page: any,
-    executionContext: string,
-    contextVariables: Map<string, any>
-  ): Promise<{ success: boolean; error?: string; updatedContext?: string }> {
-    try {
-      switch (action.operation) {
-        case StepOperation.MODIFY:
-          if (action.newStep && action.stepIndex !== undefined) {
-            // Modify existing step
-            steps[action.stepIndex] = {
-              ...action.newStep,
-              success: false,
-              error: undefined
-            };
-            // Test the modified step with current page state and variables
-            await this.executeStepCode(action.newStep.code, page);
-            return { success: true, updatedContext: executionContext + action.newStep.code };
-          }
-          break;
-          
-        case StepOperation.INSERT:
-          if (action.newStep && action.insertAfterIndex !== undefined) {
-            // Insert new step after specified index
-            const insertIndex = action.insertAfterIndex + 1;
-            const newStep = {
-              ...action.newStep,
-              success: false,
-              error: undefined
-            };
-            this.log(`INSERT: Inserting step at index ${insertIndex} with description "${newStep.description}"`);
-            this.log(`INSERT: Steps before insertion: ${steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-            
-            // Preserve success status of existing steps before insertion
-            const successStatusMap = new Map(steps.map((step, index) => [index, { success: step.success, error: step.error }]));
-            
-            steps.splice(insertIndex, 0, newStep);
-            
-            // Restore success status for steps that were shifted by the insertion
-            // Steps at insertIndex and before keep their original status
-            // Steps after insertIndex need to be shifted to their new positions
-            for (let i = insertIndex + 1; i < steps.length; i++) {
-              const originalIndex = i - 1; // The step that was originally at this position
-              if (successStatusMap.has(originalIndex)) {
-                const status = successStatusMap.get(originalIndex)!;
-                steps[i].success = status.success;
-                steps[i].error = status.error;
-              }
-            }
-            
-            // CRITICAL FIX: Ensure the inserted step doesn't overwrite existing step data
-            // The new step should only have its own description, not inherit from existing steps
-            this.log(`INSERT: Final step array after restoration: ${steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-            
-            this.log(`INSERT: Steps after insertion: ${steps.map((s, i) => `${i}: "${s.description}" (success: ${s.success})`).join(', ')}`);
-            // Test the new step with current page state
-            await this.executeStepCode(action.newStep.code, page);
-            return { success: true, updatedContext: executionContext + action.newStep.code };
-          }
-          break;
-          
-        case StepOperation.REMOVE:
-          if (action.stepIndex !== undefined) {
-            // Remove step
-            steps.splice(action.stepIndex, 1);
-            return { success: true, updatedContext: executionContext };
-          }
-          break;
-      }
-      
-      return { success: false, error: 'Invalid repair action' };
-    } catch (error) {
-      return { 
-        success: false, 
-        error: error instanceof Error ? error.message : 'Unknown error during repair action' 
-      };
-    }
-  }
-
-  private async applyRepairAction(
-    action: StepRepairAction,
-    steps: (ScriptStep & { success?: boolean; error?: string })[],
-    currentIndex: number,
-    page: any
-  ): Promise<{ success: boolean; error?: string }> {
-    try {
-      switch (action.operation) {
-        case StepOperation.MODIFY:
-          if (action.newStep && action.stepIndex !== undefined) {
-            // Modify existing step
-            steps[action.stepIndex] = {
-              ...action.newStep,
-              success: false,
-              error: undefined
-            };
-            // Test the modified step
-            await this.executeStepCode(action.newStep.code, page);
-            return { success: true };
-          }
-          break;
-          
-        case StepOperation.INSERT:
-          if (action.newStep && action.insertAfterIndex !== undefined) {
-            // Insert new step after specified index
-            const insertIndex = action.insertAfterIndex + 1;
-            const newStep = {
-              ...action.newStep,
-              success: false,
-              error: undefined
-            };
-            steps.splice(insertIndex, 0, newStep);
-            // Test the inserted step
-            await this.executeStepCode(action.newStep.code, page);
-            return { success: true };
-          }
-          break;
-          
-        case StepOperation.REMOVE:
-          if (action.stepIndex !== undefined) {
-            // Remove the step
-            steps.splice(action.stepIndex, 1);
-            return { success: true };
-          }
-          break;
-      }
-      
-      return { success: false, error: 'Invalid repair action' };
-    } catch (error) {
-      return { 
-        success: false, 
-        error: error instanceof Error ? error.message : 'Repair action execution failed' 
-      };
-    }
-  }
-
-
-
-  private generateUpdatedScript(steps: (ScriptStep & { success?: boolean; error?: string })[], repairAdvice?: string): string {
-    const scriptLines = [
-      "import { test, expect } from '@playwright/test';",
-      `test('repairedTest', async ({ page, browser, context }) => {`
-    ];
-
-    steps.forEach((step, index) => {
-      // Only add step if it has code to execute
-      if (step.code && step.code.trim().length > 0) {
-        scriptLines.push(`  // ${step.description}`);
-        const codeLines = step.code.split('\n');
-        codeLines.forEach(line => {
-          scriptLines.push(`  ${line}`);
-        });
-      }
-    });
-
-    scriptLines.push('});');
-    const script = scriptLines.join('\n');
-    
-    // Add TestChimp comment to the repaired script with repair advice
-    return addTestChimpComment(script, repairAdvice);
-  }
-
-
-  /**
-   * Initialize browser with configuration (delegates to utility function)
-   */
-  private async initializeBrowser(playwrightConfig?: string, headless?: boolean, playwrightConfigFilePath?: string): Promise<{ browser: any; context: any; page: any }> {
-    return initializeBrowser(playwrightConfig, headless, playwrightConfigFilePath, this.logger);
-  }
-
-  /**
-   * Safely serialize error information, filtering out non-serializable values
-   */
-  private safeSerializeError(error: any): string {
-    try {
-      if (error instanceof Error) {
-        return error.message;
-      }
-      
-      if (typeof error === 'string') {
-        return error;
-      }
-      
-      if (typeof error === 'object' && error !== null) {
-        // Try to extract meaningful information without serializing the entire object
-        const safeError: any = {};
-        
-        // Copy safe properties
-        if (error.message) safeError.message = error.message;
-        if (error.name) safeError.name = error.name;
-        if (error.code) safeError.code = error.code;
-        if (error.status) safeError.status = error.status;
-        
-        // Try to get stack trace safely
-        if (error.stack && typeof error.stack === 'string') {
-          safeError.stack = error.stack;
-        }
-        
-        return JSON.stringify(safeError);
-      }
-      
-      return String(error);
-    } catch (serializationError) {
-      // If even safe serialization fails, return a basic string representation
-      return `Error: ${String(error)}`;
-    }
-  }
-}