@sun-asterisk/sungen 1.0.0

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/check-action.hbs

@@ -0,0 +1 @@
+await {{> locator}}.check();

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/clear-action.hbs

@@ -0,0 +1 @@
+await {{> locator}}.clear();

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/click-action.hbs

@@ -0,0 +1 @@
+await {{> locator}}.click();

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/double-click-action.hbs

@@ -0,0 +1 @@
+await {{> locator}}.dblclick();

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/fill-action.hbs

@@ -0,0 +1 @@
+await {{> locator}}.fill('{{fillValue}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/hover-action.hbs

@@ -0,0 +1 @@
+await {{> locator}}.hover();

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/press-action.hbs

@@ -0,0 +1 @@
+await {{> locator}}.press('{{key}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/select-action.hbs

@@ -0,0 +1 @@
+await {{> locator}}.selectOption('{{selectValue}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/actions/uncheck-action.hbs

@@ -0,0 +1 @@
+await {{> locator}}.uncheck();

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/checked-assertion.hbs

@@ -0,0 +1 @@
+await expect({{> locator}}).toBeChecked();

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/contain-text-assertion.hbs

@@ -0,0 +1 @@
+await expect({{> locator}}).toContainText('{{expectedText}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/count-assertion.hbs

@@ -0,0 +1 @@
+await expect({{> locator}}).toHaveCount({{expectedCount}});

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/disabled-assertion.hbs

@@ -0,0 +1,2 @@
+const {{varName}} = await pw.getElement('[{{selectorRef}}]', '{{screenId}}');
+await expect({{varName}}).toBeDisabled();

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/empty-assertion.hbs

@@ -0,0 +1,2 @@
+const {{varName}} = await pw.getElement('[{{selectorRef}}]', '{{screenId}}');
+await expect({{varName}}).toBeEmpty();

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/enabled-assertion.hbs

@@ -0,0 +1,2 @@
+const {{varName}} = await pw.getElement('[{{selectorRef}}]', '{{screenId}}');
+await expect({{varName}}).toBeEnabled();

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/focused-assertion.hbs

@@ -0,0 +1 @@
+await expect({{> locator}}).toBeFocused();

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/have-text-assertion.hbs

@@ -0,0 +1 @@
+await expect({{> locator}}).toHaveText('{{expectedText}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/not-checked-assertion.hbs

@@ -0,0 +1 @@
+await expect({{> locator}}).not.toBeChecked();

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/not-visible-assertion.hbs

@@ -0,0 +1 @@
+await expect({{> locator}}).not.toBeVisible();

package/src/generators/test-generator/adapters/playwright/templates/steps/assertions/visible-assertion.hbs

@@ -0,0 +1 @@
+await expect({{> locator}}).toBeVisible();

package/src/generators/test-generator/adapters/playwright/templates/steps/navigation/navigation.hbs

@@ -0,0 +1 @@
+await page.goto('{{#if baseURL}}{{baseURL}}{{/if}}{{path}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/navigation/route-assertion.hbs

@@ -0,0 +1,2 @@
+await page.waitForURL('**{{path}}', { timeout: 5000 });
+expect(page.url()).toContain('{{path}}');

package/src/generators/test-generator/adapters/playwright/templates/steps/navigation/wait-for-element.hbs

@@ -0,0 +1 @@
+await {{> locator}}.waitFor({ state: '{{state}}' });

package/src/generators/test-generator/adapters/playwright/templates/steps/navigation/wait-timeout.hbs

@@ -0,0 +1 @@
+await page.waitForTimeout({{duration}});

package/src/generators/test-generator/adapters/playwright/templates/steps/partials/locator.hbs

@@ -0,0 +1 @@
+{{#if (eq strategy 'testid')}}page.getByTestId('{{value}}'){{else if (eq strategy 'role')}}page.getByRole('{{role}}', { name: '{{escapeQuotes name}}' }){{else if (eq strategy 'placeholder')}}page.getByPlaceholder('{{escapeQuotes value}}'){{else if (eq strategy 'label')}}page.getByLabel('{{escapeQuotes value}}'){{else if (eq strategy 'text')}}page.getByText('{{escapeQuotes value}}'){{else if (eq strategy 'id')}}page.locator('{{selector}}'){{else}}page.locator('{{escapeQuotes selector}}'){{/if}}{{#if (and (isDefined nth) (gt nth 0))}}.nth({{subtract nth 1}}){{/if}}

package/src/generators/test-generator/adapters/playwright/templates/steps/setup/application-running.hbs

@@ -0,0 +1 @@
+// Application should be running (no action needed)

package/src/generators/test-generator/adapters/playwright/templates/steps/setup/clear-auth.hbs

@@ -0,0 +1,6 @@
+// Clear authentication state
+await page.context().clearCookies();
+await page.evaluate(() => {
+  localStorage.clear();
+  sessionStorage.clear();
+});

package/src/generators/test-generator/adapters/playwright/templates/steps/setup/clear-browser-state.hbs

@@ -0,0 +1,6 @@
+// Clear browser state
+await page.context().clearCookies();
+await page.evaluate(() => {
+  localStorage.clear();
+  sessionStorage.clear();
+});

package/src/generators/test-generator/adapters/playwright/templates/steps/setup/clear-database.hbs

@@ -0,0 +1,4 @@
+// TODO: Clear database
+// This typically requires:
+// 1. API call to test endpoint
+// 2. Or database reset script

package/src/generators/test-generator/adapters/playwright/templates/steps/setup/user-login-todo.hbs

@@ -0,0 +1,6 @@
+// TODO: Implement login for user: {{userRef}}
+// You may need to:
+// 1. Navigate to login page
+// 2. Fill credentials
+// 3. Submit login form
+// 4. Wait for successful login

package/src/generators/test-generator/adapters/playwright/templates/test-file.hbs

@@ -0,0 +1,19 @@
+{{imports}}
+
+{{#if featureDescription}}
+/**
+ * Feature: {{featureName}}
+ * {{featureDescription}}
+ */
+{{/if}}
+
+test.describe('{{featureName}}', () => {
+{{#if background}}
+{{background}}
+
+{{/if}}
+{{#each scenarios}}
+{{this}}
+
+{{/each}}
+});

package/src/generators/test-generator/ai-step-mapper.ts

@@ -0,0 +1,224 @@
+/**
+ * AI-Based Step Mapper
+ * Fallback for dictionary when Gherkin patterns are ambiguous or unknown
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import { ParsedStep } from '../gherkin-parser';
+import { MappedStep } from './step-mapper';
+
+export class AIStepMapper {
+  private client: Anthropic;
+  private verbose: boolean;
+
+  constructor(verbose: boolean = false) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error('ANTHROPIC_API_KEY environment variable is required for AI step mapping');
+    }
+
+    this.client = new Anthropic({ apiKey });
+    this.verbose = verbose;
+  }
+
+  /**
+   * Map a Gherkin step to Playwright code using AI
+   * Provides rich context to help AI understand the intent
+   */
+  async mapStep(step: ParsedStep): Promise<MappedStep> {
+    if (this.verbose) {
+      console.log(`      [AI] Mapping step: "${step.text}"`);
+    }
+
+    const prompt = this.buildPrompt(step);
+
+    try {
+      const message = await this.client.messages.create({
+        model: 'claude-3-5-haiku-20241022', // Fast & cheap for code generation
+        max_tokens: 500,
+        temperature: 0, // Deterministic for code generation
+        messages: [{
+          role: 'user',
+          content: prompt
+        }]
+      });
+
+      const content = message.content[0];
+      if (content.type !== 'text') {
+        throw new Error('Unexpected response type from AI');
+      }
+
+      const code = this.extractCode(content.text);
+
+      if (this.verbose) {
+        console.log(`      [AI] Generated code (${code.split('\n').length} lines)`);
+      }
+
+      return {
+        code,
+        comment: `AI-generated from: ${step.text}`
+      };
+    } catch (error) {
+      console.error(`[AI] Failed to map step: ${error}`);
+
+      // Fallback to TODO comment
+      return {
+        code: `// TODO: AI mapping failed - implement manually: ${step.text}`,
+        comment: `AI mapping error: ${error instanceof Error ? error.message : 'Unknown error'}`
+      };
+    }
+  }
+
+  /**
+   * Build context-rich prompt for AI
+   * Includes examples, patterns, and clear instructions
+   */
+  private buildPrompt(step: ParsedStep): string {
+    const { keyword, text, selectorRef, dataRef, value } = step;
+
+    return `You are an expert Playwright test code generator.
+
+**Task**: Convert this Gherkin step into Playwright TypeScript code.
+
+**Gherkin Step**:
+${keyword} ${text}
+
+**Parsed Information**:
+- Element ID: ${selectorRef || 'N/A'}
+- Data Reference: ${dataRef || 'N/A'}
+- Value: ${value || 'N/A'}
+
+**Context**:
+- We use a custom selector helper: \`pw.fill(elementId, value, screenId)\`
+- Element IDs are in format: [screen.element-name]
+- Screen ID is extracted from element ID (e.g., "chat" from "[chat.input]")
+- For assertions, use: \`await pw.getElement(elementId, screenId)\` then \`expect(element)...\`
+
+**Common Patterns & Examples**:
+
+1. **Fill/Input Actions**:
+   - "user fills/inputs/enters [element] with value"
+   - "user types value in/into [element]"
+   → \`await pw.fill('[element]', 'value', 'screen');\`
+
+2. **Click Actions**:
+   - "user clicks/taps/presses [element]"
+   - "user clicks on [element]"
+   → \`await pw.click('[element]', 'screen');\`
+
+3. **Keyboard Actions**:
+   - "user presses Enter in [element]"
+   - "user hits Tab key in [element]"
+   → \`const el = await pw.getElement('[element]', 'screen');\n   await el.press('Enter');\`
+
+4. **Visibility Assertions**:
+   - "user should see [element]"
+   - "[element] is/should be visible"
+   - "[element] appears/shows"
+   → \`const el = await pw.getElement('[element]', 'screen');\n   await expect(el).toBeVisible();\`
+
+5. **State Assertions**:
+   - "[element] should be disabled/enabled"
+   - "[element] is checked/unchecked"
+   → \`const el = await pw.getElement('[element]', 'screen');\n   await expect(el).toBeDisabled();\`
+
+6. **Text Content Assertions**:
+   - "[element] should contain text \\"value\\""
+   - "[element] has/displays text \\"value\\""
+   → \`const el = await pw.getElement('[element]', 'screen');\n   await expect(el).toContainText('value');\`
+
+7. **Collection State**:
+   - "[element] should be empty"
+   - "[element] has no items"
+   → \`const el = await pw.getElement('[element]', 'screen');\n   const items = await el.locator('> *').all();\n   expect(items.length).toBe(0);\`
+
+8. **Scroll State**:
+   - "[element] should be scrolled to bottom"
+   → \`const el = await pw.getElement('[element]', 'screen');\n   const scrollHeight = await el.evaluate(el => el.scrollHeight);\n   const scrollTop = await el.evaluate(el => el.scrollTop);\n   const clientHeight = await el.evaluate(el => el.clientHeight);\n   expect(scrollTop + clientHeight).toBeGreaterThanOrEqual(scrollHeight - 10);\`
+
+**Important Rules**:
+1. Extract screen ID from element ID: "[chat.input]" → screen="chat"
+2. Use proper TypeScript syntax with await
+3. Use descriptive variable names (element, el, container, etc.)
+4. Add helpful comments for complex assertions
+5. NEVER use page.evaluate() unless absolutely necessary
+6. NEVER generate partial or incomplete statements
+7. Each step should generate COMPLETE, SELF-CONTAINED code
+8. If you can't map the step, return a comment: // TODO: Implement step
+
+**Output Format**:
+Return ONLY complete Playwright TypeScript statements, no explanations, no markdown blocks.
+Each statement must be syntactically complete and can be inserted directly into a test function.
+
+**Example Output**:
+const chat_input_123 = await pw.getElement('[chat.input]', 'chat');
+await expect(chat_input_123).toBeVisible();
+
+Now generate code for the given step.`;
+  }
+
+  /**
+   * Extract clean code from AI response
+   * Remove markdown code blocks, explanations, etc.
+   */
+  private extractCode(response: string): string {
+    let code = response.trim();
+
+    // Remove markdown code blocks
+    code = code.replace(/```(?:typescript|ts|javascript|js)?\n?/g, '');
+    code = code.replace(/```\n?/g, '');
+
+    // Remove leading/trailing whitespace
+    code = code.trim();
+
+    // If response contains explanations, try to extract only code
+    const lines = code.split('\n');
+    const codeLines = lines.filter(line => {
+      const trimmed = line.trim();
+
+      // Skip lines that are clearly explanations (start with text, not code)
+      // But keep all valid TypeScript/JavaScript syntax
+      if (trimmed === '') return true; // Keep empty lines
+      if (trimmed.startsWith('//')) return true; // Keep comments
+
+      // Exclude lines that look like natural language explanations
+      // (start with capital letter and contain spaces, no semicolons/operators)
+      if (/^[A-Z][a-z]+ [\w\s]+$/.test(trimmed) && !trimmed.includes(';')) {
+        return false; // This looks like an explanation
+      }
+
+      // Keep lines that contain code-like patterns
+      const codePatterns = [
+        'await ', 'const ', 'let ', 'var ', 'return ', 'expect(', 'if ', 'else',
+        'for ', 'while ', 'function ', '=>', 'pw.', 'page.',
+        ')', '}', '];', '});', '})', 'import ', 'export ',
+        '.', '(', '[', '=', '+', '-', '*', '/', '%', '&&', '||'
+      ];
+
+      return codePatterns.some(pattern => trimmed.includes(pattern));
+    });
+
+    // If we filtered too much, return original
+    if (codeLines.length === 0) {
+      return code;
+    }
+
+    let finalCode = codeLines.join('\n');
+
+    // Safety check: Remove incomplete page.evaluate statements
+    // If we find "page.evaluate(" without proper closing, remove it
+    const evaluatePattern = /await\s+page\.evaluate\(\(\)\s*=>\s*\{\s*$/gm;
+    if (evaluatePattern.test(finalCode)) {
+      // Has unclosed page.evaluate at end - this is incomplete, return TODO
+      return '// TODO: Implement step (AI generated incomplete code)';
+    }
+
+    // Safety check: If code ends with an opening brace/paren, it's incomplete
+    const endsIncomplete = /[\({]\s*$/.test(finalCode);
+    if (endsIncomplete) {
+      return '// TODO: Implement step (AI generated incomplete code)';
+    }
+
+    return finalCode;
+  }
+}

package/src/generators/test-generator/code-generator.ts

@@ -0,0 +1,235 @@
+import fs from 'fs';
+import path from 'path';
+import { ParsedFeature, ParsedScenario, ParsedStep } from '../gherkin-parser';
+import { StepMapper } from './step-mapper';
+import { TestGeneratorAdapter, adapterRegistry } from './adapters';
+
+/**
+ * Result of test generation for a single feature file
+ */
+export interface GeneratedTest {
+  featureName: string;
+  filePath: string;
+  code: string;
+  sourceFile?: string;  // Source feature file path
+  stepCount?: number;   // Total steps in generated test
+}
+
+export class CodeGenerator {
+  private stepMapper: StepMapper;
+  private adapter: TestGeneratorAdapter;
+  private screenName?: string;
+
+  constructor(options: { useAI?: boolean; verbose?: boolean; framework?: string; baseURL?: string; screenName?: string } = {}) {
+    this.screenName = options.screenName;
+    this.stepMapper = new StepMapper(options);
+    
+    // Get adapter from registry (default: playwright)
+    const frameworkName = options.framework || 'playwright';
+    this.adapter = adapterRegistry.getAdapter(frameworkName);
+    
+    if (options.verbose) {
+      console.log(`[CodeGenerator] Using ${this.adapter.frameworkName} adapter`);
+    }
+  }
+
+  /**
+   * Generate test file from parsed feature
+   */
+  async generateTest(
+    feature: ParsedFeature,
+    outputDir: string
+  ): Promise<GeneratedTest> {
+    // Use source file name if available, otherwise derive from feature name
+    let fileName: string;
+    if (feature.sourceFile) {
+      // Extract filename and replace .feature with .spec.ts
+      const baseName = path.basename(feature.sourceFile, path.extname(feature.sourceFile));
+      fileName = `${baseName}.spec.ts`;
+    } else {
+      // Fallback to converting feature name
+      fileName = this.featureNameToFileName(feature.name);
+    }
+    
+    // Extract screen name from source file path if available
+    // qa/screens/{screenName}/features/{featureName}.feature -> screenName
+    let screenSubdir = '';
+    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) {
+        screenSubdir = parts[screensIndex + 1]; // screen name after 'screens'
+      }
+    }
+    
+    // Build output path with screen subdirectory
+    const filePath = screenSubdir 
+      ? path.join(outputDir, screenSubdir, fileName)
+      : path.join(outputDir, fileName);
+
+    // Generate imports using adapter
+    const imports = this.adapter.renderImports();
+
+    // Generate test code (async now to support AI mapping)
+    const testCode = await this.generateTestCode(feature);
+
+    // Combine
+    const code = `${imports}\n\n${testCode}`;
+
+    return {
+      featureName: feature.name,
+      filePath,
+      code,
+      sourceFile: feature.sourceFile,
+      stepCount: this.countSteps(feature),
+    };
+  }
+
+  /**
+   * Count total steps in feature (excluding background)
+   */
+  private countSteps(feature: ParsedFeature): number {
+    let total = 0;
+    for (const scenario of feature.scenarios) {
+      total += scenario.steps.length;
+    }
+    return total;
+  }
+
+  /**
+   * Write generated test to file
+   */
+  writeTest(generatedTest: GeneratedTest): void {
+    const dir = path.dirname(generatedTest.filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(generatedTest.filePath, generatedTest.code, 'utf-8');
+  }
+
+  private async generateTestCode(feature: ParsedFeature): Promise<string> {
+    // Extract feature name from source file if available, otherwise derive from feature name
+    let featureName: string;
+    if (feature.sourceFile) {
+      // Extract filename without extension: "/path/to/login.feature" -> "login"
+      featureName = path.basename(feature.sourceFile, path.extname(feature.sourceFile));
+    } else {
+      // Fallback: derive from feature name (e.g., "User Authentication - Login" -> "login")
+      featureName = this.featureNameToFileName(feature.name).replace('.spec.ts', '');
+    }
+    
+    // Set feature context for data resolution and navigation
+    this.stepMapper.setFeatureContext(featureName, feature.path);
+    
+    // Generate background if exists
+    let background: string | undefined;
+    if (feature.background) {
+      background = await this.generateBeforeEach(feature.background);
+    }
+
+    // Generate all scenarios
+    const scenarios: string[] = [];
+    for (const scenario of feature.scenarios) {
+      scenarios.push(await this.generateScenario(scenario, !!feature.background));
+    }
+
+    // Use adapter to render the complete test file structure
+    return this.adapter.renderTestFile({
+      imports: '', // Not used in template as it's rendered separately
+      featureName: feature.name,
+      featureDescription: feature.description,
+      background,
+      scenarios,
+    });
+  }
+
+  private async generateBeforeEach(background: ParsedScenario): Promise<string> {
+    // Map all steps
+    const steps: Array<{ comment?: string; code: string }> = [];
+    for (const step of background.steps) {
+      const mapped = await Promise.resolve(this.stepMapper.mapStep(step));
+      steps.push({
+        comment: mapped.comment,
+        code: this.indentCode(mapped.code, 4),
+      });
+    }
+
+    // Use adapter to render beforeEach
+    return this.adapter.renderBeforeEach({
+      steps,
+    });
+  }
+
+  private async generateScenario(scenario: ParsedScenario, hasBackground: boolean): Promise<string> {
+    // Set scenario context for path variable resolution
+    this.stepMapper.setScenarioContext(scenario.steps);
+    
+    // Map all steps
+    const steps: Array<{ comment?: string; code: string }> = [];
+    for (const step of scenario.steps) {
+      const mapped = await Promise.resolve(this.stepMapper.mapStep(step));
+      steps.push({
+        comment: mapped.comment,
+        code: this.indentCode(mapped.code, 4),
+      });
+    }
+
+    // Use adapter to render scenario
+    return this.adapter.renderScenario({
+      scenarioName: scenario.name,
+      steps,
+    });
+  }
+
+  /**
+   * Indent code lines with specified number of spaces
+   */
+  private indentCode(code: string, spaces: number): string {
+    const indentation = ' '.repeat(spaces);
+    return code.split('\n').map(line => indentation + line).join('\n');
+  }
+
+  /**
+   * Convert feature name to file name
+   * Example: "User Login" → "user-login.spec.ts"
+   */
+  private featureNameToFileName(featureName: string): string {
+    return (
+      featureName
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '') + '.spec.ts'
+    );
+  }
+
+  /**
+   * Generate tests for all features in a directory
+   */
+  async generateAllTests(
+    featuresDir: string,
+    outputDir: string,
+    featureFiles: string[]
+  ): Promise<GeneratedTest[]> {
+    const { GherkinParser } = require('../gherkin-parser');
+    const parser = new GherkinParser();
+
+    const results: GeneratedTest[] = [];
+
+    for (const featureFile of featureFiles) {
+      try {
+        const feature = parser.parseFeatureFile(featureFile);
+        const generatedTest = await this.generateTest(feature, outputDir);
+        this.writeTest(generatedTest);
+        results.push(generatedTest);
+
+        console.log(`✓ Generated: ${path.basename(generatedTest.filePath)}`);
+      } catch (error) {
+        console.error(`✗ Failed to generate test for ${featureFile}:`, error);
+      }
+    }
+
+    return results;
+  }
+}