vibecodedshit 0.0.0-stage → 0.3.0

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

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

@@ -0,0 +1,57 @@
+import path from 'node:path';
+import { moduleName } from './roots.js';
+/** Logic files with a directory named exactly `domain` anywhere in their path. */
+function isDomainDir(file) {
+    return path.posix.dirname(file).split('/').includes('domain');
+}
+/**
+ * Dotted module names of the layers named `domain` in declared `layers` contracts: the last dotted component of the
+ * layer is `domain`; entries split on `|` and `:` and are prefixed with each container the contract names.
+ */
+export function declaredDomainModules(contracts) {
+    const out = [];
+    for (const contract of contracts) {
+        if (contract.type !== 'layers')
+            continue;
+        for (const line of contract.layers) {
+            for (const raw of line.split(/[|:]/)) {
+                const layer = raw.trim();
+                if (layer === '' || layer.split('.').pop() !== 'domain')
+                    continue;
+                if (contract.containers.length === 0)
+                    out.push(layer);
+                else
+                    for (const container of contract.containers)
+                        out.push(`${container}.${layer}`);
+            }
+        }
+    }
+    return out;
+}
+export function domainFilesOf(logicFiles, roots, declaredModules) {
+    return logicFiles.filter((file) => {
+        if (isDomainDir(file))
+            return true;
+        if (declaredModules.length === 0)
+            return false;
+        const dotted = roots.map((root) => moduleName(root, file)).find((n) => n !== undefined);
+        return dotted !== undefined && declaredModules.some((m) => dotted === m || dotted.startsWith(`${m}.`));
+    });
+}
+function inInfrastructure(file, directories) {
+    if (isDomainDir(file))
+        return false;
+    return path.posix.dirname(file).split('/').some((segment) => directories.includes(segment));
+}
+/**
+ * Impure: an import statement (lazy and type-only included) of a forbidden package by its first dotted name, an edge to
+ * an in-scope file under an infrastructure directory (unless that file is itself under `domain`), or a builtin `open` call.
+ */
+export function isImpure(info, importedFiles, lists) {
+    const forbidden = new Set(lists.forbiddenImports.python);
+    if (info?.imports.some((s) => s.level === 0 && s.modules.some((m) => forbidden.has(m.split('.')[0]))))
+        return true;
+    if (importedFiles.some((file) => inInfrastructure(file, lists.infrastructureDirectories)))
+        return true;
+    return info?.opensBuiltin === true;
+}

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

