weaver-work-cli 0.1.2 → 0.1.5

package/dist/shortcuts/plan/manifest.js

@@ -0,0 +1,53 @@
+import { planOperationDefinitions } from './operations/registry.js';
+/**
+ * 禁用边界：源资料未提供以下能力的实现依据，因此不生成对应 operation，或只能限定在某一链路。
+ * - eb 链路「撤回报告」为 ESB 动作流，源资料未给出动作流唯一标识（uniqueIndent）。
+ * - eb 链路未提供报告提交提醒、报告评论接口。
+ */
+const WITHHELD = [
+    {
+        name: 'plan.report.withdraw.eb',
+        reason: 'eb 链路撤回报告通过 ESB 动作流「eb撤回报告」实现，源资料未提供动作流 uniqueIndent，无法在本模块内触发；改由 weaver-e10-customesb-execute skill 执行同名动作流',
+    },
+    {
+        name: 'plan.report.remind.eb',
+        reason: 'eb 链路报告提交提醒接口未在源资料中给出，plan.report.remind.* 仅支持标准版链路',
+    },
+    {
+        name: 'plan.comment.list.eb',
+        reason: 'eb 链路报告评论接口未在源资料中给出，plan.comment.list 仅支持标准版链路',
+    },
+];
+function buildOperations() {
+    return planOperationDefinitions().map((definition) => ({
+        name: definition.name,
+        resource: definition.resource,
+        summary: definition.summary,
+        ...(definition.capability ? { capability: definition.capability } : {}),
+        risk: definition.risk,
+        ...(definition.requiresConfirmation ? { requiresConfirmation: true } : {}),
+        inputSchema: definition.inputSchema,
+    }));
+}
+export const planManifest = {
+    schemaVersion: 1,
+    name: 'plan',
+    title: '泛微E10计划报告（报告查询/新建/修改/发布/撤回/提交提醒/评论）',
+    version: '0.1.0',
+    host: 'e10-plan',
+    status: 'builtin',
+    sourceSkill: 'weaver-e10-plan',
+    capabilities: ['plan'],
+    /** 报告侧接口链路路由：先读租户缓存（1 天），未命中调用 plan_searchAppver 读取 ver_name。 */
+    linkRouting: {
+        versionInterface: 'plan_searchAppver',
+        versionField: 'ver_name',
+        ebWhen: 'V2',
+        cacheKeyPrefix: 'plan:version:',
+        cacheTtlSeconds: 86400,
+        ebFormTag: 'uf_plan_work_report',
+        ebAppTag: 'weaver-wrplan-eb',
+    },
+    operations: buildOperations(),
+    withheldOperations: WITHHELD,
+};

package/dist/shortcuts/plan/operations/link.js

