@sun-asterisk/sungen 1.0.14 → 1.0.15

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

@@ -1,6 +1,32 @@
 import { ParsedStep } from '../../gherkin-parser';
 import { StepPattern } from './types';
 
+/**
+ * Extract Playwright waitFor state from step text.
+ * Defaults to 'visible' if no known state keyword is found.
+ */
+function extractWaitState(text: string): string {
+  if (/\bhidden\b/.test(text)) return 'hidden';
+  if (/\bdetached\b/.test(text)) return 'detached';
+  if (/\bvisible\b/.test(text)) return 'visible';
+  return 'visible';
+}
+
+/**
+ * Map a plain element keyword (no brackets) to a Playwright ARIA role.
+ * e.g. "dialog" → "dialog", "modal" → "dialog", "alert" → "alertdialog"
+ */
+function elementKeywordToRole(text: string): string | null {
+  const match = text.match(/\bwait(?:s)?\s+for\s+(dialog|modal|alert|alertdialog|tooltip|menu|listbox|combobox|grid|table|status|banner|navigation|main|region)\b/i);
+  if (!match) return null;
+  const keyword = match[1].toLowerCase();
+  const roleMap: Record<string, string> = {
+    modal: 'dialog',
+    alert: 'alertdialog',
+  };
+  return roleMap[keyword] || keyword;
+}
+
 /**
  * Interaction patterns: click, hover, press, wait
  * Uses template engine for framework-agnostic code generation
@@ -27,7 +53,8 @@ export const interactionPatterns: StepPattern[] = [
         const resolved = context.selectorResolver.resolveSelector(
           step.selectorRef!,
           context.featureName,
-          step.elementType
+          step.elementType,
+          step.nth
         );
         selectorValue = resolved.value || '';
         nth = resolved.nth || 0;
@@ -81,7 +108,7 @@ export const interactionPatterns: StepPattern[] = [
       && step.text.includes('with'),
     generator: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, undefined, step.elementType
+        step.selectorRef!, undefined, step.elementType, step.nth
       );
 
       let dataValue: string;
@@ -115,7 +142,7 @@ export const interactionPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       (step.text.includes('clicks') || step.text.includes('click')) && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       
       const code = context.templateEngine.renderStep('click-action', { ...resolved, selectorRef: step.selectorRef });
       
@@ -131,7 +158,7 @@ export const interactionPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       step.text.includes('double') && step.text.includes('clicks') && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       
       const code = context.templateEngine.renderStep('double-click-action', { ...resolved, selectorRef: step.selectorRef });
       
@@ -147,7 +174,7 @@ export const interactionPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       step.text.includes('hovers') && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       
       const code = context.templateEngine.renderStep('hover-action', { ...resolved, selectorRef: step.selectorRef });
       
@@ -163,7 +190,7 @@ export const interactionPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       step.text.includes('presses') && step.text.includes('Enter') && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       
       const code = context.templateEngine.renderStep('press-action', {
         ...resolved,
@@ -226,6 +253,53 @@ export const interactionPatterns: StepPattern[] = [
     },
     priority: 7,
   },
+  // "wait for dialog with {{kudo.title}} hidden" - role keyword inline, no selector brackets, with data filter
+  {
+    name: 'wait-for-role-with-text',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('wait for') || step.text.includes('waits for')) &&
+      !step.selectorRef &&
+      !!step.dataRef &&
+      !!elementKeywordToRole(step.text),
+    generator: (step, context) => {
+      const role = elementKeywordToRole(step.text)!;
+
+      let dataValue: string;
+      try {
+        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch (error) {
+        dataValue = `\${${step.dataRef}}`;
+      }
+
+      const state = extractWaitState(step.text);
+
+      // Render inline — no locator partial needed, role is known directly
+      return {
+        code: `await page.getByRole('${role}').filter({ hasText: '${dataValue.replace(/'/g, "\\'")}' }).waitFor({ state: '${state}' });`,
+        comment: `Wait for ${role} with ${step.dataRef} to be ${state}`,
+      };
+    },
+    priority: 11,
+  },
+  // "wait for dialog hidden" - role keyword inline, no selector brackets, no data filter
+  {
+    name: 'wait-for-role',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('wait for') || step.text.includes('waits for')) &&
+      !step.selectorRef &&
+      !step.dataRef &&
+      !!elementKeywordToRole(step.text),
+    generator: (step, context) => {
+      const role = elementKeywordToRole(step.text)!;
+      const state = extractWaitState(step.text);
+
+      return {
+        code: `await page.getByRole('${role}').waitFor({ state: '${state}' });`,
+        comment: `Wait for ${role} to be ${state}`,
+      };
+    },
+    priority: 11,
+  },
   // NEW: Wait for page pattern
   {
     name: 'wait-for-page',
@@ -242,22 +316,55 @@ export const interactionPatterns: StepPattern[] = [
     },
     priority: 9,  // Higher than wait-for-element
   },
+  {
+    name: 'wait-for-element-with-text',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('wait for') || step.text.includes('waits for')) &&
+      !!step.selectorRef &&
+      !!step.dataRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+
+      let dataValue: string;
+      try {
+        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch (error) {
+        dataValue = `\${${step.dataRef}}`;
+      }
+
+      const state = extractWaitState(step.text);
+
+      const code = context.templateEngine.renderStep('wait-for-element-with-text', {
+        ...resolved,
+        selectorRef: step.selectorRef,
+        dataValue,
+        state,
+      });
+
+      return {
+        code,
+        comment: `Wait for ${step.selectorRef} with ${step.dataRef} to be ${state}`,
+      };
+    },
+    priority: 10,
+  },
   {
     name: 'wait-for-element',
     matcher: (step: ParsedStep) =>
       (step.text.includes('wait for') || step.text.includes('waits for')) && !!step.selectorRef,
     generator: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType);
-      
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
+      const state = extractWaitState(step.text);
+
       const code = context.templateEngine.renderStep('wait-for-element', {
         ...resolved,
         selectorRef: step.selectorRef,
-        state: 'visible',
+        state,
       });
-      
+
       return {
         code,
-        comment: `Wait for ${step.selectorRef}`,
+        comment: `Wait for ${step.selectorRef} to be ${state}`,
       };
     },
     priority: 8,

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

@@ -23,7 +23,8 @@ export const navigationPatterns: StepPattern[] = [
           const resolved = context.selectorResolver.resolveSelector(
             step.selectorRef,
             context.featureName,
-            step.elementType
+            step.elementType,
+            step.nth
           );
           // Use selector's value as the path for navigation
           path = resolved.value || path;

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

@@ -28,8 +28,9 @@ export class StepMapper {
   private baseURL: string;
   private featureName?: string;
   private screenName?: string;
-  private featurePath?: string;  // Path metadata from feature file (e.g., "/login")
-  private currentScenarioSteps?: ParsedStep[];  // All steps in current scenario for context
+  private featurePath?: string;
+  private currentScenarioSteps?: ParsedStep[];
+  private inDialogScope: boolean = false;
 
   constructor(options: { useAI?: boolean; verbose?: boolean; baseURL?: string; featureName?: string; screenName?: string; featurePath?: string } = {}) {
     this.useAI = options.useAI ?? false;
@@ -74,6 +75,9 @@ export class StepMapper {
    */
   setScenarioContext(steps: ParsedStep[]): void {
     this.currentScenarioSteps = steps;
+    // Reset dialog scope at the start of each new scenario
+    this.inDialogScope = false;
+    this.templateEngine.resetBaseContext();
   }
 
   /**
@@ -83,6 +87,18 @@ export class StepMapper {
   mapStep(step: ParsedStep): MappedStep | Promise<MappedStep> {
     this.stepCounter++;
 
+    // Dialog scope directives — intercept before pattern matching
+    if (/\buse dialog\b/i.test(step.text)) {
+      this.inDialogScope = true;
+      this.templateEngine.setBaseContext({ inDialog: true });
+      return { code: '', comment: 'Enter dialog scope' };
+    }
+    if (/\b(?:close|dismiss|exit)\s+dialog\b/i.test(step.text)) {
+      this.inDialogScope = false;
+      this.templateEngine.setBaseContext({ inDialog: false });
+      return { code: '', comment: 'Exit dialog scope' };
+    }
+
     // Try pattern registry first
     const context = this.createPatternContext();
     const mappedStep = this.patternRegistry.generateStep(step, context);

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

@@ -6,6 +6,7 @@ export class TemplateEngine {
   private templates: Map<string, HandlebarsTemplateDelegate> = new Map();
   private templatesDir: string;
   private stepsTemplatesDir: string;
+  private baseContext: Record<string, any> = {};
 
   constructor(templatesDir: string) {
     this.templatesDir = templatesDir;
@@ -83,6 +84,37 @@ export class TemplateEngine {
       const selectorName = selectorRef.split('.')[0].trim();
       return selectorName.length < 6 && !selectorName.includes(' ');
     });
+
+    // Switch/case helpers for cleaner strategy routing
+    Handlebars.registerHelper('switch', function(value: any, options: any) {
+      this.switchValue = value;
+      this.switchDefaulted = false;
+      return options.fn(this);
+    });
+
+    Handlebars.registerHelper('case', function(value: any, options: any) {
+      // Skip if already matched a case
+      if (this.switchMatched) {
+        return;
+      }
+      // Check if this case matches
+      if (value === this.switchValue) {
+        this.switchMatched = true;
+        return options.fn(this);
+      }
+    });
+
+    Handlebars.registerHelper('default', function(options: any) {
+      // Execute if no case matched
+      if (!this.switchMatched) {
+        return options.fn(this);
+      }
+    });
+
+    // Returns the Playwright root object — scoped to dialog when inDialog is true
+    Handlebars.registerHelper('pageRoot', function(this: any) {
+      return this.inDialog ? "page.getByRole('dialog')" : 'page';
+    });
   }
 
   private registerPartials(): void {
@@ -92,6 +124,33 @@ export class TemplateEngine {
       const locatorContent = fs.readFileSync(locatorPath, 'utf-8');
       Handlebars.registerPartial('locator', locatorContent);
     }
+
+    // Register locator-base partial (same as locator but without nth — for filter chaining)
+    const locatorBasePath = path.join(this.stepsTemplatesDir, 'partials', 'locator-base.hbs');
+    if (fs.existsSync(locatorBasePath)) {
+      const locatorBaseContent = fs.readFileSync(locatorBasePath, 'utf-8');
+      Handlebars.registerPartial('locator-base', locatorBaseContent);
+    }
+
+    // Register locator strategy partials
+    const strategiesDir = path.join(this.stepsTemplatesDir, 'partials', 'locator-strategies');
+    if (fs.existsSync(strategiesDir)) {
+      const strategies = ['testid', 'role', 'placeholder', 'label', 'text', 'locator', 'id', 'default'];
+      strategies.forEach(strategy => {
+        const strategyPath = path.join(strategiesDir, `${strategy}.hbs`);
+        if (fs.existsSync(strategyPath)) {
+          const strategyContent = fs.readFileSync(strategyPath, 'utf-8');
+          Handlebars.registerPartial(`locator-strategies/${strategy}`, strategyContent);
+        }
+      });
+    }
+
+    // Register locator modifier partials
+    const locatorNthPath = path.join(this.stepsTemplatesDir, 'partials', 'locator-nth.hbs');
+    if (fs.existsSync(locatorNthPath)) {
+      const locatorNthContent = fs.readFileSync(locatorNthPath, 'utf-8');
+      Handlebars.registerPartial('locator-nth', locatorNthContent);
+    }
   }
 
   private loadTemplate(templateName: string, isStepTemplate: boolean = false): HandlebarsTemplateDelegate {
@@ -140,7 +199,17 @@ export class TemplateEngine {
   }
 
   renderStep(stepTemplateName: string, data: any): string {
-    return this.render(stepTemplateName, data, true);
+    return this.render(stepTemplateName, { ...this.baseContext, ...data }, true);
+  }
+
+  /** Set base context merged into every renderStep call (e.g., { inDialog: true }) */
+  setBaseContext(ctx: Record<string, any>): void {
+    this.baseContext = { ...this.baseContext, ...ctx };
+  }
+
+  /** Reset base context (e.g., on new scenario) */
+  resetBaseContext(): void {
+    this.baseContext = {};
   }
 
   renderImports(): string {

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

@@ -270,13 +270,31 @@ export class SelectorResolver {
       .replace(/\s+/g, '.');            // Spaces to dots
   }
 
+  /**
+   * Extract the positional nth index from the text that follows an element reference.
+   * Shared by scaffold-generator (map) and gherkin-parser (generate) so both produce
+   * identical results from the same Gherkin step.
+   *
+   * Pass the text that comes AFTER the closing `]`, e.g.:
+   *   "[Email] field 3 with …"  →  afterElement = " field 3 with …"  →  returns 3
+   *   "[Submit] button 2"       →  afterElement = " button 2"         →  returns 2
+   *   "[Name]"                  →  afterElement = ""                  →  returns 0
+   *
+   * NOTE: textbox/textarea must precede "text" to prevent partial matching.
+   */
+  static extractNthFromStep(afterElement: string): number {
+    const nthRegex = /^\s*(?:field|button|textbox|textarea|text|link|input|element|item|logo|image|img|icon|raw|table|columnheader|list|listitem|row|checkbox|radio|dropdown|select|uploader)?\s*(\d+)\b/i;
+    const match = nthRegex.exec(afterElement);
+    return match ? parseInt(match[1], 10) : 0;
+  }
+
   /**
    * Resolve selector reference to Playwright locator code
    * Supports:
    * - Natural language: "Email Address", "Password" (with feature context)
    * - Legacy format: "login:email_field" or "login.email_field" (with screen prefix)
    */
-  resolveSelector(selectorRef: string, featureName?: string, elementType?: string): ResolvedSelector {
+  resolveSelector(selectorRef: string, featureName?: string, elementType?: string, nth?: number): ResolvedSelector {
     const contextName = featureName || this.featureName;
 
     // Check if it's legacy format (contains : or has dot with screen prefix)
@@ -303,7 +321,7 @@ export class SelectorResolver {
       );
     }
 
-    return this.resolveNaturalLanguage(selectorRef, contextName, elementType);
+    return this.resolveNaturalLanguage(selectorRef, contextName, elementType, nth);
   }
 
   /**
@@ -373,10 +391,19 @@ export class SelectorResolver {
   /**
    * Resolve natural language selector
    */
-  private resolveNaturalLanguage(label: string, featureName: string, elementType?: string): ResolvedSelector {
+  private resolveNaturalLanguage(label: string, featureName: string, elementType?: string, nth?: number): ResolvedSelector {
     const key = SelectorResolver.generateKey(label);
     const selectorFile = this.loadNewSelectorFile(featureName);
 
+    // Try nth-suffixed key first: hay.gui.loi.cam.on--3
+    if (nth && nth > 0) {
+      const nthKey = `${key}--${nth}`;
+      const nthEntry = selectorFile[nthKey];
+      if (nthEntry) {
+        return this.resolveFromEntry(nthEntry, label);
+      }
+    }
+
     // Try type-suffixed key first: add.campaign--button, add.campaign--text
     if (elementType) {
       const normalizedType = SelectorResolver.normalizeElementType(elementType);

package/src/input/cli-adapter.ts

@@ -36,7 +36,7 @@ export class CLIAdapter implements InputAdapter {
     program
       .name('sungen')
       .description('AI-Native E2E Test Generator - Generate Playwright tests from Gherkin features')
-      .version('1.0.14');
+      .version('1.0.15');
 
     // Global options
     program

package/src/orchestrator/project-initializer.ts

@@ -45,7 +45,8 @@ export class ProjectInitializer {
       'qa',
       'qa/screens',
       'specs',
-      'specs/generated'
+      'specs/generated',
+      'specs/storage',
     ];
 
     for (const dir of dirs) {