@atom8n/ai-workflow-builder 1.4.3 → 1.5.1

package/dist/validation/auto-fix/auto-fix-connections.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoFixConnections = autoFixConnections;
+const connection_utils_1 = require("../../tools/utils/connection.utils");
+const node_helpers_1 = require("../../utils/node-helpers");
+const node_type_map_1 = require("../../validation/utils/node-type-map");
+const resolve_connections_1 = require("../../validation/utils/resolve-connections");
+function findExistingOutgoingConnection(connections, nodeName, connectionType) {
+    const nodeConnections = connections[nodeName];
+    if (!nodeConnections)
+        return false;
+    const typeConnections = nodeConnections[connectionType];
+    if (!typeConnections)
+        return false;
+    return typeConnections.some((connArray) => connArray && connArray.length > 0);
+}
+function connectionExistsBetweenNodes(connections, sourceNodeName, targetNodeName, connectionType) {
+    const nodeConnections = connections[sourceNodeName];
+    if (!nodeConnections)
+        return false;
+    const typeConnections = nodeConnections[connectionType];
+    if (!typeConnections)
+        return false;
+    return typeConnections.some((connArray) => connArray?.some((conn) => conn.node === targetNodeName));
+}
+function checkNodeHasInputConnection(connections, targetNodeName, connectionType) {
+    for (const [, nodeConns] of Object.entries(connections)) {
+        const typeConns = nodeConns[connectionType];
+        if (!typeConns)
+            continue;
+        for (const connArray of typeConns) {
+            if (connArray?.some((conn) => conn.node === targetNodeName)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function buildSubNodeOutputsMap(workflow, nodeTypeMap, nodeTypesByName) {
+    const subNodeOutputs = new Map();
+    for (const node of workflow.nodes) {
+        if (node.disabled)
+            continue;
+        const nodeType = (0, node_type_map_1.getNodeTypeForNode)(node, nodeTypeMap, nodeTypesByName);
+        if (!nodeType)
+            continue;
+        if ((0, node_helpers_1.isSubNode)(nodeType, node)) {
+            try {
+                const nodeInfo = { node, nodeType };
+                const outputs = (0, resolve_connections_1.resolveNodeOutputs)(nodeInfo);
+                if (outputs.size > 0) {
+                    subNodeOutputs.set(node.name, outputs);
+                }
+            }
+            catch {
+            }
+        }
+    }
+    return subNodeOutputs;
+}
+function findCandidateSubNodes(ctx, targetNodeName, missingType) {
+    const candidates = [];
+    for (const [subNodeName, outputs] of ctx.subNodeOutputs) {
+        if (outputs.has(missingType)) {
+            const alreadyConnectedToTarget = connectionExistsBetweenNodes(ctx.result.updatedConnections, subNodeName, targetNodeName, missingType);
+            if (!alreadyConnectedToTarget) {
+                candidates.push(subNodeName);
+            }
+        }
+    }
+    return candidates;
+}
+function processMissingInputViolation(ctx, violation) {
+    const nodeName = violation.metadata?.nodeName;
+    const missingType = violation.metadata?.missingType;
+    if (!nodeName || !missingType)
+        return;
+    const targetNode = ctx.nodesByName.get(nodeName);
+    if (!targetNode || targetNode.disabled)
+        return;
+    if (!missingType.startsWith('ai_'))
+        return;
+    const candidates = findCandidateSubNodes(ctx, nodeName, missingType);
+    if (candidates.length === 1) {
+        const sourceNodeName = candidates[0];
+        ctx.result.updatedConnections = (0, connection_utils_1.createConnection)(ctx.result.updatedConnections, sourceNodeName, nodeName, missingType, 0, 0);
+        ctx.connectedSubNodes.add(sourceNodeName);
+        ctx.result.fixed.push({
+            sourceNodeName,
+            targetNodeName: nodeName,
+            connectionType: missingType,
+            reason: `Auto-connected orphaned sub-node to target requiring ${missingType}`,
+        });
+    }
+    else if (candidates.length === 0) {
+        ctx.result.unfixable.push({
+            nodeName,
+            missingInputType: missingType,
+            reason: `No available sub-node provides ${missingType}`,
+            candidateCount: 0,
+        });
+    }
+    else {
+        ctx.result.unfixable.push({
+            nodeName,
+            missingInputType: missingType,
+            reason: `Multiple sub-nodes (${candidates.join(', ')}) can provide ${missingType} - ambiguous`,
+            candidateCount: candidates.length,
+        });
+    }
+}
+function findTargetCandidates(ctx, subNodeName, outputType) {
+    const targetCandidates = [];
+    for (const node of ctx.workflow.nodes) {
+        if (node.disabled || node.name === subNodeName)
+            continue;
+        const nodeType = (0, node_type_map_1.getNodeTypeForNode)(node, ctx.nodeTypeMap, ctx.nodeTypesByName);
+        if (!nodeType)
+            continue;
+        if ((0, node_helpers_1.isSubNode)(nodeType, node))
+            continue;
+        try {
+            const nodeInfo = { node, nodeType };
+            const inputs = (0, resolve_connections_1.resolveNodeInputs)(nodeInfo);
+            const acceptsType = inputs.some((input) => input.type === outputType);
+            if (acceptsType) {
+                const hasConnection = checkNodeHasInputConnection(ctx.result.updatedConnections, node.name, outputType);
+                if (!hasConnection) {
+                    targetCandidates.push(node.name);
+                }
+            }
+        }
+        catch {
+        }
+    }
+    return targetCandidates;
+}
+function processDisconnectedSubNodeViolation(ctx, violation) {
+    const subNodeName = violation.metadata?.nodeName;
+    const outputType = violation.metadata?.outputType;
+    if (!subNodeName || !outputType)
+        return;
+    const subNode = ctx.nodesByName.get(subNodeName);
+    if (!subNode || subNode.disabled)
+        return;
+    if (ctx.connectedSubNodes.has(subNodeName))
+        return;
+    const nowConnected = findExistingOutgoingConnection(ctx.result.updatedConnections, subNodeName, outputType);
+    if (nowConnected)
+        return;
+    const targetCandidates = findTargetCandidates(ctx, subNodeName, outputType);
+    if (targetCandidates.length === 1) {
+        const targetNodeName = targetCandidates[0];
+        ctx.result.updatedConnections = (0, connection_utils_1.createConnection)(ctx.result.updatedConnections, subNodeName, targetNodeName, outputType, 0, 0);
+        ctx.connectedSubNodes.add(subNodeName);
+        ctx.result.fixed.push({
+            sourceNodeName: subNodeName,
+            targetNodeName,
+            connectionType: outputType,
+            reason: 'Auto-connected disconnected sub-node to only available target',
+        });
+    }
+    else if (targetCandidates.length === 0) {
+        ctx.result.unfixable.push({
+            nodeName: subNodeName,
+            missingInputType: outputType,
+            reason: `No target node accepts ${outputType} input`,
+            candidateCount: 0,
+        });
+    }
+    else {
+        ctx.result.unfixable.push({
+            nodeName: subNodeName,
+            missingInputType: outputType,
+            reason: `Multiple targets (${targetCandidates.join(', ')}) accept ${outputType} - ambiguous`,
+            candidateCount: targetCandidates.length,
+        });
+    }
+}
+function autoFixConnections(workflow, nodeTypes, violations) {
+    const { nodeTypeMap, nodeTypesByName } = (0, node_type_map_1.createNodeTypeMaps)(nodeTypes);
+    const nodesByName = new Map(workflow.nodes.map((node) => [node.name, node]));
+    const subNodeOutputs = buildSubNodeOutputsMap(workflow, nodeTypeMap, nodeTypesByName);
+    const ctx = {
+        result: {
+            fixed: [],
+            unfixable: [],
+            updatedConnections: structuredClone(workflow.connections ?? {}),
+        },
+        nodeTypeMap,
+        nodeTypesByName,
+        nodesByName,
+        subNodeOutputs,
+        connectedSubNodes: new Set(),
+        workflow,
+    };
+    const missingInputViolations = violations.filter((v) => v.name === 'node-missing-required-input');
+    for (const violation of missingInputViolations) {
+        processMissingInputViolation(ctx, violation);
+    }
+    const disconnectedSubNodeViolations = violations.filter((v) => v.name === 'sub-node-not-connected');
+    for (const violation of disconnectedSubNodeViolations) {
+        processDisconnectedSubNodeViolation(ctx, violation);
+    }
+    return ctx.result;
+}

package/dist/validation/auto-fix/index.d.ts

@@ -0,0 +1,2 @@
+export { autoFixConnections } from './auto-fix-connections';
+export type { AutoFixResult, AutoFixedConnection, UnfixableConnection, } from './auto-fix-connections';

package/dist/validation/auto-fix/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoFixConnections = void 0;
+var auto_fix_connections_1 = require("./auto-fix-connections");
+Object.defineProperty(exports, "autoFixConnections", { enumerable: true, get: function () { return auto_fix_connections_1.autoFixConnections; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom8n/ai-workflow-builder",
-  "version": "1.4.3",
+  "version": "1.5.1",
   "scripts": {
     "clean": "rimraf dist .turbo",
     "typecheck": "tsc --noEmit",
@@ -53,20 +53,20 @@
     "@langchain/core": "1.1.0",
     "@langchain/langgraph": "1.0.2",
     "@langchain/openai": "1.1.3",
-    "@n8n/backend-common": "npm:@atom8n/backend-common@1.4.4",
-    "@n8n/config": "npm:@atom8n/config@2.3.3",
-    "@n8n/di": "npm:@atom8n/di@0.12.3",
-    "@n8n/utils": "npm:@atom8n/utils@1.23.3",
+    "@n8n/backend-common": "npm:@atom8n/backend-common@1.5.1",
+    "@n8n/config": "npm:@atom8n/config@2.4.1",
+    "@n8n/di": "npm:@atom8n/di@0.13.1",
+    "@n8n/utils": "npm:@atom8n/utils@1.24.1",
     "@n8n_io/ai-assistant-sdk": "1.19.1",
     "csv-parse": "5.5.0",
     "langsmith": "^0.3.45",
     "lodash": "4.17.21",
-    "n8n-workflow": "npm:@atom8n/n8n-workflow@2.4.3",
+    "n8n-workflow": "npm:@atom8n/n8n-workflow@2.5.1",
     "picocolors": "1.0.1",
     "zod": "3.25.67"
   },
   "devDependencies": {
-    "@n8n/typescript-config": "npm:@atom8n/typescript-config@1.5.3",
+    "@n8n/typescript-config": "npm:@atom8n/typescript-config@1.6.1",
     "@types/cli-progress": "^3.11.5",
     "cli-progress": "^3.12.0",
     "cli-table3": "^0.6.3",