testchimp-runner-core 0.0.35 → 0.0.37

package/src/file-handler.ts

@@ -1,104 +0,0 @@
-/**
- * File Handler Interface
- * Defines how different platforms handle file operations
- */
-
-export interface FileHandler {
-  /**
-   * Read test file content
-   * @param filePath Path to the test file
-   * @returns File content as string
-   */
-  readTestFile(filePath: string): Promise<string>;
-
-  /**
-   * Resolve a relative path to an absolute path based on the current working directory
-   * @param relativePath Relative path to resolve
-   * @returns Absolute path
-   */
-  resolvePath(relativePath: string): string;
-
-  /**
-   * Check if a file exists
-   * @param filePath Path to check
-   * @returns True if file exists
-   */
-  fileExists(filePath: string): Promise<boolean>;
-}
-
-/**
- * Local File Handler - Direct file system operations
- * Used by VS Code extension for local development
- */
-export class LocalFileHandler implements FileHandler {
-  private fs = require('fs');
-  private path = require('path');
-  private basePath: string;
-
-  constructor(basePath?: string) {
-    this.basePath = basePath || String(process.cwd());
-  }
-
-  async readTestFile(filePath: string): Promise<string> {
-    return this.fs.readFileSync(String(filePath), 'utf8');
-  }
-
-  resolvePath(relativePath: string): string {
-    return this.path.resolve(String(this.basePath), String(relativePath));
-  }
-
-  async fileExists(filePath: string): Promise<boolean> {
-    try {
-      return this.fs.existsSync(String(filePath));
-    } catch {
-      return false;
-    }
-  }
-}
-
-/**
- * CI/CD File Handler - For CI/CD environments
- * Used by GitHub Actions for CI/CD environments
- */
-export class CIFileHandler implements FileHandler {
-  private fs = require('fs');
-  private path = require('path');
-  private basePath: string;
-
-  constructor(basePath?: string) {
-    this.basePath = basePath || String(process.cwd());
-  }
-
-  async readTestFile(filePath: string): Promise<string> {
-    return this.fs.readFileSync(String(filePath), 'utf8');
-  }
-
-  resolvePath(relativePath: string): string {
-    return this.path.resolve(String(this.basePath), String(relativePath));
-  }
-
-  async fileExists(filePath: string): Promise<boolean> {
-    try {
-      return this.fs.existsSync(String(filePath));
-    } catch {
-      return false;
-    }
-  }
-}
-
-/**
- * No-op File Handler - For testing or when file operations are not needed
- */
-export class NoOpFileHandler implements FileHandler {
-  async readTestFile(filePath: string): Promise<string> {
-    return '';
-  }
-
-  resolvePath(relativePath: string): string {
-    return relativePath;
-  }
-
-  async fileExists(filePath: string): Promise<boolean> {
-    return false;
-  }
-}

package/src/index.ts

