vibecodedshit 0.0.0-stage → 0.2.0

package/dist/scoring/pool.js

@@ -0,0 +1,65 @@
+import { scoreRaw } from './score.js';
+/**
+ * Combine the units of one parameter into one raw value and score.
+ * ratio: sum numerators and denominators, score once. Units with a failed raw (their install root's install
+ * failed) take no part in the sums; the score is multiplied by the share of the logic lines that is not failed,
+ * so a broken package costs its share and cannot be hidden.
+ * unit_weighted: score each unit, combine by weight. A failed unit scores 0.
+ */
+export function poolParameter(def, units) {
+    const scored = units.map((unit) => ({
+        ...unit,
+        score: scoreRaw(def, unit.raw, unit.group),
+    }));
+    if (def.pooling === 'ratio') {
+        const live = units.filter((unit) => unit.raw.kind !== 'failed');
+        const pooled = poolRatio(def, live, scored);
+        if (live.length === units.length)
+            return pooled;
+        return { ...pooled, score: pooled.score * liveShare(live, units) };
+    }
+    const totalWeight = scored.reduce((sum, unit) => sum + unit.weight, 0);
+    if (totalWeight === 0)
+        return { raw: null, score: def.raw.when_empty, units: scored };
+    const score = scored.reduce((sum, unit) => sum + unit.score * unit.weight, 0) / totalWeight;
+    return { raw: null, score, units: scored };
+}
+/** Share of the logic lines (of the units, when none has a line) that belongs to `live`. */
+function liveShare(live, all) {
+    const total = all.reduce((sum, unit) => sum + unit.weight, 0);
+    if (total === 0)
+        return live.length / all.length;
+    return live.reduce((sum, unit) => sum + unit.weight, 0) / total;
+}
+function poolRatio(def, units, scored) {
+    let numerator = 0;
+    let denominator = 0;
+    let scale = null;
+    let summed = null;
+    for (const unit of units) {
+        // number raws (5.1 severity points) are summed, their denominator is ignored.
+        if (unit.raw.kind === 'number') {
+            summed = (summed ?? 0) + unit.raw.value;
+            continue;
+        }
+        if (unit.raw.kind !== 'ratio')
+            throw new Error(`${def.id}: ratio pooling needs ratio raws`);
+        if (scale !== null && scale !== unit.raw.scale) {
+            throw new Error(`${def.id}: units disagree on ratio scale`);
+        }
+        scale = unit.raw.scale;
+        numerator += unit.raw.numerator;
+        denominator += unit.raw.denominator;
+    }
+    if (summed !== null) {
+        if (scale !== null)
+            throw new Error(`${def.id}: ratio pooling cannot mix number and ratio raws`);
+        const raw = { kind: 'number', value: summed };
+        return { raw, score: scoreRaw(def, raw), units: scored };
+    }
+    if (scale === null || denominator === 0) {
+        return { raw: null, score: def.raw.when_empty, units: scored };
+    }
+    const raw = { kind: 'ratio', numerator, denominator, scale };
+    return { raw, score: scoreRaw(def, raw), units: scored };
+}

package/dist/scoring/score.js

