Function runHttpScan

frontend/src/analysis/workspace.ts:184–311

()

        // HTTP scan helper — extracts connections, discovers handler/client files
        let httpConnectionsContext = '';
        const runHttpScan = async () => {
            log(`\nScanning all source files for HTTP connections...`);
            webview.updateLoadingText('Scanning HTTP connections...', `Reading source files`);
            const httpScanSourceFiles = await WorkflowDetector.getAllSourceFiles();
            const httpSourceContents: { path: string; content: string }[] = [];
            let httpScanned = 0;

            for (const uri of httpScanSourceFiles) {
                const relativePath = vscode.workspace.asRelativePath(uri, false);
                if (!workflowPaths.has(relativePath)) {
                    try {
                        const content = await vscode.workspace.fs.readFile(uri);
                        httpSourceContents.push({
                            path: relativePath,
                            content: Buffer.from(content).toString('utf8')
                        });
                    } catch (error) {
                        // Skip files that can't be read
                    }
                }
                httpScanned++;
                if (httpScanned % 100 === 0 || httpScanned === httpScanSourceFiles.length) {
                    webview.updateLoadingText(
                        'Scanning HTTP connections...',
                        `${httpScanned.toLocaleString()} / ${httpScanSourceFiles.length.toLocaleString()} files read`
                    );
                }
            }

            const allFilesForHttpExtraction = [...allFileContents, ...httpSourceContents];
            webview.updateLoadingText('Extracting HTTP connections...', `Processing ${allFilesForHttpExtraction.length.toLocaleString()} files`);
            log(`Scanning ${allFilesForHttpExtraction.length} files (${allFileContents.length} LLM + ${httpSourceContents.length} other)`);

            const rawHttpStructure = extractRepoStructure(allFilesForHttpExtraction);
            const allHttpConnections = rawHttpStructure.httpConnections;
            setHttpConnections(allHttpConnections);
            setCrossFileCalls(rawHttpStructure.crossFileCalls || []);
            setRepoFiles(rawHttpStructure.files.map(f => ({
                path: f.path,
                functions: f.functions.map(fn => ({ name: fn.name, calls: fn.calls, line: fn.line }))
            })));
            pipelineStats.analyzed.httpConnections = allHttpConnections.length;
            pipelineStats.detected.httpFiles = httpSourceContents.length;
            httpConnectionsContext = formatHttpConnectionsForPrompt(rawHttpStructure);
            if (allHttpConnections.length > 0) {
                log(`Found ${allHttpConnections.length} HTTP connection(s) between services:`);
                for (const conn of allHttpConnections) {
                    log(`  ${vscode.workspace.asRelativePath(conn.client.file)}::${conn.client.function} → ${vscode.workspace.asRelativePath(conn.handler.file)}::${conn.handler.function}`);
                    log(`    (${conn.client.method} ${conn.client.normalizedPath})`);
                }
            } else {
                log(`No HTTP connections detected`);
            }

            // Discover additional files via HTTP handler tracing (only needed for first run)
            if (isFirstRun) {
                const allHttpHandlers = new Set<string>();
                for (const conn of allHttpConnections) {