@modusensus/dsh-mneme 0.7.28 → 0.7.30

package/test/api.test.js

@@ -1,6 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
+import { readFileSync } from "node:fs";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createApi } from "../src/api.js";
@@ -434,6 +435,41 @@ test("no apiToken configured keeps all endpoints open", async () => {
   assert.equal(res.statusCode, 200, "open when apiToken is unset");
 });
 
+// --- #118: /semantic exposes embedder readiness for the status card ----------
+
+test("GET /api/dsh-mneme/semantic reports ready state per embedder", async () => {
+  const fetchSem = async (embedder) => {
+    const { routes } = setup(embedder);
+    const sem = routes.find((r) => r.path === "/api/dsh-mneme/semantic");
+    const res = new FakeRes();
+    await sem.handler(req("/api/dsh-mneme/semantic"), res);
+    assert.equal(res.statusCode, 200);
+    return JSON.parse(res.body);
+  };
+  // no embedder → everything null
+  assert.equal((await fetchSem(undefined)).embedProvider, null);
+  assert.equal((await fetchSem(undefined)).ready, null, "no embedder → ready null");
+
+  // Ollama-style embedder mid-init (ready:false) → ready false
+  class OllamaEmbedder { constructor() { this.ready = false; } }
+  const mid = await fetchSem(new OllamaEmbedder());
+  assert.equal(mid.embedProvider, "OllamaEmbedder");
+  assert.equal(mid.ready, false, "not-yet-ready embedder → ready false");
+
+  // ready after init
+  const ready = new OllamaEmbedder(); ready.ready = true;
+  assert.equal((await fetchSem(ready)).ready, true);
+
+  // legacy OpenAI embedder has no `ready` prop → treated as ready
+  assert.equal((await fetchSem({ embed() {} })).ready, true, "no ready prop → assumed ready");
+
+  // legacy embedder carries an explicit display name (constructor.name of a
+  // literal is "Object", which the status card must not render verbatim)
+  const named = await fetchSem({ name: "OpenAI", embed() {} });
+  assert.equal(named.embedProvider, "OpenAI", "explicit name beats constructor.name");
+  assert.equal(named.ready, true);
+});
+
 // --- Bug8: llm-audit API (pagination + stats) --------------------------------
 
 test("GET /api/dsh-mneme/semantic/llm-audit returns paginated rows", async () => {
@@ -517,6 +553,20 @@ test("Bug10: vector-reindex with an embed-only OpenAI-compatible embedder return
   assert.equal(vectorIndex.getEmbedding(service.all()[0].id).length, 3, "embedding persisted");
 });
 
+// --- /info（反馈预填的插件版本）-----------------------------------------------
+
+test("GET /api/dsh-mneme/info returns the package version for feedback prefills", async () => {
+  const { routes } = setup(undefined);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/info");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/info"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  // 与插件根 package.json 的版本一致（反馈 issue/邮件的预填环境信息依赖它）。
+  const expected = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+  assert.equal(data.version, expected);
+});
+
 // --- feature flags（/features：overrides + effective）------------------------
 
 test("GET /api/dsh-mneme/features returns empty overrides and effective config defaults", async () => {
@@ -527,12 +577,15 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(res.statusCode, 200);
   const data = JSON.parse(res.body);
   assert.deepEqual(data.overrides, {});
-  // effective 覆盖全部 37 个白名单键（含 v0.7.20 heatEnabled、Issue #89 新增
+  // effective 覆盖全部 42 个白名单键（含 v0.7.20 heatEnabled、Issue #89 新增
   // dreamSkipInvalid/allowCrossTypeMerge/dreamMinIntervalMinutes、面板可调的
-  // dreamMaxTokens 与本轮睡眠路由 sleepProvider/sleepModel），未覆盖时取
-  // bundle 配置的解析默认值；dreamProvider/dreamModel 无 schema 默认值
-  // （Config({}) 解析为 undefined），不编造给前端 → 37 - 2 = 35
-  assert.equal(Object.keys(data.effective).length, 35);
+  // dreamMaxTokens、睡眠路由 sleepProvider/sleepModel、PR1 新增的
+  // recallFusion/signalTransparency，以及 issue #109 新增的实体抽取路由
+  // entityExtractionProvider/entityExtractionModel/entityExtractionReasoning），
+  // 未覆盖时取 bundle 配置的解析默认值；
+  // dreamProvider/dreamModel 无 schema 默认值（Config({}) 解析为 undefined），
+  // 不编造给前端 → 42 - 2 = 40
+  assert.equal(Object.keys(data.effective).length, 40);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMinIntervalMinutes, 0);
@@ -555,6 +608,13 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(data.effective.ollamaBaseUrl, "http://localhost:11434");
   assert.equal(data.effective.ollamaModel, "nomic-embed-text");
   assert.equal(data.effective.embedProvider, "openai");
+  // PR1：融合配方枚举 + 信号透明布尔（均有默认值，故计入 effective 计数）
+  assert.equal(data.effective.recallFusion, "blend");
+  assert.equal(data.effective.signalTransparency, false);
+  // issue #109：实体抽取路由三键（均有默认值，故计入 effective 计数）
+  assert.equal(data.effective.entityExtractionProvider, "");
+  assert.equal(data.effective.entityExtractionModel, "");
+  assert.equal(data.effective.entityExtractionReasoning, "none");
 });
 
 test("PUT /api/dsh-mneme/features round-trips, overrides effective and persists", async () => {

package/test/benchmark.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { runBenchmark, TEST_CASES } from "../scripts/benchmark-recall.js";
+import { runBenchmark, runFusionBenchmark, seedService, TEST_CASES } from "../scripts/benchmark-recall.js";
 
 // The benchmark harness must stay a working evaluation: it runs the real
 // searchMemories pipeline over the seeded store and the fused configuration
@@ -33,3 +33,62 @@ test("test cases cover the scattered-term BM25 territory", () => {
     assert.ok(tc.query && tc.expected.length > 0);
   }
 });
+
+// --- PR1: recall fusion recipes + signal transparency ---------------------
+
+test("fusion-recipe A/B runs blend/rrf/minmax with valid recall on the seed corpus", async () => {
+  const report = await runFusionBenchmark({ topK: 5 });
+  assert.deepEqual(report.runs.map((r) => r.config), ["blend", "rrf", "minmax"]);
+  for (const run of report.runs) {
+    assert.equal(run.rows.length, TEST_CASES.length, `${run.config} covers every query`);
+    assert.ok(run.recallAtK >= 0 && run.recallAtK <= 1, `${run.config} recallAtK in [0,1]`);
+    assert.ok(run.avgMrr >= 0 && run.avgMrr <= 1, `${run.config} avgMrr in [0,1]`);
+  }
+});
+
+test("signalTransparency decorates rows with per-source signals", async () => {
+  const svc = seedService({ recallFusion: "blend", signalTransparency: true });
+  const rows = await svc.searchMemories("rust 异步", { mode: "auto", topK: 5, useRerank: false });
+  assert.ok(rows.length > 0, "the seed corpus returns hits for a scattered-term query");
+  for (const r of rows) {
+    assert.equal(typeof r.signals, "object", "each row carries a signals object");
+    assert.equal(typeof r.signals.final, "number", "signals carries the fused final score");
+    assert.ok([
+      "keyword" in r.signals,
+      "vector" in r.signals,
+      "bm25" in r.signals
+    ].some(Boolean), "at least one source signal is present");
+  }
+});
+
+test("recallFusion recipes produce distinct fused scores for the same memory", async () => {
+  const scores = {};
+  for (const recipe of ["blend", "rrf", "minmax"]) {
+    const svc = seedService({ recallFusion: recipe });
+    const rows = await svc.searchMemories("rust 异步", { mode: "auto", topK: 5, useRerank: false });
+    const hit = rows.find((r) => r.id === "mem_async_pattern") ?? rows[0];
+    assert.ok(hit, `${recipe} surfaces a hit`);
+    scores[recipe] = hit.score ?? 0;
+  }
+  // RRF is rank-based (Σ 1/(k+rank+1)) and minmax normalizes before blending,
+  // so they must not all collapse onto the same numeric score.
+  assert.ok(new Set(Object.values(scores)).size > 1, `recipes score differently: ${JSON.stringify(scores)}`);
+});
+
+// PR1 + CodeRabbit: an opt-in recipe must never change keyword-only behavior.
+// mode="keyword" is the documented text-only path; regardless of recipe, the
+// result must contain only keyword-sourced rows — no vector/BM25 bleed-in.
+// (Note: on a scattered-CJK query the keyword source can itself be empty, in
+// which case auto correctly falls back to BM25 — that is the pre-fusion blend
+// behavior and is NOT a regression. Only mode="keyword" is a hard text path.)
+test("opt-in recipes keep mode=keyword keyword-only (no vector/BM25 bleed)", async () => {
+  for (const recipe of ["blend", "rrf", "minmax"]) {
+    const svc = seedService({ recallFusion: recipe });
+    const rows = await svc.searchMemories("rust 异步", { mode: "keyword", topK: 5, useRerank: false });
+    const keywordOnly = rows.every((r) => r.source === "keyword");
+    assert.ok(
+      keywordOnly,
+      `${recipe} under mode=keyword must keep only keyword rows; got sources: ${[...new Set(rows.map((r) => r.source))].join(",")}`
+    );
+  }
+});

package/test/client.test.js

@@ -554,3 +554,42 @@ test("consolidation/sleep model routing: provider dropdowns from /llm-providers,
     "the route selects must share the string-input width budget"
   );
 });