@@ -0,0 +1,214 @@
+import { existsSync } from 'node:fs';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readPythonImports } from '../../../python/imports.js';
+import { trackedPaths } from '../../../scope/tracked.js';
+import { createWorkCopy } from '../../../tools/workcopy.js';
+import { failureReason } from '../../../tools/outcome.js';
+import { edgeKey } from '../types.js';
+import { presetContracts } from './contracts.js';
+import { declaredDomainModules, domainFilesOf, isImpure } from './domain.js';
+import { classifyPython } from './layers.js';
+import { pyInterpreter } from './interpreter.js';
+import { rootPackageDir } from './roots.js';
+const TOOL = 'import-linter';
+const helperPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..', 'python', 'graph_helper.py');
+async function runHelper(ctx, unit, contracts, tool, interpreter) {
+    const tracked = trackedPaths(ctx.repoPath);
+    const dirs = unit.roots.map((r) => `${rootPackageDir(r)}/`);
+    const files = tracked.filter((p) => p.endsWith('.py') && dirs.some((d) => p.startsWith(d)) && existsSync(path.join(ctx.repoPath, p)));
+    if (unit.declared !== undefined && existsSync(path.join(ctx.repoPath, unit.declared.file)))
+        files.push(unit.declared.file);
+    const scratch = await mkdtemp(path.join(tmpdir(), 'health-d3py-'));
+    let copy;
+    try {
+        copy = await createWorkCopy(ctx.repoPath, [...new Set(files)]);
+        const input = {
+            workDir: copy.dir,
+            roots: unit.roots,
+            declared: unit.declared === undefined ? null : path.join(copy.dir, unit.declared.file),
+            contracts,
+        };
+        const inFile = path.join(scratch, 'in.json');
+        const outFile = path.join(scratch, 'out.json');
+        await writeFile(inFile, JSON.stringify(input));
+        const runTool = { ...tool, command: interpreter, prefixArgs: ['-I', helperPath] };
+        const result = await ctx.tools.run(runTool, ['--in', inFile, '--out', outFile], { cwd: copy.dir });
+        const failure = failureReason(tool, result, [0]);
+        if (failure !== null)
+            return { unavailable: `${TOOL} failed: ${failure}` };
+        let output;
+        try {
+            output = JSON.parse(await readFile(outFile, 'utf8'));
+        }
+        catch {
+            return { unavailable: `${TOOL} failed: unreadable output` };
+        }
+        if (output.error !== undefined)
+            return { unavailable: `${TOOL} failed: ${output.error}` };
+        return { output };
+    }
+    catch (err) {
+        return { unavailable: `${TOOL} failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    finally {
+        await copy?.cleanup();
+        await rm(scratch, { recursive: true, force: true });
+    }
+}
+function statementsByLine(info) {
+    const out = new Map();
+    for (const statement of info?.imports ?? []) {
+        const list = out.get(statement.line) ?? [];
+        list.push(statement);
+        out.set(statement.line, list);
+    }
+    return out;
+}
+/** Runtime: at least one occurrence line maps to a statement that is neither lazy nor type-only; a line with no statement counts. */
+export function isRuntime(info, lines) {
+    if (lines.length === 0)
+        return true;
+    const byLine = statementsByLine(info);
+    return lines.some((line) => {
+        const statements = byLine.get(line);
+        return statements === undefined || statements.some((s) => !s.lazy && !s.typeOnly);
+    });
+}
+export function allTypeOnly(info, lines) {
+    if (lines.length === 0)
+        return false;
+    const byLine = statementsByLine(info);
+    return lines.every((line) => {
+        const statements = byLine.get(line);
+        return statements !== undefined && statements.length > 0 && statements.every((s) => s.typeOnly);
+    });
+}
+export function externalTypeOnly(info, name) {
+    const matching = (info?.imports ?? []).filter((s) => s.level === 0 && s.modules.some((m) => m === name || m.startsWith(`${name}.`)));
+    return matching.length > 0 && matching.every((s) => s.typeOnly);
+}
+export async function buildPyGraph(ctx, units) {
+    const tool = await ctx.tools.resolve(TOOL);
+    if (tool === undefined)
+        return { unavailable: ctx.tools.notFoundReason(TOOL) };
+    const found = pyInterpreter(tool);
+    if ('unavailable' in found)
+        return found;
+    ctx.tools.recordVersion(TOOL, tool.version);
+    const imports = await readPythonImports(ctx);
+    const tracked = new Set(trackedPaths(ctx.repoPath));
+    const warnings = [];
+    const result = [];
+    const scoped = new Map();
+    for (const file of ctx.scope.files)
+        if (file.group === 'python')
+            scoped.set(file.path, file);
+    for (const unit of units) {
+        const unitPaths = unit.files.map((f) => f.path);
+        const unitFiles = new Set(unitPaths);
+        const logicFiles = unit.logic.map((f) => f.path).sort();
+        for (const file of unitPaths) {
+            if (imports[file]?.syntaxError)
+                warnings.push(`${file}: syntax error, its imports are not counted`);
+        }
+        // Barrels (`__init__.py` that only re-export) are not scoped files but are the canonical public entries, as for
+        // TypeScript: module and entry classification covers every tracked Python file below the root packages.
+        const rootDirs = unit.roots.map((r) => `${rootPackageDir(r)}/`);
+        const graphPaths = [...new Set([...unitPaths, ...[...tracked].filter((p) => p.endsWith('.py') && rootDirs.some((d) => p.startsWith(d)))])].sort();
+        const graphFiles = new Set(graphPaths);
+        const classification = classifyPython(unit.preset, graphPaths, unit.package, unit.roots, tracked);
+        const layerFiles = new Map();
+        for (const [file, layers] of classification.layers) {
+            for (const layer of layers) {
+                const set = layerFiles.get(layer) ?? new Set();
+                set.add(file);
+                layerFiles.set(layer, set);
+            }
+        }
+        const preset = unit.declared === undefined
+            ? presetContracts(unit.package, unit.preset.rules, layerFiles, unitPaths, unit.roots)
+            : { contracts: [], meta: new Map() };
+        let output = {};
+        if (unit.roots.length > 0) {
+            const run = await runHelper(ctx, unit, preset.contracts, tool, found.interpreter);
+            if ('unavailable' in run)
+                return run;
+            output = run.output;
+            if (output.versions?.grimp !== undefined)
+                ctx.tools.recordVersion('grimp', output.versions.grimp);
+            if (output.versions?.['import-linter'] !== undefined)
+                ctx.tools.recordVersion(TOOL, output.versions['import-linter']);
+            for (const skipped of output.skipped ?? [])
+                warnings.push(`${unit.package}: ${TOOL} contract ${skipped.contract} skipped (${skipped.reason})`);
+        }
+        const edgeLines = new Map();
+        const edges = [];
+        for (const edge of output.edges ?? []) {
+            if (!unitFiles.has(edge.from) || !unitFiles.has(edge.to) || edge.from === edge.to)
+                continue;
+            edgeLines.set(edgeKey(edge.from, edge.to), edge.lines);
+            edges.push({ from: edge.from, to: edge.to, fromTest: scoped.get(edge.from)?.role === 'test', runtime: isRuntime(imports[edge.from], edge.lines) });
+        }
+        edges.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+        const violating = new Set();
+        const violationRules = {};
+        for (const violation of output.violations ?? []) {
+            if (!unitFiles.has(violation.importer) || scoped.get(violation.importer)?.role === 'test')
+                continue;
+            if (!violation.external && (!unitFiles.has(violation.imported) || violation.imported === violation.importer))
+                continue;
+            const info = preset.meta.get(violation.contract);
+            if (info !== undefined && !violation.external) {
+                const from = classification.layerModule.get(violation.importer);
+                if (from !== undefined && from === classification.layerModule.get(violation.imported))
+                    continue;
+            }
+            if (info?.excludesTypeOnly) {
+                const typeOnly = violation.external
+                    ? externalTypeOnly(imports[violation.importer], violation.imported)
+                    : allTypeOnly(imports[violation.importer], edgeLines.get(edgeKey(violation.importer, violation.imported)) ?? []);
+                if (typeOnly)
+                    continue;
+            }
+            const key = edgeKey(violation.importer, violation.imported);
+            violating.add(key);
+            const names = (violationRules[key] ??= []);
+            const label = info?.rule ?? violation.contract;
+            if (!names.includes(label))
+                names.push(label);
+        }
+        for (const names of Object.values(violationRules))
+            names.sort();
+        const moduleDirsOfUnit = new Set(logicFiles.map((f) => classification.moduleOf.get(f)).filter((m) => m !== undefined));
+        const crossings = [];
+        if (moduleDirsOfUnit.size >= 2) {
+            for (const edge of output.edges ?? []) {
+                if (!unitFiles.has(edge.from) || scoped.get(edge.from)?.role === 'test' || !graphFiles.has(edge.to) || edge.from === edge.to)
+                    continue;
+                const fromModule = classification.moduleOf.get(edge.from);
+                const toModule = classification.moduleOf.get(edge.to);
+                if (fromModule === undefined || toModule === undefined || fromModule === toModule)
+                    continue;
+                crossings.push({ from: edge.from, to: edge.to, toEntry: classification.entries.has(edge.to) });
+            }
+            crossings.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+        }
+        const declaredModules = unit.declared === undefined ? [] : declaredDomainModules(unit.declared.contracts);
+        const domainFiles = domainFilesOf(logicFiles, unit.roots, declaredModules);
+        const impure = domainFiles.filter((file) => isImpure(imports[file], edges.filter((e) => e.from === file).map((e) => e.to), ctx.methodology.d3));
+        result.push({
+            ...unit.rules,
+            logicFiles,
+            edges,
+            violating: [...violating].sort(),
+            violationRules,
+            moduleCount: moduleDirsOfUnit.size,
+            crossings,
+            domain: { files: domainFiles, impure },
+        });
+    }
+    return { units: result, warnings };
+}

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

@@ -0,0 +1,31 @@
+import { closeSync, openSync, readSync } from 'node:fs';
+/**
+ * The Python interpreter that holds import-linter and grimp: the `#!<absolute path>` first line of the
+ * resolved `lint-imports` script (a pipx or uv tool environment keeps them out of the system python3).
+ * Any other first line, or an unreadable file, is unavailable; nothing falls back to the system python3.
+ * A tool resolved in the image names its interpreter itself.
+ */
+export function pyInterpreter(tool) {
+    if (tool.interpreter !== undefined)
+        return { interpreter: tool.interpreter };
+    const fail = () => ({ unavailable: `import-linter: cannot read its Python interpreter from ${tool.command}` });
+    let line;
+    try {
+        const fd = openSync(tool.command, 'r');
+        try {
+            const buffer = Buffer.alloc(512);
+            const read = readSync(fd, buffer, 0, buffer.length, 0);
+            line = buffer.toString('utf8', 0, read).split(/\r?\n/, 1)[0] ?? '';
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        return fail();
+    }
+    const match = /^#!(\/\S+)$/.exec(line.trim());
+    if (!match?.[1] || /(^|\/)env$/.test(match[1]))
+        return fail();
+    return { interpreter: match[1] };
+}