weaver-work-cli 0.1.28 → 0.1.31

package/dist/shortcuts/workflow/operations/todoSmartConvert/todoDetailFetcher.js

@@ -0,0 +1,259 @@
+/**
+ * 批量获取流程表单详情 —— 摘要阶段的唯一取数入口。
+ *
+ * ## 为什么要单独一个文件
+ *
+ * 「怎么拉详情」这件事被**刻意收敛到本文件**：OA 侧后续会提供一个性能更好的批量接口，
+ * 到时候只改 `fetchOneDetail`（一个函数、一处 HTTP 调用）即可，调用方
+ * （`todoSmartConvert.ts` 的 `stage=summaryContext`）完全不用动。所以这里：
+ *  - 对外只暴露 `fetchRequestDetailsBatch(env, requestIds, options)`；
+ *  - 内部不掺任何结构组装、摘要生成、markdown 渲染；
+ *  - 返回的是**按 requestId 索引的纯数据**，谁要用谁自己组装。
+ *
+ * ## 取数口径（复用现成链路，不另写一套）
+ *
+ * 与 `workflow.summary` / `workflow.detail` **同一个接口、同一份归一化**：
+ *
+ *   POST /api/workflow/core/paService/v1/getWorkflowRequest
+ *   { requestId, isGetRequestBaseInfo:true, isGetRequestLog:false, isGetFormData:true,
+ *     isReadRequest:false, userId? }
+ *
+ * 归一再交给 `normalizeDetailResponse`（`read.ts`）→ `formData.fields[]` → 业务裁剪
+ * （`detailFieldRules.ts`：丢掉 `主送` 这类分发字段；内部留言类只留 `留言内容/发起人/发起时间`）
+ * → `selectSummaryFields`（业务字段筛选，剔除流程名称/发起人/时间/状态/节点等技术字段）。
+ *
+ * ★ `isReadRequest:false` 是硬要求：批量取数**不得**把用户的待办标成已读。`workflow.detail`
+ *   传的是 `true`，所以它不能被这里复用。
+ *
+ * ## 为什么并发而不是串行
+ *
+ * 真实数据 319 条待办，单条详情 HTTP 在数百毫秒级；串行要几分钟，逐条起 CLI 进程更慢
+ * （每条 ~5s，几乎全是启动与登录态开销）。这里在**进程内**用 worker 池并发，默认 10 路
+ * ——与用户给定口径一致，也不至于把服务端打满。
+ */
+import { WORKFLOW_ENDPOINTS } from '../../endpoints.js';
+import { extractRowMetrics } from './businessRules.js';
+import { dropDistributionDetailFields, isInternalMessageDetail, pickInternalMessageFieldPairs, } from './detailFieldRules.js';
+import { normalizeDetailResponse, selectSummaryFields } from '../read.js';
+/** 默认并发上限。 */
+export const DETAIL_BATCH_CONCURRENCY = 10;
+/** 单条详情默认超时。批量取数不是「补卡片」，不套用 5s 的短超时。 */
+export const DETAIL_BATCH_TIMEOUT_MS = 10_000;
+/** 默认重试次数（仅网络/超时；业务错误与登录失效不重试）。 */
+export const DETAIL_BATCH_RETRIES = 1;
+/** 单条最多取多少个业务字段（与 `workflow.summary` 的默认一致）。 */
+export const DETAIL_BATCH_FIELD_LIMIT = 12;
+/** 常见 HTML 实体 → 字符。`“` 这类 OA 富文本里到处都是，不解码会原样带进摘要。 */
+const HTML_ENTITIES = {
+    amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ',
+    ldquo: '“', rdquo: '”', lsquo: '‘', rsquo: '’', mdash: '—', ndash: '–',
+    hellip: '…', middot: '·', bull: '•', times: '×', divide: '÷', rarr: '→',
+    larr: '←', copy: '©', reg: '®', trade: '™', emsp: ' ', ensp: ' ', thinsp: ' ',
+    ge: '≥', le: '≤', laquo: '«', raquo: '»',
+};
+/** 数字实体（`&#8220;` / `&#x201C;`）与命名实体统一解码；认不出的原样保留。 */
+function decodeHtmlEntities(text) {
+    return text.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z][a-zA-Z0-9]*);/g, (match, body) => {
+        try {
+            if (body.startsWith('#x') || body.startsWith('#X')) {
+                return String.fromCodePoint(Number.parseInt(body.slice(2), 16));
+            }
+            if (body.startsWith('#')) {
+                return String.fromCodePoint(Number.parseInt(body.slice(1), 10));
+            }
+            return HTML_ENTITIES[body.toLowerCase()] ?? match;
+        }
+        catch {
+            return match;
+        }
+    });
+}
+/**
+ * 清洗字段值（**不截断**）：实体解码 + 去掉富文本残留 + 压缩空白。
+ *
+ * 单独拆出来是因为「内部留言正文有多长」要按清洗后的长度判：原始串里 `<p style=…>`、
+ * `&nbsp;` 能占掉一半篇幅，按原始长度判会把正常长度的留言误判成超长。
+ */
+function cleanFieldText(raw) {
+    let text = String(raw ?? '');
+    text = text.replace(/<(style|script)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, ' ');
+    text = text.replace(/<[^>]+>/g, ' ');
+    text = decodeHtmlEntities(text);
+    // 裸 CSS 声明块：`{ ... }` 整块丢弃（只丢大括号内的内容，不动前面的正文）
+    text = text.replace(/\{[^{}]{0,800}\}/g, ' ');
+    return text.replace(/\s+/g, ' ').trim();
+}
+/** 错误 → 稳定的短语（用于 `RequestDetailContext.error`，不暴露内部堆栈）。 */
+function stopReasonOf(error) {
+    const structured = error;
+    if (structured?.type === 'network') {
+        return structured.subtype === 'timeout' ? 'http_timeout' : 'network_error';
+    }
+    if (structured?.type === 'authentication')
+        return 'login_expired';
+    if (structured?.type === 'api')
+        return 'api_error';
+    return 'unknown_error';
+}
+/** 只有网络类错误值得重试；业务错误、登录失效重试也是同样结果。 */
+function isRetryable(error) {
+    const structured = error;
+    if (structured?.type === 'network')
+        return true;
+    return structured?.retryable === true && structured?.type !== 'authentication';
+}
+/**
+ * 单条详情取数。后续切换批量接口时，保持本文件对外的批量结果契约即可。
+ */
+async function fetchOneDetail(env, requestId, userId, options) {
+    const body = {
+        requestId,
+        isGetRequestBaseInfo: true,
+        isGetRequestLog: false,
+        isGetFormData: true,
+        // ★ 批量取数不得改变未读状态
+        isReadRequest: false,
+    };
+    if (userId)
+        body.userId = userId;
+    const response = await env.host.workflowRequest({
+        method: 'POST',
+        path: WORKFLOW_ENDPOINTS.REQUEST_DETAIL,
+        operation: 'workflow.todoSmartConvert.detail',
+        body,
+        timeoutMs: options.timeoutMs ?? DETAIL_BATCH_TIMEOUT_MS,
+    });
+    const normalized = normalizeDetailResponse(response);
+    const base = (normalized?.basicInfo ?? {});
+    const rawFields = Array.isArray(normalized?.formData?.fields) ? normalized.formData.fields : [];
+    // ① 分发类字段（`主送` …）**无条件丢弃**：值是几十个部门的收件人清单，对摘要零信息量，
+    //    还会挤占 `summaryFields` 的字段名额。必须在挑选之前丢，名额才不会被它吃掉。
+    const usableFields = dropDistributionDetailFields(rawFields);
+    // ② 内部留言类：只保留 留言内容 / 发起人 / 发起时间（其余是分发元数据，见 `detailFieldRules.ts`）。
+    const internalMessage = isInternalMessageDetail(base.workflowName, usableFields.map((field) => field?.fieldName));
+    // ③ 内部留言类只保留留言内容、发起人、发起时间；字段值只清洗不裁剪。
+    const cleanedFields = usableFields.map((field) => ({
+        ...field,
+        value: cleanFieldText(String(field?.value ?? '')),
+    }));
+    const picked = internalMessage
+        ? pickInternalMessageFieldPairs(cleanedFields, { creatorName: base.creatorName, createdAt: base.createdAt })
+        : selectSummaryFields(cleanedFields, options.fieldLimit ?? DETAIL_BATCH_FIELD_LIMIT, undefined, { fullValue: true });
+    const summaryFields = picked
+        .map((field) => ({
+        fieldName: String(field?.fieldName ?? '').trim(),
+        value: String(field?.value ?? ''),
+    }))
+        .filter((field) => field.fieldName && field.value);
+    // ④ 结构化指标（请假天数 / 假别 / 金额 / 费用类别）：**只从流程详情数据的字段里取**，
+    //    不做标题兜底（2026-10-26 用户口径：详情取不到指标就不进阈值组，标题不能当证据）。
+    const metrics = extractRowMetrics(usableFields);
+    return {
+        requestId,
+        basicInfo: {
+            requestTitle: String(base.requestTitle ?? ''),
+            workflowName: String(base.workflowName ?? ''),
+            creatorName: String(base.creatorName ?? ''),
+            createdAt: String(base.createdAt ?? ''),
+            currentNode: String(base.currentNode ?? ''),
+            requestLevel: String(base.requestLevel ?? ''),
+            flowStatus: String(base.flowStatus ?? ''),
+        },
+        summaryFields,
+        contextAvailable: summaryFields.length > 0,
+        metrics,
+    };
+}
+/**
+ * 批量拉取表单详情（并发上限默认 10，全量拉取，单条失败不拖垮整批）。
+ *
+ * 行为约定：
+ *  - **按入参去重**，返回顺序与首次出现顺序一致；
+ *  - 单条失败走重试（默认 1 次），仍失败则写入 `error`，**不抛错**——一条取不到不该让
+ *    整批 300 条白跑；
+ *  - 认证失效（`login_expired`）会**立刻上抛**：后面每一条都会同样失败，继续跑没有意义，
+ *    而且会把真正的登录问题伪装成「一堆取数失败」；
+ *  - 进度回调是可选的，只用于长批次的可观测性，不参与结果。
+ */
+export async function fetchRequestDetailsBatch(env, requestIds, options = {}) {
+    const startedAt = Date.now();
+    const unique = [];
+    const seen = new Set();
+    for (const raw of requestIds) {
+        const id = String(raw ?? '').trim();
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        unique.push(id);
+    }
+    const concurrency = Math.max(1, Math.min(Number(options.concurrency ?? DETAIL_BATCH_CONCURRENCY), 32));
+    const retries = Math.max(0, Number(options.retries ?? DETAIL_BATCH_RETRIES));
+    const details = new Map();
+    const failures = [];
+    const session = await env.host.getSession();
+    const userId = session.userId || undefined;
+    let cursor = 0;
+    let fetched = 0;
+    let contextAvailable = 0;
+    let contextEmpty = 0;
+    const worker = async () => {
+        while (cursor < unique.length) {
+            const index = cursor;
+            cursor += 1;
+            const requestId = unique[index];
+            let attempt = 0;
+            let lastError;
+            while (attempt <= retries) {
+                try {
+                    const context = await fetchOneDetail(env, requestId, userId, options);
+                    details.set(requestId, context);
+                    fetched += 1;
+                    if (context.contextAvailable)
+                        contextAvailable += 1;
+                    else
+                        contextEmpty += 1;
+                    lastError = undefined;
+                    break;
+                }
+                catch (error) {
+                    lastError = error;
+                    // 登录失效：整批都会失败，立刻上抛而不是伪装成 N 条取数失败
+                    if (stopReasonOf(error) === 'login_expired')
+                        throw error;
+                    attempt += 1;
+                    if (attempt > retries || !isRetryable(error))
+                        break;
+                }
+            }
+            if (lastError !== undefined) {
+                const reason = stopReasonOf(lastError);
+                failures.push({ requestId, error: reason });
+                details.set(requestId, {
+                    requestId,
+                    basicInfo: {
+                        requestTitle: '', workflowName: '', creatorName: '', createdAt: '',
+                        currentNode: '', requestLevel: '', flowStatus: '',
+                    },
+                    summaryFields: [],
+                    contextAvailable: false,
+                    metrics: {},
+                    error: reason,
+                });
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, Math.max(unique.length, 1)) }, () => worker()));
+    return {
+        details,
+        stats: {
+            requested: unique.length,
+            fetched,
+            contextAvailable,
+            contextEmpty,
+            failed: failures.length,
+            concurrency: Math.min(concurrency, Math.max(unique.length, 1)),
+            durationMs: Date.now() - startedAt,
+        },
+        failures: failures.slice(0, 20),
+    };
+}

