vibecodedshit 0.0.0-stage → 0.2.0

package/dist/measure/p2-2.js

@@ -0,0 +1,44 @@
+import path from 'node:path';
+import { pythonLevel } from './py/typecheck-config.js';
+import { levelOf, lowestLevel, unitConfigs } from './ts/tsconfig.js';
+import { emptyTallies, logicFiles } from './units.js';
+const TS_SOURCE = /\.(?:ts|tsx|mts|cts)$/i;
+export const p22 = {
+    id: '2.2',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const warnings = [];
+        const cache = new Map();
+        const warned = new Set();
+        const units = [];
+        const tsFiles = logicFiles(scope, 'typescript_javascript');
+        for (const tally of emptyTallies(tsFiles).values()) {
+            const unitFiles = tsFiles.filter((f) => f.package === tally.package).map((f) => f.path);
+            const { configs, read } = unitConfigs(repoPath, tally.package, unitFiles, cache);
+            for (const config of read) {
+                for (const missing of config.missingExtends) {
+                    const message = `2.2: ${path.posix.relative(repoPath.split(path.sep).join('/'), config.file)} extends ${missing}, which could not be resolved; level computed without it`;
+                    if (!warned.has(message)) {
+                        warned.add(message);
+                        warnings.push(message);
+                    }
+                }
+            }
+            const hasTypeScript = unitFiles.some((f) => TS_SOURCE.test(f));
+            const levels = configs.map((c) => (!hasTypeScript && c.options.checkJs !== true ? 'none' : levelOf(c.options)));
+            const level = levels.length === 0 ? 'none' : lowestLevel(levels);
+            units.push({ package: tally.package, group: tally.group, weight: tally.weight, raw: { kind: 'level', level } });
+        }
+        const pyFiles = logicFiles(scope, 'python');
+        for (const tally of emptyTallies(pyFiles).values()) {
+            units.push({
+                package: tally.package,
+                group: tally.group,
+                weight: tally.weight,
+                raw: { kind: 'level', level: pythonLevel(repoPath, tally.package, warnings) },
+            });
+        }
+        units.sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group));
+        return { status: 'measured', units, warnings: [...new Set(warnings)] };
+    },
+};

package/dist/measure/p2-3.js

@@ -0,0 +1,81 @@
+import ts from 'typescript';
+import { analyzePythonTyping } from '../python/typing.js';
+import { countSuppressionComments, hasLeadingDirective } from './ts/directives.js';
+import { emptyTallies, logicFiles, unitId } from './units.js';
+const FILE_LEVEL_OPT_OUT = 10;
+function isConstType(type) {
+    return ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) && type.typeName.text === 'const';
+}
+/** Escape-hatch points of one TypeScript or JavaScript file (methodology 2.3). */
+function countTsEscapeHatches(sourceFile) {
+    let points = 0;
+    const visit = (node) => {
+        switch (node.kind) {
+            case ts.SyntaxKind.AnyKeyword:
+            case ts.SyntaxKind.NonNullExpression:
+                points += 1;
+                break;
+            case ts.SyntaxKind.AsExpression:
+            case ts.SyntaxKind.TypeAssertionExpression:
+                if (!isConstType(node.type))
+                    points += 1;
+                break;
+            case ts.SyntaxKind.PropertyDeclaration:
+            case ts.SyntaxKind.VariableDeclaration:
+                if (node.exclamationToken)
+                    points += 1;
+                break;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    points += countSuppressionComments(sourceFile);
+    if (hasLeadingDirective(sourceFile, 'ts-nocheck'))
+        points += FILE_LEVEL_OPT_OUT;
+    return points;
+}
+export const p23 = {
+    id: '2.3',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const tsFiles = logicFiles(scope, 'typescript_javascript');
+        const pyFiles = logicFiles(scope, 'python');
+        const tallies = emptyTallies([...tsFiles, ...pyFiles]);
+        for (const file of tsFiles) {
+            const tally = tallies.get(unitId(file));
+            if (!tally)
+                continue;
+            tally.numerator += countTsEscapeHatches(scope.getTsSourceFile(file.path));
+            tally.denominator += file.logicLines;
+        }
+        const warnings = [];
+        const info = analyzePythonTyping(repoPath, pyFiles.map((f) => f.path));
+        let unparsed = 0;
+        for (const file of pyFiles) {
+            const tally = tallies.get(unitId(file));
+            const facts = info[file.path];
+            if (!tally)
+                continue;
+            if (!facts?.ok) {
+                unparsed += 1;
+                continue;
+            }
+            const p = facts.points;
+            tally.numerator +=
+                p.anyCount + p.castCount + p.typeIgnoreLine + p.pyrightIgnore +
+                    FILE_LEVEL_OPT_OUT * (p.typeIgnoreHeader + (p.mypyIgnoreErrors ? 1 : 0));
+            tally.denominator += file.logicLines;
+        }
+        if (unparsed > 0)
+            warnings.push(`2.3/2.4: ${unparsed} Python files could not be parsed`);
+        const units = [...tallies.values()]
+            .sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group))
+            .map((t) => ({
+            package: t.package,
+            group: t.group,
+            weight: t.weight,
+            raw: { kind: 'ratio', numerator: t.numerator, denominator: t.denominator, scale: 1000 },
+        }));
+        return { status: 'measured', units, warnings };
+    },
+};

