@sun-asterisk/sungen 1.0.24 → 2.0.1

package/src/core/selector-base/base-generator.ts

@@ -1,234 +0,0 @@
-/**
- * Selector Base Generator
- * Generates empty selector template from Gherkin features
- * Supports multiple annotation types
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import yaml from 'yaml';
-import { RuntimeConfig } from '../../config/config-schema';
-import { GherkinParser, ParsedFeature } from './gherkin-parser';
-import { AnnotationHandler } from './annotation-handler';
-
-export interface SelectorBase {
-  screen: string;
-  elements: Record<string, SelectorElement>;
-  metadata: {
-    generatedFrom: string;
-    timestamp: number;
-    totalElements: number;
-  };
-}
-
-export interface SelectorElement {
-  selector: string;  // Empty initially, will be filled by AI
-  type?: 'selector' | 'data' | 'ignore';
-  source?: string;   // Which feature file it came from
-  line?: number;     // Line number in feature file
-}
-
-export class SelectorBaseGenerator {
-  private config: RuntimeConfig;
-  private parser: GherkinParser;
-  private annotationHandler: AnnotationHandler;
-
-  constructor(config: RuntimeConfig) {
-    this.config = config;
-    this.parser = new GherkinParser(config);
-    this.annotationHandler = new AnnotationHandler(config);
-  }
-
-  /**
-   * Generate selector base for a screen
-   * Scans all Gherkin features and extracts element IDs
-   */
-  async generate(screenName: string): Promise<SelectorBase> {
-    const featuresDir = this.config.paths.featuresDir;
-
-    // Find all feature files
-    const featureFiles = this.findFeatureFiles(featuresDir);
-
-    // Extract element IDs from all features
-    const elementIds = new Set<string>();
-    const elementMetadata: Record<string, { source: string; line: number; type: string }> = {};
-
-    for (const featureFile of featureFiles) {
-      const feature = await this.parser.parse(featureFile);
-
-      // Extract element IDs from steps
-      const ids = this.extractElementIds(feature, screenName);
-
-      for (const { id, line, type } of ids) {
-        elementIds.add(id);
-        elementMetadata[id] = {
-          source: path.basename(featureFile),
-          line,
-          type
-        };
-      }
-    }
-
-    // Build selector base
-    const elements: Record<string, SelectorElement> = {};
-
-    for (const id of Array.from(elementIds)) {
-      const meta = elementMetadata[id];
-      elements[id] = {
-        selector: '',  // Empty - will be filled by AI
-        type: meta.type as any,
-        source: meta.source,
-        line: meta.line
-      };
-    }
-
-    return {
-      screen: screenName,
-      elements,
-      metadata: {
-        generatedFrom: featuresDir,
-        timestamp: Date.now(),
-        totalElements: elementIds.size
-      }
-    };
-  }
-
-  /**
-   * Save selector base to YAML file
-   */
-  async save(selectorBase: SelectorBase): Promise<string> {
-    const outputDir = path.join(this.config.paths.selectorsDir, 'screens');
-
-    // Ensure output directory exists
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
-
-    const outputPath = path.join(outputDir, `${selectorBase.screen}.yaml`);
-
-    // Format for YAML output
-    const yamlContent = {
-      screen: selectorBase.screen,
-      elements: selectorBase.elements
-    };
-
-    fs.writeFileSync(outputPath, yaml.stringify(yamlContent), 'utf-8');
-
-    if (this.config.verbose) {
-      console.log(`✓ Generated selector base: ${outputPath}`);
-      console.log(`  Elements: ${selectorBase.metadata.totalElements}`);
-    }
-
-    return outputPath;
-  }
-
-  /**
-   * Extract element IDs from feature for specific screen
-   */
-  private extractElementIds(
-    feature: ParsedFeature,
-    screenName: string
-  ): Array<{ id: string; line: number; type: string }> {
-    const ids: Array<{ id: string; line: number; type: string }> = [];
-
-    // Check background steps
-    if (feature.background) {
-      for (const step of feature.background.steps) {
-        const extracted = this.annotationHandler.extractElementId(step.text, screenName);
-        if (extracted) {
-          ids.push({
-            id: extracted.id,
-            // @ts-ignore - Legacy parser may have line field
-            line: step.line || 0,
-            type: extracted.type
-          });
-        }
-      }
-    }
-
-    // Check scenario steps
-    for (const scenario of feature.scenarios) {
-      // Check for @ignore-testcase annotation
-      if (this.annotationHandler.shouldIgnoreScenario(scenario)) {
-        continue;
-      }
-
-      for (const step of scenario.steps) {
-        // Check for @ignore annotation
-        if (this.annotationHandler.shouldIgnoreStep(step)) {
-          continue;
-        }
-
-        const extracted = this.annotationHandler.extractElementId(step.text, screenName);
-        if (extracted) {
-          ids.push({
-            id: extracted.id,
-            // @ts-ignore - Legacy parser may have line field
-            line: step.line || 0,
-            type: extracted.type
-          });
-        }
-      }
-    }
-
-    return ids;
-  }
-
-  /**
-   * Find all feature files in directory
-   */
-  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;
-  }
-
-  /**
-   * Load existing selector base (if exists)
-   */
-  async load(screenName: string): Promise<SelectorBase | null> {
-    const filePath = path.join(
-      this.config.paths.selectorsDir,
-      'screens',
-      `${screenName}.yaml`
-    );
-
-    if (!fs.existsSync(filePath)) {
-      return null;
-    }
-
-    try {
-      const content = fs.readFileSync(filePath, 'utf-8');
-      const data = yaml.parse(content);
-
-      return {
-        screen: data.screen,
-        elements: data.elements || {},
-        metadata: {
-          generatedFrom: this.config.paths.featuresDir,
-          timestamp: Date.now(),
-          totalElements: Object.keys(data.elements || {}).length
-        }
-      };
-    } catch (error) {
-      console.error(`Failed to load selector base: ${error}`);
-      return null;
-    }
-  }
-}

