forceupdate 0.1.0__py3-none-any.whl

forceupdate/checks/base.py

@@ -0,0 +1,98 @@
+"""Ce que partagent les contrôles : la version actuelle d'une dépendance, la plus proche
+version de remplacement, les noms des écarts.
+
+La version actuelle (brief, décision n°2) est celle du lockfile. Sans lockfile, c'est la
+version qu'impose une contrainte exacte (``==1.2.3``), sinon la borne basse de la contrainte,
+marquée « approximative » : la version réellement installée peut être plus haute. Sans borne
+basse (``*``, ``<2``, une étiquette npm), on ne la connaît pas, et on le dit.
+"""
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from forceupdate import versions
+from forceupdate.models import Dependency, Gap
+from forceupdate.versions import InvalidConstraint, VersionScheme
+from forceupdate.versions.npm import NpmRange
+
+GAP_LABELS = {Gap.MAJOR: "majeure", Gap.MINOR: "mineure", Gap.PATCH: "correctif"}
+"""L'écart en français, tel qu'on l'affiche."""
+
+
+@dataclass(frozen=True, kw_only=True)
+class Current:
+    """La version actuelle d'une dépendance : celle qu'on compare à ce que dit le registre."""
+
+    version: str | None
+    """L'installée ; sinon celle qu'impose une contrainte exacte ; sinon la borne basse de la
+    contrainte. ``None`` si on ne peut rien en dire (voir ``unknown``)."""
+    approximate: bool = False
+    """Vrai pour une borne basse : la version réellement installée peut être plus haute."""
+    constraint: str | None = None
+    """La contrainte à interpréter (``Dependency.effective_constraint``) ; ``None`` si elle est
+    illisible (ou un ``catalog:`` introuvable) : on se fie alors à la version installée."""
+    unknown: str | None = None
+    """Pourquoi la version actuelle est inconnue, en français, quand ``version`` est ``None``."""
+
+
+def current_version(dependency: Dependency) -> Current:
+    """La version actuelle de ``dependency`` (voir ``Current``)."""
+    scheme = versions.for_ecosystem(dependency.ecosystem)
+    text = dependency.effective_constraint
+    try:
+        parsed = scheme.parse_constraint(text)
+    except InvalidConstraint:
+        parsed = None
+    constraint = None if parsed is None else text
+    if dependency.installed is not None:
+        return Current(version=dependency.installed, constraint=constraint)
+    if parsed is None:
+        if dependency.constraint.startswith("catalog:") and dependency.resolved_constraint is None:
+            why = f"la plage de « {dependency.constraint} » est introuvable"
+        else:
+            why = f"la contrainte « {text} » est illisible"
+        return Current(version=None, unknown=f"{why}, et pas de version installée")
+    exact = parsed.exact()
+    if exact is not None:
+        return Current(version=exact, constraint=constraint)
+    lower = parsed.lower_bound()
+    if lower is not None:
+        return Current(version=lower, approximate=True, constraint=constraint)
+    if not text.strip():
+        why = "aucune contrainte"
+    elif isinstance(parsed, NpmRange) and parsed.tag is not None:
+        why = f"l'étiquette « {parsed.tag} » suit le registre"
+    else:
+        why = f"la contrainte « {text} » n'a pas de borne basse"
+    return Current(
+        version=None, constraint=constraint, unknown=f"{why}, et pas de version installée"
+    )
+
+
+def sentence(text: str) -> str:
+    """``text`` terminé par un point, sans en doubler un (le message d'un registre ou d'un avis
+    peut déjà finir par ``.``, ``!``, ``?`` ou ``…``)."""
+    text = text.rstrip()
+    return text if text.endswith((".", "!", "?", "…")) else text + "."
+
+
+def nearest(scheme: VersionScheme, current: str, choices: Iterable[str]) -> str | None:
+    """La version de ``choices`` la plus proche de ``current``, pour remplacer une version
+    retirée ou dépréciée : la plus petite au-dessus sans changer de majeure (souvent celle
+    qui corrige), sinon la plus haute en dessous, sinon la plus petite au-dessus. Parmi les
+    candidates seulement (pas de pré-version, sauf celles de ``current`` si c'en est une).
+    ``None`` s'il n'y en a aucune."""
+    above, below = [], []
+    for version in scheme.candidates(choices, current):
+        order = scheme.compare(version, current)
+        if order > 0:
+            above.append(version)
+        elif order < 0:
+            below.append(version)
+    above.sort(key=scheme.sort_key)
+    same_line = [v for v in above if scheme.gap(current, v) is not Gap.MAJOR]
+    if same_line:
+        return same_line[0]
+    if below:
+        return max(below, key=scheme.sort_key)
+    return above[0] if above else None

