peachycheck 0.1.0__py3-none-any.whl

peachycheck/__init__.py

@@ -0,0 +1 @@
+"""peachycheck: native linters and agent hooks from one peachycheck.yml."""

peachycheck/__main__.py

@@ -0,0 +1,7 @@
+"""``python -m peachycheck``."""
+
+import sys
+
+from peachycheck.cli import main
+
+sys.exit(main())

peachycheck/cli.py

@@ -0,0 +1,447 @@
+"""The command line ``peachycheck``: lint, sync and the agents' hooks.
+
+``FILES`` of a repository's ``peachycheck.yml`` names the tool configurations
+it shares: those of ``general`` with every repository, the others with each
+repository that has their marker file. ``sync`` writes them, ``sync --check``
+fails on any difference; ``lint`` runs the linters and ``hook`` answers the
+agents' hooks. ``init`` sets a repository up, ``upgrade`` moves it to
+another version. Builds and tests are the repository's own CI's.
+"""
+
+import argparse
+import filecmp
+import importlib.metadata
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tomllib
+from collections.abc import Callable, Sequence
+from dataclasses import replace
+from pathlib import Path
+from typing import Final, cast
+
+from peachycheck import config, hooks, linting
+
+PACKAGE = "peachycheck"
+WORKFLOW = """name: peachycheck
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  peachycheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: drexlerd/peachycheck@{ref}
+"""
+# The action or the reusable workflow at any ref, and the pinned version.
+USES = re.compile(
+    r"(drexlerd/peachycheck(?:/\.github/workflows/check\.yml)?@)[^\s#]+"
+)
+PIN = re.compile(r"^PEACHYCHECK_VERSION:.*$", re.M)
+GENERAL: Final = "general"  # the FILES of every repository
+MAIN_BRANCH: str = ""  # empty: the remote's default branch (origin/HEAD)
+
+
+def version() -> str:
+    """The installed version of peachycheck."""
+    return importlib.metadata.version(PACKAGE)
+
+
+def released() -> bool:
+    """Installed from a built package, not from a git or folder source."""
+    try:
+        found = importlib.metadata.distribution(PACKAGE)
+    except importlib.metadata.PackageNotFoundError:
+        return False
+    direct = json.loads(found.read_text("direct_url.json") or "{}")
+    return not {"vcs_info", "dir_info"} & set(direct)
+
+
+def _commit() -> str:
+    """The commit of peachycheck this was installed from."""
+    try:
+        found = importlib.metadata.distribution(PACKAGE)
+        direct = json.loads(found.read_text("direct_url.json") or "{}")
+        commit = str(direct.get("vcs_info", {}).get("commit_id", ""))
+    except importlib.metadata.PackageNotFoundError:
+        commit = ""
+    if commit:
+        return commit
+    head = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=Path(__file__).parent,
+        capture_output=True,
+        text=True,
+    )
+    return head.stdout.strip() if head.returncode == 0 else "main"
+
+
+def base_files(root: Path) -> dict[str, Path]:
+    """What ``.peachycheck/`` of ``root`` holds: each file, by its path there.
+
+    ``FILES`` names them under ``general`` for every repository, and under a
+    marker file, such as ``pyproject.toml``, for each repository that has
+    it; a later entry wins, and a folder brings every file below it.
+    """
+    files = cast(dict[str, dict[str, str]], config.load(root).get("FILES", {}))
+    wanted: dict[str, Path] = {}
+    for name, entries in files.items():
+        if name != GENERAL and not (root / name).exists():
+            continue
+        for target, source_name in entries.items():
+            source = Path(source_name)
+            below = sorted(p for p in source.rglob("*") if p.is_file())
+            for path in below if source.is_dir() else [source]:
+                inner = path.relative_to(source) if source.is_dir() else ""
+                wanted[(Path(target) / inner).as_posix()] = path
+    return wanted
+
+
+def sync(root: Path, *, check: bool) -> list[str]:
+    """Write ``.peachycheck/`` of ``root``; with ``check``, only compare.
+
+    The folder holds the base configurations of the repository, as
+    ``base_files`` lists them, and nothing else.
+
+    Returns:
+        The files of ``.peachycheck/`` that differ (``check``) or were
+        written or removed.
+    """
+    folder = root / config.BASE
+    wanted = base_files(root)
+    found = folder.rglob("*") if folder.is_dir() else iter(list[Path]())
+    present = {p.relative_to(folder).as_posix() for p in found if p.is_file()}
+    present -= _ignored(folder, present) if present else set()
+    differing = sorted(
+        {n for n in present if n not in wanted}
+        | {
+            n
+            for n, source in wanted.items()
+            if n not in present
+            or not filecmp.cmp(source, folder / n, shallow=False)
+        }
+    )
+    if not check:
+        for name in differing:
+            target = folder / name
+            target.unlink(missing_ok=True)
+            if name in wanted:
+                target.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(wanted[name], target)
+    return [f"{config.BASE}/{n}" for n in differing]
+
+
+def _ignored(folder: Path, names: set[str]) -> set[str]:
+    """The ``names`` in ``folder`` that git ignores, such as a tool's cache."""
+    checked = subprocess.run(
+        ["git", "check-ignore", "--stdin"],
+        cwd=folder,
+        input="\n".join(sorted(names)),
+        capture_output=True,
+        text=True,
+    )
+    return set(checked.stdout.splitlines()) & names
+
+
+# What a repository's own configuration needs to inherit the base; ``init``
+# writes it when the repository has none.
+INHERIT: Final = {
+    "ruff.toml": f'extend = "{config.BASE}/ruff.toml"\n',
+    "pyrightconfig.json": (
+        f'{{\n  "extends": "{config.BASE}/pyrightconfig.json"\n}}\n'
+    ),
+    "eslint.config.mjs": (
+        f'import base from "./{config.BASE}/eslint.config.mjs";\n\n'
+        "export default [...base];\n"
+    ),
+}
+
+
+def inherit(root: Path) -> list[str]:
+    """Write the repository's own configurations that inherit the base.
+
+    Only for a base file of ``.peachycheck/`` whose tool can extend another
+    file, and only where the repository has no configuration yet.
+    """
+    pyproject = root / "pyproject.toml"
+    ruff_there = pyproject.is_file() and "[tool.ruff" in pyproject.read_text()
+    written: list[str] = []
+    for name, text in INHERIT.items():
+        own = root / name
+        if not (root / config.BASE / name).is_file() or own.is_file():
+            continue
+        if name == "ruff.toml" and ruff_there:
+            continue
+        own.write_text(text)
+        written.append(name)
+    return written
+
+
+def _uv_add(root: Path, requirement: str) -> None:
+    subprocess.run(["uv", "add", "--dev", requirement], cwd=root, check=True)
+
+
+def _dev_dependency(root: Path, wanted: str | None, *, add: bool) -> str:
+    """Pin ``peachycheck==wanted`` in the dev group of ``root``.
+
+    Without ``add``, only an existing pin moves. A generated pyproject.toml
+    (see ``GENERATED``) gets none.
+
+    Returns:
+        What was done, or "" when ``root`` is no Python project.
+    """
+    pyproject = root / "pyproject.toml"
+    if not pyproject.is_file() or "pyproject.toml" in linting.generated(root):
+        return ""
+    if wanted is None:
+        return "pyproject.toml: no dev pin, not installed from PyPI" * add
+    requirement = f"{PACKAGE}=={wanted}"
+    groups = tomllib.loads(pyproject.read_text()).get("dependency-groups", {})
+    dev = [d for d in groups.get("dev", []) if isinstance(d, str)]
+    if requirement in dev:
+        return f"pyproject.toml: {requirement} already"
+    if not add and not any(re.match(r"peachycheck\b", d) for d in dev):
+        return ""
+    _uv_add(root, requirement)
+    return f"pyproject.toml: {requirement} in the dev dependencies"
+
+
+def _pin() -> str:
+    """The version peachycheck.yml pins: the release, else the commit."""
+    return version() if released() else _commit()
+
+
+def _ref(pin: str) -> str:
+    """The ref of the action for ``pin``: a release's tag, else ``pin``."""
+    return f"v{pin}" if re.match(r"\d+\.\d+", pin) else pin
+
+
+def init(root: Path, extends: str | None = None) -> int:
+    """Set ``root`` up: peachycheck.yml, the CI workflow, configs, tools, pin."""
+    own = root / config.NAME
+    if own.is_file():
+        print(f"{config.NAME}: exists")
+    else:
+        own.write_text(
+            "# peachycheck's configuration: "
+            "https://github.com/drexlerd/peachycheck#configuration\n"
+            + (f"EXTENDS: {extends}\n" if extends else "")
+            + f"PEACHYCHECK_VERSION: {_pin()}\n"
+        )
+        print(f"{config.NAME}: written")
+    workflow = root / ".github" / "workflows" / "peachycheck.yml"
+    if workflow.is_file():
+        print(".github/workflows/peachycheck.yml: exists")
+    else:
+        private = (root / ".gitmodules").is_file()
+        workflow.parent.mkdir(parents=True, exist_ok=True)
+        token = (
+            "        with:\n          token: ${{ secrets.SUBMODULES_TOKEN }}\n"
+        )
+        workflow.write_text(WORKFLOW.format(ref=_ref(_pin())) + token * private)
+        print(".github/workflows/peachycheck.yml: written")
+    _sync(root, check_only=False)
+    for name in inherit(root):
+        print(f"{name}: written, extending {config.BASE}/{name}")
+    install(root)
+    pinned = _dev_dependency(root, version() if released() else None, add=True)
+    if pinned:
+        print(pinned)
+    return 0
+
+
+def _moved(root: Path, path: Path, pattern: re.Pattern[str], line: str) -> None:
+    """Replace ``pattern``'s matches in ``path`` by ``line``, a replacement."""
+    name = path.relative_to(root).as_posix()
+    text = path.read_text()
+    moved = pattern.sub(line, text)
+    if moved != text:
+        path.write_text(moved)
+        print(f"{name}: moved")
+    elif pattern.search(text):
+        print(f"{name}: already")
+
+
+def upgrade(root: Path, to: str | None) -> int:
+    """Move the pins of peachycheck to ``to`` (or the installed version).
+
+    The pins are ``PEACHYCHECK_VERSION`` of peachycheck.yml, the refs of the
+    action and the reusable workflow in ``.github/workflows`` and the dev
+    dependency.
+    """
+    own = root / config.NAME
+    if not own.is_file():
+        print(f"no {config.NAME}; run `peachycheck init` first")
+        return 1
+    wanted = to.removeprefix("v") if to else None
+    if wanted is None and released():
+        wanted = version()
+    pin = wanted or _commit()
+    if not PIN.search(own.read_text()):
+        own.write_text(own.read_text() + f"PEACHYCHECK_VERSION: {pin}\n")
+    _moved(root, own, PIN, f"PEACHYCHECK_VERSION: {pin}")
+    for workflow in sorted((root / ".github" / "workflows").glob("*.y*ml")):
+        _moved(root, workflow, USES, f"\\g<1>{_ref(pin)}")
+    pinned = _dev_dependency(root, wanted, add=False)
+    if pinned:
+        print(pinned)
+    return _sync(root, check_only=False)
+
+
+# The empty tree: diffing against it lists every tracked file.
+EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+
+
+def base_of(root: Path) -> str:
+    """The merge base of ``HEAD`` with the main branch, else ``HEAD~1``.
+
+    A repository with neither diffs against the empty tree.
+
+    The main branch is ``origin/MAIN_BRANCH``, else ``origin/HEAD``, which
+    many clones lack, else ``origin/main``.
+    """
+    branches = (
+        [f"origin/{MAIN_BRANCH}"]
+        if MAIN_BRANCH
+        else ["origin/HEAD", "origin/main"]
+    )
+    for branch in branches:
+        found = subprocess.run(
+            ["git", "merge-base", "HEAD", branch],
+            cwd=root,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if found.returncode == 0:
+            return found.stdout.strip()
+    previous = subprocess.run(
+        ["git", "rev-parse", "--verify", "--quiet", "HEAD~1"],
+        cwd=root,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    # Without a main branch or a parent commit every file counts as changed.
+    return "HEAD~1" if previous.returncode == 0 else EMPTY_TREE
+
+
+def lint(root: Path, options: argparse.Namespace) -> int:
+    """Lint the given files, those changed since ``--base``, or ``--all``.
+
+    Each file is linted with the repository it belongs to (see
+    ``config.owner``); a file of another repository shows its path from
+    ``root``.
+    """
+    if options.all:
+        paths = [root / p for p in linting.all_files(root)]
+    elif options.files:
+        paths = [Path(f).resolve() for f in options.files]
+    else:
+        base = options.base or base_of(root)
+        paths = [root / p for p in linting.changed_files(root, base)]
+    messages: list[str] = []
+    for repo, result in linting.lint_files(paths, fix=options.fix):
+        prefix = os.path.relpath(repo, root)
+        if prefix != ".":
+            result.findings = [
+                replace(f, path=f"{prefix}/{f.path}") for f in result.findings
+            ]
+        messages += linting.report(result, limit=10**9)
+    print("\n".join(messages) or f"{len(paths)} files, no findings")
+    return 1 if messages else 0
+
+
+def install(root: Path | None = None) -> int:
+    """Download the pinned tools of ``VERSIONS``."""
+    versions = config.load(root).get("VERSIONS", {})
+    print("\n".join(linting.install(versions)))
+    return 0
+
+
+def install_hooks(options: argparse.Namespace) -> int:
+    """Write or remove the user's Claude Code and Codex hooks; print the diff."""
+    both = not options.claude and not options.codex
+    remove = options.action == "uninstall"
+    diff = hooks.install(
+        Path.home(),
+        claude=options.claude or both,
+        codex=options.codex or both,
+        remove=remove,
+    )
+    print(diff or f"the hooks are {'removed' if remove else 'installed'}")
+    if (options.codex or both) and not remove:
+        print("Trust the Codex hooks once with /hooks.")
+    return 0
+
+
+def parser() -> argparse.ArgumentParser:
+    """The command line; a consumer may add arguments before parsing."""
+    result = argparse.ArgumentParser(prog="peachycheck")
+    result.add_argument("--root", type=Path, default=Path.cwd())
+    result.add_argument(
+        "--version", action="version", version=f"%(prog)s {version()}"
+    )
+    commands = result.add_subparsers(dest="command", required=True)
+    commands.add_parser("install", help="download the pinned linters")
+    linted = commands.add_parser("lint", help="run the linters")
+    linted.add_argument("files", nargs="*")
+    linted.add_argument("--all", action="store_true", help="every file")
+    linted.add_argument(
+        "--base", help="files changed since; default: the merge base"
+    )
+    linted.add_argument("--fix", action="store_true", help="fix first")
+    hook = commands.add_parser("hook", help="answer a Claude or Codex hook")
+    hook.add_argument("event", choices=["post-edit", "stop"])
+    installing = commands.add_parser(
+        "hooks", help="install or uninstall the agents' hooks"
+    )
+    installing.add_argument("action", choices=["install", "uninstall"])
+    installing.add_argument("--claude", action="store_true")
+    installing.add_argument("--codex", action="store_true")
+    syncing = commands.add_parser("sync", help="write the shared tool configs")
+    syncing.add_argument("--check", action="store_true", help="only compare")
+    initializing = commands.add_parser(
+        "init", help="set the repository up: peachycheck.yml, CI, configs"
+    )
+    initializing.add_argument(
+        "--extends", help="the URL or path of the file peachycheck.yml extends"
+    )
+    upgrading = commands.add_parser(
+        "upgrade", help="move the pins of peachycheck to a version"
+    )
+    upgrading.add_argument("--to", help="default: the installed version")
+    return result
+
+
+def _sync(root: Path, check_only: bool) -> int:
+    differing = sync(root, check=check_only)
+    verb = "differs; run `peachycheck sync`" if check_only else "written"
+    print("\n".join(f"{path}: {verb}" for path in differing) or "in sync")
+    return 1 if differing and check_only else 0
+
+
+def main(arguments: Sequence[str] | None = None) -> int:
+    """Run one command of ``peachycheck``."""
+    options = parser().parse_args(arguments)
+    root: Path = options.root.resolve()
+    commands: dict[str, Callable[[], int]] = {
+        "install": lambda: install(root),
+        "lint": lambda: lint(root, options),
+        "hook": lambda: hooks.run(options.event),
+        "hooks": lambda: install_hooks(options),
+        "sync": lambda: _sync(root, options.check),
+        "init": lambda: init(root, options.extends),
+        "upgrade": lambda: upgrade(root, options.to),
+    }
+    return commands[options.command]()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

peachycheck/config.py

@@ -0,0 +1,235 @@
+"""``peachycheck.yml``: peachycheck's defaults and a repository's overrides.
+
+Every configuration extends peachycheck's defaults first. A file may
+``EXTENDS`` others (URLs or paths, resolved first); later files win, mappings
+merge key by key, and the keys ``CONFIG_PROPERTIES_TO_APPEND`` names append
+their lists, as in MegaLinter's configuration. A repository without a
+``peachycheck.yml`` gets the defaults.
+
+The paths in ``FILES`` resolve against the file that names them. A file
+extended by its GitHub raw URL
+(``https://raw.githubusercontent.com/<owner>/<repo>/<ref>/<path>``) is read
+from a snapshot of its repository at that ref, so its folders resolve too.
+"""
+
+import hashlib
+import io
+import re
+import subprocess
+import tarfile
+import urllib.request
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any, Final, cast
+
+import yaml
+
+NAME: Final = "peachycheck.yml"
+APPEND: Final = "CONFIG_PROPERTIES_TO_APPEND"
+CACHE: Final = Path("~/.cache/peachycheck/extends")
+DEFAULTS: Final = Path(__file__).parent / "defaults" / NAME
+# The folder ``sync`` writes the shared base configurations into.
+BASE: Final = ".peachycheck"
+GITHUB_RAW: Final = re.compile(
+    r"https://raw\.githubusercontent\.com/([^/]+)/([^/]+)/([^/]+)/(.+)"
+)
+
+type Config = dict[str, Any]
+
+
+def _url(source: str) -> bool:
+    return bool(re.match(r"https?://", source))
+
+
+def _download(url: str) -> bytes:
+    request = urllib.request.Request(url, headers={"User-Agent": "peachycheck"})
+    with urllib.request.urlopen(request, timeout=60) as response:
+        return cast(bytes, response.read())
+
+
+def _snapshot(owner: str, repo: str, ref: str) -> Path:
+    """The files of ``owner/repo`` at ``ref``, downloaded once.
+
+    ponytail: cached forever, so EXTENDS should pin a commit; delete the cache
+    to refetch a moving ref. Public repositories only.
+    """
+    folder = CACHE.expanduser() / owner / repo / ref
+    if not folder.is_dir():
+        data = _download(
+            f"https://codeload.github.com/{owner}/{repo}/tar.gz/{ref}"
+        )
+        partial = folder.with_name(f".{ref}.partial")
+        with tarfile.open(fileobj=io.BytesIO(data)) as archive:
+            archive.extractall(partial, filter="data")
+        (top,) = partial.iterdir()  # the archive's one folder, repo-ref/
+        top.rename(folder)
+        partial.rmdir()
+    return folder
+
+
+def local(source: str) -> str:
+    """``source`` as a local path; a GitHub raw URL in its repository's snapshot.
+
+    Other URLs stay URLs.
+    """
+    found = GITHUB_RAW.fullmatch(source)
+    if found:
+        owner, repo, ref, path = found.groups()
+        return str(_snapshot(owner, repo, ref) / path)
+    return source
+
+
+def _text(source: str) -> str:
+    """A file's text; a URL is fetched once and cached by its address."""
+    if not _url(source):
+        return Path(source).read_text()
+    cached = CACHE.expanduser() / hashlib.sha256(source.encode()).hexdigest()
+    if not cached.is_file():
+        cached.parent.mkdir(parents=True, exist_ok=True)
+        cached.write_bytes(_download(source))
+    return cached.read_text()
+
+
+def _located(entry: str, parent: str) -> str:
+    """``entry``, a path relative to the file ``parent`` that names it."""
+    if _url(entry) or Path(entry).is_absolute():
+        return entry
+    if _url(parent):
+        return parent.rsplit("/", 1)[0] + "/" + entry
+    return str(Path(parent).parent / entry)
+
+
+def _anchored(data: Config, source: str) -> Config:
+    """``data`` with its relative paths resolved against ``source``."""
+    found = dict(data)
+    files = cast(dict[str, dict[str, str]], found.get("FILES") or {})
+    found_files = {
+        kind: {
+            target: _located(str(path), source) for target, path in by.items()
+        }
+        for kind, by in files.items()
+    }
+    return {**found, "FILES": found_files} if files else found
+
+
+def merge(base: Config, extra: Config, append: Iterable[str] = ()) -> Config:
+    """``extra`` over ``base``: later wins, mappings merge, ``append`` lists join."""
+    keys = set(append) | set(base.get(APPEND, ())) | set(extra.get(APPEND, ()))
+    merged = dict(base)
+    for key, value in extra.items():
+        old = merged.get(key)
+        if key in keys and isinstance(old, list) and isinstance(value, list):
+            merged[key] = [*cast(list[Any], old), *cast(list[Any], value)]
+        elif isinstance(old, dict) and isinstance(value, dict):
+            merged[key] = merge(
+                cast(Config, old), cast(Config, value), keys - {APPEND}
+            )
+        else:
+            merged[key] = value
+    return merged
+
+
+def resolve(source: str, seen: frozenset[str] = frozenset()) -> Config:
+    """The configuration of ``source`` with everything it extends."""
+    source = local(source)
+    data = _anchored(cast(Config, yaml.safe_load(_text(source)) or {}), source)
+    extends = data.pop("EXTENDS", [])
+    result: Config = {}
+    for entry in [extends] if isinstance(extends, str) else extends:
+        located = local(_located(str(entry), source))
+        if located not in seen | {source}:  # a cycle is read once
+            result = merge(result, resolve(located, seen | {source}))
+    return merge(result, data)
+
+
+def load(root: Path | None = None) -> Config:
+    """The configuration of ``root``: the defaults and its ``peachycheck.yml``."""
+    defaults = resolve(str(DEFAULTS))
+    own = root / NAME if root else None
+    if own is None or not own.is_file():
+        return defaults
+    return merge(defaults, resolve(str(own)))
+
+
+def rule_file(root: Path, name: str) -> Path | None:
+    """The configuration file ``name`` of a linter in the repository ``root``.
+
+    The repository's own (which inherits the base natively), else the base
+    in ``.peachycheck/``, else none: the tool's own defaults.
+    """
+    candidates = (root / name, root / BASE / name)
+    return next((c for c in candidates if c.is_file()), None)
+
+
+def _toplevel(folder: Path) -> Path | None:
+    found = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        cwd=folder,
+        capture_output=True,
+        text=True,
+    )
+    return Path(found.stdout.strip()) if found.returncode == 0 else None
+
+
+def owner(path: Path) -> Path | None:
+    """The repository a file belongs to, or None when peachycheck skips it.
+
+    It is the nearest folder above the file with a peachycheck.yml, up to the
+    file's git toplevel.
+    """
+    folder = path if path.is_dir() else path.parent
+    while not folder.is_dir():
+        folder = folder.parent  # a deleted file's folder may be gone too
+    top = _toplevel(folder)
+    if top is None:
+        return None
+    for candidate in [folder, *folder.parents]:
+        if (candidate / NAME).is_file():
+            return candidate
+        if candidate == top:
+            return None
+    return None
+
+
+def grouped(paths: Iterable[Path]) -> dict[Path, list[str]]:
+    """Absolute ``paths`` by their repository, relative to it; others dropped."""
+    found: dict[Path, list[str]] = {}
+    for path in paths:
+        root = owner(path.resolve())
+        if root is not None:
+            relative = path.resolve().relative_to(root.resolve()).as_posix()
+            found.setdefault(root, []).append(relative)
+    return found
+
+
+def linters(config: Config) -> dict[str, Config]:
+    """The linters that run, with the repository's overrides applied."""
+    enabled = config.get("ENABLE_LINTERS")
+    disabled = set(config.get("DISABLE_LINTERS", ()))
+    found: dict[str, Config] = {}
+    for name, spec in cast(
+        dict[str, Config], config.get("LINTERS", {})
+    ).items():
+        if not spec.get("command") or name in disabled:
+            continue
+        if enabled is not None and name not in enabled:
+            continue
+        arguments = config.get(f"{name}_ARGUMENTS", [])
+        setting = f"{name}_{spec.get('requires_key', 'REQUIRES')}"
+        found[name] = {
+            **spec,
+            "requires": config.get(setting, spec.get("requires")),
+            "arguments": [arguments]
+            if isinstance(arguments, str)
+            else arguments,
+            "include": config.get(f"{name}_FILTER_REGEX_INCLUDE", ""),
+            "exclude": [
+                r
+                for r in (
+                    config.get("FILTER_REGEX_EXCLUDE", ""),
+                    config.get(f"{name}_FILTER_REGEX_EXCLUDE", ""),
+                )
+                if r
+            ],
+        }
+    return found