0xray 4.0.12 → 4.0.13

package/dist/delegation/ast-code-parser.js

@@ -1,877 +0,0 @@
-/**
- * AST Code Parser
- *
- * AST-based code parsing and structural analysis using ast-grep.
- * Provides advanced code understanding, pattern detection, and refactoring insights.
- *
- * @since 2026-01-11
- */
-import * as fs from "fs";
-import * as path from "path";
-import { execSync } from "child_process";
-import { frameworkLogger } from "../core/framework-logger.js";
-export class ASTCodeParser {
-    astGrepPath = null;
-    astGrepAvailable = false;
-    patterns = [
-        // TypeScript/JavaScript patterns - direct regex for fallback
-        {
-            name: "function-definition",
-            pattern: "function\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*\\([^)]*\\)\\s*\\{",
-            language: "typescript",
-            description: "Function declarations",
-        },
-        {
-            name: "arrow-function",
-            pattern: "const\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=\\s*\\([^)]*\\)\\s*=>",
-            language: "typescript",
-            description: "Arrow function assignments",
-        },
-        {
-            name: "class-definition",
-            pattern: "class\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*(?:extends\\s+[^{]+)?\\s*\\{",
-            language: "typescript",
-            description: "Class declarations",
-        },
-        {
-            name: "import-statement",
-            pattern: "import\\s+.+?\\s+from\\s*['\"]([^'\"]+)['\"]",
-            language: "typescript",
-            description: "ES6 import statements",
-        },
-        {
-            name: "export-statement",
-            pattern: "export\\s+(?:default\\s+)?[a-zA-Z_$][a-zA-Z0-9_$]*|export\\s*\\{",
-            language: "typescript",
-            description: "Export statements",
-        },
-        {
-            name: "export-statement",
-            pattern: "export $EXPORT",
-            language: "typescript",
-            description: "Export statements",
-        },
-        {
-            name: "console-log",
-            pattern: "console\\.log\\([^)]*\\)",
-            language: "typescript",
-            description: "Console log statements (potential debugging code)",
-        },
-        {
-            name: "nested-if",
-            pattern: "if ([^}]+) \\{ if ([^}]+) \\{ [^}]* \\} \\}",
-            language: "typescript",
-            description: "Nested if statements",
-        },
-        {
-            name: "large-function",
-            pattern: "function [^\\s(]+\\([^)]*\\) \\{[^}]{100,}\\}",
-            language: "typescript",
-            description: "Large function definitions",
-        },
-        {
-            name: "magic-number",
-            pattern: "$NUM",
-            language: "typescript",
-            description: "Potential magic numbers",
-        },
-        {
-            name: "unused-variable",
-            pattern: "const $NAME = $VALUE",
-            language: "typescript",
-            description: "Variable declarations",
-        },
-        // Python patterns
-        {
-            name: "python-function",
-            pattern: "def $NAME($$$PARAMS):",
-            language: "python",
-            description: "Python function definitions",
-        },
-        {
-            name: "python-class",
-            pattern: "class $NAME:",
-            language: "python",
-            description: "Python class definitions",
-        },
-        {
-            name: "python-import",
-            pattern: "import $MODULE",
-            language: "python",
-            description: "Python import statements",
-        },
-        // Java patterns
-        {
-            name: "java-method",
-            pattern: "public $TYPE $NAME($$$PARAMS) { $$$BODY }",
-            language: "java",
-            description: "Java method declarations",
-        },
-        {
-            name: "java-class",
-            pattern: "public class $NAME { $$$BODY }",
-            language: "java",
-            description: "Java class declarations",
-        },
-    ];
-    constructor(astGrepPath) {
-        try {
-            this.astGrepPath = astGrepPath || this.findAstGrep();
-            // Verify ast-grep actually works before enabling it
-            execSync(`${this.astGrepPath} --version`, { stdio: "pipe" });
-            this.astGrepAvailable = true;
-            frameworkLogger.log("ast-code-parser", "ast-grep-available", "info", {
-                path: this.astGrepPath,
-                message: "AST parsing with ast-grep enabled",
-            });
-        }
-        catch (error) {
-            this.astGrepPath = null;
-            this.astGrepAvailable = false;
-            frameworkLogger.log("ast-code-parser", "ast-grep-unavailable", "info", {
-                error: error instanceof Error ? error.message : String(error),
-                fallback: "Using regex-based parsing fallback",
-            });
-        }
-    }
-    /**
-     * Analyze code file using AST parsing
-     */
-    async analyzeFile(filePath) {
-        const jobId = `ast-analysis-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        try {
-            const content = fs.readFileSync(filePath, "utf8");
-            const extension = path.extname(filePath).toLowerCase();
-            const language = this.detectLanguage(extension);
-            if (!language) {
-                throw new Error(`Unsupported file type: ${extension}`);
-            }
-            await frameworkLogger.log("ast-code-parser", "file-analysis-start", "info", {
-                jobId,
-                filePath,
-                language,
-                usingAstGrep: this.astGrepAvailable,
-            });
-            // Choose parsing method based on ast-grep availability
-            const structure = this.astGrepAvailable
-                ? await this.parseCodeStructureWithAstGrep(content, language, filePath, jobId)
-                : await this.parseCodeStructureWithRegex(content, language, filePath, jobId);
-            const patterns = this.astGrepAvailable
-                ? await this.detectPatternsWithAstGrep(filePath, language, jobId)
-                : await this.detectPatternsWithRegex(content, language, filePath, jobId);
-            const issues = await this.identifyIssues(structure, patterns, filePath);
-            const suggestions = this.generateRefactoringSuggestions(structure, issues);
-            const metrics = this.calculateMetrics(structure, content);
-            const analysis = {
-                structure,
-                patterns,
-                issues,
-                suggestions,
-                metrics,
-            };
-            await frameworkLogger.log("ast-code-parser", "file-analysis-complete", "success", {
-                jobId,
-                filePath,
-                functions: structure.functions.length,
-                classes: structure.classes.length,
-                issues: issues.length,
-                suggestions: suggestions.length,
-            });
-            return analysis;
-        }
-        catch (error) {
-            await frameworkLogger.log("ast-code-parser", "file-analysis-failed", "error", {
-                jobId,
-                filePath,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-        }
-    }
-    /**
-     * Parse code structure using ast-grep (advanced)
-     */
-    async parseCodeStructureWithAstGrep(content, language, filePath, jobId) {
-        const functions = [];
-        const classes = [];
-        const imports = [];
-        const exports = [];
-        const patterns = [];
-        let allPatternsFailed = true;
-        try {
-            const tempFile = `${filePath}.tmp.${Date.now()}`;
-            fs.writeFileSync(tempFile, content);
-            const langFlag = this.getAstGrepLanguageFlag(language);
-            const patternsToParse = [
-                { name: "function-definition", astPattern: "function $NAME($$$PARAMS) { $$$BODY }" },
-                { name: "arrow-function", astPattern: "const $NAME = ($$$PARAMS) => $BODY" },
-                { name: "class-definition", astPattern: "class $NAME { $$$BODY }" },
-                { name: "import-statement", astPattern: "import $IMPORTS from $MODULE" },
-            ];
-            for (const { name, astPattern } of patternsToParse) {
-                try {
-                    const output = execSync(`${this.astGrepPath} print --json --pattern '${astPattern}' --lang ${langFlag} "${tempFile}"`, { encoding: "utf8", timeout: 10000 });
-                    allPatternsFailed = false;
-                    const matches = JSON.parse(output);
-                    for (const match of matches) {
-                        if (name === "function-definition") {
-                            functions.push({
-                                name: match.captures?.NAME || "anonymous",
-                                line: match.range?.start_line || 1,
-                                parameters: this.parseParameters(match.captures?.PARAMS || ""),
-                                complexity: this.calculateFunctionComplexity(match.text || ""),
-                                lines: (match.text || "").split("\n").length,
-                            });
-                        }
-                        else if (name === "arrow-function") {
-                            functions.push({
-                                name: match.captures?.NAME || "anonymous",
-                                line: match.range?.start_line || 1,
-                                parameters: this.parseParameters(match.captures?.PARAMS || ""),
-                                complexity: 1,
-                                lines: 1,
-                            });
-                        }
-                        else if (name === "class-definition") {
-                            classes.push({
-                                name: match.captures?.NAME || "anonymous",
-                                line: match.range?.start_line || 1,
-                                methods: [],
-                                properties: [],
-                            });
-                        }
-                        else if (name === "import-statement") {
-                            imports.push({
-                                module: match.captures?.MODULE || "",
-                                names: this.parseImportNames(match.captures?.IMPORTS || ""),
-                                line: match.range?.start_line || 1,
-                                type: this.determineImportType(match.text || ""),
-                                file: filePath,
-                            });
-                        }
-                    }
-                }
-                catch (astError) {
-                    await frameworkLogger.log("ast-code-parser", "ast-grep-pattern-failed", "warning", { jobId, pattern: name, error: String(astError) });
-                }
-            }
-            fs.unlinkSync(tempFile);
-            // Fall back to regex if all patterns failed
-            if (allPatternsFailed) {
-                await frameworkLogger.log("ast-code-parser", "ast-grep-all-failed", "warning", { jobId, fallback: "Using regex fallback" });
-                return this.parseCodeStructureWithRegex(content, language, filePath, jobId);
-            }
-            const complexity = {
-                cyclomatic: this.calculateCyclomaticComplexity(content),
-                cognitive: this.calculateCognitiveComplexity(functions),
-                nesting: this.calculateMaxNesting(content),
-            };
-            return { functions, classes, imports, exports, patterns, complexity };
-        }
-        catch (error) {
-            await frameworkLogger.log("ast-code-parser", "ast-grep-fallback", "warning", { jobId, error: String(error) });
-            return this.parseCodeStructureWithRegex(content, language, filePath, jobId);
-        }
-    }
-    /**
-     * Get ast-grep language flag for a language
-     */
-    getAstGrepLanguageFlag(language) {
-        const langMap = {
-            typescript: "ts",
-            javascript: "js",
-            python: "py",
-            java: "java",
-            cpp: "cpp",
-            c: "c",
-            csharp: "cs",
-            go: "go",
-            rust: "rs",
-        };
-        return langMap[language] || language;
-    }
-    /**
-     * Parse code structure using regex (fallback)
-     */
-    async parseCodeStructureWithRegex(content, language, filePath, jobId) {
-        const functions = [];
-        const classes = [];
-        const imports = [];
-        const exports = [];
-        const patterns = [];
-        // Parse functions
-        const functionMatches = await this.findMatches(content, language, "function-definition", jobId);
-        for (const match of functionMatches) {
-            functions.push({
-                name: match.captures?.NAME || "anonymous",
-                line: match.line,
-                parameters: this.parseParameters(match.captures?.PARAMS || ""),
-                complexity: this.calculateFunctionComplexity(match.content),
-                lines: match.content.split("\n").length,
-            });
-        }
-        // Parse arrow functions
-        const arrowMatches = await this.findMatches(content, language, "arrow-function", jobId);
-        for (const match of arrowMatches) {
-            functions.push({
-                name: match.captures?.NAME || "anonymous",
-                line: match.line,
-                parameters: this.parseParameters(match.captures?.PARAMS || ""),
-                complexity: 1, // Arrow functions are typically simple
-                lines: match.content.split("\n").length,
-            });
-        }
-        // Parse classes
-        const classMatches = await this.findMatches(content, language, "class-definition", jobId);
-        for (const match of classMatches) {
-            classes.push({
-                name: match.captures?.NAME || "anonymous",
-                line: match.line,
-                methods: [],
-                properties: [],
-            });
-        }
-        // Parse imports and exports
-        const importMatches = await this.findMatches(content, language, "import-statement", jobId);
-        for (const match of importMatches) {
-            imports.push({
-                module: match.captures?.MODULE || "",
-                names: this.parseImportNames(match.captures?.IMPORTS || ""),
-                line: match.line,
-                type: this.determineImportType(match.content),
-                file: filePath,
-            });
-        }
-        const exportMatches = await this.findMatches(content, language, "export-statement", jobId);
-        for (const match of exportMatches) {
-            exports.push({
-                name: this.extractExportName(match.content),
-                type: this.determineExportType(match.content),
-                line: match.line,
-            });
-        }
-        // Calculate complexity metrics
-        const complexity = {
-            cyclomatic: this.calculateCyclomaticComplexity(content),
-            cognitive: this.calculateCognitiveComplexity(functions),
-            nesting: this.calculateMaxNesting(content),
-        };
-        return {
-            functions,
-            classes,
-            imports,
-            exports,
-            patterns,
-            complexity,
-        };
-    }
-    /**
-     * Find AST matches using ast-grep
-     */
-    async findMatches(content, language, patternName, jobId) {
-        try {
-            const pattern = this.patterns.find((p) => p.name === patternName);
-            if (!pattern) {
-                return [];
-            }
-            // For now, use regex-based matching as fallback since ast-grep might not be available
-            // In production, this would use actual ast-grep binary
-            const matches = this.regexBasedMatching(content, pattern.pattern);
-            return matches.map((match) => ({
-                pattern: patternName,
-                file: "",
-                line: match.index !== undefined
-                    ? this.getLineNumber(content, match.index)
-                    : 1,
-                column: match.index !== undefined
-                    ? match.index - content.lastIndexOf("\n", match.index)
-                    : 0,
-                content: match[0],
-                captures: this.extractCaptures(match[0], patternName),
-            }));
-        }
-        catch (error) {
-            await frameworkLogger.log("ast-code-parser", "ast-matching-failed", "error", {
-                jobId,
-                patternName,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return [];
-        }
-    }
-    /**
-     * Regex-based pattern matching (fallback when ast-grep not available)
-     */
-    regexBasedMatching(content, pattern) {
-        // For fallback, patterns are already regex strings
-        const regexPattern = pattern;
-        const regex = new RegExp(regexPattern, "g");
-        const matches = [];
-        let match;
-        while ((match = regex.exec(content)) !== null) {
-            matches.push(match);
-        }
-        return matches;
-    }
-    /**
-     * Extract named captures from regex match
-     */
-    extractCaptures(match, patternName) {
-        const captures = {};
-        // For direct regex patterns, map capture groups to expected names
-        switch (patternName) {
-            case "function-definition":
-                // Extract function name from first capture group
-                const funcMatch = match.match(/function\s+([^\s(]+)/);
-                if (funcMatch && funcMatch[1])
-                    captures["NAME"] = funcMatch[1];
-                break;
-            case "arrow-function":
-                // Extract variable name from first capture group
-                const arrowMatch = match.match(/const\s+([^\s=]+)/);
-                if (arrowMatch && arrowMatch[1])
-                    captures["NAME"] = arrowMatch[1];
-                break;
-            case "class-definition":
-                // Extract class name from first capture group
-                const classMatch = match.match(/class\s+([^\s{]+)/);
-                if (classMatch && classMatch[1])
-                    captures["NAME"] = classMatch[1];
-                break;
-            case "import-statement":
-                // Extract module name
-                const importMatch = match.match(/import .+ from ["']([^"']+)["']/);
-                if (importMatch && importMatch[1]) {
-                    captures["MODULE"] = importMatch[1];
-                }
-                break;
-            case "export-statement":
-                // Extract export content
-                const exportMatch = match.match(/export (.+)/);
-                if (exportMatch && exportMatch[1])
-                    captures["EXPORT"] = exportMatch[1];
-                break;
-        }
-        return captures;
-    }
-    /**
-     * Detect code patterns using ast-grep (advanced)
-     */
-    async detectPatternsWithAstGrep(filePath, language, jobId) {
-        const patterns = [];
-        try {
-            const langFlag = this.getAstGrepLanguageFlag(language);
-            const antiPatternRules = [
-                { name: "console-log", astPattern: "console.log($$$ARGS)", severity: "medium" },
-                { name: "nested-if", astPattern: "if ($COND) { if ($INNER) { $$$BODY } }", severity: "medium" },
-                { name: "eval-usage", astPattern: "eval($CODE)", severity: "high" },
-                { name: "inner-html", astPattern: "innerHTML = $VAL", severity: "high" },
-            ];
-            for (const rule of antiPatternRules) {
-                try {
-                    const output = execSync(`${this.astGrepPath} scan --json --pattern '${rule.astPattern}' --lang ${langFlag} "${filePath}"`, { encoding: "utf8", timeout: 10000 });
-                    const matches = JSON.parse(output || "[]");
-                    if (matches.length > 0) {
-                        patterns.push({
-                            pattern: rule.name,
-                            occurrences: matches.length,
-                            files: [filePath],
-                            type: rule.name.includes("console") || rule.name.includes("eval") || rule.name.includes("inner")
-                                ? "anti-pattern"
-                                : "refactoring-opportunity",
-                            severity: rule.severity,
-                        });
-                    }
-                }
-                catch (astError) {
-                    await frameworkLogger.log("ast-code-parser", "ast-grep-pattern-scan-failed", "warning", { jobId, pattern: rule.name, error: String(astError) });
-                }
-            }
-            await this.detectCodeSmellsWithAstGrep(filePath, language, jobId, patterns);
-        }
-        catch (error) {
-            await frameworkLogger.log("ast-code-parser", "ast-grep-detection-fallback", "warning", { jobId, error: String(error) });
-        }
-        if (patterns.length === 0) {
-            const content = fs.readFileSync(filePath, "utf8");
-            return this.detectPatternsWithRegex(content, language, filePath, jobId);
-        }
-        return patterns;
-    }
-    /**
-     * Detect code smells using ast-grep rules
-     */
-    async detectCodeSmellsWithAstGrep(filePath, language, jobId, patterns) {
-        try {
-            const langFlag = this.getAstGrepLanguageFlag(language);
-            const smellRules = [
-                { name: "long-function", astPattern: "function $NAME($$$PARAMS) { $$$BODY }", minLines: 50 },
-                { name: "complex-function", astPattern: "function $NAME($$$PARAMS) { if ($COND) { if ($INNER) { return; } } }", minLines: 10 },
-            ];
-            for (const rule of smellRules) {
-                try {
-                    const output = execSync(`${this.astGrepPath} print --json --pattern '${rule.astPattern}' --lang ${langFlag} "${filePath}"`, { encoding: "utf8", timeout: 10000 });
-                    const matches = JSON.parse(output || "[]");
-                    const largeFunctions = matches.filter((m) => {
-                        const lines = (m.text || "").split("\n").length;
-                        return lines >= rule.minLines;
-                    });
-                    if (largeFunctions.length > 0) {
-                        patterns.push({
-                            pattern: rule.name,
-                            occurrences: largeFunctions.length,
-                            files: [filePath],
-                            type: "refactoring-opportunity",
-                            severity: largeFunctions.length > 3 ? "high" : "medium",
-                        });
-                    }
-                }
-                catch {
-                    // Ignore individual rule failures
-                }
-            }
-        }
-        catch {
-            // Ignore code smell detection failures
-        }
-    }
-    /**
-     * Detect code patterns using regex (fallback)
-     */
-    async detectPatternsWithRegex(content, language, filePath, jobId) {
-        const patterns = [];
-        // Detect console.log statements (anti-pattern)
-        const consoleLogs = await this.findMatches(content, language, "console-log", jobId);
-        if (consoleLogs.length > 0) {
-            patterns.push({
-                pattern: "console.log",
-                occurrences: consoleLogs.length,
-                files: [filePath],
-                type: "anti-pattern",
-                severity: consoleLogs.length > 5 ? "high" : "medium",
-            });
-        }
-        // Detect nested if statements
-        const nestedIfs = await this.findMatches(content, language, "nested-if", jobId);
-        if (nestedIfs.length > 0) {
-            patterns.push({
-                pattern: "nested-if",
-                occurrences: nestedIfs.length,
-                files: [filePath],
-                type: "refactoring-opportunity",
-                severity: "medium",
-            });
-        }
-        // Detect large functions
-        const largeFunctions = (await this.findMatches(content, language, "large-function", jobId)).filter((match) => match.content.split("\n").length > 30);
-        if (largeFunctions.length > 0) {
-            patterns.push({
-                pattern: "large-function",
-                occurrences: largeFunctions.length,
-                files: [filePath],
-                type: "refactoring-opportunity",
-                severity: "high",
-            });
-        }
-        return patterns;
-    }
-    /**
-     * Identify code issues
-     */
-    async identifyIssues(structure, patterns, filePath) {
-        const issues = [];
-        // Check for complex functions
-        for (const func of structure.functions) {
-            if (func.complexity > 10) {
-                issues.push({
-                    type: "maintainability",
-                    severity: "high",
-                    message: `Function '${func.name}' has high complexity (${func.complexity})`,
-                    file: filePath,
-                    line: func.line,
-                    suggestion: "Consider breaking down into smaller functions",
-                });
-            }
-        }
-        // Check for anti-patterns
-        for (const pattern of patterns) {
-            if (pattern.type === "anti-pattern") {
-                issues.push({
-                    type: "maintainability",
-                    severity: pattern.severity,
-                    message: `Detected ${pattern.occurrences} instances of ${pattern.pattern}`,
-                    file: filePath,
-                    line: 1,
-                    suggestion: `Remove or replace ${pattern.pattern} usage`,
-                });
-            }
-        }
-        return issues;
-    }
-    /**
-     * Generate refactoring suggestions
-     */
-    generateRefactoringSuggestions(structure, issues) {
-        const suggestions = [];
-        for (const issue of issues) {
-            if (issue.message.includes("high complexity")) {
-                suggestions.push({
-                    type: "extract-method",
-                    description: "Extract complex function logic into smaller methods",
-                    file: issue.file,
-                    line: issue.line,
-                    impact: "high",
-                    effort: "medium",
-                });
-            }
-            else if (issue.message.includes("console.log")) {
-                suggestions.push({
-                    type: "simplify",
-                    description: "Remove console.log statements from production code",
-                    file: issue.file,
-                    line: issue.line,
-                    impact: "low",
-                    effort: "low",
-                });
-            }
-        }
-        // Suggest consolidation for duplicate imports
-        const duplicateImports = this.findDuplicateImports(structure.imports);
-        for (const dup of duplicateImports) {
-            suggestions.push({
-                type: "consolidate",
-                description: `Consolidate ${dup.names.length} duplicate imports from ${dup.module}`,
-                file: dup.file,
-                line: dup.line,
-                impact: "low",
-                effort: "low",
-            });
-        }
-        return suggestions;
-    }
-    /**
-     * Calculate code metrics
-     */
-    calculateMetrics(structure, content) {
-        const linesOfCode = content.split("\n").length;
-        return {
-            linesOfCode,
-            functions: structure.functions.length,
-            classes: structure.classes.length,
-            complexity: structure.complexity.cyclomatic,
-            duplication: 0, // Would need additional analysis
-            testCoverage: 0, // Would need test file analysis
-            maintainabilityIndex: this.calculateMaintainabilityIndex(structure, linesOfCode),
-        };
-    }
-    // Helper methods
-    detectLanguage(extension) {
-        const languageMap = {
-            ".ts": "typescript",
-            ".tsx": "typescript",
-            ".js": "javascript",
-            ".jsx": "javascript",
-            ".py": "python",
-            ".java": "java",
-            ".cpp": "cpp",
-            ".c": "c",
-            ".cs": "csharp",
-            ".php": "php",
-            ".rb": "ruby",
-            ".go": "go",
-            ".rs": "rust",
-        };
-        return languageMap[extension] || null;
-    }
-    findAstGrep() {
-        try {
-            // Try to find ast-grep in PATH
-            execSync("which ast-grep", { stdio: "pipe" });
-            return "ast-grep";
-        }
-        catch {
-            // Fallback to common installation paths
-            const commonPaths = [
-                "/usr/local/bin/ast-grep",
-                "/usr/bin/ast-grep",
-                "/opt/homebrew/bin/ast-grep",
-                "./node_modules/.bin/ast-grep",
-            ];
-            for (const path of commonPaths) {
-                try {
-                    fs.accessSync(path);
-                    return path;
-                }
-                catch {
-                    // Continue searching
-                }
-            }
-            throw new Error("ast-grep not found. Please install ast-grep or ensure it is in PATH.");
-        }
-    }
-    parseParameters(paramsStr) {
-        if (!paramsStr.trim())
-            return [];
-        return paramsStr.split(",").map((p) => {
-            const trimmed = p.trim();
-            const colonSplit = trimmed.split(":")[0] || trimmed;
-            const equalsSplit = colonSplit.split("=")[0] || colonSplit;
-            return equalsSplit.trim();
-        });
-    }
-    calculateFunctionComplexity(content) {
-        let complexity = 1; // Base complexity
-        // +1 for each control flow statement
-        const controlFlowKeywords = [
-            "if",
-            "else",
-            "for",
-            "while",
-            "do",
-            "switch",
-            "case",
-            "catch",
-        ];
-        for (const keyword of controlFlowKeywords) {
-            if (!keyword)
-                continue; // Skip empty keywords
-            const regex = new RegExp(`\\b${keyword}\\b`, "g");
-            const matches = content.match(regex);
-            if (matches) {
-                complexity += matches.length;
-            }
-        }
-        return complexity;
-    }
-    parseImportNames(importStr) {
-        if (!importStr.trim())
-            return [];
-        // Handle different import patterns
-        const match = importStr.match(/{([^}]+)}/);
-        if (match && match[1]) {
-            return match[1].split(",").map((name) => {
-                const trimmed = name.trim();
-                const asSplit = trimmed.split(" as ");
-                return asSplit[0] || trimmed;
-            });
-        }
-        return [importStr.trim()];
-    }
-    determineImportType(content) {
-        if (content.includes("{") && content.includes("}"))
-            return "named";
-        if (content.includes("* as"))
-            return "namespace";
-        if (content.includes("from") && !content.includes("{"))
-            return "default";
-        return "side-effect";
-    }
-    extractExportName(content) {
-        const match = content.match(/(?:export\s+)(?:const|let|var|function|class)\s+(\w+)/);
-        return match && match[1] ? match[1] : "unknown";
-    }
-    determineExportType(content) {
-        if (content.includes("default"))
-            return "default";
-        if (content.includes("function"))
-            return "function";
-        if (content.includes("class"))
-            return "class";
-        return "variable";
-    }
-    calculateCyclomaticComplexity(content) {
-        let complexity = 1;
-        const patterns = [
-            "if",
-            "else",
-            "for",
-            "while",
-            "do",
-            "switch",
-            "case",
-            "catch",
-            "&&",
-            "||",
-            "\\?",
-        ];
-        for (const pattern of patterns) {
-            const regex = new RegExp(`\\b${pattern}\\b`, "g");
-            const matches = content.match(regex);
-            if (matches) {
-                complexity += matches.length;
-            }
-        }
-        return complexity;
-    }
-    calculateCognitiveComplexity(functions) {
-        return functions.reduce((sum, func) => sum + func.complexity, 0);
-    }
-    calculateMaxNesting(content) {
-        let maxNesting = 0;
-        let currentNesting = 0;
-        let inString = false;
-        let stringChar = "";
-        for (let i = 0; i < content.length; i++) {
-            const char = content[i];
-            const nextChar = content[i + 1] || "";
-            // Handle strings
-            if ((char === '"' || char === "'") && content[i - 1] !== "\\") {
-                if (!inString) {
-                    inString = true;
-                    stringChar = char;
-                }
-                else if (char === stringChar) {
-                    inString = false;
-                    stringChar = "";
-                }
-                continue;
-            }
-            if (inString)
-                continue;
-            // Count braces
-            if (char === "{") {
-                currentNesting++;
-                maxNesting = Math.max(maxNesting, currentNesting);
-            }
-            else if (char === "}") {
-                currentNesting = Math.max(0, currentNesting - 1);
-            }
-        }
-        return maxNesting;
-    }
-    getLineNumber(content, index) {
-        return content.substring(0, index).split("\n").length;
-    }
-    calculateMaintainabilityIndex(structure, linesOfCode) {
-        // Simplified maintainability index calculation
-        const avgComplexity = structure.complexity.cyclomatic / Math.max(structure.functions.length, 1);
-        const volume = Math.log2(Math.max(linesOfCode, 1));
-        const difficulty = avgComplexity / 2;
-        return Math.max(0, Math.min(100, 171 - 5.2 * Math.log(volume) - 0.23 * difficulty));
-    }
-    findDuplicateImports(imports) {
-        const moduleGroups = new Map();
-        for (const imp of imports) {
-            if (!moduleGroups.has(imp.module)) {
-                moduleGroups.set(imp.module, []);
-            }
-            moduleGroups.get(imp.module).push(imp);
-        }
-        const duplicates = [];
-        for (const [module, moduleImports] of Array.from(moduleGroups)) {
-            if (moduleImports.length > 1) {
-                const allNames = moduleImports.flatMap((imp) => imp.names);
-                const uniqueNames = Array.from(new Set(allNames));
-                if (uniqueNames.length < allNames.length && moduleImports[0]) {
-                    duplicates.push({
-                        module,
-                        names: uniqueNames,
-                        file: moduleImports[0].file || "",
-                        line: moduleImports[0].line,
-                    });
-                }
-            }
-        }
-        return duplicates;
-    }
-}