dsh-knit 0.4.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/LICENSE +21 -0
- package/README.en.md +178 -0
- package/README.md +167 -0
- package/assets/knit-icon-24-mono-4px.svg +1 -0
- package/cordis.patch.yml +8 -0
- package/package.json +63 -0
- package/src/client/client.js +1170 -0
- package/src/host/index.js +653 -0
- package/src/host/relevance.js +236 -0
- package/test/client.test.mjs +500 -0
- package/test/entry.test.mjs +232 -0
- package/test/harness.mjs +235 -0
- package/test/host.test.mjs +249 -0
- package/test/i18n.test.mjs +344 -0
- package/test/icon.test.mjs +153 -0
- package/test/tier1.test.mjs +443 -0
|
@@ -0,0 +1,249 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 宿主半边测试:解析、越界防护、相关性排序、对话事件提取。
|
|
3
|
+
*
|
|
4
|
+
* 跑法:node --test test/
|
|
5
|
+
*/
|
|
6
|
+
import test from 'node:test'
|
|
7
|
+
import assert from 'node:assert/strict'
|
|
8
|
+
import { fileURLToPath } from 'node:url'
|
|
9
|
+
|
|
10
|
+
import {
|
|
11
|
+
parseMarkdown,
|
|
12
|
+
scan,
|
|
13
|
+
readDocument,
|
|
14
|
+
collectDocs,
|
|
15
|
+
ERROR_CODES,
|
|
16
|
+
} from '../src/host/index.js'
|
|
17
|
+
import { extractKeywords, rankByRelevance, topicLabel } from '../src/host/relevance.js'
|
|
18
|
+
|
|
19
|
+
/** 本仓库根(08_Knit),里面有真实 Markdown 可当样本。 */
|
|
20
|
+
const PROJECT_ROOT = fileURLToPath(new URL('../../', import.meta.url))
|
|
21
|
+
|
|
22
|
+
/**
|
|
23
|
+
* 造一个假的宿主会话对象。
|
|
24
|
+
* @param {Array<object>} events - 会话事件
|
|
25
|
+
* @returns {object} 假会话
|
|
26
|
+
*/
|
|
27
|
+
function fakeSession(events) {
|
|
28
|
+
return {
|
|
29
|
+
header: { cwd: PROJECT_ROOT },
|
|
30
|
+
snapshotEvents: () => events,
|
|
31
|
+
}
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
/**
|
|
35
|
+
* 造一条会话事件。
|
|
36
|
+
* @param {string} type - 事件类型
|
|
37
|
+
* @param {number} seq - 序号
|
|
38
|
+
* @param {object} data - 载荷
|
|
39
|
+
* @returns {object} 事件
|
|
40
|
+
*/
|
|
41
|
+
function ev(type, seq, data) {
|
|
42
|
+
return { type, seq, time: Date.now(), data }
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
/**
|
|
46
|
+
* 造一条用户消息事件。
|
|
47
|
+
* @param {number} seq - 序号
|
|
48
|
+
* @param {string} text - 文本
|
|
49
|
+
* @param {string} kind - source.kind
|
|
50
|
+
* @returns {object} 事件
|
|
51
|
+
*/
|
|
52
|
+
function userMessage(seq, text, kind = 'user') {
|
|
53
|
+
return ev('user/message', seq, {
|
|
54
|
+
role: 'user',
|
|
55
|
+
content: [{ type: 'text', text }],
|
|
56
|
+
source: kind === 'user' ? { kind: 'user' } : { kind, plugin: 'test' },
|
|
57
|
+
})
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
/**
|
|
61
|
+
* 造一条助手消息事件。
|
|
62
|
+
* @param {number} seq - 序号
|
|
63
|
+
* @param {string} text - 文本
|
|
64
|
+
* @returns {object} 事件
|
|
65
|
+
*/
|
|
66
|
+
function assistantMessage(seq, text) {
|
|
67
|
+
return ev('assistant/message', seq, {
|
|
68
|
+
message: { role: 'assistant', content: [{ type: 'text', text }] },
|
|
69
|
+
})
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
/* ── parseMarkdown ─────────────────────────────────── */
|
|
73
|
+
|
|
74
|
+
test('parseMarkdown: 跳过 YAML frontmatter,取 H1 与首段', () => {
|
|
75
|
+
const head = ['---', 'title: x', '---', '', '# 我的标题', '', '这是第一段正文。', '', '## 二级', '第二段'].join('\n')
|
|
76
|
+
assert.deepEqual(parseMarkdown(head, 'fallback.md'), { title: '我的标题', summary: '这是第一段正文。' })
|
|
77
|
+
})
|
|
78
|
+
|
|
79
|
+
test('parseMarkdown: 没有 H1 时用文件名', () => {
|
|
80
|
+
const head = ['', '直接就是正文。'].join('\n')
|
|
81
|
+
assert.equal(parseMarkdown(head, '中文文件名.md').title, '中文文件名')
|
|
82
|
+
})
|
|
83
|
+
|
|
84
|
+
test('parseMarkdown: 跳过列表/引用/表格/围栏,取真正的正文', () => {
|
|
85
|
+
const head = ['# T', '', '- 列表项', '> 引用', '| a | b |', '```', 'code', '```', '真正的第一段。'].join('\n')
|
|
86
|
+
assert.equal(parseMarkdown(head, 'x.md').summary, '真正的第一段。')
|
|
87
|
+
})
|
|
88
|
+
|
|
89
|
+
test('parseMarkdown: 摘要按 60 字截断并加省略号', () => {
|
|
90
|
+
const long = '啊'.repeat(200)
|
|
91
|
+
const { summary } = parseMarkdown(`# T\n\n${long}`, 'x.md')
|
|
92
|
+
assert.equal(summary.length, 61)
|
|
93
|
+
assert.ok(summary.endsWith('…'))
|
|
94
|
+
})
|
|
95
|
+
|
|
96
|
+
/* ── 扫描 ──────────────────────────────────────────── */
|
|
97
|
+
|
|
98
|
+
test('collectDocs: 扫到工作区 Markdown,且 mtime 倒序', async () => {
|
|
99
|
+
const { docs } = await collectDocs(PROJECT_ROOT)
|
|
100
|
+
assert.ok(docs.length >= 3, `至少应有 3 篇,实际 ${docs.length}`)
|
|
101
|
+
for (let i = 1; i < docs.length; i += 1) {
|
|
102
|
+
assert.ok(docs[i - 1].mtimeMs >= docs[i].mtimeMs, 'mtime 必须倒序')
|
|
103
|
+
}
|
|
104
|
+
assert.ok(docs.every((d) => d.haystack && typeof d.haystack.body === 'string'), '每篇都要带 haystack')
|
|
105
|
+
})
|
|
106
|
+
|
|
107
|
+
test('collectDocs: 跳过 node_modules 与隐藏目录', async () => {
|
|
108
|
+
const { docs } = await collectDocs(PROJECT_ROOT)
|
|
109
|
+
assert.ok(!docs.some((d) => d.rel.includes('node_modules')), '不应包含 node_modules')
|
|
110
|
+
assert.ok(!docs.some((d) => d.rel.split('/').some((seg) => seg.startsWith('.'))), '不应包含隐藏目录')
|
|
111
|
+
})
|
|
112
|
+
|
|
113
|
+
/* ── readDocument 越界防护 ──────────────────────────── */
|
|
114
|
+
|
|
115
|
+
test('readDocument: 正常路径可读', async () => {
|
|
116
|
+
const r = await readDocument(PROJECT_ROOT, 'README.md')
|
|
117
|
+
assert.equal(r.ok, true)
|
|
118
|
+
assert.match(r.text, /Knit/)
|
|
119
|
+
})
|
|
120
|
+
|
|
121
|
+
test('readDocument: 拒绝目录穿越', async () => {
|
|
122
|
+
const r = await readDocument(PROJECT_ROOT, '../../../../etc/passwd')
|
|
123
|
+
assert.equal(r.ok, false)
|
|
124
|
+
assert.equal(r.code, ERROR_CODES.outsideWorkspace)
|
|
125
|
+
})
|
|
126
|
+
|
|
127
|
+
test('readDocument: 拒绝绝对路径逃逸', async () => {
|
|
128
|
+
const r = await readDocument(PROJECT_ROOT, '/etc/passwd')
|
|
129
|
+
assert.equal(r.ok, false)
|
|
130
|
+
})
|
|
131
|
+
|
|
132
|
+
test('readDocument: 拒绝非 Markdown', async () => {
|
|
133
|
+
const r = await readDocument(PROJECT_ROOT, 'knit/package.json')
|
|
134
|
+
assert.equal(r.ok, false)
|
|
135
|
+
assert.equal(r.code, ERROR_CODES.markdownOnly)
|
|
136
|
+
})
|
|
137
|
+
|
|
138
|
+
/* ── 相关性引擎 ─────────────────────────────────────── */
|
|
139
|
+
|
|
140
|
+
test('extractKeywords: 中文取到有意义的词,滤掉虚词', () => {
|
|
141
|
+
const kws = extractKeywords([
|
|
142
|
+
'把 better-sidebar 注册和相关性排序这两个补上',
|
|
143
|
+
'相关性排序要用本地关键词匹配,不要调模型',
|
|
144
|
+
], 20)
|
|
145
|
+
const terms = kws.map((k) => k.term)
|
|
146
|
+
assert.ok(terms.some((t) => t.includes('相关性')), `应含「相关性」,实际 ${terms.join('/')}`)
|
|
147
|
+
assert.ok(terms.includes('better'), '应含 better')
|
|
148
|
+
assert.ok(!terms.includes('的'), '不应含虚词')
|
|
149
|
+
assert.ok(!terms.includes('我们'), '不应含 2-gram 虚词')
|
|
150
|
+
})
|
|
151
|
+
|
|
152
|
+
test('extractKeywords: 最新消息只出现一次的词也保留,旧消息的要重复才要', () => {
|
|
153
|
+
const kws = extractKeywords(['最新话题甲甲甲', '很久以前的话题乙乙乙'], 5)
|
|
154
|
+
assert.ok(kws.length > 0, '应取到词')
|
|
155
|
+
// 旧消息里的词只出现一次、且不在最新消息里 → 整段滤掉
|
|
156
|
+
assert.ok(kws.every((k) => !k.term.includes('乙')), `不该出现旧消息的词:${kws.map((k) => k.term).join('/')}`)
|
|
157
|
+
assert.ok(kws.some((k) => k.term.includes('甲')), `应含最新消息的词:${kws.map((k) => k.term).join('/')}`)
|
|
158
|
+
})
|
|
159
|
+
|
|
160
|
+
test('extractKeywords: 最新消息的中文片段会进入候选(当下话题的最强信号)', () => {
|
|
161
|
+
const kws = extractKeywords(['独一无二词汇出现了'], 20)
|
|
162
|
+
assert.ok(kws.length > 0, '最新消息里的词应当保留')
|
|
163
|
+
assert.ok(kws.every((k) => '独一无二词汇出现了'.includes(k.term)), '不应凭空造词')
|
|
164
|
+
})
|
|
165
|
+
|
|
166
|
+
test('extractKeywords: 单次出现的 ASCII 词保留(chokidar 这种精确词很值钱)', () => {
|
|
167
|
+
const kws = extractKeywords(['先放着', '试试 chokidar 吧'], 20)
|
|
168
|
+
assert.ok(kws.some((k) => k.term === 'chokidar'), `应保留 chokidar,实际 ${kws.map((k) => k.term).join('/')}`)
|
|
169
|
+
})
|
|
170
|
+
|
|
171
|
+
test('rankByRelevance: 命中多的排前面且分数归一', () => {
|
|
172
|
+
const docs = [
|
|
173
|
+
{ rel: 'a.md', mtimeMs: Date.now(), haystack: { title: '相关性排序', summary: '', body: '相关性排序 相关性排序' } },
|
|
174
|
+
{ rel: 'b.md', mtimeMs: Date.now(), haystack: { title: '', summary: '', body: '无关内容' } },
|
|
175
|
+
]
|
|
176
|
+
const kws = extractKeywords(['相关性排序 相关性排序', '相关性排序'], 10)
|
|
177
|
+
const { docs: ranked } = rankByRelevance(docs, kws, Date.now())
|
|
178
|
+
assert.equal(ranked[0].rel, 'a.md')
|
|
179
|
+
assert.equal(ranked[0].score, 100)
|
|
180
|
+
assert.equal(ranked[1].score, 0)
|
|
181
|
+
})
|
|
182
|
+
|
|
183
|
+
test('rankByRelevance: 没有关键词时全部 0 分且不打乱顺序', () => {
|
|
184
|
+
const docs = [
|
|
185
|
+
{ rel: 'a.md', mtimeMs: 2, haystack: { title: '', summary: '', body: '' } },
|
|
186
|
+
{ rel: 'b.md', mtimeMs: 1, haystack: { title: '', summary: '', body: '' } },
|
|
187
|
+
]
|
|
188
|
+
const { docs: ranked } = rankByRelevance(docs, [], Date.now())
|
|
189
|
+
assert.deepEqual(ranked.map((d) => d.rel), ['a.md', 'b.md'])
|
|
190
|
+
assert.ok(ranked.every((d) => d.score === 0))
|
|
191
|
+
})
|
|
192
|
+
|
|
193
|
+
test('topicLabel: 用、连接前几个词', () => {
|
|
194
|
+
assert.equal(topicLabel([{ term: '相关性' }, { term: '排序' }, { term: 'sidebar' }]), '相关性、排序、sidebar')
|
|
195
|
+
})
|
|
196
|
+
|
|
197
|
+
/* ── scan 与排序模式 ────────────────────────────────── */
|
|
198
|
+
|
|
199
|
+
test('scan: sort=time 时 score 为 null 且 mode 为 time', async () => {
|
|
200
|
+
const r = await scan(PROJECT_ROOT, 10, { session: fakeSession([]), sessionId: 's', sort: 'time' })
|
|
201
|
+
assert.equal(r.mode, 'time')
|
|
202
|
+
assert.equal(r.topic, '')
|
|
203
|
+
assert.ok(r.docs.every((d) => d.score === null))
|
|
204
|
+
})
|
|
205
|
+
|
|
206
|
+
test('scan: sort=relevance 且有对话时给出分数与主题', async () => {
|
|
207
|
+
const session = fakeSession([
|
|
208
|
+
userMessage(1, '把 better-sidebar 注册和相关性排序这两个补上'),
|
|
209
|
+
assistantMessage(2, '我先做纯本地的相关性排序,再接 better-sidebar 的 registerTab。'),
|
|
210
|
+
userMessage(3, '相关性排序不要调模型'),
|
|
211
|
+
])
|
|
212
|
+
const r = await scan(PROJECT_ROOT, 10, { session, sessionId: 's', sort: 'relevance' })
|
|
213
|
+
assert.equal(r.mode, 'relevance')
|
|
214
|
+
assert.ok(r.topic.length > 0, '应给出话题标签')
|
|
215
|
+
assert.ok(r.docs.every((d) => typeof d.score === 'number'), '每篇都应有分数')
|
|
216
|
+
assert.ok(r.docs[0].score >= r.docs[r.docs.length - 1].score, '分数应降序')
|
|
217
|
+
})
|
|
218
|
+
|
|
219
|
+
test('scan: relevance 但会话无事件 → 老实退回 time', async () => {
|
|
220
|
+
const r = await scan(PROJECT_ROOT, 10, { session: fakeSession([]), sessionId: 's', sort: 'relevance' })
|
|
221
|
+
assert.equal(r.mode, 'time')
|
|
222
|
+
})
|
|
223
|
+
|
|
224
|
+
test('scan: relevance 但没有 session 对象 → 退回 time', async () => {
|
|
225
|
+
const r = await scan(PROJECT_ROOT, 10, { sessionId: 's', sort: 'relevance' })
|
|
226
|
+
assert.equal(r.mode, 'time')
|
|
227
|
+
})
|
|
228
|
+
|
|
229
|
+
test('scan: agent 注入的合成消息不算用户意图', async () => {
|
|
230
|
+
const session = fakeSession([
|
|
231
|
+
userMessage(1, 'AGENTS.md 项目约定:相关性排序 宿主半边 mtime 协议', 'plugin'),
|
|
232
|
+
])
|
|
233
|
+
const r = await scan(PROJECT_ROOT, 10, { session, sessionId: 's', sort: 'relevance' })
|
|
234
|
+
assert.equal(r.mode, 'time', '只有合成消息时应退回 time')
|
|
235
|
+
assert.deepEqual(r.keywords, [])
|
|
236
|
+
})
|
|
237
|
+
|
|
238
|
+
test('scan: 不把内部 haystack 泄漏给浏览器', async () => {
|
|
239
|
+
const session = fakeSession([userMessage(1, '相关性排序 相关性排序')])
|
|
240
|
+
const r = await scan(PROJECT_ROOT, 10, { session, sessionId: 's', sort: 'relevance' })
|
|
241
|
+
assert.ok(r.docs.every((d) => d.haystack === undefined), 'haystack 是内部字段')
|
|
242
|
+
assert.ok(r.docs.every((d) => typeof d.rel === 'string' && typeof d.mtimeMs === 'number'))
|
|
243
|
+
})
|
|
244
|
+
|
|
245
|
+
test('scan: limit 生效', async () => {
|
|
246
|
+
const r = await scan(PROJECT_ROOT, 2, { sessionId: 's', sort: 'time' })
|
|
247
|
+
assert.ok(r.docs.length <= 2)
|
|
248
|
+
assert.ok(r.total >= r.docs.length)
|
|
249
|
+
})
|
|
@@ -0,0 +1,344 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 国际化测试:中英双语、占位符、宿主错误码翻译、词典键对齐。
|
|
3
|
+
*
|
|
4
|
+
* 跑法:node --test test/
|
|
5
|
+
*/
|
|
6
|
+
import test from 'node:test'
|
|
7
|
+
import assert from 'node:assert/strict'
|
|
8
|
+
|
|
9
|
+
import { loadClientModule, createHarness, byClass, textOf, makeLocale } from './harness.mjs'
|
|
10
|
+
|
|
11
|
+
const harness = createHarness()
|
|
12
|
+
const React = globalThis.__knitReact
|
|
13
|
+
const h = React.createElement
|
|
14
|
+
|
|
15
|
+
/* ── 脚手架 ─────────────────────────────────────────── */
|
|
16
|
+
|
|
17
|
+
/**
|
|
18
|
+
* 造一个假上下文,用于把模块 apply 起来(真实运行时由 DSH 调用)。
|
|
19
|
+
* @param {string} locale - 活动语言
|
|
20
|
+
* @returns {{ctx: object, log: object, registered: object}} 上下文与记录
|
|
21
|
+
*/
|
|
22
|
+
function contextFor(locale) {
|
|
23
|
+
const log = { tabs: [], bsTabs: [], slots: [], effects: [] }
|
|
24
|
+
const { locale: localeService, registered } = makeLocale({ active: locale })
|
|
25
|
+
|
|
26
|
+
const slots = {
|
|
27
|
+
inject(name, cb) { cb(); return () => {} },
|
|
28
|
+
register(opts, component) { log.slots.push({ opts, component }); return () => {} },
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
const services = { slots, locale: localeService }
|
|
32
|
+
services.sidebarRightTabs = { register(def) { log.tabs.push(def); return () => {} } }
|
|
33
|
+
|
|
34
|
+
const ctx = {
|
|
35
|
+
slots,
|
|
36
|
+
locale: localeService,
|
|
37
|
+
effect(fn, label) { log.effects.push(label); return fn() },
|
|
38
|
+
get(name) { return services[name] },
|
|
39
|
+
inject(deps, callback) {
|
|
40
|
+
for (const dep of deps) if (!services[dep]) return
|
|
41
|
+
const face = { ...services }
|
|
42
|
+
face.effect = (fn, label) => { log.effects.push(label); return fn() }
|
|
43
|
+
callback(face)
|
|
44
|
+
},
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
return { ctx, log, registered }
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
/**
|
|
51
|
+
* 装载模块并 apply 到指定语言。
|
|
52
|
+
* @param {string} locale - 活动语言
|
|
53
|
+
* @param {object} [options] - 传给 loadClientModule
|
|
54
|
+
* @returns {{exports: object, log: object, registered: object}} 结果
|
|
55
|
+
*/
|
|
56
|
+
function boot(locale, options) {
|
|
57
|
+
const loaded = loadClientModule(options)
|
|
58
|
+
const { ctx, log, registered } = contextFor(locale)
|
|
59
|
+
loaded.exports.apply(ctx)
|
|
60
|
+
return { exports: loaded.exports, log, registered, markdownCalls: loaded.markdownCalls }
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
/**
|
|
64
|
+
* 造一份列表载荷。
|
|
65
|
+
* @param {object} overrides - 覆盖字段
|
|
66
|
+
* @returns {object} 载荷
|
|
67
|
+
*/
|
|
68
|
+
function listPayload(overrides = {}) {
|
|
69
|
+
return {
|
|
70
|
+
ok: true,
|
|
71
|
+
root: '/p',
|
|
72
|
+
total: 2,
|
|
73
|
+
mode: 'time',
|
|
74
|
+
topic: '',
|
|
75
|
+
docs: [
|
|
76
|
+
{ path: '/p/a.md', rel: 'a.md', name: 'a.md', title: 'A', summary: 's', mtimeMs: Date.now(), score: null },
|
|
77
|
+
{ path: '/p/b.md', rel: 'b.md', name: 'b.md', title: 'B', summary: 's', mtimeMs: Date.now() - 9e7, score: null },
|
|
78
|
+
],
|
|
79
|
+
...overrides,
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
/**
|
|
84
|
+
* 装一个 fetch 替身。
|
|
85
|
+
* @param {Function} responder - 按 url 返回载荷
|
|
86
|
+
* @returns {{calls: string[]}} 调用记录
|
|
87
|
+
*/
|
|
88
|
+
function installFetch(responder) {
|
|
89
|
+
const calls = []
|
|
90
|
+
globalThis.fetch = async (url) => {
|
|
91
|
+
calls.push(url)
|
|
92
|
+
return { json: async () => responder(url) }
|
|
93
|
+
}
|
|
94
|
+
return { calls }
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
/**
|
|
98
|
+
* 在指定语言下渲染面板并返回扁平节点。
|
|
99
|
+
* @param {string} locale - 活动语言
|
|
100
|
+
* @param {object} compose - 返回 fetch 响应的函数
|
|
101
|
+
* @returns {Promise<{nodes: object[], exports: object}>} 节点与模块导出
|
|
102
|
+
*/
|
|
103
|
+
async function renderPanel(locale, compose) {
|
|
104
|
+
installFetch(compose)
|
|
105
|
+
const { exports } = boot(locale)
|
|
106
|
+
const { KnitBody } = exports.__test
|
|
107
|
+
const rerender = (flush = false) => {
|
|
108
|
+
let next = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
109
|
+
if (flush) {
|
|
110
|
+
// 先 render 登记 effect,再执行它们,最后渲染出新结果
|
|
111
|
+
return harness.flush().then(() => harness.render(h(KnitBody, { sessionId: 's1' })))
|
|
112
|
+
}
|
|
113
|
+
return Promise.resolve(next)
|
|
114
|
+
}
|
|
115
|
+
harness.reset()
|
|
116
|
+
let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
117
|
+
await harness.flush()
|
|
118
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
119
|
+
return { nodes, exports, rerender }
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
/* ── 词典本身 ───────────────────────────────────────── */
|
|
123
|
+
|
|
124
|
+
test('词典:zh 与 en 的键集完全一致(缺一条就会回落到显示 key)', () => {
|
|
125
|
+
const { registered } = boot('zh')
|
|
126
|
+
const dicts = registered.knit
|
|
127
|
+
|
|
128
|
+
assert.ok(dicts, '应注册了 knit 命名空间')
|
|
129
|
+
assert.ok(dicts.zh, '应有 zh 词典')
|
|
130
|
+
assert.ok(dicts.en, '应有 en 词典')
|
|
131
|
+
|
|
132
|
+
const zhKeys = Object.keys(dicts.zh).sort()
|
|
133
|
+
const enKeys = Object.keys(dicts.en).sort()
|
|
134
|
+
|
|
135
|
+
const missingInEn = zhKeys.filter((k) => !(k in dicts.en))
|
|
136
|
+
const missingInZh = enKeys.filter((k) => !(k in dicts.zh))
|
|
137
|
+
assert.deepEqual(missingInEn, [], `en 缺这些键:${missingInEn.join(', ')}`)
|
|
138
|
+
assert.deepEqual(missingInZh, [], `zh 缺这些键:${missingInZh.join(', ')}`)
|
|
139
|
+
|
|
140
|
+
assert.ok(zhKeys.length >= 40, `词典条目偏少(${zhKeys.length} 条),是不是漏了一整块`)
|
|
141
|
+
})
|
|
142
|
+
|
|
143
|
+
test('词典:中英两边的占位符必须一一对应', () => {
|
|
144
|
+
const { registered } = boot('zh')
|
|
145
|
+
const { zh, en } = registered.knit
|
|
146
|
+
|
|
147
|
+
/**
|
|
148
|
+
* 抽出一个模板串里的占位符名。
|
|
149
|
+
* @param {string} template - 模板
|
|
150
|
+
* @returns {string[]} 占位符名(已排序)
|
|
151
|
+
*/
|
|
152
|
+
const holders = (template) => (String(template).match(/\{(\w+)\}/g) || []).map((s) => s).sort()
|
|
153
|
+
|
|
154
|
+
for (const key of Object.keys(zh)) {
|
|
155
|
+
assert.deepEqual(
|
|
156
|
+
holders(zh[key]),
|
|
157
|
+
holders(en[key]),
|
|
158
|
+
`键 ${key} 的占位符两边不一致:zh=${zh[key]} / en=${en[key]}`,
|
|
159
|
+
)
|
|
160
|
+
}
|
|
161
|
+
})
|
|
162
|
+
|
|
163
|
+
test('词典:不存在空串或残留的 key 自指', () => {
|
|
164
|
+
const { registered } = boot('zh')
|
|
165
|
+
for (const locale of ['zh', 'en']) {
|
|
166
|
+
for (const [key, value] of Object.entries(registered.knit[locale])) {
|
|
167
|
+
assert.ok(String(value).trim().length > 0, `${locale} 的 ${key} 是空的`)
|
|
168
|
+
}
|
|
169
|
+
}
|
|
170
|
+
})
|
|
171
|
+
|
|
172
|
+
/* ── 界面文案 ───────────────────────────────────────── */
|
|
173
|
+
|
|
174
|
+
test('渲染:英文环境下整个面板出英文', async () => {
|
|
175
|
+
const { nodes } = await renderPanel('en', () => listPayload())
|
|
176
|
+
|
|
177
|
+
assert.equal(textOf(byClass(nodes, 'knit-count')[0]), '2 docs')
|
|
178
|
+
// 默认排序偏好是「相关」,但宿主只给了 time 模式 → 如实说明「对话不足,暂按时间」
|
|
179
|
+
assert.match(textOf(byClass(nodes, 'knit-topic')[0]), /Not enough conversation yet/)
|
|
180
|
+
assert.deepEqual(
|
|
181
|
+
byClass(nodes, 'knit-seg-btn').map(textOf),
|
|
182
|
+
['Relevant', 'Recent'],
|
|
183
|
+
)
|
|
184
|
+
assert.equal(byClass(nodes, 'knit-filter')[0].props.placeholder, 'Filter title / summary / path')
|
|
185
|
+
assert.equal(textOf(byClass(nodes, 'knit-btn')[0]), 'Refresh')
|
|
186
|
+
})
|
|
187
|
+
|
|
188
|
+
test('渲染:中文环境下整个面板出中文', async () => {
|
|
189
|
+
const { nodes } = await renderPanel('zh', () => listPayload())
|
|
190
|
+
|
|
191
|
+
assert.equal(textOf(byClass(nodes, 'knit-count')[0]), '2 篇')
|
|
192
|
+
assert.match(textOf(byClass(nodes, 'knit-topic')[0]), /对话内容还不足/)
|
|
193
|
+
assert.deepEqual(
|
|
194
|
+
byClass(nodes, 'knit-seg-btn').map(textOf),
|
|
195
|
+
['相关', '最新'],
|
|
196
|
+
)
|
|
197
|
+
assert.equal(byClass(nodes, 'knit-filter')[0].props.placeholder, '过滤标题 / 摘要 / 路径')
|
|
198
|
+
assert.equal(textOf(byClass(nodes, 'knit-btn')[0]), '刷新')
|
|
199
|
+
})
|
|
200
|
+
|
|
201
|
+
test('渲染:占位符按语言正确替换(含过滤计数)', async () => {
|
|
202
|
+
const panel = await renderPanel('en', () => listPayload())
|
|
203
|
+
|
|
204
|
+
// 未过滤:{n} docs
|
|
205
|
+
assert.equal(textOf(byClass(panel.nodes, 'knit-count')[0]), '2 docs')
|
|
206
|
+
|
|
207
|
+
// 过滤掉一篇:{hit} / {total} docs
|
|
208
|
+
byClass(panel.nodes, 'knit-filter')[0].props.onChange({ target: { value: 'a.md' } })
|
|
209
|
+
const filtered = await panel.rerender()
|
|
210
|
+
assert.equal(textOf(byClass(filtered, 'knit-count')[0]), '1 / 2 docs')
|
|
211
|
+
assert.equal(byClass(filtered, 'knit-doc').length, 1)
|
|
212
|
+
})
|
|
213
|
+
|
|
214
|
+
test('渲染:相关性模式下英文话题行带 {topic} 替换', async () => {
|
|
215
|
+
const { nodes } = await renderPanel('en', () => listPayload({
|
|
216
|
+
mode: 'relevance',
|
|
217
|
+
topic: 'sidebar、registry',
|
|
218
|
+
}))
|
|
219
|
+
const topic = textOf(byClass(nodes, 'knit-topic')[0])
|
|
220
|
+
assert.match(topic, /Sorted by “sidebar、registry”/)
|
|
221
|
+
})
|
|
222
|
+
|
|
223
|
+
test('渲染:显式切到「最新」后,话题行说明按修改时间排', async () => {
|
|
224
|
+
const en = await renderPanel('en', () => listPayload())
|
|
225
|
+
byClass(en.nodes, 'knit-seg-btn').find((n) => textOf(n) === 'Recent').props.onClick()
|
|
226
|
+
const after = await en.rerender()
|
|
227
|
+
assert.match(textOf(byClass(after, 'knit-topic')[0]), /Sorted by modified time/)
|
|
228
|
+
|
|
229
|
+
const zh = await renderPanel('zh', () => listPayload())
|
|
230
|
+
byClass(zh.nodes, 'knit-seg-btn').find((n) => textOf(n) === '最新').props.onClick()
|
|
231
|
+
const afterZh = await zh.rerender()
|
|
232
|
+
assert.match(textOf(byClass(afterZh, 'knit-topic')[0]), /按修改时间倒序/)
|
|
233
|
+
})
|
|
234
|
+
|
|
235
|
+
test('渲染:英文空态 / 错误态文案', async () => {
|
|
236
|
+
const empty = await renderPanel('en', () => listPayload({ docs: [], total: 0 }))
|
|
237
|
+
assert.match(textOf(byClass(empty.nodes, 'knit-msg')[0]), /No Markdown documents/)
|
|
238
|
+
|
|
239
|
+
const failed = await renderPanel('en', () => ({ ok: false, code: 'knit/not-found' }))
|
|
240
|
+
assert.match(textOf(byClass(failed.nodes, 'knit-msg')[0]), /File not found/)
|
|
241
|
+
})
|
|
242
|
+
|
|
243
|
+
/* ── 宿主错误码翻译 ─────────────────────────────────── */
|
|
244
|
+
|
|
245
|
+
test('错误码:中英各自翻译,不是把码直接抛给用户', async () => {
|
|
246
|
+
const en = await renderPanel('en', () => ({ ok: false, code: 'knit/outside-workspace' }))
|
|
247
|
+
assert.match(textOf(byClass(en.nodes, 'knit-msg')[0]), /Path escapes the workspace/)
|
|
248
|
+
|
|
249
|
+
const zh = await renderPanel('zh', () => ({ ok: false, code: 'knit/outside-workspace' }))
|
|
250
|
+
assert.match(textOf(byClass(zh.nodes, 'knit-msg')[0]), /路径越出工作区/)
|
|
251
|
+
})
|
|
252
|
+
|
|
253
|
+
test('错误码:覆盖宿主声明的每一个码,不漏翻', async () => {
|
|
254
|
+
const { readFileSync } = await import('node:fs')
|
|
255
|
+
const hostSource = readFileSync(new URL('../src/host/index.js', import.meta.url), 'utf8')
|
|
256
|
+
|
|
257
|
+
const codes = [...hostSource.matchAll(/'(knit\/[a-z-]+)'/g)].map((m) => m[1])
|
|
258
|
+
const unique = [...new Set(codes)]
|
|
259
|
+
assert.ok(unique.length >= 10, `宿主错误码偏少(${unique.length} 个)`)
|
|
260
|
+
|
|
261
|
+
// 路由层的码不会出现在面板上,不必翻;其余必须能翻
|
|
262
|
+
const notUserFacing = new Set(['knit/not-found-route', 'knit/loopback-only', 'knit/method-not-allowed', 'knit/bad-request'])
|
|
263
|
+
const clientSource = readFileSync(new URL('../src/client/client.js', import.meta.url), 'utf8')
|
|
264
|
+
|
|
265
|
+
const untranslated = unique.filter((code) => !notUserFacing.has(code) && !clientSource.includes(`'${code}'`))
|
|
266
|
+
assert.deepEqual(untranslated, [], `宿主的这些码在客户端没有翻译:${untranslated.join(', ')}`)
|
|
267
|
+
})
|
|
268
|
+
|
|
269
|
+
test('错误码:未登记的码原样显示,便于发现漏翻', async () => {
|
|
270
|
+
const { nodes } = await renderPanel('en', () => ({ ok: false, code: 'knit/brand-new-code' }))
|
|
271
|
+
assert.match(textOf(byClass(nodes, 'knit-msg')[0]), /knit\/brand-new-code/)
|
|
272
|
+
})
|
|
273
|
+
|
|
274
|
+
test('错误码:完全没有 code 时退回通用文案', async () => {
|
|
275
|
+
const en = await renderPanel('en', () => ({ ok: false }))
|
|
276
|
+
assert.match(textOf(byClass(en.nodes, 'knit-msg')[0]), /The host returned a failure/)
|
|
277
|
+
|
|
278
|
+
const zh = await renderPanel('zh', () => ({ ok: false }))
|
|
279
|
+
assert.match(textOf(byClass(zh.nodes, 'knit-msg')[0]), /宿主返回失败/)
|
|
280
|
+
})
|
|
281
|
+
|
|
282
|
+
/* ── 注册层面的文案 ─────────────────────────────────── */
|
|
283
|
+
|
|
284
|
+
test('注册:tab 类型与 guide 文案随语言解析(不是注册时定死)', () => {
|
|
285
|
+
const zh = boot('zh')
|
|
286
|
+
const en = boot('en')
|
|
287
|
+
|
|
288
|
+
const zhDef = zh.log.tabs[0]
|
|
289
|
+
const enDef = en.log.tabs[0]
|
|
290
|
+
|
|
291
|
+
assert.equal(zhDef.title(), 'Knit')
|
|
292
|
+
assert.equal(enDef.title(), 'Knit')
|
|
293
|
+
|
|
294
|
+
assert.equal(zhDef.guide[0].title(), 'Knit 最近文档')
|
|
295
|
+
assert.equal(enDef.guide[0].title(), 'Knit — recent documents')
|
|
296
|
+
|
|
297
|
+
assert.notEqual(zhDef.guide[0].description(), enDef.guide[0].description())
|
|
298
|
+
assert.match(enDef.guide[0].description(), /Relevance-sorted/)
|
|
299
|
+
})
|
|
300
|
+
|
|
301
|
+
test('注册:入口按钮的无障碍标签随语言变', () => {
|
|
302
|
+
const zh = boot('zh')
|
|
303
|
+
const en = boot('en')
|
|
304
|
+
|
|
305
|
+
const zhBtn = zh.log.slots.find((s) => s.opts.id === 'knit:entry')
|
|
306
|
+
const enBtn = en.log.slots.find((s) => s.opts.id === 'knit:entry')
|
|
307
|
+
|
|
308
|
+
harness.reset()
|
|
309
|
+
const zhNodes = harness.render(h(zhBtn.component, {}))
|
|
310
|
+
harness.reset()
|
|
311
|
+
const enNodes = harness.render(h(enBtn.component, {}))
|
|
312
|
+
|
|
313
|
+
assert.equal(byClass(zhNodes, 'knit-entry')[0].props['aria-label'], 'Knit 最近文档')
|
|
314
|
+
assert.equal(byClass(enNodes, 'knit-entry')[0].props['aria-label'], 'Knit — recent documents')
|
|
315
|
+
})
|
|
316
|
+
|
|
317
|
+
test('注册:座位声明带上 locale 命名空间', () => {
|
|
318
|
+
const { log } = boot('zh')
|
|
319
|
+
const entry = log.slots.find((s) => s.opts.id === 'knit:entry')
|
|
320
|
+
assert.equal(entry.opts.locale, 'knit', 'list 座位要声明 locale,运行时才知道用哪个词典')
|
|
321
|
+
})
|
|
322
|
+
|
|
323
|
+
test('注册:词典通过 ctx.effect 注册(可随插件卸载回收)', () => {
|
|
324
|
+
const { log } = boot('zh')
|
|
325
|
+
assert.ok(
|
|
326
|
+
log.effects.some((label) => String(label).includes('dictionaries')),
|
|
327
|
+
`effect 标签里应有词典注册:${log.effects.join(' / ')}`,
|
|
328
|
+
)
|
|
329
|
+
})
|
|
330
|
+
|
|
331
|
+
/* ── 冒烟:两个语言都能渲染完整面板 ───────────────────── */
|
|
332
|
+
|
|
333
|
+
test('冒烟:中英环境下渲染同一份数据都不抛错,且文案确实不同', async () => {
|
|
334
|
+
const compose = () => listPayload({ mode: 'relevance', topic: 'x' })
|
|
335
|
+
const zh = await renderPanel('zh', compose)
|
|
336
|
+
const en = await renderPanel('en', compose)
|
|
337
|
+
|
|
338
|
+
const zhText = zh.nodes.map(textOf).join('|')
|
|
339
|
+
const enText = en.nodes.map(textOf).join('|')
|
|
340
|
+
|
|
341
|
+
assert.notEqual(zhText, enText, '两种语言渲染出的文案不该完全一样')
|
|
342
|
+
assert.ok(!/Refresh|Sorted by/.test(zhText), `中文环境混进了英文:${zhText}`)
|
|
343
|
+
assert.ok(!/刷新|按/.test(enText), `英文环境混进了中文:${enText}`)
|
|
344
|
+
})
|