@max-null/dsh-memory 0.2.0 → 0.2.1

package/README.md

@@ -56,6 +56,12 @@ memory_forget        →  随时删除
 
 明文还有一层**跟随仓库分享**的好处：`project` 命名空间的记忆落在项目文件夹内（`<cwd>/.dsh/storages/memory_project.json`），随 `git` 提交、分享给所有协作者；`global` 命名空间的记忆留在本地 `$DSH_HOME`。团队的共识（"本项目统一用 Vue3 `<script setup>`"）能沉淀进仓库，而不是散落在每个人的本地。FTS5 的 SQLite 二进制、向量的数字串，都无法这样"跟着仓库走"。
 
+## SSID 系列
+
+本插件属于 **`@max-null/*` 插件系列**——这一系列共同构成 **[SSID（思灵 · Seek Soul in Darkness）](https://github.com/Max-Null/seek-soul-in-darkness)** 桌面体验。SSID 是整合它们的盒：`dsh-plugin-center` · `dsh-memory` · `dsh-chinese-thinking` · `dsh-guardian` · `dsh-habit`。
+
+This plugin belongs to the **`@max-null/*` family** — a set of plugins that together form the **[SSID (思灵 · Seek Soul in Darkness)](https://github.com/Max-Null/seek-soul-in-darkness)** desktop experience.
+
 ## 开发
 
 ```bash

package/dist/engine.d.ts

@@ -74,8 +74,17 @@ export declare class MemoryEngine extends Service {
     static inject: string[];
     private globalTable?;
     private projectTable?;
+    private facility?;
     constructor(ctx: import('@deepseek-ai/cordis').Context, config?: MemoryConfig);
     protected [Service.init](): Promise<void>;
+    /** 打开两个存储域（init 与 reload 共用）。 */
+    private openDomains;
+    /**
+     * 强制重载存储：关闭两域后重开，放弃内存缓存重读文件。
+     * 供外部编辑记忆文件后刷新（JsonStorageBackend 打开时加载一次，
+     * 无 watch——2026-08-19 用户实测面板不感知外部编辑）。
+     */
+    reload(): Promise<void>;
     /** Create one record in `suggested` status — never self-promoting. */
     remember(input: MemoryWrite): Promise<MemoryRecord>;
     list(filter?: MemoryFilter): MemoryRecord[];

package/dist/engine.js

@@ -52,11 +52,17 @@ export class MemoryEngine extends Service {
     static inject = ['storage'];
     globalTable;
     projectTable;
+    facility;
     constructor(ctx, config = {}) {
         super(ctx, 'memory');
         this.config = config;
     }
     async [Service.init]() {
+        await this.openDomains();
+        this.ctx.effect(() => () => { void this.facility?.closeAll(); }, 'memory.domainsClose');
+    }
+    /** 打开两个存储域（init 与 reload 共用）。 */
+    async openDomains() {
         const globalBackend = new JsonStorageBackend(this.config.globalRoot ?? globalRoot());
         const projectBackend = new JsonStorageBackend(this.config.projectRoot ?? projectRoot());
         this.ctx.storage.backend.register('memory-global', globalBackend);
@@ -67,10 +73,19 @@ export class MemoryEngine extends Service {
         });
         const globalDomain = await facility.open(memorySpec('memory'));
         const projectDomain = await facility.open(memorySpec('memory_project'));
-        this.ctx.effect(() => () => { void facility.closeAll(); }, 'memory.domainsClose');
+        this.facility = facility;
         this.globalTable = globalDomain.table('blocks');
         this.projectTable = projectDomain.table('blocks');
     }
+    /**
+     * 强制重载存储：关闭两域后重开，放弃内存缓存重读文件。
+     * 供外部编辑记忆文件后刷新（JsonStorageBackend 打开时加载一次，
+     * 无 watch——2026-08-19 用户实测面板不感知外部编辑）。
+     */
+    async reload() {
+        await this.facility?.closeAll();
+        await this.openDomains();
+    }
     /** Create one record in `suggested` status — never self-promoting. */
     async remember(input) {
         const namespace = input.namespace ?? 'global';

package/dist/index.js

@@ -6,6 +6,7 @@
  */
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { MemoryEngine } from "./engine.js";
+import { MemoryGateway } from "./remote.js";
 export { MemoryEngine } from "./engine.js";
 export { MemoryId } from "./engine.js";
 export { bm25Scores, tokenize } from "./bm25.js";
@@ -65,6 +66,7 @@ function present(title, kind, rawInput) {
 }
 export async function apply(ctx, config) {
     await ctx.plugin(MemoryEngine, config);
+    await ctx.plugin(MemoryGateway);
     const memory = ctx.get('memory');
     if (memory === undefined)
         throw new Error('memory engine failed to register');

package/dist/remote.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `MemoryGateway` — Typert Remote projection of the memory service, so a Web
+ * client can browse, search, confirm, and forget memories through `remote.memory`.
+ *
+ * Read-only except for the two human-owned mutations (`confirm` promotes a
+ * `suggested` record to `auto`; `forget` deletes one). It owns no storage or
+ * state — every call delegates to the process-local `ctx.memory` engine.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { MemoryFilter, MemoryHit, MemoryRecord } from './engine.ts';
+/** Client-callable memory surface; registered as the `memory` Typert namespace. */
+export declare class MemoryGateway extends TypertRemoteService {
+    static inject: string[];
+    constructor(ctx: Context);
+    /** List every stored memory, optionally filtered by namespace or status. */
+    list(filter?: MemoryFilter): MemoryRecord[];
+    /** Recall memories by keyword; deterministic literal matching. */
+    search(query: string, filter?: MemoryFilter): MemoryHit[];
+    /** Confirm a suggested memory so it becomes effective (`auto`). */
+    confirm(id: string): Promise<MemoryRecord>;
+    /** Delete one stored memory by id. */
+    forget(id: string): Promise<boolean>;
+}
+export default MemoryGateway;

package/dist/remote.js

@@ -0,0 +1,92 @@
+/**
+ * `MemoryGateway` — Typert Remote projection of the memory service, so a Web
+ * client can browse, search, confirm, and forget memories through `remote.memory`.
+ *
+ * Read-only except for the two human-owned mutations (`confirm` promotes a
+ * `suggested` record to `auto`; `forget` deletes one). It owns no storage or
+ * state — every call delegates to the process-local `ctx.memory` engine.
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { TypertRemoteService, Remote } from '@deepseek-ai/dsh-typert-protocol';
+import { MemoryId } from "./engine.js";
+/** Client-callable memory surface; registered as the `memory` Typert namespace. */
+let MemoryGateway = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _list_decorators;
+    let _search_decorators;
+    let _confirm_decorators;
+    let _forget_decorators;
+    return class MemoryGateway extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _list_decorators = [Remote('list')];
+            _search_decorators = [Remote('search')];
+            _confirm_decorators = [Remote('confirm')];
+            _forget_decorators = [Remote('forget')];
+            __esDecorate(this, null, _list_decorators, { kind: "method", name: "list", static: false, private: false, access: { has: obj => "list" in obj, get: obj => obj.list }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _search_decorators, { kind: "method", name: "search", static: false, private: false, access: { has: obj => "search" in obj, get: obj => obj.search }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _confirm_decorators, { kind: "method", name: "confirm", static: false, private: false, access: { has: obj => "confirm" in obj, get: obj => obj.confirm }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _forget_decorators, { kind: "method", name: "forget", static: false, private: false, access: { has: obj => "forget" in obj, get: obj => obj.forget }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static inject = ['memory'];
+        constructor(ctx) {
+            // Service key 'memoryRemote' avoids colliding with MemoryEngine's 'memory';
+            // the wire namespace stays 'memory' so clients call `remote.memory.*`.
+            super(ctx, 'memoryRemote', { namespace: 'memory' });
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        /** List every stored memory, optionally filtered by namespace or status. */
+        list(filter) {
+            return this.ctx.memory.list(filter);
+        }
+        /** Recall memories by keyword; deterministic literal matching. */
+        search(query, filter) {
+            return this.ctx.memory.search(query, filter);
+        }
+        /** Confirm a suggested memory so it becomes effective (`auto`). */
+        confirm(id) {
+            return this.ctx.memory.setStatus(MemoryId(id), 'auto');
+        }
+        /** Delete one stored memory by id. */
+        forget(id) {
+            return this.ctx.memory.forget(MemoryId(id));
+        }
+    };
+})();
+export { MemoryGateway };
+export default MemoryGateway;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max-null/dsh-memory",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Cross-session plaintext memory plugin for the DeepSeek Harness — deterministic BM25 recall, human-owned, no embeddings",
   "license": "MIT",
   "publishConfig": {
@@ -53,7 +53,8 @@
     "@deepseek-ai/dsh-storage-domain": ">=0.0.1-rc.1",
     "@deepseek-ai/dsh-storage-json": ">=0.0.1-rc.1",
     "@deepseek-ai/dsh-system-prompt": ">=0.0.1-rc.1",
-    "@deepseek-ai/dsh-tools": ">=0.0.1-rc.1"
+    "@deepseek-ai/dsh-tools": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-typert-protocol": ">=0.0.1-rc.5"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
@@ -63,6 +64,7 @@
     "@deepseek-ai/dsh-storage-json": ">=0.0.1-rc.1",
     "@deepseek-ai/dsh-system-prompt": ">=0.0.1-rc.1",
     "@deepseek-ai/dsh-tools": ">=0.0.1-rc.1",
+    "@deepseek-ai/dsh-typert-protocol": ">=0.0.1-rc.5",
     "@types/node": "^26.2.0",
     "tsx": "^4.0.0",
     "typescript": "^5.5.0",