n8n-nodes-notion-advanced 1.2.31-beta → 1.2.33-beta

package/nodes/NotionAdvanced/NotionAITool.node.d.ts

@@ -66,6 +66,10 @@ export declare class NotionAITool implements INodeType {
     static processNestedHtmlInListItem(content: string): string;
     static convertInlineHtmlToMarkdown(content: string): string;
     static buildListHierarchy(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', childHierarchyNodes: HierarchyNode[]): HierarchyNode | null;
+    static getListItemPositions(content: string): Array<{
+        start: number;
+        end: number;
+    }>;
     static mapChildBlocksToListItems(listContent: string, childBlocks: IDataObject[], childNodes: XMLNode[]): Map<number, IDataObject[]>;
     static processNestedListWithChildBlocks(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', blocks: IDataObject[], listItemChildBlocks: Map<number, IDataObject[]>): void;
     static processNestedList(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', blocks: IDataObject[], childNodes?: XMLNode[]): void;

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -872,11 +872,12 @@ class NotionAITool {
                 }
                 // For list processors, handle them specially
                 if (xmlNode.listProcessor && (xmlNode.tagName === 'ul' || xmlNode.tagName === 'ol')) {
-                    // Extract inner content
+                    // Extract inner content and calculate offset
                     const tagName = xmlNode.tagName.toLowerCase();
                     const openTagRegex = new RegExp(`^<${tagName}[^>]*>`, 'i');
                     const closeTagRegex = new RegExp(`</${tagName}>$`, 'i');
                     let innerContent = xmlNode.match;
+                    let contentStartOffset = 0;
                     const openMatch = xmlNode.match.match(openTagRegex);
                     const closeMatch = xmlNode.match.match(closeTagRegex);
                     if (openMatch && closeMatch) {
@@ -885,9 +886,23 @@ class NotionAITool {
                         const startIndex = openTag.length;
                         const endIndex = xmlNode.match.length - closeTag.length;
                         innerContent = xmlNode.match.substring(startIndex, endIndex);
+                        contentStartOffset = xmlNode.start + startIndex; // Absolute position where list content starts
                     }
+                    // Adjust child hierarchy node positions to be relative to list content
+                    const adjustedChildNodes = childHierarchyNodes.map(child => {
+                        var _a;
+                        return ({
+                            ...child,
+                            metadata: {
+                                ...child.metadata,
+                                sourcePosition: ((_a = child.metadata) === null || _a === void 0 ? void 0 : _a.sourcePosition) !== undefined
+                                    ? child.metadata.sourcePosition - contentStartOffset
+                                    : undefined
+                            }
+                        });
+                    });
                     // Build hierarchy structure for the list
-                    const listHierarchy = NotionAITool.buildListHierarchy(innerContent, xmlNode.tagName === 'ul' ? 'bulleted_list_item' : 'numbered_list_item', childHierarchyNodes);
+                    const listHierarchy = NotionAITool.buildListHierarchy(innerContent, xmlNode.tagName === 'ul' ? 'bulleted_list_item' : 'numbered_list_item', adjustedChildNodes);
                     return listHierarchy;
                 }
                 // For regular nodes, create block and attach children
@@ -1472,21 +1487,27 @@ class NotionAITool {
             processed = processed.replace(/<\/?li\s*[^>]*>/gi, '');
             // Remove any other common list-related fragments
             processed = processed.replace(/<\/?[uo]l\s*[^>]*>/gi, '');
-            // Simple cleanup - just remove remaining HTML tags and clean whitespace
-            // Avoid convertInlineHtmlToMarkdown to prevent duplication issues
+            // Convert inline HTML formatting to markdown BEFORE removing tags
+            processed = NotionAITool.convertInlineHtmlToMarkdown(processed);
+            // Final cleanup of any remaining unhandled tags
             const result = processed
-                .replace(/<[^>]*>/g, ' ') // Remove any remaining HTML tags
                 .replace(/\s+/g, ' ') // Clean up whitespace
                 .trim();
             return result;
         }
         catch (error) {
             console.warn('Error processing nested HTML in list item:', error);
-            // Fallback: aggressively remove all HTML tags and return clean text
-            return processed
-                .replace(/<[^>]*>/g, ' ')
-                .replace(/\s+/g, ' ')
-                .trim();
+            // Fallback: convert inline HTML then remove any remaining tags
+            try {
+                const fallback = NotionAITool.convertInlineHtmlToMarkdown(processed);
+                return fallback.replace(/\s+/g, ' ').trim();
+            }
+            catch (fallbackError) {
+                return processed
+                    .replace(/<[^>]*>/g, ' ')
+                    .replace(/\s+/g, ' ')
+                    .trim();
+            }
         }
     }
     // Helper function to convert inline HTML to markdown
@@ -1523,12 +1544,13 @@ class NotionAITool {
     }
     // Build hierarchy structure for lists using HierarchyNode approach
     static buildListHierarchy(listContent, listType, childHierarchyNodes) {
+        var _a;
         try {
             // Process each <li> element and build hierarchy
             const listItems = NotionAITool.extractListItemsWithBranching(listContent);
             const listItemHierarchyNodes = [];
-            // Map child hierarchy nodes to list items based on position
-            let childNodeIndex = 0;
+            // Map child hierarchy nodes to list items based on actual position in source XML
+            const listItemPositions = NotionAITool.getListItemPositions(listContent);
             for (let i = 0; i < listItems.length; i++) {
                 const item = listItems[i];
                 if (!item.text && !item.children.length)
@@ -1547,16 +1569,19 @@ class NotionAITool {
                         listItemBlock[listType].rich_text = NotionAITool.parseBasicMarkdown(cleanText);
                     }
                 }
-                // Collect child hierarchy nodes for this list item
+                // Collect child hierarchy nodes for this list item based on position mapping
                 const itemChildNodes = [];
-                // Add child hierarchy nodes that belong to this list item
-                // For now, distribute them evenly - this could be improved with position mapping
-                const childrenPerItem = Math.floor(childHierarchyNodes.length / listItems.length);
-                const startIndex = i * childrenPerItem;
-                const endIndex = i === listItems.length - 1 ? childHierarchyNodes.length : startIndex + childrenPerItem;
-                for (let j = startIndex; j < endIndex; j++) {
-                    if (j < childHierarchyNodes.length) {
-                        itemChildNodes.push(childHierarchyNodes[j]);
+                // Map child hierarchy nodes that belong to this specific list item
+                if (i < listItemPositions.length) {
+                    const currentItemStart = listItemPositions[i].start;
+                    const currentItemEnd = listItemPositions[i].end;
+                    for (const childNode of childHierarchyNodes) {
+                        const childPosition = (_a = childNode.metadata) === null || _a === void 0 ? void 0 : _a.sourcePosition;
+                        if (childPosition !== undefined &&
+                            childPosition >= currentItemStart &&
+                            childPosition < currentItemEnd) {
+                            itemChildNodes.push(childNode);
+                        }
                     }
                 }
                 // Process nested list children (traditional nested lists)
@@ -1608,6 +1633,55 @@ class NotionAITool {
             };
         }
     }
+    // Helper function to get position ranges for each list item in the content
+    static getListItemPositions(content) {
+        const positions = [];
+        let pos = 0;
+        while (pos < content.length) {
+            // Find next <li> tag
+            const liStart = content.indexOf('<li', pos);
+            if (liStart === -1)
+                break;
+            const liOpenEnd = content.indexOf('>', liStart);
+            if (liOpenEnd === -1)
+                break;
+            // Find the matching </li> using proper depth tracking
+            let depth = 0;
+            let searchPos = liOpenEnd + 1;
+            let liEnd = -1;
+            while (searchPos < content.length) {
+                const nextLiOpen = content.indexOf('<li', searchPos);
+                const nextLiClose = content.indexOf('</li>', searchPos);
+                if (nextLiClose === -1)
+                    break;
+                if (nextLiOpen !== -1 && nextLiOpen < nextLiClose) {
+                    depth++;
+                    searchPos = nextLiOpen + 3;
+                }
+                else {
+                    if (depth === 0) {
+                        liEnd = nextLiClose + 5; // Include the '</li>'
+                        break;
+                    }
+                    else {
+                        depth--;
+                        searchPos = nextLiClose + 5;
+                    }
+                }
+            }
+            if (liEnd !== -1) {
+                positions.push({
+                    start: liStart,
+                    end: liEnd
+                });
+                pos = liEnd;
+            }
+            else {
+                pos = liOpenEnd + 1;
+            }
+        }
+        return positions;
+    }
     // Helper function to map child blocks to specific list items (legacy support)
     static mapChildBlocksToListItems(listContent, childBlocks, childNodes) {
         const listItemChildBlocks = new Map();
@@ -1756,13 +1830,30 @@ class NotionAITool {
                 continue;
             }
             const item = { text: '', children: [] };
-            // Process the content to separate text from nested lists
+            // STEP 1: Remove child block XML from content to get clean parent text
+            let parentTextContent = fullItemContent;
+            // List of XML tags that create child blocks (these should be removed from parent text)
+            const childBlockTags = [
+                'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+                'blockquote', 'quote', 'callout', 'code', 'pre',
+                'todo', 'toggle', 'image', 'embed', 'bookmark',
+                'equation', 'divider'
+            ];
+            // Remove child block XML from parent text
+            childBlockTags.forEach(tag => {
+                // Remove both self-closing and paired tags
+                const selfClosingRegex = new RegExp(`<${tag}[^>]*\\/>`, 'gis');
+                const pairedRegex = new RegExp(`<${tag}[^>]*>.*?<\\/${tag}>`, 'gis');
+                parentTextContent = parentTextContent.replace(pairedRegex, '');
+                parentTextContent = parentTextContent.replace(selfClosingRegex, '');
+            });
+            // STEP 2: Process the content to separate remaining text from nested lists
             let contentPos = 0;
             let textParts = [];
-            while (contentPos < fullItemContent.length) {
+            while (contentPos < parentTextContent.length) {
                 // Look for the next nested list (ul or ol)
-                const nextUlStart = fullItemContent.indexOf('<ul', contentPos);
-                const nextOlStart = fullItemContent.indexOf('<ol', contentPos);
+                const nextUlStart = parentTextContent.indexOf('<ul', contentPos);
+                const nextOlStart = parentTextContent.indexOf('<ol', contentPos);
                 let nextListStart = -1;
                 let listType = '';
                 if (nextUlStart !== -1 && (nextOlStart === -1 || nextUlStart < nextOlStart)) {
@@ -1775,22 +1866,22 @@ class NotionAITool {
                 }
                 if (nextListStart === -1) {
                     // No more nested lists - add remaining text
-                    const remainingText = fullItemContent.substring(contentPos);
+                    const remainingText = parentTextContent.substring(contentPos);
                     if (remainingText.trim()) {
                         textParts.push(remainingText);
                     }
                     break;
                 }
                 // Add text before the nested list
-                const textBefore = fullItemContent.substring(contentPos, nextListStart);
+                const textBefore = parentTextContent.substring(contentPos, nextListStart);
                 if (textBefore.trim()) {
                     textParts.push(textBefore);
                 }
                 // Find the end of this nested list
-                const listOpenEnd = fullItemContent.indexOf('>', nextListStart);
+                const listOpenEnd = parentTextContent.indexOf('>', nextListStart);
                 if (listOpenEnd === -1) {
                     // Malformed list tag
-                    textParts.push(fullItemContent.substring(contentPos));
+                    textParts.push(parentTextContent.substring(contentPos));
                     break;
                 }
                 // Track depth to find the matching closing tag
@@ -1799,9 +1890,9 @@ class NotionAITool {
                 let listEnd = -1;
                 const openTag = `<${listType}`;
                 const closeTag = `</${listType}>`;
-                while (listSearchPos < fullItemContent.length && listDepth > 0) {
-                    const nextListOpen = fullItemContent.indexOf(openTag, listSearchPos);
-                    const nextListClose = fullItemContent.indexOf(closeTag, listSearchPos);
+                while (listSearchPos < parentTextContent.length && listDepth > 0) {
+                    const nextListOpen = parentTextContent.indexOf(openTag, listSearchPos);
+                    const nextListClose = parentTextContent.indexOf(closeTag, listSearchPos);
                     if (nextListClose === -1)
                         break;
                     if (nextListOpen !== -1 && nextListOpen < nextListClose) {
@@ -1818,7 +1909,8 @@ class NotionAITool {
                     }
                 }
                 if (listEnd !== -1) {
-                    // Extract the content between <ul>/<ol> and </ul>/<ol>
+                    // Extract the content between <ul>/<ol> and </ul>/<ol> from ORIGINAL content
+                    // (not parentTextContent which has child blocks removed)
                     const listContent = fullItemContent.substring(listOpenEnd + 1, listEnd - closeTag.length);
                     item.children.push({
                         type: listType,
@@ -1828,7 +1920,7 @@ class NotionAITool {
                 }
                 else {
                     // Malformed nested list - treat remaining as text
-                    textParts.push(fullItemContent.substring(contentPos));
+                    textParts.push(parentTextContent.substring(contentPos));
                     break;
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-notion-advanced",
-  "version": "1.2.31-beta",
+  "version": "1.2.33-beta",
   "description": "Advanced n8n Notion nodes: Full-featured workflow node + AI Agent Tool for intelligent Notion automation with 25+ block types (BETA)",
   "scripts": {},
   "files": [