dsh-knit 0.14.0 → 0.16.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 +279 -0
- package/README.en.md +81 -23
- package/README.md +71 -20
- package/package.json +3 -2
- package/src/client/client.js +237 -98
- package/src/host/feedback.js +858 -0
- package/src/host/index.js +171 -7
- package/src/host/tool.js +63 -3
- package/test/client.test.mjs +279 -31
- package/test/context-delta.test.mjs +322 -0
- package/test/context-effectiveness.test.mjs +309 -0
- package/test/context-feedback-eval.test.mjs +220 -0
- package/test/feedback.test.mjs +247 -0
- package/test/host-http.test.mjs +249 -3
- package/test/i18n.test.mjs +22 -23
- package/test/path.test.mjs +6 -6
- package/test/peek.test.mjs +80 -26
- package/test/tool.test.mjs +132 -5
- package/tools/context-feedback-eval.mjs +362 -0
package/test/host-http.test.mjs
CHANGED
|
@@ -38,18 +38,32 @@ const PROJECT_ROOT = makeWorkspace([
|
|
|
38
38
|
* 那个回调会拿到一个没有 `tools` 的假 ctx —— 那是**替身的谎**,不是代码的 bug
|
|
39
39
|
* (AGENTS.md §6.1 的教训)。真实的 cordis 在回调前保证依赖可用。
|
|
40
40
|
*
|
|
41
|
+
* @param {object} [session] - 假会话(默认只有一个 header.cwd,没有任何事件)
|
|
41
42
|
* @returns {Promise<{base:string, close:Function}>} 地址根与关闭函数
|
|
42
43
|
*/
|
|
43
|
-
async function startKnitServer() {
|
|
44
|
+
async function startKnitServer(session, sessionId = 's') {
|
|
44
45
|
let handler = null
|
|
46
|
+
const listeners = new Map()
|
|
47
|
+
// ⚠️ v0.16:订阅回调按 `session.id` 认会话,所以假会话必须有 id,
|
|
48
|
+
// 且必须与请求里的 `sessionId` 一致 —— 这正是真机的形状。
|
|
49
|
+
const fakeSession = {
|
|
50
|
+
...(session || {}),
|
|
51
|
+
id: sessionId,
|
|
52
|
+
header: { cwd: PROJECT_ROOT, id: sessionId, ...((session && session.header) || {}) },
|
|
53
|
+
}
|
|
45
54
|
const provided = {
|
|
46
55
|
webServer: {
|
|
47
56
|
register({ handler: h }) { handler = h; return () => {} },
|
|
48
57
|
},
|
|
49
|
-
sessions: { get: () =>
|
|
58
|
+
sessions: { get: () => fakeSession },
|
|
50
59
|
effect(fn) { fn() },
|
|
51
60
|
}
|
|
52
61
|
apply({
|
|
62
|
+
on(name, fn) {
|
|
63
|
+
if (!listeners.has(name)) listeners.set(name, [])
|
|
64
|
+
listeners.get(name).push(fn)
|
|
65
|
+
return () => {}
|
|
66
|
+
},
|
|
53
67
|
inject(deps, cb) {
|
|
54
68
|
// 只提供 webServer / sessions;tools 不存在 → 那条回调不该被调用
|
|
55
69
|
if (!deps.every((dep) => dep in provided)) return
|
|
@@ -57,12 +71,21 @@ async function startKnitServer() {
|
|
|
57
71
|
},
|
|
58
72
|
})
|
|
59
73
|
assert.ok(handler, 'apply 应注册路由 handler')
|
|
74
|
+
assert.equal((listeners.get('session/event') || []).length, 1, 'apply 应恰好订阅一次 session/event')
|
|
75
|
+
/**
|
|
76
|
+
* 模拟宿主 append 之后派发的会话事件(v0.16:Knit 唯一的读证据来源)。
|
|
77
|
+
* @param {object|null} event - 会话事件
|
|
78
|
+
* @returns {void}
|
|
79
|
+
*/
|
|
80
|
+
const emit = (event) => {
|
|
81
|
+
for (const fn of listeners.get('session/event') || []) fn(fakeSession, event)
|
|
82
|
+
}
|
|
60
83
|
|
|
61
84
|
const server = http.createServer((req, res) => handler(req, res))
|
|
62
85
|
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
|
|
63
86
|
const base = `http://127.0.0.1:${server.address().port}/knit`
|
|
64
87
|
const close = () => new Promise((resolve) => server.close(resolve))
|
|
65
|
-
return { base, close }
|
|
88
|
+
return { base, close, emit }
|
|
66
89
|
}
|
|
67
90
|
|
|
68
91
|
test('HTTP 端到端:媒体列表、/raw 整文件、Range 206、安全拒绝', async () => {
|
|
@@ -279,3 +302,226 @@ test('HTTP 端到端:/api/context 返回同一份 Context Model', async () =>
|
|
|
279
302
|
await close()
|
|
280
303
|
}
|
|
281
304
|
})
|
|
305
|
+
|
|
306
|
+
/* ── v0.16 · /api/recent 的「使用情况」通道 ──────────────────
|
|
307
|
+
*
|
|
308
|
+
* 这几条走真实回环 HTTP,锁的是**最容易漂移的那一层**:
|
|
309
|
+
* 记账默认关闭、`usage=1` 才开闸、开着之后幂等、根外的读不计数、
|
|
310
|
+
* 畸形事件不许影响接口。
|
|
311
|
+
*
|
|
312
|
+
* ⚠️ v0.16 起读证据来自 `session/event` 订阅(不再从 `session.snapshotEvents()` 拉),
|
|
313
|
+
* 所以这几条必须先 `emit()` 派发事件再请求接口 —— 那也正是真机的顺序。
|
|
314
|
+
*/
|
|
315
|
+
|
|
316
|
+
/**
|
|
317
|
+
* 造一个假会话:`header.cwd` + 给**检索**用的 `snapshotEvents()`。
|
|
318
|
+
*
|
|
319
|
+
* ⚠️ `snapshotEvents()` 现在只服务检索侧(对话 → 任务上下文分级);
|
|
320
|
+
* 读证据走 `emit()` 那条 `session/event` 路线。
|
|
321
|
+
* @param {object[]} events - 会话事件(检索用)
|
|
322
|
+
* @returns {object} 假会话
|
|
323
|
+
*/
|
|
324
|
+
function sessionWithEvents(events) {
|
|
325
|
+
return { header: { cwd: PROJECT_ROOT }, snapshotEvents: () => events }
|
|
326
|
+
}
|
|
327
|
+
|
|
328
|
+
/**
|
|
329
|
+
* 一条用户消息事件。
|
|
330
|
+
* @param {number} seq - 序号
|
|
331
|
+
* @param {string} text - 文本
|
|
332
|
+
* @returns {object} 事件
|
|
333
|
+
*/
|
|
334
|
+
function userMessage(seq, text) {
|
|
335
|
+
return {
|
|
336
|
+
type: 'user/message',
|
|
337
|
+
seq,
|
|
338
|
+
time: 1000 + seq,
|
|
339
|
+
data: { role: 'user', content: [{ type: 'text', text }], source: { kind: 'user' } },
|
|
340
|
+
}
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
/**
|
|
344
|
+
* 一次 `read` 工具调用(`arguments` 是 JSON **字符串** —— 与真机逐字一致)。
|
|
345
|
+
* @param {number} seq - 序号
|
|
346
|
+
* @param {string} filePath - 参数里的路径
|
|
347
|
+
* @param {string} [callId] - 调用 id
|
|
348
|
+
* @returns {object} 事件
|
|
349
|
+
*/
|
|
350
|
+
function readCall(seq, filePath, callId = `c${seq}`) {
|
|
351
|
+
return {
|
|
352
|
+
type: 'tool/call',
|
|
353
|
+
seq,
|
|
354
|
+
time: 1000 + seq,
|
|
355
|
+
data: { turn: 1, step: 1, callId, name: 'read', arguments: JSON.stringify({ file_path: filePath }) },
|
|
356
|
+
}
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
/**
|
|
360
|
+
* 一次工具返回。默认成功;`isError: true` 表示失败(**失败不计入使用**)。
|
|
361
|
+
* @param {number} seq - 序号
|
|
362
|
+
* @param {string} callId - 对应的调用 id
|
|
363
|
+
* @param {boolean} [isError] - 是否失败
|
|
364
|
+
* @returns {object} 事件
|
|
365
|
+
*/
|
|
366
|
+
function toolResult(seq, callId, isError = false) {
|
|
367
|
+
return {
|
|
368
|
+
type: 'tool/result',
|
|
369
|
+
seq,
|
|
370
|
+
time: 1000 + seq,
|
|
371
|
+
sourceEventSeqs: [seq - 1],
|
|
372
|
+
data: {
|
|
373
|
+
turn: 1, step: 1,
|
|
374
|
+
message: {
|
|
375
|
+
role: 'tool',
|
|
376
|
+
source: { kind: 'tool', callId },
|
|
377
|
+
toolCallId: callId,
|
|
378
|
+
content: [{ type: 'text', text: '<path>…</path>' }],
|
|
379
|
+
isError,
|
|
380
|
+
id: `m${seq}`,
|
|
381
|
+
},
|
|
382
|
+
},
|
|
383
|
+
}
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
test('HTTP 端到端:默认不记账,usage=1 开闸,读事件由 session/event 进来', async () => {
|
|
387
|
+
const { base, close, emit } = await startKnitServer(
|
|
388
|
+
sessionWithEvents([userMessage(1, 'hub 这份文档')]), 's1',
|
|
389
|
+
)
|
|
390
|
+
try {
|
|
391
|
+
// ① 默认:一个字节都不记 —— 没有 usage 键,也没有任何记账状态
|
|
392
|
+
let body = await (await fetch(`${base}/api/recent?sessionId=s1&sort=relevance`)).json()
|
|
393
|
+
assert.ok(!('usage' in body), '默认不该回传 usage(更不该偷偷记账)')
|
|
394
|
+
|
|
395
|
+
// ② 打开:这一刻开始记。此刻还一次读事件都没发生 → 计数是 0。
|
|
396
|
+
// v0.16 刻意**不回溯**订阅之前的事件:宁可少记,也不去猜一段没法按当时上下文归因的历史。
|
|
397
|
+
body = await (await fetch(`${base}/api/recent?sessionId=s1&sort=relevance&usage=1`)).json()
|
|
398
|
+
assert.ok(body.usage, 'usage=1 应当回传使用情况')
|
|
399
|
+
assert.equal(body.usage.stats.reads, 0, '订阅之前发生的事件不回溯')
|
|
400
|
+
// ⚠️ `at` 是**上一份包**交出去的时间;第一次记账时还没有上一份,所以是 0。
|
|
401
|
+
// 这不是缺陷,是顺序:usage 先算、快照后记(从下一次请求起才有「上一份」)。
|
|
402
|
+
assert.equal(body.usage.at, 0)
|
|
403
|
+
// 面板只需要计数,不需要本机绝对路径
|
|
404
|
+
assert.ok(!JSON.stringify(body.usage).includes(PROJECT_ROOT), 'usage 里不许出现绝对路径')
|
|
405
|
+
|
|
406
|
+
// ③ 派发一次真实的读(先 call 后 result —— 与真机顺序一致)
|
|
407
|
+
emit(readCall(2, 'docs/hub.md'))
|
|
408
|
+
emit(toolResult(3, 'c2'))
|
|
409
|
+
|
|
410
|
+
// ④ 开着之后,后续请求不带 usage=1 也照样回传(状态在会话上,不在参数上)
|
|
411
|
+
body = await (await fetch(`${base}/api/recent?sessionId=s1&sort=relevance`)).json()
|
|
412
|
+
assert.ok(body.usage, '一旦打开,后续请求仍应回传(面板靠它持续刷新)')
|
|
413
|
+
assert.equal(body.usage.stats.reads, 1, '一次成功的 read 应被记成一次使用')
|
|
414
|
+
assert.equal(body.usage.stats.distinct, 1)
|
|
415
|
+
assert.equal(body.usage.stats.firstReadRel, 'docs/hub.md')
|
|
416
|
+
assert.ok(body.usage.at > 0, '交过包之后就有了「上一份」的时间')
|
|
417
|
+
// 端到端把「读」与「分层」接上的那一条:这次读落在上一份包的主看篇里
|
|
418
|
+
assert.equal(body.usage.stats.primaryFollowThrough, true)
|
|
419
|
+
assert.equal(body.usage.stats.firstReadTier, 'primary')
|
|
420
|
+
assert.equal(body.usage.stats.outside, 0)
|
|
421
|
+
// Epoch:第一次交包就是 Epoch 1,且这条读的归因钉在 Epoch 1
|
|
422
|
+
assert.equal(body.usage.epochId, 1)
|
|
423
|
+
assert.equal(body.usage.stats.firstReadEpoch, 1)
|
|
424
|
+
assert.equal(body.usage.stats.churn.epochs, 1)
|
|
425
|
+
assert.equal(body.usage.stats.churn.changes, 0, '一个 Epoch 里反复交同一份包不算「上下文变了」')
|
|
426
|
+
} finally {
|
|
427
|
+
await close()
|
|
428
|
+
}
|
|
429
|
+
})
|
|
430
|
+
|
|
431
|
+
test('HTTP 端到端:记账幂等 —— 同一个事件派发十次,同一次读只算一次', async () => {
|
|
432
|
+
const { base, close, emit } = await startKnitServer(
|
|
433
|
+
sessionWithEvents([userMessage(1, 'hub 这份文档')]), 's2',
|
|
434
|
+
)
|
|
435
|
+
try {
|
|
436
|
+
await fetch(`${base}/api/recent?sessionId=s2&sort=relevance&usage=1`)
|
|
437
|
+
emit(readCall(2, 'docs/hub.md'))
|
|
438
|
+
emit(toolResult(3, 'c2'))
|
|
439
|
+
let last = null
|
|
440
|
+
for (let i = 0; i < 10; i += 1) {
|
|
441
|
+
// 同一批事件再派发一遍:`seq` 游标必须保证幂等
|
|
442
|
+
emit(readCall(2, 'docs/hub.md'))
|
|
443
|
+
emit(toolResult(3, 'c2'))
|
|
444
|
+
last = await (await fetch(`${base}/api/recent?sessionId=s2&sort=relevance`)).json()
|
|
445
|
+
}
|
|
446
|
+
assert.equal(last.usage.stats.reads, 1, '同一个 seq 的事件重复派发不许重复计数')
|
|
447
|
+
assert.equal(last.usage.stats.distinct, 1)
|
|
448
|
+
} finally {
|
|
449
|
+
await close()
|
|
450
|
+
}
|
|
451
|
+
})
|
|
452
|
+
|
|
453
|
+
test('HTTP 端到端:根外的读与失败的工具返回都不计入使用', async () => {
|
|
454
|
+
const { base, close, emit } = await startKnitServer(
|
|
455
|
+
sessionWithEvents([userMessage(1, 'hub 这份文档')]), 's3',
|
|
456
|
+
)
|
|
457
|
+
try {
|
|
458
|
+
await fetch(`${base}/api/recent?sessionId=s3&sort=relevance&usage=1`)
|
|
459
|
+
// 根外(绝对路径)—— 隐私上直接丢掉,连计数都不留
|
|
460
|
+
emit(readCall(2, '/etc/passwd'))
|
|
461
|
+
emit(toolResult(3, 'c2'))
|
|
462
|
+
// 根内但读失败了 —— 「尝试读」不是「读到」
|
|
463
|
+
emit(readCall(4, 'docs/leaf.md'))
|
|
464
|
+
emit(toolResult(5, 'c4', true))
|
|
465
|
+
// 非 read 的工具不算
|
|
466
|
+
emit({ type: 'tool/call', seq: 6, time: 1006, data: { turn: 1, step: 1, callId: 'c6', name: 'grep', arguments: JSON.stringify({ pattern: 'hub' }) } })
|
|
467
|
+
emit(toolResult(7, 'c6'))
|
|
468
|
+
|
|
469
|
+
const body = await (await fetch(`${base}/api/recent?sessionId=s3&sort=relevance`)).json()
|
|
470
|
+
assert.equal(body.usage.stats.reads, 0, `根外 / 失败 / 非 read 都不算,实际 ${body.usage.stats.reads}`)
|
|
471
|
+
assert.deepEqual(body.usage.stats.outsideReads, [])
|
|
472
|
+
} finally {
|
|
473
|
+
await close()
|
|
474
|
+
}
|
|
475
|
+
})
|
|
476
|
+
|
|
477
|
+
test('HTTP 端到端:畸形事件与未记账会话的事件都不许影响接口(降级)', async () => {
|
|
478
|
+
const { base, close, emit } = await startKnitServer(
|
|
479
|
+
sessionWithEvents([userMessage(1, 'hub 这份文档')]), 's4',
|
|
480
|
+
)
|
|
481
|
+
try {
|
|
482
|
+
// 未记账:派发什么都不该被记(订阅回调首行就早退)
|
|
483
|
+
emit(readCall(2, 'docs/hub.md'))
|
|
484
|
+
emit(toolResult(3, 'c2'))
|
|
485
|
+
// 打开记账
|
|
486
|
+
await fetch(`${base}/api/recent?sessionId=s4&sort=relevance&usage=1`)
|
|
487
|
+
// 畸形事件:null / data 是 null / message 是 null / type 不是字符串 / 参数不是合法 JSON
|
|
488
|
+
emit(null)
|
|
489
|
+
emit({ type: 'tool/result', seq: 5, data: null })
|
|
490
|
+
emit({ type: 'tool/result', seq: 6, data: { message: null } })
|
|
491
|
+
emit({ type: 'tool/call', seq: 7, data: null })
|
|
492
|
+
emit({ type: 42, seq: 8, data: {} })
|
|
493
|
+
emit({ type: 'tool/call', seq: 9, data: { turn: 1, step: 1, callId: 'c9', name: 'read', arguments: '{坏掉的 JSON' } })
|
|
494
|
+
|
|
495
|
+
const r = await fetch(`${base}/api/recent?sessionId=s4&sort=relevance`)
|
|
496
|
+
const body = await r.json()
|
|
497
|
+
assert.equal(r.status, 200, '畸形事件不许把列表接口搞成 500')
|
|
498
|
+
assert.ok(Array.isArray(body.docs))
|
|
499
|
+
assert.equal(body.usage.stats.reads, 0, '畸形事件一条都不许被记成使用')
|
|
500
|
+
} finally {
|
|
501
|
+
await close()
|
|
502
|
+
}
|
|
503
|
+
})
|
|
504
|
+
|
|
505
|
+
test('HTTP 端到端:/api/context 也推进快照,但只在已记账的会话里', async () => {
|
|
506
|
+
const { base, close } = await startKnitServer(sessionWithEvents([userMessage(1, 'hub 这份文档')]), 's5')
|
|
507
|
+
try {
|
|
508
|
+
// 没打开 → 不记
|
|
509
|
+
let body = await (await fetch(`${base}/api/context?sessionId=s5`)).json()
|
|
510
|
+
assert.ok(body.ok)
|
|
511
|
+
assert.ok(!('usage' in body), '/api/context 本来就不回传 usage')
|
|
512
|
+
|
|
513
|
+
// 打开 → 这个路由交出的包同样进账(否则「上下文变了」会漏记)
|
|
514
|
+
await fetch(`${base}/api/recent?sessionId=s5&sort=relevance&usage=1`)
|
|
515
|
+
await fetch(`${base}/api/context?sessionId=s5`)
|
|
516
|
+
body = await (await fetch(`${base}/api/recent?sessionId=s5&sort=relevance`)).json()
|
|
517
|
+
assert.ok(body.usage, '已记账的会话应当继续回传使用情况')
|
|
518
|
+
assert.ok(body.usage.at > 0, '快照应当已经记下(at 有值)')
|
|
519
|
+
// 同签名不记新快照:同一份包被两个路由反复交出**不算**「上下文变了」。
|
|
520
|
+
// 否则面板 5 秒轮询一次,churn 立刻变成纯噪音。
|
|
521
|
+
assert.equal(body.usage.stats.churn.snapshots, 0, '一模一样的一份包不许记成「变化」')
|
|
522
|
+
assert.equal(body.usage.stats.churn.epochs, 1, '没换过上下文就只有一个 Epoch')
|
|
523
|
+
assert.equal(body.usage.delta, null, '没有变化就没有 Delta')
|
|
524
|
+
} finally {
|
|
525
|
+
await close()
|
|
526
|
+
}
|
|
527
|
+
})
|
package/test/i18n.test.mjs
CHANGED
|
@@ -180,27 +180,27 @@ test('渲染:英文环境下整个面板出英文', async () => {
|
|
|
180
180
|
const { nodes } = await renderPanel('en', () => listPayload())
|
|
181
181
|
|
|
182
182
|
assert.equal(textOf(byClass(nodes, 'knit-count')[0]), '2 docs')
|
|
183
|
-
//
|
|
184
|
-
|
|
183
|
+
// 排序说明那一行 2026-09-30 已整体删除(排序方式由切换按钮自己表达),
|
|
184
|
+
// 所以这里只剩切换按钮本身的文案。
|
|
185
185
|
assert.deepEqual(
|
|
186
186
|
byClass(nodes, 'knit-seg-btn').map(textOf),
|
|
187
187
|
['Relevant', 'Recent'],
|
|
188
188
|
)
|
|
189
|
-
assert.equal(byClass(nodes, 'knit-filter')[0].props.placeholder, 'Filter
|
|
190
|
-
|
|
189
|
+
assert.equal(byClass(nodes, 'knit-filter')[0].props.placeholder, 'Filter docs')
|
|
190
|
+
// v0.15:头部有**两个**按钮 —— 使用情况(默认关)与刷新
|
|
191
|
+
assert.deepEqual(byClass(nodes, 'knit-btn').map(textOf), ['Usage', 'Refresh'])
|
|
191
192
|
})
|
|
192
193
|
|
|
193
194
|
test('渲染:中文环境下整个面板出中文', async () => {
|
|
194
195
|
const { nodes } = await renderPanel('zh', () => listPayload())
|
|
195
196
|
|
|
196
197
|
assert.equal(textOf(byClass(nodes, 'knit-count')[0]), '2 篇')
|
|
197
|
-
assert.match(textOf(byClass(nodes, 'knit-topic')[0]), /对话内容还不足/)
|
|
198
198
|
assert.deepEqual(
|
|
199
199
|
byClass(nodes, 'knit-seg-btn').map(textOf),
|
|
200
200
|
['相关', '最新'],
|
|
201
201
|
)
|
|
202
|
-
assert.equal(byClass(nodes, 'knit-filter')[0].props.placeholder, '
|
|
203
|
-
assert.
|
|
202
|
+
assert.equal(byClass(nodes, 'knit-filter')[0].props.placeholder, '过滤文档')
|
|
203
|
+
assert.deepEqual(byClass(nodes, 'knit-btn').map(textOf), ['使用情况', '刷新'])
|
|
204
204
|
})
|
|
205
205
|
|
|
206
206
|
test('渲染:占位符按语言正确替换(含过滤计数)', async () => {
|
|
@@ -216,28 +216,27 @@ test('渲染:占位符按语言正确替换(含过滤计数)', async () =>
|
|
|
216
216
|
assert.equal(byClass(filtered, 'knit-doc').length, 1)
|
|
217
217
|
})
|
|
218
218
|
|
|
219
|
-
test('
|
|
220
|
-
|
|
219
|
+
test('渲染:排序说明行已整体删除(相关 / 最新 / 中英文都不再有)', async () => {
|
|
220
|
+
// 相关模式(宿主还给了命中关键词):那一行**连 title 里的关键词一起**消失
|
|
221
|
+
const rel = await renderPanel('en', () => listPayload({
|
|
221
222
|
mode: 'relevance',
|
|
222
223
|
topic: 'sidebar、registry',
|
|
223
224
|
}))
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
assert.match(String(topicNode.props.title), /matched keywords: sidebar、registry/,
|
|
228
|
-
'关键词退到 title 里当低层 metadata')
|
|
229
|
-
})
|
|
225
|
+
assert.equal(byClass(rel.nodes, 'knit-topic').length, 0, '相关模式下没有排序说明行')
|
|
226
|
+
assert.ok(!JSON.stringify(ownTexts(rel.nodes)).includes('Sorted by relevance'),
|
|
227
|
+
'这段文案不许从别的地方漏回来')
|
|
230
228
|
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
assert.match(textOf(byClass(after, 'knit-topic')[0]), /Sorted by modified time/)
|
|
229
|
+
// 切到「最新」:也不回来
|
|
230
|
+
byClass(rel.nodes, 'knit-seg-btn').find((n) => textOf(n) === 'Recent').props.onClick()
|
|
231
|
+
const after = await rel.rerender()
|
|
232
|
+
assert.equal(byClass(after, 'knit-topic').length, 0, '切到最新也没有排序说明行')
|
|
236
233
|
|
|
234
|
+
// 中文侧同样
|
|
237
235
|
const zh = await renderPanel('zh', () => listPayload())
|
|
238
|
-
byClass(zh.nodes, 'knit-
|
|
239
|
-
const
|
|
240
|
-
assert.
|
|
236
|
+
assert.equal(byClass(zh.nodes, 'knit-topic').length, 0, '中文侧也没有排序说明行')
|
|
237
|
+
const zhText = JSON.stringify(ownTexts(zh.nodes))
|
|
238
|
+
assert.ok(!zhText.includes('相关性排序') && !zhText.includes('按修改时间倒序'),
|
|
239
|
+
'中文排序说明也不许从别的地方漏回来')
|
|
241
240
|
})
|
|
242
241
|
|
|
243
242
|
test('渲染:英文空态 / 错误态文案', async () => {
|
package/test/path.test.mjs
CHANGED
|
@@ -290,14 +290,14 @@ test('路径:拼不出绝对路径时按钮 disabled,点了也不发请求',
|
|
|
290
290
|
})
|
|
291
291
|
|
|
292
292
|
/**
|
|
293
|
-
* v0.10
|
|
293
|
+
* v0.10:预览头右上角那个位置从「新标签页」换成了「本地打开」。
|
|
294
294
|
*
|
|
295
295
|
* 动机:「新标签页」开的是官方文档预览,但面板里已经有就地预览(重复度高、
|
|
296
296
|
* 用得少);而「用默认应用打开这篇文档」原本只藏在路径面包屑的悬停提示里。
|
|
297
297
|
* 把值钱的那个放到显眼处。双击列表行仍能开新标签页 —— 所以这条要同时断言
|
|
298
298
|
* **头部不再有「新标签页」**。
|
|
299
299
|
*/
|
|
300
|
-
test('
|
|
300
|
+
test('预览头:右上角是「本地打开」,点击打开这篇文档', async () => {
|
|
301
301
|
const calls = []
|
|
302
302
|
globalThis.fetch = async (url) => ({
|
|
303
303
|
json: async () => (String(url).includes('/api/doc')
|
|
@@ -317,10 +317,10 @@ test('预览头:右上角是「在本地打开」,点击打开这篇文档',
|
|
|
317
317
|
|
|
318
318
|
const headBtns = byClass(nodes, 'knit-btn')
|
|
319
319
|
const labels = headBtns.map(textOf)
|
|
320
|
-
assert.ok(labels.includes('
|
|
320
|
+
assert.ok(labels.includes('本地打开'), '头部有「本地打开」按钮,实际:' + labels.join(' / '))
|
|
321
321
|
assert.ok(!labels.includes('新标签页'), '「新标签页」已从头部移除,实际:' + labels.join(' / '))
|
|
322
322
|
|
|
323
|
-
const localBtn = headBtns.find((n) => textOf(n) === '
|
|
323
|
+
const localBtn = headBtns.find((n) => textOf(n) === '本地打开')
|
|
324
324
|
assert.notEqual(localBtn.props.disabled, true, '有服务时不禁用')
|
|
325
325
|
// tooltip 里带完整相对路径 —— 与路径面包屑同一套提示
|
|
326
326
|
assert.match(String(localBtn.props.title), /a\.md/, 'tooltip 里带相对路径')
|
|
@@ -329,7 +329,7 @@ test('预览头:右上角是「在本地打开」,点击打开这篇文档',
|
|
|
329
329
|
assert.deepEqual(calls[0], { path: '/Users/me/proj/a.md' }, '打开的是这篇文档的绝对路径')
|
|
330
330
|
})
|
|
331
331
|
|
|
332
|
-
test('预览头:没有 remote.session
|
|
332
|
+
test('预览头:没有 remote.session 时「本地打开」给出提示,不是白点一下', async () => {
|
|
333
333
|
globalThis.fetch = async (url) => ({
|
|
334
334
|
json: async () => (String(url).includes('/api/doc')
|
|
335
335
|
? { ok: true, rel: 'a.md', title: 'A', text: '正文', truncated: false }
|
|
@@ -344,7 +344,7 @@ test('预览头:没有 remote.session 时「在本地打开」给出提示,
|
|
|
344
344
|
byClass(nodes, 'knit-doc')[0].props.onClick()
|
|
345
345
|
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
346
346
|
|
|
347
|
-
const localBtn = byClass(nodes, 'knit-btn').find((n) => textOf(n) === '
|
|
347
|
+
const localBtn = byClass(nodes, 'knit-btn').find((n) => textOf(n) === '本地打开')
|
|
348
348
|
assert.ok(localBtn, '按钮仍然渲染(位置稳定)')
|
|
349
349
|
// 「禁用」只在**拿不到绝对路径**时用;拿得到路径但没有服务,走「点了给可见提示」——
|
|
350
350
|
// 与路径面包屑同一条规矩(见「路径:没有 remote.session 服务时给出提示」)
|
package/test/peek.test.mjs
CHANGED
|
@@ -44,7 +44,17 @@ function listPayload(count = 3) {
|
|
|
44
44
|
|
|
45
45
|
/**
|
|
46
46
|
* 装载模块并 apply 到一个带 sessions 的假上下文。
|
|
47
|
-
*
|
|
47
|
+
*
|
|
48
|
+
* ⚠️ 这里的 `sessions.list` 假件**必须照着现行契约写**:
|
|
49
|
+
* `SessionListState { ids, byId, phase, projectionsBySession }`——
|
|
50
|
+
* **没有 `current`**。2026-09-30 之前它假的是 `{ current: 's-1' }`,
|
|
51
|
+
* 一个现行内核里根本不存在的字段,于是 450 条测试全绿、真机上悬停浮层
|
|
52
|
+
* 却永远显示「0 篇」。要测旧内核的兜底路径就传 `legacyCurrent`。
|
|
53
|
+
*
|
|
54
|
+
* 当前会话 id 走**座位 props**(session 作用域的标准 props `sessionId`),
|
|
55
|
+
* 所以渲染入口按钮时要传 `{ sessionId: 's-1' }`。
|
|
56
|
+
*
|
|
57
|
+
* @param {{docs?: number, legacyCurrent?: string}} [options] - 列表条数、旧内核的 current
|
|
48
58
|
* @returns {{exports: object, log: object, fetches: string[]}} 结果
|
|
49
59
|
*/
|
|
50
60
|
function boot(options = {}) {
|
|
@@ -53,6 +63,7 @@ function boot(options = {}) {
|
|
|
53
63
|
const fetches = []
|
|
54
64
|
const { locale } = makeLocale({ active: 'zh' })
|
|
55
65
|
const count = options.docs === undefined ? 3 : options.docs
|
|
66
|
+
const legacy = options.legacyCurrent
|
|
56
67
|
|
|
57
68
|
globalThis.fetch = async (url) => {
|
|
58
69
|
fetches.push(url)
|
|
@@ -63,7 +74,13 @@ function boot(options = {}) {
|
|
|
63
74
|
slots: { inject(n, cb) { cb(); return () => {} }, register() { return () => {} } },
|
|
64
75
|
sessions: {
|
|
65
76
|
list: {
|
|
66
|
-
getSnapshot: () => ({
|
|
77
|
+
getSnapshot: () => ({
|
|
78
|
+
ids: [],
|
|
79
|
+
byId: {},
|
|
80
|
+
phase: 'ready',
|
|
81
|
+
projectionsBySession: {},
|
|
82
|
+
...(legacy === undefined ? {} : { current: legacy }),
|
|
83
|
+
}),
|
|
67
84
|
},
|
|
68
85
|
},
|
|
69
86
|
}
|
|
@@ -97,16 +114,16 @@ test('悬停:进入后延迟才显示,不是一碰就弹', async () => {
|
|
|
97
114
|
const Button = exports.__test.makeEntryButton(() => true)
|
|
98
115
|
|
|
99
116
|
harness.reset()
|
|
100
|
-
let nodes = harness.render(h(Button, {}))
|
|
117
|
+
let nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
101
118
|
assert.equal(peekOf(nodes), undefined, '初始没有浮层')
|
|
102
119
|
|
|
103
120
|
anchorOf(nodes).props.onMouseEnter()
|
|
104
|
-
nodes = harness.render(h(Button, {}))
|
|
121
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
105
122
|
assert.equal(peekOf(nodes), undefined, '刚进入还不该有(要等延时)')
|
|
106
123
|
assert.ok(harness.pendingTimers() >= 1, '应排了一个延时')
|
|
107
124
|
|
|
108
125
|
harness.tick()
|
|
109
|
-
nodes = harness.render(h(Button, {}))
|
|
126
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
110
127
|
assert.ok(peekOf(nodes), '延时到点后才出现')
|
|
111
128
|
})
|
|
112
129
|
|
|
@@ -115,11 +132,11 @@ test('悬停:延时到点后浮层出现,并去拉列表', async () => {
|
|
|
115
132
|
const Button = exports.__test.makeEntryButton(() => true)
|
|
116
133
|
|
|
117
134
|
harness.reset()
|
|
118
|
-
let nodes = harness.render(h(Button, {}))
|
|
135
|
+
let nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
119
136
|
anchorOf(nodes).props.onMouseEnter()
|
|
120
137
|
harness.tick() // 跑掉「延迟显示」
|
|
121
138
|
await harness.flush() // 等拉列表
|
|
122
|
-
nodes = harness.render(h(Button, {}))
|
|
139
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
123
140
|
|
|
124
141
|
const peek = peekOf(nodes)
|
|
125
142
|
assert.ok(peek, '延时到点后应出现浮层')
|
|
@@ -133,33 +150,70 @@ test('悬停:浮层列出文档标题与相对时间', async () => {
|
|
|
133
150
|
const Button = exports.__test.makeEntryButton(() => true)
|
|
134
151
|
|
|
135
152
|
harness.reset()
|
|
136
|
-
let nodes = harness.render(h(Button, {}))
|
|
153
|
+
let nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
137
154
|
anchorOf(nodes).props.onMouseEnter()
|
|
138
155
|
harness.tick()
|
|
139
156
|
await harness.flush()
|
|
140
|
-
nodes = harness.render(h(Button, {}))
|
|
157
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
141
158
|
|
|
142
159
|
const docs = byClass(nodes, 'knit-peek-doc')
|
|
143
160
|
assert.equal(docs.length, 3, '三篇都列出来')
|
|
144
161
|
assert.match(textOf(docs[0]), /文档 0/)
|
|
145
162
|
assert.equal(byClass(nodes, 'knit-peek-time').length, 3, '每篇带相对时间')
|
|
163
|
+
// 2026-10-01 用户要求:列表下面那条横线与「点击打开面板」页脚都删掉 ——
|
|
164
|
+
// 有文档的浮层里**一个 hint 都不该有**(hint 只留给 loading / 空态)
|
|
165
|
+
assert.equal(byClass(nodes, 'knit-peek-hint').length, 0, '有文档时浮层没有多余提示行')
|
|
146
166
|
})
|
|
147
167
|
|
|
148
168
|
test('悬停:没有当前会话时给出空态而不是一直转圈', async () => {
|
|
149
|
-
const { exports } = boot(
|
|
169
|
+
const { exports } = boot()
|
|
150
170
|
const Button = exports.__test.makeEntryButton(() => true)
|
|
151
171
|
|
|
152
172
|
harness.reset()
|
|
153
|
-
let nodes = harness.render(h(Button, {}))
|
|
173
|
+
let nodes = harness.render(h(Button, { sessionId: '' }))
|
|
154
174
|
anchorOf(nodes).props.onMouseEnter()
|
|
155
175
|
harness.tick()
|
|
156
176
|
await harness.flush()
|
|
157
|
-
nodes = harness.render(h(Button, {}))
|
|
177
|
+
nodes = harness.render(h(Button, { sessionId: '' }))
|
|
158
178
|
|
|
159
179
|
assert.ok(peekOf(nodes), '浮层仍在')
|
|
160
180
|
assert.match(textOf(byClass(nodes, 'knit-peek-hint')[0]), /还没有/)
|
|
161
181
|
})
|
|
162
182
|
|
|
183
|
+
/* ── 当前会话 id 的来源(2026-09-30 真机故障的回归闸门)──── */
|
|
184
|
+
|
|
185
|
+
test('会话 id:取座位 props(session 标准 props),不依赖列表快照的 current', async () => {
|
|
186
|
+
// 真机故障:现行内核的 sessions.list 快照没有 current,
|
|
187
|
+
// 老写法读 snapshot.current ⇒ 恒空 ⇒ 浮层永远「0 篇」。
|
|
188
|
+
const { exports, fetches } = boot() // 假件按现行契约写:没有 current
|
|
189
|
+
const Button = exports.__test.makeEntryButton(() => true)
|
|
190
|
+
|
|
191
|
+
harness.reset()
|
|
192
|
+
let nodes = harness.render(h(Button, { sessionId: 's-9' }))
|
|
193
|
+
anchorOf(nodes).props.onMouseEnter()
|
|
194
|
+
harness.tick()
|
|
195
|
+
await harness.flush()
|
|
196
|
+
nodes = harness.render(h(Button, { sessionId: 's-9' }))
|
|
197
|
+
|
|
198
|
+
assert.equal(fetches.length, 1, '应照常去拉列表')
|
|
199
|
+
assert.match(fetches[0], /sessionId=s-9/, '用座位给的会话 id')
|
|
200
|
+
assert.equal(byClass(nodes, 'knit-peek-doc').length, 3, '浮层里真的列出文档')
|
|
201
|
+
})
|
|
202
|
+
|
|
203
|
+
test('会话 id:旧内核没有座位 props 时,退回列表快照的 current', async () => {
|
|
204
|
+
const { exports, fetches } = boot({ legacyCurrent: 's-7' })
|
|
205
|
+
const Button = exports.__test.makeEntryButton(() => true)
|
|
206
|
+
|
|
207
|
+
harness.reset()
|
|
208
|
+
let nodes = harness.render(h(Button, {})) // 旧内核:座位不给 sessionId
|
|
209
|
+
anchorOf(nodes).props.onMouseEnter()
|
|
210
|
+
harness.tick()
|
|
211
|
+
await harness.flush()
|
|
212
|
+
|
|
213
|
+
assert.equal(fetches.length, 1, '兜底路径也应拉列表')
|
|
214
|
+
assert.match(fetches[0], /sessionId=s-7/, '退回快照里的 current')
|
|
215
|
+
})
|
|
216
|
+
|
|
163
217
|
/* ── 离开收起 ───────────────────────────────────────── */
|
|
164
218
|
|
|
165
219
|
test('离开:延迟收起,鼠标移进浮层可取消', async () => {
|
|
@@ -167,11 +221,11 @@ test('离开:延迟收起,鼠标移进浮层可取消', async () => {
|
|
|
167
221
|
const Button = exports.__test.makeEntryButton(() => true)
|
|
168
222
|
|
|
169
223
|
harness.reset()
|
|
170
|
-
let nodes = harness.render(h(Button, {}))
|
|
224
|
+
let nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
171
225
|
anchorOf(nodes).props.onMouseEnter()
|
|
172
226
|
harness.tick()
|
|
173
227
|
await harness.flush()
|
|
174
|
-
nodes = harness.render(h(Button, {}))
|
|
228
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
175
229
|
assert.ok(peekOf(nodes), '先显示出来')
|
|
176
230
|
|
|
177
231
|
// 离开按钮 → 排一个收起延时
|
|
@@ -179,13 +233,13 @@ test('离开:延迟收起,鼠标移进浮层可取消', async () => {
|
|
|
179
233
|
// 还没到点,鼠标移进浮层 → 取消收起
|
|
180
234
|
peekOf(nodes).props.onMouseEnter()
|
|
181
235
|
harness.tick()
|
|
182
|
-
nodes = harness.render(h(Button, {}))
|
|
236
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
183
237
|
assert.ok(peekOf(nodes), '移进浮层后不该被收起')
|
|
184
238
|
|
|
185
239
|
// 真正离开浮层
|
|
186
240
|
peekOf(nodes).props.onMouseLeave()
|
|
187
241
|
harness.tick()
|
|
188
|
-
nodes = harness.render(h(Button, {}))
|
|
242
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
189
243
|
assert.equal(peekOf(nodes), undefined, '离开后应收起')
|
|
190
244
|
})
|
|
191
245
|
|
|
@@ -197,17 +251,17 @@ test('点击按钮:收起浮层并打开面板', async () => {
|
|
|
197
251
|
const Button = exports.__test.makeEntryButton(() => { opened.push(1); return true })
|
|
198
252
|
|
|
199
253
|
harness.reset()
|
|
200
|
-
let nodes = harness.render(h(Button, {}))
|
|
254
|
+
let nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
201
255
|
anchorOf(nodes).props.onMouseEnter()
|
|
202
256
|
harness.tick()
|
|
203
257
|
await harness.flush()
|
|
204
|
-
nodes = harness.render(h(Button, {}))
|
|
258
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
205
259
|
|
|
206
260
|
let prevented = false
|
|
207
261
|
let stopped = false
|
|
208
262
|
buttonOf(nodes).props.onClick({ preventDefault() { prevented = true }, stopPropagation() { stopped = true } })
|
|
209
263
|
|
|
210
|
-
nodes = harness.render(h(Button, {}))
|
|
264
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
211
265
|
assert.equal(peekOf(nodes), undefined, '点击后浮层应收起')
|
|
212
266
|
assert.equal(opened.length, 1, '应打开面板')
|
|
213
267
|
assert.equal(prevented, true)
|
|
@@ -220,15 +274,15 @@ test('点击浮层里的某一篇:打开面板并记住要预览哪一篇', as
|
|
|
220
274
|
const Button = exports.__test.makeEntryButton(() => { opened.push(1); return true })
|
|
221
275
|
|
|
222
276
|
harness.reset()
|
|
223
|
-
let nodes = harness.render(h(Button, {}))
|
|
277
|
+
let nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
224
278
|
anchorOf(nodes).props.onMouseEnter()
|
|
225
279
|
harness.tick()
|
|
226
280
|
await harness.flush()
|
|
227
|
-
nodes = harness.render(h(Button, {}))
|
|
281
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
228
282
|
|
|
229
283
|
byClass(nodes, 'knit-peek-doc')[1].props.onClick() // 点第二篇
|
|
230
284
|
|
|
231
|
-
nodes = harness.render(h(Button, {}))
|
|
285
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
232
286
|
assert.equal(peekOf(nodes), undefined, '点完应收起浮层')
|
|
233
287
|
assert.equal(opened.length, 1, '应打开面板')
|
|
234
288
|
|
|
@@ -248,11 +302,11 @@ test('点击浮层里的某一篇:只消费一次,不粘住下一次打开',
|
|
|
248
302
|
const { KnitBody } = exports.__test
|
|
249
303
|
|
|
250
304
|
harness.reset()
|
|
251
|
-
let nodes = harness.render(h(Button, {}))
|
|
305
|
+
let nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
252
306
|
anchorOf(nodes).props.onMouseEnter()
|
|
253
307
|
harness.tick()
|
|
254
308
|
await harness.flush()
|
|
255
|
-
nodes = harness.render(h(Button, {}))
|
|
309
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
256
310
|
|
|
257
311
|
byClass(nodes, 'knit-peek-doc')[0].props.onClick()
|
|
258
312
|
|
|
@@ -276,11 +330,11 @@ test('浮层:没有可用宿主时点击也不抛错', async () => {
|
|
|
276
330
|
const Button = exports.__test.makeEntryButton(() => false)
|
|
277
331
|
|
|
278
332
|
harness.reset()
|
|
279
|
-
let nodes = harness.render(h(Button, {}))
|
|
333
|
+
let nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
280
334
|
anchorOf(nodes).props.onMouseEnter()
|
|
281
335
|
harness.tick()
|
|
282
336
|
await harness.flush()
|
|
283
|
-
nodes = harness.render(h(Button, {}))
|
|
337
|
+
nodes = harness.render(h(Button, { sessionId: 's-1' }))
|
|
284
338
|
|
|
285
339
|
assert.doesNotThrow(() => buttonOf(nodes).props.onClick({ preventDefault() {}, stopPropagation() {} }))
|
|
286
340
|
})
|