vibecodedshit 0.0.0-stage → 0.3.0

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

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

@@ -0,0 +1,73 @@
+import { parseTomlText } from '../../util/toml.js';
+import { findFile } from './find.js';
+const isObj = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const cmdText = (value) => (Array.isArray(value) ? [strs(value).join(' ')] : strs(value));
+const strs = (value) => (Array.isArray(value) ? value.filter((v) => typeof v === 'string') : typeof value === 'string' ? [value] : []);
+const sub = (value, ...keys) => {
+    let current = value;
+    for (const key of keys)
+        current = isObj(current) ? current[key] : undefined;
+    return isObj(current) ? current : {};
+};
+function pdm(doc) {
+    return Object.entries(sub(doc, 'tool', 'pdm', 'scripts')).map(([name, value]) => {
+        const bodies = typeof value === 'string' ? [value] : isObj(value) ? [...cmdText(value.cmd), ...strs(value.shell), ...strs(value.composite).map((c) => `pdm run ${c}`)] : [];
+        return { key: `pdm:${name}`, invoke: `pdm run ${name}`, bodies };
+    });
+}
+function hatch(doc) {
+    const out = [];
+    for (const [env, table] of Object.entries(sub(doc, 'tool', 'hatch', 'envs'))) {
+        const scripts = isObj(table) && isObj(table.scripts) ? table.scripts : {};
+        for (const [name, value] of Object.entries(scripts)) {
+            const bodies = strs(value).map((c) => (Object.hasOwn(scripts, c.trim().split(/\s+/)[0] ?? '') ? `hatch run ${env}:${c.trim().split(/\s+/)[0]}` : c));
+            out.push({ key: `hatch:${env}:${name}`, invoke: `hatch run ${env}:${name}`, bodies });
+        }
+    }
+    return out;
+}
+function rye(doc) {
+    return Object.entries(sub(doc, 'tool', 'rye', 'scripts')).map(([name, value]) => {
+        const bodies = typeof value === 'string' ? [value] : isObj(value) ? [...cmdText(value.cmd), ...strs(value.shell), ...strs(value.chain).map((c) => `rye run ${c}`)] : [];
+        return { key: `rye:${name}`, invoke: `rye run ${name}`, bodies };
+    });
+}
+function poe(doc) {
+    const tasks = sub(doc, 'tool', 'poe', 'tasks');
+    const items = (list) => (Array.isArray(list) ? list : []).flatMap((item) => (typeof item === 'string' ? [Object.hasOwn(tasks, item.trim().split(/\s+/)[0] ?? '') ? `poe ${item}` : item] : isObj(item) ? [...cmdText(item.cmd), ...strs(item.shell)] : []));
+    return Object.entries(tasks).map(([name, value]) => {
+        const bodies = typeof value === 'string' ? [value] : isObj(value) ? [...cmdText(value.cmd), ...strs(value.shell), ...items(value.sequence), ...items(value.composite)] : [];
+        return { key: `poe:${name}`, invoke: `poe ${name}`, bodies };
+    });
+}
+function taskipy(doc) {
+    return Object.entries(sub(doc, 'tool', 'taskipy', 'tasks')).map(([name, value]) => ({
+        key: `taskipy:${name}`,
+        invoke: `task ${name}`,
+        bodies: typeof value === 'string' ? [value] : isObj(value) ? strs(value.cmd) : [],
+    }));
+}
+/** `[project.scripts]` and `[tool.poetry.scripts]` targets are `module:callable`: the entry exists and runs no recognised tool. */
+function scripts(doc) {
+    const names = [...Object.keys(sub(doc, 'project', 'scripts')), ...Object.keys(sub(doc, 'tool', 'poetry', 'scripts'))];
+    return [...new Set(names)].map((name) => ({ key: `scripts:${name}`, invoke: `uv run ${name}`, bodies: [] }));
+}
+function entries(repoPath, dir) {
+    const found = findFile(repoPath, dir, ['pyproject.toml'], false);
+    const doc = found ? parseTomlText(found.text) : undefined;
+    if (!found || !doc)
+        return undefined;
+    return { file: found.file, entries: [...scripts(doc), ...pdm(doc), ...hatch(doc), ...rye(doc), ...poe(doc), ...taskipy(doc)] };
+}
+/** Script tables of the `pyproject.toml` in `dir`. Lookup names are the namespaced keys (`pdm:lint`, `hatch:default:test`). */
+export const pyprojectEntryPoints = {
+    id: 'pyproject',
+    list(repoPath, dir) {
+        return (entries(repoPath, dir)?.entries ?? []).map((e) => ({ name: e.key, invoke: e.invoke }));
+    },
+    lookup(repoPath, dir, name) {
+        const read = entries(repoPath, dir);
+        const entry = read?.entries.find((e) => e.key === name);
+        return read && entry ? { file: read.file, bodies: entry.bodies } : undefined;
+    },
+};

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