@@ -0,0 +1,256 @@
+import { isPlanErrorType, planApiError } from '../errors.js';
+import { businessMessage, isDatajsonSuccess } from '../host.js';
+import { compact, ebMainTables, normalizeEbReport, normalizeStandardReport, optionValue, } from './shared.js';
+const PLAN_APP_TAG = 'weaver-wrplan-eb';
+export const PLAN_EB_FORM_TAG = 'uf_plan_work_report';
+const VERSION_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+/** 源资料固定映射：租户 tt1pa2w2i3 的报告详情 eb 表单 id（idobjId）无需动态获取。 */
+const EB_FORM_ID_FIXED = {
+    tt1pa2w2i3: '1029659181695361024',
+};
+export function versionCacheKey(tenantKey) {
+    return `plan:version:${tenantKey}`;
+}
+export function ebFormCacheKey(tenantKey) {
+    return `plan:ebform:${tenantKey}`;
+}
+/**
+ * 版本路由：优先读租户缓存（1 天），未命中则调用 plan_searchAppver 读取 ver_name。
+ * `ver_name === 'V2'` → e10-ebuilder 链路；其它情况 → e10 标准版链路。
+ * 只有真正拿到版本答案时才写缓存；接口不可用时降级为标准版并提示，不写缓存。
+ */
+export async function resolveLink(host, options = {}) {
+    const session = await host.getSession();
+    const key = versionCacheKey(session.tenantKey);
+    if (!options.refresh) {
+        const cached = await host.getCache(key);
+        const value = cached && typeof cached === 'object' ? cached : null;
+        if (value && (value.link === 'standard' || value.link === 'eb')) {
+            return {
+                link: value.link,
+                verName: value.verName ?? null,
+                tenantKey: session.tenantKey,
+                cached: true,
+                degraded: false,
+                reason: null,
+                checkedAt: typeof value.checkedAt === 'string' ? value.checkedAt : new Date().toISOString(),
+            };
+        }
+    }
+    let verName = null;
+    let degraded = false;
+    let reason = null;
+    try {
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/ebuilder/form/formdata/v2/getFormDataList/plan_searchAppver',
+            operation: 'plan.version.check',
+            body: {
+                datajson: {
+                    mainTable: {},
+                    pageInfo: { pageNo: '1', pageSize: '10' },
+                    header: { operator: session.userId },
+                },
+            },
+        });
+        const mainTable = ebMainTables(response)[0];
+        verName = optionValue(mainTable?.ver_name) ?? null;
+    }
+    catch (error) {
+        if (isPlanErrorType(error, 'api')) {
+            degraded = true;
+            reason = error.message;
+        }
+        else {
+            throw error;
+        }
+    }
+    const link = verName === 'V2' ? 'eb' : 'standard';
+    const info = {
+        link,
+        verName,
+        tenantKey: session.tenantKey,
+        cached: false,
+        degraded,
+        reason,
+        checkedAt: new Date().toISOString(),
+    };
+    if (!degraded)
+        await host.setCache(key, info, VERSION_CACHE_TTL_MS);
+    return info;
+}
+function firstId(value) {
+    if (Array.isArray(value) && value.length > 0) {
+        const first = value[0];
+        if (typeof first === 'string' || typeof first === 'number')
+            return String(first);
+        if (first && typeof first === 'object') {
+            const record = first;
+            const candidate = record.id ?? record.idobjId ?? record.objId ?? record.value;
+            if (candidate !== undefined && candidate !== null && candidate !== '')
+                return String(candidate);
+        }
+    }
+    if (typeof value === 'string' || typeof value === 'number')
+        return String(value);
+    return undefined;
+}
+/** 获取 eb 报告详情页所需的表单 id（源资料：eb 表单 id 指 idobjId）。 */
+export async function resolveEbFormId(host) {
+    const session = await host.getSession();
+    const fixed = EB_FORM_ID_FIXED[session.tenantKey];
+    const templateOf = (idobjId) => `/sp/ebdfpage/card/0/${idobjId}/{reportId}`;
+    if (fixed) {
+        return {
+            appTag: PLAN_APP_TAG,
+            appId: null,
+            formTag: PLAN_EB_FORM_TAG,
+            idobjId: fixed,
+            source: 'fixed',
+            detailUrlTemplate: templateOf(fixed),
+        };
+    }
+    const key = ebFormCacheKey(session.tenantKey);
+    const cached = await host.getCache(key);
+    const cachedValue = cached && typeof cached === 'object' ? cached : null;
+    if (cachedValue && typeof cachedValue.idobjId === 'string' && cachedValue.idobjId) {
+        return {
+            appTag: PLAN_APP_TAG,
+            appId: typeof cachedValue.appId === 'string' ? cachedValue.appId : null,
+            formTag: PLAN_EB_FORM_TAG,
+            idobjId: cachedValue.idobjId,
+            source: 'cache',
+            detailUrlTemplate: templateOf(cachedValue.idobjId),
+        };
+    }
+    const appIdsResponse = await host.request({
+        method: 'GET',
+        path: '/api/bs/ebuilder/app/tags/getAppIds',
+        query: { tag: PLAN_APP_TAG },
+        operation: 'plan.eb.form.resolve',
+    }).catch(() => undefined);
+    const appId = firstId(appIdsResponse?.data);
+    if (!appId) {
+        throw planApiError('eb_app_not_found', '未检测到「计划报告」ebuilder 应用（appTag: weaver-wrplan-eb），无法生成报告详情页链接');
+    }
+    const formResponse = await host.request({
+        method: 'GET',
+        path: '/api/ebuilder/form/obj/getObjsByTag',
+        query: { tag: PLAN_EB_FORM_TAG, appId },
+        operation: 'plan.eb.form.resolve',
+    }).catch(() => undefined);
+    const idobjId = firstId(formResponse?.data);
+    if (!idobjId) {
+        throw planApiError('eb_form_not_found', '未找到报告详情 ebuilder 表单（tag: uf_plan_work_report），无法生成报告详情页链接');
+    }
+    const info = {
+        appTag: PLAN_APP_TAG,
+        appId,
+        formTag: PLAN_EB_FORM_TAG,
+        idobjId,
+        source: 'dynamic',
+        detailUrlTemplate: templateOf(idobjId),
+    };
+    // 源资料：取得当前租户报告详情 eb 表单 id 后长期缓存，后续不再动态获取。
+    await host.setCache(key, { appId, idobjId });
+    return info;
+}
+/** 生成报告详情页链接：标准版 /sp/plan/detail/{id}；eb 版 /sp/ebdfpage/card/0/{表单id}/{id}。 */
+export async function buildDetailUrl(host, link, reportId) {
+    if (!reportId)
+        return null;
+    if (link === 'standard')
+        return `/sp/plan/detail/${reportId}`;
+    const form = await resolveEbFormId(host);
+    return `/sp/ebdfpage/card/0/${form.idobjId}/${reportId}`;
+}
+function hasOwn(value, key) {
+    return Boolean(value && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, key));
+}
+/**
+ * 查询单个报告详情。
+ * 标准版：POST /api/workrelate/plan/workreport/view，按 id 或按周期（year+serialNumber+type+creatorUserId）。
+ * eb 版：POST plan_queryPlan，只支持按周期（creator+f_year+f_type+f_serial_number）。
+ */
+export async function lookupReport(host, link, query) {
+    const session = await host.getSession();
+    const warnings = [];
+    if (query.id) {
+        if (link === 'standard') {
+            const response = await host.request({
+                method: 'POST',
+                path: '/api/workrelate/plan/workreport/view',
+                query: { id: query.id },
+                operation: 'plan.report.get',
+            });
+            const hasReport = Boolean(hasOwn(response, 'workReport') && response.workReport);
+            const report = hasReport
+                ? normalizeStandardReport(response.workReport, await buildDetailUrl(host, 'standard', query.id))
+                : null;
+            return { link, exists: hasReport, report, precheck: 'checked', warnings };
+        }
+        // eb 版没有按 id 查询的详情接口：能拿到周期信息时用周期查询做一次校验，否则跳过预检。
+        if (query.year === undefined || !query.type || query.serialNumber === undefined) {
+            warnings.push('eb 链路没有按报告 id 查询详情的接口，缺少 year/type/serialNumber 时无法做写入前校验');
+            return { link, exists: null, report: null, precheck: 'skipped', warnings };
+        }
+        const byPeriod = await lookupReport(host, 'eb', {
+            year: query.year,
+            type: query.type,
+            serialNumber: query.serialNumber,
+            creatorUserId: query.creatorUserId,
+        });
+        if (byPeriod.report && byPeriod.report.reportId && byPeriod.report.reportId !== query.id) {
+            warnings.push(`按周期查询到的报告 id（${byPeriod.report.reportId}）与传入的 id（${query.id}）不一致`);
+            return { link, exists: false, report: null, precheck: 'checked', warnings };
+        }
+        return { ...byPeriod, warnings: [...warnings, ...byPeriod.warnings] };
+    }
+    if (query.year === undefined || !query.type || query.serialNumber === undefined) {
+        throw planApiError('lookup_incomplete', '按周期查询报告详情必须同时提供 year、type、serialNumber');
+    }
+    const creator = query.creatorUserId || session.userId;
+    if (link === 'standard') {
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/workrelate/plan/workreport/view',
+            query: {
+                year: query.year,
+                serialNumber: query.serialNumber,
+                type: query.type,
+                creatorUserId: creator,
+            },
+            operation: 'plan.report.get',
+        });
+        const hasReport = Boolean(hasOwn(response, 'workReport') && response.workReport);
+        const report = hasReport
+            ? normalizeStandardReport(response.workReport, await buildDetailUrl(host, 'standard', String(response.workReport.id ?? '')))
+            : null;
+        return { link, exists: hasReport, report, precheck: 'checked', warnings };
+    }
+    const response = await host.request({
+        method: 'POST',
+        path: '/api/ebuilder/form/formdata/v2/getFormDataByPk/plan_queryPlan',
+        operation: 'plan.report.get',
+        body: {
+            datajson: {
+                mainTable: compact({
+                    creator,
+                    f_year: query.year,
+                    f_type: query.type,
+                    f_serial_number: query.serialNumber,
+                }),
+                header: { operator: session.userId },
+            },
+        },
+    });
+    if (!isDatajsonSuccess(response)) {
+        throw planApiError('business_error', businessMessage(response), { response: businessMessage(response) });
+    }
+    const mainTable = ebMainTables(response)[0];
+    const exists = Boolean(mainTable && mainTable.id);
+    const report = exists
+        ? normalizeEbReport(mainTable, await buildDetailUrl(host, 'eb', String(mainTable.id)))
+        : null;
+    return { link, exists, report, precheck: 'checked', warnings };
+}

