n8n-nodes-docx-filler 1.1.0 → 2.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "n8n-nodes-docx-filler",
-  "version": "1.1.0",
-  "description": "n8n node to automatically fill DOCX documents (French DC1, DC2, AE forms) with company data. Works as AI Agent tool.",
+  "version": "2.0.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",
     "n8n",
@@ -15,7 +15,10 @@
     "AE",
     "french",
     "company",
-    "ai-tool"
+    "ai-tool",
+    "langchain",
+    "llm",
+    "ai-agent"
   ],
   "license": "MIT",
   "homepage": "https://github.com/rokodo-io/n8n-nodes-docx-filler",
@@ -44,7 +47,8 @@
   "n8n": {
     "n8nNodesApiVersion": 1,
     "nodes": [
-      "dist/DocxFiller/DocxFiller.node.js"
+      "dist/DocxFiller/DocxFiller.node.js",
+      "dist/DocxFillerAI/DocxFillerAI.node.js"
     ]
   },
   "devDependencies": {

package/dist/DocxFiller/DocxFiller.node.js

@@ -1,515 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocxFiller = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
-const pizzip_1 = __importDefault(require("pizzip"));
-const fs = __importStar(require("fs"));
-// Labels spécifiques à rechercher dans les documents DC/AE
-const LABEL_PATTERNS = [
-    ['siret', ['numéro siret', 'n° siret', 'siret']],
-    ['tva_intra', ['tva intracommunautaire', 'identification européen']],
-    ['email', ['adresse électronique', 'courriel', 'e-mail']],
-    ['telephone', ['numéros de téléphone', 'téléphone', 'télécopie']],
-    ['adresse', ['adresse postale', 'siège social']],
-    ['nom_commercial', ['nom commercial', 'dénomination sociale', 'raison sociale']],
-    ['forme_juridique', ['forme juridique', 'statut juridique']],
-    ['capital', ['capital social']],
-    ['code_naf', ['code naf', 'code ape']],
-];
-const CHECKBOX_UNCHECKED = ['☐', '□', '▢'];
-const CHECKBOX_CHECKED = ['☒', '☑', '▣'];
-function normalize(text) {
-    return text.replace(/^[■▪●○•\s▪]+/, '').toLowerCase().trim();
-}
-function hasCheckbox(text) {
-    return [...CHECKBOX_UNCHECKED, ...CHECKBOX_CHECKED].some(c => text.includes(c));
-}
-function isChecked(text) {
-    return CHECKBOX_CHECKED.some(c => text.includes(c));
-}
-function isLabel(text) {
-    return text.startsWith('■') || text.startsWith('[') || text.startsWith('▪');
-}
-function isValue(text) {
-    if (!text)
-        return false;
-    if (isLabel(text))
-        return false;
-    if (text.length > 200)
-        return false;
-    return true;
-}
-function replaceCheckboxState(text, checked) {
-    let result = text;
-    if (checked) {
-        for (const c of CHECKBOX_UNCHECKED) {
-            result = result.split(c).join('☒');
-        }
-    }
-    else {
-        for (const c of CHECKBOX_CHECKED) {
-            result = result.split(c).join('☐');
-        }
-    }
-    return result;
-}
-function extractParagraphs(xml) {
-    const paragraphs = [];
-    // Regex pour extraire le contenu des paragraphes <w:p>...</w:p>
-    const pRegex = /<w:p[^>]*>([\s\S]*?)<\/w:p>/g;
-    let match;
-    while ((match = pRegex.exec(xml)) !== null) {
-        // Extraire tout le texte des <w:t> dans ce paragraphe
-        const pContent = match[1];
-        const textParts = [];
-        const tRegex = /<w:t[^>]*>([^<]*)<\/w:t>/g;
-        let tMatch;
-        while ((tMatch = tRegex.exec(pContent)) !== null) {
-            textParts.push(tMatch[1]);
-        }
-        paragraphs.push(textParts.join(''));
-    }
-    return paragraphs;
-}
-function extractAllFields(paragraphs) {
-    const extracted = new Map();
-    const usedIndices = new Set();
-    for (const [fieldName, patterns] of LABEL_PATTERNS) {
-        if (extracted.has(fieldName))
-            continue;
-        for (let i = 0; i < paragraphs.length; i++) {
-            if (usedIndices.has(i))
-                continue;
-            const textNorm = normalize(paragraphs[i]);
-            const matched = patterns.some(pattern => textNorm.includes(pattern.toLowerCase()));
-            if (matched) {
-                for (let j = i + 1; j < Math.min(i + 5, paragraphs.length); j++) {
-                    if (usedIndices.has(j))
-                        continue;
-                    const valueText = paragraphs[j].trim();
-                    if (isValue(valueText)) {
-                        extracted.set(fieldName, {
-                            value: valueText,
-                            labelIndex: i,
-                            valueIndex: j,
-                        });
-                        usedIndices.add(j);
-                        break;
-                    }
-                    else if (isLabel(valueText)) {
-                        break;
-                    }
-                }
-                usedIndices.add(i);
-                break;
-            }
-        }
-    }
-    return extracted;
-}
-function extractCheckboxes(paragraphs) {
-    const checkboxes = [];
-    for (let i = 0; i < paragraphs.length; i++) {
-        const text = paragraphs[i].trim();
-        if (hasCheckbox(text)) {
-            const signature = text.replace(/[☐☒☑□▢▣]/g, '').trim().toLowerCase().slice(0, 60);
-            checkboxes.push({
-                index: i,
-                text,
-                signature,
-                checked: isChecked(text),
-            });
-        }
-    }
-    return checkboxes;
-}
-function findFillablePositions(paragraphs) {
-    const positions = new Map();
-    const usedIndices = new Set();
-    for (const [fieldName, patterns] of LABEL_PATTERNS) {
-        if (positions.has(fieldName))
-            continue;
-        for (let i = 0; i < paragraphs.length; i++) {
-            if (usedIndices.has(i))
-                continue;
-            const textNorm = normalize(paragraphs[i]);
-            const matched = patterns.some(pattern => textNorm.includes(pattern.toLowerCase()));
-            if (matched) {
-                for (let j = i + 1; j < Math.min(i + 5, paragraphs.length); j++) {
-                    if (usedIndices.has(j))
-                        continue;
-                    const valueText = paragraphs[j].trim();
-                    if (!valueText) {
-                        positions.set(fieldName, {
-                            labelIndex: i,
-                            fillIndex: j,
-                            labelText: paragraphs[i].slice(0, 50),
-                        });
-                        usedIndices.add(j);
-                        break;
-                    }
-                    else if (isLabel(valueText)) {
-                        break;
-                    }
-                }
-                usedIndices.add(i);
-                break;
-            }
-        }
-    }
-    return positions;
-}
-function fillDocumentXml(templateXml, sourceData, templatePositions, sourceCheckboxes, templateCheckboxes) {
-    let xml = templateXml;
-    const filledFields = [];
-    let modifiedCheckboxes = 0;
-    // Remplir les champs texte
-    // On doit remplacer les paragraphes vides par les valeurs
-    const pRegex = /<w:p[^>]*>([\s\S]*?)<\/w:p>/g;
-    const paragraphs = [];
-    let match;
-    while ((match = pRegex.exec(templateXml)) !== null) {
-        paragraphs.push({
-            match: match[0],
-            start: match.index,
-            end: match.index + match[0].length,
-        });
-    }
-    // Pour chaque position à remplir
-    for (const [fieldName, position] of templatePositions) {
-        if (sourceData.has(fieldName)) {
-            const value = sourceData.get(fieldName).value;
-            const pIndex = position.fillIndex;
-            if (pIndex < paragraphs.length) {
-                const p = paragraphs[pIndex];
-                // Créer un nouveau paragraphe avec la valeur
-                // On conserve le style du paragraphe original mais on remplace le contenu
-                const newP = p.match.replace(/(<w:p[^>]*>)([\s\S]*?)(<\/w:p>)/, `$1<w:r><w:t>${escapeXml(value)}</w:t></w:r>$3`);
-                xml = xml.slice(0, p.start) + newP + xml.slice(p.end);
-                // Ajuster les indices pour les remplacements suivants
-                const diff = newP.length - p.match.length;
-                for (let i = pIndex + 1; i < paragraphs.length; i++) {
-                    paragraphs[i].start += diff;
-                    paragraphs[i].end += diff;
-                }
-                paragraphs[pIndex].match = newP;
-                paragraphs[pIndex].end = paragraphs[pIndex].start + newP.length;
-                filledFields.push(`${fieldName}: ${value}`);
-            }
-        }
-    }
-    // Copier l'état des checkboxes
-    for (const templateCb of templateCheckboxes) {
-        for (const sourceCb of sourceCheckboxes) {
-            if (templateCb.signature === sourceCb.signature) {
-                if (sourceCb.checked !== templateCb.checked) {
-                    const newText = replaceCheckboxState(templateCb.text, sourceCb.checked);
-                    // Remplacer dans le XML
-                    xml = xml.split(escapeXml(templateCb.text)).join(escapeXml(newText));
-                    modifiedCheckboxes++;
-                }
-                break;
-            }
-        }
-    }
-    return { xml, filledFields, modifiedCheckboxes };
-}
-function escapeXml(text) {
-    return text
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-/**
- * Détecte le type d'entrée et retourne le buffer du document
- * Supporte : chemin de fichier, nom de propriété binaire, ou base64
- */
-async function getDocumentBuffer(context, itemIndex, input, items) {
-    // 1. Vérifier si c'est un chemin de fichier (commence par / ou contient .docx)
-    const looksLikePath = input.startsWith('/') ||
-        input.startsWith('./') ||
-        input.startsWith('../') ||
-        /^[a-zA-Z]:\\/.test(input) || // Windows path
-        (input.includes('.docx') && !input.includes(' ') && input.length < 500);
-    if (looksLikePath) {
-        // Tenter de lire le fichier depuis le système de fichiers
-        try {
-            if (fs.existsSync(input)) {
-                return fs.readFileSync(input);
-            }
-        }
-        catch {
-            // Si la lecture échoue, continuer avec les autres méthodes
-        }
-    }
-    // 2. Vérifier si c'est un nom de propriété binaire
-    if (items[itemIndex].binary && items[itemIndex].binary[input]) {
-        return await context.helpers.getBinaryDataBuffer(itemIndex, input);
-    }
-    // 3. Vérifier si c'est du base64 valide (longueur raisonnable et caractères valides)
-    const base64Regex = /^[A-Za-z0-9+/]+=*$/;
-    if (input.length > 100 && base64Regex.test(input.replace(/\s/g, ''))) {
-        const buffer = Buffer.from(input, 'base64');
-        // Vérifier que c'est bien un ZIP (DOCX = ZIP)
-        if (buffer.length > 4 && buffer[0] === 0x50 && buffer[1] === 0x4B) {
-            return buffer;
-        }
-    }
-    // 4. Si rien n'a fonctionné, donner un message d'erreur clair
-    throw new Error(`Impossible de charger le document "${input.substring(0, 50)}..."\n` +
-        `Formats acceptés:\n` +
-        `- Chemin de fichier: /path/to/document.docx\n` +
-        `- Propriété binaire: data (si le fichier est attaché en binaire)\n` +
-        `- Base64: contenu encodé en base64`);
-}
-class DocxFiller {
-    constructor() {
-        this.description = {
-            displayName: 'DOCX Filler',
-            name: 'docxFiller',
-            icon: 'file:docx.svg',
-            group: ['transform'],
-            version: 1,
-            subtitle: '={{$parameter["operation"]}}',
-            description: 'Remplit automatiquement des documents DOCX (DC1, DC2, AE) avec les données entreprise',
-            defaults: {
-                name: 'DOCX Filler',
-            },
-            // @ts-ignore - Required for AI agent tool usage
-            usableAsTool: true,
-            inputs: ['main'],
-            outputs: ['main'],
-            properties: [
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Fill Document',
-                            value: 'fill',
-                            description: 'Remplit un template avec les données d\'un document source',
-                            action: 'Fill document',
-                        },
-                        {
-                            name: 'Extract Data',
-                            value: 'extract',
-                            description: 'Extrait les données entreprise d\'un document rempli',
-                            action: 'Extract data',
-                        },
-                        {
-                            name: 'Analyze',
-                            value: 'analyze',
-                            description: 'Analyse la structure d\'un document',
-                            action: 'Analyze document',
-                        },
-                    ],
-                    default: 'fill',
-                },
-                // Fill operation
-                {
-                    displayName: 'Source Document',
-                    name: 'sourceDocument',
-                    type: 'string',
-                    default: '',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            operation: ['fill'],
-                        },
-                    },
-                    description: 'Document source contenant les données entreprise (chemin fichier, binary property name, ou base64)',
-                },
-                {
-                    displayName: 'Template Document',
-                    name: 'templateDocument',
-                    type: 'string',
-                    default: '',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            operation: ['fill'],
-                        },
-                    },
-                    description: 'Document template vide à remplir (chemin fichier, binary property name, ou base64)',
-                },
-                {
-                    displayName: 'Output Property',
-                    name: 'outputProperty',
-                    type: 'string',
-                    default: 'data',
-                    displayOptions: {
-                        show: {
-                            operation: ['fill'],
-                        },
-                    },
-                    description: 'Nom de la propriété binary pour le document de sortie',
-                },
-                // Extract operation
-                {
-                    displayName: 'Document',
-                    name: 'document',
-                    type: 'string',
-                    default: '',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            operation: ['extract', 'analyze'],
-                        },
-                    },
-                    description: 'Document à analyser (chemin fichier, binary property name, ou base64)',
-                },
-            ],
-        };
-    }
-    async execute() {
-        var _a, _b, _c, _d;
-        const items = this.getInputData();
-        const returnData = [];
-        const operation = this.getNodeParameter('operation', 0);
-        for (let i = 0; i < items.length; i++) {
-            try {
-                if (operation === 'fill') {
-                    const sourceDocParam = this.getNodeParameter('sourceDocument', i);
-                    const templateDocParam = this.getNodeParameter('templateDocument', i);
-                    const outputProperty = this.getNodeParameter('outputProperty', i);
-                    // Charger les documents (depuis chemin, binary ou base64)
-                    const sourceBuffer = await getDocumentBuffer(this, i, sourceDocParam, items);
-                    const templateBuffer = await getDocumentBuffer(this, i, templateDocParam, items);
-                    // Charger les DOCX avec PizZip
-                    const sourceZip = new pizzip_1.default(sourceBuffer);
-                    const templateZip = new pizzip_1.default(templateBuffer);
-                    const sourceXml = ((_a = sourceZip.file('word/document.xml')) === null || _a === void 0 ? void 0 : _a.asText()) || '';
-                    const templateXml = ((_b = templateZip.file('word/document.xml')) === null || _b === void 0 ? void 0 : _b.asText()) || '';
-                    // Extraire les paragraphes
-                    const sourceParagraphs = extractParagraphs(sourceXml);
-                    const templateParagraphs = extractParagraphs(templateXml);
-                    // Extraire les données
-                    const sourceData = extractAllFields(sourceParagraphs);
-                    const sourceCheckboxes = extractCheckboxes(sourceParagraphs);
-                    const templatePositions = findFillablePositions(templateParagraphs);
-                    const templateCheckboxes = extractCheckboxes(templateParagraphs);
-                    // Remplir le document
-                    const { xml: filledXml, filledFields, modifiedCheckboxes } = fillDocumentXml(templateXml, sourceData, templatePositions, sourceCheckboxes, templateCheckboxes);
-                    // Mettre à jour le ZIP
-                    templateZip.file('word/document.xml', filledXml);
-                    const outputBuffer = templateZip.generate({
-                        type: 'nodebuffer',
-                        compression: 'DEFLATE',
-                    });
-                    // Créer le résultat
-                    const binaryData = await this.helpers.prepareBinaryData(outputBuffer, 'document_rempli.docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
-                    returnData.push({
-                        json: {
-                            success: true,
-                            filledFields,
-                            modifiedCheckboxes,
-                            message: `Document rempli avec ${filledFields.length} champs et ${modifiedCheckboxes} checkboxes`,
-                        },
-                        binary: {
-                            [outputProperty]: binaryData,
-                        },
-                    });
-                }
-                else if (operation === 'extract') {
-                    const documentParam = this.getNodeParameter('document', i);
-                    const docBuffer = await getDocumentBuffer(this, i, documentParam, items);
-                    const zip = new pizzip_1.default(docBuffer);
-                    const xml = ((_c = zip.file('word/document.xml')) === null || _c === void 0 ? void 0 : _c.asText()) || '';
-                    const paragraphs = extractParagraphs(xml);
-                    const data = extractAllFields(paragraphs);
-                    const checkboxes = extractCheckboxes(paragraphs);
-                    const extractedData = {};
-                    for (const [key, value] of data) {
-                        extractedData[key] = value.value;
-                    }
-                    const checkedBoxes = checkboxes.filter(cb => cb.checked);
-                    returnData.push({
-                        json: {
-                            success: true,
-                            data: extractedData,
-                            checkboxes: {
-                                total: checkboxes.length,
-                                checked: checkedBoxes.length,
-                                items: checkedBoxes.map(cb => cb.signature),
-                            },
-                        },
-                    });
-                }
-                else if (operation === 'analyze') {
-                    const documentParam = this.getNodeParameter('document', i);
-                    const docBuffer = await getDocumentBuffer(this, i, documentParam, items);
-                    const zip = new pizzip_1.default(docBuffer);
-                    const xml = ((_d = zip.file('word/document.xml')) === null || _d === void 0 ? void 0 : _d.asText()) || '';
-                    const paragraphs = extractParagraphs(xml);
-                    const positions = findFillablePositions(paragraphs);
-                    returnData.push({
-                        json: {
-                            success: true,
-                            totalParagraphs: paragraphs.length,
-                            fillableFields: Array.from(positions.keys()),
-                            structure: paragraphs.slice(0, 50).map((p, idx) => ({
-                                index: idx,
-                                text: p.slice(0, 100),
-                                hasCheckbox: hasCheckbox(p),
-                            })),
-                        },
-                    });
-                }
-            }
-            catch (error) {
-                if (this.continueOnFail()) {
-                    returnData.push({
-                        json: {
-                            success: false,
-                            error: error.message,
-                        },
-                    });
-                    continue;
-                }
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
-            }
-        }
-        return [returnData];
-    }
-}
-exports.DocxFiller = DocxFiller;