@sun-asterisk/sungen 1.0.19 → 1.0.21

package/src/orchestrator/pipeline.ts

@@ -1,16 +1,12 @@
 /**
  * Pipeline Orchestrator
- * Coordinates all phases of test generation: UI Scan → Selector Mapping → Code Generation
+ * Coordinates test generation: Live-Scan → Scaffold → 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 { TestGeneratorFactory, GeneratedTest } from '../generators/test-generator/types';
 import { CacheManager } from './cache-manager';
 import { Reporter } from './reporter';
 
@@ -25,334 +21,6 @@ export class Pipeline {
     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
@@ -362,10 +30,10 @@ export class Pipeline {
     console.log(`\n${header}\n`);
 
     // Find all feature files from both old and new structure
-    const featureFiles = screenName 
+    const featureFiles = screenName
       ? this.findFeatureFilesForScreen(screenName)
       : this.findAllFeatureFiles();
-    
+
     if (screenName && featureFiles.length === 0) {
       throw new Error(
         `No feature files found for screen: ${screenName}\n` +
@@ -384,7 +52,7 @@ export class Pipeline {
     if (screenName) {
       const validation = this.validateSelectorFiles(screenName, features);
       const missing = validation.filter(v => !v.selectorExists);
-      
+
       if (missing.length > 0) {
         const missingList = missing.map(v => `  ✗ ${v.featureName}.feature → selector file not found`).join('\n');
         throw new Error(
@@ -412,7 +80,7 @@ export class Pipeline {
         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`);
       } catch (error) {
@@ -455,11 +123,11 @@ export class Pipeline {
       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,
@@ -467,7 +135,7 @@ export class Pipeline {
         selectorPath,
       });
     }
-    
+
     return results;
   }
 
@@ -484,7 +152,6 @@ export class Pipeline {
 
   /**
    * 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[] = [];
@@ -510,7 +177,6 @@ export class Pipeline {
     );
     possiblePaths.push(oldStructurePath);
 
-    // Find first existing file
     for (const p of possiblePaths) {
       if (fs.existsSync(p)) {
         return p;
@@ -521,10 +187,12 @@ export class Pipeline {
   }
 
   /**
-   * Run full pipeline
-   * Discovery → Selector Mapping → Test Generation
+   * Run full pipeline: Live-Scan → Scaffold → Test Generation
    */
-  async runFull(screens?: string[]): Promise<void> {
+  async runFull(
+    screens?: string[],
+    options?: { headed?: boolean; authDir?: string; skipLiveScan?: boolean; force?: boolean }
+  ): Promise<void> {
     console.log('\n🚀 Running full pipeline\n');
 
     // Discover screens if not specified
@@ -533,20 +201,43 @@ export class Pipeline {
       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);
-    }
+    const screensDir = 'qa/screens';
 
-    // Phase 2: Selector Mapping
-    console.log('📍 Phase 2: Selector Mapping\n');
     for (const screen of screens) {
-      await this.runSelectorMapping(screen);
+      // Phase 1: Live-scan
+      if (!options?.skipLiveScan) {
+        console.log(`📍 Phase 1: Live-Scan — ${screen}\n`);
+        const { LiveScanner } = require('../core/live-scanner');
+        const scanner = new LiveScanner({
+          screenName: screen,
+          screensDir,
+          headed: options?.headed,
+          authDir: options?.authDir || 'specs/.auth',
+          force: options?.force,
+        });
+        await scanner.scan();
+        console.log('');
+      }
+
+      // Phase 2: Scaffold (map)
+      console.log(`📍 Phase 2: Map — ${screen}\n`);
+      const { ScaffoldGenerator } = require('../generators/scaffold-generator');
+      const generator = new ScaffoldGenerator();
+      const results = generator.processScreen(screen, screensDir, options?.force || false);
+
+      for (const result of results) {
+        console.log(`✓ Mapped ${result.featureFile}.feature`);
+        if (result.selectorsSkipped) {
+          console.log(`   ⊘ ${path.basename(result.selectorsPath)} (skipped - already exists)`);
+        } else {
+          console.log(`   → ${path.basename(result.selectorsPath)} (${result.elementCount} elements)`);
+        }
+        console.log('');
+      }
     }
 
     // Phase 3: Test Generation
-    console.log('📍 Phase 3: Test Generation\n');
+    console.log('📍 Phase 3: Generate Tests\n');
     await this.runTestGeneration();
 
     console.log('✅ Full pipeline completed!\n');
@@ -564,65 +255,6 @@ export class Pipeline {
   // 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[] = [];
 
@@ -677,8 +309,6 @@ export class Pipeline {
 
   /**
    * 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[] = [];
@@ -704,26 +334,21 @@ export class Pipeline {
   }
 
   /**
-   * Discover all unique screens referenced in Gherkin features
+   * Discover all unique screens from qa/screens/ directory
    */
   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);
-      }
+    const screensDir = path.join(process.cwd(), 'qa', 'screens');
+    if (!fs.existsSync(screensDir)) {
+      return [];
     }
 
-    return Array.from(screens).sort();
+    return fs.readdirSync(screensDir, { withFileTypes: true })
+      .filter(entry => entry.isDirectory())
+      .filter(entry => {
+        const featuresDir = path.join(screensDir, entry.name, 'features');
+        return fs.existsSync(featuresDir);
+      })
+      .map(entry => entry.name)
+      .sort();
   }
 }

