dsh-knit 0.17.0 → 0.19.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 +333 -2
- package/README.en.md +128 -31
- package/README.md +142 -25
- package/SECURITY.md +4 -3
- package/package.json +6 -4
- package/src/client/client.js +1146 -194
- package/src/host/classification.js +250 -0
- package/src/host/context.js +31 -9
- package/src/host/index.js +336 -77
- package/src/host/tool.js +29 -13
- package/test/classification.test.mjs +237 -0
- package/test/client.test.mjs +982 -54
- package/test/code-context.test.mjs +567 -0
- package/test/eval/fixture.mjs +309 -6
- package/test/eval.test.mjs +117 -1
- package/test/harness.mjs +4 -1
- package/test/host.test.mjs +63 -3
- package/test/i18n.test.mjs +188 -5
- package/test/path.test.mjs +97 -5
- package/test/tool.test.mjs +23 -15
package/test/eval/fixture.mjs
CHANGED
|
@@ -238,6 +238,256 @@ Knit 浮层里的点击是即时响应的,不走列表接口,也不等轮询
|
|
|
238
238
|
}),
|
|
239
239
|
]
|
|
240
240
|
|
|
241
|
+
/**
|
|
242
|
+
* 造一条**代码**记录,haystack 口径严格照抄宿主的 `readCode()`
|
|
243
|
+
* (`src/host/index.js:346-359`):
|
|
244
|
+
*
|
|
245
|
+
* ```text
|
|
246
|
+
* filename → title (权重 ×4)
|
|
247
|
+
* path → summary (权重 ×2,保留结尾斜杠)
|
|
248
|
+
* content → body (权重 ×1,前 HAYSTACK_CHARS 字)
|
|
249
|
+
* ```
|
|
250
|
+
*
|
|
251
|
+
* `title` 是**带扩展名的文件名**,不是去扩展名的 stem —— 代码的文件名里扩展名本身
|
|
252
|
+
* 就是信息(`plugin-loader.js` vs `plugin.json`),去掉它反而丢掉最能把两个候选
|
|
253
|
+
* 分开的那几个字符。
|
|
254
|
+
*
|
|
255
|
+
* 为什么要有这个工厂:v0.19 的 `CODE_CASES` 必须验的是「同一个 `rankByRelevance`
|
|
256
|
+
* 在文档与代码混合的语料上怎么排」,而不是另写一套排序器。所以**代码条目和文档条目
|
|
257
|
+
* 走完全相同的 `{rel, haystack, mtimeMs}` 形状**,只是三段文本的来源不同。
|
|
258
|
+
*
|
|
259
|
+
* @param {string} rel - 工作区相对路径
|
|
260
|
+
* @param {string} head - 文件开头的内容(会被截到 `HAYSTACK_CHARS`)
|
|
261
|
+
* @param {string} [kind] - 产物类型,默认 `'code'`
|
|
262
|
+
* @returns {object} 语料记录
|
|
263
|
+
*/
|
|
264
|
+
function codeDoc(rel, head, kind = 'code') {
|
|
265
|
+
const name = rel.split('/').pop()
|
|
266
|
+
const cut = rel.lastIndexOf('/')
|
|
267
|
+
const dir = cut >= 0 ? rel.slice(0, cut + 1) : ''
|
|
268
|
+
return {
|
|
269
|
+
rel,
|
|
270
|
+
path: rel,
|
|
271
|
+
name,
|
|
272
|
+
kind,
|
|
273
|
+
size: head.length,
|
|
274
|
+
mtimeMs: SHARED_MTIME,
|
|
275
|
+
haystack: {
|
|
276
|
+
title: name.toLowerCase(),
|
|
277
|
+
summary: dir.toLowerCase(),
|
|
278
|
+
body: head.slice(0, HAYSTACK_CHARS).toLowerCase(),
|
|
279
|
+
},
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
/**
|
|
284
|
+
* v0.19 新增的**文档**候选(只给混合场景用,不进 `CORPUS`)。
|
|
285
|
+
*
|
|
286
|
+
* 单独一份的理由:`CORPUS` 是 v0.6 起就被 21 条用例钉住的基线,往里加一篇
|
|
287
|
+
* 就是在动历史刻度。Case C 需要一篇「相关但排在代码后面」的文档候选,
|
|
288
|
+
* 于是把它放进 v0.19 自己的池子里 —— 两个对比臂(只 Markdown / Markdown+Code)
|
|
289
|
+
* **都含它**,所以它不会变成某一臂的额外优势。
|
|
290
|
+
*/
|
|
291
|
+
export const V019_DOCS = [
|
|
292
|
+
doc('docs/architecture.md', {
|
|
293
|
+
title: '架构分层',
|
|
294
|
+
summary: '扫描 → 分类 → 检索 → Context Pack 的分层与职责边界。',
|
|
295
|
+
body: `
|
|
296
|
+
这份设计文档说明 knit 的分层:workspace scan 只负责找到文件,file classification
|
|
297
|
+
决定一个文件算文档、代码还是媒体,retrieval 用 BM25 在当前任务与候选之间排序,
|
|
298
|
+
最后装配成 Context Pack 的三层。分层之间只通过 artifact.kind 传递,不许互相偷看。
|
|
299
|
+
|
|
300
|
+
session context 的装配属于 retrieval 之后的一步:把检索结果按 primary / supporting /
|
|
301
|
+
related 分组,再冻结成一次 context epoch。session 的持久化不在这份文档的范围里,
|
|
302
|
+
它由 session-store 负责。架构上刻意不引入 embedding 与向量库,检索保持纯本地确定性。
|
|
303
|
+
`,
|
|
304
|
+
}),
|
|
305
|
+
]
|
|
306
|
+
|
|
307
|
+
/**
|
|
308
|
+
* v0.19 的代码语料 —— 三个真实 AI Coding 场景。
|
|
309
|
+
*
|
|
310
|
+
* 刻意让**不相关的东西也留在池子里**(`CORPUS` 那 16 篇文档全在),因为要回答的
|
|
311
|
+
* 问题不是「代码能不能排第一」,而是:
|
|
312
|
+
*
|
|
313
|
+
* > 把代码放进同一个 BM25 池子之后,**原有文档的检索质量会不会被挤坏**。
|
|
314
|
+
*
|
|
315
|
+
* 那只有在真竞争里才量得出来。
|
|
316
|
+
*/
|
|
317
|
+
export const CODE_CORPUS = [
|
|
318
|
+
// ── Case A:React / TypeScript ──────────────────────────
|
|
319
|
+
codeDoc('src/components/Component.tsx', `
|
|
320
|
+
import React, { useState, useEffect } from 'react'
|
|
321
|
+
|
|
322
|
+
/**
|
|
323
|
+
* 任务面板。父级把 state 传下来,这里同步到本地 draft。
|
|
324
|
+
* bug:父级 state 变了,这个组件 render 之后还是旧值。
|
|
325
|
+
*/
|
|
326
|
+
export function Component({ task, onChange }) {
|
|
327
|
+
const [draft, setDraft] = useState(task.title)
|
|
328
|
+
|
|
329
|
+
useEffect(() => {
|
|
330
|
+
// 同步不上的地方:依赖数组是空的,只在 mount 时跑一次,
|
|
331
|
+
// 父级后续的 props 改动被整个丢掉了。
|
|
332
|
+
setDraft(task.title)
|
|
333
|
+
}, [])
|
|
334
|
+
|
|
335
|
+
const onInput = (event) => {
|
|
336
|
+
setDraft(event.target.value)
|
|
337
|
+
onChange(event.target.value)
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
return <input value={draft} onChange={onInput} />
|
|
341
|
+
}
|
|
342
|
+
`),
|
|
343
|
+
codeDoc('src/state/state.ts', `
|
|
344
|
+
/**
|
|
345
|
+
* 任务状态。组件之间的状态同步都要经过这里,不许各存一份。
|
|
346
|
+
*/
|
|
347
|
+
export interface TaskState {
|
|
348
|
+
title: string
|
|
349
|
+
dirty: boolean
|
|
350
|
+
}
|
|
351
|
+
|
|
352
|
+
export const initialState: TaskState = { title: '', dirty: false }
|
|
353
|
+
|
|
354
|
+
export function reducer(state: TaskState, action: { type: string, value?: string }) {
|
|
355
|
+
switch (action.type) {
|
|
356
|
+
case 'title': return { ...state, title: action.value || '', dirty: true }
|
|
357
|
+
default: return state
|
|
358
|
+
}
|
|
359
|
+
}
|
|
360
|
+
`),
|
|
361
|
+
codeDoc('src/hooks/hooks.ts', `
|
|
362
|
+
import { useEffect, useRef, useState } from 'react'
|
|
363
|
+
|
|
364
|
+
/** 把外部值同步进本地 state —— 依赖数组必须带上外部值本身。 */
|
|
365
|
+
export function useSyncedValue(external) {
|
|
366
|
+
const [value, setValue] = useState(external)
|
|
367
|
+
useEffect(() => { setValue(external) }, [external])
|
|
368
|
+
return [value, setValue]
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
/** 去抖,避免每次按键都 render 父级。 */
|
|
372
|
+
export function useDebounced(value, ms = 200) {
|
|
373
|
+
const [debounced, setDebounced] = useState(value)
|
|
374
|
+
useEffect(() => {
|
|
375
|
+
const id = setTimeout(() => setDebounced(value), ms)
|
|
376
|
+
return () => clearTimeout(id)
|
|
377
|
+
}, [value, ms])
|
|
378
|
+
return debounced
|
|
379
|
+
}
|
|
380
|
+
`),
|
|
381
|
+
|
|
382
|
+
// ── Case B:Node / JavaScript ───────────────────────────
|
|
383
|
+
codeDoc('src/plugin/plugin-loader.js', `
|
|
384
|
+
/**
|
|
385
|
+
* plugin loader:扫插件目录、读 metadata、注册到 loader 表。
|
|
386
|
+
* 新增的 metadata 字段在这里认不出来,于是被静默丢掉。
|
|
387
|
+
*/
|
|
388
|
+
export async function loadPlugin(dir) {
|
|
389
|
+
const metadata = await readMetadata(dir)
|
|
390
|
+
if (!metadata || !metadata.name) {
|
|
391
|
+
throw new Error('metadata.name is required')
|
|
392
|
+
}
|
|
393
|
+
return { ...metadata, dir, loaded: true }
|
|
394
|
+
}
|
|
395
|
+
|
|
396
|
+
export async function loadAll(root) {
|
|
397
|
+
const dirs = await listPluginDirs(root)
|
|
398
|
+
const out = []
|
|
399
|
+
for (const dir of dirs) out.push(await loadPlugin(dir))
|
|
400
|
+
return out
|
|
401
|
+
}
|
|
402
|
+
`),
|
|
403
|
+
codeDoc('src/plugin/plugin.ts', `
|
|
404
|
+
/** 插件的运行时形状,以及 loader 认得的 metadata 字段。 */
|
|
405
|
+
export interface PluginMetadata {
|
|
406
|
+
name: string
|
|
407
|
+
version?: string
|
|
408
|
+
main?: string
|
|
409
|
+
}
|
|
410
|
+
|
|
411
|
+
export interface Plugin extends PluginMetadata {
|
|
412
|
+
dir: string
|
|
413
|
+
loaded: boolean
|
|
414
|
+
}
|
|
415
|
+
|
|
416
|
+
export interface PluginLoader {
|
|
417
|
+
loadPlugin(dir: string): Promise<Plugin>
|
|
418
|
+
loadAll(root: string): Promise<Plugin[]>
|
|
419
|
+
}
|
|
420
|
+
`),
|
|
421
|
+
codeDoc('src/plugin/metadata.js', `
|
|
422
|
+
import { readFile } from 'node:fs/promises'
|
|
423
|
+
import { join } from 'node:path'
|
|
424
|
+
|
|
425
|
+
/** 读 plugin.json —— loader 只认这里的字段,别处的一律忽略。 */
|
|
426
|
+
export async function readMetadata(dir) {
|
|
427
|
+
try {
|
|
428
|
+
const raw = await readFile(join(dir, 'plugin.json'), 'utf8')
|
|
429
|
+
const parsed = JSON.parse(raw)
|
|
430
|
+
return typeof parsed === 'object' && parsed !== null ? parsed : null
|
|
431
|
+
} catch {
|
|
432
|
+
return null
|
|
433
|
+
}
|
|
434
|
+
}
|
|
435
|
+
`),
|
|
436
|
+
|
|
437
|
+
// ── Case C:混合上下文(文档 + 代码竞争同一层)──────────
|
|
438
|
+
codeDoc('src/context/context-manager.ts', `
|
|
439
|
+
/**
|
|
440
|
+
* session context 的装配:把检索结果按 primary / supporting / related 分组,
|
|
441
|
+
* 再冻结成一次 context epoch。所有对 session 的读写都要经过这里。
|
|
442
|
+
*/
|
|
443
|
+
export function assembleContext(session, ranked) {
|
|
444
|
+
const primary = ranked.filter((entry) => entry.score >= HIGH)
|
|
445
|
+
const supporting = ranked.filter((entry) => entry.score >= MID && entry.score < HIGH)
|
|
446
|
+
const related = ranked.filter((entry) => entry.score < MID)
|
|
447
|
+
return { session: session.id, primary, supporting, related, epoch: session.epoch + 1 }
|
|
448
|
+
}
|
|
449
|
+
`),
|
|
450
|
+
codeDoc('src/context/session-store.ts', `
|
|
451
|
+
/**
|
|
452
|
+
* session 的持久化层。只存 id / epoch / 已读证据,不存任何检索中间结果。
|
|
453
|
+
*/
|
|
454
|
+
export function saveSession(store, session) {
|
|
455
|
+
store.set(session.id, { id: session.id, epoch: session.epoch, reads: session.reads })
|
|
456
|
+
return store.get(session.id)
|
|
457
|
+
}
|
|
458
|
+
|
|
459
|
+
export function loadSession(store, id) {
|
|
460
|
+
return store.get(id) || null
|
|
461
|
+
}
|
|
462
|
+
`),
|
|
463
|
+
]
|
|
464
|
+
|
|
465
|
+
/**
|
|
466
|
+
* v0.19 必须**一个都不准进语料**的生成 / 噪声产物(需求 §6 §7 §35)。
|
|
467
|
+
*
|
|
468
|
+
* 这张表有两个消费方,所以放在这里而不是某个测试里:
|
|
469
|
+
*
|
|
470
|
+
* 1. `code-context.test.mjs` 拿它去**真实扫描**一个临时工作区,断言这 7 条
|
|
471
|
+
* 在候选里一个都找不到(这是「verification」,不是「说明」)。
|
|
472
|
+
* 2. 基准里用它算 noise rate —— 只要有一条出现在代码用例的 top-1,
|
|
473
|
+
* 这个数就不再是 0。
|
|
474
|
+
*
|
|
475
|
+
* 注意 `node_modules` / `dist` / `coverage` 三条**同时**会被既有的 `SKIP_DIRS`
|
|
476
|
+
* 挡掉:所以它们验的是「目录级排除仍然生效」,而 `app.min.js` / `bundle.generated.js`
|
|
477
|
+
* / `app.js.map` / `package-lock.json` 验的是「新增的 code-specific noise 规则生效」。
|
|
478
|
+
* 两层都要有,因为任意一层接手都不会让它们漏进来 —— 但测出来必须是零。
|
|
479
|
+
*/
|
|
480
|
+
export const NOISE_RELS = [
|
|
481
|
+
'node_modules/foo.js',
|
|
482
|
+
'dist/app.js',
|
|
483
|
+
'coverage/report.js',
|
|
484
|
+
'app.min.js',
|
|
485
|
+
'bundle.generated.js',
|
|
486
|
+
'app.js.map',
|
|
487
|
+
'package-lock.json',
|
|
488
|
+
]
|
|
489
|
+
|
|
490
|
+
|
|
241
491
|
/**
|
|
242
492
|
* 用例。
|
|
243
493
|
*
|
|
@@ -385,6 +635,54 @@ export const CASES = [
|
|
|
385
635
|
},
|
|
386
636
|
]
|
|
387
637
|
|
|
638
|
+
/**
|
|
639
|
+
* v0.19 的代码用例 —— 需求 §34 点名的三个真实 AI Coding 场景。
|
|
640
|
+
*
|
|
641
|
+
* 标注口径与 `CASES` 完全相同(`expect` = 期望的 top-1),**不新增一套标注格式**:
|
|
642
|
+
* 二元标注够用,因为要回答的问题是「这块上下文有没有被找出来」,
|
|
643
|
+
* 而不是「它比第二名好多少」。
|
|
644
|
+
*/
|
|
645
|
+
export const CODE_CASES = [
|
|
646
|
+
{
|
|
647
|
+
name: 'V0.19-A React/TS:组件状态同步',
|
|
648
|
+
messages: [
|
|
649
|
+
'修复当前任务中的 React 组件状态同步问题',
|
|
650
|
+
'Component 里的 state 跟父级不同步,重新 render 之后还是旧值',
|
|
651
|
+
],
|
|
652
|
+
expect: 'src/components/Component.tsx',
|
|
653
|
+
// 这四条是「任务里根本没提到、但池子里有的东西」——
|
|
654
|
+
// 架构文档、变更日志、临时笔记都不该赢过一个正在报 bug 的组件。
|
|
655
|
+
notTop: ['docs/architecture.md', 'CHANGELOG.md', 'docs/one-off.md', 'docs/long-archive.md'],
|
|
656
|
+
},
|
|
657
|
+
{
|
|
658
|
+
name: 'V0.19-B Node/JS:plugin loader 的 metadata',
|
|
659
|
+
messages: [
|
|
660
|
+
'修改 plugin loader,使它支持新的 plugin metadata',
|
|
661
|
+
'loader 读 metadata 的时候认不出新加的那个字段',
|
|
662
|
+
],
|
|
663
|
+
expect: 'src/plugin/plugin-loader.js',
|
|
664
|
+
notTop: ['docs/architecture.md', 'README.md', 'docs/long-archive.md'],
|
|
665
|
+
},
|
|
666
|
+
{
|
|
667
|
+
name: 'V0.19-C 混合:session context 的实现',
|
|
668
|
+
messages: [
|
|
669
|
+
'根据项目设计修改 session context 实现',
|
|
670
|
+
'context 的装配逻辑跟 session 的存储对不上',
|
|
671
|
+
],
|
|
672
|
+
expect: 'src/context/context-manager.ts',
|
|
673
|
+
notTop: ['README.md', 'docs/long-archive.md', 'docs/one-off.md'],
|
|
674
|
+
},
|
|
675
|
+
]
|
|
676
|
+
|
|
677
|
+
/**
|
|
678
|
+
* v0.19 的两个对比臂 —— **同一个语料形状,只差一个代码语料**。
|
|
679
|
+
*
|
|
680
|
+
* 这样「Markdown only vs Markdown + Code」就不是两次不同实验的比较,
|
|
681
|
+
* 而是同一池子加料前后的差值,唯一变量就是代码。
|
|
682
|
+
*/
|
|
683
|
+
export const V019_MD_ONLY = [...CORPUS, ...V019_DOCS]
|
|
684
|
+
export const V019_WITH_CODE = [...V019_MD_ONLY, ...CODE_CORPUS]
|
|
685
|
+
|
|
388
686
|
/**
|
|
389
687
|
* 跑一遍评测。
|
|
390
688
|
*
|
|
@@ -392,12 +690,17 @@ export const CASES = [
|
|
|
392
690
|
* 关键词抽取(注入真实实现,便于新旧对比)
|
|
393
691
|
* @param {(docs: object[], keywords: object[], now: number) => {docs: object[]}} rank -
|
|
394
692
|
* 排序(注入真实实现)
|
|
693
|
+
* @param {object[]} [corpus] - 语料;默认 `CORPUS`。
|
|
694
|
+
* v0.19 新增这个口子是为了量「同一个排序器在只 Markdown 与 Markdown+Code 上的差」——
|
|
695
|
+
* 代码条目与文档条目走**完全相同的** `{rel, haystack, mtimeMs}` 形状,
|
|
696
|
+
* 所以不值得(也不允许)为代码另写一个评测器。
|
|
697
|
+
* @param {object[]} [cases] - 用例;默认 `CASES`
|
|
395
698
|
* @returns {{total: number, top1: number, top1Rate: number, mrr: number,
|
|
396
699
|
* misses: Array<{name: string, got: string, want: string}>,
|
|
397
700
|
* trapViolations: Array<{name: string, offender: string}>,
|
|
398
701
|
* degenerate: number, ranks: number[]}} 评测结果
|
|
399
702
|
*/
|
|
400
|
-
export function runEval(extract, rank) {
|
|
703
|
+
export function runEval(extract, rank, corpus = CORPUS, cases = CASES) {
|
|
401
704
|
let top1 = 0
|
|
402
705
|
let mrrSum = 0
|
|
403
706
|
let degenerate = 0
|
|
@@ -405,9 +708,9 @@ export function runEval(extract, rank) {
|
|
|
405
708
|
const trapViolations = []
|
|
406
709
|
const ranks = []
|
|
407
710
|
|
|
408
|
-
for (const testCase of
|
|
711
|
+
for (const testCase of cases) {
|
|
409
712
|
const keywords = extract(testCase.messages, 30)
|
|
410
|
-
const { docs: ranked } = rank(
|
|
713
|
+
const { docs: ranked } = rank(corpus, keywords, NOW)
|
|
411
714
|
const order = ranked.map((d) => d.rel)
|
|
412
715
|
const position = order.indexOf(testCase.expect)
|
|
413
716
|
// 名次从 1 开始;找不到记为 0(对 MRR 没有贡献)
|
|
@@ -427,10 +730,10 @@ export function runEval(extract, rank) {
|
|
|
427
730
|
}
|
|
428
731
|
|
|
429
732
|
return {
|
|
430
|
-
total:
|
|
733
|
+
total: cases.length,
|
|
431
734
|
top1,
|
|
432
|
-
top1Rate: top1 /
|
|
433
|
-
mrr: mrrSum /
|
|
735
|
+
top1Rate: top1 / cases.length,
|
|
736
|
+
mrr: mrrSum / cases.length,
|
|
434
737
|
misses,
|
|
435
738
|
trapViolations,
|
|
436
739
|
degenerate,
|
package/test/eval.test.mjs
CHANGED
|
@@ -11,7 +11,9 @@
|
|
|
11
11
|
import test from 'node:test'
|
|
12
12
|
import assert from 'node:assert/strict'
|
|
13
13
|
|
|
14
|
-
import {
|
|
14
|
+
import {
|
|
15
|
+
runEval, CASES, CODE_CASES, CODE_CORPUS, V019_MD_ONLY, V019_WITH_CODE, NOISE_RELS,
|
|
16
|
+
} from './eval/fixture.mjs'
|
|
15
17
|
import { extractKeywordsLegacy, rankByRelevanceLegacy } from './eval/legacy.mjs'
|
|
16
18
|
import { extractKeywords, rankByRelevance } from '../src/host/relevance.js'
|
|
17
19
|
|
|
@@ -78,3 +80,117 @@ test('评测集: 排序不能退化成一枝独秀', () => {
|
|
|
78
80
|
`退化排序过多:${current.degenerate}/${current.total} 个用例只有一篇文档有分`,
|
|
79
81
|
)
|
|
80
82
|
})
|
|
83
|
+
|
|
84
|
+
/* ── v0.19:Code Context 的两臂对比 ──────────────────────────────────
|
|
85
|
+
*
|
|
86
|
+
* 上面那群用例量的是「v0.19 之前的 Knit」在**文档语料**上的排序。V0.19 的新问题
|
|
87
|
+
* 不是「代码能不能显示」,而是两件事,必须分开量:
|
|
88
|
+
*
|
|
89
|
+
* 1. 代码进了同一个语料池之后,**原有文档检索质量有没有被挤下去**(corpus pressure)
|
|
90
|
+
* 2. 代码任务本身**能不能被排到第一**(code recall)
|
|
91
|
+
*
|
|
92
|
+
* 两个臂的语料形状只差一个 `CODE_CORPUS`(`V019_WITH_CODE` = `V019_MD_ONLY` + 代码),
|
|
93
|
+
* 所以差值是**同一池子加料前后**的净效果,不是两份不同语料的对比。
|
|
94
|
+
* ⚠️ 这个评测集**不是难度竞赛**:三条代码用例都是清晰的检索意图,两臂都接近满分。
|
|
95
|
+
* 它的作用是**回归钉** —— 谁把代码候选、噪声过滤或字段权重改坏了,这里会红。
|
|
96
|
+
*/
|
|
97
|
+
const v019 = {
|
|
98
|
+
docsMdOnly: runEval(extractKeywords, rankByRelevance, V019_MD_ONLY, CASES),
|
|
99
|
+
docsWithCode: runEval(extractKeywords, rankByRelevance, V019_WITH_CODE, CASES),
|
|
100
|
+
codeMdOnly: runEval(extractKeywords, rankByRelevance, V019_MD_ONLY, CODE_CASES),
|
|
101
|
+
codeWithCode: runEval(extractKeywords, rankByRelevance, V019_WITH_CODE, CODE_CASES),
|
|
102
|
+
mixed: runEval(extractKeywords, rankByRelevance, V019_WITH_CODE, [...CASES, ...CODE_CASES]),
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
test('v0.19 评测集: 加入代码语料之后,文档检索一条都不许变差', () => {
|
|
106
|
+
const before = v019.docsMdOnly
|
|
107
|
+
const after = v019.docsWithCode
|
|
108
|
+
|
|
109
|
+
assert.ok(
|
|
110
|
+
after.top1Rate >= before.top1Rate,
|
|
111
|
+
`文档 top-1 掉下去了:Markdown only ${pct(before.top1Rate)} → +Code ${pct(after.top1Rate)}。`
|
|
112
|
+
+ `这最可能是 candidate cap / 权重 / 噪声过滤 / corpus admission 里的哪一项,`
|
|
113
|
+
+ `报告里要点名,**不要**先想着换算法。`,
|
|
114
|
+
)
|
|
115
|
+
assert.ok(
|
|
116
|
+
after.mrr >= before.mrr,
|
|
117
|
+
`文档 MRR 掉下去了:${before.mrr.toFixed(3)} → ${after.mrr.toFixed(3)}`,
|
|
118
|
+
)
|
|
119
|
+
|
|
120
|
+
// 逐条比对:原来第一的,现在还得是第一。整体率相同也可能是「翻正一条、弄坏一条」。
|
|
121
|
+
const broke = []
|
|
122
|
+
before.ranks.forEach((rank, index) => {
|
|
123
|
+
if (rank !== 1) return
|
|
124
|
+
if (after.ranks[index] !== 1) {
|
|
125
|
+
broke.push(`${CASES[index].name}:${pct(1)} → 第 ${after.ranks[index] || '未命中'} 名`)
|
|
126
|
+
}
|
|
127
|
+
})
|
|
128
|
+
assert.deepEqual(broke, [], `加入代码后文档用例被顶掉:${broke.join(';')}`)
|
|
129
|
+
})
|
|
130
|
+
|
|
131
|
+
test('v0.19 评测集: 代码用例在「只有文档」的池子里必然全军覆没', () => {
|
|
132
|
+
// 这条是上一条的**对照臂**:如果代码用例在没有代码的池子里也能答对,
|
|
133
|
+
// 那「加了代码之后答对了」就什么也没证明。
|
|
134
|
+
assert.equal(
|
|
135
|
+
v019.codeMdOnly.top1Rate, 0,
|
|
136
|
+
`代码用例在纯文档语料里不该命中,却命中了 ${pct(v019.codeMdOnly.top1Rate)}`,
|
|
137
|
+
)
|
|
138
|
+
})
|
|
139
|
+
|
|
140
|
+
test('v0.19 评测集: 代码任务可以被排到第一(code recall)', () => {
|
|
141
|
+
const code = v019.codeWithCode
|
|
142
|
+
assert.ok(
|
|
143
|
+
code.top1Rate >= MIN_TOP1,
|
|
144
|
+
`代码 top-1 低于下限:${pct(code.top1Rate)} < ${pct(MIN_TOP1)};`
|
|
145
|
+
+ `未命中:${code.misses.map((m) => `${m.name}(得 ${m.got},期望 ${m.want})`).join(';')}`,
|
|
146
|
+
)
|
|
147
|
+
assert.ok(code.mrr >= MIN_MRR, `代码 MRR 低于下限:${code.mrr.toFixed(3)} < ${MIN_MRR}`)
|
|
148
|
+
// 三条用例的「不该排第一」约束(任务里根本没提的池内条目)一条都不许犯。
|
|
149
|
+
assert.deepEqual(
|
|
150
|
+
code.trapViolations, [],
|
|
151
|
+
`不该排第一的排了第一:${code.trapViolations.map((v) => `${v.name} → ${v.offender}`).join(';')}`,
|
|
152
|
+
)
|
|
153
|
+
})
|
|
154
|
+
|
|
155
|
+
test('v0.19 评测集: 混合语料的整体 MRR —— 文档与代码一起量,不是各算一半', () => {
|
|
156
|
+
const mixed = v019.mixed
|
|
157
|
+
assert.ok(
|
|
158
|
+
mixed.top1Rate >= MIN_TOP1,
|
|
159
|
+
`混合 top-1 低于下限:${pct(mixed.top1Rate)};未命中:`
|
|
160
|
+
+ mixed.misses.map((m) => `${m.name}(得 ${m.got},期望 ${m.want})`).join(';'),
|
|
161
|
+
)
|
|
162
|
+
assert.ok(mixed.mrr >= MIN_MRR, `混合 MRR 低于下限:${mixed.mrr.toFixed(3)} < ${MIN_MRR}`)
|
|
163
|
+
})
|
|
164
|
+
|
|
165
|
+
test('v0.19 评测集: 混合场景里文档没有被代码挤出去(Case C 的文档仍在候选前列)', () => {
|
|
166
|
+
// 需求 §18 的反面:不能「因为是 Code 就天然优先」。Case C(session context 的实现)
|
|
167
|
+
// 的正确答案是一篇代码,但同一语料里那篇讲分层的设计文档必须**还在前排**,
|
|
168
|
+
// 否则就说明代码把文档挤没了 —— 那正是 corpus pressure 失效的样子。
|
|
169
|
+
const c = CODE_CASES.find((x) => x.name.includes('混合'))
|
|
170
|
+
const kw = extractKeywords(c.messages, 30)
|
|
171
|
+
const ranked = rankByRelevance(V019_WITH_CODE, kw, 1_760_000_000_000).docs
|
|
172
|
+
const at = ranked.findIndex((d) => d.rel === 'docs/architecture.md')
|
|
173
|
+
|
|
174
|
+
assert.equal(ranked[0].rel, c.expect, '代码用例的 top-1 仍是它自己')
|
|
175
|
+
assert.ok(
|
|
176
|
+
at >= 0 && at < 3,
|
|
177
|
+
`设计文档被挤到了第 ${at < 0 ? '未命中' : at + 1} 名 —— 代码不该把文档挤没`,
|
|
178
|
+
)
|
|
179
|
+
})
|
|
180
|
+
|
|
181
|
+
test('v0.19 评测集: 生成 / 噪声路径一条都不在语料里', () => {
|
|
182
|
+
const pool = new Set(V019_WITH_CODE.map((d) => d.rel))
|
|
183
|
+
const leaked = NOISE_RELS.filter((rel) => pool.has(rel))
|
|
184
|
+
assert.deepEqual(leaked, [], `噪声路径漏进了评测语料:${leaked.join('、')}`)
|
|
185
|
+
|
|
186
|
+
// 噪声率:代码用例的 top-1 落在噪声路径上的比例,必须是 0。
|
|
187
|
+
const kw = CODE_CASES.map((c) => extractKeywords(c.messages, 30))
|
|
188
|
+
const noiseTop = kw.filter((keywords, i) => NOISE_RELS.includes(
|
|
189
|
+
rankByRelevance(V019_WITH_CODE, keywords, 1_760_000_000_000).docs[0].rel,
|
|
190
|
+
))
|
|
191
|
+
assert.equal(noiseTop.length / CODE_CASES.length, 0, '噪声成为 top-1 的比例必须是 0')
|
|
192
|
+
assert.equal(
|
|
193
|
+
V019_WITH_CODE.length, V019_MD_ONLY.length + CODE_CORPUS.length,
|
|
194
|
+
'加料前后的语料差必须**只有**代码 —— 差出别的说明夹具被改了,两臂的对比就无效了',
|
|
195
|
+
)
|
|
196
|
+
})
|
package/test/harness.mjs
CHANGED
|
@@ -72,7 +72,10 @@ export function loadClientModule(options = {}) {
|
|
|
72
72
|
// 右栏一起删除(2026-09-29)。名字留在这里,模块一加载就 ReferenceError ——
|
|
73
73
|
// 这个替身是**只增不减**的重灾区,删功能时记得同步删名字。
|
|
74
74
|
+ 'MIN_RATIO, MAX_RATIO, ALL_DOC_CAP, MEDIA_MAX_ITEMS, MEDIA_TRACK_PX, '
|
|
75
|
-
+ 'MEDIA_LABEL_MIN_PX, MEDIA_GAP_PX
|
|
75
|
+
+ 'MEDIA_LABEL_MIN_PX, MEDIA_GAP_PX, '
|
|
76
|
+
// v0.18 Context Usage Lens:纯函数与阈值(渲染层的东西仍走 DOM 断言)。
|
|
77
|
+
+ 'LIFE_GLYPH, lifeStatusOf, coverageOf, groupOutsideDocs, groupDelta, '
|
|
78
|
+
+ 'COMPACT_PANEL_PX, MAX_OUTSIDE_SHOWN, MAX_DELTA_SHOWN, MAX_DELTA_GROUP, FLASH_MS }\n'
|
|
76
79
|
+ " module.exports.inject = ['slots', 'locale']",
|
|
77
80
|
)
|
|
78
81
|
|
package/test/host.test.mjs
CHANGED
|
@@ -7,6 +7,7 @@ import test from 'node:test'
|
|
|
7
7
|
import assert from 'node:assert/strict'
|
|
8
8
|
import { fileURLToPath } from 'node:url'
|
|
9
9
|
import { mkdtemp, writeFile, rm } from 'node:fs/promises'
|
|
10
|
+
import { realpathSync, symlinkSync, unlinkSync } from 'node:fs'
|
|
10
11
|
import { tmpdir } from 'node:os'
|
|
11
12
|
import { join } from 'node:path'
|
|
12
13
|
|
|
@@ -136,10 +137,27 @@ test('readDocument: 拒绝绝对路径逃逸', async () => {
|
|
|
136
137
|
assert.equal(r.ok, false)
|
|
137
138
|
})
|
|
138
139
|
|
|
139
|
-
test('readDocument:
|
|
140
|
+
test('readDocument: 拒绝不可预览的类型(媒体 / 第一批范围外的源码后缀)', async () => {
|
|
141
|
+
// v0.19:这条断言以前叫「拒绝非 Markdown」,判据是 `.md$` 正则。
|
|
142
|
+
// 现在由分类层回答「能不能预览」—— 图片不能(走 /api/raw),
|
|
143
|
+
// `.go` 也不能(**明确不在第一批范围内**,需求 §5)。
|
|
144
|
+
const image = await readDocument(PROJECT_ROOT, 'assets/shot.png')
|
|
145
|
+
assert.equal(image.ok, false)
|
|
146
|
+
assert.equal(image.code, ERROR_CODES.notPreviewable)
|
|
147
|
+
|
|
148
|
+
const go = await readDocument(PROJECT_ROOT, 'main.go')
|
|
149
|
+
assert.equal(go.ok, false)
|
|
150
|
+
assert.equal(go.code, ERROR_CODES.notPreviewable)
|
|
151
|
+
})
|
|
152
|
+
|
|
153
|
+
test('readDocument: v0.19 起代码文件可读,并带上分类结论', async () => {
|
|
140
154
|
const r = await readDocument(PROJECT_ROOT, 'package.json')
|
|
141
|
-
assert.equal(r.ok,
|
|
142
|
-
assert.equal(r.
|
|
155
|
+
assert.equal(r.ok, true)
|
|
156
|
+
assert.equal(r.kind, 'code')
|
|
157
|
+
assert.equal(r.language, 'json')
|
|
158
|
+
// 代码的标题是文件名本身 —— 不拿 `parseMarkdown` 去猜(`#` 在 shell / yaml 里是注释)
|
|
159
|
+
assert.equal(r.title, 'package.json')
|
|
160
|
+
assert.match(r.text, /"name"/)
|
|
143
161
|
})
|
|
144
162
|
|
|
145
163
|
/* ── 相关性引擎 ─────────────────────────────────────── */
|
|
@@ -604,3 +622,45 @@ test('mediaInfo: 文件不存在回 notFound', async () => {
|
|
|
604
622
|
assert.equal(r.code, ERROR_CODES.notFound)
|
|
605
623
|
})
|
|
606
624
|
})
|
|
625
|
+
|
|
626
|
+
/* ── 符号链接工作区:交给宿主打开的路径必须是 realpath(v0.19 修订) ──
|
|
627
|
+
现象:工作区根是一条符号链接时(实测 `DSH_Skill_Trace -> 10_DSH_Skill_Trace`),
|
|
628
|
+
客户端「打开 / 定位」一律报 `Path has no verified Host path`;真实目录(08_Knit)没事。
|
|
629
|
+
判据在 DSH 自己那里:`verifyDesktopPath()` 要求
|
|
630
|
+
`fs.processPath(await fs.resolve(fs.processPathFromHostPath(p))) === p`,
|
|
631
|
+
而 `dsh-fs-local` 的 targetKey 落的是 `realpath()` ⇒ **含未展开链接的路径必然过不了**。
|
|
632
|
+
⇒ 宿主下发的 `hostRoot` 与每条记录的 `path` 都要先展开。 */
|
|
633
|
+
|
|
634
|
+
test('路径:工作区根是符号链接时,hostRoot 与每条 path 都已展开', async () => {
|
|
635
|
+
const linkDir = await mkdtemp(join(tmpdir(), 'knit-link-'))
|
|
636
|
+
const link = join(linkDir, 'ws')
|
|
637
|
+
symlinkSync(PROJECT_ROOT, link)
|
|
638
|
+
try {
|
|
639
|
+
const payload = await scan(link, 10, { sessionId: 's', sort: 'time' })
|
|
640
|
+
assert.notEqual(realpathSync(link), link, '前提:夹具里 link 确实是一条符号链接')
|
|
641
|
+
assert.equal(payload.root, link, 'root 仍是会话自己那条(界面显示用)')
|
|
642
|
+
assert.equal(payload.hostRoot, realpathSync(link), 'hostRoot 是展开后的 canonical 路径')
|
|
643
|
+
|
|
644
|
+
const docs = Array.isArray(payload.docs) ? payload.docs : []
|
|
645
|
+
assert.ok(docs.length > 0, '夹具里应当扫到内容')
|
|
646
|
+
for (const doc of docs) {
|
|
647
|
+
assert.equal(realpathSync(doc.path), doc.path,
|
|
648
|
+
`${doc.rel} 下发的 path 必须是 realpath —— DSH 的校验就是这一条`)
|
|
649
|
+
assert.equal(doc.path.startsWith(payload.hostRoot), true, 'path 落在 canonical 根下')
|
|
650
|
+
}
|
|
651
|
+
|
|
652
|
+
// 相对路径一字不变:展开链接不该改变 rel(检索 / 上下文 / 生命周期全靠它)
|
|
653
|
+
const direct = await scan(PROJECT_ROOT, 10, { sessionId: 's', sort: 'time' })
|
|
654
|
+
assert.deepEqual(docs.map((d) => d.rel).sort(), (direct.docs || []).map((d) => d.rel).sort(),
|
|
655
|
+
'root 换成符号链接后 rel 集合必须完全一致')
|
|
656
|
+
|
|
657
|
+
// `/api/doc` 那条路给客户端的 path 也要展开 —— 它是「正文到手后校正」的依据
|
|
658
|
+
const doc = await readDocument(link, docs[0].rel)
|
|
659
|
+
assert.equal(doc.ok, true)
|
|
660
|
+
assert.equal(realpathSync(doc.path), doc.path, '/api/doc 给的 path 必须是 realpath')
|
|
661
|
+
assert.equal(doc.rel, docs[0].rel)
|
|
662
|
+
} finally {
|
|
663
|
+
unlinkSync(link)
|
|
664
|
+
await rm(linkDir, { recursive: true, force: true })
|
|
665
|
+
}
|
|
666
|
+
})
|