dsh-bagu 0.3.1 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1,138 +1,164 @@
1
1
  # dsh-bagu
2
2
 
3
- > 名字来自「八股文」——那种格式对仗、内容空洞、谁都能写的东西。
3
+ > AI 要对外说话之前的一道门。过了就发,没过就打回。
4
4
 
5
- ## 一句话:它是干什么的
5
+ ## 这是什么
6
6
 
7
- **你把一段话粘进去,它告诉你这段话里有没有「谁都能说」的成分。**
7
+ 用在所有「AI 写的东西要被人看到」的地方:
8
8
 
9
- 不改你的字,不给分数,只指出哪几处可疑,然后问你几个问题。
9
+ - **DSH 会话** —— agent 回复之前先过一遍
10
+ - **QQ 机器人 / 养鱼** —— 每条消息发出前
11
+ - **B站评论区、贴吧发帖** —— 公开回复
10
12
 
11
- ## 什么是「八股」
13
+ AI 在这些地方会写出这种话:
12
14
 
13
- 一句话,换个人说,还成不成立?
15
+ ```
16
+ 这条我认!首先态度要正,其次内容要实,最后要持续更新。
17
+ 这个视频真的很不错,非常值得一看!
18
+ 感谢分享!这个视频通过生动有趣的方式展示了相关内容,受益匪浅。
19
+ ```
14
20
 
15
- - 成立 → 就是八股。谁都能说的话,慢慢就没人想看了。
16
- - 不成立 → 这段话里有只有你才给得出的东西。
21
+ **这个插件在发出去之前拦一道。** 通过就发,没过就打回,附一句怎么改。
17
22
 
18
- 看两个例子就懂了:
23
+ ## 一句话判断
24
+
25
+ 换个人说,还成不成立?成立,就是八股。
19
26
 
20
27
  ```text
21
- 差的:「本次修改已完成。首先调整了章节结构,其次新增了规则条款,最后优化了可读性。
22
- 综上所述,这次改动具有重要意义。」
28
+ 「卖卡卖完了随便写了」 → 能发(编不出来)
29
+ 「这个视频真的很不错」 → 打回(谁都能说)
30
+ ```
23
31
 
24
- 好的:「改了 AGENTS.md,加了 §4。第七页那个表我删了,因为原来那三列一直是空的。」
32
+ ## 怎么用
33
+
34
+ agent 每次要发消息之前,调一次:
35
+
36
+ ```js
37
+ bagu_guard({ text: "这条我认!首先态度要正,其次内容要实,最后要持续更新。" })
38
+ → "改:模板三连 · 直接说事,不用「首先其次最后」"
25
39
  ```
26
40
 
27
- 第一段把「AGENTS.md」换成任何文件名都通顺,所以它是八股。
28
- 第二段提到了第七页、提到了一个空表——别人编不出来。
41
+ 过了就回 `OK`,两个字。
29
42
 
30
- ## 它看哪四样东西
43
+ **输出预算:通过 2 字,打回一行 40 字以内。** 每次都要烧 token,多一个字都是成本。
31
44
 
32
- | 看什么 | 具体抓什么 | 为什么算数 |
33
- |---|---|---|
34
- | **具体物** | 数字、时间点、「我试过」、原话、专有名字 | 只有真在场的人才给得出 |
35
- | **撑场面的话** | 意义 / 价值 / 本质 / 趋势,重要 / 关键 / 深刻 | 说得越多,越是在给事加光 |
36
- | **留白词** | 好像 / 应该 / 大概 / 可能 | 一个都没有 = 句句在下断言 |
37
- | **结构腔** | 不是A而是B、先…再…、三段并列、破折号 | 真人用,但密度极低,超基线才报 |
45
+ ## 拦什么
38
46
 
39
- 外加一个**同义轮换**:同一段里「使用 / 采用 / 运用」挑了两个以上。真人会反复用同一个词,换着说是心虚。
47
+ 按严重度排,只报第一条——报三条 agent 会挑最轻的改。
40
48
 
41
- ## 装
49
+ | 拦什么 | 例子 |
50
+ |---|---|
51
+ | 模板三连 | 首先…其次…最后… |
52
+ | 单列首先 | 「首先,我们需要明确目标。」 |
53
+ | 对举(四种写法) | 不是A而是B/不在于A而在于B/与其说A不如说B/看似A实则B |
54
+ | 反问式对举 | 难道这不是认知问题吗 |
55
+ | 套话整句 | 这条我认/本鱼记下了/感谢分享/受益匪浅/说白了就是 |
56
+ | 同义轮换 | 使用了新方法,采用了更好的方式 |
57
+ | 八股词 | 综上所述、底层逻辑、形成闭环、赋能 |
58
+ | 三段并列 | A、B、C 排一串 |
59
+ | 开头就总结 | 总之、总的来说 |
60
+ | 空夸 | 真的很不错,非常值得一看 |
61
+ | 同构短句排比 | 很强。很方便。很实用。 |
62
+ | 破折号 | ——(仅严格模式) |
63
+
64
+ ## 实测三组数据
65
+
66
+ 这套规则跑过三组样本,结果都在 `tools/` 里可复现:
67
+
68
+ | 测试 | 样本 | 结果 |
69
+ |---|---|---|
70
+ | 真实场景(DSH/评论/机器人) | 25 条 | 漏 0,误拦 0 |
71
+ | AI 八股(客服腔/对举/空夸/模板) | 35 条 | 拦住 35(100%) |
72
+ | 真人原话(DSH 会话 + 贴吧 + 聊天) | 51 条 | 误拦 0(0%) |
42
73
 
43
74
  ```sh
44
- dsh plugin --profile web add dsh-bagu
75
+ node tools/audit.mjs # 真实场景 25 条
76
+ node tools/missrate.mjs # AI 八股 35 条,看拦截率
77
+ node tools/falserate.mjs # 真人原话 51 条,看误拦率
78
+ node tools/evasion.mjs # 对抗测试:故意绕开规则
45
79
  ```
46
80
 
47
- 装完重启一次 dsh。然后在**设置 → 八股检测**里能看到这一页。
81
+ ## 它拦不住什么
48
82
 
49
- ## 怎么用
83
+ 对抗测试(`evasion.mjs`)里,10 种绕过手法拦住了 6 种。剩下 4 种是已知边界:
50
84
 
51
- **方式一 · 让它自己查。** 你写完一段话,跟它说:
85
+ - **换同义词** —— 「功能多牛啊,用起来也顺手」,词换了形状没换,但不在表里
86
+ - **换成英文** —— 英文只做了留白词,句式没做
87
+ - **加脏话伪装** —— 「真他妈不错」,脏话把评价词淹了
88
+ - **去掉分组标记** —— 「目标是明确的,任务是拆过的,复盘也做了」
52
89
 
53
- ```
54
- 帮我查查这段有没有八股味
55
- ```
90
+ **规则只能认形状,认不了「这句话是不是真的」。** 这是一个止血带,不是解药。
56
91
 
57
- 它会调 `bagu_check`,回三行:
92
+ ## 跟 DSH 会话怎么接
58
93
 
59
- ```text
60
- 可疑 具体0 抽象1 评价1 留白0 结构0/千
61
- · 综上所述
62
- 问 「综上所述」—— 这几个词,换成平时说话你会怎么讲?
63
- ```
94
+ DSH 有 `agent/pre-step` 这个 waterfall 钩子,能拿到本轮要发出去的 `messages` 并改它。
95
+ 理论上可以在那里挂自动改写。**现在没有做**——`bagu_guard` 是个工具,靠 agent 自己调。
64
96
 
