@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,83 +0,0 @@
-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.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,53 +0,0 @@
-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/FeedbackTracker.d.ts

@@ -1,9 +0,0 @@
-import type { SearchConfig } from '../../types/config.js';
-export declare class FeedbackTracker {
-    private vectorWeight;
-    private lastVectorRanking;
-    constructor(searchConfig?: SearchConfig);
-    getVectorWeight(): number;
-    recordVectorRanking(ranking: Map<string, number>): void;
-    recordToolCallFeedback(toolName: string, vectorEnabled: boolean): boolean;
-}

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

@@ -1,26 +0,0 @@
-import { SEARCH_VECTOR_COSINE_WEIGHT } from '../../constants.js';
-export class FeedbackTracker {
-    vectorWeight;
-    lastVectorRanking = null;
-    constructor(searchConfig) {
-        this.vectorWeight = searchConfig?.vectorCosineWeight ?? SEARCH_VECTOR_COSINE_WEIGHT;
-    }
-    getVectorWeight() {
-        return this.vectorWeight;
-    }
-    recordVectorRanking(ranking) {
-        this.lastVectorRanking = ranking;
-    }
-    recordToolCallFeedback(toolName, vectorEnabled) {
-        if (!this.lastVectorRanking || !vectorEnabled)
-            return false;
-        const vectorRank = this.lastVectorRanking.get(toolName);
-        if (vectorRank !== undefined && vectorRank < 5) {
-            this.vectorWeight = Math.min(0.8, this.vectorWeight + 0.02);
-        }
-        else {
-            this.vectorWeight = Math.max(0.1, this.vectorWeight - 0.01);
-        }
-        return true;
-    }
-}

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

@@ -1,15 +0,0 @@
-import type { SearchIntentToolBoostRuleConfig } from '../../types/config.js';
-export type CompiledIntentToolBoostRule = {
-    pattern: RegExp;
-    boosts: ReadonlyArray<{
-        tool: string;
-        bonus: number;
-    }>;
-};
-export declare class IntentBoostImpl {
-    private readonly compiledRules;
-    constructor(intentToolBoostRules?: SearchIntentToolBoostRuleConfig[]);
-    static compileIntentToolBoostRules(config: SearchIntentToolBoostRuleConfig[]): ReadonlyArray<CompiledIntentToolBoostRule>;
-    resolveIntentToolBonuses(query: string): Map<string, number>;
-    getCompiledRules(): ReadonlyArray<CompiledIntentToolBoostRule>;
-}

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

@@ -1,57 +0,0 @@
-import { DEFAULT_SEARCH_CONFIG } from '../../config/search-defaults.js';
-export class IntentBoostImpl {
-    compiledRules;
-    constructor(intentToolBoostRules) {
-        this.compiledRules =
-            intentToolBoostRules !== undefined
-                ? IntentBoostImpl.compileIntentToolBoostRules(intentToolBoostRules)
-                : IntentBoostImpl.compileIntentToolBoostRules(DEFAULT_SEARCH_CONFIG.intentToolBoostRules);
-    }
-    static compileIntentToolBoostRules(config) {
-        const compiled = [];
-        for (const rule of config) {
-            if (!rule ||
-                typeof rule.pattern !== 'string' ||
-                !Array.isArray(rule.boosts) ||
-                rule.boosts.length === 0) {
-                continue;
-            }
-            let regex;
-            try {
-                regex = new RegExp(rule.pattern, rule.flags ?? 'i');
-            }
-            catch {
-                continue;
-            }
-            const boosts = rule.boosts
-                .filter((item) => item && typeof item.tool === 'string' && item.tool.length > 0)
-                .map((item) => ({
-                tool: item.tool,
-                bonus: Number.isFinite(item.bonus) ? item.bonus : 0,
-            }))
-                .filter((item) => item.bonus > 0);
-            if (boosts.length === 0) {
-                continue;
-            }
-            compiled.push({ pattern: regex, boosts });
-        }
-        return compiled;
-    }
-    resolveIntentToolBonuses(query) {
-        const lower = query.toLowerCase();
-        const bonuses = new Map();
-        for (const rule of this.compiledRules) {
-            if (!rule.pattern.test(lower)) {
-                continue;
-            }
-            for (const { tool, bonus } of rule.boosts) {
-                const prev = bonuses.get(tool) ?? 0;
-                bonuses.set(tool, Math.max(prev, bonus));
-            }
-        }
-        return bonuses;
-    }
-    getCompiledRules() {
-        return this.compiledRules;
-    }
-}

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

