@kira905/dsh-memory-toolkit 0.1.3 → 0.2.0

package/memory-engine/lib/distill-rollback.mjs

@@ -1,9 +1,9 @@
-// 记忆引擎 v2 · S3c —— 提炼产物回滚（方案 §3.5 回滚行）
+// 提炼产物回滚（方案 §3.5 的回滚行）
 //
-// 口径：**按 `tags LIKE 'distilled%'` 批量列出 / 删除**；默认 dry-run；删除前 `VACUUM INTO` 快照。
-// 为什么按 tag 而不是按 id 清单：提炼条是**推断产物**，主人可能整批否定（"这批结论不对"），
-//   也可能只否定某几组 ⇒ 两种粒度都要能选：`--key <srcKey>`（整组）/ `--id <行 id>`（单条）。
-// ⚠️ 删除语句**恒带 `AND tags LIKE 'distilled%'`** —— 即使调用方算错了 id 集合，也不可能误删真实记忆。
+// 口径：按 `tags LIKE 'distilled%'` 批量列、批量删；默认 dry-run；真删之前先用 VACUUM INTO 拍快照。
+// 为什么认 tag 而不认 id 清单：提炼条本身是**推断产物**，主人可能一句话否掉一整批，
+//   也可能只否掉其中某几组 ⇒ 两种粒度都得给：`--key <srcKey>` 整组、`--id <行 id>` 单条。
+// ⚠ 删除语句**恒带 `AND tags LIKE 'distilled%'`**：调用方就算把 id 集合算错，也误伤不到真实记忆。
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
@@ -11,83 +11,103 @@ import { DatabaseSync } from 'node:sqlite';
 import { vacuumInto } from './domain-tags.mjs';
 import { DISTILL_PREFIX } from './distill.mjs';
 
-/** 解析提炼条标签 → {srcKey, srcIds, date}。 */
-export function parseDistilledTags(tags) {
-  const t = String(tags ?? '');
-  if (!t.startsWith(DISTILL_PREFIX)) return null;
-  const key = t.match(/(?:^|\s)src=([0-9a-f]+)(?:\s|$)/);
-  const ids = t.match(/(?:^|\s)srcids=([0-9,\s]*)(?:\s|$)/);
-  const date = t.match(/(?:^|\s)date=(\d{8})(?:\s|$)/);
-  return {
-    srcKey: key ? key[1] : null,
-    srcIds: ids && ids[1] ? ids[1].split(',').map((x) => Number(x.trim())).filter((x) => Number.isFinite(x)) : [],
-    date: date ? date[1] : null,
-  };
-}
+// 标签里的三个属性位：来源键 / 来源 id 串 / 提炼日期
+const TAG_SRCKEY_RE = /(?:^|\s)src=([0-9a-f]+)(?:\s|$)/;
+const TAG_SRCIDS_RE = /(?:^|\s)srcids=([0-9,\s]*)(?:\s|$)/;
+const TAG_DATE_RE = /(?:^|\s)date=(\d{8})(?:\s|$)/;
 