forceupdate/checks/deprecated.py

@@ -0,0 +1,115 @@
+"""Type 4 du brief : le paquet est abandonné ou déprécié, la version utilisée est retirée.
+
+- **paquet déprécié** (``PackageInfo.deprecated``) : projet PyPI archivé ou déprécié, paquet
+  npm dont la ``latest`` est dépréciée, ou retiré par l'équipe sécurité de npm. Signalé, sans
+  version à proposer : le remplacer est un choix humain ;
+- **version retirée** (PyPI, ``yanked``), avec la raison donnée : à remplacer par la plus
+  proche non retirée (``checks.base.nearest``) ;
+- **version dépréciée** (npm, qui n'a pas de retrait : c'est sa façon de désavouer une version,
+  lodash 4.18.0 « Bad release ») : à remplacer par la plus proche non dépréciée. Quand tout le
+  paquet est déprécié, seul le paquet est signalé ;
+- **version inconnue du registre** : dépubliée, ou venue d'un autre index. On ne peut pas dire
+  si elle est retirée : « non concluant ».
+
+Seule une version connue est examinée : l'installée, ou celle qu'impose une contrainte exacte.
+Une borne basse (``>=2.32.0``) ne dit pas qu'on utilise ``2.32.0``.
+"""
+
+from forceupdate import versions
+from forceupdate.checks.base import Current, nearest, sentence
+from forceupdate.models import Dependency, Finding, FindingKind, Gap, Severity
+from forceupdate.registries import PackageInfo
+from forceupdate.versions import InvalidVersion
+
+
+def check(dependency: Dependency, info: PackageInfo, current: Current) -> list[Finding]:
+    """Les constats « déprécié » et « retiré » de ``dependency`` ; une liste vide s'il n'y a
+    rien à signaler."""
+    findings = []
+    common = {
+        "dependency": dependency,
+        "current_version": current.version,
+        "current_is_approximate": current.approximate,
+        "url": info.url,
+    }
+    if info.deprecated is not None:
+        findings.append(
+            Finding(
+                kind=FindingKind.DEPRECATED,
+                severity=Severity.LOW,
+                message=f"Paquet déprécié : {info.deprecated}",
+                detail=info.deprecated,
+                **common,
+            )
+        )
+    if current.version is None or current.approximate:
+        return findings
+    registry = dependency.ecosystem.value
+    published = info.get(current.version)
+    if published is None:
+        findings.append(
+            Finding(
+                kind=FindingKind.INCONCLUSIVE,
+                message=(
+                    f"Version {current.version} inconnue de {registry} : dépubliée, ou venue "
+                    f"d'un autre index. Impossible de dire si elle est retirée."
+                ),
+                **common,
+            )
+        )
+        return findings
+    scheme = versions.for_ecosystem(dependency.ecosystem)
+    if published.yanked:
+        target = _nearest(scheme, current.version, info.available())
+        reason = f" : {published.yanked_reason}" if published.yanked_reason else ""
+        reason = sentence(f"Version {current.version} retirée de {registry}{reason}")
+        replacement = (
+            f"La plus proche non retirée : {target}."
+            if target is not None
+            else "Aucune version non retirée à proposer."
+        )
+        findings.append(
+            Finding(
+                kind=FindingKind.YANKED,
+                severity=Severity.MEDIUM,
+                message=f"{reason} {replacement}",
+                target_version=target,
+                gap=_gap(scheme, current.version, target),
+                detail=published.yanked_reason,
+                **common,
+            )
+        )
+    elif published.deprecated is not None and info.deprecated is None:
+        fresh = [v.version for v in info.versions if not v.yanked and v.deprecated is None]
+        target = _nearest(scheme, current.version, fresh)
+        replacement = (
+            f"La plus proche non dépréciée : {target}."
+            if target is not None
+            else "Aucune version non dépréciée à proposer."
+        )
+        findings.append(
+            Finding(
+                kind=FindingKind.DEPRECATED,
+                severity=Severity.LOW,
+                message=(
+                    sentence(f"Version {current.version} dépréciée : {published.deprecated}")
+                    + f" {replacement}"
+                ),
+                target_version=target,
+                gap=_gap(scheme, current.version, target),
+                detail=published.deprecated,
+                **common,
+            )
+        )
+    return findings
+
+
+def _nearest(scheme: versions.VersionScheme, current: str, choices: list[str]) -> str | None:
+    try:
+        return nearest(scheme, current, choices)
+    except InvalidVersion:  # version utilisée illisible : outdated le dit déjà
+        return None
+
+
+def _gap(scheme: versions.VersionScheme, current: str, target: str | None) -> Gap | None:
+    return None if target is None else scheme.gap(current, target)

