@ilaomianyang/dsh-memory-graph 0.10.4 → 0.12.0

package/src/vault.js

@@ -260,7 +260,7 @@ export function createVault(cfg, redactor) {
       // The vault is plain text so the owner can version it themselves; keep the
       // OS junk and the per-machine distillation cursors out of that repo.
       if (!(await exists(P.gitignore))) {
-        await writeAtomic(P.gitignore, '*.tmp\n.DS_Store\nThumbs.db\n.distill-state.json\n')
+        await writeAtomic(P.gitignore, '*.tmp\n.DS_Store\nThumbs.db\n.distill-state.json\n.auto-state.json\n.update-state.json\n')
       }
     })()
     return ready
@@ -301,9 +301,19 @@ export function createVault(cfg, redactor) {
 
   /* ------------------------------------------------------------ episodes */
 
+  /**
+   * Append one episode to the day it happened.
+   *
+   * The date in the filename is the record's own `t`, not "now": a backfilled
+   * session from last month belongs in last month's file, or the vault listing
+   * would claim that three months of history happened today. A record without a
+   * parseable timestamp falls back to today.
+   */
   async function appendEpisode(record) {
     await ensure()
-    const file = path.join(P.episodes, `${today()}.jsonl`)
+    const stamp = typeof record?.t === 'string' ? record.t.slice(0, 10) : ''
+    const day = /^\d{4}-\d{2}-\d{2}$/.test(stamp) ? stamp : today()
+    const file = path.join(P.episodes, `${day}.jsonl`)
     const line = `${JSON.stringify(record)}\n`
     await withLock(`episode:${file}`, () => fsp.appendFile(file, line, 'utf8'))
     // Keep projects.json honest even before the first card is distilled.
@@ -402,7 +412,7 @@ export function createVault(cfg, redactor) {
     return {
       id: data.id,
       kind: data.kind ?? 'note',
-      title: data.title ?? '(untitled)',
+      title: data.title ?? '（无标题 untitled）',
       project: data.project ?? cfg.defaultProject,
       entities: Array.isArray(data.entities) ? data.entities : [],
       created: data.created ?? nowIso(),
@@ -503,15 +513,15 @@ export function createVault(cfg, redactor) {
         await touchProject(project)
         const why = duplicate.exact
           ? ''
-          : ` (near-duplicate ${duplicate.score.toFixed(2)} of "${String(input.title ?? '').trim()}")`
-        await audit('card', `re-confirmed ${existing.id} "${existing.title}"${why}`)
+          : ` （近似重复 near-duplicate ${duplicate.score.toFixed(2)}，对着 "${String(input.title ?? '').trim()}"）`
+        await audit('card', `再次确认 ${existing.id} "${existing.title}"${why}`)
         return { card: existing, deduped: true }
       }
 
       const card = {
         id: input.id ?? newCardId(),
         kind: CARD_KINDS.includes(input.kind) ? input.kind : 'note',
-        title: String(input.title ?? '').trim().slice(0, 160) || '(untitled)',
+        title: String(input.title ?? '').trim().slice(0, 160) || '（无标题 untitled）',
         project,
         entities: [...new Set((input.entities ?? []).map((e) => slugify(e)))].filter(Boolean),
         created: input.created ?? stamp,
@@ -538,10 +548,10 @@ export function createVault(cfg, redactor) {
         old.validTo = card.validFrom
         old.supersededBy = card.id
         await writeAtomic(cardPath(old), renderCard(old))
-        await audit('card', `${old.id} superseded by ${card.id}`)
+        await audit('card', `${old.id} 已被 ${card.id} 替换（superseded）`)
       }
 
-      await audit('card', `wrote ${card.id} [${card.kind}] "${card.title}" (${card.project})`)
+      await audit('card', `写入 ${card.id} [${card.kind}] "${card.title}" (${card.project})`)
       return { card, deduped: false }
     })
   }
@@ -552,10 +562,10 @@ export function createVault(cfg, redactor) {
       if (!card) return null
       card.status = 'retracted'
       card.validTo = card.validTo ?? today()
-      card.body = `${card.body}\n\n<!-- retracted: ${String(reason ?? 'no reason given').slice(0, 200)} -->`
+      card.body = `${card.body}\n\n<!-- 已撤回 retracted: ${String(reason ?? '没有给出原因 · no reason given').slice(0, 200)} -->`
       await writeAtomic(cardPath(card), renderCard(card))
       invalidate()
-      await audit('card', `retracted ${id}${reason ? ` (${reason})` : ''}`)
+      await audit('card', `已撤回 ${id}${reason ? ` (${reason})` : ''}`)
       return card
     })
   }
