Function analyzeBatch

frontend/src/analysis/workspace.ts:723–894

(
                    batch: { path: string; content: string; }[],
                    batchIndex: number,
                    totalBatches: number,
                    allMetadata: any[],
                    graphs: any[],
                    costTracker: CostAggregator,
                    condensedStructureParam?: string,
                    httpConnectionsContextParam?: string
                )

                // Inner function to analyze a single batch
                async function analyzeBatch(
                    batch: { path: string; content: string; }[],
                    batchIndex: number,
                    totalBatches: number,
                    allMetadata: any[],
                    graphs: any[],
                    costTracker: CostAggregator,
                    condensedStructureParam?: string,
                    httpConnectionsContextParam?: string
                ): Promise<WorkflowGraph | null> {
                    const batchPaths = batch.map(f => f.path);
                    const batchMetadata = allMetadata.filter(m => batchPaths.includes(vscode.workspace.asRelativePath(m.file, false)));

                    // Detect framework for THIS batch (use first detected in batch)
                    let batchFramework: string | null = null;
                    for (const file of batch) {
                        batchFramework = WorkflowDetector.detectFramework(file.content);
                        if (batchFramework) break;
                    }

                    // Combine batch files for analysis in XML format
                    const combinedBatchCode = combineFilesXML(batch, batchMetadata);
                    const batchTokens = estimateTokens(combinedBatchCode);

                    log(`\nAnalyzing batch ${batchIndex + 1}/${totalBatches} (${batch.length} files, ~${Math.round(batchTokens / 1000)}k tokens)...`);
                    log(`Files in batch:`);
                    batch.forEach(f => {
                        const relativePath = vscode.workspace.asRelativePath(f.path);
                        const sizeKb = Math.round(f.content.length / 1024);
                        log(`  - ${relativePath} (${sizeKb} KB)`);
                    });

                    try {

                        log(`Sending POST /analyze: ${batch.length} file(s), ~${Math.round(batchTokens / 1000)}k tokens, framework: ${batchFramework || 'none'}${condensedStructureParam ? ', with cross-batch context' : ''}${httpConnectionsContextParam ? ', with HTTP connections' : ''}`);
                        const batchResult = await api.analyzeWorkflow(
                            combinedBatchCode,
                            batchPaths,
                            batchFramework || undefined,
                            batchMetadata,
                            condensedStructureParam,
                            httpConnectionsContextParam
                        );

                        // Check if session was invalidated (cache cleared) during request
                        if (getAnalysisSession() !== sessionAtStart) {
                            log(`Batch ${batchIndex + 1} result discarded (session invalidated)`);
                            return null;
                        }

                        const batchGraph = batchResult.graph;


                        // Track actual cost from API
                        costTracker.add('analyze', batch.length, batchResult.usage, batchResult.cost, batchIndex);

                        // Track tokens for legacy logging (accumulate in outer scope)
                        totalInputTokens += batchTokens;