forceupdate/checks/outdated.py

@@ -0,0 +1,183 @@
+"""Type 1 du brief : une version plus récente existe.
+
+Pour une dépendance, trois versions, comme ``npm outdated`` :
+
+- **utilisée** : la version actuelle (``checks.base.current_version``) ;
+- **dans la contrainte** (``wanted_version``) : la plus haute que la contrainte accepte déjà.
+  On y monte en régénérant le lockfile, sans toucher au manifeste ;
+- **dernière** (``target_version``) : la dernière stable du registre (``PackageInfo.latest``),
+  à deux précisions près, prises à ``npm outdated`` :
+
+  - si elle est dépréciée, la plus haute non dépréciée qui ne la dépasse pas, s'il y en a :
+    ``@types/parse-json`` 7.0.0 est un paquet vide déprécié, on ne le propose pas à qui a la
+    4.0.2. Le paquet déprécié est signalé à part (``deprecated.py``) ;
+  - si la version utilisée est une pré-version, une pré-version plus récente de la même version
+    compte aussi (de ``2.0.0-rc.1``, on propose ``2.0.0-rc.2``), et l'étiquette ``latest`` de
+    npm même si c'est une pré-version : chromium-bidi publie ainsi toutes ses versions
+    (``158.0.8127-2``).
+
+Le constat porte l'écart entre la version utilisée et la dernière. Une version utilisée au-
+dessus de la dernière (la voie ``next`` de npm) ne donne rien.
+
+``npm outdated`` écarte aussi les versions que le Node installé ne peut pas faire tourner
+(``engines``) : jsdom 30 demande Node ``^24.15.0``, il ne la propose pas sous Node 24.12.
+forceupdate ne connaît pas le Node de la machine (ni celui d'un dépôt distant), et la propose.
+
+**Dans la contrainte, pour npm (tranché à E07)** : on choisit comme ``npm install`` et
+``npm outdated`` (``npm-pick-manifest``), pas simplement la plus haute qui respecte la plage.
+La version de l'étiquette ``latest`` si la plage l'accepte et qu'elle n'est pas dépréciée ;
+sinon la plus haute non dépréciée ; sinon la plus haute. Une plage ``>=4`` donne donc la
+``latest`` 4.17.21, pas une 5.0.0 publiée sous ``next``. Une étiquette (``"react": "next"``)
+donne sa version. PyPI : la plus haute non retirée qui respecte la contrainte, comme pip.
+"""
+
+from forceupdate import versions
+from forceupdate.checks.base import GAP_LABELS, Current
+from forceupdate.models import Dependency, Ecosystem, Finding, FindingKind, Gap, Severity
+from forceupdate.registries import PackageInfo
+from forceupdate.versions import InvalidVersion, VersionScheme
+from forceupdate.versions.npm import NPM, NpmRange
+
+
+def check(dependency: Dependency, info: PackageInfo, current: Current) -> list[Finding]:
+    """Le constat « plus récente » de ``dependency`` ; une liste vide si elle est à jour, ou
+    si le registre n'a rien à proposer (pas de dernière stable)."""
+    scheme = versions.for_ecosystem(dependency.ecosystem)
+    if current.version is not None:
+        try:
+            scheme.parse(current.version)
+        except InvalidVersion:
+            return [
+                Finding(
+                    kind=FindingKind.INCONCLUSIVE,
+                    message=(
+                        f"Version « {current.version} » illisible selon les règles de "
+                        f"{dependency.ecosystem} : impossible de la comparer."
+                    ),
+                    dependency=dependency,
+                    current_version=current.version,
+                    url=info.url,
+                )
+            ]
+    target = _target(scheme, info, current.version)
+    if target is None:
+        return []
+    wanted = wanted_version(dependency, info, current)
+    if current.version is None:
+        return [
+            Finding(
+                kind=FindingKind.INCONCLUSIVE,
+                message=f"Version utilisée inconnue : {current.unknown}. Dernière : {target}.",
+                dependency=dependency,
+                target_version=target,
+                wanted_version=wanted,
+                url=info.url,
+            )
+        ]
+    gap = scheme.gap(current.version, target)
+    if gap is None:
+        return []
+    return [
+        Finding(
+            kind=FindingKind.OUTDATED,
+            severity=Severity.LOW if gap is Gap.MAJOR else Severity.INFO,
+            message=_message(scheme, current, target, gap, wanted),
+            dependency=dependency,
+            current_version=current.version,
+            current_is_approximate=current.approximate,
+            target_version=target,
+            wanted_version=wanted,
+            gap=gap,
+            url=info.url,
+        )
+    ]
+
+
+def wanted_version(dependency: Dependency, info: PackageInfo, current: Current) -> str | None:
+    """La plus haute version que la contrainte accepte déjà, choisie comme le ferait le
+    gestionnaire de paquets ; ``None`` pour une dépendance indirecte (sa contrainte est celle
+    du paquet qui la tire) ou une contrainte illisible."""
+    if not dependency.direct or current.constraint is None:
+        return None
+    scheme = versions.for_ecosystem(dependency.ecosystem)
+    constraint = scheme.parse_constraint(current.constraint)
+    if isinstance(constraint, NpmRange) and constraint.tag is not None:
+        return info.tags.get(constraint.tag)
+    if dependency.ecosystem is Ecosystem.NPM:
+        return _npm_wanted(current.constraint, info, current.version)
+    return scheme.max_satisfying(current.constraint, info.available(), current.version)
+
+
+def _npm_wanted(constraint: str, info: PackageInfo, current: str | None) -> str | None:
+    """Le choix de ``npm-pick-manifest`` pour une plage (voir la docstring du module)."""
+    tagged = info.tags.get("latest")
+    published = None if tagged is None else info.get(tagged)
+    if published is not None and published.deprecated is None:
+        try:
+            if NPM.satisfies(constraint, published.version):
+                return published.version
+        except InvalidVersion:
+            pass
+    fresh = [v.version for v in info.versions if not v.yanked and v.deprecated is None]
+    return NPM.max_satisfying(constraint, fresh, current) or NPM.max_satisfying(
+        constraint, info.available(), current
+    )
+
+
+def _target(scheme: VersionScheme, info: PackageInfo, current: str | None) -> str | None:
+    """La version à proposer (voir la docstring du module)."""
+    target = info.latest
+    published = None if target is None else info.get(target)
+    if target is not None and published is not None and published.deprecated is not None:
+        ceiling = scheme.sort_key(target)
+        fresh = [
+            v.version
+            for v in info.versions
+            if not v.yanked and v.deprecated is None and scheme.sort_key(v.version) <= ceiling
+        ]
+        target = scheme.latest(fresh) or target
+    if current is None or not scheme.is_prerelease(current):
+        return target
+    line = [v for v in scheme.candidates(info.available(), current) if scheme.is_prerelease(v)]
+    for option in (scheme.latest(line, current), _prerelease_tag(scheme, info, current)):
+        if option is not None and (target is None or scheme.compare(option, target) > 0):
+            target = option
+    return target
+
+
+def _prerelease_tag(scheme: VersionScheme, info: PackageInfo, current: str) -> str | None:
+    """L'étiquette ``latest`` de npm si c'est une pré-version plus récente que ``current``, non
+    dépréciée ; ``None`` sinon."""
+    tagged = info.tags.get("latest")
+    if tagged is None:
+        return None
+    published = info.get(tagged)
+    if published is None or published.yanked or published.deprecated is not None:
+        return None
+    try:
+        if scheme.is_prerelease(tagged) and scheme.compare(tagged, current) > 0:
+            return tagged
+    except InvalidVersion:
+        pass
+    return None
+
+
+def _message(
+    scheme: VersionScheme, current: Current, target: str, gap: Gap, wanted: str | None
+) -> str:
+    assert current.version is not None
+    if current.approximate:
+        used = f"au moins {current.version} d'après la contrainte (pas de version installée)"
+    else:
+        used = current.version
+    text = f"Version {target} disponible ({GAP_LABELS[gap]}) ; utilisée : {used}."
+    if wanted is None:
+        return text
+    try:
+        if scheme.compare(wanted, target) == 0:
+            text += " La contrainte l'accepte déjà."
+        elif scheme.compare(wanted, current.version) > 0:
+            text += f" La contrainte accepte jusqu'à {wanted}."
+    except InvalidVersion:  # une étiquette npm qui pointe vers une version illisible
+        pass
+    return text

