n8n-mcp 2.11.3 → 2.13.0

package/dist/services/universal-expression-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"universal-expression-validator.d.ts","sourceRoot":"","sources":["../../src/services/universal-expression-validator.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,EAAE,GAAG,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,4BAA4B;IACvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAsB;IAChE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAO;IAMhD,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,GAAG,yBAAyB;IA4DtE,OAAO,CAAC,MAAM,CAAC,eAAe;IAe9B,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,yBAAyB;IA8DzE,MAAM,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,yBAAyB;IAwDvE,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,GAAG,yBAAyB,EAAE;IAyCxD,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;CAWhD"}

package/dist/services/universal-expression-validator.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniversalExpressionValidator = void 0;
+class UniversalExpressionValidator {
+    static validateExpressionPrefix(value) {
+        if (typeof value !== 'string') {
+            return {
+                isValid: true,
+                hasExpression: false,
+                needsPrefix: false,
+                isMixedContent: false,
+                confidence: 1.0,
+                explanation: 'Not a string value'
+            };
+        }
+        const hasExpression = this.EXPRESSION_PATTERN.test(value);
+        if (!hasExpression) {
+            return {
+                isValid: true,
+                hasExpression: false,
+                needsPrefix: false,
+                isMixedContent: false,
+                confidence: 1.0,
+                explanation: 'No n8n expression found'
+            };
+        }
+        const hasPrefix = value.startsWith(this.EXPRESSION_PREFIX);
+        const isMixedContent = this.hasMixedContent(value);
+        if (!hasPrefix) {
+            return {
+                isValid: false,
+                hasExpression: true,
+                needsPrefix: true,
+                isMixedContent,
+                confidence: 1.0,
+                suggestion: `${this.EXPRESSION_PREFIX}${value}`,
+                explanation: isMixedContent
+                    ? 'Mixed literal text and expression requires = prefix for expression evaluation'
+                    : 'Expression requires = prefix to be evaluated'
+            };
+        }
+        return {
+            isValid: true,
+            hasExpression: true,
+            needsPrefix: false,
+            isMixedContent,
+            confidence: 1.0,
+            explanation: 'Expression is properly formatted with = prefix'
+        };
+    }
+    static hasMixedContent(value) {
+        const content = value.startsWith(this.EXPRESSION_PREFIX)
+            ? value.substring(1)
+            : value;
+        const withoutExpressions = content.replace(/\{\{[\s\S]+?\}\}/g, '');
+        return withoutExpressions.trim().length > 0;
+    }
+    static validateExpressionSyntax(value) {
+        const hasAnyBrackets = value.includes('{{') || value.includes('}}');
+        if (!hasAnyBrackets) {
+            return {
+                isValid: true,
+                hasExpression: false,
+                needsPrefix: false,
+                isMixedContent: false,
+                confidence: 1.0,
+                explanation: 'No expression to validate'
+            };
+        }
+        const openCount = (value.match(/\{\{/g) || []).length;
+        const closeCount = (value.match(/\}\}/g) || []).length;
+        if (openCount !== closeCount) {
+            return {
+                isValid: false,
+                hasExpression: true,
+                needsPrefix: false,
+                isMixedContent: false,
+                confidence: 1.0,
+                explanation: `Unmatched expression brackets: ${openCount} opening, ${closeCount} closing`
+            };
+        }
+        const expressions = value.match(/\{\{[\s\S]+?\}\}/g) || [];
+        for (const expr of expressions) {
+            const content = expr.slice(2, -2).trim();
+            if (!content) {
+                return {
+                    isValid: false,
+                    hasExpression: true,
+                    needsPrefix: false,
+                    isMixedContent: false,
+                    confidence: 1.0,
+                    explanation: 'Empty expression {{ }} is not valid'
+                };
+            }
+        }
+        return {
+            isValid: true,
+            hasExpression: expressions.length > 0,
+            needsPrefix: false,
+            isMixedContent: this.hasMixedContent(value),
+            confidence: 1.0,
+            explanation: 'Expression syntax is valid'
+        };
+    }
+    static validateCommonPatterns(value) {
+        if (!this.EXPRESSION_PATTERN.test(value)) {
+            return {
+                isValid: true,
+                hasExpression: false,
+                needsPrefix: false,
+                isMixedContent: false,
+                confidence: 1.0,
+                explanation: 'No expression to validate'
+            };
+        }
+        const expressions = value.match(/\{\{[\s\S]+?\}\}/g) || [];
+        const warnings = [];
+        for (const expr of expressions) {
+            const content = expr.slice(2, -2).trim();
+            if (content.includes('${') && content.includes('}')) {
+                warnings.push(`Template literal syntax \${} found - use n8n syntax instead: ${expr}`);
+            }
+            if (content.startsWith('=')) {
+                warnings.push(`Double prefix detected in expression: ${expr}`);
+            }
+            if (content.includes('{{') || content.includes('}}')) {
+                warnings.push(`Nested brackets detected: ${expr}`);
+            }
+        }
+        if (warnings.length > 0) {
+            return {
+                isValid: false,
+                hasExpression: true,
+                needsPrefix: false,
+                isMixedContent: false,
+                confidence: 1.0,
+                explanation: warnings.join('; ')
+            };
+        }
+        return {
+            isValid: true,
+            hasExpression: true,
+            needsPrefix: false,
+            isMixedContent: this.hasMixedContent(value),
+            confidence: 1.0,
+            explanation: 'Expression patterns are valid'
+        };
+    }
+    static validate(value) {
+        const results = [];
+        const prefixResult = this.validateExpressionPrefix(value);
+        if (!prefixResult.isValid) {
+            results.push(prefixResult);
+        }
+        if (typeof value === 'string') {
+            const syntaxResult = this.validateExpressionSyntax(value);
+            if (!syntaxResult.isValid) {
+                results.push(syntaxResult);
+            }
+            const patternResult = this.validateCommonPatterns(value);
+            if (!patternResult.isValid) {
+                results.push(patternResult);
+            }
+        }
+        if (results.length === 0) {
+            results.push({
+                isValid: true,
+                hasExpression: prefixResult.hasExpression,
+                needsPrefix: false,
+                isMixedContent: prefixResult.isMixedContent,
+                confidence: 1.0,
+                explanation: prefixResult.hasExpression
+                    ? 'Expression is valid'
+                    : 'No expression found'
+            });
+        }
+        return results;
+    }
+    static getCorrectedValue(value) {
+        if (!this.EXPRESSION_PATTERN.test(value)) {
+            return value;
+        }
+        if (!value.startsWith(this.EXPRESSION_PREFIX)) {
+            return `${this.EXPRESSION_PREFIX}${value}`;
+        }
+        return value;
+    }
+}
+exports.UniversalExpressionValidator = UniversalExpressionValidator;
+UniversalExpressionValidator.EXPRESSION_PATTERN = /\{\{[\s\S]+?\}\}/;
+UniversalExpressionValidator.EXPRESSION_PREFIX = '=';
+//# sourceMappingURL=universal-expression-validator.js.map

