vibecodedshit 0.0.0-stage → 0.3.0

package/dist/measure/p3-2.js

@@ -0,0 +1,26 @@
+import { d3Gap, getD3Graph } from './d3/index.js';
+import { internalEdges } from './d3/types.js';
+import { unavailable } from '../tools/outcome.js';
+/** Violations per 1,000 internal import edges. */
+export const p32 = {
+    id: '3.2',
+    layer: 'static',
+    async measure(ctx) {
+        const gap = d3Gap(ctx);
+        if (gap !== undefined)
+            return { status: 'not_measured', reason: gap };
+        const graph = await getD3Graph(ctx);
+        if ('unavailable' in graph)
+            return unavailable(graph.unavailable);
+        return {
+            status: 'measured',
+            units: graph.units.map((unit) => ({
+                package: unit.package,
+                group: unit.group,
+                weight: unit.weight,
+                raw: { kind: 'ratio', numerator: unit.violating.length, denominator: internalEdges(unit).length, scale: 1000 },
+            })),
+            ...(graph.warnings.length === 0 ? {} : { warnings: graph.warnings.map((w) => `3.2: ${w}`) }),
+        };
+    },
+};

package/dist/measure/p3-3.js

@@ -0,0 +1,37 @@
+import { d3Gap, getD3Graph } from './d3/index.js';
+import { cyclicNodes } from './d3/scc.js';
+import { unavailable } from '../tools/outcome.js';
+/** Logic files in a strongly connected component of two or more files of the runtime import graph, per language group. */
+export const p33 = {
+    id: '3.3',
+    layer: 'static',
+    async measure(ctx) {
+        const gap = d3Gap(ctx);
+        if (gap !== undefined)
+            return { status: 'not_measured', reason: gap };
+        const graph = await getD3Graph(ctx);
+        if ('unavailable' in graph)
+            return unavailable(graph.unavailable);
+        const cyclic = new Map();
+        for (const group of new Set(graph.units.map((u) => u.group))) {
+            const members = graph.units.filter((u) => u.group === group);
+            const nodes = members.flatMap((u) => u.logicFiles);
+            const edges = members.flatMap((u) => u.edges.filter((e) => e.runtime && !e.fromTest).map((e) => [e.from, e.to]));
+            cyclic.set(group, cyclicNodes(nodes, edges));
+        }
+        return {
+            status: 'measured',
+            units: graph.units.map((unit) => ({
+                package: unit.package,
+                group: unit.group,
+                weight: unit.weight,
+                raw: {
+                    kind: 'ratio',
+                    numerator: unit.logicFiles.filter((f) => cyclic.get(unit.group)?.has(f)).length,
+                    denominator: unit.logicFiles.length,
+                    scale: 100,
+                },
+            })),
+        };
+    },
+};

package/dist/measure/p3-4.js

@@ -0,0 +1,26 @@
+import { d3Gap, getD3Graph } from './d3/index.js';
+import { unavailable } from '../tools/outcome.js';
+/** Cross-module imports that land on the module's public entry. Not applicable without two modules in a unit. */
+export const p34 = {
+    id: '3.4',
+    layer: 'static',
+    async measure(ctx) {
+        const gap = d3Gap(ctx);
+        if (gap !== undefined)
+            return { status: 'not_measured', reason: gap };
+        const graph = await getD3Graph(ctx);
+        if ('unavailable' in graph)
+            return unavailable(graph.unavailable);
+        const units = graph.units
+            .filter((unit) => unit.moduleCount >= 2)
+            .map((unit) => ({
+            package: unit.package,
+            group: unit.group,
+            weight: unit.weight,
+            raw: { kind: 'ratio', numerator: unit.crossings.filter((c) => c.toEntry).length, denominator: unit.crossings.length, scale: 100 },
+        }));
+        if (units.length === 0)
+            return { status: 'not_applicable', reason: ctx.param.not_applicable_when ?? 'fewer than two modules' };
+        return { status: 'measured', units };
+    },
+};

package/dist/measure/p3-5.js

@@ -0,0 +1,26 @@
+import { d3Gap, getD3Graph } from './d3/index.js';
+import { unavailable } from '../tools/outcome.js';
+/** Domain files that import infrastructure. Not applicable without a domain layer. */
+export const p35 = {
+    id: '3.5',
+    layer: 'static',
+    async measure(ctx) {
+        const gap = d3Gap(ctx);
+        if (gap !== undefined)
+            return { status: 'not_measured', reason: gap };
+        const graph = await getD3Graph(ctx);
+        if ('unavailable' in graph)
+            return unavailable(graph.unavailable);
+        const units = graph.units
+            .filter((unit) => unit.domain.files.length > 0)
+            .map((unit) => ({
+            package: unit.package,
+            group: unit.group,
+            weight: unit.weight,
+            raw: { kind: 'ratio', numerator: unit.domain.impure.length, denominator: unit.domain.files.length, scale: 100 },
+        }));
+        if (units.length === 0)
+            return { status: 'not_applicable', reason: ctx.param.not_applicable_when ?? 'no domain layer' };
+        return { status: 'measured', units };
+    },
+};

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