forceupdate/checks/priority.py

@@ -0,0 +1,82 @@
+"""L'ordre des constats, et le seuil qui fait échouer ``scan --fail-on``.
+
+L'ordre est celui du brief (décision n°8) : faille (par sévérité) > fin de vie > retiré >
+déprécié > majeure > mineure > correctif. Viennent ensuite ce qui n'a pas pu être vérifié
+(non vérifiable), puis ce qui n'a rien conclu (non concluant).
+
+**Gravité des constats autres que les failles (tranché à E07)**. Une faille a celle de son
+avis (CVSS, E08). Pour les autres, elle sert à l'affichage ; l'ordre, lui, suit le type :
+
+- version retirée : ``MEDIUM`` (ses mainteneurs l'ont retirée, souvent parce qu'elle casse
+  ou qu'elle est dangereuse) ;
+- paquet ou version déprécié : ``LOW`` ;
+- version plus récente : ``LOW`` pour une majeure, ``INFO`` pour une mineure ou un correctif ;
+- non vérifiable, non concluant : ``INFO``.
+
+Un paquet malveillant retiré par npm (crossenv) est aussi une faille critique : OSV le connaît
+(``checks.vulns``).
+"""
+
+import enum
+from collections.abc import Iterable
+
+from forceupdate.models import Finding, FindingKind, Gap
+
+_KIND_ORDER = {
+    FindingKind.VULNERABLE: 0,
+    FindingKind.EOL: 1,
+    FindingKind.YANKED: 2,
+    FindingKind.DEPRECATED: 3,
+    FindingKind.OUTDATED: 4,
+    FindingKind.UNVERIFIABLE: 5,
+    FindingKind.INCONCLUSIVE: 6,
+}
+
+
+def priority(finding: Finding) -> tuple[int, int]:
+    """La clé de tri d'un constat : la plus petite pour le plus grave."""
+    rank = _KIND_ORDER[finding.kind]
+    if finding.kind in (FindingKind.VULNERABLE, FindingKind.EOL):
+        return rank, -finding.severity.rank
+    if finding.kind is FindingKind.OUTDATED and finding.gap is not None:
+        return rank, -finding.gap.rank
+    return rank, 0
+
+
+def sort_findings(findings: Iterable[Finding]) -> list[Finding]:
+    """Les constats du plus grave au moins grave ; à gravité égale, par nom de paquet."""
+    return sorted(findings, key=_sort_key)
+
+
+def _sort_key(finding: Finding) -> tuple[tuple[int, int], str]:
+    name = finding.dependency.name if finding.dependency is not None else ""
+    return priority(finding), name
+
+
+class FailOn(enum.StrEnum):
+    """Le seuil de ``scan --fail-on`` : à partir de quel constat l'analyse échoue (code 1)."""
+
+    VULN = "vuln"
+    """Une faille."""
+    MAJOR = "major"
+    """Une faille, une fin de vie, une version retirée, un paquet ou une version déprécié, une
+    version majeure plus récente : tout ce qui précède les mineures dans l'ordre du brief."""
+    ANY = "any"
+    """Tout ce qui est à mettre à jour, mineures et correctifs compris. Ce qui n'a pas pu être
+    vérifié ou n'a rien conclu ne compte jamais."""
+
+
+def reaches(finding: Finding, threshold: FailOn) -> bool:
+    """Vrai si ``finding`` atteint le seuil ``threshold``."""
+    if threshold is FailOn.VULN:
+        return finding.kind is FindingKind.VULNERABLE
+    if finding.kind in (FindingKind.UNVERIFIABLE, FindingKind.INCONCLUSIVE):
+        return False
+    if threshold is FailOn.ANY:
+        return True
+    return priority(finding) <= (_KIND_ORDER[FindingKind.OUTDATED], -Gap.MAJOR.rank)
+
+
+def fails(findings: Iterable[Finding], threshold: FailOn) -> bool:
+    """Vrai si un des constats atteint le seuil."""
+    return any(reaches(finding, threshold) for finding in findings)