package/dist/shortcuts/workflow/operations/todoSmartConvert/todoListRows.js

@@ -0,0 +1,64 @@
+/**
+ * `getTodoListData` 响应的 **displayData 取数口径**（待办汇总链路专用，独立成文件）。
+ *
+ * 为什么单独放一个文件而不是塞进 `read.ts`：`read.ts` 是 `workflow.search` / `detail` /
+ * `summary` 共用的老模块，被其他 skill（查询、批量、写操作）大量引用；本模块只服务
+ * `workflow.todoSmartConvert`，放在这里可以让老模块**零改动**，改动面收敛在新文件里。
+ *
+ * 一条响应里只有 `displayData` 是显示层数据：同一份响应还带 `data`（技术字段行，几十个
+ * requestid/sysCode/…，与 displayData 一一重复但不含 `creatername`/`requestlevelShow` 等显示列）、
+ * `columns`（列定义）、`operates`、`pageUid`、`tableType`。汇总链路一个都不需要。
+ */
+import { responseData } from '../shared.js';
+/**
+ * 逐行白名单：按**目标格式**（`docs/todo-smart-convert/mock/ai-todo-query-target.json` 里
+ * `displayItems[].requestData` / `requestDatas[]`）收敛——定位键、状态位、展示字段、时间列
+ * 都是目标结构要的；其余 100+ 个属性（sysCode、creatorMasterJodId、tenantKey、rowKey、
+ * 统计辅助位等）一律丢弃。
+ */
+const DISPLAY_ROW_FIELDS = [
+    // 定位键
+    'requestId', 'requestid',
+    'workflowid', 'workflowId',
+    'userMasterId', 'userid',
+    'isremark', 'isremarktype',
+    'nodeid', 'currentNodeId',
+    // 状态位
+    'overdue', 'userOverTime',
+    'requestlevel', 'requestLevelShow', 'requestlevelShow', 'requestlevelTitle',
+    // 展示字段
+    'requestnamehtml', 'requestnameTitle', 'requestnametitle', 'requestname',
+    'creater', 'creatername', 'creatorName',
+    'workflowname', 'workflowName', 'workflowTypeName',
+    'requestmark', 'flowstatusShow',
+    'receivedatetime', 'operatedatetime',
+    // 最后反馈时间：`getTodoListData.displayData` 里的原始键是全小写，大小写变体一并保留。
+    'lastfeedbackdatetime', 'lastFeedbackDateTime',
+];
+/**
+ * 只保留 `displayData`（且逐行白名单）的原始行。
+ *
+ * 取值路径**不**回落到 `record.data.list` / `record.list`：那两个键在 `getTodoListData` 里
+ * 指向技术字段行；宁可返回空数组，也不把非显示列当显示列。
+ */
+export function projectDisplayRows(response) {
+    const record = responseData(response);
+    const raw = record?.data?.displayData ?? record?.displayData ?? [];
+    const rows = Array.isArray(raw) ? raw : [];
+    const projected = [];
+    for (const row of rows) {
+        if (!row || typeof row !== 'object' || Array.isArray(row))
+            continue;
+        const source = row;
+        const picked = {};
+        for (const key of DISPLAY_ROW_FIELDS) {
+            const value = source[key];
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                picked[key] = value;
+            }
+        }
+        if (Object.keys(picked).length > 0)
+            projected.push(picked);
+    }
+    return projected;
+}

