@sun-asterisk/sungen 1.0.24 → 2.0.0

package/src/generators/selector-mapper/hybrid-mapper.ts

@@ -1,427 +0,0 @@
-/**
- * Hybrid Selector Mapper
- * Combines heuristic matching (fast, free) with AI fallback (slow, accurate)
- *
- * Strategy:
- * 1. Try heuristic matching (90% success, 0 cost, instant)
- * 2. Fallback to AI mapping (10% cases, paid, 2-5s)
- *
- * Benefits:
- * - 90% cost reduction
- * - 10x faster mapping
- * - Deterministic results for common elements
- */
-
-import { AIMapper, AIMapperConfig } from './ai-mapper';
-import { UIModel, UIElement, SelectorDSL, SelectorEntry } from '../types';
-
-// ============================================================================
-// Heuristic Matcher
-// ============================================================================
-
-interface HeuristicMatch {
-  selector: string;
-  confidence: number; // 0.0 to 1.0
-  method: 'exact-testid' | 'exact-id' | 'pattern' | 'context' | 'none';
-  reason?: string;
-}
-
-class HeuristicMatcher {
-  /**
-   * Try to map element ID to selector using heuristics
-   */
-  static match(elementId: string, uiElements: UIElement[]): HeuristicMatch {
-    // Remove brackets if present: [login.email] -> login.email
-    const cleanId = elementId.replace(/[\[\]]/g, '');
-    // Extract element name: login.email -> email
-    const parts = cleanId.split('.');
-    const elementName = parts.length > 1 ? parts[parts.length - 1] : cleanId;
-
-    // Strategy 1: Exact data-testid match (highest confidence)
-    const testIdMatch = this.matchByTestId(elementName, uiElements);
-    if (testIdMatch.confidence > 0.95) return testIdMatch;
-
-    // Strategy 2: Exact id attribute match
-    const idMatch = this.matchById(elementName, uiElements);
-    if (idMatch.confidence > 0.9) return idMatch;
-
-    // Strategy 3: Pattern matching (email, password, submit...)
-    const patternMatch = this.matchByPattern(elementName, uiElements);
-    if (patternMatch.confidence > 0.85) return patternMatch;
-
-    // Strategy 4: Context-aware matching
-    const contextMatch = this.matchByContext(elementName, uiElements);
-    if (contextMatch.confidence > 0.8) return contextMatch;
-
-    // No confident match - send to AI
-    return {
-      selector: '',
-      confidence: 0,
-      method: 'none',
-      reason: 'No heuristic match found, needs AI mapping'
-    };
-  }
-
-  /**
-   * Strategy 1: data-testid exact or partial match
-   */
-  private static matchByTestId(elementName: string, elements: UIElement[]): HeuristicMatch {
-    const normalized = elementName.toLowerCase().replace(/[-_]/g, '');
-
-    for (const el of elements) {
-      const testId = el.testId;
-      if (!testId) continue;
-
-      const testIdNorm = testId.toLowerCase().replace(/[-_]/g, '');
-
-      // Exact match
-      if (testIdNorm === normalized) {
-        return {
-          selector: `[data-testid="${testId}"]`,
-          confidence: 1.0,
-          method: 'exact-testid',
-          reason: `Exact match: ${elementName} → ${testId}`
-        };
-      }
-
-      // Partial match (testid contains element name)
-      if (testIdNorm.includes(normalized)) {
-        return {
-          selector: `[data-testid="${testId}"]`,
-          confidence: 0.95,
-          method: 'exact-testid',
-          reason: `Partial match: ${elementName} in ${testId}`
-        };
-      }
-    }
-
-    return { selector: '', confidence: 0, method: 'none' };
-  }
-
-  /**
-   * Strategy 2: id attribute match
-   */
-  private static matchById(elementName: string, elements: UIElement[]): HeuristicMatch {
-    const normalized = elementName.toLowerCase().replace(/[-_]/g, '');
-
-    for (const el of elements) {
-      const id = el.id;
-      if (!id) continue;
-
-      const idNorm = id.toLowerCase().replace(/[-_]/g, '');
-
-      // Exact match
-      if (idNorm === normalized) {
-        return {
-          selector: `#${id}`,
-          confidence: 0.95,
-          method: 'exact-id',
-          reason: `Exact id match: ${elementName} → #${id}`
-        };
-      }
-
-      // Partial match
-      if (idNorm.includes(normalized) || normalized.includes(idNorm)) {
-        return {
-          selector: `#${id}`,
-          confidence: 0.9,
-          method: 'exact-id',
-          reason: `Partial id match: ${elementName} ≈ #${id}`
-        };
-      }
-    }
-
-    return { selector: '', confidence: 0, method: 'none' };
-  }
-
-  /**
-   * Strategy 3: Pattern matching for common elements
-   */
-  private static matchByPattern(elementName: string, elements: UIElement[]): HeuristicMatch {
-    const patterns = [
-      {
-        name: 'email-input',
-        keywords: ['email', 'mail'],
-        confidence: 0.9,
-        matches: (el: UIElement) =>
-          el.tag === 'input' &&
-          (el.props?.type === 'email' || el.id?.includes('email'))
-      },
-      {
-        name: 'password-input',
-        keywords: ['password', 'pass', 'pw'],
-        confidence: 0.9,
-        matches: (el: UIElement) =>
-          el.tag === 'input' && el.props?.type === 'password'
-      },
-      {
-        name: 'submit-button',
-        keywords: ['submit', 'btn', 'button', 'login', 'register', 'signin', 'signup'],
-        confidence: 0.85,
-        matches: (el: UIElement) =>
-          el.tag === 'button' && el.props?.type === 'submit'
-      },
-      {
-        name: 'textarea',
-        keywords: ['message', 'textarea', 'text', 'input', 'comment'],
-        confidence: 0.8,
-        matches: (el: UIElement) =>
-          el.tag === 'textarea'
-      }
-    ];
-
-    const nameLower = elementName.toLowerCase();
-
-    for (const pattern of patterns) {
-      if (!pattern.keywords.some(kw => nameLower.includes(kw))) continue;
-
-      // Find matching element
-      for (const el of elements) {
-        if (!pattern.matches(el)) continue;
-
-        return {
-          selector: this.buildSelector(el),
-          confidence: pattern.confidence,
-          method: 'pattern',
-          reason: `Pattern match: ${elementName} → ${pattern.name}`
-        };
-      }
-    }
-
-    return { selector: '', confidence: 0, method: 'none' };
-  }
-
-  /**
-   * Strategy 4: Context-aware matching
-   */
-  private static matchByContext(elementName: string, elements: UIElement[]): HeuristicMatch {
-    const nameLower = elementName.toLowerCase();
-
-    // Submit buttons
-    if (nameLower.includes('submit') || nameLower.includes('login') || nameLower.includes('register')) {
-      const submitBtn = elements.find(el =>
-        el.tag === 'button' &&
-        el.props?.type === 'submit'
-      );
-
-      if (submitBtn) {
-        return {
-          selector: this.buildSelector(submitBtn),
-          confidence: 0.85,
-          method: 'context',
-          reason: `Context: ${elementName} matched submit button`
-        };
-      }
-    }
-
-    // Links (signup, login, etc.)
-    if (nameLower.includes('link')) {
-      const link = elements.find(el => el.tag === 'a');
-      if (link) {
-        return {
-          selector: this.buildSelector(link),
-          confidence: 0.8,
-          method: 'context',
-          reason: `Context: ${elementName} matched link`
-        };
-      }
-    }
-
-    return { selector: '', confidence: 0, method: 'none' };
-  }
-
-  /**
-   * Build selector from UI element
-   */
-  private static buildSelector(el: UIElement): string {
-    // Prefer data-testid
-    if (el.testId) {
-      return `[data-testid="${el.testId}"]`;
-    }
-
-    // Then id
-    if (el.id) {
-      return `#${el.id}`;
-    }
-
-    // Then type
-    if (el.tag && el.props?.type) {
-      return `${el.tag}[type="${el.props.type}"]`;
-    }
-
-    // Fallback to tag
-    return el.tag || 'div';
-  }
-}
-
-// ============================================================================
-// Hybrid Mapper Class
-// ============================================================================
-
-export interface HybridMapperConfig extends AIMapperConfig {
-  heuristicFirst?: boolean; // Default: true
-  minHeuristicConfidence?: number; // Default: 0.8
-}
-
-export interface HybridMappingStats {
-  total: number;
-  heuristicMatches: number;
-  aiMatches: number;
-  heuristicSuccessRate: number;
-  estimatedCost: number;
-  estimatedTime: number;
-}
-
-export class HybridMapper {
-  private aiMapper: AIMapper;
-  private config: HybridMapperConfig;
-  private stats: HybridMappingStats;
-
-  constructor(config: HybridMapperConfig) {
-    this.config = {
-      heuristicFirst: true,
-      minHeuristicConfidence: 0.8,
-      ...config
-    };
-    this.aiMapper = new AIMapper(config);
-    this.stats = {
-      total: 0,
-      heuristicMatches: 0,
-      aiMatches: 0,
-      heuristicSuccessRate: 0,
-      estimatedCost: 0,
-      estimatedTime: 0
-    };
-  }
-
-  /**
-   * Map element IDs to selectors using hybrid approach
-   */
-  async mapSelectors(uiModel: UIModel, elementIds: string[]): Promise<SelectorDSL> {
-    const startTime = Date.now();
-    this.stats.total = elementIds.length;
-
-    if (this.config.verbose) {
-      console.log('\n🔄 Hybrid Mapping Strategy:');
-      console.log(`  Total elements: ${elementIds.length}`);
-      console.log(`  Trying heuristics first...`);
-    }
-
-    // Prepare result structure
-    const result: SelectorDSL = {};
-
-    // Track which elements need AI mapping
-    const needsAI: string[] = [];
-    const heuristicResults: Record<string, HeuristicMatch> = {};
-
-    // Step 1: Try heuristic matching for all elements
-    for (const elementId of elementIds) {
-      const match = HeuristicMatcher.match(elementId, uiModel.elements);
-
-      if (match.confidence >= this.config.minHeuristicConfidence!) {
-        // Heuristic success!
-        const cleanId = elementId.replace(/[\[\]]/g, '').split('.').pop() || elementId;
-        result[cleanId] = {
-          selector: match.selector,
-          type: 'selector',
-          description: `Matched by heuristic: ${match.method}`,
-          discoveryMethod: 'ai-static-analysis',
-          confidence: match.confidence >= 0.9 ? 'high' : match.confidence >= 0.8 ? 'medium' : 'low'
-        };
-        heuristicResults[elementId] = match;
-        this.stats.heuristicMatches++;
-
-        if (this.config.verbose) {
-          console.log(`  ✅ [Heuristic] ${elementId} → ${match.selector} (${match.method}, ${match.confidence.toFixed(2)})`);
-        }
-      } else {
-        // Need AI
-        needsAI.push(elementId);
-        if (this.config.verbose) {
-          console.log(`  ⏭️  [Needs AI] ${elementId} (heuristic confidence: ${match.confidence.toFixed(2)})`);
-        }
-      }
-    }
-
-    // Step 2: Use AI for remaining elements
-    if (needsAI.length > 0) {
-      if (this.config.verbose) {
-        console.log(`\n🤖 Calling AI for ${needsAI.length} elements...`);
-      }
-
-      const aiResult = await this.aiMapper.mapSelectors({
-        uiModel,
-        elementIds: needsAI
-      });
-
-      // Merge AI results (aiResult.selectors contains the SelectorDSL)
-      for (const [key, value] of Object.entries(aiResult.selectors)) {
-        result[key] = value;
-      }
-
-      this.stats.aiMatches = needsAI.length;
-      this.stats.estimatedCost = (needsAI.length * 0.002); // ~$0.002 per element
-    }
-
-    // Calculate stats
-    const endTime = Date.now();
-    this.stats.heuristicSuccessRate = (this.stats.heuristicMatches / this.stats.total) * 100;
-    this.stats.estimatedTime = endTime - startTime;
-
-    // Print summary
-    if (this.config.verbose) {
-      console.log('\n📊 Mapping Stats:');
-      console.log(`  Total: ${this.stats.total}`);
-      console.log(`  Heuristic: ${this.stats.heuristicMatches} (${this.stats.heuristicSuccessRate.toFixed(1)}%)`);
-      console.log(`  AI: ${this.stats.aiMatches} (${(100 - this.stats.heuristicSuccessRate).toFixed(1)}%)`);
-      console.log(`  Cost: ~$${this.stats.estimatedCost.toFixed(3)}`);
-      console.log(`  Time: ${this.stats.estimatedTime}ms`);
-      console.log(`  Savings: ~${(this.stats.heuristicSuccessRate).toFixed(0)}% cost reduction`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Get mapping statistics
-   */
-  getStats(): HybridMappingStats {
-    return { ...this.stats };
-  }
-
-  /**
-   * Reset statistics
-   */
-  resetStats(): void {
-    this.stats = {
-      total: 0,
-      heuristicMatches: 0,
-      aiMatches: 0,
-      heuristicSuccessRate: 0,
-      estimatedCost: 0,
-      estimatedTime: 0
-    };
-  }
-}
-
-/**
- * Example Usage:
- *
- * const mapper = new HybridMapper({
- *   provider: 'anthropic',
- *   apiKey: process.env.ANTHROPIC_API_KEY,
- *   verbose: true,
- *   heuristicFirst: true,
- *   minHeuristicConfidence: 0.8
- * });
- *
- * const selectors = await mapper.mapSelectors(uiModel, [
- *   '[login.email]',
- *   '[login.password]',
- *   '[login.submit]'
- * ]);
- *
- * const stats = mapper.getStats();
- * console.log(`Heuristic success: ${stats.heuristicSuccessRate}%`);
- * console.log(`Cost: $${stats.estimatedCost}`);
- */

package/src/generators/selector-mapper/index.ts

@@ -1,10 +0,0 @@
-/**
- * Selector Mapper Exports
- * Main entry point for selector mapping functionality
- */
-
-export { AIMapper, type AIMapperConfig } from './ai-mapper';
-export { HybridMapper, type HybridMapperConfig, type HybridMappingStats } from './hybrid-mapper';
-
-// Re-export for convenience
-export type { UIModel, UIElement, SelectorDSL, SelectorEntry } from '../types';