dsh-prime-memory 0.22.2 → 0.24.1

package/dist/util/md-normalize.js

@@ -0,0 +1,131 @@
+/**
+ * 记忆正文的 markdown 版式归一（P4.2「格式需要标准化」）。
+ *
+ * 只做**版式**，不做**语义**：不 bullet 化散文、不插 H1、不往正文里塞元数据（元数据一律在
+ * frontmatter）。三条理由：
+ * - 散文转列表会把"因为/所以/但是"这类连接关系拆散，且拆完不可逆；
+ * - 正文一旦带骨架，`parseMdFile` 的往返一致性（P2）就得反向剪枝，两套逻辑必然漂移；
+ * - 归一结果要进 `renderRecord`（导出）与回灌（入库）两头，任何有损改写都会被写进库。
+ *
+ * **幂等是硬要求**：`f(f(x)) === f(x)`。不幂等的话账本 `fileDigest` 每轮都变，反向同步
+ * 永远判"文件被改过"，写回环打不完——那正是 P2 用例钉死的那条性质。
+ *
+ * 刻意不用正则与转义写法：同仓产物里出现过 `\n` 被展开成真实换行、把正则字面量截断的事，
+ * 所以这里全部走字符码与字符串切片，形状只依赖文件真实结构。
+ */
+const NL = String.fromCharCode(10);
+const TAB = String.fromCharCode(9);
+const FENCE_BACKTICK = String.fromCharCode(96, 96, 96);
+const FENCE_TILDE = String.fromCharCode(126, 126, 126);
+/** 无序列表的等价符号：统一成 `- `（有序列表**不动**，`1. 2. 3.` 自带语义顺序）。 */
+const BULLETS = ['*', '+', '·', '•'];
+/** 行首缩进宽度（只数空格；tab 缩进按 1 计，不做宽度换算——换算就不是幂等的了）。 */
+function indentWidth(line) {
+    let i = 0;
+    while (i < line.length && (line.charAt(i) === ' ' || line.charAt(i) === TAB))
+        i += 1;
+    return i;
+}
+/** 行尾收口：尾部空白里空格 ≥2 视为 markdown 硬换行，压成恰好两个；单个尾随空格与所有尾随 tab 去掉。 */
+function settleEol(line) {
+    let i = line.length;
+    while (i > 0 && (line.charAt(i - 1) === ' ' || line.charAt(i - 1) === TAB))
+        i -= 1;
+    const core = line.slice(0, i);
+    const trail = line.slice(i);
+    let spaces = 0;
+    for (const c of trail)
+        if (c === ' ')
+            spaces += 1;
+    return spaces >= 2 ? `${core}  ` : core;
+}
+/** 无序列表符号归一（只认"符号 + 一个空格"的规范写法，避免把 `*` 强调语法当列表改了）。 */
+function settleBullet(line) {
+    const w = indentWidth(line);
+    const head = line.slice(0, w);
+    const rest = line.slice(w);
+    for (const b of BULLETS) {
+        if (rest.startsWith(`${b} `) || rest.startsWith(b + TAB))
+            return `${head}-${rest.slice(1)}`;
+    }
+    return line;
+}
+/** 标题行的前导空白去掉（`  # 标题` → `# 标题`）；列表项内的 `#` 不算标题（那多半是内容）。 */
+function settleHeading(line) {
+    if (indentWidth(line) === 0)
+        return line;
+    const rest = line.slice(indentWidth(line));
+    return rest.startsWith('#') ? rest : line;
+}
+/**
+ * 归一一段记忆正文。
+ *
+ * @param text - 原始正文（可含 CRLF、BOM、任意尾随空白）。
+ * @returns 版式归一后的正文：**无**前导/尾随空行、段落间恰好一个空行、围栏内（含 delimiter）
+ *          逐字保留、无末尾换行（渲染器自己控制）。
+ */
+export function normalizeContentMd(text) {
+    // ① 换行统一：BOM 去掉，CRLF/CR → LF。这一步之后再按 LF 切。
+    let src = text;
+    // BOM
+    if (src.charCodeAt(0) === 0xfeff)
+        src = src.slice(1);
+    // CRLF → LF（逐字符扫，避开转义写法）
+    let flat = '';
+    for (let i = 0; i < src.length; i += 1) {
+        const c = src.charAt(i);
+        if (c === String.fromCharCode(13)) {
+            // CR 无论后面是不是 LF 都必须落一个 LF：只进 `i += 1` 不写 `flat` 会把换行直接吞掉
+            // （自家幂等用例抓到的第一个真 bug：`甲\r\n乙` 变成 `甲乙`，段落边界就这么没了）。
+            if (src.charAt(i + 1) === NL)
+                i += 1; // CR LF → 吃掉 CR，只留下面那个 LF
+            flat += NL;
+            continue;
+        }
+        flat += c;
+    }
+    const lines = flat.split(NL);
+    const out = [];
+    let inFence = false;
+    let fenceMark = '';
+    let blanks = 0;
+    for (const raw of lines) {
+        const pre = raw.slice(indentWidth(raw));
+        const isFence = pre.startsWith(FENCE_BACKTICK) || pre.startsWith(FENCE_TILDE);
+        if (isFence) {
+            const mark = pre.startsWith(FENCE_BACKTICK) ? FENCE_BACKTICK : FENCE_TILDE;
+            if (!inFence) {
+                inFence = true;
+                fenceMark = mark;
+            }
+            else if (mark === fenceMark) {
+                inFence = false;
+                fenceMark = '';
+            }
+            // 围栏 delimiter 行就是版式的一部分：原样落盘，连行尾收口也不做
+            blanks = 0;
+            out.push(raw);
+            continue;
+        }
+        if (inFence) {
+            // 围栏内的行逐字保留：代码里的缩进、`*` 号、行尾双空格都可能是有意为之
+            blanks = 0;
+            out.push(raw);
+            continue;
+        }
+        let line = settleBullet(settleHeading(settleEol(raw)));
+        if (line.trim().length === 0) {
+            blanks += 1;
+            // 空行只在已有内容时才可能保留，且最多一个
+            if (out.length > 0 && blanks === 1)
+                out.push('');
+            continue;
+        }
+        blanks = 0;
+        out.push(line);
+    }
+    // ③ 末尾无换行：渲染器负责补，正文本体不带（否则 digest 会随写法抖动）。
+    while (out.length > 0 && out[out.length - 1] === '')
+        out.pop();
+    return out.join(NL);
+}

