@sun-asterisk/sungen 1.0.24 → 2.0.0

package/src/generators/scaffold-generator/index.ts

@@ -1,1029 +0,0 @@
-/**
- * Scaffold Generator
- * Parses Gherkin feature files and generates selector YAML scaffolds
- */
-
-import fs from 'fs';
-import path from 'path';
-import yaml from 'yaml';
-import { glob } from 'glob';
-import { SelectorResolver } from '../test-generator/utils/selector-resolver';
-import { SelectorType } from '../../utils/selector-types';
-
-export interface ScaffoldElement {
-  locator: string;
-  type: SelectorType;
-  value: string;
-  name?: string;       // For role type (accessible name), or label text
-  nth: number;
-  exact?: boolean;     // Whether to use exact matching (default: false)
-  inputMethod?: string; // 'pressSequentially' for contenteditable/rich-text elements
-}
-
-export interface ScaffoldResult {
-  [key: string]: ScaffoldElement;
-}
-
-export interface TestDataResult {
-  [key: string]: string | TestDataResult;
-}
-
-export interface MapResult {
-  featureFile: string;
-  selectorsPath: string;
-  testDataPath: string;
-  elementCount: number;
-  dataRefCount: number;
-  selectorsSkipped?: boolean;  // True if selectors file already existed (and force was not set)
-  testDataMerged?: boolean;    // True if test-data file existed and was smart-merged
-}
-
-interface ExtractedDataRef {
-  rawRef: string;         // Original ref e.g., "valid_login_email" or "valid.login_password"
-  lineText: string;       // Full line for context
-}
-
-interface ExtractedElement {
-  rawText: string;        // Original text in brackets e.g., "Email Address"
-  key: string;            // Converted key e.g., "email.address"
-  action: string;         // Action type: fill, click, see, open, select
-  targetType: string;     // Target type from Gherkin: button, link, field, radio, dropdown, text, etc.
-  lineText: string;       // Full line for context
-  nth: number;            // Index from "field 1", "button 2", etc. (0 = no index specified)
-  featurePath?: string;   // NEW: Feature path for page type (e.g., "/" or "/dashboard")
-}
-
-export class ScaffoldGenerator {
-  /**
-   * Generate scaffold YAML from a feature file
-   */
-  generateFromFile(featureFilePath: string): ScaffoldResult {
-    const content = fs.readFileSync(featureFilePath, 'utf-8');
-    return this.generateFromContent(content);
-  }
-
-  /**
-   * Generate scaffold YAML from feature content
-   */
-  generateFromContent(content: string): ScaffoldResult {
-    // Extract feature path from Gherkin metadata (e.g., "Path: login-guest?user=inactive")
-    const featurePath = this.extractFeaturePath(content);
-
-    const elements = this.extractElements(content, featurePath);
-    return this.buildScaffold(elements);
-  }
-
-  /**
-   * Extract elements from Gherkin content with their actions
-   */
-  private extractElements(content: string, featurePath?: string): ExtractedElement[] {
-    const elements: ExtractedElement[] = [];
-    const lines = content.split('\n');
-
-    // Regex to match elements in brackets [...] with optional nth index
-    // Captures: [Element] field 1, [Element] button 2, [Element] text 3, etc.
-    const elementRegex = /\[([^\]]+)\]/g;
-
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-
-      // Skip comments and empty lines
-      if (trimmedLine.startsWith('#') || !trimmedLine) {
-        continue;
-      }
-
-      // Determine action from the line
-      const action = this.detectAction(trimmedLine);
-
-      let match: RegExpExecArray | null;
-      while ((match = elementRegex.exec(trimmedLine)) !== null) {
-        const rawText = match[1];
-        const baseKey = SelectorResolver.generateKey(rawText);
-
-        // Extract nth index and target type from text after the element reference
-        // Matches patterns like: [Email] field 1, [Submit] button 2, [Name] 3
-        const afterElement = trimmedLine.slice(match.index + match[0].length);
-        const nth = SelectorResolver.extractNthFromStep(afterElement);
-        const targetType = this.extractTargetType(afterElement, action);
-
-        // Append nth to key so elements at different positions get distinct keys
-        // e.g., [Hãy gửi lời cảm ơn] field 3 → "hay.gui.loi.cam.on--3"
-        const key = nth > 0 ? `${baseKey}--${nth}` : baseKey;
-
-        // Check if element starts with "target" (semantic indicator for dynamic content)
-        // e.g., [target order], [Target Item] → element should have empty value
-        const isTargetElement = /^target\s/i.test(rawText);
-
-        elements.push({
-          rawText: isTargetElement ? '' : rawText,  // Empty value when element is a target element
-          key,
-          action,
-          targetType,
-          lineText: trimmedLine,
-          nth,
-          featurePath: targetType === 'page' ? featurePath : undefined,
-        });
-      }
-    }
-
-    return elements;
-  }
-
-  /**
-   * Extract target type from text after element reference
-   * e.g., " button" -> "button", " link 1" -> "link", " field with" -> "field"
-   */
-  private extractTargetType(text: string, action: string): string {
-    const lowerText = text.toLowerCase().trim();
-
-    // NEW: Check for 'page' keyword FIRST (highest priority)
-    if (/^page\b/.test(lowerText) || /^\d*\s*page\b/.test(lowerText)) {
-      return 'page';
-    }
-
-    // Check for specific target types in order of specificity
-    if (/^link\b/.test(lowerText) || /^\d*\s*link\b/.test(lowerText)) {
-      return 'link';
-    }
-    if (/^button\b/.test(lowerText) || /^\d*\s*button\b/.test(lowerText)) {
-      return 'button';
-    }
-    if (/^radio\b/.test(lowerText) || /^\d*\s*radio\b/.test(lowerText)) {
-      return 'radio';
-    }
-    if (/^dropdown\b/.test(lowerText) || /^\d*\s*dropdown\b/.test(lowerText) || /^select\b/.test(lowerText)) {
-      return 'dropdown';
-    }
-    if (/^checkbox\b/.test(lowerText) || /^\d*\s*checkbox\b/.test(lowerText)) {
-      return 'checkbox';
-    }
-    if (/^field\b/.test(lowerText) || /^\d*\s*field\b/.test(lowerText) || /^input\b/.test(lowerText)) {
-      return 'field';
-    }
-    if (/^textbox\b/.test(lowerText) || /^\d*\s*textbox\b/.test(lowerText)) {
-      return 'textbox';
-    }
-    if (/^textarea\b/.test(lowerText) || /^\d*\s*textarea\b/.test(lowerText)) {
-      return 'textarea';
-    }
-    if (/^editor\b/.test(lowerText) || /^\d*\s*editor\b/.test(lowerText)) {
-      return 'editor';
-    }
-    if (/^text\b/.test(lowerText) || /^\d*\s*text\b/.test(lowerText)) {
-      return 'text';
-    }
-    if (/^label\b/.test(lowerText) || /^\d*\s*label\b/.test(lowerText)) {
-      return 'label';
-    }
-    if (/^uploader\b/.test(lowerText) || /^\d*\s*uploader\b/.test(lowerText)) {
-      return 'uploader';
-    }
-    if (/^element\b/.test(lowerText) || /^\d*\s*element\b/.test(lowerText)) {
-      return 'element';
-    }
-    if (/^(column|columnheader)\b/.test(lowerText) || /^\d*\s*(column|columnheader)\b/.test(lowerText)) {
-      return 'column';
-    }
-    if (/^(logo|image|img|icon)\b/.test(lowerText) || /^\d*\s*(logo|image|img|icon)\b/.test(lowerText)) {
-      return 'img';
-    }
-    if (/^(option|item|listitem)\b/.test(lowerText) || /^\d*\s*(option|item|listitem)\b/.test(lowerText)) {
-      return 'option';
-    }
-    if (/^(dialog|modal)\b/.test(lowerText) || /^\d*\s*(dialog|modal)\b/.test(lowerText)) {
-      return 'dialog';
-    }
-    if (/^(heading|header)\b/.test(lowerText) || /^\d*\s*(heading|header)\b/.test(lowerText)) {
-      return 'heading';
-    }
-    if (/^(title|caption|message)\b/.test(lowerText) || /^\d*\s*(title|caption|message)\b/.test(lowerText)) {
-      return 'text';
-    }
-
-    // Default based on action
-    switch (action) {
-      case 'click':
-        return 'text';  // Default click to text
-      case 'fill':
-        return 'field';   // Default fill to field
-      case 'see':
-        return 'text';    // Default see to text
-      case 'select':
-        return 'dropdown'; // Default select to dropdown
-      default:
-        return 'element';
-    }
-  }
-
-  /**
-   * Extract nth index from text after element reference
-   * e.g., " field 1 with" -> 1, " button 2" -> 2, " row 1" -> 1, " text" -> 0
-   */
-  /**
-   * Detect the action type from a Gherkin step line
-   */
-  private detectAction(line: string): string {
-    const lowerLine = line.toLowerCase();
-
-    // Check for specific action keywords
-    // Order matters: check "see" before "fill" because text like "fill in all fields" may appear in assertions
-    if (/\b(see|verify|check|expect|should see|visible|displayed)\b/.test(lowerLine)) {
-      return 'see';
-    }
-    if (/\b(fill|enter|type|input)\b/.test(lowerLine)) {
-      return 'fill';
-    }
-    if (/\b(click|press|tap|submit)\b/.test(lowerLine)) {
-      return 'click';
-    }
-    if (/\b(open|navigate|go to|visit)\b/.test(lowerLine)) {
-      return 'open';
-    }
-    if (/\b(select|choose|pick)\b/.test(lowerLine)) {
-      return 'select';
-    }
-    if (/\b(wait|wait for|waits for)\b/.test(lowerLine)) {
-      return 'wait';
-    }
-
-    // Default to placeholder for unknown actions
-    return 'default';
-  }
-
-  /**
-   * Extract feature path from Gherkin metadata
-   * Looks for "Path: <value>" line in the feature file
-   * e.g., "Path: login-guest?user=inactive" -> "login-guest?user=inactive"
-   */
-  private extractFeaturePath(content: string): string | undefined {
-    const lines = content.split('\n');
-
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-
-      // Look for Path: pattern (case-insensitive)
-      const match = trimmedLine.match(/^Path:\s*(.+?)$/i);
-      if (match) {
-        return match[1].trim();
-      }
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Convert element text to YAML key format
-   * "Email Address" -> "email.address"
-   * "Your email or password is incorrect!" -> "your.email.or.password.is.incorrect"
-   */
-  /**
-   * Get action priority (higher number = higher priority)
-   */
-  private getActionPriority(action: string): number {
-    const priorities: { [key: string]: number } = {
-      'click': 4,    // Highest priority - most specific interaction
-      'fill': 3,     // Form input
-      'select': 3,   // Form select
-      'see': 2,      // Assertion
-      'open': 1,     // Navigation - lowest priority
-      'default': 0,
-    };
-    return priorities[action] ?? 0;
-  }
-
-  /**
-   * Build scaffold result from extracted elements
-   */
-  private buildScaffold(elements: ExtractedElement[]): ScaffoldResult {
-    const result: ScaffoldResult = {};
-
-    // Group elements by key to detect duplicates with different target types
-    const elementsByKey: { [key: string]: ExtractedElement[] } = {};
-    for (const element of elements) {
-      if (!elementsByKey[element.key]) {
-        elementsByKey[element.key] = [];
-      }
-      elementsByKey[element.key].push(element);
-    }
-
-    for (const key of Object.keys(elementsByKey)) {
-      const group = elementsByKey[key];
-
-      // Deduplicate by targetType, keeping highest priority action per type
-      const byType: { [type: string]: ExtractedElement } = {};
-      for (const element of group) {
-        const existing = byType[element.targetType];
-        if (!existing ||
-            this.getActionPriority(element.action) > this.getActionPriority(existing.action)) {
-          byType[element.targetType] = element;
-        }
-      }
-
-      const uniqueTypes = Object.keys(byType);
-
-      if (uniqueTypes.length <= 1) {
-        // No type conflict — use base key as before
-        const element = byType[uniqueTypes[0]];
-        result[key] = this.createScaffoldElement(element);
-      } else {
-        // Multiple types for same name — generate type-suffixed keys
-        for (const type of uniqueTypes) {
-          const suffixedKey = `${key}--${type}`;
-          result[suffixedKey] = this.createScaffoldElement(byType[type]);
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Create a scaffold element based on the action type and target type
-   */
-  private createScaffoldElement(element: ExtractedElement): ScaffoldElement {
-    const { nth, targetType } = element;
-
-    // NEW: Handle page type
-    if (targetType === 'page') {
-      return {
-        locator: '',
-        type: 'page',
-        value: element.featurePath || '/',
-        nth,
-      };
-    }
-
-    switch (element.action) {
-      case 'fill':
-        // For fill action with uploader type, use label type (file input triggered by label)
-        if (targetType === 'uploader') {
-          return {
-            locator: '',
-            type: 'label',
-            value: element.rawText,
-            nth,
-          };
-        }
-
-        // For fill action with label type, use label type
-        if (targetType === 'label') {
-          return {
-            locator: '',
-            type: 'label',
-            value: element.rawText,
-            nth,
-          };
-        }
-
-        // For fill action with field/textbox/textarea types, use role-based locator
-        return {
-          locator: '',
-          type: 'role',
-          value: this.getFillRoleValue(targetType),
-          name: element.rawText,
-          nth,
-        };
-
-      case 'click':
-        // Special case: label and text clicks use text locator
-        if (targetType === 'label' || targetType === 'text') {
-          return {
-            locator: '',
-            type: 'text',
-            value: element.rawText,
-            nth,
-          };
-        }
-
-        // Regular click actions use role
-        const clickRoleValue = this.getClickRoleValue(targetType);
-        return {
-          locator: '',
-          type: 'role',
-          value: clickRoleValue,
-          name: element.rawText, // TODO: Update with actual accessible name from inspection
-          nth,
-        };
-
-      case 'see':
-        // Column type: used for table column cell assertions, no DOM selector needed
-        if (targetType === 'column') {
-          return {
-            locator: '',
-            type: 'column',
-            value: element.rawText,
-            nth,
-          };
-        }
-
-        // For assertions - respect targetType for role-based elements
-        if (targetType === 'img' || targetType === 'button' || targetType === 'link' ||
-            targetType === 'checkbox' || targetType === 'radio' || targetType === 'heading' || targetType === 'dialog' || targetType === 'dropdown') {
-          const seeRoleValue = this.getRoleValue(targetType);
-          return {
-            locator: '',
-            type: 'role',
-            value: seeRoleValue,
-            name: element.rawText,
-            nth,
-          };
-        }
-        return {
-          locator: '',
-          type: 'text',
-          value: element.rawText,
-          nth,
-        };
-
-      case 'select':
-        // Determine role based on target type (radio, dropdown/combobox, checkbox)
-        const selectRoleValue = this.getSelectRoleValue(targetType);
-        return {
-          locator: '',
-          type: 'role',
-          value: selectRoleValue,
-          name: element.rawText, // TODO: Update with actual accessible name from inspection
-          nth,
-        };
-
-      case 'open':
-        // For page navigation, we typically don't need a selector
-        // But include it for reference
-        return {
-          locator: '',
-          type: 'text',
-          value: element.rawText,
-          nth,
-        };
-
-      default:
-        // Default to placeholder type
-        return {
-          locator: '',
-          type: 'placeholder',
-          value: element.rawText,
-          nth,
-        };
-    }
-  }
-
-  /**
-   * Get ARIA role value from target type (shared across actions)
-   */
-  private getRoleValue(targetType: string): string {
-    switch (targetType) {
-      case 'link':
-        return 'link';
-      case 'button':
-        return 'button';
-      case 'checkbox':
-        return 'checkbox';
-      case 'radio':
-        return 'radio';
-      case 'tab':
-        return 'tab';
-      case 'menuitem':
-        return 'menuitem';
-      case 'img':
-        return 'img';
-      case 'heading':
-        return 'heading';
-      case 'dialog':
-        return 'dialog';
-      case 'dropdown':
-        return 'button';
-      default:
-        return 'button'; // Default to button
-    }
-  }
-
-  /**
-   * Get role value for click actions based on target type
-   */
-  private getClickRoleValue(targetType: string): string {
-    return this.getRoleValue(targetType);
-  }
-
-  /**
-   * Get role value for select actions based on target type
-   */
-  private getSelectRoleValue(targetType: string): string {
-    switch (targetType) {
-      case 'radio':
-        return 'radio';
-      case 'checkbox':
-        return 'checkbox';
-      case 'dropdown':
-      case 'select':
-        return 'combobox';
-      case 'listbox':
-        return 'listbox';
-      default:
-        return 'combobox'; // Default to combobox
-    }
-  }
-
-  /**
-   * Get ARIA role value for fill actions — all fillable inputs use 'textbox'
-   */
-  private getFillRoleValue(targetType: string): string {
-    switch (targetType) {
-      case 'field':
-      case 'textbox':
-      case 'textarea':
-      default:
-        return 'textbox';
-    }
-  }
-
-  /**
-   * Generate YAML content from scaffold result
-   */
-  generateYamlContent(scaffold: ScaffoldResult, screenName?: string): string {
-    // For header, use name (for role type) or value (for other types)
-    const getDisplayValue = (e: ScaffoldElement) => e.name || e.value;
-
-    const header = screenName
-      ? `# ${this.capitalizeFirst(screenName)} Screen Selectors (Auto-generated)
-# Reference in features: ${Object.values(scaffold).map(e => `[${getDisplayValue(e)}]`).join(', ')}
-# Directory: qa/selectors/screens/
-
-`
-      : `# Screen Selectors (Auto-generated)
-
-`;
-
-    // Convert to YAML with proper formatting
-    const yamlContent = yaml.stringify(scaffold, {
-      indent: 2,
-      lineWidth: 100,
-      defaultKeyType: 'PLAIN',
-      defaultStringType: 'QUOTE_SINGLE',
-    });
-
-    return header + yamlContent;
-  }
-
-  /**
-   * Write scaffold to file
-   */
-  writeScaffold(
-    scaffold: ScaffoldResult,
-    outputPath: string,
-    screenName?: string
-  ): void {
-    const dir = path.dirname(outputPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-
-    const content = this.generateYamlContent(scaffold, screenName);
-    fs.writeFileSync(outputPath, content, 'utf-8');
-  }
-
-  /**
-   * Process a feature file and write scaffold to output
-   */
-  processFeatureFile(
-    featureFilePath: string,
-    outputDir: string,
-    forceOverwrite: boolean = false
-  ): { outputPath: string; elementCount: number } {
-    // Extract screen name from feature file name
-    const featureFileName = path.basename(featureFilePath, '.feature');
-    const screenName = featureFileName;
-
-    // Generate scaffold
-    const scaffold = this.generateFromFile(featureFilePath);
-    const elementCount = Object.keys(scaffold).length;
-
-    // Write to output
-    const outputPath = path.join(outputDir, `${screenName}.yaml`);
-    
-    // Check if file exists and skip if not forcing overwrite
-    if (fs.existsSync(outputPath) && !forceOverwrite) {
-      return { outputPath, elementCount };
-    }
-    
-    this.writeScaffold(scaffold, outputPath, screenName);
-
-    return { outputPath, elementCount };
-  }
-
-  /**
-   * Process all feature files in a directory
-   */
-  processAllFeatures(
-    featuresDir: string,
-    outputDir: string
-  ): Array<{ file: string; outputPath: string; elementCount: number }> {
-    const featureFiles = glob.sync('**/*.feature', {
-      cwd: featuresDir,
-      absolute: true,
-    });
-
-    const results: Array<{ file: string; outputPath: string; elementCount: number }> = [];
-
-    for (const featureFile of featureFiles) {
-      const result = this.processFeatureFile(featureFile, outputDir);
-      results.push({
-        file: featureFile,
-        ...result,
-      });
-    }
-
-    return results;
-  }
-
-  /**
-   * Enrich scaffold with live-scan data if a .live-scan.yaml file exists.
-   * Uses the Playwright locator strategy detected by live-scan:
-   *   testid      → type: testid, value: <testid>
-   *   role        → type: role, value: <aria-role>, name: <accessible-name>
-   *   label       → type: label, value: <label-text>
-   *   placeholder → type: placeholder, value: <placeholder-text>
-   *   text        → type: text, value: <visible-text>
-   */
-  private enrichWithLiveScan(scaffold: ScaffoldResult, liveScanPath: string): ScaffoldResult {
-    if (!fs.existsSync(liveScanPath)) {
-      return scaffold;
-    }
-
-    let matrixData: any;
-    try {
-      const { readMatrix, mergeMatrixElements } = require('../../core/live-scanner/matrix-reader');
-      matrixData = readMatrix(liveScanPath);
-      if (!matrixData) return scaffold;
-
-      const elements = mergeMatrixElements(matrixData);
-      if (!elements || Object.keys(elements).length === 0) return scaffold;
-
-      console.log(`   🔗 Using live-scan data from ${path.basename(liveScanPath)}`);
-
-      let enrichedCount = 0;
-      let warningCount = 0;
-
-      const enriched: ScaffoldResult = { ...scaffold };
-
-      for (const [key, scaffoldElement] of Object.entries(enriched)) {
-        // Column-type elements use header text matching, skip live-scan enrichment
-        if (scaffoldElement.type === 'column') continue;
-        // Target elements (empty value) are matched by data value at runtime, skip enrichment
-        if (!scaffoldElement.value && !scaffoldElement.name) continue;
-
-        // Try exact key first, then base key without --N suffix or --type suffix
-        let liveElement = elements[key];
-        if (!liveElement && key.includes('--')) {
-          const baseKey = key.replace(/--.*$/, '');
-          liveElement = elements[baseKey];
-        }
-        if (!liveElement) {
-          continue;
-        }
-
-        // If live-scan couldn't find the element, clear the identifying field so user must fill manually
-        if (liveElement.matchMethod === 'unresolved') {
-          if (scaffoldElement.name !== undefined) {
-            enriched[key] = { ...scaffoldElement, name: '' };
-          } else {
-            enriched[key] = { ...scaffoldElement, value: '' };
-          }
-          continue;
-        }
-
-        // Use the Playwright locator strategy that live-scan detected
-        const selectorType = liveElement.selectorType;
-
-        // Only set exact when true (omit from YAML when false for cleaner output)
-        const exactField = liveElement.exact ? { exact: true } : {};
-
-        // Strip 'name' from scaffold base — only 'role' type uses name
-        const { name: _scaffoldName, ...scaffoldBase } = scaffoldElement as any;
-
-        if (selectorType === 'testid' && liveElement.testid) {
-          // page.getByTestId('value')
-          enriched[key] = {
-            ...scaffoldBase,
-            type: 'testid' as any,
-            value: liveElement.testid,
-          };
-        } else if (selectorType === 'role' && liveElement.role) {
-          // page.getByRole('button', { name: 'Submit' })
-          // When name is empty (e.g. data-value fallback), keep it as '' —
-          // the actual name comes from test-data at runtime
-          enriched[key] = {
-            ...scaffoldBase,
-            type: 'role',
-            value: liveElement.role,
-            name: liveElement.name,
-            ...exactField,
-          };
-        } else if (selectorType === 'label' && liveElement.label) {
-          // page.getByLabel('Username')
-          enriched[key] = {
-            ...scaffoldBase,
-            type: 'label',
-            value: liveElement.label,
-            ...exactField,
-          };
-        } else if (selectorType === 'placeholder' && (liveElement.placeholder || liveElement.selectorValue)) {
-          // page.getByPlaceholder('Enter email')
-          enriched[key] = {
-            ...scaffoldBase,
-            type: 'placeholder',
-            value: liveElement.placeholder || liveElement.selectorValue,
-            ...exactField,
-          };
-        } else if (selectorType === 'text') {
-          // page.getByText('Welcome')
-          // When name is empty (data-value fallback), keep value empty —
-          // the actual text comes from test-data at runtime
-          enriched[key] = {
-            ...scaffoldBase,
-            type: 'text',
-            value: liveElement.name,
-            ...exactField,
-          };
-        } else if (selectorType === 'locator' && liveElement.selectorValue) {
-          // page.locator('[contenteditable="true"]') — CSS locator
-          // Reset nth to 0: the original nth was for text matches, not this locator type
-          enriched[key] = {
-            ...scaffoldBase,
-            type: 'locator' as any,
-            value: liveElement.selectorValue,
-            nth: 0,
-          };
-        } else {
-          continue;
-        }
-
-        // Detect contenteditable div-based editors (rich text editors like TipTap, Quill, ProseMirror)
-        // When the DOM element is contenteditable but NOT a native input/textarea,
-        // mark it so the generator uses click + pressSequentially instead of .fill()
-        if (liveElement.contenteditable && liveElement.tag !== 'textarea' && liveElement.tag !== 'input') {
-          enriched[key] = { ...enriched[key], inputMethod: 'pressSequentially' };
-        }
-
-        enrichedCount++;
-        if (liveElement.warning) {
-          warningCount++;
-          console.log(`   ⚠️  ${key}: ${liveElement.warning}`);
-        }
-      }
-
-      const textOnlyCount = Object.keys(enriched).length - enrichedCount;
-      console.log(`   📊 Live-scan: ${enrichedCount} enriched, ${textOnlyCount} text-inferred${warningCount > 0 ? `, ${warningCount} warnings` : ''}`);
-
-      return enriched;
-    } catch (error: any) {
-      console.warn(`   ⚠️  Failed to read live-scan data: ${error.message}`);
-      return scaffold;
-    }
-  }
-
-  /**
-   * Helper to capitalize first letter
-   */
-  private capitalizeFirst(str: string): string {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-
-  /**
-   * Process a screen and generate both selectors and test-data YAML
-   * Folder structure: qa/screens/<screen>/features/, selectors/, test-data/
-   */
-  processScreen(screenName: string, screensDir: string = 'qa/screens', forceOverwrite: boolean = false): MapResult[] {
-    const screenDir = path.join(screensDir, screenName);
-    const featuresDir = path.join(screenDir, 'features');
-    const selectorsDir = path.join(screenDir, 'selectors');
-    const testDataDir = path.join(screenDir, 'test-data');
-
-    // Find all feature files in the screen's features directory
-    const featureFiles = glob.sync('**/*.feature', {
-      cwd: featuresDir,
-      absolute: true,
-    });
-
-    if (featureFiles.length === 0) {
-      throw new Error(`No feature files found in ${featuresDir}`);
-    }
-
-    // Ensure directories exist
-    fs.mkdirSync(selectorsDir, { recursive: true });
-    fs.mkdirSync(testDataDir, { recursive: true });
-
-    const results: MapResult[] = [];
-
-    // Process each feature file individually
-    for (const featureFile of featureFiles) {
-      const filename = path.basename(featureFile, '.feature');
-      const content = fs.readFileSync(featureFile, 'utf-8');
-
-      // Extract feature path from Gherkin metadata
-      const featurePath = this.extractFeaturePath(content);
-
-      // Extract elements and data refs from this file
-      const elements = this.extractElements(content, featurePath);
-      const dataRefs = this.extractDataRefs(content);
-
-      // Build scaffolds from this file
-      const selectorScaffold = this.buildScaffold(elements);
-      const testDataScaffold = this.buildTestData(dataRefs);
-
-      // Enrich scaffold with live-scan data if available
-      const liveScanPath = path.join(selectorsDir, `${filename}.live-scan.yaml`);
-      const liveScanEnriched = this.enrichWithLiveScan(selectorScaffold, liveScanPath);
-
-      // Check if files exist
-      const selectorsPath = path.join(selectorsDir, `${filename}.yaml`);
-      const selectorsOverridePath = path.join(selectorsDir, `${filename}.override.yaml`);
-      const selectorsExists = fs.existsSync(selectorsPath);
-      
-      const testDataPath = path.join(testDataDir, `${filename}.yaml`);
-      const testDataOverridePath = path.join(testDataDir, `${filename}.override.yaml`);
-      const testDataExists = fs.existsSync(testDataPath);
-
-      // Write selectors YAML (BASE ONLY - never touch override files)
-      if (!selectorsExists || forceOverwrite) {
-        this.writeSelectorsYaml(liveScanEnriched, selectorsPath, filename);
-      }
-      // Override file is NEVER touched by map command
-
-      // Write test-data YAML — always smart-merge regardless of --force:
-      // • existing keys keep their current value
-      // • new keys from features are added (empty string)
-      // • keys no longer referenced in features are removed
-      if (testDataExists) {
-        const existingRaw = yaml.parse(fs.readFileSync(testDataPath, 'utf-8')) as TestDataResult || {};
-        const merged = this.mergeTestData(existingRaw, testDataScaffold);
-        this.writeTestDataYaml(merged, testDataPath, filename);
-      } else {
-        this.writeTestDataYaml(testDataScaffold, testDataPath, filename);
-      }
-      // Override file is NEVER touched by map command
-
-      results.push({
-        featureFile: filename,
-        selectorsPath,
-        testDataPath,
-        elementCount: Object.keys(liveScanEnriched).length,
-        dataRefCount: dataRefs.length,
-        selectorsSkipped: selectorsExists && !forceOverwrite,
-        testDataMerged: testDataExists,
-      });
-    }
-
-    return results;
-  }
-
-  /**
-   * Extract data references {{...}} from Gherkin content
-   */
-  private extractDataRefs(content: string): ExtractedDataRef[] {
-    const dataRefs: ExtractedDataRef[] = [];
-    const lines = content.split('\n');
-    const seen = new Set<string>();
-
-    // Regex to match data refs {{...}}
-    const dataRefRegex = /\{\{([^}]+)\}\}/g;
-
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-
-      // Skip comments and empty lines
-      if (trimmedLine.startsWith('#') || !trimmedLine) {
-        continue;
-      }
-
-      let match: RegExpExecArray | null;
-      while ((match = dataRefRegex.exec(trimmedLine)) !== null) {
-        const rawRef = match[1].trim();
-
-        // Skip duplicates
-        if (seen.has(rawRef)) {
-          continue;
-        }
-        seen.add(rawRef);
-
-        dataRefs.push({
-          rawRef,
-          lineText: trimmedLine,
-        });
-      }
-    }
-
-    return dataRefs;
-  }
-
-  /**
-   * Build test data structure from data refs
-   * Supports nested structure: "valid.login_password" -> { valid: { login_password: '' } }
-   */
-  private buildTestData(dataRefs: ExtractedDataRef[]): TestDataResult {
-    const result: TestDataResult = {};
-
-    for (const dataRef of dataRefs) {
-      const parts = dataRef.rawRef.split('.');
-
-      if (parts.length === 1) {
-        // Simple variable: "valid_login_email" -> { valid_login_email: '' }
-        result[parts[0]] = '';
-      } else {
-        // Nested variable: "valid.login_password" -> { valid: { login_password: '' } }
-        let current: TestDataResult = result;
-        for (let i = 0; i < parts.length - 1; i++) {
-          const part = parts[i];
-          if (!current[part] || typeof current[part] === 'string') {
-            current[part] = {};
-          }
-          current = current[part] as TestDataResult;
-        }
-        current[parts[parts.length - 1]] = '';
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Write selectors YAML file
-   */
-  private writeSelectorsYaml(scaffold: ScaffoldResult, outputPath: string, screenName: string): void {
-    const getDisplayValue = (e: ScaffoldElement) => e.name || e.value;
-
-    // Deduplicate display values for header comment
-    const displayValues = [...new Set(Object.values(scaffold).map(e => `[${getDisplayValue(e)}]`))];
-    const header = `# ${this.capitalizeFirst(screenName)} Screen Selectors (Auto-generated)
-# ⚠️  AUTO-GENERATED - Do not edit directly
-# To override values, edit ${screenName}.override.yaml
-# Manual edits to this file will be lost on regeneration
-#
-# Reference in features: ${displayValues.join(', ')}
-
-`;
-
-    const yamlContent = yaml.stringify(scaffold, {
-      indent: 2,
-      lineWidth: 100,
-      defaultKeyType: 'PLAIN',
-      defaultStringType: 'QUOTE_SINGLE',
-    });
-
-    fs.writeFileSync(outputPath, header + yamlContent, 'utf-8');
-  }
-
-  /**
-   * Smart-merge test-data objects:
-   * - Keys present in both: keep the existing value (user may have filled it in)
-   * - Keys only in fresh (new refs in features): add with empty value
-   * - Keys only in existing (removed from features): drop them
-   */
-  private mergeTestData(existing: TestDataResult, fresh: TestDataResult): TestDataResult {
-    const merged: TestDataResult = {};
-
-    for (const key of Object.keys(fresh)) {
-      if (key in existing) {
-        const existingVal = existing[key];
-        const freshVal = fresh[key];
-        if (typeof freshVal === 'object' && typeof existingVal === 'object') {
-          // Both are nested — recurse
-          merged[key] = this.mergeTestData(existingVal as TestDataResult, freshVal as TestDataResult);
-        } else {
-          // Keep the existing (user-supplied) value
-          merged[key] = existingVal;
-        }
-      } else {
-        // New key — add with the scaffold default (empty string or nested object)
-        merged[key] = fresh[key];
-      }
-      // Keys present in existing but absent from fresh are intentionally dropped (no longer referenced)
-    }
-
-    return merged;
-  }
-
-  /**
-   * Write test-data YAML file
-   */
-  private writeTestDataYaml(testData: TestDataResult, outputPath: string, screenName: string): void {
-    const header = `# ${this.capitalizeFirst(screenName)} Screen Test Data
-# Managed by: sungen map (smart-merge)
-# • New {{variable}} refs are added automatically (empty value)
-# • Removed refs are dropped on the next sungen map run
-# • Your existing values are never overwritten
-# To fix a value permanently, copy the key to ${screenName}.override.yaml
-#
-# Reference in features using {{variable}} syntax
-
-`;
-
-    const yamlContent = yaml.stringify(testData, {
-      indent: 2,
-      lineWidth: 100,
-      defaultKeyType: 'PLAIN',
-      defaultStringType: 'QUOTE_SINGLE',
-    });
-
-    fs.writeFileSync(outputPath, header + yamlContent, 'utf-8');
-  }
-}