@modusensus/dsh-mneme 0.1.2 → 0.1.4

package/lib/settings.js

@@ -0,0 +1,120 @@
+// User-configurable settings: profile (user self-description), rules (behavior
+// rules the agent must follow), and custom slash commands. Stored in the same
+// SQLite database via dedicated tables, isolated from the memories store.
+import { randomUUID } from "node:crypto";
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS user_settings (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS custom_commands (
+  id          TEXT PRIMARY KEY,
+  name        TEXT NOT NULL UNIQUE,
+  description TEXT NOT NULL DEFAULT '',
+  instruction TEXT NOT NULL,
+  created_at  TEXT NOT NULL,
+  updated_at  TEXT NOT NULL
+);
+`;
+
+// DSH command names must match this (lowercase, start with a letter).
+const COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
+
+/** Parse a JSON array out of a stored string, tolerant of corruption. */
+function parseList(raw) {
+  try {
+    const value = JSON.parse(raw);
+    return Array.isArray(value) ? value : [];
+  } catch {
+    return [];
+  }
+}
+
+export function createSettings(db) {
+  db.exec(SCHEMA);
+
+  function getSetting(key) {
+    const row = db.prepare("SELECT value FROM user_settings WHERE key = ?").get(key);
+    return row?.value ?? undefined;
+  }
+
+  function setSetting(key, value) {
+    db.prepare(
+      `INSERT INTO user_settings (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(key, value);
+  }
+
+  function toCommand(row) {
+    if (!row) return undefined;
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      instruction: row.instruction,
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    };
+  }
+
+  return {
+    /** The user's self-description (free text) or "" when unset. */
+    getProfile() {
+      return getSetting("profile") ?? "";
+    },
+    setProfile(text) {
+      setSetting("profile", String(text ?? ""));
+    },
+
+    /** Behavior rules as an array of strings. */
+    getRules() {
+      return parseList(getSetting("rules") ?? "[]").filter((r) => typeof r === "string");
+    },
+    setRules(rules) {
+      const list = Array.isArray(rules) ? rules.filter((r) => typeof r === "string") : [];
+      setSetting("rules", JSON.stringify(list));
+    },
+
+    /** All custom commands, sorted by name. */
+    listCommands() {
+      const rows = db.prepare("SELECT * FROM custom_commands ORDER BY name ASC").all();
+      return rows.map(toCommand);
+    },
+
+    /**
+     * Add or replace a custom command by name.
+     * @returns the stored command.
+     * @throws when name is invalid or does not match DSH's command-name grammar.
+     */
+    addCommand({ name, description = "", instruction }) {
+      const cmdName = String(name ?? "").trim();
+      if (!COMMAND_NAME.test(cmdName)) {
+        throw new Error(`invalid command name "${cmdName}": must match /^[a-z][a-z0-9_-]*$/`);
+      }
+      if (typeof instruction !== "string" || !instruction.trim()) {
+        throw new Error("command instruction must be a non-empty string");
+      }
+      const now = new Date().toISOString();
+      const existing = db.prepare("SELECT id FROM custom_commands WHERE name = ?").get(cmdName);
+      if (existing) {
+        db.prepare(
+          "UPDATE custom_commands SET description = ?, instruction = ?, updated_at = ? WHERE id = ?"
+        ).run(String(description ?? ""), instruction, now, existing.id);
+        return toCommand(db.prepare("SELECT * FROM custom_commands WHERE id = ?").get(existing.id));
+      }
+      const id = randomUUID();
+      db.prepare(
+        `INSERT INTO custom_commands (id, name, description, instruction, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(id, cmdName, String(description ?? ""), instruction, now, now);
+      return toCommand(db.prepare("SELECT * FROM custom_commands WHERE id = ?").get(id));
+    },
+
+    /** Remove a custom command by id; returns true when removed. */
+    removeCommand(id) {
+      const result = db.prepare("DELETE FROM custom_commands WHERE id = ?").run(id);
+      return result.changes > 0;
+    }
+  };
+}

package/lib/store.js

@@ -193,8 +193,9 @@ export function createStore(path) {
   function search(query, { limit = 20, includeArchived = false } = {}) {
     const q = String(query).trim();
     if (!q) return [];
-    // FTS5 over unicode61 (English + long phrases); LIKE fallback covers CJK substring.
-    // LIKE wildcards in the query are escaped so user input is matched literally.
+    // Plain LIKE substring scan over title/content/tags (wildcards escaped so
+    // user input matches literally). No FTS5: CJK substring matching needs
+    // LIKE, and typical memory stores are small enough that a scan is fine.
     const like = `%${escapeLike(q)}%`;
     const { limit: lim } = sanitizePage(limit, 0, 20);
     const archivedFilter = includeArchived ? "" : "archived = 0 AND ";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
-  "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite+FTS5 store, Markdown mirrors, 6 model tools, automatic injection, session summarization, and a Web GUI panel",
-  "version": "0.1.2",
+  "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 6 model tools, automatic injection, session summarization, and a Web GUI panel",
+  "version": "0.1.4",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",

package/src/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) {
   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) {
@@ -48,10 +70,85 @@ export function createApi(ctx, service) {
         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" });
+      }
+    }
+  });
+
+  // --- 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();
     }

package/src/commands.js

@@ -0,0 +1,64 @@
+// Custom slash-command manager: keeps the DSH command registry in sync with
+// user-defined commands persisted in SQLite. Commands are registered on boot
+// and (re)registered on add/remove through the API.
+//
+// Each custom command's handler returns the user-authored instruction as a
+// success result; the DSH UI surfaces it as a model-directed instruction.
+export function createCommandManager({ ctx, settings, logger }) {
+  const registered = new Map(); // name -> disposer
+
+  function registerOne(command) {
+    if (registered.has(command.name)) return;
+    let dispose;
+    try {
+      dispose = ctx.commands.register({
+        name: command.name,
+        description: command.description || `自定义指令 ${command.name}`,
+        handler: () => ({ kind: "success", text: command.instruction })
+      });
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme: failed to register command /${command.name}: ${String(error)}`);
+      return;
+    }
+    registered.set(command.name, dispose);
+  }
+
+  function unregisterOne(name) {
+    const dispose = registered.get(name);
+    if (dispose) {
+      try {
+        dispose();
+      } catch {
+        /* ignore double-dispose */
+      }
+      registered.delete(name);
+    }
+  }
+
+  /** Register every stored command (boot-time sync). */
+  function sync() {
+    for (const command of settings.listCommands()) registerOne(command);
+  }
+
+  /** Add (or replace) a command and register it live. */
+  function add({ name, description, instruction }) {
+    const command = settings.addCommand({ name, description, instruction });
+    registerOne(command);
+    return command;
+  }
+
+  /** Remove a command by id and unregister it live. */
+  function remove(id) {
+    const existing = settings.listCommands().find((c) => c.id === id);
+    if (!existing) return false;
+    if (!settings.removeCommand(id)) return false;
+    unregisterOne(existing.name);
+    return true;
+  }
+
+  function dispose() {
+    for (const name of [...registered.keys()]) unregisterOne(name);
+  }
+
+  return { sync, add, remove, list: () => settings.listCommands(), dispose };
+}

