@feng0531/dsh-code-review 0.19.0 → 0.19.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 变更记录
 
+## 0.19.2
+
+- 低层autoContext接Git有界跟踪regular索引及必要上下文安全捕获，双读/索引一致性、hash及总限额复用，阻塞元数据可见。
+- untracked/excluded不再进入；真实Git与全量245通过。入口/SVN/调用者搜索未完成，保持明确限制。
+
+## 0.19.1
+
+- 新增只读纯上下文候选导航：唯一tracked未修改直接相对import/include，排除歧义/条件宏/不支持文本/已选变更，20候选截断可见。
+- 尚未接捕获/入口，不声称上下文检索完成；全量244项通过。
+
 ## 0.19.0
 
 - 注册入口启用有界业务分组，预检计一次调用并披露动态综合执行前未知/初始上界，报告展示假设状态。

package/README.md

@@ -4,7 +4,7 @@
 
 ## 当前状态
 
-当前代码版本为 0.19.0，包含有界覆盖预检、显式项目规则及候选证据与反证复核；发布状态以 npm 和 GitHub Release 为准。已通过真实临时 Git/SVN 仓库测试，以及隔离进程中的真实 DSH ToolRuntime 注册验证。当前开发会话的实际预览已返回0.6.0的plan/rules字段，空变更预览与默认关闭外发已验证；已进行经宿主审批的六次小规模真实试跑，累计12次模型调用；四组合成正负例与历史修复对照符合预期，历史引入方向检出候选但引用复核未完成（partial）。不是独立盲测或整体质量证明。详情见 [试跑结果](evaluation/PILOT-RESULTS.md)。
+当前代码版本为 0.19.2，包含有界覆盖预检、显式项目规则及候选证据与反证复核；发布状态以 npm 和 GitHub Release 为准。已通过真实临时 Git/SVN 仓库测试，以及隔离进程中的真实 DSH ToolRuntime 注册验证。当前开发会话的实际预览已返回0.6.0的plan/rules字段，空变更预览与默认关闭外发已验证；已进行经宿主审批的六次小规模真实试跑，累计12次模型调用；四组合成正负例与历史修复对照符合预期，历史引入方向检出候选但引用复核未完成（partial）。不是独立盲测或整体质量证明。详情见 [试跑结果](evaluation/PILOT-RESULTS.md)。
 
 ## 工作区下多个子仓库（0.11.0）
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feng0531/dsh-code-review",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "private": false,
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" },

