@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/src/server/search/EmbeddingEngine.js

@@ -0,0 +1,83 @@
+import { Worker } from 'worker_threads';
+export class EmbeddingEngine {
+    worker = null;
+    ready = false;
+    nextId = 0;
+    pending = new Map();
+    isReady() {
+        return this.ready;
+    }
+    async embed(text) {
+        this.ensureWorker();
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, {
+                resolve: resolve,
+                reject,
+            });
+            this.worker.postMessage({ type: 'embed', id, text });
+        });
+    }
+    async embedBatch(texts) {
+        if (texts.length === 0)
+            return [];
+        this.ensureWorker();
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, {
+                resolve: resolve,
+                reject,
+            });
+            this.worker.postMessage({ type: 'embed_batch', id, texts });
+        });
+    }
+    async terminate() {
+        if (this.worker) {
+            for (const [, req] of this.pending) {
+                req.reject(new Error('EmbeddingEngine terminated'));
+            }
+            this.pending.clear();
+            await this.worker.terminate();
+            this.worker = null;
+            this.ready = false;
+        }
+    }
+    ensureWorker() {
+        if (this.worker)
+            return;
+        const workerPath = new URL('./EmbeddingWorker.js', import.meta.url);
+        this.worker = new Worker(workerPath);
+        this.worker.on('message', (msg) => {
+            const req = this.pending.get(msg.id);
+            if (!req)
+                return;
+            this.pending.delete(msg.id);
+            if (msg.type === 'result') {
+                this.ready = true;
+                req.resolve(msg.embedding);
+            }
+            else if (msg.type === 'error') {
+                req.reject(new Error(msg.message ?? 'Unknown worker error'));
+            }
+        });
+        this.worker.on('error', (err) => {
+            for (const [, req] of this.pending) {
+                req.reject(err);
+            }
+            this.pending.clear();
+            this.worker = null;
+            this.ready = false;
+        });
+        this.worker.on('exit', (code) => {
+            if (code !== 0) {
+                const err = new Error(`Embedding worker exited with code ${code}`);
+                for (const [, req] of this.pending) {
+                    req.reject(err);
+                }
+                this.pending.clear();
+            }
+            this.worker = null;
+            this.ready = false;
+        });
+    }
+}

package/dist/src/server/search/EmbeddingWorker.js

