qa360 1.4.5 → 2.0.1

package/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/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/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 };
+}

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

@@ -0,0 +1,30 @@
+/**
+ * QA360 AI Test Generation Module
+ *
+ * Generates test code from various sources using LLM.
+ * Phase 4 of AI Integration Roadmap.
+ *
+ * Components:
+ * - PromptBuilder: Build effective prompts for LLM
+ * - CodeGenerator: Generate test code from prompts
+ * - CodeFormatter: Format and validate generated code
+ * - TestOptimizer: Optimize generated tests
+ * - PackGenerator: Convert specs to QA360 pack YAML
+ * - SourceAnalyzer: Analyze source code for test requirements
+ *
+ * Supported Generators:
+ * - Playwright API tests (TypeScript)
+ * - Playwright UI tests (TypeScript)
+ * - K6 performance tests (JavaScript)
+ * - Vitest unit tests (TypeScript)
+ */
+export { PromptBuilder, PromptBuilderOptions, type BuiltPrompt } from './prompt-builder.js';
+export { CodeGenerator, CodeGeneratorOptions, type GeneratedTestInternal, type GenerationResult } from './code-generator.js';
+export { CodeFormatter, FormatterConfig, type FormatResult } from './code-formatter.js';
+export { TestOptimizer, OptimizationOptions, type OptimizationResult } from './test-optimizer.js';
+export { PackGenerator, generatePackFromApiSpec, generatePackFromUiSpec, generatePackFromPerfSpec } from './pack-generator.js';
+export { SourceAnalyzer, analyzeSourceFile, analyzeSourceDirectory, generateTestSpec } from './source-analyzer.js';
+export type { PackGeneratorOptions, PackGenerationResult } from './pack-generator.js';
+export type { SourceAnalysis, SourceAnalyzerOptions, TestSuggestion } from './source-analyzer.js';
+export type { TestSpec, ApiTestSpec, UiTestSpec, PerfTestSpec, UnitTestSpec, GenerationContext, GeneratedTest, GenerationSource, GenerationOptions, } from './types.js';
+export { generateTests, generateApiTestsFromOpenAPI, generateUiTestsFromUrl, generatePerfTests, generateUnitTests, checkGenerationAvailability, } from './generator.js';

package/dist/core/generation/index.js

@@ -0,0 +1,28 @@
+/**
+ * QA360 AI Test Generation Module
+ *
+ * Generates test code from various sources using LLM.
+ * Phase 4 of AI Integration Roadmap.
+ *
+ * Components:
+ * - PromptBuilder: Build effective prompts for LLM
+ * - CodeGenerator: Generate test code from prompts
+ * - CodeFormatter: Format and validate generated code
+ * - TestOptimizer: Optimize generated tests
+ * - PackGenerator: Convert specs to QA360 pack YAML
+ * - SourceAnalyzer: Analyze source code for test requirements
+ *
+ * Supported Generators:
+ * - Playwright API tests (TypeScript)
+ * - Playwright UI tests (TypeScript)
+ * - K6 performance tests (JavaScript)
+ * - Vitest unit tests (TypeScript)
+ */
+export { PromptBuilder } from './prompt-builder.js';
+export { CodeGenerator } from './code-generator.js';
+export { CodeFormatter } from './code-formatter.js';
+export { TestOptimizer } from './test-optimizer.js';
+export { PackGenerator, generatePackFromApiSpec, generatePackFromUiSpec, generatePackFromPerfSpec } from './pack-generator.js';
+export { SourceAnalyzer, analyzeSourceFile, analyzeSourceDirectory, generateTestSpec } from './source-analyzer.js';
+// Convenience functions
+export { generateTests, generateApiTestsFromOpenAPI, generateUiTestsFromUrl, generatePerfTests, generateUnitTests, checkGenerationAvailability, } from './generator.js';

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

@@ -0,0 +1,107 @@
+/**
+ * QA360 Pack Generator
+ *
+ * Converts generated test specifications into QA360 pack YAML format.
+ * This bridges the gap between AI-generated tests and runnable QA360 packs.
+ *
+ * @example
+ * ```typescript
+ * const generator = new PackGenerator();
+ * const packYaml = generator.generateFromApiSpec(apiSpec, {
+ *   name: 'my-api-tests',
+ *   version: 2
+ * });
+ * ```
+ */
+import { PackConfigV2 } from '../types/pack-v2.js';
+export type { TestSpec, ApiTestSpec, UiTestSpec, PerfTestSpec, UnitTestSpec, } from './types.js';
+import type { TestSpec, ApiTestSpec, UiTestSpec, PerfTestSpec } from './types.js';
+/**
+ * Pack generator options
+ */
+export interface PackGeneratorOptions {
+    /** Pack name */
+    name?: string;
+    /** Pack version (1 or 2) */
+    version?: 1 | 2;
+    /** Pack description */
+    description?: string;
+    /** Default timeout for tests */
+    timeout?: number;
+    /** Default retries */
+    retries?: number;
+    /** On failure behavior */
+    onFailure?: 'stop' | 'continue';
+    /** Include cache configuration */
+    enableCache?: boolean;
+    /** Cache TTL in milliseconds */
+    cacheTtl?: number;
+}
+/**
+ * Generated pack result
+ */
+export interface PackGenerationResult {
+    success: boolean;
+    yaml: string;
+    config: PackConfigV2;
+    warnings?: string[];
+    errors?: string[];
+}
+/**
+ * Pack Generator
+ *
+ * Converts test specifications into QA360 pack YAML format.
+ */
+export declare class PackGenerator {
+    private readonly defaults;
+    constructor(options?: PackGeneratorOptions);
+    /**
+     * Generate pack from API test specification
+     */
+    generateFromApiSpec(spec: ApiTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+    /**
+     * Generate pack from UI test specification
+     */
+    generateFromUiSpec(spec: UiTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+    /**
+     * Generate pack from performance test specification
+     */
+    generateFromPerfSpec(spec: PerfTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+    /**
+     * Generate pack from generic test specification
+     */
+    generateFromSpec(spec: TestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+    /**
+     * Format endpoint as smoke test spec
+     */
+    private formatEndpointSpec;
+    /**
+     * Format page action
+     */
+    private formatPageAction;
+    /**
+     * Extract threshold value from thresholds array
+     */
+    private extractThreshold;
+    /**
+     * Convert config to YAML string
+     * Note: This is a simple YAML generator. For production, use a proper YAML library.
+     */
+    private toYaml;
+    /**
+     * Helper to indent object properties
+     */
+    private indentObject;
+}
+/**
+ * Convenience function to generate pack from API spec
+ */
+export declare function generatePackFromApiSpec(spec: ApiTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+/**
+ * Convenience function to generate pack from UI spec
+ */
+export declare function generatePackFromUiSpec(spec: UiTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+/**
+ * Convenience function to generate pack from performance spec
+ */
+export declare function generatePackFromPerfSpec(spec: PerfTestSpec, options?: PackGeneratorOptions): PackGenerationResult;