@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/registry/fixtures/duplicate-domain/manifest.js

@@ -0,0 +1,20 @@
+const tool = {
+    name: 'alpha_other_tool',
+    description: 'alpha duplicate domain',
+    inputSchema: { type: 'object', properties: {} },
+};
+export default {
+    kind: 'domain-manifest',
+    version: 1,
+    domain: 'alpha',
+    depKey: 'alphaOtherDep',
+    profiles: ['full'],
+    registrations: [
+        {
+            tool,
+            domain: 'alpha',
+            bind: () => async () => ({ ok: true }),
+        },
+    ],
+    ensure: () => ({}),
+};

package/dist/tests/server/registry/fixtures/invalid/manifest.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    kind: string;
+};
+export default _default;

package/dist/tests/server/registry/fixtures/invalid/manifest.js

@@ -0,0 +1,3 @@
+export default {
+    kind: 'not-a-domain-manifest',
+};

package/dist/tests/server/registry/fixtures/throw-on-import/manifest.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error('fixture import failed');

package/dist/tests/server/registry/fixtures/valid-alt/manifest.d.ts

@@ -0,0 +1,22 @@
+export declare const domainManifest: {
+    kind: string;
+    version: number;
+    domain: string;
+    depKey: string;
+    profiles: string[];
+    registrations: {
+        tool: {
+            name: string;
+            description: string;
+            inputSchema: {
+                type: string;
+                properties: {};
+            };
+        };
+        domain: string;
+        bind: () => () => Promise<{
+            ok: boolean;
+        }>;
+    }[];
+    ensure: () => {};
+};

package/dist/tests/server/registry/fixtures/valid-alt/manifest.js

@@ -0,0 +1,20 @@
+const tool = {
+    name: 'gamma_tool',
+    description: 'gamma tool',
+    inputSchema: { type: 'object', properties: {} },
+};
+export const domainManifest = {
+    kind: 'domain-manifest',
+    version: 1,
+    domain: 'gamma',
+    depKey: 'gammaDep',
+    profiles: ['full'],
+    registrations: [
+        {
+            tool,
+            domain: 'gamma',
+            bind: () => async () => ({ ok: true }),
+        },
+    ],
+    ensure: () => ({}),
+};

package/dist/tests/server/registry/fixtures/valid-default/manifest.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    kind: string;
+    version: number;
+    domain: string;
+    depKey: string;
+    profiles: string[];
+    registrations: {
+        tool: {
+            name: string;
+            description: string;
+            inputSchema: {
+                type: string;
+                properties: {};
+            };
+        };
+        domain: string;
+        bind: () => () => Promise<{
+            ok: boolean;
+        }>;
+    }[];
+    ensure: () => {};
+};
+export default _default;

package/dist/tests/server/registry/fixtures/valid-default/manifest.js

@@ -0,0 +1,20 @@
+const tool = {
+    name: 'alpha_tool',
+    description: 'alpha tool',
+    inputSchema: { type: 'object', properties: {} },
+};
+export default {
+    kind: 'domain-manifest',
+    version: 1,
+    domain: 'alpha',
+    depKey: 'alphaDep',
+    profiles: ['search', 'workflow', 'full'],
+    registrations: [
+        {
+            tool,
+            domain: 'alpha',
+            bind: () => async () => ({ ok: true }),
+        },
+    ],
+    ensure: () => ({}),
+};

package/dist/tests/server/registry/fixtures/valid-named/manifest.d.ts

@@ -0,0 +1,22 @@
+export declare const manifest: {
+    kind: string;
+    version: number;
+    domain: string;
+    depKey: string;
+    profiles: string[];
+    registrations: {
+        tool: {
+            name: string;
+            description: string;
+            inputSchema: {
+                type: string;
+                properties: {};
+            };
+        };
+        domain: string;
+        bind: () => () => Promise<{
+            ok: boolean;
+        }>;
+    }[];
+    ensure: () => {};
+};

