aitable-workflow-cli 0.1.15 → 0.1.16-beta.1786022310508

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aitable-workflow-cli",
-  "version": "0.1.15",
+  "version": "0.1.16-beta.1786022310508",
   "description": "aitable-workflow 命令行工具(cli):init/design/setup/run/serve 等命令;含 relay 本地反连客户端与 daemon 进程管理。bin: aitable-workflow。",
   "type": "module",
   "bin": {
@@ -19,8 +19,8 @@
     "access": "public"
   },
   "dependencies": {
-    "aitable-workflow-core": "0.1.15",
-    "aitable-workflow-server": "0.1.15",
+    "aitable-workflow-core": "0.1.16-beta.1786022310508",
+    "aitable-workflow-server": "0.1.16-beta.1786022310508",
     "@inquirer/prompts": "^8.5.2",
     "commander": "^14.0.2",
     "dotenv": "^17.4.2",

package/templates/support-qa/lib/__tests__/declarative-matcher.test.ts

@@ -0,0 +1,240 @@
+/**
+ * 声明式规则匹配引擎（support-qa/lib/declarative-matcher）
+ *
+ * 断言逐条沿用迁移前的用例，锁死四条硬不变量：
+ *   单向匹配 / 只看用户本轮新话（剥离引用块）/ safety 看全文 / 优雅关闭。
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import {
+  loadReplyRules,
+  matchReplyRules,
+  stripQuotedBlock,
+  loadClassifierRules,
+  classifyMessage,
+  isCapabilityEnabled,
+  isGroupToggleEnabled,
+} from "../declarative-matcher.js";
+
+describe("loadReplyRules / matchReplyRules：声明式秒回规则 + 单向匹配 + 安全兜底", () => {
+  let dir: string;
+  beforeEach(async () => { dir = await mkdtemp(path.join(os.tmpdir(), "sq-fp-lib-")); });
+  afterEach(async () => { await rm(dir, { recursive: true, force: true }); });
+
+  async function writeRules(text: string): Promise<string> {
+    await mkdir(path.join(dir, "profile", "fastpath"), { recursive: true });
+    await writeFile(path.join(dir, "profile", "fastpath", "known-answers.yml"), text, "utf8");
+    return "fastpath/known-answers.yml";
+  }
+
+  it("未配置 rules → config=null（fastpath 关闭）", () => {
+    expect(loadReplyRules(dir, undefined).config).toBeNull();
+    expect(loadReplyRules(dir, "").config).toBeNull();
+  });
+
+  it("文件缺失 → config=null + issue（优雅关闭，不阻断）", () => {
+    const r = loadReplyRules(dir, "fastpath/missing.yml");
+    expect(r.config).toBeNull();
+    expect(r.issues.join("|")).toContain("不存在");
+  });
+
+  it("contains 单向匹配：消息包含规则模式命中；反向（规则含消息）绝不命中（修早期双向 includes bug）", async () => {
+    const rel = await writeRules([
+      "rules:",
+      "  - { key: row_limit, contains: 多少行, reply: 单表上限 20 万行。 }",
+    ].join("\n"));
+    const { config } = loadReplyRules(dir, rel);
+    // 正向：消息包含 "多少行" → 命中
+    expect(matchReplyRules(config, "请问单表支持多少行数据")).toMatchObject({ key: "row_limit", kind: "contains" });
+    // 反向：消息 "行" 是规则模式的子串，但消息不包含规则模式 → 绝不命中
+    expect(matchReplyRules(config, "行")).toBeNull();
+    expect(matchReplyRules(config, "多少")).toBeNull();
+  });
+
+  it("regex / template / 未命中", async () => {
+    const rel = await writeRules([
+      "rules:",
+      "  - { key: rx, regex: '(最多|上限).{0,4}行', reply: R1 }",
+      "  - { key: tpl, template: '完全固定的问法', reply: R2 }",
+    ].join("\n"));
+    const { config } = loadReplyRules(dir, rel);
+    expect(matchReplyRules(config, "最多几行")).toMatchObject({ key: "rx", kind: "regex" });
+    expect(matchReplyRules(config, "  完全固定的问法 ")).toMatchObject({ key: "tpl", kind: "template" }); // 空白归一
+    expect(matchReplyRules(config, "完全固定的问法啊")).toBeNull(); // template 需全等
+    expect(matchReplyRules(config, "无关消息")).toBeNull();
+  });
+
+  it("safety 安全兜底优先级最高（先于普通规则）", async () => {
+    const rel = await writeRules([
+      "safety: { keywords: [涉及敏感内容], reply: 安全话术 }",
+      "rules:",
+      "  - { key: any, contains: 内容, reply: 普通话术 }",
+    ].join("\n"));
+    const { config } = loadReplyRules(dir, rel);
+    expect(matchReplyRules(config, "这条涉及敏感内容的消息")).toMatchObject({ key: "safety", kind: "safety", reply: "安全话术" });
+  });
+
+  it("规则形状非法 → 记 issue 并跳过（多选/缺 reply/非法正则）", async () => {
+    const rel = await writeRules([
+      "rules:",
+      "  - { key: multi, contains: a, regex: b, reply: R }",   // 多选
+      "  - { key: noreply, contains: c }",                      // 缺 reply
+      "  - { key: badrx, regex: '(', reply: R }",               // 非法正则
+      "  - { key: ok, contains: 有效, reply: OK }",
+    ].join("\n"));
+    const { config, issues } = loadReplyRules(dir, rel);
+    expect(config.rules).toHaveLength(1);
+    expect(config.rules[0].key).toBe("ok");
+    expect(issues.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("stripQuotedBlock：剥离「引用消息:」块，只保留用户本轮新话", () => {
+    expect(stripQuotedBlock("引用字段是复制的内容\n\n引用消息: Hi u，你遇到的错误「所选字段形成循环引用」…"))
+      .toBe("引用字段是复制的内容");
+    // 全角冒号变体
+    expect(stripQuotedBlock("新话\n\n引用消息：旧报错文案")).toBe("新话");
+    // 无引用块 → 原文不变
+    expect(stripQuotedBlock("普通消息")).toBe("普通消息");
+    // 剥离后为空（只转发引用未说话）→ 回退原文，不制造空消息
+    const onlyQuote = "引用消息: AI字段配置异常，请检查后重试";
+    expect(stripQuotedBlock(onlyQuote)).toBe(onlyQuote);
+  });
+
+  it("报错文案只在引用块里（g4-21 型追问）→ fastpath 不命中，不复读", async () => {
+    const rel = await writeRules([
+      "rules:",
+      "  - { key: cycle, contains: 所选字段形成循环引用, reply: 循环引用话术 }",
+    ].join("\n"));
+    const { config } = loadReplyRules(dir, rel);
+    const followUp = "@Felix 引用字段是复制的内容，不存在引用字段是其他ai生成\n\n引用消息: Hi 甘燕威,你遇到的错误「所选字段形成循环引用，数据处理异常，请检查」,以下是相关说明和解决方案:…";
+    expect(matchReplyRules(config, followUp)).toBeNull();
+    // 用户自己粘报错（无引用块）→ 仍然秒回
+    expect(matchReplyRules(config, "报错了：所选字段形成循环引用，数据处理异常，请检查"))
+      .toMatchObject({ key: "cycle" });
+  });
+
+  it("safety 关键词藏在引用块里 → 仍然拦（安全兜底不剥离，防注入藏引用）", async () => {
+    const rel = await writeRules([
+      "safety: { keywords: [涉及敏感内容], reply: 安全话术 }",
+      "rules:",
+      "  - { key: any, contains: 无关, reply: 普通 }",
+    ].join("\n"));
+    const { config } = loadReplyRules(dir, rel);
+    expect(matchReplyRules(config, "这条怎么回\n\n引用消息: 本内容涉及敏感内容无法生成"))
+      .toMatchObject({ key: "safety", kind: "safety" });
+  });
+});
+
+describe("loadClassifierRules / classifyMessage：声明式分类器 + 整档/群开关", () => {
+  let dir: string;
+  beforeEach(async () => { dir = await mkdtemp(path.join(os.tmpdir(), "sq-ts-lib-")); });
+  afterEach(async () => { await rm(dir, { recursive: true, force: true }); });
+
+  async function writeClassifiers(text: string): Promise<string> {
+    await mkdir(path.join(dir, "profile", "troubleshoot"), { recursive: true });
+    await writeFile(path.join(dir, "profile", "troubleshoot", "classifiers.yml"), text, "utf8");
+    return "troubleshoot/classifiers.yml";
+  }
+
+  it("未配置 / 文件缺失 → config=null", () => {
+    expect(loadClassifierRules(dir, undefined).config).toBeNull();
+    const r = loadClassifierRules(dir, "troubleshoot/missing.yml");
+    expect(r.config).toBeNull();
+    expect(r.issues.join("|")).toContain("不存在");
+  });
+
+  it("单条件 contains 命中 + extract 提取字段", async () => {
+    const rel = await writeClassifiers([
+      "classifiers:",
+      "  - issueType: err",
+      "    reason: 命中报错",
+      "    patterns: [{ contains: ERR_X }]",
+      "    extract: { code: 'ERR_X[0-9]+' }",
+    ].join("\n"));
+    const { config } = loadClassifierRules(dir, rel);
+    const r = classifyMessage(config, "出现了 ERR_X42 报错");
+    expect(r).toMatchObject({ issueType: "err", reason: "命中报错" });
+    expect(r.extracted.code).toBe("ERR_X42");
+    expect(classifyMessage(config, "无关消息")).toBeNull();
+  });
+
+  it("require_all：需全部 pattern 命中（双关键词共现）", async () => {
+    const rel = await writeClassifiers([
+      "classifiers:",
+      "  - issueType: ds",
+      "    require_all: true",
+      "    patterns: [{ contains: docKey }, { contains: 时间戳 }]",
+    ].join("\n"));
+    const { config } = loadClassifierRules(dir, rel);
+    expect(classifyMessage(config, "docKey=abc 时间戳=123")).toMatchObject({ issueType: "ds" });
+    expect(classifyMessage(config, "只有 docKey=abc")).toBeNull();
+  });
+
+  it("regex 命中 + 声明顺序返回第一个满足", async () => {
+    const rel = await writeClassifiers([
+      "classifiers:",
+      "  - issueType: a",
+      "    patterns: [{ regex: '错误码\\d{3}' }]",
+      "  - issueType: b",
+      "    patterns: [{ contains: 错误 }]",
+    ].join("\n"));
+    const { config } = loadClassifierRules(dir, rel);
+    expect(classifyMessage(config, "错误码500")).toMatchObject({ issueType: "a" });
+    expect(classifyMessage(config, "只是错误描述")).toMatchObject({ issueType: "b" });
+  });
+
+  it("classifier 可从 profile 透传精确 Owner module（未声明则不带 module 字段）", async () => {
+    const rel = await writeClassifiers([
+      "classifiers:",
+      "  - issueType: ai_field",
+      "    module: AI字段",
+      "    patterns: [{ contains: 'Sheet ID:' }]",
+      "  - issueType: other",
+      "    patterns: [{ contains: 其它 }]",
+    ].join("\n"));
+
+    const { config } = loadClassifierRules(dir, rel);
+    expect(classifyMessage(config, "失败\nSheet ID: sht1")).toMatchObject({
+      issueType: "ai_field",
+      module: "AI字段",
+    });
+    const other = classifyMessage(config, "其它问题");
+    expect(other!.issueType).toBe("other");
+    expect(other!.module).toBeUndefined();
+  });
+
+  it("形状非法分类器跳过 + 记 issue", async () => {
+    const rel = await writeClassifiers([
+      "classifiers:",
+      "  - reason: 缺 issueType",
+      "    patterns: [{ contains: x }]",
+      "  - issueType: nopat",
+      "    patterns: []",
+      "  - issueType: ok",
+      "    patterns: [{ contains: 有效 }]",
+    ].join("\n"));
+    const { config, issues } = loadClassifierRules(dir, rel);
+    expect(config.classifiers).toHaveLength(1);
+    expect(config.classifiers[0].issueType).toBe("ok");
+    expect(issues.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("isCapabilityEnabled：skills_dir 未配/不存在→false；存在→true（整档关闭）", async () => {
+    expect(isCapabilityEnabled(dir, undefined)).toBe(false);
+    expect(isCapabilityEnabled(dir, "skills/troubleshooting")).toBe(false);
+    await mkdir(path.join(dir, "skills", "troubleshooting"), { recursive: true });
+    expect(isCapabilityEnabled(dir, "skills/troubleshooting")).toBe(true);
+  });
+
+  it("isGroupTroubleshootingEnabled：仅明确开启的群为真", () => {
+    const groups = [{ groupId: "c1", troubleshootingEnabled: true }, { groupId: "c2", troubleshootingEnabled: false }, { groupId: "c3" }];
+    expect(isGroupToggleEnabled(groups, "c1", "troubleshootingEnabled")).toBe(true);
+    expect(isGroupToggleEnabled(groups, "c2", "troubleshootingEnabled")).toBe(false);
+    expect(isGroupToggleEnabled(groups, "c3", "troubleshootingEnabled")).toBe(false);
+    expect(isGroupToggleEnabled(groups, "cX", "troubleshootingEnabled")).toBe(false);
+    expect(isGroupToggleEnabled(undefined, "c1", "troubleshootingEnabled")).toBe(false);
+  });
+});

package/templates/support-qa/lib/__tests__/dingtalk-group-membership.test.ts

@@ -0,0 +1,127 @@
+/**
+ * 群成员在群判定（support-qa/lib/dingtalk-group-membership）
+ *
+ * 核心不变量：**任何失败都降级为 { mode: "name" }，绝不抛错**。
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import {
+  resolveGroupMention,
+  resetGroupMembershipCache,
+} from "../dingtalk-group-membership.js";
+import { DwsClient } from "aitable-workflow-core";
+import type { CommandRunner } from "aitable-workflow-core";
+
+const CONTACT = { userId: "239198", openDingTalkId: "open-owner" };
+
+/** 用注入的 dws stub 替代真实命令 */
+function fakeDws(runJson: (args: string[]) => Promise<unknown>) {
+  return { runJson: vi.fn(async (args: string[]) => runJson(args)) };
+}
+
+beforeEach(() => {
+  resetGroupMembershipCache();
+});
+
+describe("resolveGroupMention — 判定与降级", () => {
+  it("list-by-ids 命中 → 真实 @", async () => {
+    const dws = fakeDws(async () => ({ result: { members: [{ openDingtalkId: "open-owner" }] } }));
+    await expect(resolveGroupMention("cid1", CONTACT, { dws, now: () => 1 }))
+      .resolves.toEqual({ mode: "at", userId: "239198" });
+  });
+
+  it("不在群 / 非结构化响应 / 抛错 → 一律降级 name", async () => {
+    for (const response of [
+      { result: { members: [] } },
+      { result: {} },
+      "not-an-object",
+      null,
+      { unexpected: true },
+    ]) {
+      resetGroupMembershipCache();
+      const dws = fakeDws(async () => response);
+      await expect(resolveGroupMention("cid1", CONTACT, { dws, now: () => 1 }))
+        .resolves.toEqual({ mode: "name" });
+    }
+
+    resetGroupMembershipCache();
+    const boom = fakeDws(async () => { throw new Error("timeout"); });
+    await expect(resolveGroupMention("cid1", CONTACT, { dws: boom, now: () => 1 }))
+      .resolves.toEqual({ mode: "name" });
+  });
+
+  it("两种 openDingTalkId 拼写都能匹配（不同 dws 版本返回不一致）", async () => {
+    for (const key of ["openDingTalkId", "openDingtalkId"]) {
+      resetGroupMembershipCache();
+      const dws = fakeDws(async () => ({ result: { members: [{ [key]: "open-owner" }] } }));
+      await expect(resolveGroupMention("cid1", CONTACT, { dws, now: () => 1 }))
+        .resolves.toEqual({ mode: "at", userId: "239198" });
+    }
+  });
+
+  it("缺 openDingTalkId / userId / 群ID → 直接降级 name 且不调 dws", async () => {
+    const dws = fakeDws(async () => ({ result: { members: [{ openDingTalkId: "open-owner" }] } }));
+    await expect(resolveGroupMention("cid1", { userId: "239198" }, { dws, now: () => 1 }))
+      .resolves.toEqual({ mode: "name" });
+    await expect(resolveGroupMention("cid1", { userId: "", openDingTalkId: "open-owner" }, { dws, now: () => 1 }))
+      .resolves.toEqual({ mode: "name" });
+    await expect(resolveGroupMention("", CONTACT, { dws, now: () => 1 }))
+      .resolves.toEqual({ mode: "name" });
+    expect(dws.runJson).not.toHaveBeenCalled();
+  });
+
+  it("不手写 --format json（由 DwsClient 统一追加）", async () => {
+    let seen: string[] = [];
+    const dws = fakeDws(async (args) => { seen = args; return { result: { members: [] } }; });
+    await resolveGroupMention("cid1", CONTACT, { dws, now: () => 1 });
+    expect(seen).toEqual([
+      "chat", "group", "members", "list-by-ids", "--id", "cid1", "--users", "open-owner",
+    ]);
+  });
+});
+
+describe("resolveGroupMention — 缓存", () => {
+  it("同群同人 10min 内命中缓存，过期后重新判定", async () => {
+    const dws = fakeDws(async () => ({ result: { members: [{ openDingTalkId: "open-owner" }] } }));
+    await resolveGroupMention("cid1", CONTACT, { dws, now: () => 1 });
+    await resolveGroupMention("cid1", CONTACT, { dws, now: () => 599_999 });
+    expect(dws.runJson).toHaveBeenCalledTimes(1);
+    await resolveGroupMention("cid1", CONTACT, { dws, now: () => 600_002 });
+    expect(dws.runJson).toHaveBeenCalledTimes(2);
+  });
+
+  it("降级结果同样进缓存（避免故障期每条消息都重试查询）", async () => {
+    const dws = fakeDws(async () => ({ result: { members: [] } }));
+    await resolveGroupMention("cid1", CONTACT, { dws, now: () => 1 });
+    await resolveGroupMention("cid1", CONTACT, { dws, now: () => 2 });
+    expect(dws.runJson).toHaveBeenCalledTimes(1);
+  });
+
+  it("不同群 / 不同人各自独立缓存", async () => {
+    const dws = fakeDws(async () => ({ result: { members: [{ openDingTalkId: "open-owner" }] } }));
+    await resolveGroupMention("cid1", CONTACT, { dws, now: () => 1 });
+    await resolveGroupMention("cid2", CONTACT, { dws, now: () => 1 });
+    await resolveGroupMention("cid1", { userId: "999", openDingTalkId: "open-other" }, { dws, now: () => 1 });
+    expect(dws.runJson).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe("走 DwsClient 带来的可观测性收益", () => {
+  it("dws 首次抖动后重试仍能判出 at（迁移前会直接降级为花名）", async () => {
+    let attempts = 0;
+    const runner: CommandRunner = async () => {
+      attempts += 1;
+      if (attempts === 1) throw new Error("ETIMEDOUT");
+      return {
+        stdout: JSON.stringify({ result: { members: [{ openDingTalkId: "open-owner" }] } }),
+        stderr: "",
+        exitCode: 0,
+      };
+    };
+
+    const dws = new DwsClient({ bin: "dws", runner });
+    await expect(resolveGroupMention("cid1", CONTACT, { dws, now: () => 1 }))
+      .resolves.toEqual({ mode: "at", userId: "239198" });
+    expect(attempts).toBeGreaterThan(1);
+  });
+});

package/templates/support-qa/lib/__tests__/memory-events.test.ts

@@ -0,0 +1,90 @@
+/**
+ * 场景记忆事件工厂（support-qa/lib/memory-events）
+ *
+ * 锁定：scope 常量一致性，entry 形状与 questionKey 归一行为。
+ */
+
+import { describe, it, expect } from "vitest";
+import { supportScope, supportEntry, questionKey } from "../memory-events.js";
+
+describe("supportScope", () => {
+  it("带 conversationId 时按会话隔离", () => {
+    expect(supportScope("cid1")).toEqual({
+      channel: "dingtalk",
+      scenario: "support-qa",
+      conversationId: "cid1",
+    });
+  });
+
+  it("省略 conversationId 时为场景级 scope（长期记忆读写用）", () => {
+    expect(supportScope()).toEqual({ channel: "dingtalk", scenario: "support-qa" });
+  });
+
+  it("空串 conversationId 不写入字段（避免脏 scope 分裂记忆）", () => {
+    expect(supportScope("")).toEqual({ channel: "dingtalk", scenario: "support-qa" });
+  });
+});
+
+describe("supportEntry", () => {
+  it("summary 省略时按 `sender: 正文前 80 字` 生成", () => {
+    const e = supportEntry({
+      kind: "user_message",
+      content: "x".repeat(200),
+      sender: "小明",
+      role: "user",
+      conversationId: "cid1",
+    });
+    expect(e.summary).toBe(`小明: ${"x".repeat(80)}`);
+    expect(e.kind).toBe("user_message");
+    expect(e.content).toHaveLength(200);
+  });
+
+  it("meta 固定带 sender/role/conversationId，且调用方 meta 可追加", () => {
+    const e = supportEntry({
+      kind: "agent_decision",
+      content: "(已决策回复)",
+      sender: "agent",
+      role: "agent",
+      conversationId: "cid9",
+      meta: { action: "reply", question: "上限多少" },
+    });
+    expect(e.meta).toEqual({
+      sender: "agent",
+      role: "agent",
+      conversationId: "cid9",
+      action: "reply",
+      question: "上限多少",
+    });
+  });
+
+  it("显式 summary / timestamp 优先", () => {
+    const e = supportEntry({
+      kind: "send_failed",
+      content: "正文",
+      sender: "agent",
+      role: "agent",
+      conversationId: "cid1",
+      summary: "发送失败(via=skipped)",
+      timestamp: "2026-08-05T00:00:00.000Z",
+    });
+    expect(e.summary).toBe("发送失败(via=skipped)");
+    expect(e.timestamp).toBe("2026-08-05T00:00:00.000Z");
+  });
+
+  it("timestamp 省略时为 ISO 串", () => {
+    const e = supportEntry({
+      kind: "user_message", content: "c", sender: "s", role: "user", conversationId: "cid",
+    });
+    expect(e.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z$/);
+  });
+});
+
+describe("questionKey", () => {
+  it("折叠空白并 trim（复盘配对锚点稳定）", () => {
+    expect(questionKey("  上限\n是\t多少  ")).toBe("上限 是 多少");
+  });
+
+  it("截断到 120 字", () => {
+    expect(questionKey("问".repeat(300))).toHaveLength(120);
+  });
+});

package/templates/support-qa/lib/action-dispatch.ts

@@ -71,7 +71,7 @@ export function renderOwnerMention(
 
 // ─── 内部文案（不进 Profile 配置面） ─────────────────────
 
-// Owner 尾注（追加在主体之后）。话术对齐 aitable-handoff 基线的引导式口吻：
+// Owner 尾注（追加在主体之后）。话术用引导式口吻：
 // 「建议在群内 @X 帮你看一下」——不谎称已通知（是否真实 @ 到人由发送层 atUserIds 决定）；
 // mention 两侧已带空格，模板不再额外加空格
 const BUG_FOOTER = (mention: string, module: string) =>