@sun-asterisk/sungen 1.0.5 → 1.0.6

package/src/core/validator/screen-validator.ts

@@ -0,0 +1,209 @@
+/**
+ * Screen Validator
+ * Orchestrates validation for a screen (all features in qa/screens/<name>/)
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  ValidationResult,
+  FileValidationResult,
+  ValidationSummary,
+  ValidationIssue,
+} from './index';
+import { FeatureValidator } from './feature-validator';
+import { SelectorValidator } from './selector-validator';
+import { DataValidator } from './data-validator';
+
+export interface ScreenValidatorOptions {
+  verbose?: boolean;
+  baseDir?: string;
+}
+
+export class ScreenValidator {
+  private baseDir: string;
+  private verbose: boolean;
+
+  constructor(options: ScreenValidatorOptions = {}) {
+    this.baseDir = options.baseDir || process.cwd();
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Validate a specific screen
+   */
+  validateScreen(screenName: string): ValidationResult {
+    const results: FileValidationResult[] = [];
+
+    const screenDir = path.join(this.baseDir, 'qa', 'screens', screenName);
+    const featuresDir = path.join(screenDir, 'features');
+
+    // Check if screen exists
+    if (!fs.existsSync(screenDir)) {
+      return this.createErrorResult(`Screen "${screenName}" not found at ${screenDir}`);
+    }
+
+    if (!fs.existsSync(featuresDir)) {
+      return this.createErrorResult(`Features directory not found at ${featuresDir}`);
+    }
+
+    // Find all feature files
+    const featureFiles = this.discoverFeatureFiles(featuresDir);
+
+    if (featureFiles.length === 0) {
+      return this.createErrorResult(`No .feature files found in ${featuresDir}`);
+    }
+
+    // Initialize validators
+    const featureValidator = new FeatureValidator();
+    const selectorValidator = new SelectorValidator(screenName, this.baseDir);
+    const dataValidator = new DataValidator(screenName, this.baseDir);
+
+    // Validate each feature file
+    for (const featureFile of featureFiles) {
+      const featureName = path.basename(featureFile, '.feature');
+      const relativeFile = path.relative(this.baseDir, featureFile);
+
+      const fileResult: FileValidationResult = {
+        file: relativeFile,
+        valid: true,
+        errors: [],
+        warnings: [],
+      };
+
+      // 1. Validate Gherkin syntax and extract refs
+      const featureResult = featureValidator.validate(featureFile);
+      fileResult.errors.push(...featureResult.errors);
+      fileResult.warnings.push(...featureResult.warnings);
+
+      // 2. Validate selector file
+      const selectorFileResult = selectorValidator.validateFile(featureName);
+      fileResult.errors.push(...selectorFileResult.errors);
+      fileResult.warnings.push(...selectorFileResult.warnings);
+
+      // 3. Validate selector refs exist
+      if (featureResult.refs.selectors.length > 0) {
+        const selectorRefErrors = selectorValidator.validateRefs(
+          featureName,
+          featureResult.refs.selectors,
+          relativeFile
+        );
+        fileResult.errors.push(...selectorRefErrors);
+      }
+
+      // 4. Validate data file
+      const dataFileResult = dataValidator.validateFile(featureName);
+      fileResult.errors.push(...dataFileResult.errors);
+      fileResult.warnings.push(...dataFileResult.warnings);
+
+      // 5. Validate data refs exist
+      if (featureResult.refs.dataRefs.length > 0) {
+        const dataRefErrors = dataValidator.validateRefs(
+          featureName,
+          featureResult.refs.dataRefs,
+          relativeFile
+        );
+        fileResult.errors.push(...dataRefErrors);
+      }
+
+      // Update validity
+      fileResult.valid = fileResult.errors.length === 0;
+      results.push(fileResult);
+    }
+
+    return this.buildResult(results);
+  }
+
+  /**
+   * Validate all screens
+   */
+  validateAll(): ValidationResult {
+    const screensDir = path.join(this.baseDir, 'qa', 'screens');
+
+    if (!fs.existsSync(screensDir)) {
+      return this.createErrorResult(`Screens directory not found at ${screensDir}`);
+    }
+
+    const screens = fs.readdirSync(screensDir, { withFileTypes: true })
+      .filter(entry => entry.isDirectory())
+      .map(entry => entry.name);
+
+    if (screens.length === 0) {
+      return this.createErrorResult(`No screens found in ${screensDir}`);
+    }
+
+    const allResults: FileValidationResult[] = [];
+
+    for (const screenName of screens) {
+      const screenResult = this.validateScreen(screenName);
+      allResults.push(...screenResult.results);
+    }
+
+    return this.buildResult(allResults);
+  }
+
+  /**
+   * Discover .feature files in a directory
+   */
+  private discoverFeatureFiles(dir: string): string[] {
+    const files: string[] = [];
+
+    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.discoverFeatureFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith('.feature')) {
+        files.push(fullPath);
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Build final validation result
+   */
+  private buildResult(results: FileValidationResult[]): ValidationResult {
+    const summary: ValidationSummary = {
+      totalFiles: results.length,
+      passedFiles: results.filter(r => r.valid).length,
+      failedFiles: results.filter(r => !r.valid).length,
+      totalErrors: results.reduce((sum, r) => sum + r.errors.length, 0),
+      totalWarnings: results.reduce((sum, r) => sum + r.warnings.length, 0),
+    };
+
+    return {
+      valid: summary.failedFiles === 0,
+      summary,
+      results,
+    };
+  }
+
+  /**
+   * Create error result for invalid setup
+   */
+  private createErrorResult(message: string): ValidationResult {
+    return {
+      valid: false,
+      summary: {
+        totalFiles: 0,
+        passedFiles: 0,
+        failedFiles: 0,
+        totalErrors: 1,
+        totalWarnings: 0,
+      },
+      results: [{
+        file: '',
+        valid: false,
+        errors: [{
+          type: 'error',
+          code: 'GHERKIN_SYNTAX_ERROR',
+          message,
+          file: '',
+        }],
+        warnings: [],
+      }],
+    };
+  }
+}

