Method computeWorkflows

frontend/src/cache.ts:940–1312

* Compute workflows using LLM-assigned workflow names per file, * with hub detection for end-to-end shared service inclusion. * Falls back to connectivity-based grouping if no assignments exist.

(nodes: WorkflowNode[], edges: WorkflowEdge[])

     * Falls back to connectivity-based grouping if no assignments exist.
     */
    private computeWorkflows(nodes: WorkflowNode[], edges: WorkflowEdge[]): WorkflowMetadata[] {
        // Phase 1: Group nodes by stored workflow name (per-node from LLM analysis)
        const workflowGroups = new Map<string, { id: string; name: string; description?: string; nodeIds: string[] }>();
        let hasAnyAssignment = false;

        for (const node of nodes) {
            const file = node.source?.file;
            if (!file) continue;
            const normalizedFile = this.toRelativePath(file);
            const cached = this.files[normalizedFile];
            const wfAssignment = cached?.nodeWorkflows?.[node.id];
            if (wfAssignment) {
                hasAnyAssignment = true;
                const key = wfAssignment.name;
                if (!workflowGroups.has(key)) {
                    workflowGroups.set(key, {
                        id: wfAssignment.id || `workflow_${workflowGroups.size}`,
                        name: key,
                        description: this.workflows[wfAssignment.id || '']?.description,
                        nodeIds: []
                    });
                }
                workflowGroups.get(key)!.nodeIds.push(node.id);
            }
        }

        // Fallback: if no files have workflow assignments, use connectivity-based grouping
        if (!hasAnyAssignment) {
            return this.computeWorkflowsByConnectivity(nodes, edges);
        }

        // Phase 2: Iteratively assign orphan nodes via edges until no more changes
        // This handles chains like A→B→C where only A is initially assigned
        const assignedNodes = new Set(
            [...workflowGroups.values()].flatMap(g => g.nodeIds)
        );

        let changed = true;
        let iterations = 0;
        const maxIterations = 20; // Prevent infinite loops

        while (changed && iterations < maxIterations) {
            changed = false;
            iterations++;

            for (const node of nodes) {
                if (assignedNodes.has(node.id)) continue;

                // Find any edge connecting this node to an assigned node
                const connectedEdge = edges.find(
                    e => (e.source === node.id && assignedNodes.has(e.target)) ||
                         (e.target === node.id && assignedNodes.has(e.source))
                );

                if (connectedEdge) {
                    const assignedId = connectedEdge.source === node.id
                        ? connectedEdge.target : connectedEdge.source;
                    for (const wf of workflowGroups.values()) {