package/dist/services/universal-expression-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"universal-expression-validator.js","sourceRoot":"","sources":["../../src/services/universal-expression-validator.ts"],"names":[],"mappings":"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"}

package/dist/services/workflow-auto-fixer.d.ts

@@ -0,0 +1,65 @@
+import { WorkflowValidationResult } from './workflow-validator';
+import { ExpressionFormatIssue } from './expression-format-validator';
+import { NodeRepository } from '../database/node-repository';
+import { WorkflowDiffOperation } from '../types/workflow-diff';
+import { Workflow } from '../types/n8n-api';
+export type FixConfidenceLevel = 'high' | 'medium' | 'low';
+export type FixType = 'expression-format' | 'typeversion-correction' | 'error-output-config' | 'node-type-correction' | 'webhook-missing-path';
+export interface AutoFixConfig {
+    applyFixes: boolean;
+    fixTypes?: FixType[];
+    confidenceThreshold?: FixConfidenceLevel;
+    maxFixes?: number;
+}
+export interface FixOperation {
+    node: string;
+    field: string;
+    type: FixType;
+    before: any;
+    after: any;
+    confidence: FixConfidenceLevel;
+    description: string;
+}
+export interface AutoFixResult {
+    operations: WorkflowDiffOperation[];
+    fixes: FixOperation[];
+    summary: string;
+    stats: {
+        total: number;
+        byType: Record<FixType, number>;
+        byConfidence: Record<FixConfidenceLevel, number>;
+    };
+}
+export interface NodeFormatIssue extends ExpressionFormatIssue {
+    nodeName: string;
+    nodeId: string;
+}
+export declare function isNodeFormatIssue(issue: ExpressionFormatIssue): issue is NodeFormatIssue;
+export interface NodeTypeError {
+    type: 'error';
+    nodeId?: string;
+    nodeName?: string;
+    message: string;
+    suggestions?: Array<{
+        nodeType: string;
+        confidence: number;
+        reason: string;
+    }>;
+}
+export declare class WorkflowAutoFixer {
+    private readonly defaultConfig;
+    private similarityService;
+    constructor(repository?: NodeRepository);
+    generateFixes(workflow: Workflow, validationResult: WorkflowValidationResult, formatIssues?: ExpressionFormatIssue[], config?: Partial<AutoFixConfig>): AutoFixResult;
+    private processExpressionFormatFixes;
+    private processTypeVersionFixes;
+    private processErrorOutputFixes;
+    private processNodeTypeFixes;
+    private processWebhookPathFixes;
+    private setNestedValue;
+    private filterByConfidence;
+    private filterOperationsByFixes;
+    private calculateStats;
+    private generateSummary;
+}
+//# sourceMappingURL=workflow-auto-fixer.d.ts.map

