freeform-modeling-mcp 1.0.32 → 1.0.34

package/README.md

@@ -5,6 +5,7 @@
 - 🧰 丰富工具集（`src/tools/`包含50+建模工具）
   - 基础建模工具（立方体/球体/圆环创建）
   - KJL资源库集成（资产搜索/置入/替换）
+  - KDS 脚本片段（`run_kds_script`）+ API 知识检索（`get_core_modeling_api` / `batch_search_methods` / `batch_get_methods_full`）
   - 通用 GLB/GLTF 导入
   - 材质替换
 
@@ -27,7 +28,7 @@ npx -y freeform-modeling-mcp
 ### 故障排除
 若启动失败，可尝试安装指定版本：
 ```bash
-npm i -g freeform-modeling-mcp@1.0.26 --registry=https://registry.npmjs.org
+npm i -g freeform-modeling-mcp@1.0.33 --registry=https://registry.npmjs.org
 ```
 
 ## 核心模块
@@ -56,6 +57,7 @@ npm i -g freeform-modeling-mcp@1.0.26 --registry=https://registry.npmjs.org
 1. 工具扩展：在`src/tools/`创建新工具类
 2. API集成：参考`import-tools.ts`接入第三方服务
 3. 客户端协议：遵循`llmClient.ts`定义的消息格式
+4. KDS API 知识实现位于`src/kds-api-knowledge/`（自 `kds-Plugin-MCP-Server/src/lib` 抽拷；升级时对照上游同步该目录，并钉齐 `@qunhe/kds-api` 版本）
 
 ## 贡献者协议
 请遵循`src/prompt.ts`中定义的建模规范提交代码

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freeform-modeling-mcp",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "description": "KooMaster MCP Server with WebSocket Bridge",
   "main": "index.cjs",
   "type": "module",
