mstro-app 0.4.2 → 0.4.4

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

@@ -1,466 +1,11 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
 // Licensed under the MIT License. See LICENSE file for details.
-import { spawn } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { extname, join, relative } from 'node:path';
-// ============================================================================
-// Constants
-// ============================================================================
-const ECOSYSTEM_TOOLS = {
-    node: [
-        { name: 'eslint', check: ['npx', 'eslint', '--version'], category: 'linter', installCmd: 'npm install -D eslint' },
-        { name: 'biome', check: ['npx', '@biomejs/biome', '--version'], category: 'linter', installCmd: 'npm install -D @biomejs/biome' },
-        { name: 'prettier', check: ['npx', 'prettier', '--version'], category: 'formatter', installCmd: 'npm install -D prettier' },
-        { name: 'typescript', check: ['npx', 'tsc', '--version'], category: 'general', installCmd: 'npm install -D typescript' },
-    ],
-    python: [
-        { name: 'ruff', check: ['ruff', '--version'], category: 'linter', installCmd: 'uv tool install ruff || pip install ruff' },
-        { name: 'black', check: ['black', '--version'], category: 'formatter', installCmd: 'uv tool install black || pip install black' },
-        { name: 'radon', check: ['radon', '--version'], category: 'complexity', installCmd: 'uv tool install radon || pip install radon' },
-    ],
-    rust: [
-        { name: 'clippy', check: ['cargo', 'clippy', '--version'], category: 'linter', installCmd: 'rustup component add clippy' },
-        { name: 'rustfmt', check: ['rustfmt', '--version'], category: 'formatter', installCmd: 'rustup component add rustfmt' },
-    ],
-    go: [
-        { name: 'golangci-lint', check: ['golangci-lint', '--version'], category: 'linter', installCmd: 'go install github.com/golangci-lint/golangci-lint/cmd/golangci-lint@latest' },
-        { name: 'gofmt', check: ['gofmt', '-h'], category: 'formatter', installCmd: '(built-in with Go)' },
-    ],
-    swift: [
-        { name: 'swiftlint', check: ['swiftlint', '--version'], category: 'linter', installCmd: 'brew install swiftlint' },
-        { name: 'swiftformat', check: ['swiftformat', '--version'], category: 'formatter', installCmd: 'brew install swiftformat' },
-    ],
-    kotlin: [
-        { name: 'ktlint', check: ['ktlint', '--version'], category: 'linter', installCmd: 'brew install ktlint' },
-        { name: 'ktfmt', check: ['ktfmt', '--version'], category: 'formatter', installCmd: 'brew install ktfmt' },
-    ],
-    unknown: [],
-};
-const SOURCE_EXTENSIONS = new Set([
-    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
-    '.py', '.pyi',
-    '.rs',
-    '.go',
-    '.java', '.kt',
-    '.cs',
-    '.rb',
-    '.php',
-    '.swift',
-    '.c', '.cpp', '.h', '.hpp',
-]);
-const IGNORE_DIRS = new Set([
-    'node_modules', '.git', 'dist', 'build', '.next', '__pycache__',
-    'target', 'vendor', '.venv', 'venv', '.tox', 'coverage',
-    '.mstro', '.cache', '.turbo', '.output',
-]);
-const FILE_LENGTH_THRESHOLD = 300;
-const FUNCTION_LENGTH_THRESHOLD = 50;
-const TOTAL_STEPS = 7;
-function hasInstalledToolInCategory(installedSet, ecosystems, category) {
-    for (const eco of ecosystems) {
-        const specs = ECOSYSTEM_TOOLS[eco] || [];
-        for (const spec of specs) {
-            if (spec.category === category && installedSet.has(spec.name))
-                return true;
-        }
-    }
-    return false;
-}
-// ============================================================================
-// Ecosystem Detection
-// ============================================================================
-export function detectEcosystem(dirPath) {
-    const ecosystems = [];
-    try {
-        const files = readdirSync(dirPath);
-        if (files.includes('package.json'))
-            ecosystems.push('node');
-        if (files.includes('pyproject.toml') || files.includes('setup.py') || files.includes('requirements.txt'))
-            ecosystems.push('python');
-        if (files.includes('Cargo.toml'))
-            ecosystems.push('rust');
-        if (files.includes('go.mod'))
-            ecosystems.push('go');
-        if (files.includes('Package.swift') || files.some(f => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace')))
-            ecosystems.push('swift');
-        if (files.includes('build.gradle') || files.includes('build.gradle.kts'))
-            ecosystems.push('kotlin');
-    }
-    catch {
-        // Directory not readable
-    }
-    if (ecosystems.length === 0)
-        ecosystems.push('unknown');
-    return ecosystems;
-}
-/** Detect the Node.js package manager from lockfiles */
-function detectNodePackageManager(dirPath) {
-    try {
-        const files = readdirSync(dirPath);
-        if (files.includes('bun.lockb') || files.includes('bun.lock'))
-            return 'bun';
-        if (files.includes('pnpm-lock.yaml'))
-            return 'pnpm';
-        if (files.includes('yarn.lock'))
-            return 'yarn';
-    }
-    catch {
-        // Directory not readable
-    }
-    return 'npm';
-}
-/** Build the install command for a Node.js dev dependency */
-function nodeInstallCmd(pm, pkg) {
-    switch (pm) {
-        case 'yarn': return `yarn add -D ${pkg}`;
-        case 'pnpm': return `pnpm add -D ${pkg}`;
-        case 'bun': return `bun add -d ${pkg}`;
-        default: return `npm install -D ${pkg}`;
-    }
-}
-// ============================================================================
-// Tool Detection
-// ============================================================================
-async function checkToolInstalled(check, cwd) {
-    return new Promise((resolve) => {
-        const proc = spawn(check[0], check.slice(1), {
-            cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            timeout: 10000,
-        });
-        proc.on('close', (code) => resolve(code === 0));
-        proc.on('error', () => resolve(false));
-    });
-}
-export async function detectTools(dirPath) {
-    const ecosystems = detectEcosystem(dirPath);
-    const tools = [];
-    const nodePm = ecosystems.includes('node') ? detectNodePackageManager(dirPath) : 'npm';
-    for (const eco of ecosystems) {
-        const specs = ECOSYSTEM_TOOLS[eco] || [];
-        for (const spec of specs) {
-            const installed = await checkToolInstalled(spec.check, dirPath);
-            // For node tools, resolve install command using the project's package manager
-            const installCommand = eco === 'node'
-                ? nodeInstallCmd(nodePm, spec.installCmd.replace(/^npm install -D /, ''))
-                : spec.installCmd;
-            tools.push({
-                name: spec.name,
-                installed,
-                installCommand,
-                category: spec.category,
-            });
-        }
-    }
-    return { tools, ecosystem: ecosystems };
-}
-// ============================================================================
-// Tool Installation
-// ============================================================================
-export async function installTools(dirPath, toolNames) {
-    const { tools } = await detectTools(dirPath);
-    const toInstall = tools.filter((t) => !t.installed && (!toolNames || toolNames.includes(t.name)));
-    const failures = [];
-    for (const tool of toInstall) {
-        if (tool.installCommand.startsWith('('))
-            continue; // built-in, skip
-        // Support chained commands with || (try first, fallback to second)
-        const commands = tool.installCommand.split(' || ');
-        let installed = false;
-        for (const cmd of commands) {
-            const parts = cmd.trim().split(' ');
-            const result = await runCommand(parts[0], parts.slice(1), dirPath);
-            if (result.exitCode === 0) {
-                installed = true;
-                break;
-            }
-        }
-        if (!installed) {
-            failures.push(`${tool.name}: all install methods failed`);
-        }
-    }
-    // Re-detect after install
-    const detected = await detectTools(dirPath);
-    // Check if any requested tools are still missing after install
-    const requestedNames = new Set(toolNames ?? toInstall.map((t) => t.name));
-    const stillMissing = detected.tools.filter((t) => !t.installed && requestedNames.has(t.name)).map((t) => t.name);
-    if (stillMissing.length > 0) {
-        const detail = failures.length > 0 ? ` ${failures.join('; ')}` : '';
-        throw new Error(`Failed to install: ${stillMissing.join(', ')}.${detail}`);
-    }
-    return detected;
-}
-function tryStatSync(path) {
-    try {
-        return statSync(path);
-    }
-    catch {
-        return null;
-    }
-}
-function tryReadFile(path) {
-    try {
-        return readFileSync(path, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-}
-function tryReaddirSync(dir) {
-    try {
-        return readdirSync(dir);
-    }
-    catch {
-        return null;
-    }
-}
-function tryReadSourceFile(fullPath, rootPath) {
-    const content = tryReadFile(fullPath);
-    if (!content)
-        return null;
-    return {
-        path: fullPath,
-        relativePath: relative(rootPath, fullPath),
-        lines: content.split('\n').length,
-        content,
-    };
-}
-function processEntry(entry, dir, rootPath, stack, files) {
-    if (IGNORE_DIRS.has(entry))
-        return;
-    const fullPath = join(dir, entry);
-    const stat = tryStatSync(fullPath);
-    if (!stat)
-        return;
-    if (stat.isDirectory()) {
-        stack.push(fullPath);
-        return;
-    }
-    if (!stat.isFile() || !SOURCE_EXTENSIONS.has(extname(entry).toLowerCase()))
-        return;
-    const sourceFile = tryReadSourceFile(fullPath, rootPath);
-    if (sourceFile)
-        files.push(sourceFile);
-}
-function collectSourceFiles(dirPath, rootPath) {
-    const files = [];
-    const stack = [dirPath];
-    while (stack.length > 0) {
-        const dir = stack.pop();
-        const entries = tryReaddirSync(dir);
-        if (!entries)
-            continue;
-        for (const entry of entries) {
-            processEntry(entry, dir, rootPath, stack, files);
-        }
-    }
-    return files;
-}
-// ============================================================================
-// Command Runner
-// ============================================================================
-function runCommand(cmd, args, cwd) {
-    return new Promise((resolve) => {
-        const proc = spawn(cmd, args, {
-            cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            timeout: 120000,
-        });
-        let stdout = '';
-        let stderr = '';
-        proc.stdout?.on('data', (d) => { stdout += d.toString(); });
-        proc.stderr?.on('data', (d) => { stderr += d.toString(); });
-        proc.on('close', (code) => resolve({ stdout, stderr, exitCode: code ?? 1 }));
-        proc.on('error', (err) => resolve({ stdout: '', stderr: err.message, exitCode: 1 }));
-    });
-}
-function newLintAccumulator() {
-    return { errors: 0, warnings: 0, findings: [], ran: false };
-}
-function biomeSeverity(severity) {
-    if (severity === 'error')
-        return 'high';
-    if (severity === 'warning')
-        return 'medium';
-    return 'low';
-}
-function processBiomeDiagnostic(d, acc) {
-    const sev = biomeSeverity(d.severity);
-    if (d.severity === 'error')
-        acc.errors++;
-    else
-        acc.warnings++;
-    const location = d.location;
-    const span = location?.span ?? {};
-    const start = span.start ?? {};
-    const message = d.message;
-    acc.findings.push({
-        severity: sev,
-        category: 'linting',
-        file: location?.path || '',
-        line: start.line ?? null,
-        title: d.category || 'Lint issue',
-        description: (typeof message === 'object' ? message?.text : message) || '',
-    });
-}
-function parseBiomeDiagnostics(stdout, acc) {
-    const parsed = JSON.parse(stdout);
-    if (!parsed.diagnostics)
-        return;
-    for (const d of parsed.diagnostics) {
-        processBiomeDiagnostic(d, acc);
-    }
-}
-async function lintWithBiome(dirPath, acc) {
-    const result = await runCommand('npx', ['@biomejs/biome', 'lint', '--reporter=json', '.'], dirPath);
-    if (result.exitCode > 1)
-        return;
-    acc.ran = true;
-    try {
-        parseBiomeDiagnostics(result.stdout, acc);
-    }
-    catch {
-        // JSON parse failed, try line counting
-        acc.errors += (result.stdout.match(/error/gi) || []).length;
-        acc.warnings += (result.stdout.match(/warning/gi) || []).length;
-        acc.ran = acc.errors > 0 || acc.warnings > 0 || result.exitCode === 0;
-    }
-}
-async function lintWithEslint(dirPath, acc) {
-    const result = await runCommand('npx', ['eslint', '--format=json', '.'], dirPath);
-    acc.ran = true;
-    try {
-        const parsed = JSON.parse(result.stdout);
-        for (const file of parsed) {
-            for (const msg of file.messages || []) {
-                if (msg.severity === 2)
-                    acc.errors++;
-                else
-                    acc.warnings++;
-                acc.findings.push({
-                    severity: msg.severity === 2 ? 'high' : 'medium',
-                    category: 'linting',
-                    file: relative(dirPath, file.filePath),
-                    line: msg.line ?? null,
-                    title: msg.ruleId || 'Lint issue',
-                    description: msg.message,
-                });
-            }
-        }
-    }
-    catch {
-        acc.errors += (result.stderr.match(/error/gi) || []).length;
-        acc.warnings += (result.stderr.match(/warning/gi) || []).length;
-    }
-}
-async function lintNode(dirPath, acc) {
-    const biomeConfig = existsSync(join(dirPath, 'biome.json')) || existsSync(join(dirPath, 'biome.jsonc'));
-    if (biomeConfig) {
-        await lintWithBiome(dirPath, acc);
-    }
-    else {
-        await lintWithEslint(dirPath, acc);
-    }
-}
-async function lintPython(dirPath, acc) {
-    const result = await runCommand('ruff', ['check', '--output-format=json', '.'], dirPath);
-    if (result.exitCode !== 0 && !result.stdout.trim().startsWith('['))
-        return;
-    acc.ran = true;
-    try {
-        const parsed = JSON.parse(result.stdout);
-        for (const item of parsed) {
-            const sev = item.code?.startsWith('E') ? 'high' : 'medium';
-            if (sev === 'high')
-                acc.errors++;
-            else
-                acc.warnings++;
-            acc.findings.push({
-                severity: sev,
-                category: 'linting',
-                file: item.filename ? relative(dirPath, item.filename) : '',
-                line: item.location?.row ?? null,
-                title: item.code || 'Lint issue',
-                description: item.message || '',
-            });
-        }
-    }
-    catch { /* ignore */ }
-}
-function processClippyMessage(msg, acc) {
-    if (msg.reason !== 'compiler-message' || !msg.message)
-        return;
-    const message = msg.message;
-    const level = message.level;
-    if (level === 'error')
-        acc.errors++;
-    else if (level === 'warning')
-        acc.warnings++;
-    const spans = message.spans;
-    const span = spans?.[0];
-    const code = message.code;
-    acc.findings.push({
-        severity: level === 'error' ? 'high' : 'medium',
-        category: 'linting',
-        file: span?.file_name || '',
-        line: span?.line_start ?? null,
-        title: code?.code || 'Clippy',
-        description: message.message || '',
-    });
-}
-function parseClippyOutput(stdout, acc) {
-    for (const line of stdout.split('\n')) {
-        try {
-            const msg = JSON.parse(line);
-            processClippyMessage(msg, acc);
-        }
-        catch { /* not JSON line */ }
-    }
-}
-async function lintRust(dirPath, acc) {
-    const result = await runCommand('cargo', ['clippy', '--message-format=json', '--', '-W', 'clippy::all'], dirPath);
-    if (result.exitCode > 1)
-        return;
-    acc.ran = true;
-    parseClippyOutput(result.stdout, acc);
-}
-function computeLintScore(totalErrors, totalWarnings, totalLines) {
-    const kloc = Math.max(totalLines / 1000, 1);
-    const penaltyRaw = totalErrors * 10 + totalWarnings * 3;
-    const penaltyPerKloc = penaltyRaw / kloc;
-    let score;
-    if (penaltyPerKloc === 0)
-        score = 100;
-    else if (penaltyPerKloc <= 5)
-        score = 100 - penaltyPerKloc * 2;
-    else if (penaltyPerKloc <= 20)
-        score = 90 - (penaltyPerKloc - 5) * 2;
-    else if (penaltyPerKloc <= 50)
-        score = 60 - (penaltyPerKloc - 20) * 1.5;
-    else
-        score = Math.max(0, 15 - (penaltyPerKloc - 50) * 0.3);
-    return Math.round(Math.max(0, Math.min(100, score)));
-}
-async function analyzeLinting(dirPath, ecosystems, files) {
-    const acc = newLintAccumulator();
-    if (ecosystems.includes('node'))
-        await lintNode(dirPath, acc);
-    if (ecosystems.includes('python'))
-        await lintPython(dirPath, acc);
-    if (ecosystems.includes('rust'))
-        await lintRust(dirPath, acc);
-    if (!acc.ran) {
-        return { score: 0, findings: [], available: false, issueCount: 0 };
-    }
-    const totalLines = files.reduce((sum, f) => sum + f.lines, 0);
-    const score = computeLintScore(acc.errors, acc.warnings, totalLines);
-    return {
-        score,
-        findings: acc.findings.slice(0, 100),
-        available: true,
-        issueCount: acc.errors + acc.warnings,
-    };
-}
+import { extname } from 'node:path';
+import { analyzeComplexity, analyzeFunctionLength } from './quality-complexity.js';
+import { analyzeLinting } from './quality-linting.js';
+import { collectSourceFiles, detectEcosystem, runCommand } from './quality-tools.js';
+import { FILE_LENGTH_THRESHOLD, hasInstalledToolInCategory, TOTAL_STEPS } from './quality-types.js';
+export { detectEcosystem, detectTools, installTools } from './quality-tools.js';
 // ============================================================================
 // Formatting Analysis
 // ============================================================================
@@ -471,7 +16,6 @@ async function analyzeFormatting(dirPath, ecosystems, files) {
     if (ecosystems.includes('node')) {
         const result = await runCommand('npx', ['prettier', '--check', '.'], dirPath);
         ran = true;
-        // prettier --check outputs filenames of unformatted files to stdout
         const unformatted = result.stdout.split('\n').filter((l) => l.trim() && !l.startsWith('Checking'));
         const nodeFiles = files.filter((f) => ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(extname(f.path)));
         totalFiles += nodeFiles.length;
@@ -530,192 +74,6 @@ function analyzeFileLength(files) {
     const score = Math.round(totalScore / files.length);
     return { score: Math.min(100, score), findings: findings.slice(0, 50), issueCount: findings.length };
 }
-// Match function declarations, arrow functions assigned to const/let, and methods
-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;
-    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;
-            }
-        }
-        braceDepth += countBraceDeltas(lines[i]);
-        if (currentFunc && braceDepth <= funcStartBraceDepth && i > currentFunc.startLine - 1) {
-            functions.push({
-                name: currentFunc.name,
-                file: file.relativePath,
-                startLine: currentFunc.startLine,
-                lines: i + 1 - currentFunc.startLine + 1,
-            });
-            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;
-    for (let i = 0; i < lines.length; i++) {
-        const match = defPattern.exec(lines[i]);
-        if (match) {
-            if (currentFunc) {
-                functions.push({
-                    name: currentFunc.name,
-                    file: file.relativePath,
-                    startLine: currentFunc.startLine,
-                    lines: i - currentFunc.startLine + 1,
-                });
-            }
-            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')) {
-            functions.push({
-                name: currentFunc.name,
-                file: file.relativePath,
-                startLine: currentFunc.startLine,
-                lines: i - currentFunc.startLine + 1,
-            });
-            currentFunc = null;
-        }
-    }
-    if (currentFunc) {
-        functions.push({
-            name: currentFunc.name,
-            file: file.relativePath,
-            startLine: currentFunc.startLine,
-            lines: lines.length - currentFunc.startLine + 1,
-        });
-    }
-    return functions;
-}
-function extractFunctions(file) {
-    const ext = extname(file.path).toLowerCase();
-    if (['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext))
-        return extractJsFunctions(file);
-    if (['.py', '.pyi'].includes(ext))
-        return extractPyFunctions(file);
-    return [];
-}
-function analyzeFunctionLength(files) {
-    const allFunctions = [];
-    for (const file of files) {
-        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) {
-            findings.push({
-                severity: func.lines > FUNCTION_LENGTH_THRESHOLD * 3 ? 'high' : func.lines > FUNCTION_LENGTH_THRESHOLD * 2 ? 'medium' : 'low',
-                category: 'function-length',
-                file: func.file,
-                line: func.startLine,
-                title: `${func.name}() has ${func.lines} lines (threshold: ${FUNCTION_LENGTH_THRESHOLD})`,
-                description: `Function "${func.name}" exceeds the recommended length by ${func.lines - FUNCTION_LENGTH_THRESHOLD} lines.`,
-            });
-        }
-    }
-    const score = Math.round(totalScore / allFunctions.length);
-    return { score: Math.min(100, score), findings: findings.slice(0, 50), issueCount: findings.length };
-}
-// ============================================================================
-// Cyclomatic Complexity (Heuristic)
-// ============================================================================
-function countCyclomaticComplexity(funcContent) {
-    let cc = 1; // base
-    cc += (funcContent.match(/\bif\b/g) || []).length;
-    cc += (funcContent.match(/\belse\s+if\b/g) || []).length;
-    cc += (funcContent.match(/\bfor\b/g) || []).length;
-    cc += (funcContent.match(/\bwhile\b/g) || []).length;
-    cc += (funcContent.match(/\bcase\b/g) || []).length;
-    cc += (funcContent.match(/\bcatch\b/g) || []).length;
-    cc += (funcContent.match(/&&|\|\|/g) || []).length;
-    cc += (funcContent.match(/\?\s*[^:]/g) || []).length; // ternary
-    return cc;
-}
-function complexityToScore(cc) {
-    if (cc <= 5)
-        return 100;
-    if (cc <= 10)
-        return 100 - (cc - 5) * 5;
-    if (cc <= 15)
-        return 75 - (cc - 10) * 5;
-    if (cc <= 20)
-        return 50 - (cc - 15) * 5;
-    return Math.max(0, 25 - (cc - 20) * 2.5);
-}
-function getFuncContent(file, func) {
-    return file.content.split('\n').slice(func.startLine - 1, func.startLine - 1 + func.lines).join('\n');
-}
-function complexitySeverity(cc) {
-    if (cc > 20)
-        return 'high';
-    if (cc > 15)
-        return 'medium';
-    return 'low';
-}
-function analyzeFunc(file, func, acc) {
-    const funcContent = getFuncContent(file, func);
-    const cc = countCyclomaticComplexity(funcContent);
-    const funcScore = complexityToScore(cc);
-    acc.weightedScore += funcScore * func.lines;
-    acc.weight += func.lines;
-    if (cc > 10) {
-        acc.findings.push({
-            severity: complexitySeverity(cc),
-            category: 'complexity',
-            file: func.file,
-            line: func.startLine,
-            title: `${func.name}() has cyclomatic complexity ${cc}`,
-            description: `Complexity of ${cc} exceeds the recommended threshold of 10. Consider refactoring into smaller functions.`,
-        });
-    }
-}
-function analyzeComplexity(files) {
-    const acc = { weightedScore: 0, weight: 0, findings: [] };
-    for (const file of files) {
-        const functions = extractFunctions(file);
-        for (const func of functions) {
-            analyzeFunc(file, func, acc);
-        }
-    }
-    if (acc.weight === 0)
-        return { score: 100, findings: [], issueCount: 0 };
-    const score = Math.round(acc.weightedScore / acc.weight);
-    return { score: Math.min(100, score), findings: acc.findings.slice(0, 50), issueCount: acc.findings.length };
-}
 // ============================================================================
 // Scoring
 // ============================================================================
@@ -792,9 +150,9 @@ export async function runQualityScan(dirPath, onProgress, installedToolNames) {
     const fmtResult = hasFormatter
         ? await analyzeFormatting(dirPath, ecosystems, files)
         : { score: 0, available: false, issueCount: 0 };
-    // Step 4: Analyze complexity
+    // Step 4: Analyze complexity (using real tools: Biome, ESLint, radon)
     progress('Analyzing complexity', 4);
-    const complexityResult = analyzeComplexity(files);
+    const complexityResult = await analyzeComplexity(dirPath, ecosystems, installedToolNames);
     // Step 5: Check file lengths
     progress('Checking file lengths', 5);
     const fileLengthResult = analyzeFileLength(files);
@@ -825,7 +183,7 @@ export async function runQualityScan(dirPath, onProgress, installedToolNames) {
             score: complexityResult.score,
             weight: DEFAULT_WEIGHTS.complexity,
             effectiveWeight: DEFAULT_WEIGHTS.complexity,
-            available: true,
+            available: complexityResult.available,
             issueCount: complexityResult.issueCount,
         },
         {