dsh-knit 0.19.1 → 0.20.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +249 -0
- package/README.en.md +41 -24
- package/README.md +32 -21
- package/SECURITY.md +2 -2
- package/package.json +3 -2
- package/src/client/client.js +742 -63
- package/src/host/context.js +29 -1
- package/src/host/index.js +124 -13
- package/src/host/passage.js +408 -0
- package/src/host/tool.js +104 -23
- package/test/client.test.mjs +793 -12
- package/test/context/fixture.mjs +2 -5
- package/test/deep-context.test.mjs +447 -0
- package/test/deep-eval.test.mjs +90 -0
- package/test/deep-scale.test.mjs +64 -0
- package/test/eval/deep.mjs +322 -0
- package/test/eval/fixture.mjs +6 -9
- package/test/fixture.mjs +21 -1
- package/test/harness.mjs +63 -4
- package/test/host.test.mjs +2 -2
- package/test/icon.test.mjs +11 -8
- package/test/tool.test.mjs +247 -18
|
@@ -0,0 +1,322 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* v0.20 Deep Context Retrieval · **深度评测语料与四个确定性指标**
|
|
3
|
+
*
|
|
4
|
+
* 需求 §23 点名了四个指标,本文件是它们唯一的定义处:
|
|
5
|
+
*
|
|
6
|
+
* `DeepHitRate` 目标词**只在旧窗口(前 2500 字)之后**时,目标文件是否进入结果
|
|
7
|
+
* `PassageHit@1` Top-1 文件的**第一个** passage 是否覆盖目标行
|
|
8
|
+
* `PassageRecall` 目标 passage 是否出现在该文件返回的 `matches` 里
|
|
9
|
+
* `LongDocNoiseRate` 「什么都提一句」的长归档文出现在 Primary / Supporting 的比例
|
|
10
|
+
*
|
|
11
|
+
* 三条纪律(与 `test/eval/fixture.mjs` 一致,写在这里免得下一个人踩):
|
|
12
|
+
*
|
|
13
|
+
* 1. **不碰 v0.19 的基线。** 本文件是**新的一套**语料与指标(§22:两套并存),
|
|
14
|
+
* `test/eval.test.mjs` / `test/context-eval.test.mjs` 一个字不改。
|
|
15
|
+
* 2. **确定性。** 所有 mtime 由 `makeWorkspace()` 定死;行号由构造式算术给出
|
|
16
|
+
* (先记 `l.length` 再 push,不手数行);不依赖扫描序、异步序、对象插入序(§20)。
|
|
17
|
+
* 3. **指标要能区分版本。** `DeepHitRate` 同时算一份**旧窗口模拟**
|
|
18
|
+
* (`LegacyDeepHitRate`:把正文截到前 2500 字再排序,即 v0.19 的口径)。
|
|
19
|
+
* 如果两个数字一样,这个指标就是废的 —— 测试里对这条有断言。
|
|
20
|
+
*
|
|
21
|
+
* 跑法:`node --test test/deep-eval.test.mjs`(也走 `npm test`)。
|
|
22
|
+
*/
|
|
23
|
+
import { rmSync } from 'node:fs'
|
|
24
|
+
import { rankByRelevance, extractKeywords } from '../../src/host/relevance.js'
|
|
25
|
+
import { scan } from '../../src/host/index.js'
|
|
26
|
+
import { buildContext } from '../../src/host/context.js'
|
|
27
|
+
import { makeWorkspace } from '../fixture.mjs'
|
|
28
|
+
|
|
29
|
+
/** 旧版本(v0.19)的正文窗口。模拟它才能证明「窗口一开,命中率从 0 变成 1」。 */
|
|
30
|
+
export const LEGACY_HAYSTACK_CHARS = 2500
|
|
31
|
+
|
|
32
|
+
/** 一行与任务无关的正文 —— 长度稳定,便于把目标推到 2500 字之后。 */
|
|
33
|
+
function noiseLine(i) {
|
|
34
|
+
return `第 ${i} 行:这一段与查询词毫无关系,只是把真正重要的那几行推到很靠后的位置去。`
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
/** 造一篇「长文档」,目标行按构造式计算行号(**不手数行**)。 */
|
|
38
|
+
function longDoc({ title, keys, lead = 120, tail = 12 }) {
|
|
39
|
+
const l = [`# ${title}`, '']
|
|
40
|
+
for (let i = 1; i <= lead; i += 1) l.push(noiseLine(i))
|
|
41
|
+
const marks = []
|
|
42
|
+
for (const key of keys) {
|
|
43
|
+
l.push(`处理入口:${key} 的这个分支写在 src/handler.js 里。`)
|
|
44
|
+
marks.push(l.length) // 1-based 行号
|
|
45
|
+
for (let i = 1; i <= tail; i += 1) l.push(noiseLine(lead + i))
|
|
46
|
+
}
|
|
47
|
+
return { content: l.join('\n'), lines: marks }
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
/** 造一个长代码文件,目标行 = 函数声明那一行。 */
|
|
51
|
+
function longCode({ keys, lead = 110, tail = 10 }) {
|
|
52
|
+
const l = ['// deep-code.mjs', "import { helper } from './helper.js'", '']
|
|
53
|
+
for (let i = 1; i <= lead; i += 1) l.push(`// 填充注释第 ${i} 行:与这个查询没有关系。`)
|
|
54
|
+
const marks = []
|
|
55
|
+
for (const key of keys) {
|
|
56
|
+
l.push(`export function ${key}Handler(input) {`)
|
|
57
|
+
marks.push(l.length)
|
|
58
|
+
l.push(' const value = helper(input)')
|
|
59
|
+
l.push(' return value + 1')
|
|
60
|
+
l.push('}')
|
|
61
|
+
for (let i = 1; i <= tail; i += 1) l.push(`// 结尾填充第 ${i} 行。`)
|
|
62
|
+
}
|
|
63
|
+
return { content: l.join('\n'), lines: marks }
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
/** 长归档文:每个话题词都**只提一句**(「什么话题都提一句」的真实污染源)。 */
|
|
67
|
+
function longArchive(allKeys) {
|
|
68
|
+
const l = ['# 归档 CHANGELOG', '']
|
|
69
|
+
for (let i = 1; i <= 260; i += 1) l.push(`## 历史条目 ${i}`, `第 ${i} 次改动:顺手修了一点别的东西,与当前任务无关。`, '')
|
|
70
|
+
l.push('## 杂项索引', '')
|
|
71
|
+
for (const key of allKeys) l.push(`- 有一年 ${key} 这件事被顺带提过一次,细节在别处。`)
|
|
72
|
+
return l.join('\n')
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
/** 六个用例共用的稀有词 —— 全部是造出来的,语料里只会出现在我们放的位置。 */
|
|
76
|
+
const KEYS = {
|
|
77
|
+
lateDoc: 'obsidianquark',
|
|
78
|
+
deepCode: 'marlinspike',
|
|
79
|
+
tailDoc: 'glaciermoth',
|
|
80
|
+
twinDoc: 'tungstenfin',
|
|
81
|
+
headingDoc: 'peridotlynx',
|
|
82
|
+
control: 'basaltcrow',
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
const ALL_KEYS = Object.values(KEYS)
|
|
86
|
+
|
|
87
|
+
/**
|
|
88
|
+
* 六个用例。每条:
|
|
89
|
+
* - `files` 送进 `makeWorkspace()` 的文件
|
|
90
|
+
* - `target` 期望被找到的文件与**目标行**(1-based)
|
|
91
|
+
* - `deep` 目标是否落在旧窗口(2500 字)之后 —— 控制组为 `false`
|
|
92
|
+
* - `query` 交给 `scan()` 的自然语言查询
|
|
93
|
+
*/
|
|
94
|
+
export const DEEP_CASES = (() => {
|
|
95
|
+
const cases = []
|
|
96
|
+
|
|
97
|
+
// ① 目标在正文中段(约 6000 字之后)
|
|
98
|
+
{
|
|
99
|
+
const doc = longDoc({ title: 'late-doc', keys: [KEYS.lateDoc] })
|
|
100
|
+
cases.push({
|
|
101
|
+
id: 'late-doc',
|
|
102
|
+
query: `where is ${KEYS.lateDoc} handled`,
|
|
103
|
+
files: [['docs/late-doc.md', doc.content]],
|
|
104
|
+
target: { rel: 'docs/late-doc.md', line: doc.lines[0] },
|
|
105
|
+
deep: true,
|
|
106
|
+
})
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
// ② 目标在代码文件的函数声明上(约 5000 字之后)
|
|
110
|
+
{
|
|
111
|
+
const code = longCode({ keys: [KEYS.deepCode] })
|
|
112
|
+
cases.push({
|
|
113
|
+
id: 'deep-code',
|
|
114
|
+
query: `which function implements ${KEYS.deepCode}`,
|
|
115
|
+
files: [['src/deep-code.mjs', code.content]],
|
|
116
|
+
target: { rel: 'src/deep-code.mjs', line: code.lines[0] },
|
|
117
|
+
deep: true,
|
|
118
|
+
})
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
// ③ 目标在文档**尾部**(约 7000 字之后)
|
|
122
|
+
{
|
|
123
|
+
const doc = longDoc({ title: 'tail-doc', keys: [KEYS.tailDoc], lead: 160, tail: 3 })
|
|
124
|
+
cases.push({
|
|
125
|
+
id: 'tail-doc',
|
|
126
|
+
query: `${KEYS.tailDoc} 的处理入口在哪`,
|
|
127
|
+
files: [['docs/tail-doc.md', doc.content]],
|
|
128
|
+
target: { rel: 'docs/tail-doc.md', line: doc.lines[0] },
|
|
129
|
+
deep: true,
|
|
130
|
+
})
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
// ④ 同一篇里**两处**命中,相隔 3500 字以上 ⇒ 两段都在 2500 之后
|
|
134
|
+
{
|
|
135
|
+
const doc = longDoc({ title: 'twin-doc', keys: [KEYS.twinDoc, KEYS.twinDoc], lead: 110, tail: 60 })
|
|
136
|
+
cases.push({
|
|
137
|
+
id: 'twin-doc',
|
|
138
|
+
query: `${KEYS.twinDoc} 出现在哪几处`,
|
|
139
|
+
files: [['docs/twin-doc.md', doc.content]],
|
|
140
|
+
target: { rel: 'docs/twin-doc.md', line: doc.lines[0] },
|
|
141
|
+
targetLines: doc.lines,
|
|
142
|
+
deep: true,
|
|
143
|
+
})
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
// ⑤ 目标出现在一个很深的 Markdown 标题行上
|
|
147
|
+
{
|
|
148
|
+
const doc = longDoc({ title: 'heading-doc', keys: [KEYS.headingDoc], lead: 140, tail: 6 })
|
|
149
|
+
cases.push({
|
|
150
|
+
id: 'heading-doc',
|
|
151
|
+
query: `${KEYS.headingDoc} 这一节讲什么`,
|
|
152
|
+
files: [['docs/heading-doc.md', doc.content]],
|
|
153
|
+
target: { rel: 'docs/heading-doc.md', line: doc.lines[0] },
|
|
154
|
+
deep: true,
|
|
155
|
+
})
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
// ⑥ 控制组:目标就在**文件名**里 —— 旧窗口也能命中,用来证明指标不是「一律 0」
|
|
159
|
+
{
|
|
160
|
+
const body = [
|
|
161
|
+
`# ${KEYS.control} 说明`,
|
|
162
|
+
'',
|
|
163
|
+
`${KEYS.control} 这个组件只有很短的一页文档,讲的是它的开关。`,
|
|
164
|
+
'',
|
|
165
|
+
'没有更多内容了。',
|
|
166
|
+
].join('\n')
|
|
167
|
+
cases.push({
|
|
168
|
+
id: 'control-title',
|
|
169
|
+
query: `what is ${KEYS.control}`,
|
|
170
|
+
files: [[`docs/${KEYS.control}.md`, body]],
|
|
171
|
+
target: { rel: `docs/${KEYS.control}.md`, line: 3 },
|
|
172
|
+
deep: false,
|
|
173
|
+
})
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
return cases
|
|
177
|
+
})()
|
|
178
|
+
|
|
179
|
+
/** 每个用例的工作区都额外塞一份「什么都提一句」的长归档 + 两篇普通噪声文档。 */
|
|
180
|
+
function extraFiles() {
|
|
181
|
+
return [
|
|
182
|
+
['archive/CHANGELOG.md', longArchive(ALL_KEYS)],
|
|
183
|
+
['docs/noise-a.md', '# 噪声 A\n\n与任务无关的一页。\n'],
|
|
184
|
+
['docs/noise-b.md', '# 噪声 B\n\n也与任务无关。\n'],
|
|
185
|
+
]
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
/**
|
|
189
|
+
* 旧窗口模拟:v0.19 的 haystack 口径(**先截前 2500 字,再转小写**)。
|
|
190
|
+
*
|
|
191
|
+
* 只服务于 `LegacyDeepHitRate` 这一个数字 —— 它回答「如果正文还是只取前 2500 字,
|
|
192
|
+
* 目标文件还会被找到吗」。不去碰真实的 `scan()`(那已经没有窗口了)。
|
|
193
|
+
*
|
|
194
|
+
* @param {object} c - 用例
|
|
195
|
+
* @returns {{hits: string[]}} 命中旧窗口的文件相对路径
|
|
196
|
+
*/
|
|
197
|
+
export function legacyRanking(c) {
|
|
198
|
+
const records = c.files.map(([rel, content]) => {
|
|
199
|
+
const name = rel.split('/').pop()
|
|
200
|
+
const head = content.slice(0, 4096)
|
|
201
|
+
const cut = rel.lastIndexOf('/')
|
|
202
|
+
return {
|
|
203
|
+
rel,
|
|
204
|
+
path: rel,
|
|
205
|
+
name,
|
|
206
|
+
kind: rel.endsWith('.md') ? 'md' : 'code',
|
|
207
|
+
size: content.length,
|
|
208
|
+
mtimeMs: 1_760_000_000_000,
|
|
209
|
+
haystack: {
|
|
210
|
+
title: name.toLowerCase(),
|
|
211
|
+
summary: (cut >= 0 ? rel.slice(0, cut + 1) : '').toLowerCase(),
|
|
212
|
+
body: head.slice(0, LEGACY_HAYSTACK_CHARS).toLowerCase(),
|
|
213
|
+
},
|
|
214
|
+
}
|
|
215
|
+
})
|
|
216
|
+
const keywords = extractKeywords([c.query], 30)
|
|
217
|
+
const ranked = rankByRelevance(records, keywords, 1_760_000_000_000)
|
|
218
|
+
// ⚠️ 「命中」= **真的匹配上了**(`raw > 0`),不是「出现在结果列表里」:
|
|
219
|
+
// `rankByRelevance` 把没命中的文档也排在后面返回(面板要列全量),
|
|
220
|
+
// 拿「在列表里」当命中,语料里再多噪声也永远 100% —— 这个指标就废了。
|
|
221
|
+
return { hits: ranked.docs.filter((d) => d.raw > 0).map((d) => d.rel) }
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
/** 某个 passage 是否覆盖目标行。 */
|
|
225
|
+
function covers(match, line) {
|
|
226
|
+
return Boolean(match) && match.startLine <= line && match.endLine >= line
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
/**
|
|
230
|
+
* 跑完整套深度评测。
|
|
231
|
+
*
|
|
232
|
+
* @returns {Promise<{metrics: object, cases: object[]}>} 四指标 + 逐用例明细
|
|
233
|
+
*/
|
|
234
|
+
export async function runDeepEval() {
|
|
235
|
+
const perCase = []
|
|
236
|
+
|
|
237
|
+
for (const c of DEEP_CASES) {
|
|
238
|
+
const root = makeWorkspace([...c.files, ...extraFiles()])
|
|
239
|
+
let payload
|
|
240
|
+
try {
|
|
241
|
+
payload = await scan(root, 50, { sort: 'relevance', query: c.query, kind: 'context' })
|
|
242
|
+
} finally {
|
|
243
|
+
// 一次评测要造 6 个工作区、确定性用例还要跑两遍 —— 用完就删,
|
|
244
|
+
// 别等退出时再统一清(`makeWorkspace` 的兜底监听仍在)。
|
|
245
|
+
rmSync(root, { recursive: true, force: true })
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
const hit = payload.docs.some((d) => d.rel === c.target.rel)
|
|
249
|
+
// 「进入结果」的严格口径:**被相关性检索真的命中**(`raw > 0`)。
|
|
250
|
+
// 只看 `docs.some(...)` 是不够的 —— 那个列表里本来就躺着全部扫描到的文档,
|
|
251
|
+
// 于是不管窗口开不开都是 100%(v0.19 的基线 0 就是这么被掩盖掉的)。
|
|
252
|
+
const rankedTarget = payload.ranked.find((d) => d.rel === c.target.rel) || null
|
|
253
|
+
const matched = Boolean(rankedTarget) && rankedTarget.raw > 0
|
|
254
|
+
const rank = payload.docs.findIndex((d) => d.rel === c.target.rel)
|
|
255
|
+
const target = payload.docs.find((d) => d.rel === c.target.rel) || null
|
|
256
|
+
const matches = (target && Array.isArray(target.matches)) ? target.matches : []
|
|
257
|
+
const wanted = c.targetLines || [c.target.line]
|
|
258
|
+
|
|
259
|
+
// recall = 目标行**全部**被某一段覆盖(多命中用例要求两处都在)
|
|
260
|
+
const recall = wanted.every((line) => matches.some((m) => covers(m, line)))
|
|
261
|
+
const top = payload.docs[0] || null
|
|
262
|
+
const topMatches = (top && Array.isArray(top.matches)) ? top.matches : []
|
|
263
|
+
const passageHit1 = Boolean(top) && top.rel === c.target.rel
|
|
264
|
+
&& wanted.every((line) => topMatches.some((m) => covers(m, line)))
|
|
265
|
+
|
|
266
|
+
const split = buildContext({ ranked: payload.ranked, topic: payload.topic, total: payload.total })
|
|
267
|
+
const noisy = {
|
|
268
|
+
primary: split.primary.some((d) => d.rel === 'archive/CHANGELOG.md'),
|
|
269
|
+
supporting: split.supporting.some((d) => d.rel === 'archive/CHANGELOG.md'),
|
|
270
|
+
related: split.related.some((d) => d.rel === 'archive/CHANGELOG.md'),
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
const legacy = legacyRanking(c)
|
|
274
|
+
|
|
275
|
+
perCase.push({
|
|
276
|
+
id: c.id,
|
|
277
|
+
query: c.query,
|
|
278
|
+
targetRel: c.target.rel,
|
|
279
|
+
targetLines: wanted,
|
|
280
|
+
deep: c.deep,
|
|
281
|
+
hit: matched,
|
|
282
|
+
legacyHit: legacy.hits.includes(c.target.rel),
|
|
283
|
+
rank: rank >= 0 ? rank + 1 : 0,
|
|
284
|
+
passageHit1,
|
|
285
|
+
recall,
|
|
286
|
+
noisy,
|
|
287
|
+
matchRanges: matches.map((m) => `${m.startLine}-${m.endLine}`),
|
|
288
|
+
topRel: top ? top.rel : '',
|
|
289
|
+
})
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
const n = perCase.length
|
|
293
|
+
const rate = (pick) => perCase.filter(pick).length / n
|
|
294
|
+
const metrics = {
|
|
295
|
+
DeepHitRate: rate((p) => p.hit),
|
|
296
|
+
LegacyDeepHitRate: rate((p) => p.legacyHit),
|
|
297
|
+
'PassageHit@1': rate((p) => p.passageHit1),
|
|
298
|
+
PassageRecall: rate((p) => p.recall),
|
|
299
|
+
LongDocNoiseRate: rate((p) => p.noisy.primary || p.noisy.supporting),
|
|
300
|
+
}
|
|
301
|
+
return { metrics, cases: perCase }
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
/** 把逐用例明细排成一张人看的表(`npm run` 之外由报告引用)。 */
|
|
305
|
+
export function formatDeepEval(result) {
|
|
306
|
+
const head = 'id deep hit legacy top1 recall rank ranges archive'
|
|
307
|
+
const rows = result.cases.map((p) => [
|
|
308
|
+
p.id.padEnd(14),
|
|
309
|
+
String(p.deep).padEnd(5),
|
|
310
|
+
String(p.hit).padEnd(4),
|
|
311
|
+
String(p.legacyHit).padEnd(6),
|
|
312
|
+
String(p.passageHit1).padEnd(5),
|
|
313
|
+
String(p.recall).padEnd(7),
|
|
314
|
+
String(p.rank).padEnd(5),
|
|
315
|
+
(p.matchRanges.join(',') || '-').padEnd(27),
|
|
316
|
+
p.noisy.primary ? 'PRIMARY' : (p.noisy.supporting ? 'SUPPORTING' : (p.noisy.related ? 'related' : '-')),
|
|
317
|
+
].join(' '))
|
|
318
|
+
const m = result.metrics
|
|
319
|
+
return [head, ...rows, '',
|
|
320
|
+
`DeepHitRate=${m.DeepHitRate} (legacy ${m.LegacyDeepHitRate}) PassageHit@1=${m['PassageHit@1']}`
|
|
321
|
+
+ ` PassageRecall=${m.PassageRecall} LongDocNoiseRate=${m.LongDocNoiseRate}`].join('\n')
|
|
322
|
+
}
|
package/test/eval/fixture.mjs
CHANGED
|
@@ -11,16 +11,13 @@
|
|
|
11
11
|
* 一个对所有文档相同的常数 —— 它不影响名次,评测测的就纯粹是相关性。
|
|
12
12
|
* 2. **直接构造 `{haystack, mtimeMs}`,不走文件系统。** 被测对象是排序器,
|
|
13
13
|
* 不是扫描器/解析器;把 I/O 与解析拉进来只会制造混淆变量。
|
|
14
|
-
* haystack 的口径严格照抄宿主(`src/host/index.js
|
|
15
|
-
*
|
|
14
|
+
* haystack 的口径严格照抄宿主(`src/host/index.js` 的 `readDoc`):
|
|
15
|
+
* **整篇正文转小写**(v0.20 取消了「只取前 2500 字」的窗口)。
|
|
16
16
|
*
|
|
17
17
|
* 覆盖六类用例(PRD §6.1):纯中文 / 纯英文技术词 / 中英混合 /
|
|
18
18
|
* 高频词陷阱 / 长文档陷阱 / 退化场景,另加一条一次性罕见词(SDD §4.8)。
|
|
19
19
|
*/
|
|
20
20
|
|
|
21
|
-
/** 与宿主一致的正文截断长度。 */
|
|
22
|
-
const HAYSTACK_CHARS = 2500
|
|
23
|
-
|
|
24
21
|
/** 固定的「现在」,让评测完全确定(不受运行时间影响)。 */
|
|
25
22
|
export const NOW = 1_760_000_000_000
|
|
26
23
|
|
|
@@ -46,7 +43,7 @@ function doc(rel, { title, summary = '', body = '' }) {
|
|
|
46
43
|
haystack: {
|
|
47
44
|
title: title.toLowerCase(),
|
|
48
45
|
summary: summary.toLowerCase(),
|
|
49
|
-
body: body.
|
|
46
|
+
body: body.toLowerCase(),
|
|
50
47
|
},
|
|
51
48
|
}
|
|
52
49
|
}
|
|
@@ -245,7 +242,7 @@ Knit 浮层里的点击是即时响应的,不走列表接口,也不等轮询
|
|
|
245
242
|
* ```text
|
|
246
243
|
* filename → title (权重 ×4)
|
|
247
244
|
* path → summary (权重 ×2,保留结尾斜杠)
|
|
248
|
-
* content → body (权重 ×1
|
|
245
|
+
* content → body (权重 ×1,整篇正文 —— v0.20 起不再截窗口)
|
|
249
246
|
* ```
|
|
250
247
|
*
|
|
251
248
|
* `title` 是**带扩展名的文件名**,不是去扩展名的 stem —— 代码的文件名里扩展名本身
|
|
@@ -257,7 +254,7 @@ Knit 浮层里的点击是即时响应的,不走列表接口,也不等轮询
|
|
|
257
254
|
* 走完全相同的 `{rel, haystack, mtimeMs}` 形状**,只是三段文本的来源不同。
|
|
258
255
|
*
|
|
259
256
|
* @param {string} rel - 工作区相对路径
|
|
260
|
-
* @param {string} head -
|
|
257
|
+
* @param {string} head - 文件内容(v0.20:整篇都进 body,与宿主一致)
|
|
261
258
|
* @param {string} [kind] - 产物类型,默认 `'code'`
|
|
262
259
|
* @returns {object} 语料记录
|
|
263
260
|
*/
|
|
@@ -275,7 +272,7 @@ function codeDoc(rel, head, kind = 'code') {
|
|
|
275
272
|
haystack: {
|
|
276
273
|
title: name.toLowerCase(),
|
|
277
274
|
summary: dir.toLowerCase(),
|
|
278
|
-
body: head.
|
|
275
|
+
body: head.toLowerCase(),
|
|
279
276
|
},
|
|
280
277
|
}
|
|
281
278
|
}
|
package/test/fixture.mjs
CHANGED
|
@@ -48,6 +48,26 @@ export function makeWorkspace(extra = []) {
|
|
|
48
48
|
const t = (base + i * 1000) / 1000
|
|
49
49
|
utimesSync(abs, t, t)
|
|
50
50
|
})
|
|
51
|
-
|
|
51
|
+
trackForCleanup(dir)
|
|
52
52
|
return dir
|
|
53
53
|
}
|
|
54
|
+
|
|
55
|
+
/**
|
|
56
|
+
* 退出时统一清理(**一个 `exit` 监听器**,不是每个工作区一个)。
|
|
57
|
+
*
|
|
58
|
+
* 以前每个工作区都挂一个监听器:单文件里造十几个工作区就会触发
|
|
59
|
+
* `MaxListenersExceededWarning`(v0.20 的 deep-eval 一次要造 6 个、
|
|
60
|
+
* 还要跑两遍确定性 → 当场撞上)。一个 `Set` + 一个监听器行为完全等价。
|
|
61
|
+
*/
|
|
62
|
+
const LIVE_DIRS = new Set()
|
|
63
|
+
let cleanupHooked = false
|
|
64
|
+
|
|
65
|
+
function trackForCleanup(dir) {
|
|
66
|
+
LIVE_DIRS.add(dir)
|
|
67
|
+
if (cleanupHooked) return
|
|
68
|
+
cleanupHooked = true
|
|
69
|
+
process.on('exit', () => {
|
|
70
|
+
for (const d of LIVE_DIRS) rmSync(d, { recursive: true, force: true })
|
|
71
|
+
LIVE_DIRS.clear()
|
|
72
|
+
})
|
|
73
|
+
}
|
package/test/harness.mjs
CHANGED
|
@@ -14,11 +14,15 @@ const CLIENT_PATH = fileURLToPath(new URL('../src/client/client.js', import.meta
|
|
|
14
14
|
/**
|
|
15
15
|
* 装一个假 window + 假 React,并把客户端模块的工厂函数取出来。
|
|
16
16
|
*
|
|
17
|
-
* @param {{primitives?: boolean}} options - `primitives: false`
|
|
18
|
-
*
|
|
17
|
+
* @param {{primitives?: boolean, noHighlighter?: boolean}} options - `primitives: false`
|
|
18
|
+
* 用来测「包整个不可用」的降级路径;`noHighlighter: true` 用来测「包在、但没导出
|
|
19
|
+
* 高亮器」的降级路径(旧版 DSH)
|
|
20
|
+
* @returns {{factory: Function, markdownCalls: object[], highlightCalls: string[]}} 工厂、
|
|
21
|
+
* MarkdownText 调用记录、高亮器收到的语言标识
|
|
19
22
|
*/
|
|
20
23
|
export function loadClientModule(options = {}) {
|
|
21
24
|
const usePrimitives = options.primitives !== false
|
|
25
|
+
const useHighlighter = usePrimitives && options.noHighlighter !== true
|
|
22
26
|
|
|
23
27
|
let captured = null
|
|
24
28
|
globalThis.window = {
|
|
@@ -38,6 +42,8 @@ export function loadClientModule(options = {}) {
|
|
|
38
42
|
}
|
|
39
43
|
|
|
40
44
|
const markdownCalls = []
|
|
45
|
+
const highlightCalls = []
|
|
46
|
+
const highlightCodes = []
|
|
41
47
|
const primitives = {
|
|
42
48
|
// ⚠️ 真身是 React.memo(...) 的产物 —— 一个**对象**,不是函数。
|
|
43
49
|
// 测试替身必须照抄这个形态,否则「typeof === 'function'」这类守卫的 bug 测不出来。
|
|
@@ -46,6 +52,27 @@ export function loadClientModule(options = {}) {
|
|
|
46
52
|
return { type: 'MarkdownText', props, children: [] }
|
|
47
53
|
}),
|
|
48
54
|
}
|
|
55
|
+
if (useHighlighter) {
|
|
56
|
+
// 形态照抄官方:hook 收**语言标识**、返回 `(code) => HighlightSpan[][]`。
|
|
57
|
+
// 逐行按空白切成若干 run、交替给两个 `--shiki-*` 颜色 —— 既能验证「逐 token 渲染」,
|
|
58
|
+
// 又能验证拼接后文本一字不差(`textOf` 会替我们比)。
|
|
59
|
+
primitives.useCodeHighlighter = function useCodeHighlighter(language) {
|
|
60
|
+
highlightCalls.push(language)
|
|
61
|
+
return (code) => {
|
|
62
|
+
// 记下**被上色的那截正文**(不是全部正文):封顶用例要断言「只把前 N 行交给
|
|
63
|
+
// 高亮器」,而这个差别在渲染结果上表现为「尾巴是纯文本」,从 span 数量看不出来。
|
|
64
|
+
highlightCodes.push(String(code))
|
|
65
|
+
return String(code).split('\n').map((line) => (
|
|
66
|
+
line === ''
|
|
67
|
+
? []
|
|
68
|
+
: line.split(/(\s+)/).filter((part) => part !== '').map((text, i) => ({
|
|
69
|
+
text,
|
|
70
|
+
style: { color: i % 2 === 0 ? 'var(--shiki-token-keyword)' : 'var(--shiki-token-plain)' },
|
|
71
|
+
}))
|
|
72
|
+
))
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
}
|
|
49
76
|
|
|
50
77
|
const requireStub = (spec) => {
|
|
51
78
|
if (spec === 'react') return globalThis.__knitReact
|
|
@@ -66,6 +93,13 @@ export function loadClientModule(options = {}) {
|
|
|
66
93
|
+ 'requestPreview, fmtDuration, readKindPref, mediaUrl, isMedia, mediaLayoutFor, '
|
|
67
94
|
+ 'nextIndexFor, docOptionId, planRowMotion, mergeGhostRows, motionAllowed, motionShift, '
|
|
68
95
|
+ 'rowLayoutPoint, applyRowFlips, '
|
|
96
|
+
// v0.20 Deep Context Retrieval:命中片段的行号区间与代码行锚点的几何。
|
|
97
|
+
+ 'fmtRange, firstMatchOf, anchorBandFor, '
|
|
98
|
+
// v0.20(2026-10-07 用户裁决):Markdown 预览的**文本锚点** —— 纯函数那半
|
|
99
|
+
// (归一化 + 取针)在这里;DOM 那半(`docAnchorHit` / `docBlockElement`)
|
|
100
|
+
// 需要真 document,走真机验证,不进这个替身。
|
|
101
|
+
+ 'docNeedleText, docAnchorNeedles, docPickOffset, scrollToDocAnchor, DocPane, '
|
|
102
|
+
+ 'DOC_NEEDLE_CHARS, DOC_NEEDLE_MIN, DOC_NEEDLE_MAX, '
|
|
69
103
|
+ 'MOTION_ENTER_MS, MOTION_EXIT_MS, MOTION_STAGGER_MS, MOTION_STAGGER_MAX, MOTION_EASE, '
|
|
70
104
|
+ 'MOTION_MOVE_MS, MOTION_MOVE_EPS, '
|
|
71
105
|
// ⚠️ 右栏那套名字(clampPackW / clampFloatPos / nearRightEdge / PACK_*)已随
|
|
@@ -86,6 +120,8 @@ export function loadClientModule(options = {}) {
|
|
|
86
120
|
factory: captured.factory,
|
|
87
121
|
registration: captured,
|
|
88
122
|
markdownCalls,
|
|
123
|
+
highlightCalls,
|
|
124
|
+
highlightCodes,
|
|
89
125
|
exports: captured.factory(requireStub),
|
|
90
126
|
}
|
|
91
127
|
}
|
|
@@ -99,6 +135,8 @@ export function createHarness() {
|
|
|
99
135
|
let hookStates = []
|
|
100
136
|
let hookIdx = 0
|
|
101
137
|
let pendingEffects = []
|
|
138
|
+
// 「状态真的被写了几次」—— 与渲染次数无关的语义级观测量(见 useState 里的说明)。
|
|
139
|
+
let stateWrites = 0
|
|
102
140
|
|
|
103
141
|
const React = {
|
|
104
142
|
// ⚠️ children 必须**递归摊平**(真实 React 也会摊平数组)。
|
|
@@ -117,7 +155,16 @@ export function createHarness() {
|
|
|
117
155
|
useState(init) {
|
|
118
156
|
const i = hookIdx++
|
|
119
157
|
if (!(i in hookStates)) hookStates[i] = typeof init === 'function' ? init() : init
|
|
120
|
-
|
|
158
|
+
// ⚠️ 真 React 对 setState 的值先比一次 `Object.is`:**原样返回同一个对象 ⇒ 整棵子树
|
|
159
|
+
// 不重渲染**(v0.20 轮询去重就靠这条)。替身因此只在「值真的换了」时才写槽位,并把
|
|
160
|
+
// 写入次数记下来 —— 让「同样的载荷不该落状态」这类守卫**可证伪**(旧代码每 5 s 落一个
|
|
161
|
+
// 新对象,计数必然增长)。
|
|
162
|
+
return [hookStates[i], (v) => {
|
|
163
|
+
const next = typeof v === 'function' ? v(hookStates[i]) : v
|
|
164
|
+
if (Object.is(next, hookStates[i])) return
|
|
165
|
+
stateWrites += 1
|
|
166
|
+
hookStates[i] = next
|
|
167
|
+
}]
|
|
121
168
|
},
|
|
122
169
|
useCallback: (fn) => fn,
|
|
123
170
|
useEffect: (fn) => { pendingEffects.push(fn) },
|
|
@@ -147,7 +194,19 @@ export function createHarness() {
|
|
|
147
194
|
|
|
148
195
|
return {
|
|
149
196
|
/** 重置 hook 槽位,供每个用例独立开始。 */
|
|
150
|
-
reset() {
|
|
197
|
+
reset() {
|
|
198
|
+
hookStates = []
|
|
199
|
+
hookIdx = 0
|
|
200
|
+
pendingEffects = []
|
|
201
|
+
stateWrites = 0
|
|
202
|
+
// ⚠️ 定时器也要清:轮询链会自己续命(`setTimeout` 排下一轮),而替身从不跑 effect
|
|
203
|
+
// 的 cleanup —— 上一个用例留下的链会在下一个用例的 `tick()` 里醒来,把它那份旧载荷
|
|
204
|
+
// 写进**共用**的 hook 槽位(换掉别人的 state)。真机不会这样:每个实例有自己的
|
|
205
|
+
// state,卸载即停表。
|
|
206
|
+
timers.clear()
|
|
207
|
+
},
|
|
208
|
+
/** 状态真被写了几次(同一个对象原样返回不算)。 */
|
|
209
|
+
stateWrites() { return stateWrites },
|
|
151
210
|
/** 预置 useState 的初值(按 hook 调用顺序)。 */
|
|
152
211
|
seed(values) { hookStates = values.slice() },
|
|
153
212
|
/**
|
package/test/host.test.mjs
CHANGED
|
@@ -247,7 +247,7 @@ test('rankByRelevance: 没有关键词时全部 0 分且不打乱顺序', () =>
|
|
|
247
247
|
|
|
248
248
|
/* ── v0.6:BM25 的三条新行为 ─────────────────────────── */
|
|
249
249
|
|
|
250
|
-
/** 造一条文档:haystack
|
|
250
|
+
/** 造一条文档:haystack 口径与宿主一致(v0.20:整篇正文转小写,不再截窗口)。 */
|
|
251
251
|
function bm25Doc(rel, { title = '', summary = '', body = '' }, mtimeMs) {
|
|
252
252
|
return {
|
|
253
253
|
rel,
|
|
@@ -255,7 +255,7 @@ function bm25Doc(rel, { title = '', summary = '', body = '' }, mtimeMs) {
|
|
|
255
255
|
haystack: {
|
|
256
256
|
title: title.toLowerCase(),
|
|
257
257
|
summary: summary.toLowerCase(),
|
|
258
|
-
body: body.
|
|
258
|
+
body: body.toLowerCase(),
|
|
259
259
|
},
|
|
260
260
|
}
|
|
261
261
|
}
|
package/test/icon.test.mjs
CHANGED
|
@@ -82,18 +82,21 @@ test('图标:内联的 path 与 assets 里的源文件逐字一致', () => {
|
|
|
82
82
|
)
|
|
83
83
|
})
|
|
84
84
|
|
|
85
|
-
/* ──
|
|
85
|
+
/* ── 配色(2026-10-07 用户改口:不再自己写死黑白,**走 DSH 官方主文本色令牌**)── */
|
|
86
86
|
|
|
87
|
-
test('
|
|
87
|
+
test('配色:跟随 DSH 主文本色令牌,不写死 #000 / #fff', () => {
|
|
88
88
|
assert.match(
|
|
89
89
|
CLIENT_SOURCE,
|
|
90
|
-
/\.knit-icon\s*\{\s*color:\s*#
|
|
91
|
-
'
|
|
90
|
+
/\.knit-icon\s*\{\s*color:\s*var\(--dsw-alias-label-primary,\s*#0f1115\)\s*\}/,
|
|
91
|
+
'图标配色必须走 DSH 的主文本色令牌(浅 #0f1115 / 暗 #f9fafb 由令牌自己切)',
|
|
92
92
|
)
|
|
93
|
-
assert.
|
|
94
|
-
CLIENT_SOURCE,
|
|
95
|
-
|
|
96
|
-
|
|
93
|
+
assert.ok(
|
|
94
|
+
!/data-ds-dark-theme[^{]*\.knit-icon/.test(CLIENT_SOURCE),
|
|
95
|
+
'不该再有暗色覆盖规则:令牌已经随主题切,多写一条就是自己造的一套',
|
|
96
|
+
)
|
|
97
|
+
assert.ok(
|
|
98
|
+
!/\.knit-icon\s*\{\s*color:\s*#(?:000|fff)\s*\}/.test(CLIENT_SOURCE),
|
|
99
|
+
'不许写死 #000 / #fff(暗色的 #fff 比官方 #f9fafb 还亮)',
|
|
97
100
|
)
|
|
98
101
|
})
|
|
99
102
|
|