@sun-asterisk/sungen 1.0.24 → 2.0.1

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

@@ -1,224 +0,0 @@
-/**
- * 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/auth-setup-generator.ts

@@ -1,59 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as Handlebars from 'handlebars';
-
-export interface AuthSetupGeneratorOptions {
-  roles: string[];
-  outputDir: string;  // Base specs directory
-  verbose?: boolean;
-}
-
-export class AuthSetupGenerator {
-  /**
-   * Generate auth.setup.ts if it doesn't exist
-   * Creates:
-   *   - specs/auth.setup.ts (from template)
-   *   - specs/.auth/ directory
-   *   - specs/.auth/.gitignore
-   */
-  async generateIfNeeded(options: AuthSetupGeneratorOptions): Promise<boolean> {
-    const setupFile = path.join(options.outputDir, 'auth.setup.ts');
-    
-    // Don't overwrite existing setup
-    if (fs.existsSync(setupFile)) {
-      if (options.verbose) {
-        console.log('ℹ Auth setup already exists, skipping generation');
-      }
-      return false;
-    }
-    
-    // Create .auth directory
-    const authDir = path.join(options.outputDir, '.auth');
-    fs.mkdirSync(authDir, { recursive: true });
-    
-    // Generate .gitignore (storage states are runtime artifacts)
-    const gitignore = path.join(authDir, '.gitignore');
-    fs.writeFileSync(gitignore, '*.json\n', 'utf-8');
-    
-    // Generate setup file from template
-    const template = this.loadTemplate();
-    const content = this.renderTemplate(template, { roles: options.roles });
-    fs.writeFileSync(setupFile, content, 'utf-8');
-    
-    console.log('✓ Generated specs/auth.setup.ts - Update TODOs before running tests');
-    console.log(`✓ Created specs/.auth/ directory for storage states`);
-    console.log(`  Detected roles: ${options.roles.join(', ')}`);
-    
-    return true;
-  }
-  
-  private loadTemplate(): string {
-    const templatePath = path.join(__dirname, 'templates', 'auth-setup.ts.hbs');
-    return fs.readFileSync(templatePath, 'utf-8');
-  }
-  
-  private renderTemplate(template: string, data: { roles: string[] }): string {
-    const compiled = Handlebars.compile(template);
-    return compiled(data);
-  }
-}

package/src/generators/test-generator/patterns/legacy-patterns.ts