@@ -20,6 +20,7 @@
   },
   "license": "ISC",
   "dependencies": {
+    "@kudashi/kds-api": "^2.14.8",
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.1",
     "@types/node": "22.13.5",
@@ -38,6 +39,7 @@
     "multer": "^1.4.5-lts.1",
     "node-fetch": "^3.3.2",
     "nodemon": "^3.1.9",
+    "ts-morph": "^27.0.2",
     "ts-node": "^10.9.2",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",

package/src/kds-api-knowledge/api-plugin-outline-whitelist.ts

@@ -0,0 +1,24 @@
+/**
+ * 插件场景下给 LLM 的精简 API 轮廓白名单（与 declare global 中声明名一致）。
+ * 顺序即输出排序依据。
+ */
+export const API_PLUGIN_OUTLINE_ORDER: readonly string[] = [
+  'app',
+  'GeomLib',
+  'KApplication',
+  'KDesign',
+  'KGroupDefinition',
+  'KGroupInstance',
+  'KEntity',
+  'KVertex',
+  'KHalfEdge',
+  'KEdge',
+  'KLoop',
+  'KWire',
+  'KFace',
+  'KShell',
+  'KMesh',
+  'KGeomLib',
+];
+
+export const API_PLUGIN_OUTLINE_WHITELIST = new Set(API_PLUGIN_OUTLINE_ORDER);

package/src/kds-api-knowledge/batch-methods-full.ts

@@ -0,0 +1,480 @@
+/**
+ * 基于 @qunhe/kds-api/api.d.ts（declare global）解析 interface/class 方法签名，
+ * 将参数/返回类型展开为嵌套 JSON；顶层引用去重写入 dependencies。
+ */
+import ts from 'typescript';
+import type { TopMaps } from './kds-api-dts.js';
+import {
+  buildTopMaps,
+  collectMethodNamesFromIfaceOrClass,
+  extractCommentFromInterfaceMember,
+  extractCommentText,
+  getInterfaceLikeRelations,
+  resolveKdsApiDtsPath,
+} from './kds-api-dts.js';
+
+export type BatchMethodsItem = { interface: string; methods: string[] };
+
+export type BatchMethodsFullResult = {
+  full: Array<{
+    interface: string;
+    extends: string[];
+    implements: string[];
+    methods: Array<{
+      name: string;
+      /** 该方法上的 JSDoc / 前导注释合并文本 */
+      comments?: string;
+      parameters: Record<string, unknown>;
+      returnType: unknown;
+    }>;
+  }>;
+  dependencies: {
+    consts: Array<{ name: string; comments?: string }>;
+    interfaces: Array<{
+      name: string;
+      comments?: string;
+      extends: string[];
+      implements: string[];
+      methods: string[];
+    }>;
+    types: Array<{ name: string; comments?: string }>;
+    enums: Array<{ name: string; comments?: string; values: string[] }>;
+  };
+};
+
+function mergeCommentText(...parts: (string | undefined)[]): string | undefined {
+  const pieces: string[] = [];
+  for (const p of parts) {
+    if (p?.trim()) pieces.push(p.trim());
+  }
+  return pieces.length ? pieces.join('\n\n') : undefined;
+}
+
+type DepState = {
+  consts: Map<string, { name: string; comments?: string }>;
+  interfaces: Map<
+    string,
+    {
+      name: string;
+      comments?: string;
+      extends: string[];
+      implements: string[];
+      methods: string[];
+    }
+  >;
+  types: Map<string, { name: string; comments?: string }>;
+  enums: Map<string, { name: string; comments?: string; values: string[] }>;
+};
+
+const MAX_TYPE_DEPTH = 40;
+
+type SerCtx = {
+  checker: ts.TypeChecker;
+  sourceFile: ts.SourceFile;
+  top: TopMaps;
+  deps: DepState;
+  expanding: Set<string>;
+  depth: number;
+};
+
+function safeTypeToString(checker: ts.TypeChecker, type: ts.Type): string {
+  try {
+    return checker.typeToString(type);
+  } catch {
+    return '<type>';
+  }
+}
+
+function registerConst(ctx: SerCtx, qualifiedName: string, vd: ts.VariableDeclaration): void {
+  if (ctx.deps.consts.has(qualifiedName)) return;
+  const list = vd.parent;
+  const stmt = list?.parent;
+  const stmtComments =
+    stmt && ts.isVariableStatement(stmt) ? extractCommentText(stmt, ctx.sourceFile) : undefined;
+  const row: { name: string; comments?: string } = { name: qualifiedName };
+  const c = mergeCommentText(stmtComments, extractCommentText(vd, ctx.sourceFile));
+  if (c?.trim()) row.comments = c;
+  ctx.deps.consts.set(qualifiedName, row);
+}
+
+function registerInterfaceLike(
+  ctx: SerCtx,
+  qualifiedName: string,
+  node: ts.InterfaceDeclaration | ts.ClassDeclaration
+): void {
+  if (ctx.deps.interfaces.has(qualifiedName)) return;
+  const relations = getInterfaceLikeRelations(node, ctx.sourceFile);
+  const row: {
+    name: string;
+    comments?: string;
+    extends: string[];
+    implements: string[];
+    methods: string[];
+  } = {
+    name: qualifiedName,
+    extends: relations.extends,
+    implements: relations.implements,
+    methods: collectMethodNamesFromIfaceOrClass(node, ctx.sourceFile),
+  };
+  const c = extractCommentText(node, ctx.sourceFile);
+  if (c?.trim()) row.comments = c;
+  ctx.deps.interfaces.set(qualifiedName, row);
+}
+
+function registerTypeAlias(ctx: SerCtx, qualifiedName: string, node: ts.TypeAliasDeclaration): void {
+  if (ctx.deps.types.has(qualifiedName)) return;
+  const row: { name: string; comments?: string } = { name: qualifiedName };
+  const c = extractCommentText(node, ctx.sourceFile);
+  if (c?.trim()) row.comments = c;
+  ctx.deps.types.set(qualifiedName, row);
+}
+
+function registerEnum(ctx: SerCtx, qualifiedName: string, node: ts.EnumDeclaration): void {
+  if (ctx.deps.enums.has(qualifiedName)) return;
+  const values = node.members.map((m) => m.name.getText(ctx.sourceFile));
+  const row: { name: string; comments?: string; values: string[] } = {
+    name: qualifiedName,
+    values,
+  };
+  const c = extractCommentText(node, ctx.sourceFile);
+  if (c?.trim()) row.comments = c;
+  ctx.deps.enums.set(qualifiedName, row);
+}
+
+function findQualifiedNameForDecl(
+  decl: ts.Declaration,
+  top: TopMaps
+): { kind: keyof TopMaps; name: string } | undefined {
+  for (const [name, node] of top.interfaces) {
+    if (node === decl) return { kind: 'interfaces', name };
+  }
+  for (const [name, node] of top.classes) {
+    if (node === decl) return { kind: 'classes', name };
+  }
+  for (const [name, node] of top.typeAliases) {
+    if (node === decl) return { kind: 'typeAliases', name };
+  }
+  for (const [name, node] of top.enums) {
+    if (node === decl) return { kind: 'enums', name };
+  }
+  for (const [name, node] of top.consts) {
+    if (node === decl) return { kind: 'consts', name };
+  }
+  return undefined;
+}
+
+function isPlainObjectType(type: ts.Type, checker: ts.TypeChecker): boolean {
+  return (checker.getPropertiesOfType(type) ?? []).length > 0;
+}
+
+/** 若为 api.d.ts 顶层 interface/class/enum/type alias/const，写入 dependencies 并返回 true（由调用方输出 safeTypeToString）。 */
+function registerIfTopLevelDeclaration(type: ts.Type, ctx: SerCtx): boolean {
+  const { top } = ctx;
+
+  const aliasSym = type.aliasSymbol;
+  if (aliasSym) {
+    const ad = aliasSym.getDeclarations()?.find(ts.isTypeAliasDeclaration);
+    if (ad) {
+      const hit = findQualifiedNameForDecl(ad, top);
+      if (hit?.kind === 'typeAliases') {
+        const node = top.typeAliases.get(hit.name);
+        if (node) {
+          registerTypeAlias(ctx, hit.name, node);
+          return true;
+        }
+      }
+    }
+  }
+
+  const sym = type.getSymbol();
+  if (!sym) return false;
+  const decl = sym.getDeclarations()?.[0];
+
+  if (decl && (ts.isInterfaceDeclaration(decl) || ts.isClassDeclaration(decl))) {
+    const hit = findQualifiedNameForDecl(decl, top);
+    if (hit?.kind === 'interfaces' || hit?.kind === 'classes') {
+      const node =
+        hit.kind === 'interfaces' ? top.interfaces.get(hit.name)! : top.classes.get(hit.name)!;
+      registerInterfaceLike(ctx, hit.name, node);
+      return true;
+    }
+  }
+
+  if (sym.flags & ts.SymbolFlags.Enum) {
+    const ed = sym.getDeclarations()?.find(ts.isEnumDeclaration);
+    if (ed) {
+      const hit = findQualifiedNameForDecl(ed, top);
+      if (hit?.kind === 'enums') {
+        const node = top.enums.get(hit.name);
+        if (node) {
+          registerEnum(ctx, hit.name, node);
+          return true;
+        }
+      }
+    }
+  }
+
+  if (decl && ts.isVariableDeclaration(decl)) {
+    const hit = findQualifiedNameForDecl(decl, top);
+    if (hit?.kind === 'consts') {
+      const vd = top.consts.get(hit.name);
+      if (vd) {
+        registerConst(ctx, hit.name, vd);
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function tryArrayElementType(type: ts.Type, checker: ts.TypeChecker): ts.Type | undefined {
+  const anyChk = checker as ts.TypeChecker & {
+    isArrayType?: (t: ts.Type) => boolean;
+    getElementTypeOfArrayType?: (t: ts.Type) => ts.Type | undefined;
+  };
+  if (typeof anyChk.isArrayType === 'function' && anyChk.isArrayType(type)) {
+    return anyChk.getElementTypeOfArrayType?.(type);
+  }
+  const ref = type as ts.TypeReference;
+  const sym = ref.symbol ?? ref.aliasSymbol;
+  const n = sym?.name;
+  if ((n === 'Array' || n === 'ReadonlyArray') && ref.typeArguments?.length === 1) {
+    return ref.typeArguments[0];
+  }
+  return undefined;
+}
+
+function serializeType(type: ts.Type, ctx: SerCtx): unknown {
+  ctx.depth += 1;
+  try {
+    if (ctx.depth > MAX_TYPE_DEPTH) {
+      return '…';
+    }
+    return serializeTypeInner(type, ctx);
+  } finally {
+    ctx.depth -= 1;
+  }
+}
+
+function serializeTypeInner(type: ts.Type, ctx: SerCtx): unknown {
+  const { checker } = ctx;
+
+  if (type.flags & ts.TypeFlags.TypeParameter) {
+    return safeTypeToString(checker, type);
+  }
+
+  if (
+    type.flags &
+    (ts.TypeFlags.String |
+      ts.TypeFlags.Number |
+      ts.TypeFlags.Boolean |
+      ts.TypeFlags.Null |
+      ts.TypeFlags.Undefined |
+      ts.TypeFlags.Void |
+      ts.TypeFlags.Never |
+      ts.TypeFlags.ESSymbol |
+      ts.TypeFlags.BigInt)
+  ) {
+    return safeTypeToString(checker, type);
+  }
+
+  if (type.flags & ts.TypeFlags.Any || type.flags & ts.TypeFlags.Unknown) {
+    return safeTypeToString(checker, type);
+  }
+
+  if (type.flags & ts.TypeFlags.Literal) {
+    return safeTypeToString(checker, type);
+  }
+
+  if (type.flags & ts.TypeFlags.Intersection) {
+    const inter = type as ts.IntersectionType;
+    const parts = inter.types.map((t) => serializeType(t, ctx));
+    if (parts.every((p) => p !== null && typeof p === 'object' && !Array.isArray(p))) {
+      return Object.assign({}, ...(parts as Record<string, unknown>[]));
+    }
+    return safeTypeToString(checker, type);
+  }
+
+  if (type.isUnion()) {
+    return safeTypeToString(checker, type);
+  }
+
+  if (registerIfTopLevelDeclaration(type, ctx)) {
+    return safeTypeToString(checker, type);
+  }
+
+  const callSigs = type.getCallSignatures();
+  if (callSigs.length > 0 && checker.getPropertiesOfType(type).length === 0) {
+    const sig = callSigs[callSigs.length - 1];
+    return serializeMethodSignature(
+      sig,
+      {
+        checker: ctx.checker,
+        sourceFile: ctx.sourceFile,
+        top: ctx.top,
+        deps: ctx.deps,
+        depth: ctx.depth,
+      },
+      ctx.expanding
+    );
+  }
+
+  const sym = type.getSymbol();
+
+  if (sym && sym.flags & ts.SymbolFlags.EnumMember) {
+    return safeTypeToString(checker, type);
+  }
+
+  const elem = tryArrayElementType(type, checker);
+  if (elem) {
+    if (registerIfTopLevelDeclaration(elem, ctx)) {
+      return { '[]': safeTypeToString(checker, elem) };
+    }
+    return { '[]': serializeType(elem, ctx) };
+  }
+
+  if (checker.isTupleType(type)) {
+    const ref = type as ts.TypeReference;
+    const args = checker.getTypeArguments(ref);
+    return {
+      __tuple: args.map((t) =>
+        registerIfTopLevelDeclaration(t, ctx) ? safeTypeToString(checker, t) : serializeType(t, ctx)
+      ),
+    };
+  }
+
+  const typeRef = type as ts.TypeReference;
+  const targetSym = typeRef.target?.symbol ?? typeRef.aliasSymbol ?? sym;
+  if (targetSym?.name === 'Promise' && checker.getTypeArguments(typeRef).length >= 1) {
+    const args = checker.getTypeArguments(typeRef);
+    const inner = args[0];
+    if (registerIfTopLevelDeclaration(inner, ctx)) {
+      return `Promise<${safeTypeToString(checker, inner)}>`;
+    }
+    const body = serializeType(inner, ctx);
+    return typeof body === 'string' ? `Promise<${body}>` : { __promise: body };
+  }
+
+  if (isPlainObjectType(type, checker)) {
+    return expandObjectProperties(type, ctx);
+  }
+
+  return safeTypeToString(checker, type);
+}
+
+function expandObjectProperties(type: ts.Type, ctx: SerCtx): Record<string, unknown> {
+  const { checker } = ctx;
+  const out: Record<string, unknown> = {};
+  for (const prop of checker.getPropertiesOfType(type)) {
+    const n = prop.getName();
+    if (n.startsWith('__')) continue;
+    const pt = checker.getTypeOfSymbol(prop);
+    out[n] = serializeType(pt, ctx);
+  }
+  return out;
+}
+
+function serializeMethodSignature(
+  sig: ts.Signature,
+  base: Omit<SerCtx, 'expanding'>,
+  expanding: Set<string>
+): { parameters: Record<string, unknown>; returnType: unknown } {
+  const ctx: SerCtx = { ...base, expanding };
+  const parameters: Record<string, unknown> = {};
+  for (const p of sig.getParameters()) {
+    if (p.name === 'this') continue;
+    const t = ctx.checker.getTypeOfSymbol(p);
+    parameters[p.name] = serializeType(t, ctx);
+  }
+  const ret = ctx.checker.getReturnTypeOfSignature(sig);
+  return { parameters, returnType: serializeType(ret, ctx) };
+}
+
+export function batchGetMethodsFull(items: BatchMethodsItem[]): BatchMethodsFullResult {
+  const apiPath = resolveKdsApiDtsPath();
+  const program = ts.createProgram([apiPath], {
+    target: ts.ScriptTarget.Latest,
+    skipLibCheck: true,
+    allowJs: false,
+  });
+  const checker = program.getTypeChecker();
+  const sf = program.getSourceFile(apiPath);
+  if (!sf) {
+    throw new Error(`无法加载源文件：${apiPath}`);
+  }
+
+  const top = buildTopMaps(sf);
+
+  const deps: DepState = {
+    consts: new Map(),
+    interfaces: new Map(),
+    types: new Map(),
+    enums: new Map(),
+  };
+
+  const full: BatchMethodsFullResult['full'] = [];
+  const expandingRoot = new Set<string>();
+  const baseCtx = { checker, sourceFile: sf, top, deps, depth: 0 };
+
+  for (const item of items) {
+    const ifaceName = item.interface;
+    const ifaceNode = top.interfaces.get(ifaceName) ?? top.classes.get(ifaceName);
+    if (!ifaceNode) {
+      throw new Error(`未找到 interface/class：${ifaceName}`);
+    }
+
+    const ifaceType = checker.getTypeAtLocation(ifaceNode);
+    const methodsOut: BatchMethodsFullResult['full'][0]['methods'] = [];
+    const relations = getInterfaceLikeRelations(ifaceNode, sf);
+
+    for (const methodName of item.methods) {
+      const prop = ifaceType.getProperty(methodName);
+      if (!prop) {
+        throw new Error(`${ifaceName} 上不存在方法：${methodName}`);
+      }
+      const propType = checker.getTypeOfSymbol(prop);
+      const sigs = propType.getCallSignatures();
+      if (sigs.length === 0) {
+        throw new Error(`${ifaceName}.${methodName} 不是可调用的方法签名`);
+      }
+      const sig = sigs[sigs.length - 1];
+      const { parameters, returnType } = serializeMethodSignature(sig, baseCtx, expandingRoot);
+      const sigDecl = sig.getDeclaration();
+      let methodComments: string | undefined =
+        sigDecl !== undefined ? extractCommentText(sigDecl, sf) : undefined;
+      if (!methodComments?.trim()) {
+        methodComments = extractCommentFromInterfaceMember(ifaceNode, methodName, sf);
+      }
+      const methodEntry: BatchMethodsFullResult['full'][0]['methods'][0] = {
+        name: methodName,
+        parameters,
+        returnType,
+      };
+      if (methodComments?.trim()) {
+        methodEntry.comments = methodComments.trim();
+      }
+      methodsOut.push(methodEntry);
+    }
+
+    full.push({
+      interface: ifaceName,
+      extends: relations.extends,
+      implements: relations.implements,
+      methods: methodsOut,
+    });
+  }
+
+  const sortByName = <T extends { name: string }>(arr: T[]): T[] =>
+    [...arr].sort((a, b) => a.name.localeCompare(b.name));
+
+  return {
+    full,
+    dependencies: {
+      consts: sortByName([...deps.consts.values()]),
+      interfaces: sortByName([...deps.interfaces.values()]),
+      types: sortByName([...deps.types.values()]),
+      enums: sortByName([...deps.enums.values()]),
+    },
+  };
+}

package/src/kds-api-knowledge/batch-search-methods.ts

@@ -0,0 +1,124 @@
+/**
+ * 在 @qunhe/kds-api/api.d.ts 全局 interface/class 上按**方法名字符串**子串检索，
+ * 方法名枚举与 batchGetMethodsFull 一致（含继承合并类型上的可调用成员），命中后调用 batchGetMethodsFull 展开。
+ */
+import ts from 'typescript';
+import type { BatchMethodsFullResult, BatchMethodsItem } from './batch-methods-full.js';
+import { batchGetMethodsFull } from './batch-methods-full.js';
+import { buildTopMaps, resolveKdsApiDtsPath } from './kds-api-dts.js';
+
+export type BatchSearchMethodsOptions = {
+  /** 默认 true：英文大小写不敏感 */
+  caseInsensitive?: boolean;
+};
+
+export type BatchSearchMethodsResult = BatchMethodsFullResult & {
+  keywords: string[];
+  /** 未匹配到任何方法名的关键词（子串匹配） */
+  unmatchedKeywords: string[];
+};
+
+/** 与 batchGetMethodsFull 中 ifaceType.getProperty(name) 所见方法名集合对齐（含继承，排除无调用签名的属性） */
+function listCallableMethodNames(
+  checker: ts.TypeChecker,
+  ifaceNode: ts.InterfaceDeclaration | ts.ClassDeclaration
+): string[] {
+  const ifaceType = checker.getTypeAtLocation(ifaceNode);
+  const names: string[] = [];
+  for (const prop of checker.getPropertiesOfType(ifaceType)) {
+    const methodName = prop.getName();
+    if (methodName.startsWith('__')) continue;
+    const propType = checker.getTypeOfSymbol(prop);
+    if (propType.getCallSignatures().length === 0) continue;
+    names.push(methodName);
+  }
+  return names;
+}
+
+function normalizeQueryKeywords(keywords: string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const raw of keywords) {
+    const t = raw.trim();
+    if (!t || seen.has(t)) continue;
+    seen.add(t);
+    out.push(t);
+  }
+  return out;
+}
+
+export function batchSearchMethodsByKeywords(
+  keywords: string[],
+  options: BatchSearchMethodsOptions = {}
+): BatchSearchMethodsResult {
+  const queryKeywords = normalizeQueryKeywords(keywords);
+  const caseInsensitive = options.caseInsensitive !== false;
+  const apiPath = resolveKdsApiDtsPath();
+  const program = ts.createProgram([apiPath], {
+    target: ts.ScriptTarget.Latest,
+    skipLibCheck: true,
+    allowJs: false,
+  });
+  const checker = program.getTypeChecker();
+  const maybeSf = program.getSourceFile(apiPath);
+  if (maybeSf === undefined) {
+    throw new Error(`无法加载源文件：${apiPath}`);
+  }
+  const sourceFile: ts.SourceFile = maybeSf;
+
+  const top = buildTopMaps(sourceFile);
+  const ifaceEntries: Array<[string, ts.InterfaceDeclaration | ts.ClassDeclaration]> = [
+    ...top.interfaces.entries(),
+    ...top.classes.entries(),
+  ];
+
+  const methodNamesByIface = new Map<string, string[]>();
+  for (const [ifaceName, ifaceNode] of ifaceEntries) {
+    methodNamesByIface.set(ifaceName, listCallableMethodNames(checker, ifaceNode));
+  }
+
+  /** interface -> 命中方法名（去重） */
+  const acc = new Map<string, Set<string>>();
+
+  function addMethod(ifaceName: string, methodName: string): void {
+    let s = acc.get(ifaceName);
+    if (!s) {
+      s = new Set();
+      acc.set(ifaceName, s);
+    }
+    s.add(methodName);
+  }
+
+  const unmatchedKeywords: string[] = [];
+
+  for (const kw of queryKeywords) {
+    const needle = caseInsensitive ? kw.toLowerCase() : kw;
+    let hit = false;
+    for (const [ifaceName, names] of methodNamesByIface) {
+      for (const methodName of names) {
+        const hay = caseInsensitive ? methodName.toLowerCase() : methodName;
+        if (!hay.includes(needle)) continue;
+        hit = true;
+        addMethod(ifaceName, methodName);
+      }
+    }
+    if (!hit) {
+      unmatchedKeywords.push(kw);
+    }
+  }
+
+  const items: BatchMethodsItem[] = [...acc.entries()]
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([iface, names]) => ({
+      interface: iface,
+      methods: [...names].sort((a, b) => a.localeCompare(b)),
+    }));
+
+  const expanded = batchGetMethodsFull(items);
+
+  return {
+    ...expanded,
+    keywords: queryKeywords,
+    unmatchedKeywords,
+  };
+}