@tricoteuses/senat 2.9.10 → 2.10.1

package/lib/scripts/retrieve_comptes_rendus.js

@@ -1,119 +1,272 @@
+/**
+ * Needs to be run after retrieve_agenda.ts !
+ * - downloads the ZIP of comptes-rendus des débats (CRI) from data.senat.fr
+ * - extracts XML files, distributes them by session/year
+ */
 import assert from "assert";
 import commandLineArgs from "command-line-args";
 import fs from "fs-extra";
 import path from "path";
-import { COMPTES_RENDUS_FOLDER, DATA_ORIGINAL_FOLDER, DATA_TRANSFORMED_FOLDER, iterLoadSenatDebats, } from "../loaders";
-import { getSessionsFromStart } from "../types/sessions";
+import StreamZip from "node-stream-zip";
+import * as cheerio from "cheerio";
+import { AGENDA_FOLDER, COMPTES_RENDUS_FOLDER, DATA_ORIGINAL_FOLDER, DATA_TRANSFORMED_FOLDER, } from "../loaders";
 import { commonOptions } from "./shared/cli_helpers";
-import { ensureAndClearDir } from "./shared/util";
-import { parseCompteRenduFromFile } from "../model/compte_rendu";
+import { deriveTitreObjetFromSommaire, parseCompteRenduSlotFromFile, parseYYYYMMDD, sessionStartYearFromDate } from "../model/compte_rendu";
+import { makeGroupUid } from "../utils/reunion_grouping";
+import { getSessionsFromStart } from "../types/sessions";
+import { ensureAndClearDir, fetchWithRetry } from "./shared/util";
+import { computeIntervalsBySlot } from "../utils/cr_spliting";
 const optionsDefinitions = [
     ...commonOptions,
     {
         help: "parse and convert comptes-rendus des débats into JSON",
         name: "parseDebats",
         type: Boolean,
-    },
+    }
 ];
 const options = commandLineArgs(optionsDefinitions);
