@sun-asterisk/sungen 1.0.24 → 2.0.1

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

@@ -3,7 +3,6 @@ import path from 'path';
 import { ParsedFeature, ParsedScenario, ParsedStep } from '../gherkin-parser';
 import { StepMapper } from './step-mapper';
 import { TestGeneratorAdapter, adapterRegistry } from './adapters';
-import { AuthSetupGenerator } from './auth-setup-generator';
 
 /**
  * Extract auth role from tags
@@ -41,26 +40,6 @@ function getEffectiveAuthRole(
   return featureRole;
 }
 
-/**
- * Detect all auth roles across feature
- * Returns unique roles found in feature-level and scenario-level tags
- */
-function detectAuthRoles(feature: ParsedFeature): string[] {
-  const roles = new Set<string>();
-  
-  // Feature-level tags
-  const featureTags = feature.tags || [];
-  const featureRole = extractAuthRole(featureTags);
-  if (featureRole) roles.add(featureRole);
-  
-  // Scenario-level tags
-  for (const scenario of feature.scenarios) {
-    const effectiveRole = getEffectiveAuthRole(scenario.tags, featureTags);
-    if (effectiveRole) roles.add(effectiveRole);
-  }
-  
-  return Array.from(roles);
-}
 
 /**
  * Check if tags contain @manual
@@ -100,7 +79,6 @@ export class CodeGenerator {
   private stepMapper: StepMapper;
   private adapter: TestGeneratorAdapter;
   private screenName?: string;
-  private authSetupGenerator: AuthSetupGenerator;
   private options: any;
   // Steps registry built per feature during generateTestCode(); used by countSteps()
   private stepsRegistry = new Map<string, ParsedScenario>();
@@ -109,8 +87,6 @@ export class CodeGenerator {
     this.options = options;
     this.screenName = options.screenName;
     this.stepMapper = new StepMapper(options);
-    this.authSetupGenerator = new AuthSetupGenerator();
-    
     // Get adapter from registry (default: playwright)
     const frameworkName = options.framework || 'playwright';
     this.adapter = adapterRegistry.getAdapter(frameworkName);
@@ -214,6 +190,17 @@ export class CodeGenerator {
       featureName = this.featureNameToFileName(feature.name).replace('.spec.ts', '');
     }
     
+    // Derive screen name from source file path when not explicitly set
+    // qa/screens/{screenName}/features/{featureName}.feature -> screenName
+    if (!this.screenName && 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) {
+        this.stepMapper.setScreenContext(parts[screensIndex + 1]);
+      }
+    }
+
     // Set feature context for data resolution and navigation
     this.stepMapper.setFeatureContext(featureName, feature.path);
     
@@ -408,41 +395,6 @@ export class CodeGenerator {
       );
     }
 
-    // Collect all auth roles across all features
-    const allRoles = new Set<string>();
-    for (const feature of features) {
-      const roles = detectAuthRoles(feature);
-      roles.forEach(role => allRoles.add(role));
-    }
-
-    // Generate auth setup if any roles detected
-    if (allRoles.size > 0) {
-      const setupFile = path.join(outputDir, 'auth.setup.ts');
-      const setupExists = fs.existsSync(setupFile);
-      
-      const generated = await this.authSetupGenerator.generateIfNeeded({
-        roles: Array.from(allRoles),
-        outputDir,
-        verbose: this.options.verbose
-      });
-      
-      // If setup already exists, check for new roles
-      if (!generated && setupExists) {
-        const setupContent = fs.readFileSync(setupFile, 'utf-8');
-        const newRoles = Array.from(allRoles).filter(role => 
-          !setupContent.includes(`authenticate as ${role}`)
-        );
-        
-        if (newRoles.length > 0) {
-          console.warn(
-            `⚠ New auth role(s) detected: ${newRoles.join(', ')}\n` +
-            `  Update specs/auth.setup.ts manually to add setup for these roles\n` +
-            `  Or delete auth.setup.ts to regenerate from scratch`
-          );
-        }
-      }
-    }
-
     // Generate tests
     const results: GeneratedTest[] = [];
     const generationErrors: Array<{ feature: string; error: any }> = [];

package/src/generators/test-generator/patterns/assertion-patterns.ts

@@ -331,6 +331,8 @@ export const assertionPatterns: StepPattern[] = [
           value: selectorValue,
           dataValue,
           dataRef: step.dataRef,
+          nth: resolved.nth || 0,
+          exact: resolved.exact || false,
         });
         return {
           code,

package/src/generators/test-generator/patterns/index.ts

@@ -6,7 +6,10 @@ import { formPatterns } from './form-patterns';
 import { interactionPatterns } from './interaction-patterns';
 import { assertionPatterns } from './assertion-patterns';
 import { setupPatterns } from './setup-patterns';
-import { legacyPatterns } from './legacy-patterns';
+import { keyboardPatterns } from './keyboard-patterns';
+import { scrollPatterns } from './scroll-patterns';
+import { scopePatterns } from './scope-patterns';
+import { tablePatterns } from './table-patterns';
 
 /**
  * Pattern Registry - manages all step patterns
@@ -27,7 +30,10 @@ export class PatternRegistry {
     this.patterns.push(...formPatterns);
     this.patterns.push(...interactionPatterns);
     this.patterns.push(...assertionPatterns);
-    this.patterns.push(...legacyPatterns);
+    this.patterns.push(...keyboardPatterns);
+    this.patterns.push(...scrollPatterns);
+    this.patterns.push(...scopePatterns);
+    this.patterns.push(...tablePatterns);
 
     // Sort by priority (higher first)
     this.patterns.sort((a, b) => (b.priority || 0) - (a.priority || 0));
@@ -111,5 +117,8 @@ export { navigationPatterns } from './navigation-patterns';
 export { formPatterns } from './form-patterns';
 export { interactionPatterns } from './interaction-patterns';
 export { assertionPatterns } from './assertion-patterns';
-export { legacyPatterns } from './legacy-patterns';
+export { keyboardPatterns } from './keyboard-patterns';
+export { scrollPatterns } from './scroll-patterns';
+export { scopePatterns } from './scope-patterns';
+export { tablePatterns } from './table-patterns';
 export * from './types';

package/src/generators/test-generator/patterns/interaction-patterns.ts

@@ -68,7 +68,7 @@ export const interactionPatterns: StepPattern[] = [
         comment: `${actionMethod.charAt(0).toUpperCase() + actionMethod.slice(1)} ${step.selectorRef} with ${step.dataRef}`,
       };
     },
-    priority: 15,
+    priority: 14,  // Below click-element-with-text (15) so known selectors use proper locator
   },
   {
     name: 'click-element-with-text',

package/src/generators/test-generator/patterns/keyboard-patterns.ts

@@ -0,0 +1,51 @@
+/**
+ * Keyboard Patterns
+ * Handles: press Key key, press Key on [Target] type
+ */
+
+import { StepPattern } from './types';
+
+export const keyboardPatterns: StepPattern[] = [
+  {
+    name: 'press-key-global',
+    matcher: (step) => {
+      const text = step.text.toLowerCase();
+      return /\bpress(?:es)?\s+\w+\s+key\b/.test(text) && !text.includes(' on ');
+    },
+    resolver: (step, context) => {
+      // Extract key name: "User press Escape key" → "Escape"
+      const match = step.text.match(/press(?:es)?\s+(\w+)\s+key/i);
+      const key = match ? match[1] : 'Enter';
+
+      return {
+        templateName: 'keyboard-global-action',
+        data: { key },
+        comment: `Press ${key} key`,
+      };
+    },
+    priority: 12,
+  },
+  {
+    name: 'press-key-on-element',
+    matcher: (step) => {
+      const text = step.text.toLowerCase();
+      return /\bpress(?:es)?\s+\w+\s+on\b/.test(text) && !!step.selectorRef;
+    },
+    resolver: (step, context) => {
+      // Extract key: "User press Enter on [Search] field" → "Enter"
+      const match = step.text.match(/press(?:es)?\s+(\w+)\s+on/i);
+      const key = match ? match[1] : 'Enter';
+
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, step.elementType, step.nth
+      );
+
+      return {
+        templateName: 'press-action',
+        data: { ...resolved, key },
+        comment: `Press ${key} on ${step.selectorRef}`,
+      };
+    },
+    priority: 12,
+  },
+];