package/dist/measure/p2-4.js

@@ -0,0 +1,288 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { analyzePythonTyping } from '../python/typing.js';
+import { hasLeadingDirective } from './ts/directives.js';
+import { unitConfigs } from './ts/tsconfig.js';
+import { emptyTallies, logicFiles, unitId } from './units.js';
+function hasModifier(node, kind) {
+    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((m) => m.kind === kind) ?? false);
+}
+/** A function or arrow function behind parentheses, `satisfies T` and `as T`. */
+function functionOperand(expression) {
+    let contextual = false;
+    let current = expression;
+    for (;;) {
+        if (ts.isParenthesizedExpression(current))
+            current = current.expression;
+        else if (ts.isSatisfiesExpression(current)) {
+            contextual = true;
+            current = current.expression;
+        }
+        else if (ts.isAsExpression(current)) {
+            if (!(ts.isTypeReferenceNode(current.type) && current.type.getText() === 'const'))
+                contextual = true;
+            current = current.expression;
+        }
+        else
+            break;
+    }
+    return ts.isArrowFunction(current) || ts.isFunctionExpression(current) ? { node: current, contextual } : undefined;
+}
+/** Overload signatures with an implementation count as the implementation; without one, every signature counts. */
+function groupOverloads(nodes, keyOf) {
+    const byKey = new Map();
+    for (const node of nodes) {
+        const key = keyOf(node);
+        byKey.set(key, [...(byKey.get(key) ?? []), node]);
+    }
+    return [...byKey.values()].flatMap((group) => {
+        const impls = group.filter((n) => n.body !== undefined);
+        return impls.length > 0 ? impls : group;
+    });
+}
+function classSurface(node) {
+    const candidates = [];
+    const setters = [];
+    for (const member of node.members) {
+        if (ts.isMethodDeclaration(member) || ts.isConstructorDeclaration(member))
+            candidates.push(member);
+        else if (ts.isSetAccessorDeclaration(member))
+            setters.push(member);
+        else
+            continue;
+    }
+    const isPublic = (member) => !hasModifier(member, ts.SyntaxKind.PrivateKeyword) &&
+        !hasModifier(member, ts.SyntaxKind.ProtectedKeyword) &&
+        !(member.name !== undefined && ts.isPrivateIdentifier(member.name));
+    const methods = groupOverloads(candidates.filter(isPublic), (m) => `${hasModifier(m, ts.SyntaxKind.StaticKeyword) ? 'static ' : ''}${ts.isConstructorDeclaration(m) ? 'constructor' : m.name.getText()}`);
+    return [...methods, ...setters.filter(isPublic)].map((fn) => ({ node: fn, contextual: false }));
+}
+function isLocalFunctionValue(expression) {
+    return expression ? functionOperand(expression) : undefined;
+}
+/** Functions and function-valued variables declared at the top level of a file, by name. */
+function localFunctions(sourceFile) {
+    const byName = new Map();
+    const declarations = [];
+    for (const statement of sourceFile.statements) {
+        if (ts.isFunctionDeclaration(statement) && statement.name)
+            declarations.push(statement);
+        else if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (!ts.isIdentifier(declaration.name))
+                    continue;
+                const surface = isLocalFunctionValue(declaration.initializer);
+                if (surface)
+                    byName.set(declaration.name.text, [{ ...surface, contextual: surface.contextual || declaration.type !== undefined }]);
+            }
+        }
+    }
+    for (const fn of groupOverloads(declarations, (d) => d.name?.text ?? '')) {
+        const name = fn.name?.text ?? '';
+        byName.set(name, [...(byName.get(name) ?? []), { node: fn, contextual: false }]);
+    }
+    return byName;
+}
+function publicSurface(sourceFile) {
+    const surface = new Map();
+    const add = (items) => {
+        for (const item of items)
+            surface.set(item.node, item);
+    };
+    const locals = localFunctions(sourceFile);
+    const exportedDeclarations = [];
+    for (const statement of sourceFile.statements) {
+        const exported = hasModifier(statement, ts.SyntaxKind.ExportKeyword);
+        if (ts.isFunctionDeclaration(statement) && exported)
+            exportedDeclarations.push(statement);
+        else if (ts.isClassDeclaration(statement) && exported)
+            add(classSurface(statement));
+        else if (ts.isVariableStatement(statement) && exported) {
+            for (const declaration of statement.declarationList.declarations) {
+                const fn = isLocalFunctionValue(declaration.initializer);
+                if (fn)
+                    add([{ ...fn, contextual: fn.contextual || declaration.type !== undefined }]);
+            }
+        }
+        else if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
+            const fn = functionOperand(statement.expression);
+            if (fn)
+                add([fn]);
+            else if (ts.isIdentifier(statement.expression))
+                add(locals.get(statement.expression.text) ?? []);
+        }
+        else if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+            for (const specifier of statement.exportClause.elements)
+                add(locals.get((specifier.propertyName ?? specifier.name).text) ?? []);
+        }
+        else if (ts.isExpressionStatement(statement)) {
+            add(commonJsSurface(statement.expression, locals));
+        }
+    }
+    add(groupOverloads(exportedDeclarations, (d) => d.name?.text ?? 'default').map((node) => ({ node, contextual: false })));
+    return [...surface.values()];
+}
+function commonJsSurface(expression, locals) {
+    if (!ts.isBinaryExpression(expression) || expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+        return [];
+    const left = expression.left;
+    const right = expression.right;
+    const isModuleExports = (e) => ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.expression) && e.expression.text === 'module' && e.name.text === 'exports';
+    if (isModuleExports(left)) {
+        const fn = functionOperand(right);
+        if (fn)
+            return [fn];
+        if (ts.isClassExpression(right))
+            return classSurface(right);
+        if (ts.isObjectLiteralExpression(right)) {
+            const out = [];
+            for (const property of right.properties) {
+                if (ts.isMethodDeclaration(property))
+                    out.push({ node: property, contextual: false });
+                else if (ts.isPropertyAssignment(property)) {
+                    const value = functionOperand(property.initializer);
+                    if (value)
+                        out.push(value);
+                }
+                else if (ts.isShorthandPropertyAssignment(property))
+                    out.push(...(locals.get(property.name.text) ?? []));
+            }
+            return out;
+        }
+        return [];
+    }
+    if (ts.isPropertyAccessExpression(left) &&
+        ((ts.isIdentifier(left.expression) && left.expression.text === 'exports') || isModuleExports(left.expression))) {
+        const fn = functionOperand(right);
+        return fn ? [fn] : [];
+    }
+    return [];
+}
+function countTsSlots(sourceFile, checkedAsJs) {
+    const slots = { typed: 0, total: 0 };
+    for (const { node, contextual } of publicSurface(sourceFile)) {
+        for (const parameter of node.parameters) {
+            if (ts.isIdentifier(parameter.name) && parameter.name.text === 'this')
+                continue;
+            slots.total += 1;
+            const jsdoc = checkedAsJs && ts.getJSDocParameterTags(parameter).some((tag) => tag.typeExpression !== undefined);
+            if (parameter.type !== undefined || parameter.initializer !== undefined || contextual || jsdoc)
+                slots.typed += 1;
+        }
+    }
+    return slots;
+}
+// ---- Python -------------------------------------------------------------------------------
+/** Dotted import path parts of a module, with a leading `src` directory ignored. */
+function moduleParts(file) {
+    const relative = file.package === '.' ? file.path : file.path.slice(file.package.length + 1);
+    const parts = relative.split('/');
+    if (parts[0] === 'src' && parts.length > 1)
+        parts.shift();
+    const base = path.posix.basename(relative);
+    const stem = base.replace(/\.[^.]+$/, '');
+    parts.pop();
+    if (stem !== '__init__')
+        parts.push(stem);
+    return parts;
+}
+const isPublicName = (name) => !name.startsWith('_');
+const isPublicMethod = (name) => !name.startsWith('_') || (name.startsWith('__') && name.endsWith('__') && name.length > 4);
+const isOverload = (fn) => fn.decorators.some((d) => d === 'overload' || d.endsWith('.overload'));
+/** Overload stubs are skipped when a non-overload definition of the same name exists in the same scope. */
+function withoutOverloads(functions) {
+    const implemented = new Set(functions.filter((f) => !isOverload(f)).map((f) => f.name));
+    return functions.filter((f) => !(isOverload(f) && implemented.has(f.name)));
+}
+function countFunctionSlots(fn, isMethod, slots) {
+    let params = fn.params;
+    const isStatic = fn.decorators.includes('staticmethod');
+    const first = params[0];
+    if (isMethod && (!isStatic || fn.name === '__new__') && first?.kind === 'positional')
+        params = params.slice(1);
+    for (const param of params) {
+        slots.total += 1;
+        if (param.typed)
+            slots.typed += 1;
+    }
+    if (fn.name !== '__init__') {
+        slots.total += 1;
+        if (fn.returns)
+            slots.typed += 1;
+    }
+}
+function countPythonSlots(defs, allNames) {
+    const slots = { typed: 0, total: 0 };
+    const listed = allNames === null ? null : new Set(allNames);
+    const isPublicModuleName = (name) => (listed === null ? isPublicName(name) : listed.has(name));
+    const functions = withoutOverloads(defs.filter((d) => d.kind === 'function').map((d) => d.info));
+    for (const fn of functions)
+        if (isPublicModuleName(fn.name))
+            countFunctionSlots(fn, false, slots);
+    for (const def of defs) {
+        if (def.kind !== 'class' || !isPublicModuleName(def.name))
+            continue;
+        for (const method of withoutOverloads(def.methods))
+            if (isPublicMethod(method.name))
+                countFunctionSlots(method, true, slots);
+    }
+    return slots;
+}
+// ---- Measurer -------------------------------------------------------------------------------
+export const p24 = {
+    id: '2.4',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const tsFiles = logicFiles(scope, 'typescript_javascript');
+        const pyFiles = logicFiles(scope, 'python');
+        const tallies = emptyTallies([...tsFiles, ...pyFiles]);
+        const cache = new Map();
+        const unitConfigsByPackage = new Map();
+        const configsFor = (pkg) => {
+            const existing = unitConfigsByPackage.get(pkg);
+            if (existing)
+                return existing;
+            const made = unitConfigs(repoPath, pkg, tsFiles.filter((f) => f.package === pkg).map((f) => f.path), cache);
+            unitConfigsByPackage.set(pkg, made);
+            return made;
+        };
+        for (const file of tsFiles) {
+            const tally = tallies.get(unitId(file));
+            if (!tally)
+                continue;
+            const sourceFile = scope.getTsSourceFile(file.path);
+            let checkedAsJs = false;
+            if (file.language === 'javascript') {
+                const absolute = path.resolve(repoPath, file.path).split(path.sep).join('/');
+                const byConfig = configsFor(file.package).configs.some((c) => c.options.checkJs === true && c.fileNames.has(absolute));
+                const byComment = hasLeadingDirective(sourceFile, 'ts-check') && !hasLeadingDirective(sourceFile, 'ts-nocheck');
+                checkedAsJs = byConfig || byComment;
+            }
+            const slots = countTsSlots(sourceFile, checkedAsJs);
+            tally.numerator += slots.typed;
+            tally.denominator += slots.total;
+        }
+        // Files that cannot be parsed are reported once, by 2.3.
+        const info = analyzePythonTyping(repoPath, pyFiles.map((f) => f.path));
+        for (const file of pyFiles) {
+            const tally = tallies.get(unitId(file));
+            const facts = info[file.path];
+            if (!tally || !facts?.ok)
+                continue;
+            if (moduleParts(file).some((part) => part.startsWith('_')))
+                continue;
+            const slots = countPythonSlots(facts.defs, facts.allNames);
+            tally.numerator += slots.typed;
+            tally.denominator += slots.total;
+        }
+        const units = [...tallies.values()]
+            .sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group))
+            .map((t) => ({
+            package: t.package,
+            group: t.group,
+            weight: t.weight,
+            raw: { kind: 'ratio', numerator: t.numerator, denominator: t.denominator, scale: 100 },
+        }));
+        return { status: 'measured', units };
+    },
+};

package/dist/measure/p2-5.js

@@ -0,0 +1,8 @@
+import { measureFindings } from '../exec/findings.js';
+export const p25 = {
+    id: '2.5',
+    layer: 'execution',
+    async measure(ctx) {
+        return measureFindings(ctx, (exec) => exec.lint);
+    },
+};

package/dist/measure/p3-1.js

@@ -0,0 +1,16 @@
+import { d3Gap, getD3Rules } from './d3/index.js';
+export const p31 = {
+    id: '3.1',
+    layer: 'static',
+    async measure(ctx) {
+        const gap = d3Gap(ctx);
+        if (gap !== undefined)
+            return { status: 'not_measured', reason: gap };
+        const { units, warnings } = await getD3Rules(ctx);
+        return {
+            status: 'measured',
+            units: units.map((unit) => ({ package: unit.package, group: unit.group, weight: unit.weight, raw: { kind: 'level', level: unit.level31 } })),
+            ...(warnings.length === 0 ? {} : { warnings: warnings.map((w) => `3.1: ${w}`) }),
+        };
+    },
+};

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