@sean.holung/minicode 0.3.5 → 0.3.7

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/symbol-search.js

@@ -0,0 +1,156 @@
+const MIN_SIMILARITY_QUERY_LENGTH = 3;
+const MIN_SIMILARITY_SCORE = 0.62;
+function normalizeSearchText(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function tokenizeSearchText(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean);
+}
+function levenshteinDistance(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    if (a.length === 0) {
+        return b.length;
+    }
+    if (b.length === 0) {
+        return a.length;
+    }
+    const previous = new Array(b.length + 1);
+    const current = new Array(b.length + 1);
+    for (let j = 0; j <= b.length; j += 1) {
+        previous[j] = j;
+    }
+    for (let i = 1; i <= a.length; i += 1) {
+        current[0] = i;
+        for (let j = 1; j <= b.length; j += 1) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + cost);
+        }
+        for (let j = 0; j <= b.length; j += 1) {
+            previous[j] = current[j];
+        }
+    }
+    return previous[b.length];
+}
+function diceCoefficient(a, b) {
+    if (a === b) {
+        return 1;
+    }
+    if (a.length < 2 || b.length < 2) {
+        return 0;
+    }
+    const bigrams = new Map();
+    for (let i = 0; i < a.length - 1; i += 1) {
+        const bigram = a.slice(i, i + 2);
+        bigrams.set(bigram, (bigrams.get(bigram) ?? 0) + 1);
+    }
+    let matches = 0;
+    for (let i = 0; i < b.length - 1; i += 1) {
+        const bigram = b.slice(i, i + 2);
+        const count = bigrams.get(bigram) ?? 0;
+        if (count > 0) {
+            bigrams.set(bigram, count - 1);
+            matches += 1;
+        }
+    }
+    return (2 * matches) / ((a.length - 1) + (b.length - 1));
+}
+function computeSimilarityScore(pattern, candidate) {
+    const normalizedPattern = normalizeSearchText(pattern);
+    const normalizedCandidate = normalizeSearchText(candidate);
+    if (!normalizedPattern || !normalizedCandidate) {
+        return 0;
+    }
+    if (normalizedPattern === normalizedCandidate) {
+        return 1;
+    }
+    const maxLength = Math.max(normalizedPattern.length, normalizedCandidate.length, 1);
+    const lengthPenalty = Math.abs(normalizedCandidate.length - normalizedPattern.length) / maxLength;
+    let bestScore = 0;
+    if (normalizedCandidate.startsWith(normalizedPattern) ||
+        normalizedPattern.startsWith(normalizedCandidate)) {
+        bestScore = Math.max(bestScore, 0.93 - (lengthPenalty * 0.2));
+    }
+    const tokens = tokenizeSearchText(candidate);
+    if (tokens.some((token) => token.startsWith(normalizedPattern) || normalizedPattern.startsWith(token))) {
+        bestScore = Math.max(bestScore, 0.88 - (lengthPenalty * 0.15));
+    }
+    const editDistance = levenshteinDistance(normalizedPattern, normalizedCandidate);
+    const maxDistance = Math.max(1, Math.ceil(normalizedPattern.length * 0.34));
+    if (editDistance <= maxDistance) {
+        const editSimilarity = 1 - (editDistance / maxLength);
+        bestScore = Math.max(bestScore, 0.62 + (editSimilarity * 0.3));
+    }
+    const dice = diceCoefficient(normalizedPattern, normalizedCandidate);
+    if (dice >= 0.5) {
+        bestScore = Math.max(bestScore, 0.45 + (dice * 0.35));
+    }
+    return bestScore;
+}
+function compareSubstringCandidates(pattern, a, b) {
+    const lowerPattern = pattern.toLowerCase();
+    const aExact = Number(a.lookupNames.some((value) => value.toLowerCase() === lowerPattern));
+    const bExact = Number(b.lookupNames.some((value) => value.toLowerCase() === lowerPattern));
+    if (aExact !== bExact) {
+        return bExact - aExact;
+    }
+    return Number(b.record.exported ?? false) - Number(a.record.exported ?? false) ||
+        a.record.name.localeCompare(b.record.name) ||
+        a.record.filePath.localeCompare(b.record.filePath) ||
+        a.record.startLine - b.record.startLine ||
+        a.record.qualifiedName.localeCompare(b.record.qualifiedName);
+}
+function compareSimilarCandidates(a, b) {
+    return b.score - a.score ||
+        Number(b.candidate.record.exported ?? false) - Number(a.candidate.record.exported ?? false) ||
+        a.candidate.record.name.localeCompare(b.candidate.record.name) ||
+        a.candidate.record.filePath.localeCompare(b.candidate.record.filePath) ||
+        a.candidate.record.startLine - b.candidate.record.startLine ||
+        a.candidate.record.qualifiedName.localeCompare(b.candidate.record.qualifiedName);
+}
+export function searchSymbols(candidates, pattern, options = {}) {
+    const lowerPattern = pattern.toLowerCase();
+    const normalizedKind = options.kind?.trim().toLowerCase();
+    const skip = Math.max(0, options.skip ?? 0);
+    const limit = Math.max(1, options.limit ?? 30);
+    const filtered = candidates.filter((candidate) => {
+        if (normalizedKind && candidate.record.kind.toLowerCase() !== normalizedKind) {
+            return false;
+        }
+        return true;
+    });
+    const substringMatches = filtered
+        .filter((candidate) => candidate.lookupNames.some((value) => value.toLowerCase().includes(lowerPattern)))
+        .sort((a, b) => compareSubstringCandidates(pattern, a, b));
+    if (substringMatches.length > 0) {
+        return {
+            matches: substringMatches.slice(skip, skip + limit).map((candidate) => candidate.symbol),
+            mode: "substring",
+            total: substringMatches.length,
+        };
+    }
+    const normalizedPattern = normalizeSearchText(pattern);
+    if (normalizedPattern.length < MIN_SIMILARITY_QUERY_LENGTH) {
+        return { matches: [], mode: "none", total: 0 };
+    }
+    const similarMatches = filtered
+        .map((candidate) => ({
+        candidate,
+        score: Math.max(...candidate.lookupNames.map((value) => computeSimilarityScore(pattern, value))),
+    }))
+        .filter((entry) => entry.score >= MIN_SIMILARITY_SCORE)
+        .sort(compareSimilarCandidates);
+    if (similarMatches.length === 0) {
+        return { matches: [], mode: "none", total: 0 };
+    }
+    return {
+        matches: similarMatches.slice(skip, skip + limit).map((entry) => entry.candidate.symbol),
+        mode: "similar",
+        total: similarMatches.length,
+    };
+}

