@supermodeltools/mcp-server 0.4.3 → 0.4.4

package/dist/queries/index.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * Query dispatcher - routes queries to appropriate handlers
+ * Central entry point for the query engine
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphCache = void 0;
+exports.executeQuery = executeQuery;
+exports.getAvailableQueries = getAvailableQueries;
+// @ts-ignore - jq-web doesn't have type declarations
+const jq_web_1 = __importDefault(require("jq-web"));
+const graph_cache_1 = require("../cache/graph-cache");
+const types_1 = require("./types");
+const summary_1 = require("./summary");
+const discovery_1 = require("./discovery");
+const traversal_1 = require("./traversal");
+// jq import moved to top of file
+/**
+ * Execute a query against a graph
+ * Handles caching, graph loading, and query dispatch
+ */
+async function executeQuery(params, apiResponse) {
+    // Cache by idempotencyKey only - file path shouldn't affect cache hits
+    const cacheKey = params.idempotencyKey;
+    // Try to get from cache first
+    let graph = graph_cache_1.graphCache.get(cacheKey);
+    let source = 'cache';
+    // If not cached and we have API response, build indexes and cache
+    if (!graph && apiResponse) {
+        graph = (0, graph_cache_1.buildIndexes)(apiResponse, cacheKey);
+        graph_cache_1.graphCache.set(cacheKey, graph);
+        source = 'api';
+    }
+    // Special case: graph_status works even without a cached graph
+    if (params.query === 'graph_status') {
+        return (0, summary_1.graphStatus)(params, graph);
+    }
+    // All other queries require a graph
+    if (!graph) {
+        return (0, types_1.createError)('CACHE_MISS', `Graph not found in cache for key '${cacheKey}'`, {
+            retryable: true,
+            detail: 'Re-call with the same file and idempotencyKey to fetch from API',
+        });
+    }
+    // Dispatch to appropriate handler
+    return dispatchQuery(params, graph, source);
+}
+/**
+ * Dispatch query to the appropriate handler function
+ */
+function dispatchQuery(params, graph, source) {
+    switch (params.query) {
+        // Summary queries
+        case 'summary':
+            return (0, summary_1.summary)(params, graph, source);
+        // Discovery queries
+        case 'get_node':
+            return (0, discovery_1.getNode)(params, graph, source);
+        case 'search':
+            return (0, discovery_1.search)(params, graph, source);
+        case 'list_nodes':
+            return (0, discovery_1.listNodes)(params, graph, source);
+        // Traversal queries (v1 MVP)
+        case 'function_calls_in':
+            return (0, traversal_1.functionCallsIn)(params, graph, source);
+        case 'function_calls_out':
+            return (0, traversal_1.functionCallsOut)(params, graph, source);
+        case 'definitions_in_file':
+            return (0, traversal_1.definitionsInFile)(params, graph, source);
+        // Traversal queries (v1.1)
+        case 'file_imports':
+            return (0, traversal_1.fileImports)(params, graph, source);
+        case 'domain_map':
+            return (0, traversal_1.domainMap)(params, graph, source);
+        case 'domain_membership':
+            return (0, traversal_1.domainMembership)(params, graph, source);
+        case 'neighborhood':
+            return (0, traversal_1.neighborhood)(params, graph, source);
+        // Escape hatch
+        case 'jq':
+            return executeJqQuery(params, graph, source);
+        // Not implemented yet
+        case 'uses_in_file':
+        case 'list_files_in_dir':
+            return (0, types_1.createError)('INVALID_QUERY', `Query type '${params.query}' is not yet implemented`);
+        default:
+            return (0, types_1.createError)('INVALID_QUERY', `Unknown query type: ${params.query}`);
+    }
+}
+/**
+ * Execute a raw jq query against the graph
+ * Escape hatch for queries not covered by canned types
+ */
+async function executeJqQuery(params, graph, source) {
+    if (!params.jq_filter) {
+        return (0, types_1.createError)('INVALID_PARAMS', 'jq_filter is required for jq query');
+    }
+    try {
+        // Execute jq using jq-web (in-memory, no temp file needed)
+        const jqInstance = await jq_web_1.default;
+        const result = jqInstance.json(graph.raw, params.jq_filter);
+        return {
+            query: 'jq',
+            cacheKey: graph.cacheKey,
+            source,
+            cachedAt: graph.cachedAt,
+            result,
+            warnings: [
+                'jq is an escape hatch. Consider using a canned query type for better performance.',
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return (0, types_1.createError)('BAD_JQ', `jq filter error: ${message}`, {
+            detail: params.jq_filter,
+        });
+    }
+}
+/**
+ * Get list of available query types with descriptions
+ * Useful for agent discovery
+ */
+function getAvailableQueries() {
+    return [
+        // v1 MVP
+        {
+            query: 'graph_status',
+            description: 'Check if graph is cached and get summary stats',
+            requiredParams: ['file', 'idempotencyKey'],
+            optionalParams: [],
+            phase: 'v1',
+        },
+        {
+            query: 'summary',
+            description: 'Get high-level stats about the codebase',
+            requiredParams: ['file', 'idempotencyKey'],
+            optionalParams: [],
+            phase: 'v1',
+        },
+        {
+            query: 'get_node',
+            description: 'Get full details for a specific node by ID',
+            requiredParams: ['file', 'idempotencyKey', 'targetId'],
+            optionalParams: [],
+            phase: 'v1',
+        },
+        {
+            query: 'search',
+            description: 'Search nodes by name substring',
+            requiredParams: ['file', 'idempotencyKey', 'searchText'],
+            optionalParams: ['labels', 'filePathPrefix', 'limit'],
+            phase: 'v1',
+        },
+        {
+            query: 'list_nodes',
+            description: 'List nodes with filters (labels, namePattern, filePathPrefix)',
+            requiredParams: ['file', 'idempotencyKey'],
+            optionalParams: ['labels', 'namePattern', 'filePathPrefix', 'searchText', 'limit'],
+            phase: 'v1',
+        },
+        {
+            query: 'function_calls_in',
+            description: 'Find all callers of a function',
+            requiredParams: ['file', 'idempotencyKey', 'targetId'],
+            optionalParams: ['limit'],
+            phase: 'v1',
+        },
+        {
+            query: 'function_calls_out',
+            description: 'Find all functions called by a function',
+            requiredParams: ['file', 'idempotencyKey', 'targetId'],
+            optionalParams: ['limit'],
+            phase: 'v1',
+        },
+        {
+            query: 'definitions_in_file',
+            description: 'Get all classes, functions, types defined in a file',
+            requiredParams: ['file', 'idempotencyKey'],
+            optionalParams: ['targetId', 'filePathPrefix', 'limit'],
+            phase: 'v1',
+        },
+        {
+            query: 'jq',
+            description: 'Execute raw jq filter (escape hatch)',
+            requiredParams: ['file', 'idempotencyKey', 'jq_filter'],
+            optionalParams: [],
+            phase: 'v1',
+        },
+        // v1.1
+        {
+            query: 'file_imports',
+            description: 'Get imports for a file (outgoing and incoming)',
+            requiredParams: ['file', 'idempotencyKey', 'targetId'],
+            optionalParams: ['limit'],
+            phase: 'v1.1',
+        },
+        {
+            query: 'domain_map',
+            description: 'List all domains with relationships',
+            requiredParams: ['file', 'idempotencyKey'],
+            optionalParams: [],
+            phase: 'v1.1',
+        },
+        {
+            query: 'domain_membership',
+            description: 'Get members of a domain',
+            requiredParams: ['file', 'idempotencyKey'],
+            optionalParams: ['targetId', 'searchText', 'limit'],
+            phase: 'v1.1',
+        },
+        {
+            query: 'neighborhood',
+            description: 'Get ego graph around a node',
+            requiredParams: ['file', 'idempotencyKey', 'targetId'],
+            optionalParams: ['depth', 'relationshipTypes', 'limit'],
+            phase: 'v1.1',
+        },
+    ];
+}
+// Re-export types for convenience
+__exportStar(require("./types"), exports);
+var graph_cache_2 = require("../cache/graph-cache");
+Object.defineProperty(exports, "graphCache", { enumerable: true, get: function () { return graph_cache_2.graphCache; } });

package/dist/queries/summary.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Summary queries: graph_status, summary
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphStatus = graphStatus;
+exports.summary = summary;
+const graph_cache_1 = require("../cache/graph-cache");
+const types_1 = require("./types");
+/**
+ * graph_status - Return cache status and summary if available
+ */
+function graphStatus(params, graph) {
+    const cacheKey = params.idempotencyKey;
+    const cacheStats = graph_cache_1.graphCache.status();
+    if (!graph) {
+        return (0, types_1.createResponse)('graph_status', cacheKey, 'cache', new Date().toISOString(), {
+            cached: false,
+            cacheKey,
+            cacheStats,
+        });
+    }
+    return (0, types_1.createResponse)('graph_status', cacheKey, 'cache', graph.cachedAt, {
+        cached: true,
+        cacheKey: graph.cacheKey,
+        cachedAt: graph.cachedAt,
+        summary: graph.summary,
+        cacheStats,
+    });
+}
+/**
+ * summary - Return high-level stats about the graph
+ */
+function summary(params, graph, source) {
+    return (0, types_1.createResponse)('summary', graph.cacheKey, source, graph.cachedAt, graph.summary);
+}

package/dist/queries/traversal.js

@@ -0,0 +1,392 @@
+"use strict";
+/**
+ * Traversal queries: function_calls_in, function_calls_out, definitions_in_file
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionCallsIn = functionCallsIn;
+exports.functionCallsOut = functionCallsOut;
+exports.definitionsInFile = definitionsInFile;
+exports.fileImports = fileImports;
+exports.domainMap = domainMap;
+exports.domainMembership = domainMembership;
+exports.neighborhood = neighborhood;
+const graph_cache_1 = require("../cache/graph-cache");
+const types_1 = require("./types");
+const DEFAULT_LIMIT = 200;
+/**
+ * function_calls_in - Find all callers of a function
+ */
+function functionCallsIn(params, graph, source) {
+    if (!params.targetId) {
+        return (0, types_1.createError)('INVALID_PARAMS', 'targetId is required for function_calls_in query');
+    }
+    // Verify target exists and is a function
+    const targetNode = graph.nodeById.get(params.targetId);
+    if (!targetNode) {
+        return (0, types_1.createError)('NOT_FOUND', `Node with id '${params.targetId}' not found`, {
+            detail: 'Use search or list_nodes with labels=["Function"] to discover function IDs',
+        });
+    }
+    if (targetNode.labels?.[0] !== 'Function') {
+        return (0, types_1.createError)('INVALID_PARAMS', `Node '${params.targetId}' is not a Function (got ${targetNode.labels?.[0]})`);
+    }
+    const adj = graph.callAdj.get(params.targetId);
+    if (!adj) {
+        return (0, types_1.createResponse)('function_calls_in', graph.cacheKey, source, graph.cachedAt, { nodes: [], edges: [] });
+    }
+    const limit = params.limit || DEFAULT_LIMIT;
+    const callerIds = adj.in.slice(0, limit);
+    const nodes = [];
+    const edges = [];
+    for (const callerId of callerIds) {
+        const callerNode = graph.nodeById.get(callerId);
+        if (callerNode) {
+            nodes.push((0, graph_cache_1.toNodeDescriptor)(callerNode));
+            edges.push({
+                type: 'calls',
+                from: callerId,
+                to: params.targetId,
+            });
+        }
+    }
+    const hasMore = adj.in.length > limit;
+    return (0, types_1.createResponse)('function_calls_in', graph.cacheKey, source, graph.cachedAt, { nodes, edges }, {
+        page: { limit, hasMore },
+        warnings: hasMore ? [`${adj.in.length - limit} more callers not shown. Increase limit to see more.`] : undefined,
+    });
+}
+/**
+ * function_calls_out - Find all functions called by a function
+ */
+function functionCallsOut(params, graph, source) {
+    if (!params.targetId) {
+        return (0, types_1.createError)('INVALID_PARAMS', 'targetId is required for function_calls_out query');
+    }
+    // Verify target exists and is a function
+    const targetNode = graph.nodeById.get(params.targetId);
+    if (!targetNode) {
+        return (0, types_1.createError)('NOT_FOUND', `Node with id '${params.targetId}' not found`, {
+            detail: 'Use search or list_nodes with labels=["Function"] to discover function IDs',
+        });
+    }
+    if (targetNode.labels?.[0] !== 'Function') {
+        return (0, types_1.createError)('INVALID_PARAMS', `Node '${params.targetId}' is not a Function (got ${targetNode.labels?.[0]})`);
+    }
+    const adj = graph.callAdj.get(params.targetId);
+    if (!adj) {
+        return (0, types_1.createResponse)('function_calls_out', graph.cacheKey, source, graph.cachedAt, { nodes: [], edges: [] });
+    }
+    const limit = params.limit || DEFAULT_LIMIT;
+    const calleeIds = adj.out.slice(0, limit);
+    const nodes = [];
+    const edges = [];
+    for (const calleeId of calleeIds) {
+        const calleeNode = graph.nodeById.get(calleeId);
+        if (calleeNode) {
+            nodes.push((0, graph_cache_1.toNodeDescriptor)(calleeNode));
+            edges.push({
+                type: 'calls',
+                from: params.targetId,
+                to: calleeId,
+            });
+        }
+    }
+    const hasMore = adj.out.length > limit;
+    return (0, types_1.createResponse)('function_calls_out', graph.cacheKey, source, graph.cachedAt, { nodes, edges }, {
+        page: { limit, hasMore },
+        warnings: hasMore ? [`${adj.out.length - limit} more callees not shown. Increase limit to see more.`] : undefined,
+    });
+}
+/**
+ * definitions_in_file - Get all classes, functions, types defined in a file
+ */
+function definitionsInFile(params, graph, source) {
+    // Accept either targetId (file node ID) or filePathPrefix (file path)
+    let filePath = null;
+    if (params.targetId) {
+        const targetNode = graph.nodeById.get(params.targetId);
+        if (!targetNode) {
+            return (0, types_1.createError)('NOT_FOUND', `Node with id '${params.targetId}' not found`);
+        }
+        if (targetNode.labels?.[0] !== 'File') {
+            return (0, types_1.createError)('INVALID_PARAMS', `Node '${params.targetId}' is not a File (got ${targetNode.labels?.[0]})`);
+        }
+        filePath = targetNode.properties?.filePath || targetNode.properties?.path;
+    }
+    else if (params.filePathPrefix) {
+        filePath = params.filePathPrefix;
+    }
+    else {
+        return (0, types_1.createError)('INVALID_PARAMS', 'Either targetId (file node ID) or filePathPrefix is required');
+    }
+    if (!filePath) {
+        return (0, types_1.createError)('INVALID_PARAMS', 'Could not determine file path');
+    }
+    const normalizedPath = (0, graph_cache_1.normalizePath)(filePath);
+    const pathEntry = graph.pathIndex.get(normalizedPath);
+    let resolvedPath = normalizedPath;
+    if (!pathEntry) {
+        // Try to find by partial match
+        for (const [path] of graph.pathIndex) {
+            if (path.endsWith(normalizedPath) || normalizedPath.endsWith(path)) {
+                resolvedPath = path;
+                break;
+            }
+        }
+        if (resolvedPath === normalizedPath) {
+            return (0, types_1.createError)('NOT_FOUND', `No definitions found for file '${filePath}'`, {
+                detail: 'File may not exist in the analyzed codebase or has no class/function/type definitions',
+            });
+        }
+    }
+    const entry = pathEntry || graph.pathIndex.get(resolvedPath);
+    if (!entry) {
+        return (0, types_1.createResponse)('definitions_in_file', graph.cacheKey, source, graph.cachedAt, { file: null, definitions: { nodes: [] } });
+    }
+    const limit = params.limit || DEFAULT_LIMIT;
+    const nodes = [];
+    // Get file node
+    let fileNode = null;
+    if (entry.fileId) {
+        const file = graph.nodeById.get(entry.fileId);
+        if (file) {
+            fileNode = (0, graph_cache_1.toNodeDescriptor)(file);
+        }
+    }
+    // Collect all definitions
+    const allIds = [...entry.classIds, ...entry.functionIds, ...entry.typeIds];
+    for (const id of allIds.slice(0, limit)) {
+        const node = graph.nodeById.get(id);
+        if (node) {
+            nodes.push((0, graph_cache_1.toNodeDescriptor)(node));
+        }
+    }
+    const hasMore = allIds.length > limit;
+    return (0, types_1.createResponse)('definitions_in_file', graph.cacheKey, source, graph.cachedAt, { file: fileNode, definitions: { nodes } }, {
+        page: { limit, hasMore },
+        warnings: hasMore ? [`${allIds.length - limit} more definitions not shown.`] : undefined,
+    });
+}
+/**
+ * file_imports - Get imports for a file (both outgoing and incoming)
+ * v1.1 query
+ */
+function fileImports(params, graph, source) {
+    if (!params.targetId) {
+        return (0, types_1.createError)('INVALID_PARAMS', 'targetId is required for file_imports query');
+    }
+    const targetNode = graph.nodeById.get(params.targetId);
+    if (!targetNode) {
+        return (0, types_1.createError)('NOT_FOUND', `Node with id '${params.targetId}' not found`);
+    }
+    const label = targetNode.labels?.[0];
+    if (label !== 'File' && label !== 'LocalModule' && label !== 'ExternalModule') {
+        return (0, types_1.createError)('INVALID_PARAMS', `Node '${params.targetId}' is not a File/Module (got ${label})`);
+    }
+    const limit = params.limit || DEFAULT_LIMIT;
+    const outIds = new Set();
+    const addOutgoingImports = (nodeId) => {
+        const adj = graph.importAdj.get(nodeId);
+        if (!adj)
+            return;
+        for (const outId of adj.out) {
+            outIds.add(outId);
+        }
+    };
+    // Always include imports directly attached to the target node.
+    addOutgoingImports(params.targetId);
+    // If the target is a File node, also aggregate IMPORTS edges attached to
+    // definitions within the file. This handles graphs where IMPORTS edges
+    // are modeled as Function -> Module rather than File -> Module.
+    if (label === 'File') {
+        const filePathRaw = targetNode.properties?.filePath ||
+            targetNode.properties?.path ||
+            '';
+        const filePath = (0, graph_cache_1.normalizePath)(filePathRaw);
+        const entry = graph.pathIndex.get(filePath);
+        if (entry) {
+            for (const id of entry.functionIds)
+                addOutgoingImports(id);
+            for (const id of entry.classIds)
+                addOutgoingImports(id);
+            for (const id of entry.typeIds)
+                addOutgoingImports(id);
+        }
+    }
+    const imports = [];
+    for (const id of outIds) {
+        if (imports.length >= limit)
+            break;
+        const node = graph.nodeById.get(id);
+        if (node) {
+            imports.push((0, graph_cache_1.toNodeDescriptor)(node));
+        }
+    }
+    const hasMore = outIds.size > limit;
+    return (0, types_1.createResponse)('file_imports', graph.cacheKey, source, graph.cachedAt, { imports: { nodes: imports } }, {
+        page: { limit, hasMore },
+        warnings: label === 'File' && outIds.size === 0
+            ? [
+                'No IMPORTS edges found directly on the File node or on its contained definitions. This may reflect graph modeling choices for this repository.',
+            ]
+            : undefined,
+    });
+}
+/**
+ * domain_map - List all domains with their relationships
+ * v1.1 query
+ */
+function domainMap(params, graph, source) {
+    const domains = [];
+    const relationships = [];
+    // Get domain nodes
+    const domainIds = graph.labelIndex.get('Domain') || [];
+    for (const id of domainIds) {
+        const node = graph.nodeById.get(id);
+        if (node) {
+            const name = node.properties?.name;
+            const description = node.properties?.description;
+            const domainEntry = graph.domainIndex.get(name);
+            domains.push({
+                name,
+                description,
+                memberCount: domainEntry?.memberIds.length || 0,
+            });
+            // Collect relationships
+            if (domainEntry) {
+                for (const rel of domainEntry.relationships) {
+                    const targetNode = graph.nodeById.get(rel.endNode);
+                    if (targetNode) {
+                        relationships.push({
+                            from: name,
+                            to: targetNode.properties?.name,
+                            type: rel.type,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return (0, types_1.createResponse)('domain_map', graph.cacheKey, source, graph.cachedAt, { domains, relationships });
+}
+/**
+ * domain_membership - Get members of a domain
+ * v1.1 query
+ */
+function domainMembership(params, graph, source) {
+    if (!params.searchText && !params.targetId) {
+        return (0, types_1.createError)('INVALID_PARAMS', 'searchText (domain name) or targetId (domain node ID) is required');
+    }
+    let domainName;
+    if (params.targetId) {
+        const node = graph.nodeById.get(params.targetId);
+        if (!node) {
+            return (0, types_1.createError)('NOT_FOUND', `Node with id '${params.targetId}' not found`);
+        }
+        domainName = node.properties?.name;
+    }
+    else {
+        domainName = params.searchText;
+    }
+    const domainEntry = graph.domainIndex.get(domainName);
+    if (!domainEntry) {
+        return (0, types_1.createError)('NOT_FOUND', `Domain '${domainName}' not found`, {
+            detail: 'Use domain_map to list available domains',
+        });
+    }
+    const limit = params.limit || DEFAULT_LIMIT;
+    const members = [];
+    for (const id of domainEntry.memberIds.slice(0, limit)) {
+        const node = graph.nodeById.get(id);
+        if (node)
+            members.push((0, graph_cache_1.toNodeDescriptor)(node));
+    }
+    const hasMore = domainEntry.memberIds.length > limit;
+    return (0, types_1.createResponse)('domain_membership', graph.cacheKey, source, graph.cachedAt, { domain: domainName, members: { nodes: members } }, {
+        page: { limit, hasMore },
+    });
+}
+/**
+ * neighborhood - Get ego graph around a node
+ * v1.1 query
+ */
+function neighborhood(params, graph, source) {
+    if (!params.targetId) {
+        return (0, types_1.createError)('INVALID_PARAMS', 'targetId is required for neighborhood query');
+    }
+    const targetNode = graph.nodeById.get(params.targetId);
+    if (!targetNode) {
+        return (0, types_1.createError)('NOT_FOUND', `Node with id '${params.targetId}' not found`);
+    }
+    const depth = Math.min(params.depth || 1, 3); // Cap at 3 to prevent explosion
+    const limit = params.limit || 100;
+    // Only include relationship types we actually implement
+    const relationshipTypes = params.relationshipTypes || ['calls', 'IMPORTS'];
+    const visited = new Set();
+    const nodes = [];
+    const edges = [];
+    // BFS
+    let frontier = [params.targetId];
+    visited.add(params.targetId);
+    nodes.push((0, graph_cache_1.toNodeDescriptor)(targetNode));
+    for (let d = 0; d < depth && nodes.length < limit; d++) {
+        const nextFrontier = [];
+        for (const nodeId of frontier) {
+            if (nodes.length >= limit)
+                break;
+            // Get adjacent nodes via call graph
+            if (relationshipTypes.includes('calls')) {
+                const callAdj = graph.callAdj.get(nodeId);
+                if (callAdj) {
+                    for (const adjId of [...callAdj.out, ...callAdj.in]) {
+                        if (!visited.has(adjId) && nodes.length < limit) {
+                            visited.add(adjId);
+                            const adjNode = graph.nodeById.get(adjId);
+                            if (adjNode) {
+                                nodes.push((0, graph_cache_1.toNodeDescriptor)(adjNode));
+                                nextFrontier.push(adjId);
+                                // Add edge
+                                if (callAdj.out.includes(adjId)) {
+                                    edges.push({ type: 'calls', from: nodeId, to: adjId });
+                                }
+                                else {
+                                    edges.push({ type: 'calls', from: adjId, to: nodeId });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Get adjacent nodes via import graph
+            if (relationshipTypes.includes('IMPORTS')) {
+                const importAdj = graph.importAdj.get(nodeId);
+                if (importAdj) {
+                    for (const adjId of [...importAdj.out, ...importAdj.in]) {
+                        if (!visited.has(adjId) && nodes.length < limit) {
+                            visited.add(adjId);
+                            const adjNode = graph.nodeById.get(adjId);
+                            if (adjNode) {
+                                nodes.push((0, graph_cache_1.toNodeDescriptor)(adjNode));
+                                nextFrontier.push(adjId);
+                                if (importAdj.out.includes(adjId)) {
+                                    edges.push({ type: 'IMPORTS', from: nodeId, to: adjId });
+                                }
+                                else {
+                                    edges.push({ type: 'IMPORTS', from: adjId, to: nodeId });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        frontier = nextFrontier;
+        if (frontier.length === 0)
+            break;
+    }
+    const hasMore = nodes.length >= limit;
+    return (0, types_1.createResponse)('neighborhood', graph.cacheKey, source, graph.cachedAt, { nodes, edges }, {
+        page: { limit, hasMore },
+        warnings: hasMore ? [`Neighborhood truncated at ${limit} nodes. Decrease depth or increase limit.`] : undefined,
+    });
+}