CSlawyer1985/legal-skillhub / skills/assistant-juridique-fr
assistant-juridique-fr
Unverified法国法领域的法律助理专家。法律研究、法律咨询、法律文书起草、反论证、合同与文件分析、法律动态跟踪、参考文献核验与统一。生成 Word 文档(computer use)或结构化的对话式答复。MCP:OpenLegi、Themia、LegalDataHunter。任何法律问题、任何法国法概念(合同、责任、判例、民法典、法院、损害赔偿)、任何关于欧盟法、欧洲法院(CJUE)或欧洲人权法院(CEDH)的问题,以及任何法国法律参考文献核验或统一的请求,均触发本技能。
scripts/verify_links.py
View on GitHub#!/usr/bin/env python3
"""
verify_links.py — Vérification batch d'URLs juridiques (Légifrance, HUDOC, Curia).
Vérifications effectuées pour chaque URL :
1. Correspondance à un pattern officiel reconnu (JURITEXT, CETATEXT,
JORFTEXT, LEGIARTI, LEGITEXT, conseil-constitutionnel.fr, hudoc,
curia, eur-lex).
2. Accessibilité HTTP (HEAD).
3. En mode --check-content (activé par défaut), récupération de la page
(GET) et vérification que le numéro de pourvoi / numéro d'article /
mot-clé attendu apparaît dans le contenu.
Modes de fonctionnement :
- --preflight : teste l'état de la sortie réseau et l'accès à
Légifrance, sans vérifier d'URL. Distingue désormais quatre cas :
réseau OK (0), bloqué par allowlist Cowork (2), erreur réseau
générique (3), bloqué par challenge anti-bot Cloudflare (4).
- --extract-ids : lit une liste d'URLs (ou un texte brut via
--extract-ids-from-text) et retourne les identifiants Légifrance
reconnus (LEGIARTI, JURITEXT, CETATEXT, JORFTEXT, JORFARTI,
LEGITEXT, CNILTEXT, KALITEXT) avec, pour chacun, le nom de
l'outil OpenLegi à appeler pour vérifier son existence par API.
Conçu pour les sandbox où Légifrance est inaccessible (Cloudflare
ou allowlist) : la vérification est déléguée à OpenLegi par
l'agent.
- --strict : code de retour ≠ 0 si au moins une URL est invalide
(pattern non reconnu, inaccessible, contenu non concordant).
- --check-content / --no-check-content : (dés)activer la vérification
du contenu (par défaut : activée).
Format d'entrée :
Une liste JSON dont chaque élément est :
- soit une chaîne (URL seule, sans vérification de contenu) ;
- soit un objet { "url": "...", "expected_number": "...",
"expected_keyword": "..." }
Les champs expected_* sont facultatifs et déclenchent la
vérification de contenu si --check-content est actif.
Usage :
python3 scripts/verify_links.py --urls '[{"url": "https://...",
"expected_number": "21-12.345"}]'
python3 scripts/verify_links.py --from-file urls.json --strict
python3 scripts/verify_links.py --from-file urls.json --no-check-content
Sortie : JSON avec, pour chaque URL :
url, type_legifrance, pattern_valide, status, accessible,
content_match (true / false / null si non vérifié),
content_match_detail, error.
Code de retour : 0 si tout passe (ou si --strict est désactivé), sinon 1.
"""
import argparse
import json
import re
import sys
import urllib.request
import urllib.error
import concurrent.futures
TIMEOUT_HEAD = 10
TIMEOUT_GET = 20
MAX_WORKERS = 5
USER_AGENT = "Legal-Link-Checker/2.0"
MAX_CONTENT_BYTES = 1_500_000 # plafond de lecture pour --check-content
# URL Légifrance utilisée par le mode --preflight pour détecter
# l'accès réseau. Référence stable : article 1242 du Code civil
# (CID LEGIARTI000006437058, en vigueur).
PREFLIGHT_URL = (
"https://www.legifrance.gouv.fr/codes/article_lc/LEGIARTI000006437058"
)
# URL secondaire utilisée par --preflight pour qualifier la sortie réseau
# indépendamment de Légifrance. EUR-Lex est sélectionné car il est sur la
# liste des cinq domaines officiels recommandés et ne pratique pas, à la
# date de cette skill, de challenge anti-bot.
EGRESS_TEST_URL = "https://eur-lex.europa.eu/"
# Correspondance entre le type d'identifiant Légifrance et l'outil
# OpenLegi à appeler pour vérifier son existence par API. Utilisée par
# --extract-ids pour produire les instructions destinées à l'agent.
LEGIFRANCE_TYPE_TO_OPENLEGI_TOOL = {
"JURITEXT": {
"tool": "OpenLegi:get_decision_judiciaire",
"argument": "identifiant",
"verification": (
"Appeler get_decision_judiciaire avec l'identifiant et "
"vérifier que la juridiction, la date et le numéro d'affaire "
"correspondent à ce qui est cité dans le livrable."
),
},
"CETATEXT": {
"tool": "OpenLegi:get_decision_administrative",
"argument": "identifiant",
"verification": (
"Appeler get_decision_administrative avec l'identifiant et "
"vérifier que la juridiction, la date et le numéro de "
"requête correspondent."
),
},
"CNILTEXT": {
"tool": "OpenLegi:get_decision_cnil",
"argument": "identifiant",
"verification": (
"Appeler get_decision_cnil avec l'identifiant et vérifier "
"que la décision correspond."
),
},
"LEGIARTI_CODE": {
"tool": "OpenLegi:rechercher_code",
"argument": "search=<numéro article>, code_name=<code>, champ='NUM_ARTICLE'",
"verification": (
"Appeler rechercher_code avec le numéro d'article et le nom "
"exact du code. Vérifier que le CID retourné par OpenLegi "
"correspond à l'identifiant LEGIARTI cité, et que l'état "
"juridique est VIGUEUR à la date pertinente (champs "
"date_debut_vigueur / date_fin_vigueur)."
),
},
"LEGIARTI_LODA": {
"tool": "OpenLegi:rechercher_dans_texte_legal",
"argument": "identifiant texte (LEGITEXT) + numéro article",
"verification": (
"Identifier d'abord le LEGITEXT parent du texte, puis "
"appeler rechercher_dans_texte_legal pour vérifier que "
"l'article LEGIARTI cité existe et est en vigueur."
),
},
"LEGITEXT_CODE": {
"tool": "OpenLegi:lister_codes_juridiques",
"argument": "(aucun)",
"verification": (
"Vérifier que le LEGITEXT cité figure dans la liste des "
"codes retournée par lister_codes_juridiques."
),
},
"LEGITEXT_LODA": {
"tool": "OpenLegi:rechercher_dans_texte_legal",
"argument": "identifiant texte (LEGITEXT)",
"verification": (
"Appeler rechercher_dans_texte_legal sur le LEGITEXT cité "
"et vérifier que la réponse n'est pas vide."
),
},
"JORFTEXT": {
"tool": "OpenLegi:recherche_journal_officiel",
"argument": "search=<référence loi/décret>",
"verification": (
"Appeler recherche_journal_officiel avec la référence du "
"texte (numéro et date) et vérifier que l'identifiant "
"JORFTEXT retourné correspond."
),
},
"JORFARTI": {
"tool": "OpenLegi:recherche_journal_officiel",
"argument": "search=<référence loi/décret + n° article>",
"verification": (
"Appeler recherche_journal_officiel avec la référence du "
"texte et l'article cité, vérifier que l'identifiant "
"JORFARTI retourné correspond."
),
},
"KALITEXT": {
"tool": "OpenLegi:rechercher_conventions_collectives",
"argument": "search=<intitulé convention>",
"verification": (
"Appeler rechercher_conventions_collectives avec "
"l'intitulé de la convention et vérifier que l'identifiant "
"KALITEXT retourné correspond."
),
},
}
# ─────────────────────────────────────────────────────────────────────────────
# Patterns d'URL reconnus
# ─────────────────────────────────────────────────────────────────────────────
LEGIFRANCE_PATTERNS = [
# Jurisprudence judiciaire (Cour de cassation, cours d'appel)
("JURITEXT", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/juri/id/JURITEXT\d+/?$"
, re.IGNORECASE)),
# Jurisprudence administrative (Conseil d'État, CAA, TA)
("CETATEXT", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/ceta/id/CETATEXT\d+/?$"
, re.IGNORECASE)),
# Articles de codes
("LEGIARTI_CODE", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/codes/article_lc/LEGIARTI\d+/?$"
, re.IGNORECASE)),
# Articles de textes consolidés (LODA)
("LEGIARTI_LODA", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/loda/article_lc/LEGIARTI\d+/?$"
, re.IGNORECASE)),
# Textes consolidés (LODA, niveau texte)
("LEGITEXT_LODA", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/loda/id/LEGITEXT\d+/?$"
, re.IGNORECASE)),
# Codes (niveau code)
("LEGITEXT_CODE", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/codes/texte_lc/LEGITEXT\d+/?$"
, re.IGNORECASE)),
# Textes JORF
("JORFTEXT", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/jorf/id/JORFTEXT\d+/?$"
, re.IGNORECASE)),
# Articles JORF
("JORFARTI", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/jorf/article_jo/JORFARTI\d+/?$"
, re.IGNORECASE)),
# Décisions CNIL
("CNILTEXT", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/cnil/id/CNILTEXT\d+/?$"
, re.IGNORECASE)),
# Conventions collectives (KALI)
("KALITEXT", re.compile(
r"^https?://www\.legifrance\.gouv\.fr/conv_coll/id/KALITEXT\d+/?$"
, re.IGNORECASE)),
]
EXTERNAL_OFFICIAL_PATTERNS = [
# Conseil constitutionnel (site officiel)
("CONSEIL_CONSTITUTIONNEL", re.compile(
r"^https?://(?:www\.)?conseil-constitutionnel\.fr/decision/\d{4}/"
r"\d+(?:[A-Z]+)?\.htm$"
)),
# CEDH (HUDOC)
("HUDOC_CEDH", re.compile(
r"^https?://hudoc\.echr\.coe\.int/(?:eng|fre)\??.*$"
, re.IGNORECASE)),
# CJUE (Curia)
("CURIA_CJUE", re.compile(
r"^https?://curia\.europa\.eu/juris/.+$"
, re.IGNORECASE)),
# EUR-Lex (textes UE)
("EUR_LEX", re.compile(
r"^https?://eur-lex\.europa\.eu/.+$"
, re.IGNORECASE)),
]
ALL_PATTERNS = LEGIFRANCE_PATTERNS + EXTERNAL_OFFICIAL_PATTERNS
def identify_pattern(url):
"""Retourne (type, valide) pour une URL donnée.
Si l'URL ne matche aucun pattern, retourne (None, False).
"""
if not isinstance(url, str):
return (None, False)
for type_name, pattern in ALL_PATTERNS:
if pattern.match(url):
return (type_name, True)
return (None, False)
# ─────────────────────────────────────────────────────────────────────────────
# Vérification HTTP
# ─────────────────────────────────────────────────────────────────────────────
def head_check(url):
"""Effectue un HEAD. Retourne (status, accessible, error)."""
try:
req = urllib.request.Request(
url,
method="HEAD",
headers={"User-Agent": USER_AGENT}
)
with urllib.request.urlopen(req, timeout=TIMEOUT_HEAD) as response:
return (response.getcode(), True, None)
except urllib.error.HTTPError as e:
# 405 (Method Not Allowed) : certains serveurs n'acceptent pas HEAD,
# on bascule sur GET court.
if e.code == 405:
return get_status_only(url)
return (e.code, e.code < 400, f"HTTP {e.code}: {e.reason}")
except urllib.error.URLError as e:
return (None, False, f"URL Error: {e.reason}")
except Exception as e:
return (None, False, str(e))
def get_status_only(url):
"""GET court (sans lecture du corps) en repli si HEAD est refusé."""
try:
req = urllib.request.Request(
url,
method="GET",
headers={"User-Agent": USER_AGENT}
)
with urllib.request.urlopen(req, timeout=TIMEOUT_HEAD) as response:
return (response.getcode(), True, None)
except urllib.error.HTTPError as e:
return (e.code, e.code < 400, f"HTTP {e.code}: {e.reason}")
except urllib.error.URLError as e:
return (None, False, f"URL Error: {e.reason}")
except Exception as e:
return (None, False, str(e))
def fetch_content(url):
"""Récupère le contenu HTML (plafond MAX_CONTENT_BYTES)."""
try:
req = urllib.request.Request(
url,
method="GET",
headers={"User-Agent": USER_AGENT}
)
with urllib.request.urlopen(req, timeout=TIMEOUT_GET) as response:
raw = response.read(MAX_CONTENT_BYTES)
charset = response.headers.get_content_charset() or "utf-8"
try:
return raw.decode(charset, errors="replace")
except LookupError:
return raw.decode("utf-8", errors="replace")
except Exception:
return None
# ─────────────────────────────────────────────────────────────────────────────
# Vérification de contenu
# ─────────────────────────────────────────────────────────────────────────────
def normalize_for_search(text):
"""Normalise le texte pour la recherche : minuscules, suppression des
points et tirets dans les numéros, espaces normalisés."""
if not text:
return ""
text = text.lower()
# Pour les numéros de pourvoi : supprimer les points et tirets
text = re.sub(r"[ \s]+", " ", text)
return text
def number_variants(number):
"""Retourne plusieurs variantes d'un numéro de pourvoi / d'article.
Exemple pour "21-12.345" : ["21-12.345", "2112345", "21 12 345",
"21-12345", "2112.345"].
"""
if not number:
return []
base = number.strip().lower()
variants = {base}
# Sans points
variants.add(base.replace(".", ""))
# Sans tirets
variants.add(base.replace("-", ""))
# Sans points ni tirets (numéro pur)
variants.add(re.sub(r"[\.\-\s]", "", base))
# Avec points uniquement (séparateur unique)
variants.add(base.replace("-", "."))
# Avec tirets uniquement
variants.add(base.replace(".", "-"))
# Forme "n° XX-XX.XXX"
variants.add(f"n° {base}")
variants.add(f"n°{base}")
return [v for v in variants if v]
def check_content_match(html, expected_number=None, expected_keyword=None):
"""Vérifie que le numéro et/ou le mot-clé attendu apparaît dans le HTML.
Retourne (match, detail) :
- match = True si tous les critères fournis correspondent.
- match = False sinon.
- match = None si aucun critère n'a été fourni (rien à vérifier).
"""
if expected_number is None and expected_keyword is None:
return (None, "Aucun critère de contenu fourni.")
if not html:
return (False, "Contenu HTML indisponible.")
haystack = normalize_for_search(html)
details = []
if expected_number is not None:
variants = number_variants(expected_number)
found = any(v in haystack for v in variants)
if not found:
return (
False,
f"Numéro '{expected_number}' (variantes : "
f"{variants}) introuvable dans la page."
)
details.append(f"Numéro '{expected_number}' trouvé.")
if expected_keyword is not None:
kw = expected_keyword.lower()
if kw not in haystack:
return (
False,
f"Mot-clé '{expected_keyword}' introuvable dans la page."
)
details.append(f"Mot-clé '{expected_keyword}' trouvé.")
return (True, " ".join(details))
# ─────────────────────────────────────────────────────────────────────────────
# Pipeline complet
# ─────────────────────────────────────────────────────────────────────────────
def normalize_entry(entry):
"""Convertit une entrée d'entrée en dict normalisé."""
if isinstance(entry, str):
return {
"url": entry,
"expected_number": None,
"expected_keyword": None,
}
if isinstance(entry, dict) and "url" in entry:
return {
"url": entry["url"],
"expected_number": entry.get("expected_number"),
"expected_keyword": entry.get("expected_keyword"),
}
return {
"url": None,
"expected_number": None,
"expected_keyword": None,
"_invalid_entry": entry,
}
def check_one(entry, do_check_content):
"""Vérifie une URL. Retourne un dict structuré."""
url = entry.get("url")
if not url:
return {
"url": None,
"type_legifrance": None,
"pattern_valide": False,
"status": None,
"accessible": False,
"content_match": None,
"content_match_detail": None,
"error": (
f"Entrée invalide (pas d'URL) : {entry.get('_invalid_entry')}"
),
}
# Étape 1 : reconnaissance du pattern
type_name, pattern_valide = identify_pattern(url)
result = {
"url": url,
"type_legifrance": type_name,
"pattern_valide": pattern_valide,
"status": None,
"accessible": False,
"content_match": None,
"content_match_detail": None,
"error": None,
}
if not pattern_valide:
result["error"] = (
"URL ne correspondant à aucun pattern Légifrance / HUDOC / "
"Curia / EUR-Lex reconnu. Possible signal d'hallucination ou "
"de reconstruction de mémoire."
)
return result
# Étape 2 : accessibilité HTTP
status, accessible, http_error = head_check(url)
result["status"] = status
result["accessible"] = accessible
if http_error:
result["error"] = http_error
if not accessible:
return result
# Étape 3 : vérification de contenu
if do_check_content:
html = fetch_content(url)
match, detail = check_content_match(
html,
expected_number=entry.get("expected_number"),
expected_keyword=entry.get("expected_keyword"),
)
result["content_match"] = match
result["content_match_detail"] = detail
if match is False:
existing_error = result["error"]
result["error"] = (
(existing_error + " | " if existing_error else "")
+ "Contenu non concordant : " + str(detail)
)
return result
def verify_batch(entries, do_check_content):
"""Vérifie une liste d'entrées en parallèle."""
results = []
with concurrent.futures.ThreadPoolExecutor(
max_workers=MAX_WORKERS
) as executor:
future_to_idx = {
executor.submit(check_one, e, do_check_content): i
for i, e in enumerate(entries)
}
ordered = [None] * len(entries)
for future in concurrent.futures.as_completed(future_to_idx):
idx = future_to_idx[future]
ordered[idx] = future.result()
return ordered
def is_failure(result):
"""Détermine si un résultat constitue un échec strict."""
if not result.get("pattern_valide"):
return True
if not result.get("accessible"):
return True
if result.get("content_match") is False:
return True
return False
# ─────────────────────────────────────────────────────────────────────────────
# Mode preflight : détection de l'accès réseau Légifrance
# ─────────────────────────────────────────────────────────────────────────────
def _headers_to_lower_dict(headers):
"""Convertit un objet Headers (HTTPMessage) en dict {nom_lower: value}.
Renvoie {} si headers est None ou n'est pas itérable.
"""
if headers is None:
return {}
try:
return {k.lower(): v for k, v in headers.items()}
except Exception:
return {}
def _classify_response_indicators(http_code, headers, raw_message=""):
"""Inspecte les en-têtes (et un message d'erreur brut) d'une réponse
HTTP pour décider du statut du préflight.
Statuts possibles :
- "ok" (0)
- "blocked_by_allowlist" (2) — proxy Cowork
- "network_error" (3) — erreur générique
- "blocked_by_anti_bot" (4) — challenge Cloudflare ou équivalent
"""
h = _headers_to_lower_dict(headers)
msg_lower = (raw_message or "").lower()
indicators = {
"x_proxy_error": h.get("x-proxy-error"),
"cf_mitigated": h.get("cf-mitigated"),
"server": h.get("server"),
"cf_ray": h.get("cf-ray"),
"http_status": http_code,
}
# 1. Blocage explicite par l'allowlist Cowork (en-tête sentinelle).
proxy_err = (indicators["x_proxy_error"] or "").lower()
if (
"blocked-by-allowlist" in proxy_err
or "blocked-by-allowlist" in msg_lower
or "cowork-egress-blocked" in msg_lower
or "tunnel connection failed" in msg_lower
):
return {
"status": "blocked_by_allowlist",
"exit_code": 2,
"message": (
"Accès réseau bloqué par l'allowlist du sandbox Cowork."
),
"recommendation": (
"Autoriser les cinq domaines (www.legifrance.gouv.fr, "
"www.conseil-constitutionnel.fr, hudoc.echr.coe.int, "
"curia.europa.eu, eur-lex.europa.eu) dans "
"Settings -> Capabilities -> Network access, puis "
"redémarrer la session Cowork pour propager l'allowlist."
),
"headers_indicators": indicators,
}
# 2. Challenge anti-bot Cloudflare (cas Légifrance, depuis 2026).
cf_mitigated = (indicators["cf_mitigated"] or "").lower()
server_lower = (indicators["server"] or "").lower()
is_cf_challenge = (
"challenge" in cf_mitigated
or (server_lower.startswith("cloudflare")
and http_code in (403, 503))
)
if is_cf_challenge:
return {
"status": "blocked_by_anti_bot",
"exit_code": 4,
"message": (
"Accès bloqué par un challenge anti-bot Cloudflare "
"(serveur distant). La couche réseau est opérationnelle, "
"mais le serveur refuse les requêtes automatisées."
),
"recommendation": (
"Bascule recommandée : vérifier les identifiants "
"Légifrance via OpenLegi (get_decision_judiciaire, "
"get_decision_administrative, rechercher_code, "
"recherche_journal_officiel, etc.) plutôt que par "
"requête HTTP directe. Voir mode --extract-ids."
),
"headers_indicators": indicators,
}
# 3. 200 OK : tout va bien.
if http_code == 200:
return {
"status": "ok",
"exit_code": 0,
"message": (
"Accès réseau à Légifrance opérationnel. La vérification "
"automatique par requête HTTP est utilisable."
),
"recommendation": None,
"headers_indicators": indicators,
}
# 4. Autre erreur réseau (DNS, TLS, timeout, code HTTP inattendu...).
return {
"status": "network_error",
"exit_code": 3,
"message": (
"Erreur réseau : code HTTP "
+ str(http_code)
+ " ; détail brut : "
+ (raw_message or "(non disponible)")
),
"recommendation": (
"Vérifier la connectivité réseau, l'état de Légifrance, ou "
"réessayer ultérieurement."
),
"headers_indicators": indicators,
}
def _probe_url(url, method="HEAD"):
"""Effectue une requête HEAD (ou GET) sur `url` et retourne
(http_code, headers, raw_message).
En cas d'HTTPError, les en-têtes de l'erreur sont capturés (utile
pour détecter cf-mitigated / X-Proxy-Error). En cas d'URLError ou
autre exception, http_code = None et headers = None.
"""
try:
req = urllib.request.Request(
url,
method=method,
headers={"User-Agent": USER_AGENT},
)
with urllib.request.urlopen(req, timeout=TIMEOUT_HEAD) as response:
return (response.getcode(), response.headers, "")
except urllib.error.HTTPError as e:
return (e.code, getattr(e, "headers", None),
str(e.code) + " " + str(e.reason))
except urllib.error.URLError as e:
return (None, None, str(e.reason))
except Exception as e:
return (None, None, type(e).__name__ + ": " + str(e))
def _test_egress():
"""Teste la sortie réseau via une URL UE (eur-lex). Retourne
(egress_ok: bool, detail: dict)."""
code, headers, raw = _probe_url(EGRESS_TEST_URL, method="HEAD")
indicators = _classify_response_indicators(code, headers, raw)
egress_ok = (
code is not None
and indicators["status"] != "blocked_by_allowlist"
)
return egress_ok, {
"url": EGRESS_TEST_URL,
"http_status": code,
"status_classification": indicators["status"],
"headers_indicators": indicators.get("headers_indicators"),
"raw_message": raw,
}
def preflight_check():
"""Teste l'état de la sortie réseau et l'accès à Légifrance.
Retourne un dict consolidé contenant :
- status / exit_code / message / recommendation
- http_status, headers_indicators, error_detail (diagnostic)
- network_egress ("ok" / "blocked"), network_egress_detail :
état de la sortie réseau générique, distinct du statut
spécifique Légifrance.
"""
egress_ok, egress_detail = _test_egress()
code, headers, raw = _probe_url(PREFLIGHT_URL, method="HEAD")
if code == 405:
code2, headers2, raw2 = _probe_url(PREFLIGHT_URL, method="GET")
if code2 is not None:
code, headers, raw = code2, headers2, raw2
indicators = _classify_response_indicators(code, headers, raw)
return {
"status": indicators["status"],
"exit_code": indicators["exit_code"],
"message": indicators["message"],
"http_status": code,
"headers_indicators": indicators.get("headers_indicators"),
"error_detail": raw if raw else None,
"recommendation": indicators["recommendation"],
"network_egress": "ok" if egress_ok else "blocked",
"network_egress_detail": egress_detail,
}
# Alias pour compatibilité ascendante avec le code 1.2.1 qui pouvait
# référencer _classify_network_error.
def _classify_network_error(exc):
"""Conserve la signature de la 1.2.1. Délègue à
_classify_response_indicators à partir du message d'erreur brut."""
return _classify_response_indicators(None, None, str(exc))
# ───────────────────────────────────────────────────────────────────────
# Mode --extract-ids : extraction d'identifiants Légifrance
# ───────────────────────────────────────────────────────────────────────
# Patterns d'identifiants Légifrance nus (sans préfixe URL). Ordre
# important : on teste d'abord les variantes spécifiques puis les
# génériques (LEGIARTI / LEGITEXT).
LEGIFRANCE_ID_PATTERNS = [
("JURITEXT", re.compile(r"\b(JURITEXT\d+)\b", re.IGNORECASE)),
("CETATEXT", re.compile(r"\b(CETATEXT\d+)\b", re.IGNORECASE)),
("CNILTEXT", re.compile(r"\b(CNILTEXT\d+)\b", re.IGNORECASE)),
("KALITEXT", re.compile(r"\b(KALITEXT\d+)\b", re.IGNORECASE)),
("JORFARTI", re.compile(r"\b(JORFARTI\d+)\b", re.IGNORECASE)),
("JORFTEXT", re.compile(r"\b(JORFTEXT\d+)\b", re.IGNORECASE)),
("LEGIARTI", re.compile(r"\b(LEGIARTI\d+)\b", re.IGNORECASE)),
("LEGITEXT", re.compile(r"\b(LEGITEXT\d+)\b", re.IGNORECASE)),
]
def _refine_legiarti_legitext_type(id_type, url_context):
"""Discriminer LEGIARTI / LEGITEXT en code vs LODA via l'URL parente.
À défaut d'URL contextuelle, conserve le type générique.
"""
if not url_context:
return id_type
u = url_context.lower()
if id_type == "LEGIARTI":
if "/codes/article_lc/" in u:
return "LEGIARTI_CODE"
if "/loda/article_lc/" in u:
return "LEGIARTI_LODA"
if id_type == "LEGITEXT":
if "/codes/texte_lc/" in u:
return "LEGITEXT_CODE"
if "/loda/id/" in u:
return "LEGITEXT_LODA"
return id_type
def extract_ids_from_text(text):
"""Extrait les identifiants Légifrance d'un texte brut.
Sans contexte d'URL, LEGIARTI et LEGITEXT retombent sur la variante
code (LEGIARTI_CODE, LEGITEXT_CODE) par défaut. L'agent doit, le
cas échéant, basculer sur la variante LODA.
"""
if not isinstance(text, str):
return []
seen = set()
results = []
for id_type, pattern in LEGIFRANCE_ID_PATTERNS:
for match in pattern.finditer(text):
ident = match.group(1).upper()
if ident in seen:
continue
seen.add(ident)
tool_key = id_type
if id_type == "LEGIARTI":
tool_key = "LEGIARTI_CODE"
if id_type == "LEGITEXT":
tool_key = "LEGITEXT_CODE"
mapping = LEGIFRANCE_TYPE_TO_OPENLEGI_TOOL.get(tool_key, {})
results.append({
"id": ident,
"type": id_type,
"type_resolved_assumption": tool_key,
"openlegi_tool": mapping.get("tool"),
"openlegi_argument": mapping.get("argument"),
"openlegi_verification_instruction": mapping.get(
"verification"
),
"source_context": "text",
})
return results
def extract_ids_from_urls(urls):
"""Extrait les identifiants Légifrance d'une liste d'URLs.
L'URL parente permet de discriminer LEGIARTI_CODE vs LEGIARTI_LODA
et LEGITEXT_CODE vs LEGITEXT_LODA.
"""
results = []
for url in urls:
if not isinstance(url, str):
continue
for id_type, pattern in LEGIFRANCE_ID_PATTERNS:
match = pattern.search(url)
if not match:
continue
ident = match.group(1).upper()
tool_key = _refine_legiarti_legitext_type(id_type, url)
mapping = LEGIFRANCE_TYPE_TO_OPENLEGI_TOOL.get(tool_key, {})
results.append({
"id": ident,
"type": id_type,
"type_resolved": tool_key,
"url": url,
"openlegi_tool": mapping.get("tool"),
"openlegi_argument": mapping.get("argument"),
"openlegi_verification_instruction": mapping.get(
"verification"
),
})
break # une seule extraction par URL
return results
def main():
parser = argparse.ArgumentParser(
description=(
"Vérification batch d'URLs juridiques (Légifrance, HUDOC, "
"Curia, EUR-Lex). Vérifie pattern, accessibilité, et "
"concordance de contenu. Mode --preflight pour tester "
"uniquement l'accès réseau à Légifrance."
)
)
group = parser.add_mutually_exclusive_group(required=False)
group.add_argument("--urls", help="JSON array d'URLs ou d'entrées.")
group.add_argument(
"--from-file",
help="Fichier JSON contenant la liste d'URLs ou d'entrées."
)
parser.add_argument(
"--preflight",
action="store_true",
help=(
"Tester l'état de la sortie réseau et l'accès à Légifrance. "
"Codes de retour : 0 = réseau OK et Légifrance répond ; "
"2 = bloqué par allowlist Cowork ; 3 = erreur réseau "
"générique ; 4 = bloqué par challenge anti-bot Cloudflare "
"(la couche réseau est OK, mais Légifrance refuse les "
"requêtes automatisées : utiliser --extract-ids et "
"OpenLegi)."
)
)
parser.add_argument(
"--extract-ids",
action="store_true",
help=(
"Extraire les identifiants Légifrance (LEGIARTI, JURITEXT, "
"CETATEXT, JORFTEXT, JORFARTI, LEGITEXT, CNILTEXT, "
"KALITEXT) d'une liste d'URLs (--urls / --from-file) ou "
"d'un texte brut (--extract-ids-from-text). Pour chaque "
"identifiant, retourne le nom de l'outil OpenLegi à "
"appeler pour vérification par API. Mode utile dans les "
"sandbox où Légifrance est inaccessible (Cloudflare ou "
"allowlist) : la vérification est déléguée à OpenLegi par "
"l'agent."
)
)
parser.add_argument(
"--extract-ids-from-text",
help=(
"Texte brut dans lequel rechercher les identifiants "
"Légifrance (à utiliser avec --extract-ids). Sans "
"contexte d'URL, LEGIARTI et LEGITEXT retombent sur la "
"variante code par défaut."
)
)
parser.add_argument(
"--strict",
action="store_true",
help=(
"Code de retour ≠ 0 si au moins une URL est invalide "
"(pattern non reconnu, inaccessible, ou contenu non "
"concordant)."
)
)
parser.add_argument(
"--check-content",
dest="check_content",
action="store_true",
default=True,
help=(
"Activer la vérification du contenu (par défaut : activé). "
"Récupère la page et vérifie la présence du numéro / mot-clé "
"attendu."
)
)
parser.add_argument(
"--no-check-content",
dest="check_content",
action="store_false",
help="Désactiver la vérification du contenu."
)
args = parser.parse_args()
if args.preflight:
result = preflight_check()
print(json.dumps(result, ensure_ascii=False, indent=2))
sys.exit(result["exit_code"])
if args.extract_ids:
if args.extract_ids_from_text:
ids = extract_ids_from_text(args.extract_ids_from_text)
elif args.urls or args.from_file:
if args.urls:
raw = json.loads(args.urls)
else:
with open(args.from_file, "r", encoding="utf-8") as f:
raw = json.load(f)
if not isinstance(raw, list):
parser.error(
"--urls / --from-file doit fournir un array JSON."
)
urls_only = []
for entry in raw:
if isinstance(entry, str):
urls_only.append(entry)
elif isinstance(entry, dict) and "url" in entry:
urls_only.append(entry["url"])
ids = extract_ids_from_urls(urls_only)
else:
parser.error(
"--extract-ids requiert --urls, --from-file, ou "
"--extract-ids-from-text."
)
output = {
"total_ids": len(ids),
"ids": ids,
"instruction_agent": (
"Pour chaque identifiant ci-dessous, appeler l'outil "
"OpenLegi indiqué (champ openlegi_tool) avec l'argument "
"décrit (champ openlegi_argument), puis exécuter la "
"vérification décrite (champ "
"openlegi_verification_instruction). Toute référence "
"dont l'identifiant n'est pas confirmé par OpenLegi "
"doit être supprimée du livrable ou convertie en "
"formulation impersonnelle."
),
}
print(json.dumps(output, ensure_ascii=False, indent=2))
sys.exit(0 if ids else 2)
if not args.urls and not args.from_file:
parser.error(
"--urls ou --from-file est requis (sauf en mode "
"--preflight ou --extract-ids)."
)
if args.urls:
raw = json.loads(args.urls)
else:
with open(args.from_file, "r", encoding="utf-8") as f:
raw = json.load(f)
if not isinstance(raw, list):
print(json.dumps({
"error": "L'entrée doit être un array JSON d'URLs ou d'entrées."
}))
sys.exit(2)
entries = [normalize_entry(e) for e in raw]
results = verify_batch(entries, do_check_content=args.check_content)
# Synthèse
total = len(results)
pattern_ok = sum(1 for r in results if r.get("pattern_valide"))
accessible = sum(1 for r in results if r.get("accessible"))
content_ok = sum(1 for r in results if r.get("content_match") is True)
content_ko = sum(1 for r in results if r.get("content_match") is False)
failures = [r for r in results if is_failure(r)]
summary = {
"total": total,
"pattern_valide": pattern_ok,
"accessible": accessible,
"content_match_ok": content_ok,
"content_match_ko": content_ko,
"echecs": len(failures),
"check_content_active": args.check_content,
"results": results,
}
print(json.dumps(summary, ensure_ascii=False, indent=2))
if args.strict and failures:
sys.exit(1)
sys.exit(0)
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |