dsh-bagu 0.4.0 → 0.5.1

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
@@ -4,98 +4,185 @@
4
4
 
5
5
  ## 这是什么
6
6
 
7
- 用在所有「AI 写的东西要被人看到」的地方:
7
+ 凡是 AI 写的、要被人看到的东西,都可以先过一遍:
8
8
 
9
- - **DSH 会话** —— agent 回复之前先过一遍
10
- - **QQ 机器人 / 养鱼** —— 每条消息发出前
11
- - **B站评论区、贴吧发帖** —— 公开回复
9
+ | 场景 | 例子 |
10
+ |---|---|
11
+ | **聊天** | QQ 机器人、养鱼、DSH 会话 |
12
+ | **评论** | B站、贴吧、微博、论坛 |
13
+ | **工作沟通** | 邮件、客服回复、周报 |
14
+ | **代码托管** | commit、PR 描述、review 评论、issue 回复、变更日志 |
15
+ | **文档** | README、技术文档、API 说明 |
16
+ | **代码** | 注释 |
12
17
 
13
- AI 在这些地方会写出这种话:
18
+ 这些地方 AI 会写出同一种东西:
14
19
 
15
20
  ```
16
21
  这条我认!首先态度要正,其次内容要实,最后要持续更新。
17
- 这个视频真的很不错,非常值得一看!
18
22
  感谢分享!这个视频通过生动有趣的方式展示了相关内容,受益匪浅。
23
+ feat: 优化了用户模块的代码结构,提升了可维护性
24
+ 整体实现思路清晰,代码结构合理,建议后续可以进一步优化。
25
+ // 初始化计数器
19
26
  ```
20
27
 
21
28
  **这个插件在发出去之前拦一道。** 通过就发,没过就打回,附一句怎么改。
22
29
 
23
- ## 一句话判断
30
+ ## 怎么判断
24
31
 
25
- 换个人说,还成不成立?成立,就是八股。
32
+ 一句话:**换个人说,还成不成立?**
26
33
 
27
34
  ```text
28
- 「卖卡卖完了随便写了」 → 能发(编不出来)
29
- 「这个视频真的很不错」 → 打回(谁都能说)
35
+ 「卖卡卖完了随便写了」 → 能发(编不出来)
36
+ 「这个视频真的很不错」 → 打回(谁都能说)
37
+ 「登录失败时不再清空已填的手机号」 → 能发(具体到一行)
38
+ 「优化了代码结构,提升可维护性」 → 打回(改哪一行?没说)
30
39
  ```
31
40
 
32
- ## 怎么用
41
+ ## 三层规则
33
42
 
34
- agent 每次要发消息之前,调一次:
43
+ 搭成三层,越往下越具体。前两层不分场景,第三层是各场景长出来的。
44
+
45
+ ### 第一层 · 通用
46
+
47
+ **空转**——说了动作,没说做了什么。
35
48
 
