Function parse_flowchart

backend/mermaid_parser.py:242–344

Parse flowchart lines into nodes and edges. Only creates nodes from proper shape definitions (not from edge references). Only includes edges where both endpoints are properly defined nodes.

(lines: List[str], metadata: Dict[str, Any])

def parse_flowchart(lines: List[str], metadata: Dict[str, Any]) -> Tuple[List[GraphNode], List[GraphEdge]]:
    """Parse flowchart lines into nodes and edges.

    Only creates nodes from proper shape definitions (not from edge references).
    Only includes edges where both endpoints are properly defined nodes.
    """
    nodes: Dict[str, GraphNode] = {}
    raw_edges: List[Tuple[str, str, Optional[str]]] = []  # (source, target, label)

    # Patterns for node shapes - ORDER MATTERS (more specific first)
    # [label] = step, ([label]) = llm, {label} = decision
    # Node ID pattern: matches path::function or path::function::line format
    # Uses [^\s\[\](){}]+ to match IDs like "main.py::handle", "backend/client.py::call_llm::42"
    node_id = r'([^\s\[\](){}]+)'
    node_patterns = [
        (node_id + r'\[\[([^\]]+)\]\]', 'step'),      # A[[label]] - subroutine
        (node_id + r'\(\[([^\]]+)\]\)', 'llm'),       # A([label]) - stadium/llm
        (node_id + r'\{([^}]+)\}', 'decision'),       # A{label} - diamond
        (node_id + r'\[([^\]]+)\]', 'step'),          # A[label] - rectangle
        (node_id + r'\(([^)]+)\)', 'step'),           # A(label) - rounded
    ]

    # Edge pattern: A --> B, A -->|label| B
    # Node IDs can contain path/function/line separators (. / :: -)
    # Match ID chars including '-', relying on shape suffix or whitespace to delimit
    edge_id = r'[^\s\[\](){}|>]+'
    edge_pattern = rf'({edge_id})(?:\[[^\]]*\]|\(\[[^\]]*\]\)|\{{[^}}]*\}}|\([^)]*\))?\s*-->\s*(?:\|([^|]*)\|)?\s*({edge_id})'

    for line in lines:
        # First pass: Extract node definitions with shapes
        for pattern, node_type in node_patterns:
            for match in re.finditer(pattern, line):
                node_id = match.group(1)
                label = match.group(2).strip()
                # Strip any remaining square/curly brackets from label (but NOT parentheses - used in model names)
                label = label.strip('[]{}')

                # Create node (first match wins - patterns are ordered specific to general)
                if node_id not in nodes:
                    nodes[node_id] = GraphNode(id=node_id, label=label, type=node_type)

        # Second pass: Extract edges
        edge_matches = re.findall(edge_pattern, line)
        for match in edge_matches:
            source = match[0]
            label = match[1] if len(match) > 1 and match[1] else None
            target = match[2] if len(match) > 2 else None

            if source and target:
                raw_edges.append((source, target, label.strip() if label else None))

    # Valid node types - normalize anything else to 'step'
    VALID_TYPES = {'step', 'llm', 'decision'}

    # Enrich nodes with metadata
    for node_id, node in nodes.items():
        if node_id in metadata:
            meta = metadata[node_id]