vibecodedshit 0.0.0-stage → 0.2.0

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

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

@@ -0,0 +1,120 @@
+import path from 'node:path';
+import { globLayers, moduleDirs, publicEntryGlob } from '../presets.js';
+import { rootOf, rootPackageDir } from './roots.js';
+const stem = (file) => path.posix.basename(file, '.py');
+function empty() {
+    return { layers: new Map(), moduleOf: new Map(), entries: new Set(), layerModule: new Map() };
+}
+function entryNames(preset) {
+    const entry = preset.modules.public_entry;
+    const list = Array.isArray(entry) ? entry : [];
+    return { file: list.includes('__init__.py'), names: list.filter((e) => e !== '__init__.py') };
+}
+function django(preset, files, unitDir, tracked) {
+    const out = empty();
+    const prefix = unitDir === '.' ? '' : `${unitDir}/`;
+    const apps = [...tracked]
+        .filter((p) => p.startsWith(prefix) && path.posix.basename(p) === 'apps.py')
+        .map((p) => path.posix.dirname(p))
+        .sort((a, b) => b.length - a.length);
+    const entries = entryNames(preset);
+    for (const file of files) {
+        const app = apps.find((a) => (a === '.' ? true : file.startsWith(`${a}/`)));
+        if (app === undefined)
+            continue;
+        const rel = app === '.' ? file : file.slice(app.length + 1);
+        const parts = rel.split('/');
+        const key = parts.length > 1 ? parts[0] : stem(rel);
+        out.moduleOf.set(file, app);
+        if (key === '__init__') {
+            if (entries.file && parts.length === 1)
+                out.entries.add(file);
+            continue;
+        }
+        const inLayers = Object.entries(preset.layers)
+            .filter((entry) => Array.isArray(entry[1]) && entry[1].includes(key))
+            .map(([name]) => name);
+        if (inLayers.length > 0)
+            out.layers.set(file, inLayers);
+        out.layerModule.set(file, `${app}/${key}`);
+        if (entries.names.includes(key))
+            out.entries.add(file);
+    }
+    return out;
+}
+function fastapi(preset, files, roots) {
+    const out = empty();
+    const layerOf = new Map();
+    for (const [name, list] of Object.entries(preset.layers))
+        if (Array.isArray(list))
+            for (const segment of list)
+                layerOf.set(segment, name);
+    const inFiles = new Set(files);
+    const moduleRoots = new Set();
+    for (const file of files) {
+        const root = rootOf(roots, file);
+        if (root === undefined)
+            continue;
+        const base = rootPackageDir(root);
+        const segments = path.posix.dirname(file) === base ? [] : path.posix.dirname(file).slice(base.length + 1).split('/');
+        if (stem(file) !== '__init__')
+            segments.push(stem(file));
+        for (let i = segments.length - 1; i >= 0; i -= 1) {
+            const layer = layerOf.get(segments[i]);
+            if (layer !== undefined) {
+                out.layers.set(file, [layer]);
+                break;
+            }
+        }
+        // Modules are directories below the root package: those holding router.py and the direct children of features/modules.
+        const dir = path.posix.dirname(file);
+        if (dir !== base && path.posix.basename(file) === 'router.py')
+            moduleRoots.add(dir);
+        for (let d = dir; d.length > base.length; d = path.posix.dirname(d)) {
+            const parent = path.posix.dirname(d);
+            if (parent.length >= base.length && ['features', 'modules'].includes(path.posix.basename(parent)))
+                moduleRoots.add(d);
+        }
+    }
+    const sorted = [...moduleRoots].sort((a, b) => b.length - a.length);
+    const entries = entryNames(preset);
+    for (const file of files) {
+        const dir = sorted.find((m) => file.startsWith(`${m}/`));
+        if (dir === undefined)
+            continue;
+        out.moduleOf.set(file, dir);
+        if (entries.file && path.posix.dirname(file) === dir && path.posix.basename(file) === '__init__.py' && inFiles.has(file))
+            out.entries.add(file);
+    }
+    return out;
+}
+function generic(preset, files, unitDir, roots) {
+    const out = empty();
+    const prefix = unitDir === '.' ? '' : `${unitDir}/`;
+    const rels = files.map((f) => f.slice(prefix.length));
+    const prefixes = ['', ...roots.map((r) => `${path.posix.relative(unitDir, rootPackageDir(r))}/`)];
+    const full = new Map(rels.map((rel, i) => [rel, files[i]]));
+    for (const [rel, layer] of globLayers(preset.layers, rels, prefixes))
+        out.layers.set(full.get(rel), [layer]);
+    const globs = Array.isArray(preset.modules.roots) ? preset.modules.roots : [];
+    const dirs = moduleDirs(globs, rels, prefixes);
+    const entryGlob = publicEntryGlob(preset, 'python');
+    for (const rel of rels) {
+        const dir = dirs.get(rel);
+        if (dir === undefined)
+            continue;
+        const file = full.get(rel);
+        out.moduleOf.set(file, `${prefix}${dir}`);
+        if (entryGlob !== undefined && path.posix.dirname(rel) === dir && path.posix.basename(rel) === entryGlob)
+            out.entries.add(file);
+    }
+    return out;
+}
+/** Layers, modules and public entries of a unit's in-scope Python files under the preset. `files` are repo-relative. */
+export function classifyPython(preset, files, unitDir, roots, tracked) {
+    if (preset.preset === 'django')
+        return django(preset, files, unitDir, tracked);
+    if (preset.preset === 'fastapi')
+        return fastapi(preset, files, roots);
+    return generic(preset, files, unitDir, roots);
+}

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

