vibecodedshit 0.0.0-stage → 0.2.0

package/dist/run/scan.js

@@ -0,0 +1,196 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import ts from 'typescript';
+import { createDockerRunner, imageDigest } from '../exec/docker.js';
+import { runExecution } from '../exec/run.js';
+import { executionRoots, failedRootDirs } from '../exec/roots.js';
+import { feedbackLoop } from '../measure/p6-3.js';
+import { measurers as allMeasurers } from '../measure/registry.js';
+import { computeHotspots } from '../report-only/hotspots.js';
+import { loadMethodology, packageRoot } from '../methodology/load.js';
+import { buildScope } from '../scope/build.js';
+import { poolParameter } from '../scoring/pool.js';
+import { createImageToolKit } from '../tools/image.js';
+import { createToolKit } from '../tools/kit.js';
+import { breakdownFor, dimensionScores, healthFrom } from './score-run.js';
+export class NoLogicFilesError extends Error {
+    constructor() {
+        super('The repository has no logic file, so it is not scored');
+        this.name = 'NoLogicFilesError';
+    }
+}
+function git(repoPath, args) {
+    const result = spawnSync('git', ['-C', repoPath, ...args], { encoding: 'utf8' });
+    return result.error || result.status !== 0 ? null : result.stdout.trim();
+}
+function healthVersion() {
+    const pkg = JSON.parse(readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+    return pkg.version;
+}
+function baseRun(opts) {
+    const repoPath = path.resolve(opts.repoPath);
+    const gitVersion = spawnSync('git', ['--version'], { encoding: 'utf8' }).stdout.trim().replace(/^git version /, '');
+    return {
+        schemaVersion: 1,
+        valid: true,
+        warnings: [],
+        methodology: { version: opts.methodologyVersion },
+        mode: opts.mode,
+        comparable: false,
+        comparableReason: 'preview, not comparable',
+        asOf: opts.asOf,
+        layers: ['static'],
+        repo: {
+            path: repoPath,
+            headCommit: git(repoPath, ['rev-parse', '--verify', '-q', 'HEAD']),
+            treeHash: git(repoPath, ['rev-parse', '--verify', '-q', 'HEAD^{tree}']),
+        },
+        tools: { health: healthVersion(), node: process.version, typescript: ts.version, git: gitVersion },
+    };
+}
+/** A run for a tool error: marked invalid, with no scores and no health. */
+export function invalidRun(opts, reason) {
+    return {
+        ...baseRun(opts),
+        valid: false,
+        invalidReason: reason,
+        ignoreSet: { healthignoreSha256: null, gitleaksignoreSha256: null, excludedLinesPercent: 0 },
+        scope: { logicFiles: 0, logicLines: 0, sourceLines: 0, packages: [] },
+        parameters: [],
+        dimensions: [],
+        breakdown: { byPackage: {}, byGroup: {} },
+        health: null,
+    };
+}
+export async function runScan(opts, preloaded) {
+    const methodology = preloaded ?? loadMethodology(opts.methodologyVersion, opts.rootDir);
+    const repoPath = path.resolve(opts.repoPath);
+    const scope = await buildScope(repoPath, methodology);
+    if (scope.logicFiles === 0)
+        throw new NoLogicFilesError();
+    let exec;
+    let cleanup;
+    if (opts.mode === 'full') {
+        const tag = methodology.execution.runner.image;
+        ({ results: exec, cleanup } = await runExecution({
+            repoPath,
+            methodology,
+            scope,
+            runner: opts.execRunner ?? createDockerRunner(methodology.execution.runner, opts.dockerSpawn),
+            image: { tag, digest: opts.imageDigest ?? (await imageDigest(tag, opts.dockerSpawn)) },
+        }));
+    }
+    try {
+        return await measureAll(opts, methodology, repoPath, scope, exec);
+    }
+    finally {
+        await cleanup?.();
+    }
+}
+/** Every measurer, then scoring. The execution work copy (`exec.workDir`) still exists while this runs. */
+async function measureAll(opts, methodology, repoPath, scope, exec) {
+    const tools = opts.tools
+        ?? (opts.mode === 'full'
+            ? createImageToolKit({ runner: methodology.execution.runner, repoPath, ...(opts.dockerSpawn ? { spawn: opts.dockerSpawn } : {}) })
+            : createToolKit());
+    const warnings = [...scope.warnings];
+    const reportOnly = {};
+    const parameters = [];
+    for (const dimension of methodology.dimensions) {
+        for (const def of dimension.parameters) {
+            if (def.layer === 'execution' && opts.mode === 'preview') {
+                parameters.push({
+                    id: def.id,
+                    status: 'not_measured',
+                    reason: 'execution layer, not run in preview',
+                    weight: def.weight,
+                });
+                continue;
+            }
+            const measurer = (opts.measurers ?? allMeasurers).find((m) => m.id === def.id);
+            if (!measurer) {
+                parameters.push({ id: def.id, status: 'not_measured', reason: 'not implemented yet', weight: def.weight });
+                continue;
+            }
+            const measurement = await measurer.measure({
+                methodology,
+                param: def,
+                scope,
+                repoPath,
+                asOf: opts.asOf,
+                mode: opts.mode,
+                tools,
+                ...(exec ? { exec } : {}),
+            });
+            if (measurement.status === 'measured') {
+                Object.assign(reportOnly, measurement.reportOnly);
+                warnings.push(...(measurement.warnings ?? []));
+                const pooled = poolParameter(def, measurement.units);
+                const failedDirs = exec ? failedRootDirs(exec, scope, measurement.units) : [];
+                parameters.push({
+                    id: def.id,
+                    status: 'measured',
+                    ...(failedDirs.length > 0 ? { reason: `install failed in ${failedDirs.join(', ')}` } : {}),
+                    weight: def.weight,
+                    raw: pooled.raw,
+                    score: pooled.score,
+                    units: pooled.units,
+                });
+            }
+            else if (measurement.status === 'not_measured') {
+                parameters.push({ id: def.id, status: 'not_measured', reason: measurement.reason, weight: def.weight });
+            }
+            else if (measurement.status === 'failed') {
+                parameters.push({ id: def.id, status: 'failed', reason: measurement.reason, weight: def.weight, score: 0 });
+            }
+            else {
+                parameters.push({ id: def.id, status: 'not_applicable', reason: measurement.reason, weight: def.weight });
+            }
+        }
+    }
+    const complexityByFile = reportOnly.complexityByFile;
+    if (Array.isArray(complexityByFile)) {
+        const hotspots = computeHotspots(repoPath, opts.asOf, complexityByFile);
+        reportOnly.hotspots = hotspots.hotspots;
+        warnings.push(...hotspots.warnings);
+    }
+    reportOnly.pythonInScope = scope.files.some((f) => f.language === 'python');
+    const dimensions = dimensionScores(methodology, parameters);
+    const base = baseRun(opts);
+    const unmeasured = parameters.filter((p) => p.status === 'not_measured').map((p) => `${p.id} (${p.reason})`);
+    return {
+        ...base,
+        ...(opts.mode === 'full'
+            ? {
+                layers: ['static', 'execution'],
+                comparable: unmeasured.length === 0,
+                comparableReason: unmeasured.length === 0 ? 'all parameters measured' : `not comparable, not measured: ${unmeasured.join(', ')}`,
+            }
+            : {}),
+        warnings,
+        tools: {
+            ...base.tools,
+            ...(exec ? { image: exec.image } : {}),
+            ...(scope.pythonVersion === undefined ? {} : { python: scope.pythonVersion }),
+            ...(Object.keys(tools.versions()).length === 0 ? {} : { static: tools.versions() }),
+        },
+        ...(exec ? { execution: { feedbackLoop: feedbackLoop(exec), roots: executionRoots(exec) } } : {}),
+        ...(Object.keys(reportOnly).length === 0 ? {} : { reportOnly }),
+        ignoreSet: {
+            healthignoreSha256: scope.healthignoreSha256,
+            gitleaksignoreSha256: scope.gitleaksignoreSha256,
+            excludedLinesPercent: scope.excludedLinesPercent,
+        },
+        scope: {
+            logicFiles: scope.logicFiles,
+            logicLines: scope.logicLines,
+            sourceLines: scope.sourceLines,
+            packages: scope.packages,
+        },
+        parameters,
+        dimensions,
+        breakdown: breakdownFor(methodology, parameters),
+        health: healthFrom(methodology, dimensions),
+    };
+}

package/dist/run/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/run/score-run.js

@@ -0,0 +1,42 @@
+import { bandFor, dimensionScore, healthScore, roundHalfUp } from '../scoring/aggregate.js';
+import { poolParameter } from '../scoring/pool.js';
+function liveScore(def, param, units) {
+    if (!param)
+        return null;
+    if (param.status === 'failed')
+        return 0;
+    if (param.status !== 'measured')
+        return null;
+    return poolParameter(def, units ?? param.units ?? []).score;
+}
+export function dimensionScores(methodology, parameters, filter) {
+    return methodology.dimensions.map((dimension) => {
+        const weighted = dimension.parameters.map((def) => {
+            const param = parameters.find((p) => p.id === def.id);
+            if (filter && param?.status === 'measured') {
+                const units = (param.units ?? []).filter(filter);
+                // A package or language with no units for a parameter has no data for it.
+                return { weight: def.weight, score: units.length === 0 ? null : liveScore(def, param, units) };
+            }
+            return { weight: def.weight, score: liveScore(def, param) };
+        });
+        return { id: dimension.id, key: dimension.key, score: dimensionScore(weighted) };
+    });
+}
+export function healthFrom(methodology, dimensions) {
+    const score = healthScore(dimensions.map((d) => d.score), methodology.capMargin);
+    if (score === null)
+        return null;
+    const displayed = roundHalfUp(score);
+    return { score, displayed, band: bandFor(displayed, methodology.bands).key };
+}
+export function breakdownFor(methodology, parameters) {
+    const units = parameters.flatMap((p) => p.units ?? []);
+    const packages = [...new Set(units.map((u) => u.package))].sort();
+    const groups = [...new Set(units.map((u) => u.group))].sort();
+    const toRecord = (dims) => Object.fromEntries(dims.map((d) => [String(d.id), d.score]));
+    return {
+        byPackage: Object.fromEntries(packages.map((pkg) => [pkg, toRecord(dimensionScores(methodology, parameters, (u) => u.package === pkg))])),
+        byGroup: Object.fromEntries(groups.map((group) => [group, toRecord(dimensionScores(methodology, parameters, (u) => u.group === group))])),
+    };
+}

package/dist/run/write.js

@@ -0,0 +1,4 @@
+import { writeFileSync } from 'node:fs';
+export function writeRun(file, run) {
+    writeFileSync(file, `${JSON.stringify(run, null, 2)}\n`, 'utf8');
+}

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;
+}