dsh-memu-memory 1.1.3 → 1.2.1

package/tests/media.test.mjs

@@ -0,0 +1,132 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { Readable, Writable } from 'node:stream'
+import sharp from 'sharp'
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-media-'))
+process.env.DSH_MEMU_HOME = home
+const state = await import('../lib/state.js')
+const media = await import('../lib/media.js')
+const memory = await import('../lib/memory.js')
+const inject = await import('../lib/inject.js')
+const rpc = await import('../lib/rpc.js')
+const { registerTools } = await import('../lib/tools.js')
+test.after(() => { state.flushState(); fs.rmSync(home, { recursive: true, force: true }) })
+const bytes = await sharp({ create: { width: 800, height: 600, channels: 3, background: '#339966' } }).png().toBuffer()
+const sha = crypto.createHash('sha256').update(bytes).digest('hex')
+const ref = { attachmentId: sha, mediaType: 'image/png', bytes: bytes.length, width: 800, height: 600, name: 'birthday.png' }
+const binding = state.ensureSession('images', { cwd: path.join(home, 'rp'), agentPreset: 'rp' })
+const libraryId = binding.libraryId
+const session = { header: { id: 'images', cwd: path.join(home, 'rp') } }
+const exec = { agent: { session } }
+const ctx = { get: name => name === 'attachments' ? { readImage: async () => ({ ref, data: bytes }) } : undefined }
+const event = (seq, text = '') => ({ type: 'user/message', seq, data: { source: { kind: 'user' }, content: [...(text ? [{ type: 'text', text }] : []), { type: 'image', attachment: ref }] } })
+
+test('three image events store one verified blob and hint at a habit, not an automatic memory', async () => {
+  for (let i = 0; i < 3; i++) await media.captureMediaEvent(ctx, session, event(i, '这是上次生日留下的照片。'))
+  const pool = JSON.parse(fs.readFileSync(path.join(home, 'index', `${libraryId}.media.json`)))
+  assert.equal(pool.totals.count, 1)
+  assert.equal(pool.blobs[sha].useCount, 3)
+  assert.equal(fs.readdirSync(path.join(home, 'attachments', libraryId)).length, 1)
+  assert.equal(state.getSessionBinding('images').stickerHint.sha256, sha)
+  assert.equal(Object.keys(state.loadPrivateIndex(libraryId).entries).length, 0)
+  await media.captureMediaEvent(ctx, session, event(2))
+  assert.equal(media.attachmentRefs(libraryId, [{ sha256: sha }])[0].useCount, 3, 'event replay is idempotent')
+})
+
+test('image-only turns retrieve a saved image and expose the image count in status', async () => {
+  const saved = await memory.privateRemember({ exec, title: '生日照片', content: '上次生日的一张照片。', attachments: [{ sha256: sha }], layer: 'long_term' })
+  const message = { role: 'user', ...event(4).data }
+  const decision = await inject.injectForStep({ agent: exec.agent, decision: { kind: 'enter', messages: [message] }, turn: 2, step: 1 })
+  assert.ok(decision.messages.length > 1)
+  assert.ok(decision.messages[0].content[0].text.includes(saved.id))
+  assert.equal(state.getSessionBinding('images').recentQueries.at(-1).imageCount, 1)
+  const tools = []
+  registerTools({ tools: { register: tool => { tools.push(tool); return () => {} } } })
+  assert.match(await tools.find(tool => tool.name === 'memu_status').execute({}, exec), /image_turn: 1/)
+})
+
+test('ordinary images are short-lived drafts, important ones retain separate accuracy and habits aggregate', async () => {
+  const draft = await memory.privateRemember({ exec, title: '普通图', content: '今天收到的图。', attachments: [{ sha256: sha }] })
+  assert.equal(draft.entry.layer, 'short_term')
+  assert.ok(Math.abs(Date.parse(draft.entry.expiresAt) - Date.now() - 72 * 3_600_000) < 5000)
+  const important = await memory.privateRemember({ exec, title: '重要瞬间', content: '这是生日纪念。', attachments: [{ sha256: sha }], layer: 'long_term', salientDate: '10-28', arousal: .95, confidence: .9 })
+  assert.ok(important.entry.accuracy < important.entry.confidence)
+  const habit = await memory.privateRemember({ exec, title: '表达习惯', content: '他无语时习惯发这张图。', attachments: [{ sha256: sha }], track: 'habit' })
+  assert.equal(habit.entry.track, 'habit')
+  assert.equal(habit.entry.layer, 'long_term')
+  const aggregate = await memory.privateRemember({ exec, title: '表达习惯', content: '他无语时经常发这张图，不必逐次复述。', attachments: [{ sha256: sha }], track: 'habit' })
+  assert.equal(aggregate.id, habit.id, 'an agent write aggregates the same image habit instead of appending another')
+})
+
+test('thumbnail authorization rejects secrets, session mismatches and disabled scopes; captions respect never_say', async () => {
+  const privateSession = state.ensureSession('private-image', { cwd: path.join(home, 'private') })
+  await media.captureMediaEvent(ctx, { header: { id: 'private-image' } }, event(0, 'hidden caption'))
+  const secret = await memory.privateRemember({ exec: { agent: { session: { header: { id: 'private-image' } } } }, content: 'secret body', title: 'secret', visibility: 'secret', attachments: [{ sha256: sha }], layer: 'long_term' })
+  assert.throws(() => media.getAttachment({ libraryId: privateSession.libraryId, sha256: sha, sessionId: 'private-image' }), error => error.status === 403)
+  await memory.privateUpdate({ libraryId: privateSession.libraryId, id: secret.id, visibility: 'shared', disclosure: 'never_say' })
+  assert.equal(media.getAttachment({ libraryId: privateSession.libraryId, sha256: sha, sessionId: 'private-image' }).caption, null)
+  assert.throws(() => media.getAttachment({ libraryId, sha256: sha, sessionId: 'unknown' }), error => error.status === 403)
+  state.setSessionBinding('private-image', { useLibrary: false })
+  assert.throws(() => media.getAttachment({ libraryId: privateSession.libraryId, sha256: sha, sessionId: 'private-image' }), error => error.status === 403)
+  const thumb = await media.attachmentThumbnail({ libraryId, sha256: sha, sessionId: 'images' })
+  const metadata = await sharp(thumb.data).metadata()
+  assert.equal(metadata.width, 512)
+  assert.equal(metadata.height, 384)
+})
+
+test('the size guard never reads an oversized image and still allows a missing-image memory', async () => {
+  const refTooLarge = { ...ref, attachmentId: 'f'.repeat(64), bytes: 9 * 1024 * 1024 }
+  let reads = 0
+  const out = await media.captureMediaEvent({ get: () => ({ readImage: async () => { reads++; throw new Error('must not read') } }) }, session,
+    { ...event(10), data: { source: { kind: 'user' }, content: [{ type: 'image', attachment: refTooLarge }] } })
+  assert.equal(reads, 0)
+  assert.equal(out[0].missing, true)
+  const saved = await memory.privateRemember({ exec, content: '图太大但记得收到过。', title: '大图', attachments: [{ sha256: refTooLarge.attachmentId }] })
+  assert.equal(saved.entry.attachments[0].missing, true)
+})
+
+test('an attachment archive round-trips bytes and missing files do not break memory recall', async () => {
+  const exported = await rpc.dispatch({}, 'exportLibrary', { libraryId, includeAttachments: true })
+  const other = state.createLibrary({ name: 'imported', cwd: path.join(home, 'imported') })
+  const result = await rpc.dispatch({}, 'importMemories', { libraryId: other.id, archiveBase64: exported.base64 })
+  assert.ok(result.imported > 0)
+  assert.ok(fs.existsSync(path.join(home, 'attachments', other.id, `${sha}.png`)))
+  fs.unlinkSync(path.join(home, 'attachments', libraryId, `${sha}.png`))
+  assert.equal(media.getAttachment({ libraryId, sha256: sha, sessionId: 'images' }).missing, true)
+  assert.ok((await memory.privateRecall({ exec, query: '生日', relevanceThreshold: 0 })).files.length)
+})
+
+test('GC keeps referenced images and deletes only unused month-old bytes', () => {
+  const file = path.join(home, 'index', `${libraryId}.media.json`)
+  const pool = JSON.parse(fs.readFileSync(file))
+  const orphan = 'e'.repeat(64)
+  fs.writeFileSync(path.join(home, 'attachments', libraryId, `${orphan}.png`), bytes)
+  pool.blobs[orphan] = { ...pool.blobs[sha], refs: [], lastUsedAt: '2026-01-01T00:00:00Z', sha256: orphan }
+  fs.writeFileSync(file, JSON.stringify(pool))
+  media.reconcileMedia(libraryId, state.loadPrivateIndex(libraryId), { now: Date.parse('2026-10-28T00:00:00Z') })
+  assert.ok(!fs.existsSync(path.join(home, 'attachments', libraryId, `${orphan}.png`)))
+  assert.ok(Object.keys(state.loadPrivateIndex(libraryId).entries).length > 0)
+})
+
+test('streaming archives round-trip without base64 and reject zip-slip paths', async () => {
+  const { zipSync } = await import('fflate')
+  const source = state.createLibrary({ name: 'stream-source', cwd: path.join(home, 'stream-source') })
+  state.ensureSession('stream-session', { cwd: path.join(home, 'stream-source') })
+  await media.captureMediaEvent(ctx, { header: { id: 'stream-session' } }, event(0, 'verified source image'))
+  await memory.privateRemember({ exec: { agent: { session: { header: { id: 'stream-session' } } } }, title: 'stream', content: 'streamed image evidence', attachments: [{ sha256: sha }], layer: 'long_term' })
+  const payload = await rpc.dispatch({}, 'exportLibrary', { libraryId: source.id })
+  const chunks = []
+  const output = new Writable({ write(chunk, _encoding, done) { chunks.push(Buffer.from(chunk)); done() } })
+  output.writeHead = () => {}
+  await media.streamMediaExport(source.id, payload, output)
+  const dest = state.createLibrary({ name: 'stream-dest', cwd: path.join(home, 'stream-dest') })
+  const archive = await media.importMediaStream(dest.id, Readable.from([Buffer.concat(chunks)]))
+  assert.equal(archive.memories.length, 1)
+  assert.ok(fs.existsSync(path.join(home, 'attachments', dest.id, `${sha}.png`)))
+  const malicious = zipSync({ '../outside.json': Buffer.from('{}') })
+  await assert.rejects(media.importMediaStream(dest.id, Readable.from([malicious])), /unsupported/)
+})

