@sun-asterisk/sungen 1.0.24 → 2.0.1

package/src/orchestrator/cache-manager.ts

@@ -1,32 +0,0 @@
-/**
- * Cache Manager
- * Manages cache directory operations
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { RuntimeConfig } from '../config/config-schema';
-
-export class CacheManager {
-  private config: RuntimeConfig;
-  private cacheDir: string;
-
-  constructor(config: RuntimeConfig) {
-    this.config = config;
-    this.cacheDir = path.resolve(config.paths.cacheDir);
-
-    if (!fs.existsSync(this.cacheDir)) {
-      fs.mkdirSync(this.cacheDir, { recursive: true });
-    }
-  }
-
-  /**
-   * 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 });
-    }
-  }
-}

package/src/orchestrator/pipeline.ts

@@ -1,354 +0,0 @@
-/**
- * Pipeline Orchestrator
- * Coordinates test generation: Live-Scan → Scaffold → Code Generation
- */
-
-import * as path from 'path';
-import * as fs from 'fs';
-import { RuntimeConfig } from '../config/config-schema';
-import { TestGeneratorFactory, GeneratedTest } from '../generators/test-generator/types';
-import { CacheManager } from './cache-manager';
-import { Reporter } from './reporter';
-
-export class Pipeline {
-  private config: RuntimeConfig;
-  private cacheManager: CacheManager;
-  private reporter: Reporter;
-
-  constructor(config: RuntimeConfig) {
-    this.config = config;
-    this.cacheManager = new CacheManager(config);
-    this.reporter = new Reporter(config);
-  }
-
-  /**
-   * Run test generation phase
-   * Generates Playwright test scripts from Gherkin
-   */
-  async runTestGeneration(screenName?: string): Promise<GeneratedTest[]> {
-    const header = screenName ? `Generating tests: ${screenName}` : 'Generating tests';
-    console.log(`\n${header}\n`);
-
-    // Find all feature files from both old and new structure
-    const featureFiles = screenName
-      ? this.findFeatureFilesForScreen(screenName)
-      : this.findAllFeatureFiles();
-
-    if (screenName && featureFiles.length === 0) {
-      throw new Error(
-        `No feature files found for screen: ${screenName}\n` +
-        `Looked in:\n` +
-        `  - qa/screens/${screenName}/features/\n` +
-        `  - qa/features/${screenName}.feature`
-      );
-    }
-
-    // Parse features
-    const { GherkinParser } = require('../core/selector-base/gherkin-parser');
-    const parser = new GherkinParser(this.config);
-    const features = await parser.parseAll(featureFiles);
-
-    // Validate selector files before generation
-    if (screenName) {
-      const validation = this.validateSelectorFiles(screenName, features);
-      const missing = validation.filter(v => !v.selectorExists);
-
-      if (missing.length > 0) {
-        const missingList = missing.map(v => `  ✗ ${v.featureName}.feature → selector file not found`).join('\n');
-        throw new Error(
-          `Missing selector files:\n${missingList}\n\n` +
-          `Run: sungen map --screen ${screenName}`
-        );
-      }
-    }
-
-    // Generate tests
-    const generator = TestGeneratorFactory.create(this.config.testGenerator.framework, this.config);
-    const results: GeneratedTest[] = [];
-    const errors: Array<{ feature: string; error: any }> = [];
-
-    for (const feature of features) {
-      try {
-        // Load selectors and test data
-        const selectors = {}; // TODO: Load from selector files
-        const testData = {};  // TODO: Load from test-data files
-
-        const result = await generator.generate(feature, selectors, testData, this.config);
-        results.push(result);
-
-        // Display per-file result
-        const fileName = path.basename(result.outputPath);
-        const relativePath = path.relative(process.cwd(), result.outputPath);
-        const stepInfo = result.stats?.totalSteps ? ` (${result.stats.totalSteps} steps)` : '';
-
-        console.log(`✓ Generated ${fileName}`);
-        console.log(`   → ${relativePath}${stepInfo}\n`);
-      } catch (error) {
-        const featureName = typeof feature === 'object' && feature.name ? feature.name : 'unknown';
-        console.error(`✗ Failed to generate test for feature: ${featureName}`);
-        console.error(`   Error: ${error instanceof Error ? error.message : String(error)}`);
-        errors.push({ feature: featureName, error });
-      }
-    }
-
-    // Throw if any errors occurred
-    if (errors.length > 0) {
-      const errorList = errors.map(e => `  - ${e.feature}`).join('\n');
-      throw new Error(
-        `Failed to generate ${errors.length} test(s):\n${errorList}`
-      );
-    }
-
-    // Generate report
-    await this.reporter.generate(results);
-
-    // Display next step
-    console.log(`Next step: npx playwright test --ui\n`);
-
-    return results;
-  }
-
-  /**
-   * Validate that selector files exist for all features
-   */
-  private validateSelectorFiles(screenName: string, features: any[]): Array<{
-    featureName: string;
-    sourceFile?: string;
-    selectorExists: boolean;
-    selectorPath: string | null;
-  }> {
-    const results: Array<{
-      featureName: string;
-      sourceFile?: string;
-      selectorExists: boolean;
-      selectorPath: string | null;
-    }> = [];
-
-    for (const feature of features) {
-      const featureName = this.extractFeatureName(feature);
-      const selectorPath = this.findSelectorFile(screenName, featureName);
-
-      results.push({
-        featureName,
-        sourceFile: feature.sourceFile,
-        selectorExists: selectorPath !== null,
-        selectorPath,
-      });
-    }
-
-    return results;
-  }
-
-  /**
-   * Extract feature name from parsed feature
-   */
-  private extractFeatureName(feature: any): string {
-    if (feature.sourceFile) {
-      return path.basename(feature.sourceFile, path.extname(feature.sourceFile));
-    }
-    // Fallback to feature name
-    return feature.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
-  }
-
-  /**
-   * Find selector file path for a feature
-   */
-  private findSelectorFile(screenName: string, featureName: string): string | null {
-    const possiblePaths: string[] = [];
-
-    // New structure: qa/screens/{screen}/selectors/{feature}.yaml
-    const newStructurePath = path.join(
-      process.cwd(),
-      'qa',
-      'screens',
-      screenName,
-      'selectors',
-      `${featureName}.yaml`
-    );
-    possiblePaths.push(newStructurePath);
-
-    // Old structure: qa/selectors/screens/{feature}.yaml
-    const oldStructurePath = path.join(
-      process.cwd(),
-      'qa',
-      'selectors',
-      'screens',
-      `${featureName}.yaml`
-    );
-    possiblePaths.push(oldStructurePath);
-
-    for (const p of possiblePaths) {
-      if (fs.existsSync(p)) {
-        return p;
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Run full pipeline: Live-Scan → Scaffold → Test Generation
-   */
-  async runFull(
-    screens?: string[],
-    options?: { headed?: boolean; authDir?: string; skipLiveScan?: boolean; force?: boolean }
-  ): Promise<void> {
-    console.log('\n🚀 Running full pipeline\n');
-
-    // Discover screens if not specified
-    if (!screens || screens.length === 0) {
-      screens = await this.discoverScreensFromGherkin();
-      console.log(`  Found ${screens.length} screen(s) in Gherkin: ${screens.join(', ')}\n`);
-    }
-
-    const screensDir = 'qa/screens';
-
-    for (const screen of screens) {
-      // Phase 1: Live-scan
-      if (!options?.skipLiveScan) {
-        console.log(`📍 Phase 1: Live-Scan — ${screen}\n`);
-        const { LiveScanner } = require('../core/live-scanner');
-        const scanner = new LiveScanner({
-          screenName: screen,
-          screensDir,
-          headed: options?.headed,
-          authDir: options?.authDir || 'specs/.auth',
-          force: options?.force,
-        });
-        await scanner.scan();
-        console.log('');
-      }
-
-      // Phase 2: Scaffold (map)
-      console.log(`📍 Phase 2: Map — ${screen}\n`);
-      const { ScaffoldGenerator } = require('../generators/scaffold-generator');
-      const generator = new ScaffoldGenerator();
-      const results = generator.processScreen(screen, screensDir, options?.force || false);
-
-      for (const result of results) {
-        console.log(`✓ Mapped ${result.featureFile}.feature`);
-        if (result.selectorsSkipped) {
-          console.log(`   ⊘ ${path.basename(result.selectorsPath)} (skipped - already exists)`);
-        } else {
-          console.log(`   → ${path.basename(result.selectorsPath)} (${result.elementCount} elements)`);
-        }
-        console.log('');
-      }
-    }
-
-    // Phase 3: Test Generation
-    console.log('📍 Phase 3: Generate Tests\n');
-    await this.runTestGeneration();
-
-    console.log('✅ Full pipeline completed!\n');
-  }
-
-  /**
-   * Clear all caches
-   */
-  async clearCache(): Promise<void> {
-    await this.cacheManager.clear();
-    console.log('✓ Cache cleared\n');
-  }
-
-  // ============================================================================
-  // Helper Methods
-  // ============================================================================
-
-  private findFeatureFiles(dir: string): string[] {
-    const files: string[] = [];
-
-    if (!fs.existsSync(dir)) {
-      return files;
-    }
-
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-
-      if (entry.isDirectory()) {
-        files.push(...this.findFeatureFiles(fullPath));
-      } else if (entry.isFile() && entry.name.endsWith('.feature')) {
-        files.push(fullPath);
-      }
-    }
-
-    return files;
-  }
-
-  /**
-   * Find feature files for a specific screen
-   */
-  private findFeatureFilesForScreen(screenName: string): string[] {
-    const files: string[] = [];
-
-    // New structure: qa/screens/<screenName>/features/
-    const screenFeaturesDir = path.join(
-      path.dirname(this.config.paths.featuresDir),
-      'screens',
-      screenName,
-      'features'
-    );
-
-    if (fs.existsSync(screenFeaturesDir)) {
-      files.push(...this.findFeatureFiles(screenFeaturesDir));
-    }
-
-    // Old structure: qa/features/<screenName>.feature (by convention)
-    const oldFeaturesDir = this.config.paths.featuresDir;
-    if (fs.existsSync(oldFeaturesDir)) {
-      const screenFeaturePath = path.join(oldFeaturesDir, `${screenName}.feature`);
-      if (fs.existsSync(screenFeaturePath)) {
-        files.push(screenFeaturePath);
-      }
-    }
-
-    return files;
-  }
-
-  /**
-   * Find all feature files from both old and new folder structures
-   */
-  private findAllFeatureFiles(): string[] {
-    const allFiles: string[] = [];
-
-    // Old structure: qa/features/
-    const oldFeaturesDir = this.config.paths.featuresDir;
-    allFiles.push(...this.findFeatureFiles(oldFeaturesDir));
-
-    // New structure: qa/screens/*/features/
-    const screensDir = path.join(path.dirname(oldFeaturesDir), 'screens');
-    if (fs.existsSync(screensDir)) {
-      const screenDirs = fs.readdirSync(screensDir, { withFileTypes: true })
-        .filter(entry => entry.isDirectory())
-        .map(entry => entry.name);
-
-      for (const screenName of screenDirs) {
-        const screenFeaturesDir = path.join(screensDir, screenName, 'features');
-        allFiles.push(...this.findFeatureFiles(screenFeaturesDir));
-      }
-    }
-
-    return allFiles;
-  }
-
-  /**
-   * Discover all unique screens from qa/screens/ directory
-   */
-  private async discoverScreensFromGherkin(): Promise<string[]> {
-    const screensDir = path.join(process.cwd(), 'qa', 'screens');
-    if (!fs.existsSync(screensDir)) {
-      return [];
-    }
-
-    return fs.readdirSync(screensDir, { withFileTypes: true })
-      .filter(entry => entry.isDirectory())
-      .filter(entry => {
-        const featuresDir = path.join(screensDir, entry.name, 'features');
-        return fs.existsSync(featuresDir);
-      })
-      .map(entry => entry.name)
-      .sort();
-  }
-}

package/src/orchestrator/reporter.ts

@@ -1,36 +0,0 @@
-/**
- * Reporter
- * Generates reports for test generation results
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { RuntimeConfig } from '../config/config-schema';
-import { GeneratedTest } from '../generators/test-generator/types';
-
-export class Reporter {
-  private config: RuntimeConfig;
-
-  constructor(config: RuntimeConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Generate report for test generation results
-   */
-  async generate(results: GeneratedTest[]): Promise<void> {
-    if (!this.config.verbose) {
-      return;
-    }
-
-    const totalScenarios = results.reduce((sum, r) => sum + r.stats.totalScenarios, 0);
-    const totalSteps = results.reduce((sum, r) => sum + r.stats.totalSteps, 0);
-    const totalTodos = results.reduce((sum, r) => sum + r.stats.todoCount, 0);
-
-    console.log('\n📊 Generation Report:');
-    console.log(`  Features: ${results.length}`);
-    console.log(`  Scenarios: ${totalScenarios}`);
-    console.log(`  Steps: ${totalSteps}`);
-    console.log(`  TODOs: ${totalTodos}`);
-  }
-}