@@ -1,104 +0,0 @@
-import { ParsedStep } from '../../gherkin-parser';
-import { StepPattern } from './types';
-
-/**
- * Helper to extract screen ID from selector reference.
- */
-function extractScreenId(selectorRef: string): string {
-  const match = selectorRef.match(/\[([\w-]+)\./);
-  return match ? match[1] : 'unknown';
-}
-
-/**
- * Legacy patterns migrated from step-mapper.ts tryLegacyPatterns().
- * These use templates that already exist (login, error-message-assertion, etc.)
- */
-export const legacyPatterns: StepPattern[] = [
-  {
-    name: 'legacy-login',
-    matcher: (step: ParsedStep) =>
-      step.text.includes('user is logged in as') && !!step.dataRef,
-    resolver: (step, context) => {
-      const varName = step.dataRef!.replace(/[^a-zA-Z0-9]/g, '_') + '_' + context.stepCounter;
-      return {
-        templateName: 'login',
-        data: { varName, dataRef: step.dataRef },
-        comment: `Login as ${step.dataRef}`,
-      };
-    },
-    priority: 9,
-  },
-  {
-    name: 'legacy-error-message',
-    matcher: (step: ParsedStep) =>
-      step.text.includes('error message') && step.text.includes('should'),
-    resolver: (step, context) => ({
-      templateName: 'error-message-assertion',
-      data: {},
-      comment: 'Assert error message is displayed',
-    }),
-    priority: 6,
-  },
-  {
-    name: 'legacy-generic-message',
-    matcher: (step: ParsedStep) =>
-      step.text.includes('message') && step.text.includes('should be displayed'),
-    resolver: (step, context) => {
-      const messageType = step.text.includes('welcome') ? 'welcome' :
-                         step.text.includes('success') ? 'success' : 'message';
-      return {
-        templateName: 'generic-message-assertion',
-        data: { messageType },
-        comment: `Assert ${messageType} message is displayed`,
-      };
-    },
-    priority: 6,
-  },
-  {
-    name: 'legacy-message-with-value',
-    matcher: (step: ParsedStep) =>
-      step.text.includes('should see message') && !!step.value,
-    resolver: (step, context) => {
-      const varName = (step.selectorRef || 'message').replace(/[^a-zA-Z0-9]/g, '_') + '_' + context.stepCounter;
-      return {
-        templateName: 'message-assertion-body',
-        data: { varName, value: step.value, selectorRef: step.selectorRef },
-        comment: `Assert message: ${step.value}`,
-      };
-    },
-    priority: 6,
-  },
-  {
-    name: 'legacy-ai-response',
-    matcher: (step: ParsedStep) =>
-      step.text.includes('user should see') && step.text.includes('AI response') && !!step.selectorRef,
-    resolver: (step, context) => {
-      const screenId = extractScreenId(step.selectorRef!);
-      const varName = step.selectorRef!.replace(/[^a-zA-Z0-9]/g, '_') + '_' + context.stepCounter;
-      return {
-        templateName: 'ai-response-assertion-selector',
-        data: { varName, selectorRef: step.selectorRef, screenId },
-        comment: `Assert AI response in ${step.selectorRef}`,
-      };
-    },
-    priority: 6,
-  },
-  {
-    name: 'legacy-message-count',
-    matcher: (step: ParsedStep) =>
-      (step.text.includes('messages in') || (step.text.includes('should contain') && step.text.includes('messages'))) &&
-      !!step.selectorRef,
-    resolver: (step, context) => {
-      const match = step.text.match(/(\d+)\s+messages?/);
-      const expectedCount = match ? parseInt(match[1]) : 1;
-      const screenId = extractScreenId(step.selectorRef!);
-      const varName = step.selectorRef!.replace(/[^a-zA-Z0-9]/g, '_') + '_' + context.stepCounter;
-      return {
-        templateName: 'message-count-assertion',
-        data: { varName, selectorRef: step.selectorRef, screenId, expectedCount },
-        comment: `Assert ${expectedCount} messages in ${step.selectorRef}`,
-      };
-    },
-    priority: 6,
-  },
-];

package/src/generators/test-generator/templates/auth-setup.ts.hbs

@@ -1,36 +0,0 @@
-import { test as setup, expect } from '@playwright/test';
-
-/**
- * Authentication Setup
- * 
- * This file creates authenticated browser contexts for your tests.
- * Update the TODOs with your application's actual login flow.
- * 
- * Generated roles: {{#each roles}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}
- */
-
-const authFile = (role: string) => `specs/.auth/${role}.json`;
-
-{{#each roles}}
-setup('authenticate as {{this}}', async ({ page }) => {
-  // TODO: Navigate to your login page
-  await page.goto('/login');
-
-  // TODO: Fill in credentials for {{this}} role
-  // Update these selectors to match your application
-  await page.getByLabel('Email').fill('{{this}}@example.com');
-  await page.getByLabel('Password').fill('{{this}}123');
-  
-  // TODO: Click login button
-  await page.getByRole('button', { name: 'Sign in' }).click();
-
-  // TODO: Wait for authentication to complete
-  // Update this to match your post-login URL or element
-  await page.waitForURL('/dashboard');
-
-  // Save authentication state
-  await page.context().storageState({ path: authFile('{{this}}') });
-});
-
-{{/each}}
-// TODO: Add more roles as needed by adding @auth:{role} tags to your features