@@ -0,0 +1,81 @@
+function clamp(value, lo, hi) {
+    return Math.min(hi, Math.max(lo, value));
+}
+/** The numeric value of a ratio or number raw. A ratio with no denominator has no value. */
+function rawValue(raw) {
+    if (raw.kind === 'number')
+        return raw.value;
+    if (raw.kind === 'ratio') {
+        return raw.denominator === 0 ? null : (raw.numerator / raw.denominator) * raw.scale;
+    }
+    throw new Error(`Raw of kind ${raw.kind} has no numeric value`);
+}
+function piecewiseLinear(anchors, value) {
+    const sorted = [...anchors].sort((a, b) => a.raw - b.raw);
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    if (!first || !last)
+        throw new Error('piecewise_linear needs anchors');
+    if (value <= first.raw)
+        return first.score;
+    if (value >= last.raw)
+        return last.score;
+    for (let i = 1; i < sorted.length; i += 1) {
+        const lo = sorted[i - 1];
+        const hi = sorted[i];
+        if (lo && hi && value <= hi.raw) {
+            return lo.score + ((value - lo.raw) / (hi.raw - lo.raw)) * (hi.score - lo.score);
+        }
+    }
+    return last.score;
+}
+function levelScore(levels, level) {
+    const found = levels.find((entry) => entry.level === level);
+    if (!found)
+        throw new Error(`Unknown level "${level}"`);
+    return found.score;
+}
+/** Score one raw value. A ratio with no denominator scores `raw.when_empty`. */
+export function scoreRaw(def, raw, group) {
+    if (raw.kind === 'failed')
+        return 0;
+    const scoring = def.scoring;
+    switch (scoring.method) {
+        case 'piecewise_linear': {
+            const value = rawValue(raw);
+            return value === null ? def.raw.when_empty : piecewiseLinear(scoring.anchors, value);
+        }
+        case 'levels': {
+            if (raw.kind !== 'level')
+                throw new Error(`${def.id}: levels scoring needs a level raw`);
+            if (Array.isArray(scoring.levels))
+                return levelScore(scoring.levels, raw.level);
+            if (!group)
+                throw new Error(`${def.id}: a language group is needed to score this level`);
+            const forGroup = scoring.levels[group];
+            if (!forGroup)
+                throw new Error(`${def.id}: no levels for group ${group}`);
+            return levelScore(forGroup, raw.level);
+        }
+        case 'mean_of_components': {
+            if (raw.kind !== 'components')
+                throw new Error(`${def.id}: needs a components raw`);
+            const scores = scoring.components.map((component) => {
+                const part = raw.components[component.key];
+                if (!part)
+                    throw new Error(`${def.id}: missing component ${component.key}`);
+                if (component.method === 'levels') {
+                    if (part.kind !== 'level' || !component.levels) {
+                        throw new Error(`${def.id}.${component.key}: needs a level raw`);
+                    }
+                    return levelScore(component.levels, part.level);
+                }
+                const value = rawValue(part);
+                if (value === null)
+                    return part.kind === 'ratio' ? (part.emptyScore ?? def.raw.when_empty) : def.raw.when_empty;
+                return clamp(value, 0, 100);
+            });
+            return scores.reduce((sum, s) => sum + s, 0) / scores.length;
+        }
+    }
+}

package/dist/scoring/what-if.js

@@ -0,0 +1,38 @@
+import { dimensionScore, healthScore } from './aggregate.js';
+function weighted(def, param, overrides) {
+    const override = overrides.get(def.id);
+    if (override !== undefined)
+        return { weight: def.weight, score: override };
+    if (param?.status === 'failed')
+        return { weight: def.weight, score: 0 };
+    if (param?.status === 'measured')
+        return { weight: def.weight, score: param.score ?? 0 };
+    return { weight: def.weight, score: null };
+}
+/** The unrounded health and dimension scores if the overridden parameters had the given scores. Reads the stored parameters only. */
+export function healthWith(run, methodology, overrides) {
+    const dimension = new Map();
+    for (const dim of methodology.dimensions) {
+        dimension.set(dim.id, dimensionScore(dim.parameters.map((def) => weighted(def, run.parameters.find((p) => p.id === def.id), overrides))));
+    }
+    return { health: healthScore([...dimension.values()], methodology.capMargin), dimension };
+}
+/** The lowest-scoring anchor or level above `score` that has a descriptor. Null when there is none or the parameter has no descriptors. */
+export function nextCandidate(def, score) {
+    const scoring = def.scoring;
+    let candidates;
+    if (scoring.method === 'piecewise_linear')
+        candidates = scoring.anchors;
+    else if (scoring.method === 'levels')
+        candidates = Array.isArray(scoring.levels) ? scoring.levels : Object.values(scoring.levels).flat();
+    else
+        return null;
+    let best;
+    for (const candidate of candidates) {
+        if (!candidate.descriptor || candidate.score <= score + 1e-9)
+            continue;
+        if (!best || candidate.score < best.score)
+            best = { score: candidate.score, descriptor: candidate.descriptor };
+    }
+    return best ? { score: best.score, descriptor: best.descriptor.replace(/\s+/g, ' ').trim() } : null;
+}

package/dist/scripts/checks.js

