dsh-git-push 2.18.1 → 2.20.11

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.
Files changed (46) hide show
  1. package/.gitignore +4 -0
  2. package/README.md +4 -1
  3. package/cli.mjs +16 -3
  4. package/lib/ARCHITECTURE.md +3 -0
  5. package/lib/app/audit-api.js +1 -1
  6. package/lib/app/command-registry.js +14 -2
  7. package/lib/app/inject-text.js +1 -0
  8. package/lib/app/scope-check.js +69 -0
  9. package/lib/app/tool-call.js +49 -2
  10. package/lib/ast/credential.js +130 -14
  11. package/lib/ast/dataflow.js +127 -10
  12. package/lib/ast/index.js +2 -0
  13. package/lib/ast/naming.js +9 -1
  14. package/lib/ast/scope-collisions.js +228 -0
  15. package/lib/ast/treesitter.js +142 -1
  16. package/lib/audit/history.js +1 -1
  17. package/lib/audit/orchestrate.js +93 -6
  18. package/lib/audit/scope-policy.js +110 -0
  19. package/lib/audit-rules/audit-rules-comment.yml +20 -0
  20. package/lib/audit-rules/audit-rules-dsh.yml +16 -1
  21. package/lib/audit-rules/audit-rules-nodejs.yml +21 -6
  22. package/lib/checks/common.js +4 -4
  23. package/lib/checks/dispatch.js +5 -0
  24. package/lib/checks/index.js +2 -0
  25. package/lib/checks/regex.js +2 -2
  26. package/lib/checks/scope-collision.js +68 -0
  27. package/lib/cli/commands-audit.mjs +1 -1
  28. package/lib/commit-push.js +6 -1
  29. package/lib/exempt/index.js +5 -2
  30. package/lib/git/ignore.js +6 -4
  31. package/lib/git/init-compat.js +83 -4
  32. package/lib/git/push.js +25 -2
  33. package/lib/git/sensitive.js +30 -1
  34. package/lib/lint-adapter/detect.js +161 -0
  35. package/lib/lint-adapter/index.js +50 -0
  36. package/lib/lint-adapter/runner.js +133 -0
  37. package/lib/npm/publish.js +61 -11
  38. package/lib/rule/compilers/structure.js +27 -0
  39. package/lib/score/index.js +36 -4
  40. package/lib/self/index.js +1 -1
  41. package/package.json +20 -1
  42. package/scripts/audit-ext/dsh-inject-declarations.mjs +209 -0
  43. package/scripts/bump-version.mjs +20 -5
  44. package/scripts/check-js-scope.mjs +87 -0
  45. package/scripts/check.mjs +39 -1
  46. package/skills/dev/dsh-git-push.md +8 -2
@@ -27,8 +27,16 @@
27
27
  import { tokenize } from './tokenizer.js';
28
28
  import { matchBrace } from './brace.js';
29
29
 
30
- /** 清空动作:方法调用(对象.clear() / .reset() / .flush() / .purge())。 */
31
- const CLEAR_METHODS = new Set(['clear', 'reset', 'empty', 'flush', 'purge']);
30
+ /** 清空动作:方法调用(对象.clear() / .reset() / .flush() / .purge())。
31
+ * **刻意不含 empty**:empty() 在各语言都是**查询**(Python Queue.empty() / C++ vector.empty()
32
+ * 返回 bool,JS 库的 isEmpty 同义),把它当清空会制造系统性误报——
33
+ * 实测真实语料:`while not q.empty():` 之后的 `q.get()` 被误报成"清空后访问"。
34
+ * **刻意不含 reset**(2026-11-06 实测追加):业务代码里 reset() 绝大多数是
35
+ * 「**恢复默认值/重置状态**」而不是「清空容器」——被重置后对象**仍有内容**,之后读取完全安全。
36
+ * 实测证据:某配置类 `reset() -> bool`,测试断言 `cfg.reset()` 后 `cfg.get("general.theme") == "dark"`
37
+ * (有效值,不是空);同语料 13 条命中里 **12 条**都源于把 reset() 当清空。
38
+ * 真正的容器清空在各语言里用 clear()(本表保留)。若某库确把 reset() 用作清空,宁可漏报。 */
39
+ const CLEAR_METHODS = new Set(['clear', 'flush', 'purge']);
32
40
  /** 访问动作:方法读——清空后调用会拿 undefined(.get() / .at(0) / .first() / .peek())。
33
41
  * shift/pop 是「消费式访问」,常见于 `while (len) { shift() }` 保护模式,不报(宁漏不误报)。 */
34
42
  const ACCESS_METHODS = new Set(['get', 'at', 'first', 'last', 'peek', 'head']);
@@ -90,6 +98,70 @@ function collectArrowMethodBodies(tokens) {
90
98
  return fnRanges;
91
99
  }
92
100
 
