@tricoteuses/senat 3.1.22 → 3.1.23

package/lib/src/parsers/collaborateurs.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Fonctions pures de parsing du PDF DRH des collaborateurs de sénateurs
+ * (https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf).
+ *
+ * Le PDF est un tableau à deux colonnes par page :
+ *  - "Employeur" (le sénateur) à gauche, ex. "Mme AESCHLIMANN Marie-Do" ;
+ *  - "Nom Collaborateur" à droite, ex. "M. CHAREF Dahmane".
+ * Une ligne sans employeur prolonge le sénateur précédent.
+ *
+ * Pièges traités ici : aucun matricule dans le PDF, prénoms de sénateurs tronqués
+ * ("Marie-Do"), noms composés ("DI FOLCO", "MAZENOT CHAPPUY"), accents.
+ */
+/** Élément de texte positionné extrait du PDF (x croissant vers la droite, y croissant vers le haut). */
+export type PdfTextItem = {
+    str: string;
+    x: number;
+    y: number;
+    page: number;
+};
+export type PersonneNom = {
+    civilite: string;
+    nom: string;
+    prenom: string;
+};
+export type LigneCollaborateur = {
+    senateur: PersonneNom;
+    collaborateur: PersonneNom;
+};
+/** Normalise un texte pour la comparaison : majuscules, sans accents, espaces compactés. */
+export declare function normaliserPourComparaison(valeur: string): string;
+/**
+ * Sépare une cellule "Civilité NOM(S) Prénom" en {civilite, nom, prenom}.
+ * Les jetons en majuscules de tête forment le nom (gère les noms composés), le reste le prénom.
+ * Renvoie null si la cellule n'est pas un nom de personne exploitable.
+ */
+export declare function parseCellulePersonne(cellule: string): PersonneNom | null;
+/** Extrait la date d'édition imprimée en pied de page ("Edition du JJ/MM/AAAA"). */
+export declare function extraireDateEdition(strings: string[]): Date | null;
+/**
+ * Reconstruit la liste {sénateur, collaborateur} à partir des éléments de texte positionnés.
+ * Parcourt les pages puis les lignes de haut en bas ; mémorise le sénateur courant et lui
+ * rattache les collaborateurs des lignes suivantes tant qu'aucun nouvel employeur n'apparaît.
+ */
+export declare function construireLignesCollaborateurs(items: PdfTextItem[]): LigneCollaborateur[];

package/lib/src/parsers/collaborateurs.js