@@ -0,0 +1,53 @@
+const INFO_FLAGS = new Set(['--help', '--version', '-h', '-V']);
+const TSC_NON_CHECKS = new Set(['--init', '--help', '--version', '-v', '-h']);
+const BIOME_CHECKS = new Set(['check', 'lint', 'ci']);
+/** Tools that run checks the methodology does not recognise (a finding on 6.2). */
+export const UNRECOGNISED_RUNNERS = new Set(['turbo', 'nx', 'lerna', 'next', 'ng', 'react-scripts']);
+/** `python -m unittest` is the tool `unittest` once its prefix is removed; `node --test` is the tool `node` with that flag. */
+function testToolNames(rec) {
+    const tools = new Set();
+    let nodeTest = false;
+    for (const entry of rec.testRunners) {
+        if (entry === 'node --test')
+            nodeTest = true;
+        else
+            tools.add(entry.replace(/^python3? -m /, ''));
+    }
+    return { tools, nodeTest };
+}
+/**
+ * The checks a command runs, by tool, after prefix removal. A check is recognised by tool, not by language group, so `tsc` counts
+ * for a Python unit in a mixed package and `mypy` for a TypeScript one.
+ */
+export function checkKinds(cmd, rec) {
+    const out = new Set();
+    const tool = cmd.tool;
+    if (tool === null)
+        return out;
+    if (cmd.argv.some((a) => INFO_FLAGS.has(a)))
+        return out;
+    const first = cmd.argv.find((a) => !a.startsWith('-'));
+    if (rec.typecheckers.includes(tool)) {
+        if (tool === 'tsc' && cmd.argv.some((a) => TSC_NON_CHECKS.has(a)))
+            return out;
+        out.add('typecheck');
+        return out;
+    }
+    if (rec.linters.includes(tool)) {
+        if (tool === 'ruff' && first === 'format')
+            return out;
+        if (tool === 'biome' && !(first !== undefined && BIOME_CHECKS.has(first)))
+            return out;
+        out.add('lint');
+        return out;
+    }
+    const { tools, nodeTest } = testToolNames(rec);
+    if (tool === 'tox' || tool === 'nox') {
+        if (tools.has(tool) && cmd.readable !== true)
+            out.add('test');
+        return out;
+    }
+    if (tools.has(tool) || (nodeTest && tool === 'node' && cmd.argv.includes('--test')))
+        out.add('test');
+    return out;
+}

package/dist/scripts/ci.js

