@tricoteuses/senat 2.22.10 → 2.22.11

package/lib/src/scripts/retrieve_documents.js

@@ -101,6 +101,9 @@ async function processDocument(url, destPath, docDate, options) {
 }
 export async function processTexte(texteMetadata, originalTextesDir, transformedTextesDir, enrichedTextesDir, options) {
     const texteDir = path.join(originalTextesDir, `${texteMetadata.session ?? UNDEFINED_SESSION}`, texteMetadata.name);
+    // Pre-compute whether the parsed JSON output already exists, to avoid re-parsing unchanged files
+    const parsedJsonPath = path.join(transformedTextesDir, `${texteMetadata.session ?? UNDEFINED_SESSION}`, texteMetadata.name, `${texteMetadata.name}.json`);
+    const parsedOutputExists = options.parseDocuments ? await fs.pathExists(parsedJsonPath) : false;
     let exposeDesMotifsContent = null;
     if (texteMetadata.url_expose_des_motifs) {
         const exposePath = path.join(texteDir, `${texteMetadata.name}-expose.html`);
@@ -108,7 +111,8 @@ export async function processTexte(texteMetadata, originalTextesDir, transformed
         if (res.buffer) {
             exposeDesMotifsContent = res.buffer;
         }
-        else if (res.skipped && options.parseDocuments) {
+        else if (res.skipped && options.parseDocuments && !parsedOutputExists) {
+            // Only load expose from disk if we'll actually need to re-parse
             if (await fs.pathExists(exposePath)) {
                 exposeDesMotifsContent = await fs.readFile(exposePath);
             }
@@ -128,23 +132,28 @@ export async function processTexte(texteMetadata, originalTextesDir, transformed
         const result = await processDocument(format.url.toString(), destPath, texteMetadata.date, options);
         // Specific logic: Parsing (Only applies to XML)
         if (format.isParseTarget && options.parseDocuments) {
-            if (result.buffer !== null || (await fs.pathExists(destPath))) {
+            // Skip re-parsing if the XML was not newly downloaded AND the parsed output already exists
+            const needsParsing = !result.skipped || !parsedOutputExists;
+            if (needsParsing && (result.buffer !== null || (await fs.pathExists(destPath)))) {
                 await parseDocument(texteMetadata.session, transformedTextesDir, destPath, texteMetadata.name, result.buffer, exposeDesMotifsContent, options);
-            }
-            let texteXmlContent = null;
-            if (result.buffer === null && (await fs.pathExists(destPath))) {
-                texteXmlContent = await fs.readFile(destPath, "utf-8");
-            }
-            else if (result.buffer !== null) {
-                texteXmlContent = textDecoder.decode(result.buffer);
-            }
-            if (texteXmlContent !== null) {
-                try {
-                    await convertSenatXmlToHtml(texteXmlContent, path.join(enrichedTextesDir, `${texteMetadata.session ?? UNDEFINED_SESSION}`, texteMetadata.name, `${texteMetadata.name}.html`));
+                let texteXmlContent = null;
+                if (result.buffer === null && (await fs.pathExists(destPath))) {
+                    texteXmlContent = await fs.readFile(destPath, "utf-8");
                 }
-                catch (error) {
-                    console.error(`Error converting ${texteMetadata.name} to HTML: ${error.message}`);
+                else if (result.buffer !== null) {
+                    texteXmlContent = textDecoder.decode(result.buffer);
                 }
+                if (texteXmlContent !== null) {
+                    try {
+                        await convertSenatXmlToHtml(texteXmlContent, path.join(enrichedTextesDir, `${texteMetadata.session ?? UNDEFINED_SESSION}`, texteMetadata.name, `${texteMetadata.name}.html`));
+                    }
+                    catch (error) {
+                        console.error(`Error converting ${texteMetadata.name} to HTML: ${error.message}`);
+                    }
+                }
+            }
+            else if (options.verbose) {
+                console.info(`Skipping parse for already processed texte ${texteMetadata.name}…`);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tricoteuses/senat",
-  "version": "2.22.10",
+  "version": "2.22.11",
   "description": "Handle French Sénat's open data",
   "keywords": [
     "France",

package/lib/config.d.ts

@@ -1,21 +0,0 @@
-import "dotenv/config";
-import { z } from "zod";
-export declare const configSchema: z.ZodObject<{
-    db: z.ZodObject<{
-        host: z.ZodString;
-        name: z.ZodString;
-        password: z.ZodString;
-        port: z.ZodCoercedNumber<unknown>;
-        user: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-declare const _default: {
-    db: {
-        host: string;
-        name: string;
-        password: string;
-        port: number;
-        user: string;
-    };
-};
-export default _default;

package/lib/config.js

@@ -1,27 +0,0 @@
-import "dotenv/config";
-import { z } from "zod";
-const dbSchema = z.object({
-    host: z.string().trim().min(1, "Must not be empty"),
-    name: z.string().trim().min(1, "Must not be empty"),
-    password: z.string().trim().min(1, "Must not be empty"),
-    port: z.coerce.number().int().min(0).max(65535),
-    user: z.string().trim().min(1, "Must not be empty"),
-});
-export const configSchema = z.object({
-    db: dbSchema,
-});
-const config = {
-    db: {
-        host: process.env["TRICOTEUSES_SENAT_DB_HOST"] || "localhost",
-        name: process.env["TRICOTEUSES_SENAT_DB_NAME"] || "postgres",
-        password: process.env["TRICOTEUSES_SENAT_DB_PASSWORD"] || "opendata",
-        port: process.env["TRICOTEUSES_SENAT_DB_PORT"] || 5432,
-        user: process.env["TRICOTEUSES_SENAT_DB_USER"] || "opendata",
-    },
-};
-const result = configSchema.safeParse(config);
-if (!result.success) {
-    console.error(`Error in configuration:\n${JSON.stringify(config, null, 2)}\nError:\n${JSON.stringify(result.error.issues, null, 2)}`);
-    process.exit(-1);
-}
-export default result.data;

package/lib/databases.d.ts

@@ -1,2 +0,0 @@
-import { Kysely } from "kysely";
-export declare const dbSenat: Kysely<any>;

package/lib/databases.js

@@ -1,26 +0,0 @@
-import { Kysely, PostgresDialect } from "kysely";
-import * as pg from "pg";
-import { types } from "pg";
-import Cursor from "pg-cursor";
-import config from "./config";
-// Map int8 to number instead of string
-// https://github.com/brianc/node-pg-types#use
-pg.types.setTypeParser(types.builtins.INT8, (val) => {
-    return parseInt(val, 10);
-});
-const senatPool = new pg.Pool({
-    database: "senat",
-    host: config.db.host,
-    user: config.db.user,
-    password: config.db.password,
-    port: config.db.port,
-    max: 10,
-});
-const senatDialect = new PostgresDialect({
-    pool: senatPool,
-    cursor: Cursor,
-});
-export const dbSenat = new Kysely({
-    log: ["error"],
-    dialect: senatDialect,
-});

package/lib/datasets.d.ts

@@ -1,34 +0,0 @@
-export interface Dataset {
-    database: string;
-    repairEncoding: boolean;
-    repairZip?: (dataset: Dataset, dataDir: string) => void;
-    title: string;
-    url: string;
-    indexes?: {
-        [table: string]: Array<{
-            name: string;
-            columns: string[];
-        }>;
-    };
-}
-export interface Datasets {
-    ameli: Dataset;
-    debats: Dataset;
-    dosleg: Dataset;
-    questions: Dataset;
-    sens: Dataset;
-}
-export declare enum EnabledDatasets {
-    None = 0,
-    Ameli = 1,
-    Debats = 2,
-    DosLeg = 4,
-    Questions = 8,
-    Sens = 16,
-    PhotosSenateurs = 32,
-    Agenda = 64,
-    All = 127
-}
-export declare const datasets: Datasets;
-export declare function getEnabledDatasets(categories: string[]): EnabledDatasets;
-export declare function getChosenDatasets(enabledDatasets: EnabledDatasets): Dataset[];

package/lib/datasets.js

@@ -1,233 +0,0 @@
-import fs from "fs-extra";
-import path from "path";
-import assert from "assert";
-export var EnabledDatasets;
-(function (EnabledDatasets) {
-    EnabledDatasets[EnabledDatasets["None"] = 0] = "None";
-    EnabledDatasets[EnabledDatasets["Ameli"] = 1] = "Ameli";
-    EnabledDatasets[EnabledDatasets["Debats"] = 2] = "Debats";
-    EnabledDatasets[EnabledDatasets["DosLeg"] = 4] = "DosLeg";
-    EnabledDatasets[EnabledDatasets["Questions"] = 8] = "Questions";
-    EnabledDatasets[EnabledDatasets["Sens"] = 16] = "Sens";
-    EnabledDatasets[EnabledDatasets["PhotosSenateurs"] = 32] = "PhotosSenateurs";
-    EnabledDatasets[EnabledDatasets["Agenda"] = 64] = "Agenda";
-    EnabledDatasets[EnabledDatasets["All"] = 127] = "All";
-})(EnabledDatasets || (EnabledDatasets = {}));
-export const datasets = {
-    ameli: {
-        database: "ameli",
-        repairEncoding: true,
-        repairZip: (dataset, dataDir) => {
-            const sqlFilename = `${dataset.database}.sql`;
-            const sqlFilePath = path.join(dataDir, sqlFilename);
-            fs.removeSync(sqlFilePath);
-            fs.moveSync(path.join(dataDir, "var", "opt", "opendata", sqlFilename), sqlFilePath);
-        },
-        title: "Amendements",
-        url: "https://data.senat.fr/data/ameli/ameli.zip",
-        indexes: {
-            amdsen: [
-                { name: "idx_amdid", columns: ["amdid"] },
-                { name: "idx_senid", columns: ["senid"] },
-                { name: "idx_grpid", columns: ["grpid"] },
-            ],
-            sen_ameli: [{ name: "idx_entid", columns: ["entid"] }],
-            grppol_ameli: [{ name: "idx_entid", columns: ["entid"] }],
-            sub: [
-                { name: "idx_id", columns: ["id"] },
-                { name: "idx_typid", columns: ["typid"] },
-                { name: "idx_merid", columns: ["merid"] },
-                { name: "idx_comdelid", columns: ["comdelid"] },
-            ],
-            typsub: [{ name: "idx_id", columns: ["id"] }],
-            typrect: [{ name: "idx_id", columns: ["id"] }],
-            txt_ameli: [
-                { name: "idx_id", columns: ["id"] },
-                { name: "idx_txtetaid", columns: ["txtetaid"] },
-                { name: "idx_sesdepid", columns: ["sesdepid"] },
-                { name: "idx_natid", columns: ["natid"] },
-                { name: "idx_lecid", columns: ["lecid"] },
-            ],
-            etatxt: [{ name: "idx_id", columns: ["id"] }],
-            ses: [
-                { name: "idx_id", columns: ["id"] },
-                { name: "idx_typid", columns: ["typid"] },
-                { name: "idx_ann", columns: ["ann"] },
-            ],
-            typses: [{ name: "idx_id", columns: ["id"] }],
-            nat: [{ name: "idx_id", columns: ["id"] }],
-            lec_ameli: [{ name: "idx_id", columns: ["id"] }],
-            mot: [{ name: "idx_id", columns: ["id"] }],
-            avicom: [{ name: "idx_id", columns: ["id"] }],
-            avigvt: [{ name: "idx_id", columns: ["id"] }],
-            sor: [{ name: "idx_id", columns: ["id"] }],
-            irr: [{ name: "idx_id", columns: ["id"] }],
-            com_ameli: [{ name: "idx_entid", columns: ["entid"] }],
-            cab: [{ name: "idx_entid", columns: ["entid"] }],
-            amd: [
-                { name: "idx_subid", columns: ["subid"] },
-                { name: "idx_typrectid", columns: ["typrectid"] },
-                { name: "idx_txtid", columns: ["txtid"] },
-                { name: "idx_motid", columns: ["motid"] },
-                { name: "idx_avcid", columns: ["avcid"] },
-                { name: "idx_avgid", columns: ["avgid"] },
-                { name: "idx_sorid", columns: ["sorid"] },
-                { name: "idx_irrid", columns: ["irrid"] },
-                { name: "idx_nomentid", columns: ["nomentid"] },
-            ],
-        },
-    },
-    debats: {
-        database: "debats",
-        repairEncoding: false,
-        title: "Informations relatives aux comptes rendus intégraux de la séance publique",
-        url: "https://data.senat.fr/data/debats/debats.zip",
-        indexes: {
-            secdis: [
-                { name: "idx_datsea", columns: ["datsea"] },
-                { name: "idx_typseccod", columns: ["typseccod"] },
-            ],
-            intpjl: [{ name: "idx_secdiscle", columns: ["secdiscle"] }],
-            secdivers: [
-                { name: "idx_datsea", columns: ["datsea"] },
-                { name: "idx_typseccod", columns: ["typseccod"] },
-            ],
-            intdivers: [{ name: "idx_intdiverscle", columns: ["intdiverscle"] }],
-            lecassdeb: [{ name: "idx_datsea", columns: ["datsea"] }],
-        },
-    },
-    dosleg: {
-        database: "dosleg",
-        repairEncoding: false,
-        title: "Dossiers législatifs",
-        url: "https://data.senat.fr/data/dosleg/dosleg.zip",
-        indexes: {
-            amescr: [{ name: "idx_scrnum", columns: ["scrnum"] }],
-            auteur: [{ name: "idx_autcod", columns: ["autcod"] }],
-            corscr: [{ name: "idx_scrnum", columns: ["scrnum"] }],
-            date_seance: [
-                { name: "idx_code", columns: ["code"] },
-                { name: "idx_lecidt", columns: ["lecidt"] },
-            ],
-            deccoc: [{ name: "idx_deccoccod", columns: ["deccoccod"] }],
-            etaloi: [{ name: "idx_etaloicod", columns: ["etaloicod"] }],
-            lecass: [
-                { name: "idx_lecidt", columns: ["lecidt"] },
-                { name: "idx_codass", columns: ["codass"] },
-                { name: "idx_orgcod", columns: ["orgcod"] },
-                { name: "idx_orippr", columns: ["orippr"] },
-            ],
-            lecassrap: [
-                { name: "idx_rapcod", columns: ["rapcod"] },
-                { name: "idx_lecassidt", columns: ["lecassidt"] },
-            ],
-            lecture: [
-                { name: "idx_loicod", columns: ["loicod"] },
-                { name: "idx_typleccod", columns: ["typleccod"] },
-                { name: "idx_lecidt", columns: ["lecidt"] },
-            ],
-            loi: [
-                { name: "idx_typloicod", columns: ["typloicod"] },
-                { name: "idx_etaloicod", columns: ["etaloicod"] },
-                { name: "idx_deccoccod", columns: ["deccoccod"] },
-                { name: "idx_loicod", columns: ["loicod"] },
-            ],
-            loithe: [
-                { name: "idx_thecle", columns: ["thecle"] },
-                { name: "idx_loicod", columns: ["loicod"] },
-            ],
-            posvot: [{ name: "idx_posvotcod", columns: ["posvotcod"] }],
-            rap: [
-                { name: "idx_rapcod", columns: ["rapcod"] },
-                { name: "idx_coddenrap", columns: ["coddenrap"] },
-            ],
-            rolsig: [{ name: "idx_signataire", columns: ["signataire"] }],
-            scr: [
-                { name: "idx_code", columns: ["code"] },
-                { name: "idx_scrnum", columns: ["scrnum"] },
-                { name: "idx_sesann", columns: ["sesann"] },
-            ],
-            stavot: [{ name: "idx_stavotidt", columns: ["stavotidt"] }],
-            texte: [
-                { name: "idx_lecassidt", columns: ["lecassidt"] },
-                { name: "idx_oritxtcod", columns: ["oritxtcod"] },
-                { name: "idx_typtxtcod", columns: ["typtxtcod"] },
-                { name: "idx_texcod", columns: ["texcod"] },
-            ],
-            the: [{ name: "idx_thecle", columns: ["thecle"] }],
-            titsen: [{ name: "idx_titsencod", columns: ["titsencod"] }],
-            typloi: [{ name: "idx_typloicod", columns: ["typloicod"] }],
-            typtxt: [{ name: "idx_typtxtcod", columns: ["typtxtcod"] }],
-            votsen: [
-                { name: "idx_scrnum", columns: ["scrnum"] },
-                { name: "idx_sesann", columns: ["sesann"] },
-                { name: "idx_titsencod", columns: ["titsencod"] },
-                { name: "idx_stavotidt", columns: ["stavotidt"] },
-                { name: "idx_posvotcod", columns: ["posvotcod"] },
-                { name: "idx_senmat", columns: ["senmat"] },
-            ],
-        },
-    },
-    questions: {
-        database: "questions",
-        repairEncoding: false,
-        title: "Questions écrites et orales posées par les sénateurs au Gouvernement",
-        url: "https://data.senat.fr/data/questions/questions.zip",
-        indexes: {
-            tam_reponses: [{ name: "idx_idque", columns: ["idque"] }],
-            tam_questions: [
-                { name: "idx_sorquecod", columns: ["sorquecod"] },
-                { name: "idx_etaquecod", columns: ["etaquecod"] },
-            ],
-            the: [{ name: "idx_thenouidt", columns: ["thenouidt"] }],
-            sortquestion: [{ name: "idx_sorquecod", columns: ["sorquecod"] }],
-            etatquestion: [{ name: "idx_etaquecod", columns: ["etaquecod"] }],
-        },
-    },
-    sens: {
-        database: "sens",
-        repairEncoding: false,
-        repairZip: (dataset, dataDir) => {
-            const sqlFilename = `${dataset.database}.sql`;
-            const sqlFilePath = path.join(dataDir, sqlFilename);
-            fs.removeSync(sqlFilePath);
-            fs.moveSync(path.join(dataDir, "export_sens.sql"), sqlFilePath);
-        },
-        title: "Sénateurs (y compris organes et présence)",
-        url: "https://data.senat.fr/data/senateurs/export_sens.zip",
-        indexes: {
-            dpt: [
-                { name: "idx_dptnum", columns: ["dptnum"] },
-                { name: "idx_regcod", columns: ["regcod"] },
-            ],
-            activite_loi: [{ name: "idx_actid", columns: ["actid"] }],
-            activite_delegation: [{ name: "idx_actid", columns: ["actid"] }],
-            activite_participant: [{ name: "idx_senmat", columns: ["senmat"] }],
-            activite_senateur: [{ name: "idx_senmat", columns: ["senmat"] }],
-            senbur: [
-                { name: "idx_senmat", columns: ["senmat"] },
-                { name: "idx_burcod", columns: ["burcod"] },
-            ],
-            elucan: [
-                { name: "idx_senmat", columns: ["senmat"] },
-                { name: "idx_typmancod", columns: ["typmancod"] },
-            ],
-        },
-    },
-};
-export function getEnabledDatasets(categories) {
-    categories.map((datasetName) => assert.notStrictEqual(EnabledDatasets[datasetName], undefined, `Unknown name of dataset: ${datasetName}`));
-    return categories.reduce((enabledDatasets, datasetName) => {
-        const enabledDataset = EnabledDatasets[datasetName];
-        return enabledDatasets | (enabledDataset || EnabledDatasets.None);
-    }, EnabledDatasets.None);
-}
-export function getChosenDatasets(enabledDatasets) {
-    return [
-        enabledDatasets & EnabledDatasets.Ameli ? datasets.ameli : null,
-        enabledDatasets & EnabledDatasets.Debats ? datasets.debats : null,
-        enabledDatasets & EnabledDatasets.DosLeg ? datasets.dosleg : null,
-        enabledDatasets & EnabledDatasets.Questions ? datasets.questions : null,
-        enabledDatasets & EnabledDatasets.Sens ? datasets.sens : null,
-    ].filter((dataset) => dataset !== null);
-}

package/lib/git.d.ts

@@ -1,26 +0,0 @@
-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 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/git.js

@@ -1,167 +0,0 @@
-import { execSync } from "node:child_process";
-import fs from "fs-extra";
-import path from "node:path";
-const MAXBUFFER = 50 * 1024 * 1024;
-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);
-    execSync("git add .", {
-        cwd: 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 (childProcess) {
-        if (childProcess.stdout === null ||
-            !/nothing to commit|rien à valider/.test(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 (childProcess) {
-                // Don't stop when push fails.
-                console.error(childProcess.output);
-                exitCode = childProcess.status;
-            }
-        }
-    }
-    else {
-        // There was nothing to commit.
-        exitCode = 10;
-    }
-    return exitCode;
-}
-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 (childProcess) {
-        for (const output of ["stdout", "stderr"])
-            console.error(`${output}: ${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 (childProcess) {
-        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();
-    }
-}

package/lib/index.d.ts

@@ -1,13 +0,0 @@
-export type { AmendementResult } from "./model/ameli";
-export type { DossierLegislatifResult } from "./model/dosleg";
-export type { ScrutinResult } from "./model/scrutins";
-export type { QuestionResult } from "./model/questions";
-export type { CirconscriptionResult, OrganismeResult, SenateurResult } from "./model/sens";
-export type { AgendaEvent, Reunion, ReunionOdjPoint } from "./types/agenda";
-export type { Ses, Sub, TxtAmeli } from "./types/ameli";
-export type { CompteRendu } from "./types/compte_rendu";
-export type { Debat, LecAssDeb } from "./types/debats";
-export type { Ass, Aud, Auteur, DateSeance, DecCoc, DenRap, DocAtt, Ecr, EtaLoi, LecAss, LecAssRap, Lecture, Loi, Org, OriTxt, Qua, Rap, RapOrg, Scr, Texte, TypAtt, TypLec, TypLoi, TypTxt, TypUrl, } from "./types/dosleg";
-export type { Photo, Sen } from "./types/sens";
-export { UNDEFINED_SESSION, type Session, getSessionsFromStart } from "./types/sessions";
-export type { Alinea, Article, Division, DivisionTag, FlatTexte } from "./types/texte";

package/lib/index.js

@@ -1 +0,0 @@
-export { UNDEFINED_SESSION, getSessionsFromStart } from "./types/sessions";