@furongjun1999/dsh-memory 0.2.0 → 0.2.1

package/README.md

@@ -9,7 +9,7 @@
 
 ## 特性
 
-- **工具桥接**：Agent 可直接调用 `lingxu_remember / recall / search / think` 等灵枢能力
+- **工具桥接**：Agent 可直接调用 `lingshu_remember / recall / search / think` 等灵枢能力
   （默认精选 12 个核心工具，可切换全部或自定义集合）
 - **自动记忆**：DSH 对话自动沉淀进灵枢记忆库——用户消息带重要性写入、去重，随会话累积
 - **动态 schema**：工具清单运行时从灵枢 `tools/list` 实时拉取，灵枢升级新增工具 DSH 侧零改动
@@ -22,7 +22,7 @@
 ┌─────────────────────────────────────────────┐
 │ DeepSeek Harness (cordis)                    │
 │                                             │
-│  Agent Loop ──┬── lingxu_remember/recall…   │
+│  Agent Loop ──┬── lingshu_remember/recall…   │
 │               │   (ctx.tools 注册)           │
 │  session/event│                              │
 │  (自动记忆钩子)│                              │
@@ -70,10 +70,10 @@ dsh plugin --profile <name> add <本插件本地路径或 git 地址>
 在 profile 的 `cordis.yml`（或 `cordis.patch.yml`）中追加：
 
 ```yaml
-- id: lingxu-memory
+- id: lingshu-memory
   name: '@furongjun1999/dsh-memory'
   config:
-    dbPath: 'D:/data/lingxu.db'        # 灵枢记忆库路径（目录自动创建）
+    dbPath: 'D:/data/lingshu.db'        # 灵枢记忆库路径（目录自动创建）
     identity: '灵枢'
     tools: 'core'
     memory:
@@ -90,10 +90,10 @@ dsh plugin --profile <name> add <本插件本地路径或 git 地址>
 
 | 字段 | 类型 | 默认值 | 说明 |
 |------|------|--------|------|
-| `serverName` | string | `lingxu` | 工具命名空间前缀（工具名 `lingxu_<name>`） |
+| `serverName` | string | `lingshu` | 工具命名空间前缀（工具名 `lingshu_<name>`） |
 | `python` | string | `python` | Python 可执行文件 |
 | `moduleArgs` | string[] | `['-m', 'aeis.mcp.server']` | 灵枢 server 启动参数 |
-| `dbPath` | string | `data/lingxu.db` | 记忆库 SQLite 路径（自动建目录） |
+| `dbPath` | string | `data/lingshu.db` | 记忆库 SQLite 路径（自动建目录） |
 | `identity` | string | `灵枢` | 灵枢身份标识 |
 | `env` | object | `{}` | 追加环境变量（`BOCHA_API_KEY` / `AEIS_DESIGNER_KEY`…） |
 | `tools` | `'core' \| 'all' \| string[]` | `'core'` | 暴露的工具集合 |
@@ -109,18 +109,18 @@ dsh plugin --profile <name> add <本插件本地路径或 git 地址>
 
 | 工具 | 说明 |
 |------|------|
-| `lingxu_remember` | 写入记忆（内容/重要性/标签/实体） |
-| `lingxu_recall` | 组合联想召回（相似+重要性+近因加权） |
-| `lingxu_search` | 内容检索（二元组 Jaccard） |
-| `lingxu_timeline` | 记忆时间线 |
-| `lingxu_think` | 推理前记忆注入（检索相关记忆构造上下文） |
-| `lingxu_relate` | 建立关系边（causal/similar/sequential…） |
-| `lingxu_predict_routes` | 生成式预测（未来路线集合） |
-| `lingxu_ingest_text` | 外部知识摄取（文本） |
-| `lingxu_ingest_url` | URL 页面摄取 |
-| `lingxu_session_note` | 会话要点外部化 |
-| `lingxu_self_check` | 完整性自检 |
-| `lingxu_service_info` | 灵枢服务状态 |
+| `lingshu_remember` | 写入记忆（内容/重要性/标签/实体） |
+| `lingshu_recall` | 组合联想召回（相似+重要性+近因加权） |
+| `lingshu_search` | 内容检索（二元组 Jaccard） |
+| `lingshu_timeline` | 记忆时间线 |
+| `lingshu_think` | 推理前记忆注入（检索相关记忆构造上下文） |
+| `lingshu_relate` | 建立关系边（causal/similar/sequential…） |
+| `lingshu_predict_routes` | 生成式预测（未来路线集合） |
+| `lingshu_ingest_text` | 外部知识摄取（文本） |
+| `lingshu_ingest_url` | URL 页面摄取 |
+| `lingshu_session_note` | 会话要点外部化 |
+| `lingshu_self_check` | 完整性自检 |
+| `lingshu_service_info` | 灵枢服务状态 |
 
 配置 `tools: 'all'` 可暴露全部 38 个工具（含视觉/自我认知/设计者裁决等）。
 

package/cordis.yml.example

@@ -5,14 +5,14 @@
 # - !!js process.env.X 语法在加载期求值，密钥不入库
 # - dbPath 建议用绝对路径；目录不存在会自动创建
 
-- id: lingxu-memory
+- id: lingshu-memory
   name: '@furongjun1999/dsh-memory'
   config:
-    # 工具命名空间：Agent 看到的工具名是 lingxu_remember / lingxu_recall ...
-    serverName: 'lingxu'
+    # 工具命名空间：Agent 看到的工具名是 lingshu_remember / lingshu_recall ...
+    serverName: 'lingshu'
 
     # 灵枢记忆库持久化路径（SQLite）
-    dbPath: 'D:/data/lingxu.db'
+    dbPath: 'D:/data/lingshu.db'
 
     # 灵枢身份标识
     identity: '灵枢'
@@ -42,10 +42,10 @@
     failOnStartupError: false
 
 # 多实例示例：第二个灵枢（不同记忆库/身份/命名空间）
-# - id: lingxu-memory-2
+# - id: lingshu-memory-2
 #   name: '@furongjun1999/dsh-memory'
 #   config:
-#     serverName: 'lingxu2'
-#     dbPath: 'D:/data/lingxu2.db'
+#     serverName: 'lingshu2'
+#     dbPath: 'D:/data/lingshu2.db'
 #     identity: '灵枢二号'
 #     tools: ['remember', 'recall']

package/lib/bridge.d.ts

@@ -36,7 +36,7 @@ export interface BridgeOptions {
     /** 断线重连的最大间隔（毫秒），默认 30s。 */
     maxRetryDelayMs: number;
 }
-export declare class LingxuBridge {
+export declare class LingshuBridge {
     private readonly options;
     private proc;
     private rl;

package/lib/bridge.js

@@ -10,7 +10,7 @@ import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
-export class LingxuBridge {
+export class LingshuBridge {
     options;
     proc = null;
     rl = null;
@@ -102,7 +102,7 @@ export class LingxuBridge {
             // stderr 透传日志（灵枢把日志写在 stderr，避免污染协议流）
             const text = chunk.toString('utf8').trim();
             if (text)
-                console.error(`[lingxu-bridge] ${text}`);
+                console.error(`[lingshu-bridge] ${text}`);
         });
         this.rl.on('line', (line) => {
             if (!line.trim())
@@ -112,7 +112,7 @@ export class LingxuBridge {
                 msg = JSON.parse(line);
             }
             catch {
-                console.error(`[lingxu-bridge] 非 JSON 输出: ${line.slice(0, 200)}`);
+                console.error(`[lingshu-bridge] 非 JSON 输出: ${line.slice(0, 200)}`);
                 return;
             }
             if (typeof msg['id'] === 'number') {
@@ -122,14 +122,14 @@ export class LingxuBridge {
         proc.on('error', (err) => {
             // 进程无法启动（python 不存在等）——响亮失败
             if (!this.disposed) {
-                console.error(`[lingxu-bridge] 灵枢进程启动失败: ${err.message}`);
+                console.error(`[lingshu-bridge] 灵枢进程启动失败: ${err.message}`);
                 this.readyState = 'failed';
                 this.flushBootQueue(false);
                 this.scheduleRetry();
             }
         });
         proc.on('exit', (code, signal) => {
-            console.error(`[lingxu-bridge] 灵枢进程退出 code=${code} signal=${signal}`);
+            console.error(`[lingshu-bridge] 灵枢进程退出 code=${code} signal=${signal}`);
             this.rl?.close();
             this.rl = null;
             this.rejectAll(new Error(`灵枢进程已退出（code=${code} signal=${signal ?? 'none'}）`));
@@ -157,7 +157,7 @@ export class LingxuBridge {
         }
         catch (err) {
             if (!this.disposed) {
-                console.error(`[lingxu-bridge] 握手失败: ${err.message}`);
+                console.error(`[lingshu-bridge] 握手失败: ${err.message}`);
                 this.readyState = 'failed';
                 this.flushBootQueue(false);
                 this.scheduleRetry();

package/lib/hooks.d.ts

@@ -7,7 +7,7 @@
  */
 import '@deepseek-ai/dsh-session';
 import type { Context } from '@deepseek-ai/cordis';
-import type { LingxuBridge } from './bridge.js';
+import type { LingshuBridge } from './bridge.js';
 /** 自动记忆开关。 */
 export interface MemoryHooksOptions {
     /** 用户消息 → remember（默认 true）。 */
@@ -20,4 +20,4 @@ export interface MemoryHooksOptions {
     importance: number;
 }
 /** 安装自动记忆钩子（effect 作用域内，随插件卸载自动移除）。 */
-export declare function installMemoryHooks(ctx: Context, bridge: LingxuBridge, opts: MemoryHooksOptions): void;
+export declare function installMemoryHooks(ctx: Context, bridge: LingshuBridge, opts: MemoryHooksOptions): void;

package/lib/index.d.ts

@@ -2,15 +2,15 @@
  * @furongjun1999/dsh-memory —— 灵枢（AEIS）DeepSeek Harness 插件
  *
  * 把灵枢的时空记忆/知识飞轮/自我认知接入 DSH：
- * - 工具桥接：Agent 可调用 lingxu_remember / recall / search / think 等
+ * - 工具桥接：Agent 可调用 lingshu_remember / recall / search / think 等
  * - 自动记忆：DSH 对话自动沉淀进灵枢记忆库（去重+重要性）
  *
  * 用法（cordis.yml）：
  * ```yaml
