@modusensus/dsh-mneme 0.1.3 → 0.1.5

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![dsh-plugin](https://img.shields.io/badge/dsh-plugin-awesome-orange)](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)
-[![tests](https://img.shields.io/badge/tests-108%20passed-success)](https://github.com/modusensus/dsh-mneme)
+[![tests](https://img.shields.io/badge/tests-129%20passed-success)](https://github.com/modusensus/dsh-mneme)
 
 > 给 DeepSeek Harness 的跨会话记忆插件：让 Agent 记住你、记住项目、自动整理记忆。**Mneme**（Μνήμη）——希腊记忆女神 Mnemosyne 之名，掌管记忆与梦境，正如 autoDream 在后台巩固记忆。
 
@@ -47,6 +47,16 @@
 
 侧边栏"记忆"按钮 → 模态面板：按类型浏览、全文搜索、查看详情。
 
+### 用户设置（画像 / 规则）与自定义指令 ⚙️
+
+侧边栏"设置"按钮 → 设置面板：
+
+- **用户画像**：一段自由文本描述用户自己（角色、背景、偏好），**每轮注入**到系统提示，让 Agent 始终遵循
+- **规则**：Agent 必须遵守的行为规则列表（如"回答先给结论"），同样每轮注入
+- **自定义指令**：注册斜杠命令（`/名称`），触发时把用户定义的指令内容交给 Agent。命令持久化到 SQLite，启动时自动注册到 DSH 命令表，增删实时生效
+
+> 画像与规则通过独立的 `[用户设置]` 注入区块（优先级高于记忆库），即使记忆为空也会注入。
+
 ## 📦 安装
 
 ### 前置条件
@@ -150,7 +160,7 @@ src/
 lib/
 ├── client.js         # Web 面板（手写 ModuleLoader bundle）
 └── *.js              # src 的同步分发产物
-test/                 # 108 个 node:test 测试
+test/                 # 129 个 node:test 测试
 ```
 
 ## 🧪 开发
@@ -158,7 +168,7 @@ test/                 # 108 个 node:test 测试
 ```bash
 cd dsh-mneme
 npm install        # 安装 peer 依赖（以 devDependencies 形式，用于本地测试）
-npm test           # 运行 108 个测试（--test-isolation=none 用于受限沙箱，禁止子进程 spawn）
+npm test           # 运行 129 个测试（--test-isolation=none 用于受限沙箱，禁止子进程 spawn）
 npm run sync       # 把 src/ 同步到 lib/（发布时由 prepack 钩子自动执行）
 ```
 

package/lib/api.js

@@ -5,19 +5,41 @@ function sendJson(res, status, payload) {
   res.end(JSON.stringify(payload));
 }
 
-export function createApi(ctx, service) {
+/** Collect the request body as text (tolerant of empty/invalid bodies). */
+function readBody(req) {
+  return new Promise((resolve) => {
+    let body = "";
+    req.on("data", (chunk) => { body += chunk; });
+    req.on("end", () => resolve(body));
+    req.on("error", () => resolve(""));
+  });
+}
+
+function parseBody(text) {
+  try {
+    return JSON.parse(text || "{}");
+  } catch {
+    return {};
+  }
+}
+
+export function createApi(ctx, service, settings, commands, embedder) {
   const disposers = [];
 
+  const register = (route) => {
+    disposers.push(ctx.webServer.register(route));
+  };
+
   // /api/dsh-mneme prefix fallback → 404 JSON for unknown sub-paths
-  disposers.push(ctx.webServer.register({
+  register({
     kind: "prefix",
     path: "/api/dsh-mneme",
     handler(req, res) {
       sendJson(res, 404, { error: "not-found" });
     }
-  }));
+  });
 
-  disposers.push(ctx.webServer.register({
+  register({
     kind: "exact",
     path: "/api/dsh-mneme/list",
     handler(req, res) {
@@ -32,9 +54,9 @@ export function createApi(ctx, service) {
         sendJson(res, 500, { error: "internal" });
       }
     }
-  }));
+  });
 
-  disposers.push(ctx.webServer.register({
+  register({
     kind: "exact",
     path: "/api/dsh-mneme/search",
     handler(req, res) {
@@ -42,16 +64,180 @@ export function createApi(ctx, service) {
         const url = new URL(req.url, "http://localhost");
         const q = url.searchParams.get("q") ?? "";
         const limit = Number(url.searchParams.get("limit") ?? 20);
-        const items = service.toApiList(service.search(q, { limit }));
-        sendJson(res, 200, { items });
+        // mode: auto (default) | keyword | vector
+        const mode = url.searchParams.get("mode") ?? "auto";
+        const query = q.trim();
+        if (!query) {
+          sendJson(res, 200, { items: [], mode: "keyword" });
+          return;
+        }
+        // Keyword results (existing behavior) always computed; used as a
+        // fallback and as the primary ranking when vector is unavailable.
+        const keyword = service.toApiList(service.search(query, { limit }));
+        if (mode === "keyword" || !embedder) {
+          sendJson(res, 200, { items: keyword, mode: "keyword" });
+          return;
+        }
+        const cfg = settings.getVectorConfig();
+        if (mode === "vector" && !cfg?.enabled) {
+          sendJson(res, 200, { items: keyword, mode: "keyword", error: "vector-disabled" });
+          return;
+        }
+        // Try vector search; on any failure fall back to keyword results.
+        return embedder.embed(query).then(async (vector) => {
+          let items = keyword;
+          let used = "keyword";
+          if (vector) {
+            const scored = service.toApiList(service.searchVector(vector, { limit }));
+            // Merge: keyword exact hits first (they are the user's literal
+            // words), then vector results fill the remaining slots, deduped.
+            const seen = new Set(keyword.map((m) => m.id));
+            const merged = [...keyword];
+            for (const m of scored) {
+              if (merged.length >= limit) break;
+              if (!seen.has(m.id)) {
+                seen.add(m.id);
+                merged.push(m);
+              }
+            }
+            items = merged;
+            used = "vector";
+          }
+          sendJson(res, 200, { items, mode: used });
+        }).catch(() => {
+          sendJson(res, 200, { items: keyword, mode: "keyword" });
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- user profile ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/profile",
+    handler(req, res) {
+      try {
+        if (req.method === "PUT" || req.method === "POST") {
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            settings.setProfile(typeof body.profile === "string" ? body.profile : "");
+            sendJson(res, 200, { profile: settings.getProfile() });
+          });
+        }
+        sendJson(res, 200, { profile: settings.getProfile() });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- rules ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/rules",
+    handler(req, res) {
+      try {
+        if (req.method === "PUT" || req.method === "POST") {
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            settings.setRules(Array.isArray(body.rules) ? body.rules : []);
+            sendJson(res, 200, { rules: settings.getRules() });
+          });
+        }
+        sendJson(res, 200, { rules: settings.getRules() });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- vector search config ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/vector-config",
+    handler(req, res) {
+      try {
+        if (req.method === "PUT" || req.method === "POST") {
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            const cfg = settings.setVectorConfig({
+              enabled: body.enabled,
+              baseUrl: body.baseUrl,
+              apiKey: body.apiKey,
+              model: body.model
+            });
+            sendJson(res, 200, { config: cfg });
+          });
+        }
+        sendJson(res, 200, { config: settings.getVectorConfig() ?? { enabled: false, baseUrl: "", apiKey: "", model: "" } });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- vector re-index (backfill embeddings for rows missing them) ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/vector-reindex",
+    handler(req, res) {
+      try {
+        if (!embedder) {
+          sendJson(res, 200, { indexed: 0, skipped: 0, error: "vector-unavailable" });
+          return;
+        }
+        const url = new URL(req.url, "http://localhost");
+        const limit = Number(url.searchParams.get("limit") ?? 100);
+        embedder.reindexMissing(limit).then((result) => {
+          sendJson(res, 200, result);
+        }).catch(() => {
+          sendJson(res, 200, { indexed: 0, skipped: 0, error: "vector-failed" });
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- custom commands ---
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/commands",
+    handler(req, res) {
+      try {
+        if (req.method === "POST") {
+          return readBody(req).then((text) => {
+            const body = parseBody(text);
+            try {
+              const command = commands.add({
+                name: body.name,
+                description: body.description,
+                instruction: body.instruction
+              });
+              sendJson(res, 200, { command });
+            } catch (error) {
+              sendJson(res, 400, { error: error.message });
+            }
+          });
+        }
+        if (req.method === "DELETE") {
+          const url = new URL(req.url, "http://localhost");
+          const id = url.searchParams.get("id");
+          const removed = id ? commands.remove(id) : false;
+          sendJson(res, 200, { removed });
+          return;
+        }
+        sendJson(res, 200, { commands: commands.list() });
       } catch {
         sendJson(res, 500, { error: "internal" });
       }
     }
-  }));
+  });
 
   return {
-    routes: 3,
+    routes: 6,
     dispose: () => {
       for (const dispose of disposers) dispose();
     }