qa360 1.4.5 → 2.0.1

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

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