- * - id: lingxu-memory
+ * - id: lingshu-memory
  *   name: '@furongjun1999/dsh-memory'
  *   config:
- *     dbPath: 'D:/path/to/lingxu.db'
+ *     dbPath: 'D:/path/to/lingshu.db'
  *     identity: '灵枢'
  *     memory:
  *       userMessage: true
@@ -25,7 +25,7 @@ export declare const name = "dsh-memory";
 export declare const inject: string[];
 /** 插件配置。 */
 export interface Config {
-    /** 工具命名空间前缀（默认 lingxu → lingxu_remember）。 */
+    /** 工具命名空间前缀（默认 lingshu → lingshu_remember）。 */
     serverName: string;
     /** Python 可执行文件（或 aeis-mcp console script）。 */
     python: string;

package/lib/index.js

@@ -2,32 +2,32 @@
  * @furongjun1999/dsh-memory —— 灵枢（AEIS）DeepSeek Harness 插件
  *
  * 把灵枢的时空记忆/知识飞轮/自我认知接入 DSH：
- * - 工具桥接：Agent 可调用 lingxu_remember / recall / search / think 等
+ * - 工具桥接：Agent 可调用 lingshu_remember / recall / search / think 等
  * - 自动记忆：DSH 对话自动沉淀进灵枢记忆库（去重+重要性）
  *
  * 用法（cordis.yml）：
  * ```yaml
- * - id: lingxu-memory
+ * - id: lingshu-memory
  *   name: '@furongjun1999/dsh-memory'
  *   config:
- *     dbPath: 'D:/path/to/lingxu.db'
+ *     dbPath: 'D:/path/to/lingshu.db'
  *     identity: '灵枢'
  *     memory:
  *       userMessage: true
  * ```
  */
 import z from '@deepseek-ai/schemastery';
-import { LingxuBridge } from './bridge.js';
-import { registerLingxuTools } from './tools.js';
+import { LingshuBridge } from './bridge.js';
+import { registerLingshuTools } from './tools.js';
 import { installMemoryHooks } from './hooks.js';
 export const name = 'dsh-memory';
 /** 本插件依赖的工具注册服务。 */
 export const inject = ['tools'];
 export const Config = z.object({
-    serverName: z.string().default('lingxu'),
+    serverName: z.string().default('lingshu'),
     python: z.string().default('python'),
     moduleArgs: z.array(String).default(['-m', 'aeis.mcp.server']),
-    dbPath: z.string().default('data/lingxu.db'),
+    dbPath: z.string().default('data/lingshu.db'),
     identity: z.string().default('灵枢'),
     env: z.dict(String).default({}),
     tools: z.union([z.const('core'), z.const('brain'), z.const('all'), z.array(String)]).default('brain'),
@@ -53,7 +53,7 @@ export async function apply(ctx, config) {
     // 宪章宣告（接入即接受宪章约束——docs/guardrail-charter.md v2.0-published）
     ctx.logger.info(`dsh-memory: 灵枢插件激活（大脑模式）· 接受护栏宪章 ${config.charter} —— ` +
         '接入即接受宪章约束（公开/可执行/可审计/设计者终裁）');
-    const bridge = new LingxuBridge({
+    const bridge = new LingshuBridge({
         python: config.python,
         args: config.moduleArgs,
         env: {
@@ -76,7 +76,7 @@ export async function apply(ctx, config) {
     try {
         // 工具注册（就绪后执行；未就绪时 tools/list 会报错，由重连机制兜底）
         if (ready) {
-            disposers.push(await registerLingxuTools(ctx, bridge, {
+            disposers.push(await registerLingshuTools(ctx, bridge, {
                 selection: config.tools,
                 toolPrefix: `${config.serverName}_`,
             }));

package/lib/tools.d.ts

@@ -6,7 +6,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import { type ParameterSchemaSpec } from '@deepseek-ai/dsh-tools';
-import type { LingxuBridge } from './bridge.ts';
+import type { LingshuBridge } from './bridge.ts';
 /** 默认暴露的核心工具集合（记忆/推理/摄取/元认知）。 */
 export declare const CORE_TOOLS: readonly ["remember", "recall", "search", "timeline", "think", "relate", "predict_routes", "ingest_text", "ingest_url", "session_note", "self_check", "service_info"];
 /**
@@ -28,7 +28,7 @@ export declare function extractText(content: Array<{
     [key: string]: unknown;
 }>): string;
 /** 注册灵枢工具到 ctx.tools；返回取消注册函数。 */
-export declare function registerLingxuTools(ctx: Context, bridge: LingxuBridge, opts: {
+export declare function registerLingshuTools(ctx: Context, bridge: LingshuBridge, opts: {
     selection: ToolSelection;
     toolPrefix: string;
 }): Promise<() => void>;

package/lib/tools.js

@@ -121,7 +121,7 @@ export function extractText(content) {
         .join('\n');
 }
 /** 注册灵枢工具到 ctx.tools；返回取消注册函数。 */
-export async function registerLingxuTools(ctx, bridge, opts) {
+export async function registerLingshuTools(ctx, bridge, opts) {
     const tools = await bridge.listTools();
     const wanted = new Set(selectTools(tools.map((t) => t.name), opts.selection));
     const disposers = [];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@furongjun1999/dsh-memory",
-  "version": "0.2.0",
-  "description": "灵枢（AEIS）DeepSeek Harness 插件：把灵枢的时空记忆/知识飞轮/自我认知接入 DSH，对话自动沉淀进记忆库",
+  "version": "0.2.1",
+  "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进记忆库",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -24,7 +24,7 @@
     "memory",
     "agent",
     "aeis",
-    "lingxu"
+    "lingshu"
   ],
   "license": "MIT",
   "peerDependencies": {