Method setAnalysisResult

frontend/src/cache.ts:426–683

* Store analysis result, splitting by file * Node IDs are deterministic (file__function format) so no prefixing needed

(
        graph: WorkflowGraph,
        contents: Record<string, string>
    )

     * Node IDs are deterministic (file__function format) so no prefixing needed
     */
    async setAnalysisResult(
        graph: WorkflowGraph,
        contents: Record<string, string>
    ): Promise<void> {
        await this.initPromise;

        // Helper to check if a relative path matches any content key
        const isInBatch = (relativePath: string): boolean => {
            if (contents[relativePath]) return true;
            const normalizedRel = relativePath.replace(/\\/g, '/').replace(/^\//, '');
            for (const fullPath of Object.keys(contents)) {
                const normalizedFull = fullPath.replace(/\\/g, '/');
                if (normalizedFull === normalizedRel) return true;
                if (normalizedFull.endsWith('/' + normalizedRel)) return true;
                if (normalizedFull.endsWith(normalizedRel)) return true;
            }
            return false;
        };

        // Filter nodes to only those for files in this batch
        // LLM sometimes creates symbolic nodes (Frontend_UI, Telnyx_API) — skip them.
        // Also skip nodes for files not in this batch.
        const filteredNodes: WorkflowNode[] = [];
        const skippedNodes: WorkflowNode[] = [];
        for (const node of graph.nodes) {
            const file = node.source?.file || 'unknown';
            // Skip symbolic/unknown nodes — they're not real code locations
            if (file === 'unknown' || !file.includes('.')) {
                skippedNodes.push(node);
            } else if (isInBatch(file)) {
                filteredNodes.push(node);
            } else {
                skippedNodes.push(node);
            }
        }

        // Build node lookup from filtered nodes
        const nodeById = new Map<string, WorkflowNode>();
        const nodeToFile = new Map<string, string>();

        for (const node of filteredNodes) {
            nodeById.set(node.id, node);
            const file = node.source?.file || 'unknown';
            nodeToFile.set(node.id, file);
        }

        // Group nodes by file (IDs are already deterministic)
        const nodesByFile = new Map<string, WorkflowNode[]>();
        for (const node of filteredNodes) {
            const file = node.source?.file || 'unknown';
            if (!nodesByFile.has(file)) nodesByFile.set(file, []);
            nodesByFile.get(file)!.push(node);
        }

        // Categorize edges
        const internalEdgesByFile = new Map<string, WorkflowEdge[]>();
        const newCrossFileEdges: CrossFileEdge[] = [];