0xray 2.0.0

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

@@ -0,0 +1,878 @@
+/**
+ * AST Code Parser
+ *
+ * AST-based code parsing and structural analysis using ast-grep.
+ * Provides advanced code understanding, pattern detection, and refactoring insights.
+ *
+ * @version 1.0.0
+ * @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;
+    }
+}