package/src/context-candidates.mjs

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import {relativePath} from './content.mjs';
+// Navigation only over caller-supplied tracked regular paths; no reads or authority.
+export function contextCandidates(files, trackedPaths, {maxCandidates=20}={}) {
+ if(!Array.isArray(files)||files.length>200||!Array.isArray(trackedPaths)||trackedPaths.length>10000||!Number.isSafeInteger(maxCandidates)||maxCandidates<1||maxCandidates>20)throw new Error('Invalid context candidate limit');
+ const tracked=new Set();for(const p of trackedPaths){relativePath(p);if(tracked.has(p))throw new Error('Duplicate tracked path');tracked.add(p);}
+ const changed=new Set(files.flatMap(f=>[f.path,...(f.oldPath?[f.oldPath]:[])]));
+ const found=new Map();const add=(p,from,reason)=>{if(!tracked.has(p)||changed.has(p))return;if(!found.has(p))found.set(p,{path:p,fromPaths:[],reasons:[],confidence:'navigation-only'});const v=found.get(p);if(!v.fromPaths.includes(from))v.fromPaths.push(from);if(!v.reasons.includes(reason))v.reasons.push(reason);};
+ for(const f of files){
+  relativePath(f.path);if(f.eligibility!=='reviewable'||f.rightExists===false)continue;
+  const text=f.right?.text;if(typeof text!=='string'||Buffer.byteLength(text)>256*1024)continue;
+  if(text.includes('/*')||text.includes(String.fromCharCode(96))||text.includes('R"')||/\\\r?\n/.test(text))continue;
+  const cpp=/\.(c|cc|cpp|cxx|h|hh|hpp|hxx)$/i.test(f.path),js=/\.(mjs|cjs|js|jsx|ts|tsx)$/i.test(f.path);
+  if(cpp&&/^\s*#\s*(if|ifdef|ifndef|elif|else|define|undef)\b/m.test(text))continue;
+  for(const line of text.split('\n')){
+   const match=cpp?/^\s*#\s*include\s*"([^"\\]+)"\s*(?:\/\/.*)?$/.exec(line):js?/^\s*(?:import\s+(?:(?:[^'";]+)\s+from\s+)?|export\s+(?:[^'";]+)\s+from\s+)(['"])([^'"\\]+)\1\s*;?\s*(?:\/\/.*)?$/.exec(line):null;
+   if(!match)continue;const spec=cpp?match[1]:match[2];if(!cpp&&!/^\.\.?\//.test(spec))continue;
+   const target=path.posix.normalize(path.posix.join(path.posix.dirname(f.path),spec));try{relativePath(target);}catch{continue;}
+   const candidates=js&&!path.posix.extname(target)?[target,...['.mjs','.cjs','.js','.jsx','.ts','.tsx'].flatMap(e=>[target+e,target+'/index'+e])]:[target];
+   const matches=candidates.filter(p=>tracked.has(p));if(matches.length===1)add(matches[0],f.path,cpp?'literal-relative-include':'literal-relative-import');
+  }
+ }
+ const candidates=[...found.values()].sort((a,b)=>a.path<b.path?-1:a.path>b.path?1:0);return {candidates:candidates.slice(0,maxCandidates),truncated:candidates.length>maxCandidates,notice:'Only direct current-side import/include navigation. Not caller coverage, semantic binding or historical context. No untracked, recursive or filesystem search.'};
+}

package/src/snapshot.mjs

@@ -1,3 +1,5 @@
+import { gitContextIndex } from './tracked-context.mjs';
+import { contextCandidates } from './context-candidates.mjs';
 import { lstat, realpath } from 'node:fs/promises';
 import path from 'node:path';
 import { captureGit } from './git.mjs';
@@ -31,6 +33,20 @@ export async function captureSnapshot(cwd, options = {}) {
   if (!Array.isArray(rulePaths) || rulePaths.some(name => contextPaths.includes(name))) throw new Error('Rule paths must be separate from context paths');
   const rules = await captureProjectRules(snapshot.root, rulePaths, { signal: options.signal, files: snapshot.files });
   const context = [];
+  let autoContext, index;
+  if (options.autoContext === true) {
+    if (type !== 'git') throw new Error('Automatic SVN context is not yet supported');
+    index = await gitContextIndex(snapshot.root, options);
+    const plan = contextCandidates(snapshot.files, index.paths);
+    autoContext = { ...plan, candidates: plan.candidates.filter(c => !contextPaths.includes(c.path) && !rulePaths.includes(c.path)), capturedPaths: [] };
+    for (const candidate of autoContext.candidates) {
+      if (context.length + new Set(contextPaths).size >= maxContextFiles) { candidate.status = 'blocked'; candidate.reason = 'Context file limit exceeded'; continue; }
+      try {
+        context.push({ path: candidate.path, ...await readLocal(snapshot.root, candidate.path, options) });
+        candidate.status = 'captured'; autoContext.capturedPaths.push(candidate.path);
+      } catch (error) { options.signal?.throwIfAborted(); candidate.status = 'blocked'; candidate.reason = error.message; }
+    }
+  }
   for (const name of [...new Set(contextPaths)].sort()) {
     const changed = snapshot.files.find(f => f.path === name);
     if (changed) {
@@ -42,9 +58,10 @@ export async function captureSnapshot(cwd, options = {}) {
   // Re-capture verifies both selected sides while collecting explicit context.
   if ((await capture(cwd, options)).id !== snapshot.id) throw new Error('Snapshot changed while collecting context');
   for (const item of context) if ((await readLocal(snapshot.root, item.path, options)).hash !== item.hash) throw new Error('Context changed during capture');
+  if (index && (await gitContextIndex(snapshot.root, options)).fingerprint !== index.fingerprint) throw new Error('Tracked context index changed during capture');
   const verifiedRules = await captureProjectRules(snapshot.root, rulePaths, { signal: options.signal, files: snapshot.files });
   if (JSON.stringify(verifiedRules) !== JSON.stringify(rules)) throw new Error('Rules changed during capture');
-  const result = { ...snapshot, context, ...(rules.length ? { rules } : {}) };
+  const result = { ...snapshot, context, ...(autoContext ? { autoContext } : {}), ...(rules.length ? { rules } : {}) };
   delete result.id;
   const serialized = JSON.stringify(result);
   if (Buffer.byteLength(serialized) > maxSnapshotBytes) throw new Error('Snapshot size limit exceeded');

package/src/tracked-context.mjs

@@ -0,0 +1,15 @@
+import { checked } from './process.mjs';
+import { relativePath } from './content.mjs';
+// Index metadata only; never invokes network, diff drivers or source reads.
+export async function gitContextIndex(root, options = {}) {
+ const bytes = await checked('git', ['--no-optional-locks','-c','core.fsmonitor=false','-c','core.untrackedCache=false','ls-files','--stage','-z'], {...options,cwd:root,maxBytes:1024*1024});
+ const records = new TextDecoder('utf-8',{fatal:true}).decode(bytes).split('\0').filter(Boolean);
+ if(records.length>10000)throw new Error('Tracked context index limit exceeded');
+ const entries=new Map();
+ for(const record of records){
+  const match=/^(\d{6}) ([a-f0-9]+) ([0-3])\t(.+)$/.exec(record);if(!match)throw new Error('Invalid Git context index');
+  const name=relativePath(match[4]);const valid=match[3]==='0'&&['100644','100755'].includes(match[1]);
+  if(entries.has(name))entries.set(name,false);else entries.set(name,valid);
+ }
+ return {paths:[...entries].filter(([,valid])=>valid).map(([name])=>name).sort(),fingerprint:bytes.toString('base64')};
+}