qa360 1.4.5 → 2.0.1

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

@@ -0,0 +1,307 @@
+/**
+ * QA360 Code Formatter
+ *
+ * Formats and validates generated test code.
+ * Supports TypeScript, JavaScript, Go, and Python.
+ */
+/**
+ * Code Formatter class
+ */
+export class CodeFormatter {
+    config;
+    defaultConfig = {
+        indentStyle: 'spaces',
+        indentSize: 2,
+        lineWidth: 120,
+        semicolons: true,
+        quotes: 'single',
+        trailingCommas: true,
+        sortImports: true,
+    };
+    constructor(config = {}) {
+        this.config = { ...this.defaultConfig, ...config };
+    }
+    /**
+     * Format code based on language
+     */
+    format(code, language) {
+        switch (language.toLowerCase()) {
+            case 'typescript':
+            case 'ts':
+                return this.formatTypeScript(code);
+            case 'javascript':
+            case 'js':
+                return this.formatJavaScript(code);
+            case 'go':
+                return this.formatGo(code);
+            case 'python':
+            case 'py':
+                return this.formatPython(code);
+            default:
+                return this.formatGeneric(code);
+        }
+    }
+    /**
+     * Format TypeScript code
+     */
+    formatTypeScript(code) {
+        let formatted = code;
+        // Sort imports if enabled
+        if (this.config.sortImports) {
+            formatted = this.sortImports(formatted);
+        }
+        // Normalize quotes
+        formatted = this.normalizeQuotes(formatted);
+        // Normalize spacing around braces
+        formatted = this.normalizeBraces(formatted);
+        // Fix common formatting issues
+        formatted = this.fixCommonIssues(formatted);
+        return formatted;
+    }
+    /**
+     * Format JavaScript code
+     */
+    formatJavaScript(code) {
+        // Same as TypeScript for now
+        return this.formatTypeScript(code);
+    }
+    /**
+     * Format Go code
+     */
+    formatGo(code) {
+        let formatted = code;
+        // Go uses tabs, normalize indentation
+        if (this.config.indentStyle === 'spaces') {
+            // Convert spaces to tabs for Go (Go convention)
+            formatted = formatted.replace(/^( {2,})/gm, (match) => {
+                return '\t'.repeat(match.length / 2);
+            });
+        }
+        // Remove trailing whitespace
+        formatted = formatted.replace(/[ \t]+$/gm, '');
+        // Ensure file ends with newline
+        if (!formatted.endsWith('\n')) {
+            formatted += '\n';
+        }
+        return formatted;
+    }
+    /**
+     * Format Python code
+     */
+    formatPython(code) {
+        let formatted = code;
+        // Python uses 4 spaces by convention
+        // Normalize indentation to 4 spaces
+        formatted = this.normalizePythonIndentation(formatted);
+        // Remove trailing whitespace
+        formatted = formatted.replace(/[ \t]+$/gm, '');
+        // Ensure file ends with newline
+        if (!formatted.endsWith('\n')) {
+            formatted += '\n';
+        }
+        return formatted;
+    }
+    /**
+     * Generic formatting
+     */
+    formatGeneric(code) {
+        let formatted = code;
+        // Remove trailing whitespace
+        formatted = formatted.replace(/[ \t]+$/gm, '');
+        // Ensure file ends with newline
+        if (!formatted.endsWith('\n')) {
+            formatted += '\n';
+        }
+        return formatted;
+    }
+    /**
+     * Validate code syntax
+     */
+    validate(code, language) {
+        const errors = [];
+        const warnings = [];
+        // Check for common issues
+        if (!code.trim()) {
+            errors.push('Code is empty');
+        }
+        // Check for balanced braces
+        const openBraces = (code.match(/\{/g) || []).length;
+        const closeBraces = (code.match(/\}/g) || []).length;
+        if (openBraces !== closeBraces) {
+            errors.push(`Unbalanced braces: ${openBraces} open, ${closeBraces} close`);
+        }
+        // Check for balanced parentheses
+        const openParens = (code.match(/\(/g) || []).length;
+        const closeParens = (code.match(/\)/g) || []).length;
+        if (openParens !== closeParens) {
+            errors.push(`Unbalanced parentheses: ${openParens} open, ${closeParens} close`);
+        }
+        // Check for balanced brackets
+        const openBrackets = (code.match(/\[/g) || []).length;
+        const closeBrackets = (code.match(/\]/g) || []).length;
+        if (openBrackets !== closeBrackets) {
+            errors.push(`Unbalanced brackets: ${openBrackets} open, ${closeBrackets} close`);
+        }
+        // Language-specific checks
+        if (language === 'typescript' || language === 'javascript') {
+            // Check for TODO comments
+            const todos = code.match(/TODO|FIXME|XXX/gi);
+            if (todos) {
+                warnings.push(`Found ${todos.length} TODO/FIXME comments`);
+            }
+            // Check for console.log
+            const consoleLogs = code.match(/console\.log/g);
+            if (consoleLogs && consoleLogs.length > 2) {
+                warnings.push(`Found ${consoleLogs.length} console.log statements`);
+            }
+            // Check for any declarations
+            if (code.includes(' any')) {
+                warnings.push('Using "any" type - consider specific types');
+            }
+        }
+        return {
+            formatted: this.format(code, language),
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Sort imports
+     */
+    sortImports(code) {
+        const lines = code.split('\n');
+        const importSection = [];
+        const rest = [];
+        let inImports = false;
+        let afterImports = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('import ')) {
+                inImports = true;
+                importSection.push(line);
+            }
+            else if (inImports && (trimmed.startsWith('//') || trimmed === '')) {
+                importSection.push(line);
+            }
+            else {
+                if (inImports) {
+                    afterImports = true;
+                }
+                inImports = false;
+                rest.push(line);
+            }
+        }
+        // Sort imports alphabetically
+        const sortedImports = this.sortImportLines(importSection);
+        return [...sortedImports, ...rest].join('\n');
+    }
+    /**
+     * Sort import lines
+     */
+    sortImportLines(importLines) {
+        // Separate by type: npm imports, relative imports, blank lines/comments
+        const npmImports = [];
+        const relativeImports = [];
+        const others = [];
+        for (const line of importLines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('//') || trimmed === '') {
+                others.push(line);
+            }
+            else if (trimmed.includes("from '")) {
+                const fromMatch = trimmed.match(/from\s+['"]([^'"]+)['"]/);
+                if (fromMatch) {
+                    const from = fromMatch[1];
+                    if (from.startsWith('.') || from.startsWith('/')) {
+                        relativeImports.push(line);
+                    }
+                    else {
+                        npmImports.push(line);
+                    }
+                }
+            }
+            else {
+                others.push(line);
+            }
+        }
+        // Sort each group
+        npmImports.sort();
+        relativeImports.sort();
+        return [...others, ...npmImports, ...relativeImports];
+    }
+    /**
+     * Normalize quotes
+     */
+    normalizeQuotes(code) {
+        if (this.config.quotes === 'single') {
+            // Replace double quotes with single (except for escaped quotes)
+            return code.replace(/"([^"\\]*(\\.[^"\\]*)*)"/g, (_, content) => {
+                // Check if there are escaped single quotes inside
+                if (content.includes("\\'")) {
+                    return `"${content}"`;
+                }
+                return `'${content.replace(/"/g, '\\"')}'`;
+            });
+        }
+        else {
+            // Replace single quotes with double
+            return code.replace(/'([^'\\]*(\\.[^'\\]*)*)'/g, (_, content) => {
+                if (content.includes('\\"')) {
+                    return `'${content}'`;
+                }
+                return `"${content.replace(/'/g, "\\'")}"`;
+            });
+        }
+    }
+    /**
+     * Normalize braces spacing
+     */
+    normalizeBraces(code) {
+        // Ensure consistent spacing around braces
+        // Function declarations: function name() {
+        code = code.replace(/\s*\{\s*/g, ' {\n');
+        code = code.replace(/\s*\}\s*/g, '\n}\n');
+        return code;
+    }
+    /**
+     * Fix common formatting issues
+     */
+    fixCommonIssues(code) {
+        let fixed = code;
+        // Remove multiple consecutive blank lines
+        fixed = fixed.replace(/\n{3,}/g, '\n\n');
+        // Remove trailing whitespace
+        fixed = fixed.replace(/[ \t]+$/gm, '');
+        // Ensure file ends with newline
+        if (!fixed.endsWith('\n')) {
+            fixed += '\n';
+        }
+        return fixed;
+    }
+    /**
+     * Normalize Python indentation
+     */
+    normalizePythonIndentation(code) {
+        const lines = code.split('\n');
+        const result = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed === '') {
+                result.push('');
+                continue;
+            }
+            // Count leading spaces
+            const leadingSpaces = line.match(/^(\s*)/)?.[0]?.length || 0;
+            const indentLevel = Math.ceil(leadingSpaces / 2);
+            // Python uses 4 spaces per indent level
+            result.push(' '.repeat(indentLevel * 4) + trimmed);
+        }
+        return result.join('\n');
+    }
+}
+/**
+ * Create a formatter with default config
+ */
+export function createFormatter(config) {
+    return new CodeFormatter(config);
+}

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

