dsh-macro-memory 0.3.0 → 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/README.md +63 -14
- package/lib/index.js +34 -1
- package/lib/macro/defs/admin.js +12 -9
- package/lib/macro/defs/read.js +16 -1
- package/lib/macro/defs/remember.js +201 -3
- package/lib/macro/defs/search.js +214 -4
- package/lib/macro/supersede.js +197 -0
- package/lib/macro/tools.js +2 -2
- package/package.json +1 -1
- package/vendor/VENDOR.json +5 -5
- package/vendor/dsh-memory-nebula/lib/host/adapters/meow.js +4 -1
- package/vendor/dsh-memory-nebula/lib/host/entities.js +230 -0
- package/vendor/dsh-memory-nebula/lib/host/graph.js +101 -2
- package/vendor/dsh-memory-nebula/lib/host/graphcache.js +9 -1
- package/vendor/dsh-memory-nebula/lib/host/recall.js +75 -2
- package/vendor/dsh-memory-nebula/lib/index.js +26 -3
- package/vendor/dsh-memory-nebula/lib/web/app.js +15 -2
- package/vendor/meow-memory/lib/index.js +248 -13
|
@@ -7,6 +7,9 @@
|
|
|
7
7
|
* 并且每条带出来的记忆都会附上「为什么带它出来」的证据链。
|
|
8
8
|
*/
|
|
9
9
|
import { tokenize, idf, clip } from './text.js'
|
|
10
|
+
// [macro-fusion 0.4.0 · P4] 实体层:查询里点了名(比如「memory_search 的 budget 怎么算」)
|
|
11
|
+
// 就把那个实体下面的记忆全带上。它只加种子能量,不改 nodes/edges,关掉不留痕。
|
|
12
|
+
import { entitySeedsOf, entitySeedNodes } from './entities.js'
|
|
10
13
|
|
|
11
14
|
/** 扩散衰减系数:一跳打这个折,二跳再打一次。 */
|
|
12
15
|
const HOP_DECAY = 0.58
|
|
@@ -14,6 +17,18 @@ const HOP_DECAY = 0.58
|
|
|
14
17
|
const MAX_HOPS = 2
|
|
15
18
|
/** 每跳最多从多少个高能节点继续传。 */
|
|
16
19
|
const FRONTIER_WIDTH = 110
|
|
20
|
+
/**
|
|
21
|
+
* [macro-fusion 0.4.0 · P4] 动态跳数的门槛:目标节点与查询的词面重合低于这个值,
|
|
22
|
+
* 第二跳就不再走过去。0.2 = 六个词里至少沾一个。
|
|
23
|
+
* 这条门槛只在 hop≥1 生效:第一跳是「直接邻居」,那是星图最基本的语义,不该被砍。
|
|
24
|
+
*/
|
|
25
|
+
const DYNAMIC_MIN_MATCH = 0.2
|
|
26
|
+
/**
|
|
27
|
+
* [macro-fusion 0.4.0 · P4] 硬边:这些边本身就是「同一件事」的证据(人工策展、同一标识、
|
|
28
|
+
* 跨工作区同项目),不需要再看词面。动态跳数只对软边(关键词/语义/共激活)要求匹配——
|
|
29
|
+
* 否则「这条记忆写的是半个句子」会被当成「没关系」,把真正的另一半砍掉。
|
|
30
|
+
*/
|
|
31
|
+
const HARD_EDGE = new Set(['explicit', 'entity', 'project'])
|
|
17
32
|
|
|
18
33
|
/**
|
|
19
34
|
* 归一化一组 memory id:允许传完整 node id,也允许传 meow 的裸 uid。
|
|
@@ -286,6 +301,28 @@ export function recall(graph, query, opts = {}) {
|
|
|
286
301
|
}
|
|
287
302
|
}
|
|
288
303
|
|
|
304
|
+
// ---------- 2.6 实体种子(P4) ----------
|
|
305
|
+
// 「关于 memory_search 的一切」这种问法,词面命中只能捞到正文里恰好写了全名的那几条;
|
|
306
|
+
// 实体层知道哪些记忆共享同一个工具名/路径/项目/版本,一次就能把另一半带上来。
|
|
307
|
+
// 能量比文本种子低(ENTITY_SEED = 0.6):实体是「同一件事」的证据,但不如「正文直接命中」硬。
|
|
308
|
+
const entityOn = opts.entityLayer !== false && qNorm.length > 0
|
|
309
|
+
const entityHits = entityOn ? entitySeedsOf(query, graph.entityLayer, { limit: 8 }) : []
|
|
310
|
+
const entityPairs = entityHits.length ? entitySeedNodes(entityHits, graph.entityLayer) : []
|
|
311
|
+
/** 实体成员集合:动态跳数用它给「同一实体的邻居」放行。 */
|
|
312
|
+
const entityMember = new Set()
|
|
313
|
+
for (const s of entityPairs) {
|
|
314
|
+
if (!(s.i >= 0 && s.i < n)) continue
|
|
315
|
+
if (entityMember.has(s.i)) continue
|
|
316
|
+
const node = nodes[s.i]
|
|
317
|
+
if (!selectable(node)) continue
|
|
318
|
+
entityMember.add(s.i)
|
|
319
|
+
if (s.energy > seedE[s.i]) {
|
|
320
|
+
seedE[s.i] = s.energy
|
|
321
|
+
energy[s.i] = Math.max(energy[s.i], s.energy)
|
|
322
|
+
via[s.i] = via[s.i] || { from: -1, type: 'entity', w: Math.round(s.energy * 1000) / 1000 }
|
|
323
|
+
}
|
|
324
|
+
}
|
|
325
|
+
|
|
289
326
|
// ---------- 3. 邻接表 ----------
|
|
290
327
|
let adjCached = ADJ_CACHE.get(graph)
|
|
291
328
|
if (!adjCached || adjCached.n !== n || adjCached.m !== edges.length) {
|
|
@@ -303,6 +340,22 @@ export function recall(graph, query, opts = {}) {
|
|
|
303
340
|
|
|
304
341
|
// ---------- 4. 扩散 ----------
|
|
305
342
|
const propagate = new Float64Array(n)
|
|
343
|
+
// [macro-fusion 0.4.0 · P4] 动态跳数:不再「跳满 hops 为止」,而是每跳先问
|
|
344
|
+
// 「这个邻居与本次查询还有没有关系」。没有就停——省下的不只是预算,
|
|
345
|
+
// 更是不让第二跳把同项目里那些只因为「同一个工作区」而被连上的记忆一起点亮。
|
|
346
|
+
const dynamicHops = opts.dynamicHops !== false && qTokens.size > 0
|
|
347
|
+
const qCap = Math.max(1, Math.min(qTokens.size, 6))
|
|
348
|
+
const matchOf = (j) => {
|
|
349
|
+
if (entityMember.has(j)) return 1
|
|
350
|
+
const bag = tokensOf[j]
|
|
351
|
+
if (!bag) return 0
|
|
352
|
+
let hit = 0
|
|
353
|
+
for (const t of qTokens) if (bag.has(t)) hit++
|
|
354
|
+
return hit / qCap
|
|
355
|
+
}
|
|
356
|
+
let hopsUsed = 0
|
|
357
|
+
let hopsStopped = ''
|
|
358
|
+
let skipped = 0
|
|
306
359
|
let frontier = []
|
|
307
360
|
for (let i = 0; i < n; i++) if (energy[i] > 0) frontier.push(i)
|
|
308
361
|
frontier.sort((a, b) => energy[b] - energy[a])
|
|
@@ -312,7 +365,11 @@ export function recall(graph, query, opts = {}) {
|
|
|
312
365
|
const next = new Map()
|
|
313
366
|
for (const from of frontier) {
|
|
314
367
|
const src = nodes[from]
|
|
315
|
-
|
|
368
|
+
// [macro-fusion 0.4.0 · P4] 第一跳用种子能量,第二跳起用上一跳给它的那份能量。
|
|
369
|
+
// 原来这里一律读 energy[],而 energy[] 只在种子里写过——于是第二跳每个节点的 e0 都是 0,
|
|
370
|
+
// 被下面那道 `< 0.06` 直接跳过,next 恒空、循环立刻 break。
|
|
371
|
+
// 也就是说 `hops: 2` 从来没有真的走过第二跳,MAX_HOPS 与「二跳再打一次」的注释都是空的。
|
|
372
|
+
const e0 = hop === 0 ? energy[from] : propagate[from] || 0
|
|
316
373
|
if (e0 < 0.06) continue
|
|
317
374
|
// 来源节点是「标签」不是「记忆」:能量落在它身上是对的(能看出这条记忆用过什么),
|
|
318
375
|
// 但不能让它当一个超级中转站,把 20 多条记忆一视同仁地全点亮。
|
|
@@ -321,7 +378,18 @@ export function recall(graph, query, opts = {}) {
|
|
|
321
378
|
const target = nodes[link.to]
|
|
322
379
|
if (!crossWorkspace && target.ws !== src.ws) continue
|
|
323
380
|
const damp = target.level === 'source' ? 0.55 : 1
|
|
324
|
-
|
|
381
|
+
let gain = e0 * link.w * HOP_DECAY * fromDamp * damp
|
|
382
|
+
if (dynamicHops && !HARD_EDGE.has(link.type)) {
|
|
383
|
+
const m = matchOf(link.to)
|
|
384
|
+
// 第二跳起:与查询毫无词面关系的邻居不再走过去(第一跳不受限,见 DYNAMIC_MIN_MATCH)
|
|
385
|
+
if (hop >= 1 && m < DYNAMIC_MIN_MATCH) {
|
|
386
|
+
skipped++
|
|
387
|
+
if (!hopsStopped) hopsStopped = `跳 ${hop + 1}`
|
|
388
|
+
continue
|
|
389
|
+
}
|
|
390
|
+
// 有关系也不是全给:词面各占一半,剩下的看关系本身
|
|
391
|
+
gain *= 0.45 + 0.55 * m
|
|
392
|
+
}
|
|
325
393
|
if (gain < 0.02) continue
|
|
326
394
|
const prev = next.get(link.to) || 0
|
|
327
395
|
if (gain > prev + 1e-6) {
|
|
@@ -334,6 +402,7 @@ export function recall(graph, query, opts = {}) {
|
|
|
334
402
|
}
|
|
335
403
|
}
|
|
336
404
|
if (next.size === 0) break
|
|
405
|
+
hopsUsed = hop + 1
|
|
337
406
|
frontier = [...next.entries()].sort((a, b) => b[1] - a[1]).slice(0, FRONTIER_WIDTH).map((x) => x[0])
|
|
338
407
|
}
|
|
339
408
|
|
|
@@ -432,6 +501,10 @@ export function recall(graph, query, opts = {}) {
|
|
|
432
501
|
unknown: unknownTerms,
|
|
433
502
|
hits,
|
|
434
503
|
scanned: scored.length,
|
|
504
|
+
// [macro-fusion 0.4.0 · P4] 三个数一起报:命中集、平均跳数、被砍掉的串味邻居。
|
|
505
|
+
// 只看「省了预算」不算数——跳数下降如果伴随命中集下降,那是变笨不是变省。
|
|
506
|
+
hops: { asked: hops, used: hopsUsed, stoppedAt: hopsStopped || null, skippedNeighbors: skipped, dynamic: dynamicHops },
|
|
507
|
+
entities: entityHits.map((x) => ({ label: x.label, type: x.type, members: x.members })),
|
|
435
508
|
// [macro-fusion 0.2.39] 图里一共多少节点:空命中要能分清「图是空的」和「图里真没有」。
|
|
436
509
|
// scanned 是「算进候选的条数」,查询词一个都对不上时它本来就是 0——拿它当凭据会把两种空命中混成一种。
|
|
437
510
|
nodes: n,
|
|
@@ -199,7 +199,9 @@ export function apply(ctx) {
|
|
|
199
199
|
description: '别的记忆工具刚返回的记忆 id(meow 的 id 或星图的完整 id),用来从这些点向外交扩散。',
|
|
200
200
|
},
|
|
201
201
|
limit: { type: 'number', description: '返回条数,默认 10,上限 30。' },
|
|
202
|
-
hops: { type: 'number', description: '扩散跳数,默认 2;1=只看直接邻居,2
|
|
202
|
+
hops: { type: 'number', description: '扩散跳数,默认 2;1=只看直接邻居,2=邻居的邻居。第二跳起会按「邻居与查询还有没有关系」提前停。' },
|
|
203
|
+
entity: { type: 'boolean', description: '是否按实体(项目名/路径/工具名/版本号)带同组记忆。默认开。' },
|
|
204
|
+
dynamic_hops: { type: 'boolean', description: '第二跳是否按词面收。默认开;关掉=跳满(0.4.0 前)。' },
|
|
203
205
|
},
|
|
204
206
|
required: [],
|
|
205
207
|
additionalProperties: false,
|
|
@@ -213,8 +215,29 @@ export function apply(ctx) {
|
|
|
213
215
|
const pLimit = numParam('limit', args.limit, { min: 1, max: 30, def: 10 })
|
|
214
216
|
const pHops = numParam('hops', args.hops, { min: 0, max: 3, def: 2 })
|
|
215
217
|
const notes = [pLimit.note, pHops.note].filter(Boolean)
|
|
216
|
-
|
|
217
|
-
|
|
218
|
+
// [macro-fusion 0.4.0 · P4] 两个开关默认开:实体层只读不写,动态跳数只省不亏。
|
|
219
|
+
// 关法三条:工具参数 entity=false / dynamic_hops=false,或环境变量 NEBULA_ENTITY_LAYER=0
|
|
220
|
+
// / NEBULA_DYNAMIC_HOPS=0(整机回滚,不用改配置也不动记忆)。
|
|
221
|
+
const entityOn = args.entity !== false && String(process.env.NEBULA_ENTITY_LAYER ?? '') !== '0'
|
|
222
|
+
const dynamicOn = args.dynamic_hops !== false && String(process.env.NEBULA_DYNAMIC_HOPS ?? '') !== '0'
|
|
223
|
+
const res = await nebula.recallAsync(query, {
|
|
224
|
+
limit: pLimit.value,
|
|
225
|
+
hops: pHops.value,
|
|
226
|
+
seedIds: ids,
|
|
227
|
+
entityLayer: entityOn,
|
|
228
|
+
dynamicHops: dynamicOn,
|
|
229
|
+
})
|
|
230
|
+
let base = formatHits(res, ids.length ? `种子来自你给的 ${ids.length} 条记忆 id` : '')
|
|
231
|
+
// 两条读数只在「这次确实发生了」时加一行:命中了实体、或扩散中途停了。
|
|
232
|
+
// 常态不写,免得把每次检索的尾巴都撑长。
|
|
233
|
+
const extra = []
|
|
234
|
+
if (Array.isArray(res.entities) && res.entities.length > 0) {
|
|
235
|
+
extra.push(`实体:${res.entities.map((e) => `${e.label}(${e.members})`).join('、')}`)
|
|
236
|
+
}
|
|
237
|
+
if (res.hops && res.hops.dynamic && res.hops.used < res.hops.asked) {
|
|
238
|
+
extra.push(`只走了 ${res.hops.used} 跳(问 ${res.hops.asked}):${res.hops.skippedNeighbors} 条邻居与查询无词面关系,停了。`)
|
|
239
|
+
}
|
|
240
|
+
if (extra.length) base = `${base}\n${extra.join('\n')}`
|
|
218
241
|
return notes.length ? `${base}\n${notes.join('\n')}` : base
|
|
219
242
|
},
|
|
220
243
|
}),
|
|
@@ -787,8 +787,10 @@
|
|
|
787
787
|
// 只诊断、不改记忆——这里点进去看,改不改由人(或 AI)决定。
|
|
788
788
|
const hy = ov.hygiene
|
|
789
789
|
if (hy && hy.total) {
|
|
790
|
-
|
|
791
|
-
|
|
790
|
+
// [macro-fusion 0.4.0] 后三项是写入端通胀(P2.5):前六项看「这条记忆本身」,
|
|
791
|
+
// 后三项看「写入与检索被同一批词反复喂」——同一张卡片里放,但门槛比前六项高,免得噪声常驻。
|
|
792
|
+
const HORDER = ['dup', 'stale', 'thin', 'oversize', 'unread', 'orphan', 'selfecho', 'unused', 'inflate']
|
|
793
|
+
const HMIN = { dup: 1, stale: 1, thin: 1, oversize: 2, unread: 6, orphan: 6, selfecho: 3, unused: 3, inflate: 1 }
|
|
792
794
|
const kinds = HORDER.filter((k) => (hy.counts?.[k] || 0) >= (HMIN[k] || 1))
|
|
793
795
|
if (kinds.length) {
|
|
794
796
|
const head = el('div', 'src src-click')
|
|
@@ -828,6 +830,12 @@
|
|
|
828
830
|
} else if (k === 'unread') {
|
|
829
831
|
text = (it.label || '').slice(0, 26) + ' · ' + it.days + T(' 天')
|
|
830
832
|
jump = it.id
|
|
833
|
+
} else if (k === 'selfecho') {
|
|
834
|
+
text = (it.label || '').slice(0, 26) + ' · ' + Math.round((it.rate || 0) * 100) + '%' + T(' 自证') + ' (' + it.echo + '/' + it.kws + ')'
|
|
835
|
+
jump = it.id
|
|
836
|
+
} else if (k === 'unused') {
|
|
837
|
+
text = (it.label || '').slice(0, 26) + T(' · 命中 ') + it.hits + T(' 次没读过')
|
|
838
|
+
jump = it.id
|
|
831
839
|
} else {
|
|
832
840
|
text = (it.label || '').slice(0, 28)
|
|
833
841
|
jump = it.id
|
|
@@ -2476,6 +2484,9 @@
|
|
|
2476
2484
|
const dupIt = (hy.items.dup || []).find((x) => x.a.id === n.id || x.b.id === n.id)
|
|
2477
2485
|
const overIt = (hy.items.oversize || []).find((x) => x.id === n.id)
|
|
2478
2486
|
const thinIt = (hy.items.thin || []).find((x) => x.id === n.id)
|
|
2487
|
+
// [macro-fusion 0.4.0] 写入端通胀也贴到单条上:自证与「召回过没人读」都是逐条的毛病。
|
|
2488
|
+
const echoIt = (hy.items.selfecho || []).find((x) => x.id === n.id)
|
|
2489
|
+
const unusedIt = (hy.items.unused || []).find((x) => x.id === n.id)
|
|
2479
2490
|
const notes = []
|
|
2480
2491
|
if (staleIt) notes.push(T('还挂着 active,但「') + (staleIt.by.label || '').slice(0, 24) + T('」更新更全——这条可能该并进去'))
|
|
2481
2492
|
if (dupIt) {
|
|
@@ -2484,6 +2495,8 @@
|
|
|
2484
2495
|
}
|
|
2485
2496
|
if (overIt) notes.push(T('正文 ') + overIt.size + T(' 字,属于本库最长的一批,读一次很贵'))
|
|
2486
2497
|
if (thinIt) notes.push(T('连接 ') + thinIt.degree + T(' 条但平均强度只有 ') + thinIt.avg + T(',多半是关键词撞出来的'))
|
|
2498
|
+
if (echoIt) notes.push(T('关键词有 ') + echoIt.echo + '/' + echoIt.kws + T(' 个逐字出现在正文里——这些词靠 BM25 本来就能命中,等于没扩召回面'))
|
|
2499
|
+
if (unusedIt) notes.push(T('被检索命中过 ') + unusedIt.hits + T(' 次,却一次都没被读过:排进候选但没人真去读'))
|
|
2487
2500
|
if (notes.length) {
|
|
2488
2501
|
const box = el('div', 'd-hygiene')
|
|
2489
2502
|
box.id = 'd-hygiene'
|
|
@@ -455,6 +455,7 @@ var COMMON_COLS = `
|
|
|
455
455
|
status TEXT NOT NULL DEFAULT 'active',
|
|
456
456
|
source_session TEXT,
|
|
457
457
|
hit_count INTEGER NOT NULL DEFAULT 0,
|
|
458
|
+
read_count INTEGER NOT NULL DEFAULT 0,
|
|
458
459
|
created_at INTEGER NOT NULL,
|
|
459
460
|
updated_at INTEGER NOT NULL,
|
|
460
461
|
last_accessed_at INTEGER
|
|
@@ -566,6 +567,11 @@ var MemoryDb = class {
|
|
|
566
567
|
if (level === "topic" && !cols.has("project")) {
|
|
567
568
|
this.db.exec("ALTER TABLE topic ADD COLUMN project TEXT");
|
|
568
569
|
}
|
|
570
|
+
// [macro-fusion 0.4.0] 「召回过」与「真读过」是两件事,体检的 unused 要靠后者。
|
|
571
|
+
// 老库补列(DEFAULT 0 不会把历史读当成没读,只是从这一版起开始记)。
|
|
572
|
+
if (!cols.has("read_count")) {
|
|
573
|
+
this.db.exec(`ALTER TABLE ${level} ADD COLUMN read_count INTEGER NOT NULL DEFAULT 0`);
|
|
574
|
+
}
|
|
569
575
|
const legacy = this.p(`SELECT id FROM ${level}`).all();
|
|
570
576
|
for (const { id } of legacy) {
|
|
571
577
|
if (/^[0-9a-z]{9}-/.test(id)) continue;
|
|
@@ -786,6 +792,15 @@ var MemoryDb = class {
|
|
|
786
792
|
id
|
|
787
793
|
);
|
|
788
794
|
}
|
|
795
|
+
/** [macro-fusion 0.4.0] 真被 read 打开一次。与 bumpHit 分开记:
|
|
796
|
+
* 检索命中不等于读——命中只证明「排进了候选」,读过才证明「这段正文进过上下文」。
|
|
797
|
+
* 体检的 unused 判的是后者(hit_count > 0 且 read_count = 0)。 */
|
|
798
|
+
bumpRead(level, id) {
|
|
799
|
+
this.p(`UPDATE ${level} SET read_count = read_count + 1, last_accessed_at = ? WHERE id = ?`).run(
|
|
800
|
+
Date.now(),
|
|
801
|
+
id
|
|
802
|
+
);
|
|
803
|
+
}
|
|
789
804
|
count(level) {
|
|
790
805
|
const row = this.p(`SELECT COUNT(*) AS n FROM ${level}`).get();
|
|
791
806
|
return row.n;
|
|
@@ -1175,6 +1190,9 @@ var MemoryDb = class {
|
|
|
1175
1190
|
goal: r.goal == null ? null : String(r.goal),
|
|
1176
1191
|
source_session: r.source_session == null ? null : String(r.source_session),
|
|
1177
1192
|
hit_count: Number(r.hit_count ?? 0),
|
|
1193
|
+
// [macro-fusion 0.4.0] 真被 memory_read 打开过几次。老库补列前是 undefined → 0,
|
|
1194
|
+
// 所以「0 次」在这里永远是「没记过」,不是「记过但没读」——体检的 unused 靠这条区分。
|
|
1195
|
+
read_count: Number(r.read_count ?? 0),
|
|
1178
1196
|
created_at: Number(r.created_at),
|
|
1179
1197
|
updated_at: Number(r.updated_at),
|
|
1180
1198
|
last_accessed_at: r.last_accessed_at == null ? null : Number(r.last_accessed_at)
|
|
@@ -2258,8 +2276,40 @@ var SYN_GROUPS = [
|
|
|
2258
2276
|
["封存", "冻结", "归档", "下线", "停用"],
|
|
2259
2277
|
["底线", "下限", "地板", "门槛"],
|
|
2260
2278
|
["口径", "说法", "叫法", "定义"],
|
|
2279
|
+
// [macro-fusion 0.4.0 · P5] 查询扩展第二段:口语 → 术语、中文 → 英文技术名词、常见错写。
|
|
2280
|
+
// 三条纪律不变:只扩问句不扩库、扩出来的词必须 df>0(没人命中就白算)、权重仍走 SYN_W < 1。
|
|
2281
|
+
// 与上面 18 组一样,组内互扩、组间不许有重复词(G21 的表形态判据会当场打红)。
|
|
2282
|
+
// 英文词按整词 tokenize(不受中文二元组限制),所以这里允许 2 字符以上的小写英文。
|
|
2283
|
+
["卡住", "阻塞", "挂起", "卡死"],
|
|
2284
|
+
["崩了", "崩溃", "报错", "出错", "失败"],
|
|
2285
|
+
["令牌", "token"],
|
|
2286
|
+
["缓存", "cache"],
|
|
2287
|
+
["配置", "config"],
|
|
2288
|
+
["索引", "index"],
|
|
2289
|
+
["接口", "api", "端点"],
|
|
2290
|
+
["字段", "field"],
|
|
2291
|
+
["备份", "快照", "存档"],
|
|
2292
|
+
["回滚", "还原", "恢复"],
|
|
2293
|
+
["接线", "挂载", "接入", "拼装"],
|
|
2294
|
+
["提速", "变快", "加速"],
|
|
2295
|
+
["省下", "节省", "少花"],
|
|
2296
|
+
["修好", "修复", "修掉", "补回"],
|
|
2297
|
+
["日志", "log"],
|
|
2298
|
+
["文档", "readme", "手册"],
|
|
2299
|
+
["词表", "同义", "近义"],
|
|
2300
|
+
["切片", "分片", "chunk"],
|
|
2301
|
+
["向量", "vector"],
|
|
2302
|
+
["超时", "timeout", "逾时"],
|
|
2261
2303
|
];
|
|
2262
2304
|
var SYN_W = 0.6;
|
|
2305
|
+
// [macro-fusion 0.4.0 · P5] 扩词还有一道高频门:df 占全库三成以上的词,扩了只是把噪声撒到每一条上
|
|
2306
|
+
// (idf 本来就低,收益≈0,却能把不相关条目抬进榜)。0.35 是「够常见但不至于到处都有」的分界,
|
|
2307
|
+
// 判据量两件事:①df 超过 35% 的词一个都不许扩;②照抄池/锚点池逐条零漂移(扩表不能改老读数)。
|
|
2308
|
+
// 第三参 n 缺省时这道门关着——老调用方(探针/外部脚本)行为一字不变。
|
|
2309
|
+
var SYN_MAX_DF_RATIO = 0.35;
|
|
2310
|
+
// 每个问句词最多扩几个:手工表一组平均 3~4 个,自学习最多 6 个,合流后按 6 截断。
|
|
2311
|
+
// 截断是为了防「一个高频问句词被扩成一串,把整条 query 稀释掉」——扩词是桥,不是主力。
|
|
2312
|
+
var SYN_MAX_PER_TERM = 6;
|
|
2263
2313
|
var SYN_MAP = null;
|
|
2264
2314
|
function synMapOf() {
|
|
2265
2315
|
if (SYN_MAP !== null) return SYN_MAP;
|
|
@@ -2273,14 +2323,21 @@ function synMapOf() {
|
|
|
2273
2323
|
}
|
|
2274
2324
|
return SYN_MAP;
|
|
2275
2325
|
}
|
|
2276
|
-
|
|
2326
|
+
// [macro-fusion 0.4.0 · P5] 两个来源合流:手工表是种子(管「人已经确定的等价说法」),
|
|
2327
|
+
// 共现表是自学习(管「新领域、新术语、新缩写——从来没人告诉过我它们是一回事」)。
|
|
2328
|
+
// 第四参 cooc 缺省 null 时,行为与 0.3.0 一字不差:老探针和外部脚本调三个参数照样跑。
|
|
2329
|
+
function synExpandOf(qTerms, df, n, cooc) {
|
|
2277
2330
|
const map = synMapOf();
|
|
2331
|
+
const cap = Number.isFinite(n) && n > 0 ? Math.max(1, Math.floor(n * SYN_MAX_DF_RATIO)) : Infinity;
|
|
2278
2332
|
const out = /* @__PURE__ */ new Map();
|
|
2333
|
+
const usable = (a, list) => !qTerms.includes(a) && !list.includes(a) && (df.get(a) ?? 0) > 0 && (df.get(a) ?? 0) <= cap;
|
|
2279
2334
|
for (const t of qTerms) {
|
|
2280
|
-
const
|
|
2281
|
-
|
|
2282
|
-
const use =
|
|
2283
|
-
|
|
2335
|
+
const manual = map.get(t) ?? [];
|
|
2336
|
+
const learned = cooc instanceof Map ? cooc.get(t) ?? [] : [];
|
|
2337
|
+
const use = [];
|
|
2338
|
+
for (const a of manual) if (usable(a, use)) use.push(a);
|
|
2339
|
+
for (const a of learned) if (usable(a, use)) use.push(a);
|
|
2340
|
+
if (use.length > 0) out.set(t, use.slice(0, SYN_MAX_PER_TERM));
|
|
2284
2341
|
}
|
|
2285
2342
|
return out.size > 0 ? out : null;
|
|
2286
2343
|
}
|
|
@@ -2521,6 +2578,155 @@ function indexSignature(docs) {
|
|
|
2521
2578
|
return `${docs.length}:${h >>> 0}`;
|
|
2522
2579
|
}
|
|
2523
2580
|
|
|
2581
|
+
// [macro-fusion 0.4.0 · P5] 自学习扩词:等价说法不再只靠手工表。
|
|
2582
|
+
// 手工表(SYN_GROUPS)管「我已经知道的说法」,新领域、新术语、新缩写它一概不认识;
|
|
2583
|
+
// 而库里每一条记忆都带着人写的 keywords——那就是一份随库更新的真词表。
|
|
2584
|
+
// 于是共现从 keywords 上统计,而不是从 tokenize 出来的 bigram 上统计:
|
|
2585
|
+
// bigram 里混着「名空/置面/地全/门读」这类跨词边界的碎片(真库里 223 个有扩词的词几乎全是碎片),
|
|
2586
|
+
// keywords 里则全是真词(实测 2,866 个词、2,845 个有扩词,抽样 `推送→push/发版/github`、
|
|
2587
|
+
// `基线→阴性对照/量具/doctor`、`预算→key/花钱/评测` 全是真语义关联)。
|
|
2588
|
+
// 两级证据:同一条记忆里两个关键词同时出现 = 强(+2);同一个 project 里两条记忆各自的词 = 弱(+1)。
|
|
2589
|
+
// 剪枝两道(都在判据里量):
|
|
2590
|
+
// ① 次数 ≥ 2,偶发一次不算关联;
|
|
2591
|
+
// ② 条件概率 cooc(a,b)/df(a) ≥ 0.25——a 出现十次只有一次带 b,那不算 a 的另一种说法。
|
|
2592
|
+
// 共享汉字的词对(自测/自检、切片/片段)只记弱证据:它们可能是真同义,也可能是字面撞车,
|
|
2593
|
+
// 一律排除会丢掉「自测≡自检」这种真桥,一律算强又会把字面族噪声顶上来,所以降到 +1 让它自己争。
|
|
2594
|
+
var COOC_W_SAME = 2;
|
|
2595
|
+
// 同 project 那层只算「跨文档」:一条记忆的关键词与同项目里**别的**记忆的关键词相交才算,
|
|
2596
|
+
// 同一条内部的词对不重复计——否则「同一条 + 同 project」会自动凑到 2 分,
|
|
2597
|
+
// 共享汉字的降权就等于没降。实现上每条记忆与「本项目所有词的并集减掉自己」交叉,
|
|
2598
|
+
// 双向各记一次,所以一对词「在两条记忆里各出现一次」净得 2 分,正好够线;
|
|
2599
|
+
// 「只出现在同一条里」得 0 分(那是同条层的活,权重 2)。
|
|
2600
|
+
var COOC_W_PROJ = 1;
|
|
2601
|
+
var COOC_SHARE_HAN_W = 1;
|
|
2602
|
+
var COOC_MIN_COUNT = 2;
|
|
2603
|
+
var COOC_MIN_RATIO = 0.25;
|
|
2604
|
+
var COOC_TOP_PER_TERM = 6;
|
|
2605
|
+
|
|
2606
|
+
// keywords 字段有两种形态:真数组,或者一整串(逗号/顿号分隔,个别是 JSON 字符串)。
|
|
2607
|
+
// 这里要的是原词,不是 tokenize 出来的 bigram——「阴性对照」必须保持四个字。
|
|
2608
|
+
function coocWordsOf(d) {
|
|
2609
|
+
const raw = d && d.keywords;
|
|
2610
|
+
let list = [];
|
|
2611
|
+
if (Array.isArray(raw)) list = raw;
|
|
2612
|
+
else if (typeof raw === "string" && raw.trim().length > 0) {
|
|
2613
|
+
const t = raw.trim();
|
|
2614
|
+
if (t.startsWith("[")) {
|
|
2615
|
+
try {
|
|
2616
|
+
const j = JSON.parse(t);
|
|
2617
|
+
list = Array.isArray(j) ? j : t.split(/[,,、;;]/);
|
|
2618
|
+
} catch {
|
|
2619
|
+
list = t.split(/[,,、;;]/);
|
|
2620
|
+
}
|
|
2621
|
+
} else list = t.split(/[,,、;;]/);
|
|
2622
|
+
}
|
|
2623
|
+
const out = [];
|
|
2624
|
+
for (const w of list) {
|
|
2625
|
+
const s = String(w ?? "").trim();
|
|
2626
|
+
if (s.length < 2 || s.length > 8) continue;
|
|
2627
|
+
if (!/[\u4e00-\u9fff]/.test(s) && !/^[a-zA-Z][a-zA-Z0-9_.-]{2,}$/.test(s)) continue;
|
|
2628
|
+
if (/^[0-9.]+$/.test(s)) continue;
|
|
2629
|
+
if (!out.includes(s)) out.push(s);
|
|
2630
|
+
}
|
|
2631
|
+
return out;
|
|
2632
|
+
}
|
|
2633
|
+
|
|
2634
|
+
function coocShareHan(a, b) {
|
|
2635
|
+
if (!/[\u4e00-\u9fff]/.test(a) || !/[\u4e00-\u9fff]/.test(b)) return false;
|
|
2636
|
+
for (const ch of a) if (b.includes(ch)) return true;
|
|
2637
|
+
return false;
|
|
2638
|
+
}
|
|
2639
|
+
|
|
2640
|
+
function buildCoocSyn(docs, n) {
|
|
2641
|
+
const pairs = new Map();
|
|
2642
|
+
// 两级证据分别记账:同条层(强)与项目层(弱)各一张表,最后按「强在前、弱补位」合流。
|
|
2643
|
+
// 混在一张表里按比例排序的话,项目层的词会把同条层的桥词挤出前六——实测宽池换说法因此从
|
|
2644
|
+
// 14/14 掉回 13/14(救回来的那一题正是被项目层顶掉的)。
|
|
2645
|
+
const projPairs = new Map();
|
|
2646
|
+
const bumpIn = (map, a, b, w) => {
|
|
2647
|
+
const cur = map.get(a);
|
|
2648
|
+
if (cur === void 0) map.set(a, /* @__PURE__ */ new Map([[b, w]]));
|
|
2649
|
+
else cur.set(b, (cur.get(b) ?? 0) + w);
|
|
2650
|
+
};
|
|
2651
|
+
const pairUp = (list, w) => {
|
|
2652
|
+
for (let i = 0; i < list.length; i++) {
|
|
2653
|
+
for (let j = i + 1; j < list.length; j++) {
|
|
2654
|
+
const a = list[i];
|
|
2655
|
+
const b = list[j];
|
|
2656
|
+
if (a === b) continue;
|
|
2657
|
+
const ww = coocShareHan(a, b) ? Math.min(w, COOC_SHARE_HAN_W) : w;
|
|
2658
|
+
bumpIn(pairs, a, b, ww);
|
|
2659
|
+
bumpIn(pairs, b, a, ww);
|
|
2660
|
+
}
|
|
2661
|
+
}
|
|
2662
|
+
};
|
|
2663
|
+
const kwDf = new Map();
|
|
2664
|
+
for (const d of docs) {
|
|
2665
|
+
const words = coocWordsOf(d);
|
|
2666
|
+
if (words.length === 0) continue;
|
|
2667
|
+
for (const w of words) kwDf.set(w, (kwDf.get(w) ?? 0) + 1);
|
|
2668
|
+
pairUp(words, COOC_W_SAME);
|
|
2669
|
+
}
|
|
2670
|
+
const byProject = new Map();
|
|
2671
|
+
for (const d of docs) {
|
|
2672
|
+
const words = coocWordsOf(d);
|
|
2673
|
+
if (words.length === 0) continue;
|
|
2674
|
+
const p = String(d.project ?? "全局");
|
|
2675
|
+
if (!byProject.has(p)) byProject.set(p, []);
|
|
2676
|
+
byProject.get(p).push(words);
|
|
2677
|
+
}
|
|
2678
|
+
for (const [, list] of byProject) {
|
|
2679
|
+
if (list.length < 2) continue;
|
|
2680
|
+
const union = new Set();
|
|
2681
|
+
for (const ws of list) for (const w of ws) union.add(w);
|
|
2682
|
+
const unionArr = [...union];
|
|
2683
|
+
for (const ws of list) {
|
|
2684
|
+
const self = new Set(ws);
|
|
2685
|
+
const others = unionArr.filter((w) => !self.has(w));
|
|
2686
|
+
if (others.length === 0) continue;
|
|
2687
|
+
for (const a of ws) {
|
|
2688
|
+
for (const b of others) {
|
|
2689
|
+
const ww = coocShareHan(a, b) ? Math.min(COOC_W_PROJ, COOC_SHARE_HAN_W) : COOC_W_PROJ;
|
|
2690
|
+
bumpIn(projPairs, a, b, ww);
|
|
2691
|
+
bumpIn(projPairs, b, a, ww);
|
|
2692
|
+
}
|
|
2693
|
+
}
|
|
2694
|
+
}
|
|
2695
|
+
}
|
|
2696
|
+
// 一张表的门与排序:次数、条件概率、比例降序。
|
|
2697
|
+
const pickFrom = (map, a, dfa) => {
|
|
2698
|
+
const others = map && map.get(a);
|
|
2699
|
+
if (!others || dfa <= 0) return [];
|
|
2700
|
+
const keep = [];
|
|
2701
|
+
for (const [b, c] of others) {
|
|
2702
|
+
if (c < COOC_MIN_COUNT) continue;
|
|
2703
|
+
const ratio = c / dfa;
|
|
2704
|
+
if (ratio < COOC_MIN_RATIO) continue;
|
|
2705
|
+
keep.push([b, ratio]);
|
|
2706
|
+
}
|
|
2707
|
+
keep.sort((x, y) => y[1] - x[1]);
|
|
2708
|
+
return keep.map(([b]) => b);
|
|
2709
|
+
};
|
|
2710
|
+
const out = new Map();
|
|
2711
|
+
const terms = /* @__PURE__ */ new Set([...pairs.keys(), ...projPairs.keys()]);
|
|
2712
|
+
for (const a of terms) {
|
|
2713
|
+
const dfa = kwDf.get(a) ?? 0;
|
|
2714
|
+
if (dfa <= 0) continue;
|
|
2715
|
+
const strong = pickFrom(pairs, a, dfa);
|
|
2716
|
+
const weak = pickFrom(projPairs, a, dfa);
|
|
2717
|
+
if (strong.length === 0 && weak.length === 0) continue;
|
|
2718
|
+
const seen = new Set();
|
|
2719
|
+
const list = [];
|
|
2720
|
+
for (const w of strong.concat(weak)) {
|
|
2721
|
+
if (seen.has(w)) continue;
|
|
2722
|
+
seen.add(w);
|
|
2723
|
+
list.push(w);
|
|
2724
|
+
}
|
|
2725
|
+
out.set(a, list.slice(0, COOC_TOP_PER_TERM));
|
|
2726
|
+
}
|
|
2727
|
+
return out.size > 0 ? out : null;
|
|
2728
|
+
}
|
|
2729
|
+
|
|
2524
2730
|
function buildSearchIndex(docs, opts = {}, sig = null) {
|
|
2525
2731
|
const n = docs.length;
|
|
2526
2732
|
const useField = opts.fieldBoost !== false;
|
|
@@ -2576,11 +2782,14 @@ function buildSearchIndex(docs, opts = {}, sig = null) {
|
|
|
2576
2782
|
}
|
|
2577
2783
|
const titleSets = useField ? docs.map((d) => new Set(tokenize(String(d.title ?? '')))) : null;
|
|
2578
2784
|
const kwSets = useField ? docs.map((d) => new Set((Array.isArray(d.keywords) ? d.keywords : []).flatMap((w) => tokenize(String(w ?? ''))))) : null;
|
|
2785
|
+
// [macro-fusion 0.4.0 · P5] 共现表跟索引一起建(库一变就重算,不需要额外失效逻辑)。
|
|
2786
|
+
// coocLearn:false 一键回到「只有手工表」的旧口径,用来做开/关对照。
|
|
2787
|
+
const coocSyn = opts.coocLearn === false ? null : buildCoocSyn(docs, n);
|
|
2579
2788
|
return {
|
|
2580
2789
|
__n: n,
|
|
2581
2790
|
__sig: sig ?? indexSignature(docs),
|
|
2582
|
-
__opts: `${useField ? 1 : 0}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${kwTfW}`,
|
|
2583
|
-
plainToks, docToks, avgdl, bodyLen, avgBody, df, tf, kwToks, kwTfW, titleSets, kwSets, postings, useField
|
|
2791
|
+
__opts: `${useField ? 1 : 0}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${kwTfW}${opts.coocLearn === false ? 0 : 1}`,
|
|
2792
|
+
plainToks, docToks, avgdl, bodyLen, avgBody, df, tf, kwToks, kwTfW, titleSets, kwSets, postings, useField, coocSyn
|
|
2584
2793
|
};
|
|
2585
2794
|
}
|
|
2586
2795
|
|
|
@@ -2592,7 +2801,7 @@ const SEARCH_INDEX_CACHE_MAX = 4;
|
|
|
2592
2801
|
const searchIndexCache = new Map();
|
|
2593
2802
|
|
|
2594
2803
|
function indexPathKey(docs, opts) {
|
|
2595
|
-
return `${indexSignature(docs)}|${opts.fieldBoost === false ? 0 : 1}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${Number.isFinite(opts.kwTfW) && opts.kwTfW >= 0 ? opts.kwTfW : KW_TF_W}${opts.inverted === false ? 0 : 1}`;
|
|
2804
|
+
return `${indexSignature(docs)}|${opts.fieldBoost === false ? 0 : 1}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${Number.isFinite(opts.kwTfW) && opts.kwTfW >= 0 ? opts.kwTfW : KW_TF_W}${opts.inverted === false ? 0 : 1}${opts.coocLearn === false ? 0 : 1}`;
|
|
2596
2805
|
}
|
|
2597
2806
|
|
|
2598
2807
|
// 调用方也可以直接传 opts.index(自己缓存那张表);签名或口径对不上就自己重建——
|
|
@@ -2601,7 +2810,7 @@ function searchIndexOf(docs, opts) {
|
|
|
2601
2810
|
const key = indexPathKey(docs, opts);
|
|
2602
2811
|
const given = opts.index;
|
|
2603
2812
|
if (given && given.__n === docs.length && given.__sig === indexSignature(docs) &&
|
|
2604
|
-
given.__opts === `${opts.fieldBoost === false ? 0 : 1}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${Number.isFinite(opts.kwTfW) && opts.kwTfW >= 0 ? opts.kwTfW : KW_TF_W}`) {
|
|
2813
|
+
given.__opts === `${opts.fieldBoost === false ? 0 : 1}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${Number.isFinite(opts.kwTfW) && opts.kwTfW >= 0 ? opts.kwTfW : KW_TF_W}${opts.coocLearn === false ? 0 : 1}`) {
|
|
2605
2814
|
return given;
|
|
2606
2815
|
}
|
|
2607
2816
|
if (opts.cache === false) return buildSearchIndex(docs, opts, key);
|
|
@@ -2650,7 +2859,7 @@ function search(query, docs, opts = {}) {
|
|
|
2650
2859
|
if (q.length === 0 && idents.length === 0) return [];
|
|
2651
2860
|
// [macro-fusion 0.2.153] 切词与建表挪进索引:这部分跟「问什么」无关,只跟「库里有什么」有关。
|
|
2652
2861
|
const index = searchIndexOf(docs, opts);
|
|
2653
|
-
const { docToks, avgdl, bodyLen, avgBody, df, tf, kwToks, kwTfW, titleSets, kwSets, postings } = index;
|
|
2862
|
+
const { docToks, avgdl, bodyLen, avgBody, df, tf, kwToks, kwTfW, titleSets, kwSets, postings, coocSyn } = index;
|
|
2654
2863
|
const FIELD_TITLE_W = 0.6;
|
|
2655
2864
|
const FIELD_KW_W = Number.isFinite(opts.fieldKwW) ? opts.fieldKwW : FIELD_KW_W_DEF;
|
|
2656
2865
|
const COORD_W = Number.isFinite(opts.coordW) ? opts.coordW : COORD_W_DEF;
|
|
@@ -2678,7 +2887,10 @@ function search(query, docs, opts = {}) {
|
|
|
2678
2887
|
}
|
|
2679
2888
|
const qIdfSum = opts.coord === false ? 0 : qKept.reduce((s2, t) => s2 + idfOf(t), 0) || 1;
|
|
2680
2889
|
// 同义扩词只扩问句:表里没有的词、库里 df=0 的词都不进(扩了也没人能命中,白算一遍)。
|
|
2681
|
-
|
|
2890
|
+
// [macro-fusion 0.4.0 · P5] 第四参是索引随库自建出来的共现表——手工表管「人确定过的说法」,
|
|
2891
|
+
// 共现表管「库里自己长出来的说法」。opts.coocLearn === false 时 index.coocSyn 为 null,
|
|
2892
|
+
// 这里就干净地退回只有手工表的老行为。
|
|
2893
|
+
const synOf = opts.synBridge === false ? null : synExpandOf(qKept, df, n, coocSyn);
|
|
2682
2894
|
const synW = Number.isFinite(opts.synW) && opts.synW >= 0 ? opts.synW : SYN_W;
|
|
2683
2895
|
// [macro-fusion 0.2.153] 打分只碰「问句里那几个词真的出现过」的条目。
|
|
2684
2896
|
const coverLenRelief = Number.isFinite(opts.coverLenRelief) ? Math.min(1, Math.max(0, opts.coverLenRelief)) : COVER_LEN_RELIEF;
|
|
@@ -4066,6 +4278,11 @@ function searchTool(dir) {
|
|
|
4066
4278
|
type: "boolean",
|
|
4067
4279
|
default: true,
|
|
4068
4280
|
description: "\u9ed8\u8ba4\u53ea\u7ed9\u548c\u699c\u9996\u540c\u4e00\u91cf\u7ea7\u7684\u547d\u4e2d\uff08\u5206\u6570\u4e0d\u5230\u699c\u9996 85% \u7684\u6574\u6279\u6536\u53e3\uff09\uff1b\u4f20 false = \u8fde\u4f4e\u5206\u5019\u9009\u4e00\u5e76\u5c55\u5f00\u3002"
|
|
4281
|
+
},
|
|
4282
|
+
internal: {
|
|
4283
|
+
type: "boolean",
|
|
4284
|
+
default: false,
|
|
4285
|
+
description: "只给插件内部诊断用(例如写完一条记忆后检查是否该巩固):这次查询不进本会话的「已端给你看过」账,也不计召回次数。模型不该传它。"
|
|
4069
4286
|
}
|
|
4070
4287
|
}
|
|
4071
4288
|
},
|
|
@@ -4330,8 +4547,14 @@ function searchTool(dir) {
|
|
|
4330
4547
|
fresh.push(h);
|
|
4331
4548
|
}
|
|
4332
4549
|
const hits = [...blind, ...fresh];
|
|
4333
|
-
|
|
4334
|
-
|
|
4550
|
+
// [macro-fusion 0.4.0] internal=true:插件自己的诊断查询不算「这一轮端给用户看过」。
|
|
4551
|
+
// 不关的话,写完一条紧接着问 memory_search({mode:"similar", id}),候选会被这批记成已看过而排空,
|
|
4552
|
+
// 回执变成「可比的候选一条都没有」;同时 bumpHit 会抬 hit_count,让「召回过但没人读」这类通胀指标失真。
|
|
4553
|
+
// 默认 false = 对外查询照旧记账;只有 flow.tryCall 直连 bridge 才传得进来(macro 侧检索工具的参数是白名单)。
|
|
4554
|
+
if (parsed.internal !== true) {
|
|
4555
|
+
for (const h of hits) db.bumpHit(h.level, h.id);
|
|
4556
|
+
markSearched(workspace, sessionId ?? "unknown", hits.map((h) => h.id), dir);
|
|
4557
|
+
}
|
|
4335
4558
|
const reordered = [...hits].sort((a, b) => (b.score - a.score) || ((b.updated_at ?? 0) - (a.updated_at ?? 0)));
|
|
4336
4559
|
// [macro-fusion 0.2.123] context=N:给每条命中带上同层相邻的 N 条(默认 0,一个字节都不多花)
|
|
4337
4560
|
const ctxSpan = Math.min(3, Math.max(0, Math.trunc(Number(parsed.context ?? 0)) || 0));
|
|
@@ -4663,6 +4886,9 @@ function readTool(dir) {
|
|
|
4663
4886
|
}
|
|
4664
4887
|
const { row } = found;
|
|
4665
4888
|
markAccessed(workspace, sessionIdOf(exec) ?? "unknown", [row.id], dir);
|
|
4889
|
+
// [macro-fusion 0.4.0] 读到正文才记一次 read:这是 unused 体检(hit_count>0 却从没读过)
|
|
4890
|
+
// 唯一的记账点,所以只放在这里——检索、注入、面板都不许冒充「读」。
|
|
4891
|
+
db.bumpRead(row.level, row.id);
|
|
4666
4892
|
return {
|
|
4667
4893
|
found: true,
|
|
4668
4894
|
id: row.id,
|
|
@@ -9540,7 +9766,16 @@ export {
|
|
|
9540
9766
|
QUESTION_FRAME,
|
|
9541
9767
|
SYN_GROUPS,
|
|
9542
9768
|
SYN_W,
|
|
9769
|
+
SYN_MAX_DF_RATIO,
|
|
9770
|
+
SYN_MAX_PER_TERM,
|
|
9543
9771
|
synExpandOf,
|
|
9772
|
+
COOC_W_SAME,
|
|
9773
|
+
COOC_W_PROJ,
|
|
9774
|
+
COOC_SHARE_HAN_W,
|
|
9775
|
+
COOC_MIN_COUNT,
|
|
9776
|
+
COOC_MIN_RATIO,
|
|
9777
|
+
COOC_TOP_PER_TERM,
|
|
9778
|
+
buildCoocSyn,
|
|
9544
9779
|
identsOf,
|
|
9545
9780
|
timeAnchorOf,
|
|
9546
9781
|
TIME_ANCHOR_RE,
|