vibecodedshit 0.0.0-stage → 0.2.0

package/dist/exec/test-runners/vitest.js

@@ -0,0 +1,28 @@
+import { parseCoverageRanges } from '../test-reports/coverage-ranges.js';
+import { parseCoverageSummary } from '../test-reports/coverage-summary.js';
+import { parseVitestJson } from '../test-reports/vitest-json.js';
+/** vitest 4 has no `coverage.all`; `coverage.include` reports files no test loads. The provider is `@vitest/coverage-v8`, see `health-coverage-install`. */
+export const vitest = {
+    results: 'results.json',
+    coverage: 'coverage/coverage-summary.json',
+    ranges: 'coverage/coverage-final.json',
+    argv: (invocation, globs) => [
+        'npx',
+        '--no-install',
+        'vitest',
+        'run',
+        '--reporter=json',
+        '--outputFile=/out/results.json',
+        '--coverage.enabled',
+        '--coverage.provider=v8',
+        '--coverage.reporter=json-summary',
+        '--coverage.reporter=json',
+        '--coverage.reportsDirectory=/out/coverage',
+        '--coverage.reportOnFailure',
+        ...globs.map((glob) => `--coverage.include=${glob}`),
+        ...invocation.args,
+    ],
+    parseResults: parseVitestJson,
+    parseCoverage: parseCoverageSummary,
+    parseRanges: parseCoverageRanges,
+};

package/dist/exec/tests.js

