dsh-macro-memory 0.3.0 → 0.4.1
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 +82 -17
- 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
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import { LEVELS, PROJECT_SUBCATEGORIES, TEXT_OUT, pick } from '../shared.js'
|
|
2
2
|
import { LINKS_SCHEMA } from '../linkflow.js'
|
|
3
3
|
import { cardTitle } from '../panel.js'
|
|
4
|
+
import { supersedeMode, supersedeAdvice, supersedeSuggestNote, supersedeApplyLead } from '../supersede.js'
|
|
4
5
|
|
|
5
6
|
// [macro-fusion 0.2.117] 取代关系:写新的同时,把被它顶掉的旧的标成 stale 并在正文留一句
|
|
6
7
|
// 「(已被取代:<新 id>「<新内容开头>」,<日期>)」。
|
|
@@ -68,7 +69,163 @@ function ambiguousCountOf(v, ids) {
|
|
|
68
69
|
* 每一种失败都必须单独说一句——尤其「没找到」和「没动它」:这两件事在回执里长得像是成功,
|
|
69
70
|
* 而它们恰恰是「旧条目还活着、还占着召回位」的那种状态。
|
|
70
71
|
*/
|
|
71
|
-
|
|
72
|
+
// ── 写入端巩固(0.4.0 P2 / PLAN-0.4 §5 P2)────────────────────────────────────────────
|
|
73
|
+
//
|
|
74
|
+
// 为什么不是「同 project 同一天写到第 4 条就触发」:那是数数,不是信号。一天里写四条互不相干的
|
|
75
|
+
// 事也会触发,而同一件事连写三条(最该巩固的那种)反而不触发。按 CLS 的「巩固触发」改写为
|
|
76
|
+
// 三条件同时成立——
|
|
77
|
+
// ① 重复模式:同 project 内、keywords 交集 ≥ 2 的条目在近 7 天里 ≥ 3 条(同一模式反复暴露);
|
|
78
|
+
// ② 慢路有空位:该 project 近 7 天语义层(rules / fact)少于 cap 条才准新增;满了应该**并进
|
|
79
|
+
// 已有的那条**(memory_update append),而不是再造一条同义摘要;
|
|
80
|
+
// ③ 未巩固:这批条目正文里还没有巩固句(CONSOLIDATE_MARK),防同一批反复触发。
|
|
81
|
+
//
|
|
82
|
+
// 三档:off(一个字都不变)/ suggest(只贴材料,库里一个字没动)/ write(才自动落那条摘要)。
|
|
83
|
+
// 配置写坏一律当 off——退到最保守那一档。
|
|
84
|
+
const CONSOLIDATE_MAX = 3
|
|
85
|
+
const CONSOLIDATE_DAYS = 7
|
|
86
|
+
const CONSOLIDATE_MIN_REPEAT = 3
|
|
87
|
+
const CONSOLIDATE_MIN_SHARE = 2
|
|
88
|
+
const CONSOLIDATE_SEMANTIC_CAP = 8
|
|
89
|
+
const CONSOLIDATE_MARK = '(已巩固进:'
|
|
90
|
+
const CONSOLIDATE_HEAD = 40
|
|
91
|
+
const CONSOLIDATE_ROWS = 20
|
|
92
|
+
const CONSOLIDATE_CHARS = 300
|
|
93
|
+
const CONSOLIDATE_LEVELS = ['rules', 'fact']
|
|
94
|
+
|
|
95
|
+
export function consolidateMode(config = {}) {
|
|
96
|
+
const raw = config?.consolidate
|
|
97
|
+
// 没配就是默认那一档(suggest)——与 index.js 的 MACRO_DEFAULTS 对齐,免得「默认 suggest」只在
|
|
98
|
+
// schema 层成立、函数层回 off,两处说法打架。唯独显式写错才退到 off。
|
|
99
|
+
if (raw === undefined || raw === null) return 'suggest'
|
|
100
|
+
const mode = typeof raw === 'string' ? raw.trim().toLowerCase() : ''
|
|
101
|
+
return mode === 'suggest' || mode === 'write' || mode === 'off' ? mode : 'off'
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
function kwOf(list) {
|
|
105
|
+
const out = new Set()
|
|
106
|
+
for (const one of Array.isArray(list) ? list : []) {
|
|
107
|
+
const word = String(one).trim().toLowerCase()
|
|
108
|
+
if (word !== '') out.add(word)
|
|
109
|
+
}
|
|
110
|
+
return out
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
function headOf(text, n = CONSOLIDATE_HEAD) {
|
|
114
|
+
return String(text ?? '').replace(/\s+/g, ' ').trim().slice(0, n)
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
/**
|
|
118
|
+
* 纯函数:把检索回执里的 hits 变成巩固信号。不起 IO、不读时钟,判据可以逐条钉。
|
|
119
|
+
* `cap = 0` 表示不限(永远有空位)。
|
|
120
|
+
*/
|
|
121
|
+
export function consolidateSignals({ hits = [], semanticHits = [], newId = '', keywords = [], cap = CONSOLIDATE_SEMANTIC_CAP } = {}) {
|
|
122
|
+
const mine = kwOf(keywords)
|
|
123
|
+
const rows = []
|
|
124
|
+
for (const hit of Array.isArray(hits) ? hits : []) {
|
|
125
|
+
const id = String(hit?.id ?? '')
|
|
126
|
+
if (id === '' || id === String(newId ?? '')) continue
|
|
127
|
+
const shared = [...kwOf(hit?.keywords)].filter((word) => mine.has(word))
|
|
128
|
+
if (shared.length < CONSOLIDATE_MIN_SHARE) continue
|
|
129
|
+
const body = String(hit?.content ?? '')
|
|
130
|
+
rows.push({
|
|
131
|
+
id,
|
|
132
|
+
id8: shortId(id),
|
|
133
|
+
level: String(hit?.level ?? ''),
|
|
134
|
+
day: String(hit?.created_at ?? hit?.createdAt ?? '').slice(0, 10),
|
|
135
|
+
head: headOf(body),
|
|
136
|
+
body,
|
|
137
|
+
consolidated: body.includes(CONSOLIDATE_MARK),
|
|
138
|
+
shared,
|
|
139
|
+
})
|
|
140
|
+
}
|
|
141
|
+
const semanticCount = Array.isArray(semanticHits) ? semanticHits.length : 0
|
|
142
|
+
const repeated = rows.length >= CONSOLIDATE_MIN_REPEAT
|
|
143
|
+
const room = Number(cap) === 0 || semanticCount < Number(cap)
|
|
144
|
+
const pending = rows.some((one) => !one.consolidated)
|
|
145
|
+
const kind = repeated && pending ? (room ? 'fire' : 'merge') : 'none'
|
|
146
|
+
return { rows, repeated, room, pending, semanticCount, cap: Number(cap), kind, fire: kind === 'fire' }
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
/** write 态落什么:规则版摘要。事件日期必须在正文开头——temporal 的收益全来自这里。 */
|
|
150
|
+
export function consolidateSummary({ rows = [], project = '', keywords = [], at = new Date() } = {}) {
|
|
151
|
+
const words = [...kwOf(keywords)].slice(0, 6).join('、')
|
|
152
|
+
const body = rows.slice(0, CONSOLIDATE_MAX).map((one) => `- ${one.head}`).join('\n')
|
|
153
|
+
const head = `${dayStamp(at)} · 巩固(${String(project || '全局').trim() || '全局'})${words ? `:${words}` : ''}`
|
|
154
|
+
return `${head}\n${body}`.slice(0, CONSOLIDATE_CHARS)
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
/** 巩固句:改动最小的一句话,只写「并进哪条、什么时候」,不写判决(与取代句同款形状)。 */
|
|
158
|
+
export function consolidateLineOf({ newId, newHead, at }) {
|
|
159
|
+
const head = headOf(newHead, SUPERSEDE_HEAD)
|
|
160
|
+
return `${CONSOLIDATE_MARK}${shortId(newId)}${head ? `「${head}」` : ''},${dayStamp(at)})`
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
/** suggest 那一段材料:只有「该做什么」和现成的调用形状,不含任何已落库的声明。 */
|
|
164
|
+
function consolidateNote({ signal, project, keywords }) {
|
|
165
|
+
if (!signal || signal.kind === 'none') return ''
|
|
166
|
+
const rows = signal.rows.slice(0, CONSOLIDATE_MAX)
|
|
167
|
+
const list = rows.map((one) => `${one.id8}(${one.level || '—'},${one.day || '日期未知'})「${one.head}」`).join('\n ')
|
|
168
|
+
if (signal.kind === 'merge') {
|
|
169
|
+
return [
|
|
170
|
+
`— 该并条,不是再加一条 —`,
|
|
171
|
+
`同 project 近 ${CONSOLIDATE_DAYS} 天里已经有 ${signal.semanticCount} 条语义层(rules/fact),到上限 ${signal.cap} 了。再写一条同义摘要只会让这一层更稀。`,
|
|
172
|
+
`这批:\n ${list}`,
|
|
173
|
+
`做法:memory_search 找到承载这件事的那条语义条目,用 memory_update append 把这次的增量补进去(不新增条目)。`,
|
|
174
|
+
].join('\n')
|
|
175
|
+
}
|
|
176
|
+
const ids = rows.map((one) => `'${one.id8}'`).join(', ')
|
|
177
|
+
const words = [...kwOf(keywords)].slice(0, 6).join('、')
|
|
178
|
+
return [
|
|
179
|
+
`— 同一件事已经写了 ${signal.rows.length} 条,该巩固了 —`,
|
|
180
|
+
`这批:\n ${list}`,
|
|
181
|
+
`如果它们讲的是同一件事:写一条 topic(事件日期放正文开头),再用 supersedes 指向上面这几条(旧条不删,只加一句「已巩固进」)。`,
|
|
182
|
+
` memory_remember(content: '${dayStamp(new Date())} · 谁 / 何时 / 为什么 / 结论', level: 'topic', project: '${String(project || '全局').trim() || '全局'}', keywords: [${words ? `'${words}'` : ''}], importance: 2, supersedes: [${ids}])`,
|
|
183
|
+
`(这段只是提示:库里这一个字都没动。要自动落,配置项 consolidate 设成 write。)`,
|
|
184
|
+
].join('\n')
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
async function consolidateAfterWrite({ flow, exec, mode, newId, project, keywords }) {
|
|
188
|
+
const words = [...kwOf(keywords)].join(' ')
|
|
189
|
+
if (words === '') return ''
|
|
190
|
+
// internal: true —— 这两枪是我自己为了判「该不该巩固」打的,不是端给用户看的结果。
|
|
191
|
+
// 不关记账的话,写完一条紧接着问 memory_search({mode:'similar', id}) 会得到「候选一条都没有」
|
|
192
|
+
// (同话题的这批刚被记进 seen),而且 bumpHit 会把 hit_count 抬起来污染通胀体检。
|
|
193
|
+
const base = { query: words, project, k: CONSOLIDATE_ROWS, days: CONSOLIDATE_DAYS, status: 'active', content_max: 0, internal: true }
|
|
194
|
+
const got = await flow.tryCall('memory_search', base, exec, '巩固检查:同话题条目')
|
|
195
|
+
if (!got.value) return ''
|
|
196
|
+
const hits = Array.isArray(got.value.hits) ? got.value.hits : []
|
|
197
|
+
// 语义层条数:检索没有 importance 过滤,所以这里数的是 rules/fact 全部(偏严=更容易判「有空位」,
|
|
198
|
+
// 但绝不会把一个塞满的层看成空的)。
|
|
199
|
+
const sem = await flow.tryCall('memory_search', { ...base, level: CONSOLIDATE_LEVELS.join(','), k: CONSOLIDATE_ROWS }, exec, '巩固检查:语义层')
|
|
200
|
+
const signal = consolidateSignals({ hits, semanticHits: Array.isArray(sem.value?.hits) ? sem.value.hits : [], newId, keywords })
|
|
201
|
+
const note = consolidateNote({ signal, project, keywords })
|
|
202
|
+
if (note === '') return ''
|
|
203
|
+
if (mode !== 'write' || signal.kind !== 'fire') return note
|
|
204
|
+
// merge 态即使配了 write 也只回提示:语义层满了该并进已有那条,但「哪条承载这件事」不是规则能判的,
|
|
205
|
+
// 自动挑一条并进去比不并更糟(会把两件事焊在一起)。
|
|
206
|
+
// write:真落一条 topic,再给被合并的条目加一句巩固句(status 不动——巩固不是作废)。
|
|
207
|
+
const summary = consolidateSummary({ rows: signal.rows, project, keywords })
|
|
208
|
+
const wrote = await flow.tryCall('memory_remember', { content: summary, level: 'topic', project, keywords: [...kwOf(keywords)].slice(0, 8), importance: 2 }, exec, '落巩固摘要')
|
|
209
|
+
const newOne = String(wrote.value?.id ?? '')
|
|
210
|
+
if (newOne === '') return `${note}\n\n(这条提示没能自动落库:上游没回新条目 id。按上面的调用形状手动写一次即可。)`
|
|
211
|
+
const lines = [`已自动落一条巩固摘要 ${shortId(newOne)}:${summary.split('\n')[0]}`]
|
|
212
|
+
for (const one of signal.rows.slice(0, CONSOLIDATE_MAX)) {
|
|
213
|
+
if (one.consolidated) {
|
|
214
|
+
lines.push(`- ${one.id8} 正文里已经有一句「已巩固进」,没重复追加`)
|
|
215
|
+
continue
|
|
216
|
+
}
|
|
217
|
+
const next = `${one.body}${one.body.endsWith('\n') || one.body.length === 0 ? '' : ' '}${consolidateLineOf({ newId: newOne, newHead: summary, at: new Date() })}`
|
|
218
|
+
const patched = await flow.tryCall('memory_update', { id: one.id, content: next }, exec, '加巩固句')
|
|
219
|
+
lines.push(
|
|
220
|
+
patched.value?.ok === true
|
|
221
|
+
? `- ${one.id8} 正文末尾加了一句「已巩固进」`
|
|
222
|
+
: `- ${one.id8} 没写进库(它还是原样,别当成已经并进去了)`,
|
|
223
|
+
)
|
|
224
|
+
}
|
|
225
|
+
return `${note}\n\n${lines.join('\n')}`
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
async function markSuperseded({ flow, exec, ids, extra, newId, newHead, lead = '' }) {
|
|
72
229
|
const lines = []
|
|
73
230
|
for (const asked of ids) {
|
|
74
231
|
// 「这条是不是就是刚写的那条」不能靠字符串前缀先判——同一秒写下的两条 id 前 8 位一模一样,
|
|
@@ -133,10 +290,11 @@ async function markSuperseded({ flow, exec, ids, extra, newId, newHead }) {
|
|
|
133
290
|
tail.push(`超出 ${SUPERSEDE_MAX} 条上限的 ${extra.length} 条这次没有处理:${extra.join('、')}——要一起处置就分两次调。`)
|
|
134
291
|
}
|
|
135
292
|
tail.push('反悔办法:旧条目都还在库里,memory_update 把 status 改回 active、再删掉那句取代话就恢复原样。')
|
|
136
|
-
|
|
293
|
+
const out = [...(lead ? [lead] : []), ...head, ...lines, ...tail]
|
|
294
|
+
return out.join('\n')
|
|
137
295
|
}
|
|
138
296
|
|
|
139
|
-
export function createRemember({ flow }) {
|
|
297
|
+
export function createRemember({ flow, config = {} }) {
|
|
140
298
|
return {
|
|
141
299
|
name: 'memory_remember',
|
|
142
300
|
description:
|
|
@@ -202,8 +360,48 @@ export function createRemember({ flow }) {
|
|
|
202
360
|
)
|
|
203
361
|
}
|
|
204
362
|
}
|
|
363
|
+
// [macro-fusion 0.4.0] P3:人没点名要取代时,替人看一眼「库里有没有同一件事的旧说法」。
|
|
364
|
+
// 默认 suggest 只把建议端出来(一个字不动库);apply 才真走 markSuperseded——两条路复用同一个处置
|
|
365
|
+
// 通道,免得「自动取代」和「人点名的取代」出现两套行为。off 连那一枪检索都不打。
|
|
366
|
+
const autoMode = supersedeMode(config)
|
|
367
|
+
if (autoMode !== 'off' && newId) {
|
|
368
|
+
const cands = await supersedeAdvice({
|
|
369
|
+
flow,
|
|
370
|
+
exec,
|
|
371
|
+
content: typeof args.content === 'string' ? args.content : '',
|
|
372
|
+
project: args.project,
|
|
373
|
+
level: args.level,
|
|
374
|
+
keywords: args.keywords,
|
|
375
|
+
newId,
|
|
376
|
+
// 人已经点名要取代的那几条不再重复建议:他刚刚已经处置过了。
|
|
377
|
+
skipIds: [...sup.ids, ...sup.extra],
|
|
378
|
+
})
|
|
379
|
+
if (cands.length > 0) {
|
|
380
|
+
if (autoMode === 'apply') {
|
|
381
|
+
out.push(
|
|
382
|
+
await markSuperseded({
|
|
383
|
+
flow,
|
|
384
|
+
exec,
|
|
385
|
+
ids: cands.map((one) => one.id),
|
|
386
|
+
extra: [],
|
|
387
|
+
newId,
|
|
388
|
+
newHead: typeof args.content === 'string' ? args.content : '',
|
|
389
|
+
lead: supersedeApplyLead(cands),
|
|
390
|
+
}),
|
|
391
|
+
)
|
|
392
|
+
} else {
|
|
393
|
+
out.push(supersedeSuggestNote(cands))
|
|
394
|
+
}
|
|
395
|
+
}
|
|
396
|
+
}
|
|
205
397
|
const linked = await flow.applyLinks(newId, args.links, exec, 'remember')
|
|
206
398
|
if (linked) out.push(linked)
|
|
399
|
+
// 巩固放在最后:此时新条已落库、id 已拿到,而且取代已经做完——巩固材料里不该再出现刚被顶掉的那条。
|
|
400
|
+
const mode = consolidateMode(config)
|
|
401
|
+
if (mode !== 'off' && newId) {
|
|
402
|
+
const note = await consolidateAfterWrite({ flow, exec, mode, newId, project: args.project, keywords: args.keywords })
|
|
403
|
+
if (note) out.push(note)
|
|
404
|
+
}
|
|
207
405
|
return out.join('\n\n')
|
|
208
406
|
},
|
|
209
407
|
presentCall(args) {
|
package/lib/macro/defs/search.js
CHANGED
|
@@ -367,7 +367,7 @@ function costTail(body, { budget, flags }) {
|
|
|
367
367
|
return parts.length > 0 ? `${body}\n\n${parts.join(' ')}` : body
|
|
368
368
|
}
|
|
369
369
|
|
|
370
|
-
async function runSearch(flow, args, exec, flags = {}, budget = { value: null, note: '' }) {
|
|
370
|
+
async function runSearch(flow, args, exec, flags = {}, budget = { value: null, note: '' }, mqConfig = {}) {
|
|
371
371
|
const mode = modeOf(args).name
|
|
372
372
|
const query = typeof args.query === 'string' ? args.query : ''
|
|
373
373
|
|
|
@@ -377,7 +377,7 @@ async function runSearch(flow, args, exec, flags = {}, budget = { value: null, n
|
|
|
377
377
|
const tool = mode === 'graph' ? 'nebula_recall' : 'nebula_bridge'
|
|
378
378
|
const payload =
|
|
379
379
|
mode === 'graph'
|
|
380
|
-
? pick(args, ['query', 'memory_ids', 'limit', 'hops'])
|
|
380
|
+
? pick(args, ['query', 'memory_ids', 'limit', 'hops', 'entity', 'dynamic_hops'])
|
|
381
381
|
: pick(args, ['query', 'memory_ids', 'limit', 'chars', 'min_weight', 'hops'])
|
|
382
382
|
const r = await flow.tryCall(tool, payload, exec, mode === 'graph' ? '星图检索' : '星图补充')
|
|
383
383
|
if (r.entry) {
|
|
@@ -478,6 +478,11 @@ async function runSearch(flow, args, exec, flags = {}, budget = { value: null, n
|
|
|
478
478
|
main = fit.main
|
|
479
479
|
flags.budgetNote = fit.note
|
|
480
480
|
}
|
|
481
|
+
// [macro-memory 0.4.0 P1] 查询分解:排在预算收紧之后、扩散之前——
|
|
482
|
+
// 收紧那一步会拿 localArgs 重查一次(补充段会被重查冲掉),而扩散要用合并后的 value.hits。
|
|
483
|
+
if (multiQueryMode(mqConfig) !== 'off') {
|
|
484
|
+
main = await augmentByDecompose({ flow, exec, main, localArgs, query, flags, budget })
|
|
485
|
+
}
|
|
481
486
|
const hits = Array.isArray(main.value?.hits) ? main.value.hits.length : 0
|
|
482
487
|
// [macro-fusion 0.2.133] 主人 2026-11-21 明令:默认关闭的有用能力要全开,不要急着省 token。
|
|
483
488
|
// 以前要 expand=true 或本地零命中才扩散——可星图那一路提供的是「跨会话、跨项目才看得见」的线索,
|
|
@@ -594,7 +599,210 @@ async function fusedPart({ localValue, graphText, spreadLimit, budget, flags })
|
|
|
594
599
|
return text
|
|
595
600
|
}
|
|
596
601
|
|
|
597
|
-
|
|
602
|
+
/**
|
|
603
|
+
* [macro-memory 0.4.0 P1] 查询分解:一句话里塞了两件事时,本地检索按整句算一次 BM25,
|
|
604
|
+
* 两边的词互相稀释,可能双双掉出榜——multi-hop 是四类题里最低的一类(0.5887,2026-11-20)。
|
|
605
|
+
*
|
|
606
|
+
* 这一层只做「补空位」,和「重排」一点关系都没有:
|
|
607
|
+
* · 原榜的条目、名次、正文一个字不动;
|
|
608
|
+
* · 并列焦点拆成子问句各查一次,只把原榜没给出的条目追加在末尾一段;
|
|
609
|
+
* · 每条都标明是哪一问捞到的,读者自己判断要不要读全文;
|
|
610
|
+
* · 一条都没补到就什么都不追加(连标题都不出现)——误切的代价只是多一次本地检索。
|
|
611
|
+
*
|
|
612
|
+
* 纯规则、不调模型:切错也是可复现、可复算的切错。
|
|
613
|
+
*/
|
|
614
|
+
const MQ_MAX_SUBS = 3
|
|
615
|
+
const MQ_MAX_ROWS_PER_SUB = 2
|
|
616
|
+
const MQ_ROW_CHARS = 110
|
|
617
|
+
const MQ_MAX_CONSENSUS = 3
|
|
618
|
+
/** 连接词:长的在前,否则「以及」会先被「与/和」切成半截。 */
|
|
619
|
+
const MQ_JOINERS = ['以及', '还有', '和', '跟', '与', '、']
|
|
620
|
+
/** 标点/空白一律不算信息量:`A 和 B` 能不能切,取决于两侧有没有真字符,而不是汉字数。 */
|
|
621
|
+
const MQ_PUNCT = /[\s,,。??!!、;;::“”"'‘’()()《》〈〉【】\[\]…—--]/g
|
|
622
|
+
/** 子问句开头的疑问词:剥掉之后剩下的才是真正的焦点(剥完不足两个字就整段丢弃)。 */
|
|
623
|
+
const MQ_ASK_PREFIX = /^(?:为什么|为何|怎么|怎样|如何|什么|啥|是不是|有没有|能不能|可不可以|哪些|哪个|多少|是否|请问|我想问|那么|那|然后|所以|另外|顺便)/
|
|
624
|
+
/** 子问句结尾的虚词与套话:`B 有什么区别` → `B`,`A 呢` → `A`。 */
|
|
625
|
+
const MQ_ASK_SUFFIX = /(?:有什么区别|有区别吗|之间的区别|之间|分别是什么|是什么|分别|呢|吗|吧|啊|呀|了|的)$/
|
|
626
|
+
|
|
627
|
+
/** [macro-memory 0.4.0 P1] 开关只认 off / conservative;写别的(含大小写错的)一律 off。 */
|
|
628
|
+
export function multiQueryMode(config) {
|
|
629
|
+
const raw = config?.multiQuery
|
|
630
|
+
const text = typeof raw === 'string' ? raw.trim().toLowerCase() : ''
|
|
631
|
+
return text === 'conservative' ? 'conservative' : 'off'
|
|
632
|
+
}
|
|
633
|
+
|
|
634
|
+
/** 信息量 = 去掉标点空白后的字符数(汉字、字母、数字都算)。 */
|
|
635
|
+
function infoLen(text) {
|
|
636
|
+
return String(text ?? '').replace(MQ_PUNCT, '').length
|
|
637
|
+
}
|
|
638
|
+
|
|
639
|
+
/** 只取第一个「两侧都够长」的连接词切一刀。顿号是硬并列,单字也认(`A、B`)。 */
|
|
640
|
+
function cutOnce(text, joiner) {
|
|
641
|
+
const min = joiner === '、' ? 1 : 2
|
|
642
|
+
let at = text.indexOf(joiner)
|
|
643
|
+
while (at > 0) {
|
|
644
|
+
const left = text.slice(0, at).trim()
|
|
645
|
+
const right = text.slice(at + joiner.length).trim()
|
|
646
|
+
if (infoLen(left) >= min && infoLen(right) >= min) return [left, right]
|
|
647
|
+
at = text.indexOf(joiner, at + joiner.length)
|
|
648
|
+
}
|
|
649
|
+
return null
|
|
650
|
+
}
|
|
651
|
+
|
|
652
|
+
/** 贪心多刀:每个连接词过一遍,切够段数就停(`A、B 和 C` → 三段),最后截到上限。 */
|
|
653
|
+
function splitByJoiners(text) {
|
|
654
|
+
let parts = [text]
|
|
655
|
+
for (const joiner of MQ_JOINERS) {
|
|
656
|
+
const next = []
|
|
657
|
+
for (const part of parts) {
|
|
658
|
+
const cut = cutOnce(part, joiner)
|
|
659
|
+
if (cut !== null) next.push(...cut)
|
|
660
|
+
else next.push(part)
|
|
661
|
+
}
|
|
662
|
+
parts = next
|
|
663
|
+
if (parts.length >= MQ_MAX_SUBS) break
|
|
664
|
+
}
|
|
665
|
+
return parts.slice(0, MQ_MAX_SUBS)
|
|
666
|
+
}
|
|
667
|
+
|
|
668
|
+
function cleanPiece(piece) {
|
|
669
|
+
let text = String(piece ?? '')
|
|
670
|
+
.replace(/^[\s,,。??!!、;;::“”"'()()]+|[\s,,。??!!、;;::“”"'()()]+$/g, '')
|
|
671
|
+
.trim()
|
|
672
|
+
text = text.replace(MQ_ASK_PREFIX, '').trim()
|
|
673
|
+
text = text.replace(MQ_ASK_SUFFIX, '').trim()
|
|
674
|
+
// 比较句的尾巴:`反式脂肪哪个更伤心脏` → `反式脂肪`(实体是重点,比较的是问句的壳)。
|
|
675
|
+
text = text.replace(/(?:哪个|哪一个|谁)(?:更|最)[\u4e00-\u9fff]{0,6}$/, '').trim()
|
|
676
|
+
return infoLen(text) >= 2 ? text : null
|
|
677
|
+
}
|
|
678
|
+
|
|
679
|
+
/**
|
|
680
|
+
* 拆出子问句。返回 [] 表示「这句话没有并列焦点」——不猜、不硬拆。
|
|
681
|
+
*
|
|
682
|
+
* 两种切法,按可靠程度排:
|
|
683
|
+
* 1) 多个问号:`A?B?` 天然就是两问,不需要任何句法判断;
|
|
684
|
+
* 2) 连接词:`以及 / 还有 / 和 / 跟 / 与 / 、`,两侧都要有 ≥2 个真字符,
|
|
685
|
+
* 最多切到 3 段(再多就是在猜句子结构了)。
|
|
686
|
+
*/
|
|
687
|
+
export function decomposeQuery(query) {
|
|
688
|
+
const text = String(query ?? '').trim()
|
|
689
|
+
if (infoLen(text) < 4) return []
|
|
690
|
+
const byAsk = text
|
|
691
|
+
.split(/[??]+/)
|
|
692
|
+
.map((one) => cleanPiece(one))
|
|
693
|
+
.filter((one) => one !== null)
|
|
694
|
+
if (byAsk.length >= 2 && byAsk.length <= MQ_MAX_SUBS) {
|
|
695
|
+
return byAsk.filter((one) => one !== text).slice(0, MQ_MAX_SUBS)
|
|
696
|
+
}
|
|
697
|
+
const subs = splitByJoiners(text)
|
|
698
|
+
.map((one) => cleanPiece(one))
|
|
699
|
+
.filter((one) => one !== null && one !== text)
|
|
700
|
+
return subs.length >= 2 ? subs.slice(0, MQ_MAX_SUBS) : []
|
|
701
|
+
}
|
|
702
|
+
|
|
703
|
+
function id8(id) {
|
|
704
|
+
const text = String(id ?? '')
|
|
705
|
+
return text.length > 8 ? text.slice(0, 8) : text
|
|
706
|
+
}
|
|
707
|
+
|
|
708
|
+
function clipBody(text) {
|
|
709
|
+
const one = String(text ?? '').replace(/\s+/g, ' ').trim()
|
|
710
|
+
return one.length > MQ_ROW_CHARS ? `${one.slice(0, MQ_ROW_CHARS)}…` : one
|
|
711
|
+
}
|
|
712
|
+
|
|
713
|
+
/** 补充段的正文:先说「原榜没动」,再逐条标明哪一问捞到的,最后是两问共识。 */
|
|
714
|
+
function supplementText(rows, subs, consensus = []) {
|
|
715
|
+
const head =
|
|
716
|
+
`— 问句拆开再查一遍(原榜一个字没动)—\n` +
|
|
717
|
+
`这句话有多个焦点,拆成「${subs.join('」「')}」各查了一次(子问句放宽了档位收口,才捞得到原榜压掉的条目);下面这些原榜没给出:`
|
|
718
|
+
const lines = rows.map((one) => {
|
|
719
|
+
const hit = one.hit ?? {}
|
|
720
|
+
const level = hit.level ?? 'memory'
|
|
721
|
+
const body = String(hit.title ?? '').trim() !== '' ? hit.title : clipBody(hit.content)
|
|
722
|
+
return `- 「${one.sub}」[${level}] ${id8(hit.id)} · ${clipBody(body)}`
|
|
723
|
+
})
|
|
724
|
+
const tail = []
|
|
725
|
+
if (consensus.length > 0) {
|
|
726
|
+
tail.push(`- 多个子问句都命中、原榜里也有的:${consensus.map(id8).join(', ')}(上面已列,这是它们真的相关的硬证据)`)
|
|
727
|
+
}
|
|
728
|
+
tail.push('(只截前一句;读全文用 memory_read(id)。)')
|
|
729
|
+
return [head, ...lines, ...tail].join('\n')
|
|
730
|
+
}
|
|
731
|
+
|
|
732
|
+
/**
|
|
733
|
+
* 拿原榜没给出的条目补在末尾。失败一律当「没补」(不把异常拼进一份本来成功的回执)。
|
|
734
|
+
* 返回新的 main;没补到东西时返回原 main(引用不变,调用方据此判断)。
|
|
735
|
+
*/
|
|
736
|
+
async function augmentByDecompose({ flow, exec, main, localArgs, query, flags, budget }) {
|
|
737
|
+
const subs = decomposeQuery(query)
|
|
738
|
+
if (subs.length === 0) return main
|
|
739
|
+
const baseHits = Array.isArray(main.value?.hits) ? main.value.hits : []
|
|
740
|
+
const order = baseHits.map((hit) => String(hit?.id ?? '')).filter((one) => one !== '')
|
|
741
|
+
const seen = new Set(order)
|
|
742
|
+
const consensus = new Set()
|
|
743
|
+
const rows = []
|
|
744
|
+
for (const sub of subs) {
|
|
745
|
+
let got = null
|
|
746
|
+
try {
|
|
747
|
+
got = await flow.call(
|
|
748
|
+
'memory_search',
|
|
749
|
+
// [macro-memory 0.4.0 P1] 子问句**放宽档位收口**:原榜的 min_rel / band_keep 会把
|
|
750
|
+
// 「分数低一档但其实对」的条目整段收掉,而子问句只需要「这一问里它在不在前排」。
|
|
751
|
+
// 放宽的代价由下面「每问最多两行 + score>0」两道闸门兜住。
|
|
752
|
+
{ ...localArgs, query: sub, k: MQ_MAX_ROWS_PER_SUB + 2, content_max: MQ_ROW_CHARS, min_rel: 0, band_keep: false },
|
|
753
|
+
exec,
|
|
754
|
+
)
|
|
755
|
+
} catch {
|
|
756
|
+
continue
|
|
757
|
+
}
|
|
758
|
+
const hits = Array.isArray(got?.value?.hits) ? got.value.hits : []
|
|
759
|
+
let added = 0
|
|
760
|
+
for (const hit of hits) {
|
|
761
|
+
const id = String(hit?.id ?? '')
|
|
762
|
+
if (id === '') continue
|
|
763
|
+
const score = Number(hit?.score)
|
|
764
|
+
if (Number.isFinite(score) && score <= 0) continue
|
|
765
|
+
if (seen.has(id)) {
|
|
766
|
+
// 子问句命中了原榜里已有的条目:不是新东西,但这是「它真的相关」的硬证据(和融合层 fused.both 同一套道理)。
|
|
767
|
+
consensus.add(id)
|
|
768
|
+
continue
|
|
769
|
+
}
|
|
770
|
+
seen.add(id)
|
|
771
|
+
rows.push({ sub, hit })
|
|
772
|
+
added += 1
|
|
773
|
+
if (added >= MQ_MAX_ROWS_PER_SUB) break
|
|
774
|
+
}
|
|
775
|
+
}
|
|
776
|
+
const agree = order.filter((id) => consensus.has(id)).slice(0, MQ_MAX_CONSENSUS)
|
|
777
|
+
if (rows.length === 0 && agree.length === 0) return main
|
|
778
|
+
|
|
779
|
+
let shown = rows
|
|
780
|
+
let text = supplementText(shown, subs, agree)
|
|
781
|
+
if (budget.value !== null) {
|
|
782
|
+
const base = estTokens(main.text)
|
|
783
|
+
while (shown.length > 1 && base + estTokens(text) > budget.value) {
|
|
784
|
+
shown = shown.slice(0, shown.length - 1)
|
|
785
|
+
text = supplementText(shown, subs, agree)
|
|
786
|
+
}
|
|
787
|
+
if (base + estTokens(text) > budget.value) {
|
|
788
|
+
flags.multiQuerySkipped = true
|
|
789
|
+
return main
|
|
790
|
+
}
|
|
791
|
+
}
|
|
792
|
+
flags.multiQuery = subs.join(' | ')
|
|
793
|
+
flags.multiQueryRows = shown.length
|
|
794
|
+
flags.multiQueryAgree = agree.length
|
|
795
|
+
return {
|
|
796
|
+
...main,
|
|
797
|
+
text: `${main.text}\n\n${text}`,
|
|
798
|
+
value:
|
|
799
|
+
main.value !== null && typeof main.value === 'object'
|
|
800
|
+
? { ...main.value, hits: [...baseHits, ...shown.map((one) => one.hit)] }
|
|
801
|
+
: main.value,
|
|
802
|
+
}
|
|
803
|
+
}
|
|
804
|
+
|
|
805
|
+
export function createSearch({ flow, config = {} }) {
|
|
598
806
|
return {
|
|
599
807
|
name: 'memory_search',
|
|
600
808
|
description:
|
|
@@ -630,6 +838,8 @@ export function createSearch({ flow }) {
|
|
|
630
838
|
explain: { type: 'boolean', description: '附带分项得分,排查「为什么召回它」。' },
|
|
631
839
|
limit: { type: 'integer', description: 'graph/bridge 模式返回条数(默认 10 / 4)。' },
|
|
632
840
|
hops: { type: 'integer', description: 'graph/bridge 扩散跳数。' },
|
|
841
|
+
entity: { type: 'boolean', description: 'graph 是否按实体带邻居(默认开)。' },
|
|
842
|
+
dynamic_hops: { type: 'boolean', description: 'graph 第二跳是否按词面收(默认开)。' },
|
|
633
843
|
chars: { type: 'integer', description: 'bridge 模式文本预算(字符)。' },
|
|
634
844
|
min_weight: { type: 'number', description: 'bridge 模式最低关联权重。' },
|
|
635
845
|
},
|
|
@@ -645,7 +855,7 @@ export function createSearch({ flow }) {
|
|
|
645
855
|
const flags = {}
|
|
646
856
|
// [macro-fusion 0.2.109] 预算在出口解析一次、传到底:四处 return 各自解析会写出四种口径。
|
|
647
857
|
const budget = budgetOf(args.budget)
|
|
648
|
-
const text = await runSearch(flow, args, exec, flags, budget)
|
|
858
|
+
const text = await runSearch(flow, args, exec, flags, budget, config)
|
|
649
859
|
const notes = modeNotes(mode.name, args, flags)
|
|
650
860
|
const body = notes.length > 0 ? `${text}\n\n${notes.join('\n')}` : text
|
|
651
861
|
return costTail(body, { budget, flags })
|