@@ -0,0 +1,144 @@
+/**
+ * QA360 Code Generator
+ *
+ * Generates test code using LLM providers.
+ * Orchestrates prompt building and LLM calls.
+ */
+import { type OllamaConfig } from '../ai/index.js';
+import type { TestSpec, GenerationSource, GeneratedTest, GenerationContext } from './types.js';
+export type { GenerationSource, GeneratedTest };
+export interface GenerationResult {
+    success: boolean;
+    tests: GeneratedTest[];
+    errors?: string[];
+    warnings?: string[];
+    metadata: {
+        duration: number;
+        model: string;
+        tokensUsed: number;
+    };
+}
+/**
+ * Code generator options
+ */
+export interface CodeGeneratorOptions {
+    /**
+     * LLM provider configuration
+     */
+    ollama?: OllamaConfig;
+    /**
+     * Model to use
+     */
+    model?: string;
+    /**
+     * Temperature for generation (0-1)
+     */
+    temperature?: number;
+    /**
+     * Maximum tokens to generate
+     */
+    maxTokens?: number;
+    /**
+     * Timeout for LLM generation in milliseconds (default: 30000)
+     */
+    timeout?: number;
+    /**
+     * Format the generated code
+     */
+    formatCode?: boolean;
+    /**
+     * Optimize generated tests
+     */
+    optimize?: boolean;
+    /**
+     * Output directory for generated files
+     */
+    outputDir?: string;
+    /**
+     * Prompt builder options
+     */
+    promptOptions?: {
+        includeComments?: boolean;
+        includeDetailedAssertions?: boolean;
+        includeRetryLogic?: boolean;
+        codeStyle?: 'clean' | 'verbose' | 'concise';
+    };
+}
+/**
+ * Generated test (internal)
+ */
+export interface GeneratedTestInternal extends GeneratedTest {
+    rawCode?: string;
+}
+/**
+ * Code Generator class
+ */
+export declare class CodeGenerator {
+    private readonly provider;
+    private readonly formatter;
+    private readonly options;
+    private readonly defaultOptions;
+    constructor(options?: CodeGeneratorOptions);
+    /**
+     * Generate tests from a source
+     */
+    generateFromSource(source: GenerationSource, context: Partial<GenerationContext>): Promise<GenerationResult>;
+    /**
+     * Wrap a promise with timeout
+     * Throws QA360TimeoutError on timeout
+     */
+    private withTimeout;
+    /**
+     * Generate tests from OpenAPI spec
+     */
+    generateFromOpenAPI(specPath: string, context?: Partial<GenerationContext>): Promise<GenerationResult>;
+    /**
+     * Generate tests from HAR file
+     */
+    generateFromHAR(filePath: string, context?: Partial<GenerationContext>): Promise<GenerationResult>;
+    /**
+     * Generate tests from URL
+     */
+    generateFromUrl(url: string, context?: Partial<GenerationContext>): Promise<GenerationResult>;
+    /**
+     * Generate tests from spec
+     */
+    generateFromSpec(spec: TestSpec, context?: Partial<GenerationContext>): Promise<GenerationResult>;
+    /**
+     * Generate tests from description
+     */
+    generateFromDescription(description: string, context?: Partial<GenerationContext>): Promise<GenerationResult>;
+    /**
+     * Generate tests from code
+     */
+    generateFromCode(code: string, language: string, context?: Partial<GenerationContext>): Promise<GenerationResult>;
+    /**
+     * Extract code from LLM response
+     * Handles markdown code blocks and plain code
+     */
+    private extractCode;
+    /**
+     * Parse generated tests into separate files
+     */
+    private parseGeneratedTests;
+    /**
+     * Summarize code
+     */
+    private summarizeCode;
+    /**
+     * Get file path for generated test
+     */
+    private getFilePath;
+    /**
+     * Check if generator is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * List available models
+     */
+    listModels(): Promise<string[]>;
+}
+/**
+ * Convenience function to generate tests
+ */
+export declare function generateTests(source: GenerationSource, options?: CodeGeneratorOptions): Promise<GenerationResult>;