n8n-nodes-docx-filler 2.1.0 → 2.4.0

package/dist/DocxFillerAI/DocxFillerAI.node.js

@@ -197,6 +197,32 @@ function validateFieldValue(fieldType, value) {
     const cleanValue = value.trim();
     return field.valuePatterns.some(pattern => pattern.test(cleanValue));
 }
+/**
+ * Détecte le type de document à partir des paragraphes
+ */
+function detectDocumentType(paragraphs) {
+    for (const p of paragraphs) {
+        const text = p.textNormalized;
+        // AE - Acte d'Engagement (vérifier en premier car plus spécifique)
+        if (text.includes('acte d\'engagement') || text.includes('acte d engagement') ||
+            text.includes('engagement du titulaire')) {
+            return 'AE';
+        }
+        // DC1 - Lettre de candidature
+        if (text.includes('dc1') || text.includes('lettre de candidature')) {
+            return 'DC1';
+        }
+        // DC2 - Déclaration du candidat
+        if (text.includes('dc2') || text.includes('déclaration du candidat individuel')) {
+            return 'DC2';
+        }
+        // ATTRI1 - Attribution
+        if (text.includes('attri1')) {
+            return 'ATTRI1';
+        }
+    }
+    return 'unknown';
+}
 /**
  * Extrait les données d'un document source
  */
