@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/src/server/registry/index.js

@@ -0,0 +1,143 @@
+import { discoverDomainManifests } from '../registry/discovery.js';
+import { logger } from '../../utils/logger.js';
+let _manifests = null;
+let _registrations = null;
+let _initPromise = null;
+let _domainsView = null;
+let _toolNamesView = null;
+async function init() {
+    if (_manifests !== null)
+        return;
+    if (_initPromise) {
+        await _initPromise;
+        return;
+    }
+    _initPromise = (async () => {
+        const discovered = await discoverDomainManifests();
+        _manifests = discovered;
+        const uniqueByToolName = new Map();
+        for (const m of discovered) {
+            for (const r of m.registrations) {
+                const existing = uniqueByToolName.get(r.tool.name);
+                if (existing) {
+                    logger.warn(`[registry] Duplicate tool name "${r.tool.name}": domain "${r.domain}" conflicts with "${existing.domain}" — keeping first`);
+                }
+                else {
+                    uniqueByToolName.set(r.tool.name, r);
+                }
+            }
+        }
+        _registrations = [...uniqueByToolName.values()];
+        _domainsView = new Set(_manifests.map(m => m.domain));
+        _toolNamesView = new Set(_registrations.map(r => r.tool.name));
+    })();
+    await _initPromise;
+}
+export async function initRegistry() {
+    await init();
+}
+function getManifests() {
+    if (!_manifests)
+        throw new Error('[registry] Not initialised - call initRegistry() first.');
+    return _manifests;
+}
+function getRegistrations() {
+    if (!_registrations)
+        throw new Error('[registry] Not initialised - call initRegistry() first.');
+    return _registrations;
+}
+export function getAllManifests() {
+    return getManifests();
+}
+export function getAllRegistrations() {
+    return getRegistrations();
+}
+export function getAllDomains() {
+    if (!_domainsView)
+        throw new Error('[registry] Not initialised - call initRegistry() first.');
+    return _domainsView;
+}
+export function getAllToolNames() {
+    if (!_toolNamesView)
+        throw new Error('[registry] Not initialised - call initRegistry() first.');
+    return _toolNamesView;
+}
+export function buildToolGroups() {
+    const groups = {};
+    for (const r of getRegistrations()) {
+        (groups[r.domain] ??= []).push(r.tool);
+    }
+    return groups;
+}
+export function buildToolDomainMap() {
+    const map = new Map();
+    for (const r of getRegistrations()) {
+        if (!map.has(r.tool.name))
+            map.set(r.tool.name, r.domain);
+    }
+    return map;
+}
+export function buildAllTools() {
+    return getRegistrations().map(r => r.tool);
+}
+export function buildHandlerMapFromRegistry(deps, selectedToolNames) {
+    const regs = selectedToolNames
+        ? getRegistrations().filter(r => selectedToolNames.has(r.tool.name))
+        : [...getRegistrations()];
+    return Object.fromEntries(regs.map(r => [r.tool.name, r.bind(deps)]));
+}
+export function buildProfileDomains() {
+    const profiles = {
+        search: new Set(),
+        workflow: new Set(),
+        full: new Set(),
+    };
+    for (const m of getManifests()) {
+        for (const p of m.profiles) {
+            profiles[p]?.add(m.domain);
+        }
+    }
+    const result = {};
+    for (const [p, domains] of Object.entries(profiles)) {
+        result[p] = [...domains];
+    }
+    const isSubset = (a, b) => {
+        const bSet = new Set(b);
+        return a.every(x => bSet.has(x));
+    };
+    if (!isSubset(result['search'], result['workflow'])) {
+        logger.warn('[registry] Profile hierarchy: search not subset of workflow');
+    }
+    if (!isSubset(result['workflow'], result['full'])) {
+        logger.warn('[registry] Profile hierarchy: workflow not subset of full');
+    }
+    return result;
+}
+export const ALL_DOMAINS = new Proxy(new Set(), {
+    get(_t, p) {
+        const real = getAllDomains();
+        const v = real[p];
+        return typeof v === 'function' ? v.bind(real) : v;
+    },
+});
+export const ALL_TOOL_NAMES = new Proxy(new Set(), {
+    get(_t, p) {
+        const real = getAllToolNames();
+        const v = real[p];
+        return typeof v === 'function' ? v.bind(real) : v;
+    },
+});
+export const ALL_MANIFESTS = new Proxy([], {
+    get(_t, p) {
+        const real = getAllManifests();
+        const v = real[p];
+        return typeof v === 'function' ? v.bind(real) : v;
+    },
+});
+export const ALL_REGISTRATIONS = new Proxy([], {
+    get(_t, p) {
+        const real = getAllRegistrations();
+        const v = real[p];
+        return typeof v === 'function' ? v.bind(real) : v;
+    },
+});

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

