testchimp-runner-core 0.0.35 → 0.0.36

package/src/execution-service.ts

@@ -1,996 +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';
-import { OrchestratorAgent, ToolRegistry, DEFAULT_AGENT_CONFIG } from './orchestrator';
-import type { AgentConfig, JourneyMemory } from './orchestrator';
-
-/**
- * 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;
-  private orchestratorAgent: OrchestratorAgent;
-
-  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;
-    
-    // Initialize orchestrator for repair mode (reuses all SoM infrastructure)
-    const toolRegistry = new ToolRegistry();
-    const repairConfig: Partial<AgentConfig> = {
-      useSoM: true,
-      somRestrictCoordinates: true  // Prefer SoM markers for repairs
-    };
-    
-    this.orchestratorAgent = new OrchestratorAgent(
-      this.llmFacade,
-      toolRegistry,
-      repairConfig,
-      progressReporter,
-      (msg, level) => this.log(msg)
-    );
-  }
-
-  /**
-   * 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.executeStepCode(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.executeStepCode(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...');
-
-    let repairBrowser: any = null;
-    let repairContext: any = null;
-    let repairPage: any = null;
-    
-    try {
-        let 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 (preserve original test name)
-        const updatedScript = this.generateUpdatedScript(updatedSteps, undefined, request.script);
-        
-        // 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) {
-          // IMPORTANT: Use the orchestrator-generated script directly (already has proper Playwright commands)
-          // Don't regenerate via LLM as it loses the actual repairs
-          this.log('Using orchestrator-generated script (skipping LLM regeneration to preserve repairs)');
-          
-          // For repair advice, compare original vs repaired
-          const confidenceResponse = await this.llmFacade.assessRepairConfidence(request.script!, updatedScript, model);
-          
-          // Add TestChimp comment with repair advice
-          const scriptWithAdvice = addTestChimpComment(updatedScript, confidenceResponse.advice);
-          
-          // Polish the script with minor LLM cleanup (removes redundancies, fixes formatting)
-          this.log('Applying final LLM polish to repaired script (minor cleanup only)...');
-          const cleanupResult = await this.llmFacade.cleanupScript(scriptWithAdvice, model);
-          
-          if (cleanupResult.changes.length > 0) {
-            this.log(`Script cleanup made ${cleanupResult.changes.length} minor improvements:`);
-            cleanupResult.changes.forEach((change, i) => {
-              this.log(`  ${i + 1}. ${change}`);
-            });
-          } else if (cleanupResult.skipped) {
-            this.log(`Script cleanup skipped: ${cleanupResult.skipped}`);
-          } else {
-            this.log('Script cleanup: no changes needed');
-          }
-          
-          const scriptWithRepairAdvice = cleanupResult.script;
-          
-          // 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');
-            }
-          }
-          
-          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');
-            }
-          }
-          
-          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'
-      };
-    } finally {
-      // Clean up browser resources if we created them (not provided by caller)
-      if (!useExistingBrowser && repairBrowser) {
-        try {
-          await repairBrowser.close();
-          this.log('AI repair browser closed');
-        } catch (closeError) {
-          this.log(`Error closing AI repair browser: ${closeError}`, 'warn');
-        }
-      }
-    }
-  }
-
-  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;
-    }> = [];
-
-    // Track actual executed steps (including agent repairs) for proper history
-    const executedStepDescriptions: 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}`);
-        
-        // Track executed step description for agent context
-        executedStepDescriptions.push(step.description);
-        
-        // 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);
-
-        // Use orchestrator for repair (reuses all SoM infrastructure)
-        this.log(`Calling orchestrator in REPAIR mode for step ${i + 1}`);
-        
-        // Prepare repair context - use executedStepDescriptions (includes agent repairs)
-        const priorSteps = executedStepDescriptions; // What was ACTUALLY executed (scripted + agent)
-        const nextSteps = updatedSteps.slice(i + 1).map(s => s.description);
-        
-        this.log(`  Prior steps executed: ${priorSteps.length}, Next steps: ${nextSteps.length}`);
-        this.log(`  Prior steps context:\n    ${priorSteps.map((s, idx) => `${idx + 1}. ${s}`).join('\n    ')}`);
-        
-        // Create minimal memory for repair
-        const memory: JourneyMemory = {
-          experiences: [],
-          extractedData: {},
-          history: [],
-          latestNote: undefined
-        };
-        
-        let repairSuccess = false;
-        
-        try {
-          // Call orchestrator with repair context (page object persisted)
-          const repairResult = await this.orchestratorAgent.executeStep(
-            page,                                    // Same page object (persisted state)
-            step.description,                        // Goal with testdata embedded
-            i + 1,                                   // Current step number
-            updatedSteps.length,                     // Total steps
-            updatedSteps.map(s => s.description),    // All step descriptions
-            memory,                                  // Memory (empty for repair)
-            jobId || 'repair',
-            priorSteps,  // NEW: What was already completed
-            nextSteps    // NEW: What comes after this
-          );
-          
-          if (repairResult.success && repairResult.commands.length > 0) {
-            // MODIFY: Orchestrator fixed the step - replace with new code
-            const repairedCode = repairResult.commands.join('\n');
-            
-            updatedSteps[i] = {
-              ...step,
-              code: repairedCode,
-              success: true,
-              error: undefined
-            };
-            
-            this.log(`✓ Step ${i + 1} MODIFIED by orchestrator (repair successful)`);
-            this.log(`  Original code: ${step.code}`);
-            this.log(`  New code (${repairResult.commands.length} commands):\n    ${repairResult.commands.join('\n    ')}`);
-            
-            // Track what agent actually did in history (for future repair context)
-            const agentActionSummary = `${step.description} [AI-repaired: ${repairResult.commands.length} commands]`;
-            executedStepDescriptions.push(agentActionSummary);
-            
-            // Report repaired step
-            if (this.progressReporter?.onStepProgress && jobId) {
-              await this.progressReporter.onStepProgress({
-                jobId,
-                stepId: step.id,
-                stepNumber: i + 1,
-                description: updatedSteps[i].description,
-                code: updatedSteps[i].code,
-                status: 'SUCCESS_STEP_EXECUTION' as any,
-                wasRepaired: true
-              });
-            }
-            
-            // Ensure page is stable after agent repairs before returning control to script
-            this.log(`Waiting for page stability after agent repair...`);
-            try {
-              await page.waitForLoadState('networkidle', { timeout: 5000 });
-              this.log(`Page stabilized (networkidle) after agent repair`);
-            } catch (stabilityError) {
-              try {
-                await page.waitForLoadState('domcontentloaded', { timeout: 3000 });
-                this.log(`Page loaded (domcontentloaded) after agent repair`);
-              } catch (fallbackError) {
-                this.log(`Page stability wait timed out (continuing anyway)`, 'warn');
-              }
-            }
-            
-            repairSuccess = true;
-            i++; // Continue to NEXT step (hand control back to script)
-            
-          } else if (repairResult.success && repairResult.commands.length === 0) {
-            // DELETE: Step goal already achieved or no longer needed (e.g., modal already dismissed)
-            this.log(`✓ Step ${i + 1} DELETED by orchestrator (goal already achieved, step obsolete)`);
-            this.log(`  Reason: Orchestrator completed with 0 commands - step no longer needed`);
-            
-            // Track deletion in history (helps agent understand what was skipped)
-            executedStepDescriptions.push(`${step.description} [AI-deleted: step obsolete/already done]`);
-            
-            // Remove the step from array
-            updatedSteps.splice(i, 1);
-            
-            repairSuccess = true;
-            // Don't increment i - next step moved to current position
-            
-          } else {
-            this.log(`✗ Step ${i + 1} could not be repaired by orchestrator (reason: ${repairResult.terminationReason})`);
-          }
-        } catch (repairError: any) {
-          this.log(`✗ Orchestrator repair failed: ${repairError.message}`);
-        }
-        
-        // Legacy repair code removed - now using orchestrator
-        
-        if (!repairSuccess) {
-          this.log(`Step ${i + 1} could not be repaired - stopping execution`);
-          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
-  }
-
-  // Legacy repair helper methods (now unused but kept for compilation)
-  private buildFailureHistory(): string { return ''; }
-  private buildRecentRepairsContext(): string { return ''; }
-  private async applyRepairActionInContext(): Promise<{ success: boolean; error?: string }> {
-    return { success: false };
-  }
-
-  private generateUpdatedScript(steps: (ScriptStep & { success?: boolean; error?: string })[], repairAdvice?: string, originalScript?: string): string {
-    // Extract test name and hashtags from original script if provided
-    let testName = 'repairedTest';
-    let hashtags: string[] = [];
-    
-    if (originalScript) {
-      const testNameMatch = originalScript.match(/test\(['"]([^'"]+)['"]/);
-      if (testNameMatch) {
-        testName = testNameMatch[1];
-      }
-      
-      // Extract hashtags from TestChimp comment
-      const hashtagMatch = originalScript.match(/#\w+(?:\s+#\w+)*/);
-      if (hashtagMatch) {
-        hashtags = hashtagMatch[0].split(/\s+/).filter(tag => tag.startsWith('#'));
-      }
-    }
-    
-    const scriptLines = [
-      "import { test, expect } from '@playwright/test';",
-      `test('${testName}', 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 with hashtags and repair advice
-    return addTestChimpComment(script, repairAdvice, hashtags);
-  }
-
-
-  /**
-   * 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)}`;
-    }
-  }
-}