package/dist/src/tools/search-code-map.js

@@ -1,26 +1,7 @@
 import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
 import { getSymbolDisplayName, getSymbolLookupNames } from "../indexer/symbol-names.js";
+import { searchSymbols } from "../shared/symbol-search.js";
 const DEFAULT_LIMIT = 30;
-function compareMatchedSymbols(pattern, a, b) {
-    const lowerPattern = pattern.toLowerCase();
-    const aDisplay = getSymbolDisplayName(a).toLowerCase();
-    const bDisplay = getSymbolDisplayName(b).toLowerCase();
-    const aExact = Number(aDisplay === lowerPattern || a.qualifiedName.toLowerCase() === lowerPattern || a.name.toLowerCase() === lowerPattern);
-    const bExact = Number(bDisplay === lowerPattern || b.qualifiedName.toLowerCase() === lowerPattern || b.name.toLowerCase() === lowerPattern);
-    if (aExact !== bExact) {
-        return bExact - aExact;
-    }
-    return Number(b.exported) - Number(a.exported) ||
-        aDisplay.localeCompare(bDisplay) ||
-        a.filePath.localeCompare(b.filePath) ||
-        a.startLine - b.startLine ||
-        a.qualifiedName.localeCompare(b.qualifiedName);
-}
-function matchesPattern(text, pattern) {
-    const lowerText = text.toLowerCase();
-    const lowerPattern = pattern.toLowerCase();
-    return lowerText.includes(lowerPattern);
-}
 export function createSearchCodeMapTool(projectIndex) {
     return {
         name: "search_code_map",
@@ -58,28 +39,39 @@ export function createSearchCodeMapTool(projectIndex) {
                 : undefined;
             const limit = Math.max(1, Math.min(100, expectOptionalNumber(input, "limit") ?? DEFAULT_LIMIT));
             const skip = Math.max(0, expectOptionalNumber(input, "skip") ?? 0);
-            const symbols = [...projectIndex.symbols.values()];
-            const matches = symbols.filter((sym) => {
-                const lookupNames = getSymbolLookupNames(sym);
-                if (!lookupNames.some((candidate) => matchesPattern(candidate, pattern))) {
-                    return false;
-                }
-                if (kind && sym.kind !== kind) {
-                    return false;
-                }
-                return true;
-            }).sort((a, b) => compareMatchedSymbols(pattern, a, b));
-            const shown = matches.slice(skip, skip + limit);
+            const result = searchSymbols([...projectIndex.symbols.values()].map((sym) => ({
+                symbol: sym,
+                record: {
+                    name: getSymbolDisplayName(sym),
+                    qualifiedName: sym.qualifiedName,
+                    kind: sym.kind,
+                    filePath: sym.filePath,
+                    startLine: sym.startLine,
+                    exported: sym.exported,
+                },
+                lookupNames: getSymbolLookupNames(sym),
+            })), pattern, { kind, limit, skip });
+            const shown = result.matches;
             const lines = shown.map((s) => `- ${getSymbolDisplayName(s)} (${s.kind}) — ${s.filePath}:${s.startLine} — qualified: ${s.qualifiedName}`);
-            const remaining = matches.length - skip - shown.length;
+            const remaining = result.total - skip - shown.length;
             const footer = remaining > 0
                 ? `\n... and ${remaining} more (use skip: ${skip + limit}, limit: ${limit} for next page)`
                 : "";
-            if (matches.length === 0) {
+            if (result.total === 0) {
                 return `No symbols matching "${pattern}"${kind ? ` (kind: ${kind})` : ""}. Try a shorter or different pattern.`;
             }
+            if (result.mode === "similar") {
+                return [
+                    `# No exact substring matches for "${pattern}"${kind ? ` (kind: ${kind})` : ""}`,
+                    "",
+                    `Showing similar symbols instead (${result.total} total):`,
+                    "",
+                    ...lines,
+                    footer,
+                ].join("\n");
+            }
             return [
-                `# Symbols matching "${pattern}" (${matches.length} total)`,
+                `# Symbols matching "${pattern}" (${result.total} total)`,
                 "",
                 ...lines,
                 footer,