n8n-nodes-notion-advanced 1.2.1-beta → 1.2.3-beta

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -1,1121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotionAITool = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
-const NotionUtils_1 = require("./NotionUtils");
-class NotionAITool {
-    constructor() {
-        this.description = {
-            displayName: 'Notion AI Tool',
-            name: 'notionAiTool',
-            icon: 'file:notion.svg',
-            group: ['ai'],
-            version: 1,
-            subtitle: '={{$parameter["operation"]}}',
-            description: 'AI-powered tool for creating and managing Notion content. Designed for use with AI Agent Nodes.',
-            defaults: {
-                name: 'Notion AI Tool',
-            },
-            inputs: ['main'],
-            outputs: ['main'],
-            usableAsTool: true,
-            codex: {
-                categories: ['Productivity', 'AI', 'Documentation'],
-                subcategories: {
-                    'Productivity': ['Notion', 'Knowledge Management'],
-                    'AI': ['AI Agent Tools', 'Natural Language Processing'],
-                    'Documentation': ['Page Creation', 'Content Management']
-                },
-                resources: {
-                    primaryDocumentation: [
-                        {
-                            url: 'https://github.com/AZ-IT-US/n8n-notion-advanced-node#ai-tool-usage',
-                        },
-                    ],
-                },
-                alias: ['notion', 'productivity', 'ai-tool', 'pages', 'database'],
-            },
-            credentials: [
-                {
-                    name: 'notionApi',
-                    required: true,
-                },
-            ],
-            properties: [
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Create Page with Content',
-                            value: 'createPageWithContent',
-                            description: 'Create a new Notion page with structured content including text, headings, lists, and formatting',
-                            action: 'Create a Notion page with content',
-                        },
-                        {
-                            name: 'Add Content to Page',
-                            value: 'addContentToPage',
-                            description: 'Append new content blocks (paragraphs, headings, lists, etc.) to an existing Notion page',
-                            action: 'Add content to existing page',
-                        },
-                        {
-                            name: 'Search and Retrieve Pages',
-                            value: 'searchPages',
-                            description: 'Search for Notion pages by title, content, or properties and retrieve their information',
-                            action: 'Search and retrieve pages',
-                        },
-                        {
-                            name: 'Update Page Properties',
-                            value: 'updatePageProperties',
-                            description: 'Update page title, properties, status, tags, or other metadata',
-                            action: 'Update page properties',
-                        },
-                        {
-                            name: 'Create Database Entry',
-                            value: 'createDatabaseEntry',
-                            description: 'Create a new entry in a Notion database with specified properties and values',
-                            action: 'Create database entry',
-                        },
-                        {
-                            name: 'Query Database',
-                            value: 'queryDatabase',
-                            description: 'Search and filter database entries based on criteria and retrieve matching records',
-                            action: 'Query database',
-                        },
-                    ],
-                    default: 'createPageWithContent',
-                },
-                // CREATE PAGE WITH CONTENT
-                {
-                    displayName: 'Page Title',
-                    name: 'pageTitle',
-                    type: 'string',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            operation: ['createPageWithContent'],
-                        },
-                    },
-                    default: '',
-                    description: 'The title of the new page to create',
-                },
-                {
-                    displayName: 'Parent Page/Database ID',
-                    name: 'parentId',
-                    type: 'string',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            operation: ['createPageWithContent', 'createDatabaseEntry'],
-                        },
-                    },
-                    default: '',
-                    description: 'ID of the parent page or database where this should be created. Can be a Notion URL or page ID.',
-                },
-                {
-                    displayName: 'Content',
-                    name: 'content',
-                    type: 'string',
-                    typeOptions: {
-                        rows: 6,
-                    },
-                    displayOptions: {
-                        show: {
-                            operation: ['createPageWithContent', 'addContentToPage'],
-                        },
-                    },
-                    default: '',
-                    description: 'The content to add. Use natural language - AI will structure it into appropriate blocks (headings, paragraphs, lists, etc.)',
-                    placeholder: 'Example:\n# Main Heading\nThis is a paragraph with **bold** and *italic* text.\n\n## Subheading\n- First bullet point\n- Second bullet point\n\n> This is a quote block',
-                },
-                // ADD CONTENT TO PAGE
-                {
-                    displayName: 'Target Page ID',
-                    name: 'targetPageId',
-                    type: 'string',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            operation: ['addContentToPage', 'updatePageProperties'],
-                        },
-                    },
-                    default: '',
-                    description: 'ID or URL of the existing page to modify',
-                },
-                // SEARCH PAGES
-                {
-                    displayName: 'Search Query',
-                    name: 'searchQuery',
-                    type: 'string',
-                    displayOptions: {
-                        show: {
-                            operation: ['searchPages'],
-                        },
-                    },
-                    default: '',
-                    description: 'Search terms to find pages. Leave empty to get all pages.',
-                },
-                // UPDATE PAGE PROPERTIES
-                {
-                    displayName: 'Properties to Update',
-                    name: 'propertiesToUpdate',
-                    type: 'string',
-                    typeOptions: {
-                        rows: 4,
-                    },
-                    displayOptions: {
-                        show: {
-                            operation: ['updatePageProperties'],
-                        },
-                    },
-                    default: '',
-                    description: 'Properties to update in JSON format or natural language. Example: {"status": "In Progress", "priority": "High"} or "Set status to Done and priority to Low"',
-                },
-                // DATABASE OPERATIONS
-                {
-                    displayName: 'Database ID',
-                    name: 'databaseId',
-                    type: 'string',
-                    required: true,
-                    displayOptions: {
-                        show: {
-                            operation: ['queryDatabase'],
-                        },
-                    },
-                    default: '',
-                    description: 'ID or URL of the database to query',
-                },
-                {
-                    displayName: 'Entry Properties',
-                    name: 'entryProperties',
-                    type: 'string',
-                    typeOptions: {
-                        rows: 4,
-                    },
-                    displayOptions: {
-                        show: {
-                            operation: ['createDatabaseEntry'],
-                        },
-                    },
-                    default: '',
-                    description: 'Properties for the new database entry in JSON format or natural language description',
-                },
-                {
-                    displayName: 'Query Filter',
-                    name: 'queryFilter',
-                    type: 'string',
-                    displayOptions: {
-                        show: {
-                            operation: ['queryDatabase'],
-                        },
-                    },
-                    default: '',
-                    description: 'Filter criteria in natural language (e.g., "status is Done and priority is High") or JSON format',
-                },
-                // COMMON OPTIONS
-                {
-                    displayName: 'Additional Options',
-                    name: 'additionalOptions',
-                    type: 'collection',
-                    placeholder: 'Add Option',
-                    default: {},
-                    options: [
-                        {
-                            displayName: 'Icon',
-                            name: 'icon',
-                            type: 'string',
-                            default: '',
-                            description: 'Emoji icon for the page (e.g., 📝, 🎯, 📊)',
-                        },
-                        {
-                            displayName: 'Cover Image URL',
-                            name: 'coverUrl',
-                            type: 'string',
-                            default: '',
-                            description: 'URL of cover image for the page',
-                        },
-                        {
-                            displayName: 'Max Results',
-                            name: 'maxResults',
-                            type: 'number',
-                            default: 20,
-                            description: 'Maximum number of results to return (1-100)',
-                        },
-                    ],
-                },
-            ],
-        };
-    }
-    async execute() {
-        const items = this.getInputData();
-        const responseData = [];
-        // Validate credentials
-        const isValid = await NotionUtils_1.validateCredentials.call(this);
-        if (!isValid) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid Notion API credentials');
-        }
-        for (let i = 0; i < items.length; i++) {
-            try {
-                const operation = this.getNodeParameter('operation', i);
-                let result;
-                switch (operation) {
-                    case 'createPageWithContent':
-                        result = await NotionAITool.createPageWithContent(this, i);
-                        break;
-                    case 'addContentToPage':
-                        result = await NotionAITool.addContentToPage(this, i);
-                        break;
-                    case 'searchPages':
-                        result = await NotionAITool.searchPages(this, i);
-                        break;
-                    case 'updatePageProperties':
-                        result = await NotionAITool.updatePageProperties(this, i);
-                        break;
-                    case 'createDatabaseEntry':
-                        result = await NotionAITool.createDatabaseEntry(this, i);
-                        break;
-                    case 'queryDatabase':
-                        result = await NotionAITool.queryDatabase(this, i);
-                        break;
-                    default:
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
-                }
-                responseData.push({
-                    operation,
-                    success: true,
-                    ...result,
-                });
-            }
-            catch (error) {
-                if (this.continueOnFail()) {
-                    responseData.push({
-                        error: error.message,
-                        success: false,
-                    });
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        return [this.helpers.returnJsonArray(responseData)];
-    }
-    static async createPageWithContent(executeFunctions, itemIndex) {
-        const pageTitle = executeFunctions.getNodeParameter('pageTitle', itemIndex);
-        const parentId = executeFunctions.getNodeParameter('parentId', itemIndex);
-        const content = executeFunctions.getNodeParameter('content', itemIndex, '');
-        const additionalOptions = executeFunctions.getNodeParameter('additionalOptions', itemIndex, {});
-        const resolvedParentId = await NotionUtils_1.resolvePageId.call(executeFunctions, parentId);
-        // Create the page first
-        const pageBody = {
-            parent: { page_id: resolvedParentId },
-            properties: {
-                title: {
-                    title: [(0, NotionUtils_1.createRichText)(pageTitle)],
-                },
-            },
-        };
-        // Add icon and cover if provided
-        if (additionalOptions.icon) {
-            pageBody.icon = { type: 'emoji', emoji: additionalOptions.icon };
-        }
-        if (additionalOptions.coverUrl) {
-            pageBody.cover = { type: 'external', external: { url: additionalOptions.coverUrl } };
-        }
-        const page = await NotionUtils_1.notionApiRequest.call(executeFunctions, 'POST', '/pages', pageBody);
-        // If content is provided, add it to the page
-        if (content) {
-            const blocks = NotionAITool.parseContentToBlocks(content);
-            if (blocks.length > 0) {
-                await NotionUtils_1.notionApiRequest.call(executeFunctions, 'PATCH', `/blocks/${page.id}/children`, {
-                    children: blocks,
-                });
-            }
-        }
-        return {
-            pageId: page.id,
-            title: pageTitle,
-            url: page.url,
-            message: `Created page "${pageTitle}" with content`,
-        };
-    }
-    static async addContentToPage(executeFunctions, itemIndex) {
-        const targetPageId = executeFunctions.getNodeParameter('targetPageId', itemIndex);
-        const content = executeFunctions.getNodeParameter('content', itemIndex);
-        const resolvedPageId = await NotionUtils_1.resolvePageId.call(executeFunctions, targetPageId);
-        const blocks = NotionAITool.parseContentToBlocks(content);
-        if (blocks.length === 0) {
-            throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), 'No valid content blocks found to add');
-        }
-        const result = await NotionUtils_1.notionApiRequest.call(executeFunctions, 'PATCH', `/blocks/${resolvedPageId}/children`, {
-            children: blocks,
-        });
-        return {
-            pageId: resolvedPageId,
-            blocksAdded: blocks.length,
-            message: `Added ${blocks.length} content blocks to page`,
-            result,
-        };
-    }
-    static async searchPages(executeFunctions, itemIndex) {
-        var _a, _b;
-        const searchQuery = executeFunctions.getNodeParameter('searchQuery', itemIndex, '');
-        const additionalOptions = executeFunctions.getNodeParameter('additionalOptions', itemIndex, {});
-        const maxResults = additionalOptions.maxResults || 20;
-        const body = {
-            page_size: Math.min(maxResults, 100),
-        };
-        if (searchQuery) {
-            body.query = searchQuery;
-        }
-        body.filter = {
-            property: 'object',
-            value: 'page',
-        };
-        const response = await NotionUtils_1.notionApiRequest.call(executeFunctions, 'POST', '/search', body);
-        return {
-            totalResults: ((_a = response.results) === null || _a === void 0 ? void 0 : _a.length) || 0,
-            pages: response.results || [],
-            message: `Found ${((_b = response.results) === null || _b === void 0 ? void 0 : _b.length) || 0} pages`,
-        };
-    }
-    static async updatePageProperties(executeFunctions, itemIndex) {
-        const targetPageId = executeFunctions.getNodeParameter('targetPageId', itemIndex);
-        const propertiesToUpdate = executeFunctions.getNodeParameter('propertiesToUpdate', itemIndex);
-        const resolvedPageId = await NotionUtils_1.resolvePageId.call(executeFunctions, targetPageId);
-        const properties = NotionAITool.parsePropertiesToUpdate(propertiesToUpdate);
-        const result = await NotionUtils_1.notionApiRequest.call(executeFunctions, 'PATCH', `/pages/${resolvedPageId}`, {
-            properties,
-        });
-        return {
-            pageId: resolvedPageId,
-            updatedProperties: Object.keys(properties),
-            message: `Updated ${Object.keys(properties).length} properties`,
-            result,
-        };
-    }
-    static async createDatabaseEntry(executeFunctions, itemIndex) {
-        const parentId = executeFunctions.getNodeParameter('parentId', itemIndex);
-        const entryProperties = executeFunctions.getNodeParameter('entryProperties', itemIndex);
-        const resolvedParentId = await NotionUtils_1.resolvePageId.call(executeFunctions, parentId);
-        const properties = NotionAITool.parsePropertiesToUpdate(entryProperties);
-        const result = await NotionUtils_1.notionApiRequest.call(executeFunctions, 'POST', '/pages', {
-            parent: { database_id: resolvedParentId },
-            properties,
-        });
-        return {
-            entryId: result.id,
-            databaseId: resolvedParentId,
-            message: 'Created new database entry',
-            result,
-        };
-    }
-    static async queryDatabase(executeFunctions, itemIndex) {
-        var _a, _b;
-        const databaseId = executeFunctions.getNodeParameter('databaseId', itemIndex);
-        const queryFilter = executeFunctions.getNodeParameter('queryFilter', itemIndex, '');
-        const additionalOptions = executeFunctions.getNodeParameter('additionalOptions', itemIndex, {});
-        const maxResults = additionalOptions.maxResults || 20;
-        const resolvedDatabaseId = await NotionUtils_1.resolvePageId.call(executeFunctions, databaseId);
-        const body = {
-            page_size: Math.min(maxResults, 100),
-        };
-        if (queryFilter) {
-            try {
-                body.filter = JSON.parse(queryFilter);
-            }
-            catch {
-                // If not JSON, create a simple text filter
-                body.filter = {
-                    property: 'Name',
-                    title: {
-                        contains: queryFilter,
-                    },
-                };
-            }
-        }
-        const response = await NotionUtils_1.notionApiRequest.call(executeFunctions, 'POST', `/databases/${resolvedDatabaseId}/query`, body);
-        return {
-            databaseId: resolvedDatabaseId,
-            totalResults: ((_a = response.results) === null || _a === void 0 ? void 0 : _a.length) || 0,
-            entries: response.results || [],
-            message: `Found ${((_b = response.results) === null || _b === void 0 ? void 0 : _b.length) || 0} database entries`,
-        };
-    }
-    static parseContentToBlocks(content) {
-        const blocks = [];
-        // Handle both actual newlines and escaped \n characters
-        const normalizedContent = content.replace(/\\n/g, '\n');
-        // First, process XML-like tags for reliable parsing
-        const processedContent = NotionAITool.processXmlTags(normalizedContent, blocks);
-        // Then process remaining content with traditional markdown patterns
-        const lines = processedContent.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmedLine = line.trim();
-            // Skip completely empty lines and XML placeholders
-            if (!trimmedLine || trimmedLine.startsWith('__XML_BLOCK_'))
-                continue;
-            // Traditional markdown patterns (for backwards compatibility)
-            if (trimmedLine.startsWith('# ')) {
-                blocks.push({
-                    type: 'heading_1',
-                    heading_1: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(trimmedLine.substring(2).trim())],
-                    },
-                });
-            }
-            else if (trimmedLine.startsWith('## ')) {
-                blocks.push({
-                    type: 'heading_2',
-                    heading_2: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(trimmedLine.substring(3).trim())],
-                    },
-                });
-            }
-            else if (trimmedLine.startsWith('### ')) {
-                blocks.push({
-                    type: 'heading_3',
-                    heading_3: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(trimmedLine.substring(4).trim())],
-                    },
-                });
-            }
-            else if (trimmedLine === '---' || trimmedLine === '***') {
-                blocks.push({
-                    type: 'divider',
-                    divider: {},
-                });
-            }
-            else if (trimmedLine.includes('[!') && trimmedLine.startsWith('>')) {
-                // Callout blocks: > [!info] content
-                const calloutMatch = trimmedLine.match(/^>\s*\[!(\w+)\]\s*(.*)/i);
-                if (calloutMatch) {
-                    const [, calloutType, text] = calloutMatch;
-                    const emoji = NotionAITool.getCalloutEmoji(calloutType.toLowerCase());
-                    const color = NotionAITool.getCalloutColor(calloutType.toLowerCase());
-                    blocks.push({
-                        type: 'callout',
-                        callout: {
-                            rich_text: NotionAITool.parseBasicMarkdown(text),
-                            icon: { type: 'emoji', emoji },
-                            color: color,
-                        },
-                    });
-                }
-                else {
-                    blocks.push({
-                        type: 'quote',
-                        quote: {
-                            rich_text: NotionAITool.parseBasicMarkdown(trimmedLine.substring(1).trim()),
-                        },
-                    });
-                }
-            }
-            else if (trimmedLine.startsWith('![') && trimmedLine.includes('](') && trimmedLine.endsWith(')')) {
-                // Image: ![alt text](url)
-                const match = trimmedLine.match(/^!\[(.*?)\]\((.*?)\)$/);
-                if (match) {
-                    const [, altText, url] = match;
-                    blocks.push({
-                        type: 'image',
-                        image: {
-                            type: 'external',
-                            external: { url },
-                            caption: altText ? NotionAITool.parseBasicMarkdown(altText) : [],
-                        },
-                    });
-                }
-            }
-            else if (trimmedLine.startsWith('$$') && trimmedLine.endsWith('$$') && trimmedLine.length > 4) {
-                // Equation: $$equation$$
-                const equation = trimmedLine.substring(2, trimmedLine.length - 2).trim();
-                blocks.push({
-                    type: 'equation',
-                    equation: {
-                        expression: equation,
-                    },
-                });
-            }
-            else if ((trimmedLine.startsWith('http://') || trimmedLine.startsWith('https://')) && !trimmedLine.includes(' ')) {
-                // Check if it's a video URL for embed, otherwise bookmark
-                const videoPatterns = [
-                    /(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/watch\?v=|youtu\.be\/)/i,
-                    /(?:https?:\/\/)?(?:www\.)?(?:vimeo\.com\/)/i,
-                    /(?:https?:\/\/)?(?:www\.)?(?:dailymotion\.com\/video\/)/i,
-                    /(?:https?:\/\/)?(?:www\.)?(?:twitch\.tv\/)/i,
-                    /(?:https?:\/\/)?(?:www\.)?(?:loom\.com\/share\/)/i,
-                    /(?:https?:\/\/)?(?:www\.)?(?:figma\.com\/)/i,
-                    /(?:https?:\/\/)?(?:www\.)?(?:miro\.com\/)/i,
-                    /(?:https?:\/\/)?(?:codepen\.io\/)/i
-                ];
-                const isEmbeddableUrl = videoPatterns.some(pattern => pattern.test(trimmedLine));
-                if (isEmbeddableUrl) {
-                    blocks.push({
-                        type: 'embed',
-                        embed: {
-                            url: trimmedLine,
-                        },
-                    });
-                }
-                else {
-                    blocks.push({
-                        type: 'bookmark',
-                        bookmark: {
-                            url: trimmedLine,
-                        },
-                    });
-                }
-            }
-            else if (trimmedLine.startsWith('- [') && (trimmedLine.includes('[ ]') || trimmedLine.includes('[x]') || trimmedLine.includes('[X]'))) {
-                // To-do list items: - [ ] or - [x] or - [X]
-                const isChecked = trimmedLine.includes('[x]') || trimmedLine.includes('[X]');
-                const text = trimmedLine.replace(/^-\s*\[[ xX]\]\s*/, '').trim();
-                blocks.push({
-                    type: 'to_do',
-                    to_do: {
-                        rich_text: NotionAITool.parseBasicMarkdown(text),
-                        checked: isChecked,
-                    },
-                });
-            }
-            else if (trimmedLine.startsWith('- ') && !trimmedLine.startsWith('- [')) {
-                // Bullet list items: - item (but not todos)
-                const listText = trimmedLine.substring(2).trim();
-                blocks.push({
-                    type: 'bulleted_list_item',
-                    bulleted_list_item: {
-                        rich_text: NotionAITool.parseBasicMarkdown(listText),
-                    },
-                });
-            }
-            else if (/^\d+\.\s/.test(trimmedLine)) {
-                // Numbered list items: 1. item
-                const listText = trimmedLine.replace(/^\d+\.\s/, '').trim();
-                blocks.push({
-                    type: 'numbered_list_item',
-                    numbered_list_item: {
-                        rich_text: NotionAITool.parseBasicMarkdown(listText),
-                    },
-                });
-            }
-            else if (trimmedLine.startsWith('> ') && !trimmedLine.includes('[!')) {
-                // Quote block (but not callout)
-                blocks.push({
-                    type: 'quote',
-                    quote: {
-                        rich_text: NotionAITool.parseBasicMarkdown(trimmedLine.substring(2).trim()),
-                    },
-                });
-            }
-            else if (trimmedLine.startsWith('```')) {
-                // Handle code blocks
-                const language = trimmedLine.substring(3).trim() || 'plain text';
-                const codeLines = [];
-                i++; // Skip the opening ```
-                // Collect all code lines until closing ```
-                while (i < lines.length && !lines[i].trim().startsWith('```')) {
-                    codeLines.push(lines[i]);
-                    i++;
-                }
-                blocks.push({
-                    type: 'code',
-                    code: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(codeLines.join('\n'))],
-                        language: language === 'plain text' ? 'plain_text' : language,
-                    },
-                });
-            }
-            else {
-                // Regular paragraph - handle basic markdown formatting
-                const richText = NotionAITool.parseBasicMarkdown(trimmedLine);
-                blocks.push({
-                    type: 'paragraph',
-                    paragraph: {
-                        rich_text: richText,
-                    },
-                });
-            }
-        }
-        return blocks;
-    }
-    // New XML-like tag processing function
-    static processXmlTags(content, blocks) {
-        let processedContent = content;
-        let blockCounter = 0;
-        // Process XML-like tags in order of priority
-        const tagProcessors = [
-            // Callouts: <callout type="info">content</callout>
-            {
-                regex: /<callout\s*(?:type="([^"]*)")?\s*>(.*?)<\/callout>/gis,
-                processor: (match, type = 'info', content) => {
-                    const emoji = NotionAITool.getCalloutEmoji(type.toLowerCase());
-                    const color = NotionAITool.getCalloutColor(type.toLowerCase());
-                    blocks.push({
-                        type: 'callout',
-                        callout: {
-                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
-                            icon: { type: 'emoji', emoji },
-                            color: color,
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Code blocks: <code language="javascript">content</code>
-            {
-                regex: /<code\s*(?:language="([^"]*)")?\s*>(.*?)<\/code>/gis,
-                processor: (match, language = 'plain_text', content) => {
-                    blocks.push({
-                        type: 'code',
-                        code: {
-                            rich_text: [(0, NotionUtils_1.createRichText)(content.trim())],
-                            language: language === 'plain text' ? 'plain_text' : language,
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Images: <image src="url" alt="description">caption</image>
-            {
-                regex: /<image\s+src="([^"]*)"(?:\s+alt="([^"]*)")?\s*>(.*?)<\/image>/gis,
-                processor: (match, src, alt = '', caption = '') => {
-                    const captionText = caption.trim() || alt;
-                    blocks.push({
-                        type: 'image',
-                        image: {
-                            type: 'external',
-                            external: { url: src },
-                            caption: captionText ? NotionAITool.parseBasicMarkdown(captionText) : [],
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Self-closing images: <image src="url" alt="description"/>
-            {
-                regex: /<image\s+src="([^"]*)"(?:\s+alt="([^"]*)")?\s*\/>/gis,
-                processor: (match, src, alt = '') => {
-                    blocks.push({
-                        type: 'image',
-                        image: {
-                            type: 'external',
-                            external: { url: src },
-                            caption: alt ? NotionAITool.parseBasicMarkdown(alt) : [],
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Equations: <equation>E=mc^2</equation>
-            {
-                regex: /<equation>(.*?)<\/equation>/gis,
-                processor: (match, expression) => {
-                    blocks.push({
-                        type: 'equation',
-                        equation: {
-                            expression: expression.trim(),
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Embeds: <embed>url</embed>
-            {
-                regex: /<embed>(.*?)<\/embed>/gis,
-                processor: (match, url) => {
-                    blocks.push({
-                        type: 'embed',
-                        embed: {
-                            url: url.trim(),
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Bookmarks: <bookmark>url</bookmark>
-            {
-                regex: /<bookmark>(.*?)<\/bookmark>/gis,
-                processor: (match, url) => {
-                    blocks.push({
-                        type: 'bookmark',
-                        bookmark: {
-                            url: url.trim(),
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Toggles: <toggle>title</toggle>
-            {
-                regex: /<toggle>(.*?)<\/toggle>/gis,
-                processor: (match, title) => {
-                    blocks.push({
-                        type: 'toggle',
-                        toggle: {
-                            rich_text: NotionAITool.parseBasicMarkdown(title.trim()),
-                            children: [],
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Quotes: <quote>content</quote>
-            {
-                regex: /<quote>(.*?)<\/quote>/gis,
-                processor: (match, content) => {
-                    blocks.push({
-                        type: 'quote',
-                        quote: {
-                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Dividers: <divider/> or <divider></divider>
-            {
-                regex: /<divider\s*\/?>/gis,
-                processor: (match) => {
-                    blocks.push({
-                        type: 'divider',
-                        divider: {},
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // To-do items: <todo checked="true">content</todo>
-            {
-                regex: /<todo\s*(?:checked="([^"]*)")?\s*>(.*?)<\/todo>/gis,
-                processor: (match, checked = 'false', content) => {
-                    const isChecked = checked.toLowerCase() === 'true';
-                    blocks.push({
-                        type: 'to_do',
-                        to_do: {
-                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
-                            checked: isChecked,
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Headings: <h1>content</h1>, <h2>content</h2>, <h3>content</h3>
-            {
-                regex: /<h([123])>(.*?)<\/h[123]>/gis,
-                processor: (match, level, content) => {
-                    const headingType = `heading_${level}`;
-                    blocks.push({
-                        type: headingType,
-                        [headingType]: {
-                            rich_text: [(0, NotionUtils_1.createRichText)(content.trim())],
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Paragraphs: <p>content</p>
-            {
-                regex: /<p>(.*?)<\/p>/gis,
-                processor: (match, content) => {
-                    blocks.push({
-                        type: 'paragraph',
-                        paragraph: {
-                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Bulleted lists: <ul><li>item</li></ul>
-            {
-                regex: /<ul>(.*?)<\/ul>/gis,
-                processor: (match, listContent) => {
-                    // Extract individual list items
-                    const items = listContent.match(/<li>(.*?)<\/li>/gis) || [];
-                    items.forEach(item => {
-                        const itemContent = item.replace(/<\/?li>/gi, '').trim();
-                        blocks.push({
-                            type: 'bulleted_list_item',
-                            bulleted_list_item: {
-                                rich_text: NotionAITool.parseBasicMarkdown(itemContent),
-                            },
-                        });
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Numbered lists: <ol><li>item</li></ol>
-            {
-                regex: /<ol>(.*?)<\/ol>/gis,
-                processor: (match, listContent) => {
-                    // Extract individual list items
-                    const items = listContent.match(/<li>(.*?)<\/li>/gis) || [];
-                    items.forEach(item => {
-                        const itemContent = item.replace(/<\/?li>/gi, '').trim();
-                        blocks.push({
-                            type: 'numbered_list_item',
-                            numbered_list_item: {
-                                rich_text: NotionAITool.parseBasicMarkdown(itemContent),
-                            },
-                        });
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Standalone list items: <li>content</li>
-            {
-                regex: /<li>(.*?)<\/li>/gis,
-                processor: (match, content) => {
-                    blocks.push({
-                        type: 'bulleted_list_item',
-                        bulleted_list_item: {
-                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Blockquotes: <blockquote>content</blockquote>
-            {
-                regex: /<blockquote>(.*?)<\/blockquote>/gis,
-                processor: (match, content) => {
-                    blocks.push({
-                        type: 'quote',
-                        quote: {
-                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Preformatted text: <pre>content</pre>
-            {
-                regex: /<pre>(.*?)<\/pre>/gis,
-                processor: (match, content) => {
-                    blocks.push({
-                        type: 'code',
-                        code: {
-                            rich_text: [(0, NotionUtils_1.createRichText)(content.trim())],
-                            language: 'plain_text',
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Strong/Bold: <strong>content</strong> or <b>content</b>
-            {
-                regex: /<(strong|b)>(.*?)<\/(strong|b)>/gis,
-                processor: (match, tag, content) => {
-                    blocks.push({
-                        type: 'paragraph',
-                        paragraph: {
-                            rich_text: NotionAITool.parseBasicMarkdown(`**${content.trim()}**`),
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Emphasis/Italic: <em>content</em> or <i>content</i>
-            {
-                regex: /<(em|i)>(.*?)<\/(em|i)>/gis,
-                processor: (match, tag, content) => {
-                    blocks.push({
-                        type: 'paragraph',
-                        paragraph: {
-                            rich_text: NotionAITool.parseBasicMarkdown(`*${content.trim()}*`),
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-            // Line breaks: <br/> or <br>
-            {
-                regex: /<br\s*\/?>/gis,
-                processor: (match) => {
-                    blocks.push({
-                        type: 'paragraph',
-                        paragraph: {
-                            rich_text: [(0, NotionUtils_1.createRichText)('')],
-                        },
-                    });
-                    return `__XML_BLOCK_${blockCounter++}__`;
-                }
-            },
-        ];
-        // Process each tag type
-        tagProcessors.forEach(({ regex, processor }) => {
-            processedContent = processedContent.replace(regex, (match, group1, group2, group3) => {
-                return processor(match, group1 || '', group2 || '', group3 || '');
-            });
-        });
-        return processedContent;
-    }
-    // Helper function to get callout emoji based on type
-    static getCalloutEmoji(type) {
-        const emojiMap = {
-            'info': 'ℹ️',
-            'warning': '⚠️',
-            'danger': '🚨',
-            'error': '❌',
-            'note': '📝',
-            'tip': '💡',
-            'success': '✅',
-            'question': '❓',
-        };
-        return emojiMap[type] || 'ℹ️';
-    }
-    // Helper function to get callout color based on type
-    static getCalloutColor(type) {
-        const colorMap = {
-            'info': 'blue',
-            'warning': 'yellow',
-            'danger': 'red',
-            'error': 'red',
-            'note': 'gray',
-            'tip': 'green',
-            'success': 'green',
-            'question': 'purple',
-        };
-        return colorMap[type] || 'gray';
-    }
-    // Helper function to parse basic markdown formatting in text
-    static parseBasicMarkdown(text) {
-        const richTextObjects = [];
-        // Find and collect all formatting patterns with their positions
-        const patterns = [
-            { regex: /\[([^\]]+)\]\(([^)]+)\)/g, type: 'link' }, // [text](url)
-            { regex: /\*\*\*([^*]+)\*\*\*/g, type: 'bold_italic' }, // ***bold italic***
-            { regex: /\*\*([^*]+)\*\*/g, type: 'bold' }, // **bold**
-            { regex: /\*([^*]+)\*/g, type: 'italic' }, // *italic*
-            { regex: /~~([^~]+)~~/g, type: 'strikethrough' }, // ~~strikethrough~~
-            { regex: /`([^`]+)`/g, type: 'code' }, // `code`
-        ];
-        const matches = [];
-        // Collect all matches
-        patterns.forEach(pattern => {
-            const regex = new RegExp(pattern.regex.source, 'g');
-            let match;
-            while ((match = regex.exec(text)) !== null) {
-                if (pattern.type === 'link') {
-                    matches.push({
-                        start: match.index,
-                        end: match.index + match[0].length,
-                        text: match[1], // Link text
-                        type: pattern.type,
-                        url: match[2] // Link URL
-                    });
-                }
-                else {
-                    matches.push({
-                        start: match.index,
-                        end: match.index + match[0].length,
-                        text: match[1], // Inner text
-                        type: pattern.type
-                    });
-                }
-            }
-        });
-        // Sort matches by position and resolve overlaps (prefer longer matches)
-        matches.sort((a, b) => {
-            if (a.start !== b.start)
-                return a.start - b.start;
-            return (b.end - b.start) - (a.end - a.start); // Prefer longer matches
-        });
-        // Remove overlapping matches (keep the first/longer one)
-        const resolvedMatches = [];
-        for (const match of matches) {
-            const hasOverlap = resolvedMatches.some(existing => (match.start < existing.end && match.end > existing.start));
-            if (!hasOverlap) {
-                resolvedMatches.push(match);
-            }
-        }
-        // Sort again by position
-        resolvedMatches.sort((a, b) => a.start - b.start);
-        // If no formatting found, return simple rich text
-        if (resolvedMatches.length === 0) {
-            return [(0, NotionUtils_1.createRichText)(text)];
-        }
-        // Build rich text segments
-        let lastIndex = 0;
-        resolvedMatches.forEach(match => {
-            // Add plain text before this match
-            if (match.start > lastIndex) {
-                const plainText = text.substring(lastIndex, match.start);
-                if (plainText) {
-                    richTextObjects.push((0, NotionUtils_1.createRichText)(plainText));
-                }
-            }
-            // Add formatted text
-            const richTextObj = {
-                type: 'text',
-                text: { content: match.text },
-                annotations: {}
-            };
-            // Apply formatting based on type
-            switch (match.type) {
-                case 'bold':
-                    richTextObj.annotations.bold = true;
-                    break;
-                case 'italic':
-                    richTextObj.annotations.italic = true;
-                    break;
-                case 'bold_italic':
-                    richTextObj.annotations.bold = true;
-                    richTextObj.annotations.italic = true;
-                    break;
-                case 'strikethrough':
-                    richTextObj.annotations.strikethrough = true;
-                    break;
-                case 'code':
-                    richTextObj.annotations.code = true;
-                    break;
-                case 'link':
-                    richTextObj.text.link = { url: match.url };
-                    break;
-            }
-            // Clean up empty annotations
-            if (Object.keys(richTextObj.annotations).length === 0) {
-                delete richTextObj.annotations;
-            }
-            richTextObjects.push(richTextObj);
-            lastIndex = match.end;
-        });
-        // Add remaining plain text
-        if (lastIndex < text.length) {
-            const remainingText = text.substring(lastIndex);
-            if (remainingText) {
-                richTextObjects.push((0, NotionUtils_1.createRichText)(remainingText));
-            }
-        }
-        return richTextObjects.length > 0 ? richTextObjects : [(0, NotionUtils_1.createRichText)(text)];
-    }
-    static parsePropertiesToUpdate(propertiesString) {
-        try {
-            // Try to parse as JSON first
-            return JSON.parse(propertiesString);
-        }
-        catch {
-            // If not JSON, try to parse natural language
-            const properties = {};
-            // Simple natural language parsing
-            const patterns = [
-                /set\s+(\w+)\s+to\s+(.+?)(?:\s+and|$)/gi,
-                /(\w+)\s*:\s*(.+?)(?:\s*,|$)/gi,
-                /(\w+)\s*=\s*(.+?)(?:\s*,|$)/gi,
-            ];
-            for (const pattern of patterns) {
-                let match;
-                while ((match = pattern.exec(propertiesString)) !== null) {
-                    const [, key, value] = match;
-                    properties[key.trim()] = {
-                        rich_text: [(0, NotionUtils_1.createRichText)(value.trim())],
-                    };
-                }
-            }
-            return properties;
-        }
-    }
-}
-exports.NotionAITool = NotionAITool;