package/dist/shortcuts/workflow/operations/todoSmartConvert/todoOutputPlanner.js

@@ -0,0 +1,28 @@
+function mergeWarnings(meta, warnings) {
+    const list = [...new Set((warnings ?? []).filter((item) => typeof item === 'string' && item.trim() !== ''))];
+    return list.length > 0 ? { ...(meta ?? {}), warnings: list } : meta;
+}
+/**
+ * 兼容旧调用方的名称，但不再按预算投影业务数据。
+ * requestData/requestDatas/displayItems 必须在最终 JSON 中完整返回；前端自行根据
+ * defaultExpanded 决定初始展示状态。历史 Omitted/ref 字段不属于业务协议。
+ */
+export function projectTodoOutput(data, _budgetBytes) {
+    return {
+        plan: 'full',
+        note: '',
+        data: (data && typeof data === 'object' ? data : {}),
+        notes: [],
+        bytes: Buffer.byteLength(JSON.stringify(data ?? null), 'utf8'),
+    };
+}
+/**
+ * todoSmartConvert 的输出规划兼容层：只合并告警并原样透传数据。
+ * 公共 workflow 输出入口会对本 operation 关闭递归压缩。
+ */
+export function planTodoOutput(options) {
+    return {
+        data: options.data,
+        meta: mergeWarnings(options.meta, options.warnings),
+    };
+}

