aitable-workflow-cli 0.1.23 → 0.1.24

package/templates/support-qa/workflows/group-qa/recipes/on-action.recipe.ts

@@ -1,225 +0,0 @@
-import { existsSync } from "node:fs";
-import nodePath from "node:path";
-import { z } from "zod";
-import { resolveGlobalVarRef, type RecipeDefinition, type RecipeContext, type RecipeResult } from "aitable-workflow-core";
-import { resolveGroupMention } from "../../../lib/dingtalk-group-membership.js";
-import { SUPPORT_ACTIONS, type SupportAction, KB_STATUS } from "../../../lib/contract.js";
-import { DEFAULT_ON_ACTION, type ActionPolicy, type ActionPolicyOverrides } from "../../../lib/profile.js";
-import { resolveOwner, type OwnerResolution } from "../../../lib/owner-resolver.js";
-import { buildActionDispatch, needsOwnerResolution, shouldRecordOwnerFailure } from "../../../lib/action-dispatch.js";
-import { SUPPORT_MEMORY_KINDS, SUPPORT_MEMORY_ROLES, supportEntry, supportScope } from "../../../lib/memory-events.js";
-
-type GroupConfig = { groupId: string; outbound?: string; corpId?: string };
-
-function loadGroupConfig(ctx: RecipeContext, source: unknown, conversationId: string): GroupConfig | null {
-  const list = resolveGlobalVarRef(source, ctx.getGlobalVar) as GroupConfig[] | undefined;
-  if (!Array.isArray(list)) return null;
-  return list.find((group) => group.groupId === conversationId) ?? null;
-}
-
-/**
- * 决策后处置分发（support-qa 尾前步，取代 on-silence——所有最终处置的统一分发器，spec §10）
- *
- * 职责：
- *   1. 按 action 查 policies（profile v2：ctx.config.policies，来自 profile.yml 的
- *      workflows.group-qa.steps.on_action.policies 段）得出 track/group；
- *   2. track=false → tracker:false（整行 discard）；
- *   3. 轴2 Owner 解析（needsOwnerResolution）：bug/feature/kb_gap 确定性解析 module→Owner→userid
- *      （数据源：config-sync 从功能模块人员配置表发布的 ${globalVar.module_owners} 快照），
- *      **与 group 档位无关**（静默时 Owner 仍需进通知字段）；解析失败按
- *      shouldRecordOwnerFailure 过滤后记 owner_resolution_failed；
- *   4. 轴1 群内可见性 + 轴2 Owner 尾注由 buildActionDispatch 正交合成 final_reply
- *      （group=answer 也可带 Owner 尾注；silent 则群内不说话）；
- *   5. 为 bug/feature/kb_gap 生成渠道无关的自动化通知字段（标题/内容/接收人 userid）；
- *      kb_gap 额外置「知识沉淀=待补充」进知识收件箱。
- *
- * 不负责：不调用群发送接口、不选路 Session/Webhook、不调 LLM、不发送 TODO/IM
- * （通知由 AI 表格自动化读取结构化字段按需发起）。
- */
-
-const recipe: RecipeDefinition = {
-  meta: {
-    id: "on-action",
-    name: "决策后处置",
-    role: "support",
-    description: "按 action 查 profile on_action 策略：留痕(track)、群行为(group)、Owner 解析与通知字段合成",
-    version: "1.0.0",
-    requiresAgent: false,
-    timeoutMs: 60_000,
-    config: z.object({
-      policies: z.record(z.string(), z.object({
-        track: z.boolean().optional().describe("是否建行留痕"),
-        group: z.enum(["answer", "silent"]).optional().describe("群内行为（轴1）：answer 发回答 / silent 不说话；Owner 尾注由轴2派生不在此配"),
-      })).optional().describe("按 action 的处置策略覆写；省略即用 DEFAULT_ON_ACTION"),
-      module_owners: z
-        .union([z.string(), z.array(z.unknown())])
-        .optional()
-        .describe("功能模块人员配置来源（二选一）：静态数组 [{module, owners:[{userId, nick, openDingTalkId}]}]，或引用 ${globalVar.module_owners}（config-sync 从 AI 表格发布）。缺省取后者。"),
-      group_configs: z
-        .union([z.string(), z.array(z.unknown())])
-        .optional()
-        .describe("群配置来源；Webhook 群只有 corpId 非空时才允许真实 @ 人。缺省取 ${globalVar.group_configs}"),
-    }),
-  },
-
-  async execute(ctx: RecipeContext): Promise<RecipeResult> {
-    const { input, toolkit, log } = ctx;
-    const rawAction = String(input.action ?? "").trim();
-    const reply = String(input.reply ?? "");
-    const module = String(input.module ?? "").trim();
-    const reason = String(input.reason ?? "");
-    const content = String(input.content ?? "");
-    const senderName = String(input.senderName ?? "").trim();
-    const conversationId = String(input.conversationId ?? "").trim();
-
-    if (!rawAction) {
-      // 上游未产出 action（防御）→ 不表态透传
-      return { status: "success", output: {}, tracker: false, logs: ["无 action，透传"] };
-    }
-    if (!(SUPPORT_ACTIONS as readonly string[]).includes(rawAction)) {
-      // 非法输出统一降级 agent_failure（spec §5.3）
-      log(`未知 action ${rawAction}，按 agent_failure 处理`);
-    }
-    const action = ((SUPPORT_ACTIONS as readonly string[]).includes(rawAction) ? rawAction : "agent_failure") as SupportAction;
-
-    // 策略合并（与 dev 基线 on_silence 同构）：默认值 + ctx.config.policies 逐 action spread 覆写；
-    // group 合法值（answer/silent）由 assemble preflight 闭集校验把关，运行时不再归一
-    const overrides = ctx.config.policies as ActionPolicyOverrides | undefined;
-    const policy: ActionPolicy = { ...DEFAULT_ON_ACTION[action], ...overrides?.[action] };
-
-    // Owner 解析（轴2，单点判定 needsOwnerResolution）：只看 action 是否需要找人，
-    // **与 group 档位无关**——群里说不说话由 policy.group 定，是否附 Owner 指引由
-    // 解析结果派生（见 action-dispatch）；静默时 Owner 仍需进通知字段供自动化找人。
-    let owner: OwnerResolution | null = null;
-    let ownerMentionUserId = "";
-    if (needsOwnerResolution(action)) {
-      // 不套 String()：resolveGlobalVarRef 对非 ref 值原样透传，静态数组直填走同一条路；
-      // 强转会把数组压成 "[object Object]"，下游 Array.isArray 判假 → 永远解析不出 Owner。
-      const ownersSource = ctx.config.module_owners ?? "${globalVar.module_owners}";
-      owner = resolveOwner(resolveGlobalVarRef(ownersSource, ctx.getGlobalVar), module);
-      if (owner.status === "resolved") {
-        const groupsSource = ctx.config.group_configs ?? "${globalVar.group_configs}";
-        const group = loadGroupConfig(ctx, groupsSource, conversationId);
-        const webhookCorpId = group?.outbound === "webhook" ? String(group.corpId ?? "").trim() : "";
-        if (group?.outbound === "webhook" && !webhookCorpId) {
-          // Webhook 的 userId 属于企业命名空间。群归属企业未知时不能猜测当前 DWS
-          // 默认组织，否则可能把无效 userId 作为裸 `@userId` 发进跨企业群。
-          log(`Webhook 群 ${conversationId || "(空)"} 未配置 corpId，Owner 降级为花名文本`);
-        } else {
-          // 能否真实 @：校验 Owner 在不在当前群；Webhook 群通过 `--profile <corpId>` 固定认证组织。
-          // 任何失败降级为 mode=name → 下游只渲染花名，不写假 @。
-          const mention = await resolveGroupMention(
-            conversationId,
-            { userId: owner.ownerUserId, openDingTalkId: owner.ownerOpenDingTalkId },
-            webhookCorpId ? { corpId: webhookCorpId } : {},
-          );
-          if (mention.mode === "at") ownerMentionUserId = mention.userId;
-        }
-      }
-      // 失败事件按 shouldRecordOwnerFailure 过滤：bug/feature 恒记；
-      // kb_gap 仅「给了 module 却查不到人」才记（否则大量无 module 的常态 kb_gap 会刷满事件）。
-      if (owner.status !== "resolved" && shouldRecordOwnerFailure(action, module)) {
-        log(`Owner 解析失败(${owner.reason})：module=${module || "(空)"}，本次不附 Owner 指引（正文照发）`);
-        if (conversationId) {
-          void toolkit.memory.append(
-            supportScope(conversationId),
-            supportEntry({
-              kind: SUPPORT_MEMORY_KINDS.ownerResolutionFailed,
-              content: content.slice(0, 200),
-              sender: "agent",
-              role: SUPPORT_MEMORY_ROLES.agent,
-              conversationId,
-              summary: `Owner 解析失败(${owner.reason}): action=${action} module=${module || "(空)"}`,
-              meta: { action, module, reason: owner.reason },
-            }),
-          ).catch((err) => log(`memory.append(owner_resolution_failed) 失败(不影响主流程): ${err}`));
-        }
-      }
-    }
-
-    const dispatch = buildActionDispatch({
-      action,
-      policy,
-      reply,
-      module,
-      reason,
-      content,
-      senderName,
-      conversationId,
-      owner,
-      ownerMentionUserId,
-    });
-    if (dispatch.agentReplyMissing) {
-      log(`agent_reply_missing: ${action} 缺少 Agent 回复主体，使用内部兜底文案`);
-    }
-
-    if (!policy.track) {
-      log(`处置(${action}) → 不留痕(track=false)，group=${conversationId || "(未知)"}`);
-      // logs 会被 step-engine 的 no-op info 日志抬出去（静默处置唯一的运营可见点），
-      // 必须带群 ID + 理由摘要，否则「没收到」与「收到但判定不答」无法区分。
-      return {
-        status: "success",
-        output: {},
-        tracker: false,
-        logs: [`处置 ${action}：不留痕，group=${conversationId || "(未知)"}，理由=${reason.slice(0, 120) || "(空)"}`],
-      };
-    }
-
-    const output: Record<string, unknown> = {
-      final_reply: dispatch.finalReply,
-      notification_title: dispatch.notificationTitle,
-      notification_content: dispatch.notificationContent,
-      notification_target_user_id: dispatch.notificationTargetUserId,
-      mention_user_id: dispatch.mentionUserId,
-      owner_resolution_status: dispatch.ownerResolutionStatus,
-      ...(action === "kb_gap" ? { kb_status: KB_STATUS.PENDING_SUPPLEMENT } : {}),
-    };
-
-    // kb_gap：将群消息中的图片上传到「群消息补充」附件字段，供管理员在知识收件箱中查看原始截图
-    if (action === "kb_gap") {
-      const imagePaths = extractLocalImagePaths(content);
-      if (imagePaths.length > 0) {
-        const fileTokens: Array<{ fileToken: string }> = [];
-        for (const imgPath of imagePaths) {
-          try {
-            const fileName = nodePath.basename(imgPath);
-            const result = await toolkit.table.uploadAttachmentToCurrentTable(imgPath, fileName);
-            fileTokens.push({ fileToken: result.fileToken });
-          } catch (err) {
-            log(`图片上传失败(${imgPath})，跳过: ${err}`);
-          }
-        }
-        if (fileTokens.length > 0) {
-          output.image_attachments = fileTokens;
-          log(`kb_gap 图片上传完成: ${fileTokens.length}/${imagePaths.length} 张`);
-        }
-      }
-    }
-
-    log(`处置(${action}) → 留痕(track=true)，group=${policy.group}${action === "kb_gap" ? "，进入知识收件箱" : ""}${dispatch.resolvedOwnerUserId ? `，Owner=${dispatch.resolvedOwnerName}(${dispatch.resolvedOwnerUserId})` : ""}`);
-    return {
-      status: "success",
-      output,
-      logs: [
-        `处置 ${action}：留痕，group=${policy.group}`,
-        dispatch.ownerResolutionStatus === "failed" ? "owner_resolution_failed" : "",
-        dispatch.agentReplyMissing ? "agent_reply_missing" : "",
-      ].filter(Boolean),
-    };
-  },
-};
-
-const IMAGE_PATH_RE = /!\[图片\]\(([^)]+)\)/g;
-
-function extractLocalImagePaths(content: string): string[] {
-  const paths: string[] = [];
-  for (const match of content.matchAll(IMAGE_PATH_RE)) {
-    const p = match[1]!;
-    if (p.startsWith("/") && p.includes(".aitable/media/") && !p.includes("..") && existsSync(p)) {
-      paths.push(p);
-    }
-  }
-  return paths;
-}
-
-export default recipe;