65
- 想要详细报告,加一句「完整报告」,它传 `full: true`,会给逐处的命中位置和六条问句。
97
+ 要真正变成自动门,得在插件里 `ctx.on('agent/pre-step', ...)` 拦一道。
98
+ 那是下一步的事,不是现在。
66
99
 
67
- **方式二 · 只要问句。**
100
+ ## 装
68
101
 
102
+ ```sh
103
+ dsh plugin --profile web add dsh-bagu
69
104
  ```
70
- 用 bagu_ask 问问我这段话
71
- ```
72
-
73
- 它只给问句,不给结论。答得上就留着,答不上来那处就是摆设。
74
105
 
75
- **方式三 · 设置页里当场试。** 粘一段话点「查一下」,不发送、不落盘。
106
+ 装完重启一次 dsh。**设置 → 八股检测** 里能看到这一页。
76
107
 
77
- ## 它不干什么
108
+ ## 设置页
78
109
 
79
- 这几条先说清楚,免得期待错位。
110
+ - **挡不挡** —— 总开关
111
+ - **多严** —— 正常只拦硬信号;严格连破折号、空夸也拦
112
+ - **提示那一节** —— 关掉只留工具,不往系统提示里塞话
113
+ - **试一段** —— 五种真实样本,当场看能不能过
80
114
 
81
- **它不改写。** 一个字都不动。改是人的事,工具只把材料摆出来。
115
+ ## 一个工具,三种模式
82
116
 
83
- **它不给分数。** 没有「人味 62 分」这种东西。分数会让人只盯数字,不看句子。
84
-
85
- **它不是体检报告。** 它管不了「整段是不是人写的」。通篇一个调子、每段都收个小结论、
86
- 同一件事换个说法又说一遍——这些它看不见,得你自己读。
87
-
88
- **它是体温计,不是退烧药。** 测出来 49/千字,不会让你的话变好。真要让一段话立起来的是
89
- 真实经历、只有你知道的细节、真的想说的观点。这三样插件给不了,模型也长不出来。
117
+ ```js
118
+ bagu_guard({ text }) // 守门(默认),只回 OK 或一行改法
119
+ bagu_guard({ text, mode: 'report' }) // 详细报告,给人看
120
+ bagu_guard({ text, mode: 'ask' }) // 只要问句
121
+ ```
90
122
 
91
- **规则会过期。** 今天有效的识别特征,被写成规则之后,就成了可以绕过去的东西。
92
- 这是个止血带。
123
+ 三个原本是分开的工具,合成一个了——每多一个工具就多一份描述,每次都烧 token。
93
124
 
94
125
  ## 省 token 是怎么做的
95
126
 
96
- 这个插件从设计上就在控制上下文开销:
97
-
98
127
  | 项 | 大小 |
99
128
  |---|---|
100
- | 系统提示注入 | 124 字(每次会话) |
101
- | 两个工具的描述 | 62 字 |
102
- | 默认输出 | 约 60 字(三行) |
129
+ | 系统提示注入 | **31 字** |
130
+ | 工具描述(1 个) | **54 字** |
131
+ | 守门器输出 | 2 字(通过)/40 字内(打回) |
103
132
 
104
- 所有判断都在本地正则里跑完,**不调模型**——这是零 token 成本的那一半。
105
- 要看详细报告才传 `full: true`,那时候才有几百字。
133
+ 固定开销合计 **85 字**,判断全在本地正则里跑完,**不调模型**。
134
+
135
+ 系统提示只有一句:「要发出去的话,先过 bagu_guard。被打回就改,别硬发。」
136
+ 之前那四条写作建议删了——守门器自己会拦,提示里再教一遍是重复投资。
106
137
 
107
138
  ## 短句也能查
108
139
 
109
- 大部分「AI 味检测」靠密度(每百字几个),短句分母太小,等于废掉。
140
+ 聊天回复二三十字是常态,密度指标在这个长度上分母太小。
110
141
 
111
- 这个插件在六十字以下切换成**绝对计数**:不看密度,看命中了什么。
112
- 「不是A而是B」这种句式,出现在一句话里就已经可疑了,跟字数无关。
142
+ 六十字以下切换成**绝对计数**:不看密度,看命中了什么。
113
143
 
114
144
  ```text
115
- 「这不是技术问题,而是认知问题。」 → 可疑
116
- 「卖卡卖完了随便写了」 → 正常
145
+ 「这不是技术问题,而是认知问题。」 → 打回
146
+ 「卖卡卖完了随便写了」 → 能发
117
147
  ```
118
148
 
119
149
  ## 数据从哪来
120
150
 
121
- 权重和基线不是拍的。主要依据:
122
-
123
- - 两轮对照实验,1169 篇 / 520 万字 / 100+ 项指标([lieflat-less-ai-tone](https://github.com/larashero3-dotcom/lieflat-less-ai-tone))
151
+ - 两轮对照实验,1169 篇 / 520 万字([lieflat-less-ai-tone](https://github.com/larashero3-dotcom/lieflat-less-ai-tone))
124
152
  - 10 万条真人评论 vs 2180 条 AI 评论的密度实测
125
- - [sloplint](https://github.com/DW-Studio/sloplint) 的评分公式(绝对命中 + 权重,短文本可用)
153
+ - [sloplint](https://github.com/DW-Studio/sloplint) 的评分公式
126
154
 
127
155
  ## 开发
128
156
 
129
157
  ```sh
130
- npm test # 41 个
131
- node preview.html # 需要起个本地服务器看 UI
158
+ npm test # 50 个单元测试
159
+ node tools/audit.mjs
132
160
  ```
133
161
 
134
- 设置页的样稿在 `preview.html`,起个 `python -m http.server` 打开就能看,不用装 DSH。
135
-
136
162
  ## 许可
137
163
 
138
164
  MIT。
package/client.js CHANGED
@@ -1,12 +1,14 @@
1
1
  /**
2
2
  * dsh-bagu —— 浏览器半端:设置页「八股检测」
3
3
  *
4
- * 约定:
5
- * 1. client bundle 不是 ESM,是自注册脚本
6
- * 2. 进「设置」靠 slots.inject('settings.section', ...)
7
- * 3. 宿主开 /api/bagu,这页只做 fetch
4
+ * 用在所有「AI 要对外说话」的地方:
5
+ * · DSH 会话里,agent 写完准备发出去之前
6
+ * · QQ 机器人 / 养鱼这类挂着 agent 的聊天场景
7
+ * · B站评论区、贴吧发帖这类公开回复
8
8
  *
9
- * 视觉全部走 --dsw-alias-* 设计变量,跟随主题,不写死颜色。
9
+ * 所以设置页的重点不是「查报告」,是「这道门开不开、多严」。
10
+ *
11
+ * 视觉走 --dsw-alias-* 设计变量,跟随主题。
10
12
  */
11
13
  window.__ModuleLoader__.load({
12
14
  id: 'dsh-bagu',
@@ -27,18 +29,23 @@ window.__ModuleLoader__.load({
27
29
  body: JSON.stringify(body || {}),
28
30
  }))
29
31
 
30
- const SAMPLE = '这不是技术问题,而是认知问题。我们使用了新方法,采用了更好的方式,通过提升效率来优化流程。'
32
+ // 三种真实场景各两条:八股的长什么样,真的长什么样
33
+ const SAMPLES = [
34
+ { label: '机器人八股', text: '这条我认!首先态度要正,其次内容要实,最后要持续更新。' },
35
+ { label: '评论区空夸', text: '这个视频真的很不错,非常值得一看!' },
36
+ { label: '会话对举', text: '这不是技术问题,而是认知问题。' },
37
+ { label: '评论区真话', text: '卖卡卖完了随便写了' },
38
+ { label: '会话真话', text: '改完了,加了 §4。第七页那个表我删了,因为原来那三列一直是空的。' },
39
+ ]
31
40
 
32
41
  const CSS = `
