@sean.holung/minicode 0.3.2 → 0.3.3

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

@@ -2,26 +2,75 @@ import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { generateCodeMap } from "./code-map.js";
 import { getPluginForFile, loadPlugins } from "./plugin-loader.js";
+import { getSymbolLookupNames, normalizeIndexedSymbols } from "./symbol-names.js";
 const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage"]);
-async function collectSourceFiles(dir, root, files) {
+async function collectSourceFiles(dir, root, files, validExtensions) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
             if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-                await collectSourceFiles(fullPath, root, files);
+                await collectSourceFiles(fullPath, root, files, validExtensions);
             }
             continue;
         }
         if (entry.isFile()) {
             const ext = path.extname(entry.name).toLowerCase();
-            if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+            if (validExtensions.has(ext)) {
                 files.push(path.relative(root, fullPath));
             }
         }
     }
 }
+function buildAdjacencyFrom(edges) {
+    const map = new Map();
+    for (const edge of edges) {
+        const list = map.get(edge.from);
+        if (list) {
+            list.push(edge);
+        }
+        else {
+            map.set(edge.from, [edge]);
+        }
+    }
+    return map;
+}
+function buildAdjacencyTo(edges) {
+    const map = new Map();
+    for (const edge of edges) {
+        const list = map.get(edge.to);
+        if (list) {
+            list.push(edge);
+        }
+        else {
+            map.set(edge.to, [edge]);
+        }
+    }
+    return map;
+}
+function resolveSymbol(name, symbols) {
+    const direct = symbols.get(name);
+    if (direct)
+        return direct;
+    const matches = [...symbols.values()].filter((sym) => getSymbolLookupNames(sym).includes(name));
+    if (matches.length === 0) {
+        return undefined;
+    }
+    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];
+}
 export function createProjectIndex(symbols, files, dependencyEdges, plugins, projectFiles, workspaceRoot) {
+    let adjacencyFrom = buildAdjacencyFrom(dependencyEdges);
+    function rebuildSymbolsMap() {
+        const normalizedSymbols = normalizeIndexedSymbols(files);
+        symbols.clear();
+        for (const [qualifiedName, symbol] of normalizedSymbols) {
+            symbols.set(qualifiedName, symbol);
+        }
+    }
     return {
         symbols,
         files,
@@ -30,20 +79,13 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
         projectFiles,
         workspaceRoot,
         getSymbol(name) {
-            const direct = symbols.get(name);
-            if (direct)
-                return direct;
-            for (const sym of symbols.values()) {
-                if (sym.name === name || sym.qualifiedName === name)
-                    return sym;
-            }
-            return undefined;
+            return resolveSymbol(name, symbols);
         },
         getSymbolsInFile(filePath) {
             return files.get(filePath) ?? [];
         },
         getDependencyCone(symbolName, depth = 2) {
-            const target = symbols.get(symbolName) ?? [...symbols.values()].find((s) => s.name === symbolName || s.qualifiedName === symbolName);
+            const target = resolveSymbol(symbolName, symbols);
             if (!target)
                 return [];
             const result = new Map();
@@ -52,13 +94,14 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
             for (let d = 0; d < depth; d += 1) {
                 const next = new Set();
                 for (const from of frontier) {
-                    for (const edge of dependencyEdges) {
-                        if (edge.from === from) {
-                            const dep = symbols.get(edge.to) ?? [...symbols.values()].find((s) => s.qualifiedName === edge.to || s.name === edge.to);
-                            if (dep && !result.has(dep.qualifiedName)) {
-                                result.set(dep.qualifiedName, dep);
-                                next.add(dep.qualifiedName);
-                            }
+                    const outEdges = adjacencyFrom.get(from);
+                    if (!outEdges)
+                        continue;
+                    for (const edge of outEdges) {
+                        const dep = resolveSymbol(edge.to, symbols);
+                        if (dep && !result.has(dep.qualifiedName)) {
+                            result.set(dep.qualifiedName, dep);
+                            next.add(dep.qualifiedName);
                         }
                     }
                 }
@@ -66,6 +109,108 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
             }
             return [...result.values()];
         },
+        findPath(fromSymbol, toSymbol, maxDepth = 10) {
+            const from = resolveSymbol(fromSymbol, symbols);
+            const to = resolveSymbol(toSymbol, symbols);
+            if (!from || !to)
+                return [];
+            // BFS over both outgoing and incoming edges (undirected search)
+            const adjacencyTo = buildAdjacencyTo(dependencyEdges);
+            const visited = new Set();
+            const parent = new Map();
+            const queue = [
+                { name: from.qualifiedName, depth: 0 },
+            ];
+            visited.add(from.qualifiedName);
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (current.name === to.qualifiedName) {
+                    // Reconstruct path
+                    const path = [];
+                    let node = to.qualifiedName;
+                    while (node !== undefined) {
+                        const sym = resolveSymbol(node, symbols);
+                        if (sym)
+                            path.unshift(sym);
+                        node = parent.get(node);
+                    }
+                    return path;
+                }
+                if (current.depth >= maxDepth)
+                    continue;
+                // Follow outgoing edges
+                const outEdges = adjacencyFrom.get(current.name) ?? [];
+                for (const edge of outEdges) {
+                    const target = resolveSymbol(edge.to, symbols);
+                    if (target && !visited.has(target.qualifiedName)) {
+                        visited.add(target.qualifiedName);
+                        parent.set(target.qualifiedName, current.name);
+                        queue.push({ name: target.qualifiedName, depth: current.depth + 1 });
+                    }
+                }
+                // Follow incoming edges (reverse direction)
+                const inEdges = adjacencyTo.get(current.name) ?? [];
+                for (const edge of inEdges) {
+                    const source = resolveSymbol(edge.from, symbols);
+                    if (source && !visited.has(source.qualifiedName)) {
+                        visited.add(source.qualifiedName);
+                        parent.set(source.qualifiedName, current.name);
+                        queue.push({ name: source.qualifiedName, depth: current.depth + 1 });
+                    }
+                }
+            }
+            return [];
+        },
+        findPathToEntryPoint(symbolName, maxDepth = 20) {
+            const target = resolveSymbol(symbolName, symbols);
+            if (!target)
+                return [];
+            // Build reverse adjacency: who calls/references this symbol?
+            const adjacencyTo = buildAdjacencyTo(dependencyEdges);
+            // Find entry points: symbols that have no inbound edges
+            const hasInbound = new Set();
+            for (const edge of dependencyEdges) {
+                hasInbound.add(edge.to);
+            }
+            // If the target itself is already an entry point (no inbound edges), nothing to trace
+            if (!hasInbound.has(target.qualifiedName))
+                return [];
+            // DFS from target following inbound edges back to entry points
+            const paths = [];
+            const currentPath = [target];
+            const visiting = new Set([target.qualifiedName]);
+            function dfs(node, depth) {
+                if (depth >= maxDepth)
+                    return;
+                const inEdges = adjacencyTo.get(node) ?? [];
+                const callers = inEdges
+                    .map((e) => resolveSymbol(e.from, symbols))
+                    .filter((s) => s != null && !visiting.has(s.qualifiedName));
+                if (callers.length === 0) {
+                    // Dead end going backwards — this is as far as we can trace
+                    if (currentPath.length > 1) {
+                        paths.push([...currentPath].reverse());
+                    }
+                    return;
+                }
+                for (const caller of callers) {
+                    // If this caller is an entry point (no inbound edges), record the path
+                    if (!hasInbound.has(caller.qualifiedName)) {
+                        currentPath.push(caller);
+                        paths.push([...currentPath].reverse());
+                        currentPath.pop();
+                        continue;
+                    }
+                    visiting.add(caller.qualifiedName);
+                    currentPath.push(caller);
+                    dfs(caller.qualifiedName, depth + 1);
+                    currentPath.pop();
+                    visiting.delete(caller.qualifiedName);
+                }
+            }
+            dfs(target.qualifiedName, 0);
+            return paths.slice(0, 10);
+        },
         getCodeMap(tokenBudget, focusSymbols) {
             return generateCodeMap(files, tokenBudget, dependencyEdges, focusSymbols);
         },
@@ -76,24 +221,17 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
             const plugin = getPluginForFile(relPath, plugins);
             if (!plugin)
                 return;
-            const oldSymbols = files.get(relPath) ?? [];
-            for (const sym of oldSymbols) {
-                symbols.delete(sym.qualifiedName);
-            }
             files.delete(relPath);
             projectFiles.set(relPath, content);
             const extracted = plugin.indexFile(relPath, content);
-            for (const sym of extracted) {
-                symbols.set(sym.qualifiedName, sym);
-                const existing = files.get(relPath) ?? [];
-                existing.push(sym);
-                files.set(relPath, existing);
-            }
+            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;
                 }
             }
@@ -106,8 +244,9 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
 export async function buildProjectIndex(workspaceRoot) {
     const plugins = await loadPlugins(workspaceRoot);
     const root = path.resolve(workspaceRoot);
+    const validExtensions = new Set(plugins.flatMap((p) => p.extensions));
     const sourceFiles = [];
-    await collectSourceFiles(root, root, sourceFiles);
+    await collectSourceFiles(root, root, sourceFiles, validExtensions);
     const symbols = new Map();
     const files = new Map();
     const projectFiles = new Map();
@@ -125,12 +264,12 @@ export async function buildProjectIndex(workspaceRoot) {
         }
         projectFiles.set(relPath, content);
         const extracted = plugin.indexFile(relPath, content);
-        for (const sym of extracted) {
-            symbols.set(sym.qualifiedName, sym);
-            const existing = files.get(relPath) ?? [];
-            existing.push(sym);
-            files.set(relPath, existing);
-        }
+        files.set(relPath, extracted);
+    }
+    const normalizedSymbols = normalizeIndexedSymbols(files);
+    symbols.clear();
+    for (const [qualifiedName, symbol] of normalizedSymbols) {
+        symbols.set(qualifiedName, symbol);
     }
     let dependencyEdges = [];
     for (const plugin of plugins) {

package/dist/src/indexer/symbol-names.js

@@ -0,0 +1,92 @@
+function dedupe(values) {
+    return [...new Set(values.filter((value) => value.length > 0))];
+}
+function buildDisplayName(baseName, symbol, kindCount, distinctFileCount) {
+    if (distinctFileCount > 1) {
+        return `${baseName} (${symbol.kind} in ${symbol.filePath}:${symbol.startLine})`;
+    }
+    if (kindCount === 1) {
+        return `${baseName} (${symbol.kind})`;
+    }
+    return `${baseName} (${symbol.kind}:${symbol.startLine})`;
+}
+function buildQualifiedName(baseName, symbol, kindCount, distinctFileCount) {
+    if (distinctFileCount > 1) {
+        return `${baseName}#${symbol.kind}@${symbol.filePath}:${symbol.startLine}`;
+    }
+    if (kindCount === 1) {
+        return `${baseName}#${symbol.kind}`;
+    }
+    return `${baseName}#${symbol.kind}:${symbol.startLine}`;
+}
+function countByKind(symbols) {
+    const counts = new Map();
+    for (const symbol of symbols) {
+        counts.set(symbol.kind, (counts.get(symbol.kind) ?? 0) + 1);
+    }
+    return counts;
+}
+function countByFile(symbols) {
+    const counts = new Map();
+    for (const symbol of symbols) {
+        counts.set(symbol.filePath, (counts.get(symbol.filePath) ?? 0) + 1);
+    }
+    return counts;
+}
+export function getSymbolDisplayName(symbol) {
+    return symbol.displayName ?? symbol.qualifiedName;
+}
+export function getSymbolLookupNames(symbol) {
+    return dedupe([
+        symbol.qualifiedName,
+        symbol.originalQualifiedName ?? "",
+        symbol.displayName ?? "",
+        symbol.name,
+        ...(symbol.aliases ?? []),
+    ]);
+}
+export function normalizeIndexedSymbols(symbolsByFile) {
+    const allSymbols = [...symbolsByFile.values()].flat();
+    const groupedByBaseName = new Map();
+    for (const symbol of allSymbols) {
+        const baseName = symbol.originalQualifiedName ?? symbol.qualifiedName;
+        symbol.originalQualifiedName = baseName;
+        symbol.displayName = symbol.displayName ?? baseName;
+        symbol.aliases = dedupe([
+            symbol.name,
+            baseName,
+            symbol.displayName,
+            ...(symbol.aliases ?? []),
+        ]);
+        const existing = groupedByBaseName.get(baseName);
+        if (existing) {
+            existing.push(symbol);
+        }
+        else {
+            groupedByBaseName.set(baseName, [symbol]);
+        }
+    }
+    for (const [baseName, group] of groupedByBaseName) {
+        if (group.length < 2)
+            continue;
+        const sorted = [...group].sort((a, b) => a.filePath.localeCompare(b.filePath) ||
+            a.startLine - b.startLine ||
+            a.kind.localeCompare(b.kind));
+        const kindCounts = countByKind(sorted);
+        const distinctFileCount = countByFile(sorted).size;
+        for (const symbol of sorted) {
+            const kindCount = kindCounts.get(symbol.kind) ?? 1;
+            const displayName = buildDisplayName(baseName, symbol, kindCount, distinctFileCount);
+            const qualifiedName = buildQualifiedName(baseName, symbol, kindCount, distinctFileCount);
+            symbol.displayName = displayName;
+            symbol.aliases = dedupe([
+                symbol.name,
+                baseName,
+                displayName,
+                ...(symbol.aliases ?? []),
+            ]);
+            symbol.qualifiedName = qualifiedName;
+        }
+    }
+    return new Map(allSymbols.map((symbol) => [symbol.qualifiedName, symbol]));
+}

package/dist/src/model-utils.js

@@ -0,0 +1,18 @@
+function getModelDisplayName(model) {
+    return (model.name ?? model.id).trim();
+}
+export function sortModelsAlphabetically(models) {
+    return [...models].sort((left, right) => {
+        const byDisplayName = getModelDisplayName(left).localeCompare(getModelDisplayName(right), undefined, {
+            sensitivity: "base",
+            numeric: true,
+        });
+        if (byDisplayName !== 0) {
+            return byDisplayName;
+        }
+        return left.id.localeCompare(right.id, undefined, {
+            sensitivity: "base",
+            numeric: true,
+        });
+    });
+}