@sun-asterisk/sungen 1.0.0

package/src/orchestrator/pipeline.ts

@@ -0,0 +1,713 @@
+/**
+ * Pipeline Orchestrator
+ * Coordinates all phases of test generation: UI Scan → Selector Mapping → Code Generation
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import yaml from 'yaml';
+import { RuntimeConfig } from '../config/config-schema';
+import { ScannerFactory, UIModel } from '../core/ui-scanner/scanner-interface';
+import { SelectorBaseGenerator, SelectorBase } from '../core/selector-base/base-generator';
+import { AIProviderFactory } from '../external/ai-provider';
+import { TestGeneratorFactory, GeneratedTest } from '../executor/test-generator';
+import { CacheManager } from './cache-manager';
+import { Reporter } from './reporter';
+
+export class Pipeline {
+  private config: RuntimeConfig;
+  private cacheManager: CacheManager;
+  private reporter: Reporter;
+
+  constructor(config: RuntimeConfig) {
+    this.config = config;
+    this.cacheManager = new CacheManager(config);
+    this.reporter = new Reporter(config);
+  }
+
+  /**
+   * Run UI discovery phase
+   * Scans React components and generates UI model
+   */
+  async runDiscovery(screenName: string): Promise<UIModel> {
+    const strictMode = this.config.scanner.strictMode || false;
+    const mode = strictMode ? 'strict' : 'standard';
+
+    // Debug logging
+    if (this.config.verbose) {
+      console.log(`[DEBUG] strictMode value: ${this.config.scanner.strictMode}`);
+      console.log(`[DEBUG] scanner config:`, JSON.stringify(this.config.scanner, null, 2));
+    }
+
+    console.log(`\n🔍 Discovering UI elements for screen: ${screenName} (${mode} mode)\n`);
+
+    // Check cache
+    if (!this.config.force && this.config.cache.enabled) {
+      const cached = await this.cacheManager.getUIModel(screenName);
+      if (cached) {
+        console.log(`✓ Loaded from cache (${cached.elements.length} elements)\n`);
+        return cached;
+      }
+    }
+
+    let uiModel: UIModel;
+
+    // Use StrictScanner if strict mode enabled (v3.1)
+    if (strictMode) {
+      const { StrictScanner } = require('../core/ui-scanner/strict-scanner');
+
+      const strictConfig = {
+        sourceRoot: this.config.paths.sourceRoot,
+        projectRoot: process.cwd(),
+        strictMode: true,
+        filterRules: this.config.scanner.filterRules || {
+          allowedTags: ['input', 'button', 'a', 'select', 'textarea'],
+          requireAttributes: ['data-testid', 'role'],
+          allowGenericWithId: true,
+        },
+        verbose: this.config.verbose || false,
+      };
+
+      const strictScanner = new StrictScanner(strictConfig);
+      const strictResult = await strictScanner.scan(screenName);
+
+      // Convert StrictScanResult to UIModel format
+      uiModel = {
+        screen: strictResult.screen,
+        timestamp: strictResult.timestamp,
+        framework: strictResult.framework,
+        sourceFiles: strictResult.sourceFiles,
+        elements: strictResult.elements.map(el => ({
+          id: el.logicalName,
+          type: el.tag as any,
+          selector: el.primaryLocator,
+          label: el.label,
+          placeholder: el.placeholder,
+          role: el.role,
+          testId: el.props['data-testid'],
+          context: {
+            component: path.basename(el.sourceFile),
+          },
+        })),
+        stats: {
+          totalComponents: 1,
+          totalElements: strictResult.stats.totalIncluded,
+          maxDepth: 0,
+          scanDuration: strictResult.stats.scanDuration,
+          filesScanned: strictResult.sourceFiles.length,
+        },
+      };
+
+      console.log(`  Filtered: ${strictResult.stats.totalFiltered} elements (${strictResult.stats.filterRate.toFixed(1)}%)`);
+      console.log(`  Direct ID: ${strictResult.stats.directIdMatches} elements`);
+    } else {
+      // Use standard scanner (old approach)
+      const scanner = ScannerFactory.create(this.config.scanner.framework, this.config);
+      uiModel = await scanner.scan(screenName, this.config);
+    }
+
+    // Save UI model
+    await this.saveUIModel(uiModel);
+
+    // Cache UI model
+    if (this.config.cache.enabled) {
+      await this.cacheManager.saveUIModel(screenName, uiModel);
+    }
+
+    console.log(`✓ Discovered ${uiModel.elements.length} elements in ${uiModel.stats.scanDuration}ms\n`);
+
+    return uiModel;
+  }
+
+  /**
+   * Run mapping for single screen or all screens
+   */
+  async runMapping(screenName?: string): Promise<void> {
+    if (screenName) {
+      // Map specific screen
+      await this.runSelectorMapping(screenName);
+    } else {
+      // Map all screens discovered from Gherkin
+      const screens = await this.discoverScreensFromGherkin();
+      
+      if (screens.length === 0) {
+        console.warn('⚠️  No screens found in Gherkin features');
+        return;
+      }
+
+      console.log(`📋 Found ${screens.length} screen(s): ${screens.join(', ')}\n`);
+      
+      for (const screen of screens) {
+        await this.runSelectorMapping(screen);
+      }
+    }
+  }
+
+  /**
+   * Run selector mapping phase
+   * Generates selector base and maps with AI or Hybrid Mapper
+   */
+  async runSelectorMapping(screenName: string): Promise<SelectorBase> {
+    const mode = this.config.selectorMapping.mode || 'hybrid';
+    console.log(`\n🎯 Mapping selectors for screen: ${screenName} (mode: ${mode})\n`);
+
+    // Check cache
+    if (!this.config.force && this.config.cache.enabled) {
+      const cached = await this.cacheManager.getSelectors(screenName);
+      if (cached) {
+        console.log(`✓ Loaded from cache (${Object.keys(cached.elements).length} selectors)\n`);
+        return cached;
+      }
+    }
+
+    // Generate selector base from Gherkin
+    const baseGenerator = new SelectorBaseGenerator(this.config);
+    const selectorBase = await baseGenerator.generate(screenName);
+
+    console.log(`  Generated selector base with ${selectorBase.metadata.totalElements} elements`);
+
+    // Load UI model (needed for mapping)
+    const uiModel = await this.loadUIModel(screenName);
+    if (!uiModel) {
+      throw new Error(`UI model not found for screen: ${screenName}. Run discovery first.`);
+    }
+
+    // Map selectors based on mode/strategy
+    let mappedSelectors: SelectorBase;
+
+    // v3.1: Use PriorityMapper if strategy is priority-waterfall
+    const strategy = this.config.selectorMapping.strategy;
+    if (strategy === 'priority-waterfall') {
+      const { PriorityMapper } = require('../core/selector-mapper/priority-mapper');
+
+      const mapperConfig = {
+        strategy: 'priority-waterfall' as const,
+        priorities: this.config.selectorMapping.priorities || ['direct-id', 'accessibility', 'heuristic-ai'],
+        confidenceThreshold: this.config.selectorMapping.confidenceThreshold || 0.5,
+        aiProvider: this.config.selectorMapping.aiProvider,
+        model: this.config.selectorMapping.model,
+      };
+
+      const priorityMapper = new PriorityMapper(mapperConfig);
+
+      // Extract element IDs from selector base
+      const elementIds = Object.keys(selectorBase.elements);
+
+      // Convert UI model to StrictScanResult format (compatible)
+      const strictUIModel = {
+        screen: uiModel.screen,
+        timestamp: uiModel.timestamp,
+        framework: uiModel.framework,
+        sourceFiles: uiModel.sourceFiles,
+        elements: uiModel.elements.map(el => {
+          // Check if selector contains data-testid
+          const hasTestId = el.selector.includes('data-testid');
+
+          return {
+            logicalName: el.id,
+            primaryLocator: el.selector,
+            fallbackStrategy: el.selector,
+            tag: el.type,
+            elementType: el.type,
+            discoveryMethod: hasTestId ? 'direct-id' : 'heuristic' as const,
+            confidence: hasTestId ? 0.95 : 0.5,
+            sourceFile: uiModel.sourceFiles[0] || '',
+            label: el.label,
+            placeholder: el.placeholder,
+            ariaLabel: undefined,
+            role: el.role,
+            text: undefined,
+            props: {},
+          };
+        }),
+        stats: {
+          totalScanned: uiModel.stats.totalElements,
+          totalFiltered: 0,
+          totalIncluded: uiModel.stats.totalElements,
+          filterRate: 0,
+          directIdMatches: uiModel.elements.filter(el => el.selector.includes('data-testid')).length,
+          accessibilityMatches: 0,
+          heuristicMatches: uiModel.elements.filter(el => !el.selector.includes('data-testid')).length,
+          scanDuration: uiModel.stats.scanDuration,
+        },
+      };
+
+      // Map elements using priority waterfall
+      const mappingRequests = elementIds.map(id => ({
+        elementId: `[${screenName}.${id}]`,
+        screenName,
+        uiModel: strictUIModel,
+      }));
+
+      const results = await priorityMapper.mapElements(mappingRequests);
+
+      // Convert results back to SelectorBase format
+      mappedSelectors = { ...selectorBase };
+      results.forEach(result => {
+        // result.elementId is already just the element name (e.g., "email-input")
+        const elementId = result.elementId;
+
+        if (this.config.verbose) {
+          console.log(`[DEBUG] Mapping result: ${result.elementId} → ${result.selector} (confidence: ${result.confidence})`);
+          console.log(`[DEBUG] Extracted elementId: ${elementId}`);
+        }
+
+        if (elementId && result.confidence > 0 && selectorBase.elements[elementId]) {
+          mappedSelectors.elements[elementId] = {
+            ...selectorBase.elements[elementId],
+            selector: result.selector,
+          };
+
+          if (this.config.verbose) {
+            console.log(`[DEBUG] Updated selector for ${elementId}: ${mappedSelectors.elements[elementId].selector}`);
+          }
+        }
+      });
+
+      // Show statistics
+      const stats = priorityMapper.getStats();
+      console.log(`\n📊 Priority Mapping Statistics:`);
+      console.log(`  Total elements: ${stats.totalMappings}`);
+      console.log(`  Successful: ${stats.successfulMappings} (${((stats.successfulMappings / stats.totalMappings) * 100).toFixed(1)}%)`);
+      console.log(`  Direct ID: ${stats.directIdMatches} (${((stats.directIdMatches / stats.totalMappings) * 100).toFixed(1)}%)`);
+      console.log(`  Accessibility: ${stats.accessibilityMatches}`);
+      console.log(`  Heuristic: ${stats.heuristicMatches}`);
+      console.log(`  AI: ${stats.aiMatches}`);
+      console.log(`  Avg time: ${stats.averageMappingTime.toFixed(2)}ms`);
+      console.log(`  Cost: $${stats.estimatedCost.toFixed(4)}\n`);
+    } else if (mode === 'hybrid') {
+      // Use Hybrid Mapper (heuristics + AI fallback)
+      const { HybridMapper } = require('../generators/selector-mapper/hybrid-mapper');
+      const hybridMapper = new HybridMapper({
+        provider: this.config.selectorMapping.aiProvider,
+        model: this.config.selectorMapping.model,
+        apiKey: process.env[this.config.apis.anthropic.apiKeyEnv],
+        heuristicFirst: this.config.selectorMapping.heuristicFirst,
+        minHeuristicConfidence: this.config.selectorMapping.minHeuristicConfidence,
+        verbose: this.config.verbose
+      });
+
+      // Extract element IDs from selector base
+      const elementIds = Object.keys(selectorBase.elements).map(id => `[${screenName}.${id}]`);
+
+      // Map using hybrid approach
+      const selectorDSL = await hybridMapper.mapSelectors(uiModel, elementIds);
+
+      // Convert SelectorDSL back to SelectorBase format
+      // selectorDSL is a flat object { elementId: SelectorEntry }
+      mappedSelectors = {
+        ...selectorBase,
+        elements: selectorDSL
+      };
+
+      // Show statistics if verbose
+      if (this.config.verbose) {
+        const stats = hybridMapper.getStats();
+        console.log(`\n📊 Mapping Statistics:`);
+        console.log(`  Total elements: ${stats.total}`);
+        console.log(`  Heuristic matches: ${stats.heuristicMatches} (${stats.heuristicSuccessRate.toFixed(1)}%)`);
+        console.log(`  AI fallback: ${stats.aiMatches} (${(100 - stats.heuristicSuccessRate).toFixed(1)}%)`);
+        console.log(`  Estimated cost: $${stats.estimatedCost.toFixed(4)}`);
+        console.log(`  Estimated time: ${stats.estimatedTime}ms`);
+        console.log(`  Savings vs AI-only: ~${(90 * stats.heuristicSuccessRate / 100).toFixed(0)}%\n`);
+      }
+    } else if (mode === 'ai-only') {
+      // Use AI mapper only (legacy behavior)
+      const aiProvider = AIProviderFactory.create(this.config.selectorMapping.aiProvider, this.config);
+      mappedSelectors = await aiProvider.mapSelectors(uiModel, selectorBase, this.config);
+    } else if (mode === 'heuristic-only') {
+      // Use heuristics only (no AI fallback)
+      const { HeuristicMatcher } = require('../generators/selector-mapper/hybrid-mapper');
+
+      mappedSelectors = { ...selectorBase };
+
+      for (const [elementId, element] of Object.entries(selectorBase.elements)) {
+        const match = HeuristicMatcher.match(elementId, uiModel.elements);
+
+        if (match.confidence > 0) {
+          mappedSelectors.elements[elementId] = {
+            ...element,
+            selector: match.selector
+          };
+        } else {
+          console.warn(`  ⚠️  No heuristic match for: ${elementId}`);
+        }
+      }
+    } else {
+      throw new Error(`Invalid selector mapping mode: ${mode}`);
+    }
+
+    // Apply overrides
+    const finalSelectors = await this.applyOverrides(screenName, mappedSelectors);
+
+    // Save selectors
+    await baseGenerator.save(finalSelectors);
+
+    // Cache selectors
+    if (this.config.cache.enabled) {
+      await this.cacheManager.saveSelectors(screenName, finalSelectors);
+    }
+
+    console.log(`✓ Mapped ${Object.keys(finalSelectors.elements).length} selectors\n`);
+
+    return finalSelectors;
+  }
+
+  /**
+   * Run test generation phase
+   * Generates Playwright test scripts from Gherkin
+   */
+  async runTestGeneration(screenName?: string): Promise<GeneratedTest[]> {
+    const header = screenName ? `Generating tests: ${screenName}` : 'Generating tests';
+    console.log(`\n${header}\n`);
+
+    // Find all feature files from both old and new structure
+    const featureFiles = screenName 
+      ? this.findFeatureFilesForScreen(screenName)
+      : this.findAllFeatureFiles();
+    
+    if (screenName && featureFiles.length === 0) {
+      console.error(`No feature files found for screen: ${screenName}`);
+      console.error(`Looked in:`);
+      console.error(`  - qa/screens/${screenName}/features/`);
+      console.error(`  - qa/features/${screenName}.feature`);
+      process.exit(1);
+    }
+
+    // Parse features
+    const { GherkinParser } = require('../core/selector-base/gherkin-parser');
+    const parser = new GherkinParser(this.config);
+    const features = await parser.parseAll(featureFiles);
+
+    // Validate selector files before generation
+    if (screenName) {
+      const validation = this.validateSelectorFiles(screenName, features);
+      const missing = validation.filter(v => !v.selectorExists);
+      
+      if (missing.length > 0) {
+        console.log(`\nMissing selector files:\n`);
+        missing.forEach(v => {
+          console.log(`  ✗ ${v.featureName}.feature → selector file not found`);
+        });
+        console.log(`\nRun: sungen map --screen ${screenName}\n`);
+        process.exit(1);
+      }
+    }
+
+    // Generate tests
+    const generator = TestGeneratorFactory.create(this.config.testGenerator.framework, this.config);
+    const results: GeneratedTest[] = [];
+
+    for (const feature of features) {
+      // Load selectors and test data
+      const selectors = {}; // TODO: Load from selector files
+      const testData = {};  // TODO: Load from test-data files
+
+      const result = await generator.generate(feature, selectors, testData, this.config);
+      results.push(result);
+
+      // Display per-file result
+      const fileName = path.basename(result.outputPath);
+      const relativePath = path.relative(process.cwd(), result.outputPath);
+      const stepInfo = result.stats?.totalSteps ? ` (${result.stats.totalSteps} steps)` : '';
+      
+      console.log(`✓ Generated ${fileName}`);
+      console.log(`   → ${relativePath}${stepInfo}\n`);
+    }
+
+    // Generate report
+    await this.reporter.generate(results);
+
+    // Display next step
+    console.log(`Next step: npx playwright test`);
+
+    return results;
+  }
+
+  /**
+   * Validate that selector files exist for all features
+   */
+  private validateSelectorFiles(screenName: string, features: any[]): Array<{
+    featureName: string;
+    sourceFile?: string;
+    selectorExists: boolean;
+    selectorPath: string | null;
+  }> {
+    const results: Array<{
+      featureName: string;
+      sourceFile?: string;
+      selectorExists: boolean;
+      selectorPath: string | null;
+    }> = [];
+    
+    for (const feature of features) {
+      const featureName = this.extractFeatureName(feature);
+      const selectorPath = this.findSelectorFile(screenName, featureName);
+      
+      results.push({
+        featureName,
+        sourceFile: feature.sourceFile,
+        selectorExists: selectorPath !== null,
+        selectorPath,
+      });
+    }
+    
+    return results;
+  }
+
+  /**
+   * Extract feature name from parsed feature
+   */
+  private extractFeatureName(feature: any): string {
+    if (feature.sourceFile) {
+      return path.basename(feature.sourceFile, path.extname(feature.sourceFile));
+    }
+    // Fallback to feature name
+    return feature.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+  }
+
+  /**
+   * Find selector file path for a feature
+   * Searches both old and new directory structures
+   */
+  private findSelectorFile(screenName: string, featureName: string): string | null {
+    const possiblePaths: string[] = [];
+
+    // New structure: qa/screens/{screen}/selectors/{feature}.yaml
+    const newStructurePath = path.join(
+      process.cwd(),
+      'qa',
+      'screens',
+      screenName,
+      'selectors',
+      `${featureName}.yaml`
+    );
+    possiblePaths.push(newStructurePath);
+
+    // Old structure: qa/selectors/screens/{feature}.yaml
+    const oldStructurePath = path.join(
+      process.cwd(),
+      'qa',
+      'selectors',
+      'screens',
+      `${featureName}.yaml`
+    );
+    possiblePaths.push(oldStructurePath);
+
+    // Find first existing file
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p)) {
+        return p;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Run full pipeline
+   * Discovery → Selector Mapping → Test Generation
+   */
+  async runFull(screens?: string[]): Promise<void> {
+    console.log('\n🚀 Running full pipeline\n');
+
+    // Discover screens if not specified
+    if (!screens || screens.length === 0) {
+      screens = await this.discoverScreensFromGherkin();
+      console.log(`  Found ${screens.length} screen(s) in Gherkin: ${screens.join(', ')}\n`);
+    }
+
+    // Phase 1: UI Discovery
+    console.log('📍 Phase 1: UI Discovery\n');
+    for (const screen of screens) {
+      await this.runDiscovery(screen);
+    }
+
+    // Phase 2: Selector Mapping
+    console.log('📍 Phase 2: Selector Mapping\n');
+    for (const screen of screens) {
+      await this.runSelectorMapping(screen);
+    }
+
+    // Phase 3: Test Generation
+    console.log('📍 Phase 3: Test Generation\n');
+    await this.runTestGeneration();
+
+    console.log('✅ Full pipeline completed!\n');
+  }
+
+  /**
+   * Clear all caches
+   */
+  async clearCache(): Promise<void> {
+    await this.cacheManager.clear();
+    console.log('✓ Cache cleared\n');
+  }
+
+  // ============================================================================
+  // Helper Methods
+  // ============================================================================
+
+  private async saveUIModel(uiModel: UIModel): Promise<void> {
+    const outputDir = path.join(this.config.paths.uiModelsDir, 'screens');
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    const outputPath = path.join(outputDir, `${uiModel.screen}.json`);
+    fs.writeFileSync(outputPath, JSON.stringify(uiModel, null, 2), 'utf-8');
+  }
+
+  private async loadUIModel(screenName: string): Promise<UIModel | null> {
+    const filePath = path.join(this.config.paths.uiModelsDir, 'screens', `${screenName}.json`);
+
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+
+  private async applyOverrides(screenName: string, selectors: SelectorBase): Promise<SelectorBase> {
+    const overridePath = path.join(
+      this.config.paths.selectorsDir,
+      'screens',
+      `${screenName}.override.yaml`
+    );
+
+    if (!fs.existsSync(overridePath)) {
+      return selectors;
+    }
+
+    try {
+      const content = fs.readFileSync(overridePath, 'utf-8');
+      const overrides = yaml.parse(content);
+
+      // Merge overrides (override values replace AI values)
+      if (overrides.elements) {
+        for (const [elementId, overrideValue] of Object.entries(overrides.elements)) {
+          if (selectors.elements[elementId]) {
+            Object.assign(selectors.elements[elementId], overrideValue);
+          }
+        }
+      }
+
+      if (this.config.verbose) {
+        console.log(`  Applied overrides from ${path.basename(overridePath)}`);
+      }
+    } catch (error) {
+      console.warn(`  Warning: Failed to apply overrides: ${error}`);
+    }
+
+    return selectors;
+  }
+
+  private findFeatureFiles(dir: string): string[] {
+    const files: string[] = [];
+
+    if (!fs.existsSync(dir)) {
+      return files;
+    }
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        files.push(...this.findFeatureFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith('.feature')) {
+        files.push(fullPath);
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Find feature files for a specific screen
+   */
+  private findFeatureFilesForScreen(screenName: string): string[] {
+    const files: string[] = [];
+
+    // New structure: qa/screens/<screenName>/features/
+    const screenFeaturesDir = path.join(
+      path.dirname(this.config.paths.featuresDir),
+      'screens',
+      screenName,
+      'features'
+    );
+
+    if (fs.existsSync(screenFeaturesDir)) {
+      files.push(...this.findFeatureFiles(screenFeaturesDir));
+    }
+
+    // Old structure: qa/features/<screenName>.feature (by convention)
+    const oldFeaturesDir = this.config.paths.featuresDir;
+    if (fs.existsSync(oldFeaturesDir)) {
+      const screenFeaturePath = path.join(oldFeaturesDir, `${screenName}.feature`);
+      if (fs.existsSync(screenFeaturePath)) {
+        files.push(screenFeaturePath);
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Find all feature files from both old and new folder structures
+   * Old: qa/features/*.feature
+   * New: qa/screens/*/features/*.feature
+   */
+  private findAllFeatureFiles(): string[] {
+    const allFiles: string[] = [];
+
+    // Old structure: qa/features/
+    const oldFeaturesDir = this.config.paths.featuresDir;
+    allFiles.push(...this.findFeatureFiles(oldFeaturesDir));
+
+    // New structure: qa/screens/*/features/
+    const screensDir = path.join(path.dirname(oldFeaturesDir), 'screens');
+    if (fs.existsSync(screensDir)) {
+      const screenDirs = fs.readdirSync(screensDir, { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name);
+
+      for (const screenName of screenDirs) {
+        const screenFeaturesDir = path.join(screensDir, screenName, 'features');
+        allFiles.push(...this.findFeatureFiles(screenFeaturesDir));
+      }
+    }
+
+    return allFiles;
+  }
+
+  /**
+   * Discover all unique screens referenced in Gherkin features
+   */
+  private async discoverScreensFromGherkin(): Promise<string[]> {
+    const featureFiles = this.findAllFeatureFiles();
+    const screens = new Set<string>();
+
+    // Regex to match [screen.element] pattern
+    const selectorPattern = /\[([a-z0-9-]+)\.([a-z0-9-]+)\]/gi;
+
+    for (const featureFile of featureFiles) {
+      const content = fs.readFileSync(featureFile, 'utf-8');
+
+      // Extract all [screen.element] references
+      let match;
+      while ((match = selectorPattern.exec(content)) !== null) {
+        const screenName = match[1];
+        screens.add(screenName);
+      }
+    }
+
+    return Array.from(screens).sort();
+  }
+}