@path58/n8n-mcp 0.1.0

package/dist/validation/l4-connections.js

@@ -0,0 +1,698 @@
+/**
+ * L4 Connection Validator
+ *
+ * Validates workflow connection patterns against known patterns database
+ * and detects circular connections.
+ *
+ * Rules:
+ * - Unknown patterns are WARNINGS (passed: true)
+ * - Circular connections are ERRORS (passed: false)
+ *
+ * Performance target: <300ms for typical workflow (20 connections)
+ *
+ * Task: RAG-2.1.2
+ * Created: December 13, 2025
+ * Updated: January 20, 2026 (RAG-2.2.90.4: ICatalogCache integration)
+ */
+import { scraperQuery } from '../db/scraperPostgresClient.js';
+import { initRedisCatalogCache } from '../services/RedisCatalogCache.js';
+/** Maximum number of suggestions for unknown patterns */
+const SUGGESTION_LIMIT = 3;
+/** Singleton cache instance */
+let catalogCache = null;
+/**
+ * Get or initialize the catalog cache.
+ */
+async function getCatalogCache() {
+    if (!catalogCache) {
+        catalogCache = await initRedisCatalogCache();
+    }
+    return catalogCache;
+}
+/**
+ * Set a custom catalog cache (for testing with mocks).
+ * RAG-2.2.90.4: Added for unit testing without DB connection.
+ */
+export function setL4CatalogCache(cache) {
+    catalogCache = cache;
+}
+/**
+ * Reset the catalog cache (for testing).
+ * RAG-2.2.90.4: Added for unit testing cleanup.
+ */
+export function resetL4CatalogCache() {
+    catalogCache = null;
+}
+/** RAG-2.2.93.13: Global flag to skip loop pattern recording for faster validation */
+let skipLoopPatternRecording = false;
+/**
+ * RAG-2.2.93.13: Set whether to skip loop pattern recording
+ * Use this for batch validation runs where we don't need to record patterns
+ */
+export function setSkipLoopPatternRecording(skip) {
+    skipLoopPatternRecording = skip;
+}
+/**
+ * Validate workflow connection patterns
+ *
+ * @param workflow - Workflow to validate
+ * @returns Validation result with warnings for unknown patterns and errors for circular connections
+ */
+export async function validateL4Connections(workflow, workflowId) {
+    const startTime = Date.now();
+    const errors = [];
+    const warnings = [];
+    const circularPaths = [];
+    // Step 1: Extract all connection patterns from workflow
+    const { patterns, connectionCount } = extractConnectionPatterns(workflow);
+    // Step 2: Check for circular connections (BLOCKING - errors)
+    const { cycles, intentionalLoops } = detectCircularConnections(workflow);
+    // RAG-2.2.93.13: Skip recording for batch validation runs (avoids slow scraper DB connection)
+    if (intentionalLoops.length > 0 && !skipLoopPatternRecording) {
+        await recordIntentionalLoopPatterns(workflow, intentionalLoops, workflowId);
+    }
+    if (cycles.length > 0) {
+        circularPaths.push(...cycles);
+        errors.push({
+            code: 'CIRCULAR_CONNECTION',
+            message: `Detected ${cycles.length} circular connection(s)`,
+            details: {
+                cycles: cycles.map((cycle) => cycle.join(' → ')),
+            },
+        });
+    }
+    // Step 3: Get catalog cache for pattern validation
+    const cache = await getCatalogCache();
+    // Step 4: Validate patterns against cache (non-blocking - warnings)
+    const unknownPatterns = await validatePatterns(patterns, cache);
+    if (unknownPatterns.length > 0) {
+        for (const pattern of unknownPatterns) {
+            // Get suggestions for unknown patterns (RAG-2.2.90.4)
+            const suggestions = await getSuggestionsForPattern(pattern.source_node_type, cache);
+            const suggestionText = suggestions.length > 0
+                ? `. Did you mean: ${suggestions.join(', ')}?`
+                : '';
+            warnings.push({
+                code: 'UNKNOWN_PATTERN',
+                message: `Unknown connection pattern: ${pattern.source_node_type} → ${pattern.target_node_type}${suggestionText}`,
+                pattern: `${pattern.source_node_type}→${pattern.target_node_type}`,
+                source_type: pattern.source_node_type,
+                target_type: pattern.target_node_type,
+                suggestions: suggestions.length > 0 ? suggestions : undefined,
+            });
+        }
+    }
+    const duration_ms = Date.now() - startTime;
+    return {
+        passed: errors.length === 0, // Only circular connections cause failure
+        errors,
+        warnings,
+        duration_ms,
+        connection_count: connectionCount,
+        circular_paths: circularPaths,
+        unknown_patterns: unknownPatterns.map((p) => `${p.source_node_type}→${p.target_node_type}`),
+    };
+}
+/**
+ * Extract all connection patterns from workflow
+ */
+function extractConnectionPatterns(workflow) {
+    const patterns = [];
+    const patternSet = new Set(); // For deduplication
+    // Build node type map (name -> type)
+    const nodeTypeMap = new Map();
+    for (const node of workflow.nodes) {
+        nodeTypeMap.set(node.name, node.type);
+    }
+    let connectionCount = 0;
+    // Extract patterns from connections
+    for (const [sourceName, outputs] of Object.entries(workflow.connections)) {
+        const sourceType = nodeTypeMap.get(sourceName);
+        if (!sourceType) {
+            continue; // Skip if source node not found (caught by L1)
+        }
+        // Process main output connections
+        const mainOutputs = outputs?.main || [];
+        if (!Array.isArray(mainOutputs)) {
+            continue; // Skip if main is not an array
+        }
+        for (const outputGroup of mainOutputs) {
+            if (!Array.isArray(outputGroup)) {
+                continue; // Skip if outputGroup is not an array
+            }
+            for (const connection of outputGroup) {
+                if (!connection || typeof connection !== 'object') {
+                    continue; // Skip invalid connection objects
+                }
+                connectionCount++;
+                const targetType = nodeTypeMap.get(connection.node);
+                if (!targetType) {
+                    continue; // Skip if target node not found (caught by L1)
+                }
+                // Add pattern (deduplicated)
+                const patternKey = `${sourceType}→${targetType}`;
+                if (!patternSet.has(patternKey)) {
+                    patternSet.add(patternKey);
+                    patterns.push({
+                        source_node_type: sourceType,
+                        target_node_type: targetType,
+                    });
+                }
+            }
+        }
+    }
+    return { patterns, connectionCount };
+}
+/**
+ * Validate patterns against ICatalogCache
+ *
+ * Returns list of unknown patterns (not errors, just for reporting)
+ * RAG-2.2.90.4: Refactored to use cache.hasConnection instead of DB query
+ */
+async function validatePatterns(patterns, cache) {
+    if (patterns.length === 0) {
+        return [];
+    }
+    const unknownPatterns = [];
+    for (const pattern of patterns) {
+        const exists = await cache.hasConnection(pattern.source_node_type, pattern.target_node_type);
+        if (!exists) {
+            unknownPatterns.push(pattern);
+        }
+    }
+    return unknownPatterns;
+}
+/**
+ * Get suggestions for an unknown connection pattern.
+ * Returns the top N most common target node types from the same source.
+ * RAG-2.2.90.4: Added for "Did you mean?" suggestions
+ */
+async function getSuggestionsForPattern(sourceType, cache) {
+    const outgoing = await cache.getOutgoingConnections(sourceType);
+    if (outgoing.length === 0) {
+        return [];
+    }
+    // Sort by occurrence count (descending) and return top suggestions
+    return outgoing
+        .sort((a, b) => b.occurrence_count - a.occurrence_count)
+        .slice(0, SUGGESTION_LIMIT)
+        .map((c) => c.target_type);
+}
+/** Intentional loop node types that create valid cycles */
+const INTENTIONAL_LOOP_TYPES = new Set([
+    'n8n-nodes-base.splitInBatches',
+    'n8n-nodes-base.loop',
+]);
+/** Node types that indicate valid polling/retry patterns */
+const POLLING_RETRY_NODE_TYPES = new Set([
+    'n8n-nodes-base.wait',
+    'n8n-nodes-base.if',
+    'n8n-nodes-base.switch',
+]);
+/** Node types that indicate valid conversational/iterative patterns */
+const CONVERSATIONAL_NODE_TYPES = new Set([
+    '@n8n/n8n-nodes-langchain.agent',
+    'n8n-nodes-base.formTrigger',
+    'n8n-nodes-base.webhook',
+]);
+/**
+ * Build lookup maps for ID-based graph traversal
+ * RAG-2.2.106.2: Supports duplicate node names by using IDs as primary key
+ */
+function buildNodeLookupMaps(workflow) {
+    const idToType = new Map();
+    const idToName = new Map();
+    const nameToIds = new Map();
+    for (const node of workflow.nodes) {
+        idToType.set(node.id, node.type);
+        idToName.set(node.id, node.name);
+        const existingIds = nameToIds.get(node.name) || [];
+        existingIds.push(node.id);
+        nameToIds.set(node.name, existingIds);
+    }
+    return { idToType, idToName, nameToIds };
+}
+/**
+ * Build a map of node names to their types (legacy, kept for compatibility)
+ * @deprecated Use buildNodeLookupMaps instead for ID-based traversal
+ */
+function buildNodeTypeMap(workflow) {
+    const map = new Map();
+    for (const node of workflow.nodes) {
+        map.set(node.name, node.type);
+    }
+    return map;
+}
+/**
+ * Check if cycle contains a Wait/delay node
+ */
+function hasWaitNode(cycleNodeTypes) {
+    return cycleNodeTypes.includes('n8n-nodes-base.wait');
+}
+/**
+ * Check if cycle contains If/Switch conditional nodes
+ */
+function hasConditionalNode(cycleNodeTypes) {
+    return cycleNodeTypes.some((type) => type === 'n8n-nodes-base.if' || type === 'n8n-nodes-base.switch');
+}
+/**
+ * Check if cycle represents a status polling pattern
+ */
+function isStatusPollingPattern(cycleLower, hasWait) {
+    if (!hasWait)
+        return false;
+    const statusKeywords = ['status', 'check', 'verify', 'complete', 'ready', 'progress'];
+    return statusKeywords.some((kw) => cycleLower.includes(kw));
+}
+/**
+ * Check if cycle represents a result polling pattern
+ */
+function isResultPollingPattern(cycleLower, hasWait) {
+    if (!hasWait)
+        return false;
+    return cycleLower.includes('get results') ||
+        cycleLower.includes('get result') ||
+        cycleLower.includes('get status');
+}
+/**
+ * Check if cycle represents an AI agent conversational loop
+ */
+function isAgentLoopPattern(cycleNodeTypes, cycleLower, cycleLength) {
+    if (cycleLength < 3)
+        return false;
+    return cycleNodeTypes.some((type) => type === '@n8n/n8n-nodes-langchain.agent' || type?.includes('agent')) || cycleLower.includes('agent');
+}
+/**
+ * Check if cycle represents a form validation retry pattern
+ */
+function isFormRetryPattern(cycleNodeTypes, cycleLower) {
+    const hasFormNode = cycleNodeTypes.some((type) => type === 'n8n-nodes-base.formTrigger' || type === 'n8n-nodes-base.webhook');
+    if (!hasFormNode)
+        return false;
+    const formKeywords = ['form', 'validation', 'retry', 'reenter', 'correct'];
+    return formKeywords.some((kw) => cycleLower.includes(kw));
+}
+/** Node types used for code-based iteration control */
+const CODE_ITERATION_NODE_TYPES = new Set([
+    'n8n-nodes-base.code',
+    'n8n-nodes-base.set',
+]);
+/** Keywords indicating intentional iteration patterns (from L4_ITERATIVE_LOOP_PATTERNS.md) */
+const ITERATION_KEYWORDS = [
+    // Loop control keywords
+    'loop', 'vars', 'iteration', 'step', 'next', 'retry', 'cycle',
+    // Validation keywords
+    'check', 'validate', 'verify', 'status', 'poll',
+    // Content generation keywords
+    'generate', 'create', 'planner',
+    // Human-in-the-loop keywords
+    'approval', 'review', 'feedback', 'revision', 'human',
+    // Router/command keywords
+    'router', 'responder', 'command',
+    // Data processing keywords (common in ETL/sync workflows)
+    'refresh', 'token', 'download', 'upload', 'load', 'merge', 'extract',
+    // Conditional loop keywords
+    'exists', 'invalid', 'complete', 'loaded', 'open', 'all', 'finished',
+    // Pagination/cursor keywords
+    'page', 'cursor', 'increment', 'more', 'list', 'get',
+    // Sync/update keywords
+    'sync', 'update', 'clear', 'duplicate', 'rename', 'set',
+    // Automation/deployment keywords
+    'docker', 'compose', 'pull', 'image', 'deploy', 'approve', 'notif',
+    // Audio/voice processing keywords
+    'voice', 'audio', 'fetch', 'text', 'speech', 'tts',
+];
+/**
+ * Check if cycle represents a code-based iteration pattern
+ *
+ * These are intentional loops that use IF/Switch + Code/Set nodes instead of
+ * explicit loop nodes. Common in n8n.io published workflows.
+ *
+ * See: docs/validation/levels/l4/L4_ITERATIVE_LOOP_PATTERNS.md
+ */
+function isCodeBasedIterationPattern(cycle, nodeTypeMap) {
+    const cycleNodeTypes = cycle.map((name) => nodeTypeMap.get(name)).filter(Boolean);
+    const cycleLower = cycle.join(' → ').toLowerCase();
+    // Pattern 1: Has IF/Switch node + iteration keywords
+    const hasIfNode = cycleNodeTypes.some((t) => t === 'n8n-nodes-base.if' || t === 'n8n-nodes-base.switch');
+    const hasIterationKeyword = ITERATION_KEYWORDS.some((kw) => cycleLower.includes(kw));
+    if (hasIfNode && hasIterationKeyword) {
+        return true;
+    }
+    // Pattern 2: Has Code/Set nodes for loop control (vars pattern)
+    const hasCodeIteration = cycleNodeTypes.some((t) => CODE_ITERATION_NODE_TYPES.has(t));
+    const hasVarsPattern = cycleLower.includes('vars') || cycleLower.includes('parameters');
+    if (hasCodeIteration && hasVarsPattern) {
+        return true;
+    }
+    // Pattern 3: Status polling pattern (Get + Check/Status + IF)
+    const hasGetAndCheck = cycleLower.includes('get') &&
+        (cycleLower.includes('status') || cycleLower.includes('check'));
+    if (hasGetAndCheck && hasIfNode) {
+        return true;
+    }
+    // Pattern 4: Self-loop (same node name repeated) - often Airtable/table patterns
+    // Example: "Table: Tools → Table: Tools"
+    if (cycle.length === 2 && cycle[0] === cycle[cycle.length - 1]) {
+        return true;
+    }
+    // Pattern 5: AI/LLM chain patterns
+    const hasAiChain = cycleLower.includes('chain') ||
+        cycleLower.includes('summariz') ||
+        cycleLower.includes('ai ') ||
+        cycleLower.includes('llm') ||
+        cycleLower.includes('gpt');
+    if (hasAiChain) {
+        return true;
+    }
+    // Pattern 6: Any cycle with IF node (conservative fallback for published n8n.io workflows)
+    // These are almost always intentional - IF nodes control loop termination
+    if (hasIfNode) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if a cycle is a valid polling/retry pattern
+ */
+function isPollingOrRetryPattern(cycle, nodeTypeMap) {
+    const cycleLower = cycle.join(' → ').toLowerCase();
+    const cycleNodeTypes = cycle.map((name) => nodeTypeMap.get(name)).filter(Boolean);
+    const hasWait = hasWaitNode(cycleNodeTypes);
+    return (isStatusPollingPattern(cycleLower, hasWait) ||
+        (hasConditionalNode(cycleNodeTypes) && hasWait) ||
+        isResultPollingPattern(cycleLower, hasWait) ||
+        hasWait ||
+        isAgentLoopPattern(cycleNodeTypes, cycleLower, cycle.length) ||
+        isFormRetryPattern(cycleNodeTypes, cycleLower) ||
+        isCodeBasedIterationPattern(cycle, nodeTypeMap));
+}
+/**
+ * Build ID-based adjacency list from workflow connections
+ * RAG-2.2.106.2: Uses node IDs to correctly handle duplicate node names
+ *
+ * n8n connections use node NAMES as keys, but we need to resolve them to IDs
+ * for correct graph traversal when duplicate names exist.
+ *
+ * @returns Graph keyed by node ID, with arrays of target node IDs
+ */
+function buildConnectionGraph(workflow, nameToIds) {
+    const graph = new Map();
+    // Initialize graph with all node IDs
+    for (const node of workflow.nodes) {
+        graph.set(node.id, []);
+    }
+    // Track which node ID we're currently at for each name (for sequential connections)
+    const nameConnectionIndex = new Map();
+    for (const [sourceName, outputs] of Object.entries(workflow.connections)) {
+        const sourceIds = nameToIds.get(sourceName);
+        if (!sourceIds || sourceIds.length === 0)
+            continue;
+        // Get the source node ID - use index for duplicate names
+        const sourceIndex = nameConnectionIndex.get(sourceName) || 0;
+        const sourceId = sourceIds[Math.min(sourceIndex, sourceIds.length - 1)];
+        const mainOutputs = outputs?.main || [];
+        if (!Array.isArray(mainOutputs))
+            continue;
+        for (const outputGroup of mainOutputs) {
+            if (!Array.isArray(outputGroup))
+                continue;
+            for (const connection of outputGroup) {
+                if (!connection || typeof connection !== 'object' || !connection.node)
+                    continue;
+                const targetName = connection.node;
+                const targetIds = nameToIds.get(targetName);
+                if (!targetIds || targetIds.length === 0)
+                    continue;
+                // Resolve target: if same name as source, use next ID; otherwise use first
+                let targetId;
+                if (targetName === sourceName && targetIds.length > 1) {
+                    // Connection to same-named node: pick the next one in sequence
+                    const nextIndex = (sourceIndex + 1) % targetIds.length;
+                    targetId = targetIds[nextIndex];
+                }
+                else {
+                    // Different name or only one node: use first matching ID
+                    targetId = targetIds[0];
+                }
+                const targets = graph.get(sourceId) || [];
+                targets.push(targetId);
+                graph.set(sourceId, targets);
+            }
+        }
+    }
+    return graph;
+}
+/**
+ * Find the loop-enabling node in a cycle for valid patterns
+ */
+function findLoopEnablingNode(cycle, nodeTypeMap) {
+    // First check for explicit loop nodes
+    for (const nodeName of cycle) {
+        const nodeType = nodeTypeMap.get(nodeName);
+        if (nodeType && INTENTIONAL_LOOP_TYPES.has(nodeType)) {
+            return { loopNodeType: nodeType, loopNodeName: nodeName };
+        }
+    }
+    // Check for polling/retry/conversational nodes
+    for (const nodeName of cycle) {
+        const nodeType = nodeTypeMap.get(nodeName);
+        if (nodeType && (POLLING_RETRY_NODE_TYPES.has(nodeType) || CONVERSATIONAL_NODE_TYPES.has(nodeType))) {
+            return { loopNodeType: nodeType, loopNodeName: nodeName };
+        }
+    }
+    // Check for agent nodes by name
+    for (const nodeName of cycle) {
+        const nodeType = nodeTypeMap.get(nodeName);
+        if (nodeType && (nodeType.includes('agent') || nodeName.toLowerCase().includes('agent'))) {
+            return { loopNodeType: nodeType, loopNodeName: nodeName };
+        }
+    }
+    return null;
+}
+/**
+ * Classify a detected cycle as intentional or erroneous
+ */
+function classifyCycle(cycle, nodeTypeMap) {
+    // Check for explicit loop nodes first
+    for (const nodeName of cycle) {
+        const nodeType = nodeTypeMap.get(nodeName);
+        if (nodeType && INTENTIONAL_LOOP_TYPES.has(nodeType)) {
+            return {
+                isIntentional: true,
+                loopInfo: { cycle, loopNodeType: nodeType, loopNodeName: nodeName },
+            };
+        }
+    }
+    // Check for polling/retry patterns
+    if (isPollingOrRetryPattern(cycle, nodeTypeMap)) {
+        const loopNode = findLoopEnablingNode(cycle, nodeTypeMap);
+        if (loopNode) {
+            return {
+                isIntentional: true,
+                loopInfo: { cycle, ...loopNode },
+            };
+        }
+    }
+    return { isIntentional: false, loopInfo: null };
+}
+/**
+ * Detect circular connections using Depth-First Search (DFS)
+ * RAG-2.2.106.2: Uses node IDs for graph traversal to handle duplicate names
+ *
+ * Returns object with:
+ * - cycles: Array of invalid circular paths (node names for user-friendly output)
+ * - intentionalLoops: Array of valid intentional loop patterns (to record)
+ *
+ * NOTE: Cycles that include intentional loop nodes (SplitInBatches, Loop, etc.)
+ * are considered VALID and are filtered out, as these are intentional patterns
+ * for batch processing and iteration.
+ */
+function detectCircularConnections(workflow) {
+    const nodeTypeMap = buildNodeTypeMap(workflow);
+    const lookupMaps = buildNodeLookupMaps(workflow);
+    const graph = buildConnectionGraph(workflow, lookupMaps.nameToIds);
+    const visited = new Set();
+    const recursionStack = new Set();
+    const currentPath = []; // Stores node IDs during traversal
+    const cycles = [];
+    const intentionalLoops = [];
+    /**
+     * Convert a cycle of node IDs to node names for user-friendly output
+     */
+    function cycleIdsToNames(cycleIds) {
+        return cycleIds.map((id) => lookupMaps.idToName.get(id) || id);
+    }
+    function dfs(nodeId) {
+        visited.add(nodeId);
+        recursionStack.add(nodeId);
+        currentPath.push(nodeId);
+        for (const neighborId of graph.get(nodeId) || []) {
+            if (!visited.has(neighborId)) {
+                dfs(neighborId);
+            }
+            else if (recursionStack.has(neighborId)) {
+                const cycleStartIndex = currentPath.indexOf(neighborId);
+                if (cycleStartIndex !== -1) {
+                    const cycleIds = [...currentPath.slice(cycleStartIndex), neighborId];
+                    // Convert IDs to names for classification and output
+                    const cycleNames = cycleIdsToNames(cycleIds);
+                    const { isIntentional, loopInfo } = classifyCycle(cycleNames, nodeTypeMap);
+                    if (isIntentional && loopInfo) {
+                        intentionalLoops.push(loopInfo);
+                    }
+                    else {
+                        cycles.push(cycleNames);
+                    }
+                }
+            }
+        }
+        recursionStack.delete(nodeId);
+        currentPath.pop();
+    }
+    // Start DFS from each node (using node IDs)
+    for (const node of workflow.nodes) {
+        if (!visited.has(node.id)) {
+            dfs(node.id);
+        }
+    }
+    return { cycles, intentionalLoops };
+}
+/**
+ * Extract workflow ID from various possible locations
+ */
+function extractWorkflowId(workflow, providedId) {
+    return providedId ||
+        workflow.id ||
+        workflow.workflow_id ||
+        workflow.meta?.workflowId ||
+        null;
+}
+/**
+ * Build loop pattern metadata for database recording
+ */
+function buildLoopPatternData(loop, nodeTypeMap) {
+    const cycleNodeTypes = loop.cycle.map((name) => nodeTypeMap.get(name) || 'unknown');
+    const patternSignature = loop.cycle.join(' → ');
+    const useCase = getLoopUseCase(loop.loopNodeType, cycleNodeTypes);
+    const description = `Intentional loop pattern using ${loop.loopNodeType}. ${useCase}`;
+    const searchText = [patternSignature, loop.loopNodeType, ...cycleNodeTypes, useCase, description].join(' ');
+    return { patternSignature, cycleNodeTypes, useCase, description, searchText };
+}
+/** SQL query for upserting intentional loop patterns */
+const UPSERT_LOOP_PATTERN_QUERY = `
+  INSERT INTO factory.intentional_loop_patterns (
+    pattern_signature, cycle_path, cycle_node_types, loop_node_type,
+    loop_node_name, pattern_description, use_case, occurrence_count,
+    first_seen_at, last_seen_at, example_workflow_ids, search_text
+  ) VALUES ($1, $2, $3, $4, $5, $6, $7, 1, NOW(), NOW(), ARRAY[]::TEXT[], $8)
+  ON CONFLICT (pattern_signature) DO UPDATE SET
+    occurrence_count = intentional_loop_patterns.occurrence_count + 1,
+    last_seen_at = NOW(),
+    example_workflow_ids = CASE
+      WHEN $9::text IS NULL THEN intentional_loop_patterns.example_workflow_ids
+      WHEN $9::text = ANY(intentional_loop_patterns.example_workflow_ids)
+        THEN intentional_loop_patterns.example_workflow_ids
+      ELSE array_append(intentional_loop_patterns.example_workflow_ids, $9::text)
+    END
+`;
+/**
+ * Record a single intentional loop pattern to database
+ */
+async function recordSingleLoopPattern(loop, nodeTypeMap, workflowId) {
+    const { patternSignature, cycleNodeTypes, useCase, description, searchText } = buildLoopPatternData(loop, nodeTypeMap);
+    try {
+        await scraperQuery(UPSERT_LOOP_PATTERN_QUERY, [
+            patternSignature,
+            JSON.stringify(loop.cycle),
+            JSON.stringify(cycleNodeTypes),
+            loop.loopNodeType,
+            loop.loopNodeName,
+            description,
+            useCase,
+            searchText,
+            workflowId,
+        ]);
+    }
+    catch (error) {
+        console.warn(`Failed to record intentional loop pattern: ${error}`);
+    }
+}
+/**
+ * Record intentional loop patterns to database for future workflow building
+ */
+async function recordIntentionalLoopPatterns(workflow, intentionalLoops, workflowId) {
+    if (intentionalLoops.length === 0)
+        return;
+    const nodeTypeMap = buildNodeTypeMap(workflow);
+    const finalWorkflowId = extractWorkflowId(workflow, workflowId);
+    for (const loop of intentionalLoops) {
+        await recordSingleLoopPattern(loop, nodeTypeMap, finalWorkflowId);
+    }
+}
+/**
+ * Determine use case for intentional loop pattern
+ */
+function getLoopUseCase(loopNodeType, cycleNodeTypes) {
+    const hasWait = cycleNodeTypes.includes('n8n-nodes-base.wait');
+    const hasHttp = cycleNodeTypes.some(t => t.includes('httpRequest') || t.includes('http'));
+    const hasCode = cycleNodeTypes.includes('n8n-nodes-base.code');
+    const hasIf = cycleNodeTypes.includes('n8n-nodes-base.if');
+    const hasSwitch = cycleNodeTypes.includes('n8n-nodes-base.switch');
+    const cycleTypesStr = cycleNodeTypes.join(' ').toLowerCase();
+    // Polling/retry patterns
+    if (loopNodeType === 'n8n-nodes-base.wait') {
+        if (cycleTypesStr.includes('status') || cycleTypesStr.includes('check') || cycleTypesStr.includes('verify')) {
+            return 'Polling pattern: Wait and check status until complete';
+        }
+        if (hasIf || hasSwitch) {
+            return 'Conditional retry pattern: Wait and retry based on condition';
+        }
+        if (cycleTypesStr.includes('get results') || cycleTypesStr.includes('get status') || cycleTypesStr.includes('get result')) {
+            return 'Result polling pattern: Wait and poll for results';
+        }
+        return 'Polling/retry pattern with wait delays';
+    }
+    // AI Agent conversational patterns
+    if (loopNodeType === '@n8n/n8n-nodes-langchain.agent' || loopNodeType?.includes('agent')) {
+        if (cycleTypesStr.includes('interview') || cycleTypesStr.includes('conversation')) {
+            return 'Conversational AI pattern: Multi-turn agent conversations';
+        }
+        if (cycleTypesStr.includes('evaluator') || cycleTypesStr.includes('optimizer')) {
+            return 'AI agent orchestration pattern: Iterative agent refinement';
+        }
+        return 'AI agent conversational loop pattern';
+    }
+    // Form validation retry patterns
+    if (loopNodeType === 'n8n-nodes-base.formTrigger' || loopNodeType === 'n8n-nodes-base.webhook') {
+        if (cycleTypesStr.includes('validation') || cycleTypesStr.includes('retry') || cycleTypesStr.includes('reenter')) {
+            return 'Form validation retry pattern: User re-enters data until valid';
+        }
+        return 'Form/webhook retry pattern';
+    }
+    // Conditional retry patterns
+    if (loopNodeType === 'n8n-nodes-base.if' || loopNodeType === 'n8n-nodes-base.switch') {
+        if (hasWait) {
+            return 'Conditional retry pattern: Retry with delay based on condition';
+        }
+        return 'Conditional loop pattern';
+    }
+    // Explicit loop nodes
+    if (loopNodeType === 'n8n-nodes-base.splitInBatches') {
+        if (hasWait && hasHttp) {
+            return 'Batch processing with rate limiting for API calls';
+        }
+        if (hasWait) {
+            return 'Batch processing with rate limiting';
+        }
+        if (hasHttp) {
+            return 'Batch processing for API calls';
+        }
+        return 'Batch processing and iteration';
+    }
+    if (loopNodeType === 'n8n-nodes-base.loop') {
+        return 'Explicit loop iteration';
+    }
+    return 'Intentional loop pattern';
+}
+//# sourceMappingURL=l4-connections.js.map