@@ -0,0 +1,130 @@
+import { parseIni } from '../../util/ini.js';
+import { parseTomlText } from '../../util/toml.js';
+import { findFile } from './find.js';
+const isObj = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+/** `py{311,312}-lint` becomes `py311-lint` and `py312-lint`. */
+function expandBraces(text) {
+    const match = /^(.*?)\{([^{}]*)\}(.*)$/.exec(text);
+    if (!match)
+        return [text];
+    const [, head = '', set = '', tail = ''] = match;
+    return set.split(',').flatMap((item) => expandBraces(`${head}${item.trim()}${tail}`));
+}
+function lines(value) {
+    return (value ?? '')
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l !== '' && !l.startsWith('#'));
+}
+/** Split on commas and newlines outside braces, then expand brace sets. */
+function envList(value) {
+    const parts = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of value ?? '') {
+        if (ch === '{')
+            depth += 1;
+        else if (ch === '}')
+            depth -= 1;
+        if ((ch === ',' || ch === '\n') && depth <= 0) {
+            parts.push(current);
+            current = '';
+        }
+        else
+            current += ch;
+    }
+    parts.push(current);
+    return parts.map((e) => e.trim()).filter((e) => e !== '').flatMap(expandBraces);
+}
+function fromIni(file, text) {
+    const ini = parseIni(text);
+    const section = (name) => {
+        const s = ini[name] ?? {};
+        return { commandsPre: lines(s.commands_pre), commands: lines(s.commands), commandsPost: lines(s.commands_post) };
+    };
+    const envs = new Map();
+    for (const name of Object.keys(ini))
+        if (name.startsWith('testenv:'))
+            envs.set(name.slice('testenv:'.length), section(name));
+    return { file, envlist: envList(ini.tox?.envlist), base: section('testenv'), envs };
+}
+function commandText(value) {
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return value.map((v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string').join(' ') : typeof v === 'string' ? v : '')).filter((v) => v !== '');
+    return [];
+}
+function fromToml(file, doc) {
+    const table = file.endsWith('pyproject.toml') ? (isObj(doc.tool) && isObj(doc.tool.tox) ? doc.tool.tox : undefined) : doc;
+    if (!table)
+        return undefined;
+    if (typeof table.legacy_tox_ini === 'string')
+        return fromIni(file, table.legacy_tox_ini);
+    const base = { commands: commandText(isObj(table.env_run_base) ? table.env_run_base.commands : undefined) };
+    const envs = new Map();
+    const rawEnvs = isObj(table.env) ? table.env : {};
+    for (const [name, value] of Object.entries(rawEnvs))
+        if (isObj(value))
+            envs.set(name, { commands: commandText(value.commands) });
+    const envlist = Array.isArray(table.env_list) ? table.env_list.filter((e) => typeof e === 'string').flatMap(expandBraces) : [];
+    return { file, envlist, base, envs };
+}
+function readToxConfig(repoPath, dir) {
+    const ini = findFile(repoPath, dir, ['tox.ini'], false);
+    if (ini)
+        return fromIni(ini.file, ini.text);
+    for (const name of ['tox.toml', 'pyproject.toml']) {
+        const found = findFile(repoPath, dir, [name], false);
+        const doc = found ? parseTomlText(found.text) : undefined;
+        const config = found && doc ? fromToml(found.file, doc) : undefined;
+        if (config)
+            return config;
+    }
+    return undefined;
+}
+/** `{envpython} -m` becomes `python -m`; `{posargs}`, `{toxinidir}` and other `{...}` fields are dropped. */
+function substitute(command, factors) {
+    let text = command.trim();
+    const factor = /^([A-Za-z0-9_.!,-]+):\s+(.*)$/.exec(text);
+    if (factor?.[1] && factor[2] !== undefined) {
+        const wanted = factor[1].split(',').some((f) => (f.startsWith('!') ? !factors.includes(f.slice(1)) : factors.includes(f)));
+        if (!wanted)
+            return undefined;
+        text = factor[2];
+    }
+    text = text.replace(/\{envpython\}/g, 'python').replace(/\{[^{}]*\}/g, '').replace(/^[-!]+\s*/, '').replace(/\s+/g, ' ').trim();
+    return text === '' ? undefined : text;
+}
+function envBodies(config, name) {
+    const factors = name.split('-');
+    const section = config.envs.get(name) ?? factors.map((f) => config.envs.get(f)).find((e) => e !== undefined);
+    const known = section !== undefined || config.envlist.includes(name) || name === '@base';
+    if (!known)
+        return undefined;
+    const pick = (key) => section?.[key] ?? config.base[key] ?? [];
+    return [...pick('commandsPre'), ...pick('commands'), ...pick('commandsPost')].flatMap((c) => substitute(c, factors) ?? []);
+}
+/** `tox.ini`, `tox.toml` or `[tool.tox]` in `dir`. A call is `tox [-e <envs>]`. */
+export const toxEntryPoints = {
+    id: 'tox',
+    fileFor: (repoPath, dir) => readToxConfig(repoPath, dir)?.file,
+    list(repoPath, dir) {
+        const config = readToxConfig(repoPath, dir);
+        if (!config)
+            return [];
+        const names = config.envlist.length > 0 ? config.envlist : [...config.envs.keys()];
+        return [...new Set(names)].map((name) => ({ name, invoke: `tox -e ${name}` }));
+    },
+    lookup(repoPath, dir, name) {
+        const config = readToxConfig(repoPath, dir);
+        if (!config)
+            return undefined;
+        if (name === '@default') {
+            const names = config.envlist.length > 0 ? config.envlist : ['@base'];
+            return { file: config.file, bodies: names.flatMap((n) => envBodies(config, n) ?? []) };
+        }
+        const bodies = envBodies(config, name);
+        return bodies === undefined ? undefined : { file: config.file, bodies };
+    },
+};