@@ -0,0 +1,18 @@
+export interface AffinityEdge {
+    docIndex: number;
+    weight: number;
+}
+interface DocumentInfo {
+    name: string;
+    domain: string | null;
+}
+export declare class AffinityGraphImpl {
+    private readonly graph;
+    private readonly docCount;
+    constructor(documents: DocumentInfo[]);
+    private buildAffinityGraph;
+    applyAffinityExpansion(scores: Float64Array): void;
+    static applyDomainHubExpansion(scores: Float64Array, docCount: number, getDomain: (index: number) => string | null): void;
+    getGraph(): ReadonlyMap<number, ReadonlyArray<AffinityEdge>>;
+}
+export {};

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

@@ -0,0 +1,98 @@
+import { SEARCH_AFFINITY_BOOST_FACTOR, SEARCH_AFFINITY_TOP_N, SEARCH_DOMAIN_HUB_THRESHOLD } from '../../constants.js';
+export class AffinityGraphImpl {
+    graph;
+    docCount;
+    constructor(documents) {
+        this.docCount = documents.length;
+        this.graph = this.buildAffinityGraph(documents);
+    }
+    buildAffinityGraph(documents) {
+        const graph = new Map();
+        const prefixGroups = new Map();
+        for (let i = 0; i < documents.length; i++) {
+            const name = documents[i].name;
+            const underscoreIdx = name.indexOf('_');
+            if (underscoreIdx <= 0)
+                continue;
+            const prefix = name.slice(0, underscoreIdx);
+            const group = prefixGroups.get(prefix) ?? [];
+            group.push(i);
+            prefixGroups.set(prefix, group);
+        }
+        for (const [, members] of prefixGroups) {
+            if (members.length < 2 || members.length > 15)
+                continue;
+            const affinityWeight = 0.3 / Math.sqrt(members.length);
+            for (const src of members) {
+                const edges = graph.get(src) ?? [];
+                for (const dst of members) {
+                    if (dst !== src) {
+                        edges.push({ docIndex: dst, weight: affinityWeight });
+                    }
+                }
+                graph.set(src, edges);
+            }
+        }
+        return graph;
+    }
+    applyAffinityExpansion(scores) {
+        if (this.graph.size === 0)
+            return;
+        const topN = SEARCH_AFFINITY_TOP_N;
+        const scored = [];
+        for (let i = 0; i < this.docCount; i++) {
+            if (scores[i] > 0) {
+                scored.push({ idx: i, score: scores[i] });
+            }
+        }
+        scored.sort((a, b) => b.score - a.score);
+        const boostFactor = SEARCH_AFFINITY_BOOST_FACTOR;
+        const limit = Math.min(topN, scored.length);
+        for (let rank = 0; rank < limit; rank++) {
+            const { idx, score } = scored[rank];
+            const neighbors = this.graph.get(idx);
+            if (!neighbors)
+                continue;
+            const rankDecay = 1 / (1 + rank);
+            for (const { docIndex, weight } of neighbors) {
+                if (scores[docIndex] > 0) {
+                    scores[docIndex] += score * weight * rankDecay * boostFactor;
+                }
+            }
+        }
+    }
+    static applyDomainHubExpansion(scores, docCount, getDomain) {
+        const threshold = SEARCH_DOMAIN_HUB_THRESHOLD;
+        if (threshold <= 0)
+            return;
+        const scored = [];
+        for (let i = 0; i < docCount; i++) {
+            if (scores[i] > 0) {
+                scored.push({ idx: i, score: scores[i] });
+            }
+        }
+        if (scored.length < threshold)
+            return;
+        scored.sort((a, b) => b.score - a.score);
+        const top10 = scored.slice(0, 10);
+        const domainCounts = new Map();
+        for (const { idx } of top10) {
+            const domain = getDomain(idx);
+            if (domain) {
+                domainCounts.set(domain, (domainCounts.get(domain) ?? 0) + 1);
+            }
+        }
+        for (const [domain, count] of domainCounts) {
+            if (count >= threshold) {
+                for (let i = 0; i < docCount; i++) {
+                    if (scores[i] > 0 && getDomain(i) === domain) {
+                        scores[i] *= 1.08;
+                    }
+                }
+            }
+        }
+    }
+    getGraph() {
+        return this.graph;
+    }
+}

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

@@ -0,0 +1,12 @@
+export interface QueryCategoryProfile {
+    pattern: RegExp;
+    domainBoosts: ReadonlyMap<string, number>;
+}
+export declare const QUERY_CATEGORY_PROFILES: ReadonlyArray<QueryCategoryProfile>;
+export declare class BM25ScorerImpl {
+    detectQueryCategoryBoosts(query: string): Map<string, number>;
+    expandCjkAliasTokens(text: string): string[];
+    tokenise(text: string): string[];
+    getK1(): number;
+    getB(): number;
+}

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

