sdlc-agent-4-enterprise-server 1.0.0

package/src/engine/tools/drawio-export-png.ts

@@ -0,0 +1,272 @@
+/**
+ * drawio_export_png — Export .drawio file to PNG image.
+ *
+ * Priority order for rendering:
+ * 1. draw.io CLI (drawio desktop app) — fastest, most accurate
+ * 2. chrome-devtools-mcp (upstream MCP) — uses browser screenshot
+ * 3. puppeteer MCP (upstream MCP) — headless browser
+ *
+ * If none available, tool is NOT published (hidden from tool list).
+ *
+ * Input: relative path to .drawio file
+ * Output: relative path to exported .png file
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+export const DRAWIO_EXPORT_PNG_DEFINITION = {
+  name: 'drawio_export_png',
+  description: 'Export a .drawio diagram file to PNG image. Returns the relative path to the exported PNG file.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      file_path: {
+        type: 'string',
+        description: 'Relative path to .drawio file (relative to workspace root)',
+      },
+    },
+    required: ['file_path'],
+  },
+};
+
+/** Renderer type detected at runtime */
+type RendererType = 'drawio-cli' | 'chrome-devtools-mcp' | 'puppeteer-mcp' | 'none';
+
+/** Cached renderer detection result */
+let cachedRenderer: RendererType | null = null;
+let cachedDrawioCliPath: string | null = null;
+
+/**
+ * Detect which renderer is available (priority order).
+ * Result is cached for the session.
+ */
+export function detectRenderer(orchestrationEngine?: any): RendererType {
+  if (cachedRenderer !== null) return cachedRenderer;
+
+  // Priority 1: draw.io CLI
+  const cliPath = findDrawioCli();
+  if (cliPath) {
+    cachedDrawioCliPath = cliPath;
+    cachedRenderer = 'drawio-cli';
+    console.error(`[drawio-export] Renderer: draw.io CLI at ${cliPath}`);
+    return cachedRenderer;
+  }
+
+  // Priority 2: chrome-devtools-mcp (check orchestration)
+  if (orchestrationEngine && hasUpstreamServer(orchestrationEngine, 'chrome-devtools-mcp')) {
+    cachedRenderer = 'chrome-devtools-mcp';
+    console.error('[drawio-export] Renderer: chrome-devtools-mcp (upstream)');
+    return cachedRenderer;
+  }
+
+  // Priority 3: puppeteer MCP
+  if (orchestrationEngine && hasUpstreamServer(orchestrationEngine, 'puppeteer')) {
+    cachedRenderer = 'puppeteer-mcp';
+    console.error('[drawio-export] Renderer: puppeteer-mcp (upstream)');
+    return cachedRenderer;
+  }
+
+  cachedRenderer = 'none';
+  console.error('[drawio-export] No renderer available — tool will be hidden');
+  return cachedRenderer;
+}
+
+/** Check if tool should be published (at least one renderer available) */
+export function isExportPngAvailable(orchestrationEngine?: any): boolean {
+  return detectRenderer(orchestrationEngine) !== 'none';
+}
+
+/** Reset cached renderer (for testing or when orchestration changes) */
+export function resetRendererCache(): void {
+  cachedRenderer = null;
+  cachedDrawioCliPath = null;
+}
+
+/**
+ * Handle the drawio_export_png tool call.
+ * Returns JSON with relative path to PNG or error.
+ */
+export async function handleDrawioExportPng(
+  args: Record<string, unknown>,
+  workspace: string,
+  orchestrationEngine?: any
+): Promise<string> {
+  const rawPath = args.file_path as string | undefined;
+  if (!rawPath) return jsonError('file_path is required');
+
+  // Resolve paths
+  const filePath = path.isAbsolute(rawPath)
+    ? rawPath
+    : path.resolve(workspace, rawPath);
+
+  if (!fs.existsSync(filePath)) return jsonError(`File not found: ${rawPath}`);
+  if (!filePath.endsWith('.drawio')) return jsonError('File must have .drawio extension');
+
+  // Output path: same directory, same name, .png extension
+  const pngPath = filePath.replace(/\.drawio$/, '.png');
+  const relativePngPath = path.relative(workspace, pngPath).replace(/\\/g, '/');
+
+  const renderer = detectRenderer(orchestrationEngine);
+
+  try {
+    switch (renderer) {
+      case 'drawio-cli':
+        await exportWithCli(filePath, pngPath);
+        break;
+      case 'chrome-devtools-mcp':
+        await exportWithChrome(filePath, pngPath, workspace, orchestrationEngine);
+        break;
+      case 'puppeteer-mcp':
+        await exportWithPuppeteer(filePath, pngPath, workspace, orchestrationEngine);
+        break;
+      default:
+        return jsonError('No renderer available. Install draw.io desktop or configure chrome-devtools-mcp.');
+    }
+
+    // Verify output exists
+    if (!fs.existsSync(pngPath)) {
+      return jsonError(`Export failed — PNG file was not created at ${relativePngPath}`);
+    }
+
+    const stats = fs.statSync(pngPath);
+    return JSON.stringify({
+      success: true,
+      file_path: relativePngPath,
+      size_bytes: stats.size,
+      renderer: renderer,
+    });
+  } catch (e: any) {
+    return jsonError(`Export failed: ${e.message ?? e}`);
+  }
+}
+
+// ─── Renderer Implementations ────────────────────────────────────────────────
+
+/** Priority 1: Export using draw.io CLI */
+async function exportWithCli(inputPath: string, outputPath: string): Promise<void> {
+  if (!cachedDrawioCliPath) throw new Error('draw.io CLI path not cached');
+
+  const cmd = `"${cachedDrawioCliPath}" --export --format png --border 10 --output "${outputPath}" "${inputPath}"`;
+  execSync(cmd, { timeout: 30000, stdio: 'pipe' });
+}
+
+/** Priority 2: Export using chrome-devtools-mcp */
+async function exportWithChrome(
+  inputPath: string,
+  outputPath: string,
+  _workspace: string,
+  orchestrationEngine: any
+): Promise<void> {
+  const xml = fs.readFileSync(inputPath, 'utf-8');
+  const encoded = Buffer.from(xml).toString('base64');
+  const viewerUrl = `https://viewer.diagrams.net/?lightbox=1&nav=0#R${encoded}`;
+
+  // Navigate to viewer
+  await orchestrationEngine.executeUpstreamTool('chrome-devtools-mcp', 'navigate_page', {
+    type: 'url',
+    url: viewerUrl,
+    timeout: 15000,
+  });
+
+  // Wait for diagram to render
+  await sleep(3000);
+
+  // Take screenshot and save to file
+  await orchestrationEngine.executeUpstreamTool('chrome-devtools-mcp', 'take_screenshot', {
+    format: 'png',
+    fullPage: true,
+    filePath: outputPath,
+  });
+}
+
+/** Priority 3: Export using puppeteer MCP */
+async function exportWithPuppeteer(
+  inputPath: string,
+  outputPath: string,
+  _workspace: string,
+  orchestrationEngine: any
+): Promise<void> {
+  const xml = fs.readFileSync(inputPath, 'utf-8');
+  const encoded = Buffer.from(xml).toString('base64');
+  const viewerUrl = `https://viewer.diagrams.net/?lightbox=1&nav=0#R${encoded}`;
+
+  await orchestrationEngine.executeUpstreamTool('puppeteer', 'navigate', {
+    url: viewerUrl,
+  });
+
+  await sleep(3000);
+
+  await orchestrationEngine.executeUpstreamTool('puppeteer', 'screenshot', {
+    path: outputPath,
+    fullPage: true,
+  });
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Find draw.io CLI executable on the system */
+function findDrawioCli(): string | null {
+  const candidates: string[] = [];
+
+  if (process.platform === 'win32') {
+    candidates.push(
+      'C:\\Program Files\\draw.io\\draw.io.exe',
+      `${process.env.LOCALAPPDATA || ''}\\Programs\\draw.io\\draw.io.exe`,
+      `${process.env.PROGRAMFILES || ''}\\draw.io\\draw.io.exe`,
+    );
+  } else if (process.platform === 'darwin') {
+    candidates.push(
+      '/Applications/draw.io.app/Contents/MacOS/draw.io',
+      '/usr/local/bin/drawio',
+      `${process.env.HOME || ''}/Applications/draw.io.app/Contents/MacOS/draw.io`,
+    );
+  } else {
+    // Linux
+    candidates.push(
+      '/usr/bin/drawio',
+      '/usr/local/bin/drawio',
+      '/snap/bin/drawio',
+      `${process.env.HOME || ''}/.local/bin/drawio`,
+    );
+  }
+
+  for (const candidate of candidates) {
+    if (candidate && fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  // Try PATH lookup
+  try {
+    const which = process.platform === 'win32' ? 'where drawio 2>nul' : 'which drawio';
+    const result = execSync(which, { timeout: 5000, stdio: 'pipe' }).toString().trim();
+    if (result && fs.existsSync(result.split('\n')[0])) {
+      return result.split('\n')[0];
+    }
+  } catch { /* not in PATH */ }
+
+  return null;
+}
+
+/** Check if an upstream MCP server exists in orchestration */
+function hasUpstreamServer(orchestrationEngine: any, serverName: string): boolean {
+  try {
+    const status = orchestrationEngine.getStatus?.();
+    if (!status?.servers) return false;
+    return status.servers.some((s: any) =>
+      s.name?.toLowerCase().includes(serverName.toLowerCase()) && s.state === 'ACTIVE'
+    );
+  } catch {
+    return false;
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function jsonError(msg: string): string {
+  return JSON.stringify({ success: false, error: msg });
+}

package/src/engine/tools/drawio-layout.ts

@@ -0,0 +1,143 @@
+/**
+ * Layout algorithms for draw.io diagrams — layered, force-directed, tree, radial.
+ */
+
+import { DiagramGraph, DiagramNode, DiagramEdge } from './drawio-parser.js';
+
+/** Apply layout algorithm to graph, updating node positions in-place. */
+export function applyLayout(graph: DiagramGraph, algorithm: string, spacing: number, direction: string): void {
+  if (graph.nodes.length === 0) return;
+  const dispatch: Record<string, () => void> = {
+    layered: () => layeredLayout(graph, spacing, direction),
+    force: () => forceDirectedLayout(graph.nodes, graph.edges, spacing),
+    mrtree: () => layeredLayout(graph, spacing, direction),
+    radial: () => radialLayout(graph.nodes, graph.edges, spacing),
+  };
+  (dispatch[algorithm] ?? dispatch.layered)();
+  resizeContainers(graph, spacing);
+}
+
+function layeredLayout(graph: DiagramGraph, spacing: number, direction: string): void {
+  const layers = assignLayers(graph.nodes, graph.edges);
+  positionLayers(graph.nodes, layers, spacing, direction);
+}
+
+function assignLayers(nodes: DiagramNode[], edges: DiagramEdge[]): Map<string, number> {
+  const adj = new Map<string, string[]>();
+  const inDeg = new Map<string, number>();
+  for (const n of nodes) { adj.set(n.id, []); inDeg.set(n.id, 0); }
+  for (const e of edges) {
+    if (adj.has(e.sourceId) && adj.has(e.targetId)) {
+      adj.get(e.sourceId)!.push(e.targetId);
+      inDeg.set(e.targetId, (inDeg.get(e.targetId) ?? 0) + 1);
+    }
+  }
+  const layers = new Map<string, number>();
+  const queue: string[] = [];
+  for (const [id, deg] of inDeg) { if (deg === 0) { queue.push(id); layers.set(id, 0); } }
+  while (queue.length > 0) {
+    const cur = queue.shift()!;
+    const curLayer = layers.get(cur) ?? 0;
+    for (const nxt of adj.get(cur) ?? []) {
+      const newLayer = curLayer + 1;
+      if ((layers.get(nxt) ?? -1) < newLayer) layers.set(nxt, newLayer);
+      inDeg.set(nxt, (inDeg.get(nxt) ?? 1) - 1);
+      if (inDeg.get(nxt) === 0) queue.push(nxt);
+    }
+  }
+  for (const n of nodes) { if (!layers.has(n.id)) layers.set(n.id, 0); }
+  return layers;
+}
+
+function positionLayers(nodes: DiagramNode[], layers: Map<string, number>, spacing: number, direction: string): void {
+  const grouped = new Map<number, DiagramNode[]>();
+  for (const n of nodes) {
+    const layer = layers.get(n.id) ?? 0;
+    if (!grouped.has(layer)) grouped.set(layer, []);
+    grouped.get(layer)!.push(n);
+  }
+  const layerSpacing = spacing * 2;
+  for (const [layer, layerNodes] of grouped) {
+    for (let idx = 0; idx < layerNodes.length; idx++) {
+      const node = layerNodes[idx];
+      const primary = layer * layerSpacing;
+      const secondary = idx * (node.width + spacing);
+      switch (direction) {
+        case 'DOWN': node.x = secondary; node.y = primary; break;
+        case 'RIGHT': node.x = primary; node.y = secondary; break;
+        case 'UP': node.x = secondary; node.y = -primary; break;
+        case 'LEFT': node.x = -primary; node.y = secondary; break;
+      }
+    }
+  }
+}
+
+function forceDirectedLayout(nodes: DiagramNode[], edges: DiagramEdge[], spacing: number): void {
+  const repulsion = spacing * spacing * 10;
+  const attraction = 0.01;
+  if (nodes.every(n => n.x === 0 && n.y === 0)) {
+    const cols = Math.max(1, Math.ceil(Math.sqrt(nodes.length)));
+    nodes.forEach((n, i) => { n.x = (i % cols) * spacing * 2; n.y = Math.floor(i / cols) * spacing * 2; });
+  }
+  for (let iter = 0; iter < 100; iter++) {
+    const damping = 1.0 - (iter / 100) * 0.8;
+    applyForces(nodes, edges, repulsion, attraction, damping);
+  }
+}
+
+function applyForces(nodes: DiagramNode[], edges: DiagramEdge[], repulsion: number, attraction: number, damping: number): void {
+  const n = nodes.length;
+  const dx = new Float64Array(n);
+  const dy = new Float64Array(n);
+  const nodeIdx = new Map<string, number>();
+  nodes.forEach((nd, i) => nodeIdx.set(nd.id, i));
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const diffX = nodes[i].x - nodes[j].x;
+      const diffY = nodes[i].y - nodes[j].y;
+      const dist = Math.max(1.0, Math.sqrt(diffX * diffX + diffY * diffY));
+      const force = repulsion / (dist * dist);
+      const fx = force * diffX / dist, fy = force * diffY / dist;
+      dx[i] += fx; dy[i] += fy; dx[j] -= fx; dy[j] -= fy;
+    }
+  }
+  for (const e of edges) {
+    const si = nodeIdx.get(e.sourceId), ti = nodeIdx.get(e.targetId);
+    if (si === undefined || ti === undefined) continue;
+    const diffX = nodes[ti].x - nodes[si].x, diffY = nodes[ti].y - nodes[si].y;
+    const fx = attraction * diffX, fy = attraction * diffY;
+    dx[si] += fx; dy[si] += fy; dx[ti] -= fx; dy[ti] -= fy;
+  }
+  for (let i = 0; i < n; i++) { nodes[i].x += dx[i] * damping; nodes[i].y += dy[i] * damping; }
+}
+
+function radialLayout(nodes: DiagramNode[], _edges: DiagramEdge[], spacing: number): void {
+  if (nodes.length === 0) return;
+  nodes[0].x = 0; nodes[0].y = 0;
+  const remaining = nodes.slice(1);
+  const ringSize = 8;
+  for (let start = 0; start < remaining.length; start += ringSize) {
+    const ring = remaining.slice(start, start + ringSize);
+    const ringIdx = Math.floor(start / ringSize);
+    const radius = (ringIdx + 1) * spacing * 2.5;
+    ring.forEach((node, i) => {
+      const angle = (2 * Math.PI * i) / ring.length;
+      node.x = radius * Math.cos(angle);
+      node.y = radius * Math.sin(angle);
+    });
+  }
+}
+
+function resizeContainers(graph: DiagramGraph, spacing: number): void {
+  for (const container of graph.containers) {
+    const children = graph.nodes.filter(n => n.parentId === container.id);
+    if (children.length === 0) continue;
+    const minX = Math.min(...children.map(c => c.x)) - spacing;
+    const minY = Math.min(...children.map(c => c.y)) - spacing;
+    const maxX = Math.max(...children.map(c => c.x + c.width)) + spacing;
+    const maxY = Math.max(...children.map(c => c.y + c.height)) + spacing;
+    container.x = minX; container.y = minY;
+    container.width = maxX - minX; container.height = maxY - minY;
+    for (const child of children) { child.x -= minX; child.y -= minY; }
+  }
+}

package/src/engine/tools/drawio-parser.ts

@@ -0,0 +1,118 @@
+/**
+ * Parses draw.io XML into graph nodes and edges for layout processing.
+ * Uses regex-based parsing (no external XML deps needed for draw.io format).
+ */
+
+import * as fs from 'fs';
+
+export interface DiagramNode {
+  id: string;
+  parentId: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  style: string;
+  isContainer: boolean;
+}
+
+export interface DiagramEdge {
+  id: string;
+  sourceId: string;
+  targetId: string;
+  style: string;
+}
+
+export interface DiagramGraph {
+  nodes: DiagramNode[];
+  edges: DiagramEdge[];
+  containers: DiagramNode[];
+}
+
+/** Parse .drawio XML file into DiagramGraph. */
+export function parseDrawio(filePath: string): { raw: string; graph: DiagramGraph } {
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const graph = extractGraph(raw);
+  return { raw, graph };
+}
+
+function extractGraph(xml: string): DiagramGraph {
+  const nodes: DiagramNode[] = [];
+  const edges: DiagramEdge[] = [];
+  const containers: DiagramNode[] = [];
+
+  // Match all mxCell elements (self-closing or with children)
+  const cellRegex = /<mxCell\s([^>]*?)(?:\/>|>([\s\S]*?)<\/mxCell>)/g;
+  const cells: Array<{ attrs: Record<string, string>; body: string }> = [];
+  let match: RegExpExecArray | null;
+
+  while ((match = cellRegex.exec(xml)) !== null) {
+    const attrs = parseAttrs(match[1]);
+    const body = match[2] ?? '';
+    cells.push({ attrs, body });
+  }
+
+  const cellIds = new Set(cells.map(c => c.attrs['id'] ?? ''));
+
+  for (const cell of cells) {
+    const id = cell.attrs['id'] ?? '';
+    const style = cell.attrs['style'] ?? '';
+    const parent = cell.attrs['parent'] ?? '1';
+
+    if (cell.attrs['edge'] === '1') {
+      const src = cell.attrs['source'];
+      const tgt = cell.attrs['target'];
+      if (src && tgt) edges.push({ id, sourceId: src, targetId: tgt, style });
+    } else if (id !== '0' && id !== '1') {
+      const geom = parseGeometry(cell.body, cell.attrs);
+      if (!geom) continue;
+      const isCont = hasChildren(id, cells) || isContainerStyle(style, geom.w, geom.h);
+      const node: DiagramNode = {
+        id, parentId: parent,
+        x: geom.x, y: geom.y, width: geom.w, height: geom.h,
+        style, isContainer: isCont,
+      };
+      if (isCont) containers.push(node); else nodes.push(node);
+    }
+  }
+  return { nodes, edges, containers };
+}
+
+function parseGeometry(body: string, cellAttrs: Record<string, string>): { x: number; y: number; w: number; h: number } | null {
+  // Look for mxGeometry in body or as sibling in raw XML
+  const geomRegex = /<mxGeometry\s([^>]*?)(?:\/>|>)/;
+  const geomMatch = body.match(geomRegex);
+  if (!geomMatch) return null;
+  const attrs = parseAttrs(geomMatch[1]);
+  if (attrs['as'] !== 'geometry') return null;
+  return {
+    x: parseFloat(attrs['x'] ?? '0'),
+    y: parseFloat(attrs['y'] ?? '0'),
+    w: parseFloat(attrs['width'] ?? '80'),
+    h: parseFloat(attrs['height'] ?? '40'),
+  };
+}
+
+function parseAttrs(attrStr: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  const regex = /(\w+)="([^"]*)"/g;
+  let m: RegExpExecArray | null;
+  while ((m = regex.exec(attrStr)) !== null) {
+    result[m[1]] = m[2];
+  }
+  return result;
+}
+
+function hasChildren(nodeId: string, cells: Array<{ attrs: Record<string, string>; body: string }>): boolean {
+  return cells.some(c =>
+    c.attrs['parent'] === nodeId && c.attrs['edge'] !== '1' && c.body.includes('mxGeometry')
+  );
+}
+
+function isContainerStyle(style: string, width: number, height: number): boolean {
+  const s = style.toLowerCase();
+  if (s.includes('swimlane')) return true;
+  if (s.includes('fillcolor=none') && s.includes('dashed=1')) return true;
+  if (s.includes('shape=rectangle') && s.includes('dashed=1') && width > 300 && height > 300) return true;
+  return false;
+}

package/src/engine/tools/drawio-router.ts

@@ -0,0 +1,112 @@
+/**
+ * Orthogonal edge routing — computes waypoints so connectors avoid shapes.
+ */
+
+import { DiagramGraph, DiagramNode } from './drawio-parser.js';
+
+export interface Waypoint { x: number; y: number; }
+
+/** Route all edges, returning map of edge_id → waypoints for edges needing routing. */
+export function routeEdges(graph: DiagramGraph): Map<string, Waypoint[]> {
+  const allNodes = [...graph.nodes, ...graph.containers];
+  const nodeMap = new Map(allNodes.map(n => [n.id, n]));
+  const routes = new Map<string, Waypoint[]>();
+
+  for (const edge of graph.edges) {
+    const src = nodeMap.get(edge.sourceId);
+    const tgt = nodeMap.get(edge.targetId);
+    if (!src || !tgt) continue;
+    const obstacles = allNodes.filter(n => n.id !== src.id && n.id !== tgt.id);
+    const waypoints = computeRoute(src, tgt, obstacles);
+    if (waypoints.length > 0) routes.set(edge.id, waypoints);
+  }
+  return routes;
+}
+
+function computeRoute(src: DiagramNode, tgt: DiagramNode, obstacles: DiagramNode[]): Waypoint[] {
+  const srcPort = exitPort(src, tgt);
+  const tgtPort = entryPort(src, tgt);
+  const crossed = obstacles.filter(o => lineIntersectsRect(srcPort, tgtPort, o));
+  if (crossed.length === 0) return [];
+  return orthogonalRoute(srcPort, tgtPort, crossed);
+}
+
+function orthogonalRoute(start: Waypoint, end: Waypoint, obstacles: DiagramNode[]): Waypoint[] {
+  // Try L-shape: horizontal first
+  const midL: Waypoint = { x: end.x, y: start.y };
+  if (!anyIntersection(start, midL, obstacles) && !anyIntersection(midL, end, obstacles)) return [midL];
+  // Try L-shape: vertical first
+  const midL2: Waypoint = { x: start.x, y: end.y };
+  if (!anyIntersection(start, midL2, obstacles) && !anyIntersection(midL2, end, obstacles)) return [midL2];
+  // Z-shape
+  const dx = end.x - start.x, dy = end.y - start.y;
+  const offset = 30;
+  const obs = obstacles[0];
+  if (Math.abs(dx) > Math.abs(dy)) {
+    const bypassY = start.y < obs.y ? obs.y - offset : obs.y + obs.height + offset;
+    return [
+      { x: start.x + dx * 0.3, y: start.y },
+      { x: start.x + dx * 0.3, y: bypassY },
+      { x: end.x - dx * 0.1, y: bypassY },
+    ];
+  }
+  const bypassX = start.x < obs.x ? obs.x - offset : obs.x + obs.width + offset;
+  return [
+    { x: start.x, y: start.y + dy * 0.3 },
+    { x: bypassX, y: start.y + dy * 0.3 },
+    { x: bypassX, y: end.y - dy * 0.1 },
+  ];
+}
+
+function anyIntersection(a: Waypoint, b: Waypoint, obstacles: DiagramNode[]): boolean {
+  return obstacles.some(o => lineIntersectsRect(a, b, o));
+}
+
+function lineIntersectsRect(a: Waypoint, b: Waypoint, node: DiagramNode): boolean {
+  const margin = 5;
+  const left = node.x - margin, right = node.x + node.width + margin;
+  const top = node.y - margin, bottom = node.y + node.height + margin;
+  const minX = Math.min(a.x, b.x), maxX = Math.max(a.x, b.x);
+  const minY = Math.min(a.y, b.y), maxY = Math.max(a.y, b.y);
+  if (maxX < left || minX > right || maxY < top || minY > bottom) return false;
+  const code1 = outCode(a.x, a.y, left, top, right, bottom);
+  const code2 = outCode(b.x, b.y, left, top, right, bottom);
+  if (code1 === 0 || code2 === 0) return true;
+  if ((code1 & code2) !== 0) return false;
+  return true;
+}
+
+function outCode(x: number, y: number, l: number, t: number, r: number, b: number): number {
+  let code = 0;
+  if (x < l) code |= 1;
+  if (x > r) code |= 2;
+  if (y < t) code |= 4;
+  if (y > b) code |= 8;
+  return code;
+}
+
+function exitPort(src: DiagramNode, tgt: DiagramNode): Waypoint {
+  const dx = (tgt.x + tgt.width / 2) - (src.x + src.width / 2);
+  const dy = (tgt.y + tgt.height / 2) - (src.y + src.height / 2);
+  if (Math.abs(dx) > Math.abs(dy)) {
+    return dx > 0
+      ? { x: src.x + src.width, y: src.y + src.height / 2 }
+      : { x: src.x, y: src.y + src.height / 2 };
+  }
+  return dy > 0
+    ? { x: src.x + src.width / 2, y: src.y + src.height }
+    : { x: src.x + src.width / 2, y: src.y };
+}
+
+function entryPort(src: DiagramNode, tgt: DiagramNode): Waypoint {
+  const dx = (src.x + src.width / 2) - (tgt.x + tgt.width / 2);
+  const dy = (src.y + src.height / 2) - (tgt.y + tgt.height / 2);
+  if (Math.abs(dx) > Math.abs(dy)) {
+    return dx > 0
+      ? { x: tgt.x + tgt.width, y: tgt.y + tgt.height / 2 }
+      : { x: tgt.x, y: tgt.y + tgt.height / 2 };
+  }
+  return dy > 0
+    ? { x: tgt.x + tgt.width / 2, y: tgt.y + tgt.height }
+    : { x: tgt.x + tgt.width / 2, y: tgt.y };
+}