n8n-nodes-docx-filler 2.1.0 → 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) {
@@ -530,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
  */
@@ -609,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
 // ============================================================================
@@ -738,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',
@@ -789,6 +1010,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');
@@ -854,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,

package/package.json

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