@@ -1,432 +0,0 @@
-/**
- * TestChimp Runner Core
- * Shared functionality for VS Code extension and GitHub Actions
- */
-
-// Core services
-import { ExecutionService } from './execution-service';
-import { ScenarioService } from './scenario-service';
-import { ScenarioWorker } from './scenario-worker-class';
-import { PlaywrightMCPService } from './playwright-mcp-service';
-import { LLMFacade } from './llm-facade';
-import { AuthConfig } from './auth-config';
-import { CreditUsageService, CreditUsageCallback, CreditUsage, CreditUsageReason } from './credit-usage-service';
-
-export { ExecutionService, ScenarioService, ScenarioWorker, PlaywrightMCPService, LLMFacade, CreditUsageService, CreditUsageCallback, CreditUsage, CreditUsageReason };
-
-// File handlers
-import { FileHandler, LocalFileHandler, CIFileHandler, NoOpFileHandler } from './file-handler';
-export { FileHandler, LocalFileHandler, CIFileHandler, NoOpFileHandler };
-
-// LLM Provider interfaces
-import { LLMProvider, LLMRequest, LLMResponse } from './llm-provider';
-import { ProgressReporter, StepProgress, JobProgress, StepExecutionStatus, StepInfo } from './progress-reporter';
-import { BackendProxyLLMProvider } from './providers/backend-proxy-llm-provider';
-import { LocalLLMProvider } from './providers/local-llm-provider';
-
-export { LLMProvider, LLMRequest, LLMResponse };
-export { ProgressReporter, StepProgress, JobProgress, StepExecutionStatus, StepInfo };
-export { BackendProxyLLMProvider, LocalLLMProvider };
-
-// Orchestrator (tool-using agent)
-import type { AgentConfig } from './orchestrator';
-export {
-  OrchestratorAgent,
-  ToolRegistry,
-  Tool,
-  ToolParameter,
-  ToolExecutionContext,
-  AgentConfig,
-  AgentContext,
-  AgentDecision,
-  JourneyMemory,
-  MemoryStep,
-  OrchestratorStepResult,
-  SelfReflection,
-  ToolCall,
-  ToolResult,
-  ExplorationMode,
-  DEFAULT_AGENT_CONFIG,
-  // Tools (information-gathering only)
-  TakeScreenshotTool,
-  RecallHistoryTool,
-  InspectPageTool,
-  CheckPageReadyTool,
-  ExtractDataTool
-} from './orchestrator';
-
-// Types
-export * from './types';
-export { PageInfo, InteractiveElement } from './utils/page-info-utils';
-
-// Model constants
-export { DEFAULT_MODEL, DEFAULT_SIMPLER_MODEL, VISION_MODEL } from './model-constants';
-
-// Authentication
-export * from './auth-config';
-
-// Environment configuration
-export { loadEnvConfig } from './env-loader';
-
-// Script utilities
-export * from './script-utils';
-
-// Main TestChimp service class
-export class TestChimpService {
-  private executionService: ExecutionService;
-  public scenarioService: ScenarioService; // Make public for event listening
-  private playwrightService: PlaywrightMCPService;
-  private llmProvider: LLMProvider;
-  private progressReporter?: ProgressReporter;
-  private creditUsageService: CreditUsageService;
-  private fileHandler: FileHandler;
-  private authConfig: AuthConfig | null;
-  private backendUrl: string;
-  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
-  private orchestratorOptions?: { useOrchestrator?: boolean; orchestratorConfig?: Partial<AgentConfig>; debugMode?: boolean };
-  private outputChannel?: any;  // Store outputChannel to preserve it across service recreations
-  private creditUsageCallback?: CreditUsageCallback;  // Store credit callback to preserve it across service recreations
-
-  constructor(
-    fileHandler?: FileHandler,
-    authConfig?: AuthConfig,
-    backendUrl?: string,
-    maxWorkers?: number,
-    llmProvider?: LLMProvider,
-    progressReporter?: ProgressReporter,
-    orchestratorOptions?: { useOrchestrator?: boolean; orchestratorConfig?: Partial<AgentConfig>; debugMode?: boolean },
-    creditUsageCallback?: CreditUsageCallback
-  ) {
-    this.fileHandler = fileHandler || new NoOpFileHandler();
-    this.authConfig = authConfig || null;
-    this.backendUrl = backendUrl || 'https://featureservice.testchimp.io'; // Default to production
-    this.progressReporter = progressReporter;
-    this.orchestratorOptions = orchestratorOptions;
-    this.creditUsageCallback = creditUsageCallback;
-    
-    // Use provided LLM provider or default to backend proxy (backward compatible)
-    this.llmProvider = llmProvider || new BackendProxyLLMProvider(authConfig, backendUrl);
-    
-    this.playwrightService = new PlaywrightMCPService();
-    // Pass credit callback to constructor - preserved across recreations via this.creditUsageCallback
-    this.creditUsageService = new CreditUsageService(this.authConfig || undefined, this.backendUrl, this.creditUsageCallback);
-    
-    // Create services with providers
-    this.executionService = new ExecutionService(
-      this.authConfig || undefined,
-      this.backendUrl,
-      maxWorkers || 10,
-      this.llmProvider,  // Pass the LLM provider
-      this.progressReporter  // Pass the progress reporter
-    );
-    
-    this.scenarioService = new ScenarioService(
-      maxWorkers || 2,
-      this.fileHandler,
-      this.llmProvider,
-      this.progressReporter,
-      this.authConfig || undefined,
-      this.backendUrl,
-      this.orchestratorOptions  // Pass orchestrator options
-    );
-  }
-
-  /**
-   * Set authentication configuration for the service
-   * Recreates LLM provider and services with new auth config
-   */
-  async setAuthConfig(authConfig: AuthConfig): Promise<void> {
-    this.authConfig = authConfig;
-    this.creditUsageService.setAuthConfig(authConfig);
-    
-    // Recreate LLM provider with new auth config
-    this.llmProvider = new BackendProxyLLMProvider(authConfig, this.backendUrl);
-    
-    // Set logger on new provider if we have one
-    if (this.logger) {
-      this.llmProvider.setLogger?.(this.logger);
-    }
-    
-    // Recreate services with new provider AND pass llmProvider and progressReporter
-    this.executionService = new ExecutionService(
-      this.authConfig,
-      this.backendUrl,
-      10,
-      this.llmProvider,  // Pass the LLM provider
-      this.progressReporter  // Pass the progress reporter
-    );
-    
-    this.scenarioService = new ScenarioService(
-      2,
-      this.fileHandler,
-      this.llmProvider,
-      this.progressReporter,
-      this.authConfig,
-      this.backendUrl,
-      this.orchestratorOptions  // Pass orchestrator options
-    );
-    
-    // Set logger on recreated services if we have one
-    if (this.logger) {
-      this.executionService.setLogger(this.logger);
-      this.scenarioService.setLogger(this.logger);
-    }
-    
-    // Reapply outputChannel if we have one (critical for orchestrator logs)
-    if (this.outputChannel) {
-      this.scenarioService.setOutputChannel(this.outputChannel);
-    }
-    
-    // Reinitialize the services
-    await this.executionService.initialize();
-    await this.scenarioService.initialize();
-  }
-
-  /**
-   * Set backend URL for the service
-   * Recreates LLM provider and services with new backend URL
-   */
-  setBackendUrl(backendUrl: string): void {
-    this.backendUrl = backendUrl;
-    
-    // Recreate LLM provider with new backend URL
-    this.llmProvider = new BackendProxyLLMProvider(this.authConfig || undefined, backendUrl);
-    
-    // Set logger on new provider if we have one
-    if (this.logger) {
-      this.llmProvider.setLogger?.(this.logger);
-    }
-    
-    // Recreate services with new provider (preserve credit callback)
-    this.creditUsageService = new CreditUsageService(this.authConfig || undefined, this.backendUrl, this.creditUsageCallback);
-    this.executionService = new ExecutionService(
-      this.authConfig || undefined,
-      this.backendUrl,
-      10,
-      this.llmProvider,  // Pass the LLM provider
-      this.progressReporter  // Pass the progress reporter
-    );
-    
-    this.scenarioService = new ScenarioService(
-      2,
-      this.fileHandler,
-      this.llmProvider,
-      this.progressReporter,
-      this.authConfig || undefined,
-      this.backendUrl,
-      this.orchestratorOptions  // Pass orchestrator options
-    );
-    
-    // Set logger on recreated services if we have one
-    if (this.logger) {
-      this.executionService.setLogger(this.logger);
-      this.scenarioService.setLogger(this.logger);
-    }
-    
-    // Reapply outputChannel if we have one (critical for orchestrator logs)
-    if (this.outputChannel) {
-      this.scenarioService.setOutputChannel(this.outputChannel);
-    }
-  }
-
-  /**
-   * Set logger callback for capturing execution logs
-   */
-  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
-    this.logger = logger;
-    this.executionService.setLogger(logger);
-    this.scenarioService.setLogger(logger);
-    this.llmProvider.setLogger?.(logger);
-    this.creditUsageService.setLogger(logger);
-  }
-  
-  /**
-   * Set output channel for worker logs (VS Code OutputChannel)
-   * This enables orchestrator thinking logs to appear in output console
-   */
-  setOutputChannel(outputChannel: any): void {
-    this.outputChannel = outputChannel;  // Store for future service recreations
-    if (typeof this.scenarioService?.setOutputChannel === 'function') {
-      this.scenarioService.setOutputChannel(outputChannel);
-    }
-  }
-
-  /**
-   * Set credit usage callback
-   * Server-side: Use callback to update DB directly (no axios calls)
-   * Client-side: Don't set callback, uses auth for axios calls to backend
-   */
-  setCreditUsageCallback(callback: CreditUsageCallback): void {
-    this.creditUsageCallback = callback;  // Store for future service recreations
-    this.creditUsageService.setCreditUsageCallback(callback);
-  }
-
-  /**
-   * 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
-  }
-
-  /**
-   * Get current authentication configuration
-   */
-  getAuthConfig(): AuthConfig | null {
-    return this.authConfig;
-  }
-
-  async initialize(): Promise<void> {
-    await this.playwrightService.initialize();
-    await this.executionService.initialize();
-    await this.scenarioService.initialize();
-  }
-
-  async shutdown(): Promise<void> {
-    // Cleanup resources
-  }
-
-  // Scenario generation
-  async generateScript(
-    scenario: string, 
-    testName?: string, 
-    config?: string, 
-    model?: string, 
-    scenarioFileName?: string,
-    existingBrowser?: any,
-    existingContext?: any,
-    existingPage?: any
-  ): Promise<string> {
-    return this.scenarioService.processScenario(
-      scenario, 
-      testName, 
-      config, 
-      model, 
-      scenarioFileName,
-      existingBrowser,
-      existingContext,
-      existingPage
-    );
-  }
-
-  // Test execution
-  async executeScript(request: any): Promise<any> {
-    // Read script content if not provided but scriptFilePath is
-    if (!request.script && request.scriptFilePath) {
-      try {
-        const resolvedPath = this.fileHandler.resolvePath(request.scriptFilePath);
-        request.script = await this.fileHandler.readTestFile(resolvedPath);
-        this.log(`Read script content from file: ${resolvedPath}`);
-      } catch (error) {
-        throw new Error(`Failed to read script file: ${error}`);
-      }
-    }
-
-    // Read Playwright config content if not provided but playwrightConfigFilePath is
-    if (!request.playwrightConfig && request.playwrightConfigFilePath) {
-      try {
-        const resolvedPath = this.fileHandler.resolvePath(request.playwrightConfigFilePath);
-        request.playwrightConfig = await this.fileHandler.readTestFile(resolvedPath);
-        this.log(`Read Playwright config content from file: ${resolvedPath}`);
-      } catch (error) {
-        this.log(`Failed to read Playwright config file: ${error}. Using default configuration.`, 'warn');
-        // Don't throw error, just use default config
-      }
-    }
-
-    // Log content status
-    if (request.script) {
-      this.log(`Using provided script content (${request.script.length} characters)`);
-    } else if (request.steps && request.steps.length > 0) {
-      this.log(`Using ${request.steps.length} pre-parsed steps (script will be generated if needed)`);
-    } else {
-      throw new Error('Script content is required. Provide either script or scriptFilePath.');
-    }
-
-    if (request.playwrightConfig) {
-      this.log(`Using provided Playwright config (${request.playwrightConfig.length} characters)`);
-    } else {
-      this.log(`Using default Playwright configuration`);
-    }
-
-    const result = await this.executionService.executeScript(request);
-    
-    // Return result - consumer decides what to do with updated_script
-    return result;
-  }
-
-  // Test execution with AI repair
-  async executeScriptWithAIRepair(request: any): Promise<any> {
-    const repairRequest = { ...request, mode: 'RUN_WITH_AI_REPAIR' };
-    return this.executeScript(repairRequest);
-  }
-
-  // Exploration mode execution
-  async executeExploration(page: any, explorationConfig: any, jobId: string): Promise<any> {
-    // Delegate to scenario service's orchestrator
-    return this.scenarioService.executeExploration(page, explorationConfig, jobId);
-  }
-
-  // Credit usage reporting methods
-  async reportScriptGenerationCredit(jobId?: string): Promise<void> {
-    return this.creditUsageService.reportScriptGenerationCredit(jobId);
-  }
-
-  async reportAIRepairCredit(jobId?: string): Promise<void> {
-    return this.creditUsageService.reportAIRepairCredit(jobId);
-  }
-
-  // Find TestChimp smart/managed tests (prioritizes Smart Test detection)
-  findTestChimpTests(directory: string, recursive: boolean = true): string[] {
-    const fs = require('fs');
-    const path = require('path');
-    
-    const testFiles: string[] = [];
-    
-    function scanDir(dir: string) {
-      try {
-        const items = fs.readdirSync(String(dir));
-        
-        for (const item of items) {
-          const fullPath = path.join(String(dir), String(item));
-          const stat = fs.statSync(String(fullPath));
-          
-          if (stat.isDirectory() && recursive) {
-            scanDir(fullPath);
-          } else if (stat.isFile() && isTestChimpTest(fullPath)) {
-            testFiles.push(fullPath);
-          }
-        }
-      } catch (error) {
-        // Skip directories that can't be read
-      }
-    }
-    
-    function isTestChimpTest(filePath: string): boolean {
-      // Check if file is a test file (including smart test files)
-      if (!filePath.match(/\.(smart\.spec|spec|test)\.(js|ts)$/)) {
-        return false;
-      }
-      
-      try {
-        // Read file content
-        const content = fs.readFileSync(filePath, 'utf8');
-        
-        // Check for TestChimp markers - only exact comment phrases
-        const testChimpMarkers = [
-          /This is a TestChimp Smart Test/i,
-          /This is a TestChimp Managed Test/i
-        ];
-        
-        return testChimpMarkers.some(marker => marker.test(content));
-      } catch (error) {
-        return false;
-      }
-    }
-    
-    scanDir(directory);
-    return testFiles;
-  }
-}