package/src/core/validator/selector-validator.ts

@@ -0,0 +1,208 @@
+/**
+ * Selector Validator
+ * Validates selector YAML files and checks referenced selectors exist
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import yaml from 'yaml';
+import { ValidationIssue } from './index';
+
+interface SelectorEntry {
+  selector?: string;
+  type?: 'placeholder' | 'role' | 'testid' | 'label' | 'text';
+  value?: string;
+  name?: string;
+  nth?: number;
+}
+
+type SelectorFile = Record<string, SelectorEntry>;
+
+const VALID_TYPES = ['placeholder', 'role', 'testid', 'label', 'text'];
+
+export class SelectorValidator {
+  private screenName: string;
+  private baseDir: string;
+  private selectorCache = new Map<string, SelectorFile>();
+
+  constructor(screenName: string, baseDir?: string) {
+    this.screenName = screenName;
+    this.baseDir = baseDir || process.cwd();
+  }
+
+  /**
+   * Validate selector file for a feature
+   */
+  validateFile(featureName: string): { errors: ValidationIssue[]; warnings: ValidationIssue[] } {
+    const errors: ValidationIssue[] = [];
+    const warnings: ValidationIssue[] = [];
+
+    const filePath = this.findSelectorPath(featureName);
+
+    if (!filePath) {
+      errors.push({
+        type: 'error',
+        code: 'MISSING_SELECTOR_FILE',
+        message: `Selector file not found for feature "${featureName}"`,
+        file: `qa/screens/${this.screenName}/selectors/${featureName}.yaml`,
+      });
+      return { errors, warnings };
+    }
+
+    // Load and parse YAML
+    let content: string;
+    let selectors: SelectorFile;
+
+    try {
+      content = fs.readFileSync(filePath, 'utf-8');
+    } catch (error) {
+      errors.push({
+        type: 'error',
+        code: 'INVALID_YAML_SYNTAX',
+        message: `Cannot read file: ${(error as Error).message}`,
+        file: filePath,
+      });
+      return { errors, warnings };
+    }
+
+    try {
+      selectors = yaml.parse(content) as SelectorFile;
+    } catch (error) {
+      errors.push({
+        type: 'error',
+        code: 'INVALID_YAML_SYNTAX',
+        message: `YAML parse error: ${(error as Error).message}`,
+        file: filePath,
+      });
+      return { errors, warnings };
+    }
+
+    if (!selectors || typeof selectors !== 'object') {
+      errors.push({
+        type: 'error',
+        code: 'INVALID_YAML_SYNTAX',
+        message: 'Selector file must be a valid YAML object',
+        file: filePath,
+      });
+      return { errors, warnings };
+    }
+
+    // Validate each selector entry
+    for (const [key, entry] of Object.entries(selectors)) {
+      if (!entry || typeof entry !== 'object') {
+        warnings.push({
+          type: 'warning',
+          code: 'INVALID_SELECTOR_TYPE',
+          message: `Selector "${key}" should be an object with type/value properties`,
+          file: filePath,
+          element: key,
+        });
+        continue;
+      }
+
+      // Check type is valid
+      if (entry.type && !VALID_TYPES.includes(entry.type)) {
+        warnings.push({
+          type: 'warning',
+          code: 'INVALID_SELECTOR_TYPE',
+          message: `Selector "${key}" has invalid type "${entry.type}". Valid types: ${VALID_TYPES.join(', ')}`,
+          file: filePath,
+          element: key,
+        });
+      }
+    }
+
+    // Cache for later ref validation
+    this.selectorCache.set(featureName, selectors);
+
+    return { errors, warnings };
+  }
+
+  /**
+   * Check if selector references exist
+   */
+  validateRefs(
+    featureName: string,
+    refs: Array<{ ref: string; line: number }>,
+    featureFile: string
+  ): ValidationIssue[] {
+    const errors: ValidationIssue[] = [];
+
+    // Load selectors if not cached
+    if (!this.selectorCache.has(featureName)) {
+      const filePath = this.findSelectorPath(featureName);
+      if (!filePath) {
+        // Already reported in validateFile
+        return errors;
+      }
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const selectors = yaml.parse(content) as SelectorFile;
+        this.selectorCache.set(featureName, selectors);
+      } catch {
+        // Error already reported in validateFile
+        return errors;
+      }
+    }
+
+    const selectors = this.selectorCache.get(featureName);
+    if (!selectors) {
+      return errors;
+    }
+
+    // Check each ref
+    for (const { ref, line } of refs) {
+      const key = this.generateKey(ref);
+
+      if (!(key in selectors)) {
+        errors.push({
+          type: 'error',
+          code: 'MISSING_SELECTOR',
+          message: `Selector [${ref}] (key: ${key}) not found in selectors/${featureName}.yaml`,
+          file: featureFile,
+          line,
+          element: ref,
+        });
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Generate selector key from natural language label
+   * Matches logic in SelectorResolver.generateKey()
+   */
+  private generateKey(label: string): string {
+    return label
+      .toLowerCase()
+      .replace(/['\u2019]s/g, 's')
+      .replace(/['\u2019]/g, '')
+      .replace(/[^a-z0-9\s]/g, '')
+      .trim()
+      .replace(/\s+/g, '.');
+  }
+
+  /**
+   * Find selector file path (checks override first)
+   */
+  private findSelectorPath(featureName: string): string | null {
+    const possiblePaths = [
+      // Override (highest priority)
+      path.join(this.baseDir, 'qa', 'screens', this.screenName, 'selectors', `${featureName}-override.yaml`),
+      // Normal
+      path.join(this.baseDir, 'qa', 'screens', this.screenName, 'selectors', `${featureName}.yaml`),
+      // Legacy paths
+      path.join(this.baseDir, 'qa', 'selectors', 'screens', `${featureName}-override.yaml`),
+      path.join(this.baseDir, 'qa', 'selectors', 'screens', `${featureName}.yaml`),
+    ];
+
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p)) {
+        return p;
+      }
+    }
+
+    return null;
+  }
+}

package/src/generators/cli.ts

@@ -52,7 +52,7 @@ const program = new Command();
 program
   .name('qa-generator')
   .description('AI-Native QA Selector DSL Generator')
-  .version('1.0.4');
+  .version('1.0.6');
 
 // ============================================================================
 // Command: discover

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.4');
+      .version('1.0.6');
 
     // Global options
     program
@@ -157,6 +157,18 @@ export class CLIAdapter implements InputAdapter {
       .option('-d, --description <text>', 'Screen description');
   }
 
+  /**
+   * Add validate command
+   */
+  addValidateCommand(program: Command): Command {
+    return program
+      .command('validate')
+      .description('Validate Gherkin features and selector/test-data mappings')
+      .option('-s, --screen <name>', 'Validate specific screen (optional, defaults to all)')
+      .option('--json', 'Output results as JSON')
+      .option('-v, --verbose', 'Show all checks, not just failures');
+  }
+
   /**
    * Extract options from commander Command
    */