vibecodedshit 0.0.0-stage → 0.2.0

package/dist/measure/p4-1.js

@@ -0,0 +1,184 @@
+import { readFileSync } from 'node:fs';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { ESLint } from 'eslint';
+import sonarjs from 'eslint-plugin-sonarjs';
+import tseslint from 'typescript-eslint';
+import { ToolError } from '../scope/types.js';
+import { failureReason, unavailable } from '../tools/outcome.js';
+import { createWorkCopy } from '../tools/workcopy.js';
+import { healthPlugin } from './eslint/health-plugin.js';
+import { emptyTallies, logicFiles, tallyUnits, unitId } from './units.js';
+/** Functions with cognitive complexity strictly greater than this count (methodology 4.1: "strictly greater than 15"). */
+const COMPLEXITY_THRESHOLD = 15;
+const MESSAGE = /from (\d+) to the 0 allowed/;
+const require = createRequire(import.meta.url);
+function installedVersion(pkg) {
+    const json = JSON.parse(readFileSync(require.resolve(`${pkg}/package.json`), 'utf8'));
+    return json.version;
+}
+/** TypeScript and JavaScript: the ESLint Node API with an inline config. No repository code runs, no repository config is read. */
+async function lintTypeScript(repoPath, files) {
+    const eslint = new ESLint({
+        overrideConfigFile: true,
+        cwd: repoPath,
+        ignore: false,
+        overrideConfig: [
+            {
+                files: ['**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}'],
+                languageOptions: {
+                    parser: tseslint.parser,
+                    sourceType: 'module',
+                    parserOptions: { ecmaFeatures: { jsx: true } },
+                },
+                plugins: { sonarjs, health: healthPlugin },
+                rules: { 'sonarjs/cognitive-complexity': ['error', 0], 'health/function': 'error' },
+            },
+        ],
+    });
+    const byPath = new Map(files.map((f) => [path.resolve(repoPath, f.path), f]));
+    const lint = await eslint.lintFiles([...byPath.keys()]);
+    const results = [];
+    let unparsed = 0;
+    for (const result of lint) {
+        const file = byPath.get(path.resolve(result.filePath));
+        if (!file)
+            continue;
+        if (result.messages.some((m) => m.fatal && m.ruleId === null)) {
+            unparsed += 1;
+            continue;
+        }
+        const entry = { file: file.path, group: file.group, functions: 0, complexities: [] };
+        for (const message of result.messages) {
+            if (message.ruleId === 'health/function') {
+                entry.functions += 1;
+            }
+            else if (message.ruleId === 'sonarjs/cognitive-complexity') {
+                const match = MESSAGE.exec(message.message);
+                if (!match?.[1])
+                    throw new ToolError(`eslint-plugin-sonarjs message not understood: ${message.message}`);
+                entry.complexities.push(Number(match[1]));
+            }
+        }
+        results.push(entry);
+    }
+    return { results, unparsed };
+}
+/** complexipy's line for a file it could not parse; the report still holds every other file. */
+const UNPARSED = /Failed to process /g;
+const ANSI = /\x1b\[[0-9;]*m/g;
+/**
+ * Python: complexipy in a work copy, so no repository config is read. complexipy exits 1 when any function is over
+ * --max-complexity-allowed (--ignore-complexity does not change that, 7.x and 8.x) or a file fails to parse; it still
+ * writes the report, so exit 1 is accepted and the report decides.
+ */
+async function runComplexipy(ctx, files) {
+    const tool = await ctx.tools.resolve('complexipy');
+    if (!tool)
+        return unavailable(ctx.tools.notFoundReason('complexipy'));
+    const copy = await createWorkCopy(ctx.repoPath, files.map((f) => f.path));
+    const outDir = await mkdtemp(path.join(tmpdir(), 'health-complexipy-'));
+    try {
+        const outFile = path.join(outDir, 'complexipy.json');
+        const result = await ctx.tools.run(tool, ['.', '--max-complexity-allowed', String(COMPLEXITY_THRESHOLD), '--no-ignore', '--ignore-complexity', '--output-format', 'json', '--output', outFile, '--quiet'], { cwd: copy.dir });
+        const failure = failureReason(tool, result, [0, 1]);
+        if (failure)
+            return unavailable(failure);
+        let entries;
+        try {
+            entries = JSON.parse(readFileSync(outFile, 'utf8'));
+            if (!Array.isArray(entries))
+                throw new Error('not an array');
+        }
+        catch {
+            return unavailable('complexipy printed no parseable JSON report');
+        }
+        const byRel = new Map(files.map((f) => [f.path, f]));
+        const perFile = new Map();
+        for (const entry of entries) {
+            if (typeof entry.path !== 'string' || typeof entry.complexity !== 'number') {
+                return unavailable('complexipy report has an unexpected shape');
+            }
+            const toRel = (p) => path.relative(copy.dir, path.resolve(copy.dir, p)).split(path.sep).join('/');
+            // `path` is the file; if a complexipy release makes it the directory, `file_name` completes it.
+            let rel = toRel(entry.path);
+            if (!byRel.has(rel) && typeof entry.file_name === 'string')
+                rel = toRel(path.join(entry.path, entry.file_name));
+            const file = byRel.get(rel);
+            if (!file)
+                continue;
+            const item = perFile.get(rel) ?? { file: rel, group: file.group, functions: 0, complexities: [] };
+            item.functions += 1;
+            if (entry.complexity > 0)
+                item.complexities.push(entry.complexity);
+            perFile.set(rel, item);
+        }
+        const unparsed = `${result.stdout}\n${result.stderr}`.replace(ANSI, '').match(UNPARSED)?.length ?? 0;
+        return { results: [...perFile.values()], unparsed };
+    }
+    finally {
+        await copy.cleanup();
+        await rm(outDir, { recursive: true, force: true });
+    }
+}
+export const p41 = {
+    id: '4.1',
+    layer: 'static',
+    async measure(ctx) {
+        const tsFiles = logicFiles(ctx.scope, 'typescript_javascript');
+        const pyFiles = logicFiles(ctx.scope, 'python');
+        const warnings = [];
+        const perFile = [];
+        let unparsed = 0;
+        if (tsFiles.length > 0) {
+            const ts = await lintTypeScript(ctx.repoPath, tsFiles);
+            perFile.push(...ts.results);
+            unparsed += ts.unparsed;
+            ctx.tools.recordVersion('eslint', installedVersion('eslint'));
+            ctx.tools.recordVersion('eslint-plugin-sonarjs', installedVersion('eslint-plugin-sonarjs'));
+            ctx.tools.recordVersion('@typescript-eslint/parser', installedVersion('@typescript-eslint/parser'));
+        }
+        if (pyFiles.length > 0) {
+            const py = await runComplexipy(ctx, pyFiles);
+            if (!('results' in py))
+                return py;
+            perFile.push(...py.results);
+            unparsed += py.unparsed;
+        }
+        if (unparsed > 0)
+            warnings.push(`4.1: ${unparsed} files could not be parsed`);
+        const tallies = emptyTallies([...tsFiles, ...pyFiles]);
+        const byPath = new Map([...tsFiles, ...pyFiles].map((f) => [f.path, f]));
+        const complexityByFile = [];
+        for (const item of perFile.sort((a, b) => (a.file < b.file ? -1 : a.file > b.file ? 1 : 0))) {
+            const file = byPath.get(item.file);
+            if (!file)
+                continue;
+            const tally = tallies.get(unitId(file));
+            if (!tally)
+                continue;
+            const over = item.complexities.filter((c) => c > COMPLEXITY_THRESHOLD).length;
+            tally.denominator += item.functions;
+            tally.numerator += over;
+            const sum = item.complexities.reduce((a, b) => a + b, 0);
+            if (sum > 0) {
+                complexityByFile.push({
+                    file: item.file,
+                    group: item.group,
+                    functions: item.functions,
+                    overThreshold: over,
+                    complexitySum: sum,
+                    complexityMax: Math.max(...item.complexities),
+                });
+            }
+        }
+        return {
+            status: 'measured',
+            units: tallyUnits(tallies),
+            reportOnly: { complexityByFile },
+            warnings,
+        };
+    },
+};

package/dist/measure/p4-2.js

@@ -0,0 +1,27 @@
+/** Files with more than this many logic lines are large (methodology 4.2). */
+const LARGE_FILE_LOGIC_LINES = 500;
+export const p42 = {
+    id: '4.2',
+    layer: 'static',
+    async measure({ scope }) {
+        const units = new Map();
+        for (const file of scope.files) {
+            if (file.role !== 'logic')
+                continue;
+            const key = `${file.package}\0${file.group}`;
+            const unit = units.get(key) ?? { package: file.package, group: file.group, large: 0, total: 0 };
+            unit.total += file.logicLines;
+            if (file.logicLines > LARGE_FILE_LOGIC_LINES)
+                unit.large += file.logicLines;
+            units.set(key, unit);
+        }
+        const ordered = [...units.values()].sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group));
+        const result = ordered.map((unit) => ({
+            package: unit.package,
+            group: unit.group,
+            weight: unit.total,
+            raw: { kind: 'ratio', numerator: unit.large, denominator: unit.total, scale: 100 },
+        }));
+        return { status: 'measured', units: result };
+    },
+};

