dsh-git-push 2.8.6 → 2.9.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.
Files changed (38) hide show
  1. package/README.md +18 -3
  2. package/assets/minihost.sh +35 -0
  3. package/assets/preview.html +36703 -0
  4. package/assets/start.sh +396 -0
  5. package/assets/tree-sitter/LICENSE +21 -0
  6. package/assets/tree-sitter/README.md +69 -0
  7. package/assets/tree-sitter/VERSIONS.txt +1 -0
  8. package/assets/tree-sitter/tree-sitter-javascript.wasm +0 -0
  9. package/assets/tree-sitter/tree-sitter-python.wasm +0 -0
  10. package/assets/tree-sitter/tree-sitter-typescript.wasm +0 -0
  11. package/assets/tree-sitter/tree-sitter.js +3980 -0
  12. package/assets/tree-sitter/tree-sitter.wasm +0 -0
  13. package/lib/app/apply.js +15 -2
  14. package/lib/app/command-registry.js +1 -1
  15. package/lib/app/handlers/workspace-paths.js +107 -0
  16. package/lib/app/http-handlers.js +19 -2
  17. package/lib/app/inject-text.js +1 -1
  18. package/lib/app/tool-call.js +25 -1
  19. package/lib/ast/code-lines.js +52 -0
  20. package/lib/ast/index.js +1 -1
  21. package/lib/ast/tokenizer.js +7 -2
  22. package/lib/ast/treesitter.js +208 -0
  23. package/lib/audit/audit-file.js +3 -3
  24. package/lib/audit/orchestrate.js +38 -0
  25. package/lib/audit-rules/audit-rules-nodejs.yml +2 -2
  26. package/lib/audit-rules/audit-rules-paths.yml +1 -1
  27. package/lib/audit-rules/audit-rules-performance.yml +7 -3
  28. package/lib/checks/dispatch.js +3 -3
  29. package/lib/checks/regex.js +19 -4
  30. package/lib/core/workspace-paths.js +100 -0
  31. package/lib/rule/registry.js +7 -0
  32. package/lib/self/index.js +1 -1
  33. package/lib/user-requirements.json +2 -1
  34. package/package.json +2 -1
  35. package/scripts/sync-plugin-install.mjs +84 -21
  36. package/scripts/sync-plugin.mjs +14 -9
  37. package/skills/guide/guide-cli-scripts.md +1 -1
  38. package/skills/guide/guide-commit-push.md +33 -0
package/lib/app/apply.js CHANGED
@@ -8,6 +8,7 @@
8
8
  import { VERSION } from '../self/index.js';
9
9
  import { persistGithubToken, persistSshPub, credentialsDir } from '../git/index.js';
10
10
  import { createEnvInjectionText, collectToolPaths, mapWorkspaceDirs } from '../context/index.js';
11
+ import { workspacePathsInjectionText } from '../core/workspace-paths.js';
11
12
  import { defaultConfig, resolveConfig } from '../client/index.js';
12
13
  import { loadDefineTool, registerTools, registerContext, registerHttp, registerPreStepInjection } from '../plugin/index.js';
13
14
  // 【2026-10-02 · DSH 0.2.0-rc.2 适配】0.2.0 删除了 settings.register / settings.get 旧 API