@@ -0,0 +1,58 @@
+import path from 'node:path';
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Repo-relative directory of the root package. */
+export const rootPackageDir = (root) => (root.dir === '.' ? root.name : `${root.dir}/${root.name}`);
+/**
+ * First-party root packages of a unit. Source roots: `<unit>/src` (when it holds in-scope Python files and has no
+ * `__init__.py`) and the unit directory. Root packages are the identifier-named child directories of a source root
+ * that hold an in-scope Python file at any depth, with or without `__init__.py`. When a name occurs under both
+ * source roots the `src` one wins.
+ */
+export function pythonRoots(unitDir, files, tracked, warnings) {
+    const at = (rel) => (unitDir === '.' ? rel : `${unitDir}/${rel}`);
+    const srcDir = at('src');
+    const srcHasFiles = files.some((f) => f.startsWith(`${srcDir}/`));
+    const srcIsRoot = srcHasFiles && !tracked.has(`${srcDir}/__init__.py`);
+    const sourceRoots = srcIsRoot ? [srcDir, unitDir] : [unitDir];
+    const found = new Map();
+    for (const sourceRoot of sourceRoots) {
+        const prefix = sourceRoot === '.' ? '' : `${sourceRoot}/`;
+        const children = new Set();
+        for (const file of files) {
+            if (!file.startsWith(prefix))
+                continue;
+            const parts = file.slice(prefix.length).split('/');
+            if (parts.length >= 2)
+                children.add(parts[0]);
+        }
+        for (const name of [...children].sort()) {
+            if (!IDENTIFIER.test(name))
+                continue;
+            if (sourceRoot === unitDir && srcIsRoot && name === 'src')
+                continue;
+            const existing = found.get(name);
+            if (existing !== undefined) {
+                warnings.push(`${path.posix.join(existing.dir, name)} and ${path.posix.join(sourceRoot, name)} share the package name ${name}, the src one is used`);
+                continue;
+            }
+            found.set(name, { dir: sourceRoot, name });
+        }
+    }
+    return [...found.values()];
+}
+/** Dotted module name of a file below a root, or undefined when it is not in the root or a segment is not an identifier. */
+export function moduleName(root, file) {
+    const prefix = root.dir === '.' ? '' : `${root.dir}/`;
+    if (!file.startsWith(`${prefix}${root.name}/`) || !file.endsWith('.py'))
+        return undefined;
+    const parts = file.slice(prefix.length, -3).split('/');
+    if (parts[parts.length - 1] === '__init__')
+        parts.pop();
+    return parts.every((p) => IDENTIFIER.test(p)) ? parts.join('.') : undefined;
+}
+export function rootOf(roots, file) {
+    return roots.find((root) => {
+        const dir = rootPackageDir(root);
+        return file.startsWith(`${dir}/`);
+    });
+}

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

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

package/dist/measure/d3/scc.js

@@ -0,0 +1,64 @@
+/** Strongly connected components of two or more nodes (Tarjan, iterative). Self loops are ignored. */
+export function cyclicNodes(nodes, edges) {
+    const adjacency = new Map();
+    for (const node of nodes)
+        adjacency.set(node, []);
+    for (const [from, to] of edges) {
+        if (from !== to && adjacency.has(from) && adjacency.has(to))
+            adjacency.get(from)?.push(to);
+    }
+    const index = new Map();
+    const low = new Map();
+    const onStack = new Set();
+    const stack = [];
+    const result = new Set();
+    let counter = 0;
+    for (const start of adjacency.keys()) {
+        if (index.has(start))
+            continue;
+        const work = [{ node: start, next: 0 }];
+        index.set(start, counter);
+        low.set(start, counter);
+        counter += 1;
+        stack.push(start);
+        onStack.add(start);
+        while (work.length > 0) {
+            const frame = work[work.length - 1];
+            const neighbours = adjacency.get(frame.node);
+            if (frame.next < neighbours.length) {
+                const to = neighbours[frame.next];
+                frame.next += 1;
+                if (!index.has(to)) {
+                    index.set(to, counter);
+                    low.set(to, counter);
+                    counter += 1;
+                    stack.push(to);
+                    onStack.add(to);
+                    work.push({ node: to, next: 0 });
+                }
+                else if (onStack.has(to)) {
+                    low.set(frame.node, Math.min(low.get(frame.node), index.get(to)));
+                }
+                continue;
+            }
+            work.pop();
+            const parent = work[work.length - 1];
+            if (parent)
+                low.set(parent.node, Math.min(low.get(parent.node), low.get(frame.node)));
+            if (low.get(frame.node) === index.get(frame.node)) {
+                const component = [];
+                for (;;) {
+                    const member = stack.pop();
+                    onStack.delete(member);
+                    component.push(member);
+                    if (member === frame.node)
+                        break;
+                }
+                if (component.length >= 2)
+                    for (const member of component)
+                        result.add(member);
+            }
+        }
+    }
+    return result;
+}