@@ -0,0 +1,157 @@
+/**
+ * Fonctions pures de parsing du PDF DRH des collaborateurs de sénateurs
+ * (https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf).
+ *
+ * Le PDF est un tableau à deux colonnes par page :
+ *  - "Employeur" (le sénateur) à gauche, ex. "Mme AESCHLIMANN Marie-Do" ;
+ *  - "Nom Collaborateur" à droite, ex. "M. CHAREF Dahmane".
+ * Une ligne sans employeur prolonge le sénateur précédent.
+ *
+ * Pièges traités ici : aucun matricule dans le PDF, prénoms de sénateurs tronqués
+ * ("Marie-Do"), noms composés ("DI FOLCO", "MAZENOT CHAPPUY"), accents.
+ */
+// Bandes horizontales des deux colonnes (mesurées sur le PDF : employeur ≈ 147, collaborateur ≈ 285).
+const COLONNE_EMPLOYEUR = { min: 130, max: 225 };
+const COLONNE_COLLABORATEUR = { min: 255, max: 360 };
+const CIVILITES = ["Mme", "M.", "Mlle", "M"];
+// Particules nobiliaires/patronymiques en minuscules, qui font partie du nom quand elles le précèdent
+// (ex. "de CIDRAC", "de LA GONTRIE", "de LEGGE"). Le référentiel Sénat les conserve dans Nom_usuel.
+const PARTICULES = new Set([
+    "de",
+    "du",
+    "des",
+    "d'",
+    "le",
+    "la",
+    "les",
+    "von",
+    "van",
+    "der",
+    "den",
+    "da",
+    "di",
+    "del",
+    "dos",
+]);
+// Lignes d'en-tête / pied de page à ignorer.
+const LIGNES_IGNOREES = [
+    /liste des collaborateurs/i,
+    /^employeur$/i,
+    /^nom collaborateur$/i,
+    /^a\.?g\.?a\.?s\.?/i,
+    /edition du/i,
+    /congé non rémunéré/i,
+    /^-\s*\d+\s*-$/,
+];
+/** Normalise un texte pour la comparaison : majuscules, sans accents, espaces compactés. */
+export function normaliserPourComparaison(valeur) {
+    return valeur
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .toUpperCase()
+        .replace(/['']/g, "'")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function estIgnoree(str) {
+    const t = str.trim();
+    if (!t)
+        return true;
+    return LIGNES_IGNOREES.some((re) => re.test(t));
+}
+/**
+ * Sépare une cellule "Civilité NOM(S) Prénom" en {civilite, nom, prenom}.
+ * Les jetons en majuscules de tête forment le nom (gère les noms composés), le reste le prénom.
+ * Renvoie null si la cellule n'est pas un nom de personne exploitable.
+ */
+export function parseCellulePersonne(cellule) {
+    const brut = cellule
+        .replace(/\(\*\)/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!brut)
+        return null;
+    let civilite = "";
+    let reste = brut;
+    for (const civ of CIVILITES) {
+        if (brut === civ)
+            return null;
+        if (brut.startsWith(`${civ} `)) {
+            civilite = civ;
+            reste = brut.slice(civ.length + 1).trim();
+            break;
+        }
+    }
+    if (!reste)
+        return null;
+    const jetons = reste.split(" ");
+    const estMajuscule = (jeton) => {
+        const lettres = jeton.replace(/[^A-Za-zÀ-ÿ]/g, "");
+        return lettres.length > 0 && lettres === lettres.toUpperCase();
+    };
+    const jetonsNom = [];
+    let i = 0;
+    // Particules de tête en minuscules (ex. "de", "de la") faisant partie du nom.
+    while (i < jetons.length && PARTICULES.has(jetons[i].toLowerCase())) {
+        jetonsNom.push(jetons[i]);
+        i++;
+    }
+    // Puis les jetons du nom en majuscules.
+    while (i < jetons.length && estMajuscule(jetons[i])) {
+        jetonsNom.push(jetons[i]);
+        i++;
+    }
+    // Une particule seule sans nom en majuscules n'est pas un nom valide : on rétablit.
+    if (jetonsNom.length > 0 && jetonsNom.every((j) => PARTICULES.has(j.toLowerCase()))) {
+        jetonsNom.length = 0;
+        i = 0;
+    }
+    // Si aucun jeton majuscule (cas inattendu), on prend le premier comme nom.
+    if (jetonsNom.length === 0 && jetons.length > 0) {
+        jetonsNom.push(jetons[0]);
+        i = 1;
+    }
+    const nom = jetonsNom.join(" ");
+    const prenom = jetons.slice(i).join(" ");
+    if (!nom)
+        return null;
+    return { civilite, nom, prenom };
+}
+/** Extrait la date d'édition imprimée en pied de page ("Edition du JJ/MM/AAAA"). */
+export function extraireDateEdition(strings) {
+    for (const s of strings) {
+        const m = s.match(/Edition du\s+(\d{2})\/(\d{2})\/(\d{4})/i);
+        if (m) {
+            const [, jj, mm, aaaa] = m;
+            return new Date(Date.UTC(Number(aaaa), Number(mm) - 1, Number(jj)));
+        }
+    }
+    return null;
+}
+/**
+ * Reconstruit la liste {sénateur, collaborateur} à partir des éléments de texte positionnés.
+ * Parcourt les pages puis les lignes de haut en bas ; mémorise le sénateur courant et lui
+ * rattache les collaborateurs des lignes suivantes tant qu'aucun nouvel employeur n'apparaît.
+ */
+export function construireLignesCollaborateurs(items) {
+    const utiles = items.filter((it) => !estIgnoree(it.str));
+    // Tri lecture : page croissante, puis y décroissant (haut → bas), puis x croissant (gauche → droite).
+    const tries = [...utiles].sort((a, b) => a.page - b.page || b.y - a.y || a.x - b.x);
+    const lignes = [];
+    let senateurCourant = null;
+    for (const it of tries) {
+        const dansEmployeur = it.x >= COLONNE_EMPLOYEUR.min && it.x <= COLONNE_EMPLOYEUR.max;
+        const dansCollaborateur = it.x >= COLONNE_COLLABORATEUR.min && it.x <= COLONNE_COLLABORATEUR.max;
+        if (dansEmployeur) {
+            const personne = parseCellulePersonne(it.str);
+            if (personne)
+                senateurCourant = personne;
+        }
+        else if (dansCollaborateur && senateurCourant) {
+            const collaborateur = parseCellulePersonne(it.str);
+            if (collaborateur)
+                lignes.push({ senateur: senateurCourant, collaborateur });
+        }
+    }
+    return lignes;
+}

package/lib/src/scripts/retrieve_collaborateurs.js

@@ -0,0 +1,166 @@
+import fs from "fs-extra";
+import path from "path";
+import { getDocumentProxy } from "unpdf";
+import { construireLignesCollaborateurs, extraireDateEdition, normaliserPourComparaison, } from "../parsers/collaborateurs.js";
+import { assertExistingDirectory } from "./shared/cli_helpers.js";
+import { iterFilePaths } from "../server/loaders.js";
+const URL_PDF_DEFAUT = "https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf";
+const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36";
+async function telechargerPdf(url) {
+    const cookies = new Map();
+    let courant = url;
+    for (let i = 0; i < 8; i += 1) {
+        const headers = { "User-Agent": USER_AGENT };
+        if (cookies.size > 0) {
+            headers["Cookie"] = [...cookies].map(([k, v]) => `${k}=${v}`).join("; ");
+        }
+        const reponse = await fetch(courant, { redirect: "manual", headers });
+        for (const brut of reponse.headers.getSetCookie?.() ?? []) {
+            const [paire] = brut.split(";");
+            const idx = paire.indexOf("=");
+            if (idx > 0)
+                cookies.set(paire.slice(0, idx).trim(), paire.slice(idx + 1).trim());
+        }
+        if (reponse.status >= 300 && reponse.status < 400) {
+            const location = reponse.headers.get("location");
+            if (!location)
+                throw new Error(`Redirection sans en-tête Location (HTTP ${reponse.status})`);
+            courant = new URL(location, courant).toString();
+            continue;
+        }
+        if (!reponse.ok)
+            throw new Error(`Téléchargement du PDF échoué : HTTP ${reponse.status}`);
+        const buffer = Buffer.from(await reponse.arrayBuffer());
+        if (buffer.subarray(0, 5).toString("latin1") !== "%PDF-") {
+            throw new Error("Le contenu téléchargé n'est pas un PDF");
+        }
+        return buffer;
+    }
+    throw new Error("Trop de redirections lors du téléchargement du PDF DRH");
+}
+async function extraireItemsPdf(buffer) {
+    const pdf = await getDocumentProxy(new Uint8Array(buffer));
+    const items = [];
+    const strings = [];
+    for (let p = 1; p <= pdf.numPages; p += 1) {
+        const page = await pdf.getPage(p);
+        const contenu = await page.getTextContent();
+        for (const item of contenu.items) {
+            if (typeof item.str !== "string" || !item.str.trim() || !item.transform)
+                continue;
+            items.push({ str: item.str, x: item.transform[4], y: item.transform[5], page: p });
+            strings.push(item.str);
+        }
+    }
+    return { items, strings };
+}
+function chargerSenateurs(dataDir) {
+    const senateursDir = path.join(dataDir, "sens", "senateurs");
+    const files = new Map();
+    const indexParNom = new Map();
+    if (!fs.existsSync(senateursDir))
+        return { files, indexParNom };
+    for (const filePath of iterFilePaths(senateursDir)) {
+        const senator = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        files.set(senator.matricule, senator);
+        const cle = normaliserPourComparaison(senator.nom_usuel);
+        const liste = indexParNom.get(cle);
+        if (liste)
+            liste.push(senator);
+        else
+            indexParNom.set(cle, [senator]);
+    }
+    return { files, indexParNom };
+}
+async function main() {
+    const dataDir = process.argv[2];
+    assertExistingDirectory(dataDir, "dataDir");
+    // 1. Téléchargement + parsing du PDF
+    console.log(`Téléchargement du PDF DRH : ${URL_PDF_DEFAUT}`);
+    const buffer = await telechargerPdf(URL_PDF_DEFAUT);
+    const { items, strings } = await extraireItemsPdf(buffer);
+    const lignes = construireLignesCollaborateurs(items);
+    const dateEdition = extraireDateEdition(strings);
+    console.log(`PDF lu : ${lignes.length} lignes collaborateur, édition ${dateEdition?.toISOString().slice(0, 10) ?? "inconnue"}`);
+    if (lignes.length === 0) {
+        throw new Error("Aucune ligne collaborateur extraite du PDF : format inattendu, abandon sans modification.");
+    }
+    // 2. Charger les fichiers sénateurs existants
+    const { indexParNom } = chargerSenateurs(dataDir);
+    if (indexParNom.size === 0) {
+        throw new Error("Aucun fichier sénateur trouvé. Lancez d'abord data:download pour générer les fichiers.");
+    }
+    // 3. Résoudre les sénateurs du PDF → fichiers
+    let nbEnrichis = 0;
+    let nbNonResolus = 0;
+    // Grouper les collaborateurs par matricule de sénateur
+    const collabsParMatricule = new Map();
+    const nomsNonResolus = new Set();
+    for (const ligne of lignes) {
+        const cleNom = normaliserPourComparaison(ligne.senateur.nom);
+        const candidats = indexParNom.get(cleNom);
+        if (!candidats || candidats.length === 0) {
+            nomsNonResolus.add(`${ligne.senateur.civilite} ${ligne.senateur.nom} ${ligne.senateur.prenom}`.trim());
+            nbNonResolus += 1;
+            continue;
+        }
+        // Désambiguïsation par préfixe de prénom
+        const prenomCible = normaliserPourComparaison(ligne.senateur.prenom);
+        const parPrenom = candidats.filter((c) => normaliserPourComparaison(c.prenom_usuel).startsWith(prenomCible));
+        let senator = null;
+        if (candidats.length === 1) {
+            senator = candidats[0];
+        }
+        else if (parPrenom.length === 1) {
+            senator = parPrenom[0];
+        }
+        else {
+            nomsNonResolus.add(`${ligne.senateur.civilite} ${ligne.senateur.nom} ${ligne.senateur.prenom}`.trim());
+            nbNonResolus += 1;
+            continue;
+        }
+        let collabs = collabsParMatricule.get(senator.matricule);
+        if (!collabs) {
+            collabs = [];
+            collabsParMatricule.set(senator.matricule, collabs);
+        }
+        // Dédoublonnage
+        const nNom = normaliserPourComparaison(ligne.collaborateur.nom);
+        const nPrenom = normaliserPourComparaison(ligne.collaborateur.prenom);
+        if (!collabs.some((c) => normaliserPourComparaison(c.nom) === nNom && normaliserPourComparaison(c.prenom) === nPrenom)) {
+            collabs.push({
+                civilite: ligne.collaborateur.civilite,
+                nom: ligne.collaborateur.nom,
+                prenom: ligne.collaborateur.prenom,
+            });
+        }
+    }
+    // 4. Écrire les collaborateurs dans les fichiers sénateurs
+    for (const [matricule, collaborateurs] of collabsParMatricule) {
+        const cheminFichier = path.join(dataDir, "sens", "senateurs", `${matricule}.json`);
+        if (!fs.existsSync(cheminFichier))
+            continue;
+        const senator = JSON.parse(fs.readFileSync(cheminFichier, "utf-8"));
+        senator.collaborateurs = collaborateurs;
+        fs.writeFileSync(cheminFichier, JSON.stringify(senator, null, 2) + "\n");
+        nbEnrichis += 1;
+    }
+    // 5. Nettoyer les collaborateurs des sénateurs absents du PDF
+    const matriculesEnrichis = new Set(collabsParMatricule.keys());
+    const { files: tousLesFichiers } = chargerSenateurs(dataDir);
+    for (const [matricule, senator] of tousLesFichiers) {
+        if (!matriculesEnrichis.has(matricule) && senator.collaborateurs) {
+            delete senator.collaborateurs;
+            const cheminFichier = path.join(dataDir, "sens", "senateurs", `${matricule}.json`);
+            fs.writeFileSync(cheminFichier, JSON.stringify(senator, null, 2) + "\n");
+        }
+    }
+    console.log(`${nbEnrichis} sénateur(s) enrichi(s) avec leurs collaborateurs`);
+    if (nomsNonResolus.size > 0) {
+        console.warn(`${nbNonResolus} sénateur(s) du PDF non rattaché(s) : ${[...nomsNonResolus].slice(0, 10).join(", ")}${nomsNonResolus.size > 10 ? "…" : ""}`);
+    }
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/lib/src/scripts/retrieve_cr_seance.js

@@ -28,18 +28,25 @@ const optionsDefinitions = [
 const options = commandLineArgs(optionsDefinitions);
 const CRI_ZIP_URL = "https://data.senat.fr/data/debats/cri.zip";
 let exitCode = 10; // 0: some data changed, 10: no modification
+function log(options, ...args) {
+    if (!options["silent"])
+        console.log(...args);
+}
+function warn(options, ...args) {
+    if (!options["silent"])
+        console.warn(...args);
+}
 class CompteRenduError extends Error {
     constructor(message, url) {
         super(`An error occurred while retrieving ${url}: ${message}`);
     }
 }
-async function downloadCriZip(zipPath) {
-    if (!options["silent"])
-        console.log(`Downloading CRI zip ${CRI_ZIP_URL}…`);
+async function downloadCriZip(zipPath, options) {
+    log(options, `Downloading CRI zip ${CRI_ZIP_URL}…`);
     const response = await fetchWithRetry(CRI_ZIP_URL);
     if (!response.ok) {
         if (response.status === 404) {
-            console.warn(`CRI zip ${CRI_ZIP_URL} not found`);
+            warn(options, `CRI zip ${CRI_ZIP_URL} not found`);
             return;
         }
         throw new CompteRenduError(String(response.status), CRI_ZIP_URL);
@@ -48,7 +55,7 @@ async function downloadCriZip(zipPath) {
     await fs.writeFile(zipPath, buf);
     if (!options["silent"]) {
         const mb = (buf.length / (1024 * 1024)).toFixed(1);
-        console.log(`[CRI] Downloaded ${mb} MB → ${zipPath}`);
+        log(options, `[CRI] Downloaded ${mb} MB → ${zipPath}`);
     }
 }
 async function extractAndDistributeXmlBySession(zipPath, originalRoot) {
@@ -97,9 +104,9 @@ export async function retrieveCriXmlDump(dataDir, options = {}) {
     const sessions = getSessionsFromStart((options["fromSession"] ?? UNDEFINED_SESSION));
     // 1) Download ZIP global + distribut by session
     const zipPath = path.join(dataDir, "cri.zip");
-    console.log("[CRI] Downloading global CRI zip…");
-    await downloadCriZip(zipPath);
-    console.log("[CRI] Extracting + distributing XMLs by session…");
+    log(options, "[CRI] Downloading global CRI zip…");
+    await downloadCriZip(zipPath, options);
+    log(options, "[CRI] Extracting + distributing XMLs by session…");
     for (const session of sessions) {
         const dir = path.join(originalRoot, String(session));
         if (await fs.pathExists(dir)) {
@@ -110,13 +117,13 @@ export async function retrieveCriXmlDump(dataDir, options = {}) {
     }
     const n = await extractAndDistributeXmlBySession(zipPath, originalRoot);
     if (n === 0) {
-        console.warn("[CRI] No XML extracted. Archive empty or layout changed?");
+        warn(options, "[CRI] No XML extracted. Archive empty or layout changed?");
     }
     else {
-        console.log(`[CRI] Distributed ${n} XML file(s) into session folders.`);
+        log(options, `[CRI] Distributed ${n} XML file(s) into session folders.`);
     }
     if (!options["parseDebats"]) {
-        console.log("[CRI] parseDebats not requested → done.");
+        log(options, "[CRI] parseDebats not requested → done.");
         return;
     }
     for (const session of sessions) {
@@ -147,10 +154,10 @@ export async function retrieveCriXmlDump(dataDir, options = {}) {
                             const crPath = path.join(transformedSessionDir, fn);
                             try {
                                 const cr = await fs.readJSON(crPath);
-                                await linkCriEventIntoAgenda(dataDir, yyyymmdd, eventId, cr.uid, cr, session);
+                                await linkCriEventIntoAgenda(dataDir, yyyymmdd, eventId, cr.uid, cr, session, options);
                             }
                             catch (e) {
-                                console.warn(`[CR] [${session}] Could not relink existing CR into a reunion for ${yyyymmdd} event=${eventId}:`, e);
+                                warn(options, `[CR] [${session}] Could not relink existing CR into a reunion for ${yyyymmdd} event=${eventId}:`, e);
                             }
                         }
                         continue;
@@ -160,7 +167,7 @@ export async function retrieveCriXmlDump(dataDir, options = {}) {
             // === Charger les events SP du jour depuis les agendas groupés ===
             const dayEvents = await loadAgendaSpEventsForDate(dataDir, yyyymmdd, session);
             if (dayEvents.length === 0) {
-                console.warn(`[CRI] [${session}] No agenda SP events found for ${yyyymmdd} → skip split/link`);
+                warn(options, `[CRI] [${session}] No agenda SP events found for ${yyyymmdd} → skip split/link`);
                 continue;
             }
             // === Lire XML + construire index DOM ===
@@ -175,14 +182,14 @@ export async function retrieveCriXmlDump(dataDir, options = {}) {
                 idx = new Map(order.map((el, i) => [el, i]));
             }
             catch (e) {
-                console.warn(`[CRI] [${session}] Cannot read/parse ${f}:`, e);
+                warn(options, `[CRI] [${session}] Cannot read/parse ${f}:`, e);
                 continue;
             }
             // === Extraire sommaire + matcher vers events agenda ===
             const blocks = extractSommaireBlocks($, idx);
             const intervals = buildIntervalsByAgendaEvents($, idx, order, blocks, dayEvents);
             if (!intervals.length) {
-                console.warn(`[CRI] [${session}] No confident split intervals for ${yyyymmdd} → skip`);
+                warn(options, `[CRI] [${session}] No confident split intervals for ${yyyymmdd} → skip`);
                 continue;
             }
             // === Parser / écrire / linker chaque segment par event ===
@@ -191,16 +198,16 @@ export async function retrieveCriXmlDump(dataDir, options = {}) {
                 const outPath = path.join(transformedSessionDir, outName);
                 const cr = await parseCompteRenduIntervalFromFile(xmlPath, iv.startIndex, iv.endIndex, iv.agendaEventId);
                 if (!cr) {
-                    console.warn(`[CRI] [${session}] Empty or no points for ${yyyymmdd} event=${iv.agendaEventId} → skip`);
+                    warn(options, `[CRI] [${session}] Empty or no points for ${yyyymmdd} event=${iv.agendaEventId} → skip`);
                     continue;
                 }
                 await fs.ensureDir(transformedSessionDir);
                 await fs.writeJSON(outPath, cr, { spaces: 2 });
                 try {
-                    await linkCriEventIntoAgenda(dataDir, yyyymmdd, iv.agendaEventId, cr.uid, cr, session);
+                    await linkCriEventIntoAgenda(dataDir, yyyymmdd, iv.agendaEventId, cr.uid, cr, session, options);
                 }
                 catch (e) {
-                    console.warn(`[CR] [${session}] Could not link CR into agenda for ${yyyymmdd} event=${iv.agendaEventId}:`, e);
+                    warn(options, `[CR] [${session}] Could not link CR into agenda for ${yyyymmdd} event=${iv.agendaEventId}:`, e);
                 }
             }
         }
@@ -218,7 +225,7 @@ function commitAndPushGit(datasetDir, options) {
         }
     }
 }
-async function linkCriEventIntoAgenda(dataDir, yyyymmdd, agendaEventId, crUid, cr, session) {
+async function linkCriEventIntoAgenda(dataDir, yyyymmdd, agendaEventId, crUid, cr, session, options) {
     const agendadDir = path.join(dataDir, AGENDA_FOLDER, DATA_TRANSFORMED_FOLDER, session.toString());
     fs.ensureDirSync(agendadDir);
     const dateISO = `${yyyymmdd.slice(0, 4)}-${yyyymmdd.slice(4, 6)}-${yyyymmdd.slice(6, 8)}`;
@@ -230,17 +237,17 @@ async function linkCriEventIntoAgenda(dataDir, yyyymmdd, agendaEventId, crUid, c
             agenda = await fs.readJSON(agendaPath);
         }
         catch (e) {
-            console.warn(`[CR] unreadable reunion JSON → ${agendaPath} (${e})`);
+            warn(options, `[CR] unreadable reunion JSON → ${agendaPath} (${e})`);
             agenda = null;
         }
     }
     if (!agenda) {
-        console.warn(`[CR] Missing reunion file for SP event=${agendaEventId}: ${agendaPath}`);
+        warn(options, `[CR] Missing reunion file for SP event=${agendaEventId}: ${agendaPath}`);
         return;
     }
     agenda.compteRenduRefUid = crUid;
     await fs.writeJSON(agendaPath, agenda, { spaces: 2 });
-    console.log(`[CR] Linked CR ${crUid} → ${path.basename(agendaPath)} (event=${agendaEventId})`);
+    log(options, `[CR] Linked CR ${crUid} → ${path.basename(agendaPath)} (event=${agendaEventId})`);
 }
 function buildIntervalsByAgendaEvents($, idx, order, blocks, dayEvents) {
     const MIN_SCORE = 0.65;
@@ -348,9 +355,11 @@ function resolveTargetIndex($, idx, targetId) {
 }
 async function main() {
     const dataDir = assertExistingDirectory(options["dataDir"], "data directory");
-    console.time("CRI processing time");
+    if (!options["silent"])
+        console.time("CRI processing time");
     await retrieveCriXmlDump(dataDir, options);
-    console.timeEnd("CRI processing time");
+    if (!options["silent"])
+        console.timeEnd("CRI processing time");
 }
 main()
     .then(() => process.exit(exitCode))

package/lib/src/scripts/retrieve_videos.js

@@ -17,6 +17,10 @@ import { processBisIfNeeded, processOneReunionMatch, writeIfChanged } from "../v
 const optionsDefinitions = [...commonOptions];
 const options = commandLineArgs(optionsDefinitions);
 let exitCode = 10; // 0: some data changed, 10: no modification
+function log(...args) {
+    if (!options["silent"])
+        console.log(...args);
+}
 function shouldSkipAgenda(agenda) {
     if (!agenda.date || !agenda.startTime)
         return true;
@@ -113,12 +117,12 @@ async function processGroupedReunion(agenda, session, dataDir, lastByVideo) {
         STATS.total++;
         const candidates = await fetchCandidatesForAgenda(agenda, options);
         if (!candidates) {
-            console.log(`[warn] ${agenda.uid} No candidate found for this reunion. Probably VOD not published yet.`);
+            log(`[warn] ${agenda.uid} No candidate found for this reunion. Probably VOD not published yet.`);
             return;
         }
         const match = await matchAgendaToVideo({ agenda, agendaTs: ctx.agendaTs, candidates, options });
         if (!match) {
-            console.log(`[miss] ${agenda.uid} No match found for this reunion`);
+            log(`[miss] ${agenda.uid} No match found for this reunion`);
             return;
         }
         ;
@@ -127,8 +131,7 @@ async function processGroupedReunion(agenda, session, dataDir, lastByVideo) {
         await writeMatchArtifacts({ agenda, ctx, best, secondBest });
     }
     if (best && isAmbiguousTimeOriginal(agenda.events[0].timeOriginal)) {
-        if (!options["silent"])
-            console.log("If the time is ambiguous, update agenda startTime from matched video");
+        log("If the time is ambiguous, update agenda startTime from matched video");
         agenda = { ...agenda, startTime: epochToParisDateTime(best.epoch)?.startTime ?? agenda.startTime };
     }
     // 3) Always update BEST agenda JSON from local NVS
@@ -158,7 +161,7 @@ async function processGroupedReunion(agenda, session, dataDir, lastByVideo) {
     });
 }
 async function processAll(dataDir, sessions) {
-    console.log("Process all Agendas and fetch video's url");
+    log("Process all Agendas and fetch video's url");
     for (const session of sessions) {
         const lastByVideo = new Map();
         for (const { item: agenda } of iterLoadSenatAgendas(dataDir, session)) {
@@ -186,12 +189,14 @@ async function main() {
     const dataDir = assertExistingDirectory(options["dataDir"], "data directory");
     const sessions = getSessionsFromStart((options["fromSession"] ?? UNDEFINED_SESSION));
     const TIMER = "senat-agendas→videos processing time";
-    console.time(TIMER);
+    if (!options["silent"])
+        console.time(TIMER);
     await processAll(dataDir, sessions);
-    console.timeEnd(TIMER);
+    if (!options["silent"])
+        console.timeEnd(TIMER);
     const { total, accepted } = STATS;
     const ratio = total ? ((accepted / total) * 100).toFixed(1) : "0.0";
-    console.log(`[summary] accepted=${accepted} / total=${total} (${ratio}%)`);
+    log(`[summary] accepted=${accepted} / total=${total} (${ratio}%)`);
 }
 if (import.meta.url === pathToFileURL(process.argv[1]).href) {
     main()