+
+// 帮助与反馈入口（v0.8）：设置页底部三个反馈链接——GitHub 新建 issue 预填
+// （环境信息）、邮件反馈、浏览已知问题。纯前端链接零后端成本；插件版本从
+// /info 拉取（version 只读，不铺任何 token/凭据）。公开链接不得带个人邮箱。
+test("settings feedback card: prefilled issue + mailto + browse, version from /info", () => {
+  // 1. 版本预填端点
+  assert.ok(
+    clientSource.includes('apiFetch("/api/dsh-mneme/info")'),
+    "the feedback card must fetch the plugin version from /info"
+  );
+  assert.ok(
+    clientSource.includes("setPkgVersion"),
+    "the fetched version must land in component state"
+  );
+  // 2. GitHub 新建 issue：issues/new?title=&body= 预填环境信息（当前仓库无模板）
+  assert.ok(
+    clientSource.includes("https://github.com/modusensus/dsh-mneme/issues/new?title="),
+    "the issue link must prefill title+body on issues/new"
+  );
+  assert.ok(
+    clientSource.includes("**插件版本**") && clientSource.includes("**平台**"),
+    "the prefill body must carry plugin version and platform"
+  );
+  // 3. 邮件反馈：官方邮箱（对外不写个人邮箱），mailto 预填 subject+body
+  assert.ok(
+    clientSource.includes("mailto:work@modusensus.space?subject="),
+    "the mailto link must point at the public support address"
+  );
+  // 4. 浏览已知问题：跳仓库 issues 列表页（去重前置步骤）
+  assert.ok(
+    clientSource.includes('href: "https://github.com/modusensus/dsh-mneme/issues"'),
+    "the browse link must open the repo issues list"
+  );
+  // 5. 双语 i18n
+  for (const key of ["feedback.title", "feedback.newIssue", "feedback.email", "feedback.browse", "feedback.hint"]) {
+    const occurrences = clientSource.split(`"memory.settings.${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key memory.settings.${key} must exist in both zh and en (got ${occurrences})`);
+  }
+});

