@sun-asterisk/sungen 1.0.24 → 2.0.1

package/src/core/live-scanner/role-fallback.ts

@@ -1,44 +0,0 @@
-/**
- * Role Fallback Groups
- * Maps Gherkin element type hints to ordered lists of ARIA roles to try.
- */
-
-const ROLE_FALLBACK_GROUPS: Record<string, string[]> = {
-  button:   ['button', 'link', 'menuitem', 'tab'],
-  link:     ['link', 'button', 'menuitem'],
-  field:    ['textbox', 'combobox', 'searchbox', 'spinbutton'],
-  dropdown: ['combobox', 'listbox', 'select', 'button'],
-  checkbox: ['checkbox', 'switch'],
-  text:     ['heading', 'paragraph'],
-  menuitem: ['menuitem', 'option', 'link'],
-  dialog:   ['dialog', 'alertdialog'],
-  modal:    ['dialog', 'alertdialog'],
-  tab:      ['tab', 'button', 'link'],
-  option:   ['option', 'menuitem', 'listitem'],
-  row:      ['row', 'listitem', 'option'],
-  tag:      ['button', 'link', 'option'],
-  uploader: ['textbox', 'button'],
-  textarea: ['textbox'],
-  radio:    ['radio'],
-  select:   ['combobox', 'listbox', 'select'],
-  page:     [],
-};
-
-/**
- * Get the ordered list of ARIA roles to try for a given Gherkin element type.
- * Returns empty array if the type is unknown (will fall through to text matching).
- */
-export function getRoleFallbacks(gherkinType: string): string[] {
-  const normalized = gherkinType.toLowerCase().trim();
-  return ROLE_FALLBACK_GROUPS[normalized] || [];
-}
-
-/**
- * Check if a Gherkin type should use getByText as its primary strategy
- * (types that don't map well to ARIA roles).
- */
-export function isTextOnlyType(gherkinType: string): boolean {
-  const normalized = gherkinType.toLowerCase().trim();
-  return normalized === 'text' || normalized === 'message' || normalized === 'error'
-    || normalized === 'warning' || normalized === 'success' || normalized === 'alert';
-}

package/src/core/live-scanner/scanner.ts

