@tricoteuses/senat 3.1.21 → 3.1.22

package/lib/src/debats.d.ts

@@ -0,0 +1,38 @@
+export interface DebatAuteurRow {
+    code: string | null;
+    matricule: string | null;
+    nom: string | null;
+    prenom: string | null;
+}
+export interface DebatInterventionRow {
+    analyse: string | null;
+    auteur: DebatAuteurRow | null;
+    auteur_code: string;
+    fonction_intervenant: string | null;
+    id: string | null;
+    url: string | null;
+}
+export interface DebatSectionRow {
+    categorie: string | null;
+    id?: string | null;
+    interventions: DebatInterventionRow[];
+    lecture_id?: string | null;
+    libelle?: string | null;
+    numero?: string | null;
+    objet: string | null;
+    type: string | null;
+    url?: string | null;
+}
+export interface DebatLectureRow {
+    id: string;
+}
+export interface DebatResult {
+    date_seance: string | null;
+    etat_synchronisation: string | null;
+    id: string | null;
+    lectures: DebatLectureRow[];
+    numero: string | null;
+    sections: DebatSectionRow[];
+    sections_divers: DebatSectionRow[];
+    url: string | null;
+}

package/lib/src/debats.js

@@ -0,0 +1 @@
+export {};

package/lib/src/dosleg.d.ts

@@ -0,0 +1,142 @@
+export interface DossierThemeRow {
+    libelle: string;
+}
+export type DossierAuteurRow = {
+    matricule: string | null;
+    nom_usuel: string;
+    ordre: string | null;
+    prenom: string | null;
+    qualite: string | null;
+    role: string | null;
+};
+export type DossierDocumentAnnexeRow = {
+    type_document: string;
+    url: string | null;
+};
+export type DossierTexte = {
+    auteurs?: DossierAuteurRow[] | null;
+    code_adoption?: string | null;
+    code_organisme?: string | null;
+    date?: string | null;
+    id?: string | null;
+    modification?: string | null;
+    numero?: number | string | null;
+    ordre_origine?: string | null;
+    origine?: string | null;
+    session?: number | null;
+    titre?: string | null;
+    type?: string | null;
+    url?: string | null;
+};
+export type DossierRapport = {
+    auteurs?: DossierAuteurRow[] | null;
+    code_organisme?: string | null;
+    date?: string | null;
+    documents_annexes?: DossierDocumentAnnexeRow[] | null;
+    id?: string | null;
+    numero?: number | string | null;
+    session?: number | null;
+    sous_titre?: string | null;
+    titre?: string | null;
+    type?: string | null;
+    url?: string | null;
+};
+export type DossierDateSeance = {
+    date?: string | null;
+};
+export type DossierLectureAssemblee = {
+    assemblee?: string | null;
+    code_organisme?: string | null;
+    date_publication_amendements_commission?: string | null;
+    date_publication_amendements_seance?: string | null;
+    dates_seances?: DossierDateSeance[] | null;
+    libelle_organisme?: string | null;
+    loi_intitule_modifie?: string | null;
+    numero_petite_loi?: number | null;
+    ordre_lecture_assemblee?: string | null;
+    origine_proposition?: string | null;
+    rapports?: DossierRapport[] | null;
+    session?: number | null;
+    textes?: DossierTexte[] | null;
+    url_cr_debats?: string | null;
+    url_petite_loi?: string | null;
+};
+export type DossierLecture = {
+    lectures_assemblee?: DossierLectureAssemblee[] | null;
+    libelle?: string | null;
+    ordre_lecture?: number | string | null;
+    type_lecture?: string | null;
+};
+export interface DossierLegislatifResult {
+    code: string | null;
+    code_dossier_an: string | null;
+    code_nature_dossier: string | null;
+    code_organisme_resolution: string | null;
+    condition_saisine_CoC: string | null;
+    date_decision_CoC: string | null;
+    date_opposition_procedure_acceleree: string | null;
+    date_procedure_acceleree: string | null;
+    date_publication_JO: string | null;
+    date_publication_JO_correctif_1: string | null;
+    date_publication_JO_correctif_2: string | null;
+    date_promulgation: string | null;
+    date_retrait_procedure_acceleree: string | null;
+    date_saisine_CoC: string | null;
+    etat_dossier: string | null;
+    lectures: DossierLecture[];
+    libelle_decision_CoC: string | null;
+    libelle_type_dossier: string | null;
+    mot_cle: string | null;
+    num_decision_CoC: string | null;
+    numero: string | null;
+    numero_JO: string | null;
+    numero_JO_correctif_1: string | null;
+    numero_JO_correctif_2: string | null;
+    signet: string;
+    signet_alternatif: string | null;
+    themes: DossierThemeRow[];
+    titre: string | null;
+    titre_JO: string;
+    titre_court: string | null;
+    titre_long: string | null;
+    titre_long_original: string | null;
+    urgence: string | null;
+    url: string;
+    url_JO: string | null;
+    url_JO_correctif_1: string | null;
+    url_JO_correctif_2: string | null;
+    url_decision_CoC: string | null;
+    url_dossier_assemblee_nationale: string | null;
+    url_dossier_CoC: string | null;
+    url_ordonnance: string | null;
+    url_presentation_articles: string | null;
+}
+export type DossierWithLectures = DossierLegislatifResult & {
+    actes_legislatifs?: ActeLegislatif[] | null;
+    lectures?: DossierLecture[] | null;
+    numero_JO?: string | number | null;
+    signet: string;
+    themes?: DossierThemeRow[] | null;
+    url_JO?: string | null;
+    url_decision_CoC?: string | null;
+    url_dossier_CoC?: string | null;
+};
+export type ActeLegislatif = {
+    adoption?: string;
+    chambre: "AN" | "SN";
+    code_acte: string;
+    code_organisme: string | null;
+    date: string;
+    date_publication_JO?: string | null;
+    id?: string | null;
+    libelle: string;
+    numero?: string | number | null;
+    numero_JO?: string | number | null;
+    session?: number | null;
+    signet_dossier: string;
+    texte_url?: string | null;
+    uid: string;
+    url_legifrance?: string | null;
+};
+export declare function getCodeActeLecture(codeNatureDossier: string, typeLecture: string, assemblee: string): string | null;
+export declare function buildActesLegislatifs(dossier: DossierWithLectures): ActeLegislatif[];

