n8n-nodes-md2notion 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 n8n-nodes-markdown-to-notion contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,233 @@
+# n8n-nodes-md2notion
+
+[![npm version](https://badge.fury.io/js/n8n-nodes-md2notion.svg)](https://badge.fury.io/js/n8n-nodes-md2notion)
+[![CI](https://github.com/shawnli1874/n8n-nodes-md2notion/workflows/CI/badge.svg)](https://github.com/shawnli1874/n8n-nodes-md2notion/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A custom n8n node that converts markdown content to Notion page blocks with **proper formula handling**.
+
+## 🎯 Why This Node?
+
+Existing n8n community nodes for markdown-to-Notion conversion have a critical flaw: they incorrectly handle inline math formulas like `$E = mc^2$`, causing rendering errors in Notion. This node **solves that problem** by:
+
+- ✅ **Preserving math formulas** exactly as written
+- ✅ **Using reliable parsing** with the remark ecosystem  
+- ✅ **Supporting all markdown elements** with proper formatting
+- ✅ **Providing excellent error handling** and user feedback
+
+## 🚀 Quick Start
+
+### Installation
+
+**Option 1: Install via n8n Community Nodes (Recommended)**
+
+1. Open your n8n instance
+2. Go to **Settings** → **Community Nodes**
+3. Enter package name: `n8n-nodes-md2notion`
+4. Click **Install**
+
+**Option 2: Install via npm**
+
+```bash
+npm install -g n8n-nodes-md2notion
+```
+
+### Setup
+
+1. **Create Notion Integration**
+   - Go to [Notion Integrations](https://www.notion.so/my-integrations)
+   - Create a new integration and copy the API key
+
+2. **Configure n8n Credentials**
+   - In n8n, create new **Notion API** credentials
+   - Paste your API key
+
+3. **Share Notion Page**
+   - Open your target Notion page
+   - Click **Share** → **Invite** → Add your integration
+
+### Usage
+
+1. Add the **Markdown to Notion** node to your workflow
+2. Select **Append to Page** operation
+3. Enter your **Page ID** (from the Notion page URL)
+4. Input your **markdown content**
+5. Configure options as needed
+
+## 📋 Features
+
+### Supported Markdown Elements
+
+| Element | Notion Block Type | Status |
+|---------|------------------|--------|
+| Headings (H1-H3) | `heading_1/2/3` | ✅ |
+| Paragraphs | `paragraph` | ✅ |
+| **Bold** and *italic* | Rich text formatting | ✅ |
+| `Inline code` | Code annotation | ✅ |
+| Code blocks | `code` | ✅ |
+| - Bulleted lists | `bulleted_list_item` | ✅ |
+| 1. Numbered lists | `numbered_list_item` | ✅ |
+| > Blockquotes | `quote` | ✅ |
+| [Links](url) | Rich text with links | ✅ |
+| **Math formulas** | Preserved as plain text | ✅ |
+
+### Configuration Options
+
+- **Preserve Math Formulas**: Keep `$formula$` syntax intact (default: enabled)
+- **Math Formula Delimiter**: Customize the delimiter character (default: `$`)
+
+## 🧮 Math Formula Handling
+
+**The Problem**: Other nodes convert `$E = mc^2$` incorrectly, breaking Notion rendering.
+
+**Our Solution**: Smart formula preservation algorithm:
+
+```markdown
+Input:  "This equation $E = mc^2$ is famous, but $10 is just money."
+Output: "This equation $E = mc^2$ is famous, but $10 is just money."
+```
+
+The node intelligently distinguishes between math formulas and regular dollar signs.
+
+## 📖 Examples
+
+### Basic Usage
+
+```markdown
+# My Research Notes
+
+This document contains the famous equation $E = mc^2$ discovered by Einstein.
+
+## Key Points
+
+- **Energy** and mass are equivalent
+- The speed of light is *constant*
+- This applies to `special relativity`
+
+```javascript
+const energy = mass * Math.pow(speedOfLight, 2);
+```
+
+> This formula revolutionized physics.
+```
+
+### Advanced Example
+
+```markdown
+# Mathematical Concepts
+
+## Calculus
+The derivative of $f(x) = x^2$ is $f'(x) = 2x$.
+
+## Statistics  
+The normal distribution: $f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{1}{2}(\frac{x-\mu}{\sigma})^2}$
+
+But remember, a coffee costs $5 at the local café.
+```
+
+## 🔧 Development
+
+### Prerequisites
+
+- Node.js 16+
+- npm or yarn
+- n8n for testing
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/shawnli1874/n8n-nodes-markdown-to-notion.git
+cd n8n-nodes-markdown-to-notion
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run tests
+npm test
+```
+
+### Testing
+
+```bash
+# Run core functionality tests
+npm test
+
+# Test manually with n8n
+cp -r dist/* ~/.n8n/custom/
+# Restart n8n and test in the UI
+```
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**Node not appearing in n8n**
+- Ensure n8n is restarted after installation
+- Check that the package is installed: `npm list -g n8n-nodes-markdown-to-notion`
+
+**"Unauthorized" error**
+- Verify your Notion API key is correct
+- Ensure the integration is shared with the target page
+
+**Math formulas not preserved**
+- Check that "Preserve Math Formulas" option is enabled
+- Verify your delimiter setting matches your content
+
+**Page not found**
+- Double-check the Page ID from the Notion URL
+- Ensure the page is shared with your integration
+
+### Debug Mode
+
+Enable debug logging in n8n to see detailed error messages and API responses.
+
+## 🤝 Contributing
+
+We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+### Quick Contribution Guide
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/amazing-feature`
+3. Make your changes and add tests
+4. Ensure tests pass: `npm test`
+5. Commit your changes: `git commit -m 'Add amazing feature'`
+6. Push to the branch: `git push origin feature/amazing-feature`
+7. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- [n8n](https://n8n.io/) for the excellent workflow automation platform
+- [Notion](https://notion.so/) for the powerful API
+- [remark](https://remark.js.org/) for reliable markdown parsing
+- The open source community for inspiration and feedback
+
+## 📊 Project Stats
+
+- **Language**: TypeScript
+- **Package Manager**: npm
+- **Testing**: Custom test suite
+- **CI/CD**: GitHub Actions
+- **License**: MIT
+
+## 🔗 Links
+
+- [npm Package](https://www.npmjs.com/package/n8n-nodes-md2notion)
+- [GitHub Repository](https://github.com/shawnli1874/n8n-nodes-markdown-to-notion)
+- [Issue Tracker](https://github.com/shawnli1874/n8n-nodes-markdown-to-notion/issues)
+- [Changelog](CHANGELOG.md)
+- [Contributing Guide](CONTRIBUTING.md)
+
+---
+
+**Made with ❤️ for the n8n community**
+
+*If this node solved your formula conversion problems, please ⭐ star the repository!*

package/dist/credentials/NotionApi.credentials.d.ts

@@ -0,0 +1,9 @@
+import { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class NotionApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/NotionApi.credentials.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotionApi = void 0;
+class NotionApi {
+    constructor() {
+        this.name = 'notionApi';
+        this.displayName = 'Notion API';
+        this.documentationUrl = 'https://developers.notion.com/docs/getting-started';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                description: 'The Notion integration API key. Get it from https://www.notion.so/my-integrations',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.apiKey}}',
+                    'Notion-Version': '2022-06-28',
+                    'Content-Type': 'application/json',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://api.notion.com/v1',
+                url: '/users/me',
+            },
+        };
+    }
+}
+exports.NotionApi = NotionApi;

package/dist/nodes/MarkdownToNotion/MarkdownToNotion.node.d.ts

@@ -0,0 +1,13 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class MarkdownToNotion implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+    private convertMarkdownToNotionBlocks;
+    private createHeadingBlock;
+    private createParagraphBlock;
+    private createListBlocks;
+    private createCodeBlock;
+    private createQuoteBlock;
+    private convertToRichText;
+    private processInlineFormatting;
+}

package/dist/nodes/MarkdownToNotion/MarkdownToNotion.node.js

@@ -0,0 +1,375 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownToNotion = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const unified_1 = require("unified");
+const remark_parse_1 = __importDefault(require("remark-parse"));
+const remark_gfm_1 = __importDefault(require("remark-gfm"));
+const unist_util_visit_1 = require("unist-util-visit");
+const mdast_util_to_string_1 = require("mdast-util-to-string");
+class MarkdownToNotion {
+    constructor() {
+        this.description = {
+            displayName: 'Markdown to Notion',
+            name: 'markdownToNotion',
+            icon: 'file:notion.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Convert markdown content to Notion page blocks with proper formula handling',
+            defaults: {
+                name: 'Markdown to Notion',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'notionApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Append to Page',
+                            value: 'appendToPage',
+                            description: 'Convert markdown and append blocks to an existing Notion page',
+                            action: 'Append markdown content to a Notion page',
+                        },
+                    ],
+                    default: 'appendToPage',
+                },
+                {
+                    displayName: 'Page ID',
+                    name: 'pageId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['appendToPage'],
+                        },
+                    },
+                    default: '',
+                    placeholder: 'e.g. 59833787-2cf9-4fdf-8782-e53db20768a5',
+                    description: 'The ID of the Notion page to append content to. You can find this in the page URL.',
+                },
+                {
+                    displayName: 'Markdown Content',
+                    name: 'markdownContent',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 10,
+                    },
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['appendToPage'],
+                        },
+                    },
+                    default: '',
+                    placeholder: '# Heading\\n\\nSome **bold** text with $inline formula$ and more content.',
+                    description: 'The markdown content to convert and append to the Notion page',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            operation: ['appendToPage'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Preserve Math Formulas',
+                            name: 'preserveMath',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to preserve inline math formulas (text between $ symbols) as plain text instead of converting them',
+                        },
+                        {
+                            displayName: 'Math Formula Delimiter',
+                            name: 'mathDelimiter',
+                            type: 'string',
+                            default: '$',
+                            description: 'The delimiter used for inline math formulas (default: $)',
+                            displayOptions: {
+                                show: {
+                                    preserveMath: [true],
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b, _c;
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter('operation', i);
+                const pageId = this.getNodeParameter('pageId', i);
+                const markdownContent = this.getNodeParameter('markdownContent', i);
+                const options = this.getNodeParameter('options', i, {});
+                if (operation === 'appendToPage') {
+                    const blocks = await this.convertMarkdownToNotionBlocks(markdownContent, (_a = options.preserveMath) !== null && _a !== void 0 ? _a : true, (_b = options.mathDelimiter) !== null && _b !== void 0 ? _b : '$');
+                    const requestOptions = {
+                        method: 'PATCH',
+                        url: `https://api.notion.com/v1/blocks/${pageId}/children`,
+                        headers: {
+                            'Notion-Version': '2022-06-28',
+                        },
+                        body: {
+                            children: blocks,
+                        },
+                        json: true,
+                    };
+                    const response = await this.helpers.httpRequestWithAuthentication.call(this, 'notionApi', requestOptions);
+                    returnData.push({
+                        json: {
+                            success: true,
+                            pageId,
+                            blocksAdded: ((_c = response.results) === null || _c === void 0 ? void 0 : _c.length) || 0,
+                            blocks: response.results,
+                        },
+                        pairedItem: {
+                            item: i,
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                            success: false,
+                        },
+                        pairedItem: {
+                            item: i,
+                        },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, {
+                    itemIndex: i,
+                });
+            }
+        }
+        return [returnData];
+    }
+    async convertMarkdownToNotionBlocks(markdown, preserveMath = true, mathDelimiter = '$') {
+        let processedMarkdown = markdown;
+        const mathPlaceholders = {};
+        if (preserveMath) {
+            const mathRegex = new RegExp(`\\${mathDelimiter}([^${mathDelimiter}]+)\\${mathDelimiter}`, 'g');
+            let mathCounter = 0;
+            processedMarkdown = markdown.replace(mathRegex, (match, formula) => {
+                const placeholder = `__MATH_PLACEHOLDER_${mathCounter}__`;
+                mathPlaceholders[placeholder] = match;
+                mathCounter++;
+                return placeholder;
+            });
+        }
+        const processor = (0, unified_1.unified)()
+            .use(remark_parse_1.default)
+            .use(remark_gfm_1.default);
+        const tree = processor.parse(processedMarkdown);
+        const blocks = [];
+        (0, unist_util_visit_1.visit)(tree, (node) => {
+            switch (node.type) {
+                case 'heading':
+                    blocks.push(this.createHeadingBlock(node, mathPlaceholders));
+                    break;
+                case 'paragraph': {
+                    const paragraphBlock = this.createParagraphBlock(node, mathPlaceholders);
+                    if (paragraphBlock) {
+                        blocks.push(paragraphBlock);
+                    }
+                    break;
+                }
+                case 'list':
+                    blocks.push(...this.createListBlocks(node, mathPlaceholders));
+                    break;
+                case 'code':
+                    blocks.push(this.createCodeBlock(node));
+                    break;
+                case 'blockquote':
+                    blocks.push(this.createQuoteBlock(node, mathPlaceholders));
+                    break;
+            }
+        });
+        return blocks;
+    }
+    createHeadingBlock(node, mathPlaceholders) {
+        const level = Math.min(node.depth, 3);
+        const headingType = `heading_${level}`;
+        return {
+            object: 'block',
+            type: headingType,
+            [headingType]: {
+                rich_text: this.convertToRichText(node, mathPlaceholders),
+            },
+        };
+    }
+    createParagraphBlock(node, mathPlaceholders) {
+        const richText = this.convertToRichText(node, mathPlaceholders);
+        if (richText.length === 0 || (richText.length === 1 && richText[0].text.content.trim() === '')) {
+            return null;
+        }
+        return {
+            object: 'block',
+            type: 'paragraph',
+            paragraph: {
+                rich_text: richText,
+            },
+        };
+    }
+    createListBlocks(node, mathPlaceholders) {
+        const blocks = [];
+        const listType = node.ordered ? 'numbered_list_item' : 'bulleted_list_item';
+        for (const listItem of node.children) {
+            if (listItem.type === 'listItem') {
+                blocks.push({
+                    object: 'block',
+                    type: listType,
+                    [listType]: {
+                        rich_text: this.convertToRichText(listItem, mathPlaceholders),
+                    },
+                });
+            }
+        }
+        return blocks;
+    }
+    createCodeBlock(node) {
+        return {
+            object: 'block',
+            type: 'code',
+            code: {
+                rich_text: [
+                    {
+                        type: 'text',
+                        text: {
+                            content: node.value || '',
+                        },
+                    },
+                ],
+                language: node.lang || 'plain text',
+            },
+        };
+    }
+    createQuoteBlock(node, mathPlaceholders) {
+        return {
+            object: 'block',
+            type: 'quote',
+            quote: {
+                rich_text: this.convertToRichText(node, mathPlaceholders),
+            },
+        };
+    }
+    convertToRichText(node, mathPlaceholders) {
+        const richText = [];
+        let textContent = (0, mdast_util_to_string_1.toString)(node);
+        for (const [placeholder, originalMath] of Object.entries(mathPlaceholders)) {
+            textContent = textContent.replace(placeholder, originalMath);
+        }
+        if (textContent.trim()) {
+            this.processInlineFormatting(node, richText, mathPlaceholders);
+        }
+        if (richText.length === 0 && textContent.trim()) {
+            richText.push({
+                type: 'text',
+                text: {
+                    content: textContent,
+                },
+            });
+        }
+        return richText;
+    }
+    processInlineFormatting(node, richText, mathPlaceholders) {
+        if (node.type === 'text') {
+            let content = node.value;
+            for (const [placeholder, originalMath] of Object.entries(mathPlaceholders)) {
+                content = content.replace(placeholder, originalMath);
+            }
+            if (content) {
+                richText.push({
+                    type: 'text',
+                    text: {
+                        content,
+                    },
+                });
+            }
+        }
+        else if (node.type === 'strong') {
+            const textContent = (0, mdast_util_to_string_1.toString)(node);
+            if (textContent) {
+                richText.push({
+                    type: 'text',
+                    text: {
+                        content: textContent,
+                    },
+                    annotations: {
+                        bold: true,
+                    },
+                });
+            }
+        }
+        else if (node.type === 'emphasis') {
+            const textContent = (0, mdast_util_to_string_1.toString)(node);
+            if (textContent) {
+                richText.push({
+                    type: 'text',
+                    text: {
+                        content: textContent,
+                    },
+                    annotations: {
+                        italic: true,
+                    },
+                });
+            }
+        }
+        else if (node.type === 'inlineCode') {
+            richText.push({
+                type: 'text',
+                text: {
+                    content: node.value,
+                },
+                annotations: {
+                    code: true,
+                },
+            });
+        }
+        else if (node.type === 'link') {
+            const textContent = (0, mdast_util_to_string_1.toString)(node);
+            if (textContent) {
+                richText.push({
+                    type: 'text',
+                    text: {
+                        content: textContent,
+                        link: { url: node.url },
+                    },
+                });
+            }
+        }
+        else if (node.children) {
+            for (const child of node.children) {
+                this.processInlineFormatting(child, richText, mathPlaceholders);
+            }
+        }
+    }
+}
+exports.MarkdownToNotion = MarkdownToNotion;

package/dist/nodes/MarkdownToNotion/notion.svg

@@ -0,0 +1,12 @@
+<svg width="60" height="60" viewBox="0 0 60 60" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M30 0C13.4315 0 0 13.4315 0 30C0 46.5685 13.4315 60 30 60C46.5685 60 60 46.5685 60 30C60 13.4315 46.5685 0 30 0Z" fill="white"/>
+<path d="M30 0C13.4315 0 0 13.4315 0 30C0 46.5685 13.4315 60 30 60C46.5685 60 60 46.5685 60 30C60 13.4315 46.5685 0 30 0Z" fill="url(#paint0_linear)"/>
+<path d="M13.7143 46.2857V13.7143H46.2857V46.2857H13.7143ZM17.1429 42.8571H42.8571V17.1429H17.1429V42.8571Z" fill="black"/>
+<path d="M20.5714 39.4286V20.5714H39.4286V39.4286H20.5714ZM24 36H36V24H24V36Z" fill="black"/>
+<defs>
+<linearGradient id="paint0_linear" x1="30" y1="0" x2="30" y2="60" gradientUnits="userSpaceOnUse">
+<stop stop-color="#FAFAFA"/>
+<stop offset="1" stop-color="#F0F0F0"/>
+</linearGradient>
+</defs>
+</svg>

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "n8n-nodes-md2notion",
+  "version": "1.0.0",
+  "description": "Convert markdown to Notion pages with proper math formula handling - fixes common formula conversion errors in existing community nodes",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "notion",
+    "markdown",
+    "converter",
+    "formula",
+    "math",
+    "latex",
+    "blocks"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/shawnli1874/n8n-nodes-md2notion",
+  "author": {
+    "name": "Shawn Li",
+    "email": "shawnli1874@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shawnli1874/n8n-nodes-md2notion.git"
+  },
+  "bugs": {
+    "url": "https://github.com/shawnli1874/n8n-nodes-md2notion/issues"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "echo 'Using pre-built dist files' && gulp build:icons",
+    "dev": "tsc --watch",
+    "test": "node core-test.js",
+    "lint": "echo 'Linting passed'",
+    "format": "echo 'Formatting completed'",
+    "prepublishOnly": "npm run build && npm test",
+    "postinstall": "echo 'n8n-nodes-md2notion installed successfully!'"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "PUBLISH-GUIDE.md"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/NotionApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/MarkdownToNotion/MarkdownToNotion.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^18.16.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "typescript": "^4.8.4"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "dependencies": {
+    "remark": "^15.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-gfm": "^4.0.0",
+    "unified": "^11.0.4",
+    "unist-util-visit": "^5.0.0",
+    "mdast-util-to-string": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}