package/templates/support-qa/workflows/group-qa/recipes/reply-to-group.recipe.ts

@@ -1,202 +0,0 @@
-import { z } from "zod";
-import type { RecipeDefinition, RecipeContext, RecipeResult, ReplyToConversationOptions } from "aitable-workflow-core";
-import { createFingerprintWindow, resolveGlobalVarRef } from "aitable-workflow-core";
-import { SUPPORT_MEMORY_KINDS, SUPPORT_MEMORY_ROLES, questionKey, supportEntry, supportScope } from "../../../lib/memory-events.js";
-import { echoWindow } from "../../../lib/guards.js";
-import { needsOwnerResolution } from "../../../lib/action-dispatch.js";
-import type { SupportAction } from "../../../lib/contract.js";
-
-const sendFailureWindow = createFingerprintWindow({
-  key: "send_failure_marks",
-  ttlMs: 10 * 60 * 1000,
-  capacity: 50,
-  maxPartLength: [300, 300, 200],
-});
-
-/** 群配置(config-sync 发布到 globalVar 的形状)：出站选路与凭据引用据此传给 replyToConversation。 */
-type GroupConfig = { groupId: string; corpId?: string; inbound?: string; outbound?: string; credRef?: string };
-
-/**
- * 群配置来源二选一：静态数组直填，或 "${globalVar.group_configs}" 引用（config-sync 活读）。
- * 两种形态都直接交给 resolveGlobalVarRef —— 它对非 ref 值原样透传，静态数组走同一条路。
- * 调用侧不要套 String()：数组会被压成 "[object Object]"，这里 Array.isArray 判假，
- * 于是每群都取不到配置、webhook 分支永远进不去、发送落到 via=skipped。
- */
-function loadGroupConfig(ctx: RecipeContext, source: unknown, conversationId: string): GroupConfig | null {
-  const list = resolveGlobalVarRef(source, ctx.getGlobalVar) as GroupConfig[] | undefined;
-  if (!Array.isArray(list)) return null;
-  return list.find((g) => g.groupId === conversationId) ?? null;
-}
-
-/** 兼容恢复中的旧 WorkItem：禁止把历史 Owner userId 作为裸 @ 占位符发进未知企业群。 */
-function downgradeOwnerPlaceholder(content: string, userId: string): string {
-  const placeholder = `@${userId.trim()}`;
-  return placeholder === "@" ? content : content.split(placeholder).join("**相关负责人**");
-}
-
-/**
- * 回复群消息（support-qa L0）
- *
- * 通过 messaging toolkit 的 replyToConversation 自动选路（session sessionWebhook → webhook 降级），
- * recipe 不感知传输细节。发送可靠性不变量（生产验证过）：
- *   - via=skipped 按失败处理（无可用通道 ≠ 已发送），记 send_failed；
- *     其中 configError（如 credRef 未命中 webhook_creds 命名集）返回 retryable=false，
- *     由调度层阻塞待人工改配置，不空转重试；
- *   - 发送成功才记对应事件：升级找人（bug/feature/kb_gap，与 needsOwnerResolution 同源）
- *     → owner_escalation_sent（不计为技术回答），其余 → agent_reply_sent（answered 统计口径）；
- *     发送成功同时回写 reply_status=已回复；
- *   - 发送成功后发布内容指纹（echo-guard，防 webhook 回复回流自激）。
- *
- * Owner @人（spec §11，与尾注渲染同源）：needsOwnerResolution(action) 且有 mention_user_id
- * 时追加 mentionUserIds=[Owner userid]——
- * 尾注里提了谁就 @谁，不在本 recipe 里养第二份 action 清单；
- * 花名纯文本风格下不传，沿用默认 @提问者行为，避免抬头出现数字工号。
- */
-const recipe: RecipeDefinition = {
-  meta: {
-    id: "reply-to-group",
-    name: "回复群消息",
-    role: "support",
-    description: "replyToConversation 自动选路发送；skipped 按失败处理；成功后发布回声指纹",
-    version: "1.0.0",
-    requiresAgent: false,
-    timeoutMs: 30_000,
-    config: z.object({
-      messaging: z.object({}).optional(),
-      group_configs: z
-        .union([z.string(), z.array(z.unknown())])
-        .optional()
-        .describe("群配置来源（二选一）：静态数组 [{groupId, outbound, credRef}]，或引用 ${globalVar.group_configs}（config-sync 从 AI 表格发布）。缺省取后者。按群路由出站方式与凭据引用"),
-    }),
-  },
-
-  async execute(ctx: RecipeContext): Promise<RecipeResult> {
-    const { input, toolkit, log } = ctx;
-    const answer = String(input.answer ?? "");
-    const conversationId = String(input.conversationId ?? "");
-    const action = String(input.action ?? "").trim();
-    const mentionUserId = String(input.mention_user_id ?? "").trim();
-    const groupsSource = ctx.config.group_configs ?? "${globalVar.group_configs}";
-    // 关联键：让发送事实/失败事件能回指原始提问（复盘配对首次响应）；缺 content 时不写脏字段
-    const question = questionKey(String(input.content ?? ""));
-    const questionMeta = question ? { question } : {};
-
-    if (!answer.trim()) { log("无回答内容（静默），跳过"); return { status: "success", output: { reply_status: "静默" }, tracker: false, logs: ["跳过：无回答（静默）"] }; }
-    if (!conversationId) { log("缺少群ID，跳过"); return { status: "success", output: {}, tracker: false, logs: ["跳过：群ID 为空"] }; }
-
-    const isEscalation = needsOwnerResolution(action as SupportAction);
-    const group = loadGroupConfig(ctx, groupsSource, conversationId);
-    const options: ReplyToConversationOptions = {};
-    let outboundAnswer = answer;
-    if (group?.outbound === "webhook") {
-      options.preferWebhook = true;
-      if (group.credRef) options.credRef = group.credRef;
-      if (!String(group.corpId ?? "").trim()) {
-        // 当前群配置是发送时事实源：即使 WorkItem 带着旧 eventContext / mention_user_id，
-        // corpId 缺失时也必须关闭所有 Webhook @ 并清除正文里的历史数字占位符。
-        options.mentionSender = false;
-        outboundAnswer = downgradeOwnerPlaceholder(outboundAnswer, mentionUserId);
-        log(`Webhook 群 ${conversationId} 未配置 corpId，本次发送禁用 @ 人`);
-      }
-    }
-    // Owner @人（与尾注渲染同源）：只有 on_action 已确认可在当前群真实 @
-    // 时 mention_user_id 才非空；否则保持缺省，仅 @提问者。
-    const webhookMentionAllowed = group?.outbound !== "webhook" || Boolean(String(group.corpId ?? "").trim());
-    if (isEscalation && mentionUserId && webhookMentionAllowed) {
-      options.mentionUserIds = [mentionUserId];
-    }
-    const ownerMentioned = Boolean(options.mentionUserIds?.length);
-
-    try {
-      const res = await toolkit.messaging.replyToConversation(conversationId, outboundAnswer, options);
-      const via = res.via;
-      const reason = res.reason;
-      if (via === "skipped") {
-        log(`未能发送到群 ${conversationId} (via=skipped${reason ? `, reason=${reason}` : ""})`);
-        const skipReason = reason ?? "无可用出站通道";
-        // 重试风暴去重：同群+同待发内容+同原因在窗口内只留痕一次，重试只写日志
-        if (sendFailureWindow.mark(ctx.getGlobalVar, ctx.setGlobalVar, conversationId, outboundAnswer, `skipped:${skipReason}`)) {
-          try {
-            await toolkit.memory.append(
-              supportScope(conversationId),
-              supportEntry({
-                kind: SUPPORT_MEMORY_KINDS.sendFailed,
-                content: outboundAnswer,
-                sender: "agent",
-                role: SUPPORT_MEMORY_ROLES.agent,
-                conversationId,
-                summary: `发送失败(via=skipped): ${skipReason}`,
-                meta: { sendStatus: "failed", via, ...questionMeta, ...(reason ? { reason } : {}) },
-              }),
-            );
-          } catch (memErr) {
-            log(`memory.append(send_failed) 失败(不影响主流程): ${memErr instanceof Error ? memErr.message : String(memErr)}`);
-          }
-        } else {
-          log("同一发送失败已在近期留痕，本次重试不重复写短期记忆");
-        }
-        return {
-          status: "failed",
-          output: {},
-          error: `发送群消息失败(via=skipped): ${skipReason}`,
-          // 配置错误（如 credRef 未命中 webhook_creds）改配置才能修，重试只会空转
-          ...(res.configError ? { retryable: false } : {}),
-          logs: [`未发送(via=skipped)：${conversationId}`],
-        };
-      }
-      log(`已发送到群 ${conversationId} (via=${via}${reason ? `, reason=${reason}` : ""})`);
-      // 回声防护：发布出站内容指纹（conversation_handler 据此识别回流消息）
-      try {
-        echoWindow.mark(ctx.getGlobalVar, ctx.setGlobalVar, outboundAnswer);
-      } catch (fpErr) {
-        log(`发布回声指纹失败(不影响主流程): ${fpErr instanceof Error ? fpErr.message : String(fpErr)}`);
-      }
-      try {
-        await toolkit.memory.append(
-          supportScope(conversationId),
-          supportEntry({
-            kind: isEscalation
-              ? SUPPORT_MEMORY_KINDS.ownerEscalationSent
-              : SUPPORT_MEMORY_KINDS.agentReplySent,
-            content: outboundAnswer,
-            sender: "agent",
-            role: SUPPORT_MEMORY_ROLES.agent,
-            conversationId,
-            summary: `已发送(via=${via}${ownerMentioned ? `, @Owner=${mentionUserId}` : ""}): ${outboundAnswer.slice(0, 80)}`,
-            meta: { sendStatus: "sent", via, ...questionMeta, ...(action ? { action } : {}), ...(ownerMentioned ? { ownerUserId: mentionUserId } : {}) },
-          }),
-        );
-      } catch (memErr) {
-        log(`memory.append(reply_sent) 失败(不影响主流程): ${memErr instanceof Error ? memErr.message : String(memErr)}`);
-      }
-      return { status: "success", output: { reply_status: "已回复" }, logs: [`已发送(via=${via})：${conversationId}`] };
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      log(`发送失败: ${msg}`);
-      // 与 skipped 分支同源的重试风暴去重（异常原因不同则各记一次）
-      if (sendFailureWindow.mark(ctx.getGlobalVar, ctx.setGlobalVar, conversationId, outboundAnswer, `error:${msg}`)) {
-        try {
-          await toolkit.memory.append(
-            supportScope(conversationId),
-            supportEntry({
-              kind: SUPPORT_MEMORY_KINDS.sendFailed,
-              content: outboundAnswer,
-              sender: "agent",
-              role: SUPPORT_MEMORY_ROLES.agent,
-              conversationId,
-              summary: `发送失败: ${msg}`,
-              meta: { sendStatus: "failed", error: msg, ...questionMeta },
-            }),
-          );
-        } catch (memErr) {
-          log(`memory.append(send_failed) 失败(不影响主流程): ${memErr instanceof Error ? memErr.message : String(memErr)}`);
-        }
-      } else {
-        log("同一发送失败已在近期留痕，本次重试不重复写短期记忆");
-      }
-      return { status: "failed", output: {}, error: `发送群消息失败: ${msg}`, logs: [`发送失败: ${msg}`] };
-    }
-  },
-};
-
-export default recipe;