@@ -0,0 +1,120 @@
+import { emptyTallies, tallyUnits, unitId } from '../measure/units.js';
+import { analyzeTsFile } from '../scope/ts-lines.js';
+import { failedRootOf, withFailedUnits } from './roots.js';
+import { coveredLines } from './test-reports/coverage-ranges.js';
+/** Why the test run is a repository failure (1.1 to 1.3, 6.3 score 0), or null when every run has a usable results report. */
+export function testFailure(exec) {
+    if (!exec.checksRan)
+        return 'install failed, so the step did not run';
+    for (const run of exec.test.invocations) {
+        if (run.outcome.status === 'timeout')
+            return `${run.runner} timed out in ${run.dir}`;
+        if (!run.results)
+            return `${run.runner} wrote no usable results report in ${run.dir}`;
+    }
+    return null;
+}
+export function totalCases(exec) {
+    return exec.test.invocations.reduce((sum, run) => sum + (run.results ? run.results.passed + run.results.failed + run.results.errored + run.results.skipped : 0), 0);
+}
+function isUnder(file, dir) {
+    return dir === '.' || file.startsWith(`${dir}/`);
+}
+/** 1.1: passed / (passed + failed + errored) per test invocation. Skipped cases are in neither. With no case anywhere every unit is 0 of 0. */
+export function measurePassRate(ctx) {
+    const exec = ctx.exec;
+    if (!exec)
+        return { status: 'not_measured', reason: 'execution layer did not run' };
+    const reason = testFailure(exec);
+    if (reason !== null)
+        return { status: 'failed', reason };
+    const logic = ctx.scope.files.filter((f) => f.role === 'logic');
+    if (exec.test.invocations.length === 0)
+        return { status: 'measured', units: withFailedUnits(exec, ctx.scope, tallyUnits(emptyTallies(logic))) };
+    const units = exec.test.invocations.map((run) => {
+        const counts = run.results ?? { passed: 0, failed: 0, errored: 0, skipped: 0 };
+        return {
+            package: run.dir,
+            group: run.group,
+            weight: logic.filter((f) => f.group === run.group && isUnder(f.path, run.dir)).reduce((sum, f) => sum + f.logicLines, 0),
+            raw: { kind: 'ratio', numerator: counts.passed, denominator: counts.passed + counts.failed + counts.errored, scale: 100 },
+        };
+    });
+    return { status: 'measured', units: withFailedUnits(exec, ctx.scope, units) };
+}
+/** Code lines of a TS/JS logic file and how many ran, or null when no invocation's coverage-final.json lists the file. */
+function tsLineCoverage(ctx, exec, file) {
+    const reported = exec.test.invocations.map((run) => run.ranges?.get(file)).filter((r) => r !== undefined);
+    if (reported.length === 0)
+        return null;
+    const codeLines = analyzeTsFile(file, ctx.scope.getTsSourceFile(file).text).codeLineNumbers;
+    const covered = new Set();
+    for (const ranges of reported)
+        for (const line of coveredLines(codeLines, ranges))
+            covered.add(line);
+    return { total: codeLines.size, covered: covered.size };
+}
+/**
+ * 1.2 (lines) and 1.3 (branches): covered over coverable across the in-scope logic files, per (package,
+ * group) unit. 1.2 does not take the runner's line counts, which differ between runners for the same code:
+ * for a TS/JS file the coverable lines are health's own code lines and a line is covered when the innermost
+ * statement or function range holding it ran in any invocation (see `coveredLines`). Python lines and all
+ * branches are the tool's counts. A logic file the coverage report lacks counts as 0 covered with its logic
+ * lines coverable (it adds no branches), so it cannot raise the ratio. Coverage entries outside the logic set are dropped.
+ * With no test case at all every unit is 0 of 0 and scores `when_empty`.
+ */
+export function measureCoverage(ctx, kind) {
+    const exec = ctx.exec;
+    if (!exec)
+        return { status: 'not_measured', reason: 'execution layer did not run' };
+    const reason = testFailure(exec);
+    if (reason !== null)
+        return { status: 'failed', reason };
+    const logic = ctx.scope.files.filter((f) => f.role === 'logic');
+    const tallies = emptyTallies(logic);
+    if (totalCases(exec) === 0)
+        return { status: 'measured', units: withFailedUnits(exec, ctx.scope, tallyUnits(tallies)) };
+    const merged = new Map();
+    for (const run of exec.test.invocations) {
+        for (const [file, cov] of run.coverage ?? []) {
+            const had = merged.get(file);
+            merged.set(file, {
+                lines: { total: (had?.lines.total ?? 0) + cov.lines.total, covered: (had?.lines.covered ?? 0) + cov.lines.covered },
+                branches: { total: (had?.branches.total ?? 0) + cov.branches.total, covered: (had?.branches.covered ?? 0) + cov.branches.covered },
+            });
+        }
+    }
+    let missing = 0;
+    for (const file of logic) {
+        const tally = tallies.get(unitId(file));
+        if (!tally || failedRootOf(exec, file.path, file.group))
+            continue;
+        if (kind === 'lines' && file.group === 'typescript_javascript') {
+            const lines = tsLineCoverage(ctx, exec, file.path);
+            if (lines === null) {
+                missing += 1;
+                tally.denominator += file.logicLines;
+            }
+            else {
+                tally.numerator += lines.covered;
+                tally.denominator += lines.total;
+            }
+            continue;
+        }
+        const cov = merged.get(file.path);
+        if (cov) {
+            tally.numerator += cov[kind].covered;
+            tally.denominator += cov[kind].total;
+        }
+        else {
+            missing += 1;
+            if (kind === 'lines')
+                tally.denominator += file.logicLines;
+        }
+    }
+    return {
+        status: 'measured',
+        units: withFailedUnits(exec, ctx.scope, tallyUnits(tallies)),
+        ...(kind === 'lines' && missing > 0 ? { warnings: [`${missing} logic file(s) missing from the coverage report were counted as 0% covered`] } : {}),
+    };
+}

package/dist/exec/types.js

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