@@ -98,7 +99,12 @@ export async function apply(ctx, config = {}) {
98
99
  const envInjectText = (cwdOverride) => {
99
100
  if (!cfg.injectSystemPrompt) return '';
100
101
  const root = cwdOverride || env.workspaceRoot || process.cwd();
101
- if (envInjectCache instanceof Map && envInjectCache.has(root)) return envInjectCache.get(root);
102
+ // AI 自设工作区(可多个)优先于会话 cwd:会话 header 里可能是**陈旧路径**(实测注入出
103
+ // 0.1.6-alpha.1 的旧工作区 ✗)⇒ 有自设就显示自设那份(这就是「AI 自己提醒自己」的实际作用 ✓)
104
+ const aiPaths = workspacePathsInjectionText();
105
+ // 缓存键必须带上自设清单:否则改完清单后注入不刷新 ✗(同一 root 会命中旧缓存)
106
+ const cacheKey = aiPaths ? `${root}\u0000${aiPaths}` : root;
107
+ if (envInjectCache instanceof Map && envInjectCache.has(cacheKey)) return envInjectCache.get(cacheKey);
102
108
  let text = '';
103
109
  try {
104
110
  // 工具清单:lib/tool-probes.json 模板(只 key,跨平台裸名)→ which/where 实测
@@ -119,8 +125,15 @@ export async function apply(ctx, config = {}) {
119
125
  log?.warn?.(`环境注入探测失败,降级静态清单:${e?.message || e}`);
120
126
  text = createEnvInjectionText({ cwd: root, projectRoot: root });
121
127
  }
128
+ // 自设工作区块放在**最前**:AI 每轮先看到自己登记的路径 ✓
129
+ // 同时把基座里的会话 cwd 行标注为「仅兜底」——它取自会话文件,实测可能是陈旧路径 ✗,
130
+ // 不标注就会与上方自设清单并存、继续误导(两处表达同一事实 ⇒ 必须区分主次)
131
+ if (aiPaths && text) {
132
+ text = text.replace(/^- 当前工作目录 cwd:/m, '- 会话 cwd(仅兜底,可能陈旧;以本段上方的「AI 自设工作区」为准):');
133
+ text = `${aiPaths}\n${text}`;
134
+ }
122
135
  if (!(envInjectCache instanceof Map)) envInjectCache = new Map();
123
- envInjectCache.set(root, text);
136
+ envInjectCache.set(cacheKey, text);
124
137
  return text;
125
138
  };
126
139
 
@@ -175,7 +175,7 @@ export const TOOL_REGISTRY = [
175
175
  ],
176
176
  },
177
177
  {
178
- name: 'git_api', cli: 'api', description: '直接调用本插件的 HTTP API(34 条接口,与浏览器/CLI 同源实现:内部走 handleHttp 同一条代码路径)。path=接口名(去掉 /api/git-push/ 前缀,如 status / rule-slots / audit / settings-get);method 默认 GET;query=查询参数 JSON(如 {"mode":"full"});body=POST 请求体 JSON;不传 path 则列出全部可用接口。写类接口(settings-set / repo-push 等)内部调用按本机同源放行。',
178
+ name: 'git_api', cli: 'api', description: '直接调用本插件的 HTTP API(35 条接口,与浏览器/CLI 同源实现:内部走 handleHttp 同一条代码路径)。path=接口名(去掉 /api/git-push/ 前缀,如 status / rule-slots / audit / settings-get);method 默认 GET;query=查询参数 JSON(如 {"mode":"full"});body=POST 请求体 JSON;不传 path 则列出全部可用接口。写类接口(settings-set / repo-push 等)内部调用按本机同源放行。',
179
179
  params: [
180
180
  { flag: 'path', type: 'string', positional: 0, desc: '接口名(缺省 = 列出全部接口)' },
181
181
  { flag: 'method', type: 'string', desc: 'HTTP 方法(默认 GET;写操作传 POST)' },
@@ -0,0 +1,107 @@
1
+ /**
2
+ * HTTP 处理层 · AI 自设工作区路径端点(workspace-paths)
3
+ *
4
+ * 一个端点两种方法(handleHttp 的 switch 按路径分发,方法在 ctx.method 里):
5
+ * · GET /api/git-push/workspace-paths
6
+ * 读回当前自设清单 + 注入文本预览(AI 用它自查「我登记的路径对不对」✓)
7
+ * · POST /api/git-push/workspace-paths
8
+ * 写自设清单。body 支持三种形态(都走同一套校验):
9
+ * { "paths": ["<绝对路径>", …] } 默认 set(整份替换)
10
+ * { "paths": [...], "mode": "add" } 追加(去重)
11
+ * { "paths": [...], "mode": "remove" } 移除
12
+ * { "path": "<绝对路径>", "mode": "add" } 单条简写
13
+ * 也支持 { "clear": true } 清空(回到「无自设 ⇒ 注入回退会话 cwd」)。
14
+ *
15
+ * 为什么要这个端点:环境注入里的 cwd 原先取自会话文件,实测会注入**陈旧路径**(本机注入出
16
+ * `…/0.1.6-alpha.1/工作区/…`,而真实工作区在别处)⇒ 让 AI 自己登记真实路径,注入优先显示它。
17
+ * 这正是「AI 自己提醒自己」的实现方式:注入里显示的就是 AI 自己写下的那份 ✓
18
+ */
19
+ import {
20
+ loadWorkspacePaths, saveWorkspacePaths, workspacePathsInjectionText, workspacePathsFile, MAX_WORKSPACE_PATHS,
21
+ } from '../../core/workspace-paths.js';
22
+
23
+ /** 从 body 取待处理路径数组(paths 数组优先;兼容单条 path 字符串)。 */
24
+ function pathsFromBody(body) {
25
+ if (Array.isArray(body?.paths)) return body.paths.map((x) => String(x || ''));
26
+ if (typeof body?.path === 'string' && body.path.trim()) return [body.path];
27
+ return [];
28
+ }
29
+
30
+ /** GET /api/git-push/workspace-paths —— 读自设清单 + 注入预览。 */
31
+ export function handleWorkspacePathsGet() {
32
+ const cur = loadWorkspacePaths();
33
+ const text = workspacePathsInjectionText();
34
+ return {
35
+ status: 200,
36
+ body: {
37
+ ok: true,
38
+ paths: cur.paths,
39
+ count: cur.paths.length,
40
+ updatedAt: cur.updatedAt,
41
+ updatedBy: cur.updatedBy,
42
+ file: workspacePathsFile(),
43
+ maxPaths: MAX_WORKSPACE_PATHS,
44
+ injection: text, // 注入时会显示成什么样(AI 自查用 ✓)
45
+ injectionActive: !!text, // false = 无自设 ⇒ 注入回退会话 cwd
46
+ usage: "POST 同路径写入:body {\"paths\":[\"<绝对路径>\", …], \"mode\":\"set|add|remove\"};{\"clear\":true} 清空",
47
+ },
48
+ };
49
+ }
50
+
51
+ /** POST /api/git-push/workspace-paths —— 写自设清单(set / add / remove / clear)。 */
52
+ export function handleWorkspacePathsSet(ctx) {
53
+ // body 容错:工具路径传的是**已解析对象**(tool-call 里 JSON.parse 后转字符串再交给 handleHttp),
54
+ // CLI 路径实测传进来的是**JSON 字符串**(`--body '{…}'` 原样)⇒ 两种都接受,
55
+ // 否则 CLI 调用会报「缺少 paths」而实际是 body 没被解析 ✗(2026-10-15 实测踩到)。
56
+ let body = ctx?.body;
57
+ if (typeof body === 'string') {
58
+ try { body = JSON.parse(body || '{}'); } catch { body = {}; }
59
+ }
60
+ if (!body || typeof body !== 'object' || Array.isArray(body)) body = {};
61
+ const mode = String(body.mode || 'set').toLowerCase();
62
+ const cur = loadWorkspacePaths();
63
+
64
+ if (body.clear === true || mode === 'clear') {
65
+ const r = saveWorkspacePaths([], { by: 'ai' });
66
+ return { status: r.ok ? 200 : 500, body: { ok: r.ok, mode: 'clear', paths: r.paths, error: r.rejected[0]?.reason } };
67
+ }
68
+
69
+ const input = pathsFromBody(body);
70
+ if (!input.length) {
71
+ return { status: 400, body: { ok: false, error: '缺少 paths(数组)或 path(字符串);清空请传 {"clear":true}' } };
72
+ }
73
+ if (!['set', 'add', 'remove'].includes(mode)) {
74
+ return { status: 400, body: { ok: false, error: `不支持的 mode: ${mode}(仅 set/add/remove/clear)` } };
75
+ }
76
+
77
+ if (mode === 'remove') {
78
+ // 移除按「字符串相等」比对(用户/AI 写进来的原样路径),避免因 resolve 差异删不掉
79
+ const want = new Set(input.map((x) => String(x).trim()).filter(Boolean));
80
+ const kept = cur.paths.filter((p) => !want.has(p));
81
+ const r = saveWorkspacePaths(kept, { by: 'ai' });
82
+ return {
83
+ status: r.ok ? 200 : 500,
84
+ body: { ok: r.ok, mode, removed: cur.paths.length - kept.length, paths: r.paths, error: r.rejected[0]?.reason },
85
+ };
86
+ }
87
+
88
+ const next = mode === 'add' ? [...cur.paths, ...input] : input;
89
+ const r = saveWorkspacePaths(next, { by: 'ai' });
90
+ // 全部条目被拒(如全是相对路径/不存在的目录)⇒ 必须报错,不能"成功但空"✗
91
+ // —— 否则调用方会以为写进去了,下一轮注入却什么都没有(实测过的误判形态)
92
+ const allRejected = r.paths.length === 0 && input.length > 0;
93
+ const okFinal = r.ok && !allRejected;
94
+ return {
95
+ status: okFinal ? 200 : 400,
96
+ body: {
97
+ ok: okFinal,
98
+ mode,
99
+ paths: r.paths,
100
+ count: r.paths.length,
101
+ rejected: r.rejected, // 被拒的路径 + 原因(相对路径 / 不存在 / 超上限)
102
+ file: r.file,
103
+ injection: workspacePathsInjectionText(),
104
+ error: okFinal ? undefined : (r.rejected[0]?.reason || '写入失败'),
105
+ },
106
+ };
107
+ }
@@ -27,6 +27,9 @@ import {
27
27
  import {
28
28
  handleSettingsGet, handleSettingsSet,
29
29
  } from './handlers/settings.js';
30
+ import {
31
+ handleWorkspacePathsGet, handleWorkspacePathsSet,
32
+ } from './handlers/workspace-paths.js';
30
33
  import {
31
34
  handleNpmAccount, handleNpmCheck, handleNpmOwned, handleNpmPackages, handleNpmInstall, handleNpmPublish,
32
35
  } from './handlers/npm.js';
@@ -56,10 +59,21 @@ export async function adaptHttpHandler(req, res, env, cfg) {
56
59
  return httpResult;
57
60
  }
58
61
 
59
- /** POST JSON 体:只接受非数组对象,其它一律当空对象。 */
62
+ /** POST JSON 体:接受对象,**也接受 JSON 字符串**(内部调用传的是字符串)。 */
60
63
  function readBody(req) {
61
64
  const raw = req && req['body'];
62
- return (raw && typeof raw === 'object' && !Array.isArray(raw)) ? raw : {};
65
+ if (raw && typeof raw === 'object' && !Array.isArray(raw)) return raw;
66
+ // 内部调用(git_api 工具 / CLI)把 body 以 **JSON 字符串** 传入(tool-call.js 里
67
+ // `body: bodyText`);原先一律当空对象 ⇒ **所有 POST 端点的 body 被静默丢弃** ✗
68
+ // (实测 2026-10-15:workspace-paths 的 POST 经工具/CLI 调用时 body 恒为空,
69
+ // 而浏览器路径走 adaptHttpHandler 的 readJsonBody ⇒ 正常 ✓ ⇒ 两条路径行为分叉)
70
+ if (typeof raw === 'string' && raw.trim()) {
71
+ try {
72
+ const j = JSON.parse(raw);
73
+ return (j && typeof j === 'object' && !Array.isArray(j)) ? j : {};
74
+ } catch { return {}; }
75
+ }
76
+ return {};
63
77
  }
64
78
 
65
79
  /** 统一构造 handler 上下文(各 handler 签名 handleXxx(ctx))。 */
@@ -125,6 +139,9 @@ export async function handleHttp(req = {}, env = {}, cfg = defaultConfig()) {
125
139
  case '/api/git-push/gen-ssh-key': return handleGenSshKey(ctx);
126
140
  case '/api/git-push/settings-get': return handleSettingsGet(ctx);
127
141
  case '/api/git-push/settings-set': return await handleSettingsSet(ctx);
142
+ // AI 自设工作区路径:同一路径按 HTTP 方法分发(GET 读清单 / POST 写清单)
143
+ case '/api/git-push/workspace-paths':
144
+ return method === 'POST' ? handleWorkspacePathsSet(ctx) : handleWorkspacePathsGet(ctx);
128
145
  default:
129
146
  return { status: 404, body: { ok: false, code: 'NOT_FOUND', message: `无此端点: ${method} ${path}` } };
130
147
  }
@@ -42,7 +42,7 @@ export const FUNCTION_USAGE_HINT = [
42
42
  '【凭据由插件托管,不要到处找凭据】GitHub token 与 SSH 公钥存放在插件 config.json(git-push/config.json 的 githubToken、sshPub 键,0600);SSH 私钥仍为文件(git-push/id_rsa),由插件的推送/校验流程自动读取与选择通道(默认 SSH,token 401 回退 SSH)。',
43
43
  '需要判断登录态 → 调 git_account_check;需要推送 → 调 git_commit_push。不要遍历用户目录找 token、不要把凭据抄进命令行或文档、不要在回复里明文输出凭据。',
44
44
  '【调用纪律】提交类操作先 git_scan 确认目标仓库;提交前核对 README(功能表/版本记录/用法);审计拦截 blocker 时先修复再提交;用户未要求推送时不要 push。',
45
- '· message 参数:**只能传字符串**(宿主在进插件前按工具 schema 校验,只认标量类型——数组/对象会被直接拒 ✗);要写结构化多条目请用配套参数 `messageItems`(数组:元素为字符串,或 {what,type?,scope?,why?,verify?,refs?};仅 what 必填)——它作为要点与正文,message 则作标题 ✓',
45
+ '· message 参数:**只能传字符串**(宿主在进插件前按工具 schema 校验,只认标量类型——数组/对象会被直接拒 ✗)。**推荐用法**:`message` 传标题字符串 + `messageItems` 传要点数组(元素为字符串,或 {what,type?,scope?,why?,verify?,refs?};仅 what 必填)⇒ 渲染成「标题 + 要点 + why/verify/refs 正文」✓。**该用它的信号**:① 一次提交含多个要点 ② 需要 why/verify 溯源;简单一句话就能说清时用字符串即可(不必强行结构化 ✗)',
46
46
  '(这些纪律只在**会产生新提交/要推送**时才起作用;工作区没改动时直接调用 git_commit_push 也不会报错——不要因为「没东西可提交」就绕开插件手敲 git。)',
47
47
  ].join('\n');
48
48
 
@@ -6,7 +6,7 @@
6
6
  * 与 HTTP 处理分开:两条入口(工具 / HTTP)的鉴权与返回形态完全不同。
7
7
  */
8
8
 
9
- import { existsSync, readFileSync } from 'node:fs';
9
+ import { existsSync, readFileSync, appendFileSync } from 'node:fs';
10
10
  import { MAX_MSG_PREVIEW } from './constants.js';
11
11
  import { access } from 'node:fs/promises';
12
12
  /** blocked 消息预览截断长度(工具返回精简——完整 message 走审计明细)。 */
@@ -70,6 +70,30 @@ async function pushWithPostSteps(args, env, cfg) {
70
70
  // 精确 add 路径(逗号分隔,相对 repo);空 = git add -A 全量
71
71
  paths: String(args.paths || ''),
72
72
  });
73
+ // ── 鼓励使用结构化提交信息(messageItems):提醒 + 采用率留痕 ──────────────────
74
+ // 为什么需要:默认路径(单串 message)更省事,结构化参数长期无人用 ⇒ 两件事互补:
75
+ // ① **该用时提醒**:调用方只传单串、且它偏长或含换行 ⇒ 结果里带 usageHint(随 job 结果 JSON 回到调用方)
76
+ // ② **采用率留痕**:每次调用追加一行 JSON 到 <DSH_HOME>/git-push/commit-usage.log ⇒ 用数据判断是否有效
77
+ // 判定信号 = 「多要点」或「需要 why/verify 溯源」;简单一句话提交用字符串完全正确 ✓(不强行结构化 ✗)
78
+ const msgStr = typeof args.message === 'string' ? args.message : '';
79
+ const itemList = Array.isArray(args.messageItems) ? args.messageItems : null;
80
+ const looksStructured = msgStr.includes('\n') || msgStr.length > 150;
81
+ if (r && !itemList && looksStructured) {
82
+ r.usageHint = '本次提交信息是**单串**且偏长;若含多个要点或需要 why/verify 溯源,建议改用 messageItems'
83
+ + '(数组:元素为字符串或 {what,type?,scope?,why?,verify?,refs?},仅 what 必填)'
84
+ + '——message 作标题、条目渲染成要点与正文 ✓';
85
+ }
86
+ try {
87
+ if (process.env.DSH_HOME) {
88
+ appendFileSync(join(process.env.DSH_HOME, 'git-push', 'commit-usage.log'), JSON.stringify({
89
+ t: new Date().toISOString(),
90
+ structured: !!itemList,
91
+ items: itemList ? itemList.length : 0,
92
+ msgLen: msgStr.length,
93
+ repo: String(args.repo || '').slice(-60),
94
+ }) + '\n');
95
+ }
96
+ } catch { /* 留痕失败不影响提交 ✓ */ }
73
97
  if (r?.ok && r?.pushed) {
74
98
  try {
75
99
  // 统一走 updateRepoIndex(mode='rebuild' 合并不全量覆盖),
@@ -46,6 +46,58 @@ export function makeCodeLineFilter(text = '', candidateLines = [], opts = {}) {
46
46
  };
47
47
  }
48
48
 
49
+ /* ───────────────────────── 列级精筛(行级判定的加强版) ───────────────────────── */
50
+
51
+ /**
52
+ * 正则初筛 → **列级** token 精筛。
53
+ *
54
+ * 为什么需要:行级判定只能回答「这一行有没有代码 token」,回答不了
55
+ * 「正则命中的**那一处**是不是落在字符串/注释里」。实测遗留误报:
56
+ *
57
+ * const hang = await provider.execute(session, { script: 'while (true) {}' });
58
+ *
59
+ * 该行确实含 ident(script / provider 等)⇒ 行级判定放行 ⇒
60
+ * performance/busy-wait-loop 把字符串字面量里的 while(true) 当成真实死循环报出 ✗。
61
+ *
62
+ * 做法:在行级判定之上,用 tokenizer 的 str/tmpl/comment token 构造「不透明区间」,
63
+ * 命中列落在区间内 ⇒ 判为「不是代码」。
64
+ *
65
+ * @param {string} text 文件全文
66
+ * @param {number[]} candidateLines 候选行(1-based)
67
+ * @param {{file?:string}} [opts]
68
+ * @returns {{isCode:(line:number)=>boolean, isCodeHit:(line:number, col:number)=>boolean}}
69
+ * isCodeHit 的 col 为 **1-based 列**(正则 exec 的 index + 1);
70
+ * 列缺失/非法时**退化为行级判定**(宁可放行,不因拿不到列而误杀)。
71
+ */
72
+ export function makeCodeSpanFilter(text = '', candidateLines = [], opts = {}) {
73
+ const base = makeCodeLineFilter(text, candidateLines, opts);
74
+ // 不透明区间只取**单行 token**:跨行 token(三引号/多行块注释)的 col 是续行内位置,
75
+ // 用它构造区间会算错。跨行场景本就由行级判定覆盖——续行不产 ident/num ⇒ 不算代码行。
76
+ const opaque = new Map(); // line → [[startCol, endColExclusive), ...]
77
+ for (const t of tokenize(text)) {
78
+ if (t.type !== 'str' && t.type !== 'tmpl' && t.type !== 'comment') continue;
79
+ const v = String(t.value);
80
+ if (v.includes('\n')) continue;
81
+ const col = Number(t.col);
82
+ if (!Number.isFinite(col) || col < 1) continue;
83
+ const arr = opaque.get(t.line) || [];
84
+ arr.push([col, col + v.length]);
85
+ opaque.set(t.line, arr);
86
+ }
87
+ return {
88
+ isCode: base.isCode,
89
+ isCodeHit: (line, col) => {
90
+ if (!base.isCode(line)) return false;
91
+ const ranges = opaque.get(line);
92
+ if (!ranges || !ranges.length) return true;
93
+ const c = Number(col);
94
+ if (!Number.isFinite(c) || c < 1) return true; // 拿不到列 ⇒ 退化为行级判定
95
+ for (const [s, e] of ranges) if (c >= s && c < e) return false;
96
+ return true;
97
+ },
98
+ };
99
+ }
100
+
49
101
  /**
50
102
  * 是否散文体文档 —— **只按扩展名判定**。
51
103
  *
package/lib/ast/index.js CHANGED
@@ -22,7 +22,7 @@ export { checkSyncFs, checkEmptyCatchAst, checkComplexityAst, checkNestingDepthA
22
22
  export { checkFuncLinesAst, checkFuncDensityAst, funcRangesAst, maxFunctionLength, checkFileLines, countCommentLines, checkRepeatedStringsAst, checkCommentDensityAst } from './size.js';
23
23
  export { checkNameLengthAst, checkShortFunctionNameAst, checkSmallFileReadAst, checkConsoleLogJsonAst } from './naming.js';
24
24
  export { javaKtFuncRanges, detectLang } from './lang.js';
25
- export { makeCodeLineFilter, codeStringLiterals } from './code-lines.js';
25
+ export { makeCodeLineFilter, makeCodeSpanFilter, codeStringLiterals } from './code-lines.js';
26
26
  export { shellCdDynamicLines, writeIntoGitignoredLines } from './shell.js';
27
27
  export { checkMagicNumberSmartAst } from './magic-number.js';
28
28
  export {
@@ -43,7 +43,7 @@ let TOKEN_CACHE_BYTES = 0;
43
43
  * 返回的是**共享数组**——调用方只读,禁止原地修改(push/splice/sort)。
44
44
  *
45
45
  * @param {string} text 文件全文
46
- * @returns {Array<{type:string, value:string, line:number}>}
46
+ * @returns {Array<{type:string, value:string, line:number, col:number}>}
47
47
  * type: ident / punct / str / tmpl / comment / num / ws / other
48
48
  */
49
49
  export function tokenize(text = '') {
@@ -103,7 +103,12 @@ function tokenizeUncached(text = '') {
103
103
  const src = raw;
104
104
  let i = 0;
105
105
  const n = src.length;
106
- const push = (type, value) => tokens.push({ type, value, line });
106
+ // col = token 起始列(1-based,行内)。用途:**列级精筛** —— 行级判定只能回答
107
+ // 「这一行有没有代码」,回答不了「正则命中的那一处是不是落在字符串/注释里」
108
+ // (实测遗留误报:`{ script: 'while (true) {}' }` 里的 while(true) 被当真实死循环)。
109
+ // ⚠️ 跨行 token(三引号 / 多行块注释)的 col 是**续行内位置**、不是 token 真实起点 ⇒
110
+ // 消费方必须跳过 value 含换行的 token(见 lib/ast/code-lines.js 的区间构造)。
111
+ const push = (type, value) => tokens.push({ type, value, line, col: i + 1 });
107
112
  while (i < n) {
108
113
  const ch = src[i];
109
114
  const next = src[i + 1];
@@ -0,0 +1,208 @@
1
+ /**
2
+ * AST 实现层 · tree-sitter(真语法树 · WASM)
3
+ *
4
+ * 定位:**可选增强,绝不是必需依赖**。任何一步失败(资产缺失 / wasm 加载失败 / 无对应语法 /
5
+ * 解析出语法错误 / 超出预算)都返回「未使用」信号,由调用方**回退**到
6
+ * lib/ast/code-lines.js 的 token 级判定(行级 + 列级,2.8.9 已落地)。
7
+ *
8
+ * 为什么这么设计:审计是提交门禁的一部分,**不能因为增强件坏了就整体失效** ✗。
9
+ * 回退不是异常路径,而是常态路径之一 ✓。
10
+ *
11
+ * 资产:assets/tree-sitter/(web-tree-sitter@0.27.1 + 各语言预编译 grammar;MIT)
12
+ * 来源、版本、sha256、可复现下载命令见该目录 README.md ✓
13
+ *
14
+ * 语言口径(既定口径):**加载哪些语言 = lib/audit-rules/ 里存在哪些语言规则包**
15
+ * (**空占位包也算**:cpp/go/php/rust/swift)。语法文件不存在时该语言自动走回退 ✓。
16
+ */
17
+ import { existsSync, readdirSync, readFileSync } from 'node:fs';
18
+ import { createHash } from 'node:crypto';
19
+ import { fileURLToPath, pathToFileURL } from 'node:url';
20
+ import { dirname, join } from 'node:path';
21
+
22
+ /** 资产目录(插件根/assets/tree-sitter)——本文件在 lib/ast/,故上溯两级。
23
+ * 可用 env `DSH_GIT_PUSH_TS_ASSETS` 覆盖:**回退路径测试**把它指向不存在的目录即可
24
+ * (测试禁止改动真实资产目录 ✗)。注意:本常量在**模块加载时**求值,测试需用子进程改 env ✓ */
25
+ export const ASSETS_DIR = process.env.DSH_GIT_PUSH_TS_ASSETS
26
+ || join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'assets', 'tree-sitter');
27
+
28
+ /** 扩展名 → 语法名(grammar)。没有映射的扩展名一律走回退 ✓。 */
29
+ export const EXT_TO_GRAMMAR = {
30
+ js: 'javascript', mjs: 'javascript', cjs: 'javascript', jsx: 'javascript',
31
+ ts: 'typescript', tsx: 'typescript', mts: 'typescript', cts: 'typescript',
32
+ py: 'python',
33
+ };
34
+
35
+ /** 单文件解析预算(字符数):超此长度不解析,直接回退(避免大文件拖慢审计)。 */
36
+ const MAX_PARSE_CHARS = Number(process.env.DSH_GIT_PUSH_TS_MAX_CHARS || 400000) || 400000;
37
+ /** 语法树缓存条数上限(按内容 hash 命中)。 */
38
+ const TREE_CACHE_MAX = Number(process.env.DSH_GIT_PUSH_TS_TREE_CACHE || 64) || 64;
39
+
40
+ /** 惰性状态(模块级):web-tree-sitter 模块 / 初始化 Promise / 语言与解析器缓存。 */
41
+ let modPromise = null;
42
+ let initPromise = null;
43
+ const langCache = new Map();
44
+ const parserCache = new Map();
45
+ const treeCache = new Map(); // hash → tree(简单 FIFO 淘汰)
46
+
47
+ /** 资产是否就位(供调用方与自检使用)。 */
48
+ export function treesitterAvailable() {
49
+ try {
50
+ return existsSync(join(ASSETS_DIR, 'tree-sitter.js')) && existsSync(join(ASSETS_DIR, 'tree-sitter.wasm'));
51
+ } catch { return false; }
52
+ }
53
+
54
+ /** 当前资产里实际可用的语法名列表(按目录里存在的 wasm 推断)。 */
55
+ export function availableGrammars() {
56
+ try {
57
+ return readdirSync(ASSETS_DIR)
58
+ .map((f) => /^tree-sitter-(.+)\.wasm$/.exec(f))
59
+ .filter(Boolean)
60
+ .map((m) => m[1])
61
+ .sort();
62
+ } catch { return []; }
63
+ }
64
+
65
+ /** 由扩展名(可带点)取语法名;无映射返回 ''。 */
66
+ export function grammarForExt(ext = '') {
67
+ const e = String(ext).toLowerCase().replace(/^\./, '');
68
+ return EXT_TO_GRAMMAR[e] || '';
69
+ }
70
+
71
+ /** 懒加载 web-tree-sitter 运行时(ESM 具名导出:Parser / Language / Query)。
72
+ * 文件名用上游原名:0.25.10 是 `tree-sitter.js` / `tree-sitter.wasm`(0.27.x 才是 web-tree-sitter.* ✗ 且与
73
+ * tree-sitter-wasms@0.1.13 的语法不兼容 —— 实测 0.27.1 在 getDylinkMetadata 处报空消息错误 ✗)。 */
74
+ async function loadModule() {
75
+ if (!modPromise) {
76
+ modPromise = import(pathToFileURL(join(ASSETS_DIR, 'tree-sitter.js')).href);
77
+ }
78
+ return modPromise;
79
+ }
80
+
81
+ /** 初始化一次(定位运行时 wasm)。失败返回 null(调用方回退)。 */
82
+ async function ensureInit() {
83
+ if (!initPromise) {
84
+ initPromise = (async () => {
85
+ const { Parser } = await loadModule();
86
+ // locateFile:告诉运行时去哪里取 web-tree-sitter.wasm(默认会按 URL 猜,容器里不可靠)
87
+ await Parser.init({ locateFile: (f) => join(ASSETS_DIR, f) });
88
+ return true;
89
+ })().catch(() => null);
90
+ }
91
+ return initPromise;
92
+ }
93
+
94
+ /** 取(并缓存)某语言的 Parser;不可用返回 null。 */
95
+ async function getParser(grammar) {
96
+ if (!grammar || !existsSync(join(ASSETS_DIR, `tree-sitter-${grammar}.wasm`))) return null;
97
+ if (parserCache.has(grammar)) return parserCache.get(grammar);
98
+ try {
99
+ if (!(await ensureInit())) return null;
100
+ const { Parser, Language } = await loadModule();
101
+ let lang = langCache.get(grammar);
102
+ if (!lang) {
103
+ // 传**字节**而不是路径:0.27.x 的 load(路径) 会静默失败(Node 分支虽会 readFile,但 dylink 不兼容);
104
+ // 字节是唯一被实测验证可用的入口(0.25.10 ✓)
105
+ lang = await Language.load(readFileSync(join(ASSETS_DIR, `tree-sitter-${grammar}.wasm`)));
106
+ langCache.set(grammar, lang);
107
+ }
108
+ const parser = new Parser();
109
+ parser.setLanguage(lang);
110
+ parserCache.set(grammar, parser);
111
+ return parser;
112
+ } catch {
113
+ return null; // 任何异常都退化为「不可用」⇒ 调用方回退 ✓
114
+ }
115
+ }
116
+
117
+ /** 解析文本(按内容 hash 缓存语法树);失败返回 null。 */
118
+ export async function parseText(text, grammar) {
119
+ const src = String(text ?? '');
120
+ if (!grammar || src.length > MAX_PARSE_CHARS) return null;
121
+ const hash = `${grammar}:${createHash('sha1').update(src).digest('hex')}`;
122
+ if (treeCache.has(hash)) return treeCache.get(hash);
123
+ const parser = await getParser(grammar);
124
+ if (!parser) return null;
125
+ try {
126
+ const tree = parser.parse(src);
127
+ if (!tree || !tree.rootNode || tree.rootNode.hasError) return null; // 语法错误 ⇒ 不信任该树,回退 ✓
128
+ treeCache.set(hash, tree);
129
+ while (treeCache.size > TREE_CACHE_MAX) treeCache.delete(treeCache.keys().next().value);
130
+ return tree;
131
+ } catch {
132
+ return null;
133
+ }
134
+ }
135
+
136
+ /** 节点或其祖先是否属于「不透明」构造(字符串/注释/模板/正则字面量)。 */
137
+ export function isOpaqueNode(node) {
138
+ for (let n = node; n; n = n.parent) {
139
+ const t = String(n.type || '');
140
+ if (/^(string|string_fragment|template_string|comment|line_comment|block_comment|regex|regex_pattern|interpreted_string_literal|raw_string_literal)$/.test(t)) return true;
141
+ if (/comment|string/.test(t)) return true; // 各语言命名差异的兜底
142
+ }
143
+ return false;
144
+ }
145
+
146
+ /**
147
+ * 用语法树确认一批命中是否为**真实代码**。
148
+ *
149
+ * @param {{text:string, ext?:string, grammar?:string, hits:Array<{line:number, col:number}>}} p
150
+ * @returns {Promise<{used:boolean, keep:boolean[], reason?:string}>}
151
+ * used=false ⇒ **调用方必须回退**到 token 级判定(keep 无意义);
152
+ * used=true ⇒ keep[i] 表示第 i 个命中是否为真代码(true=保留上报)。
153
+ */
154
+ export async function confirmHits({ text, ext = '', grammar = '', hits = [] } = {}) {
155
+ const g = grammar || grammarForExt(ext);
156
+ if (!g || !hits.length) return { used: false, keep: [], reason: 'no-grammar-or-hits' };
157
+ const tree = await parseText(text, g);
158
+ if (!tree) return { used: false, keep: [], reason: 'parse-unavailable' };
159
+ try {
160
+ const keep = hits.map((h) => {
161
+ const line = Number(h?.line);
162
+ const col = Number(h?.col);
163
+ if (!Number.isFinite(line) || line < 1) return true; // 拿不到位置 ⇒ 不拦(宁可放行不误杀)
164
+ const column = Number.isFinite(col) && col > 0 ? col - 1 : 0;
165
+ const node = tree.rootNode.descendantForPosition({ row: line - 1, column });
166
+ if (!node) return true;
167
+ return !isOpaqueNode(node);
168
+ });
169
+ return { used: true, keep };
170
+ } catch {
171
+ return { used: false, keep: [], reason: 'confirm-failed' };
172
+ }
173
+ }
174
+
175
+ /**
176
+ * 把已解析的语法树包成**同步**确认函数(供同步的检查器 lib/checks/* 调用)。
177
+ *
178
+ * 为什么需要:检查器是同步的,而解析是异步的 —— 由编排层(async)**预解析**后,
179
+ * 把同步闭包传下去,避免把整条检查链改成 async ✗。
180
+ *
181
+ * @param {object|null} tree parseText 的返回值
182
+ * @returns {null|((line:number, col:number)=>boolean|null)} 返回 null 表示「无法判定」,
183
+ * 调用方应回退到 token 级判定(行级 + 列级)✓
184
+ */
185
+ export function makeSyncConfirmer(tree) {
186
+ if (!tree || !tree.rootNode) return null;
187
+ return (line, col) => {
188
+ try {
189
+ const l = Number(line);
190
+ if (!Number.isFinite(l) || l < 1) return null;
191
+ const c = Number(col);
192
+ const column = Number.isFinite(c) && c > 0 ? c - 1 : 0;
193
+ const node = tree.rootNode.descendantForPosition({ row: l - 1, column });
194
+ if (!node) return null;
195
+ return !isOpaqueNode(node);
196
+ } catch {
197
+ return null;
198
+ }
199
+ };
200
+ }
201
+
202
+ /** 清空全部缓存(测试与长驻进程内存回收用)。 */
203
+ export function resetTreeSitterCache() { modPromise = null;
204
+ initPromise = null;
205
+ langCache.clear();
206
+ parserCache.clear();
207
+ treeCache.clear();
208
+ }
@@ -119,7 +119,7 @@ export function auditFile({ file, relPath, text, grouped }, opts = {}) {
119
119
  && !/no-empty-catch/.test(String(r?.id || '')));
120
120
  if (keep.length) scoped[kind] = keep;
121
121
  }
122
- let findings = runChecks({ file, relPath, text, grouped: scoped }, { level: opts?.level, repoHasJsYamlImport: opts?.repoHasJsYamlImport, repoLevelRules: opts?.repoLevelRules, repoPath: opts?.repoPath });
122
+ let findings = runChecks({ file, relPath, text, grouped: scoped }, { level: opts?.level, repoHasJsYamlImport: opts?.repoHasJsYamlImport, repoLevelRules: opts?.repoLevelRules, repoPath: opts?.repoPath, treeConfirm: opts?.treeConfirm });
123
123
  // 产物超长是属性非问题;内置行级检查(quality/empty-catch 等)与残余行级规则也屏蔽——
124
124
  // 混淆单行 10万+ 字符上 catch{} 等模式天然密集,非真实缺陷。
125
125
  const keepRule = /^secret-|^cred|security\/no-hardcoded-credentials|security\/no-path-traversal/; // 构建/混淆产物:健康度(行长/大小)是产物属性非问题,只留凭据/路径安全
@@ -132,7 +132,7 @@ export function auditFile({ file, relPath, text, grouped }, opts = {}) {
132
132
  const isTestFile = /(^|[/\\])(test|tests|__tests__|spec)[/\\]|\.(test|spec)\.(js|mjs|cjs|ts)$/i.test(String(relPath || file));
133
133
  const maintainabilityScoped = !isCode || isTestFile;
134
134
  const scopedGrouped = maintainabilityScoped ? { ...grouped, 'repeated-string': undefined, 'min-occurrences': undefined } : grouped;
135
- let findings = runChecks({ file, relPath, text, grouped: scopedGrouped }, { level: opts?.level, repoHasJsYamlImport: opts?.repoHasJsYamlImport, repoLevelRules: opts?.repoLevelRules, repoPath: opts?.repoPath });
135
+ let findings = runChecks({ file, relPath, text, grouped: scopedGrouped }, { level: opts?.level, repoHasJsYamlImport: opts?.repoHasJsYamlImport, repoLevelRules: opts?.repoLevelRules, repoPath: opts?.repoPath, treeConfirm: opts?.treeConfirm });
136
136
  const isRuleDefFile = /(^|[/\\])audit-rules-[a-z0-9-]+\.ya?ml$/i.test(String(relPath || file));
137
137
  const fileLines = String(text || '').split('\n');
138
138
  // 语义级豁免:纯 regex 规则看不到的上下文在此兜底——
@@ -145,7 +145,7 @@ export function auditFile({ file, relPath, text, grouped }, opts = {}) {
145
145
  // 规则定义文件:规则驱动命中(secret/regex/path-regex/func-lines 等 yml 规则)全豁免
146
146
  if (isRuleDefFile && f.rule !== 'quality/empty-catch' && f.rule !== 'robustness/io-risk') return false;
147
147
  // 技能/规则文档豁免:skills/ 下的 skill 文档与 rules/ 文档里的
148
- // 沟通措辞是「触发场景/规则描述」设计文本(如 whenToUse 触发场景描述),非代码残留——comment 规则不拦;
148
+ // 文档用语是「触发场景/规则描述」设计文本(如 whenToUse 触发场景描述),非代码残留——comment 规则不拦;
149
149
  // version 规则同理:版本规则文档自身描述 0.x 例外(如 versioning-rule §二「内置模块从 0 开始」),
150
150
  // 文档里的版本号示例是规则文本而非违规版本标记
151
151
  const isSkillDoc = /(^|[/\\])skills([/\\]|$)/.test(String(relPath || file));
@@ -7,6 +7,7 @@ import { groupByKind, HINT_QUALITY, checkFolderRules, checkPrivateFiles, checkDu
7
7
  import { loadRuleFiles } from '../rule/loader.js';
8
8
  import { compileAllRules } from '../rule/registry.js';
9
9
  import { auditFile } from './audit-file.js';
10
+ import { grammarForExt, parseText, makeSyncConfirmer } from '../ast/treesitter.js';
10
11
  import { detectRepoJsYamlImport } from './file-context.js';
11
12
  import { decorateTestExemptHint, makeFinding, summarize } from './finding.js';
12
13
  import { pickRepoLevelAnchorFile, repoLevelSemanticRuleIds } from './repo-level.js';
@@ -105,6 +106,39 @@ function appendIgnoreBlindSpot(findings, repoPath, scanned) {
105
106
  * @param {Array<{path?:string, rel?:string, full:string, status?:string}>} files 待审计文件(path 优先,rel 兜底)
106
107
  * @param {object} opts { scope, compiled, slots, rulesetDir, disabledSlots, auditLevel, privateFiles, visibility, truncated }
107
108
  */
109
+ /**
110
+ * 为单个文件准备 tree-sitter 的**同步**确认函数(编排层是 async,检查器是同步)。
111
+ *
112
+ * 何时才解析(性能纪律,别把所有文件都解析 ✗):
113
+ * ① 该文件扩展名有可用语法(grammarForExt ✓)
114
+ * ② 该文件的规则集里**确实存在**声明 astConfirmSpan 的规则(否则解析纯属浪费 ✓)
115
+ * 任何失败(无语法 / 资产缺失 / 解析出错 / 超预算)都返回 null
116
+ * ⇒ 检查器自动回退 token 级判定(2.8.9 行为)✓ —— 回退是常态路径,不是异常路径 ✓
117
+ *
118
+ * @returns {Promise<null|((line:number, col:number)=>boolean|null)>}
119
+ */
120
+ async function buildTreeConfirmer(relPath, text, grouped) {
121
+ try {
122
+ // ⚠️ 取**扩展名**(不是整条路径)——grammarForExt 收的是扩展名 ✓
123
+ // 按 basename 的最后一个点取:避免 `docs/.vitepress/theme/index.ts` 这类**带点目录**踩坑 ✗
124
+ // (本项目 lib/checks/filter.js 已因同类写法修过一次 ✓)
125
+ const base = String(relPath || '').split(/[\\/]/).pop();
126
+ const ext = base.includes('.') ? base.slice(base.lastIndexOf('.') + 1) : '';
127
+ const grammar = grammarForExt(ext);
128
+ if (!grammar) return null;
129
+ let need = false;
130
+ for (const rules of Object.values(grouped || {})) {
131
+ if (!Array.isArray(rules)) continue;
132
+ if (rules.some((r) => r?.astConfirmSpan === true)) { need = true; break; }
133
+ }
134
+ if (!need) return null;
135
+ const tree = await parseText(text, grammar);
136
+ return tree ? makeSyncConfirmer(tree) : null;
137
+ } catch {
138
+ return null;
139
+ }
140
+ }
141
+
108
142
  async function auditFiles(repoPath, files, opts = {}) {
109
143
  // 归一化:full 收集项用 path,changed 用 rel → 统一取 path
110
144
  const normFiles = files.map((f) => ({ path: f.path ?? f.rel, full: f.full, status: f.status }));
@@ -182,9 +216,13 @@ async function auditFiles(repoPath, files, opts = {}) {
182
216
  const text = readText(f.full);
183
217
  fileTexts.push({ path: f.path, text });
184
218
  const skipRepoLevel = repoLevelRules.size > 0 && f.path !== repoLevelAnchor;
219
+ // tree-sitter 预解析(异步):有语法 + 本文件规则集确实要 astConfirmSpan 才解析;
220
+ // 拿不到语法树 ⇒ treeConfirm 为 null ⇒ 检查器回退 token 级判定 ✓
221
+ const treeConfirm = await buildTreeConfirmer(f.path, text, grouped);
185
222
  findings.push(...auditFile({ file: f.path, relPath: f.path, text, grouped }, {
186
223
  level: opts.auditLevel, repoHasJsYamlImport, repoPath,
187
224
  repoLevelRules: skipRepoLevel ? repoLevelRules : null,
225
+ treeConfirm,
188
226
  }));
189
227
  }
190
228
  // 跨文件重复代码检测(maintainability/no-duplicate-code,该抽公共函数)。