package/dist/workspace-route.d.ts

@@ -0,0 +1,22 @@
+/** 一条路由规则。 */
+export interface WorkspaceRoute {
+    /** 命中后归到的 workspace（绝对路径；返回值已归一）。 */
+    path: string;
+    /** 命中任一关键词即归此路（大小写不敏感、已 NFKC 归一的子串匹配）。 */
+    anyOf: readonly string[];
+    /** 出现任一排除词则**此路**不命中（继续往下看下一条规则）。 */
+    noneOf?: readonly string[];
+}
+/**
+ * 按序取首个命中；全不命中返回 `undefined`（**宁缺勿猜**——归错 workspace 会让记忆在
+ * 错误的工作区可见/不可见，比不归更难查）。
+ *
+ * 排序即优先级：调用方给的表里 dsh 侧在前，故"同一段内容既谈 Hanako 又谈 dsh"会归 dsh
+ * 一侧（用户口径）；非 dsh 那条同时带 `noneOf: ['dsh']` 做二次保险。
+ */
+export declare function routeWorkspace(text: string, routes: readonly WorkspaceRoute[]): string | undefined;
+/**
+ * 路由结论与来源链结论**矛盾**时返回 true（来源链仅作交叉验证）。
+ * 单独抽出是为了把"冲突要可观测"这条判据变成可测函数，而不是散在调用点的 if 里。
+ */
+export declare function routeConflictsWithProvenance(routed: string | undefined, provenance: string | undefined): boolean;

package/dist/workspace-route.js