package/dist/manifest/package-json.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import { readTracked } from '../scope/tracked.js';
+const DEPENDENCY_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+function stringRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === 'string'));
+}
+/** The `package.json` in `dir` (repo-relative, "." for the root). Missing or invalid JSON gives undefined. */
+export function readPackageJson(repoPath, dir) {
+    const text = readTracked(repoPath, path.posix.join(dir === '' ? '.' : dir, 'package.json'));
+    if (text === null)
+        return undefined;
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (json === null || typeof json !== 'object' || Array.isArray(json))
+        return undefined;
+    const bag = json;
+    const dependencies = {};
+    for (const field of DEPENDENCY_FIELDS)
+        Object.assign(dependencies, stringRecord(bag[field]));
+    return {
+        ...(typeof bag.name === 'string' ? { name: bag.name } : {}),
+        scripts: stringRecord(bag.scripts),
+        dependencies,
+        engines: stringRecord(bag.engines),
+        ...(bag.volta !== null && typeof bag.volta === 'object' ? { volta: bag.volta } : {}),
+        ...(typeof bag.packageManager === 'string' ? { packageManager: bag.packageManager } : {}),
+        ...(bag.workspaces === undefined ? {} : { workspaces: bag.workspaces }),
+    };
+}

package/dist/manifest/python.js

