digitalsee-ai-flow-cli 0.1.7 → 0.1.8

package/dist/services/flowAnalyzer.js

@@ -3,22 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeFlow = analyzeFlow;
 exports.formatNodeType = formatNodeType;
 const NODE_TYPE_LABELS = {
-    StartEventNode: "触发器",
-    ActionNode: "动作",
-    ConditionNode: "条件",
-    LoopNode: "循环",
-    SelfLoopNode: "自循环",
-    SwitchNode: "分支",
-    EndNode: "结束",
-    AgentNode: "AI Agent",
-    AISubNode: "AI 子节点",
-    BrowserNode: "浏览器",
-    MCPServerNode: "MCP 服务",
-    BuiltinMCPNode: "内置 MCP",
-    MCPToolNode: "MCP 工具",
-    VectorStoreNode: "向量存储",
-    StickyNoteNode: "便签",
-    START: "开始",
+    StartEventNode: '触发器',
+    ActionNode: '动作',
+    ConditionNode: '条件',
+    LoopNode: '循环',
+    SelfLoopNode: '自循环',
+    SwitchNode: '分支',
+    EndNode: '结束',
+    AgentNode: 'AI Agent',
+    AISubNode: 'AI 子节点',
+    BrowserNode: '浏览器',
+    MCPServerNode: 'MCP 服务',
+    BuiltinMCPNode: '内置 MCP',
+    MCPToolNode: 'MCP 工具',
+    VectorStoreNode: '向量存储',
+    StickyNoteNode: '便签',
+    START: '开始',
 };
 function analyzeFlow(flow) {
     const { nodes = [], edges = [] } = flow;
@@ -35,8 +35,8 @@ function analyzeFlow(flow) {
         };
     }
     for (const edge of edges) {
-        const source = edge.source || "";
-        const target = edge.target || "";
+        const source = edge.source || '';
+        const target = edge.target || '';
         if (adj[source]) {
             adj[source].outgoing.push(target);
         }
@@ -45,7 +45,11 @@ function analyzeFlow(flow) {
             adj[target].inDegree++;
         }
     }
-    const executionOrder = topologicalSort(adj);
+    const nodeIndexMap = new Map();
+    nodes.forEach((node, i) => {
+        nodeIndexMap.set(node.n_id || node.id, i);
+    });
+    const executionOrder = topologicalSort(adj, nodeIndexMap);
     const nodeGroups = groupNodes(nodes);
     const dependencyGraph = renderDependencyGraph(adj, executionOrder);
     const flowchart = renderAsciiFlowchart(adj, executionOrder);
@@ -68,8 +72,16 @@ function analyzeFlow(flow) {
         flowchart,
     };
 }
