@minionry/minion 0.7.36

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

@@ -0,0 +1,775 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync } from 'node:fs';
+import { extname } from 'node:path';
+import { ENGINE_EFFORT_LEVELS, engineForModel } from '../../engines/types.js';
+import { getQualityEffortLevel, getQualityEngine, getQualityFastMode, getQualityModel } from '../settings.js';
+import { analyzeComplexity, analyzeFunctionLength, STRUCTURAL_EXTENSIONS } from './quality-complexity.js';
+import { analyzeDependencies } from './quality-dependencies.js';
+import { analyzeDuplication } from './quality-duplication.js';
+import { collectedContentReader, normalizeFindingPath, stampFingerprints } from './quality-fingerprint.js';
+import { computeQualityRating, computeReadiness, gradeFromScore } from './quality-grading.js';
+import { analyzeLinting, cargoWorkspaceRoot } from './quality-linting.js';
+import { analyzeSecrets } from './quality-secrets.js';
+import { chunkFileList, classifyFileRole, collectSourceFiles, detectEcosystem, filesByExt, isTestFile, readSourceFiles, runCommand } from './quality-tools.js';
+import { runTriagePass } from './quality-triage-agent.js';
+import { ANALYZER_FINDING_BOUND, ECOSYSTEM_TOOLS, FILE_LENGTH_THRESHOLD, findingCountsTowardGrade, hasInstalledToolInCategory, STRUCTURAL_CATEGORIES, TOTAL_STEPS } from './quality-types.js';
+const NODE_FMT_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+const PY_FMT_EXTS = ['.py', '.pyi'];
+const TRIAGE_STEP = 11;
+const SCORING_STEP = 12;
+export { detectEcosystem, detectTools, installTools } from './quality-tools.js';
+export function resolveQualityModels(sel) {
+    const engine = sel.engine ?? 'claude-code';
+    const effortLevel = sel.effortLevel && sel.effortLevel !== 'auto' && (ENGINE_EFFORT_LEVELS[engine] ?? []).includes(sel.effortLevel)
+        ? sel.effortLevel
+        : undefined;
+    const fastMode = engine === 'claude-code' ? sel.fastMode === true : false;
+    const model = sel.model && sel.model !== 'default' && engineForModel(sel.model) === engine ? sel.model : undefined;
+    if (engine === 'claude-code' && !model) {
+        return { engine, reviewModel: undefined, triageModel: 'haiku', effortLevel, fastMode };
+    }
+    return { engine, reviewModel: model, triageModel: model, effortLevel, fastMode };
+}
+export function getQualityModels() {
+    return resolveQualityModels({
+        engine: getQualityEngine(),
+        model: getQualityModel(),
+        effortLevel: getQualityEffortLevel(),
+        fastMode: getQualityFastMode(),
+    });
+}
+function backgroundTriageModels() {
+    const models = getQualityModels();
+    return models.engine === 'claude-code' ? { ...models, triageModel: 'haiku', effortLevel: undefined, fastMode: false } : models;
+}
+function failureDetail(result) {
+    const stderr = result.stderr.split('\n').map((l) => l.trim()).find(Boolean);
+    if (stderr)
+        return stderr;
+    return result.stdout.split('\n').map((l) => l.trim()).filter(Boolean).pop() ?? '';
+}
+function exitNote(tool, result) {
+    const detail = failureDetail(result);
+    return `${tool} exited ${result.exitCode}${detail ? `: ${detail}` : ''}`;
+}
+function newFmtAccumulator() {
+    return { totalFiles: 0, passingFiles: 0, ran: false, findings: [], notRun: [] };
+}
+async function fmtNode(dirPath, files, acc) {
+    const targets = filesByExt(files, NODE_FMT_EXTS);
+    if (targets.length === 0) {
+        acc.notRun.push('no JavaScript or TypeScript files to format');
+        return;
+    }
+    acc.totalFiles += targets.length;
+    const unformattedSet = new Set();
+    for (const chunk of chunkFileList(targets)) {
+        const result = await runCommand('npx', ['prettier', '--check', ...chunk], dirPath);
+        if (result.exitCode > 1) {
+            acc.failed = exitNote('Prettier', result);
+            return;
+        }
+        acc.ran = true;
+        for (const line of result.stdout.split('\n')) {
+            if (!line.trim() || line.startsWith('Checking'))
+                continue;
+            const rel = line.startsWith('/') ? line.replace(`${dirPath}/`, '') : line;
+            unformattedSet.add(rel.trim());
+        }
+    }
+    acc.passingFiles += Math.max(0, targets.length - unformattedSet.size);
+    for (const rel of unformattedSet) {
+        acc.findings.push({ severity: 'low', category: 'format', file: rel, line: null, title: 'File not formatted', description: 'Does not match Prettier formatting rules.' });
+    }
+}
+async function fmtPython(dirPath, files, acc) {
+    const targets = filesByExt(files, PY_FMT_EXTS);
+    if (targets.length === 0) {
+        acc.notRun.push('no Python files to format');
+        return;
+    }
+    acc.totalFiles += targets.length;
+    let reformatCount = 0;
+    const findings = [];
+    for (const chunk of chunkFileList(targets)) {
+        const result = await runCommand('black', ['--check', '--quiet', ...chunk], dirPath);
+        if (result.exitCode > 1) {
+            acc.failed = exitNote('Black', result);
+            return;
+        }
+        acc.ran = true;
+        if (result.exitCode === 0)
+            continue;
+        const reformatLines = result.stderr.split('\n').filter((l) => l.includes('would reformat'));
+        reformatCount += reformatLines.length;
+        for (const line of reformatLines) {
+            const match = line.match(/would reformat (.+)/);
+            if (match)
+                findings.push({ severity: 'low', category: 'format', file: match[1].trim(), line: null, title: 'File not formatted', description: 'Does not match Black formatting rules.' });
+        }
+    }
+    acc.passingFiles += Math.max(0, targets.length - reformatCount);
+    acc.findings.push(...findings);
+}
+async function fmtRust(dirPath, files, acc, cargoRoot) {
+    const result = await runCommand('cargo', ['fmt', '--check'], dirPath);
+    if (result.exitCode > 1) {
+        acc.failed = exitNote('rustfmt', result);
+        return;
+    }
+    acc.ran = true;
+    const rsFiles = files.filter((f) => extname(f.path) === '.rs');
+    acc.totalFiles += rsFiles.length;
+    if (result.exitCode === 0) {
+        acc.passingFiles += rsFiles.length;
+        return;
+    }
+    const diffLines = result.stdout.split('\n').filter((l) => l.startsWith('Diff in'));
+    for (const line of diffLines) {
+        const match = line.match(/Diff in (.+?) at/);
+        if (match)
+            acc.findings.push({ severity: 'low', category: 'format', file: normalizeFindingPath(match[1].trim(), dirPath, cargoRoot), line: null, title: 'File not formatted', description: 'Does not match rustfmt formatting rules.' });
+    }
+}
+function notRun(reason) {
+    return { score: 0, available: false, issueCount: 0, findings: [], reason };
+}
+function noInstalledTool(category, ecosystems) {
+    const rostered = ecosystems.flatMap((eco) => (ECOSYSTEM_TOOLS[eco] || []).filter((spec) => spec.category === category).map((spec) => `${spec.name} (${spec.installCmd})`));
+    return rostered.length > 0
+        ? `no ${category} is installed — ${rostered.join(' or ')}`
+        : `no ${category} is rostered for ${ecosystems.join(', ')}`;
+}
+async function analyzeFormatting(dirPath, ecosystems, files, cargoRoot = dirPath) {
+    const acc = newFmtAccumulator();
+    if (ecosystems.includes('node'))
+        await fmtNode(dirPath, files, acc);
+    if (ecosystems.includes('python') && !acc.failed)
+        await fmtPython(dirPath, files, acc);
+    if (ecosystems.includes('rust') && !acc.failed)
+        await fmtRust(dirPath, files, acc, cargoRoot);
+    if (acc.failed)
+        return notRun(acc.failed);
+    if (!acc.ran || acc.totalFiles === 0) {
+        return notRun(acc.notRun.length > 0 ? acc.notRun.join('; ') : `no formatter ran — none is rostered for ${ecosystems.join(', ')}`);
+    }
+    const score = Math.round((acc.passingFiles / acc.totalFiles) * 100);
+    return { score, available: true, issueCount: acc.findings.length, findings: acc.findings.slice(0, ANALYZER_FINDING_BOUND) };
+}
+const BUILD_FINDING_CAP = 5;
+const TYPESCRIPT_INSTALL_COMMAND = 'npm install -D typescript';
+function tscOutputToFindings(output, dirPath) {
+    const findings = [];
+    const errorPattern = /^(.+?)\((\d+),\d+\):\s+error\s+TS\d+:\s+(.+)$/gm;
+    for (const match of output.matchAll(errorPattern)) {
+        if (findings.length >= BUILD_FINDING_CAP)
+            break;
+        const filePath = match[1].replace(`${dirPath}/`, '').replace(/^\.\//, '');
+        findings.push({
+            severity: 'critical',
+            category: 'build',
+            file: filePath,
+            line: Number.parseInt(match[2], 10) || null,
+            title: `TypeScript build error`,
+            description: match[3].trim(),
+            suggestion: 'Resolve compile errors before merging — broken builds block all other quality work.',
+        });
+    }
+    return findings;
+}
+function cargoCheckOutputToFindings(output, dirPath, cargoRoot) {
+    const findings = [];
+    const errorPattern = /^error(?:\[E\d+\])?:\s+(.+?)$\s+-->\s+([^:\s]+):(\d+):\d+/gm;
+    for (const match of output.matchAll(errorPattern)) {
+        if (findings.length >= BUILD_FINDING_CAP)
+            break;
+        findings.push({
+            severity: 'critical',
+            category: 'build',
+            file: normalizeFindingPath(match[2], dirPath, cargoRoot),
+            line: Number.parseInt(match[3], 10) || null,
+            title: `Rust build error`,
+            description: match[1].trim(),
+            suggestion: 'Resolve compile errors before merging — broken builds block all other quality work.',
+        });
+    }
+    return findings;
+}
+async function checkNodeBuild(dirPath, installed) {
+    if (installed && !installed.has('typescript')) {
+        return { ran: false, reason: `typescript is not installed — ${TYPESCRIPT_INSTALL_COMMAND}` };
+    }
+    if (!existsSync(`${dirPath}/tsconfig.json`)) {
+        return { ran: false, reason: 'tsc --noEmit needs a tsconfig.json at the root of the scanned directory and there is none — a config in a subdirectory is never picked up' };
+    }
+    const result = await runCommand('npx', ['tsc', '--noEmit', '--pretty', 'false'], dirPath);
+    if (result.exitCode === 0)
+        return { ran: true, findings: [] };
+    const findings = tscOutputToFindings(`${result.stdout}\n${result.stderr}`, dirPath);
+    if (findings.length === 0) {
+        const detail = failureDetail(result);
+        return { ran: false, reason: `tsc --noEmit exited ${result.exitCode} without a parseable error${detail ? `: ${detail}` : ''}` };
+    }
+    return { ran: true, findings };
+}
+async function checkRustBuild(dirPath, cargoRoot) {
+    const result = await runCommand('cargo', ['check', '--message-format=human'], dirPath);
+    if (result.exitCode === 0)
+        return { ran: true, findings: [] };
+    const findings = cargoCheckOutputToFindings(`${result.stdout}\n${result.stderr}`, dirPath, cargoRoot);
+    if (findings.length === 0) {
+        const detail = failureDetail(result);
+        return { ran: false, reason: `cargo check exited ${result.exitCode} without a parseable error${detail ? `: ${detail}` : ''}` };
+    }
+    return { ran: true, findings };
+}
+async function analyzeBuildErrors(dirPath, ecosystems, installed, cargoRoot = dirPath) {
+    const findings = [];
+    const skipped = [];
+    let ran = false;
+    if (ecosystems.includes('node')) {
+        const check = await checkNodeBuild(dirPath, installed);
+        if (check.ran) {
+            ran = true;
+            findings.push(...check.findings);
+        }
+        else {
+            skipped.push(check.reason);
+        }
+    }
+    if (ecosystems.includes('rust')) {
+        const check = await checkRustBuild(dirPath, cargoRoot);
+        if (check.ran) {
+            ran = true;
+            findings.push(...check.findings);
+        }
+        else {
+            skipped.push(check.reason);
+        }
+    }
+    if (!ran) {
+        return {
+            findings: [],
+            available: false,
+            reason: skipped.length > 0 ? skipped.join('; ') : `no build check exists for ${ecosystems.join(', ')} — tsc --noEmit runs for node and cargo check for rust`,
+        };
+    }
+    return { findings, available: true };
+}
+const TOP_LEVEL_EXPORT_PATTERN = /^export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var|interface|type|enum)\s+(\w+)/gm;
+const TOP_LEVEL_DECL_PATTERN = /^(?:export\s+)?(?:async\s+)?(?:function|class)\s+(\w+)/gm;
+const PY_TOP_LEVEL_PATTERN = /^(?:def|class)\s+(\w+)/gm;
+const IMPORT_PATTERN = /^(?:import\s+.+from\s+['"]([^'"]+)['"]|from\s+([^\s]+)\s+import|import\s+([^\s]+))/gm;
+const SECTION_DIVIDER_PATTERN = /^\s*(?:\/\/|#)\s*={3,}|^\s*(?:\/\/|#)\s*-{3,}/gm;
+function distinctIdentifierPrefixes(names) {
+    if (names.length === 0)
+        return 0;
+    const prefixes = new Set();
+    for (const name of names) {
+        const first = name.replace(/[A-Z][a-z]+|_+/g, (m, _o, _s) => `
${m.replace(/_/g, '')}`).split('
').filter(Boolean)[0] ?? name;
+        const lowered = first.toLowerCase();
+        if (lowered.length >= 2)
+            prefixes.add(lowered);
+    }
+    return prefixes.size;
+}
+function importRoot(spec) {
+    const trimmed = spec.replace(/^['"]|['"]$/g, '').trim();
+    if (!trimmed)
+        return '';
+    if (trimmed.startsWith('.'))
+        return 'relative';
+    return trimmed.split('/')[0].replace(/^@/, '');
+}
+function jsDeclNames(content) {
+    const exports = [];
+    const decls = [];
+    for (const match of content.matchAll(TOP_LEVEL_EXPORT_PATTERN))
+        exports.push(match[1]);
+    for (const match of content.matchAll(TOP_LEVEL_DECL_PATTERN))
+        decls.push(match[1]);
+    return { exports, decls };
+}
+function pyDeclNames(content) {
+    const exports = [];
+    const decls = [];
+    for (const match of content.matchAll(PY_TOP_LEVEL_PATTERN)) {
+        decls.push(match[1]);
+        if (!match[1].startsWith('_'))
+            exports.push(match[1]);
+    }
+    return { exports, decls };
+}
+function importRootCount(content) {
+    const roots = new Set();
+    for (const match of content.matchAll(IMPORT_PATTERN)) {
+        const spec = match[1] ?? match[2] ?? match[3] ?? '';
+        const root = importRoot(spec);
+        if (root)
+            roots.add(root);
+    }
+    return roots.size;
+}
+function collectCohesionSignals(file) {
+    const ext = extname(file.path).toLowerCase();
+    const isJs = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext);
+    const isPy = ['.py', '.pyi'].includes(ext);
+    const { exports, decls } = isJs
+        ? jsDeclNames(file.content)
+        : isPy
+            ? pyDeclNames(file.content)
+            : { exports: [], decls: [] };
+    const allNames = exports.length > 0 ? exports : decls;
+    return {
+        exports: exports.length,
+        decls: decls.length,
+        prefixes: distinctIdentifierPrefixes(allNames),
+        importRoots: importRootCount(file.content),
+        dividers: (file.content.match(SECTION_DIVIDER_PATTERN) || []).length,
+        isJs,
+        isPy,
+    };
+}
+function computeMixedConcernsScore(file) {
+    const sig = collectCohesionSignals(file);
+    if (!sig.isJs && !sig.isPy)
+        return 0;
+    const exportComponent = sig.exports <= 2 ? 0 : Math.min(1, (sig.exports - 2) / 12);
+    const prefixComponent = sig.prefixes <= 1 ? 0 : Math.min(1, (sig.prefixes - 1) / 6);
+    const importComponent = sig.importRoots <= 4 ? 0 : Math.min(1, (sig.importRoots - 4) / 12);
+    const dividerComponent = sig.dividers <= 2 ? 0 : Math.min(1, (sig.dividers - 2) / 6);
+    return Math.min(1, 0.30 * prefixComponent +
+        0.30 * exportComponent +
+        0.25 * importComponent +
+        0.15 * dividerComponent);
+}
+function severityFromCohesion(mixed, lines) {
+    const isAbsurd = lines > FILE_LENGTH_THRESHOLD * 5;
+    if (mixed <= 0.30 && !isAbsurd)
+        return null;
+    if (mixed <= 0.55)
+        return 'low';
+    if (mixed <= 0.75)
+        return 'medium';
+    return 'high';
+}
+function analyzeFileLength(files) {
+    if (files.length === 0)
+        return { score: 100, findings: [], issueCount: 0 };
+    const findings = [];
+    let totalScore = 0;
+    let scoredFiles = 0;
+    for (const file of files) {
+        if (isTestFile(file.relativePath))
+            continue;
+        const ratio = Math.max(1, file.lines / FILE_LENGTH_THRESHOLD);
+        const fileScore = 100 / ratio ** 1.5;
+        totalScore += fileScore;
+        scoredFiles++;
+        if (file.lines > FILE_LENGTH_THRESHOLD) {
+            const mixedScore = computeMixedConcernsScore(file);
+            const severity = severityFromCohesion(mixedScore, file.lines);
+            if (!severity)
+                continue;
+            const cohesionPct = Math.round((1 - mixedScore) * 100);
+            findings.push({
+                severity,
+                category: 'file-length',
+                file: file.relativePath,
+                line: null,
+                title: `File has ${file.lines} lines (threshold: ${FILE_LENGTH_THRESHOLD}, cohesion: ${cohesionPct}%)`,
+                description: `Exceeds the ${FILE_LENGTH_THRESHOLD}-line threshold by ${file.lines - FILE_LENGTH_THRESHOLD} lines. ` +
+                    `Mixed-concerns score is ${roundOne(mixedScore)} (0 = focused, 1 = many concerns); ` +
+                    `severity reflects how mixed the file's responsibilities appear. ` +
+                    (mixedScore > 0.55
+                        ? 'Consider splitting unrelated exports into separate modules.'
+                        : 'The file is long but reasonably focused — split only if a clear seam exists.'),
+            });
+        }
+    }
+    if (scoredFiles === 0)
+        return { score: 100, findings: [], issueCount: 0 };
+    const score = Math.round(totalScore / scoredFiles);
+    return { score: Math.min(100, score), findings: findings.slice(0, ANALYZER_FINDING_BOUND), issueCount: findings.length };
+}
+function roundOne(n) {
+    return Math.round(n * 10) / 10;
+}
+function computeStructuralScope(files, duplicationRan) {
+    const heuristic = new Set(STRUCTURAL_EXTENSIONS);
+    const present = new Set(files.map((f) => extname(f.path).toLowerCase()));
+    const extensions = [...present].filter((ext) => duplicationRan || heuristic.has(ext)).sort();
+    const inScope = new Set(extensions);
+    let count = 0;
+    for (const f of files) {
+        if (!inScope.has(extname(f.path).toLowerCase()))
+            continue;
+        const role = classifyFileRole(f.relativePath);
+        if (role === 'test' || role === 'generated')
+            continue;
+        count++;
+    }
+    return { files: count, extensions };
+}
+const LINT_LIST_CAP = 100;
+const CATEGORY_LIST_CAP = 50;
+const SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
+function listingRank(f) {
+    return SEVERITY_RANK[f.severity] ?? SEVERITY_RANK.low + 1;
+}
+function dismissedRank(f) {
+    return f.dismissal === undefined ? 0 : 1;
+}
+function introducedRank(f) {
+    return f.introduced === true ? 0 : 1;
+}
+function inListingOrder(findings) {
+    return [...findings].sort((a, b) => dismissedRank(a) - dismissedRank(b) || introducedRank(a) - introducedRank(b) || listingRank(a) - listingRank(b));
+}
+export function applyListCap(findings, cap) {
+    return inListingOrder(findings).slice(0, cap);
+}
+export function isActiveFinding(f) {
+    return f.dismissal === undefined && f.status !== 'likely-fp';
+}
+export function indexDismissals(path, suppressions) {
+    const index = new Map();
+    for (const entry of suppressions) {
+        if (entry.path !== path)
+            continue;
+        index.set(entry.fingerprint, { reason: entry.reason, dismissedAt: entry.dismissedAt });
+    }
+    return index;
+}
+export function stampDismissals(findings, dismissals) {
+    for (const f of findings) {
+        const dismissal = f.fingerprint === undefined ? undefined : dismissals.get(f.fingerprint);
+        if (dismissal)
+            f.dismissal = { ...dismissal };
+        else if (f.dismissal !== undefined)
+            delete f.dismissal;
+    }
+    return findings;
+}
+export function applyDismissals(results, dismissals) {
+    const copy = (findings) => (findings ?? []).map((f) => ({ ...f }));
+    return recomputeGrade({
+        ...results,
+        categories: results.categories ?? [],
+        findings: stampDismissals(copy(results.findings), dismissals),
+        codeReview: stampDismissals(copy(results.codeReview), dismissals),
+    });
+}
+export function stampIntroduced(findings, baseline) {
+    for (const f of findings) {
+        f.introduced = !(f.fingerprint !== undefined && baseline.fingerprints.has(f.fingerprint));
+    }
+    return findings;
+}
+function computeGrade(score) {
+    return gradeFromScore(score);
+}
+const SEVERITY_WEIGHT = {
+    critical: 10,
+    high: 5,
+    medium: 2,
+    low: 0.5,
+};
+const CATEGORY_MULTIPLIER = {
+    security: 2.0,
+    bugs: 1.5,
+    architecture: 1.2,
+    logic: 1.2,
+    performance: 1.0,
+    oop: 0.8,
+    maintainability: 0.8,
+    complexity: 0.7,
+    lint: 0.5,
+    linting: 0.5,
+    format: 0.3,
+    'file-length': 0.3,
+    'function-length': 0.3,
+};
+const OVERALL_DECAY = 0.09;
+const CATEGORY_DECAY = 0.20;
+function findingPenalty(f) {
+    return (SEVERITY_WEIGHT[f.severity] ?? 2) * (CATEGORY_MULTIPLIER[f.category] ?? 1.0);
+}
+export function computeFormulaScore(allFindings, totalLines, unlistedCount = 0) {
+    const kloc = Math.max(totalLines / 1000, 1.0);
+    const issueDensity = Math.round(((allFindings.length + unlistedCount) / kloc) * 100) / 100;
+    if (allFindings.length === 0) {
+        return {
+            score: 100,
+            breakdown: { penaltyDensity: 0, totalPenalty: 0, issueDensity, kloc, categoryPenalties: [] },
+        };
+    }
+    const byCategory = new Map();
+    let totalPenalty = 0;
+    for (const f of allFindings) {
+        const p = findingPenalty(f);
+        totalPenalty += p;
+        const existing = byCategory.get(f.category);
+        if (existing) {
+            existing.penalty += p;
+            existing.count++;
+        }
+        else {
+            byCategory.set(f.category, { penalty: p, count: 1 });
+        }
+    }
+    const penaltyDensity = totalPenalty / kloc;
+    const score = Math.round(100 * Math.exp(-OVERALL_DECAY * penaltyDensity));
+    const categoryPenalties = [];
+    for (const [cat, data] of byCategory) {
+        const catDensity = data.penalty / kloc;
+        const catScore = Math.round(100 * Math.exp(-CATEGORY_DECAY * catDensity));
+        categoryPenalties.push({
+            category: cat,
+            score: catScore,
+            grade: computeGrade(catScore),
+            penalty: Math.round(data.penalty * 10) / 10,
+            findingCount: data.count,
+        });
+    }
+    categoryPenalties.sort((a, b) => a.score - b.score);
+    return {
+        score,
+        breakdown: {
+            penaltyDensity: Math.round(penaltyDensity * 100) / 100,
+            totalPenalty: Math.round(totalPenalty * 10) / 10,
+            issueDensity,
+            kloc: Math.round(kloc * 10) / 10,
+            categoryPenalties,
+        },
+    };
+}
+function computeGradeFields(allFindings, totalLines, forceNA, unlistedCount) {
+    const counted = allFindings.filter(findingCountsTowardGrade);
+    const { breakdown } = computeFormulaScore(counted, totalLines, unlistedCount);
+    const rating = computeQualityRating(counted, totalLines, { forceNA });
+    const prodGating = counted.filter((f) => f.category === 'build' || classifyFileRole(f.file) === 'production');
+    const prodRating = computeQualityRating(prodGating, totalLines, { forceNA });
+    const readiness = computeReadiness(prodRating.dimensions, prodGating);
+    return {
+        overall: rating.overall.score,
+        grade: rating.overall.grade,
+        scoreBreakdown: breakdown,
+        dimensions: rating.dimensions,
+        qualityGate: rating.qualityGate,
+        gradeRationale: rating.gradeRationale,
+        readiness,
+    };
+}
+function unlistedFindingCount(categories, findings) {
+    const counted = categories.reduce((sum, category) => sum + (category.issueCount ?? 0), 0);
+    return Math.max(0, counted - findings.length);
+}
+function toolBackedRow(name, result) {
+    return {
+        name,
+        score: result.score,
+        available: result.available,
+        issueCount: result.issueCount,
+        ...(result.reason === undefined ? {} : { reason: result.reason }),
+    };
+}
+function forceNAFromCategories(categories) {
+    const forceNA = new Set();
+    const linting = categories.find((c) => c.name === 'Linting');
+    const formatting = categories.find((c) => c.name === 'Formatting');
+    const complexity = categories.find((c) => c.name === 'Complexity');
+    if (!linting?.available && !formatting?.available && !complexity?.available) {
+        forceNA.add('maintainability');
+    }
+    return forceNA;
+}
+export function summarizeTriage(findings) {
+    let confirmed = 0;
+    let likelyFalsePositive = 0;
+    let uncertain = 0;
+    for (const f of findings) {
+        if (f.status === 'likely-fp')
+            likelyFalsePositive++;
+        else if (f.status === 'uncertain')
+            uncertain++;
+        else
+            confirmed++;
+    }
+    return { total: findings.length, confirmed, likelyFalsePositive, uncertain };
+}
+function stampStatuses(findings) {
+    for (const f of findings) {
+        if (f.status)
+            continue;
+        f.status = 'confirmed';
+    }
+}
+async function triageScanFindings(dirPath, allFindings, onProgress, signal, models) {
+    const candidates = allFindings.filter((f) => STRUCTURAL_CATEGORIES.has(f.category) && f.status === 'confirmed' && f.dismissal === undefined);
+    if (candidates.length === 0)
+        return allFindings;
+    onProgress?.({ step: 'Triaging findings', current: TRIAGE_STEP, total: TOTAL_STEPS });
+    const triageSend = (message) => onProgress?.({ step: message, current: TRIAGE_STEP, total: TOTAL_STEPS });
+    try {
+        const selection = models ?? backgroundTriageModels();
+        const triageResult = await runTriagePass(dirPath, candidates, triageSend, signal, selection.triageModel, selection.engine, selection.effortLevel, selection.fastMode);
+        if (!triageResult.ran)
+            return allFindings;
+        const verdictByCandidate = new Map();
+        for (let i = 0; i < candidates.length; i++) {
+            verdictByCandidate.set(candidates[i], triageResult.findings[i]);
+        }
+        return allFindings.map((f) => verdictByCandidate.get(f) ?? f);
+    }
+    catch {
+        return allFindings;
+    }
+}
+export class QualityScanAbortedError extends Error {
+    constructor() {
+        super('Quality scan aborted');
+        this.name = 'QualityScanAbortedError';
+    }
+}
+function checkAborted(signal) {
+    if (signal?.aborted)
+        throw new QualityScanAbortedError();
+}
+export function runQualityScan(dirPath, onProgressOrOptions, installedToolNames, signal, models, baseline, dismissals) {
+    const options = typeof onProgressOrOptions === 'object'
+        ? onProgressOrOptions
+        : { onProgress: onProgressOrOptions, installedToolNames, signal, models, baseline, dismissals };
+    return runScan(dirPath, options);
+}
+async function runScan(dirPath, options) {
+    const { onProgress, installedToolNames, signal, models, baseline, dismissals, toolOutputDir } = options;
+    const ecosystems = detectEcosystem(dirPath);
+    const cargoRoot = ecosystems.includes('rust') ? await cargoWorkspaceRoot(dirPath) : dirPath;
+    const installedSet = installedToolNames ? new Set(installedToolNames) : null;
+    const progress = (step, current) => {
+        onProgress?.({ step, current, total: TOTAL_STEPS });
+    };
+    checkAborted(signal);
+    progress('Collecting source files', 1);
+    const files = options.files ? readSourceFiles(dirPath, options.files) : await collectSourceFiles(dirPath, dirPath);
+    checkAborted(signal);
+    progress('Running linters', 2);
+    const lintResult = !installedSet || hasInstalledToolInCategory(installedSet, ecosystems, 'linter')
+        ? await analyzeLinting(dirPath, ecosystems, files, installedToolNames, cargoRoot)
+        : notRun(noInstalledTool('linter', ecosystems));
+    checkAborted(signal);
+    progress('Checking formatting', 3);
+    const fmtResult = !installedSet || hasInstalledToolInCategory(installedSet, ecosystems, 'formatter')
+        ? await analyzeFormatting(dirPath, ecosystems, files, cargoRoot)
+        : notRun(noInstalledTool('formatter', ecosystems));
+    checkAborted(signal);
+    progress('Checking build', 4);
+    const buildResult = await analyzeBuildErrors(dirPath, ecosystems, installedSet, cargoRoot);
+    checkAborted(signal);
+    progress('Analyzing complexity', 5);
+    const complexityResult = await analyzeComplexity(dirPath, ecosystems, files, installedToolNames);
+    checkAborted(signal);
+    progress('Checking file lengths', 6);
+    const fileLengthResult = analyzeFileLength(files);
+    checkAborted(signal);
+    progress('Checking function lengths', 7);
+    const funcLengthResult = analyzeFunctionLength(files);
+    checkAborted(signal);
+    progress('Detecting duplication', 8);
+    const duplicationResult = await analyzeDuplication(dirPath, ecosystems, files, installedSet, toolOutputDir);
+    checkAborted(signal);
+    progress('Scanning for secrets', 9);
+    const secretsResult = await analyzeSecrets(dirPath, toolOutputDir);
+    checkAborted(signal);
+    progress('Auditing dependencies', 10);
+    const dependenciesResult = await analyzeDependencies(dirPath, ecosystems, installedSet, cargoRoot, options.files !== undefined);
+    const produced = [
+        ...buildResult.findings,
+        ...lintResult.findings,
+        ...fmtResult.findings,
+        ...complexityResult.findings,
+        ...fileLengthResult.findings,
+        ...funcLengthResult.findings,
+        ...duplicationResult.findings,
+        ...secretsResult.findings,
+        ...dependenciesResult.findings,
+    ];
+    stampStatuses(produced);
+    stampFingerprints(produced, { dirPath, contentOf: collectedContentReader(files) });
+    const fingerprints = produced.flatMap((f) => (f.fingerprint ? [f.fingerprint] : []));
+    if (dismissals)
+        stampDismissals(produced, dismissals);
+    if (baseline)
+        stampIntroduced(produced, baseline);
+    const allFindings = [
+        ...buildResult.findings,
+        ...applyListCap(lintResult.findings, LINT_LIST_CAP),
+        ...applyListCap(fmtResult.findings, CATEGORY_LIST_CAP),
+        ...applyListCap(complexityResult.findings, CATEGORY_LIST_CAP),
+        ...applyListCap(fileLengthResult.findings, CATEGORY_LIST_CAP),
+        ...applyListCap(funcLengthResult.findings, CATEGORY_LIST_CAP),
+        ...applyListCap(duplicationResult.findings, CATEGORY_LIST_CAP),
+        ...applyListCap(secretsResult.findings, CATEGORY_LIST_CAP),
+        ...applyListCap(dependenciesResult.findings, CATEGORY_LIST_CAP),
+    ];
+    checkAborted(signal);
+    const triagedFindings = await triageScanFindings(dirPath, allFindings, onProgress, signal, models);
+    checkAborted(signal);
+    progress('Computing scores', SCORING_STEP);
+    const totalLines = files.reduce((sum, f) => sum + f.lines, 0);
+    const buildScore = buildResult.available && buildResult.findings.length === 0 ? 100 : 0;
+    const categories = [
+        toolBackedRow('Build', { score: buildScore, available: buildResult.available, issueCount: buildResult.findings.length, reason: buildResult.reason }),
+        toolBackedRow('Linting', lintResult),
+        toolBackedRow('Formatting', fmtResult),
+        { name: 'Complexity', score: complexityResult.score, available: complexityResult.available, issueCount: complexityResult.issueCount },
+        { name: 'File Length', score: fileLengthResult.score, available: true, issueCount: fileLengthResult.issueCount },
+        { name: 'Function Length', score: funcLengthResult.score, available: true, issueCount: funcLengthResult.issueCount },
+        toolBackedRow('Duplication', duplicationResult),
+        toolBackedRow('Secrets', secretsResult),
+        toolBackedRow('Dependencies', dependenciesResult),
+    ];
+    const forceNA = forceNAFromCategories(categories);
+    const gradeFields = computeGradeFields(triagedFindings, totalLines, forceNA, unlistedFindingCount(categories, triagedFindings));
+    return {
+        overall: gradeFields.overall,
+        grade: gradeFields.grade,
+        categories,
+        findings: inListingOrder(triagedFindings),
+        fingerprints,
+        ...(baseline ? { baselineAt: baseline.timestamp } : {}),
+        codeReview: [],
+        analyzedFiles: files.length,
+        structuralScope: computeStructuralScope(files, duplicationResult.available),
+        totalLines,
+        timestamp: new Date().toISOString(),
+        ecosystem: ecosystems,
+        scoreBreakdown: gradeFields.scoreBreakdown,
+        dimensions: gradeFields.dimensions,
+        qualityGate: gradeFields.qualityGate,
+        gradeRationale: gradeFields.gradeRationale,
+        readiness: gradeFields.readiness,
+        triage: summarizeTriage(triagedFindings),
+    };
+}
+export function recomputeGrade(results) {
+    const allFindings = [...results.findings, ...results.codeReview];
+    const forceNA = forceNAFromCategories(results.categories);
+    const gradeFields = computeGradeFields(allFindings, results.totalLines, forceNA, unlistedFindingCount(results.categories, results.findings));
+    return {
+        ...results,
+        overall: gradeFields.overall,
+        grade: gradeFields.grade,
+        scoreBreakdown: gradeFields.scoreBreakdown,
+        dimensions: gradeFields.dimensions,
+        qualityGate: gradeFields.qualityGate,
+        gradeRationale: gradeFields.gradeRationale,
+        readiness: gradeFields.readiness,
+        triage: summarizeTriage(results.findings),
+    };
+}
+export function recomputeWithAiReview(results, aiFindings) {
+    return recomputeGrade({ ...results, codeReview: [...results.codeReview, ...aiFindings] });
+}