vibecodedshit 0.0.0-stage → 0.2.0

package/dist/measure/deps/units.js

@@ -0,0 +1,5 @@
+import { emptyTallies, logicFiles } from '../units.js';
+/** Scope units: every (package, language group) with logic files, weight = its logic lines. */
+export function scopeUnits(ctx) {
+    return [...emptyTallies([...logicFiles(ctx.scope, 'typescript_javascript'), ...logicFiles(ctx.scope, 'python')]).values()].sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group));
+}

package/dist/measure/eslint/health-plugin.js

@@ -0,0 +1,19 @@
+/**
+ * Reports once for every function node (declarations, expressions, arrows, methods).
+ * `sonarjs/cognitive-complexity` registers on the same `:function` selector, so this is the
+ * denominator for 4.1: all functions as enumerated by the tool.
+ */
+const functionRule = {
+    meta: { type: 'problem', schema: [], messages: { fn: 'function' } },
+    create(context) {
+        return {
+            ':function'(node) {
+                context.report({ node, messageId: 'fn' });
+            },
+        };
+    },
+};
+export const healthPlugin = {
+    meta: { name: 'health' },
+    rules: { function: functionRule },
+};

package/dist/measure/ops/docs-commands.js

@@ -0,0 +1,73 @@
+import { splitSimple, tokenize } from '../../scripts/expand.js';
+const ALIASES = { bunx: ['npx'], uvx: ['uv', 'run'], pip3: ['pip'], python3: ['python'] };
+const SKIPPED = new Set(['sudo']);
+/** First word of a simple command after `VAR=value` words and `sudo`; aliases (`bunx`, `uvx`, `pip3`, `python3`) map to their base word. */
+function leadWord(tokens) {
+    let rest = tokens;
+    while (rest[0] !== undefined && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(rest[0]) || SKIPPED.has(rest[0])))
+        rest = rest.slice(1);
+    const first = rest[0];
+    if (first === undefined)
+        return undefined;
+    const alias = ALIASES[first];
+    if (alias)
+        rest = [...alias, ...rest.slice(1)];
+    return { word: rest[0], rest };
+}
+/** Candidates from fenced blocks (every line) and inline code spans (one per span), before splitting into simple commands. */
+function candidates(text) {
+    const out = [];
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    let fence;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? '';
+        const marker = /^\s*(```+|~~~+)/.exec(line)?.[1];
+        if (marker !== undefined) {
+            fence = fence === undefined ? marker[0] : fence === marker[0] ? undefined : fence;
+            continue;
+        }
+        if (fence === undefined) {
+            for (const span of line.matchAll(/`+([^`\n]+)`+/g))
+                out.push({ line: i + 1, text: (span[1] ?? '').trim(), inline: true });
+            continue;
+        }
+        let candidate = line.trim();
+        const start = i + 1;
+        while (candidate.endsWith('\\') && i + 1 < lines.length) {
+            i += 1;
+            candidate = `${candidate.slice(0, -1).trimEnd()} ${(lines[i] ?? '').trim()}`;
+        }
+        candidate = candidate.replace(/^[$>]\s+/, '');
+        if (candidate === '' || candidate.startsWith('#'))
+            continue;
+        out.push({ line: start, text: candidate, inline: false });
+    }
+    return out;
+}
+/**
+ * The documented commands of a file. A command is a simple command whose first word is a package manager or recognised tool.
+ * An inline span is a candidate only when it has a space (`npm` alone is not a command; `package.json` and `src/index.ts` are not).
+ */
+export function extractCommands(text, words) {
+    const out = [];
+    for (const candidate of candidates(text)) {
+        if (candidate.inline && !/\s/.test(candidate.text))
+            continue;
+        let cd = '.';
+        for (const simple of splitSimple(candidate.text)) {
+            const tokens = tokenize(simple.text);
+            const lead = leadWord(tokens);
+            if (!lead)
+                continue;
+            if (lead.word === 'cd' && lead.rest[1] !== undefined && !/[$`*?]/.test(lead.rest[1])) {
+                if (simple.sep === '&&')
+                    cd = cd === '.' ? lead.rest[1].replace(/^\.\//, '') : `${cd}/${lead.rest[1]}`;
+                continue;
+            }
+            if (!words.commandWords.has(lead.word))
+                continue;
+            out.push({ line: candidate.line, text: simple.text.trim(), cd, tokens: [lead.word, ...lead.rest.slice(1)] });
+        }
+    }
+    return out;
+}

package/dist/measure/ops/docs-resolve.js

@@ -0,0 +1,217 @@
+import path from 'node:path';
+import { readPackageJson } from '../../manifest/package-json.js';
+import { pythonDeclaredDeps } from '../../manifest/python.js';
+import { trackedPaths } from '../../scope/tracked.js';
+import { findFile } from '../../scripts/entry-points/find.js';
+import { justfileEntryPoints } from '../../scripts/entry-points/justfile.js';
+import { makefileEntryPoints } from '../../scripts/entry-points/makefile.js';
+import { noxEntryPoints } from '../../scripts/entry-points/nox.js';
+import { packageJsonEntryPoints } from '../../scripts/entry-points/package-json.js';
+import { pyprojectEntryPoints } from '../../scripts/entry-points/pyproject.js';
+import { toxEntryPoints } from '../../scripts/entry-points/tox.js';
+import { dirsUpward } from './entry-points.js';
+const NODE_BUILTINS = new Set([
+    'install', 'i', 'ci', 'add', 'remove', 'update', 'up', 'link', 'init', 'dlx', 'audit', 'outdated', 'publish', 'pack', 'version', 'config',
+    'cache', 'rebuild', 'prune', 'dedupe', 'why', 'ls', 'list', 'x',
+]);
+const UV_BUILTINS = new Set(['sync', 'lock', 'add', 'remove', 'venv', 'pip', 'python', 'tool', 'init', 'build', 'publish']);
+const POETRY_BUILTINS = new Set(['install', 'add', 'remove', 'lock', 'shell', 'build', 'publish', 'init', 'update', 'show', 'env', 'config']);
+const PDM_BUILTINS = new Set(['install', 'add', 'remove', 'lock', 'sync', 'build', 'publish', 'init']);
+const PYTHON_STDLIB = new Set(['venv', 'pip', 'http.server', 'json.tool', 'unittest', 'pytest', 'ensurepip', 'build', 'compileall', 'timeit', 'zipapp', 'http', 'site', 'sysconfig']);
+const WORKSPACE_FLAGS = new Set(['-w', '--workspace', '--workspaces', '--filter', '-F', '-r', '--recursive', '--cwd']);
+const VALUE_FLAGS = new Set(['--prefix', '-C', '--cwd', '--filter', '-F', '--workspace', '--directory']);
+const MAKEFILES = ['Makefile', 'makefile', 'GNUmakefile'];
+const join = (dir, next) => (next === undefined ? dir : path.posix.normalize(path.posix.join(dir, next)));
+export class DocResolver {
+    repoPath;
+    tracked;
+    manifests;
+    toolNames;
+    constructor(repoPath, lists) {
+        this.repoPath = repoPath;
+        this.tracked = new Set(trackedPaths(repoPath));
+        this.toolNames = new Set([...lists.typecheckers, ...lists.linters, ...lists.testRunners].map((t) => (t === 'node --test' ? 'node' : t.replace(/^python3? -m /, ''))));
+    }
+    allManifests() {
+        this.manifests ??= [...this.tracked]
+            .filter((f) => path.posix.basename(f) === 'package.json')
+            .map((f) => {
+            const dir = path.posix.dirname(f);
+            const pkg = readPackageJson(this.repoPath, dir);
+            return { dir, deps: new Set(Object.keys(pkg?.dependencies ?? {})), scripts: new Set(Object.keys(pkg?.scripts ?? {})) };
+        });
+        return this.manifests;
+    }
+    hasScript(dir, name) {
+        return packageJsonEntryPoints.lookup(this.repoPath, dir, name) !== undefined;
+    }
+    declaredPython(dir, name) {
+        const wanted = name.toLowerCase().replace(/[-_.]+/g, '-');
+        return dirsUpward(dir).some((d) => pythonDeclaredDeps(this.repoPath, d).has(wanted));
+    }
+    firstPartyModule(dir, name) {
+        const top = name.split('.').join('/');
+        return [dir, 'src'].some((base) => [`${top}.py`, `${top}/__init__.py`, `${top}/__main__.py`].some((f) => this.tracked.has(path.posix.normalize(path.posix.join(base, f)))));
+    }
+    /** `npx <t>`, `uv run <t>`, `python -m <t>` and a bare recognised tool: resolves for a script, a recognised tool, a declared dependency, a stdlib or first-party module. */
+    toolRef(tool, dir, runner) {
+        if (tool === undefined)
+            return true;
+        if (runner === 'python -m' && (PYTHON_STDLIB.has(tool) || this.firstPartyModule(dir, tool)))
+            return true;
+        if ((runner === 'uv run' || runner === 'poetry run') && pyprojectEntryPoints.lookup(this.repoPath, dir, `scripts:${tool}`) !== undefined)
+            return true;
+        if (runner === 'pdm run' && pyprojectEntryPoints.lookup(this.repoPath, dir, `pdm:${tool}`) !== undefined)
+            return true;
+        if (this.toolNames.has(tool))
+            return true;
+        if (this.allManifests().some((m) => m.deps.has(tool)))
+            return true;
+        return this.declaredPython(dir, tool);
+    }
+    nodeCommand(runner, tokens, baseDir) {
+        let dir = baseDir;
+        let workspace = false;
+        const args = [];
+        for (let i = 1; i < tokens.length; i += 1) {
+            const token = tokens[i];
+            if (token === '--')
+                break;
+            if (WORKSPACE_FLAGS.has(token))
+                workspace = true;
+            if (token === '--prefix' || token === '-C' || token === '--cwd') {
+                dir = join(baseDir, tokens[i + 1]);
+                i += 1;
+            }
+            else if (VALUE_FLAGS.has(token))
+                i += 1;
+            else if (token.startsWith('--prefix='))
+                dir = join(baseDir, token.slice(9));
+            else if (!token.startsWith('-'))
+                args.push(token);
+        }
+        const sub = args[0];
+        if (sub === undefined || NODE_BUILTINS.has(sub))
+            return true;
+        if (sub === 'exec' || (runner === 'bun' && sub === 'x'))
+            return this.toolRef(args[1], dir, runner === 'pnpm' ? 'pnpm exec' : runner);
+        let name;
+        let toolFallback = false;
+        if (sub === 'workspace')
+            name = args[2];
+        else if (sub === 'run' || sub === 'run-script')
+            name = args[1];
+        else if (['test', 'start', 'stop', 'restart'].includes(sub))
+            name = sub;
+        else if (runner === 'yarn' || runner === 'pnpm') {
+            name = sub;
+            toolFallback = true;
+        }
+        else
+            return true;
+        if (name === undefined)
+            return true;
+        if (workspace || sub === 'workspace' ? this.allManifests().some((m) => m.scripts.has(name)) : this.hasScript(dir, name))
+            return true;
+        if (name === 'start' && runner === 'npm' && this.tracked.has(path.posix.join(dir, 'server.js')))
+            return true;
+        return toolFallback && this.toolRef(name, dir, runner);
+    }
+    makeCommand(tokens, baseDir) {
+        let dir = baseDir;
+        const targets = [];
+        for (let i = 1; i < tokens.length; i += 1) {
+            const token = tokens[i];
+            if (token === '-C' || token === '--directory') {
+                dir = join(baseDir, tokens[i + 1]);
+                i += 1;
+            }
+            else if (token === '-f' || token === '--file')
+                i += 1;
+            else if (!token.startsWith('-') && !token.includes('='))
+                targets.push(token);
+        }
+        const names = new Set(makefileEntryPoints.list(this.repoPath, dir).map((e) => e.name));
+        const exists = MAKEFILES.some((m) => this.tracked.has(path.posix.join(dir, m)));
+        return targets.length === 0 ? exists : targets.every((t) => names.has(t));
+    }
+    justCommand(tokens, baseDir) {
+        let dir = baseDir;
+        const recipes = [];
+        for (let i = 1; i < tokens.length; i += 1) {
+            const token = tokens[i];
+            if (token === '-d' || token === '--working-directory') {
+                dir = join(baseDir, tokens[i + 1]);
+                i += 1;
+            }
+            else if (token === '-f' || token === '--justfile')
+                i += 1;
+            else if (!token.startsWith('-') && !token.includes('='))
+                recipes.push(token);
+        }
+        if (recipes.length === 0)
+            return findFile(this.repoPath, dir, ['justfile', 'Justfile', '.justfile'], true) !== undefined;
+        return recipes.every((r) => justfileEntryPoints.lookup(this.repoPath, dir, r) !== undefined);
+    }
+    /** Whether one documented command resolves. `dir` is the document's directory with the command's `cd` already applied. */
+    resolves(command, docDir) {
+        const dir = join(docDir, command.cd === '.' ? undefined : command.cd);
+        const tokens = command.tokens;
+        const first = tokens[0];
+        switch (first) {
+            case 'npm':
+            case 'pnpm':
+            case 'yarn':
+            case 'bun':
+                return this.nodeCommand(first, tokens, dir);
+            case 'npx': {
+                const tool = tokens.slice(1).find((t) => !t.startsWith('-'));
+                return this.toolRef(tool, dir, 'npx');
+            }
+            case 'make':
+                return this.makeCommand(tokens, dir);
+            case 'just':
+                return this.justCommand(tokens, dir);
+            case 'pip':
+            case 'pipenv':
+                return true;
+            case 'uv':
+            case 'poetry':
+            case 'pdm': {
+                const builtins = first === 'uv' ? UV_BUILTINS : first === 'poetry' ? POETRY_BUILTINS : PDM_BUILTINS;
+                const sub = tokens[1];
+                if (sub === undefined || builtins.has(sub))
+                    return true;
+                if (sub !== 'run')
+                    return first === 'uv';
+                const tool = tokens.slice(2).find((t) => !t.startsWith('-'));
+                if (tool === 'python' || tool === 'python3')
+                    return this.pythonCommand(tokens.slice(tokens.indexOf(tool)), dir);
+                return this.toolRef(tool, dir, `${first} run`);
+            }
+            case 'python':
+                return this.pythonCommand(tokens, dir);
+            case 'tox': {
+                const envs = tokens.flatMap((t, i) => (tokens[i - 1] === '-e' ? t.split(',') : []));
+                return envs.length === 0 ? toxEntryPoints.fileFor?.(this.repoPath, dir) !== undefined : envs.every((e) => toxEntryPoints.lookup(this.repoPath, dir, e) !== undefined);
+            }
+            case 'nox': {
+                const sessions = tokens.flatMap((t, i) => (['-s', '--session', '-e', '--sessions'].includes(tokens[i - 1] ?? '') ? t.split(',') : []));
+                return sessions.length === 0 ? noxEntryPoints.fileFor?.(this.repoPath, dir) !== undefined : sessions.every((s) => noxEntryPoints.lookup(this.repoPath, dir, s) !== undefined);
+            }
+            default:
+                return this.toolRef(first, dir, 'bare');
+        }
+    }
+    pythonCommand(tokens, dir) {
+        const arg = tokens[1];
+        if (arg === undefined || arg === '-c' || arg === '-' || arg === '-m') {
+            if (arg === '-m')
+                return this.toolRef(tokens[2], dir, 'python -m');
+            return true;
+        }
+        if (arg.startsWith('-'))
+            return true;
+        return this.tracked.has(path.posix.normalize(path.posix.join(dir, arg)));
+    }
+}

package/dist/measure/ops/entry-points.js

@@ -0,0 +1,49 @@
+import path from 'node:path';
+import { checkKinds, UNRECOGNISED_RUNNERS } from '../../scripts/checks.js';
+import { entryPointKinds } from '../../scripts/entry-points/index.js';
+import { expandCommand } from '../../scripts/expand.js';
+/** The directory itself and each ancestor up to the repository root ("."). */
+export function dirsUpward(dir) {
+    const out = [];
+    for (let current = path.posix.normalize(dir === '' ? '.' : dir);; current = path.posix.dirname(current)) {
+        out.push(current);
+        if (current === '.' || current === '' || current.startsWith('..'))
+            return out;
+    }
+}
+/** Entry points defined in exactly `dir`, expanded up to 3 levels, with the checks each one runs. Memoized per scan. */
+export class EntryPointChecks {
+    repoPath;
+    rec;
+    cache = new Map();
+    constructor(repoPath, rec) {
+        this.repoPath = repoPath;
+        this.rec = rec;
+    }
+    inDir(dir) {
+        const cached = this.cache.get(dir);
+        if (cached)
+            return cached;
+        const results = [];
+        for (const kind of entryPointKinds) {
+            for (const entry of kind.list(this.repoPath, dir)) {
+                const commands = expandCommand(this.repoPath, entry.invoke, { dir, file: dir }, { maxDepth: 3 });
+                const kinds = new Set();
+                const unrecognised = new Set();
+                for (const command of commands) {
+                    for (const found of checkKinds(command, this.rec))
+                        kinds.add(found);
+                    if (command.tool !== null && UNRECOGNISED_RUNNERS.has(command.tool))
+                        unrecognised.add(command.tool);
+                }
+                results.push({ name: `${path.posix.join(dir, kind.id)}:${entry.name}`, kinds, unrecognised: [...unrecognised] });
+            }
+        }
+        this.cache.set(dir, results);
+        return results;
+    }
+    /** Candidate entry points for a unit: those of its package directory and of every ancestor (a root `verify` covers every package). */
+    forUnit(dir) {
+        return dirsUpward(dir).flatMap((d) => this.inDir(d));
+    }
+}

package/dist/measure/ops/env-example.js

@@ -0,0 +1,20 @@
+/** `KEY=value`, `export KEY=value`, blank lines, `#` comment lines and quoted values. A commented-out `# KEY=` line does not count. */
+export function parseEnvExample(text) {
+    const out = {};
+    for (const raw of text.replace(/\r\n?/g, '\n').split('\n')) {
+        const line = raw.trim();
+        if (line === '' || line.startsWith('#'))
+            continue;
+        const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_.]*)\s*=\s*(.*)$/.exec(line);
+        if (!match?.[1])
+            continue;
+        let value = (match[2] ?? '').trim();
+        const quote = value[0];
+        if ((quote === '"' || quote === "'") && value.lastIndexOf(quote) > 0)
+            value = value.slice(1, value.lastIndexOf(quote));
+        else
+            value = value.replace(/\s+#.*$/, '');
+        out[match[1]] = value;
+    }
+    return out;
+}

package/dist/measure/ops/env-reads.js

@@ -0,0 +1,46 @@
+import ts from 'typescript';
+const isName = (node, text) => ts.isIdentifier(node) && node.text === text;
+/** `process.env` */
+function isProcessEnv(node) {
+    return ts.isPropertyAccessExpression(node) && isName(node.expression, 'process') && node.name.text === 'env';
+}
+/** `import.meta.env` */
+function isImportMetaEnv(node) {
+    return (ts.isPropertyAccessExpression(node) &&
+        node.name.text === 'env' &&
+        ts.isMetaProperty(node.expression) &&
+        node.expression.keywordToken === ts.SyntaxKind.ImportKeyword &&
+        node.expression.name.text === 'meta');
+}
+/**
+ * Names read through `process.env.X`, `process.env["X"]`, destructuring from `process.env` (a rest element or computed key is skipped),
+ * `import.meta.env.X` and `import.meta.env["X"]`. An alias (`const env = process.env`) and a non-literal key are not counted.
+ */
+export function tsEnvReads(sf) {
+    const names = new Set();
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) && (isProcessEnv(node.expression) || isImportMetaEnv(node.expression)))
+            names.add(node.name.text);
+        else if (ts.isElementAccessExpression(node) && (isProcessEnv(node.expression) || isImportMetaEnv(node.expression)) && ts.isStringLiteralLike(node.argumentExpression)) {
+            names.add(node.argumentExpression.text);
+        }
+        else if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer && isProcessEnv(node.initializer)) {
+            for (const element of node.name.elements) {
+                if (element.dotDotDotToken)
+                    continue;
+                const key = element.propertyName ?? element.name;
+                if (ts.isIdentifier(key))
+                    names.add(key.text);
+                else if (ts.isStringLiteralLike(key))
+                    names.add(key.text);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return names;
+}
+/** True when a name is excluded from 6.5: one of the YAML names, or starting with one of the YAML prefixes. */
+export function isExcludedEnvName(name, lists) {
+    return lists.envExcludedNames.includes(name) || lists.envExcludedPrefixes.some((prefix) => name.startsWith(prefix));
+}

package/dist/measure/ops/runtime.js

@@ -0,0 +1,73 @@
+import path from 'node:path';
+import { readPackageJson } from '../../manifest/package-json.js';
+import { readTracked } from '../../scope/tracked.js';
+import { parseTomlText } from '../../util/toml.js';
+import { dirsUpward } from './entry-points.js';
+const isObj = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const nonEmpty = (value) => (typeof value === 'string' && value.trim() !== '') || (Array.isArray(value) && value.some(nonEmpty));
+const fileHasContent = (name, group) => ({
+    group,
+    check: (repoPath, dir) => (readTracked(repoPath, path.posix.join(dir, name))?.trim() ?? '') !== '',
+});
+function toml(repoPath, file, warnings) {
+    const text = readTracked(repoPath, file);
+    if (text === null)
+        return undefined;
+    const doc = parseTomlText(text);
+    if (!doc)
+        warnings.push(`6.5: ${file} is not valid TOML, so it does not pin a runtime`);
+    return doc;
+}
+const toolVersions = (tools, group) => ({
+    group,
+    check: (repoPath, dir) => (readTracked(repoPath, path.posix.join(dir, '.tool-versions')) ?? '')
+        .split('\n')
+        .some((line) => {
+        const [tool, version] = line.trim().split(/\s+/);
+        return tool !== undefined && tools.includes(tool) && version !== undefined && !version.startsWith('#');
+    }),
+});
+const mise = (tools, group) => ({
+    group,
+    check(repoPath, dir, warnings) {
+        const doc = toml(repoPath, path.posix.join(dir, 'mise.toml'), warnings);
+        const table = doc && isObj(doc.tools) ? doc.tools : {};
+        return tools.some((tool) => nonEmpty(table[tool]));
+    },
+});
+/** The pin files of the 6.5 `runtime_pinned` measure, by the words the YAML uses; a word the YAML adds that is not here pins nothing. */
+const PROBES = {
+    '.nvmrc': [fileHasContent('.nvmrc', 'typescript_javascript')],
+    '.node-version': [fileHasContent('.node-version', 'typescript_javascript')],
+    '.tool-versions': [toolVersions(['node', 'nodejs'], 'typescript_javascript'), toolVersions(['python'], 'python')],
+    'mise.toml': [mise(['node', 'nodejs'], 'typescript_javascript'), mise(['python'], 'python')],
+    'engines.node in package.json': [
+        { group: 'typescript_javascript', check: (repoPath, dir) => nonEmpty(readPackageJson(repoPath, dir)?.engines.node) },
+    ],
+    'volta in package.json': [
+        { group: 'typescript_javascript', check: (repoPath, dir) => nonEmpty(readPackageJson(repoPath, dir)?.volta?.node) },
+    ],
+    '.python-version': [fileHasContent('.python-version', 'python')],
+    'requires-python in pyproject.toml': [
+        {
+            group: 'python',
+            check(repoPath, dir, warnings) {
+                const doc = toml(repoPath, path.posix.join(dir, 'pyproject.toml'), warnings);
+                return doc !== undefined && isObj(doc.project) && nonEmpty(doc.project['requires-python']);
+            },
+        },
+    ],
+    'runtime.txt': [fileHasContent('runtime.txt', 'python')],
+};
+/** Looked up at the unit's package directory, then each ancestor up to the repository root. Poetry's `python = "^3.12"` dependency does not count. */
+export function runtimePinned(repoPath, dir, group, pinFiles, warnings) {
+    for (const d of dirsUpward(dir)) {
+        for (const word of pinFiles) {
+            for (const probe of PROBES[word] ?? []) {
+                if (probe.group === group && probe.check(repoPath, d, warnings))
+                    return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/measure/p1-1.js

@@ -0,0 +1,8 @@
+import { measurePassRate } from '../exec/tests.js';
+export const p11 = {
+    id: '1.1',
+    layer: 'execution',
+    async measure(ctx) {
+        return measurePassRate(ctx);
+    },
+};

package/dist/measure/p1-2.js

@@ -0,0 +1,8 @@
+import { measureCoverage } from '../exec/tests.js';
+export const p12 = {
+    id: '1.2',
+    layer: 'execution',
+    async measure(ctx) {
+        return measureCoverage(ctx, 'lines');
+    },
+};

package/dist/measure/p1-3.js

@@ -0,0 +1,8 @@
+import { measureCoverage } from '../exec/tests.js';
+export const p13 = {
+    id: '1.3',
+    layer: 'execution',
+    async measure(ctx) {
+        return measureCoverage(ctx, 'branches');
+    },
+};

package/dist/measure/p1-4.js

@@ -0,0 +1,41 @@
+import { PyImportGraph } from './safety/py-tests.js';
+import { TsCredits } from './safety/ts-credits.js';
+import { createTsResolver } from './safety/ts-resolve.js';
+import { logicUnits } from './units.js';
+export const p14 = {
+    id: '1.4',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const units = logicUnits(scope);
+        const warnings = [];
+        const credited = new Set();
+        const tsTests = scope.files.filter((f) => f.role === 'test' && f.group === 'typescript_javascript');
+        if (tsTests.length > 0 && units.some((u) => u.group === 'typescript_javascript')) {
+            const credits = new TsCredits(repoPath, scope, createTsResolver(repoPath));
+            for (const test of tsTests)
+                for (const file of credits.credits(test.path))
+                    credited.add(file);
+        }
+        const pyFiles = scope.files.filter((f) => f.group === 'python');
+        const pyTests = pyFiles.filter((f) => f.role === 'test');
+        if (pyTests.length > 0 && units.some((u) => u.group === 'python')) {
+            const graph = new PyImportGraph(repoPath, pyFiles);
+            for (const test of pyTests) {
+                if (graph.factsOf(test.path)?.ok === false)
+                    warnings.push(`1.4: ${test.path}: syntax error, its imports are not counted`);
+                for (const file of graph.credits(test.path))
+                    credited.add(file);
+            }
+        }
+        return {
+            status: 'measured',
+            units: units.map((unit) => ({
+                package: unit.package,
+                group: unit.group,
+                weight: unit.weight,
+                raw: { kind: 'ratio', numerator: unit.files.filter((f) => credited.has(f.path)).length, denominator: unit.files.length, scale: 100 },
+            })),
+            ...(warnings.length === 0 ? {} : { warnings }),
+        };
+    },
+};

package/dist/measure/p1-5.js

@@ -0,0 +1,59 @@
+import { pythonTestFacts } from '../python/tests.js';
+import { testCases } from './safety/ts-cases.js';
+import { TsCredits } from './safety/ts-credits.js';
+import { createTsResolver } from './safety/ts-resolve.js';
+import { logicUnits, unitId } from './units.js';
+export const p15 = {
+    id: '1.5',
+    layer: 'static',
+    async measure({ scope, repoPath }) {
+        const units = logicUnits(scope);
+        const tallies = new Map(units.map((u) => [unitId(u), { numerator: 0, denominator: 0 }]));
+        const warnings = [];
+        const tsTests = scope.files.filter((f) => f.role === 'test' && f.group === 'typescript_javascript' && tallies.has(unitId(f)));
+        if (tsTests.length > 0) {
+            const credits = new TsCredits(repoPath, scope, createTsResolver(repoPath));
+            for (const test of tsTests) {
+                const sf = credits.source(test.path);
+                const tally = tallies.get(unitId(test));
+                if (!sf || !tally)
+                    continue;
+                for (const found of testCases(sf)) {
+                    tally.denominator += 1;
+                    if (found.asserts)
+                        tally.numerator += 1;
+                }
+            }
+        }
+        const pyFiles = scope.files.filter((f) => f.group === 'python');
+        const pyTests = pyFiles.filter((f) => f.role === 'test' && tallies.has(unitId(f)));
+        if (pyTests.length > 0) {
+            const facts = pythonTestFacts(repoPath);
+            for (const test of pyTests) {
+                const info = facts[test.path];
+                const tally = tallies.get(unitId(test));
+                if (!tally)
+                    continue;
+                if (!info?.ok) {
+                    warnings.push(`1.5: ${test.path}: syntax error, its test cases are not counted`);
+                    continue;
+                }
+                for (const found of info.cases) {
+                    tally.denominator += 1;
+                    if (found.asserts)
+                        tally.numerator += 1;
+                }
+            }
+        }
+        return {
+            status: 'measured',
+            units: units.map((unit) => ({
+                package: unit.package,
+                group: unit.group,
+                weight: unit.weight,
+                raw: { kind: 'ratio', ...tallies.get(unitId(unit)), scale: 100 },
+            })),
+            ...(warnings.length === 0 ? {} : { warnings }),
+        };
+    },
+};

package/dist/measure/p2-1.js

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