qa360 2.2.1 → 2.2.13

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

@@ -0,0 +1,293 @@
+/**
+ * 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/cli/dist/core/generation/crawler-pack-generator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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/cli/dist/core/generation/crawler-pack-generator.js

@@ -0,0 +1,245 @@
+/**
+ * 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;
+}
+/**
+ * Escape a string value for YAML output
+ * Handles quotes, backslashes, and special characters
+ */
+function escapeYamlString(value) {
+    if (!value)
+        return '';
+    return value
+        .replace(/\\/g, '\\\\') // Backslashes first
+        .replace(/"/g, '\\"') // Double quotes
+        .replace(/\n/g, '\\n') // Newlines
+        .replace(/\r/g, '\\r') // Carriage returns
+        .replace(/\t/g, '\\t'); // Tabs
+}
+/**
+ * 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: "${escapeYamlString(step.description)}"`;
+        if (step.selector)
+            yaml += `\n        selector: "${escapeYamlString(step.selector)}"`;
+        if (step.value)
+            yaml += `\n        value: "${escapeYamlString(String(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: "${escapeYamlString(test.name)}"
+      description: "${escapeYamlString(test.description || '')}"
+      path: "${escapeYamlString(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/cli/dist/core/generation/generator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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/cli/dist/core/generation/generator.js

@@ -0,0 +1,76 @@
+/**
+ * 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 };
+}