qa360 2.1.2 → 2.1.4

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

@@ -1,307 +0,0 @@
-/**
- * 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

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