@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/server/sandbox/types.d.ts

@@ -0,0 +1,27 @@
+export interface SandboxOptions {
+    timeoutMs?: number;
+    memoryLimitBytes?: number;
+    globals?: Record<string, unknown>;
+    sessionId?: string;
+}
+export interface SandboxResult {
+    ok: boolean;
+    output?: unknown;
+    error?: string;
+    timedOut: boolean;
+    durationMs: number;
+    logs: string[];
+}
+export interface BridgeCallRecord {
+    toolName: string;
+    args: Record<string, unknown>;
+    result: unknown;
+}
+export interface OrchestrationOptions extends SandboxOptions {
+    maxBridgeCalls?: number;
+    bridgeAllowlist?: string[];
+}
+export interface OrchestrationResult extends SandboxResult {
+    bridgeCallCount: number;
+    bridgeCalls: BridgeCallRecord[];
+}

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

@@ -2,6 +2,12 @@ export interface AffinityEdge {
     docIndex: number;
     weight: number;
 }
+export interface ExplicitEdge {
+    from: string;
+    to: string;
+    relation: 'requires' | 'precedes' | 'suggests';
+    weight: number;
+}
 interface DocumentInfo {
     name: string;
     domain: string | null;
@@ -9,7 +15,7 @@ interface DocumentInfo {
 export declare class AffinityGraphImpl {
     private readonly graph;
     private readonly docCount;
-    constructor(documents: DocumentInfo[]);
+    constructor(documents: DocumentInfo[], explicitEdges?: ExplicitEdge[]);
     private buildAffinityGraph;
     applyAffinityExpansion(scores: Float64Array): void;
     static applyDomainHubExpansion(scores: Float64Array, docCount: number, getDomain: (index: number) => string | null): void;

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

@@ -1,12 +1,12 @@
-import { SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_THRESHOLD } from '../../constants.js';
+import { SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_THRESHOLD, } from '../../constants.js';
 export class AffinityGraphImpl {
     graph;
     docCount;
-    constructor(documents) {
+    constructor(documents, explicitEdges) {
         this.docCount = documents.length;
-        this.graph = this.buildAffinityGraph(documents);
+        this.graph = this.buildAffinityGraph(documents, explicitEdges);
     }
-    buildAffinityGraph(documents) {
+    buildAffinityGraph(documents, explicitEdges) {
         const graph = new Map();
         const prefixGroups = new Map();
         for (let i = 0; i < documents.length; i++) {
@@ -33,6 +33,27 @@ export class AffinityGraphImpl {
                 graph.set(src, edges);
             }
         }
+        if (explicitEdges && explicitEdges.length > 0) {
+            const nameToIndex = new Map();
+            for (let i = 0; i < documents.length; i++) {
+                nameToIndex.set(documents[i].name, i);
+            }
+            for (const edge of explicitEdges) {
+                const srcIdx = nameToIndex.get(edge.from);
+                const dstIdx = nameToIndex.get(edge.to);
+                if (srcIdx === undefined || dstIdx === undefined)
+                    continue;
+                const edges = graph.get(srcIdx) ?? [];
+                const existing = edges.find((e) => e.docIndex === dstIdx);
+                if (existing) {
+                    existing.weight = Math.max(existing.weight, edge.weight);
+                }
+                else {
+                    edges.push({ docIndex: dstIdx, weight: edge.weight });
+                }
+                graph.set(srcIdx, edges);
+            }
+        }
         return graph;
     }
     applyAffinityExpansion(scores) {

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

@@ -10,12 +10,15 @@ interface CjkQueryAliasRule {
 export declare class BM25ScorerImpl {
     private readonly queryCategoryProfiles;
     private readonly cjkQueryAliases;
+    private readonly synonymExpander;
     constructor(searchConfig?: Pick<SearchConfig, 'queryCategoryProfiles' | 'cjkQueryAliases'>);
     static compileQueryCategoryProfiles(config: SearchQueryCategoryProfileConfig[]): ReadonlyArray<QueryCategoryProfile>;
     static compileCjkQueryAliasRules(config: SearchCjkQueryAliasConfig[]): ReadonlyArray<CjkQueryAliasRule>;
     detectQueryCategoryBoosts(query: string): Map<string, number>;
     expandCjkAliasTokens(text: string): string[];
-    tokenise(text: string): string[];
+    tokenise(text: string, options?: {
+        expandSynonyms?: boolean;
+    }): string[];
     getK1(): number;
     getB(): number;
 }

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

@@ -1,9 +1,11 @@
 import { DEFAULT_SEARCH_CONFIG } from '../../config/search-defaults.js';
+import { SynonymExpander } from './SynonymExpander.js';
 const K1 = 1.5;
 const B = 0.3;
 export class BM25ScorerImpl {
     queryCategoryProfiles;
     cjkQueryAliases;
+    synonymExpander;
     constructor(searchConfig) {
         this.queryCategoryProfiles =
             searchConfig?.queryCategoryProfiles !== undefined
@@ -13,6 +15,7 @@ export class BM25ScorerImpl {
             searchConfig?.cjkQueryAliases !== undefined
                 ? BM25ScorerImpl.compileCjkQueryAliasRules(searchConfig.cjkQueryAliases)
                 : BM25ScorerImpl.compileCjkQueryAliasRules(DEFAULT_SEARCH_CONFIG.cjkQueryAliases);
+        this.synonymExpander = new SynonymExpander();
     }
     static compileQueryCategoryProfiles(config) {
         return config.flatMap((profile) => {
@@ -79,7 +82,7 @@ export class BM25ScorerImpl {
         }
         return [...result];
     }
-    tokenise(text) {
+    tokenise(text, options) {
         let normalised = text.replace(/[_-]/g, ' ');
         normalised = normalised.replace(/([\u4e00-\u9fff])/g, ' $1 ');
         const words = normalised.split(/[^a-zA-Z0-9\u4e00-\u9fff]+/).filter(Boolean);
@@ -98,6 +101,9 @@ export class BM25ScorerImpl {
             }
         }
         result.push(...this.expandCjkAliasTokens(text));
+        if (options?.expandSynonyms) {
+            result.push(...this.synonymExpander.expandQuery(result));
+        }
         return result;
     }
     getK1() {

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

@@ -0,0 +1,11 @@
+export declare class EmbeddingEngine {
+    private worker;
+    private ready;
+    private nextId;
+    private readonly pending;
+    isReady(): boolean;
+    embed(text: string): Promise<Float32Array>;
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    terminate(): Promise<void>;
+    private ensureWorker;
+}

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;