dsh-memory-engine 0.7.0-beta.2b → 0.7.0-beta.6b

package/lib/routes.js

@@ -3,21 +3,87 @@ import { computeMapData } from './map.js';
 import { renderHtml } from './render/render.mjs';
 import { ONBOARD_PROMPT, ONBOARD_STEPS } from './onboard.js';
 import { readUiConfig } from './config.js';
+import { chars, retention, titleOf } from './decay.js';
+import { scoreMemories } from './render/score.mjs';
 
 const base = '/memory-engine';
-const paths = new Set([base, `${base}/`, `${base}/api/map`, `${base}/api/stats`, `${base}/api/onboard`, `${base}/api/config`]);
+const paths = new Set([base, `${base}/`, `${base}/api/map`, `${base}/api/stats`, `${base}/api/onboard`, `${base}/api/config`,
+  `${base}/api/list`, `${base}/api/export`, `${base}/api/clear`]);
 const allowedMethods = new Set(['GET', 'POST', 'PUT', 'DELETE']);
 const escapeBridge = '<script>window.addEventListener("keydown",function(event){if(event.key==="Escape")parent.postMessage({type:"dsh-memory-engine-close"},"*")});</script>';
 
+function readBody(request) {
+  return new Promise((resolve, reject) => {
+    let bytes = 0;
+    let chunks = [];
+    const finish = (error, value) => {
+      request.removeListener('data', onData);
+      request.removeListener('end', onEnd);
+      request.removeListener('error', onError);
+      request.removeListener('aborted', onAborted);
+      chunks = [];
+      if (error) reject(error); else resolve(value);
+    };
+    const onError = error => finish(error);
+    const onAborted = () => finish(Object.assign(new Error('请求已中断'), { status: 400 }));
+    const onData = chunk => {
+      bytes += chunk.length;
+      if (bytes > 1024 * 1024) {
+        finish(Object.assign(new Error('请求体不能超过 1MB'), { status: 413 }));
+        request.resume();
+      } else chunks.push(chunk);
+    };
+    const onEnd = () => {
+      let value;
+      try { value = JSON.parse(Buffer.concat(chunks).toString('utf8')); }
+      catch { return finish(Object.assign(new Error('请求体必须是有效 JSON'), { status: 400 })); }
+      if (!value || typeof value !== 'object' || Array.isArray(value)) return finish(Object.assign(new Error('请求体必须是 JSON 对象'), { status: 400 }));
+      finish(null, value);
+    };
+    request.on('data', onData);
+    request.on('end', onEnd);
+    request.on('error', onError);
+    request.on('aborted', onAborted);
+  });
+}
+
+function describeMemories(rows, now) {
+  const items = rows.map(row => ({ ...row, title: titleOf(row) }));
+  const degrees = new Map(scoreMemories(items, now).nodes.map(node => [node.id, node.degree]));
+  return items.map(row => ({ ...row, retention: retention(row, now), degree: degrees.get(row.id) }));
+}
+
+function listMemories(store, query) {
+  const sort = query.get('sort') || 'recent';
+  const invalid = message => { throw Object.assign(new Error(message), { status: 400 }); };
+  if (!['recent', 'oldest', 'fading', 'degree'].includes(sort)) invalid('sort 必须是 recent、oldest、fading 或 degree');
+  const limit = Number(query.get('limit') ?? 50);
+  const offset = Number(query.get('offset') ?? 0);
+  if (!Number.isSafeInteger(limit) || limit < 1) invalid('limit 必须是正整数');
+  if (!Number.isSafeInteger(offset) || offset < 0) invalid('offset 必须是非负整数');
+  const rows = store.read();
+  const search = (query.get('q') || '').toLowerCase();
+  const kind = query.get('kind') || '';
+  const items = describeMemories(rows, store.now()).filter(row => (!kind || row.kind === kind)
+    && (!search || row.text.toLowerCase().includes(search) || row.title.toLowerCase().includes(search)));
+  const ordering = { recent: (left, right) => right.ts - left.ts, oldest: (left, right) => left.ts - right.ts,
+    fading: (left, right) => left.retention - right.retention, degree: (left, right) => right.degree - left.degree };
+  items.sort(ordering[sort]);
+  const size = Math.min(200, limit);
+  return { total: items.length, allTotal: rows.length, limit: size, offset,
+    items: items.slice(offset, offset + size).map(row => ({ ...row, preview: chars(row.text, 60) + (Array.from(row.text).length > 60 ? '…' : '') })) };
+}
+
 export function createMemoryHandler({ store, warn = () => {} }) {
   return async (request, response) => {
+    let methods = ['GET'];
     const reply = (status, payload, html = false) => {
       response.writeHead(status, {
         'Content-Type': html ? 'text/html; charset=utf-8' : 'application/json; charset=utf-8',
         'Cache-Control': 'no-store',
         'X-Content-Type-Options': 'nosniff',
         'Referrer-Policy': 'no-referrer',
-        ...(status === 405 ? { Allow: 'GET' } : {}),
+        ...(status === 405 ? { Allow: methods.join(', ') } : {}),
         ...(html ? { 'Content-Security-Policy': "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'none'; frame-ancestors 'self'" } : {}),
       });
       response.end(html ? payload : JSON.stringify(payload));
@@ -30,20 +96,39 @@ export function createMemoryHandler({ store, warn = () => {} }) {
       let pathname;
       try { pathname = decodeURIComponent(rawPath); }
       catch { return fail(404, '找不到这个记忆接口'); }
-      if (pathname.includes('..') || pathname.includes('\\') || !paths.has(pathname)) return fail(404, '找不到这个记忆接口');
-      if (!allowedMethods.has(request.method) || request.method !== 'GET') return fail(405, '此接口仅支持 GET');
+      const item = /^\/memory-engine\/api\/item\/([^/%\\]+)$/u.exec(pathname);
+      if (pathname.includes('..') || pathname.includes('\\') || (!paths.has(pathname) && !item)) return fail(404, '找不到这个记忆接口');
+      methods = item ? ['GET', 'PUT', 'DELETE'] : pathname === `${base}/api/clear` ? ['POST'] : ['GET'];
+      if (!allowedMethods.has(request.method) || !methods.includes(request.method)) return fail(405, `此接口仅支持 ${methods.join('、')}`);
       if (Number(request.headers['content-length']) > 1024 * 1024) return fail(413, '请求体不能超过 1MB');
-      if (request.headers['transfer-encoding'] || Number(request.headers['content-length']) > 0) return fail(400, '此只读接口不接受请求体');
-      if (pathname === `${base}/api/map`) return reply(200, { ok: true, data: computeMapData(store) });
+      if (request.method === 'PUT' || request.method === 'POST') {
+        if (!/^application\/json(?:\s*;|$)/i.test(request.headers['content-type'] ?? '')) return fail(400, '请求体必须使用 application/json');
+        const body = await readBody(request);
+        return reply(200, { ok: true, data: item ? store.updateItem(item[1], body) : store.clear(body) });
+      }
+      if (request.headers['transfer-encoding'] || Number(request.headers['content-length']) > 0) return fail(400, request.method === 'GET' ? '此只读接口不接受请求体' : '此接口不接受请求体');
+      if (item) {
+        if (request.method === 'DELETE') return reply(200, { ok: true, data: store.deleteItem(item[1]) });
+        const rows = store.read();
+        if (!rows.some(row => row.id === item[1])) return fail(404, '没有这条记忆');
+        return reply(200, { ok: true, data: describeMemories(rows, store.now()).find(row => row.id === item[1]) });
+      }
+      if (pathname === `${base}/api/list`) return reply(200, { ok: true, data: listMemories(store, new URLSearchParams(request.url.includes('?') ? request.url.slice(request.url.indexOf('?') + 1) : '')) });
+      if (pathname === `${base}/api/export`) {
+        const items = store.read();
+        return reply(200, { ok: true, data: { total: items.length, items } });
+      }
+      if (pathname === `${base}/api/map`) return reply(200, { ok: true, data: computeMapData(store, { warn }) });
       if (pathname === `${base}/api/stats`) return reply(200, { ok: true, data: store.stats() });
-      if (pathname === `${base}/api/config`) return reply(200, { ok: true, data: readUiConfig(path.dirname(path.dirname(store.file))) });
+      if (pathname === `${base}/api/config`) return reply(200, { ok: true, data: readUiConfig(path.dirname(path.dirname(store.file)), { warn }) });
       if (pathname === `${base}/api/onboard`) return reply(200, { ok: true, data: {
         empty: store.read().length === 0, prompt: ONBOARD_PROMPT, steps: ONBOARD_STEPS, dataDir: path.dirname(store.file),
       } });
-      const { nodes, ...data } = computeMapData(store);
+      const { nodes, ...data } = computeMapData(store, { warn });
       const html = renderHtml({ ...data, stars: nodes }, '我的记忆神经网络');
       return reply(200, html.replace('</body>', escapeBridge + '</body>'), true);
     } catch (error) {
+      if ([400, 404, 413].includes(error.status)) return fail(error.status, error.message);
       warn(`图谱请求失败：${error.message}`);
       return fail(500, '读取记忆失败，请检查本地插件日志');
     }

package/lib/session-text.js

@@ -0,0 +1,44 @@
+export function eventText(event) {
+  let content;
+  if (event?.type === 'user/message' && (!event.data?.role || event.data.role === 'user')) content = event.data?.content;
+  if (event?.type === 'assistant/message' && (!event.data?.message?.role || event.data.message.role === 'assistant')) content = event.data?.message?.content;
+  if (!Array.isArray(content)) return '';
+  return content.filter(block => block?.type === 'text' && typeof block.text === 'string').map(block => block.text).join('\n').trim();
+}
+
+export function usefulText(text) {
+  return Array.from(text).length > 1 && !/^(?:嗯|哦|噢|啊|好|好的|好呀|好哒|行|哈哈|呵呵|嘿嘿|谢谢|收到|ok|[\s，。！!~～])+$/iu.test(text)
+    && text.replace(/```[\s\S]*?```|~~~[\s\S]*?~~~/gu, '').trim().length > 0;
+}
+
+export function createTurnCollector(onTurn) {
+  const sessions = new Map();
+  return {
+    accept(session, event) {
+      const id = session?.id;
+      if (typeof id !== 'string' || !event) return;
+      if (!['turn/start', 'turn/end', 'user/message', 'assistant/message'].includes(event.type)) return;
+      let state = sessions.get(id);
+      if (event.type === 'turn/start' && state?.turn !== undefined && state.turn !== event.data?.turn) state = undefined;
+      if (!state) {
+        state = { text: '', userText: '', turn: undefined };
+        sessions.set(id, state);
+        if (sessions.size > 256) sessions.delete(sessions.keys().next().value);
+      }
+      if (event.type === 'turn/start') state.turn = event.data?.turn;
+      if (event.type === 'assistant/message' && state.turn !== undefined && event.data?.turn !== state.turn) return;
+      const text = eventText(event);
+      if (text) {
+        const role = event.type === 'user/message' ? 'user' : 'assistant';
+        state.text = Array.from(`${state.text}\n${role}: ${text}`).slice(-4000).join('');
+        if (role === 'user') state.userText = Array.from(`${state.userText}\n${text}`).slice(-4000).join('');
+      }
+      if (event.type === 'turn/end') {
+        if (state.turn !== undefined && event.data?.turn !== state.turn) return;
+        sessions.delete(id);
+        if (state.userText.trim()) onTurn({ sessionId: id, text: state.text, userText: state.userText, time: event.time });
+      }
+    },
+    clear() { sessions.clear(); },
+  };
+}

package/lib/store.js

@@ -55,7 +55,7 @@ export class MemoryStore {
     }
   }
 
-  save({ text, kind = '对话', heat, who, ts = this.now() }) {
+  save({ text, kind = '对话', heat, who, ts = this.now() }, { threshold = 0.7 } = {}) {
     if (!nonempty(text) || Array.from(text).length > 2000) throw new Error('text 必须为 1–2000 字');
     if (!nonempty(kind)) throw new Error('kind 必须是非空字符串');
     if (heat !== undefined && ![1, 2, 3].includes(heat)) throw new Error('heat 只能为 1/2/3');
@@ -67,7 +67,7 @@ export class MemoryStore {
     let memory = { id: `m-${now}-${randomBytes(3).toString('hex')}`, text, kind, ts,
       heat: heat ?? inferred.heat, emotion: inferred.emotion,
       ...(who !== undefined ? { who } : {}), boosts: 0, createdAt: now };
-    const match = findDuplicate(rows, memory);
+    const match = findDuplicate(rows, memory, undefined, threshold);
     if (match) {
       // A repeated save is one reinforcement; batch merges simply sum counts.
       memory.boosts = 1;
@@ -83,13 +83,58 @@ export class MemoryStore {
   backup() {
     fs.mkdirSync(path.dirname(this.file), { recursive: true });
     const base = `${this.file}.bak-${Date.now()}`;
-    let file = base;
-    for (let suffix = 1; fs.existsSync(file); suffix++) file = `${base}-${suffix}`;
+    const directory = path.dirname(this.file);
+    const prefix = path.basename(base) + '-';
+    const suffixes = fs.readdirSync(directory).filter(name => name.startsWith(prefix))
+      .map(name => Number(name.slice(prefix.length))).filter(Number.isSafeInteger);
+    let suffix = suffixes.length ? Math.max(...suffixes) + 1 : 0;
+    let file = suffix ? `${base}-${suffix}` : base;
+    while (fs.existsSync(file)) file = `${base}-${++suffix}`;
     if (fs.existsSync(this.file)) fs.copyFileSync(this.file, file, fs.constants.COPYFILE_EXCL);
     else fs.writeFileSync(file, '[]\n', { flag: 'wx', mode: 0o600 });
+    const backups = fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+      const match = /^memories\.json\.bak-(\d+)(?:-(\d+))?$/u.exec(entry.name);
+      return entry.isFile() && match ? [{ name: entry.name, time: Number(match[1]), suffix: Number(match[2] ?? 0) }] : [];
+    }).sort((left, right) => right.time - left.time || right.suffix - left.suffix);
+    for (const old of backups.slice(5)) fs.unlinkSync(path.join(directory, old.name));
     return file;
   }
 
+  updateItem(id, changes) {
+    const invalid = message => { throw Object.assign(new Error(message), { status: 400 }); };
+    if (!changes || typeof changes !== 'object' || Array.isArray(changes)) invalid('请求体必须是 JSON 对象');
+    for (const key of Object.keys(changes)) {
+      if (!['text', 'kind', 'heat', 'who'].includes(key)) invalid(`不支持修改 ${key}`);
+    }
+    if (Object.hasOwn(changes, 'text') && (!nonempty(changes.text) || Array.from(changes.text).length > 2000)) invalid('text 必须是 1～2000 字符，且不能全为空白');
+    if (Object.hasOwn(changes, 'kind') && (!nonempty(changes.kind) || Array.from(changes.kind).length > 20)) invalid('kind 必须是 1～20 字符');
+    if (Object.hasOwn(changes, 'heat') && ![1, 2, 3].includes(changes.heat)) invalid('heat 必须是整数 1、2 或 3');
+    if (Object.hasOwn(changes, 'who') && (typeof changes.who !== 'string' || Array.from(changes.who).length > 40)) invalid('who 必须是 0～40 字符');
+    const rows = this.read();
+    const index = rows.findIndex(row => row.id === id);
+    if (index === -1) throw Object.assign(new Error('没有这条记忆'), { status: 404 });
+    rows[index] = { ...rows[index], ...changes };
+    const backup = this.backup();
+    this.write(rows);
+    return { ...rows[index], backup };
+  }
+
+  deleteItem(id) {
+    const rows = this.read();
+    if (!rows.some(row => row.id === id)) throw Object.assign(new Error('没有这条记忆'), { status: 404 });
+    const backup = this.backup();
+    this.write(rows.filter(row => row.id !== id));
+    return { deleted: id, backup };
+  }
+
+  clear({ confirm } = {}) {
+    if (confirm !== 'DELETE') throw Object.assign(new Error('请输入大写 DELETE 确认清空'), { status: 400 });
+    const rows = this.read();
+    const backup = this.backup();
+    this.write([]);
+    return { removed: rows.length, backup };
+  }
+
   dedupe({ threshold = 0.7, dry_run = true } = {}) {
     if (typeof dry_run !== 'boolean') throw new Error('dry_run 必须是布尔值');
     const started = performance.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-engine",
-  "version": "0.7.0-beta.2b",
+  "version": "0.7.0-beta.6b",
   "description": "Local DSH memory engine with neuron network visualization and private file import",
   "keywords": [
     "dsh",