package/dist/tests/server/registry/fixtures/valid-named/manifest.js

@@ -0,0 +1,20 @@
+const tool = {
+    name: 'beta_tool',
+    description: 'beta tool',
+    inputSchema: { type: 'object', properties: {} },
+};
+export const manifest = {
+    kind: 'domain-manifest',
+    version: 1,
+    domain: 'beta',
+    depKey: 'betaDep',
+    profiles: ['workflow', 'full'],
+    registrations: [
+        {
+            tool,
+            domain: 'beta',
+            bind: () => async () => ({ ok: true }),
+        },
+    ],
+    ensure: () => ({}),
+};

package/dist/tests/server/registry/index.test.d.ts

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

package/dist/tests/server/registry/index.test.js

@@ -0,0 +1,109 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const state = vi.hoisted(() => ({
+    discoverDomainManifests: vi.fn(),
+    logger: {
+        warn: vi.fn(),
+        info: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+vi.mock('@server/registry/discovery', () => ({
+    discoverDomainManifests: state.discoverDomainManifests,
+}));
+vi.mock('@utils/logger', () => ({
+    logger: state.logger,
+}));
+function makeRegistration(name, domain) {
+    const handler = vi.fn(async () => `${name}:ok`);
+    const bind = vi.fn(() => handler);
+    return {
+        tool: {
+            name,
+            description: `${name} description`,
+            inputSchema: { type: 'object', properties: {} },
+        },
+        domain,
+        bind,
+    };
+}
+function makeManifest(domain, depKey, profiles, registrations) {
+    return {
+        kind: 'domain-manifest',
+        version: 1,
+        domain,
+        depKey,
+        profiles,
+        registrations,
+        ensure: vi.fn(() => ({ domain })),
+    };
+}
+describe('registry/index', () => {
+    beforeEach(() => {
+        vi.resetModules();
+        vi.clearAllMocks();
+    });
+    it('throws from getters and proxies before initialization', async () => {
+        const registry = await import('../../../src/server/registry/index.js');
+        expect(() => registry.getAllDomains()).toThrow('Not initialised');
+        expect(() => registry.getAllRegistrations()).toThrow('Not initialised');
+        expect(() => registry.buildAllTools()).toThrow('Not initialised');
+        expect(() => registry.ALL_DOMAINS.size).toThrow('Not initialised');
+        expect(() => registry.ALL_MANIFESTS.length).toThrow('Not initialised');
+    });
+    it('initializes once, deduplicates tool names, and exposes proxy views', async () => {
+        const alphaTool = makeRegistration('shared_tool', 'alpha');
+        const betaTool = makeRegistration('shared_tool', 'beta');
+        const gammaTool = makeRegistration('gamma_tool', 'gamma');
+        state.discoverDomainManifests.mockResolvedValue([
+            makeManifest('alpha', 'alphaDep', ['search', 'workflow', 'full'], [alphaTool]),
+            makeManifest('beta', 'betaDep', ['workflow', 'full'], [betaTool]),
+            makeManifest('gamma', 'gammaDep', ['full'], [gammaTool]),
+        ]);
+        const registry = await import('../../../src/server/registry/index.js');
+        await Promise.all([registry.initRegistry(), registry.initRegistry()]);
+        expect(state.discoverDomainManifests).toHaveBeenCalledTimes(1);
+        expect(state.logger.warn).toHaveBeenCalledWith(expect.stringContaining('Duplicate tool name "shared_tool"'));
+        expect([...registry.getAllDomains()]).toEqual(['alpha', 'beta', 'gamma']);
+        expect([...registry.ALL_DOMAINS]).toEqual(['alpha', 'beta', 'gamma']);
+        expect(registry.ALL_TOOL_NAMES.has('shared_tool')).toBe(true);
+        expect(registry.ALL_MANIFESTS.length).toBe(3);
+        expect(registry.ALL_REGISTRATIONS.length).toBe(2);
+        expect(registry.buildAllTools().map((item) => item.name)).toEqual([
+            'shared_tool',
+            'gamma_tool',
+        ]);
+    });
+    it('builds handler maps and filters by selected tool names', async () => {
+        const alphaTool = makeRegistration('alpha_tool', 'alpha');
+        const betaTool = makeRegistration('beta_tool', 'beta');
+        state.discoverDomainManifests.mockResolvedValue([
+            makeManifest('alpha', 'alphaDep', ['search', 'workflow', 'full'], [alphaTool]),
+            makeManifest('beta', 'betaDep', ['workflow', 'full'], [betaTool]),
+        ]);
+        const registry = await import('../../../src/server/registry/index.js');
+        await registry.initRegistry();
+        const handlers = registry.buildHandlerMapFromRegistry({ dep: true }, new Set(['beta_tool']));
+        expect(Object.keys(handlers)).toEqual(['beta_tool']);
+        expect(betaTool.bind).toHaveBeenCalledTimes(1);
+        expect(alphaTool.bind).not.toHaveBeenCalled();
+        await expect(handlers.beta_tool({ test: true })).resolves.toBe('beta_tool:ok');
+    });
+    it('warns when profile hierarchies are not proper subsets', async () => {
+        state.discoverDomainManifests.mockResolvedValue([
+            makeManifest('search-only', 'searchDep', ['search'], [makeRegistration('search_tool', 'search-only')]),
+            makeManifest('workflow-only', 'workflowDep', ['workflow'], [makeRegistration('workflow_tool', 'workflow-only')]),
+            makeManifest('full-only', 'fullDep', ['full'], [makeRegistration('full_tool', 'full-only')]),
+        ]);
+        const registry = await import('../../../src/server/registry/index.js');
+        await registry.initRegistry();
+        const profiles = registry.buildProfileDomains();
+        expect(profiles).toEqual({
+            search: ['search-only'],
+            workflow: ['workflow-only'],
+            full: ['full-only'],
+        });
+        expect(state.logger.warn).toHaveBeenCalledWith('[registry] Profile hierarchy: search not subset of workflow');
+        expect(state.logger.warn).toHaveBeenCalledWith('[registry] Profile hierarchy: workflow not subset of full');
+    });
+});

package/dist/tests/server/search/AffinityGraph.test.d.ts

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

package/dist/tests/server/search/AffinityGraph.test.js

@@ -0,0 +1,45 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/constants', () => ({
+    SEARCH_AFFINITY_BOOST_FACTOR: 0.5,
+    SEARCH_AFFINITY_TOP_N: 2,
+    SEARCH_DOMAIN_HUB_THRESHOLD: 2,
+}));
+import { AffinityGraphImpl } from '../../../src/server/search/AffinityGraph.js';
+describe('search/AffinityGraph', () => {
+    beforeEach(() => {
+    });
+    it('builds edges only for prefix groups between 2 and 15 members', () => {
+        const graph = new AffinityGraphImpl([
+            { name: 'breakpoint_set', domain: 'debugger' },
+            { name: 'breakpoint_remove', domain: 'debugger' },
+            { name: 'lonely', domain: 'browser' },
+            ...Array.from({ length: 16 }, (_, index) => ({
+                name: `huge_${index}`,
+                domain: 'huge',
+            })),
+        ]);
+        expect(graph.getGraph().get(0)).toEqual([{ docIndex: 1, weight: expect.any(Number) }]);
+        expect(graph.getGraph().get(1)).toEqual([{ docIndex: 0, weight: expect.any(Number) }]);
+        expect(graph.getGraph().has(2)).toBe(false);
+    });
+    it('expands only already-relevant affinity neighbors', () => {
+        const graph = new AffinityGraphImpl([
+            { name: 'breakpoint_set', domain: 'debugger' },
+            { name: 'breakpoint_remove', domain: 'debugger' },
+            { name: 'page_navigate', domain: 'browser' },
+        ]);
+        const scores = new Float64Array([10, 1, 0]);
+        graph.applyAffinityExpansion(scores);
+        expect(scores[1]).toBeGreaterThan(1);
+        expect(scores[2]).toBe(0);
+    });
+    it('applies domain hub expansion only when a domain reaches the threshold', () => {
+        const scores = new Float64Array([3, 2, 1, 4]);
+        const domains = ['debugger', 'debugger', 'browser', 'browser'];
+        AffinityGraphImpl.applyDomainHubExpansion(scores, scores.length, (index) => domains[index] ?? null);
+        expect(scores[0]).toBeCloseTo(3 * 1.08);
+        expect(scores[1]).toBeCloseTo(2 * 1.08);
+        expect(scores[2]).toBeCloseTo(1 * 1.08);
+        expect(scores[3]).toBeCloseTo(4 * 1.08);
+    });
+});

package/dist/tests/server/search/BM25Scorer.test.d.ts

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

package/dist/tests/server/search/BM25Scorer.test.js

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { BM25ScorerImpl } from '../../../src/server/search/BM25Scorer.js';
+describe('search/BM25Scorer', () => {
+    const scorer = new BM25ScorerImpl();
+    beforeEach(() => {
+    });
+    it('uses default query category profiles and boosts matched domains', () => {
+        expect(scorer.detectQueryCategoryBoosts('debug 断点 request')).toEqual(new Map([
+            ['debugger', 1.6],
+            ['runtime', 1.2],
+            ['network', 1.6],
+            ['browser', 1.1],
+        ]));
+    });
+    it('expands Chinese aliases for search intent', () => {
+        expect(scorer.expandCjkAliasTokens('账号注册验证码')).toEqual(expect.arrayContaining(['account', 'register', 'signup', 'captcha', 'verify', 'verification']));
+        expect(scorer.expandCjkAliasTokens('plain english')).toEqual([]);
+    });
+    it('tokenises separators, camelCase, and CJK text', () => {
+        expect(scorer.tokenise('page_navigate userToken')).toEqual(expect.arrayContaining(['page', 'navigate', 'user', 'token', 'usertoken']));
+        expect(scorer.tokenise('抓取接口')).toEqual(expect.arrayContaining(['抓', '取', '接', '口', 'capture', 'api']));
+    });
+    it('returns the BM25 tuning constants', () => {
+        expect(scorer.getK1()).toBe(1.5);
+        expect(scorer.getB()).toBe(0.3);
+    });
+    it('compiles and applies custom search config rules', () => {
+        const customScorer = new BM25ScorerImpl({
+            queryCategoryProfiles: [
+                {
+                    pattern: '自定义查询',
+                    flags: 'i',
+                    domainBoosts: [{ domain: 'workflow', weight: 2.4 }],
+                },
+            ],
+            cjkQueryAliases: [
+                {
+                    pattern: '特征词',
+                    tokens: ['feature-flag'],
+                },
+            ],
+        });
+        expect(customScorer.detectQueryCategoryBoosts('自定义查询')).toEqual(new Map([['workflow', 2.4]]));
+        expect(customScorer.expandCjkAliasTokens('特征词')).toEqual(['feature-flag']);
+    });
+    it('ignores invalid custom search config rules', () => {
+        const customScorer = new BM25ScorerImpl({
+            queryCategoryProfiles: [
+                {
+                    pattern: '[invalid',
+                    domainBoosts: [{ domain: 'workflow', weight: 2.4 }],
+                },
+            ],
+            cjkQueryAliases: [
+                {
+                    pattern: '[invalid',
+                    tokens: ['feature-flag'],
+                },
+            ],
+        });
+        expect(customScorer.detectQueryCategoryBoosts('自定义查询')).toEqual(new Map());
+        expect(customScorer.expandCjkAliasTokens('特征词')).toEqual([]);
+    });
+});

package/dist/tests/server/search/IntentBoost.test.d.ts

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

package/dist/tests/server/search/IntentBoost.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { IntentBoostImpl } from '../../../src/server/search/IntentBoost.js';
+describe('search/IntentBoost', () => {
+    it('uses the built-in default rules when no config is provided', () => {
+        const boost = new IntentBoostImpl();
+        expect(boost.resolveIntentToolBonuses('账号注册验证码').get('run_extension_workflow')).toBe(40);
+        expect(boost.resolveIntentToolBonuses('抓取接口').get('web_api_capture_session')).toBe(26);
+    });
+    it('compiles only valid custom rules', () => {
+        const compiled = IntentBoostImpl.compileIntentToolBoostRules([
+            {
+                pattern: '[invalid',
+                boosts: [{ tool: 'broken', bonus: 10 }],
+            },
+            {
+                pattern: 'hello',
+                boosts: [{ tool: '', bonus: 10 }],
+            },
+            {
+                pattern: 'hello',
+                boosts: [{ tool: 'custom_tool', bonus: 11 }],
+            },
+        ]);
+        expect(compiled).toEqual([
+            {
+                pattern: /hello/i,
+                boosts: [{ tool: 'custom_tool', bonus: 11 }],
+            },
+        ]);
+    });
+    it('takes the maximum bonus when multiple custom rules target the same tool', () => {
+        const boost = new IntentBoostImpl([
+            {
+                pattern: 'hello',
+                boosts: [{ tool: 'custom_tool', bonus: 10 }],
+            },
+            {
+                pattern: 'hello world',
+                boosts: [{ tool: 'custom_tool', bonus: 25 }],
+            },
+        ]);
+        expect(boost.resolveIntentToolBonuses('hello world').get('custom_tool')).toBe(25);
+        expect(boost.getCompiledRules()).toHaveLength(2);
+    });
+    it('allows an explicit empty custom rule set', () => {
+        const boost = new IntentBoostImpl([]);
+        expect(boost.resolveIntentToolBonuses('账号注册验证码')).toEqual(new Map());
+        expect(boost.getCompiledRules()).toEqual([]);
+    });
+});

package/dist/tests/server/search/ToolSearchEngine.test.d.ts

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

package/dist/tests/server/search/ToolSearchEngine.test.js

@@ -0,0 +1,10 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+describe('search/ToolSearchEngine barrel', () => {
+    beforeEach(() => {
+    });
+    it('re-exports the implementation class', async () => {
+        const barrel = await import('../../../src/server/search/ToolSearchEngine.js');
+        const impl = await import('../../../src/server/search/ToolSearchEngineImpl.js');
+        expect(barrel.ToolSearchEngine).toBe(impl.ToolSearchEngine);
+    });
+});

package/dist/tests/server/search/ToolSearchEngineImpl.test.d.ts

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

package/dist/tests/server/search/ToolSearchEngineImpl.test.js

@@ -0,0 +1,106 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const state = vi.hoisted(() => ({
+    allTools: [],
+    getToolDomain: vi.fn((name) => {
+        if (name.startsWith('page_'))
+            return 'browser';
+        if (name.startsWith('debug_'))
+            return 'debugger';
+        if (name.startsWith('workflow_'))
+            return 'workflow';
+        return null;
+    }),
+}));
+vi.mock('@server/ToolCatalog', () => ({
+    get allTools() {
+        return state.allTools;
+    },
+    getToolDomain: state.getToolDomain,
+}));
+vi.mock('@src/constants', () => ({
+    SEARCH_TFIDF_COSINE_WEIGHT: 0.3,
+    SEARCH_AFFINITY_BOOST_FACTOR: 0.2,
+    SEARCH_AFFINITY_TOP_N: 3,
+    SEARCH_DOMAIN_HUB_THRESHOLD: 2,
+    SEARCH_QUERY_CACHE_CAPACITY: 8,
+}));
+function makeTool(name, description) {
+    return {
+        name,
+        description,
+        inputSchema: { type: 'object', properties: {} },
+    };
+}
+describe('search/ToolSearchEngineImpl', () => {
+    beforeEach(() => {
+        vi.resetModules();
+        state.getToolDomain.mockClear();
+        state.allTools = [
+            makeTool('page_navigate', 'Navigate a page. Opens a URL in the current tab.'),
+            makeTool('page_click', 'Click an element in the current tab'),
+            makeTool('debug_pause', 'Pause JavaScript execution'),
+        ];
+    });
+    it('uses ToolCatalog tools by default and extracts short descriptions', async () => {
+        const { ToolSearchEngine } = await import('../../../src/server/search/ToolSearchEngineImpl.js');
+        const engine = new ToolSearchEngine();
+        const results = engine.search('navigate page', 5);
+        expect(results[0]?.name).toBe('page_navigate');
+        expect(results[0]?.shortDescription).toBe('Navigate a page.');
+        expect(state.getToolDomain).toHaveBeenCalledWith('page_navigate');
+    });
+    it('promotes explicit tool mentions when the query uses invocation verbs', async () => {
+        const { ToolSearchEngine } = await import('../../../src/server/search/ToolSearchEngineImpl.js');
+        const engine = new ToolSearchEngine([
+            makeTool('page_navigate', 'Navigate a page'),
+            makeTool('page_click', 'Click a page element'),
+            makeTool('workflow_helper', 'Execute generic workflow helper'),
+        ]);
+        const results = engine.search('please use page navigate now', 5);
+        expect(results[0]?.name).toBe('page_navigate');
+    });
+    it('updates isActive from cache hits without changing scores', async () => {
+        const { ToolSearchEngine } = await import('../../../src/server/search/ToolSearchEngineImpl.js');
+        const engine = new ToolSearchEngine([
+            makeTool('page_navigate', 'Navigate a page'),
+            makeTool('page_click', 'Click a page element'),
+        ]);
+        const first = engine.search('page navigate', 5, new Set());
+        const second = engine.search('page navigate', 5, new Set(['page_navigate']));
+        expect(first.map((item) => item.score)).toEqual(second.map((item) => item.score));
+        expect(first.find((item) => item.name === 'page_navigate')?.isActive).toBe(false);
+        expect(second.find((item) => item.name === 'page_navigate')?.isActive).toBe(true);
+    });
+    it('applies domain and tool score multipliers', async () => {
+        const { ToolSearchEngine } = await import('../../../src/server/search/ToolSearchEngineImpl.js');
+        const engine = new ToolSearchEngine([
+            makeTool('workflow_helper', 'Execute flow helper'),
+            makeTool('page_click', 'Execute flow helper'),
+        ], new Map([
+            ['workflow_helper', 'workflow'],
+            ['page_click', 'browser'],
+        ]), new Map([['workflow', 1.5]]), new Map([['workflow_helper', 1.2]]));
+        const results = engine.search('execute flow helper', 5);
+        expect(results[0]?.name).toBe('workflow_helper');
+    });
+    it('returns grouped domain summaries', async () => {
+        const { ToolSearchEngine } = await import('../../../src/server/search/ToolSearchEngineImpl.js');
+        const engine = new ToolSearchEngine([
+            makeTool('page_navigate', 'Navigate a page'),
+            makeTool('page_click', 'Click a page'),
+            makeTool('debug_pause', 'Pause execution'),
+        ]);
+        expect(engine.getDomainSummary()).toEqual([
+            {
+                domain: 'browser',
+                count: 2,
+                tools: ['page_navigate', 'page_click'],
+            },
+            {
+                domain: 'debugger',
+                count: 1,
+                tools: ['debug_pause'],
+            },
+        ]);
+    });
+});

package/dist/tests/server/workflows/WorkflowContract.test.d.ts

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