@sun-asterisk/sungen 1.0.0

package/src/config/default.config.yaml

@@ -0,0 +1,101 @@
+# AI-Native E2E Test Framework - Default Configuration
+# This file contains default settings for the framework
+# Override values via CLI flags or custom config files
+
+# General settings
+version: "1.0.0"
+verbose: false
+force: false  # Force regeneration, bypass cache
+
+# Paths
+paths:
+  sourceRoot: "app"
+  featuresDir: "qa/features"
+  testDataDir: "qa/test-data"
+  uiModelsDir: "qa/ui-models"
+  selectorsDir: "qa/selectors"
+  specsDir: "specs/generated"
+  cacheDir: ".cache"
+
+# UI Scanner configuration
+scanner:
+  framework: "react"  # react, vue, angular
+  maxDepth: 999       # Component scan depth (999 = unlimited)
+  includePatterns:
+    - "src/**/*.tsx"
+    - "src/**/*.jsx"
+  excludePatterns:
+    - "node_modules/**"
+    - "**/*.test.*"
+    - "**/*.spec.*"
+
+# Selector mapping configuration
+selectorMapping:
+  mode: "hybrid"  # hybrid, ai-only, heuristic-only
+  aiProvider: "anthropic"  # anthropic, copilot, openai
+  model: "claude-sonnet-4-5-20250929"
+  maxTokens: 4000
+  temperature: 0
+  enableOverride: true  # Support manual .override.yaml files
+  heuristicFirst: true  # Try heuristics before AI (hybrid mode)
+  minHeuristicConfidence: 0.8  # Min confidence to use heuristic (0.0-1.0)
+
+# Gherkin annotations (for selector base generation)
+annotations:
+  selectorId:
+    pattern: "\\[([a-z0-9-]+\\.[a-z0-9-]+)\\]"
+    description: "Element selector ID, e.g., [chat.input]"
+
+  dataRef:
+    pattern: "<([a-z0-9_\\.]+)>"
+    description: "Test data reference, e.g., <user.email>"
+
+  ignore:
+    pattern: "# @ignore"
+    description: "Ignore step in generation"
+
+  ignoreTestCase:
+    pattern: "# @ignore-testcase"
+    description: "Ignore entire test case (scenario)"
+
+  skipProduction:
+    pattern: "# @skip-production"
+    description: "Skip test in production environment"
+
+# Test generation configuration
+testGenerator:
+  framework: "playwright"  # playwright, appium, integration
+  aiProvider: "anthropic"  # anthropic, copilot, openai
+  model: "claude-3-5-haiku-20241022"
+  maxTokens: 500
+  temperature: 0
+  enableAIFallback: false  # Enable AI for unknown patterns (--ai-mapper flag)
+  dictionaryPath: "qa/executor/playwright/dictionary.yaml"
+
+# Cache configuration
+cache:
+  enabled: true
+  ttl: 86400  # 24 hours in seconds
+  invalidateOnSourceChange: true
+  invalidateOnConfigChange: true
+
+# External API configuration
+apis:
+  anthropic:
+    baseURL: "https://api.anthropic.com"
+    apiKeyEnv: "ANTHROPIC_API_KEY"
+    timeout: 30000  # 30 seconds
+
+  openai:
+    baseURL: "https://api.openai.com"
+    apiKeyEnv: "OPENAI_API_KEY"
+    timeout: 30000
+
+  copilot:
+    # Will be configured via VS Code extension
+    enabled: false
+
+# Application configuration (for E2E tests)
+app:
+  baseURL: "http://localhost:3000"
+  timeout: 30000  # Default timeout for test actions

package/src/config/framework.config.yaml