101
+ /**
102
+ * 段③·前:Python 缩进式函数体区间(`def f():` / `async def f():`)。
103
+ *
104
+ * 为什么必须单独一段:前面两段都只认 **JS 风格**——`function` 关键字与 `) {`。
105
+ * Python 用 `def` + 缩进,两者都不命中,于是 `fnRanges` 为空,
106
+ * `mergeFnRanges` 的第 3 步退化成「整个文件一个区间」⇒ 同文件内**任意位置**的
107
+ * 清空与访问都会被配成一对(实测:clear 在 invalidate()、访问在 build_index(),
108
+ * 相距 177 行仍被报)。这是结构性失真,不能靠调判据修补。
109
+ *
110
+ * 块范围判据(与 Python 语法一致):从 `def` 行起,向下直到首个
111
+ * **非空、非注释且缩进 ≤ def 缩进** 的行(该行已属同级/外层,不属于本函数体)。
112
+ * 嵌套 def 会被各自识别并**独立成体**(不做父子合并,数据流不跨函数体)。
113
+ * @param {string} text 源文本
114
+ * @param {Array} tokens token 流(用于把行号换算成 token 下标,并确认 `def` 是真标识符)
115
+ * @returns {Array<[number, number]>} token 下标闭区间
116
+ */
117
+ function collectPythonDefBodies(text, tokens) {
118
+ const src = String(text || '');
119
+ if (!/^[ \t]*(async[ \t]+)?def[ \t]+\w+[ \t]*\(/m.test(src)) return [];
120
+ const lines = src.split('\n');
121
+ // tab 按 4 空格折算(与常见 Python 风格一致;混用缩进本身是语法错误,不深究)
122
+ const indentOf = (s) => {
123
+ const m = s.match(/^[ \t]*/);
124
+ return m ? m[0].replace(/\t/g, ' ').length : 0;
125
+ };
126
+ const isBlankOrComment = (s) => !s.trim() || /^\s*#/.test(s);
127
+ // 行号(1-based) → 该行首个/末个有效 token 下标
128
+ const firstTokOfLine = new Map();
129
+ const lastTokOfLine = new Map();
130
+ for (let i = 0; i < tokens.length; i++) {
131
+ const tk = tokens[i];
132
+ if (tk.type === 'ws' || tk.type === 'comment') continue;
133
+ const ln = Number(tk.line) || 0;
134
+ if (!ln) continue;
135
+ if (!firstTokOfLine.has(ln)) firstTokOfLine.set(ln, i);
136
+ lastTokOfLine.set(ln, i);
137
+ }
138
+ const ranges = [];
139
+ for (let li = 0; li < lines.length; li++) {
140
+ const m = lines[li].match(/^([ \t]*)(?:async[ \t]+)?def[ \t]+\w+[ \t]*\(/);
141
+ if (!m) continue;
142
+ const lineNo = li + 1;
143
+ // 必须确认该行的 def 是**真 token**(避免三引号字符串/注释里的 "def ")
144
+ const firstIdx = firstTokOfLine.get(lineNo);
145
+ const firstTok = firstIdx === undefined ? null : tokens[firstIdx];
146
+ const looksLikeDef = firstTok && (firstTok.value === 'def' || firstTok.value === 'async');
147
+ const lineHasDefTok = looksLikeDef || [...(firstTokOfLine.keys())].length === 0;
148
+ if (!lineHasDefTok) continue;
149
+ const base = indentOf(lines[li]);
150
+ let endLine = lineNo;
151
+ for (let lj = li + 1; lj < lines.length; lj++) {
152
+ const cur = lines[lj];
153
+ if (isBlankOrComment(cur)) continue; // 空行/注释不结束块
154
+ if (indentOf(cur) <= base) break; // 回到同级/外层 ⇒ 块结束
155
+ endLine = lj + 1;
156
+ }
157
+ const startTok = firstTokOfLine.get(lineNo);
158
+ const endTok = lastTokOfLine.get(endLine);
159
+ if (startTok === undefined || endTok === undefined || endTok < startTok) continue;
160
+ ranges.push([startTok, endTok]);
161
+ }
162
+ return ranges;
163
+ }
164
+
93
165
  /** 段③:排序去重叠(嵌套只留最外层)+ 补顶层作用域孤岛(函数外 token 段)。 */
94
166
  function mergeFnRanges(fnRanges, tokens) {
95
167
  fnRanges.sort((a, b) => a[0] - b[0]);
@@ -114,9 +186,17 @@ function mergeFnRanges(fnRanges, tokens) {
114
186
  return bodies;
115
187
  }
116
188
 
117
- /** 收集全部函数体区间(声明/表达式/箭头/方法 + 顶层孤岛)。 */
118
- function collectFnBodies(tokens) {
119
- const fnRanges = [...collectDeclaredFnBodies(tokens), ...collectArrowMethodBodies(tokens)];
189
+ /**
190
+ * 收集全部函数体区间(声明/表达式/箭头/方法 + Python def 缩进体 + 顶层孤岛)。
191
+ * @param {Array} tokens token 流
192
+ * @param {string} [text] 源文本(Python 缩进体解析必需;缺省则退化为仅花括号语言)
193
+ */
194
+ function collectFnBodies(tokens, text = '') {
195
+ const fnRanges = [
196
+ ...collectDeclaredFnBodies(tokens),
197
+ ...collectArrowMethodBodies(tokens),
198
+ ...collectPythonDefBodies(text, tokens),
199
+ ];
120
200
  return mergeFnRanges(fnRanges, tokens);
121
201
  }
122
202
 
@@ -166,7 +246,19 @@ function applyAssignClearOrWriteback(tokens, i, to, t, nxt, obj, clearMap) {
166
246
  // 声明初始化(var/let/const 变量 = [] / = null)不算清空
167
247
  const prev = prevNonWs(tokens, i);
168
248
  const decl = prev && prev.type === 'ident' && (prev.value === 'var' || prev.value === 'let' || prev.value === 'const');
169
- if (!decl) {
249
+ // ① 注解位:`self._x: list = []` 里被赋空值的是 **_x**,但扫描到 `list` 时它也满足
250
+ // 「ident 紧跟 =」——`list` 前面是 `:`(PEP 526 注解分隔符)⇒ 它在注解位,不是赋值目标。
251
+ // ⚠️ `:` 前面必须是**标识符**:Python 函数定义的 `def f(c):` 也用冒号,但其前是 `)`,
252
+ // 若不加这条就会把函数体第一条语句的赋值误当注解位 —— 实测会压制真缺陷
253
+ // (`def f(c): c = []` 后 `c[0]` 本该报却不报)。
254
+ const colonPrev = prev && prev.type === 'punct' && prev.value === ':'
255
+ ? prevNonWs(tokens, prevNonWs(tokens, i) === prev ? i - 1 : i - 1)
256
+ : null;
257
+ const annPos = !!colonPrev && colonPrev.type === 'ident';
258
+ // ② 多目标解包:`result, last = [], {}` 中 last 后面紧跟 `=`,但 `[]` 属于 **result**。
259
+ // 判据:obj 之前(同语句内)出现过 `,` 而尚未出现 `=` ⇒ 它是解包目标之一,rhs 不归它。
260
+ const unpackTarget = prev && prev.type === 'punct' && prev.value === ',';
261
+ if (!decl && !annPos && !unpackTarget) {
170
262
  clearMap.set(obj, { line: t.line, op: `= ${rhs.value === '[' ? '[]' : rhs.value}` });
171
263
  }
172
264
  return true;
@@ -200,7 +292,7 @@ function applyClearMethods(t, member, memberIdx, callOpen, tokens, obj, clearMap
200
292
  * 清空后访问:.get()/.at() 或 [下标]。命中则记一条并撤销该对象标记(同对象只报一次)。
201
293
  * @returns {number} 新的循环下标 i
202
294
  */
203
- function applyAccessAfterClear(t, nxt, member, memberIdx, callOpen, tokens, i, obj, clearMap, out) {
295
+ function applyAccessAfterClear(t, nxt, member, memberIdx, callOpen, tokens, i, obj, clearMap, out, to) {
204
296
  if (!clearMap.has(obj)) return i;
205
297
  const cleared = clearMap.get(obj);
206
298
  if (callOpen && ACCESS_METHODS.has(member)) {
@@ -210,14 +302,39 @@ function applyAccessAfterClear(t, nxt, member, memberIdx, callOpen, tokens, i, o
210
302
  }
211
303
  if (nxt?.type === 'punct' && nxt.value === '[') {
212
304
  const idx = tokens[i + 2];
213
- if (idx && (idx.type === 'num' || idx.type === 'ident')) {
305
+ // 写目标不是读:`obj[k] = v` / `obj[k] += v` 的 `[k]` 是**写入下标**,
306
+ // 读一个刚清空的容器才危险,往刚清空的容器里写恰恰是"重新填充"(安全)。
307
+ // 判据:配对 `]` 之后的下一个实义 token 若是 `=`/复合赋值,按写回处理(撤销清空),不报。
308
+ if (idx && (idx.type === 'num' || idx.type === 'ident') && !isWriteSubscript(tokens, i, to)) {
214
309
  out.push({ line: t.line, obj, clearLine: cleared.line, clearOp: cleared.op, accessOp: `[${idx.value}]` });
215
310
  clearMap.delete(obj);
311
+ } else if (idx && isWriteSubscript(tokens, i, to)) {
312
+ clearMap.delete(obj); // 写入 = 重新填充,撤销清空标记(与 push/set 同口径)
216
313
  }
217
314
  }
218
315
  return i;
219
316
  }
220
317
 
318
+ /** `obj[...]` 是否是**写入**目标(配对 `]` 后紧跟 `=` / 复合赋值)。 */
319
+ function isWriteSubscript(tokens, objIdx, to) {
320
+ // 方括号配对自己走(brace.js 的 matchBrace 只处理 {},且返回数组)
321
+ let depth = 0;
322
+ let close = -1;
323
+ for (let k = objIdx + 1; k <= to && k < tokens.length; k++) {
324
+ const tk = tokens[k];
325
+ if (tk.type !== 'punct') continue;
326
+ if (tk.value === '[') depth++;
327
+ else if (tk.value === ']') {
328
+ depth--;
329
+ if (depth === 0) { close = k; break; }
330
+ }
331
+ }
332
+ if (close < 0) return false;
333
+ const after = nextNonWs(tokens, close + 1, to);
334
+ if (!after || after.type !== 'punct') return false;
335
+ return ['=', '+=', '-=', '*=', '/='].includes(after.value);
336
+ }
337
+
221
338
  /**
222
339
  * 在单个函数体区间内判定「清空后访问」。
223
340
  *
@@ -246,7 +363,7 @@ function scanClearThenAccess(tokens, from, to) {
246
363
  if (applyAssignClearOrWriteback(tokens, i, to, t, nxt, identName, clearMap)) continue;
247
364
  const afterClear = applyClearMethods(t, member, memberIdx, callOpen, tokens, identName, clearMap, i);
248
365
  if (afterClear !== i) { i = afterClear; continue; }
249
- i = applyAccessAfterClear(t, nxt, member, memberIdx, callOpen, tokens, i, identName, clearMap, out);
366
+ i = applyAccessAfterClear(t, nxt, member, memberIdx, callOpen, tokens, i, identName, clearMap, out, to);
250
367
  }
251
368
  return out;
252
369
  }
@@ -259,7 +376,7 @@ function scanClearThenAccess(tokens, from, to) {
259
376
  */
260
377
  export function checkClearAccessAst(text = '') {
261
378
  const tokens = tokenize(text);
262
- const bodies = collectFnBodies(tokens);
379
+ const bodies = collectFnBodies(tokens, String(text || ''));
263
380
  const seen = new Set(); // 去重(同一行同对象只报一次)
264
381
  const out = [];
265
382
  for (const [from, to] of bodies) {
package/lib/ast/index.js CHANGED
@@ -32,5 +32,7 @@ export {
32
32
  } from './credential.js';
33
33
  // 三层审计 L2——数据流检查(同函数清空后访问)
34
34
  export { checkClearAccessAst } from './dataflow.js';
35
+ // 拼接产物作用域撞名(分片拼成同一作用域时 var/function 静默覆盖)
36
+ export { analyzeScopeCollisions } from './scope-collisions.js';
35
37
  // I/O 风险分级(四级;scanIoRiskAst 供 checks 层精筛与 scan-file-io 复用)
36
38
  export { scanIoRiskAst, summarizeIoRisk, rankIoFixList, RISK_BADGE, RISK_LABEL } from './io-risk.js';
package/lib/ast/naming.js CHANGED
@@ -5,6 +5,7 @@
5
5
  */
6
6
 
7
7
  import { tokenize } from './tokenizer.js';
8
+ import { shortFunctionNamesFromTree } from './treesitter.js';
8
9
 
9
10
  /** 声明/控制流关键字(Java「类型 短名」分支须排除的常见语言关键字前缀)——
10
11
  * prevT 是这些时不是「类型名」,`短名` 属各语言声明/流程语境而非 Java 变量声明。
@@ -202,13 +203,20 @@ export function checkNameLengthAst(text = '', { min = 2, allow = [] } = {}) {
202
203
  * @param {{max?: number, allow?: string[]}} [opts] max 默认 2;allow 追加白名单
203
204
  * @returns {Array<{line:number, name:string}>} 命中列表
204
205
  */
205
- export function checkShortFunctionNameAst(text = '', { max = 2, allow = [] } = {}) {
206
+ export function checkShortFunctionNameAst(text = '', { max = 2, allow = [], tree = null } = {}) {
206
207
  const tokens = tokenize(text);
207
208
  const out = [];
208
209
  // 长度 ≤2 但有公认语义的缩写(不报):i18n 的 tr/t、字典 L、常见工具名
209
210
  const ALLOW = new Set(['tr', 't', 'r', 'L', 'i18n', 'db', 'fs', 'os', 'el', 'cb', 'fn', 'ns',
210
211
  'id', 'ok', 'kv', 'ui', 'js', 'ts', 'is', 'to', 'of', 'in', 'no', 'op', 'up', 'un',
211
212
  'i', 'j', 'k', 'x', 'y', 'z', 'e', 'a', 'b', 'n', 'p', 's', 'v', 'f', ...allow]);
213
+ const isShortName = (name) => String(name).length <= max && !ALLOW.has(name);
214
+ // 「有树走树」:树版覆盖函数声明 + 类/对象方法(token 级查不到的那族),判定语汇仍是同一份
215
+ // isShortName(长度阈值 + 白名单只有一处定义)。树不可用则继续走下面的 token 路径(D5)。
216
+ if (tree && tree.rootNode) {
217
+ const fromTree = shortFunctionNamesFromTree(tree, isShortName);
218
+ if (fromTree) return fromTree;
219
+ }
212
220
  for (let i = 0; i < tokens.length; i++) {
213
221
  const t = tokens[i];
214
222
  if (!(t.type === 'ident' && t.value === 'function')) continue;
@@ -0,0 +1,228 @@
1
+ /**
2
+ * 拼接产物的**作用域撞名检查**(通用:任何「多段 JS 拼进同一作用域」的产物都适用)。
3
+ *
4
+ * 要防的是什么:把多段 JS 拼进同一个作用域时,`var`/`function` 会被提升到函数顶部,
5
+ * 同名声明**后者覆盖前者且完全不报错**——某一段依赖的函数被另一段的同名函数顶掉,
6
+ * 运行时行为错乱却查不到任何异常。`const`/`let`/`class` 虽不提升,但同一块内重复声明
7
+ * 同样会让先声明的那份失效(区别只是某些情形会抛 SyntaxError)。
8
+ *
9
+ * 典型落点(本插件是一个代表,不是特例):
10
+ * · 浏览器端插件把多个分片拼成一个 `factory` 函数体(本插件 14 个分片);
11
+ * · 用 `<script>` 直接引入多段脚本(共享全局作用域);
12
+ * · 任何 `cat a.js b.js > bundle.js` 的土制打包。
13
+ *
14
+ * 判定方式(关键:**按真实作用域帧**而不是按缩进/深度):
15
+ * 遍历 token 维护一个花括号帧栈,每个 `{` 是一个**唯一帧**;声明绑定到
16
+ * 「最近的外层作用域帧」——
17
+ * · `var` / `function` → 绑定到最近的**函数作用域帧**(函数体或顶层);
18
+ * · `const` / `let` / `class` → 绑定到**当前帧**(块级作用域);
19
+ * · `for (…)` 头部里的声明 → 绑定到该 for 语句的**专属帧**(每次迭代新绑定,
20
+ * 兄弟循环同名合法;不这样处理会把 `for (const r of a)` + `for (const r of b)`
21
+ * 误判成同帧重名——实测本项目 16 处误报全是这种写法)。
22
+ * 于是「两个不同函数里的同名局部变量」天然分属不同帧 → 不算撞名(不会误报),
23
+ * 而「同一函数体里两段各声明一次同名」会被抓住(这正是静默覆盖的触发条件)。
24
+ *
25
+ * 三条可选检查项(都能关,便于不同项目按自己的契约启用):
26
+ * ① 顶层声明:`topLevelMustBeEmpty`(拼接产物常要求「文件顶层零声明」以免与别家撞名);
27
+ * ② 命名前缀:`prefix`(如 `dshgp_`;留空则跳过),`allowlist` 放行宿主/契约名;
28
+ * ③ 同帧重名:始终启用(这是本检查存在的理由)。
29
+ */
30
+ import { tokenize } from './tokenizer.js';
31
+
32
+ /** 会产生声明的关键字(其后第一个 ident 即声明名)。 */
33
+ const DECL_KEYWORDS = new Set(['function', 'const', 'let', 'var', 'class']);
34
+ /** 这些关键字后面跟的 `(`…`)` 是**控制语句条件**,其 `{` 是块而不是函数体。 */
35
+ const CONTROL_KEYWORDS = new Set(['if', 'for', 'while', 'switch', 'catch', 'with']);
36
+
37
+ /**
38
+ * 扫描文本,找出「同一作用域内被声明多次」的名字,以及对顶层/前缀契约的违反。
39
+ *
40
+ * @param {string} text 待检查的 JS 文本
41
+ * @param {{prefix?:string, allowlist?:string[], topLevelMustBeEmpty?:boolean,
42
+ * topLevelAllowlist?:string[]}} [opts]
43
+ * prefix:要求标识符带的前缀(如 `dshgp_`);留空表示不检查前缀。
44
+ * allowlist:前缀例外(宿主注入或契约固定的名字)。
45
+ * topLevelMustBeEmpty:是否禁止文件顶层出现声明(默认 true)。
46
+ * @returns {{ok:boolean, declarations:Array, duplicates:Array, topLevel:Array,
47
+ * missingPrefix:Array, violations:string[]}}
48
+ */
49
+ export function analyzeScopeCollisions(text = '', {
50
+ prefix = '', allowlist = [], topLevelMustBeEmpty = true, topLevelAllowlist = [],
51
+ } = {}) {
52
+ const tokens = tokenize(String(text));
53
+ const allowed = new Set(allowlist);
54
+ const topAllowed = new Set(topLevelAllowlist);
55
+
56
+ // 帧栈:{ id, isFunction }。id=0 表示文件顶层(虚拟帧,永远在栈底)。
57
+ const frames = [{ id: 0, isFunction: true }];
58
+ let nextFrameId = 1;
59
+ /** 上一个「有效」token 的形态标记,用于判断 `{` 是否为函数体。 */
60
+ let prevSignificant = '';
61
+ /**
62
+ * for 头部作用域:`for (const r of …)` 的绑定属于该 for 语句自己的作用域,
63
+ * 每次迭代都是新绑定 ⇒ 兄弟循环里同名合法。把这类声明绑到**专属虚拟帧**
64
+ * (负 id,与花括号帧号不冲突),否则两个兄弟 for 循环的 `const r`/`let i`
65
+ * 会被误判成同帧重名(本项目自审计实测 16 处误报,全是这种写法)。
66
+ * 覆盖 `for await (…)`:token 流是 for → await → (。
67
+ */
68
+ const parenStack = []; // { inFor, id } —— 当前打开的括号(只关心是否 for 头部)
69
+ let nextForFrameId = -1;
70
+ let forPending = false; // 刚读到 for(其后可能跟 await),下一个 ( 即 for 头部
71
+
72
+ const declarations = [];
73
+ const duplicates = [];
74
+ /** `${frameId}|${name}` → { count, firstLine }(firstLine 用于「哪两行撞了」的可定位文案)。 */
75
+ const seen = new Map();
76
+ /**
77
+ * 共享作用域帧=**最外层的函数体**(拼接后各段共同落入的那一个)。
78
+ * 前缀检查只针对它:函数内部的局部变量各属自己的帧、彼此不可能撞名,
79
+ * 要求它们也带前缀属过度约束(实测把 244 个局部变量误判成「缺前缀」)。
80
+ * 用「第一个函数帧」而非固定深度 ⇒ 包装形态变了也不用改判定。
81
+ */
82
+ let sharedFrameId = -1;
83
+
84
+ /** 找最近的外层函数作用域帧(var/function 绑定到它)。 */
85
+ const nearestFunctionFrame = () => {
86
+ for (let i = frames.length - 1; i >= 0; i -= 1) if (frames[i].isFunction) return frames[i].id;
87
+ return 0;
88
+ };
89
+
90
+ for (let i = 0; i < tokens.length; i += 1) {
91
+ const token = tokens[i];
92
+ const value = String(token.value);
93
+
94
+ // ── `for` 头部识别:for [await] ( → 该括号里的声明归 for 自己的作用域 ──
95
+ if (value === 'for') {
96
+ forPending = true;
97
+ prevSignificant = value;
98
+ continue;
99
+ }
100
+ if (value === 'await' && forPending) {
101
+ prevSignificant = value;
102
+ continue; // 保持 pending:`for await (…)`
103
+ }
104
+ if (value === '(') {
105
+ parenStack.push(forPending ? { inFor: true, id: nextForFrameId-- } : { inFor: false, id: 0 });
106
+ forPending = false;
107
+ prevSignificant = value;
108
+ continue;
109
+ }
110
+ if (value === ')') {
111
+ parenStack.pop();
112
+ forPending = false;
113
+ prevSignificant = value;
114
+ continue;
115
+ }
116
+ forPending = false;
117
+
118
+ if (value === '{') {
119
+ // 判断这个 `{` 是不是函数体:紧跟在 `=>` 后,或紧跟在函数参数表 `)` 后,
120
+ // 且该 `)` 不是 if/for/while/switch/catch 的控制条件。
121
+ let isFunction = false;
122
+ if (prevSignificant === '=>') isFunction = true;
123
+ else if (prevSignificant === ')') {
124
+ // 往回找与这个 `)` 配对的 `(`,看它前面是不是控制关键字
125
+ let depthParen = 0;
126
+ let openIdx = -1;
127
+ for (let k = i - 1; k >= 0; k -= 1) {
128
+ const v = String(tokens[k].value);
129
+ if (v === ')') depthParen += 1;
130
+ else if (v === '(') {
131
+ depthParen -= 1;
132
+ if (depthParen === 0) { openIdx = k; break; }
133
+ }
134
+ }
135
+ const beforeParen = openIdx > 0 ? String(tokens[openIdx - 1].value) : '';
136
+ isFunction = !CONTROL_KEYWORDS.has(beforeParen);
137
+ }
138
+ frames.push({ id: nextFrameId, isFunction });
139
+ if (isFunction && sharedFrameId < 0) sharedFrameId = nextFrameId;
140
+ nextFrameId += 1;
141
+ prevSignificant = '{';
142
+ continue;
143
+ }
144
+ if (value === '}') {
145
+ if (frames.length > 1) frames.pop();
146
+ prevSignificant = '}';
147
+ continue;
148
+ }
149
+
150
+ if (DECL_KEYWORDS.has(value)) {
151
+ // 跳过修饰符后取声明名
152
+ let j = i + 1;
153
+ while (j < tokens.length && ['*', 'async', 'export', 'default'].includes(String(tokens[j].value))) j += 1;
154
+ const nameToken = tokens[j];
155
+ if (nameToken && nameToken.type === 'ident') {
156
+ const name = String(nameToken.value);
157
+ const blockScoped = value === 'const' || value === 'let' || value === 'class';
158
+ const inForHeader = Boolean(parenStack.length && parenStack[parenStack.length - 1].inFor);
159
+ // for 头部里的声明(含 var)绑到该 for 的专属帧:兄弟循环同名合法,不算撞名
160
+ const frameId = inForHeader
161
+ ? parenStack[parenStack.length - 1].id
162
+ : (blockScoped ? frames[frames.length - 1].id : nearestFunctionFrame());
163
+ // frameDepth 只对花括号帧有意义;for 头部(虚拟帧)记为 -1,既不会误入「顶层声明」,
164
+ // 也不会参与共享作用域(sharedFrameId ≥1)的前缀判定。
165
+ const frameDepth = inForHeader ? -1 : frames.length - 1;
166
+ declarations.push({ name, keyword: value, line: token.line, frameId, frameDepth });
167
+ const key = `${frameId}|${name}`;
168
+ const prev = seen.get(key);
169
+ const count = (prev?.count || 0) + 1;
170
+ const keywords = prev ? [...prev.keywords, value] : [value];
171
+ seen.set(key, { count, firstLine: prev ? prev.firstLine : token.line, keywords });
172
+ // 只报一次:第 3 次及以后的同名声明不再重复入列(同一个名字一条命中,避免刷屏)
173
+ if (count === 2) {
174
+ duplicates.push({
175
+ name,
176
+ frameId,
177
+ scope: blockScoped ? 'block' : 'function',
178
+ line: token.line, // 后来者(静默覆盖的那份)
179
+ firstLine: prev.firstLine, // 先声明的那份
180
+ keywords, // 两次声明用的关键字(决定这条命中算不算真缺陷,见检查器)
181
+ });
182
+ }
183
+ }
184
+ prevSignificant = value;
185
+ continue;
186
+ }
187
+
188
+ prevSignificant = value;
189
+ }
190
+
191
+ const topLevel = declarations.filter((d) => d.frameDepth === 0);
192
+ // 前缀只约束**共享作用域帧**(最外层函数体):各函数内部的局部变量分属自己的帧、
193
+ // 彼此不可能撞名,要求它们也带前缀属过度约束(实测会把片段里的局部变量全判成缺前缀)。
194
+ const missingPrefix = !prefix ? [] : declarations.filter(
195
+ (d) => d.frameId === sharedFrameId && !d.name.startsWith(prefix) && !allowed.has(d.name),
196
+ );
197
+
198
+ // 三类命中都带上 message:violations 直接由它们汇总而成 —— **单一措辞源**。
199
+ // 审计检查器(lib/checks/scope-collision.js)出 finding 时直接用 item.message,
200
+ // 不再各自重写一遍文案(两处措辞必然漂移)。
201
+ const topLevelHits = !topLevelMustBeEmpty ? [] : topLevel
202
+ .filter((d) => !topAllowed.has(d.name))
203
+ .map((d) => ({
204
+ ...d,
205
+ message: `顶层声明 ${d.name}(第 ${d.line} 行):拼接产物应保持文件顶层零声明,避免与其它脚本/插件撞名`,
206
+ }));
207
+ const prefixHits = !prefix ? [] : missingPrefix.map((d) => ({
208
+ ...d,
209
+ message: `声明 ${d.name}(第 ${d.line} 行)缺少 ${prefix} 前缀:拼接分片共用同一作用域,裸名易被别段覆盖`,
210
+ }));
211
+ const duplicateHits = duplicates.map((d) => ({
212
+ ...d,
213
+ message: `「${d.scope === 'function' ? '同一函数作用域' : '同一代码块'}」内 ${d.name} 被声明 2 次以上`
214
+ + `(第 ${d.firstLine} 行与第 ${d.line} 行):var/function 会静默覆盖,后者顶掉前者且不报错`,
215
+ }));
216
+
217
+ const violations = [...topLevelHits, ...prefixHits, ...duplicateHits].map((d) => d.message);
218
+
219
+ return {
220
+ ok: violations.length === 0,
221
+ declarations,
222
+ duplicates: duplicateHits,
223
+ topLevel: topLevelHits,
224
+ missingPrefix: prefixHits,
225
+ violations,
226
+ sharedFrameId,
227
+ };
228
+ }
@@ -248,7 +248,7 @@ export async function confirmHits({ text, ext = '', grammar = '', hits = [] } =
248
248
  */
249
249
  export function makeSyncConfirmer(tree) {
250
250
  if (!tree || !tree.rootNode) return null;
251
- return (line, col) => {
251
+ const fn = (line, col) => {
252
252
  try {
253
253
  const l = Number(line);
254
254
  if (!Number.isFinite(l) || l < 1) return null;
@@ -261,6 +261,147 @@ export function makeSyncConfirmer(tree) {
261
261
  return null;
262
262
  }
263
263
  };
264
+ // 附带原始语法树:供「有树走树」的语义精筛(如凭据 credentialLinesFromTree)直接消费——
265
+ // 列级 opaque 确认与树级语义确认走同一棵预解析树,不重复解析(性能纪律)。
266
+ fn.tree = tree;
267
+ return fn;
268
+ }
269
+
270
+ /**
271
+ * 用语法树提取「凭据标识符被直接赋字符串/字节字面量」的行(方向 E1「有树走树」)。
272
+ *
273
+ * 为什么用树而不是 token:token 级看不出「赋值」的语法结构——
274
+ * `def _icon(token="text.secondary")` 的参数默认值、`token="前缀:"+uuid` 的复合右值、
275
+ * `x="a" if c else "b"` 的三元分支,在 token 流里都是 `ident = str`,只能一律当硬编码
276
+ * (外部 Python 仓库实测:这一类全是误报)。语法树上它们分别是
277
+ * default_parameter / assignment_pattern(不是赋值语句)、binary_operator(右值非字面量)、
278
+ * conditional_expression(右值非字面量),一眼排除。
279
+ *
280
+ * 判定语汇(凭据名识别、值是否有意义)由调用方 credential.js 以谓词传入:
281
+ * 本模块不 import credential.js,避免反向依赖成环,也保证「什么算凭据」只有一份定义。
282
+ *
283
+ * @param {object} tree parseText 的返回值(无根节点/异常一律返回 null,调用方回退)
284
+ * @param {(name:string, raw:string)=>boolean} credHit 「名字+值」组合判据(credential.js
285
+ * 的 isHardcodedCredentialValue——强弱分级与值置信度只有一份定义)
286
+ * @returns {null|Set<number>} 命中行号集合;null = 树不可用,调用方必须回退 token 级
287
+ */
288
+ export function credentialLinesFromTree(tree, credHit) {
289
+ if (!tree || !tree.rootNode || typeof credHit !== 'function') return null;
290
+ const out = new Set();
291
+ // 属性/成员访问左值(cfg.apikey、this.token、obj["secret"])在各语言的节点名。
292
+ const ATTRIBUTE_LHS = /^(attribute|member_expression|subscript|subscript_expression)$/;
293
+ // 字符串/字节字面量节点的类型名(各语言命名差异:string / string_literal /
294
+ // interpreted_string_literal(bytes/f-string) / raw_string_literal / character_literal)。
295
+ // 刻意不含 string_concat——`"a" + "b"` 的拼接值不是「直接字面量」,属复合右值。
296
+ const LIT = /^(string|string_literal|interpreted_string_literal|raw_string_literal|character_literal)$/;
297
+ // 字面量节点是否为「纯字面量」:f-string/插值串(children 含 interpolation /
298
+ // template_substitution / interpolation_expression)里值来自变量,不算硬编码内容。
299
+ const isPlainLiteral = (node) => {
300
+ if (!node || !LIT.test(node.type)) return false;
301
+ for (const c of node.children || []) {
302
+ if (/interpolation|substitution|expansion/i.test(String(c.type || ''))) return false;
303
+ }
304
+ return true;
305
+ };
306
+ // 遍历:收集「左值是凭据名、右值是单个字面量」的直接赋值行。
307
+ const walk = (node) => {
308
+ try {
309
+ // ① 真赋值语句(Python assignment / JS·TS assignment_expression):left=identifier,right=字面量
310
+ // 参数默认值(default_parameter/assignment_pattern)不在此类,天然排除。
311
+ if (node.type === 'assignment' || node.type === 'assignment_expression') {
312
+ const lhs = node.childForFieldName('left');
313
+ const rhs = node.childForFieldName('right');
314
+ // 左值名:裸标识符直接取;属性赋值(cfg.apikey = "…" / this.token = "…")取末段——
315
+ // 回退路径(token 级,`.` 允许跨越)对这类同样会报,树路径必须同等覆盖,否则改树反而漏报。
316
+ const name = lhs
317
+ ? (lhs.type === 'identifier' || lhs.type === 'variable_declarator'
318
+ ? String(lhs.text)
319
+ : String(lhs.text).split(/[.\[\]]/).pop().replace(/^['"]|['"]$/g, ''))
320
+ : '';
321
+ const lhsOk = lhs && (lhs.type === 'identifier' || ATTRIBUTE_LHS.test(lhs.type));
322
+ if (lhsOk && isPlainLiteral(rhs) && credHit(name, rhs.text)) {
323
+ out.add(node.startPosition.row + 1);
324
+ }
325
+ }
326
+ // ② 变量声明初始化(const token = "…"):variable_declarator name=identifier value=字面量
327
+ else if (node.type === 'variable_declarator' || node.type === 'init_declarator') {
328
+ const nm = node.childForFieldName('name');
329
+ const val = node.childForFieldName('value');
330
+ if (nm && nm.type === 'identifier' && isPlainLiteral(val) && credHit(String(nm.text), val.text)) {
331
+ out.add(node.startPosition.row + 1);
332
+ }
333
+ }
334
+ // ③ 对象字段({ token: "…" } / { apiKey: "…" }):pair,键名命中凭据词 + 值是字面量。
335
+ // f-string/插值字符串的值节点是 string 类型但含 interpolation 子节点——见 ③ 下的插值判定。
336
+ else if (node.type === 'pair' || node.type === 'property_assignment' || node.type === 'object_element') {
337
+ const keyNode = node.childForFieldName('key') || node.namedChildren[0];
338
+ const valNode = node.childForFieldName('value') || node.namedChildren[1];
339
+ const keyText = keyNode ? String(keyNode.text).replace(/^['"]|['"]$/g, '') : '';
340
+ if (keyNode && isPlainLiteral(valNode) && credHit(keyText, valNode.text)) {
341
+ out.add(node.startPosition.row + 1);
342
+ }
343
+ }
344
+ for (const child of node.namedChildren) walk(child);
345
+ } catch {
346
+ // 单节点异常不打断整树:已收集的命中照常返回(部分成功优于全失败)。
347
+ }
348
+ };
349
+ try {
350
+ walk(tree.rootNode);
351
+ return out;
352
+ } catch {
353
+ return null;
354
+ }
355
+ }
356
+
357
+ /**
358
+ * 用语法树收集「函数/方法定义名过短」的命中(方向 E 迁移第二条,short-func-name 树化)。
359
+ *
360
+ * 为什么必须用树(实测漏报):token 级只认「function 关键字后的 ident」,
361
+ * 于是 `class A { gh() {} }`、`const o = { ef() {} }` 这类**方法定义**完全查不到——
362
+ * 它们同样是「名字猜不出含义」的缺陷,却静默放行。
363
+ * 想在 token 级补齐只能靠「标识符 + ( 」近似,那会把 `ab(1)` 调用、`{ ef: ... }` 属性
364
+ * 全卷进来(误报换漏报,不划算)。语法树上它们是独立节点:
365
+ * function_declaration / generator_function_declaration / function_expression /
366
+ * method_definition / method_signature,且都带 name 字段;
367
+ * arrow_function、if_statement 无 name 字段 ⇒ 天然不误伤。
368
+ *
369
+ * @param {object} tree parseText 返回值
370
+ * @param {(name:string)=>boolean} isShort 名字判定(长度阈值 + 公认缩写白名单,由 naming.js 传入——判据只有一份)
371
+ * @returns {null|Array<{line:number, name:string}>} null = 树不可用,调用方回退 token 级
372
+ */
373
+ export function shortFunctionNamesFromTree(tree, isShort) {
374
+ if (!tree || !tree.rootNode || typeof isShort !== 'function') return null;
375
+ const DECL = new Set([
376
+ 'function_declaration', 'generator_function_declaration', 'function_expression',
377
+ 'method_definition', 'method_signature',
378
+ ]);
379
+ const out = [];
380
+ const walk = (node) => {
381
+ try {
382
+ if (DECL.has(node.type)) {
383
+ // 访问器(get ab() / set cd(v))跳过:它的 name 是**属性名**而非「做某事的函数名」,
384
+ // 且 get x / set x 配对是极常见惯例(框架存取器、计算属性)——按「函数名过短」报属语义错位。
385
+ // 刻意显式排除而非依赖初筛侥幸挡住:初筛放宽后这里不能变成误报源。
386
+ // 实测节点形态:method_definition 的 children[0].type 为 get/set(普通方法是 property_identifier)。
387
+ const lead = node.children && node.children[0];
388
+ const isAccessor = lead && /^(get|set)$/.test(String(lead.type));
389
+ const nm = node.childForFieldName('name');
390
+ // 仅裸标识符/属性名才算「定义名」;computed([x](){})等形态跳过,避免取到表达式文本
391
+ if (!isAccessor && nm && /^(identifier|property_identifier|private_property_identifier)$/.test(String(nm.type))) {
392
+ const name = String(nm.text);
393
+ if (isShort(name)) out.push({ line: nm.startPosition.row + 1, name });
394
+ }
395
+ }
396
+ for (const c of node.namedChildren) walk(c);
397
+ } catch { /* 单节点异常不打断整树 */ }
398
+ };
399
+ try {
400
+ walk(tree.rootNode);
401
+ return out;
402
+ } catch {
403
+ return null;
404
+ }
264
405
  }
265
406
 
266
407
  /** 清空全部缓存(测试与长驻进程内存回收用)。 */
@@ -72,7 +72,7 @@ export async function auditHistoryCommit(repoPath, commit, opts = {}, weights =
72
72
  writeFileSync(tarPath, arch.stdout);
73
73
  execFileSync('tar', ['-x', '-C', tmpDir, '-f', tarPath], { stdio: 'ignore' });
74
74
  const historyAudit = await auditFull(tmpDir, opts);
75
- const quality = scoreQuality(historyAudit.findings || [], weights, { files: historyAudit.files, docsScore: historyAudit.docsScore, dimFileCounts: historyAudit.dimFileCounts });
75
+ const quality = scoreQuality(historyAudit.findings || [], weights, { files: historyAudit.files, docsScore: historyAudit.docsScore, dimFileCounts: historyAudit.dimFileCounts, dimRuleCounts: historyAudit.dimRuleCounts });
76
76
  return {
77
77
  summary: historyAudit.summary || {},
78
78
  quality,