@@ -1,321 +0,0 @@
-/**
- * Live Scanner
- * Main orchestrator: parses features, sets up auth, replays steps, collects elements.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { glob } from 'glob';
-import * as yaml from 'yaml';
-import { LiveScanResult, LiveScanScenario, LiveScanOptions } from './types';
-import { replaySteps } from './step-replayer';
-import { writeMatrix } from './matrix-writer';
-import { readMatrix, mergeMatrixElements } from './matrix-reader';
-import { readBaseUrlFromPlaywrightConfig } from './config-reader';
-import { readYamlIfExists } from '../../utils/yaml-io';
-
-export class LiveScanner {
-  private options: LiveScanOptions;
-
-  constructor(options: LiveScanOptions) {
-    this.options = options;
-  }
-
-  async scan(): Promise<LiveScanResult[]> {
-    const { screenName, screensDir } = this.options;
-    const screenDir = path.join(screensDir, screenName);
-    const featuresDir = path.join(screenDir, 'features');
-    const selectorsDir = path.join(screenDir, 'selectors');
-
-    if (!fs.existsSync(featuresDir)) {
-      throw new Error(`Features directory not found: ${featuresDir}`);
-    }
-
-    // Resolve baseUrl: explicit option > playwright.config.ts
-    const baseUrl = this.resolveBaseUrl();
-    console.log(`🌐 Base URL: ${baseUrl}`);
-
-    fs.mkdirSync(selectorsDir, { recursive: true });
-
-    const featureFiles = glob.sync('**/*.feature', {
-      cwd: featuresDir,
-      absolute: true,
-    });
-
-    if (featureFiles.length === 0) {
-      throw new Error(`No .feature files found in ${featuresDir}`);
-    }
-
-    // Lazy-load playwright to avoid errors when not installed
-    let playwright: any;
-    try {
-      playwright = require('playwright');
-    } catch {
-      throw new Error(
-        'Playwright is required for live-scan. Install it with: npm install playwright'
-      );
-    }
-
-    const browser = await playwright.chromium.launch({
-      headless: !this.options.headed,
-    });
-
-    const results: LiveScanResult[] = [];
-
-    try {
-      // Parse all features first
-      const { GherkinParser } = require('../../generators/gherkin-parser');
-      const parser = new GherkinParser();
-
-      for (const featureFile of featureFiles) {
-        const featureName = path.basename(featureFile, '.feature');
-        console.log(`\n📄 Scanning feature: ${featureName}`);
-
-        // Load existing matrix for incremental scan (non-force mode)
-        let existingResult: LiveScanResult | null = null;
-        if (!this.options.force) {
-          const matrixPath = path.join(selectorsDir, `${featureName}.live-scan.yaml`);
-          existingResult = readMatrix(matrixPath);
-          if (existingResult) {
-            console.log(`   📦 Found existing scan — resolved elements will be skipped`);
-          }
-        }
-
-        try {
-          const parsed = parser.parseFeatureFile(featureFile);
-          const result = await this.scanFeature(browser, playwright, parsed, baseUrl, existingResult, featureName);
-          if (!result) {
-            console.log(`   ⏭️  Feature skipped (missing test-data)`);
-            continue;
-          }
-          results.push(result);
-
-          // Write matrix file
-          const matrixPath = path.join(selectorsDir, `${featureName}.live-scan.yaml`);
-          writeMatrix(result, matrixPath);
-          console.log(`   ✅ Matrix written: ${matrixPath}`);
-        } catch (error: any) {
-          console.error(`   ❌ Failed to scan ${featureName}: ${error.message}`);
-        }
-      }
-    } finally {
-      await browser.close();
-    }
-
-    return results;
-  }
-
-  /**
-   * Load test-data YAML for a feature, merging override over base.
-   * Returns null if no test-data file exists.
-   */
-  private loadTestData(featureName: string): Record<string, any> | null {
-    const testDataDir = path.join(this.options.screensDir, this.options.screenName, 'test-data');
-    const basePath = path.join(testDataDir, `${featureName}.yaml`);
-    const overridePath = path.join(testDataDir, `${featureName}.override.yaml`);
-
-    const base = readYamlIfExists<Record<string, any>>(basePath);
-    const override = readYamlIfExists<Record<string, any>>(overridePath);
-
-    if (!base && !override) return null;
-
-    return { ...(base || {}), ...(override || {}) };
-  }
-
-  /**
-   * Find dataRef keys from steps that resolve to empty string in testData.
-   */
-  private findEmptyDataKeys(testData: Record<string, any>, steps: any[]): string[] {
-    const emptyKeys: string[] = [];
-    for (const step of steps) {
-      if (!step.dataRef) continue;
-      const parts = step.dataRef.replace(/[{}]/g, '').split('.');
-      let value: any = testData;
-      for (const part of parts) {
-        value = value?.[part];
-      }
-      if (value === undefined || value === null || value === '') {
-        emptyKeys.push(step.dataRef);
-      }
-    }
-    return [...new Set(emptyKeys)];
-  }
-
-  private resolveBaseUrl(): string {
-    // 1. Explicit option (from --url flag)
-    if (this.options.baseUrl) {
-      return this.options.baseUrl;
-    }
-
-    // 2. Auto-detect from playwright.config.ts
-    const detected = readBaseUrlFromPlaywrightConfig(process.cwd());
-    if (detected) {
-      console.log(`📋 Auto-detected baseURL from playwright.config.ts`);
-      return detected;
-    }
-
-    throw new Error(
-      'Base URL not found. Either:\n' +
-      '  • Add baseURL to your playwright.config.ts\n' +
-      '  • Use --url <baseUrl> flag'
-    );
-  }
-
-  private async scanFeature(
-    browser: any,
-    playwright: any,
-    feature: any,
-    baseUrl: string,
-    existingResult?: LiveScanResult | null,
-    featureFileName?: string
-  ): Promise<LiveScanResult | null> {
-    const featurePath = feature.path || '/';
-    const scenarios: Record<string, LiveScanScenario> = {};
-
-    // Build merged existing elements map for skip logic
-    const existingElements = existingResult ? mergeMatrixElements(existingResult) : undefined;
-
-    // Build a map of @steps scenarios for resolution
-    const stepsMap = new Map<string, any>();
-    for (const scenario of feature.scenarios) {
-      if (scenario.stepsName) {
-        stepsMap.set(scenario.stepsName, scenario);
-      }
-    }
-
-    // Collect all steps across scenarios to check for dataRefs
-    const allSteps = feature.scenarios.flatMap((s: any) => s.steps || []);
-    const hasDataRefs = allSteps.some((s: any) => s.dataRef);
-
-    // Load test-data if needed
-    let testData: Record<string, any> | null = null;
-    if (hasDataRefs) {
-      const testDataName = featureFileName || path.basename(feature.sourceFile || '', '.feature');
-      testData = this.loadTestData(testDataName);
-      if (!testData) {
-        const screenName = this.options.screenName;
-        console.warn(`   ⚠️  Feature has {{dataRef}} steps but no test-data file found — skipping feature`);
-        console.warn(`   💡 To fix:`);
-        console.warn(`      1. Run: sungen map --screen ${screenName} --skip-live-scan`);
-        console.warn(`      2. Fill test-data values in qa/screens/${screenName}/test-data/`);
-        console.warn(`      3. Re-run: sungen live-scan --screen ${screenName}`);
-        return null;
-      }
-      const emptyKeys = this.findEmptyDataKeys(testData, allSteps);
-      if (emptyKeys.length > 0) {
-        console.warn(`   ⚠️  Empty test-data values for: ${emptyKeys.join(', ')}`);
-        console.warn(`   💡 Fill these in qa/screens/${this.options.screenName}/test-data/ for accurate results`);
-      }
-    }
-
-    for (const scenario of feature.scenarios) {
-      // Skip @steps-only scenarios (they're reusable blocks, not standalone)
-      if (scenario.stepsName && !scenario.extendsName) {
-        console.log(`   ⏭️  Skipping @steps block: ${scenario.name}`);
-        continue;
-      }
-
-      const scenarioKey = slugify(scenario.name);
-      console.log(`   🎬 Scenario: ${scenario.name}`);
-
-      // Extract auth tag
-      const authTag = scenario.tags.find((t: string) => t.startsWith('@auth:'));
-      const authRole = authTag ? authTag.replace('@auth:', '') : null;
-
-      // Resolve @extend: inline base steps
-      let steps = [...scenario.steps];
-      if (scenario.extendsName) {
-        const baseScenario = stepsMap.get(scenario.extendsName);
-        if (baseScenario) {
-          steps = [...baseScenario.steps, ...steps];
-          console.log(`   🔗 Extended with @steps:${scenario.extendsName} (${baseScenario.steps.length} steps)`);
-        } else {
-          console.warn(`   ⚠️  @extend:${scenario.extendsName} not found`);
-        }
-      }
-
-      // Set up browser context with auth
-      const contextOptions: any = {};
-      if (authRole) {
-        const authPath = path.join(this.options.authDir || 'specs/.auth', `${authRole}.json`);
-        if (fs.existsSync(authPath)) {
-          contextOptions.storageState = authPath;
-          console.log(`   🔐 Auth: ${authRole}`);
-        } else {
-          console.warn(`   ⚠️  Auth file not found for role '${authRole}', scanning without authentication`);
-        }
-      }
-
-      const context = await browser.newContext(contextOptions);
-      const page = await context.newPage();
-
-      try {
-        const result = await replaySteps(page, steps, featurePath, baseUrl, existingElements, testData);
-
-        scenarios[scenarioKey] = {
-          auth: authRole,
-          extends: scenario.extendsName || null,
-          path: featurePath,
-          elements: result.elements,
-        };
-
-        // Print element summary
-        const elementCount = Object.keys(result.elements).length;
-        const skipped = Object.values(result.elements).filter(
-          (e: any) => e.skipped
-        ).length;
-        const resolved = Object.values(result.elements).filter(
-          (e: any) => e.matchMethod !== 'unresolved'
-        ).length;
-        const warnings = Object.values(result.elements).filter(
-          (e: any) => e.warning
-        ).length;
-
-        const skippedInfo = skipped > 0 ? `, ${skipped} cached` : '';
-        console.log(`   📊 Elements: ${resolved}/${elementCount} resolved${skippedInfo}${warnings > 0 ? `, ${warnings} warnings` : ''}`);
-
-        for (const error of result.errors) {
-          console.log(`   ⚠️  ${error}`);
-        }
-
-        // Print per-element status
-        for (const [key, el] of Object.entries(result.elements) as any) {
-          if (el.skipped) {
-            // Already printed in replaySteps
-            continue;
-          }
-          // Use dataValue (from data-value fallback) for display when name is empty
-          const displayName = el.name || el.dataValue || el.gherkinRef;
-          if (el.matchMethod === 'unresolved') {
-            console.log(`      ✗ [${el.gherkinRef}] ${el.gherkinType} → NOT FOUND`);
-          } else if (el.warning) {
-            console.log(`      ⚠ [${el.gherkinRef}] ${el.gherkinType} → ${el.selectorType}(${el.selectorValue || displayName}) (${el.warning})`);
-          } else {
-            console.log(`      ✓ [${el.gherkinRef}] → getBy${capitalize(el.selectorType || 'text')}${el.role ? `('${el.role}', {name: '${displayName}'})` : `('${el.selectorValue || displayName}')`}`);
-          }
-        }
-      } finally {
-        await context.close();
-      }
-    }
-
-    return {
-      screen: this.options.screenName,
-      baseUrl,
-      scannedAt: new Date().toISOString(),
-      scenarios,
-    };
-  }
-}
-
-function slugify(text: string): string {
-  return text
-    .toLowerCase()
-    .replace(/[^\w\s-]/g, '')
-    .trim()
-    .replace(/\s+/g, '-');
-}
-
-function capitalize(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}