@@ -0,0 +1,112 @@
+const K1 = 1.5;
+const B = 0.3;
+export const QUERY_CATEGORY_PROFILES = [
+    {
+        pattern: /(?:security|vuln|xss|injection|csrf|exploit|attack|prototype\s*pollution|漏洞|安全|注入|攻击)/i,
+        domainBoosts: new Map([['security', 1.6], ['analysis', 1.2]]),
+    },
+    {
+        pattern: /(?:debug|breakpoint|pause|step\s*over|step\s*into|stack\s*trace|断点|调试|单步)/i,
+        domainBoosts: new Map([['debugger', 1.6], ['runtime', 1.2]]),
+    },
+    {
+        pattern: /(?:network|request|response|header|cookie|fetch|xhr|网络|请求|抓包)/i,
+        domainBoosts: new Map([['network', 1.6], ['browser', 1.1]]),
+    },
+    {
+        pattern: /(?:transform|deobfuscate|beautify|minify|decode|encode|解密|混淆|反混淆|转换)/i,
+        domainBoosts: new Map([['transform', 1.6], ['analysis', 1.2]]),
+    },
+    {
+        pattern: /(?:memory|heap|dump|scan|inject|内存|堆|扫描)/i,
+        domainBoosts: new Map([['memory', 1.6], ['native', 1.2]]),
+    },
+    {
+        pattern: /(?:wasm|webassembly)/i,
+        domainBoosts: new Map([['wasm', 1.6]]),
+    },
+    {
+        pattern: /(?:browser|page|tab|navigate|click|screenshot|浏览器|页面|标签)/i,
+        domainBoosts: new Map([['browser', 1.4]]),
+    },
+    {
+        pattern: /(?:captcha|人机验证|验证码|图形验证)/i,
+        domainBoosts: new Map([['captcha', 1.6], ['browser', 1.1]]),
+    },
+];
+const CJK_QUERY_ALIASES = [
+    { pattern: /工作流|流程编排|流程自动化|编排/, tokens: ['workflow', 'flow', 'orchestration'] },
+    { pattern: /抓包|抓取|采集|捕获/, tokens: ['capture', 'sniff', 'collect'] },
+    { pattern: /接口|端点/, tokens: ['api', 'endpoint', 'request'] },
+    { pattern: /探测|探针|扫描/, tokens: ['probe', 'scan'] },
+    { pattern: /账号|账户|用户/, tokens: ['account', 'user'] },
+    { pattern: /注册|开户|报名/, tokens: ['register', 'signup'] },
+    { pattern: /验证|校验|激活/, tokens: ['verify', 'verification', 'activation'] },
+    { pattern: /验证码|图形验证码|人机验证/, tokens: ['captcha', 'verify', 'verification'] },
+    { pattern: /邮箱|邮件/, tokens: ['email', 'mail'] },
+    { pattern: /keygen|密钥|注册码|激活码/, tokens: ['keygen', 'key', 'activation'] },
+    { pattern: /轮询|监听/, tokens: ['poll', 'watch'] },
+    { pattern: /批量|并发/, tokens: ['batch', 'parallel'] },
+    { pattern: /令牌|凭证|鉴权|认证/, tokens: ['token', 'auth', 'credential'] },
+    { pattern: /提取|抽取|解析/, tokens: ['extract', 'parse'] },
+    { pattern: /多标签页|多标签|标签页/, tokens: ['tab', 'multi'] },
+    { pattern: /脚本库|脚本仓库/, tokens: ['script', 'library'] },
+    { pattern: /脚本/, tokens: ['script'] },
+    { pattern: /执行|运行/, tokens: ['run', 'execute'] },
+    { pattern: /导出/, tokens: ['export'] },
+    { pattern: /回放|重放/, tokens: ['replay'] },
+    { pattern: /请求/, tokens: ['request'] },
+];
+export class BM25ScorerImpl {
+    detectQueryCategoryBoosts(query) {
+        const boosts = new Map();
+        for (const profile of QUERY_CATEGORY_PROFILES) {
+            if (!profile.pattern.test(query))
+                continue;
+            for (const [domain, weight] of profile.domainBoosts) {
+                const prev = boosts.get(domain) ?? 1;
+                boosts.set(domain, Math.max(prev, weight));
+            }
+        }
+        return boosts;
+    }
+    expandCjkAliasTokens(text) {
+        const lower = text.toLowerCase();
+        const result = new Set();
+        for (const alias of CJK_QUERY_ALIASES) {
+            if (alias.pattern.test(lower)) {
+                for (const token of alias.tokens) {
+                    result.add(token);
+                }
+            }
+        }
+        return [...result];
+    }
+    tokenise(text) {
+        let normalised = text.replace(/[_-]/g, ' ');
+        normalised = normalised.replace(/([\u4e00-\u9fff])/g, ' $1 ');
+        const words = normalised.split(/[^a-zA-Z0-9\u4e00-\u9fff]+/).filter(Boolean);
+        const result = [];
+        for (const word of words) {
+            const lower = word.toLowerCase();
+            const camelParts = word.replace(/([a-z])([A-Z])/g, '$1 $2').split(/\s+/);
+            if (camelParts.length > 1) {
+                for (const part of camelParts) {
+                    result.push(part.toLowerCase());
+                }
+                result.push(lower);
+            }
+            else {
+                result.push(lower);
+            }
+        }
+        result.push(...this.expandCjkAliasTokens(text));
+        return result;
+    }
+    getK1() {
+        return K1;
+    }
+    getB() {
+        return B;
+    }
+}

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

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

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