package/tests/migration-payload.test.mjs

@@ -0,0 +1,42 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+const { migrationCommitPayload } = await import('../lib/local-vector-service.js')
+
+// 现场事故（2026-10-29）：重建时每条记忆都报 VECTOR_READBACK_FAILED，影子库只有 61KB
+// 空 schema。原因不是 embedding，而是迁移器把 `{ name, description, ...entry }` 裸对象
+// 当成 commit 载荷 —— MemU 只认 `{ recall_files, resource, user }`，于是"提交成功"却一行
+// 没写。这组用例钉住信封形状。
+
+test('the migration commit uses the recall_files envelope MemU expects', () => {
+  const payload = migrationCommitPayload({
+    id: 'mem-abc',
+    text: '标题 正文',
+    entry: { title: '标题', content: '正文' },
+  })
+  assert.deepEqual(payload, {
+    recall_files: [{ name: 'mem-abc', track: 'memory', description: '标题', content: '正文' }],
+    resource: [],
+    user: {},
+  })
+})
+
+test('a snapshot without an entry falls back to the snapshot text', () => {
+  const payload = migrationCommitPayload({ id: 'mem-1', text: 'fallback text' })
+  assert.equal(payload.recall_files[0].name, 'mem-1')
+  assert.equal(payload.recall_files[0].description, 'fallback text')
+  assert.equal(payload.recall_files[0].content, 'fallback text')
+})
+
+test('the payload is never the bare object that silently commits nothing', () => {
+  const payload = migrationCommitPayload({ id: 'mem-2', entry: {} })
+  assert.ok(Array.isArray(payload.recall_files), 'MemU needs a recall_files array')
+  assert.equal(payload.name, undefined, 'a top-level name is the old broken shape')
+  assert.equal(payload.recall_files[0].content, '')
+})
+
+test('long titles are clamped to the description budget', () => {
+  const payload = migrationCommitPayload({ id: 'mem-3', entry: { title: 'x'.repeat(400), content: 'body' } })
+  assert.equal(payload.recall_files[0].description.length, 180)
+  assert.equal(payload.recall_files[0].content, 'body')
+})