-function open(dbPath, { readOnly = false } = {}) {
-  const db = readOnly ? new DatabaseSync(dbPath, { readOnly: true }) : new DatabaseSync(dbPath);
-  if (!readOnly) db.exec('PRAGMA busy_timeout = 5000;');
-  return db;
+const SQL_LIST = `SELECT id, text, tags, updated_at, created_at%EXTRA% FROM memories WHERE tags LIKE 'distilled%' ORDER BY id`;
+const SQL_TRIGGERS = "SELECT name FROM sqlite_master WHERE type='trigger' AND tbl_name='memories'";
+const SQL_DELETE = "DELETE FROM memories WHERE id = ? AND tags LIKE 'distilled%'";
+
+// 库里有没有某一列（老库没有 owner_user / visibility 这两个多人口径字段）
+function columnExists(db, name) {
+  return db.prepare('PRAGMA table_info(memories)').all().some((row) => row.name === name);
 }
 
-/**
- * 列出提炼条（只读）。
- * @param {{dbPath:string, keys?:string[], ids?:number[], limit?:number, headChars?:number}} p
- */
-export function listDistilled({ dbPath, keys = null, ids = null, limit = 0, headChars = 100 }) {
-  const db = open(dbPath, { readOnly: true });
+// 统一开关库：只读走 readOnly 连接，写连接才设 busy_timeout；关库一律放 finally
+function withDb(dbPath, { readOnly = false } = {}, body) {
+  const conn = readOnly ? new DatabaseSync(dbPath, { readOnly: true }) : new DatabaseSync(dbPath);
   try {
-    const rows = db
-      .prepare(`SELECT id, text, tags, updated_at, created_at${hasCol(db, 'owner_user') ? ', owner_user, visibility' : ''} FROM memories WHERE tags LIKE 'distilled%' ORDER BY id`)
-      .all();
-    let items = rows.map((r) => {
-      const meta = parseDistilledTags(r.tags) ?? { srcKey: null, srcIds: [], date: null };
-      return {
-        id: Number(r.id), srcKey: meta.srcKey, srcIds: meta.srcIds, date: meta.date,
-        chars: String(r.text ?? '').length,
-        head: String(r.text ?? '').slice(0, headChars).replace(/\s+/g, ' '),
-        tags: r.tags, createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
-        ownerUser: r.owner_user ?? null, visibility: r.visibility ?? null,
-      };
-    });
-    if (Array.isArray(keys) && keys.length) {
-      const want = new Set(keys.map((k) => String(k)));
-      items = items.filter((x) => want.has(String(x.srcKey)));
-    }
-    if (Array.isArray(ids) && ids.length) {
-      const want = new Set(ids.map((x) => Number(x)));
-      items = items.filter((x) => want.has(x.id));
-    }
-    if (limit > 0) items = items.slice(0, Number(limit));
-    return items;
+    if (!readOnly) conn.exec('PRAGMA busy_timeout = 5000;');
+    return body(conn);
   } finally {
-    try { db.close(); } catch { /* ignore */ }
+    try { conn.close(); } catch { /* 关不掉也不拖累结果 */ }
   }
 }
 
-function hasCol(db, name) {
-  return db.prepare('PRAGMA table_info(memories)').all().some((r) => r.name === name);
+// 解析提炼条标签 → {srcKey, srcIds, date}；不是提炼条就给 null
+export function parseDistilledTags(tags) {
+  const raw = String(tags ?? '');
+  if (!raw.startsWith(DISTILL_PREFIX)) return null;
+
+  const pick = (pattern) => {
+    const hit = pattern.exec(raw);
+    return hit ? hit[1] : '';
+  };
+  const idText = pick(TAG_SRCIDS_RE);
+  const ids = idText
+    ? idText.split(',').map((piece) => Number(piece.trim())).filter((n) => Number.isFinite(n))
+    : [];
+  return {
+    srcKey: pick(TAG_SRCKEY_RE) || null,
+    srcIds: ids,
+    date: pick(TAG_DATE_RE) || null,
+  };
 }
 
-/**
- * **内容级摘要**：按 id 排序取 (id, text, tags, pinned, updated_at) 逐行哈希再整体哈希。
- * 为什么不用文件 sha256：SQLite 写回后页布局会变（同样的内容也可能字节不同），
- *   文件 sha 无法回答"回滚后库是否回到原状"；内容摘要可以（本卡演练的判据就靠它）。
- */
+// 列出提炼条（只读）；keys / ids 是两组独立过滤，limit > 0 才截断
+export function listDistilled({ dbPath, keys = null, ids = null, limit = 0, headChars = 100 }) {
+  return withDb(dbPath, { readOnly: true }, (conn) => {
+    const extra = columnExists(conn, 'owner_user') ? ', owner_user, visibility' : '';
+    const rows = conn.prepare(SQL_LIST.replace('%EXTRA%', extra)).all();
+    const keySet = new Set((Array.isArray(keys) ? keys : []).map((k) => String(k)));
+    const idSet = new Set((Array.isArray(ids) ? ids : []).map((x) => Number(x)));
+
+    const listed = [];
+    for (const row of rows) {
+      const meta = parseDistilledTags(row.tags) ?? { srcKey: null, srcIds: [], date: null };
+      if (keySet.size > 0 && !keySet.has(String(meta.srcKey))) continue;
+      if (idSet.size > 0 && !idSet.has(Number(row.id))) continue;
+      const text = String(row.text ?? '');
+      listed.push({
+        id: Number(row.id),
+        srcKey: meta.srcKey,
+        srcIds: meta.srcIds,
+        date: meta.date,
+        chars: text.length,
+        head: text.slice(0, headChars).replace(/\s+/g, ' '),
+        tags: row.tags,
+        createdAt: Number(row.created_at),
+        updatedAt: Number(row.updated_at),
+        ownerUser: row.owner_user ?? null,
+        visibility: row.visibility ?? null,
+      });
+    }
+    return limit > 0 ? listed.slice(0, Number(limit)) : listed;
+  });
+}
+
+// **内容级摘要**：按 id 排序取 (id, text, tags, pinned, updated_at)，逐行拼再整体哈希。
+// 为什么不看文件 sha256：SQLite 写回后页布局会变（内容一样也可能字节不同），
+//   文件 sha 回答不了"回滚后库是否回到原状"，内容摘要能。
 export function contentDigest(dbPath, { excludeTagsLike = null } = {}) {
-  const db = open(dbPath, { readOnly: true });
-  try {
-    const where = excludeTagsLike ? ` WHERE tags NOT LIKE '${excludeTagsLike}'` : '';
-    const rows = db.prepare(`SELECT id, text, tags, pinned, updated_at FROM memories${where} ORDER BY id`).all();
-    const h = crypto.createHash('sha256');
-    for (const r of rows) h.update(`${r.id}\u0001${r.text}\u0001${r.tags}\u0001${r.pinned}\u0001${r.updated_at}\u0002`, 'utf8');
-    return { count: rows.length, digest: h.digest('hex'), allCount: Number(db.prepare('SELECT COUNT(*) n FROM memories').get().n) };
-  } finally {
-    try { db.close(); } catch { /* ignore */ }
-  }
+  return withDb(dbPath, { readOnly: true }, (conn) => {
+    const filter = excludeTagsLike ? ` WHERE tags NOT LIKE '${excludeTagsLike}'` : '';
+    const rows = conn.prepare(`SELECT id, text, tags, pinned, updated_at FROM memories${filter} ORDER BY id`).all();
+    const hash = crypto.createHash('sha256');
+    const FIELD_SEP = '\u0001';
+    const ROW_END = '\u0002';
+    for (const row of rows) {
+      const fields = [row.id, row.text, row.tags, row.pinned, row.updated_at].map((value) => String(value));
+      hash.update(`${fields.join(FIELD_SEP)}${ROW_END}`, 'utf8');
+    }
+    const allCount = Number(conn.prepare('SELECT COUNT(*) n FROM memories').get().n);
+    return { count: rows.length, digest: hash.digest('hex'), allCount };
+  });
 }
 
+// 文件 sha256（读不动就给 null，怎么记由调用方决定）
 export function fileSha256(file) {
   try {
     return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
@@ -96,83 +116,103 @@ export function fileSha256(file) {
   }
 }
 
-/**
- * 批量回滚。
- * @param {{dbPath:string, apply?:boolean, keys?:string[], ids?:number[], snapshotDir?:string,
- *          now?:number, keepSnapshot?:boolean}} p
- * @returns {{ok:boolean, matched:number, deleted:number, deletedIds:number[], snapshot:string|null,
- *            before:object, after:object, dryRun:boolean, rollbackFile:string|null}}
- */
-export function rollbackDistilled(p = {}) {
-  const { dbPath, keys = null, ids = null, snapshotDir = null, now = Date.now(), apply = false } = p;
-  const before = contentDigest(dbPath);
-  const items = listDistilled({ dbPath, keys, ids });
-  const out = {
-    ok: true, dryRun: !apply, matched: items.length, deleted: 0, deletedIds: [],
-    snapshot: null, before, after: before, items: items.map((x) => ({ id: x.id, srcKey: x.srcKey, head: x.head })),
-    rollbackFile: null, warnings: [],
-  };
-  if (!items.length) return out;
-
-  if (!apply) return out;
-
-  // 删除前快照（**唯一回滚点**）
+// 删除前快照：这是整条链上唯一的回滚点
+function writeSnapshot(dbPath, snapshotDir, now) {
   const dir = snapshotDir ?? path.join(path.dirname(dbPath), 'snapshots');
   fs.mkdirSync(dir, { recursive: true });
   const stamp = new Date(Number(now)).toISOString().replace(/[:.]/g, '-');
   const snap = path.join(dir, `memory-before-distill-rollback-${stamp}.db`);
   vacuumInto(dbPath, snap);
-  out.snapshot = snap;
-  out.snapshotSha256 = fileSha256(snap);
+  return { dir, stamp, snap };
+}
 
-  const db = open(dbPath);
-  try {
-    // FTS 同步靠 `memories_ad` 触发器（触发器缺失时 DELETE 不会清 FTS 影子表 ⇒ 显式提示）
-    const triggers = db.prepare("SELECT name FROM sqlite_master WHERE type='trigger' AND tbl_name='memories'").all().map((r) => r.name);
-    out.triggers = triggers;
-    if (!triggers.some((n) => /_ad$|delete/i.test(n))) out.warnings.push('未发现 memories 的 AFTER DELETE 触发器 ⇒ FTS 影子表可能残留（建议核对 memories_fts）');
-
-    const targetIds = items.map((x) => x.id);
-    const stmt = db.prepare(`DELETE FROM memories WHERE id = ? AND tags LIKE 'distilled%'`);
-    db.exec('BEGIN IMMEDIATE');
+// 真删：先记触发器现场（FTS 影子表靠 memories_ad 同步），再在一个事务里逐条删
+function deleteDistilledRows(dbPath, items) {
+  return withDb(dbPath, {}, (conn) => {
+    const triggers = conn.prepare(SQL_TRIGGERS).all().map((row) => row.name);
+    const wipe = conn.prepare(SQL_DELETE);
+    const removed = [];
+    conn.exec('BEGIN IMMEDIATE');
     try {
-      for (const id of targetIds) {
-        const r = stmt.run(id);
-        if (Number(r.changes || 0) > 0) out.deletedIds.push(id);
+      for (const item of items) {
+        const res = wipe.run(item.id);
+        if (Number(res.changes || 0) > 0) removed.push(item.id);
       }
-      db.exec('COMMIT');
-    } catch (e) {
-      try { db.exec('ROLLBACK'); } catch { /* ignore */ }
-      throw e;
+      conn.exec('COMMIT');
+    } catch (err) {
+      try { conn.exec('ROLLBACK'); } catch { /* 忽略 */ }
+      throw err;
     }
-    out.deleted = out.deletedIds.length;
-  } finally {
-    try { db.close(); } catch { /* ignore */ }
+    return { triggers, removed };
+  });
+}
+
+// 生成"把快照写回目标库"的一键恢复脚本（覆盖前先把现有库另存一份）
+function restoreScriptText({ snapshot, target }) {
+  const lines = [
+    '// 自动生成：把提炼回滚前的快照写回目标记忆库（覆盖式，覆盖前先另存现有库）',
+    '// 用法：node <本文件路径>',
+    "import fs from 'node:fs';",
+    `const SNAPSHOT = ${JSON.stringify(snapshot)};`,
+    `const DB_TARGET = ${JSON.stringify(target)};`,
+    "const CURRENT_SUFFIXES = ['', '-wal', '-shm'];",
+    'if (!fs.existsSync(SNAPSHOT)) {',
+    "  console.error('快照不存在：' + SNAPSHOT);",
+    '  process.exit(3);',
+    '}',
+    'for (const suffix of CURRENT_SUFFIXES) {',
+    '  const file = DB_TARGET + suffix;',
+    "  try { if (fs.existsSync(file)) fs.copyFileSync(file, file + '.before-restore'); } catch { /* 忽略 */ }",
+    '}',
+    'fs.copyFileSync(SNAPSHOT, DB_TARGET);',
+    "for (const suffix of ['-wal', '-shm']) { try { fs.rmSync(DB_TARGET + suffix, { force: true }); } catch { /* 忽略 */ } }",
+    "console.log('已恢复：' + DB_TARGET + ' <- ' + SNAPSHOT);",
+    '',
+  ];
+  return lines.join('\n');
+}
+
+// 批量回滚主入口：先摘要 + 列表；没命中或 dry-run 都早退；真删才拍快照
+export function rollbackDistilled(p = {}) {
+  const { dbPath, keys = null, ids = null, snapshotDir = null, now = Date.now(), apply = false } = p;
+  const before = contentDigest(dbPath);
+  const items = listDistilled({ dbPath, keys, ids });
+
+  const out = {
+    ok: true,
+    dryRun: !apply,
+    matched: items.length,
+    deleted: 0,
+    deletedIds: [],
+    snapshot: null,
+    before,
+    after: before,
+    items: items.map((item) => ({ id: item.id, srcKey: item.srcKey, head: item.head })),
+    rollbackFile: null,
+    warnings: [],
+  };
+  if (items.length === 0) return out;
+  if (!apply) return out;
+
+  const shot = writeSnapshot(dbPath, snapshotDir, now);
+  out.snapshot = shot.snap;
+  out.snapshotSha256 = fileSha256(shot.snap);
+
+  const wiped = deleteDistilledRows(dbPath, items);
+  out.triggers = wiped.triggers;
+  if (!wiped.triggers.some((name) => /_ad$|delete/i.test(name))) {
+    out.warnings.push('memories 上没有 AFTER DELETE 触发器 ⇒ FTS 影子表可能残留脏行（建议核对 memories_fts）');
   }
+  out.deletedIds = wiped.removed;
+  out.deleted = wiped.removed.length;
+
   out.after = contentDigest(dbPath);
-  // 反向回滚脚本（把快照拷回去 = 一键恢复）
+
+  // 反向回滚脚本：把快照拷回去 = 一键恢复
   if (out.snapshot) {
-    const rbFile = path.join(dir, `restore-memory-${stamp}.mjs`);
-    fs.writeFileSync(rbFile, restoreScript({ snapshot: snap, target: dbPath }), 'utf8');
+    const rbFile = path.join(shot.dir, `restore-memory-${shot.stamp}.mjs`);
+    fs.writeFileSync(rbFile, restoreScriptText({ snapshot: shot.snap, target: dbPath }), 'utf8');
     out.rollbackFile = rbFile;
   }
   return out;
 }
-
-/** 生成"把快照写回目标库"的一键恢复脚本（纯 ASCII 头 + 覆盖前校验存在性）。 */
-function restoreScript({ snapshot, target }) {
-  return `// 自动生成：把提炼回滚前的快照写回目标记忆库（覆盖式）
-// 用法：node ${path.basename('restore-memory.mjs')}  或  node "本文件路径"
-import fs from 'node:fs';
-const SNAP = ${JSON.stringify(snapshot)};
-const TARGET = ${JSON.stringify(target)};
-if (!fs.existsSync(SNAP)) { console.error('快照不存在：' + SNAP); process.exit(3); }
-for (const suffix of ['', '-wal', '-shm']) {
-  const f = TARGET + suffix;
-  try { if (fs.existsSync(f)) fs.copyFileSync(f, f + '.before-restore'); } catch { /* ignore */ }
-}
-fs.copyFileSync(SNAP, TARGET);
-for (const suffix of ['-wal', '-shm']) { try { fs.rmSync(TARGET + suffix, { force: true }); } catch { /* ignore */ } }
-console.log('已恢复：' + TARGET + ' <- ' + SNAP);
-`;
-}