dsh-knit 0.11.0 → 0.12.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 +532 -0
- package/README.en.md +1 -1
- package/README.md +1 -1
- package/package.json +4 -3
- package/src/client/client.js +191 -1
- package/src/host/index.js +18 -1
- package/src/host/links.js +304 -0
- package/test/client.test.mjs +180 -0
- package/test/fixture.mjs +6 -1
- package/test/host-http.test.mjs +80 -2
- package/test/links.test.mjs +271 -0
package/test/client.test.mjs
CHANGED
|
@@ -1177,3 +1177,183 @@ test('媒体:媒体视图一个媒体都没有时给出专属空态', async ()
|
|
|
1177
1177
|
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1178
1178
|
assert.match(byClass(nodes, 'knit-msg').map(textOf).join(''), /还没有图片或视频/)
|
|
1179
1179
|
})
|
|
1180
|
+
|
|
1181
|
+
/* ── v0.12 引用条 ───────────────────────────────────── */
|
|
1182
|
+
|
|
1183
|
+
/** 列表 / 正文 / 引用 三路分流。 */
|
|
1184
|
+
function linksResponder(linksPayload) {
|
|
1185
|
+
return (url) => {
|
|
1186
|
+
if (url.includes('/api/links')) return linksPayload
|
|
1187
|
+
if (url.includes('/api/doc')) {
|
|
1188
|
+
return { ok: true, rel: '技术方案.md', title: '技术方案', text: '# 技术方案\n\n正文。', truncated: false }
|
|
1189
|
+
}
|
|
1190
|
+
return listPayload()
|
|
1191
|
+
}
|
|
1192
|
+
}
|
|
1193
|
+
|
|
1194
|
+
const LINKS_PAYLOAD = {
|
|
1195
|
+
ok: true,
|
|
1196
|
+
rel: '技术方案.md',
|
|
1197
|
+
incoming: [{ rel: 'sub/需求 文档.md', title: '需求' }],
|
|
1198
|
+
outgoing: [{ rel: 'CHANGELOG.md', title: '变更' }],
|
|
1199
|
+
incomingTotal: 3,
|
|
1200
|
+
outgoingTotal: 1,
|
|
1201
|
+
limited: false,
|
|
1202
|
+
}
|
|
1203
|
+
|
|
1204
|
+
/** 打开第一篇文档,把预览与引用条都跑完。 */
|
|
1205
|
+
async function openFirstDoc(nodes) {
|
|
1206
|
+
let ns = nodes
|
|
1207
|
+
ns = harness.render(h(KnitBodyForLinks(), { sessionId: 's1' }))
|
|
1208
|
+
await harness.flush()
|
|
1209
|
+
ns = harness.render(h(KnitBodyForLinks(), { sessionId: 's1' }))
|
|
1210
|
+
byClass(ns, 'knit-doc')[0].props.onClick()
|
|
1211
|
+
ns = harness.render(h(KnitBodyForLinks(), { sessionId: 's1' }))
|
|
1212
|
+
await harness.flush()
|
|
1213
|
+
return harness.render(h(KnitBodyForLinks(), { sessionId: 's1' }))
|
|
1214
|
+
}
|
|
1215
|
+
|
|
1216
|
+
/** `harness.seed` 的槽位与既有用例保持一致(notice / sort)。 */
|
|
1217
|
+
function KnitBodyForLinks() {
|
|
1218
|
+
harness.reset()
|
|
1219
|
+
harness.seed(['', 'time'])
|
|
1220
|
+
return loadClientModule().exports.__test.KnitBody
|
|
1221
|
+
}
|
|
1222
|
+
|
|
1223
|
+
test('引用条:打开一篇会请求 /api/links,默认折叠只给计数', async () => {
|
|
1224
|
+
const { calls } = installFetch(linksResponder(LINKS_PAYLOAD))
|
|
1225
|
+
const { KnitBody } = loadClientModule().exports.__test
|
|
1226
|
+
harness.reset()
|
|
1227
|
+
harness.seed(['', 'time'])
|
|
1228
|
+
let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1229
|
+
await harness.flush()
|
|
1230
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1231
|
+
|
|
1232
|
+
byClass(nodes, 'knit-doc')[0].props.onClick()
|
|
1233
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1234
|
+
await harness.flush()
|
|
1235
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1236
|
+
|
|
1237
|
+
const linksCall = calls.find((u) => u.includes('/api/links'))
|
|
1238
|
+
assert.ok(linksCall, '应请求引用关系')
|
|
1239
|
+
assert.ok(linksCall.includes(encodeURIComponent('技术方案.md')), `rel 应被编码:${linksCall}`)
|
|
1240
|
+
assert.equal(byClass(nodes, 'knit-link-row').length, 0, '默认折叠,不该有列表项')
|
|
1241
|
+
const summary = byClass(nodes, 'knit-links-summary').map(textOf).join('')
|
|
1242
|
+
assert.match(summary, /被引用 3/)
|
|
1243
|
+
assert.match(summary, /引用了 1/)
|
|
1244
|
+
})
|
|
1245
|
+
|
|
1246
|
+
test('引用条:展开后列出两侧,超出的给「还有 N 篇」', async () => {
|
|
1247
|
+
installFetch(linksResponder(LINKS_PAYLOAD))
|
|
1248
|
+
const { KnitBody } = loadClientModule().exports.__test
|
|
1249
|
+
harness.reset()
|
|
1250
|
+
harness.seed(['', 'time'])
|
|
1251
|
+
let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1252
|
+
await harness.flush()
|
|
1253
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1254
|
+
byClass(nodes, 'knit-doc')[0].props.onClick()
|
|
1255
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1256
|
+
await harness.flush()
|
|
1257
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1258
|
+
|
|
1259
|
+
byClass(nodes, 'knit-links-head')[0].props.onClick()
|
|
1260
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1261
|
+
|
|
1262
|
+
assert.equal(byClass(nodes, 'knit-link-row').length, 2, '被引用 1 条 + 引用 1 条')
|
|
1263
|
+
assert.deepEqual(byClass(nodes, 'knit-link-name').map(textOf), ['需求', '变更'])
|
|
1264
|
+
assert.deepEqual(byClass(nodes, 'knit-link-path').map(textOf),
|
|
1265
|
+
['sub/需求 文档.md', 'CHANGELOG.md'], '副行给相对路径,方便认人')
|
|
1266
|
+
// incomingTotal 3 而只列了 1 条 → 提示还有 2 篇
|
|
1267
|
+
assert.match(byClass(nodes, 'knit-links-note').map(textOf).join(''), /还有 2 篇/)
|
|
1268
|
+
})
|
|
1269
|
+
|
|
1270
|
+
test('引用条:点一项就切到那一篇,且**不重新拉列表**(订阅制,不走轮询)', async () => {
|
|
1271
|
+
const { calls } = installFetch(linksResponder(LINKS_PAYLOAD))
|
|
1272
|
+
const { KnitBody } = loadClientModule().exports.__test
|
|
1273
|
+
harness.reset()
|
|
1274
|
+
harness.seed(['', 'time'])
|
|
1275
|
+
let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1276
|
+
await harness.flush()
|
|
1277
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1278
|
+
byClass(nodes, 'knit-doc')[0].props.onClick()
|
|
1279
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1280
|
+
await harness.flush()
|
|
1281
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1282
|
+
|
|
1283
|
+
byClass(nodes, 'knit-links-head')[0].props.onClick()
|
|
1284
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1285
|
+
|
|
1286
|
+
byClass(nodes, 'knit-link-row')[0].props.onClick()
|
|
1287
|
+
// ⚠️ **刻意不 flush**:订阅制是**同步**送达的,点完立刻就该是新那篇。
|
|
1288
|
+
// 如果这一跳要经过列表接口,就必须等一次 fetch + flush,这条断言会红。
|
|
1289
|
+
// (不数 `/api/recent` 次数 —— 这个 harness 的 useEffect 不跟踪依赖,
|
|
1290
|
+
// 每次 flush 都会重跑所有 effect,数次数测不出「有没有走轮询」。)
|
|
1291
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1292
|
+
assert.match(
|
|
1293
|
+
byClass(nodes, 'knit-preview-name').map(textOf).join(''),
|
|
1294
|
+
/需求 文档\.md/,
|
|
1295
|
+
'点完立刻切到那一篇,中间不该有 fetch(AGENTS.md §6.4:即时信号别藏在轮询里)',
|
|
1296
|
+
)
|
|
1297
|
+
|
|
1298
|
+
await harness.flush()
|
|
1299
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1300
|
+
assert.ok(
|
|
1301
|
+
calls.some((u) => u.includes('/api/doc') && u.includes(encodeURIComponent('sub/需求 文档.md'))),
|
|
1302
|
+
'随后应真的去取那一篇的正文',
|
|
1303
|
+
)
|
|
1304
|
+
})
|
|
1305
|
+
|
|
1306
|
+
test('引用条:「没有被引用」与「读取失败」是两句不同的话(不都显示成空白)', async () => {
|
|
1307
|
+
installFetch(linksResponder({
|
|
1308
|
+
ok: true, rel: '技术方案.md', incoming: [], outgoing: [],
|
|
1309
|
+
incomingTotal: 0, outgoingTotal: 0, limited: false,
|
|
1310
|
+
}))
|
|
1311
|
+
let { KnitBody } = loadClientModule().exports.__test
|
|
1312
|
+
harness.reset()
|
|
1313
|
+
harness.seed(['', 'time'])
|
|
1314
|
+
let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1315
|
+
await harness.flush()
|
|
1316
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1317
|
+
byClass(nodes, 'knit-doc')[0].props.onClick()
|
|
1318
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1319
|
+
await harness.flush()
|
|
1320
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1321
|
+
byClass(nodes, 'knit-links-head')[0].props.onClick()
|
|
1322
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1323
|
+
const emptyText = byClass(nodes, 'knit-links-empty').map(textOf).join('')
|
|
1324
|
+
assert.match(emptyText, /没有被引用/)
|
|
1325
|
+
assert.match(emptyText, /没有引用别的文档/)
|
|
1326
|
+
|
|
1327
|
+
// 失败态:服务端返回错误码 → 走另一句文案,且**不给展开按钮**
|
|
1328
|
+
installFetch(linksResponder({ ok: false, code: 'knit/not-found' }))
|
|
1329
|
+
;({ KnitBody } = loadClientModule().exports.__test)
|
|
1330
|
+
harness.reset()
|
|
1331
|
+
harness.seed(['', 'time'])
|
|
1332
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1333
|
+
await harness.flush()
|
|
1334
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1335
|
+
byClass(nodes, 'knit-doc')[0].props.onClick()
|
|
1336
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1337
|
+
await harness.flush()
|
|
1338
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1339
|
+
assert.equal(byClass(nodes, 'knit-links-head').length, 0, '失败态没有可展开的头')
|
|
1340
|
+
assert.match(byClass(nodes, 'knit-links').map(textOf).join(''), /引用关系读取失败/)
|
|
1341
|
+
})
|
|
1342
|
+
|
|
1343
|
+
test('引用条:图片/视频不请求 /api/links(图里只有 .md,请求必然 404)', async () => {
|
|
1344
|
+
const { calls } = installFetch(kindResponder({ media: mediaPayload() }))
|
|
1345
|
+
const { KnitBody } = loadClientModule().exports.__test
|
|
1346
|
+
harness.reset()
|
|
1347
|
+
harness.seed(['', 'time', 'media'])
|
|
1348
|
+
let nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1349
|
+
await harness.flush()
|
|
1350
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1351
|
+
|
|
1352
|
+
byClass(nodes, 'knit-media-card')[0].props.onClick()
|
|
1353
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1354
|
+
await harness.flush()
|
|
1355
|
+
nodes = harness.render(h(KnitBody, { sessionId: 's1' }))
|
|
1356
|
+
|
|
1357
|
+
assert.ok(!calls.some((u) => u.includes('/api/links')), '媒体不该请求引用关系')
|
|
1358
|
+
assert.equal(byClass(nodes, 'knit-links').length, 0, '媒体不显示引用条')
|
|
1359
|
+
})
|
package/test/fixture.mjs
CHANGED
|
@@ -23,9 +23,13 @@ const FAKE_MP4 = Buffer.alloc(4096, 0x21)
|
|
|
23
23
|
/**
|
|
24
24
|
* 建样本工作区。文件名刻意与旧断言一致(README.md / package.json / docs/screenshot.png),
|
|
25
25
|
* 断言语义不用改;mtime 用 utimes 定死,排序断言不再看运气。
|
|
26
|
+
*
|
|
27
|
+
* @param {Array<[string, string|Buffer]>} [extra] - 追加的 `[rel, 内容]`。
|
|
28
|
+
* v0.12 的引用关系用例需要能自己造带链接的文件 —— **样本一律从这里要**,
|
|
29
|
+
* 不许去借仓库里的真实文件(AGENTS.md §6.8)。
|
|
26
30
|
* @returns {string} 工作区绝对路径;进程退出时自动清理
|
|
27
31
|
*/
|
|
28
|
-
export function makeWorkspace() {
|
|
32
|
+
export function makeWorkspace(extra = []) {
|
|
29
33
|
const dir = mkdtempSync(join(tmpdir(), 'knit-fixture-'))
|
|
30
34
|
const base = Date.now() - 120_000
|
|
31
35
|
const files = [
|
|
@@ -35,6 +39,7 @@ export function makeWorkspace() {
|
|
|
35
39
|
['package.json', '{\n "name": "sample"\n}\n'],
|
|
36
40
|
['docs/screenshot.png', PADDED_PNG],
|
|
37
41
|
['docs/clip.mp4', FAKE_MP4],
|
|
42
|
+
...extra,
|
|
38
43
|
]
|
|
39
44
|
files.forEach(([rel, content], i) => {
|
|
40
45
|
const abs = join(dir, rel)
|
package/test/host-http.test.mjs
CHANGED
|
@@ -15,8 +15,20 @@ import { stat } from 'node:fs/promises'
|
|
|
15
15
|
import { apply } from '../src/host/index.js'
|
|
16
16
|
import { makeWorkspace } from './fixture.mjs'
|
|
17
17
|
|
|
18
|
-
/**
|
|
19
|
-
|
|
18
|
+
/**
|
|
19
|
+
* 测试自带样本工作区(临时目录),里面有 docs/screenshot.png 当媒体样本。
|
|
20
|
+
*
|
|
21
|
+
* v0.12 追加了几个**带引用**的文件给 `/api/links` 用。刻意包含一组
|
|
22
|
+
* **同名但不同目录**的 `SKILL.md` —— 那是真实语料里最大的误报源
|
|
23
|
+
* (`SKILL.md` 有 20 个、`01_公众号正文.md` 有 12 个)。
|
|
24
|
+
*/
|
|
25
|
+
const PROJECT_ROOT = makeWorkspace([
|
|
26
|
+
['docs/hub.md', '# hub\n\n见 `docs/notes.md` 与 README.md\n'],
|
|
27
|
+
['docs/leaf.md', '# leaf\n\n见 [笔记](docs/notes.md)\n'],
|
|
28
|
+
['x/SKILL.md', '# x 的 skill\n'],
|
|
29
|
+
['y/SKILL.md', '# y 的 skill\n'],
|
|
30
|
+
['amb.md', '# amb\n\n见 `SKILL.md`(同名两处,不该产生边)\n'],
|
|
31
|
+
])
|
|
20
32
|
|
|
21
33
|
/**
|
|
22
34
|
* 起一个挂着 Knit 路由的回环 server(伪造 cordis 的 webServer / sessions / effect)。
|
|
@@ -130,3 +142,69 @@ test('HTTP 端到端:媒体列表、/raw 整文件、Range 206、安全拒绝'
|
|
|
130
142
|
await close()
|
|
131
143
|
}
|
|
132
144
|
})
|
|
145
|
+
|
|
146
|
+
test('HTTP 端到端:/api/links 的引用关系、缺参与越界、不泄漏内部结构', async () => {
|
|
147
|
+
const { base, close } = await startKnitServer()
|
|
148
|
+
try {
|
|
149
|
+
// 正常:hub 与 leaf 都引用了 docs/notes.md,所以它被引用 2 次、自己不引用别人
|
|
150
|
+
let r = await fetch(`${base}/api/links?sessionId=s&rel=${encodeURIComponent('docs/notes.md')}`)
|
|
151
|
+
let body = await r.json()
|
|
152
|
+
assert.equal(r.status, 200)
|
|
153
|
+
assert.equal(body.ok, true)
|
|
154
|
+
assert.equal(body.rel, 'docs/notes.md')
|
|
155
|
+
assert.equal(body.incomingTotal, 2, 'hub 与 leaf 各一条')
|
|
156
|
+
assert.deepEqual(body.incoming.map((d) => d.rel).sort(), ['docs/hub.md', 'docs/leaf.md'])
|
|
157
|
+
assert.equal(body.outgoingTotal, 0)
|
|
158
|
+
assert.deepEqual(body.outgoing, [])
|
|
159
|
+
assert.ok(body.incoming.every((d) => d.rel && d.title), '每项要有 rel 与 title')
|
|
160
|
+
|
|
161
|
+
// 不泄漏内部结构(与 knit_docs 同一条纪律)
|
|
162
|
+
for (const k of ['out', 'in', 'titles', 'signature', 'parsed', 'skipped', 'haystack']) {
|
|
163
|
+
assert.ok(!(k in body), `不该泄漏 ${k}`)
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
// 反向:hub 自己引用了 notes 与 README
|
|
167
|
+
r = await fetch(`${base}/api/links?sessionId=s&rel=${encodeURIComponent('docs/hub.md')}`)
|
|
168
|
+
body = await r.json()
|
|
169
|
+
assert.equal(r.status, 200)
|
|
170
|
+
assert.equal(body.outgoingTotal, 2)
|
|
171
|
+
assert.deepEqual(body.outgoing.map((d) => d.rel).sort(), ['README.md', 'docs/notes.md'])
|
|
172
|
+
assert.deepEqual(body.incoming, [])
|
|
173
|
+
|
|
174
|
+
// 🔴 误报回归:同名两处 SKILL.md 时,只写 basename 必须不产生边
|
|
175
|
+
r = await fetch(`${base}/api/links?sessionId=s&rel=${encodeURIComponent('x/SKILL.md')}`)
|
|
176
|
+
body = await r.json()
|
|
177
|
+
assert.equal(r.status, 200)
|
|
178
|
+
assert.equal(body.incomingTotal, 0, '歧义 basename 不许产生边')
|
|
179
|
+
|
|
180
|
+
// 缺 rel → 400,且是既有错误码
|
|
181
|
+
r = await fetch(`${base}/api/links?sessionId=s`)
|
|
182
|
+
body = await r.json()
|
|
183
|
+
assert.equal(r.status, 400)
|
|
184
|
+
assert.deepEqual(body, { ok: false, code: 'knit/missing-rel' })
|
|
185
|
+
|
|
186
|
+
// 未知 rel → 404。**越界路径也走这里** —— 图里只有工作区内的 rel,
|
|
187
|
+
// 所以这个路由**没有**按路径读文件的口子,套不出工作区外的内容。
|
|
188
|
+
for (const bad of ['nope.md', '../outside.md', '/etc/passwd.md']) {
|
|
189
|
+
r = await fetch(`${base}/api/links?sessionId=s&rel=${encodeURIComponent(bad)}`)
|
|
190
|
+
body = await r.json()
|
|
191
|
+
assert.equal(r.status, 404, `${bad} 应 404`)
|
|
192
|
+
assert.deepEqual(body, { ok: false, code: 'knit/not-found' })
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
// 安全响应头:JSON 路由与 /api/recent、/api/doc 一致 —— 都走 sendJson,设 `nosniff`。
|
|
196
|
+
// ⚠️ **CSP(含 `sandbox`)只有媒体路由 `/api/raw` 才设** —— 那是给浏览器渲染
|
|
197
|
+
// 图片/视频/SVG 用的,JSON 不吃这一套。我第一版按「所有路由都该有 CSP」写,
|
|
198
|
+
// 是**断言错了**,不是代码缺了防护。
|
|
199
|
+
r = await fetch(`${base}/api/links?sessionId=s&rel=${encodeURIComponent('docs/notes.md')}`)
|
|
200
|
+
assert.equal(r.headers.get('x-content-type-options'), 'nosniff')
|
|
201
|
+
assert.equal(r.headers.get('cache-control'), 'no-store')
|
|
202
|
+
assert.match(r.headers.get('content-type') || '', /application\/json/)
|
|
203
|
+
|
|
204
|
+
// 非 GET → 405(前置守卫覆盖新路由)
|
|
205
|
+
r = await fetch(`${base}/api/links?sessionId=s&rel=x.md`, { method: 'POST' })
|
|
206
|
+
assert.equal(r.status, 405)
|
|
207
|
+
} finally {
|
|
208
|
+
await close()
|
|
209
|
+
}
|
|
210
|
+
})
|
|
@@ -0,0 +1,271 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Knit · **引用关系解析**(v0.12)的测试
|
|
3
|
+
*
|
|
4
|
+
* 这一组测试的靶心是 **误报**,不是召回。
|
|
5
|
+
* 依据是真实语料的实测:`SKILL.md` 有 20 个、`01_公众号正文.md` 有 12 个,
|
|
6
|
+
* 那些「只写了 basename」的提及多半在讲**文件名约定**,不是在指某一篇 ——
|
|
7
|
+
* 宽松解析会让 13% 的边是错的(见 `Knit_SDD-v0.12` §1.4)。
|
|
8
|
+
*
|
|
9
|
+
* 所以有一条专门的回归用例:**同名文件存在时,光写 basename 必须不产生边**。
|
|
10
|
+
*/
|
|
11
|
+
import test from 'node:test'
|
|
12
|
+
import assert from 'node:assert/strict'
|
|
13
|
+
|
|
14
|
+
import {
|
|
15
|
+
extractRefs,
|
|
16
|
+
createIndex,
|
|
17
|
+
resolveRef,
|
|
18
|
+
buildLinkGraph,
|
|
19
|
+
linksOf,
|
|
20
|
+
resetLinkCache,
|
|
21
|
+
} from '../src/host/links.js'
|
|
22
|
+
|
|
23
|
+
/* ── extractRefs:三种真实写法 ───────────────────────── */
|
|
24
|
+
|
|
25
|
+
test('extractRefs:认反引号路径(真实语料里的主力写法,946 次)', () => {
|
|
26
|
+
assert.deepEqual(extractRefs('见 `docs/A.md` 那篇'), ['docs/A.md'])
|
|
27
|
+
})
|
|
28
|
+
|
|
29
|
+
test('extractRefs:反引号路径里的空格要保留(`00_ Knit PRD/x.md` 真实存在)', () => {
|
|
30
|
+
assert.deepEqual(extractRefs('见 `00_ Knit PRD/Knit_PRD-v0.12.md`'), ['00_ Knit PRD/Knit_PRD-v0.12.md'])
|
|
31
|
+
})
|
|
32
|
+
|
|
33
|
+
test('extractRefs:认标准 Markdown 链接,并忽略锚点', () => {
|
|
34
|
+
assert.deepEqual(extractRefs('[看这里](docs/A.md#三)'), ['docs/A.md'])
|
|
35
|
+
})
|
|
36
|
+
|
|
37
|
+
test('extractRefs:认裸路径提及(前面是空白或中文括号)', () => {
|
|
38
|
+
assert.deepEqual(extractRefs('见 docs/A.md 那篇'), ['docs/A.md'])
|
|
39
|
+
assert.deepEqual(extractRefs('(docs/A.md)'), ['docs/A.md'])
|
|
40
|
+
})
|
|
41
|
+
|
|
42
|
+
test('extractRefs:去重,保持出现顺序', () => {
|
|
43
|
+
assert.deepEqual(extractRefs('`b.md` 再 `a.md` 又 `b.md`'), ['b.md', 'a.md'])
|
|
44
|
+
})
|
|
45
|
+
|
|
46
|
+
test('extractRefs:外链不算(不是本工作区的文档)', () => {
|
|
47
|
+
assert.deepEqual(extractRefs('[x](https://ex.com/a.md)'), [])
|
|
48
|
+
assert.deepEqual(extractRefs('`ftp://h/a.md`'), [])
|
|
49
|
+
})
|
|
50
|
+
|
|
51
|
+
test('extractRefs:非 .md 不算', () => {
|
|
52
|
+
assert.deepEqual(extractRefs('`a.png` `b.js` `c`'), [])
|
|
53
|
+
})
|
|
54
|
+
|
|
55
|
+
test('extractRefs:不咬 `a.md.bak` 这种更长但不是 .md 的串', () => {
|
|
56
|
+
assert.deepEqual(extractRefs('备份在 a.md.bak'), [])
|
|
57
|
+
assert.deepEqual(extractRefs('`a.md.bak`'), [])
|
|
58
|
+
})
|
|
59
|
+
|
|
60
|
+
test('extractRefs:不做 `[[wikilink]]`(真实语料 0 次使用,SDD §7.1 已否决)', () => {
|
|
61
|
+
assert.deepEqual(extractRefs('见 [[docs/A]] 那篇'), [])
|
|
62
|
+
})
|
|
63
|
+
|
|
64
|
+
test('extractRefs:空/非字符串输入返回空数组,不抛', () => {
|
|
65
|
+
assert.deepEqual(extractRefs(''), [])
|
|
66
|
+
assert.deepEqual(extractRefs(null), [])
|
|
67
|
+
assert.deepEqual(extractRefs(undefined), [])
|
|
68
|
+
})
|
|
69
|
+
|
|
70
|
+
/* ── resolveRef:四级优先 + 歧义不算 ─────────────────── */
|
|
71
|
+
|
|
72
|
+
const IDX = createIndex([
|
|
73
|
+
'README.md',
|
|
74
|
+
'docs/README.md',
|
|
75
|
+
'docs/LoreFlow-Copilot-PRD-v0.6.md',
|
|
76
|
+
'docs/LoreFlow-Copilot-SDD-v0.6.md',
|
|
77
|
+
'a/SKILL.md',
|
|
78
|
+
'b/SKILL.md',
|
|
79
|
+
])
|
|
80
|
+
|
|
81
|
+
test('resolveRef:① 引用方所在目录优先(这才是相对路径的语义)', () => {
|
|
82
|
+
assert.equal(resolveRef('README.md', IDX, 'docs/B.md'), 'docs/README.md')
|
|
83
|
+
})
|
|
84
|
+
|
|
85
|
+
test('resolveRef:① 同目录没有才退到工作区根', () => {
|
|
86
|
+
assert.equal(resolveRef('README.md', IDX, 'other/B.md'), 'README.md')
|
|
87
|
+
})
|
|
88
|
+
|
|
89
|
+
test('resolveRef:② 完整相对路径直接命中', () => {
|
|
90
|
+
assert.equal(resolveRef('docs/LoreFlow-Copilot-PRD-v0.6.md', IDX, 'x/y.md'), 'docs/LoreFlow-Copilot-PRD-v0.6.md')
|
|
91
|
+
})
|
|
92
|
+
|
|
93
|
+
test('resolveRef:③ 缩写后缀 `-SDD-v0.6.md`(真实语料里存在)', () => {
|
|
94
|
+
assert.equal(resolveRef('-SDD-v0.6.md', IDX, 'docs/LoreFlow-Copilot-PRD-v0.6.md'),
|
|
95
|
+
'docs/LoreFlow-Copilot-SDD-v0.6.md')
|
|
96
|
+
})
|
|
97
|
+
|
|
98
|
+
test('resolveRef:③ 缩写后缀命中多个就不算(宁可少不可错)', () => {
|
|
99
|
+
// `-6.md` 能匹配 PRD-v0.6 与 SDD-v0.6,无法确定
|
|
100
|
+
assert.equal(resolveRef('-6.md', IDX, 'docs/x.md'), null)
|
|
101
|
+
})
|
|
102
|
+
|
|
103
|
+
test('resolveRef:④ basename 唯一时可以命中', () => {
|
|
104
|
+
assert.equal(resolveRef('LoreFlow-Copilot-PRD-v0.6.md', IDX, 'x/y.md'),
|
|
105
|
+
'docs/LoreFlow-Copilot-PRD-v0.6.md')
|
|
106
|
+
})
|
|
107
|
+
|
|
108
|
+
test('🔴 误报回归:同名文件存在时,光写 basename 必须不产生边', () => {
|
|
109
|
+
// 这条是 v0.12 最重要的回归 —— 真实语料里 SKILL.md 有 20 个。
|
|
110
|
+
// 宽松解析(取第一个)会让 `s5-illustration/SKILL.md` 的入度虚高到 15。
|
|
111
|
+
assert.equal(resolveRef('SKILL.md', IDX, 'z/w.md'), null)
|
|
112
|
+
})
|
|
113
|
+
|
|
114
|
+
test('resolveRef:⑤ 工作区里没有这个文件 → null,不编造', () => {
|
|
115
|
+
assert.equal(resolveRef('docs/不存在.md', IDX, 'x.md'), null)
|
|
116
|
+
})
|
|
117
|
+
|
|
118
|
+
test('resolveRef:`./` 前缀会被剥掉', () => {
|
|
119
|
+
assert.equal(resolveRef('./docs/LoreFlow-Copilot-PRD-v0.6.md', IDX, 'x.md'),
|
|
120
|
+
'docs/LoreFlow-Copilot-PRD-v0.6.md')
|
|
121
|
+
})
|
|
122
|
+
|
|
123
|
+
test('resolveRef:非法输入 → null,不抛', () => {
|
|
124
|
+
assert.equal(resolveRef('', IDX, 'x.md'), null)
|
|
125
|
+
assert.equal(resolveRef('https://e.com/a.md', IDX, 'x.md'), null)
|
|
126
|
+
assert.equal(resolveRef('a.md', null, 'x.md'), null)
|
|
127
|
+
})
|
|
128
|
+
|
|
129
|
+
/* ── buildLinkGraph:注入 list/read,缓存按签名失效 ───── */
|
|
130
|
+
|
|
131
|
+
/** 造一个可控的假 io:`files` 是 rel → 正文。 */
|
|
132
|
+
function fakeIo(files) {
|
|
133
|
+
const reads = { count: 0, byRel: new Map() }
|
|
134
|
+
const docs = Object.keys(files).map((rel, i) => ({
|
|
135
|
+
rel, title: rel.replace(/\.md$/, ''), mtimeMs: 1000 + i,
|
|
136
|
+
}))
|
|
137
|
+
return {
|
|
138
|
+
reads,
|
|
139
|
+
list: async () => ({ docs, truncated: false }),
|
|
140
|
+
read: async (_root, rel) => {
|
|
141
|
+
reads.count += 1
|
|
142
|
+
reads.byRel.set(rel, (reads.byRel.get(rel) || 0) + 1)
|
|
143
|
+
return { ok: true, rel, text: files[rel] }
|
|
144
|
+
},
|
|
145
|
+
}
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
test('buildLinkGraph:正向边与反向边一致(反向边由正向推出来)', async () => {
|
|
149
|
+
resetLinkCache()
|
|
150
|
+
const io = fakeIo({
|
|
151
|
+
'A.md': '见 `B.md` 与 C.md',
|
|
152
|
+
'B.md': '正文没有引用',
|
|
153
|
+
'C.md': '见 `A.md`',
|
|
154
|
+
})
|
|
155
|
+
const g = await buildLinkGraph('/fake-1', io)
|
|
156
|
+
assert.deepEqual([...g.out.get('A.md')].sort(), ['B.md', 'C.md'])
|
|
157
|
+
assert.deepEqual([...g.in.get('B.md')], ['A.md'])
|
|
158
|
+
assert.deepEqual([...g.in.get('A.md')], ['C.md'])
|
|
159
|
+
assert.deepEqual([...g.in.get('C.md')], ['A.md'])
|
|
160
|
+
})
|
|
161
|
+
|
|
162
|
+
test('buildLinkGraph:自引用不算边', async () => {
|
|
163
|
+
resetLinkCache()
|
|
164
|
+
const io = fakeIo({ 'A.md': '见 `A.md`' })
|
|
165
|
+
const g = await buildLinkGraph('/fake-2', io)
|
|
166
|
+
assert.equal(g.out.get('A.md').size, 0)
|
|
167
|
+
assert.equal(g.in.get('A.md').size, 0)
|
|
168
|
+
})
|
|
169
|
+
|
|
170
|
+
test('buildLinkGraph:歧义 basename 不产生边(误报回归,图这一层)', async () => {
|
|
171
|
+
resetLinkCache()
|
|
172
|
+
const io = fakeIo({
|
|
173
|
+
'x/SKILL.md': '内容',
|
|
174
|
+
'y/SKILL.md': '内容',
|
|
175
|
+
'doc.md': '见 `SKILL.md`',
|
|
176
|
+
})
|
|
177
|
+
const g = await buildLinkGraph('/fake-3', io)
|
|
178
|
+
assert.equal(g.out.get('doc.md').size, 0, '歧义 basename 不许产生边')
|
|
179
|
+
assert.equal(g.in.get('x/SKILL.md').size, 0)
|
|
180
|
+
assert.equal(g.in.get('y/SKILL.md').size, 0)
|
|
181
|
+
})
|
|
182
|
+
|
|
183
|
+
test('buildLinkGraph:同一签名不重复读盘', async () => {
|
|
184
|
+
resetLinkCache()
|
|
185
|
+
const io = fakeIo({ 'A.md': '见 `B.md`', 'B.md': 'x' })
|
|
186
|
+
await buildLinkGraph('/fake-4', io)
|
|
187
|
+
const first = io.reads.count
|
|
188
|
+
await buildLinkGraph('/fake-4', io)
|
|
189
|
+
assert.equal(io.reads.count, first, '签名没变就不该再读一遍')
|
|
190
|
+
})
|
|
191
|
+
|
|
192
|
+
test('buildLinkGraph:mtime 变了要重建', async () => {
|
|
193
|
+
resetLinkCache()
|
|
194
|
+
const files = { 'A.md': '见 `B.md`', 'B.md': 'x' }
|
|
195
|
+
let bump = 0
|
|
196
|
+
const reads = { count: 0 }
|
|
197
|
+
const docs = () => Object.keys(files).map((rel, i) => ({
|
|
198
|
+
rel, title: rel, mtimeMs: 1000 + i + bump,
|
|
199
|
+
}))
|
|
200
|
+
const io = {
|
|
201
|
+
list: async () => ({ docs: docs(), truncated: false }),
|
|
202
|
+
read: async (_r, rel) => { reads.count += 1; return { ok: true, rel, text: files[rel] } },
|
|
203
|
+
}
|
|
204
|
+
await buildLinkGraph('/fake-5', io)
|
|
205
|
+
const first = reads.count
|
|
206
|
+
bump = 500
|
|
207
|
+
await buildLinkGraph('/fake-5', io)
|
|
208
|
+
assert.ok(reads.count > first, 'mtime 变了必须重建')
|
|
209
|
+
})
|
|
210
|
+
|
|
211
|
+
test('buildLinkGraph:读失败的篇跳过,不影响其它篇(skipped 计数)', async () => {
|
|
212
|
+
resetLinkCache()
|
|
213
|
+
const io = fakeIo({ 'A.md': '见 `B.md`', 'B.md': 'x' })
|
|
214
|
+
const realRead = io.read
|
|
215
|
+
io.read = async (root, rel) => (rel === 'B.md' ? { ok: false, code: 'knit/read-failed' } : realRead(root, rel))
|
|
216
|
+
const g = await buildLinkGraph('/fake-6', io)
|
|
217
|
+
assert.equal(g.parsed, 1)
|
|
218
|
+
assert.equal(g.skipped, 1)
|
|
219
|
+
assert.deepEqual([...g.out.get('A.md')], ['B.md'], 'A 的解析不受 B 读失败影响')
|
|
220
|
+
})
|
|
221
|
+
|
|
222
|
+
/* ── linksOf:形状、排序、计数与截断 ─────────────────── */
|
|
223
|
+
|
|
224
|
+
test('linksOf:未知 rel → not-found(宿主只返回错误码,不返回文案)', () => {
|
|
225
|
+
const g = { titles: new Map([['A.md', 'A']]), in: new Map(), out: new Map(), limited: false }
|
|
226
|
+
assert.deepEqual(linksOf(g, 'nope.md'), { ok: false, code: 'knit/not-found' })
|
|
227
|
+
})
|
|
228
|
+
|
|
229
|
+
test('linksOf:只返回 rel + title,不泄漏内部结构', async () => {
|
|
230
|
+
resetLinkCache()
|
|
231
|
+
const io = fakeIo({ 'A.md': '见 `B.md`', 'B.md': 'x' })
|
|
232
|
+
const g = await buildLinkGraph('/fake-7', io)
|
|
233
|
+
const v = linksOf(g, 'B.md')
|
|
234
|
+
assert.equal(v.ok, true)
|
|
235
|
+
assert.deepEqual(Object.keys(v.incoming[0]).sort(), ['rel', 'title'])
|
|
236
|
+
assert.ok(!('out' in v) && !('titles' in v) && !('signature' in v))
|
|
237
|
+
})
|
|
238
|
+
|
|
239
|
+
test('linksOf:按「对方入度降序」排,平手按 rel 字典序(顺序必须稳定)', async () => {
|
|
240
|
+
resetLinkCache()
|
|
241
|
+
const io = fakeIo({
|
|
242
|
+
// hub 被两篇引用,leaf 没人引用;两者都引用了 T
|
|
243
|
+
'hub.md': '见 `T.md`',
|
|
244
|
+
'x.md': '见 `hub.md`',
|
|
245
|
+
'y.md': '见 `hub.md`',
|
|
246
|
+
'a-leaf.md': '见 `T.md`',
|
|
247
|
+
'T.md': 'target',
|
|
248
|
+
})
|
|
249
|
+
const g = await buildLinkGraph('/fake-8', io)
|
|
250
|
+
const v = linksOf(g, 'T.md')
|
|
251
|
+
assert.deepEqual(v.incoming.map((d) => d.rel), ['hub.md', 'a-leaf.md'],
|
|
252
|
+
'入度高的引用方排前面')
|
|
253
|
+
})
|
|
254
|
+
|
|
255
|
+
test('linksOf:计数给全量,列表可截断', async () => {
|
|
256
|
+
resetLinkCache()
|
|
257
|
+
const files = { 'T.md': 'target' }
|
|
258
|
+
for (let i = 0; i < 5; i += 1) files[`p${i}.md`] = '见 `T.md`'
|
|
259
|
+
const g = await buildLinkGraph('/fake-9', fakeIo(files))
|
|
260
|
+
const v = linksOf(g, 'T.md', 2)
|
|
261
|
+
assert.equal(v.incoming.length, 2)
|
|
262
|
+
assert.equal(v.incomingTotal, 5, '计数必须是全量,不能是截断后的长度')
|
|
263
|
+
})
|
|
264
|
+
|
|
265
|
+
test('linksOf:limited 透传(扫描被上限截断时面板要能提示「结果不完整」)', async () => {
|
|
266
|
+
resetLinkCache()
|
|
267
|
+
const io = fakeIo({ 'A.md': 'x' })
|
|
268
|
+
io.list = async () => ({ docs: [{ rel: 'A.md', title: 'A', mtimeMs: 1 }], truncated: true })
|
|
269
|
+
const g = await buildLinkGraph('/fake-10', io)
|
|
270
|
+
assert.equal(linksOf(g, 'A.md').limited, true)
|
|
271
|
+
})
|