package/src/dream.js

@@ -62,6 +62,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   let running = false;
   let disposed = false;
   let baseline = { count: 0, chars: 0 };
+  let inFlight = null;
 
   function shouldTrigger(service) {
     const memories = service.all().filter((m) => !m.archived && m.type !== "summary");
@@ -81,8 +82,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       running = true;
       // Defer the onRun invocation so a synchronous throw cannot escape the
       // timer callback (which would crash the process) and skip the teardown.
-      // Errors are logged, never swallowed silently.
-      Promise.resolve()
+      // Errors are logged, never swallowed silently. inFlight lets dispose()
+      // await the running consolidation before the caller closes the store.
+      inFlight = Promise.resolve()
         .then(() => (onRun ? onRun() : Promise.resolve({ ok: true, skipped: true })))
         .then((result) => {
           // Refresh the baseline only for a successful run (design §5.3: an
@@ -105,17 +107,19 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         })
         .finally(() => {
           running = false;
+          inFlight = null;
         });
     }, delayMs);
     return true;
   }
 
-  function dispose() {
+  async function dispose() {
     disposed = true;
     if (pendingTimer) { clearTimeout(pendingTimer); pendingTimer = null; }
-    // An in-flight run is left to complete naturally: its LLM calls are
-    // already paid for and aborting would discard the work. The caller is
-    // responsible for closing the store only after the run has finished.
+    // An in-flight run is left to complete naturally (its LLM calls are
+    // already paid for and aborting would discard the work). Await it so the
+    // caller can close the store only after every write has landed.
+    if (inFlight) await inFlight.catch(() => {});
   }
 
   async function runDream(ctx, service, config) {

package/src/index.js

@@ -6,13 +6,15 @@ import { createInjector } from "./inject.js";
 import { createSummarizer } from "./summarize.js";
 import { createDreamScheduler } from "./dream.js";
 import { createApi } from "./api.js";
+import { createSettings } from "./settings.js";
+import { createCommandManager } from "./commands.js";
 import { Config } from "./config.js";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
 export const name = "dsh-mneme";
-export const inject = ["tools", "systemPrompt", "webServer", "llm", "agentDefaultModel"];
+export const inject = ["tools", "systemPrompt", "webServer", "llm", "agentDefaultModel", "commands"];
 export { Config };
 
 // Arrow (not function declaration): cordis 4 treats any apply with a
@@ -33,10 +35,28 @@ export const apply = (ctx, config) => {
   const mirror = createMirror(memoryDir);
   const service = createService({ store, mirror, config: cfg });
 
+  // User-configurable settings (profile, rules) and custom commands share the
+  // same SQLite file but live in dedicated tables, isolated from memories.
+  const settings = createSettings(store.db);
+
+  // Custom commands: register persisted commands into the DSH command registry
+  // on boot; add/remove re-register live through the API.
+  let commands = null;
+  if (ctx.commands) {
+    commands = createCommandManager({ ctx, settings, logger: ctx.logger });
+    commands.sync();
+  }
+
   // Human edits in mirror files win on every sync; merge them back first.
-  // TYPE_FILE maps each memory type to its mirror filename.
+  // TYPE_FILE maps each memory type to its mirror filename. Read every type's
+  // edits up front: mergeHumanEdits re-renders ALL mirror files on success, so
+  // a per-type read-then-merge loop would overwrite edits in files not yet read
+  // (e.g. preferences.md merging would clobber unsynced projects.md edits).
+  const humanEdits = new Map();
   for (const type of Object.keys(TYPE_FILE)) {
-    const edits = mirror.readHumanEdits(type);
+    humanEdits.set(type, mirror.readHumanEdits(type));
+  }
+  for (const [type, edits] of humanEdits) {
     if (edits.length) service.mergeHumanEdits(type, edits);
   }
 
@@ -61,7 +81,7 @@ export const apply = (ctx, config) => {
   const disposers = [];
 
   ctx.inject(["systemPrompt"], (promptCtx) => {
-    if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, cfg));
+    if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, settings, cfg));
   });
 
   ctx.inject(["tools"], (toolsCtx) => {
@@ -72,15 +92,23 @@ export const apply = (ctx, config) => {
   disposers.push(summarizer.dispose);
 
   if (ctx.webServer) {
-    const api = createApi(ctx, service);
+    const api = createApi(ctx, service, settings, commands ?? {
+      add: () => { throw new Error("commands unavailable"); },
+      remove: () => false,
+      list: () => []
+    });
     disposers.push(api.dispose);
   }
 
-  return () => {
+  // Async disposer: cordis awaits the returned promise on unload (runDisposable),
+  // so an in-flight dream run is allowed to finish before the SQLite store is
+  // closed — dream.dispose() resolves only after its current run settles.
+  return async () => {
     for (const dispose of disposers) {
       if (typeof dispose === "function") dispose();
     }
-    if (dream) dream.dispose();
+    commands?.dispose();
+    if (dream) await dream.dispose();
     store.close();
   };
 };

package/src/inject.js

@@ -1,4 +1,4 @@
-export function createInjector(ctx, service, config) {
+export function createInjector(ctx, service, settings, config) {
   const maxItems = config.maxInjectedItems ?? 5;
   const threshold = config.importanceThreshold ?? 3;
 
@@ -11,12 +11,37 @@ export function createInjector(ctx, service, config) {
     return lines.join("\n");
   }
 
-  return ctx.systemPrompt.context({
-    name: "memory",
-    order: 90,
-    text: () => {
-      const candidates = service.injectCandidates({ maxItems, threshold });
-      return render(candidates);
+  // User profile + rules: injected ahead of the memory block because they are
+  // always-relevant instructions the agent should follow every turn.
+  function renderUserSettings() {
+    const profile = settings.getProfile().trim();
+    const rules = settings.getRules();
+    if (!profile && !rules.length) return "";
+    const lines = ["[用户设置] 来自 dsh-mneme 的用户画像与规则："];
+    if (profile) lines.push(`- 用户画像：${profile}`);
+    for (const rule of rules) lines.push(`- 规则：${rule}`);
+    return lines.join("\n");
+  }
+
+  const disposers = [
+    ctx.systemPrompt.context({
+      name: "memory",
+      order: 90,
+      text: () => {
+        const candidates = service.injectCandidates({ maxItems, threshold });
+        return render(candidates);
+      }
+    }),
+    ctx.systemPrompt.context({
+      name: "user-settings",
+      order: 85,
+      text: renderUserSettings
+    })
+  ];
+
+  return () => {
+    for (const dispose of disposers) {
+      if (typeof dispose === "function") dispose();
     }
-  });
+  };
 }

package/src/settings.js

@@ -0,0 +1,120 @@
+// User-configurable settings: profile (user self-description), rules (behavior
+// rules the agent must follow), and custom slash commands. Stored in the same
+// SQLite database via dedicated tables, isolated from the memories store.
+import { randomUUID } from "node:crypto";
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS user_settings (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS custom_commands (
+  id          TEXT PRIMARY KEY,
+  name        TEXT NOT NULL UNIQUE,
+  description TEXT NOT NULL DEFAULT '',
+  instruction TEXT NOT NULL,
+  created_at  TEXT NOT NULL,
+  updated_at  TEXT NOT NULL
+);
+`;
+
+// DSH command names must match this (lowercase, start with a letter).
+const COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
+
+/** Parse a JSON array out of a stored string, tolerant of corruption. */
+function parseList(raw) {
+  try {
+    const value = JSON.parse(raw);
+    return Array.isArray(value) ? value : [];
+  } catch {
+    return [];
+  }
+}
+
+export function createSettings(db) {
+  db.exec(SCHEMA);
+
+  function getSetting(key) {
+    const row = db.prepare("SELECT value FROM user_settings WHERE key = ?").get(key);
+    return row?.value ?? undefined;
+  }
+
+  function setSetting(key, value) {
+    db.prepare(
+      `INSERT INTO user_settings (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(key, value);
+  }
+
+  function toCommand(row) {
+    if (!row) return undefined;
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      instruction: row.instruction,
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    };
+  }
+
+  return {
+    /** The user's self-description (free text) or "" when unset. */
+    getProfile() {
+      return getSetting("profile") ?? "";
+    },
+    setProfile(text) {
+      setSetting("profile", String(text ?? ""));
+    },
+
+    /** Behavior rules as an array of strings. */
+    getRules() {
+      return parseList(getSetting("rules") ?? "[]").filter((r) => typeof r === "string");
+    },
+    setRules(rules) {
+      const list = Array.isArray(rules) ? rules.filter((r) => typeof r === "string") : [];
+      setSetting("rules", JSON.stringify(list));
+    },
+
+    /** All custom commands, sorted by name. */
+    listCommands() {
+      const rows = db.prepare("SELECT * FROM custom_commands ORDER BY name ASC").all();
+      return rows.map(toCommand);
+    },
+
+    /**
+     * Add or replace a custom command by name.
+     * @returns the stored command.
+     * @throws when name is invalid or does not match DSH's command-name grammar.
+     */
+    addCommand({ name, description = "", instruction }) {
+      const cmdName = String(name ?? "").trim();
+      if (!COMMAND_NAME.test(cmdName)) {
+        throw new Error(`invalid command name "${cmdName}": must match /^[a-z][a-z0-9_-]*$/`);
+      }
+      if (typeof instruction !== "string" || !instruction.trim()) {
+        throw new Error("command instruction must be a non-empty string");
+      }
+      const now = new Date().toISOString();
+      const existing = db.prepare("SELECT id FROM custom_commands WHERE name = ?").get(cmdName);
+      if (existing) {
+        db.prepare(
+          "UPDATE custom_commands SET description = ?, instruction = ?, updated_at = ? WHERE id = ?"
+        ).run(String(description ?? ""), instruction, now, existing.id);
+        return toCommand(db.prepare("SELECT * FROM custom_commands WHERE id = ?").get(existing.id));
+      }
+      const id = randomUUID();
+      db.prepare(
+        `INSERT INTO custom_commands (id, name, description, instruction, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(id, cmdName, String(description ?? ""), instruction, now, now);
+      return toCommand(db.prepare("SELECT * FROM custom_commands WHERE id = ?").get(id));
+    },
+
+    /** Remove a custom command by id; returns true when removed. */
+    removeCommand(id) {
+      const result = db.prepare("DELETE FROM custom_commands WHERE id = ?").run(id);
+      return result.changes > 0;
+    }
+  };
+}

package/src/store.js

@@ -193,8 +193,9 @@ export function createStore(path) {
   function search(query, { limit = 20, includeArchived = false } = {}) {
     const q = String(query).trim();
     if (!q) return [];
-    // FTS5 over unicode61 (English + long phrases); LIKE fallback covers CJK substring.
-    // LIKE wildcards in the query are escaped so user input is matched literally.
+    // Plain LIKE substring scan over title/content/tags (wildcards escaped so
+    // user input matches literally). No FTS5: CJK substring matching needs
+    // LIKE, and typical memory stores are small enough that a scan is fine.
     const like = `%${escapeLike(q)}%`;
     const { limit: lim } = sanitizePage(limit, 0, 20);
     const archivedFilter = includeArchived ? "" : "archived = 0 AND ";