package/lib/src/dosleg.js

@@ -0,0 +1,193 @@
+export function getCodeActeLecture(codeNatureDossier, typeLecture, assemblee) {
+    const codeAssemblee = assemblee === "Sénat" ? "SN" : assemblee === "Assemblée nationale" ? "AN" : null;
+    if (typeLecture === "Commission mixte paritaire") {
+        return "CMP";
+    }
+    if (!codeAssemblee) {
+        return null;
+    }
+    if (["ppl", "pjl", "cvn"].includes(codeNatureDossier) && typeLecture === "Première lecture") {
+        return `${codeAssemblee}1`;
+    }
+    if (["ppl", "pjl", "cvn"].includes(codeNatureDossier) && typeLecture === "Deuxième lecture") {
+        return `${codeAssemblee}2`;
+    }
+    if (["ppl", "pjl", "cvn"].includes(codeNatureDossier) && typeLecture === "Troisième lecture") {
+        return `${codeAssemblee}3`;
+    }
+    if (["ppl", "pjl", "cvn"].includes(codeNatureDossier) && typeLecture === "Quatrième lecture") {
+        return `${codeAssemblee}4`;
+    }
+    if (["ppl", "pjl", "cvn"].includes(codeNatureDossier) && typeLecture === "Nouvelle lecture") {
+        return `${codeAssemblee}NLEC`;
+    }
+    if (["ppl", "pjl", "cvn"].includes(codeNatureDossier) && typeLecture === "Lecture définitive") {
+        return `${codeAssemblee}LDEF`;
+    }
+    if (["ppr"].includes(codeNatureDossier) && typeLecture === "Première lecture") {
+        return `${codeAssemblee}LUNI`;
+    }
+    return null;
+}
+function getDateSortValue(value) {
+    if (!value) {
+        return Number.POSITIVE_INFINITY;
+    }
+    const timestamp = new Date(value).getTime();
+    return Number.isNaN(timestamp) ? Number.POSITIVE_INFINITY : timestamp;
+}
+function compareByDate(left, right) {
+    return getDateSortValue(left.date) - getDateSortValue(right.date);
+}
+function getPhasePrefix(lecture, assemblee) {
+    if (assemblee !== "Sénat")
+        return null;
+    const typeLibelle = (lecture.type_lecture || "").toLowerCase();
+    if (typeLibelle.includes("cmp") || typeLibelle.includes("mixte"))
+        return "CMP";
+    if (typeLibelle.includes("nouvelle lecture"))
+        return "SNNLEC";
+    if (typeLibelle.includes("définitive"))
+        return "SNLDEF";
+    if (typeLibelle.includes("unique"))
+        return "SNLUNI";
+    if (lecture.ordre_lecture) {
+        return `SN${lecture.ordre_lecture}`;
+    }
+    if (typeLibelle.includes("première"))
+        return "SN1";
+    if (typeLibelle.includes("deuxième") || typeLibelle.includes("seconde"))
+        return "SN2";
+    return "SN1";
+}
+export function buildActesLegislatifs(dossier) {
+    const actes = [];
+    const loiSignet = dossier.signet;
+    const lectures = dossier.lectures ?? [];
+    for (const lecture of lectures) {
+        const lecturesAssemblee = lecture.lectures_assemblee ?? [];
+        for (const lecAss of lecturesAssemblee) {
+            if (lecAss.assemblee !== "Sénat")
+                continue;
+            const phasePrefix = getPhasePrefix(lecture, lecAss.assemblee);
+            if (!phasePrefix)
+                continue;
+            const textes = lecAss.textes ?? [];
+            const textesTries = [...textes].sort(compareByDate);
+            const depotTexte = textesTries.find((t) => (t.origine || "").toLowerCase().includes("déposé") ||
+                (t.origine || "").toLowerCase().includes("transmis") ||
+                t.ordre_origine === "0");
+            if (depotTexte && depotTexte.date) {
+                actes.push({
+                    code_acte: `${phasePrefix}-DEPOT`,
+                    date: depotTexte.date,
+                    libelle: `Dépôt du texte n°${depotTexte.numero}`,
+                    id: depotTexte.id,
+                    numero: depotTexte.numero,
+                    uid: `${loiSignet}-${phasePrefix}-DEPOT`,
+                    session: lecAss.session,
+                    chambre: "SN",
+                    signet_dossier: loiSignet,
+                    texte_url: depotTexte.url,
+                    code_organisme: null,
+                });
+            }
+            const rapports = lecAss.rapports ?? [];
+            for (const rap of rapports) {
+                if (rap.date) {
+                    actes.push({
+                        code_acte: `${phasePrefix}-COM-FOND`,
+                        date: rap.date,
+                        libelle: `Rapport n°${rap.numero} de la commission`,
+                        id: rap.id,
+                        numero: rap.numero,
+                        code_organisme: rap.code_organisme ?? null,
+                        uid: `${loiSignet}-${phasePrefix}-COM`,
+                        session: lecAss.session,
+                        chambre: "SN",
+                        signet_dossier: loiSignet,
+                        texte_url: rap.url,
+                    });
+                }
+            }
+            const datesSeances = lecAss.dates_seances ?? [];
+            if (datesSeances.length > 0) {
+                datesSeances.sort(compareByDate);
+                const premiereSeance = datesSeances[0];
+                if (premiereSeance && premiereSeance.date) {
+                    actes.push({
+                        code_acte: `${phasePrefix}-DEBATS-SEANCE`,
+                        date: premiereSeance.date,
+                        libelle: "Discussion en séance publique",
+                        id: null,
+                        uid: `${loiSignet}-${phasePrefix}-DEBATS-SEANCE`,
+                        session: lecAss.session,
+                        chambre: "SN",
+                        signet_dossier: loiSignet,
+                        code_organisme: null,
+                    });
+                }
+            }
+            const texteFinal = [...textesTries].reverse().find((t) => {
+                const origine = (t.origine || "").toLowerCase();
+                return (origine.includes("adopté") ||
+                    origine.includes("rejeté") ||
+                    origine.includes("devenu résolution") ||
+                    t.code_adoption === "O");
+            });
+            if (texteFinal && texteFinal.date) {
+                const origine = (texteFinal.origine || "").toLowerCase();
+                let libelleStatut = "Adopté";
+                if (origine.includes("rejeté")) {
+                    libelleStatut = "Rejeté";
+                }
+                else if (origine.includes("devenue résolution")) {
+                    libelleStatut = "Adopté";
+                }
+                actes.push({
+                    code_acte: `${phasePrefix}-DEBATS-DEC`,
+                    date: texteFinal.date,
+                    libelle: `${libelleStatut === "Adopté" ? "Adoption" : "Rejet"} (Texte n°${texteFinal.numero})`,
+                    id: texteFinal.id,
+                    numero: texteFinal.numero,
+                    adoption: libelleStatut,
+                    uid: `${loiSignet}-DEC-${texteFinal.numero}`,
+                    session: lecAss.session,
+                    chambre: "SN",
+                    signet_dossier: loiSignet,
+                    texte_url: texteFinal.url,
+                    code_organisme: null,
+                });
+            }
+        }
+    }
+    if (dossier.date_decision_CoC) {
+        actes.push({
+            code_acte: "CC",
+            date: dossier.date_decision_CoC,
+            libelle: "Décision du Conseil constitutionnel",
+            id: dossier.url_decision_CoC,
+            uid: `${loiSignet}-CC`,
+            chambre: "AN",
+            signet_dossier: loiSignet,
+            code_organisme: null,
+            texte_url: dossier.url_decision_CoC || dossier.url_dossier_CoC,
+        });
+    }
+    if (dossier.date_promulgation) {
+        actes.push({
+            code_acte: "PROM",
+            date: dossier.date_promulgation,
+            libelle: "Promulgation de la loi",
+            date_publication_JO: dossier.date_publication_JO,
+            numero_JO: dossier.numero_JO,
+            url_legifrance: dossier.url_JO,
+            id: dossier.url_JO,
+            uid: `${loiSignet}-PROM`,
+            chambre: "AN",
+            signet_dossier: loiSignet,
+            code_organisme: null,
+        });
+    }
+    return actes.sort(compareByDate);
+}