@@ -0,0 +1,139 @@
+import path from 'node:path';
+import { parse } from 'yaml';
+import { readTracked, trackedPaths } from '../scope/tracked.js';
+import { triggersFor } from './triggers.js';
+/** The five CI files of methodology 3.1 `ci_files`. */
+function ciFormatOf(file) {
+    if (/^\.github\/workflows\/[^/]+\.ya?ml$/.test(file))
+        return 'github';
+    if (file === '.gitlab-ci.yml')
+        return 'gitlab';
+    if (file === '.circleci/config.yml')
+        return 'circleci';
+    if (file === 'bitbucket-pipelines.yml')
+        return 'bitbucket';
+    if (file === 'azure-pipelines.yml')
+        return 'azure';
+    return undefined;
+}
+const isObj = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+function strings(value) {
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap(strings);
+    return [];
+}
+function workingDir(value) {
+    return typeof value === 'string' && value.trim() !== '' ? path.posix.normalize(value.trim().replace(/^\.\//, '')) : '.';
+}
+function withCd(command, dir) {
+    const match = /^\s*cd\s+([^\s&;|"'$`]+)\s*&&/.exec(command);
+    return match?.[1] ? path.posix.normalize(path.posix.join(dir, match[1])) : dir;
+}
+function collect(doc, file, format, repoPath, out) {
+    const triggers = new Map();
+    const push = (job, command, dir, triggerKey = job) => {
+        if (command.trim() === '')
+            return;
+        const key = triggerKey;
+        if (!triggers.has(key))
+            triggers.set(key, triggersFor(format, doc, key, repoPath));
+        out.push({ file, format, job, command, dir: withCd(command, dir), triggers: triggers.get(key) });
+    };
+    if (!isObj(doc))
+        return;
+    if (format === 'github' || format === 'circleci') {
+        const jobs = isObj(doc.jobs) ? doc.jobs : {};
+        for (const [name, job] of Object.entries(jobs)) {
+            if (!isObj(job))
+                continue;
+            const defaults = isObj(job.defaults) && isObj(job.defaults.run) ? workingDir(job.defaults.run['working-directory']) : '.';
+            const steps = Array.isArray(job.steps) ? job.steps : [];
+            for (const step of steps) {
+                if (format === 'github') {
+                    if (!isObj(step) || typeof step.run !== 'string')
+                        continue;
+                    push(name, step.run, step['working-directory'] === undefined ? defaults : workingDir(step['working-directory']));
+                }
+                else {
+                    const run = isObj(step) ? step.run : undefined;
+                    const command = typeof run === 'string' ? run : isObj(run) && typeof run.command === 'string' ? run.command : undefined;
+                    if (command !== undefined)
+                        push(name, command, '.');
+                }
+            }
+        }
+    }
+    else if (format === 'gitlab') {
+        for (const [name, value] of Object.entries(doc)) {
+            if (!isObj(value))
+                continue;
+            for (const key of ['before_script', 'script', 'after_script'])
+                for (const command of strings(value[key]))
+                    push(name, command, '.');
+        }
+    }
+    else if (format === 'bitbucket') {
+        const walk = (node, name, section) => {
+            if (Array.isArray(node))
+                node.forEach((child) => walk(child, name, section));
+            else if (isObj(node)) {
+                for (const [key, child] of Object.entries(node)) {
+                    if (key === 'script')
+                        for (const command of strings(child))
+                            push(name, command, '.', section);
+                    else
+                        walk(child, key === 'name' || typeof child !== 'object' ? name : key, section);
+                }
+            }
+        };
+        for (const [section, child] of Object.entries(isObj(doc.pipelines) ? doc.pipelines : {}))
+            walk(child, section, section);
+    }
+    else {
+        const walk = (node, name) => {
+            if (Array.isArray(node))
+                node.forEach((child) => walk(child, name));
+            else if (isObj(node)) {
+                for (const [key, child] of Object.entries(node)) {
+                    if (key === 'steps' && Array.isArray(child)) {
+                        for (const step of child) {
+                            if (!isObj(step))
+                                continue;
+                            for (const field of ['script', 'bash', 'pwsh', 'powershell']) {
+                                if (typeof step[field] === 'string')
+                                    push(name, step[field], workingDir(step.workingDirectory), '');
+                            }
+                        }
+                    }
+                    else
+                        walk(child, typeof node.job === 'string' ? node.job : name);
+                }
+            }
+        };
+        walk(doc, 'steps');
+    }
+}
+/** Every command of the repository's CI files. Invalid YAML is skipped with a warning. */
+export function ciCommands(repoPath, warnings = []) {
+    const out = [];
+    for (const file of trackedPaths(repoPath)) {
+        const format = ciFormatOf(file);
+        if (!format)
+            continue;
+        const text = readTracked(repoPath, file);
+        if (text === null)
+            continue;
+        let doc;
+        try {
+            doc = parse(text);
+        }
+        catch (err) {
+            warnings.push(`${file}: invalid YAML, skipped (${err instanceof Error ? err.message.split('\n')[0] : String(err)})`);
+            continue;
+        }
+        collect(doc, file, format, repoPath, out);
+    }
+    return out;
+}

package/dist/scripts/entry-points/find.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import { readTracked } from '../../scope/tracked.js';
+/** The first of `names` that is tracked in `dir`, or in the nearest ancestor when `ancestors` is set. */
+export function findFile(repoPath, dir, names, ancestors) {
+    for (let current = path.posix.normalize(dir === '' ? '.' : dir);; current = path.posix.dirname(current)) {
+        for (const name of names) {
+            const file = path.posix.join(current, name);
+            const text = readTracked(repoPath, file);
+            if (text !== null)
+                return { file, text };
+        }
+        if (!ancestors || current === '.' || current === '' || current.startsWith('..'))
+            return undefined;
+    }
+}
+/** Join backslash-continued lines. */
+export function joinContinuations(lines) {
+    const out = [];
+    let pending = '';
+    for (const line of lines) {
+        if (line.endsWith('\\')) {
+            pending += `${line.slice(0, -1).trimEnd()} `;
+            continue;
+        }
+        out.push((pending + line).trim());
+        pending = '';
+    }
+    if (pending.trim() !== '')
+        out.push(pending.trim());
+    return out;
+}

package/dist/scripts/entry-points/index.js

@@ -0,0 +1,18 @@
+import { justfileEntryPoints } from './justfile.js';
+import { makefileEntryPoints } from './makefile.js';
+import { noxEntryPoints } from './nox.js';
+import { packageJsonEntryPoints } from './package-json.js';
+import { pyprojectEntryPoints } from './pyproject.js';
+import { toxEntryPoints } from './tox.js';
+/** Explicit list. */
+export const entryPointKinds = [
+    packageJsonEntryPoints,
+    makefileEntryPoints,
+    justfileEntryPoints,
+    toxEntryPoints,
+    noxEntryPoints,
+    pyprojectEntryPoints,
+];
+export function entryPointKind(id) {
+    return entryPointKinds.find((kind) => kind.id === id);
+}

package/dist/scripts/entry-points/justfile.js

@@ -0,0 +1,62 @@
+import { findFile, joinContinuations } from './find.js';
+const JUSTFILES = ['justfile', 'Justfile', '.justfile'];
+/** Line based: `name [params...]: [dependencies]`, indented lines are the body. `alias`, `set`, `import`, `mod`, assignments and attributes are ignored. */
+function parseJustfile(text) {
+    const recipes = new Map();
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    let current;
+    let shebang = false;
+    for (const line of lines) {
+        if (/^[ \t]+\S/.test(line)) {
+            if (!current)
+                continue;
+            const trimmed = line.trim();
+            if (current.body.length === 0 && trimmed.startsWith('#!')) {
+                shebang = true;
+                current.body.push('');
+                continue;
+            }
+            if (shebang)
+                current.body[0] = `${current.body[0] ?? ''}\n${trimmed}`.replace(/^\n/, '');
+            else
+                current.body.push(trimmed.replace(/^[@-]+\s*/, ''));
+            continue;
+        }
+        if (line.trim() === '')
+            continue;
+        current = undefined;
+        shebang = false;
+        if (/^\s*#/.test(line) || /^\s*\[/.test(line) || /^(alias|set|import|mod|export)\b/.test(line))
+            continue;
+        const match = /^@?([A-Za-z_][\w-]*)([^:=]*?):(?!=)\s*(.*)$/.exec(line);
+        if (!match?.[1])
+            continue;
+        const dependencies = (match[3] ?? '')
+            .replace(/#.*$/, '')
+            .split(/&&|\s+/)
+            .map((d) => d.replace(/^\(|\)$/g, '').trim())
+            .filter((d) => d !== '' && /^[A-Za-z_][\w-]*$/.test(d));
+        current = { dependencies, body: [] };
+        recipes.set(match[1], current);
+    }
+    for (const recipe of recipes.values())
+        recipe.body = joinContinuations(recipe.body).filter((l) => l !== '');
+    return recipes;
+}
+/** `justfile`, `Justfile` or `.justfile` in `dir`, else the nearest ancestor. Dependencies are expanded like Makefile prerequisites. */
+export const justfileEntryPoints = {
+    id: 'justfile',
+    list(repoPath, dir) {
+        const found = findFile(repoPath, dir, JUSTFILES, false);
+        return found ? [...parseJustfile(found.text).keys()].map((name) => ({ name, invoke: `just ${name}` })) : [];
+    },
+    lookup(repoPath, dir, name) {
+        const found = findFile(repoPath, dir, JUSTFILES, true);
+        if (!found)
+            return undefined;
+        const recipes = parseJustfile(found.text);
+        const key = name === '@default' ? [...recipes.keys()][0] : name;
+        const recipe = key === undefined ? undefined : recipes.get(key);
+        return recipe ? { file: found.file, bodies: [...recipe.dependencies.map((d) => `just ${d}`), ...recipe.body] } : undefined;
+    },
+};

package/dist/scripts/entry-points/makefile.js

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import { readTracked } from '../../scope/tracked.js';
+const MAKEFILE_NAMES = ['Makefile', 'makefile', 'GNUmakefile'];
+/** Line based: `name [name...]: [prerequisites]` and tab-indented recipe lines. */
+export function parseMakefile(text) {
+    const targets = new Map();
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    let current = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        let line = lines[i] ?? '';
+        if (line.startsWith('\t')) {
+            while (line.endsWith('\\') && i + 1 < lines.length) {
+                i += 1;
+                line = `${line.slice(0, -1).trimEnd()} ${(lines[i] ?? '').trim()}`;
+            }
+            const command = line.trim().replace(/^[@\-+]+\s*/, '');
+            if (command !== '')
+                for (const target of current)
+                    target.recipe.push(command);
+            continue;
+        }
+        current = [];
+        const match = /^([^\s#:=][^:=#]*?)\s*:(?![:=])\s*([^#]*)/.exec(line);
+        if (!match?.[1] || /^(include|-include|ifeq|ifneq|ifdef|ifndef|else|endif|define|endef|export|override)\b/.test(line))
+            continue;
+        const names = match[1].split(/\s+/).filter((n) => n !== '' && !n.includes('%') && !n.includes('$') && n !== '.PHONY');
+        const prerequisites = (match[2] ?? '').split(/\s+/).filter((n) => n !== '' && !n.includes('$') && !n.includes('%'));
+        for (const name of names) {
+            const target = targets.get(name) ?? { prerequisites: [], recipe: [] };
+            target.prerequisites.push(...prerequisites);
+            targets.set(name, target);
+            current.push(target);
+        }
+    }
+    return targets;
+}
+/** Targets of the Makefile in `dir`. A prerequisite is expanded like a call to `make <prerequisite>`. */
+export const makefileEntryPoints = {
+    id: 'makefile',
+    list(repoPath, dir) {
+        const base = dir === '' ? '.' : dir;
+        for (const candidate of MAKEFILE_NAMES) {
+            const text = readTracked(repoPath, path.posix.join(base, candidate));
+            if (text === null)
+                continue;
+            return [...parseMakefile(text).keys()]
+                .filter((name) => !name.startsWith('.') && !name.includes('%'))
+                .map((name) => ({ name, invoke: `make ${name}` }));
+        }
+        return [];
+    },
+    lookup(repoPath, dir, name) {
+        const base = dir === '' ? '.' : dir;
+        for (const candidate of MAKEFILE_NAMES) {
+            const file = path.posix.join(base, candidate);
+            const text = readTracked(repoPath, file);
+            if (text === null)
+                continue;
+            const target = parseMakefile(text).get(name);
+            if (!target)
+                return undefined;
+            return { file, bodies: [...target.prerequisites.map((p) => `make ${p}`), ...target.recipe] };
+        }
+        return undefined;
+    },
+};

package/dist/scripts/entry-points/nox.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { noxSessions } from '../../python/nox.js';
+import { trackedPaths } from '../../scope/tracked.js';
+function noxfileIn(repoPath, dir) {
+    const file = path.posix.join(dir === '' ? '.' : dir, 'noxfile.py');
+    return trackedPaths(repoPath).includes(file) ? file : undefined;
+}
+/** `noxfile.py` in `dir`. A call is `nox [-s <sessions>]`; without `-s` every session runs. */
+export const noxEntryPoints = {
+    id: 'nox',
+    fileFor: noxfileIn,
+    list(repoPath, dir) {
+        const file = noxfileIn(repoPath, dir);
+        const sessions = file ? noxSessions(repoPath, file) : undefined;
+        return (sessions ?? []).map((s) => ({ name: s.name, invoke: `nox -s ${s.name}` }));
+    },
+    lookup(repoPath, dir, name) {
+        const file = noxfileIn(repoPath, dir);
+        const sessions = file ? noxSessions(repoPath, file) : undefined;
+        if (!file || !sessions)
+            return undefined;
+        if (name === '@all')
+            return { file, bodies: sessions.flatMap((s) => s.commands) };
+        const session = sessions.find((s) => s.name === name);
+        if (!session)
+            return undefined;
+        return { file, bodies: [...session.notify.map((n) => `nox -s ${n}`), ...session.commands] };
+    },
+};

package/dist/scripts/entry-points/package-json.js

@@ -0,0 +1,21 @@
+import path from 'node:path';
+import { readPackageJson } from '../../manifest/package-json.js';
+/** `scripts` of the `package.json` in `dir`, else the nearest ancestor within the repository. */
+export const packageJsonEntryPoints = {
+    id: 'package-json',
+    list(repoPath, dir) {
+        const manifest = readPackageJson(repoPath, dir);
+        return Object.keys(manifest?.scripts ?? {}).map((name) => ({ name, invoke: `npm run ${name}` }));
+    },
+    lookup(repoPath, dir, name) {
+        for (let current = path.posix.normalize(dir === '' ? '.' : dir);; current = path.posix.dirname(current)) {
+            const manifest = readPackageJson(repoPath, current);
+            if (manifest) {
+                const body = manifest.scripts[name];
+                return body === undefined ? undefined : { file: path.posix.join(current, 'package.json'), bodies: [body] };
+            }
+            if (current === '.' || current === '' || current.startsWith('..'))
+                return undefined;
+        }
+    },
+};