package/test/entities.test.js

@@ -520,3 +520,28 @@ test("extractor fails safe when callLLM rejects → {ok:false}", async () => {
   assert.ok(result.error);
   store.close();
 });
+
+// --- issue #109: provider/model override + reasoning effort pass-through -----
+
+test("extractor passes provider/model/reasoningEffort through to callLLM options", async () => {
+  const store = openStore();
+  let captured = null;
+  const callLLM = async (_messages, options) => {
+    captured = options;
+    return JSON.stringify({ entities: [{ name: "Vite", type: "technology", attrs: [] }], relations: [] });
+  };
+  const config = { entityExtractionProvider: "openai", entityExtractionModel: "gpt-x", entityExtractionReasoning: "high" };
+  const result = await extractEntities({ id: "m1", content: "Vite 是前端构建工具" }, { store, config, callLLM });
+  assert.equal(result.ok, true);
+  assert.deepEqual(captured, { provider: "openai", model: "gpt-x", reasoningEffort: "high" });
+  store.close();
+});
+
+test("extractor omits empty provider/model and 'none' reasoning from options", async () => {
+  const store = openStore();
+  let captured = "unset";
+  const callLLM = async (_m, options) => { captured = options; return JSON.stringify({ entities: [], relations: [] }); };
+  await extractEntities({ id: "m2", content: "空文本" }, { store, config: {}, callLLM });
+  assert.deepEqual(captured, {}, "no provider/model/reasoning keys when unset");
+  store.close();
+});

package/test/local-embedder.test.js

