@sun-asterisk/sungen 1.0.24 → 2.0.0

package/src/generators/test-generator/step-mapper.ts

@@ -1,5 +1,4 @@
 import { ParsedStep } from '../gherkin-parser';
-import { AIStepMapper } from './ai-step-mapper';
 import { TemplateEngine } from './template-engine';
 import { PatternRegistry, PatternContext } from './patterns';
 import { SelectorResolver } from './utils/selector-resolver';
@@ -18,8 +17,6 @@ export interface MappedStep {
  */
 export class StepMapper {
   private stepCounter: number = 0;
-  private aiMapper: AIStepMapper | null = null;
-  private useAI: boolean = false;
   private verbose: boolean = false;
   private templateEngine: TemplateEngine;
   private patternRegistry: PatternRegistry;
@@ -31,9 +28,9 @@ export class StepMapper {
   private featurePath?: string;
   private currentScenarioSteps?: ParsedStep[];
   private inDialogScope: boolean = false;
+  private inFrameScope: boolean = false;
 
-  constructor(options: { useAI?: boolean; verbose?: boolean; baseURL?: string; featureName?: string; screenName?: string; featurePath?: string } = {}) {
-    this.useAI = options.useAI ?? false;
+  constructor(options: { verbose?: boolean; baseURL?: string; featureName?: string; screenName?: string; featurePath?: string } = {}) {
     this.verbose = options.verbose ?? false;
     this.baseURL = options.baseURL || null;  // null means path-only navigation
     this.featureName = options.featureName;
@@ -46,18 +43,8 @@ export class StepMapper {
     this.selectorResolver = new SelectorResolver(undefined, options.screenName);
     this.dataResolver = new DataResolver(undefined, options.screenName);
 
-    if (this.useAI) {
-      try {
-        this.aiMapper = new AIStepMapper(this.verbose);
-        if (this.verbose) {
-          console.log(`  [StepMapper] AI fallback enabled (${this.patternRegistry.getPatternCount()} patterns loaded)`);
-        }
-      } catch (error) {
-        console.warn('[StepMapper] AI mapper initialization failed:', error);
-        this.useAI = false;
-      }
-    } else if (this.verbose) {
-      console.log(`  [StepMapper] Dictionary mode (${this.patternRegistry.getPatternCount()} patterns loaded)`);
+    if (this.verbose) {
+      console.log(`  [StepMapper] ${this.patternRegistry.getPatternCount()} patterns loaded`);
     }
   }
 
@@ -75,8 +62,9 @@ export class StepMapper {
    */
   setScenarioContext(steps: ParsedStep[]): void {
     this.currentScenarioSteps = steps;
-    // Reset dialog scope at the start of each new scenario
+    // Reset dialog and frame scope at the start of each new scenario
     this.inDialogScope = false;
+    this.inFrameScope = false;
     this.templateEngine.resetBaseContext();
   }
 
@@ -87,6 +75,32 @@ export class StepMapper {
   mapStep(step: ParsedStep): MappedStep | Promise<MappedStep> {
     this.stepCounter++;
 
+    // Frame scope directives — intercept before pattern matching
+    if (/\bswitch(?:es)?\s+to\b/i.test(step.text) &&
+        (step.elementType === 'frame' || step.elementType === 'iframe')) {
+      const selectorRef = step.selectorRef || '';
+
+      if (selectorRef.toLowerCase() === 'main') {
+        // Exit frame scope
+        this.inFrameScope = false;
+        this.templateEngine.setBaseContext({ inFrame: false });
+        return { code: '// Back to main page context', comment: 'Exit frame scope' };
+      }
+
+      // Enter frame scope
+      this.inFrameScope = true;
+      let frameSelector = selectorRef;
+      try {
+        const resolved = this.selectorResolver.resolveSelector(selectorRef, this.featureName, 'frame', 0);
+        frameSelector = resolved.value || selectorRef;
+      } catch {
+        // Use selectorRef as-is
+      }
+      this.templateEngine.setBaseContext({ inFrame: true, frameSelector });
+      const code = `const frame = page.frameLocator('${frameSelector}');`;
+      return { code, comment: `Switch to ${selectorRef} frame` };
+    }
+
     // Dialog scope directives — intercept before pattern matching
     if (/\buse dialog\b/i.test(step.text)) {
       this.inDialogScope = true;
@@ -142,15 +156,7 @@ export class StepMapper {
       return mappedStep;
     }
 
-    // Fallback to AI if enabled
-    if (this.useAI && this.aiMapper) {
-      if (this.verbose) {
-        console.log(`  → AI fallback for: ${step.text.substring(0, 50)}...`);
-      }
-      return this.aiMapper.mapStep(step);
-    }
-
-    // No pattern matched and no AI - return generic code with comment
+    // No pattern matched - return TODO comment
     return {
       code: `// TODO: Implement step: ${step.text}`,
       comment: `Unrecognized step pattern: ${step.text}`,

package/src/generators/test-generator/template-engine.ts

@@ -112,8 +112,10 @@ export class TemplateEngine {
       }
     });
 
-    // Returns the Playwright root object — scoped to dialog when inDialog is true
+    // Returns the Playwright root object — scoped to dialog or frame when active
     Handlebars.registerHelper('pageRoot', function(this: any) {
+      // Frame scope takes precedence (frame > dialog > page)
+      if (this.inFrame) return 'frame';
       if (!this.inDialog) return 'page';
       const partial = Handlebars.partials['dialog-root'];
       if (partial) {

package/src/generators/test-generator/types.ts

@@ -1,38 +1,17 @@
 /**
- * Test Generator Interface
- * Defines contract for test framework code generators
+ * Test Generator Types
+ * Core type definitions for the test generation compiler
  */
 
-import { RuntimeConfig } from '../../config/config-schema';
-import { ParsedFeature } from '../../core/selector-base/gherkin-parser';
-import * as path from 'path';
-
 /**
- * Main Test Generator Interface
- */
-export interface TestGenerator {
-  readonly framework: string;
-
-  generate(
-    feature: ParsedFeature,
-    selectors: Record<string, any>,
-    testData: Record<string, any>,
-    config: RuntimeConfig
-  ): Promise<GeneratedTest>;
-
-  getFileExtension(): string;
-
-  validate(): boolean;
-}
-
-/**
- * Generated Test Result (executor-level)
+ * Generated Test Result
  */
 export interface GeneratedTest {
-  feature: string;
-  outputPath: string;
+  featureName: string;
+  filePath: string;
   code: string;
-  stats: GenerationStats;
+  sourceFile?: string;
+  stepCount?: number;
 }
 
 /**
@@ -42,90 +21,6 @@ export interface GenerationStats {
   totalScenarios: number;
   totalSteps: number;
   dictionaryMatched: number;
-  aiGenerated: number;
   todoCount: number;
   generationTime: number;
 }
-
-/**
- * Test Generator Factory
- */
-export class TestGeneratorFactory {
-  static create(framework: string, config: RuntimeConfig): TestGenerator {
-    switch (framework) {
-      case 'playwright': {
-        const { CodeGenerator } = require('./code-generator');
-
-        return {
-          framework: 'playwright',
-
-          async generate(
-            feature: ParsedFeature,
-            selectors: Record<string, any>,
-            testData: Record<string, any>,
-            cfg: RuntimeConfig
-          ): Promise<GeneratedTest> {
-            const startTime = Date.now();
-
-            let screenName: string | undefined;
-            if (feature.sourceFile) {
-              const sourceDir = path.dirname(feature.sourceFile);
-              const parts = sourceDir.split(path.sep);
-              const screensIndex = parts.indexOf('screens');
-              if (screensIndex >= 0 && screensIndex < parts.length - 2) {
-                screenName = parts[screensIndex + 1];
-              }
-            }
-
-            const generator = new CodeGenerator({
-              useAI: cfg.testGenerator.enableAIFallback,
-              verbose: cfg.verbose,
-              screenName,
-            });
-
-            const outputDir = cfg.paths.specsDir;
-            const result = await generator.generateTest(feature, outputDir);
-            generator.writeTest(result);
-
-            const countSteps = (f: ParsedFeature) =>
-              f.scenarios.reduce((sum: number, s: any) => sum + (s.steps ? s.steps.length : 0), 0);
-            const countTodos = (code: string) => (code.match(/\/\/ TODO/g) || []).length;
-
-            const stats: GenerationStats = {
-              totalScenarios: feature.scenarios.length,
-              totalSteps: countSteps(feature),
-              dictionaryMatched: 0,
-              aiGenerated: 0,
-              todoCount: countTodos(result.code),
-              generationTime: Date.now() - startTime,
-            };
-
-            return {
-              feature: feature.name,
-              outputPath: result.filePath,
-              code: result.code,
-              stats,
-            };
-          },
-
-          getFileExtension() {
-            return '.spec.ts';
-          },
-
-          validate() {
-            return true;
-          },
-        };
-      }
-
-      case 'appium':
-        throw new Error('Appium generator not yet implemented');
-
-      case 'integration':
-        throw new Error('Integration test generator not yet implemented');
-
-      default:
-        throw new Error(`Unsupported test framework: ${framework}`);
-    }
-  }
-}

package/src/generators/test-generator/utils/selector-resolver.ts

@@ -190,15 +190,33 @@ function convertJapaneseToRomaji(text: string): string {
 
 import { SelectorType } from '../../../utils/selector-types';
 
-// New structured selector format
+// Structured selector format v2
 interface SelectorEntry {
-  locator?: string;  // CSS locator (optional, empty string means use type/value)
-  type?: SelectorType;  // Locator strategy
-  value?: string;     // Natural language value for the locator (e.g., 'button', 'link' for role)
-  name?: string;      // Accessible name for role-based selectors (e.g., 'Login', 'Submit')
-  nth?: number;       // Element index (0 = no index, 1+ = append .nth())
-  exact?: boolean;    // Whether to use exact matching (default: false)
-  inputMethod?: string; // 'pressSequentially' for contenteditable/rich-text elements
+  locator?: string;       // CSS locator (optional, empty string means use type/value)
+  type?: SelectorType;    // Locator strategy
+  value?: string;         // Natural language value for the locator (e.g., 'button', 'link' for role)
+  name?: string;          // Accessible name for role-based selectors (e.g., 'Login', 'Submit')
+  nth?: number;           // Element index (0 = no index, 1+ = append .nth())
+  exact?: boolean;        // Whether to use exact matching (default: false)
+  inputMethod?: string;   // 'pressSequentially' for contenteditable/rich-text elements
+
+  // === v2: Disambiguation ===
+  scope?: string;         // Parent landmark aria-label to scope within (e.g., 'desktop navigation')
+  match?: 'exact' | 'partial';  // For getByText matching (default: partial)
+
+  // === v2: Complex Elements ===
+  variant?: 'native' | 'custom' | 'dragdrop';  // Dropdown/upload subtype
+  trigger?: string;       // Visible button that triggers hidden file input
+  frame?: string;         // iframe selector for cross-frame elements
+  contenteditable?: boolean;  // Rich text editor (contenteditable div)
+
+  // === v2: Table ===
+  columns?: Record<string, { index: number; header: string; elements?: Record<string, SelectorEntry> }>;
+  pagination?: Record<string, string>;
+
+  // === v2: Assertion Helpers ===
+  attribute?: string;     // Attribute to check (for "has" assertions)
+  pattern?: string;       // Regex for attribute value
 }
 
 // New selector file structure: flat key-value pairs
@@ -220,12 +238,24 @@ interface LegacySelectorFile {
 export interface ResolvedSelector {
   strategy: 'testid' | 'id' | 'placeholder' | 'label' | 'text' | 'css' | 'role' | 'locator';
   value: string;
-  role?: string;      // For role-based selectors (e.g., 'button', 'link')
-  name?: string;      // For accessible name in role selectors
-  locator?: string;  // CSS locator for fallback
-  nth?: number;       // Index for .nth() if multiple matches exist
-  exact?: boolean;    // Whether to use exact matching (default: false)
+  role?: string;        // For role-based selectors (e.g., 'button', 'link')
+  name?: string;        // For accessible name in role selectors
+  locator?: string;     // CSS locator for fallback
+  nth?: number;         // Index for .nth() if multiple matches exist
+  exact?: boolean;      // Whether to use exact matching (default: false)
   inputMethod?: string; // 'pressSequentially' for contenteditable/rich-text elements
+
+  // === v2 fields ===
+  scope?: string;       // Parent landmark to scope within
+  match?: 'exact' | 'partial';  // For getByText exact matching
+  variant?: 'native' | 'custom' | 'dragdrop';  // Dropdown/upload type
+  trigger?: string;     // Button that triggers hidden file input
+  frame?: string;       // iframe selector
+  contenteditable?: boolean;  // Rich text editor
+  columns?: Record<string, { index: number; header: string; elements?: Record<string, any> }>;
+  pagination?: Record<string, string>;
+  attribute?: string;   // Attribute to check
+  pattern?: string;     // Regex for attribute value
 }
 
 /**
@@ -520,17 +550,32 @@ export class SelectorResolver {
     // Check if name exists in entry (even if empty string), use it; otherwise use originalLabel
     const name = entry.name !== undefined && entry.name !== null ? entry.name : originalLabel;
     const nth = entry.nth || 0;
-    const exact = entry.exact === true;
+    const exact = entry.exact === true || entry.match === 'exact';
     const inputMethod = entry.inputMethod;
 
-    // Helper to attach inputMethod only when present
-    const withInputMethod = (resolved: ResolvedSelector): ResolvedSelector =>
-      inputMethod ? { ...resolved, inputMethod } : resolved;
+    // v2 fields
+    const v2Fields: Partial<ResolvedSelector> = {};
+    if (entry.scope) v2Fields.scope = entry.scope;
+    if (entry.match) v2Fields.match = entry.match;
+    if (entry.variant) v2Fields.variant = entry.variant;
+    if (entry.trigger) v2Fields.trigger = entry.trigger;
+    if (entry.frame) v2Fields.frame = entry.frame;
+    if (entry.contenteditable) v2Fields.contenteditable = true;
+    if (entry.columns) v2Fields.columns = entry.columns;
+    if (entry.pagination) v2Fields.pagination = entry.pagination;
+    if (entry.attribute) v2Fields.attribute = entry.attribute;
+    if (entry.pattern) v2Fields.pattern = entry.pattern;
+
+    // Helper to attach v2 fields and inputMethod
+    const withExtras = (resolved: ResolvedSelector): ResolvedSelector => {
+      if (inputMethod) resolved.inputMethod = inputMethod;
+      return { ...resolved, ...v2Fields };
+    };
 
     // If type is 'locator', use locator field (or value as fallback) as the CSS locator directly
     if (type === 'locator') {
       const locatorValue = locator && locator.trim() ? locator : value;
-      return withInputMethod({
+      return withExtras({
         strategy: 'locator',
         value: locatorValue,
         locator: locatorValue,
@@ -540,7 +585,7 @@ export class SelectorResolver {
 
     // If custom locator is provided and type is not 'locator', use it as CSS selector
     if (locator && locator.trim()) {
-      return withInputMethod({
+      return withExtras({
         strategy: 'css',
         value: locator,
         locator: locator,
@@ -551,7 +596,7 @@ export class SelectorResolver {
     // Use type-based strategy
     switch (type) {
       case 'placeholder':
-        return withInputMethod({
+        return withExtras({
           strategy: 'placeholder',
           value,
           nth,
@@ -559,7 +604,7 @@ export class SelectorResolver {
         });
 
       case 'role':
-        return withInputMethod({
+        return withExtras({
           strategy: 'role',
           role: value,
           name: name,  // Use the name field for accessible name
@@ -569,14 +614,14 @@ export class SelectorResolver {
         });
 
       case 'testid':
-        return withInputMethod({
+        return withExtras({
           strategy: 'testid',
           value,
           nth,
         });
 
       case 'label':
-        return withInputMethod({
+        return withExtras({
           strategy: 'label',
           value,
           nth,
@@ -584,7 +629,7 @@ export class SelectorResolver {
         });
 
       case 'text':
-        return withInputMethod({
+        return withExtras({
           strategy: 'text',
           value,
           nth,
@@ -593,7 +638,7 @@ export class SelectorResolver {
 
       default:
         // Fallback to placeholder
-        return withInputMethod({
+        return withExtras({
           strategy: 'placeholder',
           value,
           nth,