package/dist/shortcuts/plan/operations/read.js

@@ -0,0 +1,259 @@
+import { planValidationError } from '../errors.js';
+import { SCHEMA_ID, SCHEMA_REPORT_TYPE, planSuccess, schemaOf, } from './types.js';
+import { assertLinkSupported, assertReportType, ebMainTables, normalizeEbReport, normalizeStandardReport, resolveSerialNumber, resolveYear, toIdString, } from './shared.js';
+import { buildDetailUrl, lookupReport, resolveLink, } from './link.js';
+const COMMENT_MODULE = 'workreport';
+// ---------------------------------------------------------------------------
+// 单份报告详情（按 id 或按周期），并按规则附加评论总条数
+// ---------------------------------------------------------------------------
+async function commentTotalCount(host, reportId) {
+    const response = await host.request({
+        method: 'POST',
+        path: '/api/plan/common/comment/commentPage',
+        operation: 'plan.report.get',
+        body: {
+            pageNo: 1,
+            pageSize: 1,
+            targetId: reportId,
+            module: COMMENT_MODULE,
+            foldCommentList: false,
+        },
+    });
+    const total = response?.data?.page?.totalCount;
+    const numeric = Number(total);
+    return Number.isFinite(numeric) ? numeric : null;
+}
+const planReportGet = {
+    name: 'plan.report.get',
+    resource: 'plan',
+    method: 'report.get',
+    action: 'plan.report.get',
+    summary: '按报告 id 或按周期（年份+类型+周期+创建人）查询单个报告详情，并按规则附带评论总条数',
+    capability: 'plan',
+    risk: 'read',
+    inputSchema: schemaOf({
+        id: { ...SCHEMA_ID, description: '报告 id；与周期参数二选一，给 id 时忽略周期参数' },
+        year: { type: 'integer', description: '报告年份；缺省取本年' },
+        type: { ...SCHEMA_REPORT_TYPE, description: '报告类型' },
+        serialNumber: { type: 'integer', minimum: 1, description: '报告周期' },
+        creatorUserId: { ...SCHEMA_ID, description: '报告创建人 id；缺省为当前登录人' },
+        withComments: { type: 'boolean', default: true, description: '标准版链路下是否同时查询评论总条数' },
+    }, {
+        oneOf: [{ required: ['id'] }, { required: ['type', 'serialNumber'] }],
+    }),
+    handler: async (args, { host }) => {
+        const warnings = [];
+        const query = args.id !== undefined && args.id !== ''
+            ? { id: toIdString(args.id, 'id') }
+            : {
+                year: resolveYear(args.year),
+                type: assertReportType(args.type),
+                serialNumber: resolveSerialNumber(args.serialNumber),
+                ...(args.creatorUserId !== undefined && args.creatorUserId !== ''
+                    ? { creatorUserId: toIdString(args.creatorUserId, 'creatorUserId') }
+                    : {}),
+            };
+        const linkInfo = await resolveLink(host);
+        const result = await lookupReport(host, linkInfo.link, query);
+        warnings.push(...result.warnings);
+        const data = {
+            link: result.link,
+            exists: result.exists,
+            report: result.report,
+            detailUrl: result.report?.detailUrl ?? null,
+            warnings,
+        };
+        if (result.link === 'eb') {
+            data.commentsSupported = false;
+            warnings.push('eb 链路未提供报告评论接口，评论总条数不可用');
+        }
+        else if (result.exists && result.report?.reportId && args.withComments !== false) {
+            try {
+                const total = await commentTotalCount(host, result.report.reportId);
+                if (total !== null && total > 0) {
+                    data.commentCount = total;
+                    data.commentHint = `该报告下共有${total}条评论，是否需要查看评论内容？`;
+                }
+            }
+            catch {
+                warnings.push('评论总条数查询失败，报告详情已返回');
+            }
+        }
+        return planSuccess('plan.report.get', data);
+    },
+};
+// ---------------------------------------------------------------------------
+// 分页查询报告列表
+// ---------------------------------------------------------------------------
+function pageArgs(args) {
+    const pageNo = args.pageNo === undefined || args.pageNo === '' ? 1 : Number(args.pageNo);
+    const pageSize = args.pageSize === undefined || args.pageSize === '' ? 10 : Number(args.pageSize);
+    if (!Number.isInteger(pageNo) || pageNo < 1) {
+        throw planValidationError('page_invalid', 'pageNo 必须是不小于 1 的整数');
+    }
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) {
+        throw planValidationError('page_invalid', 'pageSize 必须是 1~100 的整数');
+    }
+    return { pageNo, pageSize };
+}
+const planReportPage = {
+    name: 'plan.report.page',
+    resource: 'plan',
+    method: 'report.page',
+    action: 'plan.report.page',
+    summary: '分页查询报告列表（共享给我的报告 / 我自己与他人共享的报告），返回可直接跳转详情的行数据',
+    capability: 'plan',
+    risk: 'read',
+    inputSchema: schemaOf({
+        scope: { type: 'string', enum: ['share', 'mine'], default: 'share', description: 'share-共享给我的；mine-我自己及他人共享给我的（eb 链路按创建人筛选）' },
+        unreadOnly: { type: 'boolean', default: false, description: '仅看未读（标准版专属）' },
+        year: { type: 'integer', description: '报告年份筛选' },
+        type: { ...SCHEMA_REPORT_TYPE, description: '报告类型筛选' },
+        serialNumber: { type: 'integer', minimum: 1, description: '报告周期筛选' },
+        creatorUserId: { ...SCHEMA_ID, description: '报告创建人 id 筛选（eb 链路支持）' },
+        onlyIncludeSubs: { type: 'boolean', description: '是否只包含下属（标准版专属）' },
+        pageNo: { type: 'integer', minimum: 1, default: 1, description: '页码' },
+        pageSize: { type: 'integer', minimum: 1, maximum: 100, default: 10, description: '每页条数' },
+    }),
+    handler: async (args, { host }) => {
+        const { pageNo, pageSize } = pageArgs(args);
+        const warnings = [];
+        const linkInfo = await resolveLink(host);
+        const session = await host.getSession();
+        const rows = [];
+        if (linkInfo.link === 'standard') {
+            if (args.scope === 'mine') {
+                warnings.push('标准版分页接口只返回「共享给我的报告」，scope=mine 不能作为创建人过滤条件');
+            }
+            if (args.creatorUserId !== undefined && args.creatorUserId !== '') {
+                warnings.push('标准版分页接口不支持按创建人筛选，creatorUserId 已忽略');
+            }
+            const query = {
+                type: args.unreadOnly === true ? 'unreadPage' : 'sharePage',
+                pageNo,
+                pageSize,
+            };
+            if (args.type !== undefined)
+                query.workReportType = assertReportType(args.type);
+            if (args.onlyIncludeSubs !== undefined)
+                query.onlyIncludeSubs = args.onlyIncludeSubs === true;
+            const response = await host.request({
+                method: 'GET',
+                path: '/api/workrelate/plan/workreport/indexGet',
+                query,
+                operation: 'plan.report.page',
+            });
+            const result = response?.page?.result;
+            if (Array.isArray(result)) {
+                for (const row of result) {
+                    const reportId = row?.id === undefined || row?.id === null || row?.id === '' ? null : String(row.id);
+                    rows.push(normalizeStandardReport(row, await buildDetailUrl(host, 'standard', reportId)));
+                }
+            }
+            return planSuccess('plan.report.page', {
+                link: 'standard',
+                pageNo,
+                pageSize,
+                count: rows.length,
+                rows,
+                warnings,
+            });
+        }
+        if (args.unreadOnly === true)
+            warnings.push('eb 链路分页接口不支持「仅看未读」，unreadOnly 已忽略');
+        if (args.onlyIncludeSubs !== undefined)
+            warnings.push('eb 链路分页接口不支持 onlyIncludeSubs，已忽略');
+        const creator = args.creatorUserId !== undefined && args.creatorUserId !== ''
+            ? toIdString(args.creatorUserId, 'creatorUserId')
+            : session.userId;
+        const mainTable = { creator };
+        if (args.year !== undefined)
+            mainTable.f_year = resolveYear(args.year);
+        if (args.type !== undefined)
+            mainTable.f_type = assertReportType(args.type);
+        if (args.serialNumber !== undefined)
+            mainTable.f_serial_number = resolveSerialNumber(args.serialNumber);
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/ebuilder/form/formdata/v2/getFormDataList/plan_pageQueryPlan',
+            operation: 'plan.report.page',
+            body: {
+                datajson: {
+                    mainTable,
+                    pageInfo: { pageNo: String(pageNo), pageSize: String(pageSize) },
+                    header: { operator: session.userId },
+                },
+            },
+        });
+        for (const item of ebMainTables(response)) {
+            const reportId = item?.id === undefined || item?.id === null || item?.id === '' ? null : String(item.id);
+            rows.push(normalizeEbReport(item, await buildDetailUrl(host, 'eb', reportId)));
+        }
+        return planSuccess('plan.report.page', {
+            link: 'eb',
+            pageNo,
+            pageSize,
+            count: rows.length,
+            rows,
+            warnings,
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 报告评论列表
+// ---------------------------------------------------------------------------
+const planCommentList = {
+    name: 'plan.comment.list',
+    resource: 'plan',
+    method: 'comment.list',
+    action: 'plan.comment.list',
+    summary: '分页查询某份报告的评论内容（标准版链路）；仅在用户明确要求查看评论内容时调用',
+    capability: 'plan',
+    risk: 'read',
+    inputSchema: schemaOf({
+        reportId: { ...SCHEMA_ID, description: '报告 id' },
+        pageNo: { type: 'integer', minimum: 1, default: 1, description: '页码' },
+        pageSize: { type: 'integer', minimum: 1, maximum: 100, default: 10, description: '每页条数' },
+    }, { required: ['reportId'] }),
+    handler: async (args, { host }) => {
+        const { pageNo, pageSize } = pageArgs(args);
+        const reportId = toIdString(args.reportId, 'reportId');
+        const linkInfo = await resolveLink(host);
+        assertLinkSupported(linkInfo.link, 'standard', 'plan.comment.list', 'eb 链路未提供报告评论接口，无法查询评论内容；当前租户走 e10-ebuilder 链路');
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/plan/common/comment/commentPage',
+            operation: 'plan.comment.list',
+            body: {
+                pageNo,
+                pageSize,
+                targetId: reportId,
+                module: COMMENT_MODULE,
+                foldCommentList: false,
+            },
+        });
+        const page = response?.data?.page ?? {};
+        const result = Array.isArray(page.result) ? page.result : [];
+        const totalCount = Number(page.totalCount);
+        return planSuccess('plan.comment.list', {
+            link: 'standard',
+            reportId,
+            pageNo,
+            pageSize,
+            totalCount: Number.isFinite(totalCount) ? totalCount : result.length,
+            comments: result.map((item) => ({
+                commentId: item?.id ?? null,
+                commentorId: item?.commentor?.id ?? null,
+                commentorName: item?.commentor?.username ?? item?.commentor?.name ?? null,
+                content: item?.content ?? item?.originContent ?? null,
+                addTime: item?.addTime ?? null,
+                parentCommentId: item?.parent?.id ?? null,
+            })),
+        });
+    },
+};
+export const planReadOperations = [
+    planReportGet,
+    planReportPage,
+    planCommentList,
+];

package/dist/shortcuts/plan/operations/registry.js

@@ -0,0 +1,33 @@
+import { planValidationError } from '../errors.js';
+import { planReadOperations } from './read.js';
+import { planVersionOperations } from './version.js';
+import { planWriteOperations } from './write.js';
+function buildRegistry() {
+    const registry = new Map();
+    const definitions = [
+        ...planVersionOperations,
+        ...planReadOperations,
+        ...planWriteOperations,
+    ];
+    for (const definition of definitions) {
+        if (registry.has(definition.name)) {
+            throw new Error(`duplicate plan operation: ${definition.name}`);
+        }
+        registry.set(definition.name, definition);
+    }
+    return registry;
+}
+const planOperationRegistry = buildRegistry();
+export function planOperationDefinitions() {
+    return [...planOperationRegistry.values()];
+}
+export function getPlanOperation(operation) {
+    const definition = planOperationRegistry.get(operation);
+    if (!definition) {
+        throw planValidationError('operation_unknown', `计划报告模块不支持操作：${operation}`);
+    }
+    return definition;
+}
+export function hasPlanOperation(operation) {
+    return planOperationRegistry.has(operation);
+}