package/tests/mood.test.mjs

@@ -0,0 +1,109 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-mood-'))
+process.env.DSH_MEMU_HOME = home
+
+const state = await import('../lib/state.js')
+const mood = await import('../lib/mood.js')
+const { normalizeSalientDate } = await import('../lib/memory.js')
+const inject = await import('../lib/inject.js')
+
+test.after(() => {
+  try { fs.rmSync(home, { recursive: true, force: true }) } catch {}
+})
+
+test('readMood signs the present state without reading meaning', () => {
+  assert.ok(mood.readMood('今天太开心了，测试全部通过').valence > 0)
+  assert.ok(mood.readMood('我很难受，一点都跑不起来').valence < 0)
+  assert.equal(mood.readMood('把 index.js 里的 import 改成相对路径').valence, 0)
+})
+
+test('mood congruence pulls same-signed memories up and pushes opposites down', () => {
+  assert.ok(mood.moodCongruence(-0.8, -0.6) > 0)
+  assert.ok(mood.moodCongruence(0.8, -0.6) < 0)
+  assert.equal(mood.moodCongruence(0.8, 0), 0)
+})
+
+test('mood fades to neutral instead of holding all day', () => {
+  const now = Date.now()
+  const fresh = mood.moodDecay({ valence: -0.8, arousal: 0.9, at: now }, now)
+  const later = mood.moodDecay({ valence: -0.8, arousal: 0.9, at: now }, now + 6 * 60 * 60 * 1000)
+  assert.ok(Math.abs(later.valence) < Math.abs(fresh.valence))
+  assert.ok(later.arousal < fresh.arousal && later.arousal >= 0.35)
+  assert.equal(mood.moodDecay(null, now).valence, 0)
+})
+
+test('salient dates keep the year when one is given and refuse anything unparseable', () => {
+  assert.equal(normalizeSalientDate('3-05'), '03-05')
+  // A full date keeps its year: it is one day, not an anniversary that recurs.
+  assert.equal(normalizeSalientDate('2026-03-05T00:00:00.000Z'), '2026-03-05')
+  assert.equal(normalizeSalientDate('下次再说'), null)
+  assert.equal(normalizeSalientDate('13-40'), null)
+  assert.equal(normalizeSalientDate(null), null)
+})
+
+test('an anniversary fires once per day and not again', () => {
+  const binding = state.ensureSession('mood-anniv', { cwd: path.join(home, 'p-anniv'), agentPreset: 'rp' })
+  const now = new Date()
+  const md = `${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`
+  const index = state.loadPrivateIndex(binding.libraryId)
+  index.entries['mem-anniv'] = {
+    track: 'memory', layer: 'long_term', title: '第一次一起看海', content: '那天下着小雨。',
+    status: 'active', salientDate: md, createdAt: now.toISOString(), updatedAt: now.toISOString(),
+  }
+  state.savePrivateIndex(binding.libraryId, index)
+
+  const first = inject.buildAnniversary('mood-anniv', binding, now)
+  assert.match(first.text, /memory-anniversary/)
+  assert.match(first.text, /第一次一起看海/)
+  assert.deepEqual(first.ids, ['mem-anniv'])
+
+  state.markAnniversaryShown('mood-anniv', 'mem-anniv', first.dayKey)
+  const second = inject.buildAnniversary('mood-anniv', binding, now)
+  assert.equal(second.text, '')
+})
+
+test('an anniversary on a different day stays silent', () => {
+  const binding = state.ensureSession('mood-anniv2', { cwd: path.join(home, 'p-anniv2'), agentPreset: 'rp' })
+  const index = state.loadPrivateIndex(binding.libraryId)
+  index.entries['mem-someday'] = {
+    track: 'memory', layer: 'long_term', title: '某个九月', content: '', status: 'active',
+    salientDate: '09-21', createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
+  }
+  state.savePrivateIndex(binding.libraryId, index)
+  const out = inject.buildAnniversary('mood-anniv2', binding, new Date('2026-03-05T12:00:00'))
+  assert.equal(out.text, '')
+})
+
+test('low-confidence memory is injected as a hedge, not a fact', () => {
+  const binding = state.ensureSession('mood-fuzzy', { cwd: path.join(home, 'p-fuzzy'), agentPreset: 'rp' })
+  const index = state.loadPrivateIndex(binding.libraryId)
+  index.entries['mem-fuzzy'] = {
+    track: 'memory', layer: 'long_term', title: '也许养过一只猫', content: '记不清了。',
+    status: 'active', confidence: 0.3, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
+  }
+  index.entries['mem-solid'] = {
+    track: 'memory', layer: 'must_remember', title: '对花生过敏', content: '确定。',
+    status: 'active', confidence: 0.95, pinReason: '安全相关', pinSource: 'user_explicit',
+    createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
+  }
+  state.savePrivateIndex(binding.libraryId, index)
+  const anchor = inject.buildAnchor(binding, { ...state.getSettings(), anchorTokens: 1200 })
+  const fuzzyLine = anchor.text.split('\n').find((l) => l.includes('mem-fuzzy'))
+  const solidLine = anchor.text.split('\n').find((l) => l.includes('mem-solid'))
+  assert.match(fuzzyLine, /记忆模糊/)
+  assert.doesNotMatch(solidLine, /记忆模糊/)
+})
+
+test('session mood is stored on the binding and read back', () => {
+  state.ensureSession('mood-store', { cwd: path.join(home, 'p-store'), agentPreset: 'rp' })
+  state.setSessionMood('mood-store', { valence: -0.6, arousal: 0.8 })
+  const stored = state.getSessionMood('mood-store')
+  assert.equal(stored.valence, -0.6)
+  assert.equal(stored.arousal, 0.8)
+  assert.ok(typeof stored.at === 'number')
+})

