@sean.holung/minicode 0.3.4 → 0.3.6

package/dist/src/indexer/project-index.js

@@ -48,22 +48,26 @@ function buildAdjacencyTo(edges) {
     }
     return map;
 }
-function resolveSymbol(name, symbols) {
+function resolveSymbols(name, symbols) {
     const direct = symbols.get(name);
     if (direct)
-        return direct;
+        return [direct];
     const matches = [...symbols.values()].filter((sym) => getSymbolLookupNames(sym).includes(name));
     if (matches.length === 0) {
-        return undefined;
+        return [];
     }
     matches.sort((a, b) => Number(b.exported) - Number(a.exported) ||
         a.filePath.localeCompare(b.filePath) ||
         a.startLine - b.startLine ||
         a.qualifiedName.localeCompare(b.qualifiedName));
-    return matches[0];
+    return matches;
+}
+function resolveSymbol(name, symbols) {
+    return resolveSymbols(name, symbols)[0];
 }
 export function createProjectIndex(symbols, files, dependencyEdges, plugins, projectFiles, workspaceRoot) {
     let adjacencyFrom = buildAdjacencyFrom(dependencyEdges);
+    const root = path.resolve(workspaceRoot);
     function rebuildSymbolsMap() {
         const normalizedSymbols = normalizeIndexedSymbols(files);
         symbols.clear();
@@ -71,6 +75,42 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
             symbols.set(qualifiedName, symbol);
         }
     }
+    function rebuildDependencyEdges() {
+        for (const p of plugins) {
+            if (p.resolveDependencies) {
+                const allSymbols = [...symbols.values()];
+                const edges = p.resolveDependencies(allSymbols, projectFiles);
+                dependencyEdges.splice(0, dependencyEdges.length, ...edges);
+                adjacencyFrom = buildAdjacencyFrom(dependencyEdges);
+                break;
+            }
+        }
+    }
+    async function refreshFromWorkspace() {
+        const validExtensions = new Set(plugins.flatMap((p) => p.extensions));
+        const sourceFiles = [];
+        await collectSourceFiles(root, root, sourceFiles, validExtensions);
+        files.clear();
+        projectFiles.clear();
+        for (const relPath of sourceFiles) {
+            const plugin = getPluginForFile(relPath, plugins);
+            if (!plugin)
+                continue;
+            const absPath = path.join(root, relPath);
+            let content;
+            try {
+                content = await readFile(absPath, "utf8");
+            }
+            catch {
+                continue;
+            }
+            projectFiles.set(relPath, content);
+            const extracted = plugin.indexFile(relPath, content);
+            files.set(relPath, extracted);
+        }
+        rebuildSymbolsMap();
+        rebuildDependencyEdges();
+    }
     return {
         symbols,
         files,
@@ -81,6 +121,9 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
         getSymbol(name) {
             return resolveSymbol(name, symbols);
         },
+        getSymbolMatches(name) {
+            return resolveSymbols(name, symbols);
+        },
         getSymbolsInFile(filePath) {
             return files.get(filePath) ?? [];
         },
@@ -226,16 +269,9 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
             const extracted = plugin.indexFile(relPath, content);
             files.set(relPath, extracted);
             rebuildSymbolsMap();
-            for (const p of plugins) {
-                if (p.resolveDependencies) {
-                    const allSymbols = [...symbols.values()];
-                    const edges = p.resolveDependencies(allSymbols, projectFiles);
-                    dependencyEdges.splice(0, dependencyEdges.length, ...edges);
-                    adjacencyFrom = buildAdjacencyFrom(dependencyEdges);
-                    break;
-                }
-            }
+            rebuildDependencyEdges();
         },
+        refreshFromWorkspace,
     };
 }
 /**

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,27 +76,46 @@ 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"]);
@@ -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) {
@@ -276,10 +335,18 @@ export class AgentBridge {
             return undefined;
         return this.projectIndex.getSymbol(name);
     }
+    getSymbolMatches(name) {
+        if (!this.projectIndex)
+            return [];
+        return this.projectIndex.getSymbolMatches(name);
+    }
     getDependencies(symbolName, depth) {
         if (!this.projectIndex)
             return undefined;
-        const cone = this.projectIndex.getDependencyCone(symbolName, depth);
+        const matches = this.projectIndex.getSymbolMatches(symbolName);
+        if (matches.length !== 1)
+            return undefined;
+        const cone = this.projectIndex.getDependencyCone(matches[0].qualifiedName, depth);
         if (cone.length === 0)
             return undefined;
         return cone.map((sym) => ({
@@ -293,9 +360,10 @@ export class AgentBridge {
     getReferences(symbolName) {
         if (!this.projectIndex)
             return undefined;
-        const sym = this.projectIndex.getSymbol(symbolName);
-        if (!sym)
+        const matches = this.projectIndex.getSymbolMatches(symbolName);
+        if (matches.length !== 1)
             return undefined;
+        const sym = matches[0];
         // Find all edges pointing TO this symbol
         const refs = this.projectIndex.dependencyEdges
             .filter((e) => e.to === sym.qualifiedName || e.to === sym.name)
@@ -464,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.
@@ -482,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/mcp-server.js

@@ -10,6 +10,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z } from "zod";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
+import { formatAmbiguousSymbolMatches, resolveSymbolInput, } from "../shared/symbol-resolution.js";
 /** Active transports keyed by session ID. */
 const transports = new Map();
 /**
@@ -44,12 +45,19 @@ function createMcpServer(bridge, emit) {
     // ── Tools ──
     server.tool("read_symbol", "Read a specific function, class, interface, or type by name from the AST index. Returns source code, signature, dependencies, references, and annotations in one call — much more targeted than reading an entire file. PREFERRED over read_file for .ts/.tsx/.js/.jsx when you know the symbol name.", { name: z.string().describe("The symbol name or qualified name (e.g. 'Session' or 'Session.trim')") }, async ({ name }) => {
         return wrapToolCall("read_symbol", { name }, async () => {
-            const sym = bridge.getSymbol(name);
-            if (!sym) {
+            const resolution = resolveSymbolInput(bridge, name);
+            if (resolution.status === "missing") {
                 return { content: [{ type: "text", text: `Symbol "${name}" not found in the project index.` }], isError: true };
             }
-            const deps = bridge.getDependencies(name, 1);
-            const refs = bridge.getReferences(name);
+            if (resolution.status === "ambiguous") {
+                return {
+                    content: [{ type: "text", text: formatAmbiguousSymbolMatches("read_symbol", name, resolution.matches) }],
+                    isError: true,
+                };
+            }
+            const sym = resolution.symbol;
+            const deps = bridge.getDependencies(sym.qualifiedName, 1);
+            const refs = bridge.getReferences(sym.qualifiedName);
             const lines = [
                 `## ${sym.kind}: ${getSymbolDisplayName(sym)}`,
                 `File: ${sym.filePath}:${sym.startLine}`,
@@ -85,14 +93,28 @@ function createMcpServer(bridge, emit) {
             return { content: [{ type: "text", text: lines.join("\n") }] };
         });
     });
-    server.tool("find_references", "Find all symbols that call, import, or reference a given symbol. Essential for understanding impact before making changes.", { name: z.string().describe("The symbol name to find references for") }, async ({ name }) => {
+    server.tool("find_references", "Find all symbols that call, import, or reference a given symbol. Essential for understanding impact before making changes.", { name: z.string().describe("The symbol name or qualified name to find references for") }, async ({ name }) => {
         return wrapToolCall("find_references", { name }, async () => {
-            const refs = bridge.getReferences(name);
+            const resolution = resolveSymbolInput(bridge, name);
+            if (resolution.status === "missing") {
+                return { content: [{ type: "text", text: `Symbol "${name}" not found.` }], isError: true };
+            }
+            if (resolution.status === "ambiguous") {
+                return {
+                    content: [{ type: "text", text: formatAmbiguousSymbolMatches("find_references", name, resolution.matches) }],
+                    isError: true,
+                };
+            }
+            const symbol = resolution.symbol;
+            const refs = bridge.getReferences(symbol.qualifiedName);
             if (!refs || refs.length === 0) {
                 return { content: [{ type: "text", text: `No references found for "${name}".` }] };
             }
-            const lines = [`References to "${name}":`, ...refs.map((r) => `  - ${r.name ?? r.from} (${r.kind})`)];
-            const annotations = bridge.getAnnotationsForSymbol(name);
+            const lines = [
+                `References to ${getSymbolDisplayName(symbol)}:`,
+                ...refs.map((r) => `  - ${r.name ?? r.from} (${r.kind})`),
+            ];
+            const annotations = bridge.getAnnotationsForSymbol(symbol.qualifiedName);
             if (annotations.length > 0) {
                 lines.push("", `[User annotation: ${annotations.join("; ")}]`);
             }
@@ -100,19 +122,30 @@ function createMcpServer(bridge, emit) {
         });
     });
     server.tool("get_dependencies", "Get the dependency cone of a symbol — everything it calls, imports, extends, or references. Essential for understanding implementation and data flow.", {
-        name: z.string().describe("The symbol name to get dependencies for"),
+        name: z.string().describe("The symbol name or qualified name to get dependencies for"),
         depth: z.number().optional().default(2).describe("How many levels deep to traverse (default: 2)"),
     }, async ({ name, depth }) => {
         return wrapToolCall("get_dependencies", { name, depth }, async () => {
-            const deps = bridge.getDependencies(name, depth);
+            const resolution = resolveSymbolInput(bridge, name);
+            if (resolution.status === "missing") {
+                return { content: [{ type: "text", text: `Symbol "${name}" not found.` }], isError: true };
+            }
+            if (resolution.status === "ambiguous") {
+                return {
+                    content: [{ type: "text", text: formatAmbiguousSymbolMatches("get_dependencies", name, resolution.matches) }],
+                    isError: true,
+                };
+            }
+            const symbol = resolution.symbol;
+            const deps = bridge.getDependencies(symbol.qualifiedName, depth);
             if (!deps || deps.length === 0) {
                 return { content: [{ type: "text", text: `No dependencies found for "${name}".` }] };
             }
             const lines = [
-                `Dependencies of "${name}" (depth=${depth}):`,
+                `Dependencies of ${getSymbolDisplayName(symbol)} (depth=${depth}):`,
                 ...deps.map((d) => `  - ${d.qualifiedName} (${d.kind}) — ${d.filePath}`),
             ];
-            const annotations = bridge.getAnnotationsForSymbol(name);
+            const annotations = bridge.getAnnotationsForSymbol(symbol.qualifiedName);
             if (annotations.length > 0) {
                 lines.push("", `[User annotation: ${annotations.join("; ")}]`);
             }
@@ -140,29 +173,41 @@ function createMcpServer(bridge, emit) {
             }
             const lines = [
                 `Found ${matches.length} symbol(s) matching "${query}":`,
-                ...matches.map((s) => `  - ${s.name} (${s.kind}) — ${s.filePath}:${s.startLine}${s.signature ? `\n    ${s.signature}` : ""}`),
+                ...matches.map((s) => `  - ${s.name} (${s.kind}) — ${s.filePath}:${s.startLine} — qualified: ${s.qualifiedName}${s.signature ? `\n    ${s.signature}` : ""}`),
             ];
             return { content: [{ type: "text", text: lines.join("\n") }] };
         });
     });
     server.tool("find_path", "Find the shortest dependency path between two symbols, or trace a symbol back to an entry point. Useful for understanding how code connects.", {
-        from: z.string().describe("Source symbol name"),
-        to: z.string().optional().describe("Target symbol name. If omitted, traces back to the nearest entry point."),
+        from: z.string().describe("Source symbol name or qualified name"),
+        to: z.string().optional().describe("Target symbol name or qualified name. If omitted, traces back to the nearest entry point."),
     }, async ({ from, to }) => {
         return wrapToolCall("find_path", { from, to }, async () => {
             if (!bridge.hasIndex()) {
                 return { content: [{ type: "text", text: "No project index available." }], isError: true };
             }
-            // Use the bridge's project index via getSymbol to verify symbols exist
-            const fromSym = bridge.getSymbol(from);
-            if (!fromSym) {
+            const fromResolution = resolveSymbolInput(bridge, from);
+            if (fromResolution.status === "missing") {
                 return { content: [{ type: "text", text: `Symbol "${from}" not found.` }], isError: true };
             }
+            if (fromResolution.status === "ambiguous") {
+                return {
+                    content: [{ type: "text", text: formatAmbiguousSymbolMatches("find_path", from, fromResolution.matches) }],
+                    isError: true,
+                };
+            }
+            const fromSym = fromResolution.symbol;
             if (to) {
-                const toSym = bridge.getSymbol(to);
-                if (!toSym) {
+                const toResolution = resolveSymbolInput(bridge, to);
+                if (toResolution.status === "missing") {
                     return { content: [{ type: "text", text: `Symbol "${to}" not found.` }], isError: true };
                 }
+                if (toResolution.status === "ambiguous") {
+                    return {
+                        content: [{ type: "text", text: formatAmbiguousSymbolMatches("find_path", to, toResolution.matches) }],
+                        isError: true,
+                    };
+                }
             }
             // Delegate to the find_path tool via the tool registry
             // We need the actual ProjectIndex for this, so access it through the bridge's getGraph
@@ -189,7 +234,11 @@ function createMcpServer(bridge, emit) {
             }
             const startId = fromSym.qualifiedName;
             if (to) {
-                const toSym = bridge.getSymbol(to);
+                const toResolution = resolveSymbolInput(bridge, to);
+                if (toResolution.status !== "resolved") {
+                    return { content: [{ type: "text", text: `Symbol "${to}" could not be resolved.` }], isError: true };
+                }
+                const toSym = toResolution.symbol;
                 const endId = toSym.qualifiedName;
                 // BFS shortest path
                 const visited = new Set([startId]);