@minionry/minion 0.7.36

package/dist/server/services/websocket/quality-complexity.js

@@ -0,0 +1,345 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { extname, relative } from 'node:path';
+import { collectedContentReader } from './quality-fingerprint.js';
+import { chunkFileList, filesByExt, isTestFile, runCommand } from './quality-tools.js';
+import { ANALYZER_FINDING_BOUND, biomeDiagToFinding, FUNCTION_LENGTH_THRESHOLD, isBiomeComplexityDiagnostic, isEslintComplexityRule } from './quality-types.js';
+const NODE_COMPLEXITY_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+const PY_COMPLEXITY_EXTS = ['.py', '.pyi'];
+export const STRUCTURAL_EXTENSIONS = [...NODE_COMPLEXITY_EXTS, ...PY_COMPLEXITY_EXTS];
+function paramCountFromSignature(line) {
+    const open = line.indexOf('(');
+    if (open === -1)
+        return 0;
+    const close = line.lastIndexOf(')');
+    const inner = (close > open ? line.slice(open + 1, close) : line.slice(open + 1)).trim();
+    if (!inner)
+        return 0;
+    return inner.split(',').filter((p) => p.trim().length > 0).length;
+}
+const RETURN_KEYWORD = /\breturn\b/g;
+function countReturns(body) {
+    return (body.match(RETURN_KEYWORD) || []).length;
+}
+function pyMaxDepth(bodyLines, baseIndent) {
+    let max = 0;
+    for (const line of bodyLines) {
+        if (!line.trim())
+            continue;
+        const indent = line.length - line.trimStart().length;
+        const depth = Math.max(0, Math.floor((indent - baseIndent) / 4) - 1);
+        if (depth > max)
+            max = depth;
+    }
+    return max;
+}
+const BRANCH_PATTERN = /\b(?:if|elif|for|while|case|catch)\b|&&|\|\||\?\?|\?(?![?.:])/g;
+export function countBranches(body) {
+    return (body.match(BRANCH_PATTERN) || []).length;
+}
+const JS_FUNC_PATTERN = /^(\s*)(export\s+)?(async\s+)?function\s+(\w+)|^(\s*)(export\s+)?(const|let|var)\s+(\w+)\s*=\s*(async\s+)?\(|^(\s*)(public|private|protected)?\s*(async\s+)?(\w+)\s*\(/;
+function countBraceDeltas(line) {
+    let delta = 0;
+    for (const ch of line) {
+        if (ch === '{')
+            delta++;
+        else if (ch === '}')
+            delta--;
+    }
+    return delta;
+}
+function matchJsFuncStart(line) {
+    const match = JS_FUNC_PATTERN.exec(line);
+    if (!match)
+        return null;
+    const name = match[4] || match[8] || match[13] || 'anonymous';
+    const indent = (match[1] || match[5] || match[10] || '').length;
+    return { name, indent };
+}
+function extractJsFunctions(file) {
+    const functions = [];
+    const lines = file.content.split('\n');
+    let braceDepth = 0;
+    let currentFunc = null;
+    let funcStartBraceDepth = 0;
+    let maxRelDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (!currentFunc) {
+            const funcStart = matchJsFuncStart(lines[i]);
+            if (funcStart) {
+                currentFunc = { name: funcStart.name, startLine: i + 1, indent: funcStart.indent };
+                funcStartBraceDepth = braceDepth;
+                maxRelDepth = 0;
+            }
+        }
+        braceDepth += countBraceDeltas(lines[i]);
+        if (currentFunc)
+            maxRelDepth = Math.max(maxRelDepth, braceDepth - funcStartBraceDepth);
+        if (currentFunc && braceDepth <= funcStartBraceDepth && i > currentFunc.startLine - 1) {
+            const startLine = currentFunc.startLine;
+            const endLine = i + 1;
+            const body = lines.slice(startLine - 1, endLine).join('\n');
+            functions.push({
+                name: currentFunc.name,
+                file: file.relativePath,
+                startLine,
+                lines: endLine - startLine + 1,
+                branches: countBranches(body),
+                params: paramCountFromSignature(lines[startLine - 1]),
+                maxDepth: Math.max(0, maxRelDepth - 1),
+                returns: countReturns(body),
+            });
+            currentFunc = null;
+        }
+    }
+    return functions;
+}
+function extractPyFunctions(file) {
+    const functions = [];
+    const lines = file.content.split('\n');
+    const defPattern = /^(\s*)(async\s+)?def\s+(\w+)/;
+    let currentFunc = null;
+    const recordFunction = (name, startLine, endLine, baseIndent) => {
+        const bodyLines = lines.slice(startLine - 1, endLine);
+        const body = bodyLines.join('\n');
+        functions.push({
+            name,
+            file: file.relativePath,
+            startLine,
+            lines: endLine - startLine + 1,
+            branches: countBranches(body),
+            params: paramCountFromSignature(lines[startLine - 1]),
+            maxDepth: pyMaxDepth(bodyLines, baseIndent),
+            returns: countReturns(body),
+        });
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const match = defPattern.exec(lines[i]);
+        if (match) {
+            if (currentFunc)
+                recordFunction(currentFunc.name, currentFunc.startLine, i, currentFunc.indent);
+            currentFunc = { name: match[3], startLine: i + 1, indent: match[1].length };
+        }
+        else if (currentFunc && lines[i].trim() && !lines[i].startsWith(' '.repeat(currentFunc.indent + 1)) && !lines[i].startsWith('\t')) {
+            recordFunction(currentFunc.name, currentFunc.startLine, i, currentFunc.indent);
+            currentFunc = null;
+        }
+    }
+    if (currentFunc) {
+        recordFunction(currentFunc.name, currentFunc.startLine, lines.length, currentFunc.indent);
+    }
+    return functions;
+}
+export function extractFunctions(file) {
+    const ext = extname(file.path).toLowerCase();
+    if (NODE_COMPLEXITY_EXTS.includes(ext))
+        return extractJsFunctions(file);
+    if (PY_COMPLEXITY_EXTS.includes(ext))
+        return extractPyFunctions(file);
+    return [];
+}
+function severityFromBranchiness(branches, lines) {
+    const branchesPer50 = (branches * 50) / Math.max(1, lines);
+    const isAbsurd = lines > FUNCTION_LENGTH_THRESHOLD * 5;
+    if (branchesPer50 < 3 && !isAbsurd)
+        return null;
+    if (branchesPer50 < 6)
+        return 'low';
+    if (branchesPer50 < 10)
+        return 'medium';
+    return 'high';
+}
+export function analyzeFunctionLength(files) {
+    const allFunctions = [];
+    for (const file of files) {
+        if (isTestFile(file.relativePath))
+            continue;
+        allFunctions.push(...extractFunctions(file));
+    }
+    if (allFunctions.length === 0)
+        return { score: 100, findings: [], issueCount: 0 };
+    const findings = [];
+    let totalScore = 0;
+    for (const func of allFunctions) {
+        const ratio = Math.max(1, func.lines / FUNCTION_LENGTH_THRESHOLD);
+        const funcScore = 100 / ratio ** 1.5;
+        totalScore += funcScore;
+        if (func.lines > FUNCTION_LENGTH_THRESHOLD) {
+            const severity = severityFromBranchiness(func.branches, func.lines);
+            if (!severity)
+                continue;
+            findings.push({
+                severity,
+                category: 'function-length',
+                file: func.file,
+                line: func.startLine,
+                title: `${func.name}() has ${func.lines} lines, ~${func.branches} branches`,
+                description: `Function "${func.name}" exceeds the ${FUNCTION_LENGTH_THRESHOLD}-line threshold by ${func.lines - FUNCTION_LENGTH_THRESHOLD} lines ` +
+                    `with approximately ${func.branches} decision points (cyclomatic complexity proxy). ` +
+                    (severity === 'high'
+                        ? 'High branchiness makes this hard to test and review — extract sub-functions or simplify control flow.'
+                        : 'Long but with manageable branching — consider extracting helpers if the function does multiple things.'),
+            });
+        }
+    }
+    const score = Math.round(totalScore / allFunctions.length);
+    return { score: Math.min(100, score), findings: findings.slice(0, ANALYZER_FINDING_BOUND), issueCount: findings.length };
+}
+function computeComplexityScore(findings) {
+    let penalty = 0;
+    for (const f of findings) {
+        if (f.severity === 'high' || f.severity === 'critical')
+            penalty += 8;
+        else if (f.severity === 'medium')
+            penalty += 5;
+        else
+            penalty += 3;
+    }
+    return Math.max(0, 100 - penalty);
+}
+async function complexityFromBiome(dirPath, files) {
+    const targets = filesByExt(files, NODE_COMPLEXITY_EXTS);
+    if (targets.length === 0)
+        return [];
+    const findings = [];
+    const contentOf = collectedContentReader(files);
+    for (const chunk of chunkFileList(targets)) {
+        const result = await runCommand('npx', ['@biomejs/biome', 'lint', '--reporter=json', ...chunk], dirPath);
+        if (result.exitCode > 1)
+            return null;
+        try {
+            const parsed = JSON.parse(result.stdout);
+            if (!parsed.diagnostics)
+                continue;
+            for (const d of parsed.diagnostics) {
+                if (isBiomeComplexityDiagnostic(d))
+                    findings.push(biomeDiagToFinding(d, 'complexity', contentOf));
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    return findings;
+}
+function eslintFileToComplexityFindings(file, dirPath) {
+    const out = [];
+    for (const msg of file.messages || []) {
+        if (!isEslintComplexityRule(msg.ruleId))
+            continue;
+        out.push({
+            severity: msg.severity === 2 ? 'high' : 'medium',
+            category: 'complexity',
+            file: relative(dirPath, file.filePath),
+            line: msg.line ?? null,
+            title: msg.ruleId || 'complexity',
+            description: msg.message,
+        });
+    }
+    return out;
+}
+async function complexityFromEslint(dirPath, files) {
+    const targets = filesByExt(files, NODE_COMPLEXITY_EXTS);
+    if (targets.length === 0)
+        return [];
+    const findings = [];
+    for (const chunk of chunkFileList(targets)) {
+        const result = await runCommand('npx', ['eslint', '--format=json', ...chunk], dirPath);
+        if (result.exitCode > 1 && !result.stdout.trim().startsWith('['))
+            return null;
+        try {
+            const parsed = JSON.parse(result.stdout);
+            for (const file of parsed)
+                findings.push(...eslintFileToComplexityFindings(file, dirPath));
+        }
+        catch {
+            return null;
+        }
+    }
+    return findings;
+}
+function radonFuncToFinding(filePath, func) {
+    const cc = func.complexity;
+    if (cc <= 10)
+        return null;
+    return {
+        severity: cc > 20 ? 'high' : cc > 15 ? 'medium' : 'low',
+        category: 'complexity',
+        file: filePath,
+        line: func.lineno ?? null,
+        title: `${func.name}() has cyclomatic complexity ${cc}`,
+        description: `Complexity of ${cc} exceeds threshold of 10. Rank: ${func.rank}. Consider refactoring.`,
+    };
+}
+function radonPayloadToFindings(payload) {
+    const out = [];
+    for (const [filePath, functions] of Object.entries(payload)) {
+        for (const func of functions) {
+            const finding = radonFuncToFinding(filePath, func);
+            if (finding)
+                out.push(finding);
+        }
+    }
+    return out;
+}
+async function complexityFromRadon(dirPath, files) {
+    const targets = filesByExt(files, PY_COMPLEXITY_EXTS);
+    if (targets.length === 0)
+        return [];
+    const findings = [];
+    for (const chunk of chunkFileList(targets)) {
+        const result = await runCommand('radon', ['cc', '--json', ...chunk], dirPath);
+        if (result.exitCode !== 0 && !result.stdout.trim().startsWith('{'))
+            return null;
+        try {
+            const parsed = JSON.parse(result.stdout);
+            findings.push(...radonPayloadToFindings(parsed));
+        }
+        catch {
+            return null;
+        }
+    }
+    return findings;
+}
+async function analyzeNodeComplexity(dirPath, installed, files) {
+    const hasCapableTool = !installed || installed.has('biome') || installed.has('eslint');
+    if (!hasCapableTool)
+        return null;
+    const hasBiome = !installed || installed.has('biome');
+    if (hasBiome) {
+        const findings = await complexityFromBiome(dirPath, files);
+        if (findings)
+            return findings;
+    }
+    return complexityFromEslint(dirPath, files);
+}
+async function analyzePythonComplexity(dirPath, installed, files) {
+    const hasRadon = !installed || installed.has('radon');
+    if (!hasRadon)
+        return null;
+    return complexityFromRadon(dirPath, files);
+}
+export async function analyzeComplexity(dirPath, ecosystems, files, installedToolNames) {
+    const allFindings = [];
+    const installed = installedToolNames ? new Set(installedToolNames) : null;
+    let canAnalyze = false;
+    for (const ecosystem of ecosystems) {
+        const analyze = ecosystem === 'node' ? analyzeNodeComplexity : ecosystem === 'python' ? analyzePythonComplexity : null;
+        if (!analyze)
+            continue;
+        const findings = await analyze(dirPath, installed, files);
+        if (findings) {
+            canAnalyze = true;
+            allFindings.push(...findings);
+        }
+    }
+    if (!canAnalyze) {
+        return { score: 0, findings: [], issueCount: 0, available: false };
+    }
+    return {
+        score: allFindings.length > 0 ? computeComplexityScore(allFindings) : 100,
+        findings: allFindings.slice(0, ANALYZER_FINDING_BOUND),
+        issueCount: allFindings.length,
+        available: true,
+    };
+}