@sun-asterisk/sungen 1.0.0

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

@@ -0,0 +1,94 @@
+import { ParsedStep } from '../../gherkin-parser';
+import { StepPattern } from './types';
+
+/**
+ * Setup and precondition patterns: application setup, authentication state, etc.
+ * Uses templates for framework-agnostic code generation
+ */
+export const setupPatterns: StepPattern[] = [
+  {
+    name: 'application-running',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('application is running') ||
+      step.text.includes('application running') ||
+      step.text.includes('app is running'),
+    generator: (step, context) => {
+      const code = context.templateEngine.renderStep('application-running', {});
+      
+      return {
+        code,
+        comment: `Setup: Application is running`,
+      };
+    },
+    priority: 5,
+  },
+  {
+    name: 'user-not-logged-in',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('user is not logged in') ||
+      step.text.includes('not logged in') ||
+      step.text.includes('logged out'),
+    generator: (step, context) => {
+      const code = context.templateEngine.renderStep('clear-auth', {});
+      
+      return {
+        code,
+        comment: `Clear authentication state (ensure user is logged out)`,
+      };
+    },
+    priority: 9,
+  },
+  {
+    name: 'user-logged-in',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('user is logged in') ||
+       step.text.includes('logged in as')) &&
+      !step.text.includes('not logged in'),
+    generator: (step, context) => {
+      // Check if there's a data reference for user credentials
+      const userRef = step.dataRef || 'valid_user';
+      
+      const code = context.templateEngine.renderStep('user-login-todo', {
+        userRef,
+      });
+      
+      return {
+        code,
+        comment: `Setup: User logged in as ${userRef}`,
+      };
+    },
+    priority: 9,
+  },
+  {
+    name: 'clear-database',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('database is empty') ||
+      step.text.includes('database is cleared') ||
+      step.text.includes('clear database'),
+    generator: (step, context) => {
+      const code = context.templateEngine.renderStep('clear-database', {});
+      
+      return {
+        code,
+        comment: `Setup: Clear/reset database`,
+      };
+    },
+    priority: 7,
+  },
+  {
+    name: 'browser-state-clean',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('clean browser state') ||
+      step.text.includes('fresh browser') ||
+      step.text.includes('new browser session'),
+    generator: (step, context) => {
+      const code = context.templateEngine.renderStep('clear-browser-state', {});
+      
+      return {
+        code,
+        comment: `Clear browser state (cookies, storage)`,
+      };
+    },
+    priority: 8,
+  },
+];

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

@@ -0,0 +1,41 @@
+import { ParsedStep } from '../../gherkin-parser';
+import { MappedStep } from '../step-mapper';
+import { SelectorResolver } from '../utils/selector-resolver';
+import { DataResolver } from '../utils/data-resolver';
+
+/**
+ * Pattern matcher function or regex
+ */
+export type PatternMatcher = RegExp | ((step: ParsedStep) => boolean);
+
+/**
+ * Pattern generator function
+ */
+export type PatternGenerator = (step: ParsedStep, context: PatternContext) => MappedStep;
+
+/**
+ * Context passed to pattern generators
+ */
+export interface PatternContext {
+  stepCounter: number;
+  extractScreenId: (selectorRef: string) => string;
+  templateEngine: any;
+  selectorResolver: SelectorResolver;
+  dataResolver: DataResolver;
+  renderLocator: (resolved: any) => string;
+  baseURL?: string;  // Base URL from config (e.g., 'http://localhost:3000')
+  featureName?: string;  // Feature name for data resolution (e.g., 'login')
+  screenName?: string;  // Screen name for path inference (e.g., 'sign-in')
+  featurePath?: string;  // Path metadata from feature file (e.g., '/login')
+  scenarioSteps?: ParsedStep[];  // All steps in scenario for path variable extraction
+}
+
+/**
+ * Step pattern definition
+ */
+export interface StepPattern {
+  name: string;
+  matcher: PatternMatcher;
+  generator: PatternGenerator;
+  priority?: number; // Higher priority = checked first (default: 0)
+}

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

