n8n-mcp 2.23.0 → 2.24.1

package/dist/mcp/server.js

@@ -53,6 +53,7 @@ const property_filter_1 = require("../services/property-filter");
 const task_templates_1 = require("../services/task-templates");
 const enhanced_config_validator_1 = require("../services/enhanced-config-validator");
 const property_dependencies_1 = require("../services/property-dependencies");
+const type_structure_service_1 = require("../services/type-structure-service");
 const simple_cache_1 = require("../utils/simple-cache");
 const template_service_1 = require("../templates/template-service");
 const workflow_validator_1 = require("../services/workflow-validator");
@@ -727,9 +728,6 @@ class N8NDocumentationMCPServer {
                 return this.getToolsDocumentation(args.topic, args.depth);
             case 'list_nodes':
                 return this.listNodes(args);
-            case 'get_node_info':
-                this.validateToolParams(name, args, ['nodeType']);
-                return this.getNodeInfo(args.nodeType);
             case 'search_nodes':
                 this.validateToolParams(name, args, ['query']);
                 const limit = args.limit !== undefined ? Number(args.limit) || 20 : 20;
@@ -741,9 +739,9 @@ class N8NDocumentationMCPServer {
                 return this.getNodeDocumentation(args.nodeType);
             case 'get_database_statistics':
                 return this.getDatabaseStatistics();
-            case 'get_node_essentials':
+            case 'get_node':
                 this.validateToolParams(name, args, ['nodeType']);
-                return this.getNodeEssentials(args.nodeType, args.includeExamples);
+                return this.getNode(args.nodeType, args.detail, args.mode, args.includeTypeInfo, args.includeExamples, args.fromVersion, args.toVersion);
             case 'search_node_properties':
                 this.validateToolParams(name, args, ['nodeType', 'query']);
                 const maxResults = args.maxResults !== undefined ? Number(args.maxResults) || 20 : 20;
@@ -1723,6 +1721,236 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
         this.cache.set(cacheKey, result, 3600);
         return result;
     }
+    async getNode(nodeType, detail = 'standard', mode = 'info', includeTypeInfo, includeExamples, fromVersion, toVersion) {
+        await this.ensureInitialized();
+        if (!this.repository)
+            throw new Error('Repository not initialized');
+        const validDetailLevels = ['minimal', 'standard', 'full'];
+        const validModes = ['info', 'versions', 'compare', 'breaking', 'migrations'];
+        if (!validDetailLevels.includes(detail)) {
+            throw new Error(`get_node: Invalid detail level "${detail}". Valid options: ${validDetailLevels.join(', ')}`);
+        }
+        if (!validModes.includes(mode)) {
+            throw new Error(`get_node: Invalid mode "${mode}". Valid options: ${validModes.join(', ')}`);
+        }
+        const normalizedType = node_type_normalizer_1.NodeTypeNormalizer.normalizeToFullForm(nodeType);
+        if (mode !== 'info') {
+            return this.handleVersionMode(normalizedType, mode, fromVersion, toVersion);
+        }
+        return this.handleInfoMode(normalizedType, detail, includeTypeInfo, includeExamples);
+    }
+    async handleInfoMode(nodeType, detail, includeTypeInfo, includeExamples) {
+        switch (detail) {
+            case 'minimal': {
+                let node = this.repository.getNode(nodeType);
+                if (!node) {
+                    const alternatives = (0, node_utils_1.getNodeTypeAlternatives)(nodeType);
+                    for (const alt of alternatives) {
+                        const found = this.repository.getNode(alt);
+                        if (found) {
+                            node = found;
+                            break;
+                        }
+                    }
+                }
+                if (!node) {
+                    throw new Error(`Node ${nodeType} not found`);
+                }
+                return {
+                    nodeType: node.nodeType,
+                    workflowNodeType: (0, node_utils_1.getWorkflowNodeType)(node.package ?? 'n8n-nodes-base', node.nodeType),
+                    displayName: node.displayName,
+                    description: node.description,
+                    category: node.category,
+                    package: node.package,
+                    isAITool: node.isAITool,
+                    isTrigger: node.isTrigger,
+                    isWebhook: node.isWebhook
+                };
+            }
+            case 'standard': {
+                const essentials = await this.getNodeEssentials(nodeType, includeExamples);
+                const versionSummary = this.getVersionSummary(nodeType);
+                if (includeTypeInfo) {
+                    essentials.requiredProperties = this.enrichPropertiesWithTypeInfo(essentials.requiredProperties);
+                    essentials.commonProperties = this.enrichPropertiesWithTypeInfo(essentials.commonProperties);
+                }
+                return {
+                    ...essentials,
+                    versionInfo: versionSummary
+                };
+            }
+            case 'full': {
+                const fullInfo = await this.getNodeInfo(nodeType);
+                const versionSummary = this.getVersionSummary(nodeType);
+                if (includeTypeInfo && fullInfo.properties) {
+                    fullInfo.properties = this.enrichPropertiesWithTypeInfo(fullInfo.properties);
+                }
+                return {
+                    ...fullInfo,
+                    versionInfo: versionSummary
+                };
+            }
+            default:
+                throw new Error(`Unknown detail level: ${detail}`);
+        }
+    }
+    async handleVersionMode(nodeType, mode, fromVersion, toVersion) {
+        switch (mode) {
+            case 'versions':
+                return this.getVersionHistory(nodeType);
+            case 'compare':
+                if (!fromVersion) {
+                    throw new Error(`get_node: fromVersion is required for compare mode (nodeType: ${nodeType})`);
+                }
+                return this.compareVersions(nodeType, fromVersion, toVersion);
+            case 'breaking':
+                if (!fromVersion) {
+                    throw new Error(`get_node: fromVersion is required for breaking mode (nodeType: ${nodeType})`);
+                }
+                return this.getBreakingChanges(nodeType, fromVersion, toVersion);
+            case 'migrations':
+                if (!fromVersion || !toVersion) {
+                    throw new Error(`get_node: Both fromVersion and toVersion are required for migrations mode (nodeType: ${nodeType})`);
+                }
+                return this.getMigrations(nodeType, fromVersion, toVersion);
+            default:
+                throw new Error(`get_node: Unknown mode: ${mode} (nodeType: ${nodeType})`);
+        }
+    }
+    getVersionSummary(nodeType) {
+        const cacheKey = `version-summary:${nodeType}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const versions = this.repository.getNodeVersions(nodeType);
+        const latest = this.repository.getLatestNodeVersion(nodeType);
+        const summary = {
+            currentVersion: latest?.version || 'unknown',
+            totalVersions: versions.length,
+            hasVersionHistory: versions.length > 0
+        };
+        this.cache.set(cacheKey, summary, 86400000);
+        return summary;
+    }
+    getVersionHistory(nodeType) {
+        const versions = this.repository.getNodeVersions(nodeType);
+        return {
+            nodeType,
+            totalVersions: versions.length,
+            versions: versions.map(v => ({
+                version: v.version,
+                isCurrent: v.isCurrentMax,
+                minimumN8nVersion: v.minimumN8nVersion,
+                releasedAt: v.releasedAt,
+                hasBreakingChanges: (v.breakingChanges || []).length > 0,
+                breakingChangesCount: (v.breakingChanges || []).length,
+                deprecatedProperties: v.deprecatedProperties || [],
+                addedProperties: v.addedProperties || []
+            })),
+            available: versions.length > 0,
+            message: versions.length === 0 ?
+                'No version history available. Version tracking may not be enabled for this node.' :
+                undefined
+        };
+    }
+    compareVersions(nodeType, fromVersion, toVersion) {
+        const latest = this.repository.getLatestNodeVersion(nodeType);
+        const targetVersion = toVersion || latest?.version;
+        if (!targetVersion) {
+            throw new Error('No target version available');
+        }
+        const changes = this.repository.getPropertyChanges(nodeType, fromVersion, targetVersion);
+        return {
+            nodeType,
+            fromVersion,
+            toVersion: targetVersion,
+            totalChanges: changes.length,
+            breakingChanges: changes.filter(c => c.isBreaking).length,
+            changes: changes.map(c => ({
+                property: c.propertyName,
+                changeType: c.changeType,
+                isBreaking: c.isBreaking,
+                severity: c.severity,
+                oldValue: c.oldValue,
+                newValue: c.newValue,
+                migrationHint: c.migrationHint,
+                autoMigratable: c.autoMigratable
+            }))
+        };
+    }
+    getBreakingChanges(nodeType, fromVersion, toVersion) {
+        const breakingChanges = this.repository.getBreakingChanges(nodeType, fromVersion, toVersion);
+        return {
+            nodeType,
+            fromVersion,
+            toVersion: toVersion || 'latest',
+            totalBreakingChanges: breakingChanges.length,
+            changes: breakingChanges.map(c => ({
+                fromVersion: c.fromVersion,
+                toVersion: c.toVersion,
+                property: c.propertyName,
+                changeType: c.changeType,
+                severity: c.severity,
+                migrationHint: c.migrationHint,
+                oldValue: c.oldValue,
+                newValue: c.newValue
+            })),
+            upgradeSafe: breakingChanges.length === 0
+        };
+    }
+    getMigrations(nodeType, fromVersion, toVersion) {
+        const migrations = this.repository.getAutoMigratableChanges(nodeType, fromVersion, toVersion);
+        const allChanges = this.repository.getPropertyChanges(nodeType, fromVersion, toVersion);
+        return {
+            nodeType,
+            fromVersion,
+            toVersion,
+            autoMigratableChanges: migrations.length,
+            totalChanges: allChanges.length,
+            migrations: migrations.map(m => ({
+                property: m.propertyName,
+                changeType: m.changeType,
+                migrationStrategy: m.migrationStrategy,
+                severity: m.severity
+            })),
+            requiresManualMigration: migrations.length < allChanges.length
+        };
+    }
+    enrichPropertyWithTypeInfo(property) {
+        if (!property || !property.type)
+            return property;
+        const structure = type_structure_service_1.TypeStructureService.getStructure(property.type);
+        if (!structure)
+            return property;
+        return {
+            ...property,
+            typeInfo: {
+                category: structure.type,
+                jsType: structure.jsType,
+                description: structure.description,
+                isComplex: type_structure_service_1.TypeStructureService.isComplexType(property.type),
+                isPrimitive: type_structure_service_1.TypeStructureService.isPrimitiveType(property.type),
+                allowsExpressions: structure.validation?.allowExpressions ?? true,
+                allowsEmpty: structure.validation?.allowEmpty ?? false,
+                ...(structure.structure && {
+                    structureHints: {
+                        hasProperties: !!structure.structure.properties,
+                        hasItems: !!structure.structure.items,
+                        isFlexible: structure.structure.flexible ?? false,
+                        requiredFields: structure.structure.required ?? []
+                    }
+                }),
+                ...(structure.notes && { notes: structure.notes })
+            }
+        };
+    }
+    enrichPropertiesWithTypeInfo(properties) {
+        if (!properties || !Array.isArray(properties))
+            return properties;
+        return properties.map((prop) => this.enrichPropertyWithTypeInfo(prop));
+    }
     async searchNodeProperties(nodeType, query, maxResults = 20) {
         await this.ensureInitialized();
         if (!this.repository)