package/dist/services/workflow-auto-fixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-auto-fixer.d.ts","sourceRoot":"","sources":["../../src/services/workflow-auto-fixer.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EACL,qBAAqB,EAEtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAgB,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAK1D,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAC3D,MAAM,MAAM,OAAO,GACf,mBAAmB,GACnB,wBAAwB,GACxB,qBAAqB,GACrB,sBAAsB,GACtB,sBAAsB,CAAC;AAE3B,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB,mBAAmB,CAAC,EAAE,kBAAkB,CAAC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,GAAG,CAAC;IACZ,KAAK,EAAE,GAAG,CAAC;IACX,UAAU,EAAE,kBAAkB,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,qBAAqB,EAAE,CAAC;IACpC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAChC,YAAY,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;KAClD,CAAC;CACH;AAED,MAAM,WAAW,eAAgB,SAAQ,qBAAqB;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAKD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,GAAG,KAAK,IAAI,eAAe,CAIxF;AAKD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,KAAK,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;CACJ;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAI5B;IACF,OAAO,CAAC,iBAAiB,CAAsC;gBAEnD,UAAU,CAAC,EAAE,cAAc;IASvC,aAAa,CACX,QAAQ,EAAE,QAAQ,EAClB,gBAAgB,EAAE,wBAAwB,EAC1C,YAAY,GAAE,qBAAqB,EAAO,EAC1C,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM,GAClC,aAAa;IA4DhB,OAAO,CAAC,4BAA4B;IAqEpC,OAAO,CAAC,uBAAuB;IA8C/B,OAAO,CAAC,uBAAuB;IA0C/B,OAAO,CAAC,oBAAoB;IAkD5B,OAAO,CAAC,uBAAuB;IA+D/B,OAAO,CAAC,cAAc;IAmGtB,OAAO,CAAC,kBAAkB;IAkB1B,OAAO,CAAC,uBAAuB;IAiB/B,OAAO,CAAC,cAAc;IA4BtB,OAAO,CAAC,eAAe;CA6BxB"}

package/dist/services/workflow-auto-fixer.js

