mcp-xdx-schema-ctx 1.1.9

package/dist/tools/system-tools.js

@@ -0,0 +1,1102 @@
+import { z } from "zod";
+import { table, envDb } from "../db.js";
+import { T, userName, WARNING, escapeSql, escapeLike, envelope, ok, sqlPagination, topNPagination, } from "../shared.js";
+import { tableNames } from "../config.js";
+import { getTableColumns, getTableInfo, pickCols, hasCol, tableExists, userTableExists, resolveSelect, tryQuery, clearSchemaCache, } from "../schema-compat.js";
+import { buildWhere, buildOrderBy, buildPagedQuery, buildViewLineageSql, } from "../sql-build.js";
+import { computeToolAvailability, USER_DB_PROBE_TABLES, } from "../tool-availability.js";
+export function registerSystemTools(server) {
+    // ============================================================
+    // get_function_tree
+    // ============================================================
+    server.registerTool("get_function_tree", {
+        description: WARNING +
+            "\n\n获取功能菜单树。返回 FunctionTB → FormSetTB 的层级结构，包含菜单类型、关联窗体、前端路由、组件路径。支持按平台(WEB/APP/PDA)过滤。",
+        inputSchema: {
+            keyword: z.string().max(200).optional().describe("按功能名称模糊搜索"),
+            type: z
+                .enum(["menu", "button", "all"])
+                .optional()
+                .default("all")
+                .describe("过滤类型"),
+            platform: z
+                .enum(["WEB", "APP", "PDA"])
+                .optional()
+                .describe("平台过滤: WEB/APP/PDA"),
+            limit: z.number().optional().default(100).describe("返回条数上限"),
+            page: z.number().int().min(1).default(1).describe("页码"),
+            pageSize: z
+                .number()
+                .int()
+                .min(1)
+                .max(200)
+                .default(50)
+                .describe("每页数量"),
+        },
+    }, async ({ keyword, type, platform, page = 1, pageSize = 50 }) => {
+        const warnings = [];
+        if (!(await tableExists(T("function")))) {
+            return ok(envelope({
+                items: [],
+                pagination: sqlPagination(page, pageSize, 0),
+                warnings: [
+                    {
+                        module: "get_function_tree",
+                        message: `环境库缺少 ${T("function")}`,
+                        hint: "可用 get_capabilities 查看本环境支持的元数据表",
+                        fallback: "get_capabilities",
+                    },
+                ],
+            }));
+        }
+        const funcInfo = await getTableInfo(T("function"));
+        const rs = await resolveSelect(T("function"), [
+            "FunctionID",
+            "FunctionName",
+            "Type",
+            "LinkForm",
+            "Component",
+            "Icon",
+            "Path",
+            "ApiPath",
+            "Redirect",
+            "IsHidden",
+            "ParentId",
+            "LevelCode",
+            "WebSort",
+            "PlatformType",
+        ]);
+        if (rs.missing.length > 0) {
+            warnings.push({
+                module: "get_function_tree",
+                message: `以下列在本环境库不存在，已置空: ${rs.missing.join(", ")}`,
+            });
+        }
+        const groups = [];
+        if (keyword)
+            groups.push({
+                filters: [{ col: "FunctionName", op: "like", value: keyword }],
+            });
+        if (type && type !== "all")
+            groups.push({ filters: [{ col: "Type", op: "eq", value: type }] });
+        if (platform)
+            groups.push({
+                filters: [{ col: "PlatformType", op: "eq", value: platform }],
+            });
+        const { where, skipped } = buildWhere(funcInfo.columns, groups);
+        if (skipped.length > 0) {
+            warnings.push({
+                module: "get_function_tree",
+                message: `以下列在本环境库不存在，条件已跳过: ${skipped.join(", ")}`,
+            });
+        }
+        const order = buildOrderBy(funcInfo.columns, ["LevelCode", "WebSort"]);
+        const q = buildPagedQuery({
+            table: T("function"),
+            cols: rs.present.length > 0
+                ? rs.present.map((c) => `[${c}]`)
+                : ["[FunctionID]"],
+            where,
+            orderBy: order.orderBy,
+            page,
+            pageSize,
+        });
+        const cnt = await tryQuery("get_function_tree.count", q.countSql, warnings);
+        const total = Number(cnt[0]?.Total ?? 0);
+        const funcs = total > 0 ? await tryQuery("get_function_tree", q.sql, warnings) : [];
+        const formIds = [
+            ...new Set(funcs
+                .filter((f) => f.LinkForm)
+                .map((f) => `'${escapeSql(String(f.LinkForm))}'`)),
+        ];
+        let forms = [];
+        if (formIds.length > 0 && (await tableExists(T("formDef")))) {
+            const frs = await resolveSelect(T("formDef"), [
+                "FormID",
+                "FormName",
+                "LinkTable",
+                "FormType",
+                "ApiPath",
+                "ServiceType",
+            ]);
+            forms = await tryQuery("get_function_tree.forms", `SELECT ${frs.select} FROM ${T("formDef")} WHERE [FormID] IN (${formIds.join(",")})`, warnings);
+        }
+        let platformStats = [];
+        if (platform && hasCol(funcInfo.columns, "PlatformType")) {
+            platformStats = await tryQuery("get_function_tree.platformStats", `SELECT [PlatformType], COUNT(*) AS cnt FROM ${T("function")} WHERE [PlatformType]='${escapeSql(platform)}' GROUP BY [PlatformType]`, warnings);
+        }
+        return ok(envelope({
+            items: funcs,
+            pagination: sqlPagination(page, pageSize, total),
+            warnings,
+            forms,
+            platformStats,
+        }));
+    });
+    // ============================================================
+    // get_page_actions
+    // ============================================================
+    server.registerTool("get_page_actions", {
+        description: WARNING +
+            "\n\n根据页面Code查询该页面所有可用按钮及功能。MenuFunction 表(28518条)记录了每个页面(Code)可用哪些按钮(ButtonID)和功能(FunctionID)。",
+        inputSchema: {
+            code: z
+                .string()
+                .max(50)
+                .optional()
+                .describe("页面Code，如 ckwhfgoutlist"),
+            functionName: z.string().max(200).optional().describe("按功能名称搜索"),
+            buttonId: z.string().max(50).optional().describe("按按钮ID搜索"),
+            limit: z.number().optional().default(50),
+            page: z.number().int().min(1).default(1).describe("页码"),
+            pageSize: z
+                .number()
+                .int()
+                .min(1)
+                .max(200)
+                .default(50)
+                .describe("每页数量"),
+        },
+    }, async ({ code, functionName, buttonId, page = 1, pageSize = 50 }) => {
+        const warnings = [];
+        if (!(await tableExists(T("menuFunction")))) {
+            return ok(envelope({
+                items: [],
+                pagination: sqlPagination(page, pageSize, 0),
+                warnings: [
+                    {
+                        module: "get_page_actions",
+                        message: `环境库缺少 ${T("menuFunction")}`,
+                        hint: "可用 get_capabilities 查看本环境支持的元数据表",
+                        fallback: "get_capabilities",
+                    },
+                ],
+            }));
+        }
+        const info = await getTableInfo(T("menuFunction"));
+        const rs = await resolveSelect(T("menuFunction"), [
+            "Code",
+            "FunctionID",
+            "FunctionName",
+            "ButtonID",
+            "iLineNo",
+        ]);
+        if (rs.missing.length > 0) {
+            warnings.push({
+                module: "get_page_actions",
+                message: `以下列在本环境库不存在，已置空: ${rs.missing.join(", ")}`,
+            });
+        }
+        const groups = [];
+        if (code)
+            groups.push({ filters: [{ col: "Code", op: "like", value: code }] });
+        if (functionName)
+            groups.push({
+                filters: [{ col: "FunctionName", op: "like", value: functionName }],
+            });
+        if (buttonId)
+            groups.push({ filters: [{ col: "ButtonID", op: "eq", value: buttonId }] });
+        const { where, skipped } = buildWhere(info.columns, groups);
+        if (skipped.length > 0) {
+            warnings.push({
+                module: "get_page_actions",
+                message: `以下列在本环境库不存在，条件已跳过: ${skipped.join(", ")}`,
+            });
+        }
+        const order = buildOrderBy(info.columns, ["Code", "iLineNo"]);
+        const q = buildPagedQuery({
+            table: T("menuFunction"),
+            cols: rs.present.length > 0
+                ? rs.present.map((c) => `[${c}]`)
+                : ["[Code]"],
+            where,
+            orderBy: order.orderBy,
+            page,
+            pageSize,
+        });
+        const cnt = await tryQuery("get_page_actions.count", q.countSql, warnings);
+        const total = Number(cnt[0]?.Total ?? 0);
+        const items = total > 0 ? await tryQuery("get_page_actions", q.sql, warnings) : [];
+        const buttonIds = [
+            ...new Set(items
+                .filter((i) => i.ButtonID)
+                .map((i) => `'${escapeSql(String(i.ButtonID))}'`)),
+        ];
+        let buttons = {
+            module: "buttons",
+            available: true,
+            items: [],
+        };
+        if (buttonIds.length > 0) {
+            if (await tableExists(T("button"))) {
+                const brs = await resolveSelect(T("button"), [
+                    "ButtonID",
+                    "ButtonText",
+                    "ButtonStyle",
+                    "Seq",
+                    "isBatch",
+                    "AuthorityFlag",
+                ]);
+                buttons = {
+                    module: "buttons",
+                    available: true,
+                    items: await tryQuery("get_page_actions.buttons", `SELECT ${brs.select} FROM ${T("button")} WHERE [ButtonID] IN (${buttonIds.join(",")})`, warnings),
+                };
+            }
+            else {
+                buttons = {
+                    module: "buttons",
+                    available: false,
+                    reason: `环境库缺少 ${T("button")}`,
+                };
+                warnings.push({
+                    module: "get_page_actions.buttons",
+                    message: `环境库缺少 ${T("button")}，按钮明细不可用（页面-功能映射仍可用）`,
+                    fallback: "get_capabilities",
+                });
+            }
+        }
+        return ok(envelope({
+            items,
+            pagination: sqlPagination(page, pageSize, total),
+            warnings,
+            buttons,
+        }));
+    });
+    // ============================================================
+    // get_choose_ui_detail
+    // ============================================================
+    server.registerTool("get_choose_ui_detail", {
+        description: WARNING +
+            "\n\n获取UI选择器(下拉框/参照)的配置详情，包括数据源SQL、显示字段、树结构、权限过滤等。ChooseUISetTB(234条)定义了系统中所有弹出选择器的行为。",
+        inputSchema: {
+            name: z.string().max(200).optional().describe("选择器名称"),
+            keyword: z.string().max(200).optional().describe("模糊搜索名称"),
+            page: z.number().int().min(1).default(1).describe("页码"),
+            pageSize: z
+                .number()
+                .int()
+                .min(1)
+                .max(200)
+                .default(50)
+                .describe("每页数量"),
+        },
+    }, async ({ name, keyword, page = 1, pageSize = 50 }) => {
+        const warnings = [];
+        if (!(await tableExists(T("chooseUISet")))) {
+            return ok(envelope({
+                items: [],
+                pagination: sqlPagination(page, pageSize, 0),
+                warnings: [
+                    {
+                        module: "get_choose_ui_detail",
+                        message: `环境库缺少 ${T("chooseUISet")}`,
+                        hint: "可用 get_capabilities 查看本环境支持的元数据表",
+                        fallback: "get_capabilities",
+                    },
+                ],
+            }));
+        }
+        const info = await getTableInfo(T("chooseUISet"));
+        const rs = await resolveSelect(T("chooseUISet"), [
+            "cName",
+            "cFormType",
+            "bMutiChs",
+            "cListSource",
+            "cListShowField",
+            "cListFilter",
+            "cListSort",
+            "cTreeInfo",
+            "cTreeFilter",
+            "cTreeSort",
+            "PrimayKeyField",
+            "cListUniqueKey",
+            "WareRightField",
+            "CustRightField",
+            "ItemKindRightField",
+        ]);
+        if (rs.missing.length > 0) {
+            warnings.push({
+                module: "get_choose_ui_detail",
+                message: `以下列在本环境库不存在，已置空: ${rs.missing.join(", ")}`,
+            });
+        }
+        const groups = [];
+        if (name)
+            groups.push({ filters: [{ col: "cName", op: "eq", value: name }] });
+        if (keyword)
+            groups.push({ filters: [{ col: "cName", op: "like", value: keyword }] });
+        const { where, skipped } = buildWhere(info.columns, groups);
+        if (skipped.length > 0) {
+            warnings.push({
+                module: "get_choose_ui_detail",
+                message: `以下列在本环境库不存在，条件已跳过: ${skipped.join(", ")}`,
+            });
+        }
+        const order = buildOrderBy(info.columns, ["cName"]);
+        const q = buildPagedQuery({
+            table: T("chooseUISet"),
+            cols: rs.present.length > 0
+                ? rs.present.map((c) => `[${c}]`)
+                : ["[cName]"],
+            where,
+            orderBy: order.orderBy,
+            page,
+            pageSize,
+        });
+        const cnt = await tryQuery("get_choose_ui_detail.count", q.countSql, warnings);
+        const total = Number(cnt[0]?.Total ?? 0);
+        const items = total > 0 ? await tryQuery("get_choose_ui_detail", q.sql, warnings) : [];
+        if (rs.missing.length > 0 && items.length === 0) {
+            warnings.push({
+                module: "get_choose_ui_detail",
+                message: `因列缺失(${rs.missing.join(", ")})，过滤条件可能失效，结果可能不完整——无法确定是「确实没有匹配项」还是「条件未生效」`,
+                hint: '可用 describe_table(tableName="ChooseUISetTB") 查看实际字段',
+            });
+        }
+        return ok(envelope({
+            items,
+            pagination: sqlPagination(page, pageSize, total),
+            warnings,
+        }));
+    });
+    // ============================================================
+    // get_button_detail
+    // ============================================================
+    server.registerTool("get_button_detail", {
+        description: WARNING +
+            "\n\n查询按钮的完整定义和所有使用场景。串联: ButtonTB(按钮库10980条)→FormStateSetTB(哪些窗体用了)→MenuFunction(哪些页面用了)。",
+        inputSchema: {
+            buttonId: z
+                .string()
+                .max(50)
+                .optional()
+                .describe("按钮ID，如 add/edit/delete"),
+            keyword: z.string().max(200).optional().describe("按按钮文本模糊搜索"),
+            limit: z.number().optional().default(50),
+            page: z.number().int().min(1).default(1).describe("页码"),
+            pageSize: z
+                .number()
+                .int()
+                .min(1)
+                .max(200)
+                .default(50)
+                .describe("每页数量"),
+        },
+    }, async ({ buttonId, keyword, page = 1, pageSize = 50 }) => {
+        const warnings = [];
+        if (!(await tableExists(T("button")))) {
+            return ok(envelope({
+                items: [],
+                pagination: sqlPagination(page, pageSize, 0),
+                warnings: [
+                    {
+                        module: "get_button_detail",
+                        message: `环境库缺少 ${T("button")}`,
+                        hint: "可用 get_capabilities 查看本环境支持的元数据表",
+                        fallback: "get_capabilities",
+                    },
+                ],
+            }));
+        }
+        const info = await getTableInfo(T("button"));
+        const rs = await resolveSelect(T("button"), [
+            "ButtonID",
+            "ButtonText",
+            "ButtonStyle",
+            "ButtonFunctionType",
+            "Seq",
+            "isBatch",
+            "AuthorityFlag",
+            "FrontFunctionName",
+            "BackFunctionName",
+        ]);
+        if (rs.missing.length > 0) {
+            warnings.push({
+                module: "get_button_detail",
+                message: `以下列在本环境库不存在，已置空: ${rs.missing.join(", ")}`,
+            });
+        }
+        const groups = [];
+        if (buttonId)
+            groups.push({ filters: [{ col: "ButtonID", op: "eq", value: buttonId }] });
+        if (keyword)
+            groups.push({ filters: [{ col: "ButtonText", op: "like", value: keyword }] });
+        const { where, skipped } = buildWhere(info.columns, groups);
+        if (skipped.length > 0) {
+            warnings.push({
+                module: "get_button_detail",
+                message: `以下列在本环境库不存在，条件已跳过: ${skipped.join(", ")}`,
+            });
+        }
+        const order = buildOrderBy(info.columns, ["ButtonID"]);
+        const q = buildPagedQuery({
+            table: T("button"),
+            cols: rs.present.length > 0
+                ? rs.present.map((c) => `[${c}]`)
+                : ["[ButtonID]"],
+            where,
+            orderBy: order.orderBy,
+            page,
+            pageSize,
+        });
+        const cnt = await tryQuery("get_button_detail.count", q.countSql, warnings);
+        const total = Number(cnt[0]?.Total ?? 0);
+        const buttons = total > 0
+            ? (await tryQuery("get_button_detail", q.sql, warnings))
+            : [];
+        const result = [];
+        for (const b of buttons) {
+            const bid = String(b.ButtonID ?? "").replace(/'/g, "''");
+            // FormStateSetTB 可能缺失 → 降级为不可用
+            let formStates = { module: "formStates", available: true, items: [] };
+            if (await tableExists(T("formState"))) {
+                const frs = await resolveSelect(T("formState"), [
+                    "FormID",
+                    "ButtonID",
+                    "ButtonText",
+                    "AddState",
+                    "UpdState",
+                    "AuditState",
+                    "ViewState",
+                ]);
+                formStates = {
+                    module: "formStates",
+                    available: true,
+                    items: await tryQuery("get_button_detail.formStates", `SELECT TOP 20 ${frs.select} FROM ${T("formState")} WHERE [ButtonID]='${bid}'`, warnings),
+                };
+            }
+            else {
+                formStates = {
+                    module: "formStates",
+                    available: false,
+                    reason: `环境库缺少 ${T("formState")}`,
+                };
+                warnings.push({
+                    module: "get_button_detail.formStates",
+                    message: `环境库缺少 ${T("formState")}`,
+                    fallback: "get_capabilities",
+                });
+            }
+            let menuUsage = { module: "menuUsage", available: true, items: [] };
+            if (await tableExists(T("menuFunction"))) {
+                const mrs = await resolveSelect(T("menuFunction"), [
+                    "Code",
+                    "FunctionName",
+                    "ButtonID",
+                ]);
+                menuUsage = {
+                    module: "menuUsage",
+                    available: true,
+                    items: await tryQuery("get_button_detail.menuUsage", `SELECT TOP 20 ${mrs.select} FROM ${T("menuFunction")} WHERE [ButtonID]='${bid}'`, warnings),
+                };
+            }
+            else {
+                menuUsage = {
+                    module: "menuUsage",
+                    available: false,
+                    reason: `环境库缺少 ${T("menuFunction")}`,
+                };
+                warnings.push({
+                    module: "get_button_detail.menuUsage",
+                    message: `环境库缺少 ${T("menuFunction")}`,
+                    fallback: "get_capabilities",
+                });
+            }
+            const formIds = [
+                ...new Set((Array.isArray(formStates.items)
+                    ? formStates.items
+                    : [])
+                    .filter((f) => f.FormID !== undefined && f.FormID !== null)
+                    .map((f) => `'${escapeSql(String(f.FormID))}'`)),
+            ];
+            let forms = [];
+            if (formIds.length > 0 && (await tableExists(T("formDef")))) {
+                const frs2 = await resolveSelect(T("formDef"), [
+                    "FormID",
+                    "FormName",
+                    "LinkTable",
+                    "FormType",
+                ]);
+                forms = await tryQuery("get_button_detail.forms", `SELECT ${frs2.select} FROM ${T("formDef")} WHERE [FormID] IN (${formIds.join(",")})`, warnings);
+            }
+            result.push({ button: b, usedInForms: forms, formStates, menuUsage });
+        }
+        return ok(envelope({
+            items: result,
+            pagination: sqlPagination(page, pageSize, total),
+            warnings,
+        }));
+    });
+    // ============================================================
+    // get_system_enums
+    // ============================================================
+    server.registerTool("get_system_enums", {
+        description: WARNING +
+            "\n\n查询系统内置字典: 链接类型(LinkTypeTB)、操作类型(OperateTypeTB)、功能类型(FunctionKindTB)、用户报表方案(UserReportFindSetTB)。支持按类型筛选或一次返回全部。",
+        inputSchema: {
+            type: z
+                .enum([
+                "linkTypes",
+                "operateTypes",
+                "functionKinds",
+                "reportSchemes",
+                "all",
+            ])
+                .optional()
+                .default("all")
+                .describe("字典类型: linkTypes/operateTypes/functionKinds/reportSchemes/all"),
+            userId: z
+                .string()
+                .max(50)
+                .optional()
+                .describe("按用户ID过滤报表方案(仅 reportSchemes/all 时有效)"),
+            reportId: z
+                .string()
+                .max(128)
+                .optional()
+                .describe("按报表ID过滤(仅 reportSchemes/all 时有效)"),
+        },
+    }, async ({ type, userId, reportId }) => {
+        const warnings = [];
+        const groupMeta = [];
+        const result = {};
+        const want = (t) => type === "all" || type === t;
+        /** 单个字典组：缺表 → available:false；缺列 → NULL 占位 + warning */
+        const enumGroup = async (module, tableRef, wanted, orderSql, alias) => {
+            if (!(await tableExists(tableRef))) {
+                warnings.push({
+                    module,
+                    message: `环境库缺少 ${tableRef}`,
+                    hint: "可用 get_capabilities 查看本环境支持的元数据表",
+                    fallback: "get_capabilities",
+                });
+                const g = {
+                    module,
+                    available: false,
+                    reason: `环境库缺少 ${tableRef}`,
+                };
+                groupMeta.push({ type: module, available: false, reason: g.reason });
+                return g;
+            }
+            const rs = await resolveSelect(tableRef, wanted);
+            if (rs.missing.length > 0) {
+                warnings.push({
+                    module,
+                    message: `以下列在本环境库不存在，已置空: ${rs.missing.join(", ")}`,
+                });
+            }
+            const rows = (await tryQuery(module, `SELECT ${rs.select} FROM ${tableRef}${orderSql}`, warnings));
+            const items = alias ? rows.map(alias) : rows;
+            groupMeta.push({ type: module, available: true, count: items.length });
+            return { module, available: true, items, missing: rs.missing };
+        };
+        if (want("linkTypes")) {
+            result.linkTypes = await enumGroup("linkTypes", T("linkType"), ["iLinkType", "cTypeName", "LinkTypeDesc", "LinkURL", "IconName"], " ORDER BY [iLinkType]", (r) => ({
+                LinkTypeID: r.iLinkType,
+                LinkTypeName: r.cTypeName,
+                LinkTypeDesc: r.LinkTypeDesc,
+                LinkURL: r.LinkURL,
+                IconName: r.IconName,
+            }));
+        }
+        if (want("operateTypes")) {
+            result.operateTypes = await enumGroup("operateTypes", T("operateType"), [
+                "iOperateType",
+                "cOperateName",
+                "OperateTypeDesc",
+                "OperateCode",
+                "IconName",
+            ], " ORDER BY [iOperateType]", (r) => ({
+                OperateTypeID: r.iOperateType,
+                OperateTypeName: r.cOperateName,
+                OperateTypeDesc: r.OperateTypeDesc,
+                OperateCode: r.OperateCode,
+                IconName: r.IconName,
+            }));
+        }
+        if (want("functionKinds")) {
+            result.functionKinds = await enumGroup("functionKinds", T("functionKind"), ["KindID", "KindName", "KindDesc"], " ORDER BY [KindID]");
+        }
+        if (want("reportSchemes")) {
+            const tableRef = T("userReportFind");
+            if (!(await tableExists(tableRef))) {
+                warnings.push({
+                    module: "reportSchemes",
+                    message: `环境库缺少 ${tableRef}`,
+                    hint: "可用 get_capabilities 查看本环境支持的元数据表",
+                    fallback: "get_capabilities",
+                });
+                groupMeta.push({
+                    type: "reportSchemes",
+                    available: false,
+                    reason: `环境库缺少 ${tableRef}`,
+                });
+                result.reportSchemes = {
+                    module: "reportSchemes",
+                    available: false,
+                    reason: `环境库缺少 ${tableRef}`,
+                };
+            }
+            else {
+                const info = await getTableInfo(tableRef);
+                const rs = await resolveSelect(tableRef, [
+                    "XDID",
+                    "FormID",
+                    "UserID",
+                    "FieldName",
+                    "FieldDesc",
+                    "iOrder",
+                    "bVisiable",
+                    "MakeDate",
+                ]);
+                const groups = [];
+                if (reportId)
+                    groups.push({
+                        filters: [{ col: "FormID", op: "eq", value: reportId }],
+                    });
+                if (userId)
+                    groups.push({ filters: [{ col: "UserID", op: "eq", value: userId }] });
+                const { where } = buildWhere(info.columns, groups);
+                const order = buildOrderBy(info.columns, ["FormID", "iOrder"]);
+                const items = await tryQuery("reportSchemes", `SELECT ${rs.select} FROM ${tableRef}${where}${order.orderBy}`, warnings);
+                groupMeta.push({
+                    type: "reportSchemes",
+                    available: true,
+                    count: items.length,
+                });
+                result.reportSchemes = {
+                    module: "reportSchemes",
+                    available: true,
+                    items,
+                    missing: rs.missing,
+                };
+            }
+        }
+        return ok(envelope({
+            items: groupMeta,
+            pagination: null,
+            warnings,
+            ...result,
+        }));
+    });
+    // ============================================================
+    // get_sys_dict
+    // ============================================================
+    server.registerTool("get_sys_dict", {
+        description: WARNING +
+            "\n\n查询系统字典。传 typeName 返回该类型的键值列表+类型描述；不传则返回 SysDbType 分类树+各类型值数量统计。数据来源: XDWmsUser.dbo.SysDbType + SyDbValue",
+        inputSchema: {
+            typeName: z
+                .string()
+                .max(50)
+                .optional()
+                .describe("字典类型名，如 BsSex。不传返回类型分类树"),
+            keyword: z
+                .string()
+                .max(200)
+                .optional()
+                .describe("按编码值/名称模糊搜索"),
+            limit: z
+                .number()
+                .optional()
+                .default(100)
+                .describe("已废弃：本工具已改为 SQL 端分页，请用 page/pageSize"),
+            page: z.number().int().min(1).default(1).describe("页码"),
+            pageSize: z
+                .number()
+                .int()
+                .min(1)
+                .max(200)
+                .default(50)
+                .describe("每页数量"),
+        },
+    }, async ({ typeName, keyword, page = 1, pageSize = 50 }) => {
+        const warnings = [];
+        if (!userName) {
+            return ok(envelope({
+                items: [],
+                pagination: null,
+                warnings: [
+                    {
+                        module: "get_sys_dict",
+                        message: "用户库未配置(DB_TARGET_DATABASES 为空)",
+                    },
+                ],
+            }));
+        }
+        // 用户库字典表字段因环境而异(如 IsDelete)，先取实际列再拼 SQL
+        const syDbValueRef = table(userName, "SyDbValue");
+        const sysDbTypeRef = table(userName, "SysDbType");
+        const syDbValueCols = await getTableColumns(syDbValueRef);
+        const sysDbTypeCols = await getTableColumns(sysDbTypeRef);
+        if (typeName) {
+            const vCols = pickCols(syDbValueCols, [
+                "XDID",
+                "ParentType",
+                "cCodeValue",
+                "cCodeName",
+                "Remark",
+                "Sort",
+                "ILineNo",
+                "ParentXDID",
+                "Level",
+                "LevelPath",
+                "IsStop",
+            ]);
+            if (vCols.length === 0) {
+                return ok(envelope({
+                    items: [],
+                    pagination: sqlPagination(page, pageSize, 0),
+                    warnings: [
+                        { module: "get_sys_dict", message: "SyDbValue 无可用字段" },
+                    ],
+                    typeName,
+                    typeInfos: [],
+                    totalValues: 0,
+                }));
+            }
+            const groups = [];
+            if (hasCol(syDbValueCols, "ParentType")) {
+                groups.push({
+                    filters: [{ col: "ParentType", op: "eq", value: typeName }],
+                });
+            }
+            else {
+                warnings.push({
+                    module: "get_sys_dict",
+                    message: "SyDbValue 缺少 ParentType 列，typeName 过滤无法下推，返回的是全部字典值",
+                    hint: "可用 describe_table 查看用户库 SyDbValue 的实际字段",
+                });
+            }
+            if (keyword) {
+                const filters = ["cCodeValue", "cCodeName", "Remark"]
+                    .filter((c) => hasCol(syDbValueCols, c))
+                    .map((c) => ({ col: c, op: "like", value: keyword }));
+                if (filters.length > 0)
+                    groups.push({ logic: "or", filters });
+            }
+            if (hasCol(syDbValueCols, "IsDelete"))
+                groups.push({ filters: [{ col: "IsDelete", op: "eq", value: "0" }] });
+            const { where, skipped } = buildWhere(syDbValueCols, groups);
+            const order = buildOrderBy(syDbValueCols, [
+                { col: "Sort", expr: "ISNULL([Sort],9999)" },
+                { col: "ILineNo", expr: "[ILineNo]" },
+            ]);
+            if (skipped.length > 0) {
+                warnings.push({
+                    module: "get_sys_dict",
+                    message: `以下列在本环境库不存在，条件已跳过: ${skipped.join(", ")}`,
+                });
+            }
+            const q = buildPagedQuery({
+                table: syDbValueRef,
+                cols: vCols,
+                where,
+                orderBy: order.orderBy,
+                page,
+                pageSize,
+            });
+            const cnt = await tryQuery("get_sys_dict.values.count", q.countSql, warnings);
+            const total = Number(cnt[0]?.Total ?? 0);
+            const values = total > 0 ? await tryQuery("get_sys_dict.values", q.sql, warnings) : [];
+            const tCols = pickCols(sysDbTypeCols, [
+                "TypeName",
+                "TypeDesc",
+                "ParentType",
+            ]);
+            const typeInfos = tCols.length > 0
+                ? await tryQuery("get_sys_dict.typeInfos", `SELECT ${tCols.map((c) => `[${c}]`).join(", ")} FROM ${sysDbTypeRef} WHERE [TypeName]='${escapeSql(typeName)}'`, warnings)
+                : [];
+            return ok(envelope({
+                items: values,
+                pagination: sqlPagination(page, pageSize, total),
+                warnings,
+                typeName,
+                typeInfos,
+                totalValues: total,
+            }));
+        }
+        // 无 typeName：返回类型分类树 + 各类型值数量
+        const tCols = pickCols(sysDbTypeCols, [
+            "TypeName",
+            "TypeDesc",
+            "ParentType",
+            "bUser",
+        ]);
+        if (tCols.length === 0) {
+            return ok(envelope({
+                items: [],
+                pagination: sqlPagination(page, pageSize, 0),
+                warnings: [
+                    { module: "get_sys_dict", message: "SysDbType 无可用字段" },
+                ],
+                totalTypes: 0,
+            }));
+        }
+        const groups = [];
+        if (keyword) {
+            const filters = ["TypeName", "TypeDesc"]
+                .filter((c) => hasCol(sysDbTypeCols, c))
+                .map((c) => ({ col: c, op: "like", value: keyword }));
+            if (filters.length > 0)
+                groups.push({ logic: "or", filters });
+        }
+        if (hasCol(sysDbTypeCols, "IsDelete"))
+            groups.push({ filters: [{ col: "IsDelete", op: "eq", value: "0" }] });
+        const { where } = buildWhere(sysDbTypeCols, groups);
+        const order = buildOrderBy(sysDbTypeCols, [
+            { col: "ParentType", expr: "ISNULL([ParentType],'')" },
+            { col: "TypeName", expr: "[TypeName]" },
+        ]);
+        const q = buildPagedQuery({
+            table: sysDbTypeRef,
+            cols: tCols,
+            where,
+            orderBy: order.orderBy,
+            page,
+            pageSize,
+        });
+        const cnt = await tryQuery("get_sys_dict.types.count", q.countSql, warnings);
+        const total = Number(cnt[0]?.Total ?? 0);
+        const types = total > 0 ? await tryQuery("get_sys_dict.types", q.sql, warnings) : [];
+        const typeNames = hasCol(sysDbTypeCols, "TypeName")
+            ? types
+                .map((t) => `'${escapeSql(String(t.TypeName))}'`)
+                .join(",")
+            : "";
+        let valueCounts = [];
+        if (typeNames && hasCol(syDbValueCols, "ParentType")) {
+            let countSql = `SELECT [ParentType], COUNT(*) AS valueCount FROM ${syDbValueRef} WHERE [ParentType] IN (${typeNames})`;
+            if (hasCol(syDbValueCols, "IsDelete"))
+                countSql += " AND [IsDelete]=0";
+            countSql += " GROUP BY [ParentType]";
+            valueCounts = await tryQuery("get_sys_dict.valueCounts", countSql, warnings);
+        }
+        return ok(envelope({
+            items: types,
+            pagination: sqlPagination(page, pageSize, total),
+            warnings,
+            valueCounts,
+            totalTypes: total,
+        }));
+    });
+    // ============================================================
+    // get_db_object_source
+    // ============================================================
+    server.registerTool("get_db_object_source", {
+        description: WARNING +
+            "\n\n查询用户库的视图/存储过程/函数完整定义（CREATE SQL 正文），支持按类型过滤、按名称精确或模糊搜索，SQL 端分页。数据来源: 用户库 sys.objects + sys.sql_modules。",
+        inputSchema: {
+            objectType: z
+                .enum(["view", "procedure", "function", "all"])
+                .optional()
+                .default("all")
+                .describe("view=视图 / procedure=存储过程 / function=函数(标量+表值) / all=全部"),
+            name: z
+                .string()
+                .max(128)
+                .optional()
+                .describe("对象精确名称（如 v_SaleOrder）"),
+            keyword: z
+                .string()
+                .max(200)
+                .optional()
+                .describe("按对象名模糊搜索（% _ [ ] 按普通字符处理）"),
+            includeDefinition: z
+                .boolean()
+                .optional()
+                .describe("是否返回 CREATE SQL 正文（默认：仅当传了 name 精确查询时为 true，列表模式为 false，避免输出被截断）"),
+            page: z.number().int().min(1).default(1).describe("页码"),
+            pageSize: z
+                .number()
+                .int()
+                .min(1)
+                .max(200)
+                .default(50)
+                .describe("每页数量"),
+        },
+    }, async ({ objectType, name, keyword, includeDefinition, page = 1, pageSize = 50, }) => {
+        const warnings = [];
+        if (!userName) {
+            return ok(envelope({
+                items: [],
+                pagination: null,
+                warnings: [
+                    {
+                        module: "get_db_object_source",
+                        message: "用户库未配置(DB_TARGET_DATABASES 为空)",
+                    },
+                ],
+            }));
+        }
+        const typeMap = {
+            view: ["V"],
+            procedure: ["P"],
+            function: ["FN", "IF", "TF"],
+        };
+        const types = objectType === "all"
+            ? ["V", "P", "FN", "IF", "TF"]
+            : typeMap[objectType] ?? ["V", "P", "FN", "IF", "TF"];
+        const typeList = types.map((t) => `'${t}'`).join(",");
+        const withDefinition = includeDefinition === true || (!!name && includeDefinition !== false);
+        let where = `WHERE o.is_ms_shipped = 0 AND o.type IN (${typeList})`;
+        if (name)
+            where += ` AND o.name = N'${escapeSql(name)}'`;
+        if (keyword)
+            where += ` AND o.name LIKE N'%${escapeLike(keyword)}%' ESCAPE '\\'`;
+        const base = `FROM [${userName}].sys.objects o INNER JOIN [${userName}].sys.sql_modules m ON o.object_id = m.object_id ${where}`;
+        const countRows = await tryQuery("get_db_object_source.count", `SELECT COUNT(*) AS Total ${base}`, warnings);
+        const total = Number(countRows[0]?.Total ?? 0);
+        const offset = (page - 1) * pageSize;
+        const metaCols = "o.name AS ObjectName, SCHEMA_NAME(o.schema_id) AS SchemaName, o.type AS ObjectType, o.type_desc AS ObjectTypeDesc, o.create_date AS CreateDate, o.modify_date AS ModifyDate, LEN(m.definition) AS DefinitionLength";
+        const sql = `SELECT ${metaCols}${withDefinition ? ", m.definition AS Definition" : ""} ${base} ORDER BY o.type, SCHEMA_NAME(o.schema_id), o.name OFFSET ${offset} ROWS FETCH NEXT ${pageSize} ROWS ONLY`;
+        const items = total > 0
+            ? await tryQuery("get_db_object_source", sql, warnings)
+            : [];
+        return ok(envelope({
+            items,
+            pagination: sqlPagination(page, pageSize, total),
+            warnings,
+            objectType,
+            userDb: userName,
+            totalObjects: total,
+            definitionIncluded: withDefinition,
+        }));
+    });
+    // ============================================================
+    // get_capabilities（能力自描述 — 探测本环境实际支持的元数据表）
+    // ============================================================
+    server.registerTool("get_capabilities", {
+        description: WARNING +
+            "\n\n【能力自描述】探测当前环境库实际支持的元数据表与各工具可用性。首次诊断、或遇到「缺表/缺列」时建议先调用本工具，避免盲目试错。",
+        inputSchema: {
+            refresh: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("清空 schema 缓存后重新探测"),
+        },
+    }, async ({ refresh }) => {
+        const warnings = [];
+        if (refresh)
+            clearSchemaCache();
+        const probedTables = {};
+        const keys = Object.keys(tableNames);
+        await Promise.all(keys.map(async (k) => {
+            probedTables[tableNames[k]] = await tableExists(T(k));
+        }));
+        let userDbReachable = false;
+        if (userName) {
+            const rows = await tryQuery("get_capabilities.userDb", `SELECT DB_ID('${userName.replace(/'/g, "''")}') AS id`, warnings);
+            userDbReachable = Number(rows[0]?.id ?? 0) > 0;
+        }
+        // 用户库表探测（如 get_sys_dict 依赖的 SysDbType/SyDbValue 在用户库）
+        const userTables = {};
+        if (userName && userDbReachable) {
+            await Promise.all(USER_DB_PROBE_TABLES.map(async (t) => {
+                userTables[t] = await userTableExists(userName, t);
+            }));
+        }
+        const items = computeToolAvailability({
+            tables: probedTables,
+            userTables,
+            userDbConfigured: !!userName,
+            userDbReachable,
+        });
+        const presentTables = Object.entries(probedTables)
+            .filter(([, v]) => v)
+            .map(([k]) => k);
+        return ok(envelope({
+            items,
+            pagination: null,
+            warnings,
+            env: {
+                serverDatabase: envDb(),
+                userDatabase: userName || null,
+                userDatabaseReachable: userDbReachable,
+                presentTableCount: presentTables.length,
+                probedTableCount: keys.length,
+            },
+            presentTables,
+            probedTables,
+        }));
+    });
+    // ============================================================
+    // get_view_lineage（视图/对象血缘 — 递归 CTE）
+    // ============================================================
+    server.registerTool("get_view_lineage", {
+        description: WARNING +
+            "\n\n追踪视图/对象的依赖血缘（基于用户库 sys.sql_expression_dependencies 递归展开）。返回 level/objectName/objectType/parent 的依赖链，便于理解视图由哪些表/视图构成。",
+        inputSchema: {
+            name: z.string().max(128).describe("视图/对象名，如 vwAboutOut"),
+            maxDepth: z
+                .number()
+                .int()
+                .min(1)
+                .max(10)
+                .default(5)
+                .describe("递归深度（1..10）"),
+        },
+    }, async ({ name, maxDepth = 5 }) => {
+        const warnings = [];
+        if (!userName) {
+            return ok(envelope({
+                items: [],
+                pagination: null,
+                warnings: [
+                    {
+                        module: "get_view_lineage",
+                        message: "用户库未配置(DB_TARGET_DATABASES 为空)",
+                    },
+                ],
+            }));
+        }
+        const safeName = name.replace(/[^a-zA-Z0-9_]/g, "");
+        if (!safeName) {
+            return ok(envelope({
+                items: [],
+                pagination: null,
+                warnings: [
+                    {
+                        module: "get_view_lineage",
+                        message: `对象名 "${name}" 非法（仅允许字母/数字/下划线）`,
+                    },
+                ],
+            }));
+        }
+        const sql = buildViewLineageSql({
+            db: userName,
+            name: safeName,
+            maxDepth,
+        });
+        const rows = await tryQuery("get_view_lineage", sql, warnings);
+        const items = rows.map((r) => ({
+            level: Number(r.lvl),
+            objectName: r.objectName,
+            objectType: r.objectType,
+            parent: r.parentName,
+        }));
+        if (items.length === 0 && warnings.length === 0) {
+            warnings.push({
+                module: "get_view_lineage",
+                message: `未找到 "${safeName}" 的依赖，或该对象没有依赖记录`,
+                hint: "可用 get_db_object_source(name=...) 确认对象是否存在",
+                fallback: "get_db_object_source",
+            });
+        }
+        const tree = {};
+        for (const it of items)
+            (tree[it.level] ??= []).push(it);
+        return ok(envelope({
+            items,
+            pagination: topNPagination(500, items.length),
+            warnings,
+            root: safeName,
+            userDb: userName,
+            maxDepth,
+            tree,
+        }));
+    });
+}
+//# sourceMappingURL=system-tools.js.map