@@ -0,0 +1,52 @@
+# QA Automation Framework Configuration
+
+# AI Provider Settings
+ai:
+  provider: "claude"  # claude | openai | gemini
+  model: "claude-3-haiku-20240307"
+  temperature: 0.2
+  maxTokens: 2048
+
+# Selector Discovery Settings
+selectors:
+  autoDiscovery: false  # Enable in Phase 2
+  selfHealing: false    # Enable in Phase 2
+  confidenceThreshold: 0.8
+  defaultTimeout: 30000  # 30 seconds
+
+# Caching Settings
+caching:
+  enabled: true
+  ttl: 86400  # 24 hours in seconds
+  directory: ".cache/flows"
+
+# Generation Settings
+generation:
+  patternMatchingFirst: true  # Try pattern matching before AI
+  parallelGeneration: false   # Generate multiple features in parallel
+  validateSelectors: true     # Validate selectors exist before generation
+
+# Reporting Settings
+reporting:
+  formats:
+    - "html"
+    - "json"
+    - "junit"
+  outputDir: "reports"
+  screenshots: "only-on-failure"
+  video: false
+  trace: "on-first-retry"
+
+# Test Execution Settings
+execution:
+  baseURL: "http://localhost:3000"
+  headless: true
+  timeout: 30000
+  retries: 2
+  workers: 1
+  browser: "chromium"
+
+# Logging
+logging:
+  level: "info"  # debug | info | warn | error
+  verbose: false

package/src/config/routes.yaml

@@ -0,0 +1,31 @@
+# Routes Configuration
+# Centralized route management for all environments
+
+# Development routes
+development:
+  home: "/"
+  login: "/auth/login"
+  register: "/auth/register"
+  chat: "/chat"
+
+# Staging routes (if different)
+staging:
+  home: "/"
+  login: "/auth/login"
+  register: "/auth/register"
+  chat: "/chat"
+
+# Production routes (if different)
+production:
+  home: "/"
+  login: "/login"  # Maybe different in production
+  register: "/register"
+  chat: "/chat"
+
+# Default environment
+default: "development"
+
+# Route aliases for backward compatibility
+aliases:
+  "login": "auth.login"
+  "register": "auth.register"

package/src/core/selector-base/annotation-handler.ts