@@ -209,12 +235,21 @@ function extractSourceData(paragraphs) {
     for (let i = 0; i < paragraphs.length; i++) {
         const p = paragraphs[i];
         const text = p.text.trim();
-        // Détecter le type de document
-        if (p.textNormalized.includes('dc1') || p.textNormalized.includes('lettre de candidature')) {
-            documentType = 'DC1';
-        }
-        else if (p.textNormalized.includes('dc2') || p.textNormalized.includes('déclaration du candidat')) {
-            documentType = 'DC2';
+        // Détecter le type de document (priorité au premier match explicite)
+        if (documentType === 'unknown') {
+            if (p.textNormalized.includes('acte d\'engagement') || p.textNormalized.includes('acte d engagement') ||
+                (p.textNormalized.includes('ae') && p.textNormalized.includes('formulaire'))) {
+                documentType = 'AE';
+            }
+            else if (p.textNormalized.includes('dc1') || p.textNormalized.includes('lettre de candidature')) {
+                documentType = 'DC1';
+            }
+            else if (p.textNormalized.includes('dc2') || p.textNormalized.includes('déclaration du candidat')) {
+                documentType = 'DC2';
+            }
+            else if (p.textNormalized.includes('attri1') || p.textNormalized.includes('attribution')) {
+                documentType = 'ATTRI1';
+            }
         }
         // Extraire les checkboxes
         if (p.hasCheckbox) {
@@ -271,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({
@@ -296,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
@@ -530,6 +606,139 @@ async function getDocumentBuffer(context, itemIndex, inputType, inputValue, item
     validateDocxBuffer(buffer, source);
     return buffer;
 }
+/**
+ * Génère un rapport de vérification basique (sans LLM)
+ */
+function generateBasicVerificationReport(sourceData, templateDocType, filledFields, fillPositions) {
+    const fieldDetails = [];
+    const warnings = [];
+    const suggestions = [];
+    // Analyser les champs remplis
+    for (const field of sourceData.fields) {
+        const wasFilled = filledFields.some(f => f.includes(field.fieldType));
+        fieldDetails.push({
+            fieldType: field.fieldType,
+            label: field.label,
+            filledValue: field.value,
+            confidence: field.confidence >= 0.9 ? 'high' : field.confidence >= 0.7 ? 'medium' : 'low',
+            doubt: field.confidence < 0.7 ? 'Confiance faible dans l\'extraction' : null,
+            wasEmpty: !wasFilled,
+        });
+    }
+    // Identifier les champs non remplis
+    const filledTypes = new Set(sourceData.fields.map(f => f.fieldType));
+    const expectedFields = ['nom_commercial', 'siret', 'adresse', 'email', 'telephone'];
+    const unfilledFields = expectedFields.filter(f => !filledTypes.has(f));
+    if (unfilledFields.length > 0) {
+        warnings.push(`Champs attendus non trouvés: ${unfilledFields.join(', ')}`);
+    }
+    // Vérifier la compatibilité
+    const compatiblePairs = [
+        ['DC1', 'DC1'], ['DC1', 'DC2'], ['DC2', 'DC1'], ['DC2', 'DC2'],
+        ['AE', 'AE'], ['AE', 'DC1'], ['AE', 'DC2'],
+        ['DC1', 'AE'], ['DC2', 'AE'],
+    ];
+    const isCompatible = compatiblePairs.some(([s, t]) => sourceData.documentType.includes(s) && templateDocType.includes(t)) || sourceData.documentType === 'unknown' || templateDocType === 'unknown';
+    if (!isCompatible) {
+        warnings.push(`Types de documents potentiellement incompatibles: ${sourceData.documentType} → ${templateDocType}`);
+    }
+    // Suggestions
+    if (sourceData.fields.length < 3) {
+        suggestions.push('Peu de champs extraits. Vérifiez que le document source contient bien les données entreprise.');
+    }
+    if (fillPositions.length > sourceData.fields.length) {
+        suggestions.push('Le template contient plus de champs que le source. Certains resteront vides.');
+    }
+    const highConfCount = fieldDetails.filter(f => f.confidence === 'high').length;
+    const medConfCount = fieldDetails.filter(f => f.confidence === 'medium').length;
+    const lowConfCount = fieldDetails.filter(f => f.confidence === 'low').length;
+    return {
+        documentsCompatible: isCompatible,
+        compatibilityScore: isCompatible ? (sourceData.fields.length > 3 ? 85 : 60) : 30,
+        compatibilityReason: isCompatible
+            ? 'Documents compatibles pour le mapping des données entreprise'
+            : 'Types de documents potentiellement incompatibles',
+        sourceDocType: sourceData.documentType,
+        templateDocType,
+        fieldsAnalysis: {
+            total: fillPositions.length,
+            filled: filledFields.length,
+            unfilled: fillPositions.length - filledFields.length,
+            highConfidence: highConfCount,
+            mediumConfidence: medConfCount,
+            lowConfidence: lowConfCount,
+        },
+        fieldDetails,
+        checkboxesAnalysis: {
+            total: sourceData.checkboxes.length,
+            checked: sourceData.checkboxes.filter(c => c.isChecked).length,
+            unchecked: sourceData.checkboxes.filter(c => !c.isChecked).length,
+        },
+        warnings,
+        suggestions,
+    };
+}
+/**
+ * Effectue une vérification avec le LLM
+ */
+async function performLLMVerification(llm, sourceText, templateText, sourceDocType, templateDocType, mappedFields) {
+    var _a, _b, _c, _d, _e, _f;
+    const prompt = VERIFICATION_PROMPT
+        .replace('{source_type}', sourceDocType)
+        .replace('{template_type}', templateDocType)
+        .replace('{source_text}', sourceText.substring(0, 3000))
+        .replace('{template_text}', templateText.substring(0, 3000))
+        .replace('{mapped_fields}', JSON.stringify(mappedFields, null, 2));
+    try {
+        const response = await llm.invoke(prompt);
+        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]);
+            return {
+                documentsCompatible: (_a = parsed.documentsCompatible) !== null && _a !== void 0 ? _a : true,
+                compatibilityScore: (_b = parsed.compatibilityScore) !== null && _b !== void 0 ? _b : 70,
+                compatibilityReason: (_c = parsed.compatibilityReason) !== null && _c !== void 0 ? _c : 'Analyse IA effectuée',
+                warnings: (_d = parsed.warnings) !== null && _d !== void 0 ? _d : [],
+                suggestions: (_e = parsed.suggestions) !== null && _e !== void 0 ? _e : [],
+                fieldDetails: ((_f = parsed.fieldVerifications) !== null && _f !== void 0 ? _f : []).map((fv) => ({
+                    fieldType: fv.fieldType,
+                    label: fv.label,
+                    filledValue: fv.filledValue,
+                    confidence: fv.confidence || 'medium',
+                    doubt: fv.doubt,
+                    wasEmpty: false,
+                })),
+            };
+        }
+    }
+    catch (error) {
+        // En cas d'erreur, retourner un rapport partiel
+        return {
+            warnings: [`Erreur lors de la vérification IA: ${error.message}`],
+        };
+    }
+    return {};
+}
 /**
  * Convertit le document en texte structuré pour le LLM
  */
@@ -587,28 +796,102 @@ 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).
 
-DONNÉES SOURCE:
+OBJECTIF: Mapper INTELLIGEMMENT les données entreprise du document SOURCE vers le TEMPLATE vide.
+
+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"}
   ]
-}
+}`;
+const VERIFICATION_PROMPT = `Tu es un expert en vérification de documents administratifs français (DC1, DC2, AE, ATTRI1).
+
+CONTEXTE:
+- Document SOURCE (contient les données de l'entreprise): {source_type}
+- Document TEMPLATE (formulaire à remplir): {template_type}
 
-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]`;
+DOCUMENT SOURCE (avec données):
+"""
+{source_text}
+"""
+
+DOCUMENT TEMPLATE (à remplir):
+"""
+{template_text}
+"""
+
+DONNÉES EXTRAITES ET MAPPÉES:
+{mapped_fields}
+
+ANALYSE DEMANDÉE:
+1. Les deux documents sont-ils compatibles pour un mapping de données entreprise ?
+   - Un DC1/DC2/AE rempli peut servir de source pour un autre DC1/DC2/AE vide
+   - Les données d'entreprise (SIRET, adresse, nom, etc.) sont transférables entre formulaires similaires
+
+2. Pour chaque champ mappé, évalue:
+   - La CONFIANCE du mapping (high/medium/low)
+   - Un éventuel DOUTE si le mapping semble incorrect
+
+3. Identifie:
+   - Les champs qui DEVRAIENT être remplis mais ne le sont pas
+   - Les WARNINGS (incohérences potentielles)
+   - Les SUGGESTIONS d'amélioration
+
+IMPORTANT - Distingue bien:
+- Données de l'ACHETEUR (nom du marché, références, dates limites) = NE PAS mapper
+- Données du CANDIDAT (entreprise: SIRET, adresse, nom commercial, etc.) = À mapper
+
+Retourne UNIQUEMENT un JSON valide:
+{
+  "documentsCompatible": true,
+  "compatibilityScore": 85,
+  "compatibilityReason": "Les deux documents sont des formulaires de marchés publics partageant les mêmes champs entreprise",
+  "fieldVerifications": [
+    {
+      "fieldType": "siret",
+      "label": "Numéro SIRET",
+      "filledValue": "89198692900018",
+      "confidence": "high",
+      "doubt": null
+    },
+    {
+      "fieldType": "adresse",
+      "label": "Adresse postale",
+      "filledValue": "13 rue exemple",
+      "confidence": "medium",
+      "doubt": "L'adresse semble incomplète (code postal manquant)"
+    }
+  ],
+  "unfilledFields": ["capital", "code_naf"],
+  "warnings": ["Le SIRET source ne correspond pas au format attendu"],
+  "suggestions": ["Vérifier manuellement le champ TVA intracommunautaire"]
+}`;
 // ============================================================================
 // Main Node Class
 // ============================================================================
