@tricoteuses/assemblee 1.8.0 → 1.9.1

package/lib/parsers/textes_lois.mjs

@@ -1,43 +1,608 @@
 import { ChatOpenAI } from "@langchain/openai";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import Ajv from "ajv";
-const texteLoiSchema = require("../schemas/texte_loi/TexteLoi.json");
+import { delimiter, runLogFun } from "../logger.mjs";
+const EXPOSE_MOTIFS_SCHEMA = require("../schemas/texte_loi/ExposeMotifs");
+const META_DONNEES_SCHEMA = require("../schemas/texte_loi/MetaDonnees");
+const PROJET_LOI_SCHEMA = require("../schemas/texte_loi/ProjetLoi");
+const ALINEA_SCHEMA = require("../schemas/texte_loi/Alinea");
+const SOMMAIRE_SCHEMA = require("../schemas/texte_loi/Sommaire");
+
+/**
+ * Object containing input examples and their output schemas.
+ * Used to train the LLM.
+ * @type {Record<string, {motifs: any, input: any, loi: any, meta: any, sommaire: any}>}
+ */
+const EXAMPLES = {
+  PRJLANR5L16B0914: {
+    motifs: require("../examples/PRJLANR5L16B0914/motifs"),
+    input: require("../examples/PRJLANR5L16B0914/input"),
+    loi: require("../examples/PRJLANR5L16B0914/loi"),
+    meta: require("../examples/PRJLANR5L16B0914/meta"),
+    sommaire: require("../examples/PRJLANR5L16B0914/sommaire")
+  },
+  PRJLANR5L16B2014: {
+    motifs: require("../examples/PRJLANR5L16B2014/motifs"),
+    input: require("../examples/PRJLANR5L16B2014/input"),
+    loi: require("../examples/PRJLANR5L16B2014/loi"),
+    meta: require("../examples/PRJLANR5L16B2014/meta"),
+    sommaire: require("../examples/PRJLANR5L16B2014/sommaire")
+  },
+  PRJLANR5L16B2424: {
+    alineas: require("../examples/PRJLANR5L16B2424/alineas"),
+    motifs: require("../examples/PRJLANR5L16B2424/motifs"),
+    input: require("../examples/PRJLANR5L16B2424/input"),
+    loi: require("../examples/PRJLANR5L16B2424/loi"),
+    meta: require("../examples/PRJLANR5L16B2424/meta"),
+    sommaire: require("../examples/PRJLANR5L16B2424/sommaire")
+  }
+};
+const FULL_TEXTE_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Sommaire",
+  description: "Récupération d'un texte complet",
+  type: "object",
+  properties: {
+    texte: {
+      description: "Texte complet de la section indiquée.",
+      type: "string"
+    }
+  },
+  required: ["texte"]
+};
+
+/**
+ * LLM model.
+ */
+let MODEL = null;
+if (process.env.OPENAI_API_KEY) {
+  MODEL = new ChatOpenAI({
+    temperature: 0,
+    topP: 0.0,
+    model: "gpt-4o-mini",
+    apiKey: process.env.OPENAI_API_KEY,
+    maxTokens: -1
+  });
+}
+
+/**
+ * System input template for the LLM.
+ */
+const SYSTEM_TEMPLATE = `
+  # Instructions :
+  
+  Tu es un expert de la loi et de l'analyse de pages HTML.
+  Tu dois analyser un texte de loi afin de séparer et de structurer les éléments qui le composent. Le format d'entrée est HTML.
+
+  Le texte est divisé en deux parties :
+  A) un exposé des motifs qui indique les raisons pour lesquelles ce projet est soumis au Parlement. Il peut contenir 3 éléments : 1) une citation au début d'un document, 2) le texte principal qui développe les arguments de l'auteur à l'appui de la modification législative ou des dispositions nouvelles qu'il propose, 3) des paragraphes qui présentent les articles.
+  B) le dispositif qui est la partie normative et rédigée en articles. Il peut comporter des divisions nommées titres, chapitres, sections, sous-sections. Lorsqu'il y a un seul niveau de structure, on retrouvera le chapitre ; s’il y a deux niveaux de structure, on retrouvera des chapitres puis des sections. S’il y a trois niveaux de structure, on retrouvera des titres puis des chapitres puis des sections.
+
+  Si le texte de loi ne comporte pas de division, le sommaire doit rester vide.
+  Toutes les lignes qui débutent par un '«' ne sont pas à prendre en compte dans les divisions
+  Ta réponse doit être un JSON structuré avec les éléments du texte de loi en respectant le schéma JSON fourni.
+`;
+let SILENT_LOG = false;
+
+/**
+ * Parses the given HTML string and returns the parsed textes loi.
+ *
+ * @param {string} html - The HTML string to parse.
+ * @return {Promise<{partial: {sommaire: any, loi: any, motifs: any, meta: any}, completed: {sommaire: any, loi: any, motifs: any, meta: any}}>} - The parsed textes loi, including the partial and completed versions.
+ */
+export async function parseTexteLoi(html, options = {
+  silent: false
+}) {
+  SILENT_LOG = options.silent;
+  runLogFun(console.info("Start extracting loi..."), options);
+  const meta = await extractMetaDonnees(html);
+  const sommaire = await extractSommaire(html);
+  const partialMotifs = await extractMotifs(html);
+  const partialLoi = await extractProjetLoi(html);
+  const exposeMotifs = await populateMotifs(partialMotifs, html);
+  const loi = await populateProjetLoi(partialLoi, html);
+  return {
+    sommaire,
+    loi,
+    exposeMotifs,
+    meta
+  };
+}
+
+/**
+ * Cleans the given HTML string by removing unnecessary tags and content.
+ *
+ * @param {string} html - The HTML string to be cleaned.
+ * @return {string} The cleaned HTML string.
+ */
 function cleanHtml(html) {
   let cleanedHtml = html.replace(/(<style[\w\W]+style>)/g, "");
   cleanedHtml = cleanedHtml.replace(/(<head[\w\W]+head>)/g, "");
   cleanedHtml = cleanedHtml.replace(/<img[^>]*>/g, "");
   return cleanedHtml;
 }