package/dist/shortcuts/workflow/operations/todoSmartConvert/todoSmartConvert.aggregate.js

@@ -0,0 +1,70 @@
+import { assertKnownKeys, groupKeyOf, readGroupBy, readItems, readTopN, renderMarkdown, } from './todoSmartConvert.core.js';
+export function runSmartConvert(args) {
+    assertKnownKeys(args);
+    const { rawCount, rows, duplicateCount, unreadableCount } = readItems(args.items);
+    const groupBy = readGroupBy(args.groupBy);
+    const topN = readTopN(args.topN);
+    const buckets = new Map();
+    let amountSumTotal = 0;
+    let amountMissing = 0;
+    for (const row of rows) {
+        const key = groupKeyOf(row, groupBy);
+        let group = buckets.get(key);
+        if (!group) {
+            group = { key, count: 0, amountCount: 0, amountSum: 0, requestIds: [] };
+            buckets.set(key, group);
+        }
+        group.count += 1;
+        if (row.requestId)
+            group.requestIds.push(row.requestId);
+        if (typeof row.amount === 'number') {
+            group.amountCount += 1;
+            group.amountSum += row.amount;
+            amountSumTotal += row.amount;
+        }
+        else {
+            amountMissing += 1;
+        }
+    }
+    const sorted = [...buckets.values()].sort((a, b) => {
+        if (b.count !== a.count)
+            return b.count - a.count;
+        return a.key.localeCompare(b.key, 'zh-CN');
+    });
+    const groups = sorted.slice(0, topN);
+    const rest = sorted.slice(topN);
+    const restCount = rest.reduce((sum, group) => sum + group.count, 0);
+    const warnings = [];
+    if (duplicateCount > 0) {
+        warnings.push(`已按 requestId 去重：原始 ${rawCount} 条，唯一 ${rows.length} 条，重复 ${duplicateCount} 条`);
+    }
+    if (unreadableCount > 0) {
+        warnings.push(`有 ${unreadableCount} 条不是对象结构，已跳过`);
+    }
+    if (amountMissing > 0 && amountMissing < rows.length) {
+        warnings.push(`有 ${amountMissing} 条缺少金额，金额合计只统计了带金额的条目`);
+    }
+    return {
+        groupBy,
+        totalInput: rawCount,
+        total: rows.length,
+        duplicateCount,
+        groupCount: sorted.length,
+        totals: {
+            count: rows.length,
+            amountSum: Math.round(amountSumTotal * 100) / 100,
+            amountMissing,
+        },
+        groups,
+        restGroups: rest.length > 0 ? { groupCount: rest.length, count: restCount } : null,
+        warnings,
+        markdown: renderMarkdown({
+            groupBy,
+            total: rows.length,
+            groups,
+            restGroupCount: rest.length,
+            restCount,
+            hasAmount: amountMissing < rows.length,
+        }),
+    };
+}