forceupdate/checks/vulns.py

@@ -0,0 +1,201 @@
+"""Type 2 du brief : la version utilisée a une faille connue.
+
+Les failles se cherchent sur toutes les dépendances vérifiables, indirectes comprises (brief,
+décision n°3), quelle que soit ``--transitive``, qui ne vaut que pour les versions plus
+récentes et les retraits ; celles de développement sauf avec ``--no-dev``. C'est le moteur qui
+interroge OSV (``advisories``) ; ce module en tire les constats.
+
+- **Une faille, un constat.** OSV a souvent plusieurs avis pour la même faille : celui de
+  GitHub (GHSA) et celui de PyPI (PYSEC), qui se citent l'un l'autre dans leurs alias. Ils
+  sont réunis, avec tous leurs identifiants : les CVE d'abord, puis les GHSA, puis les autres.
+  Les avis d'un paquet malveillant sont tous réunis : ils disent la même chose.
+- **Gravité** : celle du plus grave des avis réunis (CVSS 3, sinon celle de GitHub). Un paquet
+  malveillant est toujours critique. Sans rien pour en juger, moyenne : le message dit
+  « gravité inconnue ».
+- **Version corrigée** (``target_version``) : la plus petite qui corrige la faille au-dessus de
+  la version utilisée (``Advisory.fixed_in``) ; si les avis réunis ne sont pas d'accord, la
+  plus haute des leurs.
+- **Version utilisée** : l'installée, ou celle d'une contrainte exacte. Sans lockfile, la
+  borne basse de la contrainte, « approximative » : la faille n'est alors que **possible**
+  (affichée « faille possible »), car la version réellement installée peut être plus récente,
+  et corrigée. Elle reste une faille, et compte pour ``--fail-on vuln`` : la contrainte
+  accepte une version concernée, et la relever la corrige. Sans version utilisée (``*``, une
+  étiquette npm), rien n'est demandé à OSV ; le contrôle « plus récente » le dit déjà.
+- **Erreur** : jamais « pas de faille ». Une version qu'OSV n'a pas pu examiner donne un
+  constat « non concluant » (``unchecked``) ; un avis illisible reste une faille, de gravité et
+  de version corrigée inconnues.
+"""
+
+from collections.abc import Sequence
+
+from forceupdate import versions
+from forceupdate.advisories import Advisory, OsvError, Vulnerabilities
+from forceupdate.checks.base import Current, current_version, sentence
+from forceupdate.models import Dependency, Finding, FindingKind, ScanOptions, Scope, Severity
+
+SEVERITY_LABELS = {
+    Severity.CRITICAL: "critique",
+    Severity.HIGH: "élevée",
+    Severity.MEDIUM: "moyenne",
+    Severity.LOW: "faible",
+    Severity.INFO: "nulle",
+}
+"""La gravité d'une faille en français, telle qu'on l'affiche."""
+
+_PREFIXES = ("CVE-", "GHSA-")
+"""Les identifiants qu'on cite dans le message, et qui passent en tête de ``identifiers``."""
+
+
+def audited(dependency: Dependency, options: ScanOptions) -> bool:
+    """Vrai si l'analyse cherche les failles de ``dependency`` : vérifiable, directe ou non ;
+    de développement seulement avec ``options.dev``. Encore faut-il connaître sa version
+    (``version_to_check``)."""
+    return dependency.verifiable and (options.dev or dependency.scope is not Scope.DEV)
+
+
+def version_to_check(dependency: Dependency) -> Current | None:
+    """La version actuelle de ``dependency``, à soumettre à OSV ; ``None`` si on ne la connaît
+    pas, ou si les versions de son écosystème ne sont pas encore gérées."""
+    try:
+        current = current_version(dependency)
+    except LookupError:
+        return None
+    return current if current.version is not None else None
+
+
+def check(dependency: Dependency, current: Current, found: Vulnerabilities) -> list[Finding]:
+    """Les failles de ``dependency`` en version ``current``, d'après ce qu'OSV en dit
+    (``found``) : un constat par faille, les plus graves d'abord (gravité, puis score CVSS).
+    Une liste vide s'il n'y en a pas."""
+    findings = [_finding(dependency, current, group) for group in _groups(found.advisories)]
+    return sorted(findings, key=lambda f: (-f.severity.rank, -(f.cvss_score or 0), f.identifiers))
+
+
+def unchecked(dependency: Dependency, current: Current, error: OsvError) -> Finding:
+    """Le constat « non concluant » de ``dependency`` quand OSV n'a pas pu dire quelles failles
+    concernent sa version."""
+    return Finding(
+        kind=FindingKind.INCONCLUSIVE,
+        message=f"Failles non vérifiées. {error}",
+        dependency=dependency,
+        current_version=current.version,
+        current_is_approximate=current.approximate,
+    )
+
+
+def _groups(advisories: Sequence[Advisory]) -> list[list[Advisory]]:
+    """Les avis réunis par faille : ceux qui partagent un identifiant (le leur, ou un alias),
+    de proche en proche ; et tous ceux d'un paquet malveillant ensemble. Les avis retirés
+    sont écartés."""
+    groups: list[tuple[set[str], list[Advisory]]] = []
+    malicious = []
+    for advisory in advisories:
+        if advisory.withdrawn:
+            continue
+        if advisory.malicious:
+            malicious.append(advisory)
+            continue
+        names = {advisory.id, *advisory.aliases}
+        members = [advisory]
+        kept = []
+        for group_names, group in groups:
+            if group_names & names:
+                names |= group_names
+                members = group + members
+            else:
+                kept.append((group_names, group))
+        groups = [*kept, (names, members)]
+    found = [group for _, group in groups]
+    if malicious:
+        found.append(malicious)
+    return found
+
+
+def _finding(dependency: Dependency, current: Current, group: list[Advisory]) -> Finding:
+    assert current.version is not None
+    scheme = versions.for_ecosystem(dependency.ecosystem)
+    known = [advisory for advisory in group if advisory.unavailable is None]
+    identifiers = _identifiers(group)
+    shown = ", ".join([i for i in identifiers if i.startswith(_PREFIXES)] or identifiers[:1])
+    malicious = any(advisory.malicious for advisory in group)
+    severities = [a.severity for a in known if a.severity is not None]
+    score = max((a.score for a in known if a.score is not None), default=None)
+    if malicious:
+        severity = Severity.CRITICAL
+    elif severities:
+        severity = max(severities, key=lambda s: s.rank)
+    else:
+        severity = Severity.MEDIUM
+    fixes = [
+        fix
+        for advisory in known
+        if (fix := advisory.fixed_in(dependency.ecosystem, dependency.name, current.version))
+    ]
+    target = max(fixes, key=scheme.sort_key) if fixes else None
+    main = min(group, key=_main_order)
+    summary = next((a.summary for a in sorted(group, key=_main_order) if a.summary), "")
+
+    if not known:
+        reasons = "; ".join(dict.fromkeys(a.unavailable or "" for a in group))
+        message = (
+            f"{shown} : détail de l'avis indisponible ({reasons}) ; gravité et version corrigée "
+            "inconnues."
+        )
+    else:
+        if malicious:
+            head = f"Code malveillant ({shown})"
+        elif severities:
+            cvss = "" if score is None else f", CVSS {score:.1f}".replace(".", ",")
+            head = f"{shown} (gravité {SEVERITY_LABELS[severity]}{cvss})"
+        else:
+            head = f"{shown} (gravité inconnue)"
+        message = sentence(f"{head} : {summary}" if summary else head)
+        if target is not None:
+            message += f" Corrigée en {target}."
+        elif malicious:
+            message += " Retirer ce paquet : aucune version sûre connue."
+        else:
+            message += " Aucune version corrigée connue."
+    if current.approximate:
+        message += (
+            f" Faille possible : {current.version} est la borne basse de « "
+            f"{dependency.effective_constraint} », faute de lockfile ; la version installée peut "
+            "être plus récente."
+        )
+    return Finding(
+        kind=FindingKind.VULNERABLE,
+        severity=severity,
+        message=message,
+        dependency=dependency,
+        current_version=current.version,
+        current_is_approximate=current.approximate,
+        target_version=target,
+        gap=None if target is None else scheme.gap(current.version, target),
+        identifiers=identifiers,
+        cvss_score=score,
+        detail=summary or None,
+        url=main.url,
+    )
+
+
+def _identifiers(group: list[Advisory]) -> tuple[str, ...]:
+    """Les identifiants des avis et leurs alias, sans doublon : les CVE, puis les GHSA, puis
+    les autres, chacun dans l'ordre alphabétique."""
+    found = {name for advisory in group for name in (advisory.id, *advisory.aliases)}
+
+    def order(name: str) -> tuple[int, str]:
+        rank = next((i for i, p in enumerate(_PREFIXES) if name.startswith(p)), len(_PREFIXES))
+        return rank, name
+
+    return tuple(sorted(found, key=order))
+
+
+def _main_order(advisory: Advisory) -> tuple[bool, bool, bool, str]:
+    """L'avis qui représente la faille (son lien, son titre) : un avis lu, de GitHub de
+    préférence (ils ont un titre), avec un titre."""
+    return (
+        advisory.unavailable is not None,
+        not advisory.id.startswith("GHSA-"),
+        not advisory.summary,
+        advisory.id,
+    )