@@ -0,0 +1,127 @@
+/**
+ * Annotation Handler
+ * Handles Gherkin annotations: selector IDs, data refs, ignore, etc.
+ */
+
+import { RuntimeConfig } from '../../config/config-schema';
+import { ParsedScenario, ParsedStep } from './gherkin-parser';
+
+export interface ExtractedAnnotation {
+  id: string;
+  type: 'selector' | 'data' | 'ignore';
+  value?: string;
+}
+
+export class AnnotationHandler {
+  private config: RuntimeConfig;
+
+  constructor(config: RuntimeConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Extract element ID from step text
+   * Supports: [screen.element] ONLY (not data refs)
+   * Data refs <data.field> are handled separately in test-data system
+   */
+  extractElementId(stepText: string, screenName: string): ExtractedAnnotation | null {
+    // Extract selector ID: [screen.element-name]
+    const selectorPattern = new RegExp(this.config.annotations.selectorId.pattern);
+    const selectorMatch = stepText.match(selectorPattern);
+
+    if (selectorMatch) {
+      const fullId = selectorMatch[1]; // e.g., "chat.input"
+      const [screen, element] = fullId.split('.');
+
+      // Only return if it matches the target screen
+      if (screen === screenName) {
+        return {
+          id: element,
+          type: 'selector'
+        };
+      }
+    }
+
+    // NOTE: Data references <data.field> are NOT included in selector files
+    // They belong in qa/test-data/ directory, not qa/selectors/
+    // This is per GHERKIN_STANDARDS.md specification
+
+    return null;
+  }
+
+  /**
+   * Check if step should be ignored
+   * Supports: # @ignore
+   */
+  shouldIgnoreStep(step: ParsedStep): boolean {
+    const ignorePattern = new RegExp(this.config.annotations.ignore.pattern);
+    return ignorePattern.test(step.text);
+  }
+
+  /**
+   * Check if entire scenario should be ignored
+   * Supports: # @ignore-testcase
+   */
+  shouldIgnoreScenario(scenario: ParsedScenario): boolean {
+    // Check scenario description
+    // @ts-ignore - Legacy parser may have description field
+    if (scenario.description) {
+      const ignorePattern = new RegExp(this.config.annotations.ignoreTestCase.pattern);
+      // @ts-ignore
+      if (ignorePattern.test(scenario.description)) {
+        return true;
+      }
+    }
+
+    // Check scenario tags (if any)
+    // @ts-ignore - Legacy parser may have tags field
+    if (scenario.tags && scenario.tags.includes('@ignore')) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if step should be skipped in production
+   * Supports: # @skip-production
+   */
+  shouldSkipInProduction(step: ParsedStep): boolean {
+    const skipPattern = new RegExp(this.config.annotations.skipProduction.pattern);
+    return skipPattern.test(step.text);
+  }
+
+  /**
+   * Extract all element IDs from step (can have multiple)
+   */
+  extractAllElementIds(stepText: string): string[] {
+    const ids: string[] = [];
+
+    // Extract all [screen.element] patterns
+    const selectorPattern = new RegExp(this.config.annotations.selectorId.pattern, 'g');
+    let match;
+
+    while ((match = selectorPattern.exec(stepText)) !== null) {
+      ids.push(match[1]);
+    }
+
+    return ids;
+  }
+
+  /**
+   * Extract data references from step
+   */
+  extractDataRefs(stepText: string): string[] {
+    const refs: string[] = [];
+
+    // Extract all <data.ref> patterns
+    const dataPattern = new RegExp(this.config.annotations.dataRef.pattern, 'g');
+    let match;
+
+    while ((match = dataPattern.exec(stepText)) !== null) {
+      refs.push(match[1]);
+    }
+
+    return refs;
+  }
+}

package/src/core/selector-base/base-generator.ts

@@ -0,0 +1,234 @@
+/**
+ * Selector Base Generator
+ * Generates empty selector template from Gherkin features
+ * Supports multiple annotation types
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import yaml from 'yaml';
+import { RuntimeConfig } from '../../config/config-schema';
+import { GherkinParser, ParsedFeature } from './gherkin-parser';
+import { AnnotationHandler } from './annotation-handler';
+
+export interface SelectorBase {
+  screen: string;
+  elements: Record<string, SelectorElement>;
+  metadata: {
+    generatedFrom: string;
+    timestamp: number;
+    totalElements: number;
+  };
+}
+
+export interface SelectorElement {
+  selector: string;  // Empty initially, will be filled by AI
+  type?: 'selector' | 'data' | 'ignore';
+  source?: string;   // Which feature file it came from
+  line?: number;     // Line number in feature file
+}
+
+export class SelectorBaseGenerator {
+  private config: RuntimeConfig;
+  private parser: GherkinParser;
+  private annotationHandler: AnnotationHandler;
+
+  constructor(config: RuntimeConfig) {
+    this.config = config;
+    this.parser = new GherkinParser(config);
+    this.annotationHandler = new AnnotationHandler(config);
+  }
+
+  /**
+   * Generate selector base for a screen
+   * Scans all Gherkin features and extracts element IDs
+   */
+  async generate(screenName: string): Promise<SelectorBase> {
+    const featuresDir = this.config.paths.featuresDir;
+
+    // Find all feature files
+    const featureFiles = this.findFeatureFiles(featuresDir);
+
+    // Extract element IDs from all features
+    const elementIds = new Set<string>();
+    const elementMetadata: Record<string, { source: string; line: number; type: string }> = {};
+
+    for (const featureFile of featureFiles) {
+      const feature = await this.parser.parse(featureFile);
+
+      // Extract element IDs from steps
+      const ids = this.extractElementIds(feature, screenName);
+
+      for (const { id, line, type } of ids) {
+        elementIds.add(id);
+        elementMetadata[id] = {
+          source: path.basename(featureFile),
+          line,
+          type
+        };
+      }
+    }
+
+    // Build selector base
+    const elements: Record<string, SelectorElement> = {};
+
+    for (const id of Array.from(elementIds)) {
+      const meta = elementMetadata[id];
+      elements[id] = {
+        selector: '',  // Empty - will be filled by AI
+        type: meta.type as any,
+        source: meta.source,
+        line: meta.line
+      };
+    }
+
+    return {
+      screen: screenName,
+      elements,
+      metadata: {
+        generatedFrom: featuresDir,
+        timestamp: Date.now(),
+        totalElements: elementIds.size
+      }
+    };
+  }
+
+  /**
+   * Save selector base to YAML file
+   */
+  async save(selectorBase: SelectorBase): Promise<string> {
+    const outputDir = path.join(this.config.paths.selectorsDir, 'screens');
+
+    // Ensure output directory exists
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    const outputPath = path.join(outputDir, `${selectorBase.screen}.yaml`);
+
+    // Format for YAML output
+    const yamlContent = {
+      screen: selectorBase.screen,
+      elements: selectorBase.elements
+    };
+
+    fs.writeFileSync(outputPath, yaml.stringify(yamlContent), 'utf-8');
+
+    if (this.config.verbose) {
+      console.log(`✓ Generated selector base: ${outputPath}`);
+      console.log(`  Elements: ${selectorBase.metadata.totalElements}`);
+    }
+
+    return outputPath;
+  }
+
+  /**
+   * Extract element IDs from feature for specific screen
+   */
+  private extractElementIds(
+    feature: ParsedFeature,
+    screenName: string
+  ): Array<{ id: string; line: number; type: string }> {
+    const ids: Array<{ id: string; line: number; type: string }> = [];
+
+    // Check background steps
+    if (feature.background) {
+      for (const step of feature.background.steps) {
+        const extracted = this.annotationHandler.extractElementId(step.text, screenName);
+        if (extracted) {
+          ids.push({
+            id: extracted.id,
+            // @ts-ignore - Legacy parser may have line field
+            line: step.line || 0,
+            type: extracted.type
+          });
+        }
+      }
+    }
+
+    // Check scenario steps
+    for (const scenario of feature.scenarios) {
+      // Check for @ignore-testcase annotation
+      if (this.annotationHandler.shouldIgnoreScenario(scenario)) {
+        continue;
+      }
+
+      for (const step of scenario.steps) {
+        // Check for @ignore annotation
+        if (this.annotationHandler.shouldIgnoreStep(step)) {
+          continue;
+        }
+
+        const extracted = this.annotationHandler.extractElementId(step.text, screenName);
+        if (extracted) {
+          ids.push({
+            id: extracted.id,
+            // @ts-ignore - Legacy parser may have line field
+            line: step.line || 0,
+            type: extracted.type
+          });
+        }
+      }
+    }
+
+    return ids;
+  }
+
+  /**
+   * Find all feature files in directory
+   */
+  private findFeatureFiles(dir: string): string[] {
+    const files: string[] = [];
+
+    if (!fs.existsSync(dir)) {
+      return files;
+    }
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        files.push(...this.findFeatureFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith('.feature')) {
+        files.push(fullPath);
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Load existing selector base (if exists)
+   */
+  async load(screenName: string): Promise<SelectorBase | null> {
+    const filePath = path.join(
+      this.config.paths.selectorsDir,
+      'screens',
+      `${screenName}.yaml`
+    );
+
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const data = yaml.parse(content);
+
+      return {
+        screen: data.screen,
+        elements: data.elements || {},
+        metadata: {
+          generatedFrom: this.config.paths.featuresDir,
+          timestamp: Date.now(),
+          totalElements: Object.keys(data.elements || {}).length
+        }
+      };
+    } catch (error) {
+      console.error(`Failed to load selector base: ${error}`);
+      return null;
+    }
+  }
+}

package/src/core/selector-base/gherkin-parser.ts

@@ -0,0 +1,57 @@
+/**
+ * Gherkin Parser
+ * Parses Gherkin feature files into structured format
+ * This is a wrapper around the existing parser with new interface
+ */
+
+import * as fs from 'fs';
+import { RuntimeConfig } from '../../config/config-schema';
+import {
+  GherkinParser as LegacyParser,
+  ParsedFeature as LegacyFeature,
+  ParsedScenario as LegacyScenario,
+  ParsedStep as LegacyStep
+} from '../../generators/gherkin-parser';
+
+// Re-export types from legacy parser for now
+export type ParsedFeature = LegacyFeature;
+export type ParsedScenario = LegacyScenario;
+export type ParsedStep = LegacyStep;
+
+export class GherkinParser {
+  private config: RuntimeConfig;
+  private legacyParser: LegacyParser;
+
+  constructor(config: RuntimeConfig) {
+    this.config = config;
+    this.legacyParser = new LegacyParser();
+  }
+
+  /**
+   * Parse a Gherkin feature file
+   */
+  async parse(featurePath: string): Promise<ParsedFeature> {
+    // Use correct method name from legacy parser
+    return this.legacyParser.parseFeatureFile(featurePath);
+  }
+
+  /**
+   * Parse multiple feature files
+   */
+  async parseAll(featureFiles: string[]): Promise<ParsedFeature[]> {
+    const features: ParsedFeature[] = [];
+
+    for (const file of featureFiles) {
+      try {
+        const feature = await this.parse(file);
+        features.push(feature);
+      } catch (error) {
+        if (this.config.verbose) {
+          console.error(`Failed to parse ${file}: ${error}`);
+        }
+      }
+    }
+
+    return features;
+  }
+}