@sun-asterisk/sungen 1.0.0

package/src/cli/index.ts

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * Sungen CLI - AI-Native E2E Test Generator
+ * Command-line interface for generating E2E tests from Gherkin features
+ */
+
+import { CLIAdapter } from '../input/cli-adapter';
+import { ConfigLoader } from '../config/config-loader';
+import { Pipeline } from '../orchestrator/pipeline';
+import { CacheManager } from '../orchestrator/cache-manager';
+
+async function main() {
+  const adapter = new CLIAdapter();
+  const program = adapter.createProgram();
+
+  // Add commands
+  const discoverCmd = adapter.addDiscoverCommand(program);
+  discoverCmd.action(async (options) => {
+    try {
+      const cliOptions = {
+        ...program.opts(),
+        ...options
+      };
+      const config = new ConfigLoader().load(cliOptions);
+      const pipeline = new Pipeline(config);
+
+      if (options.screen) {
+        await pipeline.runDiscovery(options.screen);
+      } else {
+        console.error('❌ Error: --screen parameter is required');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('❌ Discovery failed:', error);
+      process.exit(1);
+    }
+  });
+
+  const mapCmd = adapter.addMapCommand(program);
+  mapCmd.action(async (options) => {
+    try {
+      const cliOptions = {
+        ...program.opts(),
+        ...options
+      };
+      const config = new ConfigLoader().load(cliOptions);
+      const { ScaffoldGenerator } = require('../generators/scaffold-generator');
+      const path = require('path');
+
+      const generator = new ScaffoldGenerator();
+
+      if (options.screen) {
+        // Process screen folder: qa/screens/<screen>/features/
+        const screensDir = options.output || 'qa/screens';
+        const forceOverwrite = cliOptions.force || false;
+        
+        if (forceOverwrite) {
+          console.log(`Mapping screen: ${options.screen} (force overwrite enabled)\n`);
+        } else {
+          console.log(`Mapping screen: ${options.screen}\n`);
+        }
+        
+        const results = generator.processScreen(options.screen, screensDir, forceOverwrite);
+        
+        for (const result of results) {
+          console.log(`✓ Mapped ${result.featureFile}.feature`);
+          
+          // Show selector status
+          if (result.selectorsSkipped) {
+            console.log(`   ⊘ ${path.basename(result.selectorsPath)} (skipped - already exists)`);
+          } else {
+            console.log(`   → ${path.basename(result.selectorsPath)} (${result.elementCount} elements)`);
+          }
+          
+          // Show test data status
+          if (result.testDataSkipped) {
+            console.log(`   ⊘ ${path.basename(result.testDataPath)} (skipped - already exists)\n`);
+          } else {
+            console.log(`   → ${path.basename(result.testDataPath)} (${result.dataRefCount} variables)\n`);
+          }
+        }
+        
+        console.log(`Next step: sungen generate --screen ${options.screen}`);
+        console.log('     This will create the test specs based on the mapped selectors and test data.');
+      } else if (options.file) {
+        // Process single feature file (legacy mode)
+        const outputDir = options.output || path.join(config.paths.selectorsDir, 'screens');
+        const forceOverwrite = cliOptions.force || false;
+        console.log(`🗺️  Mapping from file: ${options.file}`);
+        const result = generator.processFeatureFile(options.file, outputDir, forceOverwrite);
+        console.log(`✅ Generated: ${result.outputPath} (${result.elementCount} elements)`);
+      } else {
+        console.error('❌ Error: Please specify --screen <name> or --file <path>');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('❌ Mapping failed:', error);
+      process.exit(1);
+    }
+  });
+
+  const genCmd = adapter.addGenerateCommand(program);
+  genCmd.action(async (options) => {
+    try {
+      const cliOptions = {
+        ...program.opts(),
+        ...options
+      };
+      const config = new ConfigLoader().load(cliOptions);
+      const pipeline = new Pipeline(config);
+
+      await pipeline.runTestGeneration(options.screen);
+    } catch (error) {
+      console.error('❌ Test generation failed:', error);
+      process.exit(1);
+    }
+  });
+
+  const fullCmd = adapter.addFullCommand(program);
+  fullCmd.action(async (options) => {
+    try {
+      const cliOptions = {
+        ...program.opts(),
+        ...options
+      };
+      const config = new ConfigLoader().load(cliOptions);
+      const pipeline = new Pipeline(config);
+
+      const screens = options.screen ? [options.screen] : undefined;
+      await pipeline.runFull(screens);
+    } catch (error) {
+      console.error('❌ Full pipeline failed:', error);
+      process.exit(1);
+    }
+  });
+
+  const initCmd = adapter.addInitCommand(program);
+  initCmd.action(async (options) => {
+    try {
+      const { ProjectInitializer } = require('../orchestrator/project-initializer');
+      const initializer = new ProjectInitializer();
+      await initializer.initialize();
+    } catch (error) {
+      console.error('❌ Init failed:', error);
+      process.exit(1);
+    }
+  });
+
+  const cacheCmd = adapter.addCacheCommand(program);
+  cacheCmd.action(async (options) => {
+    try {
+      const config = new ConfigLoader().load(adapter.extractOptions(cacheCmd));
+      const cacheManager = new CacheManager(config);
+
+      console.log('🗑️  Clearing cache...');
+      await cacheManager.clear();
+      console.log('✅ Cache cleared successfully');
+    } catch (error) {
+      console.error('❌ Cache clear failed:', error);
+      process.exit(1);
+    }
+  });
+
+  const autoTagCmd = adapter.addAutoTagCommand(program);
+  autoTagCmd.action(async (options) => {
+    try {
+      const cliOptions = {
+        ...program.opts(),
+        ...options
+      };
+      const config = new ConfigLoader().load(cliOptions);
+      const { createAutoTagCommand } = require('./commands/auto-tag-command');
+
+      await createAutoTagCommand(config).parseAsync(['node', 'sungen', ...process.argv.slice(3)]);
+    } catch (error) {
+      console.error('❌ Auto-tagging failed:', error);
+      process.exit(1);
+    }
+  });
+
+  const addScreenCmd = adapter.addAddScreenCommand(program);
+  addScreenCmd.action(async (options) => {
+    try {
+      const { ScreenManager } = require('../orchestrator/screen-manager');
+      const manager = new ScreenManager();
+
+      await manager.addScreen({
+        name: options.screen,
+        path: options.path,
+        description: options.description
+      });
+    } catch (error) {
+      console.error('❌ Add screen failed:', error);
+      process.exit(1);
+    }
+  });
+
+  // Parse arguments
+  await program.parseAsync(process.argv);
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/src/config/ai-providers.yaml

@@ -0,0 +1,56 @@
+# AI Provider Configuration
+
+providers:
+  # Claude - Best for DSL generation (cheap + fast)
+  claude:
+    generation:
+      model: "claude-3-haiku-20240307"
+      temperature: 0.2
+      maxTokens: 2048
+    vision:
+      model: "claude-3-sonnet-20240229"
+      temperature: 0.3
+      maxTokens: 4096
+
+  # OpenAI - Best for vision tasks
+  openai:
+    generation:
+      model: "gpt-4o-mini"
+      temperature: 0.2
+      maxTokens: 2048
+    vision:
+      model: "gpt-4o"
+      temperature: 0.3
+      maxTokens: 4096
+
+  # Gemini - Alternative provider
+  gemini:
+    generation:
+      model: "gemini-1.5-flash"
+      temperature: 0.2
+      maxTokens: 2048
+    vision:
+      model: "gemini-1.5-pro"
+      temperature: 0.3
+      maxTokens: 4096
+
+# Default provider for each task type
+defaults:
+  generation: "claude"
+  vision: "openai"
+  analysis: "claude"
+
+# Cost optimization (estimated cost per 1M tokens)
+costs:
+  claude-haiku:
+    input: 0.25
+    output: 1.25
+  gpt-4o-mini:
+    input: 0.15
+    output: 0.60
+  gpt-4o:
+    input: 2.50
+    output: 10.00
+  gemini-flash:
+    input: 0.075
+    output: 0.30

package/src/config/config-loader.ts

@@ -0,0 +1,248 @@
+/**
+ * Configuration Loader
+ * Loads and merges configuration from multiple sources with priority:
+ * CLI Options > Custom Config File > Default Config File
+ */
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import { FrameworkConfig, CLIOptions, RuntimeConfig } from './config-schema';
+
+export class ConfigLoader {
+  private defaultConfigPath: string;
+
+  constructor() {
+    this.defaultConfigPath = path.join(__dirname, 'default.config.yaml');
+  }
+
+  /**
+   * Load runtime configuration with priority merging
+   * Priority: CLI > Custom File > Default File
+   */
+  load(cliOptions: CLIOptions = {}): RuntimeConfig {
+    // 1. Load default config
+    const defaultConfig = this.loadDefaultConfig();
+
+    // 2. Load custom config file if specified, or look for sungen.config.yaml in CWD
+    let fileConfig: Partial<FrameworkConfig> = {};
+    let configSource: 'default' | 'file' | 'cli' = 'default';
+
+    if (cliOptions.config) {
+      fileConfig = this.loadCustomConfig(cliOptions.config);
+      configSource = 'file';
+    } else {
+      // Try to load sungen.config.yaml from current working directory
+      const defaultConfigPath = path.join(process.cwd(), 'sungen.config.yaml');
+      if (fs.existsSync(defaultConfigPath)) {
+        fileConfig = this.loadCustomConfig(defaultConfigPath);
+        configSource = 'file';
+      }
+    }
+
+    // 3. Merge configs: default < file < CLI
+    const mergedConfig = this.mergeConfigs(defaultConfig, fileConfig, cliOptions);
+
+    // Override source if CLI has significant options
+    if (Object.keys(cliOptions).length > 0) {
+      configSource = 'cli';
+    }
+
+    return {
+      ...mergedConfig,
+      cliOptions,
+      configSource
+    };
+  }
+
+  /**
+   * Load default configuration from default.config.yaml
+   */
+  private loadDefaultConfig(): FrameworkConfig {
+    try {
+      const content = fs.readFileSync(this.defaultConfigPath, 'utf-8');
+      return yaml.parse(content) as FrameworkConfig;
+    } catch (error) {
+      throw new Error(`Failed to load default config: ${error}`);
+    }
+  }
+
+  /**
+   * Load custom configuration file
+   */
+  private loadCustomConfig(configPath: string): Partial<FrameworkConfig> {
+    try {
+      const fullPath = path.resolve(configPath);
+
+      if (!fs.existsSync(fullPath)) {
+        throw new Error(`Config file not found: ${fullPath}`);
+      }
+
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      return yaml.parse(content) as Partial<FrameworkConfig>;
+    } catch (error) {
+      throw new Error(`Failed to load custom config: ${error}`);
+    }
+  }
+
+  /**
+   * Merge configurations with priority: CLI > File > Default
+   */
+  private mergeConfigs(
+    defaultConfig: FrameworkConfig,
+    fileConfig: Partial<FrameworkConfig>,
+    cliOptions: CLIOptions
+  ): FrameworkConfig {
+    // Deep merge default + file config
+    const merged = this.deepMerge(defaultConfig, fileConfig);
+
+    // Apply CLI overrides (highest priority)
+    if (cliOptions.verbose !== undefined) {
+      merged.verbose = cliOptions.verbose;
+    }
+
+    if (cliOptions.force !== undefined) {
+      merged.force = cliOptions.force;
+    }
+
+    if (cliOptions.depth !== undefined) {
+      merged.scanner.maxDepth = cliOptions.depth;
+    }
+
+    if (cliOptions.aiMapper !== undefined) {
+      merged.testGenerator.enableAIFallback = cliOptions.aiMapper;
+    }
+
+    if (cliOptions.framework !== undefined) {
+      merged.testGenerator.framework = cliOptions.framework;
+    }
+
+    // Selector mapping mode overrides
+    if (cliOptions.mode !== undefined) {
+      merged.selectorMapping.mode = cliOptions.mode;
+    }
+
+    return merged;
+  }
+
+  /**
+   * Deep merge two objects
+   */
+  private deepMerge<T>(target: T, source: Partial<T>): T {
+    const result = { ...target };
+
+    for (const key in source) {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+
+      if (sourceValue === undefined) {
+        continue;
+      }
+
+      if (this.isObject(sourceValue) && this.isObject(targetValue)) {
+        result[key] = this.deepMerge(targetValue, sourceValue as any);
+      } else {
+        result[key] = sourceValue as any;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if value is a plain object
+   */
+  private isObject(value: any): value is Record<string, any> {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+  }
+
+  /**
+   * Validate configuration
+   */
+  validate(config: RuntimeConfig): void {
+    const errors: string[] = [];
+
+    // Validate required paths
+    if (!config.paths.sourceRoot) {
+      errors.push('paths.sourceRoot is required');
+    }
+
+    // Validate scanner
+    if (!['react', 'vue', 'angular'].includes(config.scanner.framework)) {
+      errors.push(`Invalid scanner.framework: ${config.scanner.framework}`);
+    }
+
+    if (config.scanner.maxDepth < 1) {
+      errors.push('scanner.maxDepth must be >= 1');
+    }
+
+    // Validate AI provider
+    if (!['anthropic', 'copilot', 'openai'].includes(config.selectorMapping.aiProvider)) {
+      errors.push(`Invalid selectorMapping.aiProvider: ${config.selectorMapping.aiProvider}`);
+    }
+
+    // Validate test framework
+    if (!['playwright', 'appium', 'integration'].includes(config.testGenerator.framework)) {
+      errors.push(`Invalid testGenerator.framework: ${config.testGenerator.framework}`);
+    }
+
+    if (errors.length > 0) {
+      throw new Error(`Configuration validation failed:\n${errors.join('\n')}`);
+    }
+  }
+
+  /**
+   * Get configuration value by path (dot notation)
+   * Example: get('scanner.maxDepth')
+   */
+  get(config: RuntimeConfig, path: string): any {
+    return path.split('.').reduce((obj, key) => obj?.[key], config as any);
+  }
+
+  /**
+   * Display current configuration (for debugging)
+   */
+  display(config: RuntimeConfig): string {
+    const displayed = {
+      version: config.version,
+      source: config.configSource,
+      verbose: config.verbose,
+      force: config.force,
+      scanner: {
+        framework: config.scanner.framework,
+        maxDepth: config.scanner.maxDepth
+      },
+      selectorMapping: {
+        aiProvider: config.selectorMapping.aiProvider,
+        model: config.selectorMapping.model
+      },
+      testGenerator: {
+        framework: config.testGenerator.framework,
+        aiProvider: config.testGenerator.aiProvider,
+        enableAIFallback: config.testGenerator.enableAIFallback
+      },
+      cache: {
+        enabled: config.cache.enabled
+      }
+    };
+
+    return yaml.stringify(displayed);
+  }
+}
+
+// Singleton instance
+let configLoader: ConfigLoader;
+
+export function getConfigLoader(): ConfigLoader {
+  if (!configLoader) {
+    configLoader = new ConfigLoader();
+  }
+  return configLoader;
+}
+
+export function loadConfig(cliOptions: CLIOptions = {}): RuntimeConfig {
+  const loader = getConfigLoader();
+  const config = loader.load(cliOptions);
+  loader.validate(config);
+  return config;
+}

package/src/config/config-schema.ts

@@ -0,0 +1,148 @@
+/**
+ * Configuration Schema
+ * TypeScript types for framework configuration
+ */
+
+export interface FrameworkConfig {
+  version: string;
+  verbose: boolean;
+  force: boolean;
+
+  paths: PathsConfig;
+  scanner: ScannerConfig;
+  selectorMapping: SelectorMappingConfig;
+  annotations: AnnotationsConfig;
+  testGenerator: TestGeneratorConfig;
+  cache: CacheConfig;
+  apis: ApisConfig;
+  app: AppConfig;
+}
+
+export interface PathsConfig {
+  sourceRoot: string;
+  featuresDir: string;
+  testDataDir: string;
+  uiModelsDir: string;
+  selectorsDir: string;
+  specsDir: string;
+  cacheDir: string;
+}
+
+export interface ScannerConfig {
+  framework: 'react' | 'vue' | 'angular';
+  maxDepth: number;
+  includePatterns: string[];
+  excludePatterns: string[];
+
+  // v3.1 - Strict Mode
+  strictMode?: boolean;                    // Enable strict filtering
+  filterRules?: {
+    allowedTags?: string[];                // Interactive tags only
+    requireAttributes?: string[];          // Must have data-testid or role
+    allowGenericWithId?: boolean;          // Allow div/span with id
+  };
+}
+
+export interface SelectorMappingConfig {
+  mode: 'hybrid' | 'ai-only' | 'heuristic-only';
+  aiProvider: AIProvider;
+  model: string;
+  maxTokens: number;
+  temperature: number;
+  enableOverride: boolean;
+  heuristicFirst: boolean;
+  minHeuristicConfidence: number;
+
+  // v3.1 - Priority-based Mapping
+  strategy?: 'priority-waterfall' | 'hybrid';  // NEW: Priority waterfall
+  priorities?: ('direct-id' | 'accessibility' | 'heuristic-ai')[];
+  confidenceThreshold?: number;                // Min confidence (0.0-1.0)
+}
+
+export interface AnnotationsConfig {
+  selectorId: AnnotationDefinition;
+  dataRef: AnnotationDefinition;
+  ignore: AnnotationDefinition;
+  ignoreTestCase: AnnotationDefinition;
+  skipProduction: AnnotationDefinition;
+  [key: string]: AnnotationDefinition;
+}
+
+export interface AnnotationDefinition {
+  pattern: string;
+  description: string;
+}
+
+export interface TestGeneratorConfig {
+  framework: TestFramework;
+  aiProvider: AIProvider;
+  model: string;
+  maxTokens: number;
+  temperature: number;
+  enableAIFallback: boolean;
+  dictionaryPath: string;
+}
+
+export interface CacheConfig {
+  enabled: boolean;
+  ttl: number;
+  invalidateOnSourceChange: boolean;
+  invalidateOnConfigChange: boolean;
+}
+
+export interface ApisConfig {
+  anthropic: APIProviderConfig;
+  openai: APIProviderConfig;
+  copilot: CopilotConfig;
+}
+
+export interface APIProviderConfig {
+  baseURL: string;
+  apiKeyEnv: string;
+  timeout: number;
+}
+
+export interface CopilotConfig {
+  enabled: boolean;
+}
+
+export interface AppConfig {
+  baseURL: string;
+  timeout: number;
+}
+
+export type AIProvider = 'anthropic' | 'copilot' | 'openai';
+export type TestFramework = 'playwright' | 'appium' | 'integration';
+
+/**
+ * CLI Options (can override config file values)
+ */
+export interface CLIOptions {
+  // Discovery options
+  screen?: string;
+  depth?: number;
+  force?: boolean;
+
+  // Generation options
+  aiMapper?: boolean;
+  framework?: TestFramework;
+
+  // Selector mapping options
+  mode?: 'hybrid' | 'ai-only' | 'heuristic-only';
+  aiOnly?: boolean;
+  heuristicOnly?: boolean;
+
+  // Global options
+  verbose?: boolean;
+  config?: string;  // Path to custom config file
+}
+
+/**
+ * Merged Runtime Configuration
+ * Result of merging: default config + file config + CLI options
+ */
+export interface RuntimeConfig extends FrameworkConfig {
+  // Additional runtime fields
+  cliOptions: CLIOptions;
+  configSource: 'default' | 'file' | 'cli';
+}