@@ -566,7 +576,7 @@ export function createVault(cfg, redactor) {
       if (!card) return false
       await fsp.rm(card.file, { force: true })
       invalidate()
-      await audit('card', `purged ${id}`)
+      await audit('card', `已彻底删除 ${id}（purged）`)
       return true
     })
   }

package/test/auto.mjs

@@ -125,6 +125,74 @@ await check('a threshold with no clock still fires at once: that rule is the pil
   assert.equal(calls.length, 1)
 })
 
+/* -------------------------------------------------------------- catch-up */
+
+const CATCH_UP = { ...AUTO, enabled: true, minEpisodes: 0, everyMinutes: 0, minGapMinutes: 30, catchUp: true, catchUpEveryMinutes: 10, maxBatchesPerDay: 3 }
+
+await check('catch-up is off unless asked for: a full batch is not a queue', () => {
+  const base = { auto: { ...AUTO, minEpisodes: 0, everyMinutes: 0 }, now: 5_000_000, lastAttemptAt: null, pending: 500, batchSize: 40 }
+  assert.equal(autoDecision(base).due, false)
+})
+
+await check('catch-up runs on its own cadence even though minGapMinutes is longer', async () => {
+  const { distiller, calls, clock } = makeDistiller({ auto: CATCH_UP, pending: 500 })
+  const first = await distiller.tick()
+  assert.equal(first.rule, 'catch-up', 'a backlog is due on the first tick')
+  assert.equal(first.batchesToday, 1)
+  assert.equal(calls.length, 1)
+  clock.at += 5 * MINUTE
+  const tooSoon = await distiller.tick()
+  assert.equal(tooSoon.due, false, 'ten minutes is the catch-up cadence, five is not enough')
+  assert.match(tooSoon.reason, /catch-up gap/u)
+  clock.at += 6 * MINUTE
+  const again = await distiller.tick()
+  assert.equal(again.rule, 'catch-up')
+  assert.equal(again.batchesToday, 2)
+  assert.equal(calls.length, 2)
+})
+
+await check('catch-up stops at the daily cap and starts again the next day', async () => {
+  const { distiller, calls, clock, vault } = makeDistiller({ auto: CATCH_UP, pending: 500 })
+  for (let i = 0; i < 3; i += 1) {
+    assert.equal((await distiller.tick()).rule, 'catch-up')
+    clock.at += 11 * MINUTE
+  }
+  const capped = await distiller.tick()
+  assert.equal(capped.due, false)
+  assert.match(capped.reason, /上限 3/u)
+  assert.equal(calls.length, 3, 'three batches are the whole day')
+  assert.equal(vault.written.batchesToday, 3)
+
+  clock.at += 24 * 60 * MINUTE
+  const tomorrow = await distiller.tick()
+  assert.equal(tomorrow.rule, 'catch-up')
+  assert.equal(tomorrow.batchesToday, 1, 'a new day resets the counter')
+})
+
+await check('a pile smaller than one batch is not catch-up work', async () => {
+  const { distiller, calls } = makeDistiller({ auto: CATCH_UP, pending: 12 })
+  const decision = await distiller.tick()
+  assert.equal(decision.due, false, 'twelve episodes wait for a schedule or a threshold')
+  assert.equal(calls.length, 0)
+})
+
+await check('the daily counter is read back from the vault, not assumed to be zero', async () => {
+  const clock = { at: new Date(2026, 10, 3, 9, 0, 0).getTime() }
+  const state = { batchDay: '2026-11-03', batchesToday: 3, lastAttemptAt: clock.at - 20 * MINUTE }
+  const { distiller, calls } = makeDistiller({ auto: CATCH_UP, pending: 500, state, clock })
+  const decision = await distiller.tick()
+  assert.equal(decision.due, false, 'a restart must not hand out a fresh daily allowance')
+  assert.match(decision.reason, /上限 3/u)
+  assert.equal(calls.length, 0)
+})
+
+await check('quiet hours outrank catch-up', async () => {
+  const at = new Date(2026, 10, 3, 2, 0, 0).getTime()
+  const decision = autoDecision({ auto: { ...CATCH_UP, quietHours: '23:00-08:00' }, now: at, lastAttemptAt: null, pending: 500, batchSize: 40 })
+  assert.equal(decision.due, false)
+  assert.equal(decision.reason, 'quiet hours')
+})
+
 await check('both rules can be on: whichever is satisfied first runs', () => {
   const auto = { ...AUTO, minEpisodes: 10, everyMinutes: 60 }
   const now = 100 * MINUTE

package/test/client.mjs

@@ -321,7 +321,7 @@ await check('the page renders every knob the served value makes visible', () =>
   try {
     const expected = visibleFields(SERVED)
     // The harness route hides the seven http-only knobs and the provider field.
-    assert.equal(expected.length, 27, `expected 27 visible fields, spec says ${expected.length}`)
+    assert.equal(expected.length, 34, `expected 34 visible fields, spec says ${expected.length}`)
     for (const field of expected) {
       const key = field.path.join('.')
       assert.ok(control(instance.tree, key), `${key} has no control on the page`)
@@ -335,18 +335,18 @@ await check('the page renders every knob the served value makes visible', () =>
   }
 })
 
-await check('the five sections are all there, each with a title', () => {
+await check('the six sections are all there, each with a title', () => {
   const instance = render(makeForm(clone(SERVED)))
   try {
     const titles = byClass(instance.tree, 'mg-card-t').map(text)
-    assert.equal(titles.length, 5)
+    assert.equal(titles.length, 6)
     for (const title of titles) assert.ok(title.length > 0)
   } finally {
     instance.unmount()
   }
 })
 
-await check('the automatic distiller has both triggers on the page, each with its own switch', async () => {
+await check('the automatic distiller has its three rules on the page, each with its own switch', async () => {
   const form = makeForm(clone(SERVED))
   const instance = render(form)
   try {
@@ -354,7 +354,17 @@ await check('the automatic distiller has both triggers on the page, each with it
     assert.ok(section, 'automatic distillation needs a section of its own, not a corner of another one')
     assert.deepEqual(
       section.fields.map((field) => field.path.join('.')),
-      ['auto.enabled', 'auto.minEpisodes', 'auto.everyMinutes', 'auto.minGapMinutes', 'auto.quietHours', 'auto.project'],
+      [
+        'auto.enabled',
+        'auto.minEpisodes',
+        'auto.everyMinutes',
+        'auto.minGapMinutes',
+        'auto.quietHours',
+        'auto.project',
+        'auto.catchUp',
+        'auto.catchUpEveryMinutes',
+        'auto.maxBatchesPerDay',
+      ],
     )
     // Both rules show as 0 — "this rule is off" — rather than as a blank.
     assert.equal(control(instance.tree, 'auto.minEpisodes').props.value, '0')

package/test/history.mjs

@@ -0,0 +1,249 @@
+/**
+ * History test: replay a session file the way the store actually laid it out,
+ * and check what reaches the vault.   node test/history.mjs
+ *
+ * The fixture `test/fixtures/session.v4.jsonl.zstd` is a real zstd frame holding
+ * real event shapes, so the decompression path is exercised rather than mocked.
+ * It was produced once with:
+ *
+ *   node -e "… zlib.zstdCompressSync(JSON.stringify(events).split…)"   (node >= 22.15)
+ *
+ * and holds three turns: one real, one that is only a runtime snapshot, and one
+ * with a `<system-reminder>` wrapped around the person's own words.
+ */
+import assert from 'node:assert/strict'
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { resolveConfig } from '../src/config.js'
+import { createRedactor } from '../src/privacy.js'
+import { createVault } from '../src/vault.js'
+import { isoAt } from '../src/turns.js'
+import { createReplay, importSession, listSessions, runBackfill } from '../src/history.js'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const fixture = path.join(here, 'fixtures', 'session.v4.jsonl.zstd')
+
+const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'memgraph-hist-'))
+const cfg = resolveConfig({ vaultDir: dir })
+const redactor = createRedactor(cfg.privacy)
+const vault = createVault(cfg, redactor)
+
+/** An empty store laid out exactly like ~/.dsh/sessions. */
+async function makeStore(name = 'store') {
+  const root = path.join(dir, name)
+  return root
+}
+
+async function plant(root, { group = '--G-TempProject-Test--', id = 'session-history-fixture', file = fixture, mtime } = {}) {
+  const target = path.join(root, group, id)
+  await fsp.mkdir(target, { recursive: true })
+  const copy = path.join(target, 'session.v4.jsonl.zstd')
+  await fsp.copyFile(file, copy)
+  if (mtime) await fsp.utimes(copy, mtime, mtime)
+  return copy
+}
+
+const results = []
+async function check(name, fn) {
+  try {
+    await fn()
+    results.push(`  ok   ${name}`)
+  } catch (error) {
+    results.push(`  FAIL ${name}: ${error.message}`)
+    process.exitCode = 1
+  }
+}
+
+/* ------------------------------------------------------------------ store */
+
+const store = await makeStore()
+await plant(store)
+await plant(store, { group: '--G-Article2--', id: 'session-older', mtime: new Date(Date.now() - 86_400_000) })
+
+await check('the store is walked two levels deep, newest directory first', async () => {
+  const found = await listSessions(store)
+  assert.equal(found.length, 2, `expected 2 sessions, got ${found.length}`)
+  assert.equal(found[0].dirName, 'session-history-fixture')
+  assert.equal(found[1].dirName, 'session-older')
+  assert.ok(found[0].size > 0)
+})
+
+await check('a missing directory reports nothing instead of throwing', async () => {
+  const found = await listSessions(path.join(dir, 'nope'))
+  assert.deepEqual(found, [])
+})
+
+/* ----------------------------------------------------------------- replay */
+
+await check('a real turn is replayed, a runtime snapshot is not', () => {
+  const seen = new Set()
+  const replay = createReplay({ cfg, redactor, seen })
+  replay.feed(JSON.stringify({ type: 'session', id: 'session-x', cwd: 'C:\\TempProject\\历史项目' }))
+  replay.feed(
+    JSON.stringify({
+      type: 'user/message',
+      time: 1793170060000,
+      data: { content: [{ type: 'text', text: '我们决定把记忆存成纯文本 vault，每一轮对话追加一条情节。' }], source: { kind: 'user' } },
+    }),
+  )
+  replay.feed(JSON.stringify({ type: 'turn/end', time: 1793170090000, data: { turn: 1 } }))
+  replay.feed(
+    JSON.stringify({
+      type: 'user/message',
+      time: 1793170100000,
+      data: {
+        content: [{ type: 'text', text: 'Current runtime context. This snapshot supersedes earlier snapshots.' }],
+        source: { kind: 'user' },
+      },
+    }),
+  )
+  replay.feed(JSON.stringify({ type: 'assistant/message', time: 1793170110000, data: { content: [{ type: 'text', text: '收到。' }] } }))
+  replay.feed(JSON.stringify({ type: 'turn/end', time: 1793170120000, data: { turn: 2 } }))
+  const report = replay.finish()
+
+  assert.equal(report.episodes.length, 1, 'only the turn a person typed should survive')
+  assert.equal(report.episodes[0].turn, 1)
+  assert.ok(report.episodes[0].user.includes('纯文本 vault'))
+  assert.equal(report.closedTurns, 2)
+})
+
+await check('a reminder inside a real message is stripped, not the message', () => {
+  const replay = createReplay({ cfg, redactor, seen: new Set() })
+  replay.feed(
+    JSON.stringify({
+      type: 'user/message',
+      time: 1793170060000,
+      data: {
+        content: [{ type: 'text', text: '<system-reminder>sampled time</system-reminder>把记忆图谱的面板改成中文。' }],
+        source: { kind: 'user' },
+      },
+    }),
+  )
+  replay.feed(JSON.stringify({ type: 'turn/end', time: 1793170090000, data: { turn: 3 } }))
+  const [episode] = replay.finish().episodes
+  assert.ok(episode, 'the message should survive')
+  assert.ok(!episode.user.includes('system-reminder'), 'the reminder must be gone')
+  assert.equal(episode.user, '把记忆图谱的面板改成中文。')
+})
+
+await check('the timestamp is the turn’s own, not the day of the import', () => {
+  const replay = createReplay({ cfg, redactor, seen: new Set() })
+  replay.feed(
+    JSON.stringify({
+      type: 'user/message',
+      time: 1793170060000,
+      data: { content: [{ type: 'text', text: '这段历史发生在上个月，应该落在上个月的时间轴上。' }], source: { kind: 'user' } },
+    }),
+  )
+  replay.feed(JSON.stringify({ type: 'turn/end', time: 1793170090000, data: { turn: 1 } }))
+  const [episode] = replay.finish().episodes
+  assert.equal(episode.t, isoAt(1793170090000))
+  assert.ok(episode.t.startsWith('2026-'), `expected a 2026 date, got ${episode.t}`)
+})
+
+await check('a secret in replayed text is redacted before it is stored', () => {
+  const replay = createReplay({ cfg, redactor, seen: new Set() })
+  replay.feed(
+    JSON.stringify({
+      type: 'user/message',
+      time: 1793170060000,
+      data: {
+        content: [{ type: 'text', text: '出问题就写信给 someone@example.com，别贴密钥 sk-live-abcdefghijklmnopqrstuvwx。' }],
+        source: { kind: 'user' },
+      },
+    }),
+  )
+  replay.feed(JSON.stringify({ type: 'turn/end', time: 1793170090000, data: { turn: 1 } }))
+  const [episode] = replay.finish().episodes
+  assert.ok(!episode.user.includes('someone@example.com'), `email leaked: ${episode.user}`)
+  assert.ok(!episode.user.includes('sk-live-abcdefghijklmnopqrstuvwx'), `secret leaked: ${episode.user}`)
+})
+
+await check('a corrupt line is counted, not thrown', () => {
+  const replay = createReplay({ cfg, redactor, seen: new Set() })
+  replay.feed('{not json')
+  replay.feed(JSON.stringify({ type: 'turn/end', time: 1793170090000, data: { turn: 1 } }))
+  const report = replay.finish()
+  assert.equal(report.malformed, 1)
+  assert.equal(report.episodes.length, 0)
+})
+
+await check('a turn already in the vault is skipped', () => {
+  const seen = new Set(['session-y#1'])
+  const replay = createReplay({ cfg, redactor, seen })
+  replay.feed(JSON.stringify({ type: 'session', id: 'session-y' }))
+  replay.feed(
+    JSON.stringify({
+      type: 'user/message',
+      time: 1793170060000,
+      data: { content: [{ type: 'text', text: '这一轮已经在记忆库里了，不该再写一遍。' }], source: { kind: 'user' } },
+    }),
+  )
+  replay.feed(JSON.stringify({ type: 'turn/end', time: 1793170090000, data: { turn: 1 } }))
+  const report = replay.finish()
+  assert.equal(report.episodes.length, 0)
+  assert.equal(report.duplicates, 1)
+})
+
+/* ------------------------------------------------------------------- file */
+
+await check('the real zstd frame is decompressed into the vault', async () => {
+  const [entry] = await listSessions(store)
+  const report = await importSession({ entry, cfg, vault, redactor, seen: new Set() })
+  assert.equal(report.id, 'session-history-fixture')
+  assert.equal(report.project, '历史项目', 'the project comes from the session header')
+  assert.equal(report.truncated, false)
+  assert.equal(report.episodes, 2, `expected 2 usable turns, got ${report.episodes}`)
+
+  const stats = await vault.stats()
+  assert.equal(stats.episodes.records, 2, 'both turns should be on disk')
+  assert.deepEqual(stats.projects, ['历史项目'], 'the project file is touched too')
+})
+
+await check('a second run imports nothing twice', async () => {
+  const report = await runBackfill({ cfg, vault, redactor, dir: store })
+  assert.equal(report.found, 2)
+  assert.equal(report.imported, 0, `re-imported ${report.imported} episodes`)
+  assert.ok(report.duplicates >= 2, `expected the two known turns, got ${report.duplicates}`)
+  const stats = await vault.stats()
+  assert.equal(stats.episodes.records, 2, 'the vault must not have grown')
+})
+
+/* -------------------------------------------------------------- dry run */
+
+await check('a dry run reports without writing', async () => {
+  // Its own vault: the dedupe key is the session id inside the file, so a
+  // second vault is what proves the dry run *would* have written these turns.
+  const freshDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'memgraph-dry-'))
+  const freshCfg = resolveConfig({ vaultDir: freshDir })
+  const freshVault = createVault(freshCfg, createRedactor(freshCfg.privacy))
+  const fresh = await makeStore('dry')
+  await plant(fresh)
+
+  const report = await runBackfill({ cfg: freshCfg, vault: freshVault, redactor, dir: fresh, dryRun: true })
+  assert.equal(report.dryRun, true)
+  assert.equal(report.imported, 2, 'it should still say what it would import')
+  assert.equal((await freshVault.stats()).episodes.records, 0, 'a dry run must not write')
+
+  // And the same run without the flag does write those two.
+  const real = await runBackfill({ cfg: freshCfg, vault: freshVault, redactor, dir: fresh })
+  assert.equal(real.imported, 2)
+  assert.equal((await freshVault.stats()).episodes.records, 2)
+})
+
+await check('the limit takes the newest sessions first', async () => {
+  const report = await runBackfill({ cfg, vault, redactor, dir: store, limit: 1, dryRun: true })
+  assert.equal(report.scanned, 1)
+  assert.equal(report.sessions[0].id, 'session-history-fixture')
+})
+
+let failed = 0
+for (const line of results) {
+  if (line.includes('FAIL')) failed += 1
+}
+console.log(results.join('\n'))
+console.log(failed === 0 ? `\nall ${results.length} checks passed` : `\n${failed} of ${results.length} checks failed`)
+if (failed === 0) process.exitCode = 0

package/test/tools.mjs

@@ -57,8 +57,9 @@ async function call(name, args) {
 }
 
 /* ------------------------------------------------------------------ shape */
-check('registers the eight memory tools', () => {
+check('registers the nine memory tools', () => {
   assert.deepEqual([...byName.keys()].sort(), [
+    'memory_backfill',
     'memory_distill',
     'memory_forget',
     'memory_get',