@sun-asterisk/sungen 1.0.0

package/src/input/cli-adapter.ts

@@ -0,0 +1,185 @@
+/**
+ * CLI Input Adapter
+ * Parses command-line arguments into CLIOptions
+ */
+
+import { Command } from 'commander';
+import { CLIOptions } from '../config/config-schema';
+import { InputAdapter, InputSource } from './input-adapter';
+
+export class CLIAdapter implements InputAdapter {
+  name = InputSource.CLI;
+
+  /**
+   * Parse CLI arguments into options
+   */
+  parse(argv?: string[]): CLIOptions {
+    // This will be called by commander when parsing CLI
+    // For now, return empty options (will be populated by commander)
+    return {};
+  }
+
+  /**
+   * Validate CLI arguments format
+   */
+  validate(): boolean {
+    // Commander handles validation
+    return true;
+  }
+
+  /**
+   * Create commander program with all commands
+   */
+  createProgram(): Command {
+    const program = new Command();
+
+    program
+      .name('sungen')
+      .description('AI-Native E2E Test Generator - Generate Playwright tests from Gherkin features')
+      .version('3.1.0');
+
+    // Global options
+    program
+      .option('-c, --config <path>', 'Path to custom config file')
+      .option('-v, --verbose', 'Enable verbose logging')
+      .option('-f, --force', 'Force regeneration, bypass cache');
+
+    return program;
+  }
+
+  /**
+   * Add discover command
+   */
+  addDiscoverCommand(program: Command): Command {
+    return program
+      .command('discover')
+      .description('Discover UI elements and generate UI model')
+      .requiredOption('-s, --screen <name>', 'Screen name to discover')
+      .option('-d, --depth <number>', 'Component scan depth (default: unlimited)', '999')
+      .option('-f, --force', 'Force rescan, bypass cache')
+      .option('--mode <type>', 'Mapping mode: hybrid, ai-only, heuristic-only')
+      .option('--ai-only', 'Force AI-only mapping (bypass heuristics)')
+      .option('--heuristic-only', 'Force heuristic-only mapping (no AI fallback)');
+  }
+
+  /**
+   * Add generate-tests command
+   */
+  addGenerateTestsCommand(program: Command): Command {
+    return program
+      .command('generate-tests')
+      .description('Generate E2E test scripts from Gherkin features')
+      .option('--ai-mapper', 'Enable AI fallback for unknown Gherkin patterns')
+      .option('--framework <name>', 'Test framework (playwright, appium, integration)', 'playwright');
+  }
+
+  /**
+   * Add map command (generate selector and test-data YAML from Gherkin)
+   */
+  addMapCommand(program: Command): Command {
+    return program
+      .command('map')
+      .description('Generate selector and test-data YAML from Gherkin feature files')
+      .option('-s, --screen <name>', 'Screen name (reads from qa/screens/<name>/features/)')
+      .option('--file <path>', 'Path to specific .feature file')
+      .option('-o, --output <dir>', 'Output directory for generated files')
+      .option('-f, --force', 'Force overwrite existing YAML files')
+      .option('-v, --verbose', 'Detailed output');
+  }
+
+  /**
+   * Add generate command (test code generation)
+   */
+  addGenerateCommand(program: Command): Command {
+    return program
+      .command('generate')
+      .description('Generate Playwright test code from features')
+      .option('--ai-mapper', 'Enable AI fallback for unknown Gherkin patterns')
+      .option('--framework <name>', 'Test framework (playwright, appium, integration)', 'playwright')
+      .option('-s, --screen <name>', 'Filter generation to specific screen')
+      .option('-f, --force', 'Force regeneration, bypass cache');
+  }
+
+  /**
+   * Add full command
+   */
+  addFullCommand(program: Command): Command {
+    return program
+      .command('full')
+      .description('Run full pipeline (discover + map + generate)')
+      .option('-s, --screen <name>', 'Process specific screen (optional)')
+      .option('-d, --depth <number>', 'Component scan depth (default: unlimited)', '999')
+      .option('-f, --force', 'Force regeneration, bypass cache')
+      .option('--mode <type>', 'Mapping mode: hybrid, ai-only, heuristic-only')
+      .option('--ai-only', 'Force AI-only mapping (bypass heuristics)')
+      .option('--heuristic-only', 'Force heuristic-only mapping (no AI fallback)');
+  }
+
+  /**
+   * Add init command
+   */
+  addInitCommand(program: Command): Command {
+    return program
+      .command('init')
+      .description('Initialize Sungen project (create essential directories and config)');
+  }
+
+  /**
+   * Add cache-clear command
+   */
+  addCacheCommand(program: Command): Command {
+    return program
+      .command('cache-clear')
+      .description('Clear all caches');
+  }
+
+  /**
+   * Add auto-tag command
+   */
+  addAutoTagCommand(program: Command): Command {
+    return program
+      .command('auto-tag')
+      .description('Auto-inject stable data-testid attributes into source code')
+      .option('-s, --screen <name>', 'Tag specific screen (optional, defaults to all)')
+      .option('--dry-run', 'Preview changes without modifying files')
+      .option('--force', 'Overwrite existing data-testid attributes')
+      .option('-v, --verbose', 'Show detailed output');
+  }
+
+  /**
+   * Add add --screen command
+   */
+  addAddScreenCommand(program: Command): Command {
+    return program
+      .command('add')
+      .description('Add screen definition with scaffolded files')
+      .requiredOption('--screen <name>', 'Screen name')
+      .option('-p, --path <path>', 'Screen route path')
+      .option('-d, --description <text>', 'Screen description');
+  }
+
+  /**
+   * Extract options from commander Command
+   */
+  extractOptions(command: Command): CLIOptions {
+    const opts = command.opts();
+
+    // Determine mode from flags
+    let mode: 'hybrid' | 'ai-only' | 'heuristic-only' | undefined = opts.mode;
+    if (opts.aiOnly) mode = 'ai-only';
+    if (opts.heuristicOnly) mode = 'heuristic-only';
+
+    return {
+      screen: opts.screen,
+      depth: opts.depth ? parseInt(opts.depth, 10) : undefined,
+      force: opts.force,
+      aiMapper: opts.aiMapper,
+      framework: opts.framework,
+      mode,
+      aiOnly: opts.aiOnly,
+      heuristicOnly: opts.heuristicOnly,
+      verbose: opts.verbose,
+      config: opts.config
+    };
+  }
+}