@@ -0,0 +1,106 @@
+import path from 'node:path';
+import { parse } from 'smol-toml';
+import { readTracked, trackedPaths } from '../scope/tracked.js';
+import { parseIni } from '../util/ini.js';
+/** PEP 503 normalisation: lowercase, runs of `-`, `_` and `.` become `-`. */
+export function normalizeName(name) {
+    return name.toLowerCase().replace(/[-_.]+/g, '-');
+}
+/** The distribution name at the start of a requirement string (`Django[argon2]>=4 ; python_version>"3"`). */
+function requirementName(text) {
+    const match = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/.exec(text);
+    return match?.[1] === undefined ? undefined : normalizeName(match[1]);
+}
+function readTomlTracked(repoPath, rel) {
+    const text = readTracked(repoPath, rel);
+    if (text === null)
+        return undefined;
+    try {
+        return parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+const asRecord = (value) => (typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {});
+function addRequirements(out, value) {
+    if (!Array.isArray(value))
+        return;
+    for (const entry of value) {
+        if (typeof entry !== 'string')
+            continue;
+        const name = requirementName(entry);
+        if (name !== undefined)
+            out.add(name);
+    }
+}
+function addKeys(out, value) {
+    for (const key of Object.keys(asRecord(value))) {
+        if (key.toLowerCase() !== 'python')
+            out.add(normalizeName(key));
+    }
+}
+function addRequirementsFile(repoPath, rel, out, followIncludes) {
+    const text = readTracked(repoPath, rel);
+    if (text === null)
+        return;
+    for (const raw of text.split(/\r\n|\r|\n/)) {
+        const line = raw.replace(/(^|\s)#.*$/, '').trim();
+        if (line === '')
+            continue;
+        const include = /^(?:-r|--requirement)[\s=]+(\S+)/.exec(line);
+        if (include?.[1] !== undefined) {
+            if (followIncludes)
+                addRequirementsFile(repoPath, path.posix.normalize(path.posix.join(path.posix.dirname(rel), include[1])), out, false);
+            continue;
+        }
+        if (line.startsWith('-'))
+            continue;
+        const name = requirementName(line);
+        if (name !== undefined)
+            out.add(name);
+    }
+}
+/**
+ * Dependency names declared by the manifests in `dir` only (never an ancestor's): `[project]` dependencies and
+ * optional dependencies, `[dependency-groups]`, `[tool.poetry]` tables, `requirements*.txt` (with `-r` includes one
+ * level deep), `Pipfile` packages and `setup.cfg` `install_requires`. Names are PEP 503 normalised.
+ */
+export function pythonDeclaredDeps(repoPath, dir) {
+    const out = new Set();
+    const at = (name) => (dir === '.' || dir === '' ? name : path.posix.join(dir, name));
+    const pyproject = readTomlTracked(repoPath, at('pyproject.toml'));
+    if (pyproject !== undefined) {
+        const project = asRecord(pyproject.project);
+        addRequirements(out, project.dependencies);
+        for (const list of Object.values(asRecord(project['optional-dependencies'])))
+            addRequirements(out, list);
+        for (const list of Object.values(asRecord(pyproject['dependency-groups'])))
+            addRequirements(out, list);
+        const poetry = asRecord(asRecord(pyproject.tool).poetry);
+        addKeys(out, poetry.dependencies);
+        addKeys(out, poetry['dev-dependencies']);
+        for (const group of Object.values(asRecord(poetry.group)))
+            addKeys(out, asRecord(group).dependencies);
+    }
+    const prefix = dir === '.' || dir === '' ? '' : `${dir}/`;
+    for (const file of trackedPaths(repoPath)) {
+        if (!file.startsWith(prefix))
+            continue;
+        const name = file.slice(prefix.length);
+        if (/^requirements[^/]*\.txt$/.test(name))
+            addRequirementsFile(repoPath, file, out, true);
+    }
+    const pipfile = readTomlTracked(repoPath, at('Pipfile'));
+    if (pipfile !== undefined) {
+        addKeys(out, pipfile.packages);
+        addKeys(out, pipfile['dev-packages']);
+    }
+    const setupCfg = readTracked(repoPath, at('setup.cfg'));
+    if (setupCfg !== null) {
+        const required = parseIni(setupCfg).options?.install_requires;
+        if (required !== undefined)
+            addRequirements(out, required.split('\n'));
+    }
+    return out;
+}

package/dist/measure/d3/index.js

@@ -0,0 +1,45 @@
+import { pyAdapter } from './py/adapter.js';
+import { tsAdapter } from './ts/adapter.js';
+/** Explicit list. */
+const D3_ADAPTERS = [tsAdapter, pyAdapter];
+function adaptersFor(ctx) {
+    const groups = new Set(ctx.scope.files.filter((f) => f.role === 'logic').map((f) => f.group));
+    return D3_ADAPTERS.filter((adapter) => groups.has(adapter.group));
+}
+/**
+ * Why D3 cannot be measured as a whole: a language group has logic files but no adapter yet.
+ * Partial pooling would score only the languages that have one.
+ */
+export function d3Gap(ctx) {
+    const covered = new Set(D3_ADAPTERS.map((adapter) => adapter.group));
+    const missing = [...new Set(ctx.scope.files.filter((f) => f.role === 'logic').map((f) => f.group))].filter((g) => !covered.has(g));
+    return missing.length === 0 ? undefined : `D3 is not implemented yet for ${missing.join(', ')}`;
+}
+/** The rules facet: needs no external tool. Memoized per scan. */
+export function getD3Rules(ctx) {
+    return ctx.tools.memo(`d3:rules:${ctx.repoPath}`, async () => {
+        const units = [];
+        const warnings = [];
+        for (const adapter of adaptersFor(ctx)) {
+            const result = await adapter.rules(ctx);
+            units.push(...result.units);
+            warnings.push(...result.warnings);
+        }
+        return { units, warnings };
+    });
+}
+/** The graph facet. When any needed adapter is unavailable, the whole facet is (no partial pool). Memoized per scan. */
+export function getD3Graph(ctx) {
+    return ctx.tools.memo(`d3:graph:${ctx.repoPath}`, async () => {
+        const units = [];
+        const warnings = [];
+        for (const adapter of adaptersFor(ctx)) {
+            const result = await adapter.graph(ctx);
+            if ('unavailable' in result)
+                return result;
+            units.push(...result.units);
+            warnings.push(...result.warnings);
+        }
+        return { units, warnings };
+    });
+}

package/dist/measure/d3/presets.js

@@ -0,0 +1,100 @@
+import path from 'node:path';
+import picomatch from 'picomatch';
+/** Detection order of the D3 dimension file. */
+const DETECTION_ORDER = ['nextjs', 'express', 'django', 'fastapi', 'generic'];
+const LANGUAGES = { typescript_javascript: ['typescript', 'javascript'], python: ['python'] };
+/**
+ * The first preset in detection order whose `languages` include the group and whose detection predicate
+ * (`matches[key]`, supplied by the language adapter) holds. `generic` is the fallback.
+ */
+export function choosePreset(methodology, group, matches) {
+    for (const key of DETECTION_ORDER) {
+        const preset = methodology.presets[key];
+        if (!preset || !preset.languages.some((l) => LANGUAGES[group].includes(l)))
+            continue;
+        if (key === 'generic' || matches[key] === true)
+            return preset;
+    }
+    throw new Error('methodology has no generic preset');
+}
+const MATCH_OPTIONS = { dot: true };
+/** TypeScript and JavaScript match a glob with or without `src/`. Python passes its root package directories. */
+const TS_PREFIXES = ['', 'src/'];
+/** A glob `g` matches path `p` when `p` matches `prefix + g` for any of the prefixes (each empty or ending in `/`). */
+export function globMatcher(globs, prefixes = TS_PREFIXES) {
+    const matchers = prefixes.map((prefix) => picomatch(globs.map((g) => `${prefix}${g}`), MATCH_OPTIONS));
+    return (rel) => matchers.some((match) => match(rel));
+}
+/** Leading literal directory segments of a glob (`app/**` has 1, `features/*` has 1, `**` has 0). */
+function literalDepth(glob) {
+    const segments = glob.split('/');
+    let depth = 0;
+    for (const segment of segments.slice(0, -1)) {
+        if (/[*?[\]{}()!]/.test(segment))
+            break;
+        depth += 1;
+    }
+    return depth;
+}
+/**
+ * The glob layer of each file (paths relative to the package directory): the layer with the longest
+ * matching directory prefix, ties to the first layer listed. Files in no layer are absent.
+ */
+export function globLayers(layers, relFiles, prefixes = TS_PREFIXES) {
+    const compiled = Object.entries(layers)
+        .filter((entry) => Array.isArray(entry[1]))
+        .map(([name, globs]) => ({
+        name,
+        entries: globs.map((glob) => ({ depth: literalDepth(glob), match: globMatcher([glob], prefixes) })),
+    }));
+    const result = new Map();
+    for (const rel of relFiles) {
+        let best;
+        for (const layer of compiled) {
+            for (const entry of layer.entries) {
+                if (!entry.match(rel))
+                    continue;
+                const depth = entry.depth;
+                if (!best || depth > best.depth)
+                    best = { name: layer.name, depth };
+            }
+        }
+        if (best)
+            result.set(rel, best.name);
+    }
+    return result;
+}
+/** Directory (relative to the package) of the deepest module root containing the file, else undefined. */
+export function moduleDirs(roots, relFiles, prefixes = TS_PREFIXES) {
+    const isRoot = globMatcher(roots, prefixes);
+    const known = new Map();
+    const rootDir = (dir) => {
+        let value = known.get(dir);
+        if (value === undefined) {
+            value = isRoot(dir);
+            known.set(dir, value);
+        }
+        return value;
+    };
+    const result = new Map();
+    for (const rel of relFiles) {
+        let found;
+        for (let dir = path.posix.dirname(rel); dir !== '.' && dir !== '/'; dir = path.posix.dirname(dir)) {
+            if (rootDir(dir)) {
+                found = dir;
+                break;
+            }
+        }
+        result.set(rel, found);
+    }
+    return result;
+}
+/** The entry glob that applies to the group. */
+export function publicEntryGlob(preset, group) {
+    const entry = preset.modules.public_entry;
+    if (typeof entry === 'string')
+        return entry;
+    if (Array.isArray(entry))
+        return undefined;
+    return entry[group];
+}

package/dist/measure/d3/py/adapter.js

@@ -0,0 +1,67 @@
+import { pythonDeclaredDeps } from '../../../manifest/python.js';
+import { trackedPaths } from '../../../scope/tracked.js';
+import { ciInvokes } from '../../../scripts/expand.js';
+import { choosePreset } from '../presets.js';
+import { findPyDeclared } from './config.js';
+import { buildPyGraph } from './graph.js';
+import { pythonRoots } from './roots.js';
+const GROUP = 'python';
+function setup(ctx) {
+    return ctx.tools.memo(`d3:py:setup:${ctx.repoPath}`, async () => {
+        const warnings = [];
+        const tracked = new Set(trackedPaths(ctx.repoPath));
+        const byPackage = new Map();
+        for (const file of ctx.scope.files) {
+            if (file.group !== GROUP)
+                continue;
+            const list = byPackage.get(file.package) ?? [];
+            list.push(file);
+            byPackage.set(file.package, list);
+        }
+        const ciHits = ciInvokes(ctx.repoPath, ['lint-imports'], { warnings });
+        const declaredCache = new Map();
+        const units = [];
+        for (const [pkg, files] of [...byPackage].sort(([a], [b]) => a.localeCompare(b))) {
+            const logic = files.filter((f) => f.role === 'logic');
+            if (logic.length === 0)
+                continue;
+            const deps = pythonDeclaredDeps(ctx.repoPath, pkg);
+            const preset = choosePreset(ctx.methodology, GROUP, { django: deps.has('django'), fastapi: deps.has('fastapi') });
+            const declared = findPyDeclared(ctx.repoPath, pkg, warnings, declaredCache);
+            const weight = logic.reduce((sum, f) => sum + f.logicLines, 0);
+            const level31 = declared === undefined ? 'none' : ciHits.length > 0 ? 'enforced' : 'declared';
+            units.push({
+                package: pkg,
+                files,
+                logic,
+                weight,
+                preset,
+                declared,
+                roots: pythonRoots(pkg, files.map((f) => f.path), tracked, warnings),
+                rules: {
+                    package: pkg,
+                    group: GROUP,
+                    weight,
+                    preset: preset.preset,
+                    rulesSource: declared === undefined ? 'preset' : 'declared',
+                    ...(declared === undefined ? {} : { rulesFile: declared.file }),
+                    level31,
+                },
+            });
+        }
+        return { units, warnings };
+    });
+}
+export const pyAdapter = {
+    group: GROUP,
+    async rules(ctx) {
+        const { units, warnings } = await setup(ctx);
+        return { units: units.map((u) => u.rules), warnings };
+    },
+    async graph(ctx) {
+        return ctx.tools.memo(`d3:py:graph:${ctx.repoPath}`, async () => {
+            const { units } = await setup(ctx);
+            return buildPyGraph(ctx, units);
+        });
+    },
+};

package/dist/measure/d3/py/config.js

@@ -0,0 +1,80 @@
+import { parse } from 'smol-toml';
+import { readTracked } from '../../../scope/tracked.js';
+import { parseIni } from '../../../util/ini.js';
+const DIRECTION_TYPES = new Set(['layers', 'forbidden', 'independence']);
+/** The order import-linter itself tries its config files in. */
+const CONFIG_NAMES = ['setup.cfg', '.importlinter', 'pyproject.toml'];
+const lines = (value) => (value ?? '').split(/\r\n|\r|\n/).map((l) => l.trim()).filter((l) => l !== '');
+function iniContracts(text, requireSection) {
+    const ini = parseIni(text);
+    if (requireSection && ini.importlinter === undefined)
+        return undefined;
+    const out = [];
+    for (const [section, values] of Object.entries(ini)) {
+        if (!section.startsWith('importlinter:contract:'))
+            continue;
+        out.push({
+            name: values.name ?? section.slice('importlinter:contract:'.length),
+            type: (values.type ?? '').trim(),
+            layers: lines(values.layers),
+            containers: lines(values.containers),
+        });
+    }
+    return out;
+}
+function strings(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === 'string') : [];
+}
+function tomlContracts(text, file, warnings) {
+    let doc;
+    try {
+        doc = parse(text);
+    }
+    catch {
+        warnings.push(`${file}: could not be parsed, treated as absent`);
+        return undefined;
+    }
+    const tool = doc.tool;
+    const section = tool?.importlinter;
+    if (section === undefined || typeof section !== 'object')
+        return undefined;
+    const list = Array.isArray(section.contracts) ? section.contracts : [];
+    return list
+        .filter((c) => typeof c === 'object' && c !== null)
+        .map((c, index) => ({
+        name: typeof c.name === 'string' ? c.name : `contract-${index + 1}`,
+        type: typeof c.type === 'string' ? c.type : '',
+        layers: strings(c.layers),
+        containers: strings(c.containers),
+    }));
+}
+/**
+ * The rules file that governs a unit: walking from the unit directory up to the repository root, at each directory
+ * `setup.cfg`, `.importlinter`, `pyproject.toml` in that order; the first one with at least one layers, forbidden or
+ * independence contract. Files with other contract types only, an unparseable file and a `setup.cfg` without
+ * `[importlinter]` do not govern.
+ */
+export function findPyDeclared(repoPath, unitDir, warnings, cache) {
+    let dir = unitDir;
+    for (;;) {
+        for (const name of CONFIG_NAMES) {
+            const file = dir === '.' ? name : `${dir}/${name}`;
+            let result = cache.get(file);
+            if (result === undefined) {
+                const text = readTracked(repoPath, file);
+                let contracts;
+                if (text !== null)
+                    contracts = name === 'pyproject.toml' ? tomlContracts(text, file, warnings) : iniContracts(text, name === 'setup.cfg' || name === '.importlinter');
+                const direction = contracts?.filter((c) => DIRECTION_TYPES.has(c.type)) ?? [];
+                result = direction.length > 0 ? { file, contracts: direction } : null;
+                cache.set(file, result);
+            }
+            if (result !== null)
+                return result;
+        }
+        if (dir === '.')
+            return undefined;
+        const slash = dir.lastIndexOf('/');
+        dir = slash === -1 ? '.' : dir.slice(0, slash);
+    }
+}

package/dist/measure/d3/py/contracts.js

@@ -0,0 +1,57 @@
+import { moduleName } from './roots.js';
+/**
+ * Preset rules as contracts for one unit. `layerFiles` maps a layer to the unit's files in it; `unitFiles` is every
+ * in-scope file of the unit. One contract per (preset rule, `to` alternative), named `<package>:<rule>` with a
+ * `#packages` suffix on the packages alternative. Only files in a root package have module names.
+ */
+export function presetContracts(packageDir, rules, layerFiles, unitFiles, roots) {
+    const names = (files) => {
+        const out = new Set();
+        for (const file of files) {
+            for (const root of roots) {
+                const name = moduleName(root, file);
+                if (name !== undefined) {
+                    out.add(name);
+                    break;
+                }
+            }
+        }
+        return [...out].sort();
+    };
+    const union = (layers) => [...new Set(layers.flatMap((l) => [...(layerFiles.get(l) ?? [])]))];
+    const contracts = [];
+    const meta = new Map();
+    for (const rule of rules) {
+        if (rule.severity === 'info')
+            continue;
+        let fromFiles;
+        if (rule.from.in)
+            fromFiles = union(rule.from.in);
+        else {
+            const excluded = new Set(union(rule.from.not_in ?? []));
+            fromFiles = unitFiles.filter((f) => !excluded.has(f));
+        }
+        const source = names(fromFiles);
+        if (source.length === 0)
+            continue;
+        const base = `${packageDir}:${rule.name}`;
+        const add = (name, forbidden) => {
+            if (forbidden.length === 0)
+                return;
+            contracts.push({
+                id: name,
+                name,
+                type: 'forbidden',
+                source_modules: source,
+                forbidden_modules: forbidden,
+                as_packages: 'false',
+                allow_indirect_imports: 'true',
+                unmatched_ignore_imports_alerting: 'none',
+            });
+            meta.set(name, { rule: rule.name, excludesTypeOnly: rule.type_only_imports === 'excluded' });
+        };
+        add(base, rule.to.in ? names(union(rule.to.in)) : []);
+        add(`${base}#packages`, rule.to.packages ?? []);
+    }
+    return { contracts, meta };
+}