qa360 2.1.2 → 2.1.4

package/dist/core/generation/source-analyzer.js

@@ -1,657 +0,0 @@
-/**
- * QA360 Source Code Analyzer
- *
- * Analyzes source code to extract test requirements and generate test specifications.
- * Supports TypeScript, JavaScript, Python, and Go source code.
- *
- * @example
- * ```typescript
- * const analyzer = new SourceAnalyzer();
- * const spec = await analyzer.analyzeFile('./src/userService.ts');
- * const tests = await analyzer.generateTests(spec);
- * ```
- */
-import { readFileSync, existsSync, readdirSync } from 'fs';
-import { join, extname, basename } from 'path';
-/**
- * Source Analyzer
- *
- * Analyzes source code to extract testable elements and suggest tests.
- */
-export class SourceAnalyzer {
-    options;
-    defaultOptions = {
-        includePrivate: false,
-        maxComplexity: 10,
-        exclude: ['node_modules', 'dist', 'build', '.git', 'coverage'],
-        followImports: false
-    };
-    constructor(options = {}) {
-        this.options = { ...this.defaultOptions, ...options };
-    }
-    /**
-     * Analyze a single source file
-     */
-    analyzeFile(filePath) {
-        if (!existsSync(filePath)) {
-            throw new Error(`Source file not found: ${filePath}`);
-        }
-        const content = readFileSync(filePath, 'utf-8');
-        const ext = extname(filePath);
-        const language = this.getLanguage(ext);
-        const analysis = {
-            filePath,
-            language,
-            exports: [],
-            functions: [],
-            classes: [],
-            imports: [],
-            hasTests: false,
-            complexity: 0,
-            linesOfCode: content.split('\n').length
-        };
-        switch (language) {
-            case 'typescript':
-            case 'javascript':
-                this.analyzeTypeScriptScript(content, analysis);
-                break;
-            case 'python':
-                this.analyzePython(content, analysis);
-                break;
-            case 'go':
-                this.analyzeGo(content, analysis);
-                break;
-        }
-        // Calculate overall complexity
-        analysis.complexity = this.calculateComplexity(analysis);
-        // Check if test file exists
-        analysis.testFilePath = this.findTestFile(filePath);
-        analysis.hasTests = analysis.testFilePath !== undefined;
-        return analysis;
-    }
-    /**
-     * Analyze a directory recursively
-     */
-    analyzeDirectory(dirPath) {
-        const results = [];
-        if (!existsSync(dirPath)) {
-            throw new Error(`Directory not found: ${dirPath}`);
-        }
-        this.traverseDirectory(dirPath, (filePath) => {
-            try {
-                const ext = extname(filePath);
-                if (this.isSourceFile(ext)) {
-                    results.push(this.analyzeFile(filePath));
-                }
-            }
-            catch (error) {
-                // Skip files that fail to analyze
-                console.warn(`Warning: Failed to analyze ${filePath}:`, error);
-            }
-        });
-        return results;
-    }
-    /**
-     * Generate test specification from analysis
-     */
-    generateSpec(analysis) {
-        const functionsToTest = analysis.exports.filter(e => {
-            const fn = analysis.functions.find(f => f.name === e);
-            return fn && fn.isPublic && fn.complexity <= this.options.maxComplexity;
-        });
-        return {
-            type: 'unit',
-            name: this.generateTestName(analysis.filePath),
-            source: {
-                language: analysis.language,
-                filePath: analysis.filePath,
-                exports: functionsToTest
-            },
-            framework: this.recommendFramework(analysis.language)
-        };
-    }
-    /**
-     * Generate test suggestions
-     */
-    generateSuggestions(analysis) {
-        const suggestions = [];
-        // Suggest unit tests for each public function
-        for (const fn of analysis.functions) {
-            if (!fn.isPublic)
-                continue;
-            const complexity = fn.complexity;
-            let priority = 'low';
-            if (complexity > this.options.maxComplexity) {
-                priority = 'high';
-            }
-            else if (complexity > 5) {
-                priority = 'medium';
-            }
-            suggestions.push({
-                type: 'unit',
-                priority,
-                description: `Test function ${fn.name}`,
-                functionName: fn.name,
-                assertions: this.generateAssertions(fn),
-                mocks: this.generateMocks(fn, analysis.imports)
-            });
-        }
-        // Suggest integration tests for classes with multiple methods
-        for (const cls of analysis.classes) {
-            if (cls.methods.length >= 3) {
-                suggestions.push({
-                    type: 'integration',
-                    priority: 'medium',
-                    description: `Test class ${cls.name} interactions`,
-                    assertions: ['class instance created', 'methods work together'],
-                    mocks: this.generateMocksForClass(cls, analysis.imports)
-                });
-            }
-        }
-        // Suggest E2E tests if external APIs are used
-        const hasExternalCalls = analysis.imports.some(i => i.isExternal && this.isHttpModule(i.module));
-        if (hasExternalCalls) {
-            suggestions.push({
-                type: 'e2e',
-                priority: 'low',
-                description: 'Test external API integrations',
-                assertions: ['API calls succeed', 'error handling works'],
-                mocks: []
-            });
-        }
-        return suggestions.sort((a, b) => {
-            const priorityOrder = { high: 0, medium: 1, low: 2 };
-            return priorityOrder[a.priority] - priorityOrder[b.priority];
-        });
-    }
-    /**
-     * Generate API spec from Express/HTTP handlers
-     */
-    generateApiSpec(analysis) {
-        const endpoints = [];
-        const baseUrl = this.extractBaseUrl(analysis);
-        for (const fn of analysis.functions) {
-            const endpoint = this.extractEndpoint(fn, analysis);
-            if (endpoint) {
-                endpoints.push(endpoint);
-            }
-        }
-        for (const cls of analysis.classes) {
-            for (const method of cls.methods) {
-                const endpoint = this.extractEndpoint(method, analysis);
-                if (endpoint) {
-                    endpoints.push(endpoint);
-                }
-            }
-        }
-        if (endpoints.length === 0) {
-            return null;
-        }
-        return {
-            type: 'api',
-            name: `${basename(analysis.filePath)} API`,
-            baseUrl,
-            endpoints
-        };
-    }
-    /**
-     * Analyze TypeScript/JavaScript code
-     */
-    analyzeTypeScriptScript(content, analysis) {
-        const lines = content.split('\n');
-        // Extract exports
-        const exportRegex = /export\s+(?:async\s+)?(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)\s*=>|function))/g;
-        for (const match of content.matchAll(exportRegex)) {
-            const name = match[1] || match[2];
-            if (name && !analysis.exports.includes(name)) {
-                analysis.exports.push(name);
-            }
-        }
-        // Extract class declarations
-        const classRegex = /export\s+class\s+(\w+)(?:\s+extends\s+(\w+))?\s*\{/g;
-        for (const match of content.matchAll(classRegex)) {
-            const className = match[1];
-            const extendsClass = match[2];
-            const classInfo = {
-                name: className,
-                methods: [],
-                properties: [],
-                extends: extendsClass,
-                lineNumber: this.findLineNumber(content, match.index)
-            };
-            // Extract class methods
-            const classContent = this.extractClassContent(content, match.index);
-            const methodRegex = /(?:public|private|protected)?\s*(?:async\s+)?(\w+)\s*\(([^)]*)\)(?:\s*:\s*(\w+))?/g;
-            for (const methodMatch of classContent.matchAll(methodRegex)) {
-                if (methodMatch[1] === 'constructor')
-                    continue;
-                classInfo.methods.push({
-                    name: methodMatch[1],
-                    params: this.parseParams(methodMatch[2]),
-                    returnType: methodMatch[3],
-                    isAsync: classContent.includes('async') && classContent.indexOf('async') < classContent.indexOf(methodMatch[1]),
-                    isPublic: !classContent.slice(0, methodMatch.index).includes('private'),
-                    lineNumber: analysis.linesOfCode,
-                    complexity: this.estimateFunctionComplexity(classContent)
-                });
-            }
-            analysis.classes.push(classInfo);
-        }
-        // Extract function declarations
-        const fnRegex = /((?:export\s+)?(?:async\s+)?function\s+\w+\s*\([^)]*\)(?:\s*:\s*\w+)?)/g;
-        for (const match of content.matchAll(fnRegex)) {
-            const fullMatch = match[1];
-            const fnNameMatch = /function\s+(\w+)/.exec(fullMatch);
-            const paramsMatch = /\(([^)]*)\)/.exec(fullMatch);
-            const returnMatch = /:\s*(\w+)/.exec(fullMatch);
-            if (fnNameMatch) {
-                // Get more context for complexity estimation (function body)
-                const fnStart = match.index;
-                const fnEnd = Math.min(fnStart + 1000, content.length); // Look ahead up to 1000 chars
-                const fnContext = content.slice(fnStart, fnEnd);
-                analysis.functions.push({
-                    name: fnNameMatch[1],
-                    params: paramsMatch ? this.parseParams(paramsMatch[1]) : [],
-                    returnType: returnMatch ? returnMatch[1] : undefined,
-                    isAsync: fullMatch.includes('async'),
-                    isPublic: this.options.includePrivate || !fullMatch.includes('private'),
-                    lineNumber: this.findLineNumber(content, match.index),
-                    complexity: this.estimateFunctionComplexity(fnContext)
-                });
-            }
-        }
-        // Extract imports
-        const importRegex = /import\s+(?:(\{[^}]+\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
-        for (const match of content.matchAll(importRegex)) {
-            const module = match[2];
-            const imports = match[1] ? match[1].replace(/[{}*\s]/g, '').split(',').filter(Boolean) : [module.split('/').pop() || module];
-            analysis.imports.push({
-                module,
-                imports,
-                isExternal: this.isExternalModule(module)
-            });
-        }
-        // Check for require statements
-        const requireRegex = /(?:const|let|var)\s+(\w+)\s*=\s*require\(['"]([^'"]+)['"]\)/g;
-        for (const match of content.matchAll(requireRegex)) {
-            analysis.imports.push({
-                module: match[2],
-                imports: [match[1]],
-                isExternal: this.isExternalModule(match[2])
-            });
-        }
-    }
-    /**
-     * Analyze Python code
-     */
-    analyzePython(content, analysis) {
-        // Extract class definitions
-        const classRegex = /^class\s+(\w+)(?:\(([^)]+)\))?\s*:/gm;
-        for (const match of content.matchAll(classRegex)) {
-            const className = match[1];
-            const baseClass = match[2];
-            analysis.classes.push({
-                name: className,
-                methods: [],
-                properties: [],
-                extends: baseClass,
-                lineNumber: this.findLineNumber(content, match.index)
-            });
-        }
-        // Extract function definitions
-        const fnRegex = /^def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*(\w+))?:/gm;
-        for (const match of content.matchAll(fnRegex)) {
-            const isPrivate = match[1].startsWith('_');
-            analysis.functions.push({
-                name: match[1],
-                params: this.parseParams(match[2]),
-                returnType: match[3],
-                isAsync: content.slice(0, match.index).trimEnd().endsWith('async'),
-                isPublic: this.options.includePrivate || !isPrivate,
-                lineNumber: this.findLineNumber(content, match.index),
-                complexity: this.estimateFunctionComplexity(content.slice(match.index, Math.min(match.index + 500, content.length)))
-            });
-            // Top-level functions are exports
-            if (!isPrivate && !content.slice(0, match.index).includes('class ')) {
-                analysis.exports.push(match[1]);
-            }
-        }
-        // Extract imports
-        const importRegex = /^(?:from\s+(\S+)\s+)?import\s+(.+)/gm;
-        for (const match of content.matchAll(importRegex)) {
-            const module = match[1] || match[2].split('.')[0];
-            const imports = match[1] ? match[2].split(',').map(s => s.trim()) : [module];
-            analysis.imports.push({
-                module,
-                imports,
-                isExternal: !module.startsWith('.')
-            });
-        }
-    }
-    /**
-     * Analyze Go code
-     */
-    analyzeGo(content, analysis) {
-        // Extract function definitions
-        const fnRegex = /func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(([^)]*)\)(?:\s*\(([^)]*)\))?/g;
-        for (const match of content.matchAll(fnRegex)) {
-            const isPrivate = match[1] && match[1][0] === match[1][0].toLowerCase();
-            analysis.exports.push(match[1]);
-            analysis.functions.push({
-                name: match[1],
-                params: this.parseParams(match[2]),
-                returnType: match[3],
-                isAsync: false,
-                isPublic: this.options.includePrivate || !isPrivate,
-                lineNumber: this.findLineNumber(content, match.index),
-                complexity: this.estimateFunctionComplexity(content.slice(match.index, match.index + 500))
-            });
-        }
-        // Extract type definitions (similar to classes)
-        const typeRegex = /type\s+(\w+)\s+struct\s*\{([^}]*)\}/g;
-        for (const match of content.matchAll(typeRegex)) {
-            analysis.classes.push({
-                name: match[1],
-                methods: [],
-                properties: match[2].split('\n').map(l => l.trim()).filter(Boolean),
-                lineNumber: this.findLineNumber(content, match.index)
-            });
-        }
-        // Extract imports
-        const importRegex = /import\s+(?:\(\s*)?["']([^"']+)["']/g;
-        for (const match of content.matchAll(importRegex)) {
-            analysis.imports.push({
-                module: match[1],
-                imports: [],
-                isExternal: !match[1].startsWith('.')
-            });
-        }
-    }
-    /**
-     * Get language from file extension
-     */
-    getLanguage(ext) {
-        const langMap = {
-            '.ts': 'typescript',
-            '.tsx': 'typescript',
-            '.js': 'javascript',
-            '.jsx': 'javascript',
-            '.py': 'python',
-            '.go': 'go'
-        };
-        return langMap[ext] || 'typescript';
-    }
-    /**
-     * Check if file is a source file
-     */
-    isSourceFile(ext) {
-        return ['.ts', '.tsx', '.js', '.jsx', '.py', '.go'].includes(ext);
-    }
-    /**
-     * Traverse directory recursively
-     */
-    traverseDirectory(dir, callback) {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = join(dir, entry.name);
-            // Skip excluded directories
-            if (this.options.exclude.some(pattern => fullPath.includes(pattern))) {
-                continue;
-            }
-            if (entry.isDirectory()) {
-                this.traverseDirectory(fullPath, callback);
-            }
-            else if (entry.isFile()) {
-                callback(fullPath);
-            }
-        }
-    }
-    /**
-     * Find test file for a source file
-     */
-    findTestFile(filePath) {
-        const dir = join(filePath, '..');
-        const base = basename(filePath, extname(filePath));
-        const ext = extname(filePath);
-        const testPatterns = [
-            join(dir, `${base}.test.ts`),
-            join(dir, `${base}.spec.ts`),
-            join(dir, `${base}.test.js`),
-            join(dir, `${base}.spec.js`),
-            join(dir, '__tests__', `${base}.test.ts`),
-            join(dir, '__tests__', `${base}.spec.ts`),
-            join(dir, 'tests', `${base}.test.ts`)
-        ];
-        for (const pattern of testPatterns) {
-            if (existsSync(pattern)) {
-                return pattern;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Calculate overall complexity score
-     */
-    calculateComplexity(analysis) {
-        let complexity = 0;
-        for (const fn of analysis.functions) {
-            complexity += fn.complexity;
-        }
-        for (const cls of analysis.classes) {
-            for (const method of cls.methods) {
-                complexity += method.complexity;
-            }
-        }
-        return complexity;
-    }
-    /**
-     * Estimate function complexity
-     */
-    estimateFunctionComplexity(code) {
-        let complexity = 1; // Base complexity
-        // Count decision points
-        const decisionPatterns = [
-            /\bif\b/g,
-            /\belse\b/g,
-            /\bfor\b/g,
-            /\bwhile\b/g,
-            /\bswitch\b/g,
-            /\bcase\b/g,
-            /\bcatch\b/g,
-            /\?\s*:/g, // ternary
-            /\|\|/g, // logical OR
-            /&&/g // logical AND
-        ];
-        for (const pattern of decisionPatterns) {
-            const matches = code.match(pattern);
-            if (matches) {
-                complexity += matches.length;
-            }
-        }
-        return complexity;
-    }
-    /**
-     * Parse function parameters
-     */
-    parseParams(paramsStr) {
-        if (!paramsStr.trim())
-            return [];
-        return paramsStr.split(',').map(p => p.trim()).filter(Boolean);
-    }
-    /**
-     * Extract class content
-     */
-    extractClassContent(content, startIndex) {
-        let depth = 0;
-        let inClass = false;
-        let result = '';
-        for (let i = startIndex; i < content.length; i++) {
-            const char = content[i];
-            if (char === '{') {
-                depth++;
-                inClass = true;
-            }
-            else if (char === '}') {
-                depth--;
-                if (inClass && depth === 0) {
-                    break;
-                }
-            }
-            if (inClass) {
-                result += char;
-            }
-        }
-        return result;
-    }
-    /**
-     * Find line number for a position in content
-     */
-    findLineNumber(content, index) {
-        return content.slice(0, index).split('\n').length;
-    }
-    /**
-     * Generate test name from file path
-     */
-    generateTestName(filePath) {
-        const base = basename(filePath, extname(filePath));
-        return base.replace(/[^a-zA-Z0-9]/g, ' ') + ' Tests';
-    }
-    /**
-     * Recommend testing framework based on language
-     */
-    recommendFramework(language) {
-        const frameworkMap = {
-            typescript: 'vitest',
-            javascript: 'vitest',
-            python: 'pytest',
-            go: 'go test'
-        };
-        return frameworkMap[language] || 'vitest';
-    }
-    /**
-     * Generate assertions for a function
-     */
-    generateAssertions(fn) {
-        const assertions = [];
-        if (fn.isAsync) {
-            assertions.push('function resolves', 'function completes without timeout');
-        }
-        if (fn.returnType?.toLowerCase().includes('void') || fn.params.length === 0) {
-            assertions.push('function executes without error');
-        }
-        else {
-            assertions.push('function returns expected value');
-        }
-        if (fn.params.length > 0) {
-            assertions.push('function handles invalid input');
-        }
-        return assertions;
-    }
-    /**
-     * Generate mocks for a function
-     */
-    generateMocks(fn, imports) {
-        const mocks = [];
-        for (const imp of imports) {
-            if (imp.isExternal && this.isHttpModule(imp.module)) {
-                mocks.push(imp.module);
-            }
-        }
-        return mocks;
-    }
-    /**
-     * Generate mocks for a class
-     */
-    generateMocksForClass(cls, imports) {
-        const mocks = [];
-        for (const imp of imports) {
-            if (imp.isExternal) {
-                mocks.push(imp.module);
-            }
-        }
-        return mocks;
-    }
-    /**
-     * Check if module is an HTTP module
-     */
-    isHttpModule(module) {
-        const httpModules = ['http', 'https', 'axios', 'fetch', 'node-fetch', 'request', 'supertest'];
-        return httpModules.some(m => module.toLowerCase().includes(m));
-    }
-    /**
-     * Check if module is external
-     */
-    isExternalModule(module) {
-        return !module.startsWith('.') && !module.startsWith('/');
-    }
-    /**
-     * Extract base URL from imports
-     */
-    extractBaseUrl(analysis) {
-        // Try to find a base URL in constants or config
-        const urlConstants = analysis.imports.filter(i => i.module.toLowerCase().includes('config') ||
-            i.module.toLowerCase().includes('constants'));
-        if (urlConstants.length > 0) {
-            return 'https://api.example.com'; // Placeholder
-        }
-        return 'https://localhost:3000';
-    }
-    /**
-     * Extract API endpoint from function
-     */
-    extractEndpoint(fn, analysis) {
-        const name = fn.name.toLowerCase();
-        // Check for HTTP method prefixes
-        const httpMethods = ['get', 'post', 'put', 'patch', 'delete'];
-        let method;
-        let path = `/${fn.name}`;
-        for (const httpMethod of httpMethods) {
-            if (name.startsWith(httpMethod)) {
-                method = httpMethod.toUpperCase();
-                path = `/${name.slice(httpMethod.length)}`;
-                break;
-            }
-        }
-        // Check for Express/Fastify patterns
-        if (fn.params.some(p => p.includes('req') || p.includes('request') || p.includes('res') || p.includes('response'))) {
-            return {
-                method: method || 'GET',
-                path,
-                description: fn.name,
-                expectations: [{ status: 200 }]
-            };
-        }
-        return null;
-    }
-    /**
-     * Get analysis as GenerationSource
-     */
-    toGenerationSource(analysis) {
-        return {
-            type: 'code',
-            code: readFileSync(analysis.filePath, 'utf-8'),
-            language: analysis.language
-        };
-    }
-}
-/**
- * Convenience function to analyze a source file
- */
-export function analyzeSourceFile(filePath, options) {
-    const analyzer = new SourceAnalyzer(options);
-    return analyzer.analyzeFile(filePath);
-}
-/**
- * Convenience function to analyze a directory
- */
-export function analyzeSourceDirectory(dirPath, options) {
-    const analyzer = new SourceAnalyzer(options);
-    return analyzer.analyzeDirectory(dirPath);
-}
-/**
- * Convenience function to generate test spec from analysis
- */
-export function generateTestSpec(analysis) {
-    const analyzer = new SourceAnalyzer();
-    return analyzer.generateSpec(analysis);
-}