n8n-mcp 2.77.0 → 2.78.0

package/dist/mcp/server.js

@@ -76,6 +76,8 @@ const node_type_normalizer_1 = require("../utils/node-type-normalizer");
 const typeversion_1 = require("../utils/typeversion");
 const validation_schemas_1 = require("../utils/validation-schemas");
 const protocol_version_1 = require("../utils/protocol-version");
+const breaking_change_detector_1 = require("../services/breaking-change-detector");
+const node_parser_1 = require("../parsers/node-parser");
 const telemetry_1 = require("../telemetry");
 const startup_checkpoints_1 = require("../telemetry/startup-checkpoints");
 const STDIO_MAX_BUFFER_SIZE = Math.max(1024 * 1024, parseInt(process.env.N8N_MCP_STDIO_MAX_BUFFER_SIZE || '', 10) || 64 * 1024 * 1024);
@@ -86,6 +88,7 @@ class N8NDocumentationMCPServer {
     constructor(instanceContext, earlyLogger, options) {
         this.db = null;
         this.repository = null;
+        this.breakingChangeDetector = null;
         this.templateService = null;
         this.cache = new simple_cache_1.SimpleCache();
         this.clientInfo = null;
@@ -2530,28 +2533,75 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
             ...extra
         };
     }
-    getVersionHistory(nodeType) {
+    async getVersionHistory(nodeType) {
         if (!this.repository.hasVersionMetadata(nodeType)) {
+            const node = this.repository.getNode(nodeType);
+            if (node && node.isVersioned === false && node.version) {
+                return {
+                    nodeType,
+                    available: true,
+                    totalVersions: 1,
+                    versions: [{
+                            version: String(node.version),
+                            isCurrent: true,
+                            hasBreakingChanges: false,
+                            breakingChangesCount: 0,
+                            deprecatedProperties: [],
+                            addedProperties: []
+                        }]
+                };
+            }
             return this.versionMetadataUnavailable(nodeType, { totalVersions: 0, versions: [] });
         }
         const versions = this.repository.getNodeVersions(nodeType);
-        return {
-            nodeType,
-            available: true,
-            totalVersions: versions.length,
-            versions: versions.map(v => ({
+        const entries = [];
+        for (let i = 0; i < versions.length; i++) {
+            const v = versions[i];
+            const previous = versions[i + 1];
+            const breakingCount = previous
+                ? (await this.analyzeVersionUpgrade(nodeType, previous.version, v.version))
+                    .changes.filter(c => c.isBreaking).length
+                : 0;
+            entries.push({
                 version: v.version,
                 isCurrent: v.isCurrentMax,
-                minimumN8nVersion: v.minimumN8nVersion,
-                releasedAt: v.releasedAt,
-                hasBreakingChanges: (v.breakingChanges || []).length > 0,
-                breakingChangesCount: (v.breakingChanges || []).length,
+                hasBreakingChanges: breakingCount > 0,
+                breakingChangesCount: breakingCount,
                 deprecatedProperties: v.deprecatedProperties || [],
                 addedProperties: v.addedProperties || []
-            }))
+            });
+        }
+        return {
+            nodeType,
+            available: true,
+            totalVersions: entries.length,
+            versions: entries
         };
     }
-    compareVersions(nodeType, fromVersion, toVersion) {
+    async analyzeVersionUpgrade(nodeType, fromVersion, toVersion) {
+        const from = (0, node_parser_1.normalizeNodeVersion)(fromVersion);
+        const to = (0, node_parser_1.normalizeNodeVersion)(toVersion ?? this.defaultTargetVersion(nodeType, from));
+        for (const version of [from, to]) {
+            if (!this.repository.getNodeVersion(nodeType, version)) {
+                const known = this.repository.getNodeVersions(nodeType).map(v => v.version).join(', ');
+                throw new Error(`get_node: version "${version}" is not a recorded version of ${nodeType} (recorded: ${known})`);
+            }
+        }
+        this.breakingChangeDetector ?? (this.breakingChangeDetector = new breaking_change_detector_1.BreakingChangeDetector(this.repository));
+        return this.breakingChangeDetector.analyzeVersionUpgrade(node_type_normalizer_1.NodeTypeNormalizer.toWorkflowFormat(nodeType), from, to);
+    }
+    defaultTargetVersion(nodeType, fromVersion) {
+        const current = this.repository.getLatestNodeVersion(nodeType)?.version
+            ?? this.repository.getNode(nodeType)?.version;
+        if (!current) {
+            throw new Error('No target version available');
+        }
+        if (Number(fromVersion) <= Number(current))
+            return current;
+        const newest = this.repository.getNodeVersions(nodeType)[0]?.version;
+        return newest ?? current;
+    }
+    async compareVersions(nodeType, fromVersion, toVersion) {
         if (!this.repository.hasVersionMetadata(nodeType)) {
             return this.versionMetadataUnavailable(nodeType, {
                 fromVersion,
@@ -2560,20 +2610,15 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
                 changes: []
             });
         }
-        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);
+        const analysis = await this.analyzeVersionUpgrade(nodeType, fromVersion, toVersion);
         return {
             nodeType,
             available: true,
-            fromVersion,
-            toVersion: targetVersion,
-            totalChanges: changes.length,
-            breakingChanges: changes.filter(c => c.isBreaking).length,
-            changes: changes.map(c => ({
+            fromVersion: analysis.fromVersion,
+            toVersion: analysis.toVersion,
+            totalChanges: analysis.changes.length,
+            breakingChanges: analysis.changes.filter(c => c.isBreaking).length,
+            changes: analysis.changes.map(c => ({
                 property: c.propertyName,
                 changeType: c.changeType,
                 isBreaking: c.isBreaking,
@@ -2581,11 +2626,12 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
                 oldValue: c.oldValue,
                 newValue: c.newValue,
                 migrationHint: c.migrationHint,
-                autoMigratable: c.autoMigratable
+                autoMigratable: c.autoMigratable,
+                source: c.source
             }))
         };
     }
-    getBreakingChanges(nodeType, fromVersion, toVersion) {
+    async getBreakingChanges(nodeType, fromVersion, toVersion) {
         if (!this.repository.hasVersionMetadata(nodeType)) {
             return this.versionMetadataUnavailable(nodeType, {
                 fromVersion,
@@ -2594,27 +2640,30 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
                 changes: []
             });
         }
-        const breakingChanges = this.repository.getBreakingChanges(nodeType, fromVersion, toVersion);
+        const analysis = await this.analyzeVersionUpgrade(nodeType, fromVersion, toVersion);
+        const breakingChanges = analysis.changes.filter(c => c.isBreaking);
         return {
             nodeType,
             available: true,
-            fromVersion,
-            toVersion: toVersion || 'latest',
+            fromVersion: analysis.fromVersion,
+            toVersion: analysis.toVersion,
             totalBreakingChanges: breakingChanges.length,
             changes: breakingChanges.map(c => ({
-                fromVersion: c.fromVersion,
-                toVersion: c.toVersion,
+                fromVersion: c.fromVersion ?? analysis.fromVersion,
+                toVersion: c.toVersion ?? analysis.toVersion,
                 property: c.propertyName,
                 changeType: c.changeType,
                 severity: c.severity,
                 migrationHint: c.migrationHint,
                 oldValue: c.oldValue,
-                newValue: c.newValue
+                newValue: c.newValue,
+                source: c.source
             })),
-            upgradeSafe: breakingChanges.length === 0
+            upgradeSafe: breakingChanges.length === 0,
+            recommendations: analysis.recommendations
         };
     }
-    getMigrations(nodeType, fromVersion, toVersion) {
+    async getMigrations(nodeType, fromVersion, toVersion) {
         if (!this.repository.hasVersionMetadata(nodeType)) {
             return this.versionMetadataUnavailable(nodeType, {
                 fromVersion,
@@ -2624,22 +2673,25 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
                 migrations: []
             });
         }
-        const migrations = this.repository.getAutoMigratableChanges(nodeType, fromVersion, toVersion);
-        const allChanges = this.repository.getPropertyChanges(nodeType, fromVersion, toVersion);
+        const analysis = await this.analyzeVersionUpgrade(nodeType, fromVersion, toVersion);
+        const migrations = analysis.changes.filter(c => c.autoMigratable && c.migrationStrategy);
+        const noActionRequired = analysis.changes.filter(c => c.autoMigratable && !c.migrationStrategy).length;
         return {
             nodeType,
             available: true,
-            fromVersion,
-            toVersion,
+            fromVersion: analysis.fromVersion,
+            toVersion: analysis.toVersion,
             autoMigratableChanges: migrations.length,
-            totalChanges: allChanges.length,
+            noActionRequired,
+            totalChanges: analysis.changes.length,
             migrations: migrations.map(m => ({
                 property: m.propertyName,
                 changeType: m.changeType,
                 migrationStrategy: m.migrationStrategy,
-                severity: m.severity
+                severity: m.severity,
+                source: m.source
             })),
-            requiresManualMigration: migrations.length < allChanges.length
+            requiresManualMigration: analysis.manualRequiredCount > 0
         };
     }
     enrichPropertyWithTypeInfo(property) {