@@ -1,6 +0,0 @@
-export declare const QueryNormalizer: {
-    extractParamTokens(inputSchema: unknown): string[];
-    extractShortDescription(description: string): string;
-    containsCJK(query: string): boolean;
-    normalizeToolName(query: string): string;
-};

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

@@ -1,94 +0,0 @@
-const PARAM_DESCRIPTION_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',
-]);
-export const QueryNormalizer = {
-    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 descWords = desc
-                        .toLowerCase()
-                        .split(/[^a-z0-9]+/)
-                        .filter(Boolean);
-                    for (const w of descWords) {
-                        if (w.length > 2 && !PARAM_DESCRIPTION_STOP_WORDS.has(w)) {
-                            tokens.push(w);
-                        }
-                    }
-                }
-            }
-        }
-        return tokens;
-    },
-    extractShortDescription(description) {
-        if (!description)
-            return '';
-        const firstSentence = description.match(/^[^.!?\n]+[.!?]?/);
-        if (firstSentence) {
-            const result = firstSentence[0].trim();
-            return result.length > 120 ? result.slice(0, 117) + '...' : result;
-        }
-        return description.length > 120 ? description.slice(0, 117) + '...' : description;
-    },
-    containsCJK(query) {
-        return /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/.test(query);
-    },
-    normalizeToolName(query) {
-        return query.toLowerCase().replace(/[\s-]+/g, '_');
-    },
-};

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

@@ -1,7 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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/ToolSearchEngine.d.ts

@@ -1 +0,0 @@
-export { ToolSearchEngine, type ToolSearchResult } from './ToolSearchEngineImpl.js';

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

@@ -1 +0,0 @@
-export { ToolSearchEngine } from './ToolSearchEngineImpl.js';

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

@@ -1,51 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { SearchConfig } from '../../types/config.js';
-export interface ToolSearchResult {
-    name: string;
-    domain: string | null;
-    shortDescription: string;
-    score: number;
-    isActive: boolean;
-}
-export declare class ToolSearchEngine {
-    private readonly docs;
-    private readonly invertedIndex;
-    private readonly sortedKeys;
-    private readonly avgDocLength;
-    private readonly docCount;
-    private readonly domainOverrides?;
-    private readonly domainScoreMultipliers?;
-    private readonly toolScoreMultipliers?;
-    private readonly idfMap;
-    private readonly docNameIndex;
-    private readonly affinityGraph;
-    private readonly queryCache;
-    private readonly trigramIndex;
-    private readonly embeddingEngine;
-    private toolEmbeddings;
-    private readonly feedbackTracker;
-    private feedbackEpoch;
-    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>): Promise<ToolSearchResult[]>;
-    getDomainSummary(): Array<{
-        domain: string | null;
-        count: number;
-        tools: string[];
-    }>;
-    private scoreToken;
-    private findPrefixMatches;
-    private scorePostings;
-    private applyRRFFusion;
-    private computeTfidfCosineScores;
-    private rankByScores;
-    private rankByMap;
-    private ensureToolEmbeddings;
-    private computeVectorCosineScores;
-    recordToolCallFeedback(toolName: string, _lastQuery: string): void;
-    private applyIntentBonusBand;
-    private buildAffinityGraph;
-    private applyAffinityExpansion;
-    private applyDomainHubExpansion;
-}