n8n-nodes-docx-filler 2.0.1 → 2.3.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) {
@@ -393,14 +428,78 @@ function validateDocxBuffer(buffer, source) {
         throw new Error(`Erreur lors de la lecture du fichier "${source}": ${zipError.message}`);
     }
 }
+/**
+ * Trouve tous les binaires DOCX disponibles dans l'item
+ */
+function findAllDocxBinaries(item) {
+    if (!item.binary)
+        return [];
+    const results = [];
+    for (const [key, binaryData] of Object.entries(item.binary)) {
+        // Vérifier le type MIME ou l'extension
+        const isDocx = (binaryData.mimeType && DOCX_MIME_TYPES.includes(binaryData.mimeType)) ||
+            (binaryData.fileName && binaryData.fileName.toLowerCase().endsWith('.docx'));
+        if (isDocx) {
+            results.push({ key, data: binaryData });
+        }
+    }
+    return results;
+}
+/**
+ * Trouve le premier binaire DOCX disponible dans l'item
+ */
+function findFirstDocxBinary(item) {
+    const all = findAllDocxBinaries(item);
+    return all.length > 0 ? all[0] : null;
+}
+/**
+ * Trouve le deuxième binaire DOCX disponible dans l'item
+ */
+function findSecondDocxBinary(item) {
+    const all = findAllDocxBinaries(item);
+    return all.length > 1 ? all[1] : null;
+}
 /**
  * Charge un document DOCX depuis différentes sources
  */
 async function getDocumentBuffer(context, itemIndex, inputType, inputValue, items, documentName) {
     let buffer = null;
     let source = inputValue;
-    // Mode binaire
-    if (inputType === 'binary' || inputType === 'auto') {
+    // Mode "Premier DOCX" - trouve automatiquement le premier binaire DOCX
+    if (inputType === 'firstDocx') {
+        const found = findFirstDocxBinary(items[itemIndex]);
+        if (found) {
+            buffer = await context.helpers.getBinaryDataBuffer(itemIndex, found.key);
+            source = found.data.fileName || found.key;
+        }
+        else {
+            const availableBinaries = items[itemIndex].binary
+                ? Object.keys(items[itemIndex].binary)
+                : [];
+            throw new Error(`Aucun fichier DOCX trouvé dans les binaires pour ${documentName}. ` +
+                `Binaires disponibles: ${availableBinaries.length > 0 ? availableBinaries.join(', ') : 'aucun'}`);
+        }
+    }
+    // Mode "Second DOCX" - trouve le deuxième binaire DOCX
+    if (inputType === 'secondDocx') {
+        const found = findSecondDocxBinary(items[itemIndex]);
+        if (found) {
+            buffer = await context.helpers.getBinaryDataBuffer(itemIndex, found.key);
+            source = found.data.fileName || found.key;
+        }
+        else {
+            const allDocx = findAllDocxBinaries(items[itemIndex]);
+            if (allDocx.length === 0) {
+                throw new Error(`Aucun fichier DOCX trouvé pour ${documentName}.`);
+            }
+            else if (allDocx.length === 1) {
+                throw new Error(`Un seul fichier DOCX trouvé (${allDocx[0].data.fileName || allDocx[0].key}). ` +
+                    `Le mode "Second DOCX" nécessite au moins 2 fichiers DOCX.`);
+            }
+        }
+    }
+    // Mode binaire (avec nom spécifique)
+    if (!buffer && (inputType === 'binary' || inputType === 'auto')) {
         if (items[itemIndex].binary && items[itemIndex].binary[inputValue]) {
             const binaryData = items[itemIndex].binary[inputValue];
             if (binaryData.mimeType && !DOCX_MIME_TYPES.includes(binaryData.mimeType)) {
@@ -466,6 +565,122 @@ 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);
+        const responseText = typeof response === 'string'
+            ? response
+            : response.content || response.text || 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
  */
@@ -545,6 +760,68 @@ 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:
+- Document SOURCE (contient les données de l'entreprise): {source_type}
+- Document TEMPLATE (formulaire à remplir): {template_type}
+
+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
 // ============================================================================
@@ -600,19 +877,28 @@ class DocxFillerAI {
                     type: 'options',
                     displayOptions: { show: { operation: ['fill'] } },
                     options: [
-                        { name: 'Binary', value: 'binary', description: 'Propriété binaire' },
+                        { name: 'First DOCX Binary', value: 'firstDocx', description: 'Premier fichier DOCX trouvé (idéal après Merge)' },
+                        { name: 'Second DOCX Binary', value: 'secondDocx', description: 'Deuxième fichier DOCX trouvé' },
+                        { name: 'Binary Property', value: 'binary', description: 'Propriété binaire spécifique' },
                         { name: 'File Path', value: 'path', description: 'Chemin fichier' },
-                        { name: 'Auto-Detect', value: 'auto', description: 'Détection auto' },
+                        { name: 'Auto-Detect', value: 'auto', description: 'Détection auto (nom requis)' },
                     ],
-                    default: 'auto',
+                    default: 'firstDocx',
                 },
                 {
                     displayName: 'Source Document',
                     name: 'sourceDocument',
                     type: 'string',
                     default: '',
-                    required: true,
-                    displayOptions: { show: { operation: ['fill'] } },
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['fill'],
+                        },
+                        hide: {
+                            sourceInputType: ['firstDocx', 'secondDocx'],
+                        },
+                    },
                     description: 'Document source (propriété binaire, chemin, ou base64)',
                     placeholder: 'sourceDoc ou /path/to/source.docx',
                 },
@@ -623,19 +909,28 @@ class DocxFillerAI {
                     type: 'options',
                     displayOptions: { show: { operation: ['fill'] } },
                     options: [
-                        { name: 'Binary', value: 'binary', description: 'Propriété binaire' },
+                        { name: 'Second DOCX Binary', value: 'secondDocx', description: 'Deuxième fichier DOCX trouvé (idéal après Merge)' },
+                        { name: 'First DOCX Binary', value: 'firstDocx', description: 'Premier fichier DOCX trouvé' },
+                        { name: 'Binary Property', value: 'binary', description: 'Propriété binaire spécifique' },
                         { name: 'File Path', value: 'path', description: 'Chemin fichier' },
-                        { name: 'Auto-Detect', value: 'auto', description: 'Détection auto' },
+                        { name: 'Auto-Detect', value: 'auto', description: 'Détection auto (nom requis)' },
                     ],
-                    default: 'auto',
+                    default: 'secondDocx',
                 },
                 {
                     displayName: 'Template Document',
                     name: 'templateDocument',
                     type: 'string',
                     default: '',
-                    required: true,
-                    displayOptions: { show: { operation: ['fill'] } },
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['fill'],
+                        },
+                        hide: {
+                            templateInputType: ['firstDocx', 'secondDocx'],
+                        },
+                    },
                     description: 'Template à remplir (propriété binaire, chemin, ou base64)',
                     placeholder: 'templateDoc ou /path/to/template.docx',
                 },
@@ -656,6 +951,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',
@@ -663,19 +966,23 @@ class DocxFillerAI {
                     type: 'options',
                     displayOptions: { show: { operation: ['extract'] } },
                     options: [
-                        { name: 'Binary', value: 'binary' },
-                        { name: 'File Path', value: 'path' },
-                        { name: 'Auto-Detect', value: 'auto' },
+                        { name: 'First DOCX Binary', value: 'firstDocx', description: 'Premier fichier DOCX trouvé' },
+                        { name: 'Binary Property', value: 'binary', description: 'Propriété binaire spécifique' },
+                        { name: 'File Path', value: 'path', description: 'Chemin fichier' },
+                        { name: 'Auto-Detect', value: 'auto', description: 'Détection auto' },
                     ],
-                    default: 'auto',
+                    default: 'firstDocx',
                 },
                 {
                     displayName: 'Document',
                     name: 'extractDocument',
                     type: 'string',
                     default: '',
-                    required: true,
-                    displayOptions: { show: { operation: ['extract'] } },
+                    required: false,
+                    displayOptions: {
+                        show: { operation: ['extract'] },
+                        hide: { extractInputType: ['firstDocx'] },
+                    },
                     description: 'Document à analyser',
                 },
             ],
