@sean.holung/minicode 0.3.5 → 0.3.6

package/dist/src/cli/config-slash-command.js

@@ -1,5 +1,5 @@
 import { formatConfigForDisplay, MINICODE_HOME, resolveConfigEnv } from "../agent/config.js";
-import { formatPersistedConfigValue, getEditableConfigDefinition, getEffectiveEditableConfigValue, isEditableConfigKey, listEditableConfigDefinitions, loadPersistedConfig, setPersistedConfigValue, unsetPersistedConfigValue, } from "../agent/editable-config.js";
+import { buildStructuredConfigPayload, formatPersistedConfigValue, getEditableConfigDefinition, getEffectiveEditableConfigValue, isEditableConfigKey, listEditableConfigDefinitions, setPersistedConfigValue, unsetPersistedConfigValue, } from "../agent/editable-config.js";
 function renderUsage() {
     return [
         'Usage:',
@@ -12,7 +12,7 @@ function renderUsage() {
 }
 function renderEditableKeys() {
     const lines = [
-        "Editable config keys (persisted in ~/.minicode/agent.config.json; environment variables take precedence):",
+        "Editable config keys (persisted in ~/.minicode/.env; exported shell environment variables take precedence):",
     ];
     for (const definition of listEditableConfigDefinitions()) {
         const valueHint = definition.type === "enum"
@@ -21,7 +21,7 @@ function renderEditableKeys() {
         lines.push(`  ${definition.key} ${valueHint} — ${definition.description} (env: ${definition.envVar})`);
     }
     lines.push("");
-    lines.push('Use "/config set <key> <value>" to update your global config.');
+    lines.push('Use "/config set <key> <value>" to update ~/.minicode/.env.');
     lines.push("Secrets like API keys stay env-only for now.");
     return lines.join("\n");
 }
@@ -31,14 +31,16 @@ async function renderConfigValue(key, context) {
     }
     const minicodeHome = context.minicodeHome ?? MINICODE_HOME;
     const definition = getEditableConfigDefinition(key);
-    const persisted = await loadPersistedConfig(minicodeHome);
-    const env = await resolveConfigEnv({ minicodeHome });
-    const envValue = env.values[definition.envVar];
+    const payload = await buildStructuredConfigPayload(context.config, minicodeHome);
+    const entry = payload.entries.find((item) => item.key === key);
+    if (!entry) {
+        return `Unknown editable config key "${key}".\n\n${renderEditableKeys()}`;
+    }
     return [
         `${definition.key}`,
         `  effective: ${getEffectiveEditableConfigValue(context.config, key)}`,
-        `  config file: ${formatPersistedConfigValue(persisted[definition.fileKey])}`,
-        `  env override (${definition.envVar}): ${formatPersistedConfigValue(envValue)}`,
+        `  saved in ~/.minicode/.env: ${formatPersistedConfigValue(entry.persistedValue)}`,
+        `  exported env override (${definition.envVar}): ${formatPersistedConfigValue(entry.envValue)}`,
     ].join("\n");
 }
 async function persistConfigValue(key, rawValue, context) {
@@ -59,8 +61,8 @@ async function persistConfigValue(key, rawValue, context) {
             `File: ${result.path}`,
             "Restart minicode to pick up persisted config changes in a new session.",
         ];
-        if (env.values[definition.envVar] !== undefined) {
-            lines.push(`Note: ${definition.envVar} is currently set and will override this persisted value until it is unset.`);
+        if (env.sources[definition.envVar] === "process") {
+            lines.push(`Note: ${definition.envVar} is currently exported in your shell and will override this saved value until it is unset.`);
         }
         return lines.join("\n");
     }
@@ -82,11 +84,11 @@ async function removeConfigValue(key, context) {
     });
     const lines = [
         `Removed persisted value for "${key}".`,
-        `File: ${minicodeHome}/agent.config.json`,
+        `File: ${minicodeHome}/.env`,
         "Restart minicode to ensure the updated config is applied in a new session.",
     ];
-    if (env.values[definition.envVar] !== undefined) {
-        lines.push(`Note: ${definition.envVar} is still set in the environment, so the effective value may remain unchanged.`);
+    if (env.sources[definition.envVar] === "process") {
+        lines.push(`Note: ${definition.envVar} is still exported in your shell, so the effective value may remain unchanged.`);
     }
     return lines.join("\n");
 }

package/dist/src/serve/agent-bridge.js

@@ -13,9 +13,11 @@ import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 export class AgentBridge {
     agent;
     config;
+    baseConfig;
     modelClient;
     projectIndex;
-    buildAgent;
+    toolRegistry;
+    sessionOpenRouterConnected = false;
     busy = false;
     abortController = null;
     broadcast;
@@ -43,9 +45,8 @@ export class AgentBridge {
     }
     async init() {
         const config = await loadAgentConfig();
-        let modelClient;
         try {
-            modelClient = createModelClient(config);
+            this.modelClient = createModelClient(config);
         }
         catch {
             // Model client may fail to initialize if API keys are missing.
@@ -75,28 +76,47 @@ export class AgentBridge {
             return this.appendAnnotationsToResult(name, input, result);
         };
         this.config = config;
+        this.baseConfig = AgentBridge.cloneConfig(config);
         this.projectIndex = projectIndex;
-        if (modelClient) {
-            this.modelClient = modelClient;
-            this.buildAgent = (session, onUiUpdate) => {
-                return new CodingAgent({
-                    config,
-                    modelClient,
-                    toolRegistry,
-                    verbose: this.verbose,
-                    ...(session ? { session } : {}),
-                    ...(projectIndex !== undefined
-                        ? { getCodeMap: (focusSymbols) => projectIndex.getCodeMap(undefined, focusSymbols) }
-                        : {}),
-                    onUiUpdate: onUiUpdate ?? ((event) => {
-                        this.emit(event);
-                    }),
-                    getSystemPromptSuffix: () => this.buildAnnotationSuffix(),
-                });
-            };
-            this.agent = this.buildAgent();
+        this.toolRegistry = toolRegistry;
+        if (this.modelClient) {
+            this.agent = this.createAgent();
         }
     }
+    static cloneConfig(config) {
+        return {
+            ...config,
+            commandDenylist: [...config.commandDenylist],
+        };
+    }
+    static applyConfig(target, source) {
+        const targetRecord = target;
+        for (const key of Object.keys(targetRecord)) {
+            if (!(key in source)) {
+                delete targetRecord[key];
+            }
+        }
+        Object.assign(targetRecord, AgentBridge.cloneConfig(source));
+    }
+    createAgent(session, onUiUpdate) {
+        if (!this.modelClient || !this.toolRegistry) {
+            throw new Error("Agent runtime is not initialized.");
+        }
+        return new CodingAgent({
+            config: this.config,
+            modelClient: this.modelClient,
+            toolRegistry: this.toolRegistry,
+            verbose: this.verbose,
+            ...(session ? { session } : {}),
+            ...(this.projectIndex !== undefined
+                ? { getCodeMap: (focusSymbols) => this.projectIndex.getCodeMap(undefined, focusSymbols) }
+                : {}),
+            onUiUpdate: onUiUpdate ?? ((event) => {
+                this.emit(event);
+            }),
+            getSystemPromptSuffix: () => this.buildAnnotationSuffix(),
+        });
+    }
     // ── File watcher for automatic reindexing ──
     static WATCH_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
     static SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage"]);
@@ -171,6 +191,45 @@ export class AgentBridge {
     getConfig() {
         return this.config;
     }
+    isOpenRouterSessionConnected() {
+        return this.sessionOpenRouterConnected;
+    }
+    connectOpenRouter(apiKey) {
+        const trimmedKey = apiKey.trim();
+        if (!trimmedKey) {
+            throw new Error("OpenRouter OAuth exchange did not return an API key.");
+        }
+        if (this.busy) {
+            throw new Error("busy");
+        }
+        const currentSession = this.agent?.getSession();
+        this.config.modelProvider = "openai-compatible";
+        this.config.openAiBaseUrl = "https://openrouter.ai/api/v1";
+        this.config.openAiApiKey = trimmedKey;
+        this.sessionOpenRouterConnected = true;
+        this.modelClient = createModelClient(this.config);
+        this.agent = this.createAgent(currentSession);
+    }
+    disconnectOpenRouter() {
+        if (this.busy) {
+            throw new Error("busy");
+        }
+        if (!this.sessionOpenRouterConnected) {
+            return false;
+        }
+        const currentSession = this.agent?.getSession();
+        AgentBridge.applyConfig(this.config, this.baseConfig);
+        this.sessionOpenRouterConnected = false;
+        try {
+            this.modelClient = createModelClient(this.config);
+            this.agent = this.createAgent(currentSession);
+        }
+        catch {
+            this.modelClient = undefined;
+            this.agent = undefined;
+        }
+        return true;
+    }
     requireAgent() {
         if (!this.agent) {
             throw new Error("Agent is not configured. Set MODEL and provider settings in ~/.minicode/.env");
@@ -230,13 +289,13 @@ export class AgentBridge {
         return saveSession(agent.getSession(), label, annotationsObj);
     }
     async loadSess(label) {
-        if (!this.buildAgent) {
+        if (!this.modelClient) {
             throw new Error("Agent is not configured.");
         }
         const result = (await loadSessionByLabel(label)) ?? (await loadSession(label));
         if (!result)
             return null;
-        this.agent = this.buildAgent(result.session);
+        this.agent = this.createAgent(result.session);
         // Restore annotations from saved session
         this.annotations.clear();
         if (result.annotations) {
@@ -473,12 +532,12 @@ export class AgentBridge {
     async explainSymbol(name, onEvent, signal) {
         if (!this.projectIndex)
             throw new Error("No project index");
-        if (!this.buildAgent)
+        if (!this.modelClient)
             throw new Error("Agent is not configured.");
         const sym = this.projectIndex.getSymbol(name);
         if (!sym)
             throw new Error(`Symbol "${name}" not found`);
-        const explainAgent = this.buildAgent(undefined, onEvent);
+        const explainAgent = this.createAgent(undefined, onEvent);
         const prompt = `Explain "${sym.name}" (${sym.kind} in ${sym.filePath}).
 Use read_symbol, get_dependencies, find_references to gather context.
 Explain what it does, how it works, what depends on it, and key design decisions.
@@ -491,12 +550,12 @@ Be concise but thorough.`;
         const report = this.getStructuralAnalysis();
         if (!report)
             throw new Error("No project index");
-        if (!this.buildAgent)
+        if (!this.modelClient)
             throw new Error("Agent is not configured.");
         const finding = report.findings.find((item) => item.id === findingId);
         if (!finding)
             throw new Error(`Structural finding "${findingId}" not found`);
-        const explainAgent = this.buildAgent(undefined, onEvent);
+        const explainAgent = this.createAgent(undefined, onEvent);
         const affectedSymbols = finding.symbols.length > 0
             ? finding.symbols.slice(0, 8).join(", ")
             : "(none)";

package/dist/src/serve/server.js

@@ -8,9 +8,11 @@ import { createWebSocketServer } from "./websocket.js";
 import { handleChatCompletions, handleModels } from "./openai-compat.js";
 import { formatConfigForDisplay, getConfigMissing } from "../agent/config.js";
 import { applyPersistedConfigUpdates, buildStructuredConfigPayload } from "../agent/editable-config.js";
+import { getHomeEnvPath, upsertHomeEnvValues } from "../agent/home-env.js";
 import { sortModelsAlphabetically } from "../model-utils.js";
 import { serializeSymbolMatch } from "../shared/symbol-resolution.js";
 import { handleMcpRequest } from "./mcp-server.js";
+import { buildSessionPreview } from "../session/session-preview.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Resolve web dir: always serve from dist/src/web (built by scripts/build-web.mjs)
 // In dev (tsx): __dirname = src/serve → go up to project root, then dist/src/web
@@ -49,7 +51,12 @@ async function serveStatic(res, urlPath) {
         const content = await readFile(filePath);
         const ext = path.extname(filePath);
         const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
-        res.writeHead(200, { "Content-Type": contentType });
+        res.writeHead(200, {
+            "Content-Type": contentType,
+            // This local UI changes often during development. Avoid stale browser bundles
+            // causing the app to run an older client against a newer server.
+            "Cache-Control": "no-store",
+        });
         res.end(content);
     }
     catch {
@@ -62,7 +69,6 @@ async function buildWebSettingsPayload(config, minicodeHome) {
 }
 /** Create the HTTP request handler. Exported for testing. */
 export function createRequestHandler(bridge, emit, options = {}) {
-    const config = bridge.getConfig();
     const emitFn = emit ?? (() => { });
     const minicodeHome = options.minicodeHome;
     return (req, res) => {
@@ -70,6 +76,7 @@ export function createRequestHandler(bridge, emit, options = {}) {
         const method = req.method ?? "GET";
         const pathname = url.pathname;
         const handle = async () => {
+            const config = bridge.getConfig();
             // MCP (Model Context Protocol) endpoint
             if (pathname === "/mcp") {
                 await handleMcpRequest(req, res, bridge, emitFn);
@@ -92,6 +99,8 @@ export function createRequestHandler(bridge, emit, options = {}) {
                     workspace: config.workspaceRoot,
                     model: config.model,
                     provider: config.modelProvider,
+                    baseUrl: config.openAiBaseUrl,
+                    sessionOpenRouterConnected: bridge.isOpenRouterSessionConnected(),
                     needsSetup: missing.length > 0,
                     missing,
                 });
@@ -102,6 +111,132 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 sendJson(res, 200, { models, activeModel: config.model });
                 return;
             }
+            if (pathname === "/api/openrouter/connect" && method === "POST") {
+                const body = JSON.parse(await readBody(req));
+                if (!body.code || typeof body.code !== "string") {
+                    sendJson(res, 400, { error: "code is required" });
+                    return;
+                }
+                if (!body.codeVerifier || typeof body.codeVerifier !== "string") {
+                    sendJson(res, 400, { error: "codeVerifier is required" });
+                    return;
+                }
+                let exchangeResponse;
+                try {
+                    exchangeResponse = await fetch("https://openrouter.ai/api/v1/auth/keys", {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({
+                            code: body.code,
+                            code_verifier: body.codeVerifier,
+                            code_challenge_method: "S256",
+                        }),
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "OpenRouter OAuth exchange failed";
+                    sendJson(res, 502, { error: message });
+                    return;
+                }
+                if (!exchangeResponse.ok) {
+                    const message = await exchangeResponse.text();
+                    sendJson(res, exchangeResponse.status, {
+                        error: message.trim().length > 0
+                            ? `OpenRouter OAuth exchange failed: ${message}`
+                            : `OpenRouter OAuth exchange failed (${exchangeResponse.status})`,
+                    });
+                    return;
+                }
+                const payload = await exchangeResponse.json();
+                if (!payload.key || typeof payload.key !== "string") {
+                    sendJson(res, 502, { error: "OpenRouter OAuth exchange did not return an API key." });
+                    return;
+                }
+                try {
+                    bridge.connectOpenRouter(payload.key);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to configure OpenRouter";
+                    sendJson(res, message === "busy" ? 409 : 400, { error: message });
+                    return;
+                }
+                let persistedToEnv = false;
+                let persistedEnvPath = null;
+                let persistWarning = null;
+                if (body.persistToEnv === true) {
+                    try {
+                        const result = await upsertHomeEnvValues({
+                            values: {
+                                MODEL_PROVIDER: "openai-compatible",
+                                OPENAI_BASE_URL: "https://openrouter.ai/api/v1",
+                                OPENROUTER_API_KEY: payload.key,
+                            },
+                            ...(minicodeHome ? { minicodeHome } : {}),
+                        });
+                        persistedToEnv = true;
+                        persistedEnvPath = result.path;
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : "Failed to update ~/.minicode/.env";
+                        persistedEnvPath = getHomeEnvPath(minicodeHome);
+                        persistWarning = `OpenRouter connected for this serve session, but minicode could not update ${persistedEnvPath}: ${message}`;
+                    }
+                }
+                const missing = getConfigMissing(config);
+                const onlyModelMissing = missing.length === 1 && missing[0] === "MODEL is not set";
+                const message = persistWarning
+                    ? `${persistWarning}${onlyModelMissing ? " Select a model to continue." : ""}`
+                    : persistedToEnv
+                        ? (onlyModelMissing
+                            ? "OpenRouter connected for this serve session and saved to ~/.minicode/.env. Select a model to continue, and minicode will remember it for future runs."
+                            : "OpenRouter connected for this serve session and saved to ~/.minicode/.env for future runs.")
+                        : (onlyModelMissing
+                            ? "OpenRouter connected for this serve session. Select a model to continue."
+                            : "OpenRouter connected for this serve session.");
+                sendJson(res, 200, {
+                    ok: true,
+                    sessionOnly: true,
+                    persistedToEnv,
+                    persistedEnvPath,
+                    persistWarning,
+                    provider: config.modelProvider,
+                    model: config.model,
+                    baseUrl: config.openAiBaseUrl,
+                    needsSetup: missing.length > 0,
+                    missing,
+                    message,
+                });
+                return;
+            }
+            if (pathname === "/api/openrouter/disconnect" && method === "POST") {
+                let disconnected = false;
+                try {
+                    disconnected = bridge.disconnectOpenRouter();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to remove OpenRouter session";
+                    sendJson(res, message === "busy" ? 409 : 400, { error: message });
+                    return;
+                }
+                const missing = getConfigMissing(config);
+                const body = {
+                    ok: true,
+                    disconnected,
+                    sessionOnly: true,
+                    provider: config.modelProvider,
+                    model: config.model,
+                    baseUrl: config.openAiBaseUrl,
+                    needsSetup: missing.length > 0,
+                    missing,
+                    message: disconnected
+                        ? "Removed the session-only OpenRouter connection and restored your original provider settings."
+                        : "No session-only OpenRouter connection was active.",
+                };
+                sendJson(res, 200, body);
+                return;
+            }
             if (pathname === "/api/model" && method === "POST") {
                 const body = JSON.parse(await readBody(req));
                 if (!body.model || typeof body.model !== "string") {
@@ -109,7 +244,26 @@ export function createRequestHandler(bridge, emit, options = {}) {
                     return;
                 }
                 bridge.switchModel(body.model);
-                sendJson(res, 200, { model: body.model });
+                let persistedToEnv = false;
+                let persistedEnvPath = null;
+                let message;
+                try {
+                    const result = await upsertHomeEnvValues({
+                        values: {
+                            MODEL: body.model,
+                        },
+                        ...(minicodeHome ? { minicodeHome } : {}),
+                    });
+                    persistedToEnv = true;
+                    persistedEnvPath = result.path;
+                    message = `Saved MODEL=${body.model} to ~/.minicode/.env.`;
+                }
+                catch (error) {
+                    const persistMessage = error instanceof Error ? error.message : "Failed to update ~/.minicode/.env";
+                    sendJson(res, 500, { error: persistMessage });
+                    return;
+                }
+                sendJson(res, 200, { model: body.model, persistedToEnv, persistedEnvPath, message });
                 return;
             }
             if (pathname === "/api/context" && method === "GET") {
@@ -180,7 +334,10 @@ export function createRequestHandler(bridge, emit, options = {}) {
                     sendJson(res, 404, { error: "Session not found" });
                     return;
                 }
-                sendJson(res, 200, { label: result.label });
+                sendJson(res, 200, {
+                    label: result.label,
+                    messages: buildSessionPreview(result.session.getMessages()),
+                });
                 return;
             }
             // ── Graph / Index API ──

package/dist/src/session/session-preview.js

@@ -0,0 +1,14 @@
+export const DEFAULT_SESSION_PREVIEW_LIMIT = 10;
+const COMPACTION_SUMMARY_PREFIX = "[Conversation Summary";
+export function isCompactionSummaryMessage(message) {
+    return (message.role === "user" &&
+        message.content.startsWith(COMPACTION_SUMMARY_PREFIX));
+}
+export function buildSessionPreview(messages, limit = DEFAULT_SESSION_PREVIEW_LIMIT) {
+    if (limit <= 0) {
+        return [];
+    }
+    return messages
+        .filter((message) => !isCompactionSummaryMessage(message))
+        .slice(-limit);
+}

package/dist/src/shared/graph-search.js

@@ -0,0 +1,80 @@
+import { compareGraphNodeIds, getGraphNodeLabel, matchesGraphNodeQuery, } from "./graph-symbols.js";
+export function getGraphNodeFilePath(node) {
+    return node.filePath || node.file || "";
+}
+export function buildGraphFileIndex(nodes) {
+    const files = new Map();
+    for (const [id, node] of nodes) {
+        const filePath = getGraphNodeFilePath(node);
+        if (!filePath)
+            continue;
+        const existing = files.get(filePath);
+        if (existing) {
+            existing.push(id);
+        }
+        else {
+            files.set(filePath, [id]);
+        }
+    }
+    for (const symbolIds of files.values()) {
+        symbolIds.sort((a, b) => compareGraphNodeIds(a, b, nodes));
+    }
+    return files;
+}
+export function compareGraphFilePaths(a, b, fileIndex) {
+    const countDifference = (fileIndex.get(b)?.length ?? 0) - (fileIndex.get(a)?.length ?? 0);
+    if (countDifference !== 0) {
+        return countDifference;
+    }
+    return a.localeCompare(b, undefined, { sensitivity: "base" });
+}
+export function matchesGraphFileQuery(query, filePath) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (normalizedQuery.length === 0) {
+        return false;
+    }
+    return filePath.toLowerCase().includes(normalizedQuery);
+}
+export function buildGraphSearchResults({ query, symbolIds, nodes, fileIndex, symbolLimit = 12, fileLimit = 8, }) {
+    const normalizedQuery = query.trim().toLowerCase();
+    const showDefaultResults = normalizedQuery.length < 2;
+    const rankedFiles = [...fileIndex.keys()].sort((a, b) => compareGraphFilePaths(a, b, fileIndex));
+    const symbolResults = symbolIds
+        .filter((id) => {
+        if (showDefaultResults) {
+            return true;
+        }
+        return matchesGraphNodeQuery(normalizedQuery, nodes.get(id) || {}, id);
+    })
+        .slice(0, symbolLimit)
+        .map((id) => {
+        const node = nodes.get(id) || {};
+        return {
+            type: "symbol",
+            id,
+            label: getGraphNodeLabel(node, id),
+            subtitle: getGraphNodeFilePath(node),
+            kind: (node.kind || "symbol").toLowerCase(),
+        };
+    });
+    const fileResults = rankedFiles
+        .filter((filePath) => {
+        if (showDefaultResults) {
+            return true;
+        }
+        return matchesGraphFileQuery(normalizedQuery, filePath);
+    })
+        .slice(0, fileLimit)
+        .map((filePath) => {
+        const symbolCount = fileIndex.get(filePath)?.length ?? 0;
+        return {
+            type: "file",
+            id: filePath,
+            label: filePath,
+            subtitle: `${symbolCount} symbol${symbolCount === 1 ? "" : "s"}`,
+            kind: "file",
+            symbolCount,
+        };
+    });
+    return [...symbolResults, ...fileResults];
+}

package/dist/src/shared/graph-selection.js

@@ -0,0 +1,40 @@
+export function buildGraphEdgeId(edge) {
+    return `${edge.source}->${edge.target}:${edge.kind}`;
+}
+export function buildGraphEdgeIndex(edges) {
+    const edgeIndex = new Map();
+    for (const edge of edges) {
+        const sourceEdges = edgeIndex.get(edge.source);
+        if (sourceEdges) {
+            sourceEdges.push(edge);
+        }
+        else {
+            edgeIndex.set(edge.source, [edge]);
+        }
+        const targetEdges = edgeIndex.get(edge.target);
+        if (targetEdges) {
+            targetEdges.push(edge);
+        }
+        else {
+            edgeIndex.set(edge.target, [edge]);
+        }
+    }
+    return edgeIndex;
+}
+export function buildFileFocusedSelection({ filePath, fileIndex, edgeIndex, }) {
+    const fileSymbolIds = fileIndex.get(filePath) || [];
+    const nodeIds = new Set();
+    const edges = new Map();
+    for (const symbolId of fileSymbolIds) {
+        nodeIds.add(symbolId);
+        for (const edge of edgeIndex.get(symbolId) || []) {
+            nodeIds.add(edge.source);
+            nodeIds.add(edge.target);
+            edges.set(buildGraphEdgeId(edge), edge);
+        }
+    }
+    return {
+        nodeIds: [...nodeIds],
+        edges: [...edges.values()],
+    };
+}