dsh-memory-github 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # 更新日志
 
+## 0.4.0 — 2026-10-25
+
+定位从「又一个跨会话记忆插件」改成「**多端共享记忆**」——本地记忆库的同类插件已有上百个，
+多设备共用一份记忆才是这个项目的差异点。
+
+### 新增
+
+- **`autoRecall` 自动召回（默认开）**：每轮从当前用户消息抽检索词（英文整词、中文双字滑窗），
+  给归档打分（标题 ×3 / 标签 ×2 / 正文 ×1），把最相关的几条直接注入系统提示。
+  不需要模型"想起来去 `memory_search`"——这是竞品最影响体感的能力，用纯词袋实现，
+  不发 LLM 请求、不引入数据库。
+  - `autoRecall: false` 关闭
+  - `autoRecallLimit: 5` 最多注入几条
+  - `autoRecallMinScore: 4` 分数门槛（调高更保守，避免无关记忆干扰）
+- 用户消息文本从 `user/message` 事件的 `content` 取（兼容字符串与 block 数组两种形态）。
+
+### 文档
+
+- README 重写开头：说明「为什么不跟本地库插件比功能」、适合与不适合的场景
+- 特性列表、配置示例补上 `autoRecall` 三项
+
+### 测试
+
+- 冒烟测试 63 → **68 条**（覆盖：命中相关归档、不注入无关归档、无相关时不硬塞、关闭开关）
+
 ## 0.3.0 — 2026-10-25
 
 参考同类插件（dsh-prime-memory、meow-memory、@try-works/dsh-memory、@modusensus/dsh-mneme 等

package/README.md