-function topologicalSort(adj) {
-    const inDegree = { ...Object.fromEntries(Object.entries(adj).map(([id, info]) => [id, info.inDegree])) };
+function isTriggerNode(node) {
+    const type = node.node_type || 'ActionNode';
+    return (type === 'StartEventNode' ||
+        type === 'START' ||
+        (node.connector_name?.toLowerCase().includes('webhook') ?? false));
+}
+function topologicalSort(adj, nodeIndexMap) {
+    const inDegree = {
+        ...Object.fromEntries(Object.entries(adj).map(([id, info]) => [id, info.inDegree])),
+    };
     const queue = [];
     for (const [id, degree] of Object.entries(inDegree)) {
         if (degree === 0) {
@@ -78,7 +90,17 @@ function topologicalSort(adj) {
     }
     const result = [];
     while (queue.length > 0) {
-        queue.sort();
+        queue.sort((a, b) => {
+            const aTrigger = isTriggerNode(adj[a].node);
+            const bTrigger = isTriggerNode(adj[b].node);
+            if (aTrigger && !bTrigger)
+                return -1;
+            if (!aTrigger && bTrigger)
+                return 1;
+            const aIdx = nodeIndexMap.get(a) ?? Infinity;
+            const bIdx = nodeIndexMap.get(b) ?? Infinity;
+            return aIdx - bIdx;
+        });
         const current = queue.shift();
         result.push(current);
         for (const next of adj[current]?.outgoing || []) {
@@ -88,6 +110,12 @@ function topologicalSort(adj) {
             }
         }
     }
+    // Include remaining nodes (in cycles) so they appear in graph/flowchart output
+    const remaining = Object.entries(inDegree)
+        .filter(([, d]) => d > 0)
+        .map(([id]) => id)
+        .sort((a, b) => (nodeIndexMap.get(a) ?? Infinity) - (nodeIndexMap.get(b) ?? Infinity));
+    result.push(...remaining);
     return result;
 }
 function groupNodes(nodes) {
@@ -100,31 +128,29 @@ function groupNodes(nodes) {
         others: [],
     };
     for (const node of nodes) {
-        const type = node.node_type || "ActionNode";
-        if (type === "StartEventNode" ||
-            type === "START" ||
-            node.connector_name?.toLowerCase().includes("webhook")) {
+        const type = node.node_type || 'ActionNode';
+        if (isTriggerNode(node)) {
             groups.triggers.push(node);
         }
-        else if (type === "ConditionNode") {
+        else if (type === 'ConditionNode') {
             groups.conditions.push(node);
         }
-        else if (type === "SwitchNode") {
+        else if (type === 'SwitchNode') {
             groups.conditions.push(node);
         }
-        else if (type === "LoopNode" || type === "SelfLoopNode") {
+        else if (type === 'LoopNode' || type === 'SelfLoopNode') {
             groups.loops.push(node);
         }
-        else if (type === "AgentNode" ||
-            type === "AISubNode" ||
-            type === "BrowserNode" ||
-            type === "VectorStoreNode" ||
-            type === "MCPServerNode" ||
-            type === "BuiltinMCPNode" ||
-            type === "MCPToolNode") {
+        else if (type === 'AgentNode' ||
+            type === 'AISubNode' ||
+            type === 'BrowserNode' ||
+            type === 'VectorStoreNode' ||
+            type === 'MCPServerNode' ||
+            type === 'BuiltinMCPNode' ||
+            type === 'MCPToolNode') {
             groups.aiNodes.push(node);
         }
-        else if (type === "ActionNode" || !type) {
+        else if (type === 'ActionNode' || !type) {
             groups.actions.push(node);
         }
         else {
@@ -135,7 +161,7 @@ function groupNodes(nodes) {
 }
 function renderDependencyGraph(adj, order) {
     if (order.length === 0)
-        return "(无节点)";
+        return '(无节点)';
     const lines = [];
     const depth = {};
     const visiting = new Set();
@@ -156,7 +182,14 @@ function renderDependencyGraph(adj, order) {
             assignDepth(id, 0);
         }
     }
-    const maxDepth = Math.max(...Object.values(depth), 0);
+    // Assign fallback depth to nodes in cycles (not reachable from inDegree-0 nodes)
+    let maxDepth = Math.max(...Object.values(depth), 0);
+    for (const id of order) {
+        if (depth[id] === undefined) {
+            maxDepth = maxDepth + 1;
+            depth[id] = maxDepth;
+        }
+    }
     const depthNodes = {};
     for (let i = 0; i <= maxDepth; i++)
         depthNodes[i] = [];
@@ -171,36 +204,39 @@ function renderDependencyGraph(adj, order) {
         const labels = nodeIds.map((nid) => {
             const node = adj[nid]?.node;
             const name = node?.connector_name || node?.action_name || nid;
-            const type = NODE_TYPE_LABELS[node?.node_type || ""] || node?.node_type || "";
+            const type = NODE_TYPE_LABELS[node?.node_type || ''] || node?.node_type || '';
             return `[${type}] ${name}`;
         });
-        lines.push(labels.join("  │  "));
+        lines.push(labels.join('  │  '));
         if (d < maxDepth) {
             const hasChildren = nodeIds.some((nid) => adj[nid]?.outgoing.length > 0);
             if (hasChildren) {
-                lines.push("  │");
-                lines.push("  ▼");
+                lines.push('  │');
+                lines.push('  ▼');
             }
         }
     }
-    return lines.join("\n");
+    return lines.join('\n');
 }
 function renderAsciiFlowchart(adj, order) {
     if (order.length === 0)
-        return "(无节点)";
+        return '(无节点)';
     function displayWidth(s) {
         let w = 0;
         for (const ch of s) {
             const code = ch.charCodeAt(0);
-            w += (code >= 0x4e00 && code <= 0x9fff) ||
-                (code >= 0x3000 && code <= 0x303f) ||
-                (code >= 0xff00 && code <= 0xffef) ? 2 : 1;
+            w +=
+                (code >= 0x4e00 && code <= 0x9fff) ||
+                    (code >= 0x3000 && code <= 0x303f) ||
+                    (code >= 0xff00 && code <= 0xffef)
+                    ? 2
+                    : 1;
         }
         return w;
     }
     function padRight(text, targetWidth) {
         const dw = displayWidth(text);
-        return text + " ".repeat(Math.max(0, targetWidth - dw));
+        return text + ' '.repeat(Math.max(0, targetWidth - dw));
     }
     // Assign depths via longest-path DFS
     const depth = {};
@@ -222,11 +258,34 @@ function renderAsciiFlowchart(adj, order) {
             assignDepth(id, 0);
         }
     }
-    const maxDepth = Math.max(...Object.values(depth), 0);
-    // Group nodes by depth, ordered by median parent position
-    const BOX_W = 42;
-    const INNER_W = BOX_W - 2;
+    let adjustedMaxDepth = Math.max(...Object.values(depth), 0);
+    // Assign fallback depth to cycle nodes (not reachable from inDegree-0 nodes)
+    for (const id of order) {
+        if (depth[id] === undefined) {
+            adjustedMaxDepth = adjustedMaxDepth + 1;
+            depth[id] = adjustedMaxDepth;
+        }
+    }
+    const maxDepth = adjustedMaxDepth;
+    // Pre-compute per-node box widths based on content
+    const MIN_BOX_W = 22;
     const GAP = 4;
+    function boxHalfLeft(_nid) {
+        return Math.floor(boxWidths[_nid] / 2);
+    }
+    function boxHalfRight(_nid) {
+        return Math.ceil(boxWidths[_nid] / 2);
+    }
+    const boxWidths = {};
+    for (const nid of order) {
+        const node = adj[nid]?.node;
+        const actionName = node?.action_name || '';
+        const connectorName = node?.connector_name || '';
+        const shortId = nid.length > 22 ? nid.substring(0, 20) + '..' : nid;
+        const maxTextW = Math.max(displayWidth(actionName), displayWidth(connectorName || nid), displayWidth(shortId));
+        // boxW = maxTextW + 3 (left border "│ " + right border "│")
+        boxWidths[nid] = Math.max(Math.max(maxTextW, 0) + 3, MIN_BOX_W);
+    }
     const depthNodes = {};
     for (let d = 0; d <= maxDepth; d++) {
         depthNodes[d] = [];
@@ -243,16 +302,16 @@ function renderAsciiFlowchart(adj, order) {
         if (row.length === 0)
             continue;
         if (d === 0) {
-            // First row: space evenly
-            const rowW = row.length * BOX_W + (row.length - 1) * GAP;
-            const startX = Math.floor(BOX_W / 2);
+            // First row: space evenly with per-node widths
+            let startX = boxHalfLeft(row[0]);
             for (let i = 0; i < row.length; i++) {
-                boxCenters[row[i]] = startX + i * (BOX_W + GAP);
+                boxCenters[row[i]] = startX;
+                if (i < row.length - 1) {
+                    startX += boxHalfRight(row[i]) + GAP + boxHalfLeft(row[i + 1]);
+                }
             }
         }
         else {
-            // Position children based on parent positions
-            // Build child -> parents and parent -> children
             const prevRow = depthNodes[d - 1] || [];
             const childParents = {};
             const parentChildren = {};
@@ -264,7 +323,6 @@ function renderAsciiFlowchart(adj, order) {
                     parentChildren[p].push(nid);
                 }
             }
-            // First, place children near their parents
             const rawPositions = {};
             const placed = new Set();
             // Children of single-child parents: place under parent
@@ -284,11 +342,13 @@ function renderAsciiFlowchart(adj, order) {
                 if (children.length === 0)
                     continue;
                 const pCX = boxCenters[p];
-                const halfW = Math.floor(((children.length - 1) * (BOX_W + GAP)) / 2);
+                // Total width including gaps
+                const totalW = children.reduce((sum, c) => sum + boxWidths[c], 0) + (children.length - 1) * GAP;
+                const startOffset = pCX - Math.floor(totalW / 2) + boxHalfLeft(children[0]);
+                let curCX = startOffset;
                 for (let i = 0; i < children.length; i++) {
-                    const cx = pCX - halfW + i * (BOX_W + GAP);
-                    rawPositions[children[i]] = cx;
-                    placed.add(children[i]);
+                    rawPositions[children[i]] = curCX;
+                    curCX += boxHalfRight(children[i]) + GAP + boxHalfLeft(children[i + 1] ?? '');
                 }
             }
             // Children with multiple parents: average parent positions
@@ -299,80 +359,103 @@ function renderAsciiFlowchart(adj, order) {
                     rawPositions[nid] = Math.round(sum / parents.length);
                 }
             }
-            // Nodes without parents (shouldn't happen at d>0, but handle)
+            // Nodes without parents
             for (const nid of row) {
                 if (rawPositions[nid] === undefined) {
-                    rawPositions[nid] = Math.floor(BOX_W / 2) + Object.keys(rawPositions).length * (BOX_W + GAP);
+                    let accX = boxHalfLeft(nid);
+                    for (const existing of Object.keys(rawPositions)) {
+                        accX += boxHalfRight(existing) + GAP + boxHalfLeft(nid);
+                    }
+                    rawPositions[nid] = accX;
                 }
             }
             // Sort row by raw position and resolve overlaps
             const sorted = [...row].sort((a, b) => (rawPositions[a] ?? 0) - (rawPositions[b] ?? 0));
-            // Resolve overlaps with a sweep
-            let nextX = Math.floor(BOX_W / 2);
-            for (const nid of sorted) {
+            // Resolve overlaps with a sweep using actual box widths
+            let nextX = boxHalfLeft(sorted[0]);
+            for (let i = 0; i < sorted.length; i++) {
+                const nid = sorted[i];
                 const ideal = rawPositions[nid] ?? nextX;
                 boxCenters[nid] = Math.max(nextX, ideal);
-                nextX = boxCenters[nid] + BOX_W + GAP;
+                if (i < sorted.length - 1) {
+                    const nextNid = sorted[i + 1];
+                    nextX = boxCenters[nid] + boxHalfRight(nid) + GAP + boxHalfLeft(nextNid);
+                }
             }
         }
     }
-    // Calculate canvas width
-    let canvasW = BOX_W;
-    for (const cx of Object.values(boxCenters)) {
-        const rightEdge = cx + Math.floor(BOX_W / 2) + 1;
+    // Calculate canvas width using actual box sizes
+    let canvasW = 0;
+    for (const nid of Object.keys(boxCenters)) {
+        const cx = boxCenters[nid];
+        const rightEdge = cx + boxHalfRight(nid);
         if (rightEdge > canvasW)
             canvasW = rightEdge;
     }
     // Normalize to start at 0
-    const minX = Math.min(...Object.values(boxCenters).map((cx) => cx - Math.floor(BOX_W / 2)));
+    const minX = Math.min(...Object.keys(boxCenters).map((nid) => boxCenters[nid] - boxHalfLeft(nid)));
     for (const nid of Object.keys(boxCenters)) {
         boxCenters[nid] -= minX;
     }
     canvasW -= minX;
     function buildBox(nid) {
         const node = adj[nid]?.node;
-        const name = node?.connector_name || node?.action_name || nid;
-        const typeLabel = NODE_TYPE_LABELS[node?.node_type || ""] || node?.node_type || "";
-        const shortId = nid.length > 22 ? nid.substring(0, 20) + ".." : nid;
-        const padW = INNER_W - 1;
+        const actionName = node?.action_name || '';
+        const connectorName = node?.connector_name || nid;
+        const shortId = nid.length > 22 ? nid.substring(0, 20) + '..' : nid;
+        const boxW = boxWidths[nid];
+        const innerW = boxW - 2;
+        const padW = innerW - 1;
         return [
-            "┌" + "─".repeat(INNER_W) + "┐",
-            "│ " + padRight(name, padW) + "│",
-            "│ " + padRight(shortId, padW) + "│",
-            "│ " + padRight(typeLabel, padW) + "│",
-            "└" + "─".repeat(INNER_W) + "┘",
+            '┌' + '─'.repeat(innerW) + '┐',
+            '│ ' + padRight(connectorName, padW) + '│',
+            '│ ' + padRight(shortId, padW) + '│',
+            '│ ' + padRight(actionName, padW) + '│',
+            '└' + '─'.repeat(innerW) + '┘',
         ];
     }
     const BOX_H = 5;
     const canvas = [];
     const rowMap = {};
+    // Track occupied box regions to prevent edge lines from drawing through boxes
+    const boxRegions = [];
     function ensureRow(y) {
         while (canvas.length <= y) {
-            canvas.push(Array(canvasW).fill(" "));
+            canvas.push(Array(canvasW).fill(' '));
+        }
+    }
+    function isInBoxRegion(cx, y) {
+        for (const r of boxRegions) {
+            if (cx >= r.x1 && cx < r.x2 && y >= r.y1 && y < r.y2)
+                return true;
         }
+        return false;
     }
-    function drawStr(x, y, s) {
+    function drawStr(x, y, s, soft = false) {
         ensureRow(y);
         let cx = x;
         for (const ch of s) {
             if (cx >= 0 && cx < canvasW) {
-                canvas[y][cx] = ch;
+                const cellEmpty = canvas[y][cx] === ' ' || canvas[y][cx] === '';
+                if (!soft || (cellEmpty && !isInBoxRegion(cx, y))) {
+                    canvas[y][cx] = ch;
+                }
             }
             const dw = displayWidth(ch);
             for (let j = 1; j < dw && cx + j < canvasW; j++) {
-                canvas[y][cx + j] = "";
+                canvas[y][cx + j] = '';
             }
             cx += dw;
         }
     }
-    function drawLine(x1, y1, x2, y2, ch) {
+    function drawLine(x1, y1, x2, y2, ch, soft = false) {
         if (x1 === x2) {
             for (let y = Math.min(y1, y2); y <= Math.max(y1, y2); y++)
-                drawStr(x1, y, ch);
+                drawStr(x1, y, ch, soft);
         }
         else if (y1 === y2) {
             for (let x = Math.min(x1, x2); x <= Math.max(x1, x2); x++)
-                drawStr(x, y1, ch);
+                drawStr(x, y1, ch, soft);
         }
     }
     let currentY = 0;
@@ -382,135 +465,105 @@ function renderAsciiFlowchart(adj, order) {
             continue;
         for (const nid of row) {
             const box = buildBox(nid);
-            const cx = boxCenters[nid] - Math.floor(BOX_W / 2);
+            const leftX = boxCenters[nid] - boxHalfLeft(nid);
             for (let i = 0; i < BOX_H; i++) {
-                drawStr(cx, currentY + i, box[i]);
+                drawStr(leftX, currentY + i, box[i]);
             }
             rowMap[nid] = currentY;
+            boxRegions.push({
+                x1: leftX,
+                x2: leftX + boxWidths[nid],
+                y1: currentY,
+                y2: currentY + BOX_H,
+            });
         }
-        if (d > 0) {
-            const prevRow = depthNodes[d - 1] || [];
-            const startY = rowMap[prevRow[0]] + BOX_H;
-            const endY = currentY;
-            const midY = startY + Math.floor((endY - startY) / 2);
-            // Build parent ↔ child maps
-            const childParents = {};
-            const parentChildren = {};
-            for (const nid of row) {
-                childParents[nid] = (adj[nid]?.incoming || []).filter((p) => prevRow.includes(p));
-                for (const p of childParents[nid]) {
-                    if (!parentChildren[p])
-                        parentChildren[p] = [];
-                    parentChildren[p].push(nid);
-                }
+        currentY += BOX_H;
+        if (d < maxDepth)
+            currentY += 3;
+    }
+    // Draw all edges using unified per-edge routing
+    // Backward edges drawn first so their arrows take priority in shared gap space
+    const GAP_H = 3;
+    // Pass 1: backward edges (src deeper than tgt)
+    for (const nid of order) {
+        for (const tgt of adj[nid]?.outgoing || []) {
+            if (!boxCenters[nid] || !boxCenters[tgt])
+                continue;
+            if (depth[nid] === undefined || depth[tgt] === undefined)
+                continue;
+            if (depth[nid] <= depth[tgt])
+                continue;
+            const srcCX = boxCenters[nid];
+            const tgtCX = boxCenters[tgt];
+            const srcTop = rowMap[nid];
+            const tgtBottom = rowMap[tgt] + BOX_H - 1;
+            const midY = srcTop - Math.floor(GAP_H / 2) - 1;
+            drawLine(srcCX, srcTop - 2, srcCX, midY, '│', true);
+            if (srcCX !== tgtCX) {
+                drawLine(Math.min(srcCX, tgtCX), midY, Math.max(srcCX, tgtCX), midY, '─', true);
+                drawStr(srcCX, midY, tgtCX > srcCX ? '└' : '┘', true);
             }
-            // Draw vertical lines from every parent that has children
-            for (const p of prevRow) {
-                if ((parentChildren[p]?.length || 0) > 0) {
-                    drawLine(boxCenters[p], startY, boxCenters[p], midY, "│");
-                }
+            drawLine(tgtCX, midY, tgtCX, tgtBottom + 2, '│', true);
+            drawStr(tgtCX, tgtBottom + 1, '▲', false);
+        }
+    }
+    // Pass 2: forward edges (src shallower than tgt)
+    for (const nid of order) {
+        for (const tgt of adj[nid]?.outgoing || []) {
+            if (!boxCenters[nid] || !boxCenters[tgt])
+                continue;
+            if (depth[nid] === undefined || depth[tgt] === undefined)
+                continue;
+            if (depth[nid] >= depth[tgt])
+                continue;
+            const srcCX = boxCenters[nid];
+            const tgtCX = boxCenters[tgt];
+            const srcBottom = rowMap[nid] + BOX_H;
+            const tgtTop = rowMap[tgt];
+            if (srcBottom >= tgtTop)
+                continue;
+            if (srcCX === tgtCX) {
+                drawLine(srcCX, srcBottom, tgtCX, tgtTop - 2, '│', true);
             }
-            // Draw horizontal connections and verticals down to children
-            const drawnParent = new Set();
-            const doneMerge = new Set();
-            for (const nid of row) {
-                const parents = childParents[nid];
-                if (parents.length === 0)
-                    continue;
-                const childCX = boxCenters[nid];
-                if (parents.length === 1) {
-                    const p = parents[0];
-                    const siblings = parentChildren[p] || [nid];
-                    if (siblings.length > 1) {
-                        // Branching: one parent → multiple children
-                        if (drawnParent.has(p))
-                            continue;
-                        drawnParent.add(p);
-                        const pCX = boxCenters[p];
-                        const sibCenters = siblings.map((c) => boxCenters[c]);
-                        const minCX = Math.min(pCX, ...sibCenters);
-                        const maxCX = Math.max(pCX, ...sibCenters);
-                        drawLine(minCX, midY, maxCX, midY, "─");
-                        // Pick junction char: parent vertical (up) + child directions
-                        const hasBelow = sibCenters.some((cx) => cx === pCX);
-                        const hasLeft = sibCenters.some((cx) => cx < pCX);
-                        const hasRight = sibCenters.some((cx) => cx > pCX);
-                        if (hasBelow && hasLeft && hasRight)
-                            drawStr(pCX, midY, "┼");
-                        else if (hasBelow && hasRight)
-                            drawStr(pCX, midY, "├");
-                        else if (hasBelow && hasLeft)
-                            drawStr(pCX, midY, "┤");
-                        else
-                            drawStr(pCX, midY, "┬");
-                        for (const ccx of sibCenters) {
-                            drawLine(ccx, midY + 1, ccx, endY - 1, "│");
-                            drawStr(ccx, endY - 1, "▼");
-                        }
-                    }
-                    else {
-                        // Single child
-                        const pCX = boxCenters[p];
-                        if (pCX === childCX) {
-                            drawLine(childCX, midY, childCX, endY - 1, "│");
-                            drawStr(childCX, endY - 1, "▼");
-                        }
-                        else {
-                            drawLine(Math.min(pCX, childCX), midY, Math.max(pCX, childCX), midY, "─");
-                            drawLine(childCX, midY + 1, childCX, endY - 1, "│");
-                            drawStr(pCX, midY, childCX > pCX ? "└" : "┘");
-                            drawStr(childCX, endY - 1, "▼");
-                        }
-                    }
-                }
-                else {
-                    // Merge: multiple parents → one child
-                    if (doneMerge.has(nid))
-                        continue;
-                    // Group children that share these same parents
-                    const siblingSet = new Set();
-                    for (const other of row) {
-                        const op = childParents[other];
-                        if (op.length > 1 && op.some((pp) => parents.includes(pp))) {
-                            siblingSet.add(other);
-                        }
-                    }
-                    const pCenters = parents.map((pp) => boxCenters[pp]);
-                    const allChildCenters = [...siblingSet].map((c) => boxCenters[c]);
-                    const minCX = Math.min(...pCenters, ...allChildCenters);
-                    const maxCX = Math.max(...pCenters, ...allChildCenters);
-                    drawLine(minCX, midY, maxCX, midY, "─");
-                    for (const pCX of pCenters)
-                        drawStr(pCX, midY, "┴");
-                    for (const c of siblingSet) {
-                        const ccx = boxCenters[c];
-                        drawStr(ccx, midY, "┬");
-                        drawLine(ccx, midY + 1, ccx, endY - 1, "│");
-                        drawStr(ccx, endY - 1, "▼");
-                        doneMerge.add(c);
-                    }
-                }
+            else {
+                const routeY = srcBottom + Math.floor(GAP_H / 2);
+                drawLine(srcCX, srcBottom, srcCX, routeY, '│', true);
+                drawLine(Math.min(srcCX, tgtCX), routeY, Math.max(srcCX, tgtCX), routeY, '─', true);
+                drawStr(srcCX, routeY, tgtCX > srcCX ? '└' : '┘', true);
+                drawLine(tgtCX, routeY + 1, tgtCX, tgtTop - 2, '│', true);
             }
+            drawStr(tgtCX, tgtTop - 1, '▼', true);
         }
-        currentY += BOX_H;
-        if (d < maxDepth) {
-            const nextRow = depthNodes[d + 1] || [];
-            const hasConnection = row.some((nid) => (adj[nid]?.outgoing || []).some((c) => nextRow.includes(c)));
-            const arrowLines = hasConnection ? 3 : 1;
-            currentY += arrowLines;
+    }
+    // Draw same-depth edges (horizontal) just above the target box
+    for (const nid of order) {
+        const outgoing = adj[nid]?.outgoing || [];
+        for (const tgt of outgoing) {
+            if (!boxCenters[nid] || !boxCenters[tgt])
+                continue;
+            if (depth[nid] !== depth[tgt])
+                continue;
+            if (boxCenters[nid] === boxCenters[tgt])
+                continue;
+            const tgtTop = rowMap[tgt];
+            const y = tgtTop - 1;
+            const srcCX = boxCenters[nid];
+            const tgtCX = boxCenters[tgt];
+            drawLine(Math.min(srcCX, tgtCX), y, Math.max(srcCX, tgtCX), y, '─', true);
+            drawStr(tgtCX, y, tgtCX > srcCX ? '▶' : '◀', true);
         }
     }
     const lines = canvas.map((row) => {
-        let line = "";
+        let line = '';
         for (const cell of row) {
-            if (cell !== "")
+            if (cell !== '')
                 line += cell;
         }
         return line.trimEnd();
     });
-    return lines.join("\n");
+    return lines.join('\n');
 }
 function formatNodeType(type) {
-    return NODE_TYPE_LABELS[type] || type || "未知";
+    return NODE_TYPE_LABELS[type] || type || '未知';
 }
 //# sourceMappingURL=flowAnalyzer.js.map