package/src/generators/test-generator/patterns/scope-patterns.ts

@@ -0,0 +1,40 @@
+/**
+ * Scope Patterns
+ * Handles: switch to [Target] frame, switch to [main] frame
+ */
+
+import { StepPattern } from './types';
+
+export const scopePatterns: StepPattern[] = [
+  {
+    name: 'switch-to-frame',
+    matcher: (step) => {
+      return /\bswitch(?:es)?\s+to\b/i.test(step.text) &&
+             (step.elementType === 'frame' || step.elementType === 'iframe');
+    },
+    resolver: (step, context) => {
+      const selectorRef = step.selectorRef || '';
+
+      // "switch to [main] frame" → reset to page context
+      if (selectorRef.toLowerCase() === 'main') {
+        return {
+          templateName: 'frame-exit-action',
+          data: {},
+          comment: 'Exit frame scope, return to main page',
+        };
+      }
+
+      // "switch to [Payment] frame" → enter frame scope
+      const resolved = context.selectorResolver.resolveSelector(
+        selectorRef, context.featureName, 'frame', step.nth
+      );
+
+      return {
+        templateName: 'frame-enter-action',
+        data: { ...resolved, frameName: selectorRef },
+        comment: `Switch to ${selectorRef} frame`,
+      };
+    },
+    priority: 11,
+  },
+];