package/src/orchestrator/reporter.ts

@@ -6,7 +6,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { RuntimeConfig } from '../config/config-schema';
-import { GeneratedTest } from '../executor/test-generator';
+import { GeneratedTest } from '../generators/test-generator/types';
 
 export class Reporter {
   private config: RuntimeConfig;

package/src/orchestrator/screen-manager.ts

@@ -182,7 +182,7 @@ export class ScreenManager {
 
   @high
   Scenario: Sample scenario for ${options.name}
-    Given User open [${options.name}] page
+    Given User is on [${options.name}] page
     When User click [element] button
     Then User see [result] text with {{success}}
 `;

package/src/utils/feature-finder.ts

@@ -0,0 +1,33 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getFeaturesDir } from './screen-paths';
+
+/**
+ * Find all .feature files for a specific screen.
+ */
+export function findFeatureFiles(screensRoot: string, screenName: string): string[] {
+  const featuresDir = getFeaturesDir(screensRoot, screenName);
+  if (!fs.existsSync(featuresDir)) {
+    return [];
+  }
+  return fs.readdirSync(featuresDir)
+    .filter(f => f.endsWith('.feature'))
+    .map(f => path.join(featuresDir, f));
+}
+
+/**
+ * Find all .feature files across all screens.
+ */
+export function findAllFeatureFiles(screensRoot: string): string[] {
+  if (!fs.existsSync(screensRoot)) {
+    return [];
+  }
+  const files: string[] = [];
+  const screens = fs.readdirSync(screensRoot).filter(d =>
+    fs.statSync(path.join(screensRoot, d)).isDirectory()
+  );
+  for (const screen of screens) {
+    files.push(...findFeatureFiles(screensRoot, screen));
+  }
+  return files;
+}

package/src/utils/screen-paths.ts

@@ -0,0 +1,37 @@
+import * as path from 'path';
+
+export function getScreenDir(screensRoot: string, screenName: string): string {
+  return path.join(screensRoot, screenName);
+}
+
+export function getFeaturesDir(screensRoot: string, screenName: string): string {
+  return path.join(screensRoot, screenName, 'features');
+}
+
+export function getSelectorsDir(screensRoot: string, screenName: string): string {
+  return path.join(screensRoot, screenName, 'selectors');
+}
+
+export function getTestDataDir(screensRoot: string, screenName: string): string {
+  return path.join(screensRoot, screenName, 'test-data');
+}
+
+export function getSelectorBasePath(screensRoot: string, screenName: string, featureName: string): string {
+  return path.join(screensRoot, screenName, 'selectors', `${featureName}.yaml`);
+}
+
+export function getSelectorOverridePath(screensRoot: string, screenName: string, featureName: string): string {
+  return path.join(screensRoot, screenName, 'selectors', `${featureName}.override.yaml`);
+}
+
+export function getTestDataBasePath(screensRoot: string, screenName: string, featureName: string): string {
+  return path.join(screensRoot, screenName, 'test-data', `${featureName}.yaml`);
+}
+
+export function getTestDataOverridePath(screensRoot: string, screenName: string, featureName: string): string {
+  return path.join(screensRoot, screenName, 'test-data', `${featureName}.override.yaml`);
+}
+
+export function getLiveScanPath(screensRoot: string, screenName: string, featureName: string): string {
+  return path.join(screensRoot, screenName, 'selectors', `${featureName}.live-scan.yaml`);
+}