dsh-knit 0.19.0 → 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 +285 -0
- package/README.en.md +298 -217
- package/README.md +184 -113
- package/SECURITY.md +2 -2
- package/package.json +7 -3
- 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
package/test/context/fixture.mjs
CHANGED
|
@@ -24,9 +24,6 @@
|
|
|
24
24
|
* 检索评测集只需要小写 haystack,不带原文 —— 它的被测对象是打分器,不需要引用图。
|
|
25
25
|
*/
|
|
26
26
|
|
|
27
|
-
/** 与宿主一致的正文截断长度(`HAYSTACK_CHARS`)。 */
|
|
28
|
-
const HAYSTACK_CHARS = 2500
|
|
29
|
-
|
|
30
27
|
/** 固定的「现在」,让评测完全确定。 */
|
|
31
28
|
export const NOW = 1_760_000_000_000
|
|
32
29
|
|
|
@@ -37,7 +34,7 @@ const SHARED_MTIME = NOW - 60_000
|
|
|
37
34
|
* 造一条文档记录。
|
|
38
35
|
*
|
|
39
36
|
* haystack 口径严格照抄宿主(`src/host/index.js` 的 `readDoc`):
|
|
40
|
-
*
|
|
37
|
+
* **整篇正文转小写**(v0.20 起不再截前 2500 字)。
|
|
41
38
|
*
|
|
42
39
|
* @param {string} rel - 工作区相对路径
|
|
43
40
|
* @param {{title: string, summary?: string, body?: string}} doc - 三段文本
|
|
@@ -56,7 +53,7 @@ function make(rel, { title, summary = '', body = '' }) {
|
|
|
56
53
|
haystack: {
|
|
57
54
|
title: title.toLowerCase(),
|
|
58
55
|
summary: summary.toLowerCase(),
|
|
59
|
-
body: body.
|
|
56
|
+
body: body.toLowerCase(),
|
|
60
57
|
},
|
|
61
58
|
}
|
|
62
59
|
}
|
|
@@ -0,0 +1,447 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* v0.20 Deep Context Retrieval:**内容片段层**测试。
|
|
3
|
+
*
|
|
4
|
+
* 需求 §21 点名了 12 个用例(本文件逐条对应,外加一条 §17 的媒体反例)。
|
|
5
|
+
* 两件事与其它测试文件不同,是刻意的:
|
|
6
|
+
*
|
|
7
|
+
* 1. **不动 v0.19 的基线。** `test/eval.test.mjs` / `test/context-eval.test.mjs`
|
|
8
|
+
* 一行都没改(§22)。要证明「窗口打开后确实更准」,用的是本文件里的
|
|
9
|
+
* `deep-document.md` 回归(§14),不是把旧断言改松。
|
|
10
|
+
* 2. **断言「片段覆盖了目标行」而不是「片段等于某个范围」。** 切分口径以后可以调,
|
|
11
|
+
* 但「命中行必须落在报出去的行区间里」这条永远成立 —— 断言它才有意义。
|
|
12
|
+
*
|
|
13
|
+
* 跑法:node --test test/
|
|
14
|
+
*/
|
|
15
|
+
import test from 'node:test'
|
|
16
|
+
import assert from 'node:assert/strict'
|
|
17
|
+
import { writeFileSync } from 'node:fs'
|
|
18
|
+
import { join } from 'node:path'
|
|
19
|
+
|
|
20
|
+
import { scan, publicScanPayload } from '../src/host/index.js'
|
|
21
|
+
import { buildContext } from '../src/host/context.js'
|
|
22
|
+
import {
|
|
23
|
+
chunkText,
|
|
24
|
+
passageMatchesFor,
|
|
25
|
+
windowTf,
|
|
26
|
+
PASSAGE_MAX_PER_FILE,
|
|
27
|
+
PASSAGE_WINDOW,
|
|
28
|
+
SNIPPET_CHARS,
|
|
29
|
+
} from '../src/host/passage.js'
|
|
30
|
+
import { makeWorkspace } from './fixture.mjs'
|
|
31
|
+
|
|
32
|
+
/** 测试用稀有词:不会自然出现,于是「命中」一定是这一条造出来的。 */
|
|
33
|
+
const KEY = 'zephyrite'
|
|
34
|
+
|
|
35
|
+
/** 一行与任务无关的正文(长度稳定,便于推算字符位置)。 */
|
|
36
|
+
function noiseLine(i) {
|
|
37
|
+
return `无关内容第 ${i} 行:这一段与查询词毫无关系,只是把目标词推到更靠后的位置去。`
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
/** 与任务无关的 n 行。 */
|
|
41
|
+
function noise(n) {
|
|
42
|
+
const out = []
|
|
43
|
+
for (let i = 0; i < n; i++) out.push(noiseLine(i + 1))
|
|
44
|
+
return out
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
/** 逗号友好的拼接:`lines('a', ['b','c'])` → `'a\nb\nc'`。 */
|
|
48
|
+
function lines(...parts) {
|
|
49
|
+
return parts.flat().join('\n')
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
/**
|
|
53
|
+
* 以显式 query 走相关性排序扫一遍(不依赖任何会话事件)。
|
|
54
|
+
* @param {string} root - 工作区
|
|
55
|
+
* @param {string} query - 查询词
|
|
56
|
+
* @param {object} [options] - 透传给 `scan()`(`kind` 等)
|
|
57
|
+
*/
|
|
58
|
+
async function relevanceScan(root, query, options = {}) {
|
|
59
|
+
return scan(root, 50, { sort: 'relevance', query, ...options })
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
/** 从公开载荷里取一条记录(找不到就是失败,别让 `?.` 把断言吞掉)。 */
|
|
63
|
+
function pick(payload, rel) {
|
|
64
|
+
const hit = payload.docs.find((d) => d.rel === rel)
|
|
65
|
+
assert.ok(hit, `载荷里必须有 ${rel}`)
|
|
66
|
+
return hit
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
test('deep-context ①:命中词在文件头部 → 片段指回头部', async () => {
|
|
70
|
+
const body = lines('# 头部命中', '', `${KEY} 出现在第三行。`, noise(40))
|
|
71
|
+
const root = makeWorkspace([['head.md', body]])
|
|
72
|
+
const payload = await relevanceScan(root, KEY)
|
|
73
|
+
|
|
74
|
+
const hit = pick(payload, 'head.md')
|
|
75
|
+
assert.equal(hit.matches.length, 1)
|
|
76
|
+
// 首段从第 1 行开始,且覆盖第 3 行 —— 这就是「指回头部」的可验证形式。
|
|
77
|
+
assert.equal(hit.matches[0].startLine, 1)
|
|
78
|
+
assert.ok(hit.matches[0].endLine >= 3, '片段必须覆盖目标行')
|
|
79
|
+
assert.deepEqual(hit.matches[0].terms, [KEY])
|
|
80
|
+
assert.match(hit.matches[0].snippet, new RegExp(KEY))
|
|
81
|
+
assert.ok(hit.score > 0, '头部命中必须真的拿到分')
|
|
82
|
+
})
|
|
83
|
+
|
|
84
|
+
test('deep-context ②:命中词在文件中间 → 片段落在中间段', async () => {
|
|
85
|
+
const L = ['# 中间命中', '']
|
|
86
|
+
L.push(...noise(30))
|
|
87
|
+
L.push(`这里提到 ${KEY}。`)
|
|
88
|
+
const keyLine = L.length
|
|
89
|
+
L.push(...noise(30))
|
|
90
|
+
const root = makeWorkspace([['mid.md', L.join('\n')]])
|
|
91
|
+
const payload = await relevanceScan(root, KEY)
|
|
92
|
+
|
|
93
|
+
const m = pick(payload, 'mid.md').matches[0]
|
|
94
|
+
assert.ok(m.startLine > 1, '不该是首段')
|
|
95
|
+
assert.ok(m.startLine <= keyLine && keyLine <= m.endLine,
|
|
96
|
+
`片段必须覆盖第 ${keyLine} 行,实际 ${m.startLine}-${m.endLine}`)
|
|
97
|
+
})
|
|
98
|
+
|
|
99
|
+
test('deep-context ③:命中词在文件尾部 → 片段落在尾段', async () => {
|
|
100
|
+
const L = ['# 尾部命中', '']
|
|
101
|
+
L.push(...noise(60))
|
|
102
|
+
L.push(`结尾之前提到 ${KEY}。`)
|
|
103
|
+
const keyLine = L.length
|
|
104
|
+
const root = makeWorkspace([['tail.md', L.join('\n')]])
|
|
105
|
+
const payload = await relevanceScan(root, KEY)
|
|
106
|
+
|
|
107
|
+
const m = pick(payload, 'tail.md').matches[0]
|
|
108
|
+
assert.ok(m.startLine <= keyLine && keyLine <= m.endLine,
|
|
109
|
+
`片段必须覆盖第 ${keyLine} 行,实际 ${m.startLine}-${m.endLine}`)
|
|
110
|
+
assert.ok(m.endLine > 40, '尾部命中不该被报成开头那段')
|
|
111
|
+
})
|
|
112
|
+
|
|
113
|
+
test('deep-context ④:目标词只出现在第 2500 字之后(v0.20 的核心回归,§14)', async () => {
|
|
114
|
+
// 前 2500 字全是无关内容 —— v0.19 只对前 2500 字建 haystack,这个词根本不可见。
|
|
115
|
+
const lead = noise(70) // ≈ 2900 字符
|
|
116
|
+
const keyLine = lead.length + 1
|
|
117
|
+
const body = lines('# 深文档', '', lead, `目标词 ${KEY} 藏在很后面。`)
|
|
118
|
+
const root = makeWorkspace([['deep-document.md', body]])
|
|
119
|
+
|
|
120
|
+
// 先证明「旧窗口确实看不到」:这不是装饰性断言,它是这一版存在的理由。
|
|
121
|
+
assert.ok(body.length > 2500, '样本必须长过旧窗口')
|
|
122
|
+
assert.equal(body.slice(0, 2500).toLowerCase().includes(KEY), false,
|
|
123
|
+
'前 2500 字里不许出现目标词(否则这条回归就白做了)')
|
|
124
|
+
|
|
125
|
+
const payload = await relevanceScan(root, KEY)
|
|
126
|
+
const hit = pick(payload, 'deep-document.md')
|
|
127
|
+
assert.ok(hit.score > 0, 'v0.20 必须能找到旧窗口之外的目标词')
|
|
128
|
+
const m = hit.matches[0]
|
|
129
|
+
// 片段本身可以从 2500 字之前**起**(切分口径不是断言对象),
|
|
130
|
+
// 但它必须**延伸到窗口之后**并且覆盖目标行 —— 这才是「找到了窗口外的东西」。
|
|
131
|
+
assert.ok(m.endOffset > 2500, `命中片段必须延伸到 2500 字之后,实际 endOffset ${m.endOffset}`)
|
|
132
|
+
assert.ok(m.startLine <= keyLine && keyLine <= m.endLine, '片段必须覆盖目标行')
|
|
133
|
+
assert.match(m.snippet, new RegExp(KEY))
|
|
134
|
+
})
|
|
135
|
+
|
|
136
|
+
test('deep-context ⑤:一篇文件命中多段 → 最多报 2 段,按行号升序', async () => {
|
|
137
|
+
// 目标行号一律**由数组自己算**(`L.push` 之后 `L.length` 就是刚推入那行的行号):
|
|
138
|
+
// 手算行号漏掉一个空行就会写下一条假断言,而这条测试的价值全在行号上。
|
|
139
|
+
const L = ['# 多段命中', '']
|
|
140
|
+
L.push(...noise(20))
|
|
141
|
+
L.push(`第一处 ${KEY}。`)
|
|
142
|
+
const firstKey = L.length
|
|
143
|
+
L.push(...noise(40))
|
|
144
|
+
L.push(`第二处又提到 ${KEY}。`)
|
|
145
|
+
const secondKey = L.length
|
|
146
|
+
L.push(...noise(6))
|
|
147
|
+
const root = makeWorkspace([['multi.md', L.join('\n')]])
|
|
148
|
+
const payload = await relevanceScan(root, KEY)
|
|
149
|
+
|
|
150
|
+
const matches = pick(payload, 'multi.md').matches
|
|
151
|
+
assert.equal(matches.length, PASSAGE_MAX_PER_FILE)
|
|
152
|
+
assert.ok(matches[0].startLine <= firstKey && firstKey <= matches[0].endLine,
|
|
153
|
+
`第 1 段必须覆盖第 ${firstKey} 行,实际 ${matches[0].startLine}-${matches[0].endLine}`)
|
|
154
|
+
assert.ok(matches[1].startLine <= secondKey && secondKey <= matches[1].endLine,
|
|
155
|
+
`第 2 段必须覆盖第 ${secondKey} 行,实际 ${matches[1].startLine}-${matches[1].endLine}`)
|
|
156
|
+
assert.ok(matches[0].endLine < matches[1].startLine, '两段不能重叠,且按行号升序')
|
|
157
|
+
for (const m of matches) {
|
|
158
|
+
assert.deepEqual(m.terms, [KEY])
|
|
159
|
+
assert.match(m.snippet, new RegExp(KEY))
|
|
160
|
+
}
|
|
161
|
+
})
|
|
162
|
+
|
|
163
|
+
test('deep-context ⑥:多文件多段 → 每篇各自带自己的片段', async () => {
|
|
164
|
+
const root = makeWorkspace([
|
|
165
|
+
['docs/a.md', lines('# A', '', noise(25), `A 提到 ${KEY}。`)],
|
|
166
|
+
['docs/b.md', lines('# B', '', `B 开头就提到 ${KEY}。`, noise(25))],
|
|
167
|
+
['docs/c.md', lines('# C', '', noise(12), `C 中间提到 ${KEY}。`, noise(12))],
|
|
168
|
+
])
|
|
169
|
+
const payload = await relevanceScan(root, KEY)
|
|
170
|
+
|
|
171
|
+
const rels = payload.docs.filter((d) => d.score > 0).map((d) => d.rel)
|
|
172
|
+
assert.deepEqual(rels.slice().sort(), ['docs/a.md', 'docs/b.md', 'docs/c.md'])
|
|
173
|
+
for (const rel of rels) {
|
|
174
|
+
const hit = pick(payload, rel)
|
|
175
|
+
assert.ok(hit.matches.length >= 1, `${rel} 必须带片段`)
|
|
176
|
+
assert.ok(hit.matches[0].terms.includes(KEY))
|
|
177
|
+
}
|
|
178
|
+
})
|
|
179
|
+
|
|
180
|
+
test('deep-context ⑦:同样命中两次时,长文件不许因长度占优(§9)', async () => {
|
|
181
|
+
// 60KB 的归档:目标词出现 2 次,但埋在噪声里。
|
|
182
|
+
const archive = []
|
|
183
|
+
archive.push('# 归档变更')
|
|
184
|
+
for (let i = 0; i < 500; i++) archive.push(noiseLine(i + 1))
|
|
185
|
+
archive.push(`顺带提到 ${KEY}。`)
|
|
186
|
+
for (let i = 0; i < 500; i++) archive.push(noiseLine(i + 1000))
|
|
187
|
+
archive.push(`又一次提到 ${KEY}。`)
|
|
188
|
+
// 300 字左右的聚焦文档:目标词同样出现 2 次。
|
|
189
|
+
const focus = lines('# 聚焦', '', '配置说明如下。', `${KEY} 是主开关。`, `再写一遍 ${KEY}。`, noise(3))
|
|
190
|
+
|
|
191
|
+
const root = makeWorkspace([['archive/CHANGELOG.md', lines(archive)], ['docs/focus.md', focus]])
|
|
192
|
+
const payload = await relevanceScan(root, KEY)
|
|
193
|
+
|
|
194
|
+
const order = payload.docs.filter((d) => d.score > 0).map((d) => d.rel)
|
|
195
|
+
assert.deepEqual(order, ['docs/focus.md', 'archive/CHANGELOG.md'],
|
|
196
|
+
'长度归一化必须让聚焦短文排在长归档之前')
|
|
197
|
+
})
|
|
198
|
+
|
|
199
|
+
test('deep-context ⑧:代码命中落在函数附近', async () => {
|
|
200
|
+
// alpha 必须**够长**(超过 PASSAGE_MIN_CHARS / 300 字),否则前几节会被
|
|
201
|
+
// 合并规则并进 beta 那一段,片段就从文件头开始了 —— 那是切分口径,不是缺陷。
|
|
202
|
+
const L = [
|
|
203
|
+
"import { readFile } from 'node:fs/promises'",
|
|
204
|
+
'',
|
|
205
|
+
'const LIMIT = 100',
|
|
206
|
+
'',
|
|
207
|
+
'/** 甲函数:把输入规整一遍再交出去。 */',
|
|
208
|
+
'export function alpha(n) {',
|
|
209
|
+
' const step = n + LIMIT',
|
|
210
|
+
" const padded = String(step).padStart(6, '0')",
|
|
211
|
+
' const parts = padded.split("")',
|
|
212
|
+
" const reversed = parts.reverse().join('-')",
|
|
213
|
+
' const upper = reversed.toUpperCase()',
|
|
214
|
+
' const again = upper.split("-").join("")',
|
|
215
|
+
' return again.length > 0 ? again : padded',
|
|
216
|
+
'}',
|
|
217
|
+
'',
|
|
218
|
+
'/** 乙函数:这里用到了目标词。 */',
|
|
219
|
+
'export function beta(n) {',
|
|
220
|
+
` const label = '${KEY}-' + n`,
|
|
221
|
+
' return label.toUpperCase()',
|
|
222
|
+
'}',
|
|
223
|
+
'',
|
|
224
|
+
'/** 丙函数。 */',
|
|
225
|
+
'export function gamma(n) {',
|
|
226
|
+
' return n - 1',
|
|
227
|
+
'}',
|
|
228
|
+
]
|
|
229
|
+
const betaStart = L.findIndex((l) => l.includes('乙函数')) + 1
|
|
230
|
+
const keyLine = L.findIndex((l) => l.includes(KEY)) + 1
|
|
231
|
+
const root = makeWorkspace([['src/target.mjs', L.join('\n')]])
|
|
232
|
+
const payload = await relevanceScan(root, KEY, { kind: 'code' })
|
|
233
|
+
|
|
234
|
+
const hit = pick(payload, 'src/target.mjs')
|
|
235
|
+
const m = hit.matches[0]
|
|
236
|
+
assert.ok(m.startLine <= keyLine && keyLine <= m.endLine,
|
|
237
|
+
`片段必须覆盖第 ${keyLine} 行,实际 ${m.startLine}-${m.endLine}`)
|
|
238
|
+
assert.ok(m.startLine >= betaStart,
|
|
239
|
+
`结构化切分应让片段从 beta 那一节开始(第 ${betaStart} 行),实际从第 ${m.startLine} 行开始`)
|
|
240
|
+
assert.ok(m.endLine <= L.length)
|
|
241
|
+
assert.match(m.snippet, new RegExp(KEY))
|
|
242
|
+
})
|
|
243
|
+
|
|
244
|
+
test('deep-context ⑨:Markdown 命中贴着 heading 分段', async () => {
|
|
245
|
+
const L = ['# 顶层', '', '## 概览', '']
|
|
246
|
+
L.push(...noise(8))
|
|
247
|
+
L.push('', '## 配置项', '')
|
|
248
|
+
const headLine = L.length - 1 // 刚推入的是 ['', '## 配置项', ''],标题在倒数第二个
|
|
249
|
+
L.push(`这一段讲的正是 ${KEY} 的配置方式。`)
|
|
250
|
+
const keyLine = L.length
|
|
251
|
+
L.push('', ...noise(8))
|
|
252
|
+
|
|
253
|
+
const root = makeWorkspace([['docs/config.md', L.join('\n')]])
|
|
254
|
+
const payload = await relevanceScan(root, KEY)
|
|
255
|
+
|
|
256
|
+
const m = pick(payload, 'docs/config.md').matches[0]
|
|
257
|
+
// 结构优先:片段**从标题那一行开始**(而不是从上一个段落的中途)。
|
|
258
|
+
assert.equal(m.startLine, headLine, '片段应当从 heading 起算')
|
|
259
|
+
assert.ok(m.startLine <= keyLine && keyLine <= m.endLine,
|
|
260
|
+
`片段必须覆盖第 ${keyLine} 行,实际 ${m.startLine}-${m.endLine}`)
|
|
261
|
+
})
|
|
262
|
+
|
|
263
|
+
test('deep-context ⑩:零命中时没有片段,也没有编造出来的分', async () => {
|
|
264
|
+
const root = makeWorkspace([['docs/empty.md', lines('# 无关', '', noise(30))]])
|
|
265
|
+
const payload = await relevanceScan(root, KEY)
|
|
266
|
+
|
|
267
|
+
assert.equal(payload.mode, 'relevance', '有关键词就还是相关性模式')
|
|
268
|
+
assert.deepEqual(payload.keywords, [], '语料里没有这个词,matched 必须是空的')
|
|
269
|
+
for (const d of payload.docs) {
|
|
270
|
+
assert.equal('matches' in d, false, `${d.rel} 不该带 matches 键`)
|
|
271
|
+
assert.equal(d.score, 0)
|
|
272
|
+
}
|
|
273
|
+
})
|
|
274
|
+
|
|
275
|
+
test('deep-context ⑪:同分时按行号稳定排序,且两次跑逐字相同(§20)', async () => {
|
|
276
|
+
// 两段**字节数完全相同**的文本(甲/乙 都是 1 个字符),于是分数必然相同。
|
|
277
|
+
const block = (name) => [`## ${name}`, '', ...noise(9), `这里提到 ${KEY}。`, ...noise(2)]
|
|
278
|
+
const body = lines(block('甲'), block('乙'))
|
|
279
|
+
|
|
280
|
+
const keywords = [{ term: KEY, weight: 1 }]
|
|
281
|
+
const entry = { body, kind: 'md', rel: 'same.md', mtimeMs: 1 }
|
|
282
|
+
const first = passageMatchesFor(entry, keywords, 1)
|
|
283
|
+
const second = passageMatchesFor(entry, keywords, 1)
|
|
284
|
+
|
|
285
|
+
assert.equal(first.length, 2)
|
|
286
|
+
assert.ok(first[0].endLine < first[1].startLine, '同分时按行号升序')
|
|
287
|
+
assert.deepEqual(first, second, '同一输入必须两次逐字相同')
|
|
288
|
+
|
|
289
|
+
// 反证:把输入顺序颠倒,结果不许变(并列排序不许依赖输入顺序)。
|
|
290
|
+
const reordered = passageMatchesFor(
|
|
291
|
+
{ ...entry, body: lines(block('乙'), block('甲')) },
|
|
292
|
+
keywords,
|
|
293
|
+
1,
|
|
294
|
+
)
|
|
295
|
+
assert.deepEqual(first.map((m) => m.terms), reordered.map((m) => m.terms))
|
|
296
|
+
})
|
|
297
|
+
|
|
298
|
+
test('deep-context ⑫:文件改动后片段缓存失效,行号跟着变', async () => {
|
|
299
|
+
const root = makeWorkspace([['shift.md', lines('# 位移', '', `${KEY} 在最前面。`, noise(30))]])
|
|
300
|
+
const before = await relevanceScan(root, KEY)
|
|
301
|
+
const firstLine = pick(before, 'shift.md').matches[0].startLine
|
|
302
|
+
|
|
303
|
+
// 重写:把目标词挪到后面(mtime 由 fixture 定在 2 分钟前,写盘必然更新)。
|
|
304
|
+
const movedLines = ['# 位移', '', ...noise(40), `${KEY} 挪到了后面。`]
|
|
305
|
+
const keyLine = movedLines.length
|
|
306
|
+
writeFileSync(join(root, 'shift.md'), movedLines.join('\n'))
|
|
307
|
+
const after = await relevanceScan(root, KEY)
|
|
308
|
+
const moved = pick(after, 'shift.md').matches[0]
|
|
309
|
+
|
|
310
|
+
assert.ok(moved.startLine > firstLine, `行号必须跟着文件改动走:${firstLine} → ${moved.startLine}`)
|
|
311
|
+
assert.ok(moved.startLine <= keyLine && keyLine <= moved.endLine,
|
|
312
|
+
`片段必须覆盖第 ${keyLine} 行,实际 ${moved.startLine}-${moved.endLine}`)
|
|
313
|
+
})
|
|
314
|
+
|
|
315
|
+
test('deep-context ⑬:媒体不参与片段检索(§17)', async () => {
|
|
316
|
+
const root = makeWorkspace([['docs/zephyrite-shot.png', Buffer.from([0x89, 0x50, 0x4e, 0x47])]])
|
|
317
|
+
const payload = await relevanceScan(root, KEY, { kind: 'all' })
|
|
318
|
+
|
|
319
|
+
const media = payload.docs.find((d) => d.rel === 'docs/zephyrite-shot.png')
|
|
320
|
+
assert.ok(media, '文件名命中时媒体仍进列表(v0.19 行为)')
|
|
321
|
+
assert.equal('matches' in media, false, '媒体没有正文,不许有片段')
|
|
322
|
+
})
|
|
323
|
+
|
|
324
|
+
test('deep-context ⑭:片段的行号与偏移量恒等式成立(§11)', () => {
|
|
325
|
+
const body = lines('# 标题', '', noise(30), `中间提到 ${KEY}。`, noise(30), `后面又提到 ${KEY}。`)
|
|
326
|
+
const { passages } = chunkText(body, { kind: 'md' })
|
|
327
|
+
assert.ok(passages.length > 1, '样本必须被切成多段')
|
|
328
|
+
for (const p of passages) {
|
|
329
|
+
assert.equal(body.slice(p.startOffset, p.endOffset), p.text, '偏移量必须能切回原文')
|
|
330
|
+
assert.equal(p.body, p.text.toLowerCase())
|
|
331
|
+
assert.ok(p.startLine >= 1 && p.endLine >= p.startLine)
|
|
332
|
+
}
|
|
333
|
+
})
|
|
334
|
+
|
|
335
|
+
test('deep-context ⑮:windowTf 只数「同一个窗口里」的出现次数(D5 的长度无关量)', () => {
|
|
336
|
+
// 不重叠计数(与 relevance.js 的 countOccurrences 同口径):'aa' 在 'aaaa' 里是 2 次而不是 3 次
|
|
337
|
+
assert.equal(windowTf('aaaa', 'aa', 4), 2)
|
|
338
|
+
assert.equal(windowTf('aaaa', 'aa', 3), 1, '窗口放不下两处时只能算 1 次')
|
|
339
|
+
|
|
340
|
+
// 两处相隔 102 个字符:窗口 200 装得下,收紧到 50 就只剩一处
|
|
341
|
+
const spread = `${'x'.repeat(100)}zz${'x'.repeat(100)}zz`
|
|
342
|
+
assert.equal(windowTf(spread, 'zz', 200), 2)
|
|
343
|
+
assert.equal(windowTf(spread, 'zz', 50), 1)
|
|
344
|
+
|
|
345
|
+
// 真实场景:29000 字的归档里出现两次 ⇒ 每次都是孤立的
|
|
346
|
+
const huge = `${'x'.repeat(14000)}${KEY}${'x'.repeat(14000)}${KEY}`
|
|
347
|
+
assert.equal(windowTf(huge, KEY, 1200), 1, '窗口 1200 只看得见一处')
|
|
348
|
+
assert.equal(windowTf(huge, KEY, 40000), 2, '窗口拉到比文件还长就看得见两处')
|
|
349
|
+
|
|
350
|
+
// 边界:空正文、空词都必须是 0 而不是 NaN
|
|
351
|
+
assert.equal(windowTf('', 'zz'), 0)
|
|
352
|
+
assert.equal(windowTf('zz', ''), 0)
|
|
353
|
+
})
|
|
354
|
+
|
|
355
|
+
test('deep-context ⑯:长归档不许靠整篇字频混进 Supporting(§9 / D5)', async () => {
|
|
356
|
+
// 归档:两处 KEY 相隔约 4 万字 —— 整篇字频 2 次(旧口径「够格」),单窗口只有 1 次
|
|
357
|
+
const archive = ['# 归档变更']
|
|
358
|
+
for (let i = 0; i < 300; i++) archive.push(noiseLine(i + 1))
|
|
359
|
+
archive.push(`顺带提到 ${KEY}。`)
|
|
360
|
+
for (let i = 0; i < 900; i++) archive.push(noiseLine(i + 1000))
|
|
361
|
+
archive.push(`又一次提到 ${KEY}。`)
|
|
362
|
+
|
|
363
|
+
const root = makeWorkspace([
|
|
364
|
+
['archive/CHANGELOG.md', lines(archive)],
|
|
365
|
+
// 聚焦短文:标题就命中(grounded ⇒ 够格进 Primary)
|
|
366
|
+
['docs/focus.md', lines(`# ${KEY} 配置`, '', `${KEY} 只在这里提一次。`)],
|
|
367
|
+
// 正文命中但标题不命中:只有 isDocHit 这一条路能让它进 Supporting
|
|
368
|
+
// (首段必须与命中词无关,否则摘要会命中 ⇒ grounded ⇒ 走的是另一条路)
|
|
369
|
+
['docs/notes.md', lines('# 随手记', '', '这一篇讲的是别的事情。', '', `${KEY} 与 ${KEY} 都在这一段里。`)],
|
|
370
|
+
])
|
|
371
|
+
const payload = await relevanceScan(root, KEY)
|
|
372
|
+
|
|
373
|
+
// 第一层保证(文件级):长度归一化让聚焦短文排第一,长归档排后面
|
|
374
|
+
assert.equal(payload.docs[0].rel, 'docs/focus.md')
|
|
375
|
+
|
|
376
|
+
// 第二层保证(分层):同一段里出现两次才算「这一篇在讲它」
|
|
377
|
+
const pack = buildContext({ ranked: payload.ranked, topic: payload.topic, total: payload.total })
|
|
378
|
+
const rels = (tier) => tier.map((e) => e.rel)
|
|
379
|
+
assert.deepEqual(rels(pack.primary), ['docs/focus.md'])
|
|
380
|
+
assert.ok(
|
|
381
|
+
rels(pack.supporting).includes('docs/notes.md'),
|
|
382
|
+
'同一段里出现两次的词必须能把这一篇抬进 Supporting(否则这条用例只是「什么都不放行」)',
|
|
383
|
+
)
|
|
384
|
+
assert.equal(
|
|
385
|
+
rels(pack.supporting).includes('archive/CHANGELOG.md'),
|
|
386
|
+
false,
|
|
387
|
+
'两处散布在 4 万字里 ⇒ 单窗口只有 1 次,不许进 Supporting',
|
|
388
|
+
)
|
|
389
|
+
})
|
|
390
|
+
|
|
391
|
+
test('R2 面板预算:/api/recent 的片段增量有界 —— ≤24 篇、每篇 ≤2 段、片段 ≤SNIPPET_CHARS+8', async () => {
|
|
392
|
+
// 需求 §16:进上下文的要更精准、不是更多。面板载荷走的是本地 HTTP,不进模型上下文,
|
|
393
|
+
// 但它仍然是**每一篇都可能被拼进去**的东西(`docs` 数组),所以同样要有上界。
|
|
394
|
+
//
|
|
395
|
+
// 实现说明 §7 的 R2 估算「≤10 KB / 每段 ~220 B」偏低了(漏算了 startOffset/endOffset/
|
|
396
|
+
// terms/行号这些 JSON 元数据,每段 ≈110 B);2026-10-07 真机压力语料实测
|
|
397
|
+
// 24 篇 × 2 段 = 14.8 KB、每篇 615 B。这里把**实测上界**钉成断言(16 KB / 每篇 700 B),
|
|
398
|
+
// 以后谁把每篇段数或片段长度加大,这条会先红。
|
|
399
|
+
const extra = []
|
|
400
|
+
for (let i = 1; i <= 30; i += 1) {
|
|
401
|
+
extra.push([`docs/budget-${i}.md`, lines(
|
|
402
|
+
`# 预算 ${i}`, '',
|
|
403
|
+
noise(4), '',
|
|
404
|
+
`命中:bramblefinch 在这一篇的第一处,${'后面继续展开细节,'.repeat(16)}`, '',
|
|
405
|
+
noise(40), '',
|
|
406
|
+
`再次命中:bramblefinch 在这一篇的第二处,${'同样继续展开细节,'.repeat(16)}`, '',
|
|
407
|
+
noise(60),
|
|
408
|
+
)])
|
|
409
|
+
}
|
|
410
|
+
const root = makeWorkspace(extra)
|
|
411
|
+
const payload = publicScanPayload(await relevanceScan(root, 'bramblefinch'))
|
|
412
|
+
|
|
413
|
+
const withMatches = payload.docs.filter((d) => Array.isArray(d.matches) && d.matches.length > 0)
|
|
414
|
+
assert.ok(withMatches.length > 0, '要有带片段的记录,否则这条守卫是空的')
|
|
415
|
+
assert.ok(
|
|
416
|
+
withMatches.length <= PASSAGE_WINDOW,
|
|
417
|
+
`带片段的记录 ${withMatches.length} 篇 > PASSAGE_WINDOW ${PASSAGE_WINDOW}`,
|
|
418
|
+
)
|
|
419
|
+
for (const doc of withMatches) {
|
|
420
|
+
assert.ok(
|
|
421
|
+
doc.matches.length <= PASSAGE_MAX_PER_FILE,
|
|
422
|
+
`${doc.rel} 报了 ${doc.matches.length} 段 > 每篇上限 ${PASSAGE_MAX_PER_FILE}`,
|
|
423
|
+
)
|
|
424
|
+
for (const m of doc.matches) {
|
|
425
|
+
for (const key of ['startLine', 'endLine', 'startOffset', 'endOffset', 'terms', 'snippet']) {
|
|
426
|
+
assert.ok(key in m, `${doc.rel} 的片段少了 ${key}(§11 的最低要求)`)
|
|
427
|
+
}
|
|
428
|
+
assert.ok(
|
|
429
|
+
m.snippet.length <= SNIPPET_CHARS + 8,
|
|
430
|
+
`${doc.rel} 的片段 ${m.snippet.length} 字符 > ${SNIPPET_CHARS} + 8`,
|
|
431
|
+
)
|
|
432
|
+
}
|
|
433
|
+
}
|
|
434
|
+
|
|
435
|
+
const strip = (list) => list.map(({ matches, ...rest }) => rest)
|
|
436
|
+
const before = JSON.stringify({ ...payload, docs: strip(payload.docs) }).length
|
|
437
|
+
const after = JSON.stringify(payload).length
|
|
438
|
+
const delta = after - before
|
|
439
|
+
console.log(` R2 面板实测:${withMatches.length} 篇带片段,载荷 ${before} → ${after} 字节`
|
|
440
|
+
+ `(+${delta},每篇 ${(delta / withMatches.length).toFixed(0)} 字节)`)
|
|
441
|
+
assert.ok(delta > 0, 'v0.20 应当比 v0.19 的载荷更大(否则守卫是假的)')
|
|
442
|
+
assert.ok(delta <= 16000, `片段让载荷多出 ${delta} 字节 > 实测上界 16 KB`)
|
|
443
|
+
assert.ok(
|
|
444
|
+
delta / withMatches.length <= 700,
|
|
445
|
+
`每篇多出 ${(delta / withMatches.length).toFixed(0)} 字节 > 实测上界 700 字节`,
|
|
446
|
+
)
|
|
447
|
+
})
|
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* v0.20 Deep Context Retrieval · **深度评测**(需求 §22 / §23)
|
|
3
|
+
*
|
|
4
|
+
* 守四个确定性指标(定义在 `test/eval/deep.mjs`,本文件只做断言):
|
|
5
|
+
*
|
|
6
|
+
* DeepHitRate ≥ 1.0 目标词只在旧窗口之后时,目标文件必须被命中
|
|
7
|
+
* PassageHit@1 ≥ 0.8 Top-1 文件的第一个 passage 覆盖目标行
|
|
8
|
+
* PassageRecall ≥ 0.8 目标 passage 出现在该文件的 `matches` 里
|
|
9
|
+
* LongDocNoiseRate = 0 长归档文不得进 Primary / Supporting
|
|
10
|
+
*
|
|
11
|
+
* 外加两条「这个指标是不是废的」自检:
|
|
12
|
+
* - 旧窗口模拟(v0.19 口径)必须**几乎全灭**(只有控制组命中)——
|
|
13
|
+
* 如果新旧一样,说明用例根本没把目标推到窗口之后。
|
|
14
|
+
* - 同一次评测跑两遍必须**逐字相同**(需求 §20 的确定性)。
|
|
15
|
+
*
|
|
16
|
+
* 与 v0.19 的两套基线的关系(§22):`test/eval.test.mjs` 与
|
|
17
|
+
* `test/context-eval.test.mjs` 一个字都没改,它们继续守着老语料上的
|
|
18
|
+
* `MIN_TOP1_GAIN = 0.15` / `MIN_MRR_GAIN = 0.10` / `MIN_TOP1 = 0.8` / `MIN_MRR = 0.85`。
|
|
19
|
+
* 本文件是**第二套**指标,不替换它们。
|
|
20
|
+
*
|
|
21
|
+
* 跑法:`node --test test/deep-eval.test.mjs`(也走 `npm test`)。
|
|
22
|
+
*/
|
|
23
|
+
import test from 'node:test'
|
|
24
|
+
import assert from 'node:assert/strict'
|
|
25
|
+
|
|
26
|
+
import { DEEP_CASES, runDeepEval, formatDeepEval, LEGACY_HAYSTACK_CHARS } from './eval/deep.mjs'
|
|
27
|
+
|
|
28
|
+
/** 行号 → 该行之前的字符数(用来证明目标确实在旧窗口之外)。 */
|
|
29
|
+
function offsetOfLine(content, line) {
|
|
30
|
+
return content.split('\n').slice(0, line - 1).join('\n').length
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
test('deep-eval 夹具自检:标了 deep 的用例,目标行确实在旧窗口之外', () => {
|
|
34
|
+
const deep = DEEP_CASES.filter((c) => c.deep)
|
|
35
|
+
assert.ok(deep.length >= 5, `至少有 5 条深度用例,实际 ${deep.length}`)
|
|
36
|
+
for (const c of deep) {
|
|
37
|
+
const [rel, content] = c.files[0]
|
|
38
|
+
const wanted = c.targetLines || [c.target.line]
|
|
39
|
+
for (const line of wanted) {
|
|
40
|
+
const offset = offsetOfLine(content, line)
|
|
41
|
+
assert.ok(offset > LEGACY_HAYSTACK_CHARS,
|
|
42
|
+
`${c.id} 的第 ${line} 行只落在第 ${offset} 字 —— 没推到 ${LEGACY_HAYSTACK_CHARS} 字之后,用例是假的`)
|
|
43
|
+
}
|
|
44
|
+
}
|
|
45
|
+
// 控制组必须**不是**深度用例:它证明指标不是「一律 0」
|
|
46
|
+
const control = DEEP_CASES.filter((c) => !c.deep)
|
|
47
|
+
assert.equal(control.length, 1, '恰好一条控制组(目标在文件名里)')
|
|
48
|
+
})
|
|
49
|
+
|
|
50
|
+
test('deep-eval:四个指标(§23)—— DeepHitRate / PassageHit@1 / PassageRecall / LongDocNoiseRate', async () => {
|
|
51
|
+
const { metrics, cases } = await runDeepEval()
|
|
52
|
+
|
|
53
|
+
assert.equal(metrics.DeepHitRate, 1,
|
|
54
|
+
`目标词在旧窗口之后时也必须命中:${JSON.stringify(cases.map((c) => [c.id, c.hit]))}`)
|
|
55
|
+
assert.ok(metrics.LegacyDeepHitRate <= 0.2,
|
|
56
|
+
`旧窗口模拟必须几乎全灭(只有控制组命中),实际 ${metrics.LegacyDeepHitRate} —— 新旧一样就说明指标是废的`)
|
|
57
|
+
assert.ok(metrics['PassageHit@1'] >= 0.8, `PassageHit@1 = ${metrics['PassageHit@1']}`)
|
|
58
|
+
assert.ok(metrics.PassageRecall >= 0.8, `PassageRecall = ${metrics.PassageRecall}`)
|
|
59
|
+
assert.equal(metrics.LongDocNoiseRate, 0,
|
|
60
|
+
'长归档文(什么都提一句)不得进 Primary / Supporting')
|
|
61
|
+
|
|
62
|
+
// 逐用例的硬要求:命中的文件必须真的带回 `matches`,且行区间覆盖目标行
|
|
63
|
+
for (const c of cases) {
|
|
64
|
+
assert.ok(c.rank >= 1, `${c.id} 必须出现在结果里`)
|
|
65
|
+
assert.notEqual(c.matchRanges.length, 0, `${c.id} 必须带回命中片段`)
|
|
66
|
+
assert.equal(c.noisy.supporting, false, `${c.id}:归档文不得进 Supporting`)
|
|
67
|
+
assert.equal(c.noisy.primary, false, `${c.id}:归档文不得进 Primary`)
|
|
68
|
+
}
|
|
69
|
+
// 旧的 v0.19 语料与基线没被这次评测牵动(§22)——这里只记录,不改它
|
|
70
|
+
assert.ok(formatDeepEval({ metrics, cases }).includes('DeepHitRate=1'))
|
|
71
|
+
})
|
|
72
|
+
|
|
73
|
+
test('deep-eval:指标里不许出现任何 AI 分数 / 置信度(§23 / §26)', async () => {
|
|
74
|
+
const { metrics } = await runDeepEval()
|
|
75
|
+
const keys = Object.keys(metrics).join(',')
|
|
76
|
+
for (const banned of ['contextScore', 'confidence', 'aiScore', 'relevanceScore']) {
|
|
77
|
+
assert.ok(!keys.includes(banned), `不许新增 ${banned}`)
|
|
78
|
+
}
|
|
79
|
+
// 四个名字就是全部(多一个都要先过需求 §23 这一关)
|
|
80
|
+
assert.deepEqual(Object.keys(metrics).sort(),
|
|
81
|
+
['DeepHitRate', 'LegacyDeepHitRate', 'LongDocNoiseRate', 'PassageHit@1', 'PassageRecall'].sort())
|
|
82
|
+
})
|
|
83
|
+
|
|
84
|
+
test('deep-eval:同一份语料跑两遍,逐字相同(需求 §20 确定性)', async () => {
|
|
85
|
+
const a = await runDeepEval()
|
|
86
|
+
const b = await runDeepEval()
|
|
87
|
+
assert.deepEqual(a.cases, b.cases,
|
|
88
|
+
'文件序 / 名次 / 行区间 / 片段在两次运行之间必须完全一致')
|
|
89
|
+
assert.deepEqual(a.metrics, b.metrics)
|
|
90
|
+
})
|
|
@@ -0,0 +1,64 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* v0.20 · **规模门槛(R1)**:全文检索轮到 5 秒轮询了没有?
|
|
3
|
+
*
|
|
4
|
+
* 实现说明 §7 R1 的硬门槛(`1000 文件 totalMs <= 1500`)如果只写在
|
|
5
|
+
* `tools/deep-benchmark.mjs` 里,那它就是「跑过一遍的记录」,不是门 —— 改坏了没人知道。
|
|
6
|
+
* 所以这里用**同一个**语料工厂(`makeScaleWorkspace`)跑一条小规模但同形状的门槛:
|
|
7
|
+
*
|
|
8
|
+
* 1. 1000 个文件(四类混合:小 md / 中 md / 大 md / 大代码)
|
|
9
|
+
* 2. 冷扫打一次带 query 的 `scan()` —— 这**正是**客户端每 5 秒轮询打的那条路
|
|
10
|
+
* (`/knit/api/recent` → `scan()`,`POLL_MS = 5000`)
|
|
11
|
+
* 3. 断言 `totalMs <= 1500`(R1 门槛)与 `warmMs <= 500`(热扫必须远低于 5 秒)
|
|
12
|
+
*
|
|
13
|
+
* ⚠️ 门槛是**量级**断言(实测 ~160ms vs 1500ms,十倍余量),不是性能回归曲线;
|
|
14
|
+
* 真机曲线看 `node tools/deep-benchmark.mjs`。语料上限由 `MAX_DOCS = 400` /
|
|
15
|
+
* `MAX_CODE = 300` 决定 —— 1000 个文件在盘上,进池的是 400 + 100(10% 是代码)。
|
|
16
|
+
*
|
|
17
|
+
* 跑法:`node --test test/deep-scale.test.mjs`(也走 `npm test`)。
|
|
18
|
+
*/
|
|
19
|
+
import test from 'node:test'
|
|
20
|
+
import assert from 'node:assert/strict'
|
|
21
|
+
|
|
22
|
+
import { makeScaleWorkspace, timeWorkspace, GATES, SIZES } from '../tools/deep-benchmark.mjs'
|
|
23
|
+
import { scan } from '../src/host/index.js'
|
|
24
|
+
|
|
25
|
+
test('规模门槛 R1:1000 文件、带 query 的完整 scan 必须远低于 5 秒轮询', async () => {
|
|
26
|
+
const ws = makeScaleWorkspace(1000, 'knit-scale-test')
|
|
27
|
+
try {
|
|
28
|
+
const r = await timeWorkspace(ws.root)
|
|
29
|
+
|
|
30
|
+
// 语料真的造出来了、也真的被上限截过(否则这条门槛测的是空气)
|
|
31
|
+
assert.ok(r.counts.scanned > 0, '扫到了文件')
|
|
32
|
+
assert.ok(r.counts.docs <= 400, `文档池受 MAX_DOCS 约束:${r.counts.docs}`)
|
|
33
|
+
assert.ok(r.counts.code <= 300, `代码池受 MAX_CODE 约束:${r.counts.code}`)
|
|
34
|
+
assert.ok(r.ranked > 0, '排序结果非空')
|
|
35
|
+
|
|
36
|
+
assert.ok(r.totalMs <= GATES.synthetic1000Ms,
|
|
37
|
+
`R1 硬门槛:1000 文件冷扫 ${r.totalMs.toFixed(0)}ms 必须 <= ${GATES.synthetic1000Ms}ms`)
|
|
38
|
+
assert.ok(r.warmMs <= 500,
|
|
39
|
+
`热扫(缓存命中)${r.warmMs.toFixed(0)}ms 必须远低于 POLL_MS = 5000ms`)
|
|
40
|
+
} finally {
|
|
41
|
+
ws.cleanup()
|
|
42
|
+
}
|
|
43
|
+
})
|
|
44
|
+
|
|
45
|
+
test('规模门槛 R1:语料档位与门槛常量就是实现说明里写的那几个', () => {
|
|
46
|
+
assert.deepEqual(SIZES, [100, 500, 1000], '§18 点名的三档')
|
|
47
|
+
assert.equal(GATES.synthetic1000Ms, 1500, '合成语料门槛')
|
|
48
|
+
assert.equal(GATES.realMs, 1200, '真实工作区门槛')
|
|
49
|
+
})
|
|
50
|
+
|
|
51
|
+
test('规模门槛 R1:同一份语料两次 scan 的相对顺序逐字相同(§20)', async () => {
|
|
52
|
+
const ws = makeScaleWorkspace(120, 'knit-scale-det')
|
|
53
|
+
try {
|
|
54
|
+
const a = await scan(ws.root, 400, { sort: 'relevance', query: 'handler', kind: 'context' })
|
|
55
|
+
const b = await scan(ws.root, 400, { sort: 'relevance', query: 'handler', kind: 'context' })
|
|
56
|
+
assert.deepEqual(a.docs.map((d) => d.rel), b.docs.map((d) => d.rel),
|
|
57
|
+
'文件序不许受扫描序 / 缓存命中影响')
|
|
58
|
+
assert.deepEqual(a.docs.map((d) => (d.matches || []).map((m) => `${m.startLine}-${m.endLine}`).join(',')),
|
|
59
|
+
b.docs.map((d) => (d.matches || []).map((m) => `${m.startLine}-${m.endLine}`).join(',')),
|
|
60
|
+
'片段行区间同样要稳定')
|
|
61
|
+
} finally {
|
|
62
|
+
ws.cleanup()
|
|
63
|
+
}
|
|
64
|
+
})
|