package/lib/src/git.d.ts

@@ -0,0 +1,27 @@
+export declare function initRepo(repositoryDir: string): void;
+export declare function commit(repositoryDir: string, message: string): boolean;
+export declare function commitAndPush(repositoryDir: string, message: string, remotes?: string[]): number;
+export declare function pull(repositoryDir: string, remote?: string, branch?: string): boolean;
+export declare function resetAndPull(gitDir: string): boolean;
+export declare function clone(gitGroupUrl: string | undefined, gitName: string, workingDir: string): void;
+export declare function run(repositoryDir: string, args: string, verbose?: boolean): string;
+export declare function test(repositoryDir: string, args: string, verbose?: boolean): boolean;
+/**
+ * Information about a changed file in git
+ */
+export interface GitChangedFile {
+    path: string;
+    status: "A" | "M" | "D" | "R" | "C" | "T" | "U";
+}
+/**
+ * Get the list of files that have changed since a specific commit in a git repository.
+ * @param repositoryDir The directory of the git repository
+ * @param sinceCommit The commit hash to compare against (e.g., "HEAD~1", "abc123", etc.)
+ * @param options Options for filtering
+ * @param options.diffFilter Git diff-filter string (default: "AMR").
+ *        A=Added, M=Modified, D=Deleted, R=Renamed, C=Copied, T=Type changed, U=Unmerged
+ * @returns A Map of file paths to their git status
+ */
+export declare function getChangedFilesSinceCommit(repositoryDir: string, sinceCommit: string, options?: {
+    diffFilter?: string;
+}): Map<string, GitChangedFile["status"]>;