@@ -0,0 +1,51 @@
+import { parentPort } from 'worker_threads';
+let embedder = null;
+const MODEL_ID = 'Xenova/bge-micro-v2';
+async function getEmbedder() {
+    if (!embedder) {
+        const { pipeline } = await import('@huggingface/transformers');
+        embedder = await pipeline('feature-extraction', MODEL_ID, {
+            quantized: true,
+        });
+    }
+    return embedder;
+}
+function normalise(data) {
+    let norm = 0;
+    for (let i = 0; i < data.length; i++) {
+        norm += data[i] * data[i];
+    }
+    norm = Math.sqrt(norm);
+    if (norm > 0) {
+        for (let i = 0; i < data.length; i++) {
+            data[i] /= norm;
+        }
+    }
+    return data;
+}
+parentPort?.on('message', async (msg) => {
+    try {
+        if (msg.type === 'embed') {
+            const pipe = await getEmbedder();
+            const output = await pipe(msg.text, { pooling: 'mean', normalize: true });
+            const raw = output.data;
+            const embedding = normalise(new Float32Array(raw));
+            parentPort.postMessage({ type: 'result', id: msg.id, embedding }, [embedding.buffer]);
+        }
+        else if (msg.type === 'embed_batch') {
+            const pipe = await getEmbedder();
+            const texts = msg.texts;
+            const embeddings = [];
+            for (const text of texts) {
+                const output = await pipe(text, { pooling: 'mean', normalize: true });
+                const raw = output.data;
+                embeddings.push(normalise(new Float32Array(raw)));
+            }
+            parentPort.postMessage({ type: 'result', id: msg.id, embedding: embeddings });
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        parentPort.postMessage({ type: 'error', id: msg.id, message });
+    }
+});

package/dist/src/server/search/SynonymExpander.d.ts

@@ -0,0 +1,7 @@
+export declare class SynonymExpander {
+    private readonly reverseMap;
+    constructor();
+    expand(token: string): string[];
+    expandQuery(tokens: string[]): string[];
+    private static buildReverseMap;
+}

package/dist/src/server/search/SynonymExpander.js

@@ -0,0 +1,97 @@
+import { SEARCH_SYNONYM_EXPANSION_LIMIT } from '../../constants.js';
+const SYNONYM_GROUPS = [
+    ['navigate', 'go', 'open', 'visit', 'browse', 'load'],
+    ['intercept', 'capture', 'monitor', 'sniff', 'collect', 'record', 'track'],
+    ['request', 'fetch', 'xhr', 'ajax', 'http', 'api'],
+    ['authenticate', 'auth', 'login', 'credential', 'token', 'jwt', 'session'],
+    ['breakpoint', 'pause', 'halt', 'stop', 'break'],
+    ['step', 'next', 'continue', 'resume'],
+    ['deobfuscate', 'beautify', 'unminify', 'decode', 'transform', 'decompile'],
+    ['screenshot', 'snapshot', 'image', 'picture', 'photo'],
+    ['evaluate', 'execute', 'run', 'eval', 'invoke', 'call'],
+    ['element', 'node', 'selector', 'dom', 'component'],
+    ['click', 'tap', 'press', 'interact', 'trigger'],
+    ['type', 'input', 'enter', 'fill', 'write'],
+    ['cookie', 'localstorage', 'storage', 'cache', 'indexeddb'],
+    ['websocket', 'ws', 'socket', 'realtime'],
+    ['scroll', 'swipe', 'drag'],
+    ['search', 'find', 'query', 'lookup', 'discover', 'locate'],
+    ['hook', 'patch', 'override', 'replace', 'wrap', 'proxy'],
+    ['script', 'code', 'source', 'javascript', 'js'],
+    ['bundle', 'webpack', 'module', 'pack', 'chunk'],
+    ['block', 'filter', 'deny', 'reject', 'prevent'],
+    ['allow', 'permit', 'whitelist', 'accept', 'enable'],
+    ['remove', 'delete', 'clear', 'clean', 'purge', 'erase'],
+    ['list', 'show', 'display', 'enumerate', 'get'],
+    ['set', 'configure', 'config', 'setup', 'assign'],
+    ['stealth', 'antidetect', 'fingerprint', 'evasion', 'undetected'],
+    ['mobile', 'device', 'emulate', 'responsive', 'phone'],
+    ['performance', 'profile', 'benchmark', 'metric', 'vitals'],
+    ['register', 'signup', 'account', 'enroll', 'join'],
+    ['captcha', 'challenge', 'verification', 'verify', 'solve'],
+    ['tab', 'window', 'page'],
+    ['inspect', 'examine', 'analyze', 'analyse', 'debug', 'investigate'],
+    ['wait', 'delay', 'sleep', 'timeout', 'poll'],
+    ['close', 'disconnect', 'quit', 'exit', 'shutdown', 'terminate'],
+    ['traffic', 'network', 'request', 'response', 'connection'],
+    ['heap', 'memory', 'allocation', 'gc', 'garbage'],
+    ['export', 'save', 'dump', 'download', 'extract'],
+    ['replay', 'resend', 'repeat', 'redo', 'retry'],
+    ['variable', 'scope', 'local', 'closure', 'context'],
+    ['watch', 'observe', 'monitor', 'trace', 'track'],
+    ['protobuf', 'proto', 'binary', 'msgpack', 'grpc'],
+    ['wasm', 'webassembly', 'assembly'],
+    ['sse', 'eventsource', 'stream', 'streaming'],
+    ['graphql', 'gql', 'introspect', 'mutation', 'subscription'],
+];
+export class SynonymExpander {
+    reverseMap;
+    constructor() {
+        this.reverseMap = SynonymExpander.buildReverseMap(SYNONYM_GROUPS);
+    }
+    expand(token) {
+        const synonyms = this.reverseMap.get(token.toLowerCase());
+        return synonyms ? [...synonyms] : [];
+    }
+    expandQuery(tokens) {
+        const existing = new Set(tokens.map((t) => t.toLowerCase()));
+        const expanded = [];
+        const limit = SEARCH_SYNONYM_EXPANSION_LIMIT;
+        for (const token of tokens) {
+            const synonyms = this.reverseMap.get(token.toLowerCase());
+            if (!synonyms)
+                continue;
+            let added = 0;
+            for (const syn of synonyms) {
+                if (added >= limit)
+                    break;
+                if (!existing.has(syn)) {
+                    expanded.push(syn);
+                    existing.add(syn);
+                    added++;
+                }
+            }
+        }
+        return expanded;
+    }
+    static buildReverseMap(groups) {
+        const map = new Map();
+        for (const group of groups) {
+            for (const token of group) {
+                const lower = token.toLowerCase();
+                let synonymSet = map.get(lower);
+                if (!synonymSet) {
+                    synonymSet = new Set();
+                    map.set(lower, synonymSet);
+                }
+                for (const otherToken of group) {
+                    const otherLower = otherToken.toLowerCase();
+                    if (otherLower !== lower) {
+                        synonymSet.add(otherLower);
+                    }
+                }
+            }
+        }
+        return map;
+    }
+}

package/dist/src/server/search/ToolSearchEngineImpl.d.ts

@@ -20,10 +20,15 @@ export declare class ToolSearchEngine {
     private readonly docNameIndex;
     private readonly affinityGraph;
     private readonly queryCache;
+    private readonly trigramIndex;
+    private readonly embeddingEngine;
+    private toolEmbeddings;
+    private vectorWeight;
+    private lastVectorRanking;
     private readonly bm25Scorer;
     private readonly intentBoost;
     constructor(tools?: Tool[], domainOverrides?: ReadonlyMap<string, string>, domainScoreMultipliers?: ReadonlyMap<string, number>, toolScoreMultipliers?: ReadonlyMap<string, number>, searchConfig?: SearchConfig);
-    search(query: string, topK?: number, activeToolNames?: ReadonlySet<string>): ToolSearchResult[];
+    search(query: string, topK?: number, activeToolNames?: ReadonlySet<string>): Promise<ToolSearchResult[]>;
     getDomainSummary(): Array<{
         domain: string | null;
         count: number;
@@ -32,7 +37,15 @@ export declare class ToolSearchEngine {
     private scoreToken;
     private findPrefixMatches;
     private scorePostings;
-    private applyTfidfCosineBoost;
+    private applyRRFFusion;
+    private computeTfidfCosineScores;
+    private rankByScores;
+    private rankByMap;
+    private ensureToolEmbeddings;
+    private computeVectorCosineScores;
+    recordToolCallFeedback(toolName: string, _lastQuery: string): void;
+    private applyIntentBonusBand;
+    static extractParamTokens(inputSchema: unknown): string[];
     private buildAffinityGraph;
     private applyAffinityExpansion;
     private applyDomainHubExpansion;

package/dist/src/server/search/ToolSearchEngineImpl.js

@@ -1,7 +1,9 @@
 import { allTools, getToolDomain } from '../ToolCatalog.js';
-import { SEARCH_TFIDF_COSINE_WEIGHT, SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_THRESHOLD, SEARCH_QUERY_CACHE_CAPACITY, } from '../../constants.js';
+import { SEARCH_TFIDF_COSINE_WEIGHT, SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_THRESHOLD, SEARCH_QUERY_CACHE_CAPACITY, SEARCH_TRIGRAM_WEIGHT, SEARCH_RRF_K, SEARCH_PARAM_TOKEN_WEIGHT, SEARCH_VECTOR_ENABLED, SEARCH_VECTOR_COSINE_WEIGHT, } from '../../constants.js';
 import { BM25ScorerImpl } from './BM25Scorer.js';
+import { EmbeddingEngine } from './EmbeddingEngine.js';
 import { IntentBoostImpl } from './IntentBoost.js';
+import { TrigramIndex } from './TrigramIndex.js';
 class LRUCache {
     capacity;
     map = new Map();
@@ -41,6 +43,11 @@ export class ToolSearchEngine {
     docNameIndex = new Map();
     affinityGraph;
     queryCache;
+    trigramIndex;
+    embeddingEngine;
+    toolEmbeddings = null;
+    vectorWeight;
+    lastVectorRanking = null;
     bm25Scorer;
     intentBoost;
     constructor(tools, domainOverrides, domainScoreMultipliers, toolScoreMultipliers, searchConfig) {
@@ -50,6 +57,9 @@ export class ToolSearchEngine {
         this.toolScoreMultipliers = toolScoreMultipliers;
         this.docCount = source.length;
         this.bm25Scorer = new BM25ScorerImpl(searchConfig);
+        const vectorEnabled = searchConfig?.vectorEnabled ?? SEARCH_VECTOR_ENABLED;
+        this.embeddingEngine = vectorEnabled ? new EmbeddingEngine() : null;
+        this.vectorWeight = searchConfig?.vectorCosineWeight ?? SEARCH_VECTOR_COSINE_WEIGHT;
         this.intentBoost = new IntentBoostImpl(searchConfig?.intentToolBoostRules);
         let totalLength = 0;
         for (let i = 0; i < source.length; i++) {
@@ -61,7 +71,8 @@ export class ToolSearchEngine {
             const nameTokenSet = new Set(nameTokens);
             const domainTokens = domain ? this.bm25Scorer.tokenise(domain) : [];
             const descTokens = this.bm25Scorer.tokenise(description);
-            const allTokens = [...nameTokens, ...domainTokens, ...descTokens];
+            const paramTokens = ToolSearchEngine.extractParamTokens(tool.inputSchema);
+            const allTokens = [...nameTokens, ...domainTokens, ...descTokens, ...paramTokens];
             const doc = {
                 name: tool.name,
                 domain,
@@ -97,6 +108,12 @@ export class ToolSearchEngine {
                 entry.weight = Math.max(entry.weight, 1);
                 termFreqs.set(token, entry);
             }
+            for (const token of paramTokens) {
+                const entry = termFreqs.get(token) ?? { tf: 0, weight: 0 };
+                entry.tf++;
+                entry.weight = Math.max(entry.weight, SEARCH_PARAM_TOKEN_WEIGHT);
+                termFreqs.set(token, entry);
+            }
             for (const [token, { tf, weight }] of termFreqs) {
                 let postings = this.invertedIndex.get(token);
                 if (!postings) {
@@ -131,10 +148,11 @@ export class ToolSearchEngine {
             doc.tfidfMagnitude = Math.sqrt(magnitudeSq);
         }
         this.affinityGraph = this.buildAffinityGraph();
+        this.trigramIndex = new TrigramIndex(this.docs.map((d) => d.name));
         this.queryCache = new LRUCache(SEARCH_QUERY_CACHE_CAPACITY);
     }
-    search(query, topK = 10, activeToolNames) {
-        const queryTokens = this.bm25Scorer.tokenise(query);
+    async search(query, topK = 10, activeToolNames) {
+        const queryTokens = this.bm25Scorer.tokenise(query, { expandSynonyms: true });
         if (queryTokens.length === 0) {
             return [];
         }
@@ -201,9 +219,7 @@ export class ToolSearchEngine {
                 }
             }
         }
-        if (SEARCH_TFIDF_COSINE_WEIGHT > 0) {
-            this.applyTfidfCosineBoost(queryTokens, scores);
-        }
+        await this.applyRRFFusion(queryTokens, query, scores);
         const categoryDomainBoosts = this.bm25Scorer.detectQueryCategoryBoosts(query);
         const queryNormalised = query.toLowerCase().replace(/[\s-]+/g, '_');
         const queryTokenSet = new Set(queryTokens);
@@ -214,9 +230,6 @@ export class ToolSearchEngine {
                 continue;
             if (doc.name === queryNormalised) {
                 scores[i] *= 2.5;
-                if (intentBonus > 0) {
-                    scores[i] += intentBonus;
-                }
                 continue;
             }
             let matchedCount = 0;
@@ -229,9 +242,7 @@ export class ToolSearchEngine {
                 const precision = matchedCount / queryTokenSet.size;
                 scores[i] *= 1 + 0.5 * coverage * precision;
             }
-            const domainMultiplier = doc.domain
-                ? (this.domainScoreMultipliers?.get(doc.domain) ?? 1)
-                : 1;
+            const domainMultiplier = doc.domain ? (this.domainScoreMultipliers?.get(doc.domain) ?? 1) : 1;
             if (domainMultiplier !== 1) {
                 scores[i] *= domainMultiplier;
             }
@@ -245,12 +256,10 @@ export class ToolSearchEngine {
             if (toolMultiplier !== 1) {
                 scores[i] *= toolMultiplier;
             }
-            if (intentBonus > 0) {
-                scores[i] += intentBonus;
-            }
         }
         this.applyAffinityExpansion(scores);
         this.applyDomainHubExpansion(scores);
+        this.applyIntentBonusBand(scores, intentToolBonuses);
         if (explicitToolMention) {
             const explicitIdx = this.docNameIndex.get(explicitToolMention);
             if (explicitIdx !== undefined) {
@@ -329,7 +338,49 @@ export class ToolSearchEngine {
             scores[docIndex] += idf * tfNorm * weight * multiplier;
         }
     }
-    applyTfidfCosineBoost(queryTokens, scores) {
+    async applyRRFFusion(queryTokens, query, scores) {
+        const k = SEARCH_RRF_K;
+        const trigramWeight = SEARCH_TRIGRAM_WEIGHT;
+        const tfidfWeight = SEARCH_TFIDF_COSINE_WEIGHT;
+        const bm25Ranked = this.rankByScores(scores);
+        const cosineScores = this.computeTfidfCosineScores(queryTokens);
+        const cosineRanked = this.rankByMap(cosineScores);
+        const trigramScores = this.trigramIndex.search(query, 0.2);
+        const trigramRanked = this.rankByMap(trigramScores);
+        const vectorScores = await this.computeVectorCosineScores(query);
+        const vectorRanked = this.rankByMap(vectorScores);
+        if (vectorRanked.size > 0) {
+            this.lastVectorRanking = new Map();
+            for (const [docIdx, rank] of vectorRanked) {
+                this.lastVectorRanking.set(this.docs[docIdx].name, rank);
+            }
+        }
+        for (let i = 0; i < this.docCount; i++) {
+            let rrfScore = 0;
+            const bm25Rank = bm25Ranked.get(i);
+            if (bm25Rank !== undefined) {
+                rrfScore += 1 / (k + bm25Rank);
+            }
+            const cosineRank = cosineRanked.get(i);
+            if (cosineRank !== undefined && tfidfWeight > 0) {
+                rrfScore += tfidfWeight * (1 / (k + cosineRank));
+            }
+            const trigramRank = trigramRanked.get(i);
+            if (trigramRank !== undefined && trigramWeight > 0) {
+                rrfScore += trigramWeight * (1 / (k + trigramRank));
+            }
+            const vectorRank = vectorRanked.get(i);
+            if (vectorRank !== undefined && this.vectorWeight > 0) {
+                rrfScore += this.vectorWeight * (1 / (k + vectorRank));
+            }
+            if (rrfScore > 0) {
+                const bm25Original = scores[i];
+                const rrfRescaled = rrfScore * 1000;
+                scores[i] = Math.max(bm25Original, rrfRescaled * 0.5) + rrfRescaled * 0.5;
+            }
+        }
+    }
+    computeTfidfCosineScores(queryTokens) {
         const queryTf = new Map();
         for (const token of queryTokens) {
             queryTf.set(token, (queryTf.get(token) ?? 0) + 1);
@@ -345,27 +396,170 @@ export class ToolSearchEngine {
             queryMagSq += w * w;
         }
         if (queryMagSq === 0)
-            return;
+            return new Map();
         const queryMagnitude = Math.sqrt(queryMagSq);
-        const weight = SEARCH_TFIDF_COSINE_WEIGHT;
+        const results = new Map();
         for (let i = 0; i < this.docCount; i++) {
-            if (scores[i] <= 0)
-                continue;
             const doc = this.docs[i];
             if (doc.tfidfMagnitude === 0)
                 continue;
             let dot = 0;
             for (const [term, qw] of queryWeights) {
                 const dw = doc.tfidfWeights.get(term);
-                if (dw !== undefined) {
+                if (dw !== undefined)
                     dot += qw * dw;
-                }
             }
             if (dot <= 0)
                 continue;
-            const cosine = dot / (queryMagnitude * doc.tfidfMagnitude);
-            scores[i] *= 1 + weight * cosine;
+            results.set(i, dot / (queryMagnitude * doc.tfidfMagnitude));
+        }
+        return results;
+    }
+    rankByScores(scores) {
+        const entries = [];
+        for (let i = 0; i < scores.length; i++) {
+            if (scores[i] > 0) {
+                entries.push({ idx: i, score: scores[i] });
+            }
+        }
+        entries.sort((a, b) => b.score - a.score);
+        const ranked = new Map();
+        for (let rank = 0; rank < entries.length; rank++) {
+            ranked.set(entries[rank].idx, rank);
+        }
+        return ranked;
+    }
+    rankByMap(scoreMap) {
+        const entries = [...scoreMap.entries()].sort((a, b) => b[1] - a[1]);
+        const ranked = new Map();
+        for (let rank = 0; rank < entries.length; rank++) {
+            ranked.set(entries[rank][0], rank);
+        }
+        return ranked;
+    }
+    async ensureToolEmbeddings() {
+        if (this.toolEmbeddings || !this.embeddingEngine)
+            return;
+        const descriptions = this.docs.map((doc) => `${doc.name.replace(/_/g, ' ')}: ${doc.description}`);
+        this.toolEmbeddings = await this.embeddingEngine.embedBatch(descriptions);
+    }
+    async computeVectorCosineScores(query) {
+        if (!this.embeddingEngine)
+            return new Map();
+        try {
+            await this.ensureToolEmbeddings();
+        }
+        catch {
+            return new Map();
+        }
+        if (!this.toolEmbeddings)
+            return new Map();
+        let queryEmbedding;
+        try {
+            queryEmbedding = await this.embeddingEngine.embed(query);
+        }
+        catch {
+            return new Map();
+        }
+        const results = new Map();
+        for (let i = 0; i < this.toolEmbeddings.length; i++) {
+            const toolEmb = this.toolEmbeddings[i];
+            let dot = 0;
+            for (let j = 0; j < queryEmbedding.length; j++) {
+                dot += queryEmbedding[j] * toolEmb[j];
+            }
+            if (dot > 0) {
+                results.set(i, dot);
+            }
+        }
+        return results;
+    }
+    recordToolCallFeedback(toolName, _lastQuery) {
+        if (!this.lastVectorRanking || !this.embeddingEngine)
+            return;
+        const vectorRank = this.lastVectorRanking.get(toolName);
+        if (vectorRank !== undefined && vectorRank < 5) {
+            this.vectorWeight = Math.min(0.8, this.vectorWeight + 0.02);
+            this.queryCache.clear();
+        }
+        else {
+            this.vectorWeight = Math.max(0.1, this.vectorWeight - 0.01);
+            this.queryCache.clear();
+        }
+    }
+    applyIntentBonusBand(scores, intentToolBonuses) {
+        if (intentToolBonuses.size === 0) {
+            return;
+        }
+        let maxScore = 0;
+        for (let i = 0; i < this.docCount; i++) {
+            maxScore = Math.max(maxScore, scores[i]);
+        }
+        let maxBonus = 0;
+        for (const bonus of intentToolBonuses.values()) {
+            maxBonus = Math.max(maxBonus, bonus);
+        }
+        if (maxBonus <= 0) {
+            return;
+        }
+        const bonusBand = Math.max(1, maxScore + 1);
+        const distinctBonuses = [...new Set([...intentToolBonuses.values()].filter((bonus) => bonus > 0))]
+            .sort((a, b) => a - b);
+        const bonusTierByValue = new Map();
+        for (let i = 0; i < distinctBonuses.length; i++) {
+            bonusTierByValue.set(distinctBonuses[i], i + 1);
+        }
+        for (const [toolName, bonus] of intentToolBonuses) {
+            if (bonus <= 0) {
+                continue;
+            }
+            const docIndex = this.docNameIndex.get(toolName);
+            if (docIndex === undefined) {
+                continue;
+            }
+            const tier = bonusTierByValue.get(bonus);
+            if (tier === undefined) {
+                continue;
+            }
+            scores[docIndex] += bonusBand * tier;
+        }
+    }
+    static extractParamTokens(inputSchema) {
+        const tokens = [];
+        if (!inputSchema || typeof inputSchema !== 'object')
+            return tokens;
+        const schema = inputSchema;
+        const properties = schema.properties;
+        if (!properties || typeof properties !== 'object')
+            return tokens;
+        for (const [paramName, paramDef] of Object.entries(properties)) {
+            const nameParts = paramName.replace(/([a-z])([A-Z])/g, '$1 $2').split(/[\s_-]+/);
+            for (const part of nameParts) {
+                const lower = part.toLowerCase();
+                if (lower.length > 1) {
+                    tokens.push(lower);
+                }
+            }
+            if (paramDef && typeof paramDef === 'object') {
+                const desc = paramDef.description;
+                if (typeof desc === 'string') {
+                    const STOP_WORDS = new Set([
+                        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been',
+                        'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from',
+                        'or', 'and', 'not', 'this', 'that', 'it', 'its', 'if', 'as',
+                        'will', 'can', 'may', 'must', 'should', 'would', 'could',
+                        'e', 'g', 'default', 'optional', 'required', 'when', 'set',
+                    ]);
+                    const descWords = desc.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+                    for (const w of descWords) {
+                        if (w.length > 2 && !STOP_WORDS.has(w)) {
+                            tokens.push(w);
+                        }
+                    }
+                }
+            }
         }
+        return tokens;
     }
     buildAffinityGraph() {
         const graph = new Map();

package/dist/src/server/search/TrigramIndex.d.ts

@@ -0,0 +1,7 @@
+export declare class TrigramIndex {
+    private readonly trigramSets;
+    constructor(names: string[]);
+    search(query: string, threshold?: number): Map<number, number>;
+    static extractTrigrams(text: string): ReadonlySet<string>;
+    private static jaccardSimilarity;
+}

package/dist/src/server/search/TrigramIndex.js

@@ -0,0 +1,40 @@
+export class TrigramIndex {
+    trigramSets;
+    constructor(names) {
+        this.trigramSets = names.map((name) => TrigramIndex.extractTrigrams(name));
+    }
+    search(query, threshold = 0.3) {
+        const queryTrigrams = TrigramIndex.extractTrigrams(query);
+        if (queryTrigrams.size === 0)
+            return new Map();
+        const results = new Map();
+        for (let i = 0; i < this.trigramSets.length; i++) {
+            const docTrigrams = this.trigramSets[i];
+            if (docTrigrams.size === 0)
+                continue;
+            const similarity = TrigramIndex.jaccardSimilarity(queryTrigrams, docTrigrams);
+            if (similarity >= threshold) {
+                results.set(i, similarity);
+            }
+        }
+        return results;
+    }
+    static extractTrigrams(text) {
+        const normalised = text.toLowerCase().replace(/[_\-\s]+/g, '');
+        const trigrams = new Set();
+        for (let i = 0; i <= normalised.length - 3; i++) {
+            trigrams.add(normalised.slice(i, i + 3));
+        }
+        return trigrams;
+    }
+    static jaccardSimilarity(a, b) {
+        let intersection = 0;
+        const [smaller, larger] = a.size <= b.size ? [a, b] : [b, a];
+        for (const item of smaller) {
+            if (larger.has(item))
+                intersection++;
+        }
+        const union = a.size + b.size - intersection;
+        return union === 0 ? 0 : intersection / union;
+    }
+}