cgraphx 2.0.2 → 2.0.6

package/dist/core/code/engine/core/ingestion/pipeline-phases/di.js

@@ -0,0 +1,338 @@
+"use strict";
+/**
+ * Phase: di
+ *
+ * Framework-neutral dependency-injection resolution. Per-language resolvers
+ * identify injection sites and provider metadata; this phase performs only
+ * graph-level type/heritage resolution and emits owner/site -> provider INJECTS edges.
+ *
+ * @deps    mro
+ * @reads   graph (Class/Interface/member nodes and heritage/ownership edges)
+ * @writes  graph (INJECTS edges)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diPhase = void 0;
+const index_js_1 = require("../di-extractors/index.js");
+const env_js_1 = require("../utils/env.js");
+const logger_js_1 = require("../../logger.js");
+const AMBIGUOUS = Symbol('ambiguous');
+function addProvidedType(index, language, typeName, providerId) {
+    const byName = index.get(language) ?? new Map();
+    const names = new Set([typeName, typeName.slice(typeName.lastIndexOf('.') + 1)]);
+    for (const name of names) {
+        const providers = byName.get(name) ?? new Set();
+        providers.add(providerId);
+        byName.set(name, providers);
+    }
+    index.set(language, byName);
+}
+function emptyNameIndex() {
+    return { byQualifiedName: new Map(), bySimpleName: new Map() };
+}
+function addIndexedName(index, node) {
+    const qualifiedName = node.properties.qualifiedName;
+    if (typeof qualifiedName === 'string') {
+        index.byQualifiedName.set(qualifiedName, index.byQualifiedName.has(qualifiedName) ? AMBIGUOUS : node.id);
+    }
+    const simpleName = node.properties.name;
+    index.bySimpleName.set(simpleName, index.bySimpleName.has(simpleName) ? AMBIGUOUS : node.id);
+}
+function resolveIndexedName(index, name) {
+    if (index === undefined)
+        return undefined;
+    return name.includes('.') ? index.byQualifiedName.get(name) : index.bySimpleName.get(name);
+}
+function providerCandidates(ids, providers) {
+    const all = [...ids];
+    const recognized = all.filter((id) => providers.has(id));
+    // Recall-first fallback: provider metadata can be incomplete (custom
+    // registration mechanisms and legacy indexes can omit it). Prefer
+    // framework-recognized providers when present, but keep structurally valid
+    // candidates when none are known instead of dropping the injection entirely.
+    return recognized.length > 0 ? recognized : all;
+}
+exports.diPhase = {
+    name: 'di',
+    deps: ['mro'],
+    async execute(ctx) {
+        ctx.onProgress({
+            phase: 'enriching',
+            percent: 98,
+            message: 'Resolving dependency-injection edges...',
+            stats: { filesProcessed: 0, totalFiles: 0, nodesCreated: ctx.graph.nodeCount },
+        });
+        const candidates = [];
+        const providers = new Map();
+        const providedTypes = new Map();
+        const providerNames = new Map();
+        const providerNodes = new Map();
+        const providersByDeclarer = new Map();
+        ctx.graph.forEachNode((node) => {
+            const language = node.properties.language;
+            if (language === undefined || !(0, index_js_1.isSupportedLanguage)(language))
+                return;
+            const resolver = index_js_1.DI_RESOLVERS.get(language);
+            if (resolver === undefined)
+                return;
+            const provider = resolver.matchProvider(node);
+            if (provider !== null) {
+                providers.set(node.id, provider);
+                providerNodes.set(node.id, node);
+                const namesByLanguage = providerNames.get(language) ?? new Map();
+                for (const name of provider.names) {
+                    const namedProviders = namesByLanguage.get(name) ?? new Set();
+                    namedProviders.add(node.id);
+                    namesByLanguage.set(name, namedProviders);
+                }
+                providerNames.set(language, namesByLanguage);
+                if (provider.providedTypeName !== undefined) {
+                    addProvidedType(providedTypes, language, provider.providedTypeName, node.id);
+                }
+                if (provider.declaredByNodeId !== undefined) {
+                    const declared = providersByDeclarer.get(provider.declaredByNodeId) ?? new Set();
+                    declared.add(node.id);
+                    providersByDeclarer.set(provider.declaredByNodeId, declared);
+                }
+            }
+            for (const match of resolver.matchInjectionSites(node)) {
+                candidates.push({ ...match, siteNodeId: node.id, language });
+            }
+        });
+        if (candidates.length === 0) {
+            return {
+                injectsEdges: 0,
+                fieldsScanned: 0,
+                ambiguousSkipped: 0,
+                ambiguousInjections: 0,
+            };
+        }
+        const interfaceToImplementers = new Map();
+        const directSupertypes = new Map();
+        for (const rel of ctx.graph.iterRelationshipsByType('IMPLEMENTS')) {
+            const set = interfaceToImplementers.get(rel.targetId) ?? new Set();
+            set.add(rel.sourceId);
+            interfaceToImplementers.set(rel.targetId, set);
+            const supertypes = directSupertypes.get(rel.sourceId) ?? new Set();
+            supertypes.add(rel.targetId);
+            directSupertypes.set(rel.sourceId, supertypes);
+        }
+        for (const rel of ctx.graph.iterRelationshipsByType('EXTENDS')) {
+            const supertypes = directSupertypes.get(rel.sourceId) ?? new Set();
+            supertypes.add(rel.targetId);
+            directSupertypes.set(rel.sourceId, supertypes);
+        }
+        const memberToClass = new Map();
+        for (const relationType of ['HAS_PROPERTY', 'HAS_METHOD']) {
+            for (const rel of ctx.graph.iterRelationshipsByType(relationType)) {
+                memberToClass.set(rel.targetId, rel.sourceId);
+            }
+        }
+        const candidateLanguages = new Set(candidates.map((candidate) => candidate.language));
+        const interfacesByLanguage = new Map();
+        const classesByLanguage = new Map();
+        ctx.graph.forEachNode((node) => {
+            if (node.label !== 'Class' && node.label !== 'Interface')
+                return;
+            const language = node.properties.language;
+            if (typeof language !== 'string' || !candidateLanguages.has(language))
+                return;
+            const indexes = node.label === 'Class' ? classesByLanguage : interfacesByLanguage;
+            const index = indexes.get(language) ?? emptyNameIndex();
+            addIndexedName(index, node);
+            indexes.set(language, index);
+            if (node.label === 'Class')
+                providerNodes.set(node.id, node);
+        });
+        // A declaration returning a concrete class is assignable to every class or
+        // interface that type extends/implements. Expand once per language+type and
+        // register the declaration under those ancestor names. This keeps named
+        // selection fast (set intersection below) while allowing, for example, a
+        // `DefaultGateway` Bean to satisfy a named `Gateway` Resource site.
+        const assignableNamesByProvidedType = new Map();
+        for (const [providerId, provider] of providers) {
+            if (provider.providedTypeName === undefined)
+                continue;
+            const providerNode = providerNodes.get(providerId);
+            const language = providerNode?.properties.language;
+            if (typeof language !== 'string')
+                continue;
+            const cacheKey = `${language}\0${provider.providedTypeName}`;
+            let assignableTypeNames = assignableNamesByProvidedType.get(cacheKey);
+            if (assignableTypeNames === undefined) {
+                const classEntry = resolveIndexedName(classesByLanguage.get(language), provider.providedTypeName);
+                const interfaceEntry = resolveIndexedName(interfacesByLanguage.get(language), provider.providedTypeName);
+                const rootTypeId = typeof classEntry === 'string' && interfaceEntry === undefined
+                    ? classEntry
+                    : typeof interfaceEntry === 'string' && classEntry === undefined
+                        ? interfaceEntry
+                        : undefined;
+                const names = new Set();
+                if (rootTypeId !== undefined) {
+                    const queue = [rootTypeId];
+                    const visited = new Set();
+                    while (queue.length > 0) {
+                        const typeId = queue.pop();
+                        if (typeId === undefined)
+                            continue;
+                        if (visited.has(typeId))
+                            continue;
+                        visited.add(typeId);
+                        const typeNode = ctx.graph.getNode(typeId);
+                        if ((typeNode?.label === 'Class' || typeNode?.label === 'Interface') &&
+                            typeNode.properties.language === language) {
+                            names.add(typeNode.properties.name);
+                            const qualifiedName = typeNode.properties.qualifiedName;
+                            if (typeof qualifiedName === 'string')
+                                names.add(qualifiedName);
+                        }
+                        for (const supertypeId of directSupertypes.get(typeId) ?? []) {
+                            queue.push(supertypeId);
+                        }
+                    }
+                }
+                assignableTypeNames = [...names];
+                assignableNamesByProvidedType.set(cacheKey, assignableTypeNames);
+            }
+            for (const typeName of assignableTypeNames) {
+                addProvidedType(providedTypes, language, typeName, providerId);
+            }
+        }
+        let ambiguousSkipped = 0;
+        let ambiguousInjections = 0;
+        const ambiguousTypeNames = new Set();
+        const pending = new Map();
+        const queueEdge = (edge) => {
+            if (edge.sourceId === edge.targetId)
+                return;
+            const id = `INJECTS:${edge.sourceId}->${edge.targetId}`;
+            const existing = pending.get(id);
+            if (existing === undefined || edge.confidence > existing.confidence)
+                pending.set(id, edge);
+        };
+        for (const candidate of candidates) {
+            const siteNode = ctx.graph.getNode(candidate.siteNodeId);
+            const consumerClassId = siteNode?.label === 'Class' ? siteNode.id : memberToClass.get(candidate.siteNodeId);
+            if (consumerClassId === undefined)
+                continue;
+            const edgeSourceId = candidate.edgeSource === 'site' && siteNode !== undefined ? siteNode.id : consumerClassId;
+            const classEntry = resolveIndexedName(classesByLanguage.get(candidate.language), candidate.targetTypeName);
+            const interfaceEntry = resolveIndexedName(interfacesByLanguage.get(candidate.language), candidate.targetTypeName);
+            if (classEntry === AMBIGUOUS ||
+                interfaceEntry === AMBIGUOUS ||
+                (classEntry !== undefined && interfaceEntry !== undefined)) {
+                // A simple/qualified name claimed by both a Class and an Interface is
+                // type-ambiguous too. Fail closed rather than guessing which Java type
+                // the injection site meant; import-aware disambiguation is not
+                // available in this graph-only phase. This intentionally applies to
+                // legacy collection sites too: a Class/Interface collision no longer
+                // fans out through the interface on a simple-name guess.
+                ambiguousSkipped++;
+                ambiguousTypeNames.add(candidate.targetTypeName);
+                continue;
+            }
+            const structural = new Set();
+            if (typeof classEntry === 'string')
+                structural.add(classEntry);
+            if (typeof interfaceEntry === 'string') {
+                for (const id of interfaceToImplementers.get(interfaceEntry) ?? [])
+                    structural.add(id);
+            }
+            for (const id of providedTypes.get(candidate.language)?.get(candidate.targetTypeName) ?? []) {
+                structural.add(id);
+            }
+            for (const id of providersByDeclarer.get(edgeSourceId) ?? [])
+                structural.delete(id);
+            structural.delete(consumerClassId);
+            structural.delete(edgeSourceId);
+            if (structural.size === 0)
+                continue;
+            const namedSelection = candidate.namedSelection;
+            let usedNamedSelection = false;
+            let selectionSuffix = '';
+            let viable;
+            if (namedSelection !== undefined) {
+                const named = [
+                    ...(providerNames.get(candidate.language)?.get(namedSelection.name) ?? []),
+                ].filter((id) => structural.has(id));
+                if (named.length > 0) {
+                    viable = named;
+                    usedNamedSelection = true;
+                    selectionSuffix = `; ${namedSelection.reason}`;
+                }
+                else if (namedSelection.fallbackToType === true) {
+                    viable = providerCandidates(structural, providers);
+                    selectionSuffix = `; ${namedSelection.reason} unmatched; type fallback`;
+                }
+                else {
+                    continue;
+                }
+            }
+            else {
+                viable = providerCandidates(structural, providers);
+            }
+            if (candidate.cardinality === 'collection') {
+                const confidence = usedNamedSelection ? 0.9 : 0.8;
+                for (const targetId of viable) {
+                    queueEdge({
+                        sourceId: edgeSourceId,
+                        targetId,
+                        confidence,
+                        reason: candidate.reason + selectionSuffix,
+                    });
+                }
+                continue;
+            }
+            if (viable.length === 1) {
+                queueEdge({
+                    sourceId: edgeSourceId,
+                    targetId: viable[0],
+                    confidence: usedNamedSelection ? 0.95 : namedSelection === undefined ? 0.9 : 0.85,
+                    reason: candidate.reason + selectionSuffix,
+                });
+                continue;
+            }
+            const preferred = viable.flatMap((id) => {
+                const reason = providers.get(id)?.preferenceReason;
+                return reason === undefined ? [] : [{ id, reason }];
+            });
+            if (!usedNamedSelection && preferred.length === 1) {
+                const selected = preferred[0];
+                queueEdge({
+                    sourceId: edgeSourceId,
+                    targetId: selected.id,
+                    confidence: 0.95,
+                    reason: `${candidate.reason}${selectionSuffix}; ${selected.reason}`,
+                });
+                continue;
+            }
+            ambiguousInjections++;
+            const candidateNames = viable
+                .map((id) => providerNodes.get(id)?.properties.name ?? id)
+                .sort()
+                .join(', ');
+            for (const targetId of viable) {
+                queueEdge({
+                    sourceId: edgeSourceId,
+                    targetId,
+                    confidence: 0.5,
+                    reason: `${candidate.reason}${selectionSuffix}; ambiguous candidates: ${candidateNames}`,
+                });
+            }
+        }
+        for (const [id, edge] of pending) {
+            ctx.graph.addRelationship({ id, type: 'INJECTS', ...edge });
+        }
+        if (env_js_1.isDev && ambiguousSkipped > 0) {
+            logger_js_1.logger.debug(`DI: ${ambiguousSkipped} site(s) skipped because requested type names were ambiguous: ${[...ambiguousTypeNames].sort().join(', ')}`);
+        }
+        if (env_js_1.isDev && (pending.size > 0 || ambiguousInjections > 0)) {
+            logger_js_1.logger.info(`DI: ${pending.size} INJECTS edges from ${candidates.length} injection sites (${ambiguousInjections} ambiguous single-site resolutions)`);
+        }
+        return {
+            injectsEdges: pending.size,
+            fieldsScanned: candidates.length,
+            ambiguousSkipped,
+            ambiguousInjections,
+        };
+    },
+};

package/dist/core/code/engine/core/ingestion/pipeline-phases/http-api-calls.js

@@ -0,0 +1,312 @@
+"use strict";
+/**
+ * Phase: httpApiCalls
+ *
+ * Detects HTTP API calls from frontend TypeScript/JavaScript files to
+ * backend @Center-annotated interfaces. Extracts API URLs from frontend
+ * code, splits them by known centerName prefixes, and matches to backend
+ * Method nodes in the knowledge graph.
+ *
+ * @deps    parse, rpcEdges
+ * @reads   graph (Interface nodes with @Center, Method nodes, HAS_METHOD edges), filesystem
+ * @writes  graph (HTTP_CALLS edges, ExternalService nodes)
+ * @output  HttpApiCallsOutput
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpApiCallsPhase = void 0;
+exports.extractApiUrls = extractApiUrls;
+exports.splitUrlSegment = splitUrlSegment;
+const workspace_config_js_1 = require("../workspace-config.js");
+const utils_js_1 = require("../../../lib/utils.js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+// ── Exported pure functions (for testing) ──────────────────────────────────────
+/**
+ * Extract API URLs from all .ts/.js files under apiDir.
+ *
+ * Recognized patterns:
+ *   Pattern A: url: `${varName}/prefix_methodName`  (template literal with variable)
+ *   Pattern B: url: "/hardcoded/path/prefix_methodName"  (hardcoded string)
+ *   Pattern C: url: `${varName}methodName`  (variable already contains prefix)
+ */
+function extractApiUrls(apiDir) {
+    const results = [];
+    const files = listFilesRecursive(apiDir);
+    for (const filePath of files) {
+        try {
+            const content = (0, node_fs_1.readFileSync)(filePath, 'utf-8');
+            const relativePath = filePath.slice(apiDir.length).replace(/^\//, '');
+            // Collect local string constants (for template variable resolution)
+            const localConstants = new Map();
+            for (const m of content.matchAll(/(?:const|let|var)\s+(\w+)\s*=\s*[`"']([^`"']+)[`"']/g)) {
+                localConstants.set(m[1], m[2]);
+            }
+            // Pattern A: `${varName}/prefix_method` (template with slash)
+            for (const m of content.matchAll(/url:\s*['"`]\$\{(\w+)\}\/?([a-zA-Z0-9_-]+)['"`]/g)) {
+                const varName = m[1];
+                const segment = m[2];
+                const servicePath = localConstants.get(varName) ?? '';
+                if (servicePath.startsWith('/')) {
+                    results.push({ servicePath, lastSegment: segment, sourceFile: relativePath });
+                }
+            }
+            // Pattern B: "/hardcoded/path/prefix_method"
+            for (const m of content.matchAll(/url:\s*['"`]\/((?:[^/${}'"`]+\/)+)([a-zA-Z0-9_-]+)['"`]/g)) {
+                const pathPart = '/' + m[1].replace(/\/$/, '');
+                const segment = m[2];
+                results.push({ servicePath: pathPart, lastSegment: segment, sourceFile: relativePath });
+            }
+            // Pattern C: `${varName}methodName` (no slash — serviceName already contains prefix)
+            for (const m of content.matchAll(/url:\s*['"`]\$\{(\w+)\}([a-zA-Z0-9_-]+)['"`]/g)) {
+                const varName = m[1];
+                const segment = m[2];
+                const servicePath = localConstants.get(varName) ?? '';
+                if (servicePath.startsWith('/') && !servicePath.endsWith('/')) {
+                    results.push({ servicePath, lastSegment: segment, sourceFile: relativePath });
+                }
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    // Deduplicate by (servicePath, lastSegment)
+    const seen = new Set();
+    return results.filter((u) => {
+        const key = `${u.servicePath}|${u.lastSegment}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/**
+ * Split a URL last segment into (centerName, methodName) using the longest
+ * matching centerName prefix from the known list.
+ *
+ * IMPORTANT: The centerNames list MUST be sorted by length descending
+ * (longest first) so that "sopub_api" matches before "so_api" etc.
+ */
+function splitUrlSegment(lastSegment, centerNamesSorted) {
+    for (const cn of centerNamesSorted) {
+        if (lastSegment.startsWith(cn) && lastSegment.length > cn.length &&
+            lastSegment[cn.length] === '_') {
+            return {
+                centerName: cn,
+                methodName: lastSegment.slice(cn.length + 1),
+            };
+        }
+    }
+    return null;
+}
+// ── Internal helpers ──────────────────────────────────────────────────────────
+function listFilesRecursive(dir) {
+    const results = [];
+    try {
+        const entries = (0, node_fs_1.readdirSync)(dir);
+        for (const entry of entries) {
+            const full = (0, node_path_1.join)(dir, entry);
+            const stat = (0, node_fs_1.statSync)(full);
+            if (stat.isDirectory()) {
+                results.push(...listFilesRecursive(full));
+            }
+            else if (/\.(ts|js)$/.test(entry) && !entry.endsWith('.d.ts')) {
+                results.push(full);
+            }
+        }
+    }
+    catch {
+        // Directory not readable
+    }
+    return results;
+}
+// ── ExternalService node helper ──────────────────────────────────────────────
+function ensureExternalServiceNode(graph, serviceId) {
+    const nodeId = (0, utils_js_1.generateId)('ExternalService', serviceId);
+    if (!graph.getNode(nodeId)) {
+        graph.addNode({
+            id: nodeId,
+            label: 'ExternalService',
+            properties: {
+                name: serviceId,
+                filePath: '',
+                description: `External RPC service: ${serviceId}`,
+            },
+        });
+    }
+    return nodeId;
+}
+// ── Pipeline phase ────────────────────────────────────────────────────────────
+exports.httpApiCallsPhase = {
+    name: 'httpApiCalls',
+    deps: ['parse', 'rpcEdges'],
+    async execute(ctx, _deps) {
+        const config = (0, workspace_config_js_1.loadWorkspaceConfig)(ctx.repoPath);
+        if (!config?.httpApi) {
+            return { edges: [], matchedEdges: 0, unmatchedEdges: 0, externalServiceNodes: 0 };
+        }
+        const { frontends, serviceMapping } = config.httpApi;
+        // Step 1: Collect known centerNames from @Center annotations in the graph
+        const centerNames = new Set();
+        const providerRegex = new RegExp(config.annotations.rpc.provider.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+            '\\s*\\(\\s*(?:(?:value|)\\s*=\\s*)?["\']([^"\']+)["\']');
+        ctx.graph.forEachNode((node) => {
+            if (node.label !== 'Interface')
+                return;
+            const filePath = node.properties?.filePath;
+            if (!filePath)
+                return;
+            try {
+                const full = (0, node_fs_1.readFileSync)((0, node_path_1.join)(ctx.repoPath, filePath), 'utf-8');
+                const header = full.split('\n').slice(0, 50).join('\n');
+                const match = header.match(providerRegex);
+                if (match)
+                    centerNames.add(match[1]);
+            }
+            catch {
+                // unreadable
+            }
+        });
+        // Sort by length descending for longest-prefix matching
+        const centerNamesSorted = [...centerNames].sort((a, b) => b.length - a.length);
+        // Step 2: Build backend method index: (centerName, methodName) -> methodNodeId[]
+        const backendMethodIndex = new Map();
+        const methodsByParent = new Map();
+        ctx.graph.forEachRelationship((rel) => {
+            if (rel.type === 'HAS_METHOD') {
+                let list = methodsByParent.get(rel.sourceId);
+                if (!list) {
+                    list = [];
+                    methodsByParent.set(rel.sourceId, list);
+                }
+                const targetNode = ctx.graph.getNode(rel.targetId);
+                if (targetNode) {
+                    list.push({ id: targetNode.id, name: targetNode.properties?.name });
+                }
+            }
+        });
+        ctx.graph.forEachNode((node) => {
+            if (node.label !== 'Interface')
+                return;
+            const filePath = node.properties?.filePath;
+            if (!filePath)
+                return;
+            try {
+                const full = (0, node_fs_1.readFileSync)((0, node_path_1.join)(ctx.repoPath, filePath), 'utf-8');
+                const header = full.split('\n').slice(0, 50).join('\n');
+                const match = header.match(providerRegex);
+                if (!match)
+                    return;
+                const cn = match[1];
+                const methods = methodsByParent.get(node.id) ?? [];
+                let serviceMap = backendMethodIndex.get(cn);
+                if (!serviceMap) {
+                    serviceMap = new Map();
+                    backendMethodIndex.set(cn, serviceMap);
+                }
+                const normalized = filePath.replace(/\\/g, '/');
+                const svcDir = normalized.split('/')[0];
+                for (const m of methods) {
+                    let arr = serviceMap.get(m.name);
+                    if (!arr) {
+                        arr = [];
+                        serviceMap.set(m.name, arr);
+                    }
+                    arr.push({ methodId: m.id, serviceDir: svcDir });
+                }
+            }
+            catch {
+                // unreadable
+            }
+        });
+        // Step 3: Extract frontend API URLs
+        const allUrls = [];
+        for (const frontend of frontends) {
+            const apiDir = (0, node_path_1.join)(ctx.repoPath, frontend.dir, frontend.apiDir);
+            const urls = extractApiUrls(apiDir);
+            allUrls.push(...urls);
+        }
+        // Step 4: Match URLs to backend methods and create HTTP_CALLS edges
+        const edges = [];
+        let matchedEdges = 0;
+        let unmatchedEdges = 0;
+        const externalServiceIds = new Set();
+        for (const url of allUrls) {
+            const split = splitUrlSegment(url.lastSegment, centerNamesSorted);
+            if (!split)
+                continue;
+            const { centerName, methodName } = split;
+            const serviceMap = backendMethodIndex.get(centerName);
+            if (!serviceMap) {
+                const extNodeId = ensureExternalServiceNode(ctx.graph, centerName);
+                externalServiceIds.add(centerName);
+                ctx.graph.addRelationship({
+                    id: (0, utils_js_1.generateId)('HTTP_CALLS', `frontend:${url.sourceFile}:${centerName}:${methodName}->${extNodeId}`),
+                    sourceId: extNodeId,
+                    targetId: extNodeId,
+                    type: 'HTTP_CALLS',
+                    confidence: 0.5,
+                    reason: `http:unmatched:${centerName}:${methodName}`,
+                });
+                unmatchedEdges++;
+                continue;
+            }
+            const candidates = serviceMap.get(methodName);
+            if (!candidates || candidates.length === 0) {
+                unmatchedEdges++;
+                edges.push({
+                    frontendFile: url.sourceFile,
+                    centerName,
+                    methodName,
+                    backendMethodId: null,
+                    backendServiceDir: null,
+                });
+                continue;
+            }
+            let target;
+            if (candidates.length === 1) {
+                target = candidates[0];
+            }
+            else if (serviceMapping?.[url.servicePath]) {
+                const expectedDir = serviceMapping[url.servicePath];
+                const filtered = candidates.filter((c) => c.serviceDir === expectedDir);
+                if (filtered.length === 1)
+                    target = filtered[0];
+            }
+            if (!target) {
+                unmatchedEdges++;
+                edges.push({
+                    frontendFile: url.sourceFile,
+                    centerName,
+                    methodName,
+                    backendMethodId: null,
+                    backendServiceDir: null,
+                });
+                continue;
+            }
+            const edgeId = (0, utils_js_1.generateId)('HTTP_CALLS', `${url.sourceFile}:${centerName}:${methodName}->${target.methodId}`);
+            ctx.graph.addRelationship({
+                id: edgeId,
+                sourceId: target.methodId,
+                targetId: target.methodId,
+                type: 'HTTP_CALLS',
+                confidence: 1.0,
+                reason: `http:${centerName}:${methodName}`,
+            });
+            matchedEdges++;
+            edges.push({
+                frontendFile: url.sourceFile,
+                centerName,
+                methodName,
+                backendMethodId: target.methodId,
+                backendServiceDir: target.serviceDir,
+            });
+        }
+        return {
+            edges,
+            matchedEdges,
+            unmatchedEdges,
+            externalServiceNodes: externalServiceIds.size,
+        };
+    },
+};