package/src/input/config-adapter.ts

@@ -0,0 +1,71 @@
+/**
+ * Config File Input Adapter
+ * Parses configuration from YAML/JSON files
+ */
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import { CLIOptions } from '../config/config-schema';
+import { InputAdapter, InputSource } from './input-adapter';
+
+export class ConfigAdapter implements InputAdapter {
+  name = InputSource.FILE;
+  private configPath: string;
+
+  constructor(configPath: string) {
+    this.configPath = path.resolve(configPath);
+  }
+
+  /**
+   * Parse config file into CLIOptions
+   * Note: Full config is loaded by ConfigLoader, this just validates the file
+   */
+  parse(): CLIOptions {
+    if (!this.validate()) {
+      throw new Error(`Invalid config file: ${this.configPath}`);
+    }
+
+    // Return empty options - actual config loading is done by ConfigLoader
+    // This adapter is mainly for validation
+    return {
+      config: this.configPath
+    };
+  }
+
+  /**
+   * Validate config file exists and is valid YAML/JSON
+   */
+  validate(): boolean {
+    try {
+      if (!fs.existsSync(this.configPath)) {
+        console.error(`Config file not found: ${this.configPath}`);
+        return false;
+      }
+
+      const content = fs.readFileSync(this.configPath, 'utf-8');
+      const ext = path.extname(this.configPath);
+
+      if (ext === '.yaml' || ext === '.yml') {
+        yaml.parse(content);
+      } else if (ext === '.json') {
+        JSON.parse(content);
+      } else {
+        console.error(`Unsupported config file format: ${ext}`);
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      console.error(`Config file validation failed: ${error}`);
+      return false;
+    }
+  }
+
+  /**
+   * Get config file path
+   */
+  getPath(): string {
+    return this.configPath;
+  }
+}

package/src/input/input-adapter.ts

@@ -0,0 +1,32 @@
+/**
+ * Input Adapter Interface
+ * Defines how input sources provide configuration and commands
+ */
+
+import { CLIOptions } from '../config/config-schema';
+
+export interface InputAdapter {
+  /**
+   * Adapter name (for logging/debugging)
+   */
+  name: string;
+
+  /**
+   * Parse input and return CLI options
+   */
+  parse(...args: any[]): CLIOptions;
+
+  /**
+   * Validate input format
+   */
+  validate(): boolean;
+}
+
+/**
+ * Input source types
+ */
+export enum InputSource {
+  CLI = 'cli',
+  FILE = 'file',
+  VSCODE = 'vscode'
+}

package/src/input/vscode-adapter.ts

@@ -0,0 +1,90 @@
+/**
+ * VS Code Extension Input Adapter
+ * Handles input from VS Code extension commands
+ *
+ * This is a placeholder for future VS Code extension integration
+ * The extension will call framework methods directly via this adapter
+ */
+
+import { CLIOptions } from '../config/config-schema';
+import { InputAdapter, InputSource } from './input-adapter';
+
+export class VSCodeAdapter implements InputAdapter {
+  name = InputSource.VSCODE;
+
+  /**
+   * Parse VS Code extension command into options
+   *
+   * @param command - VS Code command object
+   * @example
+   * // From VS Code extension:
+   * const options = vscodeAdapter.parse({
+   *   action: 'discover',
+   *   screen: 'chat',
+   *   depth: 999
+   * });
+   */
+  parse(command: VSCodeCommand): CLIOptions {
+    return {
+      screen: command.screen,
+      depth: command.depth,
+      force: command.force,
+      aiMapper: command.aiMapper,
+      framework: command.framework,
+      verbose: command.verbose,
+      config: command.config
+    };
+  }
+
+  /**
+   * Validate VS Code command format
+   */
+  validate(): boolean {
+    // VS Code extension will handle validation
+    return true;
+  }
+
+  /**
+   * Execute framework command from VS Code
+   * This will be the main entry point for VS Code extension
+   *
+   * @param command - VS Code command
+   * @returns Result object with success/error information
+   */
+  async execute(command: VSCodeCommand): Promise<VSCodeResult> {
+    // This will be implemented when VS Code extension is built
+    // It will call the orchestrator pipeline with parsed options
+
+    return {
+      success: false,
+      message: 'VS Code adapter not yet implemented',
+      data: null
+    };
+  }
+}
+
+/**
+ * VS Code Command Interface
+ * Defines the structure of commands sent from VS Code extension
+ */
+export interface VSCodeCommand {
+  action: 'discover' | 'generate' | 'full' | 'cache-clear';
+  screen?: string;
+  depth?: number;
+  force?: boolean;
+  aiMapper?: boolean;
+  framework?: 'playwright' | 'appium' | 'integration';
+  verbose?: boolean;
+  config?: string;
+}
+
+/**
+ * VS Code Result Interface
+ * Defines the structure of results returned to VS Code extension
+ */
+export interface VSCodeResult {
+  success: boolean;
+  message: string;
+  data: any;
+  errors?: string[];
+}

package/src/orchestrator/cache-manager.ts

@@ -0,0 +1,138 @@
+/**
+ * Cache Manager
+ * Centralized cache operations for UI models and selectors
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { RuntimeConfig } from '../config/config-schema';
+import { UIModel } from '../core/ui-scanner/scanner-interface';
+import { SelectorBase } from '../core/selector-base/base-generator';
+
+export class CacheManager {
+  private config: RuntimeConfig;
+  private cacheDir: string;
+
+  constructor(config: RuntimeConfig) {
+    this.config = config;
+    this.cacheDir = path.resolve(config.paths.cacheDir);
+
+    // Ensure cache directory exists
+    if (!fs.existsSync(this.cacheDir)) {
+      fs.mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Get cached UI model
+   */
+  async getUIModel(screenName: string): Promise<UIModel | null> {
+    if (!this.config.cache.enabled) {
+      return null;
+    }
+
+    const cacheFile = path.join(this.cacheDir, 'ui-models', `${screenName}.json`);
+
+    if (!fs.existsSync(cacheFile)) {
+      return null;
+    }
+
+    try {
+      const content = fs.readFileSync(cacheFile, 'utf-8');
+      const cached = JSON.parse(content);
+
+      // Validate cache is not expired
+      if (!this.isCacheValid(cached.timestamp)) {
+        return null;
+      }
+
+      return cached;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Save UI model to cache
+   */
+  async saveUIModel(screenName: string, uiModel: UIModel): Promise<void> {
+    if (!this.config.cache.enabled) {
+      return;
+    }
+
+    const cacheDir = path.join(this.cacheDir, 'ui-models');
+    if (!fs.existsSync(cacheDir)) {
+      fs.mkdirSync(cacheDir, { recursive: true });
+    }
+
+    const cacheFile = path.join(cacheDir, `${screenName}.json`);
+    fs.writeFileSync(cacheFile, JSON.stringify(uiModel, null, 2), 'utf-8');
+  }
+
+  /**
+   * Get cached selectors
+   */
+  async getSelectors(screenName: string): Promise<SelectorBase | null> {
+    if (!this.config.cache.enabled) {
+      return null;
+    }
+
+    const cacheFile = path.join(this.cacheDir, 'selectors', `${screenName}.json`);
+
+    if (!fs.existsSync(cacheFile)) {
+      return null;
+    }
+
+    try {
+      const content = fs.readFileSync(cacheFile, 'utf-8');
+      const cached = JSON.parse(content);
+
+      // Validate cache is not expired
+      if (!this.isCacheValid(cached.metadata.timestamp)) {
+        return null;
+      }
+
+      return cached;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Save selectors to cache
+   */
+  async saveSelectors(screenName: string, selectors: SelectorBase): Promise<void> {
+    if (!this.config.cache.enabled) {
+      return;
+    }
+
+    const cacheDir = path.join(this.cacheDir, 'selectors');
+    if (!fs.existsSync(cacheDir)) {
+      fs.mkdirSync(cacheDir, { recursive: true });
+    }
+
+    const cacheFile = path.join(cacheDir, `${screenName}.json`);
+    fs.writeFileSync(cacheFile, JSON.stringify(selectors, null, 2), 'utf-8');
+  }
+
+  /**
+   * Clear all caches
+   */
+  async clear(): Promise<void> {
+    if (fs.existsSync(this.cacheDir)) {
+      fs.rmSync(this.cacheDir, { recursive: true, force: true });
+      fs.mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Check if cache is valid (not expired)
+   */
+  private isCacheValid(timestamp: number): boolean {
+    const now = Date.now();
+    const age = now - timestamp;
+    const ttl = this.config.cache.ttl * 1000; // Convert to ms
+
+    return age < ttl;
+  }
+}