@@ -0,0 +1,254 @@
+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';
+import { DataResolver } from './utils/data-resolver';
+import * as path from 'path';
+
+export interface MappedStep {
+  code: string; // Generated Playwright code
+  comment?: string; // Optional comment
+  imports?: string[]; // Required imports
+}
+
+/**
+ * StepMapper - Orchestrates step-to-code conversion using pattern registry
+ * Refactored from 907 lines to < 200 lines
+ */
+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;
+  private selectorResolver: SelectorResolver;
+  private dataResolver: DataResolver;
+  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
+
+  constructor(options: { useAI?: boolean; verbose?: boolean; baseURL?: string; featureName?: string; screenName?: string; featurePath?: string } = {}) {
+    this.useAI = options.useAI ?? false;
+    this.verbose = options.verbose ?? false;
+    this.baseURL = options.baseURL || null;  // null means path-only navigation
+    this.featureName = options.featureName;
+    this.screenName = options.screenName;
+    this.featurePath = options.featurePath;
+    // Use Playwright templates as default for pattern-based generation
+    const playwrightTemplatesDir = path.join(__dirname, 'adapters', 'playwright', 'templates');
+    this.templateEngine = new TemplateEngine(playwrightTemplatesDir);
+    this.patternRegistry = new PatternRegistry();
+    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)`);
+    }
+  }
+
+  /**
+   * Set feature context for data and selector resolution
+   */
+  setFeatureContext(featureName: string, featurePath?: string): void {
+    this.featureName = featureName;
+    this.featurePath = featurePath;
+    this.selectorResolver.setFeatureContext(featureName);
+  }
+
+  /**
+   * Set scenario context for path variable resolution
+   */
+  setScenarioContext(steps: ParsedStep[]): void {
+    this.currentScenarioSteps = steps;
+  }
+
+  /**
+   * Map a Gherkin step to Playwright code
+   * Uses pattern registry first, falls back to AI if enabled
+   */
+  mapStep(step: ParsedStep): MappedStep | Promise<MappedStep> {
+    this.stepCounter++;
+
+    // Try pattern registry first
+    const context = this.createPatternContext();
+    const mappedStep = this.patternRegistry.generateStep(step, context);
+    
+    if (mappedStep) {
+      if (this.verbose) {
+        console.log(`  ✓ Pattern matched: ${step.text.substring(0, 50)}...`);
+      }
+      return mappedStep;
+    }
+
+    // Fallback: Try legacy patterns for backward compatibility
+    const legacyStep = this.tryLegacyPatterns(step);
+    if (legacyStep) {
+      if (this.verbose) {
+        console.log(`  ✓ Legacy pattern matched: ${step.text.substring(0, 50)}...`);
+      }
+      return legacyStep;
+    }
+
+    // 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
+    return {
+      code: `// TODO: Implement step: ${step.text}`,
+      comment: `Unrecognized step pattern: ${step.text}`,
+    };
+  }
+
+  /**
+   * Create pattern context for generators
+   */
+  private createPatternContext(): PatternContext {
+    return {
+      stepCounter: this.stepCounter,
+      extractScreenId: this.extractScreenId.bind(this),
+      templateEngine: this.templateEngine,
+      selectorResolver: this.selectorResolver,
+      dataResolver: this.dataResolver,
+      renderLocator: (resolved) => this.templateEngine.renderStep('locator', resolved),
+      baseURL: this.baseURL,
+      featureName: this.featureName,
+      screenName: this.screenName,
+      featurePath: this.featurePath,  // Pass feature path to patterns
+      scenarioSteps: this.currentScenarioSteps || [],  // Pass scenario steps for path variables
+    };
+  }
+
+  /**
+   * Extract screen ID from selector reference
+   */
+  private extractScreenId(selectorRef: string): string {
+    const match = selectorRef.match(/\[([\w-]+)\./);
+    return match ? match[1] : 'unknown';
+  }
+
+  /**
+   * Try legacy patterns for backward compatibility
+   * These are patterns not yet migrated to the pattern registry
+   */
+  private tryLegacyPatterns(step: ParsedStep): MappedStep | null {
+    const { text, selectorRef, dataRef, value } = step;
+
+    // Login pattern
+    if (text.includes('user is logged in as') && dataRef) {
+      return this.mapLoginStep(dataRef);
+    }
+
+    // Error message assertions
+    if (text.includes('error message') && text.includes('should')) {
+      return this.mapErrorMessageAssertion();
+    }
+
+    // Generic message assertions
+    if (text.includes('message') && text.includes('should be displayed')) {
+      return this.mapGenericMessageAssertion(text);
+    }
+
+    // Message with value assertions
+    if (text.includes('should see message') && value) {
+      return this.mapMessageAssertion(value, selectorRef);
+    }
+
+    // AI response assertions
+    if (text.includes('user should see') && text.includes('AI response') && selectorRef) {
+      return this.mapAIResponseAssertion(selectorRef);
+    }
+
+    // Message count assertions
+    if (text.includes('messages in') && selectorRef) {
+      return this.mapMessageCountAssertion(text, selectorRef);
+    }
+
+    // Message contains assertions
+    if (text.includes('should contain') && text.includes('messages') && selectorRef) {
+      return this.mapMessageCountAssertion(text, selectorRef);
+    }
+
+    return null;
+  }
+
+  // ========================================
+  // LEGACY METHODS (to be migrated to patterns)
+  // ========================================
+
+  private mapLoginStep(dataRef: string): MappedStep {
+    const varName = dataRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+    return {
+      code: this.templateEngine.renderStep('login', { varName, dataRef }),
+      comment: `Login as ${dataRef}`,
+    };
+  }
+
+  private mapErrorMessageAssertion(): MappedStep {
+    return {
+      code: this.templateEngine.renderStep('error-message-assertion', {}),
+      comment: 'Assert error message is displayed',
+    };
+  }
+
+  private mapGenericMessageAssertion(text: string): MappedStep {
+    const messageType = text.includes('welcome') ? 'welcome' : 
+                       text.includes('success') ? 'success' : 'message';
+    return {
+      code: this.templateEngine.renderStep('generic-message-assertion', { messageType }),
+      comment: `Assert ${messageType} message is displayed`,
+    };
+  }
+
+  private mapMessageAssertion(value: string, selectorRef?: string): MappedStep {
+    const varName = (selectorRef || 'message').replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+    return {
+      code: this.templateEngine.renderStep('message-assertion-body', { varName, value, selectorRef }),
+      comment: `Assert message: ${value}`,
+    };
+  }
+
+  private mapAIResponseAssertion(selectorRef: string): MappedStep {
+    const screenId = this.extractScreenId(selectorRef);
+    const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+    return {
+      code: this.templateEngine.renderStep('ai-response-assertion-selector', { varName, selectorRef, screenId }),
+      comment: `Assert AI response in ${selectorRef}`,
+    };
+  }
+
+  private mapMessageCountAssertion(text: string, selectorRef: string): MappedStep {
+    const match = text.match(/(\d+)\s+messages?/);
+    const expectedCount = match ? parseInt(match[1]) : 1;
+    const screenId = this.extractScreenId(selectorRef);
+    const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+    
+    return {
+      code: this.templateEngine.renderStep('message-count-assertion', {
+        varName,
+        selectorRef,
+        screenId,
+        expectedCount,
+      }),
+      comment: `Assert ${expectedCount} messages in ${selectorRef}`,
+    };
+  }
+}

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

