n8n-nodes-docx-filler 2.3.0 → 2.4.1

package/dist/DocxFillerAI/DocxFillerAI.node.js

@@ -306,21 +306,61 @@ function extractSourceData(paragraphs) {
     }
     return { documentType, companyName, fields, checkboxes };
 }
+/**
+ * Vérifie si un texte est une note de bas de page ou un titre de section (faux positif)
+ */
+function isFalsePositive(text) {
+    const trimmed = text.trim();
+    const normalized = normalize(text);
+    // Notes de bas de page
+    if (/^\(\*+\)/.test(trimmed))
+        return true;
+    if (/^\*+\s/.test(trimmed))
+        return true;
+    // Titres de section (A -, B -, C -, etc.)
+    if (/^[A-Z]\s*[-–—]\s/.test(trimmed))
+        return true;
+    // Textes explicatifs trop longs (généralement des instructions)
+    if (trimmed.length > 150 && !trimmed.includes(':'))
+        return true;
+    // Références aux membres du groupement (zone spéciale, pas candidat individuel)
+    if (normalized.includes('membres du groupement') && normalized.includes('***'))
+        return true;
+    if (normalized.includes('groupement conjoint'))
+        return true;
+    if (normalized.includes('groupement solidaire'))
+        return true;
+    // Textes qui commencent par des références de notes
+    if (/^\(\*/.test(trimmed) || /^à défaut/.test(normalized))
+        return true;
+    return false;
+}
 /**
  * Trouve les positions à remplir dans un template
+ * IMPORTANT: Chaque type de champ n'est rempli qu'UNE SEULE FOIS (premier match)
  */
 function findFillPositions(paragraphs) {
     const positions = [];
     const usedFillIndices = new Set();
+    const usedFieldTypes = new Set(); // NOUVEAU: éviter les doublons par type
     for (let i = 0; i < paragraphs.length; i++) {
         const p = paragraphs[i];
+        // Ignorer les faux positifs (notes, titres, etc.)
+        if (isFalsePositive(p.text))
+            continue;
         const fieldType = detectFieldType(p.text);
+        // NOUVEAU: Si ce type de champ a déjà été trouvé, passer au suivant
+        if (fieldType && usedFieldTypes.has(fieldType))
+            continue;
         if (fieldType) {
             // Chercher le prochain paragraphe vide pour y insérer la valeur
             for (let j = i + 1; j < Math.min(i + 6, paragraphs.length); j++) {
                 if (usedFillIndices.has(j))
                     continue;
                 const nextP = paragraphs[j];
+                // Ignorer les faux positifs comme position de remplissage
+                if (isFalsePositive(nextP.text))
+                    continue;
                 // Position vide = remplissable
                 if (nextP.isEmpty) {
                     positions.push({
@@ -331,6 +371,7 @@ function findFillPositions(paragraphs) {
                         paragraph: nextP,
                     });
                     usedFillIndices.add(j);
+                    usedFieldTypes.add(fieldType); // NOUVEAU: marquer comme utilisé
                     break;
                 }
                 // Si on trouve un autre label, arrêter
@@ -650,9 +691,26 @@ async function performLLMVerification(llm, sourceText, templateText, sourceDocTy
         .replace('{mapped_fields}', JSON.stringify(mappedFields, null, 2));
     try {
         const response = await llm.invoke(prompt);
-        const responseText = typeof response === 'string'
-            ? response
-            : response.content || response.text || JSON.stringify(response);
+        let responseText;
+        if (typeof response === 'string') {
+            responseText = response;
+        }
+        else if (response && typeof response.content === 'string') {
+            responseText = response.content;
+        }
+        else if (response && typeof response.text === 'string') {
+            responseText = response.text;
+        }
+        else if (response && Array.isArray(response.content)) {
+            // Format OpenAI/Anthropic avec content array
+            responseText = response.content
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text)
+                .join('');
+        }
+        else {
+            responseText = JSON.stringify(response);
+        }
         const jsonMatch = responseText.match(/\{[\s\S]*\}/);
         if (jsonMatch) {
             const parsed = JSON.parse(jsonMatch[0]);
@@ -738,28 +796,40 @@ IMPORTANT:
 - Extrait TOUTES les valeurs remplies (SIRET, adresse, email, téléphone, etc.)
 - Pour les checkboxes, isChecked=true si ☒☑▣, false si ☐□▢
 - paragraphIndex = numéro entre crochets au début de chaque ligne`;
-const FILL_PROMPT = `Tu dois mapper les données source vers les positions du template.
+const FILL_PROMPT = `Tu es un expert en remplissage de formulaires administratifs français (DC1, DC2, AE).
+
+OBJECTIF: Mapper INTELLIGEMMENT les données entreprise du document SOURCE vers le TEMPLATE vide.
 
-DONNÉES SOURCE:
+DONNÉES ENTREPRISE EXTRAITES DU SOURCE:
 {source_data}
 
-TEMPLATE (positions vides à remplir):
+TEMPLATE À REMPLIR (paragraphes indexés):
 {template_text}
 
-Retourne UNIQUEMENT un JSON:
+RÈGLES CRITIQUES:
+1. NE MAPPER QUE les données ENTREPRISE (candidat): nom commercial, SIRET, adresse, email, téléphone, TVA, etc.
+2. NE PAS MAPPER les données ACHETEUR: nom du marché, objet, références, dates limites, montants du marché
+3. CHAQUE champ ne doit être rempli qu'UNE SEULE FOIS (pas de doublons!)
+4. NE PAS remplir les zones qui sont:
+   - Des notes de bas de page (commençant par (*), (**), etc.)
+   - Des titres de section (A -, B -, C -, F -, etc.)
+   - Des instructions ou explications
+5. Ne remplir QUE les [EMPTY] qui suivent directement un [LABEL] correspondant à un champ entreprise
+
+Retourne UNIQUEMENT un JSON valide:
 {
   "mappings": [
-    {"sourceField": "nom_commercial", "templateIndex": 34, "value": "ROKODO.IO"}
+    {"fieldType": "nom_commercial", "templateIndex": 34, "value": "ROKODO.IO", "confidence": "high"},
+    {"fieldType": "siret", "templateIndex": 56, "value": "89198692900018", "confidence": "high"}
   ],
   "checkboxMappings": [
-    {"sourceSignature": "candidat pme", "templateIndex": 45, "shouldBeChecked": true}
+    {"templateIndex": 45, "shouldBeChecked": true, "reason": "PME confirmé"}
+  ],
+  "skippedFields": [
+    {"templateIndex": 78, "reason": "Note de bas de page, pas un champ à remplir"},
+    {"templateIndex": 90, "reason": "Titre de section F"}
   ]
-}
-
-RÈGLES:
-1. Fais le mapping SÉMANTIQUE (Raison sociale = Dénomination = Nom commercial)
-2. Utilise les [EMPTY] du template comme positions cibles
-3. Le templateIndex doit correspondre à un paragraphe [EMPTY] qui suit un [LABEL]`;
+}`;
 const VERIFICATION_PROMPT = `Tu es un expert en vérification de documents administratifs français (DC1, DC2, AE, ATTRI1).
 
 CONTEXTE:
@@ -1047,19 +1117,80 @@ class DocxFillerAI {
                             // Fallback au mode sans LLM
                             sourceData = extractSourceData(sourceParagraphs);
                         }
-                        // Mapping avec LLM (pour amélioration future)
+                        // Mapping avec LLM - UTILISER les résultats de l'IA
                         const fillPrompt = FILL_PROMPT
                             .replace('{source_data}', JSON.stringify(sourceData, null, 2))
                             .replace('{template_text}', templateStructured);
-                        // Note: LLM mapping response peut être utilisé pour un mapping plus intelligent
-                        // Pour l'instant, on utilise la logique standard de mapping par patterns
-                        await llm.invoke(fillPrompt);
-                        // Utiliser la logique standard de mapping
-                        const fillPositions = findFillPositions(templateParagraphs);
-                        const result = fillTemplateXml(templateXml, templateParagraphs, sourceData, fillPositions);
-                        templateXml = result.xml;
-                        filledFields = result.filledFields;
-                        modifiedCheckboxes = result.modifiedCheckboxes;
+                        const fillResponse = await llm.invoke(fillPrompt);
+                        let llmMappings = [];
+                        // Parser la réponse du LLM
+                        try {
+                            let fillText;
+                            if (typeof fillResponse === 'string') {
+                                fillText = fillResponse;
+                            }
+                            else if (fillResponse && typeof fillResponse.content === 'string') {
+                                fillText = fillResponse.content;
+                            }
+                            else if (fillResponse && typeof fillResponse.text === 'string') {
+                                fillText = fillResponse.text;
+                            }
+                            else if (fillResponse && Array.isArray(fillResponse.content)) {
+                                fillText = fillResponse.content
+                                    .filter((c) => c.type === 'text')
+                                    .map((c) => c.text)
+                                    .join('');
+                            }
+                            else {
+                                fillText = JSON.stringify(fillResponse);
+                            }
+                            const jsonMatch = fillText.match(/\{[\s\S]*\}/);
+                            if (jsonMatch) {
+                                const parsed = JSON.parse(jsonMatch[0]);
+                                llmMappings = parsed.mappings || [];
+                            }
+                        }
+                        catch {
+                            // Fallback si parsing échoue
+                            llmMappings = [];
+                        }
+                        // Si l'IA a fourni des mappings valides, les utiliser
+                        if (llmMappings.length > 0) {
+                            // Collecter les modifications avec leurs positions
+                            const modifications = [];
+                            const usedIndices = new Set();
+                            for (const mapping of llmMappings) {
+                                if (usedIndices.has(mapping.templateIndex))
+                                    continue;
+                                const targetParagraph = templateParagraphs.find(p => p.index === mapping.templateIndex);
+                                if (!targetParagraph)
+                                    continue;
+                                const oldP = targetParagraph.fullMatch;
+                                const newP = oldP.replace(/(<w:p[^>]*>)([\s\S]*?)(<\/w:p>)/, `$1<w:r><w:t>${escapeXml(mapping.value)}</w:t></w:r>$3`);
+                                modifications.push({
+                                    start: targetParagraph.start,
+                                    end: targetParagraph.end,
+                                    newContent: newP,
+                                    fieldType: mapping.fieldType,
+                                    value: mapping.value,
+                                });
+                                usedIndices.add(mapping.templateIndex);
+                            }
+                            // Appliquer les modifications en ordre INVERSE (pour éviter les décalages de position)
+                            modifications.sort((a, b) => b.start - a.start);
+                            for (const mod of modifications) {
+                                templateXml = templateXml.slice(0, mod.start) + mod.newContent + templateXml.slice(mod.end);
+                                filledFields.push(`${mod.fieldType}: ${mod.value}`);
+                            }
+                        }
+                        else {
+                            // Fallback: utiliser la logique standard
+                            const fillPositions = findFillPositions(templateParagraphs);
+                            const result = fillTemplateXml(templateXml, templateParagraphs, sourceData, fillPositions);
+                            templateXml = result.xml;
+                            filledFields = result.filledFields;
+                            modifiedCheckboxes = result.modifiedCheckboxes;
+                        }
                     }
                     else {
                         // Mode sans LLM: extraction et mapping par patterns

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-docx-filler",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "description": "n8n node to automatically fill DOCX documents (French DC1, DC2, AE forms) using AI for semantic understanding and field mapping.",
   "keywords": [
     "n8n-community-node-package",