mcp-multi-bridge 2.1.4 → 2.3.0

package/lib/config.js

@@ -5,48 +5,110 @@
  * 配置结构由登录侧 CLI（如 mes-login-cli）定义，两边各自维护默认值必然漂移，
  * 所以桥接层只认文件；文件缺失时明确报错，引导用户去跑登录命令。
  *
- * 目录可换：默认沿用 ~/.mes-mcp-login（历史约定），
- * 用 MCP_BRIDGE_HOME 指向别的目录即可支持第二套系统并存，
- * 两套互不干扰，各自登录各自的 token。
+ * 配置目录必须显式指定，两种方式：
+ *   1. MCP_MULTI_HOME=<绝对路径>   直接指目录
+ *   2. --name <系统名>             用约定目录 ~/.<系统名>-mcp-login
+ *
+ * 故意不设「默认目录」。以前没配时会静默回落到 ~/.mes-mcp-login，
+ * 结果是新加的系统忘了配就默默读到 MES 的配置和 token，
+ * 工具名显示 erp、数据却是 MES 的，且不报错——跨系统串数据极难排查。
+ * 现在没配就报错，宁可启动失败也不要读错数据。
  */
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 
-/** 历史默认目录，保持兼容 */
-const LEGACY_DIR_NAME = '.mes-mcp-login';
+/** 用 --name 推导目录时统一加的后缀 */
+export const NAME_DIR_SUFFIX = '-mcp-login';
+
+/**
+ * 从命令行取 --name 的值
+ *
+ * 支持 `--name erp` / `--name=erp` / `-n erp`。
+ * 放在 config.js 里读 process.argv 是因为 CONFIG_DIR 是模块级常量，
+ * 在 import 阶段就要算出来——此时 argv 已就绪，可用。
+ */
+function nameFromArgv() {
+    const argv = process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--name' || a === '-n') return String(argv[i + 1] || '').trim();
+        if (a.startsWith('--name=')) return a.slice('--name='.length).trim();
+    }
+    return '';
+}
+
+/** 展开 ~ 与相对路径 */
+function expand(raw) {
+    const s = String(raw || '').trim();
+    if (!s) return '';
+    if (s === '~') return os.homedir();
+    if (s.startsWith('~/') || s.startsWith('~\\')) return path.join(os.homedir(), s.slice(2));
+    return path.resolve(s);
+}
 
 /**
  * 解析配置目录
  *
- * 优先级：MCP_MULTI_HOME > MCP_BRIDGE_HOME（旧名） > ~/.mes-mcp-login
+ * 优先级：MCP_MULTI_HOME > MCP_BRIDGE_HOME（旧名） > --name 推导
  * 用环境变量而不是 config.json 里的字段——要读配置就得先知道目录，写进配置里是循环依赖。
  *
- * 与登录 CLI 用同一套变量名，两边必须读到同一个目录，否则登录完 bridge 找不到 token。
+ * @returns {{dir:string, name:string, error:string|null}} dir 为空表示未配置
+ *   name 是 --name 传入的系统名（用环境变量指定目录时为空），供工具分组使用
  */
 function resolveDir() {
     const pick = (v) => (typeof v === 'string' && v.trim() ? v.trim() : '');
+
     const custom = pick(process.env.MCP_MULTI_HOME) || pick(process.env.MCP_BRIDGE_HOME);
-    if (custom) {
-        // 支持 ~ 开头，避免用户写了相对路径找不到
-        if (custom === '~') return os.homedir();
-        if (custom.startsWith('~/') || custom.startsWith('~\\')) {
-            return path.join(os.homedir(), custom.slice(2));
+    if (custom) return { dir: expand(custom), name: '', error: null };
+
+    const name = pick(nameFromArgv());
+    if (name) {
+        // --name 会拼进路径，限定字符集，避免 ../ 之类跑出 home 目录
+        if (!/^[A-Za-z0-9._-]+$/.test(name) || name === '.' || name === '..') {
+            return {
+                dir: '',
+                name: '',
+                error: `--name 的值不合法：「${name}」。只允许字母、数字、点、下划线、连字符。`
+            };
         }
-        return path.resolve(custom);
+        return { dir: path.join(os.homedir(), `.${name}${NAME_DIR_SUFFIX}`), name, error: null };
     }
-    return path.join(os.homedir(), LEGACY_DIR_NAME);
+
+    return {
+        dir: '',
+        name: '',
+        error:
+            '未指定配置目录。启动时加其中之一：\n' +
+            '  1) 环境变量 MCP_MULTI_HOME=<配置目录绝对路径>\n' +
+            `  2) 命令行参数 --name <系统名>（目录为 ~/.<系统名>${NAME_DIR_SUFFIX}）\n` +
+            'MCP 客户端里一般写在 mcp.json 的 env 或 args。'
+    };
 }
 
-export const CONFIG_DIR = resolveDir();
-export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-export const TOKEN_FILE = path.join(CONFIG_DIR, 'token.json');
+const RESOLVED = resolveDir();
+
+/** 配置目录；未配置时为空字符串 */
+export const CONFIG_DIR = RESOLVED.dir;
+/** 未配置时的说明文字；已配置为 null */
+export const CONFIG_DIR_ERROR = RESOLVED.error;
+/**
+ * --name 传入的系统名；用 MCP_MULTI_HOME 指定目录或未配置时为空字符串。
+ *
+ * 用途：工具分组时若本实例只连一个后端，直接用它做系统名，
+ * 比从 path 末段猜（sz-mes / tc-mes）更准——部署者写什么就是什么。
+ * 注意它和 CONFIG_DIR 是两回事：--name 只决定目录，不参与路由选择。
+ */
+export const CONFIG_NAME = RESOLVED.name;
+export const CONFIG_FILE = CONFIG_DIR ? path.join(CONFIG_DIR, 'config.json') : '';
+export const TOKEN_FILE = CONFIG_DIR ? path.join(CONFIG_DIR, 'token.json') : '';
 
 /**
  * 读取配置
- * @returns {object|null} 配置对象；文件缺失或损坏返回 null
+ * @returns {object|null} 配置对象；未配置目录、文件缺失或损坏都返回 null
  */
 export function loadConfig() {
+    if (!CONFIG_FILE) return null;
     try {
         if (!fs.existsSync(CONFIG_FILE)) return null;
         const cfg = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));

package/lib/toolindex.js

@@ -0,0 +1,425 @@
+/**
+ * toolindex.js —— 工具索引与检索
+ *
+ * 为什么需要这一层：
+ * 工具定义要占模型上下文。按中等复杂度工具约 350 tokens 估算，
+ * 1000 个工具就是 350K tokens，超过多数模型的整个窗口。
+ * 所以不能全量塞给模型，得让它按需查。
+ *
+ * 但「全量塞」在工具少时是更好的——少一次往返，模型看得见全部选项。
+ * 因此这里只提供索引能力，什么时候切换由调用方（bin.js）按数量决定。
+ */
+
+/**
+ * 从 MCP path 提取系统标识
+ *
+ * /mcp-servers/sz-mes-mcp-server  →  sz-mes
+ * /mcp-servers/erp-api            →  erp
+ * /foo                            →  foo
+ */
+export function systemFromPath(p) {
+    const segs = String(p || '').split('/').filter(Boolean);
+    let seg = segs.pop() || '';
+
+    // 末段只是容器名（/sap/mcp 这种），真正标识在上一层
+    if (/^(mcp|api|sse|v1|v2|server|srv)$/i.test(seg) && segs.length) seg = segs.pop();
+
+    return seg
+        .replace(/[-_](mcp|api)([-_](server|srv))?$/i, '')
+        .replace(/[-_](server|srv)$/i, '')
+        .toLowerCase() || 'default';
+}
+
+/**
+ * 工具定义的指纹，用于判断「同名工具是否真的同一个」
+ *
+ * 只取参数结构，不含 description——同一套后端的多个部署环境，
+ * 描述里可能带环境相关的字眼（如「深圳正式环境」），但参数是一样的。
+ */
+export function schemaFingerprint(tool) {
+    const s = tool?.inputSchema || {};
+    const norm = (v) => {
+        if (Array.isArray(v)) return v.map(norm);
+        if (v && typeof v === 'object') {
+            const out = {};
+            for (const k of Object.keys(v).sort()) out[k] = norm(v[k]);
+            return out;
+        }
+        return v;
+    };
+    try {
+        return JSON.stringify(norm(s));
+    } catch (e) {
+        return '{}';
+    }
+}
+
+/**
+ * 把分词结果规范化：英文小写拆驼峰与下划线，中文按二元组切
+ *
+ * 驼峰必须在转小写之前拆，否则 searchRidReport 会变成一个整词，
+ * rid / report 都拿不到——那样按「RID」搜就完全搜不到本该首位的结果。
+ */
+export function tokenize(text) {
+    const raw = String(text || '');
+    const out = new Set();
+
+    // 驼峰、下划线、连字符统一拆成空格，再小写
+    const flat = raw
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .replace(/[_-]/g, ' ')
+        .toLowerCase();
+
+    for (const w of flat.match(/[a-z][a-z0-9]*/g) || []) out.add(w);
+
+    // 中文：完整词 + 二元组，短词精确命中权重更高
+    const cjk = raw.match(/[\u4e00-\u9fa5]+/g) || [];
+    for (const run of cjk) {
+        if (run.length === 1) out.add(run);
+        for (let i = 0; i + 1 < run.length; i++) out.add(run.slice(i, i + 2));
+        if (run.length <= 6) out.add(run);
+    }
+
+    return out;
+}
+
+/**
+ * 给单个工具建检索字段
+ *
+ * 只返回索引相关的词集合，不碰 tool/name/system——
+ * 早先版本在这里返回了 system，结果把调用方算好的合并系统覆盖成占位符，
+ * 分类目录里出现一个无名的 `*` 组。
+ */
+function entryOf(tool) {
+    const props = Object.keys(tool?.inputSchema?.properties || {});
+    const desc = String(tool?.description || '');
+    const name = String(tool?.name || '');
+
+    // 名称权重最高，其次是描述，参数名再次。
+    // 名称里带动作词（query/create/update），描述里多是业务对象，两者互补。
+    const basis = [name, desc, props.join(' ')].join(' ');
+
+    return {
+        tokens: tokenize(basis),
+        nameTokens: tokenize(name),
+        propTokens: tokenize(props.join(' ')),
+        text: (name + ' ' + desc).toLowerCase()
+    };
+}
+
+/**
+ * 构建索引并解决同名冲突
+ *
+ * 冲突判定：同一工具名在多套系统里出现，且参数指纹不同 → 真冲突。
+ * 指纹相同说明是同一套后端的不同部署环境（如 sz / tc 两个 MES），应当合并，
+ * 「组织」维度已经能区分它们，加前缀反而会让模型困惑。
+ *
+ * 系统名的来源按优先级：
+ *   1. opts.defaultSystem —— 调用方给的（一般来自 --name），仅在本实例
+ *      只连一个后端时使用。一套系统一个 --name 是更自然的部署方式，
+ *      这时 --name 就是最准的系统标识，不用从 path 末段猜。
+ *   2. path 末段推导 —— 一个实例连多套系统时只能这样，
+ *      因为 --name 代表的是配置目录，下面挂着好几套后端。
+ *
+ * @param {{path:string, tools:object[]}[]} byPath 每个后端的工具列表
+ * @param {Map<string,string[]>} orgKeysByPath path → 该 path 下的组织 key
+ * @param {{defaultSystem?:string}} [opts]
+ * @returns {{items:Map<string,object>, bySystem:Map<string,object>, conflicts:string[]}}
+ */
+export function buildIndex(byPath, orgKeysByPath, opts = {}) {
+    // 只连一个后端且给了 defaultSystem 时，用这个名字，别去猜 path
+    const forced = byPath.length === 1 ? String(opts.defaultSystem || '').trim() : '';
+
+    // 先把所有 (系统, 工具) 摊平
+    const flat = [];
+    for (const g of byPath) {
+        const system = forced || systemFromPath(g.path);
+        const orgKeys = orgKeysByPath.get(g.path) || [];
+        for (const t of g.tools || []) {
+            if (!t || !t.name) continue;
+            flat.push({ tool: t, system, path: g.path, orgKeys, fp: schemaFingerprint(t) });
+        }
+    }
+
+    // 按工具名归组，看每个名字跨了几套系统、指纹是否一致
+    const byName = new Map();
+    for (const f of flat) {
+        if (!byName.has(f.tool.name)) byName.set(f.tool.name, []);
+        byName.get(f.tool.name).push(f);
+    }
+
+    const items = new Map();
+    const bySystem = new Map();
+    const conflicts = [];
+
+    for (const [name, list] of byName) {
+        const fps = new Set(list.map((x) => x.fp));
+        const systems = new Set(list.map((x) => x.system));
+        // 同名 + 多系统 + 指纹不一致 = 真冲突，必须区分
+        const needPrefix = systems.size > 1 && fps.size > 1;
+
+        if (needPrefix) conflicts.push(name);
+
+        // 冲突时按系统拆成多条；否则合并成一条
+        const buckets = needPrefix
+            ? groupBy(list, (x) => x.system)
+            : new Map([['*', list]]);
+
+        for (const [sys, group] of buckets) {
+            const exposed = needPrefix ? `${sys}__${name}` : name;
+            const orgKeys = new Set();
+            const paths = new Set();
+            const systems = new Set();
+            for (const x of group) {
+                for (const k of x.orgKeys) orgKeys.add(k);
+                paths.add(x.path);
+                systems.add(x.system);
+            }
+
+            const realName = exposed;
+            const realTool = { ...group[0].tool, name: realName };
+
+            items.set(exposed, {
+                name: realName,
+                originalName: name,
+                // 合并时可能是多套环境共用一套工具，记成列表；过滤时按包含判断
+                system: [...systems].sort().join(','),
+                systemList: [...systems].sort(),
+                prefixed: needPrefix,
+                tool: realTool,
+                orgKeys: [...orgKeys].sort(),
+                paths: [...paths].sort(),
+                ...entryOf(realTool)
+            });
+
+            // 目录按系统建索引。合并掉的工具要登记到它涉及的每个系统下——
+            // 否则 sz-mes / tc-mes 共用的工具只会挂在一个占位名下，目录就成了空的。
+            for (const s of systems) {
+                if (!bySystem.has(s)) bySystem.set(s, []);
+                bySystem.get(s).push(exposed);
+            }
+        }
+    }
+
+    return { items, bySystem, conflicts: [...new Set(conflicts)] };
+}
+
+function groupBy(arr, keyFn) {
+    const m = new Map();
+    for (const x of arr) {
+        const k = keyFn(x);
+        if (!m.has(k)) m.set(k, []);
+        m.get(k).push(x);
+    }
+    return m;
+}
+
+/**
+ * 动作词分级
+ *
+ * 同为只读，query 和 export 也不是一回事：用户说「料号」是要看数据，
+ * 不是要导出一份文件。不分级的话 exportMaterial 会靠字母序排到 queryMaterial 前面。
+ * 主级是日常查询，次级是导出/统计这类更重或更少用的操作。
+ */
+const READ_PRIMARY = ['query', 'search', 'get', 'list', 'find', 'select', 'fetch', 'detail', 'page', 'read'];
+const READ_SECONDARY = ['export', 'report', 'count', 'view', 'check', 'exists', 'summary', 'stat'];
+
+const WRITE_PRIMARY = ['create', 'add', 'insert', 'update', 'modify', 'edit', 'delete', 'remove', 'save', 'submit'];
+const WRITE_SECONDARY = ['import', 'cancel', 'approve', 'reject', 'batch', 'sync'];
+
+/**
+ * 判定查询意图
+ *
+ * 业务 API 的工具名几乎都是 queryXxx / createXxx / updateXxx / deleteXxx 四件套，
+ * 光看业务对象（material、customer）四个分数完全一样。
+ * 用户说「料号」时想要的是查，不是创建——不区分意图就会随机选中 createMaterial。
+ *
+ * 返回 read / write / unknown。unknown 在打分时按 read 处理：
+ * 读操作无副作用，选错代价小；写操作选错有数据风险。
+ */
+export function detectIntent(query) {
+    const q = String(query || '');
+    if (/创建|新增|添加|新建|修改|更新|编辑|删除|移除|保存|提交|导入|作废|审核|撤销/.test(q)) return 'write';
+    if (/\b(create|add|insert|update|modify|delete|remove|save|submit|cancel)\w*/i.test(q)) return 'write';
+    if (/查询|搜索|查找|获取|列出|查看|导出|统计|报表|明细|列表|详情|有多少/.test(q)) return 'read';
+    if (/\b(query|search|get|list|find|fetch|export|count)\w*/i.test(q)) return 'read';
+    return 'unknown';
+}
+
+/**
+ * 工具名开头的动作词等级
+ * @returns {'read'|'read2'|'write'|'write2'|''}
+ */
+function verbOf(name) {
+    const s = String(name || '');
+    // 带系统前缀时（erp__queryOrder）只看前缀后的部分
+    const tail = s.includes('__') ? s.split('__').slice(1).join('__') : s;
+    const w = (String(tail).match(/^[A-Za-z]+/) || [''])[0].toLowerCase();
+    if (!w) return '';
+
+    for (const v of READ_PRIMARY) if (w.startsWith(v)) return 'read';
+    for (const v of WRITE_PRIMARY) if (w.startsWith(v)) return 'write';
+    for (const v of READ_SECONDARY) if (w.startsWith(v)) return 'read2';
+    for (const v of WRITE_SECONDARY) if (w.startsWith(v)) return 'write2';
+    return '';
+}
+
+/** 意图与动作词的加权 */
+function verbBonus(intent, kind) {
+    if (!kind) return 0;
+    if (intent === 'write') {
+        return kind === 'write' ? 20 : kind === 'write2' ? 10 : kind === 'read' ? -4 : -2;
+    }
+    // read 与 unknown 都偏向读操作
+    return kind === 'read' ? 20 : kind === 'read2' ? 8 : kind === 'write' ? -12 : -6;
+}
+
+/**
+ * 查询里明说的动作词 → 工具名动词
+ *
+ * 「导出物料」和「查询物料」都算 read，只按读/写分级的话 exportMaterial
+ * 会被 queryMaterial 挤到后面。用户既然说了「导出」，就该给 export 额外加权。
+ */
+const ACTION_HINTS = {
+    导出: ['export'],
+    下载: ['export', 'download'],
+    统计: ['stat', 'count', 'summary'],
+    计数: ['count'],
+    列表: ['list', 'page'],
+    分页: ['page', 'list'],
+    详情: ['detail', 'get'],
+    明细: ['detail', 'report'],
+    创建: ['create', 'add'],
+    新增: ['create', 'add'],
+    添加: ['add', 'create'],
+    新建: ['create', 'add'],
+    修改: ['update', 'modify', 'edit'],
+    更新: ['update'],
+    编辑: ['edit', 'update'],
+    删除: ['delete', 'remove'],
+    移除: ['remove', 'delete'],
+    审批: ['approve'],
+    作废: ['cancel', 'void'],
+    查询: ['query'],
+    搜索: ['search'],
+    查找: ['find', 'search'],
+    获取: ['get', 'fetch']
+};
+
+/** 工具名的首个英文词（去掉系统前缀） */
+function leadingWord(name) {
+    const s = String(name || '');
+    const tail = s.includes('__') ? s.split('__').slice(1).join('__') : s;
+    return ((String(tail).match(/^[A-Za-z]+/) || [''])[0] || '').toLowerCase();
+}
+
+/** 查询里明说的动作词命中时额外加权 */
+function actionBonus(query, name) {
+    const w = leadingWord(name);
+    if (!w) return 0;
+    let bonus = 0;
+    for (const [cn, ens] of Object.entries(ACTION_HINTS)) {
+        if (!query.includes(cn)) continue;
+        for (const en of ens) if (w.startsWith(en)) { bonus += 25; break; }
+    }
+    return bonus;
+}
+
+/**
+ * 检索工具
+ *
+ * 打分是手写的加权命中，没有引入 BM25：工具描述普遍很短，
+ * 文档长度差异对相关性的影响远小于「名称是否命中」，
+ * IDF 那套在这种语料上收益有限，反而多一层不好调的参数。
+ *
+ * 刻意不做「业务词别名表」。曾经有一份约 30 条的「料号→material/item」
+ * 对照表，实测有两个问题：
+ *   1. 对描述写全中文的工具零贡献——「料号、批次、仓库」本来就出现在描述里
+ *   2. 会误匹配——把 item 当成物料，但别的系统里 item 可能是电商商品
+ * 匹配依据只认三处：工具名、描述、参数名。缺中文就去补描述，
+ * 不在桥接层维护一张注定对不齐的词表。
+ *
+ * @param {Map} items buildIndex 返回的 items
+ * @param {string} query 检索词
+ * @param {{system?:string, limit?:number}} opts
+ */
+export function searchTools(items, query, opts = {}) {
+    const q = String(query || '').trim();
+    const limit = Math.max(1, Math.min(50, opts.limit || 5));
+    if (!q) return [];
+
+    const qTokens = tokenize(q);
+    const qLower = q.toLowerCase();
+    const intent = detectIntent(q);
+    const scored = [];
+
+    for (const item of items.values()) {
+        if (opts.system && !(item.systemList || []).includes(opts.system)) continue;
+
+        // 先算「文本是否相关」。意图与动作加权只在相关的前提下生效——
+        // 否则任何 queryXxx 对任何查询词都能靠动作词白得 20 分，
+        // 「完全无关的词」也会搜出结果。
+        let base = 0;
+
+        const nm = item.name.toLowerCase();
+        if (nm === qLower) base += 200;
+        else if (nm.includes(qLower)) base += 80;
+        else if (item.originalName && item.originalName.toLowerCase().includes(qLower)) base += 70;
+
+        // 分词命中：名称权重高，参数名次之，描述再次
+        for (const t of qTokens) {
+            if (item.nameTokens.has(t)) base += 25;
+            else if (item.propTokens.has(t)) base += 10;
+            else if (item.tokens.has(t)) base += 4;
+        }
+
+        // 查询串整体出现在描述里，说明是业务对象层面的匹配
+        if (qLower.length >= 2 && item.text.includes(qLower)) base += 20;
+
+        if (base <= 0) continue;
+
+        // 业务对象打平时，用动作词分出读/写、主次
+        let score = base + verbBonus(intent, verbOf(item.name));
+
+        // 用户明说了动作词（导出、统计、创建…）时，匹配该动作的工具再抬高
+        score += actionBonus(q, item.name);
+
+        scored.push({ item, score });
+    }
+
+    scored.sort((a, b) => b.score - a.score || a.item.name.localeCompare(b.item.name));
+    return scored.slice(0, limit).map((x) => x.item);
+}
+
+/**
+ * 生成按系统分组的目录
+ *
+ * 工具集完全相同的系统合并成一行。
+ * 这不只是排版问题：MES 的 sz/tc/vn/hn/qc 是同一套 API 的五个部署环境，
+ * 逐行列出会让模型以为有 5 倍的工具量，进而更倾向于放弃检索、直接猜名字。
+ * 合并后写作「sz-mes / tc-mes（共用 3 个）」，既准确又短。
+ */
+export function summarize(bySystem, items, perSystemSample = 4) {
+    const groups = new Map();
+    for (const [system, names] of bySystem) {
+        const key = [...names].sort().join('\u0000');
+        if (!groups.has(key)) groups.set(key, { systems: [], names });
+        groups.get(key).systems.push(system);
+    }
+
+    return [...groups.values()]
+        .map(({ systems, names }) => {
+            systems.sort();
+            const sample = names.slice(0, perSystemSample).join('、');
+            const more = names.length > perSystemSample ? ` 等 ${names.length} 个` : '';
+            const label = systems.length > 1 ? `${systems.join(' / ')}（共用 ${names.length} 个）` : `${systems[0]}（${names.length} 个）`;
+            return {
+                system: systems.join(','),
+                systems,
+                count: names.length,
+                text: `${label}：${sample}${more}`
+            };
+        })
+        .sort((a, b) => b.count - a.count || a.system.localeCompare(b.system));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-multi-bridge",
-  "version": "2.1.4",
+  "version": "2.3.0",
   "description": "多后端 MCP 桥接：把网关后多个后端、多个租户的工具集合并成一个 MCP 服务，凭据由登录 CLI 提供",
   "type": "module",
   "bin": {
@@ -16,7 +16,8 @@
   },
   "scripts": {
     "start": "node bin.js",
-    "pack:check": "npm pack --dry-run"
+    "pack:check": "npm pack --dry-run",
+    "test": "node test/toolindex.test.mjs"
   },
   "keywords": [
     "mcp",