package/lib/src/git.js

@@ -0,0 +1,251 @@
+import { execSync } from "node:child_process";
+import fs from "fs-extra";
+import path from "node:path";
+const MAXBUFFER = 50 * 1024 * 1024;
+const GIT_LOCK_RETRY_DELAY_MS = 1000;
+const GIT_LOCK_RETRY_COUNT = 5;
+const GIT_LOCK_STALE_AFTER_MS = 2 * 60 * 1000;
+function asExecSyncError(error) {
+    return error;
+}
+function outputToString(output) {
+    if (output == null) {
+        return "";
+    }
+    return Buffer.isBuffer(output) ? output.toString("utf-8") : output;
+}
+function sleep(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function getIndexLockPath(repositoryDir) {
+    return path.join(repositoryDir, ".git", "index.lock");
+}
+function isIndexLockError(error) {
+    const stderr = error instanceof Error ? outputToString(asExecSyncError(error).stderr) : "";
+    return /index\.lock': File exists\./.test(stderr);
+}
+function removeStaleIndexLock(repositoryDir) {
+    const lockPath = getIndexLockPath(repositoryDir);
+    if (!fs.existsSync(lockPath)) {
+        return false;
+    }
+    const stats = fs.statSync(lockPath);
+    const ageMs = Date.now() - stats.mtimeMs;
+    if (ageMs < GIT_LOCK_STALE_AFTER_MS) {
+        return false;
+    }
+    fs.removeSync(lockPath);
+    return true;
+}
+function execGitWithIndexLockRecovery(command, repositoryDir, options) {
+    let lockRemoved = false;
+    for (let attempt = 1; attempt <= GIT_LOCK_RETRY_COUNT; attempt++) {
+        try {
+            execSync(command, {
+                cwd: repositoryDir,
+                ...options,
+            });
+            return;
+        }
+        catch (error) {
+            if (!isIndexLockError(error)) {
+                throw error;
+            }
+            if (!lockRemoved && removeStaleIndexLock(repositoryDir)) {
+                lockRemoved = true;
+                continue;
+            }
+            if (attempt === GIT_LOCK_RETRY_COUNT) {
+                throw error;
+            }
+            sleep(GIT_LOCK_RETRY_DELAY_MS);
+        }
+    }
+}
+export function initRepo(repositoryDir) {
+    if (!fs.existsSync(path.join(repositoryDir, ".git"))) {
+        fs.ensureDirSync(repositoryDir);
+        execSync("git init", {
+            cwd: repositoryDir,
+            env: process.env,
+            encoding: "utf-8",
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+    }
+}
+export function commit(repositoryDir, message) {
+    initRepo(repositoryDir);
+    execGitWithIndexLockRecovery("git add .", repositoryDir, {
+        env: process.env,
+        encoding: "utf-8",
+        stdio: ["ignore", "ignore", "pipe"],
+        maxBuffer: MAXBUFFER,
+    });
+    try {
+        execSync(`git commit -m "${message}" --quiet`, {
+            cwd: repositoryDir,
+            env: process.env,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return true;
+    }
+    catch (error) {
+        const childProcess = asExecSyncError(error);
+        if (childProcess.stdout === null || !/nothing to commit|rien à valider/.test(outputToString(childProcess.stdout))) {
+            console.error(childProcess.output);
+            throw childProcess;
+        }
+        return false;
+    }
+}
+export function commitAndPush(repositoryDir, message, remotes) {
+    let exitCode = 0;
+    if (commit(repositoryDir, message)) {
+        for (const remote of remotes || []) {
+            try {
+                execSync(`git push ${remote} master`, {
+                    cwd: repositoryDir,
+                    env: process.env,
+                    encoding: "utf-8",
+                    stdio: ["ignore", "ignore", "pipe"],
+                });
+            }
+            catch (error) {
+                const childProcess = asExecSyncError(error);
+                // Don't stop when push fails.
+                console.error(childProcess.output);
+                exitCode = childProcess.status ?? 1;
+            }
+        }
+    }
+    else {
+        // There was nothing to commit.
+        exitCode = 10;
+    }
+    return exitCode;
+}
+export function pull(repositoryDir, remote = "origin", branch = "master") {
+    initRepo(repositoryDir);
+    const statusOutput = execSync("git status --porcelain", {
+        cwd: repositoryDir,
+        env: process.env,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+        maxBuffer: MAXBUFFER,
+    }).trim();
+    if (statusOutput.length > 0) {
+        return false;
+    }
+    execSync(`git pull --rebase ${remote} ${branch}`, {
+        cwd: repositoryDir,
+        env: process.env,
+        encoding: "utf-8",
+        stdio: ["ignore", "ignore", "pipe"],
+        maxBuffer: MAXBUFFER,
+    });
+    return true;
+}
+export function resetAndPull(gitDir) {
+    execSync("git reset --hard origin/master", {
+        cwd: gitDir,
+        env: process.env,
+        encoding: "utf-8",
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    execSync("git pull --rebase", {
+        cwd: gitDir,
+        env: process.env,
+        encoding: "utf-8",
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    return true;
+}
+export function clone(gitGroupUrl, gitName, workingDir) {
+    if (gitGroupUrl !== undefined) {
+        execSync(`git clone ${gitGroupUrl}/${gitName}.git`, {
+            cwd: workingDir,
+            env: process.env,
+            encoding: "utf-8",
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+    }
+}
+export function run(repositoryDir, args, verbose) {
+    try {
+        if (verbose)
+            console.log(`git -C ${repositoryDir} ${args}`);
+        const output = execSync(`git ${args}`, {
+            cwd: repositoryDir,
+            maxBuffer: MAXBUFFER,
+        })
+            .toString()
+            .trim();
+        if (verbose)
+            console.log(output);
+        return output;
+    }
+    catch (error) {
+        const childProcess = asExecSyncError(error);
+        for (const output of ["stdout", "stderr"]) {
+            console.error(`${output}: ${outputToString(childProcess[output])}`);
+        }
+        throw childProcess;
+    }
+}
+export function test(repositoryDir, args, verbose) {
+    try {
+        if (verbose)
+            console.log(`git -C ${repositoryDir} ${args}`);
+        const output = execSync(`git ${args}`, {
+            cwd: repositoryDir,
+            stdio: ["ignore", "pipe", "pipe"],
+            maxBuffer: MAXBUFFER,
+        })
+            .toString()
+            .trim();
+        if (verbose)
+            console.log(output);
+        return true;
+    }
+    catch (error) {
+        const childProcess = asExecSyncError(error);
+        if (childProcess.status !== 0)
+            return false;
+        throw childProcess;
+    }
+}
+/**
+ * Get the list of files that have changed since a specific commit in a git repository.
+ * @param repositoryDir The directory of the git repository
+ * @param sinceCommit The commit hash to compare against (e.g., "HEAD~1", "abc123", etc.)
+ * @param options Options for filtering
+ * @param options.diffFilter Git diff-filter string (default: "AMR").
+ *        A=Added, M=Modified, D=Deleted, R=Renamed, C=Copied, T=Type changed, U=Unmerged
+ * @returns A Map of file paths to their git status
+ */
+export function getChangedFilesSinceCommit(repositoryDir, sinceCommit, options = {}) {
+    const { diffFilter } = options;
+    try {
+        // Using diff-filter: A = Added, M = Modified, R = Renamed, D = Deleted, etc.
+        // Default to AMR (excludes deleted files to prevent loading errors)
+        const filter = diffFilter ?? "AMR";
+        const output = run(repositoryDir, `diff --name-status --diff-filter=${filter} ${sinceCommit}`, false);
+        const changedFiles = new Map();
+        for (const line of output.split("\n")) {
+            if (line.trim().length === 0)
+                continue;
+            const parts = line.split("\t");
+            if (parts.length >= 2) {
+                const status = parts[0].charAt(0);
+                const path = parts[1];
+                changedFiles.set(path, status);
+            }
+        }
+        return changedFiles;
+    }
+    catch (error) {
+        console.error(`Error getting changed files since commit ${sinceCommit}:`, error);
+        return new Map();
+    }
+}