@@ -738,6 +1021,14 @@ class DocxFillerAI {
                     displayOptions: { show: { operation: ['fill'] } },
                     description: 'Utiliser le LLM connecté pour un mapping plus intelligent (plus lent)',
                 },
+                {
+                    displayName: 'AI Verification',
+                    name: 'enableVerification',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: { show: { operation: ['fill'] } },
+                    description: 'Activer la vérification IA pour valider le mapping et détecter les doutes',
+                },
                 // Extract
                 {
                     displayName: 'Document Input Type',
@@ -789,6 +1080,7 @@ class DocxFillerAI {
                     const templateValue = this.getNodeParameter('templateDocument', i, '');
                     const outputProperty = this.getNodeParameter('outputProperty', i);
                     const useLLM = this.getNodeParameter('useLLM', i);
+                    const enableVerification = this.getNodeParameter('enableVerification', i);
                     // Charger les documents
                     const sourceBuffer = await getDocumentBuffer(this, i, sourceInputType, sourceValue, items, 'source');
                     const templateBuffer = await getDocumentBuffer(this, i, templateInputType, templateValue, items, 'template');
@@ -825,19 +1117,68 @@ 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) {
+                            // Utiliser les mappings de l'IA
+                            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`);
+                                templateXml = templateXml.replace(oldP, newP);
+                                filledFields.push(`${mapping.fieldType}: ${mapping.value}`);
+                                usedIndices.add(mapping.templateIndex);
+                            }
+                        }
+                        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
@@ -854,22 +1195,87 @@ class DocxFillerAI {
                         type: 'nodebuffer',
                         compression: 'DEFLATE',
                     });
+                    // Détecter le type du template (document de sortie)
+                    const templateDocType = detectDocumentType(templateParagraphs);
+                    const finalDocType = templateDocType !== 'unknown' ? templateDocType : sourceData.documentType;
+                    // Générer le rapport de vérification
+                    const fillPositionsForReport = findFillPositions(templateParagraphs);
+                    let verificationReport = generateBasicVerificationReport(sourceData, finalDocType, filledFields, fillPositionsForReport);
+                    // Si vérification IA activée et LLM disponible, enrichir le rapport
+                    if (enableVerification && llm) {
+                        const sourceStructuredText = docxToStructuredText(sourceParagraphs);
+                        const templateStructuredText = docxToStructuredText(templateParagraphs);
+                        const llmVerification = await performLLMVerification(llm, sourceStructuredText, templateStructuredText, sourceData.documentType, finalDocType, filledFields);
+                        // Fusionner les résultats LLM avec le rapport basique
+                        if (llmVerification.documentsCompatible !== undefined) {
+                            verificationReport.documentsCompatible = llmVerification.documentsCompatible;
+                        }
+                        if (llmVerification.compatibilityScore !== undefined) {
+                            verificationReport.compatibilityScore = llmVerification.compatibilityScore;
+                        }
+                        if (llmVerification.compatibilityReason) {
+                            verificationReport.compatibilityReason = llmVerification.compatibilityReason;
+                        }
+                        if (llmVerification.warnings && llmVerification.warnings.length > 0) {
+                            verificationReport.warnings = [...verificationReport.warnings, ...llmVerification.warnings];
+                        }
+                        if (llmVerification.suggestions && llmVerification.suggestions.length > 0) {
+                            verificationReport.suggestions = [...verificationReport.suggestions, ...llmVerification.suggestions];
+                        }
+                        if (llmVerification.fieldDetails && llmVerification.fieldDetails.length > 0) {
+                            // Enrichir avec les détails LLM (doutes, confiance)
+                            for (const llmField of llmVerification.fieldDetails) {
+                                const existingField = verificationReport.fieldDetails.find(f => f.fieldType === llmField.fieldType);
+                                if (existingField && llmField.doubt) {
+                                    existingField.doubt = llmField.doubt;
+                                    existingField.confidence = llmField.confidence;
+                                }
+                            }
+                        }
+                    }
                     // Générer le nom de fichier
                     const date = new Date().toISOString().split('T')[0];
                     const companyName = (sourceData.companyName || 'Document').replace(/[^a-zA-Z0-9]/g, '_');
-                    const outputFilename = `${companyName}_${sourceData.documentType}_${date}.docx`;
+                    const outputFilename = `${companyName}_${finalDocType}_${date}.docx`;
                     const binaryData = await this.helpers.prepareBinaryData(outputBuffer, outputFilename, DOCX_MIME_TYPE);
+                    // Extraire les champs avec doutes pour un accès facile
+                    const fieldsWithDoubts = verificationReport.fieldDetails
+                        .filter(f => f.doubt !== null)
+                        .map(f => ({ field: f.fieldType, label: f.label, doubt: f.doubt }));
                     returnData.push({
                         json: {
                             success: true,
                             filename: outputFilename,
-                            documentType: sourceData.documentType,
+                            documentType: finalDocType,
+                            sourceDocumentType: sourceData.documentType,
                             companyName: sourceData.companyName,
-                            filledFields,
-                            modifiedCheckboxes,
-                            extractedFieldsCount: sourceData.fields.length,
+                            // Résumé du remplissage
+                            summary: {
+                                filledFields: filledFields.length,
+                                unfilledFields: verificationReport.fieldsAnalysis.unfilled,
+                                modifiedCheckboxes,
+                                extractedFieldsCount: sourceData.fields.length,
+                                compatibilityScore: verificationReport.compatibilityScore,
+                            },
+                            // Détails des champs remplis
+                            filledFieldsList: filledFields,
+                            // Rapport de vérification complet
+                            verification: {
+                                documentsCompatible: verificationReport.documentsCompatible,
+                                compatibilityScore: verificationReport.compatibilityScore,
+                                compatibilityReason: verificationReport.compatibilityReason,
+                                fieldsAnalysis: verificationReport.fieldsAnalysis,
+                                checkboxesAnalysis: verificationReport.checkboxesAnalysis,
+                                fieldsWithDoubts,
+                                warnings: verificationReport.warnings,
+                                suggestions: verificationReport.suggestions,
+                            },
+                            // Détails complets des champs (pour debug)
+                            fieldDetails: verificationReport.fieldDetails,
+                            // Métadonnées
                             usedLLM: useLLM && !!llm,
-                            message: `Rempli: ${filledFields.length} champs, ${modifiedCheckboxes} checkboxes`,
+                            usedVerification: enableVerification && !!llm,
+                            message: `Rempli: ${filledFields.length} champs, ${modifiedCheckboxes} checkboxes. Score: ${verificationReport.compatibilityScore}%`,
                         },
                         binary: {
                             [outputProperty]: binaryData,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-docx-filler",
-  "version": "2.1.0",
+  "version": "2.4.0",
   "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",