-export async function parseTexteLoi(html) {
-  const cleanedHtml = cleanHtml(html);
-  const model = new ChatOpenAI({
-    temperature: 0,
-    model: "gpt-4o",
-    apiKey: process.env.OPENAI_API_KEY
+
+/**
+ * Removes all HTML tags from the given HTML string and returns the cleaned text.
+ *
+ * @param {string} html - The HTML string from which to remove tags.
+ * @return {string} The cleaned text without any HTML tags.
+ */
+function removeHtmlTags(html) {
+  // Regular expression to match HTML tags
+  const htmlTagRegex = /<[^>]*>/g;
+
+  // Replace all HTML tags with an empty string
+  const textWithoutTags = html.replace(htmlTagRegex, "");
+  return textWithoutTags;
+}
+
+/**
+ * Populates the motifs object with the extracted text from the given HTML.
+ *
+ * @param {Record<string, any>} motifs - The motifs object to be populated.
+ * @param {string} html - The HTML string from which to extract the text.
+ * @return {Promise<Record<string, any>>} - The populated motifs object.
+ */
+async function populateMotifs(motifs, html) {
+  runLogFun(console.info("Populating expose motifs..."));
+  let cleanedHtml = cleanHtml(html);
+  if (motifs.debut === motifs.fin || !motifs.fin) {
+    motifs.texte = motifs.debut;
+  } else {
+    const systemTemplate = `
+      # Instructions :
+
+      Tu es un expert de la loi et de l'analyse de pages HTML.
+      Tu dois analyser un texte de loi afin d'en extraire certaines parties. 
+      Le format d'entrée est du HTML. Le format de sortie est du texte.
+      Récupère l'intégralité du texte commençant par :
+
+      """
+      {debut}
+      """
+
+      Et finissant par :
+
+      """
+      {fin}
+      """
+    `;
+    const prompt = ChatPromptTemplate.fromMessages([["system", systemTemplate], ["human", "{input}"]]);
+    const structuredModel = MODEL.withStructuredOutput(FULL_TEXTE_SCHEMA);
+    const chain = prompt.pipe(structuredModel);
+    const articlePromptResult = await chain.invoke({
+      input: cleanedHtml,
+      debut: motifs.debut,
+      fin: motifs.fin
+    });
+    motifs.texte = articlePromptResult.texte;
+  }
+  runLogFun(console.info("Opération de peuplement de l'exposé des motifs terminée ✅"), {
+    silent: SILENT_LOG
   });
-  const structuredModel = model.withStructuredOutput(texteLoiSchema);
+  delimiter(SILENT_LOG);
+  delete motifs.debut;
+  delete motifs.fin;
+  return motifs;
+}
+
+/**
+ * Asynchronously populates a projet loi object with the full text of each article and alinea in the given HTML.
+ *
+ * @param {Record<string, any>} partial - The partial projet loi object to be populated.
+ * @param {string} html - The HTML containing the text of the articles and alineas.
+ * @return {Promise<Record<string, any>>} A Promise that resolves to the fully populated projet loi object.
+ */
+async function populateProjetLoi(partial, html) {
+  runLogFun(console.group("Peuplement du projet loi..."), {
+    silent: SILENT_LOG
+  });
+  let cleanedHtml = cleanHtml(html);
+  const articles = partial.articles;
+  const fullArticles = [];
   const systemTemplate = `
-        Tu es un expert de la loi et de l'analyse de pages HTML.
-        Tu dois analyser un texte de loi afin de séparer et structurer les éléments qui le composent. Le format d'entrée est HTML.
+    # Instructions :
 
-        Le texte est divisé en deux parties :
-        A) un exposé des motifs qui indique les raisons pour lesquelles ce projet est soumis au Parlement. Il peut contenir 3 éléments : 1) une citation au début d'un document, 2) le texte principal qui développe les arguments de l'auteur à l'appui de la modification législative ou des dispositions nouvelles qu'il propose, 3) des paragraphes qui présentent les articles.
-        B) le dispositif qui est la partie normative et rédigée en articles. Il peut comporter des divisions nommées titres, chapitres, sections, sous-sections. Lorsqu'il y a un seul niveau de structure, on retrouvera le chapitre ; s’il y a deux niveaux de structure, on retrouvera des chapitres puis des sections. S’il y a trois niveaux de structure, on retrouvera des titres puis des chapitres puis des sections.
+    Tu es un expert de la loi et de l'analyse de pages HTML.
+    Tu dois analyser un texte de loi afin d'en extraire certaines parties. 
+    Le format d'entrée est du HTML. Le format de sortie est du texte.
+    Récupère l'intégralité du texte commençant par :
 
-        Si le texte de loi ne comporte pas de division, le sommaire doit rester vide.
-        Toutes les lignes qui débutent par un '«' ne sont pas à prendre en compte dans les divisions
-        Lorsque les textes ont été modifiés, il n'y pas d'exposé des motifs.
-        Ta réponse doit être un JSON structuré avec les éléments du texte de loi en respectant le schéma JSON fourni.
-    `;
+    """
+    {debut}
+    """
+
+    Et finissant par :
+
+    """
+    {fin}
+    """
+  `;
   const prompt = ChatPromptTemplate.fromMessages([["system", systemTemplate], ["human", "{input}"]]);
+  const structuredModel = MODEL.withStructuredOutput(FULL_TEXTE_SCHEMA);
+  const chain = prompt.pipe(structuredModel);
+  for (const article of articles) {
+    if (article.debut === article.fin || !article.fin) {
+      article.texte = article.debut;
+    } else {
+      const articlePromptResult = await chain.invoke({
+        input: cleanedHtml,
+        debut: article.debut,
+        fin: article.fin
+      });
+      article.texte = articlePromptResult.texte;
+    }
+    for (const alinea of article.alineas) {
+      if (alinea.debut === alinea.fin || !alinea.fin) {
+        alinea.texte = alinea.debut;
+        continue;
+      }
+      const alineaPromptResult = await chain.invoke({
+        input: article.texte,
+        debut: alinea.debut,
+        fin: alinea.fin
+      });
+      delete alinea.debut;
+      delete alinea.fin;
+      alinea.texte = alineaPromptResult.texte;
+    }
+    runLogFun(console.info("Opération de peuplement du contenu du projet de loi terminée ✅"), {
+      silent: SILENT_LOG
+    });
+    delete article.debut;
+    delete article.fin;
+    fullArticles.push(article);
+  }
+  const projetLoi = {
+    ...partial,
+    articles: fullArticles
+  };
+  runLogFun(console.groupEnd(), {
+    silent: SILENT_LOG
+  });
+  delimiter();
+  return projetLoi;
+}
+
+/**
+ * Asynchronously extracts the "expose motifs" from the given HTML.
+ *
+ * @param {string} html - The HTML string from which to extract the "expose motifs".
+ * @return {Promise<Record<string, any>>} - A Promise that resolves to the extracted "expose motifs" object.
+ * The object contains the following properties:
+ * - `debut`: The beginning of the "expose motifs".
+ * - `fin`: The end of the "expose motifs".
+ * @throws {Error} - If the extracted "expose motifs" do not validate against the EXPOSE_MOTIFS_SCHEMA.
+ */
+async function extractMotifs(html) {
+  runLogFun(console.group("Parsing expose motifs..."), {
+    silent: SILENT_LOG
+  });
+  let cleanedHtml = cleanHtml(html);
+  cleanedHtml = removeHtmlTags(cleanedHtml);
+  const structuredModel = MODEL.withStructuredOutput(EXPOSE_MOTIFS_SCHEMA);
+  const motifsSystemTemplate = `
+    ${SYSTEM_TEMPLATE}
+
+    # Examples: 
+
+    ## Exemple 1 User Input :
+    """
+    {example1}
+    """
+    
+    ## Exemple 1 JSON Output :
+    """
+    {output1}
+    """
+
+    ## Exemple 2 User Input :
+    """
+    {example2}
+    """
+    
+    ## Exemple 2 JSON Output :
+    """
+    {output2}
+    """
+    `;
+  const prompt = ChatPromptTemplate.fromMessages([["system", motifsSystemTemplate], ["human", "{input}"]]);
+  const chain = prompt.pipe(structuredModel);
+  const motifsPromptResult = await chain.invoke({
+    input: cleanedHtml,
+    example1: EXAMPLES.PRJLANR5L16B0914.input,
+    example2: EXAMPLES.PRJLANR5L16B2424.input,
+    output1: EXAMPLES.PRJLANR5L16B0914.motifs,
+    output2: EXAMPLES.PRJLANR5L16B2424.motifs
+  });
+
+  // console.log(JSON.stringify(motifsPromptResult))
+  runLogFun(console.table([["Début", motifsPromptResult.debut.substring(0, 30)], ["Fin", motifsPromptResult.fin.substring(0, 30)]]), {
+    silent: SILENT_LOG
+  });
+  runLogFun(console.groupEnd(), {
+    silent: SILENT_LOG
+  });
+  delimiter();
+  const ajv = new Ajv();
+  if (ajv.validate(EXPOSE_MOTIFS_SCHEMA, motifsPromptResult)) {
+    runLogFun(console.info("Exposé des motifs OK 👌"), {
+      silent: SILENT_LOG
+    });
+    return motifsPromptResult;
+  }
+  runLogFun(console.warn("Exposé des motifs KO ❌"), {
+    silent: SILENT_LOG
+  });
+  return {};
+}
+
+/**
+ * Asynchronously extracts the metadata from the given HTML.
+ *
+ * @param {string} html - The HTML string from which to extract the metadata.
+ * @return {Promise<Record<string, any>>} - A Promise that resolves to the extracted metadata object.
+ * The object contains the following properties:
+ * - `documentRef`: The reference of the document.
+ * - `titre`: The title of the document.
+ * - `numeroTexte`: The number of the text.
+ * - `procedureAcceleree`: The accelerated procedure.
+ * @throws {Error} - If the extracted metadata do not validate against the META_DONNEES_SCHEMA.
+ */
+async function extractMetaDonnees(html) {
+  delimiter();
+  let cleanedHtml = cleanHtml(html);
+  cleanedHtml = removeHtmlTags(cleanedHtml);
+  const structuredModel = MODEL.withStructuredOutput(META_DONNEES_SCHEMA);
+  const metaDonneesSystemTemplate = `
+    ${SYSTEM_TEMPLATE}
+    `;
+  const prompt = ChatPromptTemplate.fromMessages([["system", metaDonneesSystemTemplate], ["human", "{input}"]]);
   const chain = prompt.pipe(structuredModel);
   const result = await chain.invoke({
-    input: cleanedHtml
+    input: cleanedHtml,
+    example1: EXAMPLES.PRJLANR5L16B0914.input,
+    example2: EXAMPLES.PRJLANR5L16B2424.input,
+    output1: EXAMPLES.PRJLANR5L16B0914.meta,
+    output2: EXAMPLES.PRJLANR5L16B2424.meta
   });
+  console.group("Meta-données");
+  console.table([["Référence", result.documentRef], ["Titre", result.titre], ["Numéro du texte", result.numeroTexte], ["Procédure accéléré", result.procedureAcceleree]]);
+  console.groupEnd();
+  delimiter();
   const ajv = new Ajv();
-  if (ajv.validate(texteLoiSchema, result)) {
+  if (ajv.validate(META_DONNEES_SCHEMA, result)) {
+    runLogFun(console.warn("Meta-données OK 👌"), {
+      silent: SILENT_LOG
+    });
     return result;
   }
-  return false;
+  runLogFun(console.warn("Meta-données non-conforme ❌"), {
+    silent: SILENT_LOG
+  });
+  return {};
+}
+
+/**
+ * Asynchronously extracts the "projet de loi" from the given HTML.
+ *
+ * @param {string} html - The HTML string from which to extract the "projet de loi".
+ * @return {Promise<Record<string, any>>} - A Promise that resolves to the extracted "projet de loi" object.
+ * The object contains the following properties:
+ * - `articles`: An array of article objects, each containing the following properties:
+ *   - `numeroArticle`: The number of the article.
+ *   - `cardinal`: The cardinal of the article.
+ *   - `titre`: The title of the article.
+ *   - `debut`: The beginning of the article.
+ *   - `fin`: The end of the article.
+ *   - `alineas`: An array of alineas.
+ * @throws {Error} - If the extracted "projet de loi" does not validate against the PROJET_LOI_SCHEMA.
+ */
+async function extractProjetLoi(html) {
+  runLogFun(console.group("Parsing loi..."), {
+    silent: SILENT_LOG
+  });
+  let cleanedHtml = cleanHtml(html);
+  const structuredModel = MODEL.withStructuredOutput(PROJET_LOI_SCHEMA);
+  const projetLoiSystemTemplate = `
+    ${SYSTEM_TEMPLATE}
+
+    # Examples: 
+
+    ## Exemple 1 User Input :
+    """
+    {example1}
+    """
+    
+    ## Exemple 1 JSON Output :
+    """
+    {output1}
+    """
+
+    ## Exemple 2 User Input :
+    """
+    {example2}
+    """
+    
+    ## Exemple 2 JSON Output :
+    """
+    {output2}
+    """
+    `;
+  const prompt = ChatPromptTemplate.fromMessages([["system", projetLoiSystemTemplate], ["human", "{input}"]]);
+  const chain = prompt.pipe(structuredModel);
+  const articlesPromptResult = await chain.invoke({
+    input: cleanedHtml,
+    example1: EXAMPLES.PRJLANR5L16B0914.input,
+    example2: EXAMPLES.PRJLANR5L16B2424.input,
+    output1: EXAMPLES.PRJLANR5L16B0914.loi,
+    output2: EXAMPLES.PRJLANR5L16B2424.loi
+  });
+  runLogFun(console.log("Found ", articlesPromptResult.articles.length, " articles."), {
+    silent: SILENT_LOG
+  });
+  for (const article of articlesPromptResult.articles) {
+    article.alineas = await extractAlineas(html, article);
+  }
+  runLogFun(console.table(articlesPromptResult.articles.map(article => [article.numeroArticle, article.titre, article.debut.substring(0, 10), article.fin.substring(0, 10), `Nombre d'alineas : ${article.alineas.length}`])), {
+    silent: SILENT_LOG
+  });
+  runLogFun(console.groupEnd(), {
+    silent: SILENT_LOG
+  });
+  const ajv = new Ajv();
+  if (ajv.validate(PROJET_LOI_SCHEMA, articlesPromptResult)) {
+    runLogFun(console.info("Projet de loi OK 👌"), {
+      silent: SILENT_LOG
+    });
+    delimiter();
+    return articlesPromptResult;
+  }
+  runLogFun(console.warn("Projet de loi KO ❌"), {
+    silent: SILENT_LOG
+  });
+  delimiter();
+  return {};
+}
+async function extractAlineas(html, article) {
+  runLogFun(console.group("Parsing alineas..."), {
+    silent: SILENT_LOG
+  });
+  let cleanedHtml = cleanHtml(html);
+  const structuredModel = MODEL.withStructuredOutput(ALINEA_SCHEMA);
+  const alineasSystemTemplate = `
+    ${SYSTEM_TEMPLATE}
+
+    Extrais tous les alineas de la portion de texte commençant par « {debut} » et finissant par « {fin} ».
+    Un alinéa contiennent toujours une balise « <img ».
+
+    # Examples: 
+
+    ## Exemple 1 User Input :
+    """
+    {example1}
+    """
+    
+    ## Exemple 1 JSON Output :
+    """
+    {output1}
+    """
+    `;
+  const prompt = ChatPromptTemplate.fromMessages([["system", alineasSystemTemplate], ["human", "{input}"]]);
+  const chain = prompt.pipe(structuredModel);
+  const alineasPromptResult = await chain.invoke({
+    input: cleanedHtml,
+    debut: article.debut,
+    fin: article.fin,
+    example1: EXAMPLES.PRJLANR5L16B2424.input,
+    output1: EXAMPLES.PRJLANR5L16B2424.alineas
+  });
+  const ajv = new Ajv();
+  if (ajv.validate(ALINEA_SCHEMA, alineasPromptResult)) {
+    runLogFun(console.info("Found ", alineasPromptResult.alineas.length, " alineas for Article ", article.numeroArticle, article.titre), {
+      silent: SILENT_LOG
+    });
+    runLogFun(console.groupEnd(), {
+      silent: SILENT_LOG
+    });
+    delimiter();
+    return alineasPromptResult.alineas;
+  }
+  runLogFun(console.warn("Alineas KO"), {
+    silent: SILENT_LOG
+  });
+  delimiter();
+  return {};
+}
+
+/**
+ * Asynchronously extracts the "sommaire" (outline) from the given HTML.
+ *
+ * @param {string} html - The HTML string from which to extract the "sommaire".
+ * @return {Promise<Record<string, any>>} - A Promise that resolves to the extracted "sommaire" object.
+ * The object contains the following properties:
+ * - `sommaire`: An array of main division objects, each containing the following properties:
+ *   - `numeroDivision`: The number of the main division.
+ *   - `titre`: The title of the main division.
+ *   - `typeDivision`: The type of content in the main division.
+ *   - `sequence`: The sequence of the main division.
+ *   - `parent`: The parent of the main division.
+ * @throws {Error} - If the extracted "sommaire" does not validate against the SOMMAIRE_SCHEMA.
+ */
+async function extractSommaire(html) {
+  let cleanedHtml = cleanHtml(html);
+  cleanedHtml = removeHtmlTags(cleanedHtml);
+  const structuredModel = MODEL.withStructuredOutput(SOMMAIRE_SCHEMA);
+  const sommaireSystemTemplate = `
+    ${SYSTEM_TEMPLATE}
+
+    # Examples: 
+
+    ## Exemple 1 User Input :
+    """
+    {example1}
+    """
+    
+    ## Exemple 1 JSON Output :
+    """
+    {output1}
+    """
+
+    ## Exemple 2 User Input :
+    """
+    {example2}
+    """
+    
+    ## Exemple 2 JSON Output :
+    """
+    {output2}
+    """
+    `;
+  const prompt = ChatPromptTemplate.fromMessages([["system", sommaireSystemTemplate], ["human", "{input}"]]);
+  const chain = prompt.pipe(structuredModel);
+  const sommairePromptResult = await chain.invoke({
+    input: cleanedHtml,
+    example1: EXAMPLES.PRJLANR5L16B2014.input,
+    output1: EXAMPLES.PRJLANR5L16B2014.sommaire,
+    example2: EXAMPLES.PRJLANR5L16B0914.input,
+    output2: EXAMPLES.PRJLANR5L16B0914.sommaire
+  });
+  if (!sommairePromptResult.sommaire) {
+    runLogFun(console.warn("Aucun sommaire n'a été trouvé ❓"), {
+      silent: SILENT_LOG
+    });
+    delimiter();
+    return {
+      sommaire: []
+    };
+  }
+  runLogFun(console.group("Sommaire"), {
+    silent: SILENT_LOG
+  });
+  runLogFun(console.log("Found ", sommairePromptResult.sommaire.length, " main divisions (level 1)."), {
+    silent: SILENT_LOG
+  });
+  runLogFun(console.table(sommairePromptResult.sommaire.map(item => [item.sequence, item.titre, item.typeDivision, item.parent])), {
+    silent: SILENT_LOG
+  });
+  runLogFun(console.groupEnd(), {
+    silent: SILENT_LOG
+  });
+  const ajv = new Ajv();
+  if (ajv.validate(SOMMAIRE_SCHEMA, sommairePromptResult)) {
+    runLogFun(console.info("Sommaire OK 👌"), {
+      silent: SILENT_LOG
+    });
+    delimiter();
+    return sommairePromptResult.sommaire;
+  }
+  runLogFun(console.warn("La construction du sommaire est KO ❌"), {
+    silent: SILENT_LOG
+  });
+  delimiter();
+  return {
+    sommaire: []
+  };
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ChatOpenAI","ChatPromptTemplate","Ajv","delimiter","runLogFun","EXPOSE_MOTIFS_SCHEMA","require","META_DONNEES_SCHEMA","PROJET_LOI_SCHEMA","ALINEA_SCHEMA","SOMMAIRE_SCHEMA","EXAMPLES","PRJLANR5L16B0914","motifs","input","loi","meta","sommaire","PRJLANR5L16B2014","PRJLANR5L16B2424","alineas","FULL_TEXTE_SCHEMA","$schema","title","description","type","properties","texte","required","MODEL","process","env","OPENAI_API_KEY","temperature","topP","model","apiKey","maxTokens","SYSTEM_TEMPLATE","SILENT_LOG","parseTexteLoi","html","options","silent","console","info","extractMetaDonnees","extractSommaire","partialMotifs","extractMotifs","partialLoi","extractProjetLoi","exposeMotifs","populateMotifs","populateProjetLoi","cleanHtml","cleanedHtml","replace","removeHtmlTags","htmlTagRegex","textWithoutTags","debut","fin","systemTemplate","prompt","fromMessages","structuredModel","withStructuredOutput","chain","pipe","articlePromptResult","invoke","partial","group","articles","fullArticles","article","alinea","alineaPromptResult","push","projetLoi","groupEnd","motifsSystemTemplate","motifsPromptResult","example1","example2","output1","output2","table","substring","ajv","validate","warn","metaDonneesSystemTemplate","result","documentRef","titre","numeroTexte","procedureAcceleree","projetLoiSystemTemplate","articlesPromptResult","log","length","extractAlineas","map","numeroArticle","alineasSystemTemplate","alineasPromptResult","sommaireSystemTemplate","sommairePromptResult","item","sequence","typeDivision","parent"],"sources":["../../src/parsers/textes_lois.ts"],"sourcesContent":["import { ChatOpenAI } from \"@langchain/openai\"\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\"\nimport Ajv from \"ajv\"\n\nimport { delimiter, runLogFun } from \"../logger\"\n\nconst EXPOSE_MOTIFS_SCHEMA = require(\"../schemas/texte_loi/ExposeMotifs\")\nconst META_DONNEES_SCHEMA = require(\"../schemas/texte_loi/MetaDonnees\")\nconst PROJET_LOI_SCHEMA = require(\"../schemas/texte_loi/ProjetLoi\")\nconst ALINEA_SCHEMA = require(\"../schemas/texte_loi/Alinea\")\nconst SOMMAIRE_SCHEMA = require(\"../schemas/texte_loi/Sommaire\")\n\n/**\n * Object containing input examples and their output schemas.\n * Used to train the LLM.\n * @type {Record<string, {motifs: any, input: any, loi: any, meta: any, sommaire: any}>}\n */\nconst EXAMPLES = {\n  PRJLANR5L16B0914: {\n    motifs: require(\"../examples/PRJLANR5L16B0914/motifs\"),\n    input: require(\"../examples/PRJLANR5L16B0914/input\"),\n    loi: require(\"../examples/PRJLANR5L16B0914/loi\"),\n    meta: require(\"../examples/PRJLANR5L16B0914/meta\"),\n    sommaire: require(\"../examples/PRJLANR5L16B0914/sommaire\"),\n  },\n  PRJLANR5L16B2014: {\n    motifs: require(\"../examples/PRJLANR5L16B2014/motifs\"),\n    input: require(\"../examples/PRJLANR5L16B2014/input\"),\n    loi: require(\"../examples/PRJLANR5L16B2014/loi\"),\n    meta: require(\"../examples/PRJLANR5L16B2014/meta\"),\n    sommaire: require(\"../examples/PRJLANR5L16B2014/sommaire\"),\n  },\n  PRJLANR5L16B2424: {\n    alineas: require(\"../examples/PRJLANR5L16B2424/alineas\"),\n    motifs: require(\"../examples/PRJLANR5L16B2424/motifs\"),\n    input: require(\"../examples/PRJLANR5L16B2424/input\"),\n    loi: require(\"../examples/PRJLANR5L16B2424/loi\"),\n    meta: require(\"../examples/PRJLANR5L16B2424/meta\"),\n    sommaire: require(\"../examples/PRJLANR5L16B2424/sommaire\"),\n  },\n}\n\nconst FULL_TEXTE_SCHEMA = {\n  $schema: \"http://json-schema.org/draft-07/schema#\",\n  title: \"Sommaire\",\n  description: \"Récupération d'un texte complet\",\n  type: \"object\",\n  properties: {\n    texte: {\n      description: \"Texte complet de la section indiquée.\",\n      type: \"string\",\n    },\n  },\n  required: [\"texte\"],\n}\n\n/**\n * LLM model.\n */\nlet MODEL: any = null\n\nif (process.env.OPENAI_API_KEY) {\n  MODEL = new ChatOpenAI({\n    temperature: 0,\n    topP: 0.0,\n    model: \"gpt-4o-mini\",\n    apiKey: process.env.OPENAI_API_KEY,\n    maxTokens: -1,\n  })\n}\n\n/**\n * System input template for the LLM.\n */\nconst SYSTEM_TEMPLATE: string = `\n  # Instructions :\n  \n  Tu es un expert de la loi et de l'analyse de pages HTML.\n  Tu dois analyser un texte de loi afin de séparer et de structurer les éléments qui le composent. Le format d'entrée est HTML.\n\n  Le texte est divisé en deux parties :\n  A) un exposé des motifs qui indique les raisons pour lesquelles ce projet est soumis au Parlement. Il peut contenir 3 éléments : 1) une citation au début d'un document, 2) le texte principal qui développe les arguments de l'auteur à l'appui de la modification législative ou des dispositions nouvelles qu'il propose, 3) des paragraphes qui présentent les articles.\n  B) le dispositif qui est la partie normative et rédigée en articles. Il peut comporter des divisions nommées titres, chapitres, sections, sous-sections. Lorsqu'il y a un seul niveau de structure, on retrouvera le chapitre ; s’il y a deux niveaux de structure, on retrouvera des chapitres puis des sections. S’il y a trois niveaux de structure, on retrouvera des titres puis des chapitres puis des sections.\n\n  Si le texte de loi ne comporte pas de division, le sommaire doit rester vide.\n  Toutes les lignes qui débutent par un '«' ne sont pas à prendre en compte dans les divisions\n  Ta réponse doit être un JSON structuré avec les éléments du texte de loi en respectant le schéma JSON fourni.\n`\n\nlet SILENT_LOG = false\n\n/**\n * Parses the given HTML string and returns the parsed textes loi.\n *\n * @param {string} html - The HTML string to parse.\n * @return {Promise<{partial: {sommaire: any, loi: any, motifs: any, meta: any}, completed: {sommaire: any, loi: any, motifs: any, meta: any}}>} - The parsed textes loi, including the partial and completed versions.\n */\nexport async function parseTexteLoi(html: string, options = { silent: false }) {\n  SILENT_LOG = options.silent\n\n  runLogFun(console.info(\"Start extracting loi...\"), options)\n  const meta = await extractMetaDonnees(html)\n  const sommaire = await extractSommaire(html)\n  const partialMotifs: any = await extractMotifs(html)\n  const partialLoi: any = await extractProjetLoi(html)\n  const exposeMotifs = await populateMotifs(partialMotifs, html)\n  const loi = await populateProjetLoi(partialLoi, html)\n\n  return {\n    sommaire,\n    loi,\n    exposeMotifs,\n    meta,\n  }\n}\n\n/**\n * Cleans the given HTML string by removing unnecessary tags and content.\n *\n * @param {string} html - The HTML string to be cleaned.\n * @return {string} The cleaned HTML string.\n */\nfunction cleanHtml(html: string) {\n  let cleanedHtml = html.replace(/(<style[\\w\\W]+style>)/g, \"\")\n  cleanedHtml = cleanedHtml.replace(/(<head[\\w\\W]+head>)/g, \"\")\n  cleanedHtml = cleanedHtml.replace(/<img[^>]*>/g, \"\")\n\n  return cleanedHtml\n}\n\n/**\n * Removes all HTML tags from the given HTML string and returns the cleaned text.\n *\n * @param {string} html - The HTML string from which to remove tags.\n * @return {string} The cleaned text without any HTML tags.\n */\nfunction removeHtmlTags(html: string): string {\n  // Regular expression to match HTML tags\n  const htmlTagRegex = /<[^>]*>/g\n\n  // Replace all HTML tags with an empty string\n  const textWithoutTags = html.replace(htmlTagRegex, \"\")\n  return textWithoutTags\n}\n\n/**\n * Populates the motifs object with the extracted text from the given HTML.\n *\n * @param {Record<string, any>} motifs - The motifs object to be populated.\n * @param {string} html - The HTML string from which to extract the text.\n * @return {Promise<Record<string, any>>} - The populated motifs object.\n */\nasync function populateMotifs(motifs: Record<string, any>, html: string) {\n  runLogFun(console.info(\"Populating expose motifs...\"))\n  let cleanedHtml = cleanHtml(html)\n\n  if (motifs.debut === motifs.fin || !motifs.fin) {\n    motifs.texte = motifs.debut\n  } else {\n    const systemTemplate = `\n      # Instructions :\n\n      Tu es un expert de la loi et de l'analyse de pages HTML.\n      Tu dois analyser un texte de loi afin d'en extraire certaines parties. \n      Le format d'entrée est du HTML. Le format de sortie est du texte.\n      Récupère l'intégralité du texte commençant par :\n\n      \"\"\"\n      {debut}\n      \"\"\"\n\n      Et finissant par :\n\n      \"\"\"\n      {fin}\n      \"\"\"\n    `\n\n    const prompt = ChatPromptTemplate.fromMessages([\n      [\"system\", systemTemplate],\n      [\"human\", \"{input}\"],\n    ])\n\n    const structuredModel = MODEL.withStructuredOutput(FULL_TEXTE_SCHEMA)\n    const chain = prompt.pipe(structuredModel)\n\n    const articlePromptResult: any = await chain.invoke({\n      input: cleanedHtml,\n      debut: motifs.debut,\n      fin: motifs.fin,\n    })\n\n    motifs.texte = articlePromptResult.texte\n  }\n\n  runLogFun(\n    console.info(\"Opération de peuplement de l'exposé des motifs terminée ✅\"),\n    { silent: SILENT_LOG },\n  )\n  delimiter(SILENT_LOG)\n\n  delete motifs.debut\n  delete motifs.fin\n  return motifs\n}\n\n/**\n * Asynchronously populates a projet loi object with the full text of each article and alinea in the given HTML.\n *\n * @param {Record<string, any>} partial - The partial projet loi object to be populated.\n * @param {string} html - The HTML containing the text of the articles and alineas.\n * @return {Promise<Record<string, any>>} A Promise that resolves to the fully populated projet loi object.\n */\nasync function populateProjetLoi(partial: Record<string, any>, html: string) {\n  runLogFun(console.group(\"Peuplement du projet loi...\"), {\n    silent: SILENT_LOG,\n  })\n  let cleanedHtml = cleanHtml(html)\n\n  const articles: Record<string, any>[] = partial.articles\n  const fullArticles: Record<string, any>[] = []\n\n  const systemTemplate = `\n    # Instructions :\n\n    Tu es un expert de la loi et de l'analyse de pages HTML.\n    Tu dois analyser un texte de loi afin d'en extraire certaines parties. \n    Le format d'entrée est du HTML. Le format de sortie est du texte.\n    Récupère l'intégralité du texte commençant par :\n\n    \"\"\"\n    {debut}\n    \"\"\"\n\n    Et finissant par :\n\n    \"\"\"\n    {fin}\n    \"\"\"\n  `\n\n  const prompt = ChatPromptTemplate.fromMessages([\n    [\"system\", systemTemplate],\n    [\"human\", \"{input}\"],\n  ])\n\n  const structuredModel = MODEL.withStructuredOutput(FULL_TEXTE_SCHEMA)\n  const chain = prompt.pipe(structuredModel)\n\n  for (const article of articles) {\n    if (article.debut === article.fin || !article.fin) {\n      article.texte = article.debut\n    } else {\n      const articlePromptResult: any = await chain.invoke({\n        input: cleanedHtml,\n        debut: article.debut,\n        fin: article.fin,\n      })\n\n      article.texte = articlePromptResult.texte\n    }\n\n    for (const alinea of article.alineas) {\n      if (alinea.debut === alinea.fin || !alinea.fin) {\n        alinea.texte = alinea.debut\n        continue\n      }\n\n      const alineaPromptResult: any = await chain.invoke({\n        input: article.texte,\n        debut: alinea.debut,\n        fin: alinea.fin,\n      })\n\n      delete alinea.debut\n      delete alinea.fin\n      alinea.texte = alineaPromptResult.texte\n    }\n\n    runLogFun(\n      console.info(\n        \"Opération de peuplement du contenu du projet de loi terminée ✅\",\n      ),\n      { silent: SILENT_LOG },\n    )\n    delete article.debut\n    delete article.fin\n    fullArticles.push(article)\n  }\n\n  const projetLoi = {\n    ...partial,\n    articles: fullArticles,\n  }\n\n  runLogFun(console.groupEnd(), { silent: SILENT_LOG })\n  delimiter()\n  return projetLoi\n}\n\n/**\n * Asynchronously extracts the \"expose motifs\" from the given HTML.\n *\n * @param {string} html - The HTML string from which to extract the \"expose motifs\".\n * @return {Promise<Record<string, any>>} - A Promise that resolves to the extracted \"expose motifs\" object.\n * The object contains the following properties:\n * - `debut`: The beginning of the \"expose motifs\".\n * - `fin`: The end of the \"expose motifs\".\n * @throws {Error} - If the extracted \"expose motifs\" do not validate against the EXPOSE_MOTIFS_SCHEMA.\n */\nasync function extractMotifs(html: string) {\n  runLogFun(console.group(\"Parsing expose motifs...\"), { silent: SILENT_LOG })\n  let cleanedHtml = cleanHtml(html)\n  cleanedHtml = removeHtmlTags(cleanedHtml)\n\n  const structuredModel = MODEL.withStructuredOutput(EXPOSE_MOTIFS_SCHEMA)\n\n  const motifsSystemTemplate = `\n    ${SYSTEM_TEMPLATE}\n\n    # Examples: \n\n    ## Exemple 1 User Input :\n    \"\"\"\n    {example1}\n    \"\"\"\n    \n    ## Exemple 1 JSON Output :\n    \"\"\"\n    {output1}\n    \"\"\"\n\n    ## Exemple 2 User Input :\n    \"\"\"\n    {example2}\n    \"\"\"\n    \n    ## Exemple 2 JSON Output :\n    \"\"\"\n    {output2}\n    \"\"\"\n    `\n\n  const prompt = ChatPromptTemplate.fromMessages([\n    [\"system\", motifsSystemTemplate],\n    [\"human\", \"{input}\"],\n  ])\n\n  const chain = prompt.pipe(structuredModel)\n  const motifsPromptResult: any = await chain.invoke({\n    input: cleanedHtml,\n    example1: EXAMPLES.PRJLANR5L16B0914.input,\n    example2: EXAMPLES.PRJLANR5L16B2424.input,\n    output1: EXAMPLES.PRJLANR5L16B0914.motifs,\n    output2: EXAMPLES.PRJLANR5L16B2424.motifs,\n  })\n\n  // console.log(JSON.stringify(motifsPromptResult))\n  runLogFun(\n    console.table([\n      [\"Début\", motifsPromptResult.debut.substring(0, 30)],\n      [\"Fin\", motifsPromptResult.fin.substring(0, 30)],\n    ]),\n    { silent: SILENT_LOG },\n  )\n\n  runLogFun(console.groupEnd(), { silent: SILENT_LOG })\n  delimiter()\n\n  const ajv = new Ajv()\n  if (ajv.validate(EXPOSE_MOTIFS_SCHEMA, motifsPromptResult)) {\n    runLogFun(console.info(\"Exposé des motifs OK 👌\"), { silent: SILENT_LOG })\n    return motifsPromptResult\n  }\n\n  runLogFun(console.warn(\"Exposé des motifs KO ❌\"), { silent: SILENT_LOG })\n  return {}\n}\n\n/**\n * Asynchronously extracts the metadata from the given HTML.\n *\n * @param {string} html - The HTML string from which to extract the metadata.\n * @return {Promise<Record<string, any>>} - A Promise that resolves to the extracted metadata object.\n * The object contains the following properties:\n * - `documentRef`: The reference of the document.\n * - `titre`: The title of the document.\n * - `numeroTexte`: The number of the text.\n * - `procedureAcceleree`: The accelerated procedure.\n * @throws {Error} - If the extracted metadata do not validate against the META_DONNEES_SCHEMA.\n */\nasync function extractMetaDonnees(html: string) {\n  delimiter()\n  let cleanedHtml = cleanHtml(html)\n  cleanedHtml = removeHtmlTags(cleanedHtml)\n\n  const structuredModel = MODEL.withStructuredOutput(META_DONNEES_SCHEMA)\n\n  const metaDonneesSystemTemplate = `\n    ${SYSTEM_TEMPLATE}\n    `\n\n  const prompt = ChatPromptTemplate.fromMessages([\n    [\"system\", metaDonneesSystemTemplate],\n    [\"human\", \"{input}\"],\n  ])\n\n  const chain = prompt.pipe(structuredModel)\n  const result: any = await chain.invoke({\n    input: cleanedHtml,\n    example1: EXAMPLES.PRJLANR5L16B0914.input,\n    example2: EXAMPLES.PRJLANR5L16B2424.input,\n    output1: EXAMPLES.PRJLANR5L16B0914.meta,\n    output2: EXAMPLES.PRJLANR5L16B2424.meta,\n  })\n\n  console.group(\"Meta-données\")\n  console.table([\n    [\"Référence\", result.documentRef],\n    [\"Titre\", result.titre],\n    [\"Numéro du texte\", result.numeroTexte],\n    [\"Procédure accéléré\", result.procedureAcceleree],\n  ])\n  console.groupEnd()\n  delimiter()\n\n  const ajv = new Ajv()\n  if (ajv.validate(META_DONNEES_SCHEMA, result)) {\n    runLogFun(console.warn(\"Meta-données OK 👌\"), { silent: SILENT_LOG })\n    return result\n  }\n\n  runLogFun(console.warn(\"Meta-données non-conforme ❌\"), {\n    silent: SILENT_LOG,\n  })\n  return {}\n}\n\n/**\n * Asynchronously extracts the \"projet de loi\" from the given HTML.\n *\n * @param {string} html - The HTML string from which to extract the \"projet de loi\".\n * @return {Promise<Record<string, any>>} - A Promise that resolves to the extracted \"projet de loi\" object.\n * The object contains the following properties:\n * - `articles`: An array of article objects, each containing the following properties:\n *   - `numeroArticle`: The number of the article.\n *   - `cardinal`: The cardinal of the article.\n *   - `titre`: The title of the article.\n *   - `debut`: The beginning of the article.\n *   - `fin`: The end of the article.\n *   - `alineas`: An array of alineas.\n * @throws {Error} - If the extracted \"projet de loi\" does not validate against the PROJET_LOI_SCHEMA.\n */\nasync function extractProjetLoi(html: string) {\n  runLogFun(console.group(\"Parsing loi...\"), { silent: SILENT_LOG })\n  let cleanedHtml = cleanHtml(html)\n  const structuredModel = MODEL.withStructuredOutput(PROJET_LOI_SCHEMA)\n\n  const projetLoiSystemTemplate = `\n    ${SYSTEM_TEMPLATE}\n\n    # Examples: \n\n    ## Exemple 1 User Input :\n    \"\"\"\n    {example1}\n    \"\"\"\n    \n    ## Exemple 1 JSON Output :\n    \"\"\"\n    {output1}\n    \"\"\"\n\n    ## Exemple 2 User Input :\n    \"\"\"\n    {example2}\n    \"\"\"\n    \n    ## Exemple 2 JSON Output :\n    \"\"\"\n    {output2}\n    \"\"\"\n    `\n\n  const prompt = ChatPromptTemplate.fromMessages([\n    [\"system\", projetLoiSystemTemplate],\n    [\"human\", \"{input}\"],\n  ])\n\n  const chain = prompt.pipe(structuredModel)\n  const articlesPromptResult: any = await chain.invoke({\n    input: cleanedHtml,\n    example1: EXAMPLES.PRJLANR5L16B0914.input,\n    example2: EXAMPLES.PRJLANR5L16B2424.input,\n    output1: EXAMPLES.PRJLANR5L16B0914.loi,\n    output2: EXAMPLES.PRJLANR5L16B2424.loi,\n  })\n\n  runLogFun(\n    console.log(\"Found \", articlesPromptResult.articles.length, \" articles.\"),\n    { silent: SILENT_LOG },\n  )\n\n  for (const article of articlesPromptResult.articles) {\n    article.alineas = await extractAlineas(html, article)\n  }\n\n  runLogFun(\n    console.table(\n      articlesPromptResult.articles.map((article: any) => [\n        article.numeroArticle,\n        article.titre,\n        article.debut.substring(0, 10),\n        article.fin.substring(0, 10),\n        `Nombre d'alineas : ${article.alineas.length}`,\n      ]),\n    ),\n    { silent: SILENT_LOG },\n  )\n  runLogFun(console.groupEnd(), { silent: SILENT_LOG })\n\n  const ajv = new Ajv()\n  if (ajv.validate(PROJET_LOI_SCHEMA, articlesPromptResult)) {\n    runLogFun(console.info(\"Projet de loi OK 👌\"), { silent: SILENT_LOG })\n    delimiter()\n    return articlesPromptResult\n  }\n\n  runLogFun(console.warn(\"Projet de loi KO ❌\"), { silent: SILENT_LOG })\n  delimiter()\n  return {}\n}\n\nasync function extractAlineas(html: string, article: any) {\n  runLogFun(console.group(\"Parsing alineas...\"), { silent: SILENT_LOG })\n  let cleanedHtml = cleanHtml(html)\n\n  const structuredModel = MODEL.withStructuredOutput(ALINEA_SCHEMA)\n\n  const alineasSystemTemplate = `\n    ${SYSTEM_TEMPLATE}\n\n    Extrais tous les alineas de la portion de texte commençant par « {debut} » et finissant par « {fin} ».\n    Un alinéa contiennent toujours une balise « <img ».\n\n    # Examples: \n\n    ## Exemple 1 User Input :\n    \"\"\"\n    {example1}\n    \"\"\"\n    \n    ## Exemple 1 JSON Output :\n    \"\"\"\n    {output1}\n    \"\"\"\n    `\n\n  const prompt = ChatPromptTemplate.fromMessages([\n    [\"system\", alineasSystemTemplate],\n    [\"human\", \"{input}\"],\n  ])\n\n  const chain = prompt.pipe(structuredModel)\n  const alineasPromptResult: any = await chain.invoke({\n    input: cleanedHtml,\n    debut: article.debut,\n    fin: article.fin,\n    example1: EXAMPLES.PRJLANR5L16B2424.input,\n    output1: EXAMPLES.PRJLANR5L16B2424.alineas,\n  })\n\n  const ajv = new Ajv()\n  if (ajv.validate(ALINEA_SCHEMA, alineasPromptResult as any)) {\n    runLogFun(\n      console.info(\n        \"Found \",\n        alineasPromptResult.alineas.length,\n        \" alineas for Article \",\n        article.numeroArticle,\n        article.titre,\n      ),\n      { silent: SILENT_LOG },\n    )\n    runLogFun(console.groupEnd(), { silent: SILENT_LOG })\n    delimiter()\n    return alineasPromptResult.alineas\n  }\n\n  runLogFun(console.warn(\"Alineas KO\"), { silent: SILENT_LOG })\n  delimiter()\n  return {}\n}\n\n/**\n * Asynchronously extracts the \"sommaire\" (outline) from the given HTML.\n *\n * @param {string} html - The HTML string from which to extract the \"sommaire\".\n * @return {Promise<Record<string, any>>} - A Promise that resolves to the extracted \"sommaire\" object.\n * The object contains the following properties:\n * - `sommaire`: An array of main division objects, each containing the following properties:\n *   - `numeroDivision`: The number of the main division.\n *   - `titre`: The title of the main division.\n *   - `typeDivision`: The type of content in the main division.\n *   - `sequence`: The sequence of the main division.\n *   - `parent`: The parent of the main division.\n * @throws {Error} - If the extracted \"sommaire\" does not validate against the SOMMAIRE_SCHEMA.\n */\nasync function extractSommaire(html: string) {\n  let cleanedHtml = cleanHtml(html)\n  cleanedHtml = removeHtmlTags(cleanedHtml)\n\n  const structuredModel = MODEL.withStructuredOutput(SOMMAIRE_SCHEMA)\n\n  const sommaireSystemTemplate = `\n    ${SYSTEM_TEMPLATE}\n\n    # Examples: \n\n    ## Exemple 1 User Input :\n    \"\"\"\n    {example1}\n    \"\"\"\n    \n    ## Exemple 1 JSON Output :\n    \"\"\"\n    {output1}\n    \"\"\"\n\n    ## Exemple 2 User Input :\n    \"\"\"\n    {example2}\n    \"\"\"\n    \n    ## Exemple 2 JSON Output :\n    \"\"\"\n    {output2}\n    \"\"\"\n    `\n\n  const prompt = ChatPromptTemplate.fromMessages([\n    [\"system\", sommaireSystemTemplate],\n    [\"human\", \"{input}\"],\n  ])\n\n  const chain = prompt.pipe(structuredModel)\n  const sommairePromptResult: any = await chain.invoke({\n    input: cleanedHtml,\n    example1: EXAMPLES.PRJLANR5L16B2014.input,\n    output1: EXAMPLES.PRJLANR5L16B2014.sommaire,\n    example2: EXAMPLES.PRJLANR5L16B0914.input,\n    output2: EXAMPLES.PRJLANR5L16B0914.sommaire,\n  })\n\n  if (!sommairePromptResult.sommaire) {\n    runLogFun(console.warn(\"Aucun sommaire n'a été trouvé ❓\"), {\n      silent: SILENT_LOG,\n    })\n    delimiter()\n    return { sommaire: [] }\n  }\n\n  runLogFun(console.group(\"Sommaire\"), { silent: SILENT_LOG })\n  runLogFun(\n    console.log(\n      \"Found \",\n      sommairePromptResult.sommaire.length,\n      \" main divisions (level 1).\",\n    ),\n    { silent: SILENT_LOG },\n  )\n  runLogFun(\n    console.table(\n      sommairePromptResult.sommaire.map((item: any) => [\n        item.sequence,\n        item.titre,\n        item.typeDivision,\n        item.parent,\n      ]),\n    ),\n    { silent: SILENT_LOG },\n  )\n  runLogFun(console.groupEnd(), { silent: SILENT_LOG })\n\n  const ajv = new Ajv()\n  if (ajv.validate(SOMMAIRE_SCHEMA, sommairePromptResult as any)) {\n    runLogFun(console.info(\"Sommaire OK 👌\"), { silent: SILENT_LOG })\n    delimiter()\n    return sommairePromptResult.sommaire\n  }\n\n  runLogFun(console.warn(\"La construction du sommaire est KO ❌\"), {\n    silent: SILENT_LOG,\n  })\n  delimiter()\n  return { sommaire: [] }\n}\n"],"mappings":"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","ignoreList":[]}