qa360 2.1.2 → 2.1.4

package/dist/core/generation/code-generator.js

@@ -1,293 +0,0 @@
-/**
- * QA360 Code Generator
- *
- * Generates test code using LLM providers.
- * Orchestrates prompt building and LLM calls.
- */
-import { OllamaProvider } from '../ai/index.js';
-import { PromptBuilder } from './prompt-builder.js';
-import { CodeFormatter } from './code-formatter.js';
-/**
- * Code Generator class
- */
-export class CodeGenerator {
-    provider;
-    formatter;
-    options;
-    defaultOptions = {
-        ollama: {},
-        model: 'auto', // Let provider choose best model
-        temperature: 0.3, // Lower temperature for code generation
-        maxTokens: 8192,
-        timeout: 30000, // 30 seconds default timeout
-        formatCode: true,
-        optimize: false,
-        outputDir: './tests/generated',
-        promptOptions: {
-            includeComments: true,
-            includeDetailedAssertions: true,
-            includeRetryLogic: true,
-            codeStyle: 'clean',
-        },
-    };
-    constructor(options = {}) {
-        // Runtime guard: validate options before proceeding
-        if (options.timeout !== undefined && (options.timeout < 100 || options.timeout > 600000)) {
-            throw new Error(`CODE_GENERATOR: timeout must be between 100ms and 600000ms (10 minutes), got ${options.timeout}ms`);
-        }
-        if (options.temperature !== undefined && (options.temperature < 0 || options.temperature > 1)) {
-            throw new Error(`CODE_GENERATOR: temperature must be between 0 and 1, got ${options.temperature}`);
-        }
-        this.options = { ...this.defaultOptions, ...options };
-        // Initialize OllamaProvider
-        this.provider = new OllamaProvider(this.options.ollama);
-        this.formatter = new CodeFormatter();
-    }
-    /**
-     * Generate tests from a source
-     */
-    async generateFromSource(source, context) {
-        const startTime = Date.now();
-        try {
-            // Build prompt
-            const promptBuilder = new PromptBuilder(this.options.promptOptions);
-            const builtPrompt = await promptBuilder.buildFromSource(source);
-            // Generate code with timeout
-            const response = await this.withTimeout(this.provider.generate({
-                prompt: builtPrompt.user,
-                systemPrompt: builtPrompt.system,
-                temperature: this.options.temperature,
-                maxTokens: this.options.maxTokens,
-                jsonMode: false, // We want code, not JSON
-            }));
-            // Extract code from response
-            const code = this.extractCode(response.content);
-            // Parse multiple test files if present
-            const tests = this.parseGeneratedTests(code, context);
-            // Format if requested
-            if (this.options.formatCode) {
-                for (const test of tests) {
-                    test.code = this.formatter.format(test.code, test.language);
-                }
-            }
-            // Calculate file paths
-            for (const test of tests) {
-                test.filePath = this.getFilePath(test, context);
-                test.metadata = {
-                    generatedAt: new Date().toISOString(),
-                    model: response.model,
-                    tokensUsed: response.usage.totalTokens,
-                };
-            }
-            return {
-                success: true,
-                tests,
-                metadata: {
-                    duration: Date.now() - startTime,
-                    model: response.model,
-                    tokensUsed: response.usage.totalTokens,
-                },
-            };
-        }
-        catch (error) {
-            // Distinguish timeout from other errors
-            const isTimeout = error instanceof Error && error.name === 'QA360TimeoutError';
-            return {
-                success: false,
-                tests: [],
-                errors: isTimeout
-                    ? [`TIMEOUT: LLM generation exceeded ${this.options.timeout}ms limit`]
-                    : [error instanceof Error ? error.message : String(error)],
-                metadata: {
-                    duration: Date.now() - startTime,
-                    model: this.options.model,
-                    tokensUsed: 0,
-                },
-            };
-        }
-    }
-    /**
-     * Wrap a promise with timeout
-     * Throws QA360TimeoutError on timeout
-     */
-    async withTimeout(promise) {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
-        try {
-            // Note: OllamaProvider doesn't support AbortSignal natively
-            // We race the promise against a timeout
-            return await Promise.race([
-                promise,
-                new Promise((_, reject) => setTimeout(() => {
-                    const err = new Error(`TIMEOUT: Operation exceeded ${this.options.timeout}ms`);
-                    err.name = 'QA360TimeoutError';
-                    reject(err);
-                }, this.options.timeout)),
-            ]);
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Generate tests from OpenAPI spec
-     */
-    async generateFromOpenAPI(specPath, context = {}) {
-        return this.generateFromSource({ type: 'openapi', urlOrPath: specPath }, context);
-    }
-    /**
-     * Generate tests from HAR file
-     */
-    async generateFromHAR(filePath, context = {}) {
-        return this.generateFromSource({ type: 'har', filePath }, context);
-    }
-    /**
-     * Generate tests from URL
-     */
-    async generateFromUrl(url, context = {}) {
-        return this.generateFromSource({ type: 'url', url }, context);
-    }
-    /**
-     * Generate tests from spec
-     */
-    async generateFromSpec(spec, context = {}) {
-        return this.generateFromSource({ type: 'spec', spec }, context);
-    }
-    /**
-     * Generate tests from description
-     */
-    async generateFromDescription(description, context = {}) {
-        return this.generateFromSource({ type: 'description', description }, context);
-    }
-    /**
-     * Generate tests from code
-     */
-    async generateFromCode(code, language, context = {}) {
-        return this.generateFromSource({ type: 'code', code, language }, context);
-    }
-    /**
-     * Extract code from LLM response
-     * Handles markdown code blocks and plain code
-     */
-    extractCode(response) {
-        // Check for markdown code blocks
-        const codeBlockRegex = /```(?:typescript|javascript|ts|js|go|python)?\n([\s\S]+?)```/g;
-        const matches = Array.from(response.matchAll(codeBlockRegex));
-        if (matches.length > 0) {
-            // Return all code blocks concatenated
-            return matches.map(m => m[1].trim()).join('\n\n');
-        }
-        // No code blocks found, return as-is
-        return response.trim();
-    }
-    /**
-     * Parse generated tests into separate files
-     */
-    parseGeneratedTests(code, context) {
-        const tests = [];
-        // Try to split by describe blocks or test suites
-        const suiteRegex = /(?:test\.describe|describe|suite)\s*\(\s*['"]([^'"]+)['"]/g;
-        const matches = Array.from(code.matchAll(suiteRegex));
-        if (matches.length > 1) {
-            // Multiple test suites found
-            let lastIndex = 0;
-            const framework = context.framework || 'playwright';
-            const language = context.language || 'typescript';
-            for (let i = 0; i < matches.length; i++) {
-                const match = matches[i];
-                const nextMatch = matches[i + 1];
-                const startIndex = match.index || 0;
-                const endIndex = nextMatch?.index || code.length;
-                const suiteCode = code.substring(startIndex, endIndex).trim();
-                const suiteName = match[1];
-                tests.push({
-                    name: suiteName,
-                    code: suiteCode,
-                    language,
-                    framework,
-                    filePath: '', // Will be set later
-                    summary: this.summarizeCode(suiteCode),
-                });
-            }
-        }
-        else {
-            // Single test file
-            const framework = context.framework || 'playwright';
-            const language = context.language || 'typescript';
-            tests.push({
-                name: context.projectName || 'generated-tests',
-                code,
-                language,
-                framework,
-                filePath: '',
-                summary: this.summarizeCode(code),
-            });
-        }
-        return tests;
-    }
-    /**
-     * Summarize code
-     */
-    summarizeCode(code) {
-        const lines = code.split('\n').length;
-        // Count test functions
-        const testMatches = code.match(/\b(test|it)\s*\(/g) || [];
-        const testCount = testMatches.length;
-        // Count assertions
-        const assertMatches = code.match(/\b(expect|assert)\b/g) || [];
-        const assertionCount = assertMatches.length;
-        return {
-            lines,
-            testCount,
-            assertionCount,
-        };
-    }
-    /**
-     * Get file path for generated test
-     */
-    getFilePath(test, context) {
-        const outputDir = context.outputDir || this.options.outputDir;
-        const name = test.name.toLowerCase().replace(/\s+/g, '-');
-        let extension = 'ts';
-        if (test.language === 'javascript' || test.language === 'js') {
-            extension = 'js';
-        }
-        else if (test.language === 'go') {
-            extension = 'go';
-        }
-        else if (test.language === 'python') {
-            extension = 'py';
-        }
-        // Determine subdirectory based on test type
-        let subdir = '';
-        if (test.framework === 'playwright') {
-            subdir = test.name.includes('API') || test.name.includes('api') ? 'api' : 'ui';
-        }
-        else if (test.framework === 'k6') {
-            subdir = 'performance';
-        }
-        else {
-            subdir = 'unit';
-        }
-        return `${outputDir}/${subdir}/${name}.${extension}`;
-    }
-    /**
-     * Check if generator is available
-     */
-    async isAvailable() {
-        return this.provider.isAvailable();
-    }
-    /**
-     * List available models
-     */
-    async listModels() {
-        return this.provider.models;
-    }
-}
-/**
- * Convenience function to generate tests
- */
-export async function generateTests(source, options) {
-    const generator = new CodeGenerator(options);
-    return generator.generateFromSource(source, {});
-}

package/dist/core/generation/crawler-pack-generator.d.ts

@@ -1,44 +0,0 @@
-/**
- * QA360 Crawler Pack Generator
- *
- * Crawls a website and generates a complete pack.yml with E2E tests
- */
-import type { CrawlOptions, CrawlResult } from '../crawler/index.js';
-/**
- * Crawler Pack Generator Options
- */
-export interface CrawlerPackGeneratorOptions {
-    /** Base URL to crawl */
-    baseUrl: string;
-    /** Output pack file path */
-    output?: string;
-    /** Crawl options */
-    crawl?: Partial<CrawlOptions>;
-    /** Pack name */
-    packName?: string;
-    /** Include accessibility tests */
-    includeA11y?: boolean;
-    /** Include performance tests */
-    includePerf?: boolean;
-    /** Include security tests */
-    includeSecurity?: boolean;
-    /** Custom journey names */
-    journeyNames?: Record<string, string>;
-}
-/**
- * Generate pack.yml from crawled website
- */
-export declare function generatePackFromCrawl(options: CrawlerPackGeneratorOptions): Promise<{
-    success: boolean;
-    packPath?: string;
-    result?: CrawlResult;
-    error?: string;
-}>;
-/**
- * Quick crawl - generates pack without detailed analysis
- */
-export declare function quickCrawl(baseUrl: string, outputPath?: string): Promise<{
-    success: boolean;
-    packPath?: string;
-    error?: string;
-}>;

package/dist/core/generation/crawler-pack-generator.js

@@ -1,231 +0,0 @@
-/**
- * QA360 Crawler Pack Generator
- *
- * Crawls a website and generates a complete pack.yml with E2E tests
- */
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
-import { resolve, dirname } from 'path';
-import { crawlWebsite } from '../crawler/index.js';
-/**
- * Generate pack.yml from crawled website
- */
-export async function generatePackFromCrawl(options) {
-    try {
-        console.log(`🕷️  Crawling ${options.baseUrl}...`);
-        // Crawl the website
-        const crawlResult = await crawlWebsite({
-            baseUrl: options.baseUrl,
-            maxDepth: options.crawl?.maxDepth || 2,
-            maxPages: options.crawl?.maxPages || 20,
-            headless: options.crawl?.headless ?? true,
-            screenshots: false,
-            timeout: 30000,
-            excludePatterns: options.crawl?.excludePatterns,
-        });
-        if (!crawlResult.success) {
-            return {
-                success: false,
-                result: crawlResult,
-                error: 'Crawling failed',
-            };
-        }
-        console.log(`  ✅ Discovered ${crawlResult.siteMap.metadata.pagesCrawled} pages`);
-        console.log(`  ✅ Found ${crawlResult.forms.length} forms`);
-        console.log(`  ✅ Generated ${crawlResult.userJourneys.length} user journeys`);
-        // Generate pack.yml
-        const pack = generatePackFromCrawlResult(crawlResult, options);
-        // Write pack file
-        const packPath = options.output || resolve(process.cwd(), 'pack.yml');
-        const packDir = dirname(packPath);
-        if (!existsSync(packDir)) {
-            mkdirSync(packDir, { recursive: true });
-        }
-        writeFileSync(packPath, pack, 'utf-8');
-        console.log(`\n📦 Generated pack: ${packPath}`);
-        return {
-            success: true,
-            packPath,
-            result: crawlResult,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Generate pack.yml YAML from crawl result
- */
-function generatePackFromCrawlResult(crawlResult, options) {
-    const { siteMap, userJourneys, forms } = crawlResult;
-    const packName = options.packName || `${new URL(options.baseUrl).hostname.replace(/\./g, '-')}-tests`;
-    // Build gates array
-    const gates = ['ui'];
-    if (options.includeA11y)
-        gates.push('a11y');
-    // Build UI tests from user journeys
-    const uiTests = userJourneys.map((journey, index) => ({
-        name: options.journeyNames?.[journey.name] || journey.name,
-        description: journey.description,
-        path: new URL(journey.entryPoint).pathname,
-        steps: journey.steps.map((step, stepIndex) => journeyStepToUiTestStep(step, stepIndex)),
-    }));
-    // Also add form-based tests
-    for (const form of forms) {
-        if (form.purpose !== 'login' && form.purpose !== 'signup') {
-            uiTests.push({
-                name: `${form.purpose.charAt(0).toUpperCase() + form.purpose.slice(1)} Form Test`,
-                description: `Test the ${form.purpose} form`,
-                path: siteMap.pages.find(p => p.elements.forms.includes(form))?.path || '/',
-                steps: generateFormTestSteps(form),
-            });
-        }
-    }
-    // Generate YAML
-    let yaml = `# QA360 Pack - Generated by crawler
-# Source: ${options.baseUrl}
-# Generated: ${new Date().toISOString()}
-
-version: 1
-name: "${packName}"
-description: "Auto-generated E2E tests for ${new URL(options.baseUrl).hostname}"
-
-gates:
-${gates.map(g => `  - ${g}`).join('\n')}
-
-targets:
-  web:
-    baseUrl: "${options.baseUrl}"
-    headless: true
-    screenshot: "only-on-fail"
-    video: "retain-on-fail"
-
-    # Pages discovered by crawler
-    pages:
-${siteMap.pages.map(p => `      - "${p.path}"`).join('\n')}
-
-    # E2E UI tests generated from discovered user journeys
-    uiTests:
-${uiTests.map(test => generateUiTestYaml(test)).join('\n')}
-`;
-    if (siteMap.metadata.pagesCrawled > 0) {
-        yaml += `
-budgets:
-  a11y_min: 80
-  perf_p95_ms: ${Math.round(siteMap.metadata.avgLoadTime * 1.5)}
-`;
-    }
-    return yaml;
-}
-/**
- * Convert journey step to UI test step
- */
-function journeyStepToUiTestStep(step, index) {
-    const uiStep = {
-        order: index + 1,
-        action: step.action,
-        description: step.description,
-        selector: step.selector,
-        value: step.value,
-        wait: 500,
-    };
-    if (step.expected) {
-        uiStep.expected = {};
-        if (step.expected.url)
-            uiStep.expected.url = step.expected.url;
-        if (step.expected.visible)
-            uiStep.expected.visible = step.expected.visible;
-    }
-    return uiStep;
-}
-/**
- * Generate test steps for a form
- */
-function generateFormTestSteps(form) {
-    const steps = [];
-    // Navigate to form
-    steps.push({
-        order: 1,
-        action: 'navigate',
-        description: 'Navigate to form',
-        value: form.selector,
-    });
-    // Fill form fields
-    for (const field of form.fields) {
-        if (field.required) {
-            const step = {
-                order: steps.length + 1,
-                action: field.inputType === 'select-one' ? 'select' : 'fill',
-                description: `Fill ${field.name || field.inputType}`,
-                selector: field.selector,
-            };
-            if (field.inputType === 'select-one' && field.options && field.options.length > 0) {
-                step.value = field.options[0];
-            }
-            else if (field.inputType === 'email') {
-                step.value = 'test@example.com';
-            }
-            else if (field.inputType === 'tel') {
-                step.value = '+1234567890';
-            }
-            else if (field.inputType === 'checkbox') {
-                step.action = 'check';
-            }
-            else {
-                step.value = 'Test value';
-            }
-            steps.push(step);
-        }
-    }
-    // Submit form
-    if (form.submitButton) {
-        steps.push({
-            order: steps.length + 1,
-            action: 'click',
-            description: 'Submit form',
-            selector: form.submitButton.selector,
-            wait: 1000,
-        });
-    }
-    return steps;
-}
-/**
- * Generate YAML for a UI test definition
- */
-function generateUiTestYaml(test) {
-    const steps = test.steps.map(step => {
-        let yaml = `      - action: ${step.action}`;
-        if (step.description)
-            yaml += `\n        description: "${step.description}"`;
-        if (step.selector)
-            yaml += `\n        selector: "${step.selector}"`;
-        if (step.value)
-            yaml += `\n        value: "${step.value}"`;
-        if (step.expected)
-            yaml += `\n        expected: ${JSON.stringify(step.expected)}`;
-        if (step.wait)
-            yaml += `\n        wait: ${step.wait}`;
-        return yaml;
-    }).join('\n');
-    return `    - name: "${test.name}"
-      description: "${test.description || ''}"
-      path: "${test.path || '/'}"
-      steps:
-${steps}`;
-}
-/**
- * Quick crawl - generates pack without detailed analysis
- */
-export async function quickCrawl(baseUrl, outputPath) {
-    return generatePackFromCrawl({
-        baseUrl,
-        output: outputPath,
-        crawl: {
-            maxDepth: 1,
-            maxPages: 10,
-        },
-        includeA11y: true,
-    });
-}

package/dist/core/generation/generator.d.ts

@@ -1,40 +0,0 @@
-/**
- * QA360 Test Generator - Convenience Functions
- *
- * High-level functions for test generation.
- * These are the main entry points for the generation module.
- */
-import { type CodeGeneratorOptions, type GenerationResult } from './code-generator.js';
-import { type OptimizationOptions } from './test-optimizer.js';
-import type { GenerationSource } from './types.js';
-/**
- * Generate tests from various sources with optimization
- */
-export declare function generateTests(source: GenerationSource, options?: CodeGeneratorOptions & {
-    optimize?: boolean;
-    optimizationOptions?: OptimizationOptions;
-}): Promise<GenerationResult>;
-/**
- * Generate API tests from OpenAPI spec
- */
-export declare function generateApiTestsFromOpenAPI(specPath: string, options?: CodeGeneratorOptions): Promise<GenerationResult>;
-/**
- * Generate UI tests from URL
- */
-export declare function generateUiTestsFromUrl(url: string, options?: CodeGeneratorOptions): Promise<GenerationResult>;
-/**
- * Generate performance tests
- */
-export declare function generatePerfTests(specPath: string, options?: CodeGeneratorOptions): Promise<GenerationResult>;
-/**
- * Generate unit tests from code
- */
-export declare function generateUnitTests(code: string, language: string, options?: CodeGeneratorOptions): Promise<GenerationResult>;
-/**
- * Check if Ollama is available for generation
- */
-export declare function checkGenerationAvailability(): Promise<{
-    available: boolean;
-    models: string[];
-    recommended: string;
-}>;

package/dist/core/generation/generator.js

@@ -1,76 +0,0 @@
-/**
- * QA360 Test Generator - Convenience Functions
- *
- * High-level functions for test generation.
- * These are the main entry points for the generation module.
- */
-import { CodeGenerator } from './code-generator.js';
-import { TestOptimizer } from './test-optimizer.js';
-/**
- * Generate tests from various sources with optimization
- */
-export async function generateTests(source, options = {}) {
-    const { optimize = false, optimizationOptions, ...generatorOptions } = options;
-    // Generate tests
-    const generator = new CodeGenerator(generatorOptions);
-    let result = await generator.generateFromSource(source, {});
-    if (!result.success) {
-        return result;
-    }
-    // Optimize if requested
-    if (optimize) {
-        const optimizer = new TestOptimizer(optimizationOptions);
-        const optimization = optimizer.optimize(result.tests);
-        result.tests = optimization.optimized;
-        if (result.warnings) {
-            result.warnings.push(...optimization.improvements);
-        }
-        else {
-            result.warnings = optimization.improvements;
-        }
-    }
-    return result;
-}
-/**
- * Generate API tests from OpenAPI spec
- */
-export async function generateApiTestsFromOpenAPI(specPath, options) {
-    const generator = new CodeGenerator(options);
-    return generator.generateFromOpenAPI(specPath, { framework: 'playwright' });
-}
-/**
- * Generate UI tests from URL
- */
-export async function generateUiTestsFromUrl(url, options) {
-    const generator = new CodeGenerator(options);
-    return generator.generateFromUrl(url, { framework: 'playwright' });
-}
-/**
- * Generate performance tests
- */
-export async function generatePerfTests(specPath, options) {
-    const generator = new CodeGenerator(options);
-    return generator.generateFromOpenAPI(specPath, { framework: 'k6' });
-}
-/**
- * Generate unit tests from code
- */
-export async function generateUnitTests(code, language, options) {
-    const generator = new CodeGenerator(options);
-    return generator.generateFromCode(code, language, {
-        framework: language === 'typescript' ? 'vitest' : 'jest',
-    });
-}
-/**
- * Check if Ollama is available for generation
- */
-export async function checkGenerationAvailability() {
-    const generator = new CodeGenerator();
-    const available = await generator.isAvailable();
-    if (!available) {
-        return { available: false, models: [], recommended: 'deepseek-coder' };
-    }
-    const models = await generator.listModels();
-    const recommended = models.find(m => m.includes('deepseek') || m.includes('codellama') || m.includes('qwen')) || models[0] || 'deepseek-coder';
-    return { available, models, recommended };
-}