@@ -3,22 +3,39 @@
 [![test](https://github.com/Administrator016/dsh-memory-github/actions/workflows/test.yml/badge.svg)](https://github.com/Administrator016/dsh-memory-github/actions/workflows/test.yml)
 [![license](https://img.shields.io/github/license/Administrator016/dsh-memory-github)](LICENSE)
 
-给 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 用的**跨会话记忆插件**。
+给 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 用的**多端共享记忆插件**。
 
-默认把记忆存在本地目录；想要换机器也能接着用，就把它接成一个 **GitHub 私有仓库**——
-插件会在每次写入后自动 commit + push，启动时自动 pull。
+生态里同类插件有上百个（`dsh-prime-memory`、`meow-memory`、`dsh-mnemonic`…），绝大多数是
+**本地库**：SQLite、向量索引、面板 UI，功能很强，但**只在那一台机器上**。
+这个插件的取舍相反——不引入数据库、不调 embedding，只用一个目录 + 一个 git 仓库，
+把「手机 / 电脑 / 移动硬盘」这些设备连成**同一份记忆**：
+
+- 一台机当**整理端**（`role: primary`）负责写和推
+- 其余机器当**子端**（`role: child`）只读，想留话就写 `inbox/`，整理端处理完归档
+- 换机器：`git clone` 或拷贝目录即恢复；连不联网都能用
 
 > 记忆分两层：**核心记忆**（`MEMORY.md`，每轮注入系统提示，硬上限可配）和**归档记忆**
-> （`notes/*.md` + `index.json`，按关键词检索）。模型自己决定什么时候写、写什么。
+> （`notes/*.md` + `index.json`，按关键词检索 + **自动召回**）。模型自己决定什么时候写、写什么。
 
 ## 特性
 
 - 🧠 **两段式记忆**：核心记忆常驻注入，归档记忆按需检索（`memory_search` / `memory_read`）
-- 💾 **默认本地**：一个目录就是记忆库（Markdown + JSON，随便备份、随便看）
-- ☁️ **可选 GitHub**：同一个目录套上 git，写入自动推送、启动自动拉取
-- 🔒 **只读模式**：`readOnly: true` 只注册读工具，适合"手机写入、电脑只读"这类多设备分工
+- 🎯 **自动召回**：每轮按你的消息自动挑几条相关归档注入（无需模型想起来去 search）
+- 🌐 **多端共享**：`primary` / `child` 角色分工，GitHub 做同步总线
+- 💾 **零依赖**：一个目录就是记忆库（Markdown + JSON），可读、可审计、可 `git diff`
+- ☁️ **可选 GitHub**：写入自动 commit + push，启动自动 pull，冲突自动 `rebase --abort`
+- 🔒 **只读模式**：`readOnly: true` 只注册读工具，适合"手机写入、电脑只读"这类分工
 - 🩹 **索引自愈**：`index.json` 丢了会从 `notes/` 重建，不会因为一个文件损坏就丢记忆
-- 🧪 **自带冒烟测试**：`node test/smoke.mjs`，30 条断言不依赖 DSH 运行时
+- 🧪 **自带测试**：`node test/smoke.mjs`（68 条断言）+ `test/git-backend.mjs`（12 条），不依赖 DSH 运行时
+
+## 什么时候适合用它
+
+✅ 你有多台设备（手机 + 电脑），想让它们记住同一批事
+✅ 你想知道 AI 到底记住了什么（纯 Markdown，直接打开看）
+✅ 记忆要能带走、能版本管理、能自己审查
+
+❌ 你要的是单机最强检索（那去用带 BM25 / 向量库的插件）
+❌ 你要的是聊天框里的记忆面板 UI（本项目没有客户端插件）
 
 ## 两种后端
 
@@ -29,6 +46,7 @@
 | 多设备 | 各存各的 | 共享一份，自动 pull / push |
 | 依赖 | 无 | `git` 可执行文件 |
 
+
 ## 安装
 
 **方式一：npm（推荐）**
@@ -81,6 +99,11 @@ dsh plugin --profile desktop add link:/path/to/dsh-memory-github
     pushOnTurnEnd: false      # 每轮结束若有未提交改动就推送
     remindEvery: 6            # 每 N 条用户消息没动记忆 → 注入提醒（0=关）
     staleMinutes: 0           # 距上次同步超过 N 分钟 → 提示先 pull（0=关）
+    autoRecall: true          # 按当前用户消息自动召回相关归档（默认开）
+    autoRecallLimit: 5        # 自动召回最多注入几条
+    autoRecallMinScore: 4     # 自动召回打分门槛，调高更保守
+    recentLimit: 0            # 额外注入最近 N 条归档标题（0=关）
+    dedupeHint: true          # 写入时提示与已有归档高度相似
     commitMessage: 'memory: {tool}'   # {tool} 会替换成触发的工具名
     gitBin: git               # git 可执行文件（不在 PATH 就写绝对路径）
     authorName: dsh-memory

package/lib/index.js

@@ -35,6 +35,9 @@ const DEFAULTS = {
   remindEvery: 6,          // 每 N 条用户消息、且期间没动过记忆 → 提醒（0=关）
   staleMinutes: 0,         // 距上次同步超过 N 分钟 → 提醒（0=关）
   recentLimit: 0,          // 每轮额外注入最近 N 条归档的标题与标签（0=关）
+  autoRecall: true,        // 按当前用户消息自动召回相关归档并注入（不用模型主动 search）
+  autoRecallLimit: 5,      // 自动召回最多注入几条
+  autoRecallMinScore: 4,   // 自动召回打分门槛，越高越保守
   dedupeHint: true,        // 写入时检查是否与已有归档高度相似
   commitMessage: 'memory: {tool}',
   gitBin: 'git',
@@ -260,6 +263,69 @@ function recentSection(p, limit) {
   return ['', `### 最近归档（${notes.length} 条，细节用 memory_search）`, ...lines].join('\n');
 }
 
+/**
+ * 从用户消息里抽检索词：英文/数字按整词，中文按双字滑窗（中文没有空格，整句当词反而匹配不上）。
+ */
+function recallTerms(text) {
+  const terms = new Set();
+  for (const w of String(text ?? '').toLowerCase().split(/[^\p{L}\p{N}]+/u)) {
+    if (!w) continue;
+    if (/^[a-z0-9]+$/.test(w)) {
+      if (w.length > 1) terms.add(w);
+    } else {
+      for (let i = 0; i < w.length - 1; i += 1) terms.add(w.slice(i, i + 2));
+    }
+  }
+  return [...terms].slice(0, 150);
+}
+
+/**
+ * 自动召回：拿当前用户消息的词去给归档打分，注入最相关的几条。
+ * 竞品的卖点就是"不用问它就记得"，这里用纯词袋实现，不发 LLM 请求、不需要数据库。
+ */
+function autoRecallSection(p, config, query) {
+  if (config.autoRecall === false) return '';
+  const limit = Number(config.autoRecallLimit);
+  if (!Number.isFinite(limit) || limit <= 0) return '';
+  const terms = recallTerms(query);
+  if (!terms.length) return '';
+  const minScore = Number.isFinite(Number(config.autoRecallMinScore)) ? Number(config.autoRecallMinScore) : 4;
+
+  const scored = [];
+  for (const n of loadIndex(p)) {
+    const parsed = parseNoteFile(readTextSafe(join(p.notes, `${n.id}.md`), ''));
+    const title = String(n.title ?? '').toLowerCase();
+    const tags = (n.tags ?? []).join(' ').toLowerCase();
+    const body = (parsed.content ?? '').toLowerCase();
+    let score = 0;
+    for (const t of terms) {
+      if (title.includes(t)) score += 3;
+      if (tags.includes(t)) score += 2;
+      if (body.includes(t)) score += 1;
+    }
+    if (score >= minScore) scored.push({ n, score });
+  }
+  if (!scored.length) return '';
+  scored.sort((a, b) => b.score - a.score);
+  const top = scored.slice(0, Math.floor(limit));
+  const lines = top.map(({ n }) => `- \`${n.id}\` ${n.title}${(n.tags ?? []).length ? '  #' + n.tags.join(' #') : ''}`);
+  return [
+    '',
+    `### 可能与当前任务相关的归档（自动召回 ${top.length} 条，细节用 memory_read / memory_search）`,
+    ...lines,
+  ].join('\n');
+}
+
+/** 把一条 user/message 事件的 content 取成纯文本。 */
+function messageText(data) {
+  const c = data?.content;
+  if (typeof c === 'string') return c;
+  if (Array.isArray(c)) {
+    return c.map((b) => (typeof b === 'string' ? b : (b?.text ?? ''))).join('\n');
+  }
+  return '';
+}
+
 // ---------------------------------------------------------------- core 记忆
 
 function coreLimit(config) {
@@ -527,7 +593,7 @@ export function apply(ctx, config0) {
   const readOnly = Boolean(config.readOnly) || config.role === 'child';
 
   // 提醒状态：消息计数 / 最近一次记忆活动 / 最近一次成功同步
-  const syncState = { count: 0, lastActivity: activityStamp(p), lastSyncAt: Date.now() };
+  const syncState = { count: 0, lastActivity: activityStamp(p), lastSyncAt: Date.now(), lastUserText: '' };
 
   const doPull = () => {
     const r = gitPull(p, config);
@@ -576,7 +642,9 @@ export function apply(ctx, config0) {
     name: 'dsh-memory-github:core',
     order: 60,
     text: () => {
-      const base = coreSection(readCore(p), coreLimit(config)) + recentSection(p, config.recentLimit);
+      const base = coreSection(readCore(p), coreLimit(config))
+        + recentSection(p, config.recentLimit)
+        + autoRecallSection(p, config, syncState.lastUserText);
       const stamp = activityStamp(p);
       if (stamp > syncState.lastActivity) {
         // 记忆被写过（本进程写的，或别的进程/设备同步下来的），计数归零
@@ -609,6 +677,7 @@ export function apply(ctx, config0) {
       if (!event || typeof event.type !== 'string') return;
       if (event.type === 'user/message') {
         syncState.count += 1;
+        syncState.lastUserText = messageText(event.data);
       } else if (event.type === 'turn/end' && githubMode && config.pushOnTurnEnd && !readOnly) {
         enqueue(() => {
           try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-github",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Cross-session memory for DeepSeek Harness. Local memory store by default, optional GitHub-backed sync (git), with primary/child roles for multi-device setups.",
   "type": "module",
   "main": "lib/index.js",