@@ -0,0 +1,160 @@
+import Handlebars from 'handlebars';
+import fs from 'fs';
+import path from 'path';
+
+export class TemplateEngine {
+  private templates: Map<string, HandlebarsTemplateDelegate> = new Map();
+  private templatesDir: string;
+  private stepsTemplatesDir: string;
+
+  constructor(templatesDir: string) {
+    this.templatesDir = templatesDir;
+    this.stepsTemplatesDir = path.join(this.templatesDir, 'steps');
+    this.registerHelpers();
+    this.registerPartials();
+  }
+
+  private registerHelpers(): void {
+    Handlebars.registerHelper('indent', function(text: string, spaces: number) {
+      const indentation = ' '.repeat(spaces);
+      return text.split('\n').map(line => indentation + line).join('\n');
+    });
+
+    Handlebars.registerHelper('escapeQuotes', function(text: string) {
+      return text.replace(/'/g, "\\'");
+    });
+
+    // Comparison helpers for conditional logic
+    Handlebars.registerHelper('eq', function(a: any, b: any) {
+      return a === b;
+    });
+
+    Handlebars.registerHelper('or', function(...args: any[]) {
+      // Remove Handlebars options object from end
+      const values = args.slice(0, -1);
+      return values.some(v => !!v);
+    });
+
+    Handlebars.registerHelper('and', function(...args: any[]) {
+      // Remove Handlebars options object from end
+      const values = args.slice(0, -1);
+      return values.every(v => !!v);
+    });
+
+    // Comparison helpers
+    Handlebars.registerHelper('gt', function(a: any, b: any) {
+      return a > b;
+    });
+
+    Handlebars.registerHelper('lt', function(a: any, b: any) {
+      return a < b;
+    });
+
+    Handlebars.registerHelper('gte', function(a: any, b: any) {
+      return a >= b;
+    });
+
+    Handlebars.registerHelper('lte', function(a: any, b: any) {
+      return a <= b;
+    });
+
+    // Math helpers
+    Handlebars.registerHelper('subtract', function(a: any, b: any) {
+      return a - b;
+    });
+
+    Handlebars.registerHelper('add', function(a: any, b: any) {
+      return a + b;
+    });
+
+    // Check if value is defined (not null/undefined) - useful for nth: 0
+    Handlebars.registerHelper('isDefined', function(value: any) {
+      return value !== undefined && value !== null;
+    });
+  }
+
+  private registerPartials(): void {
+    // Register locator partial for reusable selector rendering
+    const locatorPath = path.join(this.stepsTemplatesDir, 'partials', 'locator.hbs');
+    if (fs.existsSync(locatorPath)) {
+      const locatorContent = fs.readFileSync(locatorPath, 'utf-8');
+      Handlebars.registerPartial('locator', locatorContent);
+    }
+  }
+
+  private loadTemplate(templateName: string, isStepTemplate: boolean = false): HandlebarsTemplateDelegate {
+    if (this.templates.has(templateName)) {
+      return this.templates.get(templateName)!;
+    }
+
+    const baseDir = isStepTemplate ? this.stepsTemplatesDir : this.templatesDir;
+    
+    // Try to find template in organized folders
+    if (isStepTemplate) {
+      const folders = ['actions', 'assertions', 'navigation', 'setup', 'partials'];
+      
+      for (const folder of folders) {
+        const templatePath = path.join(baseDir, folder, `${templateName}.hbs`);
+        if (fs.existsSync(templatePath)) {
+          const templateContent = fs.readFileSync(templatePath, 'utf-8');
+          const template = Handlebars.compile(templateContent, { noEscape: true });
+          this.templates.set(templateName, template);
+          return template;
+        }
+      }
+      
+      // Fallback: try root steps directory
+      const templatePath = path.join(baseDir, `${templateName}.hbs`);
+      if (fs.existsSync(templatePath)) {
+        const templateContent = fs.readFileSync(templatePath, 'utf-8');
+        const template = Handlebars.compile(templateContent, { noEscape: true });
+        this.templates.set(templateName, template);
+        return template;
+      }
+      
+      throw new Error(`Template not found: ${templateName}.hbs in any subfolder`);
+    } else {
+      const templatePath = path.join(baseDir, `${templateName}.hbs`);
+      const templateContent = fs.readFileSync(templatePath, 'utf-8');
+      const template = Handlebars.compile(templateContent, { noEscape: true });
+      this.templates.set(templateName, template);
+      return template;
+    }
+  }
+
+  render(templateName: string, data: any, isStepTemplate: boolean = false): string {
+    const template = this.loadTemplate(templateName, isStepTemplate);
+    return template(data);
+  }
+
+  renderStep(stepTemplateName: string, data: any): string {
+    return this.render(stepTemplateName, data, true);
+  }
+
+  renderImports(): string {
+    return this.render('imports', {});
+  }
+
+  renderTestFile(data: {
+    imports: string;
+    featureName: string;
+    featureDescription?: string;
+    background?: string;
+    scenarios: string[];
+  }): string {
+    return this.render('test-file', data);
+  }
+
+  renderBeforeEach(data: {
+    steps: Array<{ comment?: string; code: string }>;
+  }): string {
+    return this.render('before-each', data);
+  }
+
+  renderScenario(data: {
+    scenarioName: string;
+    steps: Array<{ comment?: string; code: string }>;
+  }): string {
+    return this.render('scenario', data);
+  }
+}

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

@@ -0,0 +1,147 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import yaml from 'yaml';
+
+/**
+ * DataResolver - Resolves data references to actual values
+ * at generation time (not runtime)
+ */
+export class DataResolver {
+  private dataCache = new Map<string, any>();
+  private testDataDir: string;
+  private screenName?: string;
+
+  constructor(testDataDir?: string, screenName?: string) {
+    this.testDataDir = testDataDir || path.join(process.cwd(), 'qa', 'test-data');
+    this.screenName = screenName;
+  }
+
+  /**
+   * Set screen context for data resolution
+   */
+  setScreenContext(screenName: string): void {
+    this.screenName = screenName;
+  }
+
+  /**
+   * Resolve data reference to actual value
+   * @param dataRef - Format: email.valid (path.to.value without filename)
+   * @param featureName - Name of the feature file (e.g., "login" from "login.feature")
+   * @returns The resolved value
+   */
+  resolveData(dataRef: string, featureName?: string): string {
+    // Split into parts: email.valid -> [email, valid]
+    // Use only dot (.) as separator
+    const parts = dataRef.split('.');
+    
+    if (parts.length < 1) {
+      throw new Error(`Invalid data reference: ${dataRef}. Expected format: path.to.value`);
+    }
+
+    // If featureName provided, use it as the file name
+    // Otherwise, use first part as filename (backward compatibility)
+    let fileName: string;
+    let valuePath: string[];
+    
+    if (featureName) {
+      fileName = featureName;
+      valuePath = parts;
+    } else {
+      if (parts.length < 2) {
+        throw new Error(`Invalid data reference: ${dataRef}. Expected format: file.path.to.value or provide featureName`);
+      }
+      fileName = parts[0];
+      valuePath = parts.slice(1);
+    }
+
+    // Load data file
+    const data = this.loadDataFile(fileName);
+
+    // Navigate to the value
+    let current = data;
+    for (const key of valuePath) {
+      if (current && typeof current === 'object' && key in current) {
+        current = current[key];
+      } else {
+        throw new Error(
+          `Data path not found: ${dataRef}. Failed at key: ${key}`
+        );
+      }
+    }
+
+    // Return as string
+    if (typeof current === 'string') {
+      return current;
+    } else if (typeof current === 'number' || typeof current === 'boolean') {
+      return String(current);
+    } else {
+      throw new Error(
+        `Data reference ${dataRef} must resolve to a primitive value, got: ${typeof current}`
+      );
+    }
+  }
+
+  /**
+   * Load data file from disk (with caching)
+   * Searches new screen-based directory structure only
+   */
+  private loadDataFile(fileName: string): any {
+    if (this.dataCache.has(fileName)) {
+      return this.dataCache.get(fileName)!;
+    }
+
+    const filePath = this.findDataFilePath(fileName);
+    
+    if (!filePath) {
+      const possiblePaths = this.getPossibleDataPaths(fileName);
+      throw new Error(
+        `Data file not found. Tried:\n${possiblePaths.join('\n')}`
+      );
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const data = yaml.parse(content);
+
+    this.dataCache.set(fileName, data);
+    return data;
+  }
+
+  /**
+   * Find data file path (checks new screen-based structure)
+   */
+  private findDataFilePath(fileName: string): string | null {
+    const possiblePaths = this.getPossibleDataPaths(fileName);
+    
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p)) {
+        return p;
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Get list of possible data file paths (priority order)
+   */
+  private getPossibleDataPaths(fileName: string): string[] {
+    const paths: string[] = [];
+
+    // New structure: qa/screens/{screenName}/test-data/{fileName}.yaml
+    if (this.screenName) {
+      const cwd = process.cwd();
+      const newPath = path.join(cwd, 'qa', 'screens', this.screenName, 'test-data', `${fileName}.yaml`);
+      const newPathYml = path.join(cwd, 'qa', 'screens', this.screenName, 'test-data', `${fileName}.yml`);
+      paths.push(newPath, newPathYml);
+    }
+
+    return paths;
+  }
+
+  /**
+   * Clear cache (useful for testing)
+   */
+  clearCache(): void {
+    this.dataCache.clear();
+  }
+}