@@ -0,0 +1,101 @@
+import { SEARCH_INTENT_TOOL_BOOST_RULES_OVERRIDE, } from '../../constants.js';
+const DEFAULT_INTENT_TOOL_BOOST_RULES = [
+    {
+        pattern: /(?:端到端闭环|全链路闭环|一键闭环|api\s*capture\s*session|抓取接口|抓包流程)/i,
+        boosts: [
+            { tool: 'web_api_capture_session', bonus: 26 },
+            { tool: 'api_probe_batch', bonus: 18 },
+            { tool: 'network_extract_auth', bonus: 10 },
+            { tool: 'network_export_har', bonus: 8 },
+        ],
+    },
+    {
+        pattern: /(?:register|signup|sign\s*up|账号注册|账户注册|邮箱验证|验证账号|激活账号|注册验证|验证码|邮箱激活|激活链接|mail\s*verify|email\s*verify|account\s*pending|keygen)/i,
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 40 },
+            { tool: 'list_extension_workflows', bonus: 24 },
+            { tool: 'register_account_flow', bonus: 20 },
+            { tool: 'batch_register', bonus: 18 },
+            { tool: 'tab_workflow', bonus: 8 },
+        ],
+    },
+    {
+        pattern: /(?:script\s*library|script\s*preset|run\s*script|脚本库执行|脚本库|执行脚本)/i,
+        boosts: [
+            { tool: 'page_script_run', bonus: 22 },
+            { tool: 'page_script_register', bonus: 16 },
+            { tool: 'run_extension_workflow', bonus: 10 },
+        ],
+    },
+    {
+        pattern: /(?:bundle|webpack|js\s*bundle|脚本包|静态包|源码包)/i,
+        boosts: [
+            { tool: 'js_bundle_search', bonus: 20 },
+            { tool: 'source_map_extract', bonus: 10 },
+            { tool: 'webpack_enumerate', bonus: 8 },
+        ],
+    },
+    {
+        pattern: /(?:workflow|orchestration|工作流|流程编排|流程自动化)/i,
+        boosts: [
+            { tool: 'run_extension_workflow', bonus: 26 },
+            { tool: 'list_extension_workflows', bonus: 16 },
+            { tool: 'web_api_capture_session', bonus: 8 },
+        ],
+    },
+];
+export class IntentBoostImpl {
+    compiledRules;
+    constructor() {
+        this.compiledRules =
+            IntentBoostImpl.compileIntentToolBoostRules(SEARCH_INTENT_TOOL_BOOST_RULES_OVERRIDE) ??
+                DEFAULT_INTENT_TOOL_BOOST_RULES;
+    }
+    static compileIntentToolBoostRules(config) {
+        if (!config || !Array.isArray(config)) {
+            return null;
+        }
+        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.length > 0 ? compiled : null;
+    }
+    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/ToolSearchEngine.d.ts

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

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

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

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

@@ -0,0 +1,38 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.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 bm25Scorer;
+    private readonly intentBoost;
+    constructor(tools?: Tool[], domainOverrides?: ReadonlyMap<string, string>, domainScoreMultipliers?: ReadonlyMap<string, number>, toolScoreMultipliers?: ReadonlyMap<string, number>);
+    search(query: string, topK?: number, activeToolNames?: ReadonlySet<string>): ToolSearchResult[];
+    getDomainSummary(): Array<{
+        domain: string | null;
+        count: number;
+        tools: string[];
+    }>;
+    private scoreToken;
+    private findPrefixMatches;
+    private scorePostings;
+    private applyTfidfCosineBoost;
+    private buildAffinityGraph;
+    private applyAffinityExpansion;
+    private applyDomainHubExpansion;
+}