@@ -0,0 +1,66 @@
+/**
+ * 记忆的 **内容路由**（workspace 归属）：按「这条记忆谈到哪个项目」给出归属路径。
+ *
+ * ## 为什么不是「来源会话反查」
+ * 直觉做法是顺着 L1 → 来源会话 → 会话的工作目录往回推。实测三处都断：
+ * - `l1_records.session_id` 恒为 `'default'`（蒸馏写入时用的是后台自己的会话标识，
+ *   与来源对话无关）；
+ * - `metadata.dsh_source_anchors` 里确实带 `sessionId`，但锚点覆盖率仅 69%，且其中
+ *   能在磁盘会话树（`~/.dsh/sessions/<slug>/<uuid>`）找到目录的只有 **7.3%**——
+ *   会话树会被清理/隔离，不能当持久事实源；
+ * - L1 的 `timestamp_str` 与 L0 的 `recorded_at` / `timestamp` 两列**零命中**
+ *   （L1 时间戳来自抽取回显，不是消息元数据）。
+ *
+ * 内容路由不受这些缺失影响：**内容自己说它属于哪个项目**。这也与人的归类习惯一致
+ * （谈 dsh 生态的收到 dsh 项目下，谈 Hanako/inferglow 且与 dsh 无关的收到另一个项目）。
+ *
+ * ## 只写归属列，不动可见性
+ * 返回值只用于填 `l1_records.workspace_id`；**`scope` 一律不改**。
+ * 理由：`resolveRecordScope` 规则③ 刻意在 `cfg.scope='global'` 时不写归属，以保证既有
+ * 部署零漂移；而检索可见性判据是 `scope` + `workspace_id` 的组合（`isScopeVisible`），
+ * 单改 `workspace_id` 在 `scope='global'` 下不产生任何过滤差异。
+ * 所以本路由是「**先把事实存下来**」：将来真启用 workspace 围栏时它是现成的正确依据，
+ * 今天则一行行为都不改变。
+ */
+import { normalizeWorkspacePath } from './workspace.js';
+/** 归一：NFKC + 小写 + 空白折叠（与 `memport/format.normText` 同口径，不另造一套）。 */
+function norm(s) {
+    return s.normalize('NFKC').toLowerCase().replace(/\s+/g, ' ').trim();
+}
+/**
+ * 按序取首个命中；全不命中返回 `undefined`（**宁缺勿猜**——归错 workspace 会让记忆在
+ * 错误的工作区可见/不可见，比不归更难查）。
+ *
+ * 排序即优先级：调用方给的表里 dsh 侧在前，故"同一段内容既谈 Hanako 又谈 dsh"会归 dsh
+ * 一侧（用户口径）；非 dsh 那条同时带 `noneOf: ['dsh']` 做二次保险。
+ */
+export function routeWorkspace(text, routes) {
+    const hay = norm(text);
+    if (hay.length === 0)
+        return undefined;
+    for (const route of routes) {
+        const target = typeof route.path === 'string' ? route.path.trim() : '';
+        if (target.length === 0)
+            continue;
+        const excluded = (route.noneOf ?? []).some((word) => word.length > 0 && hay.includes(norm(word)));
+        if (excluded)
+            continue;
+        const hit = (route.anyOf ?? []).some((word) => word.length > 0 && hay.includes(norm(word)));
+        if (!hit)
+            continue;
+        // 归一失败（空串/非法路径）时**不写**：路由表写错不该污染归属列。
+        const normalized = normalizeWorkspacePath(target);
+        if (normalized)
+            return normalized;
+    }
+    return undefined;
+}
+/**
+ * 路由结论与来源链结论**矛盾**时返回 true（来源链仅作交叉验证）。
+ * 单独抽出是为了把"冲突要可观测"这条判据变成可测函数，而不是散在调用点的 if 里。
+ */
+export function routeConflictsWithProvenance(routed, provenance) {
+    if (!routed || !provenance)
+        return false;
+    return normalizeWorkspacePath(routed) !== normalizeWorkspacePath(provenance);
+}

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.22.2",
+  "version": "0.24.1",
   "description": {
     "en": "Layered distilled memory plugin (L0 capture → L1 atomic memory → L2 scenes → L3 persona) with automatic recall injection before each model step.",
     "zh": "L0~L3 分层蒸馏记忆插件:自动捕获对话、抽取原子记忆、整合场景块、蒸馏核心画像,并在模型步骤前自动召回注入。"

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.22.2",
+  "version": "0.24.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
-    "tag": "dsh-0.2.0"
+    "tag": "latest"
   },
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
@@ -77,6 +77,7 @@
   "author": "drscrewdriver <597093681@qq.com>",
   "license": "MIT",
   "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.4",
     "@node-rs/jieba": "^2.0.2",
     "sqlite-vec": "^0.1.7-alpha.2",
     "undici": "^7.29.0"
@@ -125,16 +126,17 @@
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
     "@deepseek-ai/cordis-plugin-loader": "^1.0.5",
+    "@deepseek-ai/cosmokit": "1.8.5",
     "@deepseek-ai/dsh-agent": "0.2.0-rc.1",
     "@deepseek-ai/dsh-agent-default-model": "0.2.0-rc.1",
     "@deepseek-ai/dsh-client-connection": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-compaction": "0.2.0-rc.1",
     "@deepseek-ai/dsh-home-paths": "0.2.0-rc.1",
     "@deepseek-ai/dsh-llm": "0.2.0-rc.1",
     "@deepseek-ai/dsh-session": "0.2.0-rc.1",
     "@deepseek-ai/dsh-settings": "0.2.0-rc.1",
     "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.1",
     "@deepseek-ai/dsh-tools": "0.2.0-rc.1",
-    "@deepseek-ai/schemastery": "^3.18.4",
     "@eslint/js": "^10.0.1",
     "@types/node": "^22.0.0",
     "@types/react": "^19.2.18",
@@ -143,7 +145,6 @@
     "globals": "^17.12.0",
     "typescript": "^5.6.0",
     "typescript-eslint": "^8.69.0",
-    "vitest": "^4.1.11",
-    "@deepseek-ai/dsh-compaction": "0.2.0-rc.1"
+    "vitest": "^4.1.11"
   }
 }