package/tests/multiprocess.test.mjs

@@ -0,0 +1,29 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-memu-memory-multi-'))
+process.env.DSH_MEMU_HOME = home
+const state = await import('../lib/state.js')
+test.after(() => { state.flushState(); fs.rmSync(home, { recursive: true, force: true }) })
+const library = state.createLibrary({ name: 'parallel', cwd: path.join(home, 'parallel') })
+const moduleUrl = new URL('../lib/state.js', import.meta.url).href
+function worker(prefix) {
+  return new Promise((resolve, reject) => {
+    const pathsUrl = new URL('../lib/paths.js', import.meta.url).href
+    const code = `const state = await import(${JSON.stringify(moduleUrl)}); const {retryStoreWrite}=await import(${JSON.stringify(pathsUrl)}); for(let i=0;i<15;i++){await retryStoreWrite(()=>state.updatePrivateIndex(${JSON.stringify(library.id)}, index=>{index.entries[${JSON.stringify(prefix)}+i]={content:'retained '+i}}));state.setSessionBinding(${JSON.stringify(prefix)}+i,{useGlobal:false});await retryStoreWrite(()=>state.flushState())}`
+    const child = spawn(process.execPath, ['--input-type=module', '-e', code], { env: { ...process.env, DSH_MEMU_HOME: home }, windowsHide: true })
+    let errors = ''
+    child.stderr.on('data', data => { errors += data })
+    child.on('error', reject)
+    child.on('close', code => code === 0 ? resolve() : reject(new Error(errors)))
+  })
+}
+test('independent processes keep every disjoint memory and session binding', async () => {
+  await Promise.all([worker('a'), worker('b'), worker('c')])
+  state.clearCaches()
+  assert.equal(Object.keys(state.loadPrivateIndex(library.id).entries).length, 45)
+  assert.equal(Object.keys(state.loadState().sessions).length, 45)
+})