package/src/core/selector-base/gherkin-parser.ts

@@ -1,57 +0,0 @@
-/**
- * Gherkin Parser
- * Parses Gherkin feature files into structured format
- * This is a wrapper around the existing parser with new interface
- */
-
-import * as fs from 'fs';
-import { RuntimeConfig } from '../../config/config-schema';
-import {
-  GherkinParser as LegacyParser,
-  ParsedFeature as LegacyFeature,
-  ParsedScenario as LegacyScenario,
-  ParsedStep as LegacyStep
-} from '../../generators/gherkin-parser';
-
-// Re-export types from legacy parser for now
-export type ParsedFeature = LegacyFeature;
-export type ParsedScenario = LegacyScenario;
-export type ParsedStep = LegacyStep;
-
-export class GherkinParser {
-  private config: RuntimeConfig;
-  private legacyParser: LegacyParser;
-
-  constructor(config: RuntimeConfig) {
-    this.config = config;
-    this.legacyParser = new LegacyParser();
-  }
-
-  /**
-   * Parse a Gherkin feature file
-   */
-  async parse(featurePath: string): Promise<ParsedFeature> {
-    // Use correct method name from legacy parser
-    return this.legacyParser.parseFeatureFile(featurePath);
-  }
-
-  /**
-   * Parse multiple feature files
-   */
-  async parseAll(featureFiles: string[]): Promise<ParsedFeature[]> {
-    const features: ParsedFeature[] = [];
-
-    for (const file of featureFiles) {
-      try {
-        const feature = await this.parse(file);
-        features.push(feature);
-      } catch (error) {
-        if (this.config.verbose) {
-          console.error(`Failed to parse ${file}: ${error}`);
-        }
-      }
-    }
-
-    return features;
-  }
-}