@@ -0,0 +1,394 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowAutoFixer = void 0;
+exports.isNodeFormatIssue = isNodeFormatIssue;
+const crypto_1 = __importDefault(require("crypto"));
+const node_similarity_service_1 = require("./node-similarity-service");
+const logger_1 = require("../utils/logger");
+const logger = new logger_1.Logger({ prefix: '[WorkflowAutoFixer]' });
+function isNodeFormatIssue(issue) {
+    return 'nodeName' in issue && 'nodeId' in issue &&
+        typeof issue.nodeName === 'string' &&
+        typeof issue.nodeId === 'string';
+}
+class WorkflowAutoFixer {
+    constructor(repository) {
+        this.defaultConfig = {
+            applyFixes: false,
+            confidenceThreshold: 'medium',
+            maxFixes: 50
+        };
+        this.similarityService = null;
+        if (repository) {
+            this.similarityService = new node_similarity_service_1.NodeSimilarityService(repository);
+        }
+    }
+    generateFixes(workflow, validationResult, formatIssues = [], config = {}) {
+        const fullConfig = { ...this.defaultConfig, ...config };
+        const operations = [];
+        const fixes = [];
+        const nodeMap = new Map();
+        workflow.nodes.forEach(node => {
+            nodeMap.set(node.name, node);
+            nodeMap.set(node.id, node);
+        });
+        if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('expression-format')) {
+            this.processExpressionFormatFixes(formatIssues, nodeMap, operations, fixes);
+        }
+        if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('typeversion-correction')) {
+            this.processTypeVersionFixes(validationResult, nodeMap, operations, fixes);
+        }
+        if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('error-output-config')) {
+            this.processErrorOutputFixes(validationResult, nodeMap, workflow, operations, fixes);
+        }
+        if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('node-type-correction')) {
+            this.processNodeTypeFixes(validationResult, nodeMap, operations, fixes);
+        }
+        if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('webhook-missing-path')) {
+            this.processWebhookPathFixes(validationResult, nodeMap, operations, fixes);
+        }
+        const filteredFixes = this.filterByConfidence(fixes, fullConfig.confidenceThreshold);
+        const filteredOperations = this.filterOperationsByFixes(operations, filteredFixes, fixes);
+        const limitedFixes = filteredFixes.slice(0, fullConfig.maxFixes);
+        const limitedOperations = this.filterOperationsByFixes(filteredOperations, limitedFixes, filteredFixes);
+        const stats = this.calculateStats(limitedFixes);
+        const summary = this.generateSummary(stats);
+        return {
+            operations: limitedOperations,
+            fixes: limitedFixes,
+            summary,
+            stats
+        };
+    }
+    processExpressionFormatFixes(formatIssues, nodeMap, operations, fixes) {
+        const fixesByNode = new Map();
+        for (const issue of formatIssues) {
+            if (issue.issueType === 'missing-prefix') {
+                if (!isNodeFormatIssue(issue)) {
+                    logger.warn('Expression format issue missing node information', {
+                        fieldPath: issue.fieldPath,
+                        issueType: issue.issueType
+                    });
+                    continue;
+                }
+                const nodeName = issue.nodeName;
+                if (!fixesByNode.has(nodeName)) {
+                    fixesByNode.set(nodeName, []);
+                }
+                fixesByNode.get(nodeName).push(issue);
+            }
+        }
+        for (const [nodeName, nodeIssues] of fixesByNode) {
+            const node = nodeMap.get(nodeName);
+            if (!node)
+                continue;
+            const updatedParameters = JSON.parse(JSON.stringify(node.parameters || {}));
+            for (const issue of nodeIssues) {
+                const fieldPath = issue.fieldPath.split('.');
+                this.setNestedValue(updatedParameters, fieldPath, issue.correctedValue);
+                fixes.push({
+                    node: nodeName,
+                    field: issue.fieldPath,
+                    type: 'expression-format',
+                    before: issue.currentValue,
+                    after: issue.correctedValue,
+                    confidence: 'high',
+                    description: issue.explanation
+                });
+            }
+            const operation = {
+                type: 'updateNode',
+                nodeId: nodeName,
+                updates: {
+                    parameters: updatedParameters
+                }
+            };
+            operations.push(operation);
+        }
+    }
+    processTypeVersionFixes(validationResult, nodeMap, operations, fixes) {
+        for (const error of validationResult.errors) {
+            if (error.message.includes('typeVersion') && error.message.includes('exceeds maximum')) {
+                const versionMatch = error.message.match(/typeVersion (\d+(?:\.\d+)?) exceeds maximum supported version (\d+(?:\.\d+)?)/);
+                if (versionMatch) {
+                    const currentVersion = parseFloat(versionMatch[1]);
+                    const maxVersion = parseFloat(versionMatch[2]);
+                    const nodeName = error.nodeName || error.nodeId;
+                    if (!nodeName)
+                        continue;
+                    const node = nodeMap.get(nodeName);
+                    if (!node)
+                        continue;
+                    fixes.push({
+                        node: nodeName,
+                        field: 'typeVersion',
+                        type: 'typeversion-correction',
+                        before: currentVersion,
+                        after: maxVersion,
+                        confidence: 'medium',
+                        description: `Corrected typeVersion from ${currentVersion} to maximum supported ${maxVersion}`
+                    });
+                    const operation = {
+                        type: 'updateNode',
+                        nodeId: nodeName,
+                        updates: {
+                            typeVersion: maxVersion
+                        }
+                    };
+                    operations.push(operation);
+                }
+            }
+        }
+    }
+    processErrorOutputFixes(validationResult, nodeMap, workflow, operations, fixes) {
+        for (const error of validationResult.errors) {
+            if (error.message.includes('onError: \'continueErrorOutput\'') &&
+                error.message.includes('no error output connections')) {
+                const nodeName = error.nodeName || error.nodeId;
+                if (!nodeName)
+                    continue;
+                const node = nodeMap.get(nodeName);
+                if (!node)
+                    continue;
+                fixes.push({
+                    node: nodeName,
+                    field: 'onError',
+                    type: 'error-output-config',
+                    before: 'continueErrorOutput',
+                    after: undefined,
+                    confidence: 'medium',
+                    description: 'Removed onError setting due to missing error output connections'
+                });
+                const operation = {
+                    type: 'updateNode',
+                    nodeId: nodeName,
+                    updates: {
+                        onError: undefined
+                    }
+                };
+                operations.push(operation);
+            }
+        }
+    }
+    processNodeTypeFixes(validationResult, nodeMap, operations, fixes) {
+        if (!this.similarityService) {
+            return;
+        }
+        for (const error of validationResult.errors) {
+            const nodeError = error;
+            if (error.message?.includes('Unknown node type:') && nodeError.suggestions) {
+                const highConfidenceSuggestion = nodeError.suggestions.find(s => s.confidence >= 0.9);
+                if (highConfidenceSuggestion && nodeError.nodeId) {
+                    const node = nodeMap.get(nodeError.nodeId) || nodeMap.get(nodeError.nodeName || '');
+                    if (node) {
+                        fixes.push({
+                            node: node.name,
+                            field: 'type',
+                            type: 'node-type-correction',
+                            before: node.type,
+                            after: highConfidenceSuggestion.nodeType,
+                            confidence: 'high',
+                            description: `Fix node type: "${node.type}" → "${highConfidenceSuggestion.nodeType}" (${highConfidenceSuggestion.reason})`
+                        });
+                        const operation = {
+                            type: 'updateNode',
+                            nodeId: node.name,
+                            updates: {
+                                type: highConfidenceSuggestion.nodeType
+                            }
+                        };
+                        operations.push(operation);
+                    }
+                }
+            }
+        }
+    }
+    processWebhookPathFixes(validationResult, nodeMap, operations, fixes) {
+        for (const error of validationResult.errors) {
+            if (error.message === 'Webhook path is required') {
+                const nodeName = error.nodeName || error.nodeId;
+                if (!nodeName)
+                    continue;
+                const node = nodeMap.get(nodeName);
+                if (!node)
+                    continue;
+                if (!node.type?.includes('webhook'))
+                    continue;
+                const webhookId = crypto_1.default.randomUUID();
+                const currentTypeVersion = node.typeVersion || 1;
+                const needsVersionUpdate = currentTypeVersion < 2.1;
+                fixes.push({
+                    node: nodeName,
+                    field: 'path',
+                    type: 'webhook-missing-path',
+                    before: undefined,
+                    after: webhookId,
+                    confidence: 'high',
+                    description: needsVersionUpdate
+                        ? `Generated webhook path and ID: ${webhookId} (also updating typeVersion to 2.1)`
+                        : `Generated webhook path and ID: ${webhookId}`
+                });
+                const updates = {
+                    'parameters.path': webhookId,
+                    'webhookId': webhookId
+                };
+                if (needsVersionUpdate) {
+                    updates['typeVersion'] = 2.1;
+                }
+                const operation = {
+                    type: 'updateNode',
+                    nodeId: nodeName,
+                    updates
+                };
+                operations.push(operation);
+            }
+        }
+    }
+    setNestedValue(obj, path, value) {
+        if (!obj || typeof obj !== 'object') {
+            throw new Error('Cannot set value on non-object');
+        }
+        if (path.length === 0) {
+            throw new Error('Cannot set value with empty path');
+        }
+        try {
+            let current = obj;
+            for (let i = 0; i < path.length - 1; i++) {
+                const key = path[i];
+                if (key.includes('[')) {
+                    const matches = key.match(/^([^[]+)\[(\d+)\]$/);
+                    if (!matches) {
+                        throw new Error(`Invalid array notation: ${key}`);
+                    }
+                    const [, arrayKey, indexStr] = matches;
+                    const index = parseInt(indexStr, 10);
+                    if (isNaN(index) || index < 0) {
+                        throw new Error(`Invalid array index: ${indexStr}`);
+                    }
+                    if (!current[arrayKey]) {
+                        current[arrayKey] = [];
+                    }
+                    if (!Array.isArray(current[arrayKey])) {
+                        throw new Error(`Expected array at ${arrayKey}, got ${typeof current[arrayKey]}`);
+                    }
+                    while (current[arrayKey].length <= index) {
+                        current[arrayKey].push({});
+                    }
+                    current = current[arrayKey][index];
+                }
+                else {
+                    if (current[key] === null || current[key] === undefined) {
+                        current[key] = {};
+                    }
+                    if (typeof current[key] !== 'object' || Array.isArray(current[key])) {
+                        throw new Error(`Cannot traverse through ${typeof current[key]} at ${key}`);
+                    }
+                    current = current[key];
+                }
+            }
+            const lastKey = path[path.length - 1];
+            if (lastKey.includes('[')) {
+                const matches = lastKey.match(/^([^[]+)\[(\d+)\]$/);
+                if (!matches) {
+                    throw new Error(`Invalid array notation: ${lastKey}`);
+                }
+                const [, arrayKey, indexStr] = matches;
+                const index = parseInt(indexStr, 10);
+                if (isNaN(index) || index < 0) {
+                    throw new Error(`Invalid array index: ${indexStr}`);
+                }
+                if (!current[arrayKey]) {
+                    current[arrayKey] = [];
+                }
+                if (!Array.isArray(current[arrayKey])) {
+                    throw new Error(`Expected array at ${arrayKey}, got ${typeof current[arrayKey]}`);
+                }
+                while (current[arrayKey].length <= index) {
+                    current[arrayKey].push(null);
+                }
+                current[arrayKey][index] = value;
+            }
+            else {
+                current[lastKey] = value;
+            }
+        }
+        catch (error) {
+            logger.error('Failed to set nested value', {
+                path: path.join('.'),
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    filterByConfidence(fixes, threshold) {
+        if (!threshold)
+            return fixes;
+        const levels = ['high', 'medium', 'low'];
+        const thresholdIndex = levels.indexOf(threshold);
+        return fixes.filter(fix => {
+            const fixIndex = levels.indexOf(fix.confidence);
+            return fixIndex <= thresholdIndex;
+        });
+    }
+    filterOperationsByFixes(operations, filteredFixes, allFixes) {
+        const fixedNodes = new Set(filteredFixes.map(f => f.node));
+        return operations.filter(op => {
+            if (op.type === 'updateNode') {
+                return fixedNodes.has(op.nodeId || '');
+            }
+            return true;
+        });
+    }
+    calculateStats(fixes) {
+        const stats = {
+            total: fixes.length,
+            byType: {
+                'expression-format': 0,
+                'typeversion-correction': 0,
+                'error-output-config': 0,
+                'node-type-correction': 0,
+                'webhook-missing-path': 0
+            },
+            byConfidence: {
+                'high': 0,
+                'medium': 0,
+                'low': 0
+            }
+        };
+        for (const fix of fixes) {
+            stats.byType[fix.type]++;
+            stats.byConfidence[fix.confidence]++;
+        }
+        return stats;
+    }
+    generateSummary(stats) {
+        if (stats.total === 0) {
+            return 'No fixes available';
+        }
+        const parts = [];
+        if (stats.byType['expression-format'] > 0) {
+            parts.push(`${stats.byType['expression-format']} expression format ${stats.byType['expression-format'] === 1 ? 'error' : 'errors'}`);
+        }
+        if (stats.byType['typeversion-correction'] > 0) {
+            parts.push(`${stats.byType['typeversion-correction']} version ${stats.byType['typeversion-correction'] === 1 ? 'issue' : 'issues'}`);
+        }
+        if (stats.byType['error-output-config'] > 0) {
+            parts.push(`${stats.byType['error-output-config']} error output ${stats.byType['error-output-config'] === 1 ? 'configuration' : 'configurations'}`);
+        }
+        if (stats.byType['node-type-correction'] > 0) {
+            parts.push(`${stats.byType['node-type-correction']} node type ${stats.byType['node-type-correction'] === 1 ? 'correction' : 'corrections'}`);
+        }
+        if (stats.byType['webhook-missing-path'] > 0) {
+            parts.push(`${stats.byType['webhook-missing-path']} webhook ${stats.byType['webhook-missing-path'] === 1 ? 'path' : 'paths'}`);
+        }
+        if (parts.length === 0) {
+            return `Fixed ${stats.total} ${stats.total === 1 ? 'issue' : 'issues'}`;
+        }
+        return `Fixed ${parts.join(', ')}`;
+    }
+}
+exports.WorkflowAutoFixer = WorkflowAutoFixer;
+//# sourceMappingURL=workflow-auto-fixer.js.map