package/src/generators/test-generator/patterns/scroll-patterns.ts

@@ -0,0 +1,27 @@
+/**
+ * Scroll Patterns
+ * Handles: scroll to [Target] type
+ */
+
+import { StepPattern } from './types';
+
+export const scrollPatterns: StepPattern[] = [
+  {
+    name: 'scroll-to-element',
+    matcher: (step) => {
+      return /\bscroll(?:s)?\s+to\b/i.test(step.text) && !!step.selectorRef;
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, step.elementType, step.nth
+      );
+
+      return {
+        templateName: 'scroll-action',
+        data: { ...resolved },
+        comment: `Scroll to ${step.selectorRef}`,
+      };
+    },
+    priority: 8,
+  },
+];

package/src/generators/test-generator/patterns/table-patterns.ts

@@ -0,0 +1,232 @@
+/**
+ * Table Patterns
+ * Handles: table row assertions, table cell lookups, actions in table rows
+ */
+
+import { StepPattern } from './types';
+
+export const tablePatterns: StepPattern[] = [
+  // "User see [Users] table has {{count}} rows" — must have "rows" AFTER {{data}}
+  {
+    name: 'table-row-count',
+    matcher: (step) => {
+      return /\btable\s+has\b/i.test(step.text) &&
+             /\}\}\s*rows?\b/i.test(step.text) &&
+             !!step.dataRef;
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'table', step.nth
+      );
+      const count = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+
+      return {
+        templateName: 'table-row-count',
+        data: { ...resolved, expectedCount: count },
+        comment: `Assert ${step.selectorRef} table has ${count} rows`,
+      };
+    },
+    priority: 16,
+  },
+
+  // "User see [Users] table has [Email] column"
+  {
+    name: 'table-column-exists',
+    matcher: (step) => {
+      return /\btable\s+has\b/i.test(step.text) &&
+             /\bcolumn\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      // Extract column name from second [bracket] reference
+      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
+      const columnName = brackets.length >= 2
+        ? brackets[1].replace(/[\[\]]/g, '')
+        : 'Unknown';
+
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'table', step.nth
+      );
+
+      return {
+        templateName: 'table-column-exists',
+        data: { ...resolved, columnName },
+        comment: `Assert ${step.selectorRef} table has ${columnName} column`,
+      };
+    },
+    priority: 16,
+  },
+
+  // "User see [Users] table is empty"
+  {
+    name: 'table-is-empty',
+    matcher: (step) => {
+      return /\btable\s+is\s+empty\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'table', step.nth
+      );
+
+      return {
+        templateName: 'table-empty',
+        data: { ...resolved },
+        comment: `Assert ${step.selectorRef} table is empty`,
+      };
+    },
+    priority: 16,
+  },
+
+  // "User see [Users] table row with {{name}} has [Status] with {{value}}"
+  {
+    name: 'table-cell-by-filter',
+    matcher: (step) => {
+      return /\btable\s+row\s+with\b/i.test(step.text) &&
+             /\bhas\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      // Extract: [Table] table row with {{filter}} has [Col] with {{value}}
+      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
+      const tableName = brackets[0]?.replace(/[\[\]]/g, '') || '';
+      const columnName = brackets.length >= 2
+        ? brackets[1].replace(/[\[\]]/g, '')
+        : '';
+
+      // Extract data refs: first is filter, second is cell value
+      const dataRefs = step.text.match(/\{\{([^}]+)\}\}/g) || [];
+      const filterRef = dataRefs[0]?.replace(/\{\{|\}\}/g, '') || '';
+      const valueRef = dataRefs.length >= 2
+        ? dataRefs[1].replace(/\{\{|\}\}/g, '')
+        : '';
+
+      const filterValue = filterRef
+        ? context.dataResolver.resolveData(filterRef, context.featureName)
+        : '';
+      const cellValue = valueRef
+        ? context.dataResolver.resolveData(valueRef, context.featureName)
+        : '';
+
+      const resolved = context.selectorResolver.resolveSelector(
+        tableName, context.featureName, 'table', step.nth
+      );
+
+      return {
+        templateName: 'table-cell-by-filter',
+        data: { ...resolved, filterValue, columnName, cellValue },
+        comment: `Assert ${tableName} table row with ${filterRef} has ${columnName} = ${valueRef}`,
+      };
+    },
+    priority: 17,
+  },
+
+  // "User see [Users] table row 1 [Name] cell with {{value}}"
+  {
+    name: 'table-cell-by-index',
+    matcher: (step) => {
+      return /\btable\s+row\s+\d+\b/i.test(step.text) &&
+             /\bcell\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
+      const tableName = brackets[0]?.replace(/[\[\]]/g, '') || '';
+      const columnName = brackets.length >= 2
+        ? brackets[1].replace(/[\[\]]/g, '')
+        : '';
+
+      const rowMatch = step.text.match(/\brow\s+(\d+)\b/i);
+      const rowIndex = rowMatch ? parseInt(rowMatch[1], 10) : 1;
+
+      const cellValue = step.dataRef
+        ? context.dataResolver.resolveData(step.dataRef, context.featureName)
+        : '';
+
+      const resolved = context.selectorResolver.resolveSelector(
+        tableName, context.featureName, 'table', step.nth
+      );
+
+      return {
+        templateName: 'table-cell-by-index',
+        data: { ...resolved, rowIndex, columnName, cellValue },
+        comment: `Assert ${tableName} table row ${rowIndex} ${columnName} cell = ${step.dataRef}`,
+      };
+    },
+    priority: 17,
+  },
+
+  // "User see [Users] table has row with {{name}}"
+  {
+    name: 'table-row-exists',
+    matcher: (step) => {
+      return /\btable\s+has\s+row\s+with\b/i.test(step.text) && !!step.dataRef;
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'table', step.nth
+      );
+      const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+
+      return {
+        templateName: 'table-row-exists',
+        data: { ...resolved, filterValue },
+        comment: `Assert ${step.selectorRef} table has row with ${step.dataRef}`,
+      };
+    },
+    priority: 18,
+  },
+
+  // "User see [Users] table has no row with {{name}}"
+  {
+    name: 'table-row-not-exists',
+    matcher: (step) => {
+      return /\btable\s+has\s+no\s+row\s+with\b/i.test(step.text) && !!step.dataRef;
+    },
+    resolver: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(
+        step.selectorRef!, context.featureName, 'table', step.nth
+      );
+      const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+
+      return {
+        templateName: 'table-row-not-exists',
+        data: { ...resolved, filterValue },
+        comment: `Assert ${step.selectorRef} table has no row with ${step.dataRef}`,
+      };
+    },
+    priority: 19,
+  },
+
+  // "User click [Edit] in [Users] table row with {{name}}"
+  {
+    name: 'table-action-in-row',
+    matcher: (step) => {
+      return /\bin\b.*\btable\s+row\s+with\b/i.test(step.text);
+    },
+    resolver: (step, context) => {
+      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
+      const elementName = brackets[0]?.replace(/[\[\]]/g, '') || '';
+      const tableName = brackets.length >= 2
+        ? brackets[1].replace(/[\[\]]/g, '')
+        : '';
+
+      const dataRefs = step.text.match(/\{\{([^}]+)\}\}/g) || [];
+      const filterRef = dataRefs[0]?.replace(/\{\{|\}\}/g, '') || '';
+      const filterValue = filterRef
+        ? context.dataResolver.resolveData(filterRef, context.featureName)
+        : '';
+
+      const tableResolved = context.selectorResolver.resolveSelector(
+        tableName, context.featureName, 'table', 0
+      );
+
+      // Determine action
+      const actionMatch = step.text.match(/\b(click|check|uncheck)\b/i);
+      const action = actionMatch ? actionMatch[1].toLowerCase() : 'click';
+
+      return {
+        templateName: 'table-action-in-row',
+        data: { ...tableResolved, elementName, filterValue, action },
+        comment: `${action} ${elementName} in ${tableName} table row with ${filterRef}`,
+      };
+    },
+    priority: 17,
+  },
+];

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`);
     }
   }
 
@@ -70,13 +57,23 @@ export class StepMapper {
     this.selectorResolver.setFeatureContext(featureName);
   }
 
+  /**
+   * Update screen context (used in --all mode to set per-feature screen name)
+   */
+  setScreenContext(screenName: string): void {
+    this.screenName = screenName;
+    this.selectorResolver.setScreenContext(screenName);
+    this.dataResolver.setScreenContext(screenName);
+  }
+
   /**
    * Set scenario context for path variable resolution
    */
   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 +84,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 +165,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) {