package/dist/measure/p4-3.js

@@ -0,0 +1,106 @@
+import { readFileSync } from 'node:fs';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { failureReason, unavailable } from '../tools/outcome.js';
+import { createWorkCopy } from '../tools/workcopy.js';
+import { emptyTallies, logicFiles, tallyUnits, unitId } from './units.js';
+/** Methodology 4.3: min-tokens 50, min-lines 5. */
+const MIN_TOKENS = '50';
+const MIN_LINES = '5';
+/** Physical lines the way jscpd counts them: a trailing newline does not start another line. */
+function physicalLines(text) {
+    if (text === '')
+        return 0;
+    const lines = text.split(/\r\n|\r|\n/);
+    return text.endsWith('\n') || text.endsWith('\r') ? lines.length - 1 : lines.length;
+}
+function isRange(fragment) {
+    return !!fragment && typeof fragment.name === 'string' && typeof fragment.start === 'number' && typeof fragment.end === 'number';
+}
+/**
+ * Duplicated lines per file, the way jscpd's `duplicatedLines` counts them: each clone once, with the
+ * lines of the fragment it is attributed to. A clone belongs to its firstFile, or to its secondFile when
+ * firstFile is out of scope; a clone with neither file in scope is dropped. Returns null on a malformed clone.
+ */
+export function attributeClones(clones, inScope, rel) {
+    const byFile = new Map();
+    for (const clone of clones) {
+        if (!isRange(clone.firstFile) || !isRange(clone.secondFile))
+            return null;
+        const target = [clone.firstFile, clone.secondFile].find((f) => inScope(rel(f.name)));
+        if (!target)
+            continue;
+        const file = rel(target.name);
+        byFile.set(file, (byFile.get(file) ?? 0) + target.end - target.start + 1);
+    }
+    return byFile;
+}
+export const p43 = {
+    id: '4.3',
+    layer: 'static',
+    async measure(ctx) {
+        const files = [...logicFiles(ctx.scope, 'typescript_javascript'), ...logicFiles(ctx.scope, 'python')];
+        const tallies = emptyTallies(files);
+        if (files.length === 0)
+            return { status: 'measured', units: [] };
+        const tool = await ctx.tools.resolve('jscpd');
+        if (!tool)
+            return unavailable(ctx.tools.notFoundReason('jscpd'));
+        const copy = await createWorkCopy(ctx.repoPath, files.map((f) => f.path));
+        const outDir = await mkdtemp(path.join(tmpdir(), 'health-jscpd-'));
+        try {
+            const result = await ctx.tools.run(tool, [
+                '.',
+                '--min-tokens', MIN_TOKENS,
+                '--min-lines', MIN_LINES,
+                '--reporters', 'json',
+                '--output', outDir,
+                '--format', 'typescript,javascript,jsx,tsx,python',
+                '--max-lines', '1000000',
+                '--max-size', '100mb',
+                '--no-gitignore',
+                '--no-colors',
+            ], { cwd: copy.dir });
+            const failure = failureReason(tool, result, [0]);
+            if (failure)
+                return unavailable(failure);
+            let duplicates;
+            try {
+                const report = JSON.parse(readFileSync(path.join(outDir, 'jscpd-report.json'), 'utf8'));
+                if (!Array.isArray(report.duplicates))
+                    throw new Error('no duplicates array');
+                duplicates = report.duplicates;
+            }
+            catch {
+                return unavailable('jscpd report is missing or has an unexpected shape');
+            }
+            // jscpd 5 reports line totals per format, not per file, so the per-unit numbers are rebuilt here:
+            // lines are the file's physical lines (jscpd skips files shorter than min-lines), duplicated
+            // lines are the clones attributed to the file, each clone counted once.
+            const counted = new Map();
+            for (const file of files) {
+                const lines = physicalLines(readFileSync(path.join(copy.dir, file.path), 'utf8'));
+                if (lines >= Number(MIN_LINES))
+                    counted.set(file.path, lines);
+            }
+            const rel = (name) => path.relative(copy.dir, path.resolve(copy.dir, name)).split(path.sep).join('/');
+            const duplicated = attributeClones(duplicates, (file) => counted.has(file), rel);
+            if (!duplicated)
+                return unavailable('jscpd report has an unexpected shape');
+            for (const file of files) {
+                const tally = tallies.get(unitId(file));
+                const lines = counted.get(file.path);
+                if (!tally || lines === undefined)
+                    continue;
+                tally.denominator += lines;
+                tally.numerator += duplicated.get(file.path) ?? 0;
+            }
+            return { status: 'measured', units: tallyUnits(tallies) };
+        }
+        finally {
+            await copy.cleanup();
+            await rm(outDir, { recursive: true, force: true });
+        }
+    },
+};

