@sun-asterisk/sungen 1.0.24 → 2.0.1

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

@@ -1,209 +0,0 @@
-/**
- * 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';
-import { SelectorResolver } from '../../generators/test-generator/utils/selector-resolver';
-import { VALID_SELECTOR_TYPES, SelectorType } from '../../utils/selector-types';
-
-interface SelectorEntry {
-  selector?: string;
-  type?: SelectorType;
-  value?: string;
-  name?: string;
-  nth?: number;
-}
-
-type SelectorFile = Record<string, SelectorEntry>;
-
-const VALID_TYPES = VALID_SELECTOR_TYPES;
-
-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);
-
-      // Check: exact key, or any suffixed key (key--button, key--text, etc.)
-      const found = (key in selectors) ||
-        Object.keys(selectors).some(k => k.startsWith(`${key}--`));
-
-      if (!found) {
-        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
-   * Delegates to SelectorResolver.generateKey() for consistent behavior
-   * (includes Vietnamese tone removal and Japanese Romaji conversion)
-   */
-  private generateKey(label: string): string {
-    return SelectorResolver.generateKey(label);
-  }
-
-  /**
-   * 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/external/ai-provider.ts

@@ -1,90 +0,0 @@
-/**
- * AI Provider Interface
- * Defines contract for AI service providers (Anthropic, OpenAI, Copilot)
- */
-
-import { RuntimeConfig } from '../config/config-schema';
-import { UIModel } from '../core/ui-scanner/scanner-interface';
-import { SelectorBase } from '../core/selector-base/base-generator';
-
-/**
- * Main AI Provider Interface
- */
-export interface AIProvider {
-  /**
-   * Provider name
-   */
-  readonly name: string;
-
-  /**
-   * Provider type
-   */
-  readonly type: 'anthropic' | 'openai' | 'copilot';
-
-  /**
-   * Map element IDs to CSS selectors using AI
-   *
-   * @param uiModel - UI model with discovered elements
-   * @param selectorBase - Selector template with empty selectors
-   * @param config - Runtime configuration
-   * @returns Filled selector base with AI-generated selectors
-   */
-  mapSelectors(
-    uiModel: UIModel,
-    selectorBase: SelectorBase,
-    config: RuntimeConfig
-  ): Promise<SelectorBase>;
-
-  /**
-   * Generate Playwright code for a Gherkin step using AI
-   *
-   * @param step - Parsed Gherkin step
-   * @param context - Context (selectors, test data, examples)
-   * @param config - Runtime configuration
-   * @returns Generated Playwright code
-   */
-  generateStepCode(
-    step: any,
-    context: StepContext,
-    config: RuntimeConfig
-  ): Promise<string>;
-
-  /**
-   * Validate provider can be used (API key exists, etc.)
-   */
-  validate(): boolean;
-}
-
-/**
- * Context for step code generation
- */
-export interface StepContext {
-  selectors: Record<string, any>;
-  testData: Record<string, any>;
-  examples: string[];
-}
-
-/**
- * AI Provider Factory
- */
-export class AIProviderFactory {
-  /**
-   * Create AI provider instance
-   */
-  static create(type: 'anthropic' | 'openai' | 'copilot', config: RuntimeConfig): AIProvider {
-    switch (type) {
-      case 'anthropic':
-        const AnthropicProvider = require('./anthropic-provider').AnthropicProvider;
-        return new AnthropicProvider(config);
-
-      case 'openai':
-        throw new Error('OpenAI provider not yet implemented');
-
-      case 'copilot':
-        throw new Error('GitHub Copilot provider not yet implemented');
-
-      default:
-        throw new Error(`Unsupported AI provider: ${type}`);
-    }
-  }
-}

package/src/external/anthropic-provider.ts

@@ -1,114 +0,0 @@
-/**
- * Anthropic AI Provider
- * Uses Claude models for selector mapping and code generation
- */
-
-import Anthropic from '@anthropic-ai/sdk';
-import { AIProvider, StepContext } from './ai-provider';
-import { RuntimeConfig } from '../config/config-schema';
-import { UIModel } from '../core/ui-scanner/scanner-interface';
-import { SelectorBase } from '../core/selector-base/base-generator';
-
-// Import legacy AI mappers
-import { AIMapper } from '../generators/selector-mapper/ai-mapper';
-import { AIStepMapper } from '../generators/test-generator/ai-step-mapper';
-
-export class AnthropicProvider implements AIProvider {
-  readonly name = 'Anthropic Claude';
-  readonly type = 'anthropic' as const;
-
-  private config: RuntimeConfig;
-  private selectorMapper: AIMapper;
-  private stepMapper: AIStepMapper;
-
-  constructor(config: RuntimeConfig) {
-    this.config = config;
-
-    const apiKey = process.env[config.apis.anthropic.apiKeyEnv];
-    if (!apiKey) {
-      throw new Error(`${config.apis.anthropic.apiKeyEnv} environment variable is required`);
-    }
-
-    // Initialize legacy AI mapper
-    this.selectorMapper = new AIMapper({
-      provider: 'anthropic',
-      model: config.selectorMapping.model,
-      apiKey,
-      verbose: config.verbose
-    });
-
-    this.stepMapper = new AIStepMapper(config.verbose);
-  }
-
-  /**
-   * Map selectors using Claude Sonnet via legacy AIMapper
-   */
-  async mapSelectors(
-    uiModel: UIModel,
-    selectorBase: SelectorBase,
-    config: RuntimeConfig
-  ): Promise<SelectorBase> {
-    if (config.verbose) {
-      console.log(`  [Anthropic] Mapping selectors for screen: ${selectorBase.screen}`);
-    }
-
-    try {
-      // Prepare element IDs from selector base
-      const elementIds = Object.keys(selectorBase.elements).map(id => `[${selectorBase.screen}.${id}]`);
-
-      // Use legacy AIMapper
-      const result = await this.selectorMapper.mapSelectors({
-        uiModel: uiModel as any,  // Cast to legacy format
-        elementIds
-      });
-
-      // Merge results back to selector base
-      for (const [fullId, selectorEntry] of Object.entries(result.selectors)) {
-        // Extract element name from full ID: [screen.element] -> element
-        const elementName = fullId.replace(/\[.*?\.(.*?)\]/, '$1');
-
-        if (selectorBase.elements[elementName]) {
-          // Get selector value and normalize format
-          let selector = selectorEntry.selector || '';
-
-          // Normalize: ensure all selectors are unquoted (YAML handles quoting)
-          // Remove surrounding quotes if present
-          selector = selector.replace(/^["'](.*)["']$/, '$1');
-
-          // Assign normalized selector
-          selectorBase.elements[elementName].selector = selector;
-        }
-      }
-
-      if (config.verbose) {
-        console.log(`  [Anthropic] Mapped ${Object.keys(result.selectors).length} selectors`);
-      }
-
-      return selectorBase;
-    } catch (error) {
-      console.error(`[Anthropic] Selector mapping failed: ${error}`);
-      throw error;
-    }
-  }
-
-  /**
-   * Generate step code using Claude Haiku
-   */
-  async generateStepCode(
-    step: any,
-    context: StepContext,
-    config: RuntimeConfig
-  ): Promise<string> {
-    // Use legacy AI step mapper
-    const mapped = await this.stepMapper.mapStep(step);
-    return mapped.code;
-  }
-
-  /**
-   * Validate Anthropic provider
-   */
-  validate(): boolean {
-    const apiKey = process.env[this.config.apis.anthropic.apiKeyEnv];
-    return !!apiKey;
-  }
-}