dsh-knit 0.23.1 → 0.25.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.
@@ -0,0 +1,245 @@
1
+ /**
2
+ * **对话里「工具产出」的图**(v0.25)。
3
+ *
4
+ * 为什么要这个模块:在对话里生成的图**不在工作区里** —— 它们落在 DSH 的附件库
5
+ * `<dsh home>/attachments/v1/objects/<前两位>/<sha256>`,而 Knit 的扫描只能看会话工作区内,
6
+ * 所以那些图在媒体档里一个都看不到。
7
+ *
8
+ * 为了看到它们,这个模块只走一条**窄路**(与 L1 §6.9 / `SECURITY.md` 同一条纪律):
9
+ *
10
+ * 1. **列表从事件来,不从盘来** —— 会话事件里本来就带着完整元数据
11
+ * (`attachmentId: sha256:…` / `mediaType` / `width` / `height` / `bytes` / `name`),
12
+ * 所以「本会话有哪些图」**零 I/O**。
13
+ * 2. **只认 `tool/result` 里的图** —— 那是工具产出的(模型生成的);用户自己贴的图走
14
+ * `user/message` / `agent/inbox/spliced`,**默认不进媒体档**(隐私更保守)。
15
+ * 3. **字节只按 sha256 读** —— 路由不接受任何路径,只接受 `sha256:<64 hex>`;
16
+ * 而且**只有本会话出现过**的 id 才允许读(跨会话一律 404)。
17
+ * 4. **去重不扫全库** —— 附件 id 就是内容的 sha256,所以「工作区里已经有了吗」只要拿
18
+ * **大小相同**的候选文件算哈希即可(候选来自扫描结果里现成的 `size`,零额外 stat)。
19
+ *
20
+ * 纯函数与 I/O 分离:`attachmentsFromEvent` / `dropSaved` / `objectPath` 都能用假件真断言,
21
+ * 真正读盘只在 `readAttachment` 一处。
22
+ */
23
+
24
+ import { createHash } from 'node:crypto'
25
+ import { createReadStream } from 'node:fs'
26
+ import { homedir } from 'node:os'
27
+ import { join } from 'node:path'
28
+
29
+ /** 一条附件 id 的**唯一**合法形状。这是整个边界的地基:只认内容哈希,不认路径。 */
30
+ const ATTACHMENT_ID_RE = /^sha256:([0-9a-f]{64})$/
31
+
32
+ /** 每个会话最多记多少条(超了丢最老的)。 */
33
+ const MAX_ATTACHMENTS_PER_SESSION = 200
34
+ /** 最多跟踪多少个会话(LRU;进程重启即失)。 */
35
+ const MAX_TRACKED_SESSIONS = 24
36
+ /** 单个附件的字节上限 —— 与图片上限同档,超过的不列(既不列也不读)。 */
37
+ export const MAX_ATTACHMENT_BYTES = 12 * 1024 * 1024
38
+
39
+ /** 只认这两种媒体类型:媒体档本来就只显示图片与视频。 */
40
+ const MEDIA_RE = /^(image|video)\/[a-z0-9][a-z0-9.+-]*$/i
41
+
42
+ /**
43
+ * 是不是一条合法的附件 id。
44
+ * @param {unknown} value - 候选值
45
+ * @returns {boolean} 合法与否
46
+ */
47
+ export function isAttachmentId(value) {
48
+ return ATTACHMENT_ID_RE.test(String(value == null ? '' : value))
49
+ }
50
+
51
+ /**
52
+ * 取出 id 里的十六进制(不合法时回空串)。
53
+ * @param {unknown} value - 候选值
54
+ * @returns {string} 64 位十六进制
55
+ */
56
+ export function attachmentHex(value) {
57
+ const m = ATTACHMENT_ID_RE.exec(String(value == null ? '' : value))
58
+ return m ? m[1] : ''
59
+ }
60
+
61
+ /**
62
+ * 附件库的根目录。
63
+ *
64
+ * 优先 `DSH_HOME`(宿主自己也是这么定的),否则 `<用户目录>/.dsh`。
65
+ * **这是本插件唯一一处读工作区之外的地方** —— 见模块顶部那四条边界。
66
+ *
67
+ * @param {Record<string, string|undefined>} [env] - 环境变量(测试可注入)
68
+ * @returns {string} 绝对路径
69
+ */
70
+ export function attachmentsRoot(env = process.env) {
71
+ const home = env && typeof env.DSH_HOME === 'string' && env.DSH_HOME ? env.DSH_HOME : join(homedir(), '.dsh')
72
+ return join(home, 'attachments', 'v1', 'objects')
73
+ }
74
+
75
+ /**
76
+ * 一条 id 对应的对象文件路径。
77
+ *
78
+ * 路径**由哈希算出来**(前两位做目录,与 DSH 的布局一致),所以调用方给不出一个
79
+ * 能穿越到别处的路径 —— 不是「校验字符串里有没有 `..`」,而是**根本没有接受路径的入口**。
80
+ *
81
+ * @param {string} root - 附件库根
82
+ * @param {unknown} id - 附件 id
83
+ * @returns {string} 绝对路径(id 不合法时回空串)
84
+ */
85
+ export function objectPath(root, id) {
86
+ const hex = attachmentHex(id)
87
+ if (!hex || typeof root !== 'string' || !root) return ''
88
+ return join(root, hex.slice(0, 2), hex)
89
+ }
90
+
91
+ /**
92
+ * 从**一条会话事件**里取出工具产出的图。
93
+ *
94
+ * 只认 `tool/result`:那是工具(模型)产出的。用户自己贴的图在 `user/message` /
95
+ * `agent/inbox/spliced` 里,**这里刻意不收**。
96
+ *
97
+ * @param {object} event - 会话事件
98
+ * @returns {{id:string, name:string, mediaType:string, kind:'image'|'video', width:number, height:number, bytes:number, at:number}[]} 元数据(可能为空)
99
+ */
100
+ export function attachmentsFromEvent(event) {
101
+ if (!event || event.type !== 'tool/result') return []
102
+ const data = event.data && typeof event.data === 'object' ? event.data : {}
103
+ const message = data.message && typeof data.message === 'object' ? data.message : {}
104
+ const content = Array.isArray(message.content) ? message.content : []
105
+ const out = []
106
+ for (const part of content) {
107
+ if (!part || typeof part !== 'object') continue
108
+ if (part.type !== 'image' && part.type !== 'video') continue
109
+ const meta = part.attachment
110
+ if (!meta || typeof meta !== 'object') continue
111
+ const id = typeof meta.attachmentId === 'string' ? meta.attachmentId : ''
112
+ if (!isAttachmentId(id)) continue
113
+ const mediaType = typeof meta.mediaType === 'string' ? meta.mediaType : ''
114
+ if (!MEDIA_RE.test(mediaType)) continue
115
+ const bytes = Number.isFinite(meta.bytes) ? meta.bytes : 0
116
+ // 太小的多半不是图;太大的**不列也不读**(宁可漏,不去搬 12 MB 以上的东西)
117
+ if (!(bytes > 0) || bytes > MAX_ATTACHMENT_BYTES) continue
118
+ const kind = mediaType.toLowerCase().indexOf('video/') === 0 ? 'video' : 'image'
119
+ const name = typeof meta.name === 'string' && meta.name.trim() ? meta.name.trim() : `attachment-${attachmentHex(id).slice(0, 8)}`
120
+ out.push({
121
+ id,
122
+ name,
123
+ mediaType: mediaType.toLowerCase(),
124
+ kind,
125
+ width: Number.isFinite(meta.width) ? meta.width : 0,
126
+ height: Number.isFinite(meta.height) ? meta.height : 0,
127
+ bytes,
128
+ at: Number.isFinite(event.time) ? event.time : 0,
129
+ })
130
+ }
131
+ return out
132
+ }
133
+
134
+ /**
135
+ * 一个**有界**的附件登记簿(只活在内存里,进程重启即失)。
136
+ *
137
+ * 它存在的唯一理由:`/api/attachment` 必须能回答「这个 id 在本会话里出现过吗」。
138
+ * 没有这条判断,任何拿到哈希的人都能读附件库 —— 那就等于开了一个任意读。
139
+ *
140
+ * @param {{maxSessions?:number, maxPerSession?:number}} [options] - 上限
141
+ * @returns {{note:Function, list:Function, get:Function, has:Function, reset:Function, size:number}} 登记簿
142
+ */
143
+ export function createAttachmentStore(options = {}) {
144
+ const maxSessions = Number.isFinite(options.maxSessions) ? options.maxSessions : MAX_TRACKED_SESSIONS
145
+ const maxPerSession = Number.isFinite(options.maxPerSession) ? options.maxPerSession : MAX_ATTACHMENTS_PER_SESSION
146
+ /** @type {Map<string, Map<string, object>>} 会话 → (id → 元数据),插入顺序即先后 */
147
+ const bySession = new Map()
148
+
149
+ const touch = (sessionId) => {
150
+ let bag = bySession.get(sessionId)
151
+ if (!bag) {
152
+ bag = new Map()
153
+ bySession.set(sessionId, bag)
154
+ } else {
155
+ // 触达即把会话挪到 LRU 队尾
156
+ bySession.delete(sessionId)
157
+ bySession.set(sessionId, bag)
158
+ }
159
+ return bag
160
+ }
161
+
162
+ return {
163
+ /**
164
+ * 记一条事件(不是带图的事件就什么都不做 —— 默认成本是一次类型判断)。
165
+ * @param {string} sessionId - 会话 id
166
+ * @param {object} event - 会话事件
167
+ * @returns {number} 这条事件里记下的图数
168
+ */
169
+ note(sessionId, event) {
170
+ if (typeof sessionId !== 'string' || !sessionId) return 0
171
+ const items = attachmentsFromEvent(event)
172
+ if (!items.length) return 0
173
+ const bag = touch(sessionId)
174
+ for (const item of items) bag.set(item.id, item)
175
+ while (bag.size > maxPerSession) bag.delete(bag.keys().next().value)
176
+ while (bySession.size > maxSessions) bySession.delete(bySession.keys().next().value)
177
+ return items.length
178
+ },
179
+ /**
180
+ * 本会话登记过的图(按先后顺序)。
181
+ * @param {string} sessionId - 会话 id
182
+ * @returns {object[]} 副本
183
+ */
184
+ list(sessionId) {
185
+ const bag = bySession.get(sessionId)
186
+ return bag ? [...bag.values()] : []
187
+ },
188
+ /**
189
+ * 取一条(读字节前要用它拿 `mediaType` / `bytes`)。
190
+ * @param {string} sessionId - 会话 id
191
+ * @param {string} id - 附件 id
192
+ * @returns {object|undefined} 元数据
193
+ */
194
+ get(sessionId, id) {
195
+ const bag = bySession.get(sessionId)
196
+ return bag ? bag.get(id) : undefined
197
+ },
198
+ /**
199
+ * 这个 id 在本会话里出现过吗(**读字节的唯一闸门**)。
200
+ * @param {string} sessionId - 会话 id
201
+ * @param {string} id - 附件 id
202
+ * @returns {boolean} 出现与否
203
+ */
204
+ has(sessionId, id) {
205
+ return Boolean(this.get(sessionId, id))
206
+ },
207
+ reset() {
208
+ bySession.clear()
209
+ },
210
+ get size() {
211
+ return bySession.size
212
+ },
213
+ }
214
+ }
215
+
216
+ /**
217
+ * 把「工作区里已经有同内容文件」的条目去掉。
218
+ *
219
+ * 附件 id 就是内容的 sha256,所以这里是**内容级**去重,不是文件名去重:
220
+ * 你把图存成什么名字都行,只要字节一样就不会重复出现。
221
+ *
222
+ * 代价刻意压到最低:先按 `bytes` 筛候选(大小不同绝不可能同内容),
223
+ * 只给**大小相同**的那几个候选算哈希 —— 不扫全库、不给每张图算哈希。
224
+ *
225
+ * @param {object[]} items - 本会话登记的图
226
+ * @param {{candidates?:{rel:string,bytes:number}[], sha256Of?:(rel:string)=>Promise<string>|string}} [io] - 候选与哈希器(可注入)
227
+ * @returns {Promise<object[]>} 过滤后的列表
228
+ */
229
+ export async function dropSaved(items, io = {}) {
230
+ const list = Array.isArray(items) ? items : []
231
+ if (!list.length) return []
232
+ const candidates = Array.isArray(io.candidates) ? io.candidates : []
233
+ const sha256Of = io.sha256Of
234
+ if (!candidates.length || typeof sha256Of !== 'function') return list.slice()
235
+ const sizes = new Set(list.map((item) => item.bytes))
236
+ const suspects = candidates.filter((c) => c && sizes.has(c.bytes))
237
+ if (!suspects.length) return list.slice()
238
+ const saved = new Set()
239
+ for (const candidate of suspects) {
240
+ let hex = ''
241
+ try { hex = await sha256Of(candidate.rel) } catch { hex = '' }
242
+ if (hex) saved.add(hex)
243
+ }
244
+ return list.filter((item) => !saved.has(attachmentHex(item.id)))
245
+ }
@@ -0,0 +1,208 @@
1
+ /**
2
+ * Knit · **Git 变更关联投影**(v0.25 Git-aware Context Retrieval)
3
+ *
4
+ * 这一层回答的问题只有一句:**「这些被改过的文件,按已有的关联证据,还牵着谁」**。
5
+ *
6
+ * ## 它不发明关系,只挑已有的边
7
+ *
8
+ * 边全部来自 `relations.js` 的 `buildRelationFacts()` —— 那四类(`tests` / `imports` /
9
+ * `references` / `documents`)已经有各自的证据与守卫。本模块**只做一件事**:
10
+ * 把「变更文件」当作种子,去事实表里取它**已经存在**的边,再把边指向的那一端投影成
11
+ * 一条可以摆进列表的结果。**没有 AST、没有新图、没有猜出来的依赖。**
12
+ *
13
+ * ## 一条边都没有的变更文件怎么办
14
+ *
15
+ * 如实进 `unresolved`(面板据此说「N 个变更文件没有关联证据」),**不硬凑**。
16
+ * 这与 `context.js` 给 Related 层写下的那条纪律是同一条:说不出凭什么,就不出场。
17
+ *
18
+ * ## 为什么已删除 / 重命名前的路径也要当种子
19
+ *
20
+ * 这是本模块唯一一处需要解释的设计:**文件被删掉之后,它就不在候选集里了**,
21
+ * 于是 `relations.js` 的解析(`resolveRef` / `resolveSpec` / `testsOf`)**都不再认它** ——
22
+ * 「删掉 `tests/foo.test.ts`,谁在用它」这个问题会一声不响地没有答案。
23
+ *
24
+ * 修法很小:把**变更清单里那些已经不在工作区里的路径**,作为 `head: ''` 的**合成候选**
25
+ * 一并交给 `buildRelationFacts()`。索引里因此有这个 rel,别人指向它的边就能解析出来。
26
+ * 两条边界:
27
+ * · 合成候选的 `head` 是空的 ⇒ 它**自己**产不出任何出边(它确实已经没了);
28
+ * · 它**永远只能当种子,不能当结果**(`itemRels` 把它排除掉)—— 你没法打开一个不存在的文件。
29
+ *
30
+ * ## 截断(确定性)
31
+ *
32
+ * 结果按「证据类型优先级(沿用 `relations.js` 的 `RELATION_TYPES` 顺序)→ 关联到的变更文件数降序
33
+ * → rel 字典序」排,超过 `MAX_CHANGE_RELATED` 截断并如实给出 `relatedTotal`。
34
+ */
35
+
36
+ import { RELATION_TYPES, MAX_RELATIONS_PER_ITEM } from './relations.js'
37
+
38
+ /** 面板「变更关联」区最多几条(§6.7 同一条预算纪律:这是上限,不是建议)。 */
39
+ export const MAX_CHANGE_RELATED = 8
40
+
41
+ const TYPE_RANK = new Map(RELATION_TYPES.map((t, i) => [t, i]))
42
+ const rankOf = (type) => (TYPE_RANK.has(type) ? TYPE_RANK.get(type) : 99)
43
+
44
+ /** 方向翻转:一条边在两端各有一次登记,`line` 属于**叙述方**,所以翻转方向不改行号。 */
45
+ const flip = (dir) => (dir === 'in' ? 'out' : 'in')
46
+
47
+ /**
48
+ * 把一次变更清单分成三份:**能当结果的**、**只能当种子的**、**够不着的**。
49
+ *
50
+ * @param {object} changeSet - `git.js` 的 `read()` 产物
51
+ * @param {Set<string>} corpusRels - 当前候选集里的 rel(**只有它们能当结果**)
52
+ * @returns {{seeds: string[], gone: string[], outside: string[], seedRels: string[]}}
53
+ * `seeds` = 变更里确实还在候选集中的路径(含重命名后的新路径)—— 可以当结果,也可以当种子
54
+ * `gone` = 变更里**不在**候选集里的文件路径(删除的、重命名前的、工作区外的)——
55
+ * **只能当种子**(合成候选,见 `ghostCandidates()`),永远不当结果
56
+ * `outside` = 同 `gone`,但只算「看起来像文件」的(目录条目不算)—— 面板据此说
57
+ * 「N 个变更不在检索范围」
58
+ * `seedRels`= `seeds` + `gone`(**查找关系时两者都要问**:删掉的测试文件照样牵着它的被测文件)
59
+ *
60
+ * ⚠️ 目录条目(`?? some/dir/`)既不当种子也不算 `outside`:它不是文件,
61
+ * 而 `resolveRef` / `testsOf` 只会去认文件。它仍然出现在 `changeSet.files` 里(如实报告)。
62
+ */
63
+ export function splitSeeds(changeSet, corpusRels) {
64
+ const files = Array.isArray(changeSet && changeSet.files) ? changeSet.files : []
65
+ const seeds = []
66
+ const gone = []
67
+ const outside = []
68
+ const seenSeed = new Set()
69
+ const seenGone = new Set()
70
+ // ⚠️ `gone` 与 `outside` 是**两张表、两条去重线**:同一个 rel 同时属于两张表是**正常**的
71
+ // (「不在语料里的变更文件」既是「只能当种子」也是「不在检索范围」)。共用一个 Set
72
+ // 会让第二次 push 被当成重复而静默丢掉一枚(写完当场被测试抓到过一次)。
73
+ const seenOutside = new Set()
74
+ const push = (list, seen, rel) => {
75
+ if (!rel || seen.has(rel)) return
76
+ seen.add(rel)
77
+ list.push(rel)
78
+ }
79
+ const pushGone = (rel, isDir) => {
80
+ if (isDir) return
81
+ push(gone, seenGone, rel)
82
+ push(outside, seenOutside, rel)
83
+ }
84
+ for (const file of files) {
85
+ const rel = String(file.rel || '')
86
+ if (!rel) continue
87
+ const isDir = file.isDir === true
88
+ if (corpusRels.has(rel)) push(seeds, seenSeed, rel)
89
+ else pushGone(rel, isDir)
90
+ // 重命名 / 复制:原路径也当种子 —— 别人引用它的那条边还在,只是目标换了名字
91
+ const orig = file.origRel ? String(file.origRel) : ''
92
+ if (orig) {
93
+ if (corpusRels.has(orig)) push(seeds, seenSeed, orig)
94
+ else pushGone(orig, false)
95
+ }
96
+ }
97
+ seeds.sort()
98
+ gone.sort()
99
+ outside.sort()
100
+ return { seeds, gone, outside, seedRels: [...seeds, ...gone].sort() }
101
+ }
102
+
103
+ /**
104
+ * 合成候选:给「已经不在候选集里的变更路径」一个空壳,好让**别人指向它的边**解析得出来。
105
+ * 只喂给 `buildRelationFacts()`,**不进任何结果**。
106
+ *
107
+ * @param {string[]} gone - `splitSeeds()` 的 `gone`
108
+ * @returns {Array<{rel: string, head: string, mtimeMs: number, kind: string}>}
109
+ */
110
+ export function ghostCandidates(gone) {
111
+ return (Array.isArray(gone) ? gone : []).map((rel) => ({ rel, head: '', mtimeMs: 0, kind: 'md' }))
112
+ }
113
+
114
+ /**
115
+ * 种子 + 事实表 → 关联结果。**纯函数**(不读盘、不看时钟、不发请求)。
116
+ *
117
+ * @param {object} input
118
+ * @param {string[]} input.seeds - 变更文件里在候选集中的那些
119
+ * @param {Map<string, Array<object>>} input.incident - `buildRelationFacts().incident`
120
+ * @param {Set<string>} input.itemRels - **允许当结果**的 rel(= 候选集;已删除的路径不在里面)
121
+ * @param {Set<string>} [input.exclude] - 明确排除的 rel(变更文件自己 + 已经在三层 / 固定区里的)。
122
+ * 变更文件自己不当结果:这一区要回答的是「**还**该一起看什么」,不是「你改了什么」。
123
+ * @param {number} [input.limit] - 最多几条结果
124
+ * @returns {{related: Array<{rel: string, evidence: Array<object>, types: string[]}>, unresolved: string[], relatedTotal: number}}
125
+ */
126
+ export function projectChangeRelated(input) {
127
+ const seeds = Array.isArray(input && input.seeds) ? input.seeds : []
128
+ const incident = input && input.incident
129
+ const itemRels = input && input.itemRels instanceof Set ? input.itemRels : new Set()
130
+ const exclude = input && input.exclude instanceof Set ? input.exclude : new Set()
131
+ const limit = Number.isInteger(input && input.limit) && input.limit > 0 ? input.limit : MAX_CHANGE_RELATED
132
+
133
+ /** target rel → { rel, evidence: Map<key, edge> } */
134
+ const targets = new Map()
135
+ const unresolved = []
136
+
137
+ for (const seed of seeds) {
138
+ const edges = (incident && typeof incident.get === 'function' ? incident.get(seed) : null) || []
139
+ let count = 0
140
+ for (const edge of edges) {
141
+ if (!edge || typeof edge.other !== 'string' || !edge.type) continue
142
+ const target = edge.other
143
+ // 结果必须能打开:合成候选(已删除的路径)永远不当结果
144
+ if (target === seed || !itemRels.has(target) || exclude.has(target)) continue
145
+ let bucket = targets.get(target)
146
+ if (!bucket) {
147
+ bucket = { rel: target, evidence: new Map() }
148
+ targets.set(target, bucket)
149
+ }
150
+ // 证据按(起点 + 类型 + 方向)去重:同一对文件只留一条,行号取最靠前的
151
+ const key = `${seed}\u0000${edge.type}\u0000${flip(edge.dir)}`
152
+ const prev = bucket.evidence.get(key)
153
+ if (!prev) {
154
+ // ⚠️ 字段名逐字沿用 `relations.js` 的边形状(`type` / `dir` / `other` / `line`)——
155
+ // 面板的行级证据弹层与工具 `ITEM_SCHEMA` 都直接吃这一份,改个名字就会两处一起坏。
156
+ // 这里的 `other` 就是**关联起点**(那个被改过的文件)。
157
+ bucket.evidence.set(key, {
158
+ type: edge.type,
159
+ dir: flip(edge.dir),
160
+ other: seed,
161
+ ...(Number.isInteger(edge.line) ? { line: edge.line } : {}),
162
+ })
163
+ } else if (Number.isInteger(edge.line) && (!Number.isInteger(prev.line) || edge.line < prev.line)) {
164
+ prev.line = edge.line
165
+ }
166
+ count += 1
167
+ }
168
+ if (count === 0) unresolved.push(seed)
169
+ }
170
+
171
+ const rows = [...targets.values()].map((bucket) => {
172
+ const evidence = [...bucket.evidence.values()]
173
+ // 同一目标、同一类型、不同起点时,按类型优先级 → 起点字典序
174
+ evidence.sort((a, b) => {
175
+ const ta = rankOf(a.type)
176
+ const tb = rankOf(b.type)
177
+ if (ta !== tb) return ta - tb
178
+ const la = Number.isInteger(a.line) ? a.line : Number.MAX_SAFE_INTEGER
179
+ const lb = Number.isInteger(b.line) ? b.line : Number.MAX_SAFE_INTEGER
180
+ if (la !== lb) return la - lb
181
+ return a.other < b.other ? -1 : a.other > b.other ? 1 : 0
182
+ })
183
+ return { rel: bucket.rel, evidence, sources: new Set(evidence.map((e) => e.other)) }
184
+ })
185
+
186
+ rows.sort((a, b) => {
187
+ const ta = rankOf(a.evidence[0] && a.evidence[0].type)
188
+ const tb = rankOf(b.evidence[0] && b.evidence[0].type)
189
+ if (ta !== tb) return ta - tb
190
+ // 关联到的**变更文件**越多越靠前 —— 两个变更文件都指向它,是更强的「一起改」信号
191
+ if (a.sources.size !== b.sources.size) return b.sources.size - a.sources.size
192
+ return a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0
193
+ })
194
+
195
+ const relatedTotal = rows.length
196
+ const related = rows.slice(0, limit).map((row) => {
197
+ const shown = row.evidence.slice(0, MAX_RELATIONS_PER_ITEM)
198
+ return {
199
+ rel: row.rel,
200
+ evidence: shown,
201
+ evidenceTotal: row.evidence.length,
202
+ types: [...new Set(row.evidence.map((e) => e.type))],
203
+ from: [...new Set(row.evidence.map((e) => e.other))],
204
+ }
205
+ })
206
+ unresolved.sort()
207
+ return { related, unresolved, relatedTotal }
208
+ }