@sun-asterisk/sungen 1.0.0

package/src/executor/playwright/playwright-generator.ts

@@ -0,0 +1,125 @@
+/**
+ * Playwright Test Generator
+ * Generates Playwright test scripts from Gherkin features
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { TestGenerator, GeneratedTest, GenerationStats } from '../test-generator';
+import { RuntimeConfig } from '../../config/config-schema';
+import { ParsedFeature } from '../../core/selector-base/gherkin-parser';
+
+// Import legacy code generator
+import { CodeGenerator as LegacyCodeGenerator } from '../../generators/test-generator/code-generator';
+
+export class PlaywrightGenerator implements TestGenerator {
+  readonly framework = 'playwright';
+
+  private config: RuntimeConfig;
+
+  constructor(config: RuntimeConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Generate Playwright test from Gherkin feature
+   */
+  async generate(
+    feature: ParsedFeature,
+    selectors: Record<string, any>,
+    testData: Record<string, any>,
+    config: RuntimeConfig
+  ): Promise<GeneratedTest> {
+    const startTime = Date.now();
+
+    // Extract screen name from feature source file
+    let screenName: string | undefined;
+    if (feature.sourceFile) {
+      const sourceDir = path.dirname(feature.sourceFile);
+      const parts = sourceDir.split(path.sep);
+      const screensIndex = parts.indexOf('screens');
+      if (screensIndex >= 0 && screensIndex < parts.length - 2) {
+        screenName = parts[screensIndex + 1];
+      }
+    }
+
+    // Create generator with screen context
+    const legacyGenerator = new LegacyCodeGenerator({
+      useAI: config.testGenerator.enableAIFallback,
+      verbose: config.verbose,
+      screenName: screenName
+    });
+
+    // Use legacy generator
+    const outputDir = config.paths.specsDir;
+    const result = await legacyGenerator.generateTest(feature, outputDir);
+
+    // Write the test file (legacy generator doesn't auto-write)
+    legacyGenerator.writeTest(result);
+
+    // Build stats
+    const stats: GenerationStats = {
+      totalScenarios: feature.scenarios.length,
+      totalSteps: this.countSteps(feature),
+      dictionaryMatched: 0, // Not tracked by legacy
+      aiGenerated: 0,       // Not tracked by legacy
+      todoCount: this.countTodos(result.code),
+      generationTime: Date.now() - startTime
+    };
+
+    return {
+      feature: feature.name,
+      outputPath: result.filePath,  // Legacy uses 'filePath' not 'outputPath'
+      code: result.code,
+      stats
+    };
+  }
+
+  /**
+   * Get file extension for Playwright tests
+   */
+  getFileExtension(): string {
+    return '.spec.ts';
+  }
+
+  /**
+   * Validate Playwright generator
+   */
+  validate(): boolean {
+    // Check if output directory exists or can be created
+    const outputDir = this.config.paths.specsDir;
+    try {
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Count total steps in feature
+   */
+  private countSteps(feature: ParsedFeature): number {
+    let count = 0;
+
+    if (feature.background) {
+      count += feature.background.steps.length;
+    }
+
+    for (const scenario of feature.scenarios) {
+      count += scenario.steps.length;
+    }
+
+    return count;
+  }
+
+  /**
+   * Count TODO comments in generated code
+   */
+  private countTodos(code: string): number {
+    const matches = code.match(/\/\/ TODO/g);
+    return matches ? matches.length : 0;
+  }
+}

package/src/executor/test-generator.ts

@@ -0,0 +1,90 @@
+/**
+ * Test Generator Interface
+ * Defines contract for test framework code generators
+ */
+
+import { RuntimeConfig } from '../config/config-schema';
+import { ParsedFeature } from '../core/selector-base/gherkin-parser';
+
+/**
+ * Main Test Generator Interface
+ */
+export interface TestGenerator {
+  /**
+   * Framework name
+   */
+  readonly framework: string;
+
+  /**
+   * Generate test script from Gherkin feature
+   *
+   * @param feature - Parsed Gherkin feature
+   * @param selectors - Final selectors (AI + overrides)
+   * @param testData - Test data
+   * @param config - Runtime configuration
+   * @returns Generated test script information
+   */
+  generate(
+    feature: ParsedFeature,
+    selectors: Record<string, any>,
+    testData: Record<string, any>,
+    config: RuntimeConfig
+  ): Promise<GeneratedTest>;
+
+  /**
+   * Get output file extension
+   */
+  getFileExtension(): string;
+
+  /**
+   * Validate generator can run
+   */
+  validate(): boolean;
+}
+
+/**
+ * Generated Test Result
+ */
+export interface GeneratedTest {
+  feature: string;
+  outputPath: string;
+  code: string;
+  stats: GenerationStats;
+}
+
+/**
+ * Generation Statistics
+ */
+export interface GenerationStats {
+  totalScenarios: number;
+  totalSteps: number;
+  dictionaryMatched: number;
+  aiGenerated: number;
+  todoCount: number;
+  generationTime: number;
+}
+
+/**
+ * Test Generator Factory
+ */
+export class TestGeneratorFactory {
+  /**
+   * Create test generator instance
+   */
+  static create(framework: string, config: RuntimeConfig): TestGenerator {
+    switch (framework) {
+      case 'playwright':
+        const PlaywrightGenerator = require('./playwright/playwright-generator').PlaywrightGenerator;
+        return new PlaywrightGenerator(config);
+
+      case 'appium':
+        throw new Error('Appium generator not yet implemented');
+
+      case 'integration':
+        throw new Error('Integration test generator not yet implemented');
+
+      default:
+        throw new Error(`Unsupported test framework: ${framework}`);
+    }
+  }
+}

package/src/external/ai-provider.ts

@@ -0,0 +1,90 @@
+/**
+ * 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

@@ -0,0 +1,114 @@
+/**
+ * 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;
+  }
+}