33
42
  [data-bg]{display:flex;flex-direction:column;gap:20px;padding:4px 2px 12px;max-width:660px;
34
43
  color:var(--dsw-alias-label-primary,inherit);font-size:13px;line-height:1.5;}
35
44
 
36
- /* 头部 */
37
45
  [data-bg-head]{display:flex;flex-direction:column;gap:6px;}
38
46
  [data-bg-title]{font-size:15px;font-weight:600;letter-spacing:-.01em;}
39
47
  [data-bg-sub]{font-size:12px;line-height:1.6;color:var(--dsw-alias-label-tertiary,#9aa0a6);}
40
48
 
41
- /* 卡片 */
42
49
  [data-bg-card]{display:flex;flex-direction:column;
43
50
  border:1px solid var(--dsw-alias-border-l,rgba(128,128,128,.2));
44
51
  border-radius:12px;overflow:hidden;
@@ -48,8 +55,6 @@ window.__ModuleLoader__.load({
48
55
  [data-bg-grow]{flex:1;min-width:0;}
49
56
  [data-bg-label]{font-size:13px;font-weight:500;}
50
57
  [data-bg-note]{font-size:11.5px;line-height:1.55;color:var(--dsw-alias-label-tertiary,#9aa0a6);margin-top:2px;}
51
-
52
- /* 分区标题 */
53
58
  [data-bg-h]{font-size:11px;font-weight:600;letter-spacing:.05em;text-transform:uppercase;
54
59
  color:var(--dsw-alias-label-caption,#8b8b8b);margin-bottom:8px;}
55
60
 
@@ -62,7 +67,7 @@ window.__ModuleLoader__.load({
62
67
  [data-bg-sw][data-on]::after{transform:translateX(17px);}
63
68
  [data-bg-sw][disabled]{opacity:.45;cursor:default;}
64
69
 
65
- /* 数字输入 */
70
+ /* 数字 */
66
71
  [data-bg-num]{width:88px;padding:6px 9px;border-radius:8px;font:inherit;font-size:13px;
67
72
  font-variant-numeric:tabular-nums;text-align:right;color:inherit;
68
73
  border:1px solid var(--dsw-alias-border-l,rgba(128,128,128,.28));
@@ -70,7 +75,7 @@ window.__ModuleLoader__.load({
70
75
  [data-bg-num]:focus{outline:2px solid var(--dsw-alias-state-business-primary,#3b82f6);outline-offset:-1px;}
71
76
 
72
77
  /* 文本域 */
73
- [data-bg-in]{width:100%;box-sizing:border-box;resize:vertical;min-height:86px;padding:11px 13px;border:0;
78
+ [data-bg-in]{width:100%;box-sizing:border-box;resize:vertical;min-height:72px;padding:11px 13px;border:0;
74
79
  font:inherit;font-size:13px;line-height:1.65;color:inherit;
75
80
  background:var(--dsw-alias-bg-base,transparent);}
76
81
  [data-bg-in]:focus{outline:none;}
@@ -84,28 +89,35 @@ window.__ModuleLoader__.load({
84
89
  [data-bg-btn][disabled]{opacity:.45;cursor:default;}
85
90
  [data-bg-btn][data-primary]{background:var(--dsw-alias-state-business-primary,#3b82f6);
86
91
  border-color:transparent;color:#fff;}
87
- [data-bg-btn][data-primary]:hover:not([disabled]){filter:brightness(1.08);}
88
92
 
89
- /* 结果 */
90
- [data-bg-out]{padding:12px 14px;white-space:pre-wrap;word-break:break-word;
91
- font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;
92
- font-size:11.5px;line-height:1.75;
93
- background:var(--dsw-alias-bg-base,rgba(128,128,128,.06));
93
+ /* 样本 chip */
94
+ [data-bg-chips]{display:flex;flex-wrap:wrap;gap:6px;padding:10px 14px 0;}
95
+ [data-bg-chip]{padding:4px 10px;border-radius:14px;cursor:pointer;font-size:11.5px;
96
+ border:1px solid var(--dsw-alias-border-l,rgba(128,128,128,.24));
97
+ background:transparent;color:var(--dsw-alias-label-secondary,#555);}
98
+ [data-bg-chip]:hover{background:var(--dsw-alias-interactive-bg-hover,rgba(128,128,128,.1));}
99
+
100
+ /* 守门结果:一条横条,绿/红 */
101
+ [data-bg-verdict]{display:flex;align-items:center;gap:10px;padding:11px 14px;
102
+ font-size:13px;font-weight:500;
94
103
  border-top:1px solid var(--dsw-alias-border-l,rgba(128,128,128,.12));}
104
+ [data-bg-verdict][data-pass]{background:color-mix(in srgb,var(--dsw-alias-state-business-primary,#3b82f6) 9%,transparent);
105
+ color:var(--dsw-alias-state-business-tertiary,#1d4ed8);}
106
+ [data-bg-verdict][data-block]{background:color-mix(in srgb,var(--dsw-alias-state-error-secondary,#dc2626) 9%,transparent);
107
+ color:var(--dsw-alias-state-error-secondary,#dc2626);}
108
+ [data-bg-dot]{flex:none;width:7px;height:7px;border-radius:4px;background:currentColor;}
109
+ [data-bg-verdict-text]{flex:1;min-width:0;}
95
110
 
96
- /* 状态条 */
97
- [data-bg-msg]{font-size:12px;padding:9px 13px;border-radius:8px;display:flex;gap:8px;align-items:flex-start;
111
+ [data-bg-msg]{font-size:12px;padding:9px 13px;border-radius:8px;
98
112
  background:var(--dsw-alias-fill-secondary,rgba(128,128,128,.1));}
99
113
  [data-bg-msg][data-err]{background:color-mix(in srgb,var(--dsw-alias-state-error-secondary,#dc2626) 12%,transparent);
100
114
  color:var(--dsw-alias-state-error-secondary,#dc2626);}
101
115
  [data-bg-msg][data-ok]{background:color-mix(in srgb,var(--dsw-alias-state-business-primary,#3b82f6) 12%,transparent);
102
116
  color:var(--dsw-alias-state-business-tertiary,inherit);}
103
117
 
104
- /* 脚注 */
105
118
  [data-bg-foot]{font-size:11px;color:var(--dsw-alias-label-dimmed,#7a7a7a);
106
119
  font-family:ui-monospace,SFMono-Regular,Menlo,monospace;word-break:break-all;}
107
120
 
108
- /* 加载 */
109
121
  [data-bg-skel]{height:64px;border-radius:12px;
110
122
  background:linear-gradient(90deg,var(--dsw-alias-fill-secondary,rgba(128,128,128,.08)) 25%,
111
123
  var(--dsw-alias-interactive-bg-hover,rgba(128,128,128,.14)) 37%,
@@ -124,13 +136,9 @@ window.__ModuleLoader__.load({
124
136
 
125
137
  function Switch(props) {
126
138
  return h('button', {
127
- 'data-bg-sw': '',
128
- 'data-on': props.on ? '' : undefined,
129
- 'aria-checked': props.on ? 'true' : 'false',
130
- role: 'switch',
131
- 'aria-label': props.label,
132
- disabled: props.disabled,
133
- onClick: props.onChange,
139
+ 'data-bg-sw': '', 'data-on': props.on ? '' : undefined,
140
+ role: 'switch', 'aria-checked': props.on ? 'true' : 'false',
141
+ 'aria-label': props.label, disabled: props.disabled, onClick: props.onChange,
134
142
  })
135
143
  }
136
144
 
@@ -139,15 +147,13 @@ window.__ModuleLoader__.load({
139
147
  const [view, setView] = React.useState(null)
140
148
  const [busy, setBusy] = React.useState('')
141
149
  const [msg, setMsg] = React.useState(null)
142
- const [text, setText] = React.useState(SAMPLE)
143
- const [out, setOut] = React.useState('')
144
- const [full, setFull] = React.useState(false)
150
+ const [text, setText] = React.useState(SAMPLES[0].text)
151
+ const [verdict, setVerdict] = React.useState(null)
145
152
 
146
153
  const load = React.useCallback(async () => {
147
154
  try {
148
155
  const s = await jget('/status')
149
- setSt(s)
150
- setView(s.config)
156
+ setSt(s); setView(s.config)
151
157
  } catch (e) {
152
158
  setMsg({ err: true, text: '读不到配置:' + (e && e.message ? e.message : String(e)) })
153
159
  }
@@ -167,12 +173,12 @@ window.__ModuleLoader__.load({
167
173
  } finally { setBusy('') }
168
174
  }
169
175
 
170
- const preview = async () => {
171
- setBusy('preview'); setMsg(null)
176
+ const check = async () => {
177
+ setBusy('check'); setMsg(null); setVerdict(null)
172
178
  try {
173
- const r = await jpost('/preview', { text, full })
174
- if (r.ok) setOut(r.text)
175
- else setMsg({ err: true, text: r.error || '没查出结果' })
179
+ const r = await jpost('/guard', { text, strict: view.strict })
180
+ if (r.ok) setVerdict({ pass: r.ok, line: r.line || 'OK', why: r.why, hint: r.hint })
181
+ else setMsg({ err: true, text: r.error || '查不了' })
176
182
  } catch (e) {
177
183
  setMsg({ err: true, text: '查不了:' + (e && e.message ? e.message : String(e)) })
178
184
  } finally { setBusy('') }
@@ -187,9 +193,8 @@ window.__ModuleLoader__.load({
187
193
 
188
194
  if (!view) {
189
195
  return h('div', { 'data-bg': '' },
190
- h('div', { 'data-bg-head': '' },
191
- h('div', { 'data-bg-title': '' }, '八股检测')),
192
- msg ? h('div', { 'data-bg-msg': '', 'data-err': msg.err ? '' : undefined }, msg.text) : null,
196
+ h('div', { 'data-bg-head': '' }, h('div', { 'data-bg-title': '' }, '八股检测')),
197
+ msg ? h('div', { 'data-bg-msg': '', 'data-err': '' }, msg.text) : null,
193
198
  h('div', { 'data-bg-skel': '' }),
194
199
  h('div', { 'data-bg-skel': '' }))
195
200
  }
@@ -198,53 +203,87 @@ window.__ModuleLoader__.load({
198
203
 
199
204
  return h('div', { 'data-bg': '' },
200
205
 
201
- // ── 头部 ─────────────────────────────
202
206
  h('div', { 'data-bg-head': '' },
203
207
  h('div', { 'data-bg-title': '' }, '八股检测'),
204
208
  h('div', { 'data-bg-sub': '' },
205
- '一句话换个人说还成不成立?成立,就是八股。只读不改写,给坐标不给成品。')),
209
+ 'AI 要对外说话之前的一道门。DSH 会话、QQ 机器人、B站评论,都算。过了就发,没过就打回。')),
206
210
 
207
211
  // ── 开关 ─────────────────────────────
208
212
  h('div', null,
209
- h('div', { 'data-bg-h': '' }, '开关'),
213
+ h('div', { 'data-bg-h': '' }, '挡不挡'),
210
214
  h('div', { 'data-bg-card': '' },
211
215
  h(Row, {
212
- label: on ? '已开启' : '已关闭',
213
- note: on
214
- ? (st.promptActive ? '提示那一节挂上了,现在生效。' : '已开启,但提示那一节没挂上。')
215
- : '关掉后整节从系统提示里撤掉,两个工具还在。',
216
+ label: on ? '开着' : '关了',
217
+ note: on ? 'AI 要发出去的话会先过一遍。' : '关掉后不拦,工具还在,只是不再往提示里塞话。',
216
218
  }, h(Switch, { on, label: '总开关', disabled: busy === 'save', onChange: () => save({ enabled: !on }) })),
217
219
 
220
+ h(Row, {
221
+ label: view.strict ? '严格:轻的也拦' : '正常:只拦明显的',
222
+ note: view.strict
223
+ ? '破折号、只有评价没有具体东西,这些也打回。'
224
+ : '只拦模板三连、不是A而是B、同义轮换这类硬信号。',
225
+ }, h(Switch, {
226
+ on: view.strict === true, label: '严格模式', disabled: busy === 'save' || !on,
227
+ onChange: () => save({ strict: view.strict !== true }),
228
+ })),
229
+
218
230
  h(Row, {
219
231
  label: view.prompt !== false ? '提示那一节:开' : '提示那一节:关',
220
- note: '关掉只留工具,不往提示里塞话。只想手动查的人用这个。',
232
+ note: '关掉只留工具,不往提示里塞话。',
221
233
  }, h(Switch, {
222
234
  on: view.prompt !== false, label: '提示节', disabled: busy === 'save' || !on,
223
235
  onChange: () => save({ prompt: view.prompt === false }),
224
236
  })))),
225
237
 
238
+ // ── 试一下 ───────────────────────────
239
+ h('div', null,
240
+ h('div', { 'data-bg-h': '' }, '试一条'),
241
+ h('div', { 'data-bg-card': '' },
242
+ h('div', { 'data-bg-chips': '' },
243
+ SAMPLES.map((s, i) => h('button', {
244
+ key: i, 'data-bg-chip': '', onClick: () => { setText(s.text); setVerdict(null) },
245
+ }, s.label))),
246
+ h('textarea', {
247
+ 'data-bg-in': '', value: text, rows: 3,
248
+ placeholder: '粘一条准备发出去的回复',
249
+ onChange: (e) => { setText(e.target.value); setVerdict(null) },
250
+ }),
251
+ h('div', { 'data-bg-row': '' },
252
+ h('button', {
253
+ 'data-bg-btn': '', 'data-primary': '',
254
+ disabled: busy === 'check', onClick: check,
255
+ }, busy === 'check' ? '过着…' : '过一遍'),
256
+ h('div', { 'data-bg-grow': '' },
257
+ h('div', { 'data-bg-note': '' }, verdict
258
+ ? (verdict.pass ? '能发' : '打回')
259
+ : '看这段能不能发出去'))),
260
+ verdict ? h('div', {
261
+ 'data-bg-verdict': '',
262
+ 'data-pass': verdict.pass ? '' : undefined,
263
+ 'data-block': verdict.pass ? undefined : '',
264
+ },
265
+ h('div', { 'data-bg-dot': '' }),
266
+ h('div', { 'data-bg-verdict-text': '' }, verdict.line),
267
+ ) : null)),
268
+
226
269
  // ── 阈值 ─────────────────────────────
227
270
  h('div', null,
228
271
  h('div', { 'data-bg-h': '' }, '阈值'),
229
272
  h('div', { 'data-bg-card': '' },
230
273
  h(Row, {
231
274
  label: '留白词下限',
232
- note: '每千字几个「好像 / 应该 / 大概」才算够。低于这个就报句句在下断言。',
275
+ note: '每千字几个「好像 / 应该 / 大概」。低于这个就报句句在下断言。',
233
276
  }, num('hedgeFloor')),
234
-
235
277
  h(Row, {
236
278
  label: '结构腔倍数',
237
279
  note: '超过同文体基线的几倍才报。调大更宽容。',
238
280
  }, num('structureTimes')),
239
-
240
281
  h(Row, {
241
282
  label: '具体物下限',
242
283
  note: '每百字至少几个数字、时间、经历、原话、名字。',
243
284
  }, num('concreteFloor')),
244
-
245
285
  h('div', { 'data-bg-row': '' },
246
- h('div', { 'data-bg-grow': '' },
247
- h('div', { 'data-bg-note': '' }, '恢复研究给出的默认值。')),
286
+ h('div', { 'data-bg-grow': '' }, h('div', { 'data-bg-note': '' }, '恢复默认。')),
248
287
  h('button', {
249
288
  'data-bg-btn': '', disabled: busy === 'save',
250
289
  onClick: () => save({
@@ -254,33 +293,10 @@ window.__ModuleLoader__.load({
254
293
  }),
255
294
  }, '恢复默认')))),
256
295
 
257
- // ── 试一下 ───────────────────────────
258
- h('div', null,
259
- h('div', { 'data-bg-h': '' }, '试一下'),
260
- h('div', { 'data-bg-card': '' },
261
- h('textarea', {
262
- 'data-bg-in': '', value: text, rows: 3,
263
- placeholder: '粘一段话,短句也行。',
264
- onChange: (e) => setText(e.target.value),
265
- }),
266
- h('div', { 'data-bg-row': '' },
267
- h('button', {
268
- 'data-bg-btn': '', 'data-primary': '',
269
- disabled: busy === 'preview', onClick: preview,
270
- }, busy === 'preview' ? '查着…' : '查一下'),
271
- h('div', { 'data-bg-grow': '' },
272
- h('div', { 'data-bg-note': '' }, full ? '完整报告' : '三行摘要')),
273
- h(Switch, { on: full, label: '完整报告', disabled: false, onChange: () => setFull(!full) })),
274
- out ? h('div', { 'data-bg-out': '' }, out) : null)),
275
-
276
- // ── 状态 ─────────────────────────────
277
296
  msg ? h('div', {
278
- 'data-bg-msg': '',
279
- 'data-err': msg.err ? '' : undefined,
280
- 'data-ok': msg.ok ? '' : undefined,
297
+ 'data-bg-msg': '', 'data-err': msg.err ? '' : undefined, 'data-ok': msg.ok ? '' : undefined,
281
298
  }, msg.text) : null,
282
299
 
283
- // ── 脚注 ─────────────────────────────
284
300
  h('div', { 'data-bg-foot': '' }, String(st.configFile || 'config.json')))
285
301
  }
286
302
 
package/cordis.patch.yml CHANGED
@@ -12,6 +12,7 @@
12
12
  config:
13
13
  enabled: true
14
14
  prompt: true
15
+ strict: false
15
16
  order: 921
16
17
  hedgeFloor: 0.5
17
18
  structureTimes: 3
package/dsh-plugin.json CHANGED
@@ -3,9 +3,9 @@
3
3
  "manifestVersion": "0.15",
4
4
  "id": "dsh-bagu",
5
5
  "name": "dsh-bagu",
6
- "version": "0.3.1",
6
+ "version": "0.4.0",
7
7
  "license": "MIT",
8
- "description": "八股检测:数具体物、撑场面的话、留白词、结构腔密度。只读不改写。",
8
+ "description": "AI 要对外说话之前的一道门:过了就发,没过就打回。",
9
9
  "facets": {
10
10
  "host": {
11
11
  "entry": "lib/index.js",
@@ -29,7 +29,7 @@
29
29
  "x-display": [
30
30
  {
31
31
  "title": "dsh-bagu",
32
- "description": "查一段话有多可替换:具体性、抽象度、留白、结构腔,带设置页,只给问句不自动改"
32
+ "description": "每条对外回复发出前过一遍,像八股就打回。只回 OK 或一行改法。"
33
33
  }
34
34
  ]
35
35
  }
package/lib/config.js CHANGED
@@ -16,6 +16,8 @@ export const DEFAULTS = {
16
16
  enabled: true,
17
17
  /** 只要「查」,不挂 prompt 那一节的话设 false */
18
18
  prompt: true,
19
+ /** 严格模式:破折号、只有评价没有具体东西,这些也打回 */
20
+ strict: false,
19
21
  /** prompt 节的 order,越大越靠后 */
20
22
  order: 921,
21
23
  /** 留白词低于这个密度(每千字)就报「句句在下断言」 */
package/lib/guard.js ADDED
@@ -0,0 +1,198 @@
1
+ /**
2
+ * 守门器:agent 把要发出去的那句话递进来,只回「能发」或「改」。
3
+ *
4
+ * 跟 analyze() 的区别:
5
+ * analyze 给人看,多行报告,判断有余地
6
+ * guard 给 agent 用,一行,只有通过和不通过
7
+ *
8
+ * 这个文件的存在理由就一个:QQ 机器人、养鱼这类场景里,
9
+ * 一条回复二三十字,人不会自己开脚本查,得让机器在发出前拦一道。
10
+ *
11
+ * 输出预算:通过两个字,打回一行(30 字以内)。每次调用都要烧 token,
12
+ * 所以这里每一行都要挣来自己的位置。
13
+ */
14
+
15
+ import { analyze } from './analyze.js';
16
+ import { STOCK_PHRASES } from './lexicon.js';
17
+
18
+ /**
19
+ * 打回原因按严重度排。谁先命中谁负责,只报一条 —— 报三条 agent 会挑最轻的改。
20
+ *
21
+ * 权重来自 lieflat 的 δ:
22
+ * 同义轮换 +0.91 > 不是A而是B +0.88 > 顿号并列 +0.56
23
+ * 聊天场景再叠一层:一条二十字的回复里出现模板三连,比长文里更假。
24
+ */
25
+ const OPPOSITION_FRAMES = [
26
+ // 不是A而是B 已经在 STRUCTURE_FRAMES 里,这里补同族的
27
+ /不在于[^。!?\n]{1,20}(?:而在于|而在)/, // 问题不在于A,而在于B
28
+ /与其说[^。!?\n]{1,20}(?:不如说|不如)/, // 与其说A,不如说B
29
+ /与其([^。!?\n]{1,20})不如/, // 与其A不如B
30
+ /看似[^。!?\n]{1,20}(?:实则|实际|其实)/, // 看似A,实则B
31
+ /不仅[^。!?\n]{1,24}(?:更|还|而且)/, // 不仅A更B
32
+ /不是[^。!?\n]{1,20}[。!]\s*[^。!?\n]{0,4}(?:这|那|而|就)?(?:才)?是/, // 拆成两句:不是X。这是Y
33
+ ];
34
+
35
+ const REASONS = [
36
+ {
37
+ id: 'triple-template',
38
+ // 逗号和分号都算。QQ 机器人一条回复通常不分号,写成「首先A,其次B,最后C」
39
+ test: (r, text) => /首先[^。!?\n]{1,30}[,,;;][^。!?\n]{0,12}其次/.test(text),
40
+ why: '模板三连',
41
+ hint: '直接说事,不用「首先其次最后」',
42
+ },
43
+ {
44
+ id: 'bare-first',
45
+ // 单列的「首先/其次/最后」开头:没有后续的列举,直接是空转
46
+ test: (r, text) => {
47
+ const m = text.match(/^(首先|其次|最后|首先|其一|其二)[,,]/);
48
+ return m !== null && text.length < 40;
49
+ },
50
+ why: '单列首先/其次',
51
+ hint: '直接说正题',
52
+ },
53
+ {
54
+ id: 'rhetorical',
55
+ // 反问句里的对举:难道这不是A吗 / 这难道不是B吗
56
+ test: (r, text) => /(?:难道|岂不|岂不是)[^。!?\n]{0,20}(?:不是|而是|才)/.test(text),
57
+ why: '反问式对举',
58
+ hint: '直接说结论,别用反问',
59
+ },
60
+ {
61
+ id: 'stock',
62
+ test: (r, text) => {
63
+ const hit = STOCK_PHRASES.find((re) => re.test(text));
64
+ return hit !== undefined;
65
+ },
66
+ why: (r, text) => {
67
+ const hit = STOCK_PHRASES.find((re) => re.test(text));
68
+ return hit ? `套话「${(text.match(hit) || [''])[0]}」` : '套话';
69
+ },
70
+ hint: '这句是模板,换成自己会说的话',
71
+ },
72
+ {
73
+ id: 'negation',
74
+ test: (r, text) =>
75
+ r.hits.structures.some((s) => s.id === 'negation') ||
76
+ OPPOSITION_FRAMES.some((re) => re.test(text)),
77
+ why: (r, text) => {
78
+ if (r.hits.structures.some((s) => s.id === 'negation')) return '不是A而是B';
79
+ const re = OPPOSITION_FRAMES.find((x) => x.test(text));
80
+ return re ? `对举「${(text.match(re) || [''])[0]}」` : '对举';
81
+ },
82
+ hint: '拆成两句话,或者直接说结论',
83
+ },
84
+ {
85
+ id: 'synonym',
86
+ // 两组以上,或者一组里挑了三个以上 —— 后者已经是明显在轮换
87
+ test: (r) => r.synonyms.length >= 2 || r.synonyms.some((g) => g.length >= 3),
88
+ why: (r) => `同义轮换${r.synonyms.map((g) => g.length).reduce((a, b) => a + b, 0)}个词`,
89
+ hint: (r) => `「${r.synonyms[0].join('/')}」选一个,重复用没关系`,
90
+ },
91
+ {
92
+ id: 'ai-words',
93
+ test: (r) => r.hits.aiWords.length >= 1,
94
+ why: (r) => r.hits.aiWords.map((h) => h.word).slice(0, 2).join('、'),
95
+ hint: '换成平时会说的词',
96
+ },
97
+ {
98
+ id: 'triple-list',
99
+ test: (r) => r.hits.structures.some((s) => s.id === 'triple'),
100
+ why: '三段并列',
101
+ hint: '挑一个说透,别凑三个',
102
+ },
103
+ {
104
+ id: 'summary',
105
+ test: (r) => r.hits.summary.length > 0,
106
+ why: (r) => r.hits.summary[0].word,
107
+ hint: '删掉这句,前面已经说完了',
108
+ },
109
+ {
110
+ id: 'fake-significance',
111
+ test: (r) => r.hits.fakeSignificance.length > 0,
112
+ why: (r) => r.hits.fakeSignificance[0].word,
113
+ hint: '讲它是什么,不讲它多重要',
114
+ },
115
+ {
116
+ id: 'emdash',
117
+ test: (r) => r.hits.structures.some((s) => s.id === 'emdash'),
118
+ why: '破折号',
119
+ hint: '聊天里用逗号或句号',
120
+ },
121
+ {
122
+ id: 'choppy-parallel',
123
+ // 三个以上同构短句连着:很强。很方便。很实用。
124
+ test: (r, text) => {
125
+ const sents = text.split(/[。!?]/).map((s) => s.trim()).filter(Boolean);
126
+ if (sents.length < 3) return false;
127
+ // 前三个句子长度相近(±3 字)且都以同一个字开头
128
+ const first3 = sents.slice(0, 3);
129
+ const sameHead = first3.every((s) => s[0] === first3[0][0]);
130
+ const similarLen = Math.max(...first3.map((s) => s.length)) - Math.min(...first3.map((s) => s.length)) <= 3;
131
+ return sameHead && similarLen && r.scores.concretePer100 === 0;
132
+ },
133
+ why: '同构短句排比',
134
+ hint: '合成一句,或者补一个具体的东西',
135
+ },
136
+ {
137
+ id: 'hollow-praise',
138
+ // 夸人不是问题,问题是整条回复只有夸、没有一个具体东西。
139
+ // 「转场那里剪得挺流畅的」有具体位置,能过;
140
+ // 「真的很不错,非常值得一看」只有空气,拦住。
141
+ test: (r, text) => {
142
+ if (text.length < 12) return false;
143
+ if (r.scores.concretePer100 > 0) return false;
144
+ // 评价词 + 程度词 + 感叹号,三样凑齐就是空夸
145
+ // 只要两个以上评价词、且零具体物,就是空夸。
146
+ // 不管带不带「很/非常」这些程度词。
147
+ return r.scores.evaluation >= 2;
148
+ },
149
+ why: '只有夸,没有具体东西',
150
+ hint: '说一句你具体看到的东西',
151
+ },
152
+ {
153
+ id: 'no-concrete',
154
+ // 长一点的回复里一个具体物都没有,说明在说空话
155
+ // 聊天回复 20 字就是正常长度,门槛不该按长文的标准设
156
+ test: (r, text) => text.length >= 12 && r.scores.concretePer100 === 0 && r.scores.evaluation >= 2,
157
+ why: '全在评价,没有具体东西',
158
+ hint: '说一件具体发生的事',
159
+ },
160
+ ];
161
+
162
+ /**
163
+ * 过一遍。
164
+ *
165
+ * @param {string} text 准备发出去的那句话
166
+ * @param {{strict?: boolean}} opts strict = 连轻微的信号也拦
167
+ * @returns {{ok: boolean, why?: string, hint?: string, line: string}}
168
+ */
169
+ export function guard(text, opts = {}) {
170
+ const src = String(text ?? '').trim();
171
+ if (!src) return { ok: true, line: 'OK' };
172
+
173
+ // 太长的不拦 —— 那是长文,不是聊天回复,判断标准不一样
174
+ if (src.length > 300) return { ok: true, line: 'OK', skipped: 'too-long' };
175
+
176
+ const r = analyze(src);
177
+ const strict = opts.strict === true;
178
+
179
+ for (const reason of REASONS) {
180
+ let hit = false;
181
+ try { hit = reason.test(r, src); } catch { hit = false; }
182
+ if (!hit) continue;
183
+
184
+ // 非 strict 时,最后两条(破折号、无具体物)只警告不打回
185
+ if (!strict && (reason.id === 'emdash' || reason.id === 'no-concrete')) continue;
186
+
187
+ const why = typeof reason.why === 'function' ? reason.why(r) : reason.why;
188
+ const hint = typeof reason.hint === 'function' ? reason.hint(r) : reason.hint;
189
+ return { ok: false, why, hint, line: `改:${why} · ${hint}` };
190
+ }
191
+
192
+ return { ok: true, line: 'OK' };
193
+ }
194
+
195
+ /** 只回一行,给最省的模式。 */
196
+ export function guardLine(text, opts) {
197
+ return guard(text, opts).line;
198
+ }
package/lib/index.js CHANGED
@@ -13,6 +13,7 @@
13
13
 
14
14
  import { analyze } from './analyze.js';
15
15
  import { render, renderBrief } from './render.js';
16
+ import { guard } from './guard.js';
16
17
  import { readConfig, writeConfig, CONFIG_FILE, DEFAULTS } from './config.js';
17
18
 
18
19
  export const name = 'dsh-bagu';
@@ -22,18 +23,12 @@ export { analyze, render, renderBrief };
22
23
  let live = readConfig();
23
24
  const syncers = new Set();
24
25
 
25
- /** 150 字。每次会话注入,多一个字都是白烧。 */
26
- const PROMPT = `一句话换个人说还成不成立?成立,就是八股。
27
-
28
- - 别急着认错。对方问一句,不等于你在说错。
29
- - 留一处不确定。全篇一个「大概」都没有,是在下断言。
30
- - 具体压过评价。「骨架在推所以有点飘」只有看过的人才说得出。
31
- - 别每句一样长。整齐本身就是痕迹。`;
26
+ /** 每次会话都注入,多一个字都是白烧。 */
27
+ const PROMPT = `要发出去的话,先过 bagu_guard。被打回就改,别硬发。`;
32
28
 
33
29
  /** 60 字。 */
34
- const TOOL_CHECK = `查一段话有多可替换:具体物、抽象词、留白、同义轮换、结构腔。只报不给改。默认三行,full 给详细报告。`;
35
-
36
- const TOOL_ASK = `只要问句,不要结论。`;
30
+ /** 一个工具,三种模式。描述只占一份。 */
31
+ const TOOL_GUARD = `发出去之前过一遍。默认只回 OK 或一行改法。mode=report 给详细报告,mode=ask 给问句。`;
37
32
 
38
33
  function toolOutput() {
39
34
  return {
@@ -112,44 +107,47 @@ export function apply(root, config = {}) {
112
107
  });
113
108
 
114
109
  root.inject(['tools'], (ctx) => {
110
+ // 一个工具,三种模式。mode 缺省是守门(日常路径),另外两个是调试用。
115
111
  ctx.tools.register({
116
- name: 'bagu_check',
117
- description: TOOL_CHECK,
112
+ name: 'bagu_guard',
113
+ description: TOOL_GUARD,
118
114
  parameters: {
119
115
  type: 'object',
120
116
  properties: {
121
- text: { type: 'string', description: '整段话。' },
122
- full: { type: 'boolean', description: 'true 给详细报告。默认三行。' },
117
+ text: { type: 'string', description: '要发出去的那段话。' },
118
+ mode: {
119
+ type: 'string',
120
+ enum: ['guard', 'report', 'ask'],
121
+ description: 'guard 只回 OK/一行改法(默认);report 给详细报告;ask 只给问句。',
122
+ },
123
+ strict: { type: 'boolean', description: '连轻微信号也拦。' },
124
+ full: { type: 'boolean', description: 'mode=report 时给完整输出。' },
125
+ n: { type: 'number', description: 'mode=ask 时几条问句,默认 3,最多 6。' },
123
126
  },
124
127
  required: ['text'],
125
128
  },
126
129
  output: toolOutput(),
127
130
  execute: async (args) => {
128
131
  const src = String(args?.text ?? '');
129
- if (!src.trim()) return { ok: false, text: '没有文字。' };
130
- const r = analyze(src, thresholdsOf(live));
131
- return { ok: true, text: render(r, { full: args?.full === true }) };
132
- },
133
- });
132
+ const mode = args?.mode || 'guard';
134
133
 
135
- ctx.tools.register({
136
- name: 'bagu_ask',
137
- description: TOOL_ASK,
138
- parameters: {
139
- type: 'object',
140
- properties: {
141
- text: { type: 'string', description: '整段话。' },
142
- n: { type: 'number', description: '几条,默认 3,最多 6。' },
143
- },
144
- required: ['text'],
145
- },
146
- output: toolOutput(),
147
- execute: async (args) => {
148
- const src = String(args?.text ?? '');
149
- if (!src.trim()) return { ok: false, text: '没有文字。' };
150
- const r = analyze(src, thresholdsOf(live));
151
- const n = Math.min(6, Math.max(1, Number(args?.n) || 3));
152
- return { ok: true, text: r.asks.slice(0, n).map((a, i) => `${i + 1}. ${a}`).join('\n') };
134
+ if (!src.trim()) {
135
+ return { ok: true, text: mode === 'guard' ? 'OK' : '没有文字。' };
136
+ }
137
+
138
+ if (mode === 'report') {
139
+ const r = analyze(src, thresholdsOf(live));
140
+ return { ok: true, text: render(r, { full: args?.full === true }) };
141
+ }
142
+
143
+ if (mode === 'ask') {
144
+ const r = analyze(src, thresholdsOf(live));
145
+ const n = Math.min(6, Math.max(1, Number(args?.n) || 3));
146
+ return { ok: true, text: r.asks.slice(0, n).map((a, i) => `${i + 1}. ${a}`).join('\n') };
147
+ }
148
+
149
+ const g = guard(src, { strict: args?.strict ?? live.strict });
150
+ return { ok: true, text: g.line };
153
151
  },
154
152
  });
155
153
  });
@@ -176,6 +174,14 @@ export function apply(root, config = {}) {
176
174
  return sendJson(res, 200, { ok: true, config: next });
177
175
  }
178
176
 
177
+ if (req.method === 'POST' && path === '/guard') {
178
+ const body = await readBody(req);
179
+ const src = String(body?.text ?? '');
180
+ if (!src.trim()) return sendJson(res, 200, { ok: true, line: 'OK' });
181
+ const g = guard(src, { strict: body?.strict ?? live.strict });
182
+ return sendJson(res, 200, { ok: g.ok, line: g.line, why: g.why, hint: g.hint });
183
+ }
184
+
179
185
  if (req.method === 'POST' && path === '/preview') {
180
186
  const body = await readBody(req);
181
187
  const src = String(body?.text ?? '');
package/lib/lexicon.js CHANGED
@@ -29,6 +29,15 @@ export const AI_WORDS = [
29
29
  '联动',
30
30
  '生态位',
31
31
  '心智',
32
+ // 补:多维度/剖析/核心竞争力/闭环/抓手/赋能
33
+ '多维度',
34
+ '多角度',
35
+ '深入剖析',
36
+ '核心竞争力',
37
+ '形成闭环',
38
+ '找到抓手',
39
+ '赋能',
40
+ '价值主张',
32
41
  ];
33
42
 
34
43
  /** 开头就总结。 */
@@ -92,6 +101,10 @@ export const ABSTRACT_NOUNS = [
92
101
 
93
102
  /** 评价性形容词。说得越满,越像评职称。 */
94
103
  export const EVAL_ADJECTIVES = [
104
+ // 聊天里最常见的空评价(QQ 机器人、评论区高频)
105
+ '不错', '很好', '挺好', '真好', '太棒', '很棒', '优秀', '厉害', '牛',
106
+ '值得', '推荐', '干货', '硬核', '绝了', '爱了', '笑死', '感动',
107
+ '强大', '方便', '简洁', '大方', '流畅', '用心', '到位', '扎实', '详实',
95
108
  '重要',
96
109
  '关键',
97
110
  '核心',
@@ -209,6 +222,14 @@ export const SYNONYM_GROUPS = [
209
222
  ['问题', '难题', '挑战', '困境', '痛点'],
210
223
  ['帮助', '协助', '助力', '支持'],
211
224
  ['显著', '大幅', '明显', '卓有成效'],
225
+ // 客服腔三件套
226
+ ['感谢', '谢谢', '感激', '多谢'],
227
+ // 「受益匪浅」家族的客套
228
+ ['受益', '收获', '学到', '涨知识'],
229
+ // 表态套件
230
+ ['我说句', '说实话', '老实说', '讲道理', '客观来说'],
231
+ // 过度礼貌
232
+ ['您好', '你好', '亲', '亲爱的'],
212
233
  ];
213
234
 
214
235
  /**
@@ -218,6 +239,42 @@ export const SYNONYM_GROUPS = [
218
239
  * 但三连齐全时它仍是模板的标记 —— issue #1 评论实测:
219
240
  * 「首先我们要明确目标;其次要拆解任务;最后要复盘总结。」26 字判「正常」。
220
241
  */
242
+ /**
243
+ * 整句套话。这些不是词,是完整的句式,命中就说明在按模板说话。
244
+ *
245
+ * 覆盖三类场景:
246
+ * · 鱼八股(这个生态里长出来的固定说法)
247
+ * · 客服腔(评论区常见的感谢体)
248
+ * · 客套开场(过度礼貌)
249
+ */
250
+ export const STOCK_PHRASES = [
251
+ // 鱼八股
252
+ /这条我认/,
253
+ /本鱼(记下|最|觉得|认为)/,
254
+ /我记下了/,
255
+ /收到主人/,
256
+ // 客服腔
257
+ /感谢(分享|您的)/,
258
+ /(通过|以)[^,。]{0,12}方式[^,。]{0,10}(展示|呈现|讲解)/,
259
+ /(令人|让人)?受益匪浅/,
260
+ /希望(这些)?(能|对你有)帮/,
261
+ /如有(疑问|需要)/,
262
+ // 客套开场
263
+ /^(您好|你好|亲|亲爱的)[,,!!]/,
264
+ /^我来(为您|帮你|给大家)/,
265
+ // 表态套话
266
+ /^说句(实话|公道话|心里话)/,
267
+ /^说了你可能不信/,
268
+ /^客观(地)?(来)?说/,
269
+ /^(客观|老实)(地)?(来)?(讲|说)/,
270
+ /^说白了(就是)?[,,]/,
271
+ /^说穿了[,,]/,
272
+ /(?:从|在)(?:根|底|本质)(?:上|儿)(?:讲|说|解决|来看)/,
273
+ /^不得不(说|承认)/,
274
+ /^说真的[,,]/,
275
+ /^(看到|听到|读完)[^。!?]{0,10}(我)?(坐直|鸡皮|破防|震惊)/,
276
+ ];
277
+
221
278
  export const TEMPLATE_TRIPLE = /首先[^。;!?\n]{1,30}[;;][^。;!?\n]{0,10}其次[^。;!?\n]{1,30}[;;,,][^。;!?\n]{0,10}(?:最后|最终|总之)/;
222
279
 
223
280
  /** 文体基线与判定词,按真人评论语料实测。 */
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "dsh-bagu",
3
- "version": "0.3.1",
4
- "description": "八股检测:判断一句话是不是谁都能说。AI 味不是礼貌问题,是可替换问题。",
3
+ "version": "0.4.0",
4
+ "description": "AI 要对外说话之前的一道门。DSH 会话、QQ 机器人、B站评论都算。过了就发,没过就打回。",
5
5
  "type": "module",
6
6
  "main": "lib/index.js",
7
7
  "exports": {
@@ -120,11 +120,11 @@ test('接口是 /api/bagu 的三条', () => {
120
120
  assert.ok(code.includes("'/api/bagu'"))
121
121
  assert.ok(code.includes("jget('/status')"))
122
122
  assert.ok(code.includes("jpost('/config'"))
123
- assert.ok(code.includes("jpost('/preview'"))
123
+ assert.ok(code.includes("jpost('/guard'"), '守门器接口 /guard 必须接上')
124
124
  })
125
125
 
126
- test('preview 会带 full 开关', () => {
127
- assert.ok(code.includes('{ text, full }'), 'preview 请求体里要带 full')
126
+ test('守门请求带 strict 开关', () => {
127
+ assert.ok(code.includes('{ text, strict: view.strict }'), '/guard 请求体里要带 strict')
128
128
  })
129
129
 
130
130
  test('没写死颜色值,只允许纯白', () => {
@@ -0,0 +1,82 @@
1
+ import { test } from 'node:test';
2
+ import assert from 'node:assert/strict';
3
+ import { guard, guardLine } from '../lib/guard.js';
4
+
5
+ // ── 机器人场景的真实样本 ──────────────────────────
6
+ const BLOCK = [
7
+ ['模板三连', '这条我认!首先态度要正,其次内容要实,最后要持续更新。'],
8
+ ['对举', '这不是技术问题,而是认知问题。'],
9
+ ['同义轮换', '我们今天使用了新方法,采用了更好的方式。'],
10
+ ['空夸', '这个视频真的很不错,非常值得一看!'],
11
+ ['八股词', '综上所述,这次改动具有重要意义。'],
12
+ ];
13
+
14
+ const PASS = [
15
+ ['真人短评', '卖卡卖完了随便写了'],
16
+ ['具体经历', '我上次也踩过,8443 端口被占了'],
17
+ ['正常夸', '转场那里剪得挺流畅的,我看了一遍'],
18
+ ['闲聊', '吃了,就一碗面,汤有点咸'],
19
+ ['反问', '你没看明白我想说的。'],
20
+ ];
21
+
22
+ test('该拦的都拦住', () => {
23
+ for (const [name, text] of BLOCK) {
24
+ const r = guard(text);
25
+ assert.equal(r.ok, false, `${name} 该拦但放过了: ${text}`);
26
+ assert.ok(r.line.startsWith('改:'), `${name} 的输出该以「改:」开头: ${r.line}`);
27
+ }
28
+ });
29
+
30
+ test('该放的全放过', () => {
31
+ for (const [name, text] of PASS) {
32
+ const r = guard(text);
33
+ assert.equal(r.ok, true, `${name} 被误拦了: ${text} → ${r.line}`);
34
+ }
35
+ });
36
+
37
+ test('一行不超过 40 字,烧 token 要省', () => {
38
+ for (const [name, text] of BLOCK) {
39
+ const r = guard(text);
40
+ assert.ok(r.line.length <= 40, `${name} 的输出太长(${r.line.length} 字): ${r.line}`);
41
+ }
42
+ });
43
+
44
+ test('空输入直接放过', () => {
45
+ assert.equal(guard('').ok, true);
46
+ assert.equal(guard(' ').ok, true);
47
+ });
48
+
49
+ test('长文不当聊天回复拦', () => {
50
+ // 门槛是 300 字:QQ 机器人一条回复二三十字,超过这个量级的是文档不是聊天
51
+ const long = '先说明一下背景。这个项目从去年开始,中间换过两次负责人,第一次是团队重组,第二次是预算砍掉了一半。现在剩下的人手只够维护,不够做新功能。'.repeat(6);
52
+ assert.ok(long.length > 300, '样本得够长,实际 ' + long.length);
53
+ const r = guard(long);
54
+ assert.equal(r.ok, true);
55
+ assert.equal(r.skipped, 'too-long');
56
+ });
57
+
58
+ test('严格模式多拦两条', () => {
59
+ const dash = guard('改完了——真的改完了。');
60
+ assert.equal(dash.ok, true, '正常模式不该为破折号打回');
61
+
62
+ const strict = guard('改完了——真的改完了。', { strict: true });
63
+ assert.equal(strict.ok, false, '严格模式该拦破折号');
64
+ });
65
+
66
+ test('只报一条原因,不堆', () => {
67
+ const r = guard('首先这样,其次那样——这不是技术问题,而是认知问题。');
68
+ assert.equal(r.ok, false);
69
+ assert.equal(r.line.split(' · ').length, 2, '只有「为什么 + 怎么改」两段');
70
+ assert.ok(!r.line.includes('|'), '不并列多条原因');
71
+ });
72
+
73
+ test('guardLine 只回一行', () => {
74
+ assert.equal(guardLine('卖卡卖完了随便写了'), 'OK');
75
+ assert.ok(guardLine('这不是技术问题,而是认知问题。').startsWith('改:'));
76
+ });
77
+
78
+ test('打回的原因按严重度排,三连优先于对举', () => {
79
+ const both = '首先态度要正,其次内容要实——这不是技术问题,而是认知问题。';
80
+ const r = guard(both);
81
+ assert.ok(r.why.includes('三连'), `该先报三连,实际报了 ${r.why}`);
82
+ });