@mycodemap/mycodemap 1.9.0 → 2.7.0

package/dist/core/ast-complexity-analyzer.js

@@ -1,240 +1,399 @@
 // [META] since:2026-03-03 | owner:orchestrator-team | stable:true
-// [WHY] 提供基于 AST 的精确圈复杂度计算，支持函数级复杂度详情分析
-import * as ts from 'typescript';
+// [WHY] Provide the canonical complexity seam for active TS/JS/Python/Go parser flows
 import * as fs from 'fs';
 import * as path from 'path';
-// 高复杂度阈值
+import * as ts from 'typescript';
 const HIGH_COMPLEXITY_THRESHOLD = 10;
-/**
- * 基于 AST 分析单个文件的圈复杂度
- */
-function analyzeFileWithAST(filePath, sourceCode) {
-    const sourceFile = ts.createSourceFile(path.basename(filePath), sourceCode, ts.ScriptTarget.Latest, true);
-    const functionDetails = [];
-    // 遍历 AST 节点
-    function visit(node, context) {
-        // 检测函数/方法
-        let currentFunction = context.inFunction;
-        let functionName = context.functionName;
-        let functionKind = context.functionKind;
-        let functionStart = context.functionStart;
-        let cyclomatic = 1;
-        let maxDepth = 0;
-        let currentDepth = 0;
-        if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node)) {
-            currentFunction = true;
-            functionName = node.name?.getText(sourceFile) || '<anonymous>';
-            functionKind = ts.isFunctionDeclaration(node) ? 'function' : ts.isMethodDeclaration(node) ? 'method' : 'constructor';
-            functionStart = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-            cyclomatic = 1;
-            currentDepth = 0;
+const SUPPORTED_EXTENSIONS = new Map([
+    ['.ts', 'typescript'],
+    ['.tsx', 'typescript'],
+    ['.js', 'javascript'],
+    ['.jsx', 'javascript'],
+    ['.mjs', 'javascript'],
+    ['.cjs', 'javascript'],
+    ['.py', 'python'],
+    ['.go', 'go'],
+]);
+function calculateMaintainabilityIndex(loc, cyclomatic, commentRatio) {
+    const normalizedLOC = Math.max(1, loc);
+    const normalizedCC = Math.max(1, cyclomatic);
+    let mi = 100;
+    mi -= (normalizedCC - 1) * 2;
+    mi -= Math.log(normalizedLOC / 10 + 1) * 5;
+    mi += commentRatio * 15;
+    return Math.max(0, Math.min(100, Math.round(mi)));
+}
+function detectLanguageFromFilePath(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    const language = SUPPORTED_EXTENSIONS.get(extension);
+    if (!language) {
+        throw new Error(`不支持的 complexity 语言: ${filePath}`);
+    }
+    return language;
+}
+function toComplexityMetrics(fileComplexity) {
+    return {
+        cyclomatic: fileComplexity.cyclomatic,
+        cognitive: fileComplexity.cognitive,
+        maintainability: fileComplexity.maintainability,
+        details: {
+            functions: fileComplexity.functionDetails.map((detail) => ({
+                name: detail.name,
+                cyclomatic: detail.cyclomatic,
+                cognitive: detail.cognitive,
+                lines: detail.lines,
+            })),
+        },
+    };
+}
+function buildFileComplexity(filePath, lines, classes, functionDetails, cyclomatic, cognitive, maintainability) {
+    return {
+        filePath,
+        relativePath: path.basename(filePath),
+        cyclomatic,
+        cognitive,
+        maintainability,
+        functions: functionDetails.length,
+        classes,
+        lines,
+        functionDetails: functionDetails.map((detail) => ({
+            name: detail.name,
+            kind: detail.kind,
+            line: detail.line,
+            column: 1,
+            cyclomatic: detail.cyclomatic,
+            cognitive: detail.cognitive,
+            lines: detail.lines,
+            nestingDepth: detail.nestingDepth,
+            isHighComplexity: detail.cyclomatic >= HIGH_COMPLEXITY_THRESHOLD,
+        })),
+    };
+}
+function countLines(content) {
+    return content.split('\n').length;
+}
+function countCommentLines(content, language) {
+    return content
+        .split('\n')
+        .filter((line) => {
+        const trimmed = line.trim();
+        if (language === 'python') {
+            return trimmed.startsWith('#');
         }
-        // 计算控制流复杂度
-        if (currentFunction) {
-            if (ts.isIfStatement(node) || ts.isWhileStatement(node) ||
-                ts.isForStatement(node) || ts.isForInStatement(node) ||
-                ts.isForOfStatement(node) || ts.isCaseClause(node) ||
-                ts.isCatchClause(node) || ts.isConditionalExpression(node)) {
-                cyclomatic++;
-            }
-            // 三元运算符增加复杂度
-            if (ts.isConditionalExpression(node)) {
-                cyclomatic++; // 三元运算符算作一个分支
-            }
-            // 逻辑运算符增加复杂度
-            if (ts.isBinaryExpression(node)) {
-                const operator = node.operatorToken.kind;
-                if (operator === ts.SyntaxKind.AmpersandAmpersandToken ||
-                    operator === ts.SyntaxKind.BarBarToken) {
-                    // && 和 || 每个增加一个分支
-                    cyclomatic++;
-                }
+        return trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*');
+    })
+        .length;
+}
+function normalizeIndent(rawLine) {
+    return rawLine.replace(/\t/g, '    ').match(/^ */)?.[0].length ?? 0;
+}
+function stripPythonInlineComment(line) {
+    let inSingle = false;
+    let inDouble = false;
+    for (let index = 0; index < line.length; index++) {
+        const current = line[index];
+        if (current === "'" && !inDouble && line[index - 1] !== '\\') {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (current === '"' && !inSingle && line[index - 1] !== '\\') {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (current === '#' && !inSingle && !inDouble) {
+            return line.slice(0, index);
+        }
+    }
+    return line;
+}
+function countRegexMatches(value, regex) {
+    const matches = value.match(regex);
+    return matches ? matches.length : 0;
+}
+function isTypeScriptBranchNode(node) {
+    return ts.isIfStatement(node) ||
+        ts.isWhileStatement(node) ||
+        ts.isForStatement(node) ||
+        ts.isForInStatement(node) ||
+        ts.isForOfStatement(node) ||
+        ts.isCaseClause(node) ||
+        ts.isCatchClause(node) ||
+        ts.isConditionalExpression(node) ||
+        ts.isSwitchStatement(node) ||
+        ts.isTryStatement(node);
+}
+function measureTypeScriptComplexity(node) {
+    let branches = 0;
+    let maxDepth = 0;
+    const visit = (current, depth) => {
+        const isBranch = isTypeScriptBranchNode(current);
+        if (ts.isIfStatement(current) ||
+            ts.isWhileStatement(current) ||
+            ts.isForStatement(current) ||
+            ts.isForInStatement(current) ||
+            ts.isForOfStatement(current) ||
+            ts.isCaseClause(current) ||
+            ts.isCatchClause(current) ||
+            ts.isConditionalExpression(current)) {
+            branches++;
+        }
+        if (ts.isBinaryExpression(current)) {
+            const operator = current.operatorToken.kind;
+            if (operator === ts.SyntaxKind.AmpersandAmpersandToken ||
+                operator === ts.SyntaxKind.BarBarToken) {
+                branches++;
             }
         }
-        // 计算嵌套深度
-        if (ts.isIfStatement(node) || ts.isWhileStatement(node) ||
-            ts.isForStatement(node) || ts.isForInStatement(node) ||
-            ts.isForOfStatement(node) || ts.isSwitchStatement(node) ||
-            ts.isTryStatement(node)) {
-            currentDepth = context.depth + 1;
-            maxDepth = Math.max(maxDepth, currentDepth);
+        const nextDepth = isBranch ? depth + 1 : depth;
+        if (isBranch) {
+            maxDepth = Math.max(maxDepth, nextDepth);
         }
-        // 类计数
+        ts.forEachChild(current, (child) => visit(child, nextDepth));
+    };
+    visit(node, 0);
+    const cyclomatic = branches + 1;
+    return {
+        cyclomatic,
+        cognitive: cyclomatic + maxDepth * 2,
+        nestingDepth: maxDepth,
+    };
+}
+function analyzeTypeScriptFile(filePath, sourceCode) {
+    const sourceFile = ts.createSourceFile(path.basename(filePath), sourceCode, ts.ScriptTarget.Latest, true);
+    const functionDetails = [];
+    let classCount = 0;
+    const collect = (node) => {
         if (ts.isClassDeclaration(node)) {
             classCount++;
         }
-        // 递归遍历子节点
-        ts.forEachChild(node, child => {
-            visit(child, {
-                depth: currentDepth,
-                inFunction: currentFunction,
-                functionName,
-                functionKind,
-                functionStart
-            });
-        });
-        // 在函数结束时记录复杂度
-        if (currentFunction && (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node))) {
-            const endLine = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-            functionDetails.push({
-                name: functionName,
-                kind: functionKind,
-                line: functionStart.line + 1,
-                column: functionStart.character + 1,
-                cyclomatic,
-                cognitive: cyclomatic + maxDepth * 2, // 认知复杂度考虑嵌套深度
-                nestingDepth: maxDepth,
-                isHighComplexity: cyclomatic >= HIGH_COMPLEXITY_THRESHOLD
-            });
-        }
-    }
-    // 先收集所有函数信息，然后计算文件级别的复杂度
-    const allFunctions = [];
-    function collectFunctions(node) {
         if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node)) {
+            const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+            const metrics = measureTypeScriptComplexity(node);
             const name = node.name?.getText(sourceFile) || '<anonymous>';
-            const kind = ts.isFunctionDeclaration(node) ? 'function' : ts.isMethodDeclaration(node) ? 'method' : 'constructor';
-            const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-            let cyclomatic = 1;
-            let maxDepth = 0;
-            // 统计函数内的控制流
-            function countControlFlow(n, depth) {
-                if (ts.isIfStatement(n) || ts.isWhileStatement(n) ||
-                    ts.isForStatement(n) || ts.isForInStatement(n) ||
-                    ts.isForOfStatement(n) || ts.isCaseClause(n) ||
-                    ts.isCatchClause(n)) {
-                    cyclomatic++;
-                }
-                if (ts.isConditionalExpression(n)) {
-                    cyclomatic++;
-                }
-                if (ts.isBinaryExpression(n)) {
-                    const operator = n.operatorToken.kind;
-                    if (operator === ts.SyntaxKind.AmpersandAmpersandToken ||
-                        operator === ts.SyntaxKind.BarBarToken) {
-                        cyclomatic++;
-                    }
-                }
-                if (ts.isIfStatement(n) || ts.isWhileStatement(n) ||
-                    ts.isForStatement(n) || ts.isForInStatement(n) ||
-                    ts.isForOfStatement(n) || ts.isSwitchStatement(n) ||
-                    ts.isTryStatement(n)) {
-                    maxDepth = Math.max(maxDepth, depth + 1);
-                }
-                ts.forEachChild(n, child => countControlFlow(child, ts.isBlock(n) ? depth : depth + (ts.isIfStatement(n) || ts.isWhileStatement(n) || ts.isForStatement(n) ? 1 : 0)));
-            }
-            countControlFlow(node, 0);
-            allFunctions.push({
+            functionDetails.push({
                 name,
-                kind,
-                line: start.line + 1,
-                cyclomatic,
-                cognitive: cyclomatic + maxDepth * 2,
-                nestingDepth: maxDepth
+                kind: ts.isConstructorDeclaration(node)
+                    ? 'constructor'
+                    : ts.isMethodDeclaration(node)
+                        ? 'method'
+                        : 'function',
+                line: position.line + 1,
+                cyclomatic: metrics.cyclomatic,
+                cognitive: metrics.cognitive,
+                lines: sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line - position.line + 1,
+                nestingDepth: metrics.nestingDepth,
             });
         }
-        ts.forEachChild(node, collectFunctions);
+        ts.forEachChild(node, collect);
+    };
+    collect(sourceFile);
+    const fileMetrics = measureTypeScriptComplexity(sourceFile);
+    const lines = countLines(sourceCode);
+    const commentRatio = countCommentLines(sourceCode, 'typescript') / Math.max(1, lines);
+    return buildFileComplexity(filePath, lines, classCount, functionDetails, fileMetrics.cyclomatic, fileMetrics.cognitive, calculateMaintainabilityIndex(lines, fileMetrics.cyclomatic, commentRatio));
+}
+function countPythonBranchTokens(line) {
+    let branches = countRegexMatches(line, /\b(if|elif|for|while|except|assert)\b/g);
+    branches += countRegexMatches(line, /\b(and|or)\b/g);
+    if (/\bif\b.+\belse\b/.test(line)) {
+        branches++;
     }
-    collectFunctions(sourceFile);
-    // 统计类数量
-    let classCount = 0;
-    function countClasses(n) {
-        if (ts.isClassDeclaration(n)) {
-            classCount++;
+    return branches;
+}
+function countPythonClasses(content) {
+    return content
+        .split('\n')
+        .filter((line) => /^\s*class\s+\w+/.test(stripPythonInlineComment(line)))
+        .length;
+}
+function analyzePythonFile(filePath, content) {
+    const lines = content.split('\n');
+    const classStack = [];
+    const functionStack = [];
+    const functionDetails = [];
+    let fileBranches = 0;
+    let fileMaxDepth = 0;
+    const finalizeFunctions = (indent, lineNumber) => {
+        while (functionStack.length > 0 && indent <= functionStack[functionStack.length - 1].indent) {
+            const current = functionStack.pop();
+            functionDetails.push({
+                name: current.qualifiedName,
+                kind: current.kind,
+                line: current.startLine,
+                cyclomatic: current.branchCount + 1,
+                cognitive: current.branchCount + 1 + current.maxDepth * 2,
+                lines: Math.max(1, lineNumber - current.startLine),
+                nestingDepth: current.maxDepth,
+            });
         }
-        ts.forEachChild(n, countClasses);
-    }
-    countClasses(sourceFile);
-    // 计算文件级别的圈复杂度
-    let fileCyclomatic = 1;
-    function countFileControlFlow(n) {
-        if (ts.isIfStatement(n) || ts.isWhileStatement(n) ||
-            ts.isForStatement(n) || ts.isForInStatement(n) ||
-            ts.isForOfStatement(n) || ts.isCatchClause(n)) {
-            fileCyclomatic++;
+    };
+    lines.forEach((rawLine, index) => {
+        const line = stripPythonInlineComment(rawLine);
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            return;
         }
-        // switch 语句: 每个 case 增加复杂度 (不包括 default)
-        if (ts.isCaseClause(n)) {
-            fileCyclomatic++;
+        const indent = normalizeIndent(rawLine);
+        finalizeFunctions(indent, index + 1);
+        while (classStack.length > 0 && indent <= classStack[classStack.length - 1].indent) {
+            classStack.pop();
         }
-        // 三元运算符增加复杂度
-        if (ts.isConditionalExpression(n)) {
-            fileCyclomatic++;
+        const classMatch = trimmed.match(/^class\s+([A-Za-z_]\w*)/);
+        if (classMatch) {
+            classStack.push({ indent, name: classMatch[1] });
+            return;
         }
-        if (ts.isBinaryExpression(n)) {
-            const operator = n.operatorToken.kind;
-            if (operator === ts.SyntaxKind.AmpersandAmpersandToken ||
-                operator === ts.SyntaxKind.BarBarToken) {
-                fileCyclomatic++;
+        const functionMatch = trimmed.match(/^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/);
+        if (functionMatch) {
+            const currentClass = classStack[classStack.length - 1];
+            const currentFunction = functionStack[functionStack.length - 1];
+            const isMethod = Boolean(currentClass && (!currentFunction || currentClass.indent >= currentFunction.indent));
+            const name = functionMatch[1];
+            functionStack.push({
+                indent,
+                startLine: index + 1,
+                name,
+                qualifiedName: isMethod ? `${currentClass.name}.${name}` : name,
+                kind: isMethod ? 'method' : 'function',
+                branchCount: 0,
+                maxDepth: 0,
+            });
+            return;
+        }
+        const branches = countPythonBranchTokens(trimmed);
+        if (branches === 0) {
+            return;
+        }
+        fileBranches += branches;
+        const fileDepth = Math.floor(indent / 4) + 1;
+        fileMaxDepth = Math.max(fileMaxDepth, fileDepth);
+        const currentFunction = functionStack[functionStack.length - 1];
+        if (!currentFunction) {
+            return;
+        }
+        currentFunction.branchCount += branches;
+        const relativeDepth = Math.max(1, Math.floor(Math.max(0, indent - currentFunction.indent - 4) / 4) + 1);
+        currentFunction.maxDepth = Math.max(currentFunction.maxDepth, relativeDepth);
+    });
+    finalizeFunctions(-1, lines.length + 1);
+    const totalLines = countLines(content);
+    const commentRatio = countCommentLines(content, 'python') / Math.max(1, totalLines);
+    const cyclomatic = fileBranches + 1;
+    return buildFileComplexity(filePath, totalLines, countPythonClasses(content), functionDetails, cyclomatic, cyclomatic + fileMaxDepth * 2, calculateMaintainabilityIndex(totalLines, cyclomatic, commentRatio));
+}
+function findMatchingBrace(content, openBraceIndex) {
+    let depth = 0;
+    for (let index = openBraceIndex; index < content.length; index++) {
+        const current = content[index];
+        if (current === '{') {
+            depth++;
+        }
+        else if (current === '}') {
+            depth--;
+            if (depth === 0) {
+                return index;
             }
         }
-        ts.forEachChild(n, countFileControlFlow);
     }
-    countFileControlFlow(sourceFile);
-    // 计算认知复杂度（考虑嵌套）
-    let maxNesting = 0;
-    function countNesting(n, depth) {
-        if (ts.isIfStatement(n) || ts.isWhileStatement(n) ||
-            ts.isForStatement(n) || ts.isForInStatement(n) ||
-            ts.isForOfStatement(n) || ts.isSwitchStatement(n) ||
-            ts.isTryStatement(n)) {
-            maxNesting = Math.max(maxNesting, depth + 1);
+    return content.length - 1;
+}
+function getLineNumber(content, index) {
+    return content.slice(0, index).split('\n').length;
+}
+function countGoBranchTokens(line) {
+    let branches = countRegexMatches(line, /\b(if|for|switch|case|select)\b/g);
+    branches += countRegexMatches(line, /&&|\|\|/g);
+    return branches;
+}
+function extractGoFunctions(content) {
+    const functions = [];
+    const functionRegex = /func\s+(?:\([^)]+\)\s+)?([A-Za-z_]\w*)\s*\([^)]*\)\s*[^{]*\{/g;
+    let match;
+    while ((match = functionRegex.exec(content)) !== null) {
+        const name = match[1];
+        const braceIndex = content.indexOf('{', match.index);
+        if (!name || braceIndex === -1) {
+            continue;
+        }
+        functions.push({
+            name,
+            startLine: getLineNumber(content, match.index),
+            startOffset: braceIndex,
+            endOffset: findMatchingBrace(content, braceIndex),
+        });
+    }
+    return functions;
+}
+function measureGoFunctionComplexity(content, range) {
+    const body = content.slice(range.startOffset + 1, range.endOffset);
+    const lines = body.split('\n');
+    let branchCount = 0;
+    let maxDepth = 0;
+    let braceDepth = 0;
+    for (const rawLine of lines) {
+        const trimmed = rawLine.trim();
+        if (!trimmed) {
+            braceDepth += countRegexMatches(rawLine, /{/g) - countRegexMatches(rawLine, /}/g);
+            continue;
+        }
+        const branches = countGoBranchTokens(trimmed);
+        if (branches > 0) {
+            branchCount += branches;
+            maxDepth = Math.max(maxDepth, braceDepth + 1);
         }
-        ts.forEachChild(n, child => countNesting(child, ts.isBlock(n) ? depth : depth));
+        braceDepth += countRegexMatches(rawLine, /{/g) - countRegexMatches(rawLine, /}/g);
     }
-    countNesting(sourceFile, 0);
-    const fileCognitive = fileCyclomatic + maxNesting * 2;
-    // 计算可维护性指数
-    const lines = sourceCode.split('\n').length;
-    const commentLines = sourceCode.split('\n').filter(line => line.trim().startsWith('//') || line.trim().startsWith('/*') || line.trim().startsWith('*')).length;
-    const commentRatio = commentLines / Math.max(1, lines);
-    const maintainability = calculateMaintainabilityIndex(lines, fileCyclomatic, commentRatio);
+    const cyclomatic = branchCount + 1;
     return {
-        filePath,
-        relativePath: path.basename(filePath),
-        cyclomatic: fileCyclomatic,
-        cognitive: fileCognitive,
-        maintainability,
-        functions: allFunctions.length,
-        classes: classCount,
-        lines,
-        functionDetails: allFunctions.map(f => ({
-            name: f.name,
-            kind: f.kind,
-            line: f.line,
-            column: 1,
-            cyclomatic: f.cyclomatic,
-            cognitive: f.cognitive,
-            nestingDepth: f.nestingDepth,
-            isHighComplexity: f.cyclomatic >= HIGH_COMPLEXITY_THRESHOLD
-        }))
+        name: range.name,
+        kind: 'function',
+        line: range.startLine,
+        cyclomatic,
+        cognitive: cyclomatic + maxDepth * 2,
+        lines: Math.max(1, body.split('\n').length),
+        nestingDepth: maxDepth,
     };
 }
-/**
- * 计算可维护性指数
- */
-function calculateMaintainabilityIndex(loc, cyclomatic, commentRatio) {
-    const normalizedLOC = Math.max(1, loc);
-    const normalizedCC = Math.max(1, cyclomatic);
-    let mi = 100;
-    mi -= (normalizedCC - 1) * 2;
-    mi -= Math.log(normalizedLOC / 10 + 1) * 5;
-    mi += commentRatio * 15;
-    return Math.max(0, Math.min(100, Math.round(mi)));
+function analyzeGoFile(filePath, content) {
+    const functionRanges = extractGoFunctions(content);
+    const functionDetails = functionRanges.map((range) => measureGoFunctionComplexity(content, range));
+    const totalLines = countLines(content);
+    const commentRatio = countCommentLines(content, 'go') / Math.max(1, totalLines);
+    const totalBranches = countRegexMatches(content, /\b(if|for|switch|case|select)\b/g) + countRegexMatches(content, /&&|\|\|/g);
+    const maxDepth = functionDetails.reduce((highest, detail) => Math.max(highest, detail.nestingDepth), 0);
+    const cyclomatic = totalBranches + 1;
+    return buildFileComplexity(filePath, totalLines, 0, functionDetails, cyclomatic, cyclomatic + maxDepth * 2, calculateMaintainabilityIndex(totalLines, cyclomatic, commentRatio));
+}
+export function analyzeFileComplexityFromContent(input) {
+    switch (input.language) {
+        case 'typescript':
+        case 'javascript':
+            return analyzeTypeScriptFile(input.filePath, input.content);
+        case 'python':
+            return analyzePythonFile(input.filePath, input.content);
+        case 'go':
+            return analyzeGoFile(input.filePath, input.content);
+        default: {
+            const exhaustiveCheck = input.language;
+            throw new Error(`不支持的 complexity 语言: ${exhaustiveCheck}`);
+        }
+    }
+}
+export function analyzeComplexityFromContent(input) {
+    return toComplexityMetrics(analyzeFileComplexityFromContent(input));
 }
-/**
- * 分析文件复杂度（公开 API）
- */
 export function analyzeFileComplexity(filePath) {
     if (!fs.existsSync(filePath)) {
         throw new Error(`文件不存在: ${filePath}`);
     }
     const sourceCode = fs.readFileSync(filePath, 'utf-8');
-    return analyzeFileWithAST(filePath, sourceCode);
+    const language = detectLanguageFromFilePath(filePath);
+    return analyzeFileComplexityFromContent({
+        filePath,
+        content: sourceCode,
+        language,
+    });
 }
-/**
- * 分析多个文件复杂度（公开 API）
- */
 export function analyzeMultipleFiles(filePaths, rootDir) {
     const files = [];
     for (const filePath of filePaths) {
@@ -257,14 +416,14 @@ export function analyzeMultipleFiles(filePaths, rootDir) {
                 averageCyclomatic: 0,
                 averageCognitive: 0,
                 averageMaintainability: 0,
-                highComplexityFunctions: 0
-            }
+                highComplexityFunctions: 0,
+            },
         };
     }
-    const totalCyclomatic = files.reduce((sum, f) => sum + f.cyclomatic, 0);
-    const totalCognitive = files.reduce((sum, f) => sum + f.cognitive, 0);
-    const totalMaintainability = files.reduce((sum, f) => sum + f.maintainability, 0);
-    const highComplexityFunctions = files.reduce((sum, f) => sum + f.functionDetails.filter(d => d.isHighComplexity).length, 0);
+    const totalCyclomatic = files.reduce((sum, file) => sum + file.cyclomatic, 0);
+    const totalCognitive = files.reduce((sum, file) => sum + file.cognitive, 0);
+    const totalMaintainability = files.reduce((sum, file) => sum + file.maintainability, 0);
+    const highComplexityFunctions = files.reduce((sum, file) => sum + file.functionDetails.filter((detail) => detail.isHighComplexity).length, 0);
     return {
         files,
         summary: {
@@ -272,8 +431,8 @@ export function analyzeMultipleFiles(filePaths, rootDir) {
             averageCyclomatic: Math.round(totalCyclomatic / files.length),
             averageCognitive: Math.round(totalCognitive / files.length),
             averageMaintainability: Math.round(totalMaintainability / files.length),
-            highComplexityFunctions
-        }
+            highComplexityFunctions,
+        },
     };
 }
 //# sourceMappingURL=ast-complexity-analyzer.js.map