-const SENAT_COMPTE_RENDU_URL_ROOT = "https://www.senat.fr/seances";
+const CRI_ZIP_URL = "https://data.senat.fr/data/debats/cri.zip";
+const SLOT_ORDER = ["MATIN", "APRES-MIDI", "SOIR"];
 class CompteRenduError extends Error {
-    constructor(message, compteRenduUrl) {
-        super(`An error occurred while retrieving Compte-Rendu ${compteRenduUrl}: ${message}`);
+    constructor(message, url) {
+        super(`An error occurred while retrieving ${url}: ${message}`);
     }
 }
-async function fetchWithRetry(url, retries = 5, backoffMs = 1000) {
-    for (let attempt = 0; attempt < retries; attempt++) {
-        try {
-            return await fetch(url);
-        }
-        catch (e) {
-            if (attempt === retries)
-                break;
-            console.warn(`Fetch attempt ${attempt + 1} for ${url} failed. Retrying in ${backoffMs}ms...`);
-            await new Promise((resolve) => setTimeout(resolve, backoffMs));
-            backoffMs *= 2;
-        }
-    }
-    console.log(`Failed to fetch ${url} after ${retries} attempts.`);
+function pickFirstSlotOfDay(slots) {
+    for (const s of SLOT_ORDER)
+        if (slots.includes(s))
+            return s;
     return null;
 }
-async function retrieveComptesRendus(dataDir, sessions) {
-    const comptesRendusRootDir = path.join(dataDir, COMPTES_RENDUS_FOLDER);
-    ensureAndClearDir(comptesRendusRootDir);
-    const originalComptesRendusDir = path.join(comptesRendusRootDir, DATA_ORIGINAL_FOLDER);
-    fs.ensureDirSync(originalComptesRendusDir);
-    const transformedComptesRendusDir = path.join(comptesRendusRootDir, DATA_TRANSFORMED_FOLDER);
-    if (options["parseDebats"]) {
-        fs.ensureDirSync(transformedComptesRendusDir);
+function loadAgendaSPSlotsForDate(dataDir, yyyymmdd, session) {
+    const dirPath = path.join(dataDir, AGENDA_FOLDER, DATA_TRANSFORMED_FOLDER, session.toString());
+    if (!fs.existsSync(dirPath)) {
+        console.warn(`[AGENDA] Directory not found for session ${session} → ${dirPath}`);
+        return null;
     }
-    for (const session of sessions) {
-        const originalComptesRendusSessionDir = path.join(originalComptesRendusDir, `${session}`);
-        fs.ensureDirSync(originalComptesRendusSessionDir);
-        const transformedComptesRendusSessionDir = path.join(transformedComptesRendusDir, `${session}`);
-        if (options["parseDebats"]) {
-            fs.ensureDirSync(transformedComptesRendusSessionDir);
+    const pattern = new RegExp(`^RUSN${yyyymmdd}IDS-(MATIN|APRES-MIDI|SOIR)\\.json$`);
+    const ALLOWED_SLOTS = new Set(["MATIN", "APRES-MIDI", "SOIR"]);
+    try {
+        const files = fs.readdirSync(dirPath);
+        const matched = files.filter((f) => pattern.test(f));
+        if (matched.length === 0) {
+            return null;
         }
-        for (const { item: debat } of iterLoadSenatDebats(dataDir, session)) {
-            if (!debat.url)
-                continue;
-            try {
-                const debatMonoUrl = `${path.parse(debat.url).dir}/s${debat.id}_mono.html`;
-                const compteRenduPath = path.join(originalComptesRendusSessionDir, `${debat.id}.html`);
-                await downloadCompteRendu(debatMonoUrl, compteRenduPath);
-                if (options["parseDebats"]) {
-                    await parseAndWriteJSON(transformedComptesRendusSessionDir, compteRenduPath, debat);
-                }
-            }
-            catch (error) {
-                console.error(error);
-            }
+        const found = new Set();
+        for (const name of matched) {
+            const m = name.match(pattern);
+            const raw = (m?.[1] ?? "");
+            if (ALLOWED_SLOTS.has(raw))
+                found.add(raw);
         }
+        const slots = Array.from(found);
+        if (slots.length === 0) {
+            return null;
+        }
+        return { filePath: dirPath, slots };
     }
-}
-async function downloadCompteRendu(debatUrl, compteRenduPath) {
-    const compteRenduUrl = `${SENAT_COMPTE_RENDU_URL_ROOT}/${debatUrl}`;
-    if (!options["silent"]) {
-        console.log(`Downloading Compte-Rendu ${compteRenduUrl}…`);
+    catch {
+        return null;
     }
-    const response = await fetchWithRetry(compteRenduUrl);
+}
+async function downloadCriZip(zipPath) {
+    if (!options["silent"])
+        console.log(`Downloading CRI zip ${CRI_ZIP_URL}…`);
+    const response = await fetchWithRetry(CRI_ZIP_URL);
     if (!response.ok) {
         if (response.status === 404) {
-            console.warn(`Compte-Rendu ${compteRenduUrl} not found`);
+            console.warn(`CRI zip ${CRI_ZIP_URL} not found`);
+            return;
         }
-        else {
-            throw new CompteRenduError(String(response.status), compteRenduUrl);
-        }
-        return;
+        throw new CompteRenduError(String(response.status), CRI_ZIP_URL);
     }
-    const compteRenduContent = await response.arrayBuffer();
-    if (!compteRenduContent)
-        return;
-    fs.writeFileSync(compteRenduPath, Buffer.from(compteRenduContent));
-}
-async function parseAndWriteJSON(transformedComptesRendusSessionDir, compteRenduPath, debat) {
+    const buf = Buffer.from(await response.arrayBuffer());
+    await fs.writeFile(zipPath, buf);
     if (!options["silent"]) {
-        console.log(`Parsing compte-rendu ${compteRenduPath}…`);
+        const mb = (buf.length / (1024 * 1024)).toFixed(1);
+        console.log(`[CRI] Downloaded ${mb} MB → ${zipPath}`);
+    }
+}
+async function extractAndDistributeXmlBySession(zipPath, originalRoot) {
+    const zip = new StreamZip.async({ file: zipPath });
+    const entries = await zip.entries();
+    let count = 0;
+    for (const entryName of Object.keys(entries)) {
+        if (!entryName.toLowerCase().endsWith(".xml"))
+            continue;
+        // ex: d20231005.xml
+        const base = path.basename(entryName);
+        const m = base.match(/^d(\d{8})\.xml$/i);
+        if (!m)
+            continue;
+        const yyyymmdd = m[1];
+        const dt = parseYYYYMMDD(yyyymmdd);
+        if (!dt)
+            continue;
+        const session = sessionStartYearFromDate(dt);
+        const destDir = path.join(originalRoot, String(session));
+        await fs.ensureDir(destDir);
+        const outPath = path.join(destDir, base);
+        await zip.extract(entryName, outPath);
+        count++;
     }
-    const parsed = await parseCompteRenduFromFile(compteRenduPath);
-    if (!parsed)
+    await zip.close();
+    return count;
+}
+export async function retrieveCriXmlDump(dataDir, options = {}) {
+    const root = path.join(dataDir, COMPTES_RENDUS_FOLDER);
+    ensureAndClearDir(root);
+    const originalRoot = path.join(root, DATA_ORIGINAL_FOLDER);
+    fs.ensureDirSync(originalRoot);
+    const transformedRoot = path.join(root, DATA_TRANSFORMED_FOLDER);
+    if (options["parseDebats"])
+        fs.ensureDirSync(transformedRoot);
+    const sessions = getSessionsFromStart(options["fromSession"]);
+    // 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…");
+    for (const session of sessions) {
+        const dir = path.join(originalRoot, String(session));
+        if (await fs.pathExists(dir)) {
+            for (const f of await fs.readdir(dir))
+                if (/\.xml$/i.test(f))
+                    await fs.remove(path.join(dir, f));
+        }
+    }
+    const n = await extractAndDistributeXmlBySession(zipPath, originalRoot);
+    if (n === 0) {
+        console.warn("[CRI] No XML extracted. Archive empty or layout changed?");
+    }
+    else {
+        console.log(`[CRI] Distributed ${n} XML file(s) into session folders.`);
+    }
+    if (!options["parseDebats"]) {
+        console.log("[CRI] parseDebats not requested → done.");
         return;
-    const parsedFilePath = path.parse(compteRenduPath);
-    fs.writeJSONSync(path.join(transformedComptesRendusSessionDir, `${parsedFilePath.name}.json`), parsed, { spaces: 2 });
+    }
+    for (const session of sessions) {
+        const originalSessionDir = path.join(originalRoot, String(session));
+        if (!(await fs.pathExists(originalSessionDir))) {
+            continue;
+        }
+        const xmlFiles = (await fs.readdir(originalSessionDir))
+            .filter((f) => /^d\d{8}\.xml$/i.test(f))
+            .sort();
+        const transformedSessionDir = path.join(transformedRoot, String(session));
+        if (options["parseDebats"])
+            await fs.ensureDir(transformedSessionDir);
+        for (const f of xmlFiles) {
+            const yyyymmdd = f.slice(1, 9);
+            const xmlPath = path.join(originalSessionDir, f);
+            // 1) Deduce slot(s) from agenda if it exsits
+            const agendaInfo = loadAgendaSPSlotsForDate(dataDir, yyyymmdd, session);
+            const firstSlotOfDay = pickFirstSlotOfDay(agendaInfo?.slots ?? []);
+            // 2) Detect slots from CRI content
+            let slotsInCri = [];
+            try {
+                const raw = await fs.readFile(xmlPath, "utf8");
+                const $ = cheerio.load(raw, { xml: false });
+                const order = $("body *").toArray();
+                const idx = new Map(order.map((el, i) => [el, i]));
+                const intervals = computeIntervalsBySlot($, idx, firstSlotOfDay ?? undefined);
+                const uniq = new Set();
+                for (const iv of intervals)
+                    if (iv.slot && iv.slot !== "UNKNOWN")
+                        uniq.add(iv.slot);
+                slotsInCri = Array.from(uniq);
+            }
+            catch (e) {
+                console.warn(`[CRI] [${session}] Cannot read/parse ${f}:`, e);
+                continue;
+            }
+            if (slotsInCri.length === 0) {
+                slotsInCri = [firstSlotOfDay ?? "MATIN"];
+            }
+            // 3) Parse & write each slot
+            for (const slot of slotsInCri) {
+                const outName = `CRSSN${yyyymmdd}-${slot}.json`;
+                const cr = await parseCompteRenduSlotFromFile(xmlPath, slot, firstSlotOfDay ?? slot);
+                if (!cr) {
+                    console.warn(`[CRI] [${session}] Empty or no points for ${yyyymmdd} (${slot}) → skip`);
+                    continue;
+                }
+                const outDir = transformedSessionDir;
+                await fs.ensureDir(outDir);
+                const outPath = path.join(outDir, outName);
+                await fs.writeJSON(outPath, cr, { spaces: 2 });
+                try {
+                    await linkCriSlotIntoAgendaGrouped(dataDir, yyyymmdd, slot, cr.uid, cr, session);
+                }
+                catch (e) {
+                    console.warn(`[AGENDA] [${session}] Could not link CR into grouped for ${yyyymmdd} ${slot}:`, e);
+                }
+            }
+        }
+    }
 }
 async function main() {
     const dataDir = options["dataDir"];
     assert(dataDir, "Missing argument: data directory");
-    const sessions = getSessionsFromStart(options["fromSession"]);
-    console.time("comptes-rendus processing time");
-    await retrieveComptesRendus(dataDir, sessions);
+    console.time("CRI processing time");
+    await retrieveCriXmlDump(dataDir, options);
     if (!options["silent"]) {
-        console.timeEnd("comptes-rendus processing time");
+        console.timeEnd("CRI processing time");
     }
 }
 main()
     .then(() => process.exit(0))
     .catch((error) => {
-    console.log(error);
+    console.error(error);
     process.exit(1);
 });
+async function linkCriSlotIntoAgendaGrouped(dataDir, yyyymmdd, slot, crUid, cr, session) {
+    const groupedDir = path.join(dataDir, AGENDA_FOLDER, DATA_TRANSFORMED_FOLDER, session.toString());
+    fs.ensureDirSync(groupedDir);
+    const groupedPath = path.join(groupedDir, 'RUSN' + yyyymmdd + 'IDS-' + slot + '.json');
+    let groups = [];
+    if (fs.existsSync(groupedPath)) {
+        try {
+            groups = JSON.parse(fs.readFileSync(groupedPath, "utf8"));
+            if (!Array.isArray(groups))
+                groups = [];
+        }
+        catch (e) {
+            console.warn(`[AGENDA] unreadable grouped JSON → ${groupedPath} (${e}) → recreating`);
+            groups = [];
+        }
+    }
+    // find existing group with same slot
+    const sameSlot = groups.filter(g => g?.slot === slot);
+    let target = null;
+    if (sameSlot.length > 1) {
+        console.warn(`[AGENDA] multiple groups for ${yyyymmdd} ${slot} in ${groupedPath} → linking the first`);
+    }
+    target = sameSlot[0] ?? null;
+    const dateISO = `${yyyymmdd.slice(0, 4)}-${yyyymmdd.slice(4, 6)}-${yyyymmdd.slice(6, 8)}`;
+    const sommaire = cr?.metadonnees?.sommaire;
+    const { titre: dTitre, objet: dObjet } = deriveTitreObjetFromSommaire(sommaire, slot);
+    if (!target) {
+        const newGroup = {
+            uid: makeGroupUid(dateISO, slot),
+            chambre: "SN",
+            date: dateISO,
+            slot,
+            type: "Séance publique",
+            startTime: null,
+            endTime: null,
+            captationVideo: false,
+            titre: dTitre,
+            objet: dObjet || "",
+            reunions: [],
+            compteRenduRefUid: crUid,
+        };
+        groups.push(newGroup);
+    }
+    else {
+        target.compteRenduRefUid = crUid;
+    }
+    await fs.writeJSON(groupedPath, groups, { spaces: 2 });
+    console.log(`[AGENDA] Linked CR ${crUid} → ${path.basename(groupedPath)} [${slot}]`);
+}

package/lib/scripts/retrieve_open_data.js

@@ -79,6 +79,8 @@ async function copyToSenat(dataset, dataDir, options) {
     const schemaDumpFile = path.join(dataDir, `${dataset.database}_schema_dump.sql`);
     // Write the header and then stream the rest of the SQL file
     const schemaSqlWriter = fs.createWriteStream(schemaDumpFile, { encoding: "utf8" });
+    // Add CREATE SCHEMA statement at the top
+    schemaSqlWriter.write(`CREATE SCHEMA IF NOT EXISTS ${dataset.database};\n`);
     const lineReader = readline.createInterface({
         input: fs.createReadStream(sqlFilePath, { encoding: "utf8" }),
         crlfDelay: Infinity,
@@ -110,9 +112,9 @@ async function copyToSenat(dataset, dataDir, options) {
         schemaSqlWriter.on("finish", () => {
             try {
                 execSync(`${options["sudo"] ? `sudo -u ${options["sudo"]} ` : ""}psql --quiet -d senat -f ${schemaDumpFile}`, {
-                    cwd: dataDir,
                     env: process.env,
                     encoding: "utf-8",
+                    stdio: ["ignore", "ignore", "pipe"],
                 });
             }
             finally {

package/lib/scripts/retrieve_videos.js

@@ -7,6 +7,7 @@ import path from "path";
 import { AGENDA_FOLDER, DATA_TRANSFORMED_FOLDER, iterLoadSenatAgendas, } from "../loaders";
 import { getSessionsFromStart } from "../types/sessions";
 import { commonOptions } from "./shared/cli_helpers";
+import { formatYYYYMMDD, makeReunionUid } from "../utils/reunion_grouping";
 // ===================== Constants =====================
 const MATCH_THRESHOLD = 0.60;
 const MAX_CANDIDATES = 15;
@@ -136,15 +137,6 @@ function toFRDate(dateYYYYMMDD) {
     const [y, m, d] = dateYYYYMMDD.split("-");
     return `${d}/${m}/${y}`; // DD/MM/YYYY
 }
-function formatYYYYMMDD(dateYYYYMMDD) {
-    const [y, m, d] = dateYYYYMMDD.split("-");
-    return `${y}${m}${d}`;
-}
-function makeReunionUid(agenda) {
-    // agenda.date is expected as "YYYY-MM-DD"
-    const ymd = agenda.date ? formatYYYYMMDD(agenda.date) : "00000000";
-    return `${ymd}-${agenda.id}`;
-}
 function extractCandidatesFromSearchHtml(html) {
     const out = [];
     const re = /href="\/?video\.(\d+)_([a-z0-9]+)\.[^"]+"/gi;

package/lib/types/agenda.d.ts

@@ -12,6 +12,23 @@ export interface AgendaEvent {
     captationVideo: boolean;
     urlDossierSenat: string | null;
     quantieme: string | null;
-    urlVideo: string | null;
-    timecodeDebutVideo: number | null;
+}
+export type TimeSlot = "MATIN" | "APRES-MIDI" | "SOIR" | "UNKNOWN";
+export interface GroupedReunion {
+    uid: string;
+    chambre: "SN";
+    date: string;
+    slot?: TimeSlot;
+    startTime: string | null;
+    endTime: string | null;
+    captationVideo: boolean;
+    titre: string;
+    type: string;
+    organe?: string;
+    objet?: string;
+    lieu?: string;
+    reunions: AgendaEvent[];
+    compteRenduRefUid?: string;
+    urlVideo?: string;
+    timecodeDebutVideo?: number;
 }

package/lib/types/compte_rendu.d.ts

@@ -20,7 +20,7 @@ export interface Metadonnees {
     version: string;
     environnement: string;
     heureGeneration: Date;
-    sommaire: Sommaire;
+    sommaire?: Sommaire;
 }
 export interface Contenu {
     quantiemes: Quantiemes;

package/lib/utils/cr_spliting.d.ts

@@ -0,0 +1,7 @@
+import { TimeSlot } from "../types/agenda";
+import * as cheerio from "cheerio";
+export declare function computeIntervalsBySlot($: cheerio.CheerioAPI, idx: Map<any, number>, firstSlotOfDay?: TimeSlot): {
+    slot: TimeSlot;
+    start: number;
+    end: number;
+}[];

package/lib/utils/cr_spliting.js

@@ -0,0 +1,125 @@
+export function computeIntervalsBySlot($, idx, firstSlotOfDay) {
+    const all = $("body *").toArray();
+    const cuts = [{ pos: 0, hhmm: undefined }];
+    $('a[name]').each((_, a) => {
+        const name = (a.attribs?.["name"] || "").trim();
+        if (!/^su/i.test(name))
+            return;
+        const pos = idx.get(a);
+        if (pos == null)
+            return;
+        const hhmm = hhmmFromSuName(name); // "SU1620" -> "1620"
+        cuts.push({ pos, hhmm });
+    });
+    cuts.sort((a, b) => a.pos - b.pos);
+    cuts.push({ pos: all.length, hhmm: undefined });
+    let initialSlot = firstSlotOfDay;
+    if (!initialSlot) {
+        const openHHMM = extractOpeningHHMM($);
+        if (openHHMM)
+            initialSlot = slotOfHHMM(openHHMM);
+    }
+    if (!initialSlot)
+        initialSlot = "MATIN";
+    const intervals = [];
+    let lastSlot = initialSlot;
+    for (let i = 0; i + 1 < cuts.length; i++) {
+        const start = cuts[i].pos;
+        const end = cuts[i + 1].pos;
+        if (end <= start)
+            continue;
+        // i=0  initialSlot
+        // i>0 : if current cut has SU -> slotOfHHMM, otherwise lastSlot
+        const slot = i === 0 ? initialSlot : (cuts[i].hhmm ? slotOfHHMM(cuts[i].hhmm) : lastSlot);
+        intervals.push({ slot, start, end });
+        lastSlot = slot;
+    }
+    return intervals;
+}
+function hhmmFromSuName(name) {
+    const m = name.match(/^SU(\d{2})(\d{2})$/i);
+    if (!m)
+        return;
+    return `${m[1]}:${m[2]}`;
+}
+function slotOfHHMM(hhmm) {
+    if (!hhmm)
+        return "MATIN";
+    const [h, m] = hhmm.split(":").map(Number);
+    const v = h + m / 60;
+    if (v < 12)
+        return "MATIN";
+    if (v < 18.5)
+        return "APRES-MIDI";
+    return "SOIR";
+}
+// Looks for text like "(La séance est ouverte à quinze heures.)" and extracts "HH:MM"
+function extractOpeningHHMM($) {
+    let txt = "";
+    $("span.info_entre_parentheses, .info_entre_parentheses").each((_, el) => {
+        const t = ($(el).text() || "").replace(/\s+/g, " ").trim();
+        if (!txt && /\bs[eé]ance est ouverte\b/i.test(t))
+            txt = t;
+    });
+    if (!txt)
+        return undefined;
+    const inner = txt.match(/\(.*?ouverte\s+à\s+([^)]+?)\)/i)?.[1];
+    if (!inner)
+        return undefined;
+    return parseFrenchClockToHHMM(inner);
+}
+// Convert "quinze heures trente", "15 heures 30", "dix-sept heures moins le quart", etc. en "HHMM"
+function parseFrenchClockToHHMM(input) {
+    const s = (input || "").toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").trim();
+    if (!s)
+        return undefined;
+    const digitMatch = s.match(/(\d{1,2})\s*heures?(?:\s*(\d{1,2}))?/);
+    if (digitMatch) {
+        const h = Math.min(24, Math.max(0, parseInt(digitMatch[1], 10)));
+        const m = digitMatch[2] ? Math.min(59, Math.max(0, parseInt(digitMatch[2], 10))) : 0;
+        return `${String(h).padStart(2, "0")}${String(m).padStart(2, "0")}`;
+    }
+    const NUM = new Map([
+        ["zero", 0], ["une", 1], ["un", 1], ["deux", 2], ["trois", 3], ["quatre", 4], ["cinq", 5], ["six", 6],
+        ["sept", 7], ["huit", 8], ["neuf", 9], ["dix", 10], ["onze", 11], ["douze", 12], ["treize", 13],
+        ["quatorze", 14], ["quinze", 15], ["seize", 16], ["dix-sept", 17], ["dix sept", 17], ["dix-huit", 18],
+        ["dix huit", 18], ["dix-neuf", 19], ["dix neuf", 19], ["vingt", 20], ["vingt et une", 21],
+        ["vingt-et-une", 21], ["vingt et un", 21], ["vingt-et-un", 21], ["vingt-deux", 22], ["vingt deux", 22],
+        ["vingt-trois", 23], ["vingt trois", 23], ["vingt-quatre", 24], ["vingt quatre", 24],
+    ]);
+    const hourWordMatch = s.match(/([a-z\- ]+?)\s*heures?/);
+    if (!hourWordMatch)
+        return undefined;
+    const hourWord = hourWordMatch[1].trim();
+    let hour = NUM.get(hourWord);
+    if (hour == null) {
+        const cleaned = hourWord.replace(/\s+/g, " ");
+        hour = NUM.get(cleaned);
+    }
+    if (hour == null)
+        return undefined;
+    let minutes = 0;
+    if (/\bet (demie|demi)\b/.test(s))
+        minutes = 30;
+    else if (/\bet quart\b/.test(s))
+        minutes = 15;
+    else if (/\bmoins le quart\b/.test(s)) {
+        hour = (hour + 23) % 24;
+        minutes = 45;
+    }
+    else {
+        const MIN = new Map([
+            ["cinq", 5], ["dix", 10], ["quinze", 15], ["vingt", 20], ["vingt-cinq", 25], ["vingt cinq", 25],
+            ["trente", 30], ["trente-cinq", 35], ["trente cinq", 35], ["quarante", 40], ["quarante-cinq", 45],
+            ["quarante cinq", 45], ["cinquante", 50], ["cinquante-cinq", 55], ["cinquante cinq", 55],
+        ]);
+        const minWordMatch = s.match(/heures?\s+([a-z\- ]+?)(?:[).,;]|$)/);
+        if (minWordMatch) {
+            const mw = minWordMatch[1].trim();
+            const m1 = MIN.get(mw);
+            if (m1 != null)
+                minutes = m1;
+        }
+    }
+    return `${String(hour).padStart(2, "0")}${String(minutes).padStart(2, "0")}`;
+}

package/lib/utils/reunion_grouping.d.ts

@@ -0,0 +1,6 @@
+import { AgendaEvent, GroupedReunion, TimeSlot } from "../types/agenda";
+export declare function groupNonSPByTypeOrganeHour(events: AgendaEvent[]): Record<"IDC" | "IDM" | "IDO" | "IDI", GroupedReunion[]>;
+export declare function groupSeancePubliqueBySlot(events: AgendaEvent[]): GroupedReunion[];
+export declare function makeGroupUid(date: string, slot: TimeSlot): string;
+export declare function formatYYYYMMDD(dateYYYYMMDD: string): string;
+export declare function makeReunionUid(agenda: AgendaEvent): string;