package/dist/measure/p4-4.js

@@ -0,0 +1,309 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { analyzePythonDeadCode } from '../python/deadcode.js';
+import { isOutcome, knipFailed, runKnip } from '../tools/knip.js';
+import { failureReason, unavailable } from '../tools/outcome.js';
+import { createWorkCopy } from '../tools/workcopy.js';
+import { readToml } from '../util/toml.js';
+import { countExportedSymbols } from './ts/exports.js';
+import { emptyTallies, logicFiles, tallyUnits, unitId } from './units.js';
+/** methodology 4.4: vulture min-confidence 60. */
+const VULTURE_MIN_CONFIDENCE = '60';
+const VULTURE_LINE = /^(.+?):(\d+): unused (function|class|method) '(.+)' \((\d+)% confidence\)$/;
+/** Module basenames that are entry points: never reported as unused modules (methodology 4.4). */
+const ENTRY_NAMES = new Set([
+    '__main__', 'manage', 'wsgi', 'asgi', 'conftest', 'settings',
+    'models', 'admin', 'apps', 'urls', 'views', // Django conventions
+    'main', // FastAPI
+]);
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function pkgDirOf(pkg) {
+    return pkg === '.' ? '' : pkg;
+}
+function joinRel(...parts) {
+    return parts.filter((p) => p !== '').join('/');
+}
+// ---- TypeScript and JavaScript ----------------------------------------------------------
+/** Fills the TS/JS tallies. `failed` collects the units beneath a knip root whose install and knip both failed. */
+async function measureTypeScript(ctx, tallies, warnings, failed) {
+    const files = logicFiles(ctx.scope, 'typescript_javascript');
+    if (files.length === 0)
+        return null;
+    const knip = await runKnip(ctx);
+    if (!isOutcome(knip))
+        return knip;
+    warnings.push(...knip.warnings.map((w) => `4.4: ${w}`));
+    const perUnit = new Map();
+    for (const file of files) {
+        if (knipFailed(knip, file.path)) {
+            failed.add(unitId(file));
+            continue;
+        }
+        const exported = countExportedSymbols(ctx.scope.getTsSourceFile(file.path));
+        const issues = knip.files.get(file.path);
+        const unused = issues?.unusedFile ? exported : (issues?.exports ?? 0);
+        const key = unitId(file);
+        const unit = perUnit.get(key) ?? { numerator: 0, denominator: 0 };
+        unit.denominator += exported;
+        unit.numerator += unused;
+        perUnit.set(key, unit);
+    }
+    for (const [key, unit] of perUnit) {
+        const tally = tallies.get(key);
+        if (!tally)
+            continue;
+        if (unit.numerator > unit.denominator) {
+            warnings.push(`4.4: ${tally.package} (${tally.group}): knip reported ${unit.numerator} unused exports for ${unit.denominator} exported symbols, clamped`);
+            unit.numerator = unit.denominator;
+        }
+        tally.numerator += unit.numerator;
+        tally.denominator += unit.denominator;
+    }
+    return null;
+}
+function importRoots(pkg) {
+    const dir = pkgDirOf(pkg);
+    return [...new Set([dir, joinRel(dir, 'src'), ''])];
+}
+/** Module parts of `file` under import root `root`, or undefined when the file is not under it. */
+function modulePartsUnder(file, root) {
+    if (root !== '' && !file.startsWith(`${root}/`))
+        return undefined;
+    const rel = root === '' ? file : file.slice(root.length + 1);
+    const parts = rel.replace(/\.py$/, '').split('/');
+    if (parts[parts.length - 1] === '__init__')
+        parts.pop();
+    return parts;
+}
+function isDistributedPackage(repoPath, pkg, pyproject) {
+    if (pyproject && (asRecord(pyproject.project) || asRecord(asRecord(pyproject.tool)?.poetry)))
+        return true;
+    const dir = path.join(repoPath, pkgDirOf(pkg));
+    return existsSync(path.join(dir, 'setup.py')) || existsSync(path.join(dir, 'setup.cfg'));
+}
+function scriptTargets(pyproject) {
+    const targets = { modules: new Set(), objects: new Set() };
+    const add = (scripts) => {
+        for (const value of Object.values(asRecord(scripts) ?? {})) {
+            const text = typeof value === 'string' ? value : typeof asRecord(value)?.reference === 'string' ? String(asRecord(value)?.reference) : '';
+            const [modulePart, objectPart] = text.split(':');
+            const module = (modulePart ?? '').trim();
+            if (module === '')
+                continue;
+            targets.modules.add(module);
+            const object = (objectPart ?? '').trim();
+            if (object !== '')
+                targets.objects.add(`${module}:${object}`);
+        }
+    };
+    add(asRecord(pyproject?.project)?.scripts);
+    add(asRecord(asRecord(pyproject?.tool)?.poetry)?.scripts);
+    return targets;
+}
+function isEntryModule(mod, scripts) {
+    const segments = mod.file.path.replace(/\.py$/, '').split('/');
+    const base = segments[segments.length - 1] ?? '';
+    if (ENTRY_NAMES.has(base))
+        return true;
+    if (segments.slice(0, -1).includes('settings'))
+        return true;
+    return [...mod.names].some((name) => scripts.modules.has(name));
+}
+/** Imported dotted name to the files that import it. */
+function importGraph(modules, tests, pkg) {
+    const importedBy = new Map();
+    const mark = (name, importer) => {
+        if (name === '')
+            return;
+        const set = importedBy.get(name) ?? new Set();
+        set.add(importer);
+        importedBy.set(name, set);
+    };
+    const markWithParents = (parts, importer) => {
+        for (let i = 1; i <= parts.length; i += 1)
+            mark(parts.slice(0, i).join('.'), importer);
+    };
+    for (const mod of [...modules, ...tests]) {
+        for (const root of importRoots(pkg)) {
+            const own = modulePartsUnder(mod.file.path, root);
+            if (!own)
+                continue;
+            const isInit = mod.file.path.endsWith('/__init__.py') || mod.file.path === '__init__.py';
+            const ownPackage = isInit ? own : own.slice(0, -1);
+            for (const imp of mod.info.imports) {
+                const moduleParts = imp.module === '' ? [] : imp.module.split('.');
+                let base;
+                if (imp.level === 0) {
+                    base = moduleParts;
+                }
+                else {
+                    const keep = ownPackage.length - (imp.level - 1);
+                    if (keep < 0)
+                        continue;
+                    base = [...ownPackage.slice(0, keep), ...moduleParts];
+                }
+                markWithParents(base, mod.file.path);
+                if (imp.names.length > 0 && base.length > 0) {
+                    for (const name of imp.names)
+                        mark([...base, name].join('.'), mod.file.path);
+                }
+                else if (imp.names.length > 0) {
+                    for (const name of imp.names)
+                        mark(name, mod.file.path);
+                }
+            }
+        }
+    }
+    return importedBy;
+}
+/**
+ * A method vulture flags is used when it may be called through a base class (methodology 4.4): its class,
+ * directly or through base classes defined in the repository, has a base defined outside the scanned files
+ * (a framework or standard-library hook), or a base class defined in the repository has a method of the same name.
+ */
+export function isOverride(infos, file, qualname) {
+    const dot = qualname.indexOf('.');
+    if (dot === -1)
+        return false;
+    const method = qualname.slice(dot + 1);
+    const seen = new Set([`${file}\0${qualname.slice(0, dot)}`]);
+    const queue = [[file, qualname.slice(0, dot)]];
+    for (let next = queue.shift(); next; next = queue.shift()) {
+        const [classFile, className] = next;
+        const info = infos[classFile];
+        const cls = info?.ok ? info.classes[className] : undefined;
+        for (const base of cls?.bases ?? []) {
+            if (base.file === null || base.class === null)
+                return true;
+            const key = `${base.file}\0${base.class}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const baseInfo = infos[base.file];
+            if (baseInfo?.ok && baseInfo.symbols.some((s) => s.kind === 'method' && s.qualname === `${base.class}.${method}`))
+                return true;
+            queue.push([base.file, base.class]);
+        }
+    }
+    return false;
+}
+function matchSymbol(symbols, name, line) {
+    return symbols.find((s) => s.name === name && s.startLine <= line && line <= s.line);
+}
+async function measurePython(ctx, tallies, warnings) {
+    const logic = logicFiles(ctx.scope, 'python');
+    if (logic.length === 0)
+        return null;
+    const tests = ctx.scope.files.filter((f) => f.role === 'test' && f.group === 'python');
+    const vulture = await ctx.tools.resolve('vulture');
+    if (!vulture)
+        return unavailable(ctx.tools.notFoundReason('vulture'));
+    const infos = analyzePythonDeadCode(ctx.repoPath, [...logic, ...tests].map((f) => f.path));
+    let unparsed = 0;
+    for (const file of [...logic, ...tests])
+        if (infos[file.path]?.ok !== true)
+            unparsed += 1;
+    if (unparsed > 0)
+        warnings.push(`4.4: ${unparsed} Python files could not be parsed`);
+    const toModule = (file) => {
+        const info = infos[file.path];
+        if (!info || !info.ok)
+            return undefined;
+        const names = new Set();
+        for (const root of importRoots(file.package)) {
+            const parts = modulePartsUnder(file.path, root);
+            if (parts && parts.length > 0)
+                names.add(parts.join('.'));
+        }
+        return { file, info, names };
+    };
+    const packages = [...new Set(logic.map((f) => f.package))];
+    for (const pkg of packages) {
+        const unitLogic = logic.filter((f) => f.package === pkg).map(toModule).filter((m) => m !== undefined);
+        const unitTests = tests.filter((f) => f.package === pkg).map(toModule).filter((m) => m !== undefined);
+        const tally = tallies.get(unitId({ package: pkg, group: 'python' }));
+        if (!tally || unitLogic.length === 0)
+            continue;
+        const pyprojectPath = path.join(ctx.repoPath, joinRel(pkgDirOf(pkg), 'pyproject.toml'));
+        const pyproject = readToml(pyprojectPath);
+        if (pyproject === undefined && existsSync(pyprojectPath)) {
+            warnings.push(`${joinRel(pkgDirOf(pkg), 'pyproject.toml')}: invalid TOML, ignored`);
+        }
+        const distributed = isDistributedPackage(ctx.repoPath, pkg, pyproject);
+        const scripts = scriptTargets(pyproject);
+        const importedBy = importGraph(unitLogic, unitTests, pkg);
+        const unusedModules = new Set();
+        for (const mod of unitLogic) {
+            if (isEntryModule(mod, scripts))
+                continue;
+            const used = [...mod.names].some((name) => [...(importedBy.get(name) ?? [])].some((importer) => importer !== mod.file.path));
+            if (!used)
+                unusedModules.add(mod.file.path);
+        }
+        const copy = await createWorkCopy(ctx.repoPath, [...unitLogic, ...unitTests].map((m) => m.file.path));
+        let hits;
+        try {
+            const result = await ctx.tools.run(vulture, ['.', '--min-confidence', VULTURE_MIN_CONFIDENCE], { cwd: copy.dir });
+            const failure = failureReason(vulture, result, [0, 3]);
+            if (failure)
+                return unavailable(failure);
+            hits = [];
+            for (const line of result.stdout.split('\n')) {
+                const match = VULTURE_LINE.exec(line.trim());
+                if (!match)
+                    continue;
+                hits.push({
+                    file: path.posix.normalize((match[1] ?? '').split(path.sep).join('/')).replace(/^\.\//, ''),
+                    line: Number(match[2]),
+                    name: match[4] ?? '',
+                });
+            }
+        }
+        finally {
+            await copy.cleanup();
+        }
+        const hitsByFile = new Map();
+        for (const hit of hits)
+            hitsByFile.set(hit.file, [...(hitsByFile.get(hit.file) ?? []), hit]);
+        for (const mod of unitLogic) {
+            tally.denominator += mod.info.symbols.length;
+            if (unusedModules.has(mod.file.path)) {
+                tally.numerator += mod.info.symbols.length;
+                continue;
+            }
+            const counted = new Set();
+            const allNames = new Set(distributed ? (mod.info.allNames ?? []) : []);
+            for (const hit of hitsByFile.get(mod.file.path) ?? []) {
+                const symbol = matchSymbol(mod.info.symbols, hit.name, hit.line);
+                if (!symbol || symbol.decorated || allNames.has(symbol.name))
+                    continue;
+                if (symbol.kind === 'method' && isOverride(infos, mod.file.path, symbol.qualname))
+                    continue;
+                if ([...mod.names].some((name) => scripts.objects.has(`${name}:${symbol.qualname}`)))
+                    continue;
+                counted.add(symbol);
+            }
+            tally.numerator += counted.size;
+        }
+    }
+    return null;
+}
+export const p44 = {
+    id: '4.4',
+    layer: 'static',
+    async measure(ctx) {
+        const tallies = emptyTallies([...logicFiles(ctx.scope, 'typescript_javascript'), ...logicFiles(ctx.scope, 'python')]);
+        const warnings = [];
+        const failed = new Set();
+        const ts = await measureTypeScript(ctx, tallies, warnings, failed);
+        if (ts)
+            return ts;
+        const py = await measurePython(ctx, tallies, warnings);
+        if (py)
+            return py;
+        const units = tallyUnits(tallies).map((unit) => (failed.has(`${unit.package}\0${unit.group}`) ? { ...unit, raw: { kind: 'failed' } } : unit));
+        return { status: 'measured', units, warnings };
+    },
+};