36
- ```js
37
- bagu_guard({ text: "这条我认!首先态度要正,其次内容要实,最后要持续更新。" })
38
- → "改:模板三连 · 直接说事,不用「首先其次最后」"
49
+ ```
50
+ 优化了代码结构 / 提升了可维护性 / 修复了若干已知问题 / 进行了必要的处理
39
51
  ```
40
52
 
41
- 过了就回 `OK`,两个字。
53
+ **空形容词**——能贴到任何产品上的词。
42
54
 
43
- **输出预算:通过 2 字,打回一行 40 字以内。** 每次都要烧 token,多一个字都是成本。
55
+ ```
56
+ 先进的技术架构 / 高性能、高可用 / 具备良好的扩展性 / 能够满足业务发展的需要
57
+ ```
44
58
 
45
- ## 拦什么
59
+ **万能话**——放到哪都通顺。
46
60
 
47
- 按严重度排,只报第一条——报三条 agent 会挑最轻的改。
61
+ ```
62
+ 随着人工智能的发展 / 众所周知 / 值得注意的是 / 不仅…更…
63
+ ```
48
64
 
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/` 里可复现:
65
+ ### 第二层 · 套话
66
+
67
+ **模板整句**
68
+
69
+ ```
70
+ 这条我认 / 本鱼记下了 / 感谢分享 / 受益匪浅 / 说白了就是
71
+ ```
72
+
73
+ **鸡汤口号**
74
+
75
+ ```
76
+ 愿你所行皆坦途 / 新的一天新的开始 / 努力不一定会成功,但不努力一定会失败
77
+ ```
78
+
79
+ **学习腔**
80
+
81
+ ```
82
+ 学到了很多 / 涨知识了 / 非常实用 / 希望以后多发这类帖子
83
+ ```
84
+
85
+ ### 第三层 · 场景
86
+
87
+ **git**(commit / PR / review / issue / changelog)
88
+
89
+ ```
90
+ feat: 优化了用户模块的代码结构 → 空转
91
+ ## 概述 / ## 改动 / ## 影响 → PR 模板骨架
92
+ 整体实现思路清晰,建议后续优化 → review 空话
93
+ 感谢反馈!这个问题我们已经记录 → issue 客服腔
94
+ ```
95
+
96
+ **代码注释**——把代码念一遍。
97
+
98
+ ```js
99
+ // 初始化计数器 → 打回
100
+ let total = 0;
101
+ // 这里之所以要排序,是因为下游依赖顺序稳定的分页 → 能发
102
+ ```
103
+
104
+ 判据来自 [beagle style-criteria](https://github.com/existential-birds/beagle/blob/main/plugins/beagle-core/skills/llm-artifacts-detection/references/style-criteria.md)
105
+ 和 [voku/code-slop](https://github.com/voku/agent-skills/blob/main/skills/code-slop/rules/comments-hygiene.md):
106
+
107
+ > comments must explain **why**, never **what** the code already expresses.
108
+
109
+ ## 实测六组数据
110
+
111
+ 全部在 `tools/` 里可复现:
67
112
 
68
113
  | 测试 | 样本 | 结果 |
69
114
  |---|---|---|
70
- | 真实场景(DSH/评论/机器人) | 25 条 | 漏 0,误拦 0 |
71
- | AI 八股(客服腔/对举/空夸/模板) | 35 条 | 拦住 35(100%) |
72
- | 真人原话(DSH 会话 + 贴吧 + 聊天) | 51 条 | 误拦 0(0%) |
115
+ | **贴吧真人**(孙吧 + v吧原文) | 68 条 | 误拦 0 |
116
+ | **全域场景**(18 个场景 × 2 条) | 36 条 | 漏 0,误拦 0 |
117
+ | **真人原话**(DSH + 聊天) | 51 条 | 误拦 0 |
118
+ | **git 真人**(commit + PR + review) | 28 条 | 误拦 0 |
119
+ | **AI 八股**(客服腔 + 对举 + 空夸 + 模板) | 35 条 | 拦住 35(100%) |
120
+ | **真实场景** | 25 条 | 漏 0,误拦 0 |
121
+ | **对抗绕过**(故意换皮) | 10 种 | 拦住 6(60%) |
73
122
 
74
123
  ```sh
75
- node tools/audit.mjs # 真实场景 25 条
76
- node tools/missrate.mjs # AI 八股 35 条,看拦截率
77
- node tools/falserate.mjs # 真人原话 51 条,看误拦率
78
- node tools/evasion.mjs # 对抗测试:故意绕开规则
124
+ node tools/tieba-real.mjs # 贴吧真人 68 条(孙吧、v吧原文)
125
+ node tools/all-scenes.mjs # 18 个场景,36 条
126
+ node tools/falserate.mjs # 真人 51 条
127
+ node tools/git-false.mjs # git 真人 28 条
128
+ node tools/missrate.mjs # AI 八股 35 条
129
+ node tools/evasion.mjs # 对抗绕过
130
+ node tools/audit.mjs # 真实场景 25 条
131
+ ```
132
+
133
+ ### 贴吧那批语料为什么值钱
134
+
135
+ 孙吧、v吧的真人说话充满了「八股规则看来可疑」的形状——
136
+
137
+ ```text
138
+ 反问: 你确定看不到过去的时间?兄弟
139
+ 三段并列:提瓦特世界是过去、现在、未来同时存在的
140
+ 复述后反打:是啊,所以就静悄悄的也忘了
141
+ 直接骂: 你放屁,分明是天理提供的
142
+ 单字回复:诶嘿 / 草 / 就这?
143
+ 接梗: 那维莱特:新鞋,别搞
79
144
  ```
80
145
 
146
+ 这些都是真人在说真话。68 条零误拦,说明规则没把这些当成套话。
147
+
81
148
  ## 它拦不住什么
82
149
 
83
- 对抗测试(`evasion.mjs`)里,10 种绕过手法拦住了 6 种。剩下 4 种是已知边界:
150
+ 对抗测试里 10 种绕过手法拦住了 6 种。剩下 4 种是已知边界:
84
151
 
85
- - **换同义词** —— 「功能多牛啊,用起来也顺手」,词换了形状没换,但不在表里
152
+ - **换同义词** —— 「功能多牛啊,用起来也顺手」,词换了形状没换
86
153
  - **换成英文** —— 英文只做了留白词,句式没做
87
154
  - **加脏话伪装** —— 「真他妈不错」,脏话把评价词淹了
88
- - **去掉分组标记** —— 「目标是明确的,任务是拆过的,复盘也做了」
155
+ - **去掉分组标记** —— 「目标是明确的,任务是拆过的」
156
+
157
+ **规则只能认形状,认不了「这句话是不是真的」。** 这是止血带,不是解药。
89
158
 
90
- **规则只能认形状,认不了「这句话是不是真的」。** 这是一个止血带,不是解药。
159
+ ## 长文也判
91
160
 
92
- ## 跟 DSH 会话怎么接
161
+ 300 字以上不跳过——长邮件、长周报、长 PR 一样会八股。
93
162
 
94
- DSH 有 `agent/pre-step` 这个 waterfall 钩子,能拿到本轮要发出去的 `messages` 并改它。
95
- 理论上可以在那里挂自动改写。**现在没有做**——`bagu_guard` 是个工具,靠 agent 自己调。
163
+ 但长文的门槛不同:同一个信号要出现**两次以上**才算,一次不算。这样长文里偶尔一个「优化了」不会被打回,反复出现才被拦。
96
164
 
97
- 要真正变成自动门,得在插件里 `ctx.on('agent/pre-step', ...)` 拦一道。
98
- 那是下一步的事,不是现在。
165
+ ## 怎么用
166
+
167
+ ```js
168
+ bagu_guard({ text: "这条我认!首先态度要正,其次内容要实,最后要持续更新。" })
169
+ → "改:模板三连 · 直接说事,不用「首先其次最后」"
170
+
171
+ bagu_guard({ text: "登录失败时不再清空已填的手机号" })
172
+ → "OK"
173
+ ```
174
+
175
+ 过了就回 `OK`,两个字。
176
+
177
+ **三种模式:**
178
+
179
+ ```js
180
+ bagu_guard({ text }) // 守门(默认)
181
+ bagu_guard({ text, mode: 'report' }) // 详细报告,给人看
182
+ bagu_guard({ text, mode: 'ask' }) // 只要问句
183
+ ```
184
+
185
+ **输出预算:通过 2 字,打回一行 40 字内。** 按严重度排,只报第一条——报三条 agent 会挑最轻的改。
99
186
 
100
187
  ## 装
101
188
 
@@ -108,21 +195,11 @@ dsh plugin --profile web add dsh-bagu
108
195
  ## 设置页
109
196
 
110
197
  - **挡不挡** —— 总开关
111
- - **多严** —— 正常只拦硬信号;严格连破折号、空夸也拦
198
+ - **多严** —— 正常只拦硬信号;严格连破折号也拦
112
199
  - **提示那一节** —— 关掉只留工具,不往系统提示里塞话
113
- - **试一段** —— 五种真实样本,当场看能不能过
200
+ - **试一段** —— 五种样本,当场看能不能过
114
201
 
115
- ## 一个工具,三种模式
116
-
117
- ```js
118
- bagu_guard({ text }) // 守门(默认),只回 OK 或一行改法
119
- bagu_guard({ text, mode: 'report' }) // 详细报告,给人看
120
- bagu_guard({ text, mode: 'ask' }) // 只要问句
121
- ```
122
-
123
- 三个原本是分开的工具,合成一个了——每多一个工具就多一份描述,每次都烧 token。
124
-
125
- ## 省 token 是怎么做的
202
+ ## 省 token
126
203
 
127
204
  | 项 | 大小 |
128
205
  |---|---|
@@ -130,16 +207,13 @@ bagu_guard({ text, mode: 'ask' }) // 只要问句
130
207
  | 工具描述(1 个) | **54 字** |
131
208
  | 守门器输出 | 2 字(通过)/40 字内(打回) |
132
209
 
133
- 固定开销合计 **85 字**,判断全在本地正则里跑完,**不调模型**。
210
+ 固定开销合计 **85 字**。判断全在本地正则里跑完,**不调模型**。
134
211
 
135
212
  系统提示只有一句:「要发出去的话,先过 bagu_guard。被打回就改,别硬发。」
136
- 之前那四条写作建议删了——守门器自己会拦,提示里再教一遍是重复投资。
137
213
 
138
214
  ## 短句也能查
139
215
 
140
- 聊天回复二三十字是常态,密度指标在这个长度上分母太小。
141
-
142
- 六十字以下切换成**绝对计数**:不看密度,看命中了什么。
216
+ 聊天回复二三十字是常态,密度指标在这个长度上分母太小。六十字以下切换成**绝对计数**:不看密度,看命中了什么。
143
217
 
144
218
  ```text
145
219
  「这不是技术问题,而是认知问题。」 → 打回
@@ -151,12 +225,12 @@ bagu_guard({ text, mode: 'ask' }) // 只要问句
151
225
  - 两轮对照实验,1169 篇 / 520 万字([lieflat-less-ai-tone](https://github.com/larashero3-dotcom/lieflat-less-ai-tone))
152
226
  - 10 万条真人评论 vs 2180 条 AI 评论的密度实测
153
227
  - [sloplint](https://github.com/DW-Studio/sloplint) 的评分公式
228
+ - [beagle style-criteria](https://github.com/existential-birds/beagle/blob/main/plugins/beagle-core/skills/llm-artifacts-detection/references/style-criteria.md) 和 [voku/code-slop](https://github.com/voku/agent-skills/blob/main/skills/code-slop/rules/comments-hygiene.md) 的注释判据
154
229
 
155
230
  ## 开发
156
231
 
157
232
  ```sh
158
- npm test # 50 个单元测试
159
- node tools/audit.mjs
233
+ npm test # 70 个单元测试
160
234
  ```
161
235
 
162
236
  ## 许可
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.4.0",
6
+ "version": "0.5.1",
7
7
  "license": "MIT",
8
- "description": "AI 要对外说话之前的一道门:过了就发,没过就打回。",
8
+ "description": "AI 对外说话前的一道门:聊天、评论、邮件、commit、PR、文档、注释都管。",
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": "每条对外回复发出前过一遍,像八股就打回。只回 OK 或一行改法。"
32
+ "description": "所有对外文本发出前过一遍,像八股就打回。只回 OK 或一行改法。"
33
33
  }
34
34
  ]
35
35
  }
package/lib/guard.js CHANGED
@@ -13,7 +13,8 @@
13
13
  */
14
14
 
15
15
  import { analyze } from './analyze.js';
16
- import { STOCK_PHRASES } from './lexicon.js';
16
+ import { STOCK_PHRASES, GIT_STOCK, GIT_TEMPLATE_ROWS, countTemplateRows, REVIEW_STOCK } from './lexicon.js';
17
+ import { HOLLOW_ACTIONS, HOLLOW_ADJECTIVES, LEARNED_TONE, CODE_COMMENT_NARRATION, MOTIVATIONAL_SLOP, UNIVERSAL_FILLER } from './layers.js';
17
18
 
18
19
  /**
19
20
  * 打回原因按严重度排。谁先命中谁负责,只报一条 —— 报三条 agent 会挑最轻的改。
@@ -33,6 +34,105 @@ const OPPOSITION_FRAMES = [
33
34
  ];
34
35
 
35
36
  const REASONS = [
37
+ {
38
+ id: 'universal-filler',
39
+ // 万能话:放到任何语境都通顺,等于什么都没说
40
+ test: (r, text, o = {}) => {
41
+ const bar = o.repeatBar || 1;
42
+ const n = UNIVERSAL_FILLER.reduce((a, re) => {
43
+ const m = text.match(new RegExp(re.source, 'g'));
44
+ return a + (m ? m.length : 0);
45
+ }, 0);
46
+ return n >= bar;
47
+ },
48
+ why: (r, text) => {
49
+ const re = UNIVERSAL_FILLER.map((x) => new RegExp(x.source)).find((x) => x.test(text));
50
+ return re ? `万能话「${(text.match(re) || [''])[0].slice(0, 12)}」` : '万能话';
51
+ },
52
+ hint: '删掉这句,直接说事',
53
+ },
54
+ {
55
+ id: 'hollow-action',
56
+ // 动词 + 宏观名词:说了动作,没说改哪一行。不分场景。
57
+ test: (r, text, o = {}) => {
58
+ const bar = o.repeatBar || 1;
59
+ const n = HOLLOW_ACTIONS.reduce((a, re) => {
60
+ const m = text.match(new RegExp(re.source, 'g'));
61
+ return a + (m ? m.length : 0);
62
+ }, 0);
63
+ return n >= bar;
64
+ },
65
+ why: (r, text) => {
66
+ const re = HOLLOW_ACTIONS.map((x) => new RegExp(x.source)).find((x) => x.test(text));
67
+ const hit = re ? (text.match(re) || [''])[0] : '';
68
+ return hit ? `空转「${hit.slice(0, 14)}」` : '空转';
69
+ },
70
+ hint: '说清改了什么,比如具体到哪一行、哪一次',
71
+ },
72
+
73
+ {
74
+ id: 'motivational',
75
+ // 鸡汤/口号:不求证的句子
76
+ test: (r, text) => MOTIVATIONAL_SLOP.some((re) => new RegExp(re.source).test(text)),
77
+ why: (r, text) => {
78
+ const re = MOTIVATIONAL_SLOP.map((x) => new RegExp(x.source)).find((x) => x.test(text));
79
+ return re ? `鸡汤「${(text.match(re) || [''])[0].slice(0, 12)}」` : '鸡汤';
80
+ },
81
+ hint: '说一件具体的事',
82
+ },
83
+ {
84
+ id: 'changelog-hollow',
85
+ // 变更日志里的空转条目:一行说了个动作,但没说改了什么
86
+ // 「性能大幅提升」「全新的用户界面」「修复了若干已知问题」
87
+ test: (r, text) => {
88
+ if (!/^#{1,4}\s*(?:新增|修复|变更|改进|移除|Added|Fixed|Changed|Removed)/im.test(text)) return false;
89
+ // 逐条看 - 开头的行
90
+ const lines = text.split('\n').filter((l) => /^-\s/.test(l));
91
+ const hollow = lines.filter((l) =>
92
+ /(?:全新|大幅|显著|全面|若干|多个|一些|相关|优化了|提升了|完善了)/.test(l)
93
+ );
94
+ return hollow.length >= 1 && hollow.length >= lines.length * 0.5;
95
+ },
96
+ why: '变更日志空转',
97
+ hint: '每条说清改了什么,比如「登录失败时不再清空手机号」',
98
+ },
99
+ {
100
+ id: 'comment-narration',
101
+ // 代码注释把代码念一遍:「// 初始化计数器」「// 遍历每个商品」
102
+ test: (r, text) => {
103
+ if (!text.includes('//') && !text.includes('#')) return false;
104
+ return CODE_COMMENT_NARRATION.some((re) => new RegExp(re.source, re.flags).test(text));
105
+ },
106
+ why: '注释念代码',
107
+ hint: '写为什么这么做,不写代码在做什么',
108
+ },
109
+ {
110
+ id: 'hollow-adjective',
111
+ // 空形容词:能贴到任何产品上的词堆在一起
112
+ test: (r, text, o = {}) => {
113
+ const bar = o.repeatBar || 1;
114
+ const n = HOLLOW_ADJECTIVES.reduce((a, re) => {
115
+ const m = text.match(new RegExp(re.source, 'g'));
116
+ return a + (m ? m.length : 0);
117
+ }, 0);
118
+ return n >= bar;
119
+ },
120
+ why: (r, text) => {
121
+ const re = HOLLOW_ADJECTIVES.map((x) => new RegExp(x.source)).find((x) => x.test(text));
122
+ return re ? `空形容词「${(text.match(re) || [''])[0].slice(0, 14)}」` : '空形容词';
123
+ },
124
+ hint: '说它具体做到了什么',
125
+ },
126
+ {
127
+ id: 'learned-tone',
128
+ // 学习腔:学到了 / 涨知识 / 希望多发。评论区特有,换到哪都是假学生
129
+ test: (r, text) => LEARNED_TONE.some((re) => new RegExp(re.source).test(text)),
130
+ why: (r, text) => {
131
+ const re = LEARNED_TONE.map((x) => new RegExp(x.source)).find((x) => x.test(text));
132
+ return re ? `学习腔「${(text.match(re) || [''])[0].slice(0, 12)}」` : '学习腔';
133
+ },
134
+ hint: '说你自己看到的具体东西,别说学到了',
135
+ },
36
136
  {
37
137
  id: 'triple-template',
38
138
  // 逗号和分号都算。QQ 机器人一条回复通常不分号,写成「首先A,其次B,最后C」
@@ -57,6 +157,40 @@ const REASONS = [
57
157
  why: '反问式对举',
58
158
  hint: '直接说结论,别用反问',
59
159
  },
160
+ {
161
+ id: 'git-stock',
162
+ // commit / PR 里的「优化了结构、提升可维护性」—— 说了动作没说改哪一行
163
+ test: (r, text, o = {}) => {
164
+ const bar = o.repeatBar || 1;
165
+ const n = GIT_STOCK.reduce((a, re) => {
166
+ const m = text.match(new RegExp(re.source, 'g'));
167
+ return a + (m ? m.length : 0);
168
+ }, 0);
169
+ return n >= bar;
170
+ },
171
+ why: (r, text) => {
172
+ const re = GIT_STOCK.find((x) => x.test(text));
173
+ return re ? `套话「${(text.match(re) || [''])[0]}」` : 'git 套话';
174
+ },
175
+ hint: '说改了什么,比如「登录失败时不再清空已填的手机号」',
176
+ },
177
+ {
178
+ id: 'git-template',
179
+ // PR 模板骨架:## 概述 / ## 改动 / ## 影响,两行以上就假
180
+ test: (r, text) => countTemplateRows(text) >= 2,
181
+ why: 'PR 模板骨架',
182
+ hint: '一两句话说清为什么改,不要分节',
183
+ },
184
+ {
185
+ id: 'review-stock',
186
+ // review 里的「思路清晰、建议后续优化」—— 提了意见没指哪一行
187
+ test: (r, text) => REVIEW_STOCK.some((re) => re.test(text)),
188
+ why: (r, text) => {
189
+ const re = REVIEW_STOCK.find((x) => x.test(text));
190
+ return re ? `套话「${(text.match(re) || [''])[0]}」` : 'review 套话';
191
+ },
192
+ hint: '指出具体哪一行、什么问题',
193
+ },
60
194
  {
61
195
  id: 'stock',
62
196
  test: (r, text) => {
@@ -71,9 +205,39 @@ const REASONS = [
71
205
  },
72
206
  {
73
207
  id: 'negation',
74
- test: (r, text) =>
75
- r.hits.structures.some((s) => s.id === 'negation') ||
76
- OPPOSITION_FRAMES.some((re) => re.test(text)),
208
+ test: (r, text) => {
209
+ const hit = r.hits.structures.some((s) => s.id === 'negation') ||
210
+ OPPOSITION_FRAMES.some((re) => re.test(text));
211
+ if (!hit) return false;
212
+ // 前半句已经种下一个可能被误解的说法 → 这个对立有活干,放过。
213
+ // 判据抄 issue #1:前面出现过「以为/很多人/不是词表」这类,或者
214
+ // 「不是X」里的 X 在前面真正被提过。
215
+ const m = text.match(/不是([^,。!?\n]{1,20})[,]?(?:而是|,是)/);
216
+ const x = m ? m[1].trim() : null;
217
+
218
+ if (m) {
219
+ const before = text.slice(0, text.indexOf(m[0]));
220
+ if (before.includes(x)) return false; // X 在前面被种下过
221
+ }
222
+ // 前面有「以为/很多人/都」这类误解标记
223
+ if (/(?:以为|很多人|不少人|都说|总有人|别人说)/.test(text.slice(0, text.indexOf(m ? m[0] : '')))) {
224
+ return false;
225
+ }
226
+ if (!m) return true;
227
+
228
+ // 两边都是专名(人名、地名、组织名)时,这是对事实的纠正,不是自造对立。
229
+ // 「不是天理,是阿斯莫代」—— 放过
230
+ // 「不是技术问题,而是认知问题」—— 拦
231
+ const after = text.slice(text.indexOf(m[0]) + m[0].length);
232
+ const y = after.split(/[,。!?]/)[0].replace(/^(?:而是|,是|是)/, '').trim();
233
+ // 专名判据要严:两边都不带抽象后缀,长度都在 2-5 字。
234
+ const SUFFIX = /(?:问题|层面|角度|维度|本质|核心|关键|认知|思维|逻辑|方式|方法|原因|结论)$/;
235
+ const isName = (w) => typeof w === 'string' && w.length >= 2 && w.length <= 5 && !SUFFIX.test(w);
236
+ if (isName(x) && isName(y)) {
237
+ return false;
238
+ }
239
+ return true;
240
+ },
77
241
  why: (r, text) => {
78
242
  if (r.hits.structures.some((s) => s.id === 'negation')) return '不是A而是B';
79
243
  const re = OPPOSITION_FRAMES.find((x) => x.test(text));
@@ -96,7 +260,22 @@ const REASONS = [
96
260
  },
97
261
  {
98
262
  id: 'triple-list',
99
- test: (r) => r.hits.structures.some((s) => s.id === 'triple'),
263
+ // 列举真实存在的东西不算凑数。判据:并列项里能不能指认出具体的名词或数字。
264
+ // 「开关、三个阈值、当场试一下」→ 能指认,放过
265
+ // 「成本低、维护简单、扩展性好」→ 全是形容词,拦
266
+ test: (r, text) => {
267
+ const row = r.hits.structures.find((s) => s.id === 'triple');
268
+ if (!row) return false;
269
+ const span = row.spans[0]?.text || '';
270
+ const items = span.split('、').filter(Boolean);
271
+ // 每一项里有没有数字、英文、或者带量词的实词
272
+ // 判据:这一项末尾是不是形容词/评价。
273
+ // 「成本低」「维护简单」「扩展性好」—— 都以形容词收尾,是凑数。
274
+ // 「三个阈值」「当场试一下」「开关」—— 是能指认的东西。
275
+ const ADJ_TAIL = /(?:低|高|好|快|慢|强|弱|简单|复杂|清晰|合理|稳定|流畅|方便|优秀|完善|丰富|独特|重要|关键|核心)$/;
276
+ const concrete = items.filter((it) => !ADJ_TAIL.test(it.trim()));
277
+ return concrete.length < 2;
278
+ },
100
279
  why: '三段并列',
101
280
  hint: '挑一个说透,别凑三个',
102
281
  },
@@ -159,6 +338,9 @@ const REASONS = [
159
338
  },
160
339
  ];
161
340
 
341
+ /** 供测试用:直接调用每条规则的 test,绕开 guard 的 try/catch 兜底。 */
342
+ export const REASONS_FOR_TEST = REASONS;
343
+
162
344
  /**
163
345
  * 过一遍。
164
346
  *
@@ -170,15 +352,20 @@ export function guard(text, opts = {}) {
170
352
  const src = String(text ?? '').trim();
171
353
  if (!src) return { ok: true, line: 'OK' };
172
354
 
173
- // 太长的不拦 —— 那是长文,不是聊天回复,判断标准不一样
174
- if (src.length > 300) return { ok: true, line: 'OK', skipped: 'too-long' };
355
+ // PR 描述、长 commit 也是对外文本,不该当文档放过。
356
+ // 先判是不是 git 内容,再决定要不要跳过长文。
357
+ // 判是不是 git 文本,用逐行的独立正则,不依赖 GIT_TEMPLATE_ROWS 的 m 标志
358
+ // 长文本不跳过 —— 长邮件、长周报、长 PR 一样会像八股。
359
+ // 但长文的判据要放宽:同一信号出现两三次才算,一次不算。
360
+ const isLong = src.length > 300;
361
+ const repeatBar = isLong ? 2 : 1;
175
362
 
176
363
  const r = analyze(src);
177
364
  const strict = opts.strict === true;
178
365
 
179
366
  for (const reason of REASONS) {
180
367
  let hit = false;
181
- try { hit = reason.test(r, src); } catch { hit = false; }
368
+ try { hit = reason.test(r, src, { repeatBar }); } catch { hit = false; }
182
369
  if (!hit) continue;
183
370
 
184
371
  // 非 strict 时,最后两条(破折号、无具体物)只警告不打回
package/lib/layers.js ADDED
@@ -0,0 +1,91 @@
1
+ /**
2
+ * 通用层:不分场景,凡是人写的话都成立。
3
+ *
4
+ * 下面前两层跟场景无关 —— README、微博、邮件、commit、review,
5
+ * 都是在「一句话换个人说还成不成立」这一个判据上过的。
6
+ *
7
+ * 场景层只是补充:每个场景有自己长出来的套话,但那不是判断依据,
8
+ * 只是提高命中率的加速器。
9
+ */
10
+
11
+ /** 第二层:空转。说了一个动作,但没说做了什么。哪都适用。 */
12
+ export const HOLLOW_ACTIONS = [
13
+ // 动词 + 宏观名词。改哪一行?没说。
14
+ /(?:优化|提升|改善|增强|完善|强化|改进)了?[^,。!?\n]{0,8}(?:结构|性能|体验|流程|逻辑|质量|效率|可维护性|可读性|稳定性|兼容性|扩展性|可用性|合理性|规范性)/g,
15
+ /(?:调整|修改|更新|变更)了?[^,。!?\n]{0,10}(?:相关|部分|若干|一些|整体|全部|必要|相应)/g,
16
+ /(?:修复|解决|处理)了?(?:若干|多个|一些|部分|一系列|相关|已知)[^。!?\n]{0,8}(?:问题|bug|缺陷|错误|情况)?/gi,
17
+ // 「进行了」开头的一律是空转
18
+ /进行了?[^,。!?\n]{0,12}(?:处理|操作|调整|优化|改进|完善)/g,
19
+ // 「使得/使其」句式
20
+ /(?:使得?|令)[^,。!?\n]{0,12}(?:更加?|更)[^,。!?\n]{0,8}(?:清晰|简洁|友好|高效|稳定|合理)/g,
21
+ ];
22
+
23
+ /**
24
+ * 第二层补充:空形容词。能贴到任何产品/项目/方案上,就是在撑场面。
25
+ * 「先进的」「高性能」「高可用」「灵活」「易用」「完善的」「全面的」
26
+ */
27
+ export const HOLLOW_ADJECTIVES = [
28
+ // 「具备/拥有 + 良好的 X」是空转的标准形状,X 填什么都行
29
+ /(?:具备|拥有|具有)[^,。!?\n]{0,6}(?:良好|优秀|出色|卓越|强大|完善)的[^,。!?\n]{0,8}/g,
30
+ // 「能够满足…需要/需求」——满足谁的需要?没说是谁
31
+ /(?:能够?|可以|可)(?:满足|适应|支持)[^,。!?\n]{0,12}(?:需要|需求|要求|发展)/g,
32
+ /(?:先进|领先|专业|成熟|完善|全面|丰富|强大|灵活|易用|高效|稳定|可靠|安全|优质|卓越|创新)(?:的)?(?:技术|架构|方案|体系|能力|功能|体验|服务|设计|平台|产品|支持|保障)/g,
33
+ /(?:高|极)(?:性能|可用|并发|效率|质量|标准|精度|稳定)/g,
34
+ /(?:多种|各类|全方位|一站式|集成化|模块化)[^,。!?\n]{0,12}(?:支持|方案|服务|能力|方式)/g,
35
+ ];
36
+
37
+ /**
38
+ * 第三层补充:学习/认可腔。评论区特有,但换到哪都是假学生。
39
+ * 「学到了」「涨知识」「受益匪浅」「说得太对了」
40
+ */
41
+ export const LEARNED_TONE = [
42
+ /(?:学|涨)到了?[^,。!?\n]{0,4}(?:很多|不少|东西|知识)?/g,
43
+ /(?:涨|长)(?:知识|见识|姿势)了?/g,
44
+ /(?:受益|收获)(?:匪浅|颇多|良多|很大)/g,
45
+ // 只认明确在拍马屁的形态。「你说得对但是我不听」是梗,不在此列。
46
+ // 「讲得很好」「说得太对」都是拍马屁。「你说得对」不收(那是接梗/抬杠)。
47
+ /(?:说得|讲得)(?:太|很|非常|真)(?:对|好|准)(?:了)?/g,
48
+ /(?:非常|很|挺)(?:实用|有用|干货|有价值)/g,
49
+ /希望(?:以后|下次|继续|多)[^,。!?\n]{0,8}(?:多发|更新|分享)/g,
50
+ ];
51
+
52
+ /**
53
+ * 代码注释:把代码本身念一遍。
54
+ *
55
+ * 来源:beagle style-criteria「Obvious Comments」、voku code-slop「comments-hygiene」。
56
+ * 判据是「注释删掉之后,读代码能不能得到同样的信息」。能,就是废话。
57
+ *
58
+ * 注意:这条只认最明显的形态 —— 注释里出现「初始化/循环/遍历/返回/设置」
59
+ * 这类把动作念一遍的动词。真正聪明的判断要读代码,正则做不到。
60
+ */
61
+ export const CODE_COMMENT_NARRATION = [
62
+ /^\s*\/\/\s*(?:初始化|循环|遍历|迭代|返回|设置|赋值|定义|声明|创建|获取|判断|检查)[^\n]{0,20}$/gm,
63
+ /^\s*#\s*(?:initialize|loop|iterate|return|set|create|get|check|define)[^\n]{0,24}$/gim,
64
+ /\/\/\s*end\s+(?:if|for|while|switch|function|class)\s*$/gim,
65
+ ];
66
+
67
+ /**
68
+ * 鸡汤/口号。微博、朋友圈、公众号开头重灾区。
69
+ *
70
+ * 判据跟别的不一样:这类句子的问题不在句式,在「它不求证」。
71
+ * 「努力不一定会成功」——对,但跟什么都没说一样。
72
+ * 「愿你所行皆坦途」——祝福,但没有一个具体的人。
73
+ */
74
+ export const MOTIVATIONAL_SLOP = [
75
+ /愿[你您][^。!?\n]{0,20}(?:皆|都|一切)[^。!?\n]{0,8}(?:坦途|美好|顺遂|如意|如愿)/g,
76
+ /(?:新|崭新)的(?:一天|开始|一年|征程)[,,]?/g,
77
+ /(?:早安|晚安|中午好)[!!,,]?\s*(?:新|今天|愿)/g,
78
+ /(?:努力|坚持|奋斗|拼搏)[^。!?\n]{0,10}(?:不一定|就会|才能|才会)/g,
79
+ /(?:加|一起)?油[!!]/g,
80
+ /(?:所行|所遇|所见|所得)[^。!?\n]{0,6}(?:皆|都)/g,
81
+ /(?:每一个|每一天)[^。!?\n]{0,10}(?:值得|都)(?:被|是)/g,
82
+ ];
83
+
84
+ /** 第三层:万能话。放到任何语境都通顺,等于什么都没说。 */
85
+ export const UNIVERSAL_FILLER = [
86
+ /(?:随着|在)[^,。!?\n]{0,10}(?:的)?(?:发展|进步|普及|到来|推动)/g,
87
+ /(?:在)?(?:当今|现在|如今)[^,。!?\n]{0,6}(?:时代|社会|环境|背景)/g,
88
+ /众所周知[,,]?/g,
89
+ /(?:值得|需要)(?:一提|注意|强调|指出)的?是/g,
90
+ /(?:不仅|不只)(?:仅)?[^,。!?\n]{0,16}(?:更|还|而且)/g,
91
+ ];
package/lib/lexicon.js CHANGED
@@ -24,7 +24,6 @@ export const AI_WORDS = [
24
24
  '抓手',
25
25
  '闭环',
26
26
  '颗粒度',
27
- '对齐',
28
27
  '拉通',
29
28
  '联动',
30
29
  '生态位',
@@ -259,6 +258,10 @@ export const STOCK_PHRASES = [
259
258
  /(令人|让人)?受益匪浅/,
260
259
  /希望(这些)?(能|对你有)帮/,
261
260
  /如有(疑问|需要)/,
261
+ /感谢(反馈|建议|支持|关注)/,
262
+ /(?:我们)?(?:已经?|已)(?:记录|收到|确认)(?:了)?/,
263
+ /(?:会在|将在|后续)(?:版本|更新)[^。\n]{0,10}(?:修复|处理|支持|优化)/,
264
+ /这个问题(?:我们)?(?:会|将|已经)/,
262
265
  // 客套开场
263
266
  /^(您好|你好|亲|亲爱的)[,,!!]/,
264
267
  /^我来(为您|帮你|给大家)/,
@@ -267,6 +270,8 @@ export const STOCK_PHRASES = [
267
270
  /^说了你可能不信/,
268
271
  /^客观(地)?(来)?说/,
269
272
  /^(客观|老实)(地)?(来)?(讲|说)/,
273
+ // 黑话里的「对齐」:后面跟抽象名词才是空话。跟时间/版本/文件名是实词。
274
+ /对齐[^。!?\n]{0,4}(?:认知|目标|预期|思想|方向|共识|口径|资源|需求)/,
270
275
  /^说白了(就是)?[,,]/,
271
276
  /^说穿了[,,]/,
272
277
  /(?:从|在)(?:根|底|本质)(?:上|儿)(?:讲|说|解决|来看)/,
@@ -275,6 +280,61 @@ export const STOCK_PHRASES = [
275
280
  /^(看到|听到|读完)[^。!?]{0,10}(我)?(坐直|鸡皮|破防|震惊)/,
276
281
  ];
277
282
 
283
+ /**
284
+ * git 场景的套话。commit、PR 描述、review 评论是另一套形状:
285
+ * 不是「真的很不错」那种空夸,是「动词 + 宏观名词」——
286
+ * 「优化了代码结构」「提升了可维护性」「修复了若干问题」。
287
+ *
288
+ * 共同特征:说了一个动作,但没说这个动作具体改哪一行。
289
+ */
290
+ export const GIT_STOCK = [
291
+ // 优化类(最泛滥)
292
+ /优化了?[^,。 conv\n]{0,6}(?:结构|性能|体验|流程|逻辑|代码|可维护性|可读性)/,
293
+ /提升了?[^,。\n]{0,6}(?:可维护性|可读性|性能|效率|质量|稳定性|复用性|扩展性)/,
294
+ /改善了?[^,。\n]{0,6}(?:结构|组织|设计|体验)/,
295
+ /重构了?[^,。\n]{0,8}(?:逻辑|结构|代码|模块)/,
296
+ // 模糊数量
297
+ /修复了?(?:若干|多个|一些|部分|一系列)[^。\n]{0,6}(?:问题|bug|缺陷|错误)/i,
298
+ /(?:调整|修改|更新)了?(?:若干|多个|一些|部分)[^。\n]{0,8}/,
299
+ // 元话术
300
+ /(?:相关|本次|此次)(?:改动|修改|更新|变更)[::]/,
301
+ /(?:完善|改进)了?[^。\n]{0,6}(?:功能|逻辑|流程)/,
302
+ /使[^。\n]{0,12}更加[^。\n]{0,8}(?:清晰|简洁|友好|高效|稳定)/,
303
+ ];
304
+
305
+ /**
306
+ * PR 描述的模板骨架。命中两行以上就不像人写的。
307
+ * 常见于自动生成的 PR:## 概述 / ## 改动 / ## 影响
308
+ */
309
+ export const GIT_TEMPLATE_ROWS = [
310
+ /^#{1,4}\s*(概述|背景|改动|变更|影响|测试|备注|检查项|Checklist)\s*$/gm,
311
+ /^-\s*\[(?:x| )\]\s*(?:已|未)?(?:测试|验证|更新|添加)/gm,
312
+ /^(?:本|该)(?:PR|pr|次改动)(?:优化|调整|新增|修复|重构)/gm,
313
+ ];
314
+
315
+ /** 数 PR 模板骨架命中了几行(不是几个正则命中,是几行)。 */
316
+ export function countTemplateRows(text) {
317
+ const src = String(text ?? '');
318
+ let n = 0;
319
+ for (const re of GIT_TEMPLATE_ROWS) {
320
+ const m = src.match(re);
321
+ if (m) n += m.length;
322
+ }
323
+ return n;
324
+ }
325
+
326
+ /**
327
+ * review 评论的空话。提了意见但没指出哪一行。
328
+ */
329
+ export const REVIEW_STOCK = [
330
+ /(?:思路|实现|代码|逻辑)[^。\n]{0,4}(?:清晰|合理|清楚|规范|整洁)/,
331
+ /建议(?:后续|以后|将来|下次)/,
332
+ /(?:可以|建议)(?:进一步|继续|再)[^。\n]{0,8}/,
333
+ /(?:整体|总体)(?:来看|来说|上)[^。\n]{0,10}/,
334
+ /(?:这段|这里|这个)[^。\n]{0,8}(?:写得|做得)(?:很|挺|比较)?(?:好|不错|清晰)/,
335
+ /(?:LGTM|looks good|没问题|可以合)/i,
336
+ ];
337
+
278
338
  export const TEMPLATE_TRIPLE = /首先[^。;!?\n]{1,30}[;;][^。;!?\n]{0,10}其次[^。;!?\n]{1,30}[;;,,][^。;!?\n]{0,10}(?:最后|最终|总之)/;
279
339
 
280
340
  /** 文体基线与判定词,按真人评论语料实测。 */
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "dsh-bagu",
3
- "version": "0.4.0",
4
- "description": "AI 要对外说话之前的一道门。DSH 会话、QQ 机器人、B站评论都算。过了就发,没过就打回。",
3
+ "version": "0.5.1",
4
+ "description": "AI 对外说话前的一道门。聊天、评论、邮件、commit、PR、文档、注释都管:过了就发,没过就打回。",
5
5
  "type": "module",
6
6
  "main": "lib/index.js",
7
7
  "exports": {
@@ -65,7 +65,10 @@
65
65
  "中文",
66
66
  "AI味",
67
67
  "八股",
68
- "写作"
68
+ "写作",
69
+ "commit",
70
+ "review",
71
+ "注释"
69
72
  ],
70
73
  "devDependencies": {
71
74
  "happy-dom": "^21.0.4"
@@ -0,0 +1,98 @@
1
+ import { test } from 'node:test';
2
+ import assert from 'node:assert/strict';
3
+ import { guard } from '../lib/guard.js';
4
+
5
+ // ── 边界与健壮性 ─────────────────────────────────
6
+
7
+ test('空输入都不崩', () => {
8
+ for (const t of ['', ' ', '\n\n', '\t', null, undefined, 0, false]) {
9
+ assert.doesNotThrow(() => guard(t), `崩在 ${JSON.stringify(t)}`);
10
+ const r = guard(t);
11
+ assert.equal(r.ok, true);
12
+ }
13
+ });
14
+
15
+ test('纯符号 / 单字 / emoji', () => {
16
+ for (const t of ['好', '?!。', '😀😀😀', '。。。', '——']) {
17
+ const r = guard(t);
18
+ assert.equal(r.ok, true, `「${t}」不该被拦: ${r.line}`);
19
+ }
20
+ });
21
+
22
+ test('超长不崩,耗时可控', () => {
23
+ const t = '这个地方需要改动一下,因为原来的实现有点问题。'.repeat(400);
24
+ const start = Date.now();
25
+ const r = guard(t);
26
+ const ms = Date.now() - start;
27
+ assert.ok(ms < 500, `超长输入耗时 ${ms}ms,超过 500ms`);
28
+ assert.equal(typeof r.ok, 'boolean');
29
+ });
30
+
31
+ test('纯英文长文不崩', () => {
32
+ const t = 'The quick brown fox jumps over the lazy dog. '.repeat(60);
33
+ assert.doesNotThrow(() => guard(t));
34
+ });
35
+
36
+ test('纯代码不崩', () => {
37
+ const t = 'const x = 1;\nlet y = 2;\nfunction f() { return x + y; }';
38
+ assert.doesNotThrow(() => guard(t));
39
+ });
40
+
41
+ test('只有代码没有注释时不拦', () => {
42
+ const t = 'const x = 1;\nlet y = 2;';
43
+ const r = guard(t);
44
+ assert.equal(r.ok, true, '没注释不该触发注释规则');
45
+ });
46
+
47
+ test('长文里同一个信号只出现一次不算', () => {
48
+ // 300 字以上的文本,空转信号要出现两次以上才判。
49
+ // 样本必须真的只有一处空转 —— 拿整段 repeat 会把那句一起复制。
50
+ const body = [
51
+ '昨晚十一点半我第三次跑那个脚本,卡在 8443 端口上了。',
52
+ '日志里就一行 EADDRINUSE,我盯着看了半天才反应过来。',
53
+ '后来把之前那个进程 kill 掉就好了,大概是我自己忘了关。',
54
+ '今天又试了一次,端口换成 8445 就通了。',
55
+ '配置改在 /etc/app/config.yml,第 12 行那个 listen 指令。',
56
+ '备份留在 /tmp/app.bak,想退随时退。',
57
+ '测试跑了 37 个,全过。抽了三帧看构图,没发现黑场。',
58
+ '音频峰值在 -3.2 dB,没爆。字幕对齐到第 4 分 12 秒。',
59
+ '文件放在 /Users/me/project/out/,命名是 day1.mp4。',
60
+ '这次的改动其实很小,只是把 timeout 从 30 秒改成 60 秒。',
61
+ '压测跑到 800 QPS 时 p99 超过 200ms,记在 issue #12 了。',
62
+ '回滚的话 git reset --hard 到 a1b2c3d,别 push。',
63
+ '这次优化了流程。', // 全文唯一一处空转
64
+ ];
65
+ const padded = body.join('');
66
+ assert.ok(padded.length > 300, '样本得够长,实际 ' + padded.length);
67
+ assert.ok(padded.length > 300, '样本得够长,实际 ' + padded.length);
68
+ const r = guard(padded);
69
+ assert.equal(r.ok, true, '长文里一处空转不该拦,实际拦了: ' + r.line);
70
+ });
71
+
72
+ test('长文里信号反复出现要拦', () => {
73
+ const slop = ('本周完成了以下工作:优化了系统架构,提升了运行效率,完善了相关文档。' +
74
+ '同时,我们也会持续改进,为用户提供更好的服务。').repeat(6);
75
+ assert.ok(slop.length > 300);
76
+ const r = guard(slop);
77
+ assert.equal(r.ok, false, '长文里反复空转该拦');
78
+ });
79
+
80
+ test('返回值结构稳定', () => {
81
+ for (const t of ['', '好', '这不是技术问题,而是认知问题。']) {
82
+ const r = guard(t);
83
+ assert.equal(typeof r.ok, 'boolean');
84
+ assert.equal(typeof r.line, 'string');
85
+ if (!r.ok) {
86
+ assert.equal(typeof r.why, 'string');
87
+ assert.equal(typeof r.hint, 'string');
88
+ }
89
+ }
90
+ });
91
+
92
+ test('strict 模式只多拦,不少拦', () => {
93
+ const t = '改完了——真的改完了。';
94
+ const normal = guard(t);
95
+ const strict = guard(t, { strict: true });
96
+ assert.equal(normal.ok, true);
97
+ assert.equal(strict.ok, false);
98
+ });
@@ -0,0 +1,126 @@
1
+ import { test } from 'node:test';
2
+ import assert from 'node:assert/strict';
3
+ import { guard } from '../lib/guard.js';
4
+
5
+ // ── git 场景:commit / PR / review / issue ─────────────
6
+
7
+ test('git:套路 commit 全拦', () => {
8
+ const slop = [
9
+ 'feat: 优化了用户模块的代码结构,提升了可维护性',
10
+ 'fix: 修复了若干已知问题',
11
+ 'refactor: 重构时间线生成逻辑,提升代码质量',
12
+ 'chore: 优化了构建流程',
13
+ '更新了一些相关文件',
14
+ '此次改动完善了功能逻辑',
15
+ ];
16
+ for (const t of slop) {
17
+ const r = guard(t);
18
+ assert.equal(r.ok, false, `该拦但放过了: ${t}`);
19
+ assert.ok(r.line.startsWith('改:'), `输出该以「改:」开头: ${r.line}`);
20
+ }
21
+ });
22
+
23
+ test('git:好的 commit 全放过', () => {
24
+ const good = [
25
+ '登录失败时不再清空已填的手机号',
26
+ '修 timeout 重试把同一个订单提交了两次',
27
+ '时间线那段拆出来单放一个文件,不然改一次要翻八百行',
28
+ '去掉出处标注',
29
+ '补 npm 元数据,可以打包发布了',
30
+ '热梗库补释义:从 144 条补到 502 条',
31
+ 'package.json 补 dsh.bundle.patch',
32
+ '0.4.0:守门器 + 省 token',
33
+ '加设置页:开关、三个阈值、当场试一下',
34
+ ];
35
+ for (const t of good) {
36
+ const r = guard(t);
37
+ assert.equal(r.ok, true, `误拦了: ${t} → ${r.line}`);
38
+ }
39
+ });
40
+
41
+ test('git:PR 模板骨架要拦', () => {
42
+ const template = [
43
+ '## 概述\n本 PR 优化了代码结构。\n\n## 改动\n- 调整了章节\n- 新增了条款\n\n## 影响\n无',
44
+ '## 背景\n此次改动提升了可维护性。\n\n## 变更\n见文件列表',
45
+ ];
46
+ for (const t of template) {
47
+ const r = guard(t);
48
+ assert.equal(r.ok, false, `PR 模板该拦: ${r.line}`);
49
+ }
50
+ });
51
+
52
+ test('git:review 空话要拦', () => {
53
+ const slop = [
54
+ '整体实现思路清晰,代码结构合理,建议后续可以进一步优化。',
55
+ '代码写得很好,逻辑很清晰,赞!',
56
+ 'LGTM',
57
+ '建议后续补充测试',
58
+ '这里可以进一步优化一下',
59
+ ];
60
+ for (const t of slop) {
61
+ const r = guard(t);
62
+ assert.equal(r.ok, false, `review 套话该拦: ${t}`);
63
+ }
64
+ });
65
+
66
+ test('git:具体的 review 要放过', () => {
67
+ const good = [
68
+ '第 42 行那个 await 少了一层,函数本身没返回 promise',
69
+ '这里 n+1 了,一次请求会打 200 次库',
70
+ '这个正则没锚定开头,会把 mid 里的也匹配上',
71
+ '测试里那个断言依赖了系统时区,CI 上会挂',
72
+ '这个分支没处理空数组,返回 undefined 会让调用方崩',
73
+ ];
74
+ for (const t of good) {
75
+ const r = guard(t);
76
+ assert.equal(r.ok, true, `具体 review 被误拦: ${t} → ${r.line}`);
77
+ }
78
+ });
79
+
80
+ test('git:issue 客服腔要拦', () => {
81
+ const slop = [
82
+ '感谢反馈!这个问题我们已经记录,会在后续版本中修复。',
83
+ '感谢您的建议,我们会持续改进。',
84
+ '这个需求已经在排期中,感谢关注。',
85
+ ];
86
+ for (const t of slop) {
87
+ const r = guard(t);
88
+ assert.equal(r.ok, false, `issue 客服腔该拦: ${t}`);
89
+ }
90
+ });
91
+
92
+ test('git:issue 实话要放过', () => {
93
+ const good = [
94
+ '你说对了,我搞错了。加权方向反了,经历最好编。',
95
+ '这条我改不了,得先有分文体的语料。',
96
+ '复现了,8443 端口占用导致的。',
97
+ '这个数我核不出来,原始语料不在手上。',
98
+ ];
99
+ for (const t of good) {
100
+ const r = guard(t);
101
+ assert.equal(r.ok, true, `实话被误拦: ${t} → ${r.line}`);
102
+ }
103
+ });
104
+
105
+ test('git:长 PR 描述不当文档放过', () => {
106
+ // 超过 300 字的聊天内容可以跳过,但 PR 描述不该跳过
107
+ const longPr = '## 概述\n' +
108
+ '这个改动修了三个地方,每个都写清为什么。'.repeat(20) +
109
+ '\n\n## 改动\n' +
110
+ '- 第 42 行那个 await 少了一层\n' +
111
+ '- 正则加了锚定'.repeat(10);
112
+ const r = guard(longPr);
113
+ assert.ok(longPr.length > 300, '样本得够长');
114
+ assert.equal(r.ok, false, 'PR 模板不该因为长就放过');
115
+ assert.notEqual(r.skipped, 'too-long');
116
+ });
117
+
118
+ test('git:长 PR 描述照样判', () => {
119
+ // 长文不再一律跳过。PR 描述本来就长,该判就得判。
120
+ const longPr = '## 概述\n' + '本 PR 优化了代码结构,提升了可维护性。'.repeat(20) +
121
+ '\n\n## 改动\n- 调整了章节结构\n- 新增了规则条款';
122
+ assert.ok(longPr.length > 300);
123
+ const r = guard(longPr);
124
+ assert.equal(r.ok, false, '长 PR 模板该拦');
125
+ assert.equal(r.skipped, undefined, '不该走 too-long');
126
+ });
@@ -46,13 +46,24 @@ test('空输入直接放过', () => {
46
46
  assert.equal(guard(' ').ok, true);
47
47
  });
48
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');
49
+ test('长文不跳过,看内容判断', () => {
50
+ // 300 字以上曾经一律放过,这是个漏洞:长邮件、长周报一样八股。
51
+ // 现在长文照样过规则,只是同一信号要出现两次以上才算。
52
+ const longReal = ('昨晚十一点半我第三次跑那个脚本,又卡在 8443 端口上了。日志里就一行 EADDRINUSE。' +
53
+ '后来把之前那个进程 kill 掉就好了,大概是我自己忘了关。').repeat(6);
54
+ assert.ok(longReal.length > 300, '样本得够长,实际 ' + longReal.length);
55
+ const r = guard(longReal);
56
+ assert.equal(r.ok, true, '长真话该放过,实际 ' + r.line);
57
+ assert.equal(r.skipped, undefined, '不该再走 too-long 跳过路径');
58
+ });
59
+
60
+ test('长邮件要拦', () => {
61
+ const longEmail = ('您好,关于您反馈的问题,我们已进行核实,现回复如下:经查证,该问题属于系统正常现象,建议您稍后重试。' +
62
+ '同时,我们也会持续优化产品体验,为您提供更好的服务。如有其他问题,欢迎随时联系我们。' +
63
+ '感谢您的理解与支持,祝您生活愉快!').repeat(4);
64
+ assert.ok(longEmail.length > 300);
65
+ const r = guard(longEmail);
66
+ assert.equal(r.ok, false, '长邮件该拦,实际放过了');
56
67
  });
57
68
 
58
69
  test('严格模式多拦两条', () => {
@@ -0,0 +1,91 @@
1
+ import { test } from 'node:test';
2
+ import assert from 'node:assert/strict';
3
+ import { guard, REASONS_FOR_TEST } from '../lib/guard.js';
4
+
5
+ /**
6
+ * 贴吧真人语料回归。样本从孙笑川吧 / v吧原文抄的。
7
+ *
8
+ * 这批句子的价值在于:它们充满了「八股规则看来可疑」的形状 ——
9
+ * 反问、三段并列、复述、骂人、单字 —— 但都是真人在说真话。
10
+ * 如果哪条被拦了,说明规则又放得太宽。
11
+ */
12
+
13
+ const TIEBA = [
14
+ '?', '3', '???', '诶嘿', '哎嘿', '就这?', '啊这', '难绷',
15
+ '还有盾斧的事', '超解确实帅', '什么宿舍还是5人寝',
16
+ '为了方便鼠鼠就称呼它为超姐',
17
+ '超姐这个外号就是来源于玩怪物猎人的那个人',
18
+ '鼠鼠是大一新生,宿舍是六人寝,但运气比较好只分到了五个人',
19
+ '经典傅首尔面相,凭一己之力孤立全宿舍人',
20
+ '尸体镇楼', '室友在宿舍卡泡怎么办', '像这样的室友我们宿舍有两个',
21
+ '这个世界是不是癫了?', '你们如果知道我长这样,还会骂我吗?',
22
+ '本来我只是纯良v87的', '这下直接被感动了',
23
+ '他们刷生日快乐给我刷了五分钟的屏',
24
+ '她半天没说话,我又说了句学生时代没钱是正常的先顾好自己吃饱穿暖',
25
+ '我看不下去就说了句666还让人家用生活费上舰',
26
+ '刚才发了个30sc 说主播我今天生日可以祝我生日快乐吗',
27
+ '一开始的一两千还算比较中肯的数据,到2000多,甚至到了大几千',
28
+ '鉴于有些谣言已经越传越离谱,本人澄清一下,顺便赛博留档',
29
+ '一句轻飘飘的道歉就能抹去蒙德到须弥做的孽吗?',
30
+ '这个龙不是博士搞出来的吗?', '编剧你回答的了吗?',
31
+ '拉倒吧,纯粹编剧为了洗至冬给的理由',
32
+ '原神可以有很多,活下来的原神只能一国一个',
33
+ '老玛:我的这双眼睛究竟看到了多远,看穿了第四面墙',
34
+ '那维莱特:新鞋,别搞', '水龙:别,我不想,你个战斗狂',
35
+ '希诺宁,他鼠标转冒烟了,快给他修一下。',
36
+ '他俩一个是自转,一个是公转,就这点区别',
37
+ '脑子里出现了水龙在中心自转,火神在外圈绕圈的画面',
38
+ '编剧已经没闹子考虑那么多了',
39
+ '现在这剧情看看就得了,没必要深究',
40
+ '卖卡卖完了随便写了',
41
+ '你放屁,分明是天理提供的',
42
+ '是啊,所以就静悄悄的也忘了,底民的死跟我伟大的神明有什么关系',
43
+ ];
44
+
45
+ test('贴吧真人语料零误拦', () => {
46
+ const fails = [];
47
+ for (const t of TIEBA) {
48
+ const r = guard(t);
49
+ if (!r.ok) fails.push({ t, line: r.line });
50
+ }
51
+ assert.deepEqual(fails, [], '误拦了 ' + fails.length + ' 条:\n' +
52
+ fails.map((f) => `「${f.t}」→ ${f.line}`).join('\n'));
53
+ });
54
+
55
+ test('专名对举放过,抽象对举拦住', () => {
56
+ // 「不是天理,是阿斯莫代」两边都是专名 → 对事实的纠正
57
+ assert.equal(guard('一开头拦下双子的人就不是天理,是阿斯莫代').ok, true);
58
+ assert.equal(guard('不是因为崩坏,是被策划削了').ok, true);
59
+
60
+ // 「不是技术问题,而是认知问题」两边都是抽象概念 → 自造对立
61
+ assert.equal(guard('这不是技术问题,而是认知问题。').ok, false);
62
+ assert.equal(guard('问题不在于工具本身,而在于使用工具的人。').ok, false);
63
+ assert.equal(guard('与其说是技术突破,不如说是思维方式的转变。').ok, false);
64
+ });
65
+
66
+ test('规则不能静默失效:直接调每条 test,不要靠 try/catch 兜着', () => {
67
+ // 曾经踩过的坑:x 在 if 块里 const 声明,块外又引用,
68
+ // 抛 ReferenceError 之后被 guard 的 try/catch 吞成「没命中」——
69
+ // 规则整个失效,但 doestNotThrow 永远测不出来。
70
+ // 所以这里绕过 guard,直接拿每条规则的 test 函数跑一遍。
71
+ const cases = [
72
+ '这不是技术问题,而是认知问题。',
73
+ '一开头拦下双子的人就不是天理,是阿斯莫代',
74
+ '不是',
75
+ '不是A而是B',
76
+ '',
77
+ '?',
78
+ '这条我认!首先态度要正,其次内容要实',
79
+ 'feat: 优化了用户模块的代码结构',
80
+ '// 初始化计数器\nlet total = 0;',
81
+ ];
82
+ for (const reason of REASONS_FOR_TEST) {
83
+ for (const t of cases) {
84
+ let hit;
85
+ assert.doesNotThrow(() => {
86
+ hit = reason.test({ hits: { structures: [], aiWords: [], summary: [], fakeSignificance: [] }, synonyms: [], scores: {}, band: 'low' }, t, { repeatBar: 1 });
87
+ }, `规则 ${reason.id} 在「${t}」上抛异常`);
88
+ assert.equal(typeof hit, 'boolean', `规则 ${reason.id} 在「${t}」上返回了 ${typeof hit},不是布尔`);
89
+ }
90
+ }
91
+ });