@@ -116,7 +116,9 @@ test("OllamaEmbedder init probes server and infers dimension", async () => {
   });
   try {
     const e = new OllamaEmbedder({ baseUrl: "http://localhost:11434", model: "nomic-embed-text" });
+    assert.equal(e.ready, false, "not ready before init");
     await e.init();
+    assert.equal(e.ready, true, "ready after init");
     assert.equal(e.dimension, 768);
   } finally {
     restore();

package/test/reasoning-effort.test.js

@@ -13,6 +13,7 @@ import { runSleep } from "../src/dream/sleep.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createVectorIndex } from "../src/vector-index.js";
+import { createEntityStreamAdapter } from "../src/index.js";
 
 const embedder = {
   embedSingle: async () => [1, 0, 0],
@@ -576,3 +577,79 @@ test("defaultEffort trap: sleep conflict pass remaps a poison effort too", async
   }
   store.close();
 });
+
+// ------------------------------------------------- entity extraction adapter (issue #108/#109)
+// The streamEntityText adapter lives in index.js; it maps the extractor's
+// options onto a dsh-llm stream route and retries once without the effort
+// when the first attempt is rejected. These tests drive the real exported
+// factory, not a mock of it.
+
+test("issue#109: entity extraction effort rejection retries once without the effort", async () => {
+  const calls = [];
+  const warnings = [];
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        // First attempt carries the effort: the provider rejects it via an
+        // error finish chunk (the realistic stream-level rejection).
+        if (options.reasoningEffort) {
+          yield { type: "finish", reason: { kind: "error", message: "UNSUPPORTED_REASONING_EFFORT" } };
+          return;
+        }
+        yield { type: "text-delta", index: 0, text: "{\"entities\":[{\"name\":\"张三\",\"type\":\"person\",\"attrs\":[{\"key\":\"职业\",\"value\":\"工程师\",\"confidence\":0.9}]}],\"relations\":[]}" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: (m) => warnings.push(String(m)) }
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    { reasoningEffort: "low" }
+  );
+  assert.equal(calls.length, 2, "attempt (rejected) + retry without effort");
+  assert.equal(calls[0].reasoningEffort, "low", "first attempt forwards the effort");
+  assert.equal("reasoningEffort" in calls[1], false, "retry omits the rejected effort field");
+  assert.equal(calls[0].provider, "mock", "route resolved from agentDefaultModel");
+  assert.equal(calls[0].model, "mock-model", "route model from agentDefaultModel");
+  assert.equal(calls[0].maxTokens, 4096, "extraction caps its output");
+  assert.ok(text.includes("张三"), "retry stream text is returned");
+  assert.ok(warnings.some((w) => w.includes("rejected, retrying without it")), "rejection is logged");
+});
+
+test("issue#109: entity extraction never retries blindly without an effort configured", async () => {
+  const calls = [];
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        yield { type: "finish", reason: { kind: "error", message: "overloaded" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} }
+  });
+  const text = await streamEntityText([{ role: "user", content: [] }], {});
+  assert.equal(text, undefined, "failure yields no text");
+  assert.equal(calls.length, 1, "no blind retry when no effort was requested");
+});
+
+test("issue#109: entity extraction explicit provider/model win over the default route", async () => {
+  const calls = [];
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        yield { type: "text-delta", index: 0, text: "{}" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "default", model: "default-model" }) },
+    logger: { warn: () => {} }
+  });
+  await streamEntityText([{ role: "user", content: [] }], { provider: "volcano", model: "deepseek-v3" });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].provider, "volcano", "explicit provider beats the default");
+  assert.equal(calls[0].model, "deepseek-v3", "explicit model beats the default");
+});

package/test/store.test.js

@@ -242,6 +242,15 @@ test("setEmbedding, embeddedCount, needsEmbedding and threshold filtering", () =
   assert.equal(store.embeddedCount(), 0);
   store.setEmbedding(m2.id, [0, 1]);
   assert.equal(store.embeddedCount(), 1);
+  // Status-card denominator alignment: count() defaults exclude archived and
+  // forgotten rows, so embeddedCount must drop them too.
+  store.setArchived(m2.id, true);
+  assert.equal(store.embeddedCount(), 0, "archived rows leave the embedded count");
+  store.setArchived(m2.id, false);
+  store.setForget(m2.id, true);
+  assert.equal(store.embeddedCount(), 0, "forgotten rows leave the embedded count");
+  store.setForget(m2.id, false);
+  assert.equal(store.embeddedCount(), 1);
   const missing = store.needsEmbedding(10);
   assert.equal(missing.length, 1);
   assert.equal(missing[0].id, t1.id, "only the non-embedded row is listed");