vibecodedshit 0.0.0-stage → 0.3.0

package/dist/scope/build.js

@@ -0,0 +1,173 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import ignore from 'ignore';
+import picomatch from 'picomatch';
+import { analyzePythonFiles, pythonVersion } from '../python/scope.js';
+import { detectPackages, packageOf } from './packages.js';
+import { hasGeneratedMarker, looksMinified, physicalLines } from './rules.js';
+import { analyzeTsFile, parseTsFile } from './ts-lines.js';
+import { ToolError, } from './types.js';
+export class NotAGitRepositoryError extends Error {
+    constructor(repoPath) {
+        super(`${repoPath} is not a git repository`);
+        this.name = 'NotAGitRepositoryError';
+    }
+}
+function sha256(text) {
+    return createHash('sha256').update(text).digest('hex');
+}
+function readIfPresent(file) {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function trackedFiles(repoPath) {
+    const result = spawnSync('git', ['-C', repoPath, 'ls-files', '-z'], {
+        encoding: 'utf8',
+        maxBuffer: 256 * 1024 * 1024,
+    });
+    if (result.error || result.status !== 0)
+        throw new NotAGitRepositoryError(repoPath);
+    return result.stdout.split('\0').filter((entry) => entry !== '');
+}
+function languageOf(file, methodology) {
+    const ext = path.posix.extname(file).toLowerCase();
+    const { extensions } = methodology.scope.source_files;
+    if (extensions.typescript.includes(ext))
+        return 'typescript';
+    if (extensions.javascript.includes(ext))
+        return 'javascript';
+    if (extensions.python.includes(ext))
+        return 'python';
+    return null;
+}
+function groupOf(language) {
+    return language === 'python' ? 'python' : 'typescript_javascript';
+}
+/** Glob entries only: scope.yaml mixes globs with prose rules, which are code in rules.ts. */
+function globsOnly(entries) {
+    return entries.filter((entry) => !/\s/.test(entry));
+}
+export async function buildScope(repoPath, methodology) {
+    const cfg = methodology.scope;
+    const tracked = trackedFiles(repoPath);
+    const fixedGlobs = [
+        ...cfg.exclusions.vendored,
+        ...cfg.exclusions.build_output,
+        ...cfg.exclusions.generated,
+        ...cfg.exclusions.minified,
+        ...cfg.exclusions.migrations,
+        ...cfg.exclusions.declarations,
+        ...cfg.exclusions.test_data,
+    ].filter((entry) => !/\s/.test(entry));
+    const isFixedExcluded = picomatch(fixedGlobs, { dot: true });
+    const isTest = {
+        typescript_javascript: picomatch(globsOnly(cfg.file_roles.test.typescript_javascript), { dot: true }),
+        python: picomatch(globsOnly(cfg.file_roles.test.python), { dot: true }),
+    };
+    const isConfig = picomatch(globsOnly(cfg.file_roles.config), { dot: true });
+    const healthignoreText = readIfPresent(path.join(repoPath, '.healthignore'));
+    const healthignore = healthignoreText === null ? null : ignore().add(healthignoreText);
+    const gitleaksText = readIfPresent(path.join(repoPath, '.gitleaksignore'));
+    const afterFixed = tracked.filter((file) => !isFixedExcluded(file));
+    const packages = detectPackages(repoPath, afterFixed);
+    const warnings = [];
+    let ignoredLines = 0;
+    let sourceExtLines = 0;
+    const candidates = [];
+    for (const file of afterFixed) {
+        const language = languageOf(file, methodology);
+        if (!language)
+            continue;
+        const text = readIfPresent(path.join(repoPath, file));
+        if (text === null)
+            continue; // tracked but deleted in the working tree
+        const normalized = text.replace(/\r\n?/g, '\n');
+        if (hasGeneratedMarker(normalized) || looksMinified(normalized))
+            continue;
+        const lines = physicalLines(normalized);
+        sourceExtLines += lines;
+        if (healthignore?.ignores(file)) {
+            ignoredLines += lines;
+            continue;
+        }
+        candidates.push({ file, language, text: normalized });
+    }
+    const pyFiles = candidates.filter((c) => c.language === 'python').map((c) => c.file);
+    const pyInfo = analyzePythonFiles(repoPath, pyFiles);
+    const pyVersion = pyFiles.length > 0 ? pythonVersion() : undefined;
+    const tsCache = new Map();
+    const textByPath = new Map(candidates.map((c) => [c.file, c.text]));
+    const files = [];
+    for (const { file, language, text } of candidates) {
+        const group = groupOf(language);
+        const base = { path: file, language, group, package: packageOf(file, packages) };
+        let role;
+        let codeLines;
+        if (isTest[group](file)) {
+            role = 'test';
+        }
+        else if (isConfig(file)) {
+            role = 'config';
+        }
+        else {
+            role = null; // decided below from whether the file defines anything callable
+        }
+        if (group === 'python') {
+            const info = pyInfo[file];
+            if (!info)
+                throw new ToolError(`scope_helper.py returned nothing for ${file}`);
+            if (!info.parsed)
+                warnings.push(`Python file ${file} did not parse; counted non-blank lines not starting with #`);
+            codeLines = info.lines;
+            if (role === null)
+                role = info.hasDef ? 'logic' : null;
+        }
+        else {
+            const info = analyzeTsFile(file, text);
+            tsCache.set(file, info.sourceFile);
+            codeLines = info.codeLines;
+            if (role === null)
+                role = info.definesCallable ? 'logic' : null;
+        }
+        if (role === null)
+            continue; // barrels, type-only and constant-only files are not logic files
+        files.push({
+            ...base,
+            role,
+            logicLines: role === 'logic' ? codeLines : 0,
+            sourceLines: role === 'logic' || role === 'test' ? codeLines : 0,
+        });
+    }
+    files.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    const logic = files.filter((f) => f.role === 'logic');
+    const usedPackages = [...new Set(files.map((f) => f.package))].sort();
+    return {
+        files,
+        excludedLinesPercent: sourceExtLines === 0 ? 0 : (ignoredLines / sourceExtLines) * 100,
+        packages: usedPackages,
+        logicFiles: logic.length,
+        logicLines: logic.reduce((sum, f) => sum + f.logicLines, 0),
+        sourceLines: files.reduce((sum, f) => sum + f.sourceLines, 0),
+        warnings,
+        healthignoreSha256: healthignoreText === null ? null : sha256(healthignoreText),
+        gitleaksignoreSha256: gitleaksText === null ? null : sha256(gitleaksText),
+        ...(pyVersion === undefined ? {} : { pythonVersion: pyVersion }),
+        getTsSourceFile(file) {
+            const cached = tsCache.get(file);
+            if (cached)
+                return cached;
+            const text = textByPath.get(file);
+            if (text === undefined)
+                throw new Error(`${file} is not an in-scope TypeScript or JavaScript file`);
+            const parsed = parseTsFile(file, text);
+            tsCache.set(file, parsed);
+            return parsed;
+        },
+    };
+}

package/dist/scope/packages.js

@@ -0,0 +1,87 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import picomatch from 'picomatch';
+import { parse } from 'yaml';
+function readIfPresent(file) {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function workspacePatterns(repoPath) {
+    const patterns = [];
+    const pkg = readIfPresent(path.join(repoPath, 'package.json'));
+    if (pkg !== null) {
+        try {
+            const json = JSON.parse(pkg);
+            const ws = json.workspaces;
+            if (Array.isArray(ws))
+                patterns.push(...ws.filter((w) => typeof w === 'string'));
+            else if (ws && typeof ws === 'object' && 'packages' in ws && Array.isArray(ws.packages)) {
+                patterns.push(...ws.packages.filter((w) => typeof w === 'string'));
+            }
+        }
+        catch {
+            // A malformed package.json declares no workspaces.
+        }
+    }
+    const pnpm = readIfPresent(path.join(repoPath, 'pnpm-workspace.yaml'));
+    if (pnpm !== null) {
+        try {
+            const doc = parse(pnpm);
+            if (doc && Array.isArray(doc.packages)) {
+                patterns.push(...doc.packages.filter((w) => typeof w === 'string'));
+            }
+        }
+        catch {
+            // Ignore a malformed pnpm-workspace.yaml.
+        }
+    }
+    const pyproject = readIfPresent(path.join(repoPath, 'pyproject.toml'));
+    if (pyproject !== null) {
+        const section = /\[tool\.uv\.workspace\]([\s\S]*?)(?:\n\[|$)/.exec(pyproject);
+        const members = section?.[1] ? /members\s*=\s*\[([\s\S]*?)\]/.exec(section[1]) : null;
+        if (members?.[1]) {
+            for (const match of members[1].matchAll(/["']([^"']+)["']/g)) {
+                if (match[1])
+                    patterns.push(match[1]);
+            }
+        }
+    }
+    return patterns;
+}
+/**
+ * Workspace package directories (repo-relative posix, never "."), found from
+ * workspace declarations and from directories that have their own pyproject.toml.
+ */
+export function detectPackages(repoPath, trackedFiles) {
+    const patterns = workspacePatterns(repoPath).map((p) => p.replace(/^\.\//, '').replace(/\/+$/, ''));
+    const positive = patterns.filter((p) => !p.startsWith('!'));
+    const negative = patterns.filter((p) => p.startsWith('!')).map((p) => p.slice(1));
+    const matchesDeclared = positive.length > 0 ? picomatch(positive, { dot: true, ignore: negative }) : null;
+    const found = new Set();
+    for (const file of trackedFiles) {
+        const base = path.posix.basename(file);
+        if (base !== 'package.json' && base !== 'pyproject.toml')
+            continue;
+        const dir = path.posix.dirname(file);
+        if (dir === '.')
+            continue;
+        if (base === 'pyproject.toml')
+            found.add(dir);
+        else if (matchesDeclared?.(dir))
+            found.add(dir);
+    }
+    return [...found].sort();
+}
+/** Deepest package directory containing the file, else ".". */
+export function packageOf(file, packages) {
+    let best = '.';
+    for (const pkg of packages) {
+        if (file.startsWith(`${pkg}/`) && (best === '.' || pkg.length > best.length))
+            best = pkg;
+    }
+    return best;
+}

package/dist/scope/rules.js

@@ -0,0 +1,21 @@
+// The only hard-coded rule constants: the prose exclusions in scope.yaml and the
+// "defines a function, method or class" test.
+const GENERATED_MARKERS = ['@generated', 'Code generated'];
+const GENERATED_HEAD_LINES = 5;
+const MINIFIED_AVG_LINE_LENGTH = 300;
+export function hasGeneratedMarker(text) {
+    const head = text.split('\n', GENERATED_HEAD_LINES).join('\n');
+    return GENERATED_MARKERS.some((marker) => head.includes(marker));
+}
+export function looksMinified(text) {
+    if (text.length === 0)
+        return false;
+    const lines = text.split('\n').length;
+    return text.length / lines > MINIFIED_AVG_LINE_LENGTH;
+}
+export function physicalLines(text) {
+    if (text.length === 0)
+        return 0;
+    const parts = text.split('\n');
+    return text.endsWith('\n') ? parts.length - 1 : parts.length;
+}

package/dist/scope/tracked.js

@@ -0,0 +1,34 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+const MAX_BYTES = 2 * 1024 * 1024;
+const cache = new Map();
+/** `git ls-files -z`, posix, before the fixed exclusions and `.healthignore`. Memoized per repository. */
+export function trackedPaths(repoPath) {
+    const key = path.resolve(repoPath);
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    const result = spawnSync('git', ['-C', key, 'ls-files', '-z'], { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+    const paths = result.error || result.status !== 0 ? [] : result.stdout.split('\0').filter((entry) => entry !== '');
+    cache.set(key, paths);
+    return paths;
+}
+export function resetTrackedCache() {
+    cache.clear();
+}
+/** UTF-8 text from the working tree; null when the path is not tracked, is missing or is over 2 MB. */
+export function readTracked(repoPath, rel) {
+    const normalized = path.posix.normalize(rel.split(path.sep).join('/'));
+    if (!trackedPaths(repoPath).includes(normalized))
+        return null;
+    const file = path.join(path.resolve(repoPath), normalized);
+    try {
+        if (statSync(file).size > MAX_BYTES)
+            return null;
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/scope/ts-lines.js

@@ -0,0 +1,63 @@
+import ts from 'typescript';
+const CALLABLE_KINDS = new Set([
+    ts.SyntaxKind.FunctionDeclaration,
+    ts.SyntaxKind.FunctionExpression,
+    ts.SyntaxKind.ArrowFunction,
+    ts.SyntaxKind.MethodDeclaration,
+    ts.SyntaxKind.Constructor,
+    ts.SyntaxKind.GetAccessor,
+    ts.SyntaxKind.SetAccessor,
+    ts.SyntaxKind.ClassDeclaration,
+    ts.SyntaxKind.ClassExpression,
+]);
+function scriptKindFor(file) {
+    const ext = file.slice(file.lastIndexOf('.')).toLowerCase();
+    if (ext === '.tsx')
+        return ts.ScriptKind.TSX;
+    if (ext === '.jsx')
+        return ts.ScriptKind.JSX;
+    if (ext === '.js' || ext === '.mjs' || ext === '.cjs')
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+export function parseTsFile(file, text) {
+    return ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, scriptKindFor(file));
+}
+/**
+ * Classify lines using the token stream: a line is code when a token (not trivia)
+ * touches it. Multi-line template literals and JSX text are tokens, so their lines
+ * are code. Comments, JSDoc and shebangs are trivia.
+ */
+export function analyzeTsFile(file, text) {
+    const sourceFile = parseTsFile(file, text);
+    const lineHasToken = new Set();
+    let definesCallable = false;
+    const visit = (node) => {
+        if (node.kind >= ts.SyntaxKind.FirstJSDocNode && node.kind <= ts.SyntaxKind.LastJSDocNode)
+            return;
+        if (CALLABLE_KINDS.has(node.kind))
+            definesCallable = true;
+        const children = node.getChildren(sourceFile);
+        if (children.length === 0) {
+            const start = node.getStart(sourceFile);
+            const end = node.getEnd();
+            if (end > start) {
+                const first = sourceFile.getLineAndCharacterOfPosition(start).line;
+                const last = sourceFile.getLineAndCharacterOfPosition(end - 1).line;
+                for (let line = first; line <= last; line += 1)
+                    lineHasToken.add(line);
+            }
+            return;
+        }
+        for (const child of children)
+            visit(child);
+    };
+    visit(sourceFile);
+    const lines = text.split('\n');
+    const codeLineNumbers = new Set();
+    for (const line of lineHasToken) {
+        if ((lines[line] ?? '').trim() !== '')
+            codeLineNumbers.add(line + 1);
+    }
+    return { sourceFile, definesCallable, codeLines: codeLineNumbers.size, codeLineNumbers };
+}

package/dist/scope/types.js

@@ -0,0 +1,7 @@
+/** A failure of the tool itself (missing interpreter, crashed helper), not of the scanned repository. */
+export class ToolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ToolError';
+    }
+}

package/dist/scoring/aggregate.js

@@ -0,0 +1,38 @@
+/** Weights after not-applicable and not-measured weight is spread in proportion. Null-score entries get 0. */
+export function effectiveWeights(params) {
+    const live = params.reduce((sum, p) => (p.score === null ? sum : sum + p.weight), 0);
+    const total = params.reduce((sum, p) => sum + p.weight, 0);
+    return params.map((p) => (p.score === null || live === 0 ? 0 : (p.weight / live) * total));
+}
+/** Weighted mean of the scored parameters. Null when none is scored. */
+export function dimensionScore(params) {
+    let weighted = 0;
+    let weights = 0;
+    for (const p of params) {
+        if (p.score === null)
+            continue;
+        weighted += p.score * p.weight;
+        weights += p.weight;
+    }
+    return weights === 0 ? null : weighted / weights;
+}
+/** health = min(mean, min + capMargin) over the scored dimensions. Null when none is scored. */
+export function healthScore(dimensionScores, capMargin) {
+    const scores = dimensionScores.filter((s) => s !== null);
+    if (scores.length === 0)
+        return null;
+    const mean = scores.reduce((sum, s) => sum + s, 0) / scores.length;
+    return Math.min(mean, Math.min(...scores) + capMargin);
+}
+/** Round half up to `digits` decimals. The tolerance makes a value written as x.x5 round as written; negative zero becomes 0. */
+export function roundHalfUp(value, digits = 0) {
+    const factor = 10 ** digits;
+    const rounded = Math.floor(value * factor + 0.5 + 1e-9) / factor;
+    return rounded === 0 ? 0 : rounded;
+}
+export function bandFor(displayedHealth, bands) {
+    const band = bands.find((b) => displayedHealth >= b.min && displayedHealth <= b.max);
+    if (!band)
+        throw new Error(`No band for health ${displayedHealth}`);
+    return band;
+}

package/dist/scoring/pool.js

@@ -0,0 +1,65 @@
+import { scoreRaw } from './score.js';
+/**
+ * Combine the units of one parameter into one raw value and score.
+ * ratio: sum numerators and denominators, score once. Units with a failed raw (their install root's install
+ * failed) take no part in the sums; the score is multiplied by the share of the logic lines that is not failed,
+ * so a broken package costs its share and cannot be hidden.
+ * unit_weighted: score each unit, combine by weight. A failed unit scores 0.
+ */
+export function poolParameter(def, units) {
+    const scored = units.map((unit) => ({
+        ...unit,
+        score: scoreRaw(def, unit.raw, unit.group),
+    }));
+    if (def.pooling === 'ratio') {
+        const live = units.filter((unit) => unit.raw.kind !== 'failed');
+        const pooled = poolRatio(def, live, scored);
+        if (live.length === units.length)
+            return pooled;
+        return { ...pooled, score: pooled.score * liveShare(live, units) };
+    }
+    const totalWeight = scored.reduce((sum, unit) => sum + unit.weight, 0);
+    if (totalWeight === 0)
+        return { raw: null, score: def.raw.when_empty, units: scored };
+    const score = scored.reduce((sum, unit) => sum + unit.score * unit.weight, 0) / totalWeight;
+    return { raw: null, score, units: scored };
+}
+/** Share of the logic lines (of the units, when none has a line) that belongs to `live`. */
+function liveShare(live, all) {
+    const total = all.reduce((sum, unit) => sum + unit.weight, 0);
+    if (total === 0)
+        return live.length / all.length;
+    return live.reduce((sum, unit) => sum + unit.weight, 0) / total;
+}
+function poolRatio(def, units, scored) {
+    let numerator = 0;
+    let denominator = 0;
+    let scale = null;
+    let summed = null;
+    for (const unit of units) {
+        // number raws (5.1 severity points) are summed, their denominator is ignored.
+        if (unit.raw.kind === 'number') {
+            summed = (summed ?? 0) + unit.raw.value;
+            continue;
+        }
+        if (unit.raw.kind !== 'ratio')
+            throw new Error(`${def.id}: ratio pooling needs ratio raws`);
+        if (scale !== null && scale !== unit.raw.scale) {
+            throw new Error(`${def.id}: units disagree on ratio scale`);
+        }
+        scale = unit.raw.scale;
+        numerator += unit.raw.numerator;
+        denominator += unit.raw.denominator;
+    }
+    if (summed !== null) {
+        if (scale !== null)
+            throw new Error(`${def.id}: ratio pooling cannot mix number and ratio raws`);
+        const raw = { kind: 'number', value: summed };
+        return { raw, score: scoreRaw(def, raw), units: scored };
+    }
+    if (scale === null || denominator === 0) {
+        return { raw: null, score: def.raw.when_empty, units: scored };
+    }
+    const raw = { kind: 'ratio', numerator, denominator, scale };
+    return { raw, score: scoreRaw(def, raw), units: scored };
+}

package/dist/scoring/score.js

@@ -0,0 +1,81 @@
+function clamp(value, lo, hi) {
+    return Math.min(hi, Math.max(lo, value));
+}
+/** The numeric value of a ratio or number raw. A ratio with no denominator has no value. */
+function rawValue(raw) {
+    if (raw.kind === 'number')
+        return raw.value;
+    if (raw.kind === 'ratio') {
+        return raw.denominator === 0 ? null : (raw.numerator / raw.denominator) * raw.scale;
+    }
+    throw new Error(`Raw of kind ${raw.kind} has no numeric value`);
+}
+function piecewiseLinear(anchors, value) {
+    const sorted = [...anchors].sort((a, b) => a.raw - b.raw);
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    if (!first || !last)
+        throw new Error('piecewise_linear needs anchors');
+    if (value <= first.raw)
+        return first.score;
+    if (value >= last.raw)
+        return last.score;
+    for (let i = 1; i < sorted.length; i += 1) {
+        const lo = sorted[i - 1];
+        const hi = sorted[i];
+        if (lo && hi && value <= hi.raw) {
+            return lo.score + ((value - lo.raw) / (hi.raw - lo.raw)) * (hi.score - lo.score);
+        }
+    }
+    return last.score;
+}
+function levelScore(levels, level) {
+    const found = levels.find((entry) => entry.level === level);
+    if (!found)
+        throw new Error(`Unknown level "${level}"`);
+    return found.score;
+}
+/** Score one raw value. A ratio with no denominator scores `raw.when_empty`. */
+export function scoreRaw(def, raw, group) {
+    if (raw.kind === 'failed')
+        return 0;
+    const scoring = def.scoring;
+    switch (scoring.method) {
+        case 'piecewise_linear': {
+            const value = rawValue(raw);
+            return value === null ? def.raw.when_empty : piecewiseLinear(scoring.anchors, value);
+        }
+        case 'levels': {
+            if (raw.kind !== 'level')
+                throw new Error(`${def.id}: levels scoring needs a level raw`);
+            if (Array.isArray(scoring.levels))
+                return levelScore(scoring.levels, raw.level);
+            if (!group)
+                throw new Error(`${def.id}: a language group is needed to score this level`);
+            const forGroup = scoring.levels[group];
+            if (!forGroup)
+                throw new Error(`${def.id}: no levels for group ${group}`);
+            return levelScore(forGroup, raw.level);
+        }
+        case 'mean_of_components': {
+            if (raw.kind !== 'components')
+                throw new Error(`${def.id}: needs a components raw`);
+            const scores = scoring.components.map((component) => {
+                const part = raw.components[component.key];
+                if (!part)
+                    throw new Error(`${def.id}: missing component ${component.key}`);
+                if (component.method === 'levels') {
+                    if (part.kind !== 'level' || !component.levels) {
+                        throw new Error(`${def.id}.${component.key}: needs a level raw`);
+                    }
+                    return levelScore(component.levels, part.level);
+                }
+                const value = rawValue(part);
+                if (value === null)
+                    return part.kind === 'ratio' ? (part.emptyScore ?? def.raw.when_empty) : def.raw.when_empty;
+                return clamp(value, 0, 100);
+            });
+            return scores.reduce((sum, s) => sum + s, 0) / scores.length;
+        }
+    }
+}

package/dist/scoring/what-if.js

@@ -0,0 +1,38 @@
+import { dimensionScore, healthScore } from './aggregate.js';
+function weighted(def, param, overrides) {
+    const override = overrides.get(def.id);
+    if (override !== undefined)
+        return { weight: def.weight, score: override };
+    if (param?.status === 'failed')
+        return { weight: def.weight, score: 0 };
+    if (param?.status === 'measured')
+        return { weight: def.weight, score: param.score ?? 0 };
+    return { weight: def.weight, score: null };
+}
+/** The unrounded health and dimension scores if the overridden parameters had the given scores. Reads the stored parameters only. */
+export function healthWith(run, methodology, overrides) {
+    const dimension = new Map();
+    for (const dim of methodology.dimensions) {
+        dimension.set(dim.id, dimensionScore(dim.parameters.map((def) => weighted(def, run.parameters.find((p) => p.id === def.id), overrides))));
+    }
+    return { health: healthScore([...dimension.values()], methodology.capMargin), dimension };
+}
+/** The lowest-scoring anchor or level above `score` that has a descriptor. Null when there is none or the parameter has no descriptors. */
+export function nextCandidate(def, score) {
+    const scoring = def.scoring;
+    let candidates;
+    if (scoring.method === 'piecewise_linear')
+        candidates = scoring.anchors;
+    else if (scoring.method === 'levels')
+        candidates = Array.isArray(scoring.levels) ? scoring.levels : Object.values(scoring.levels).flat();
+    else
+        return null;
+    let best;
+    for (const candidate of candidates) {
+        if (!candidate.descriptor || candidate.score <= score + 1e-9)
+            continue;
+        if (!best || candidate.score < best.score)
+            best = { score: candidate.score, descriptor: candidate.descriptor };
+    }
+    return best ? { score: best.score, descriptor: best.descriptor.replace(/\s+/g, ' ').trim() } : null;
+}

package/dist/scripts/checks.js

@@ -0,0 +1,53 @@
+const INFO_FLAGS = new Set(['--help', '--version', '-h', '-V']);
+const TSC_NON_CHECKS = new Set(['--init', '--help', '--version', '-v', '-h']);
+const BIOME_CHECKS = new Set(['check', 'lint', 'ci']);
+/** Tools that run checks the methodology does not recognise (a finding on 6.2). */
+export const UNRECOGNISED_RUNNERS = new Set(['turbo', 'nx', 'lerna', 'next', 'ng', 'react-scripts']);
+/** `python -m unittest` is the tool `unittest` once its prefix is removed; `node --test` is the tool `node` with that flag. */
+function testToolNames(rec) {
+    const tools = new Set();
+    let nodeTest = false;
+    for (const entry of rec.testRunners) {
+        if (entry === 'node --test')
+            nodeTest = true;
+        else
+            tools.add(entry.replace(/^python3? -m /, ''));
+    }
+    return { tools, nodeTest };
+}
+/**
+ * The checks a command runs, by tool, after prefix removal. A check is recognised by tool, not by language group, so `tsc` counts
+ * for a Python unit in a mixed package and `mypy` for a TypeScript one.
+ */
+export function checkKinds(cmd, rec) {
+    const out = new Set();
+    const tool = cmd.tool;
+    if (tool === null)
+        return out;
+    if (cmd.argv.some((a) => INFO_FLAGS.has(a)))
+        return out;
+    const first = cmd.argv.find((a) => !a.startsWith('-'));
+    if (rec.typecheckers.includes(tool)) {
+        if (tool === 'tsc' && cmd.argv.some((a) => TSC_NON_CHECKS.has(a)))
+            return out;
+        out.add('typecheck');
+        return out;
+    }
+    if (rec.linters.includes(tool)) {
+        if (tool === 'ruff' && first === 'format')
+            return out;
+        if (tool === 'biome' && !(first !== undefined && BIOME_CHECKS.has(first)))
+            return out;
+        out.add('lint');
+        return out;
+    }
+    const { tools, nodeTest } = testToolNames(rec);
+    if (tool === 'tox' || tool === 'nox') {
+        if (tools.has(tool) && cmd.readable !== true)
+            out.add('test');
+        return out;
+    }
+    if (tools.has(tool) || (nodeTest && tool === 'node' && cmd.argv.includes('--test')))
+        out.add('test');
+    return out;
+}