@sean.holung/minicode 0.3.4 → 0.3.6

package/dist/src/serve/server.js

@@ -8,8 +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
@@ -48,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 {
@@ -61,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) => {
@@ -69,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);
@@ -91,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,
                 });
@@ -101,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") {
@@ -108,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") {
@@ -179,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 ──
@@ -195,7 +353,19 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/dependencies".length));
                 const depthParam = url.searchParams.get("depth");
                 const depth = depthParam ? Number(depthParam) : undefined;
-                const result = bridge.getDependencies(name, depth);
+                const matches = bridge.getSymbolMatches(name);
+                if (matches.length === 0) {
+                    sendJson(res, 404, { error: `Symbol "${name}" not found` });
+                    return;
+                }
+                if (matches.length > 1) {
+                    sendJson(res, 409, {
+                        error: `Symbol "${name}" is ambiguous`,
+                        candidates: matches.map(serializeSymbolMatch),
+                    });
+                    return;
+                }
+                const result = bridge.getDependencies(matches[0].qualifiedName, depth);
                 if (!result) {
                     sendJson(res, 404, { error: `Symbol "${name}" not found` });
                     return;
@@ -205,7 +375,19 @@ export function createRequestHandler(bridge, emit, options = {}) {
             }
             if (pathname.startsWith("/api/symbols/") && pathname.endsWith("/references") && method === "GET") {
                 const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/references".length));
-                const result = bridge.getReferences(name);
+                const matches = bridge.getSymbolMatches(name);
+                if (matches.length === 0) {
+                    sendJson(res, 404, { error: `Symbol "${name}" not found` });
+                    return;
+                }
+                if (matches.length > 1) {
+                    sendJson(res, 409, {
+                        error: `Symbol "${name}" is ambiguous`,
+                        candidates: matches.map(serializeSymbolMatch),
+                    });
+                    return;
+                }
+                const result = bridge.getReferences(matches[0].qualifiedName);
                 if (!result) {
                     sendJson(res, 404, { error: `Symbol "${name}" not found` });
                     return;
@@ -215,11 +397,19 @@ export function createRequestHandler(bridge, emit, options = {}) {
             }
             if (pathname.startsWith("/api/symbols/") && pathname.endsWith("/source") && method === "GET") {
                 const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/source".length));
-                const sym = bridge.getSymbol(name);
-                if (!sym) {
+                const matches = bridge.getSymbolMatches(name);
+                if (matches.length === 0) {
                     sendJson(res, 404, { error: `Symbol "${name}" not found` });
                     return;
                 }
+                if (matches.length > 1) {
+                    sendJson(res, 409, {
+                        error: `Symbol "${name}" is ambiguous`,
+                        candidates: matches.map(serializeSymbolMatch),
+                    });
+                    return;
+                }
+                const sym = matches[0];
                 try {
                     const fileContent = await readFile(path.resolve(config.workspaceRoot, sym.filePath), "utf8");
                     const lines = fileContent.split(/\r?\n/);

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()],
+    };
+}

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

@@ -0,0 +1,82 @@
+function dedupe(values) {
+    return [...new Set(values.filter((value) => value.length > 0))];
+}
+function stripCollisionSuffix(value) {
+    const hashIndex = value.indexOf("#");
+    return hashIndex >= 0 ? value.slice(0, hashIndex) : value;
+}
+function stripDisplayKindSuffix(value) {
+    return value.replace(/\s+\([^()]+\)$/, "");
+}
+export function getGraphNodeId(node, fallbackId = "") {
+    return node.qualifiedName || node.id || fallbackId || node.name || "";
+}
+export function getGraphNodeLabel(node, fallbackId = "") {
+    const label = node.name?.trim();
+    if (label && label.length > 0) {
+        return label;
+    }
+    const id = getGraphNodeId(node, fallbackId);
+    return id.split(".").pop() || id;
+}
+export function getGraphNodeAliases(node, fallbackId = "") {
+    const id = getGraphNodeId(node, fallbackId);
+    const label = getGraphNodeLabel(node, fallbackId);
+    const shortId = id.split(".").pop() || id;
+    return dedupe([
+        id,
+        node.id ?? "",
+        node.qualifiedName ?? "",
+        label,
+        stripDisplayKindSuffix(label),
+        shortId,
+        stripCollisionSuffix(shortId),
+        stripCollisionSuffix(id),
+    ]);
+}
+function compareLabels(a, b) {
+    return a.localeCompare(b, undefined, { sensitivity: "base" });
+}
+export function compareGraphNodeIds(a, b, nodes) {
+    const nodeA = nodes.get(a);
+    const nodeB = nodes.get(b);
+    const exportedA = nodeA ? Number(!!nodeA.exported) : 0;
+    const exportedB = nodeB ? Number(!!nodeB.exported) : 0;
+    if (exportedA !== exportedB) {
+        return exportedB - exportedA;
+    }
+    const labelA = getGraphNodeLabel(nodeA ?? {}, a);
+    const labelB = getGraphNodeLabel(nodeB ?? {}, b);
+    const labelComparison = compareLabels(labelA, labelB);
+    if (labelComparison !== 0) {
+        return labelComparison;
+    }
+    return compareLabels(a, b);
+}
+export function matchesGraphNodeQuery(query, node, fallbackId = "") {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (normalizedQuery.length === 0) {
+        return false;
+    }
+    return getGraphNodeAliases(node, fallbackId).some((alias) => alias.toLowerCase().includes(normalizedQuery));
+}
+export function resolveGraphNodeIds(nodes, symbolName) {
+    const query = symbolName.trim();
+    if (query.length === 0) {
+        return [];
+    }
+    if (nodes.has(query)) {
+        return [query];
+    }
+    const exactMatches = [...nodes.entries()]
+        .filter(([id, node]) => getGraphNodeAliases(node, id).includes(query))
+        .map(([id]) => id)
+        .sort((a, b) => compareGraphNodeIds(a, b, nodes));
+    if (exactMatches.length > 0) {
+        return exactMatches;
+    }
+    return [...nodes.entries()]
+        .filter(([id, node]) => matchesGraphNodeQuery(query, node, id))
+        .map(([id]) => id)
+        .sort((a, b) => compareGraphNodeIds(a, b, nodes));
+}

package/dist/src/shared/symbol-resolution.js

@@ -0,0 +1,33 @@
+import { getSymbolDisplayName } from "../indexer/symbol-names.js";
+export function resolveSymbolInput(projectIndex, name) {
+    const matches = projectIndex.getSymbolMatches(name);
+    if (matches.length === 0) {
+        return { status: "missing" };
+    }
+    if (matches.length > 1) {
+        return { status: "ambiguous", matches };
+    }
+    return { status: "resolved", symbol: matches[0] };
+}
+export function formatSymbolMatch(match) {
+    return `${getSymbolDisplayName(match)} (${match.kind}) — ${match.filePath}:${match.startLine} — qualified: ${match.qualifiedName}`;
+}
+export function formatAmbiguousSymbolMatches(toolName, name, matches) {
+    return [
+        `Symbol "${name}" is ambiguous; ${matches.length} matches were found.`,
+        `Re-run ${toolName} with one of these qualified or disambiguated names:`,
+        "",
+        ...matches.map((match) => `- ${formatSymbolMatch(match)}`),
+    ].join("\n");
+}
+export function serializeSymbolMatch(match) {
+    return {
+        name: getSymbolDisplayName(match),
+        qualifiedName: match.qualifiedName,
+        kind: match.kind,
+        filePath: match.filePath,
+        startLine: match.startLine,
+        endLine: match.endLine,
+        signature: match.signature,
+    };
+}

package/dist/src/tools/find-path.js

@@ -1,5 +1,6 @@
 import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
+import { formatAmbiguousSymbolMatches, resolveSymbolInput, } from "../shared/symbol-resolution.js";
 export function createFindPathTool(projectIndex) {
     return {
         name: "find_path",
@@ -27,17 +28,25 @@ export function createFindPathTool(projectIndex) {
             const from = expectNonEmptyString(input, "from");
             const to = typeof input.to === "string" && input.to.length > 0 ? input.to : undefined;
             const maxDepth = expectOptionalNumber(input, "max_depth");
-            const fromSymbol = projectIndex.getSymbol(from);
-            if (!fromSymbol) {
+            const fromResolution = resolveSymbolInput(projectIndex, from);
+            if (fromResolution.status === "missing") {
                 return `Symbol "${from}" not found in the project index.`;
             }
+            if (fromResolution.status === "ambiguous") {
+                return formatAmbiguousSymbolMatches("find_path", from, fromResolution.matches);
+            }
+            const fromSymbol = fromResolution.symbol;
             if (to) {
                 // Path between two symbols
-                const toSymbol = projectIndex.getSymbol(to);
-                if (!toSymbol) {
+                const toResolution = resolveSymbolInput(projectIndex, to);
+                if (toResolution.status === "missing") {
                     return `Symbol "${to}" not found in the project index.`;
                 }
-                const path = projectIndex.findPath(from, to, maxDepth ?? 10);
+                if (toResolution.status === "ambiguous") {
+                    return formatAmbiguousSymbolMatches("find_path", to, toResolution.matches);
+                }
+                const toSymbol = toResolution.symbol;
+                const path = projectIndex.findPath(fromSymbol.qualifiedName, toSymbol.qualifiedName, maxDepth ?? 10);
                 if (path.length === 0) {
                     return `No path found between "${from}" and "${to}".`;
                 }
@@ -53,7 +62,7 @@ export function createFindPathTool(projectIndex) {
             }
             else {
                 // Trace to entry point(s)
-                const paths = projectIndex.findPathToEntryPoint(from, maxDepth ?? 20);
+                const paths = projectIndex.findPathToEntryPoint(fromSymbol.qualifiedName, maxDepth ?? 20);
                 if (paths.length === 0) {
                     return `No entry point paths found for "${from}". It may itself be an entry point.`;
                 }

package/dist/src/tools/find-references.js

@@ -1,5 +1,6 @@
 import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
+import { formatAmbiguousSymbolMatches, resolveSymbolInput, } from "../shared/symbol-resolution.js";
 const DEFAULT_LIMIT = 50;
 export function createFindReferencesTool(projectIndex) {
     return {
@@ -28,10 +29,14 @@ export function createFindReferencesTool(projectIndex) {
             const name = expectNonEmptyString(input, "name");
             const skip = Math.max(0, expectOptionalNumber(input, "skip") ?? 0);
             const limit = Math.max(1, Math.min(100, expectOptionalNumber(input, "limit") ?? DEFAULT_LIMIT));
-            const symbol = projectIndex.getSymbol(name);
-            if (!symbol) {
+            const resolution = resolveSymbolInput(projectIndex, name);
+            if (resolution.status === "missing") {
                 return `Symbol "${name}" not found in the project index.`;
             }
+            if (resolution.status === "ambiguous") {
+                return formatAmbiguousSymbolMatches("find_references", name, resolution.matches);
+            }
+            const symbol = resolution.symbol;
             const refs = projectIndex.dependencyEdges.filter((e) => e.to === symbol.qualifiedName || e.to === symbol.name);
             if (refs.length === 0) {
                 return `No references found for "${name}".`;

package/dist/src/tools/get-dependencies.js

@@ -1,5 +1,6 @@
 import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
+import { formatAmbiguousSymbolMatches, resolveSymbolInput, } from "../shared/symbol-resolution.js";
 export function createGetDependenciesTool(projectIndex) {
     return {
         name: "get_dependencies",
@@ -32,11 +33,15 @@ export function createGetDependenciesTool(projectIndex) {
             const depth = expectOptionalNumber(input, "depth") ?? 1;
             const skip = Math.max(0, expectOptionalNumber(input, "skip") ?? 0);
             const limit = Math.max(1, Math.min(100, expectOptionalNumber(input, "limit") ?? 50));
-            const symbol = projectIndex.getSymbol(name);
-            if (!symbol) {
+            const resolution = resolveSymbolInput(projectIndex, name);
+            if (resolution.status === "missing") {
                 return `Symbol "${name}" not found in the project index.`;
             }
-            const cone = projectIndex.getDependencyCone(name, depth);
+            if (resolution.status === "ambiguous") {
+                return formatAmbiguousSymbolMatches("get_dependencies", name, resolution.matches);
+            }
+            const symbol = resolution.symbol;
+            const cone = projectIndex.getDependencyCone(symbol.qualifiedName, depth);
             const shown = cone.slice(skip, skip + limit);
             const lines = shown.map((s) => {
                 const header = `${s.kind} ${getSymbolDisplayName(s)}`;