@@ -698,11 +1005,12 @@ class DocxFillerAI {
             try {
                 if (operation === 'fill') {
                     const sourceInputType = this.getNodeParameter('sourceInputType', i);
-                    const sourceValue = this.getNodeParameter('sourceDocument', i);
+                    const sourceValue = this.getNodeParameter('sourceDocument', i, '');
                     const templateInputType = this.getNodeParameter('templateInputType', i);
-                    const templateValue = this.getNodeParameter('templateDocument', i);
+                    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');
@@ -739,17 +1047,14 @@ class DocxFillerAI {
                             // Fallback au mode sans LLM
                             sourceData = extractSourceData(sourceParagraphs);
                         }
-                        // Mapping avec LLM
+                        // Mapping avec LLM (pour amélioration future)
                         const fillPrompt = FILL_PROMPT
                             .replace('{source_data}', JSON.stringify(sourceData, null, 2))
                             .replace('{template_text}', templateStructured);
-                        const fillResponse = await llm.invoke(fillPrompt);
-                        const fillText = typeof fillResponse === 'string'
-                            ? fillResponse
-                            : fillResponse.content || fillResponse.text || JSON.stringify(fillResponse);
-                        // Parser les instructions et appliquer
-                        // ... (logique similaire à avant)
-                        // Pour simplifier, on utilise aussi la logique standard
+                        // 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;
@@ -771,22 +1076,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,
@@ -795,7 +1165,7 @@ class DocxFillerAI {
                 }
                 else if (operation === 'extract') {
                     const inputType = this.getNodeParameter('extractInputType', i);
-                    const inputValue = this.getNodeParameter('extractDocument', i);
+                    const inputValue = this.getNodeParameter('extractDocument', i, '');
                     const docBuffer = await getDocumentBuffer(this, i, inputType, inputValue, items, 'document');
                     const zip = new pizzip_1.default(docBuffer);
                     const xml = ((_c = zip.file('word/document.xml')) === null || _c === void 0 ? void 0 : _c.asText()) || '';

package/package.json

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