@modusensus/dsh-mneme 0.5.0 → 0.5.1

package/test/hot-memory.test.js

@@ -49,6 +49,35 @@ test("estimateTokens counts CJK heavier than ASCII", () => {
   assert.ok(estimateTokens("中文内容") > estimateTokens("abcd"));
 });
 
+// --- entry defense: non-positive / non-integer bounds fall back to defaults ---
+// Bug: createHotMemory({ maxRounds: -1 }) made the eviction while-loop
+// `while (buffer.length > maxRounds)` unbounded — after the buffer emptied,
+// `0 > -1` stayed true and buffer.shift() on an empty array is a no-op, so
+// every add() spun forever. Non-integer values (1.5, NaN, null) were also
+// silently wrong. The fix clamps them to the 5/2000 defaults at the door.
+
+test("hot memory falls back to maxRounds=5 for non-positive/invalid values", () => {
+  for (const bad of [0, -1, 1.5, NaN, null]) {
+    const hot = createHotMemory({ maxRounds: bad, maxTokens: 10000 });
+    for (let i = 0; i < 8; i++) hot.add({ query: `第${i}轮`, response: "x" });
+    assert.equal(hot.rounds().length, 5, `maxRounds=${bad} must fall back to 5, no infinite loop`);
+    assert.ok(hot.getContext().includes("第7轮"), `maxRounds=${bad}: newest round survives`);
+    assert.ok(!hot.getContext().includes("第0轮"), `maxRounds=${bad}: oldest round evicted`);
+  }
+});
+
+test("hot memory falls back to maxTokens=2000 for non-positive/infinite values", () => {
+  for (const bad of [0, -1, Infinity]) {
+    const hot = createHotMemory({ maxRounds: 50, maxTokens: bad });
+    // 50 rounds at ~74 tokens each blow a 2000-token budget; the fallback must
+    // evict into (1, 50). A broken budget of 0/-1 would squeeze to 1 round and
+    // Infinity would keep all 50 — both are the pre-fix behavior.
+    for (let i = 0; i < 50; i++) hot.add({ query: `第${i}轮`, response: "长回答".repeat(40) });
+    const n = hot.rounds().length;
+    assert.ok(n > 1 && n < 50, `maxTokens=${bad} falls back to 2000 (kept ${n} rounds)`);
+  }
+});
+
 // --- service-level: BM25 fusion + semantic dedup + selective injection ---
 
 function toyVec(text) {

package/test/reranker.test.js

@@ -1,5 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import { LocalReranker } from "../src/reranker.js";
 
 /** Injected scorer: records (query, passage) calls, returns a fixed score. */
@@ -195,3 +197,44 @@ test("dispose releases the loaded pipeline", async () => {
   assert.equal(r.pipeline, null);
   assert.equal(extractor.disposed, true);
 });
+
+test("default pipeline loader mirrors cache_dir onto env.cacheDir (issue #13)", () => {
+  // The fix lives in the module's *default* loader — the dynamic-import of
+  // @huggingface/transformers that the in-process tests bypass by injecting
+  // engineFactory. So it is exercised in a child node process under the
+  // --experimental-test-module-mocks flag: the transformers module is mocked
+  // with an empty env, LocalReranker uses the real default loader, and we
+  // assert env.cacheDir picks up the constructor's cache_dir. A regression
+  // (loader no longer mirroring) fails the child and surfaces here as a
+  // non-zero exit.
+  const srcUrl = new URL("../src/reranker.js", import.meta.url).href;
+  const cacheDir = "/tmp/dsh-mneme-cache-mirror-test";
+  const script = `
+    import { test } from "node:test";
+    const cacheDir = ${JSON.stringify(cacheDir)};
+    test("cache_dir is mirrored onto env.cacheDir", async (t) => {
+      t.mock.module("@huggingface/transformers", {
+        namedExports: {
+          env: {},
+          pipeline: async () => ({ dispose: () => {} })
+        }
+      });
+      const { LocalReranker } = await import(${JSON.stringify(srcUrl)});
+      const r = new LocalReranker({ cacheDir, device: "cpu" });
+      await r.init();
+      const { env } = await import("@huggingface/transformers");
+      if (env.cacheDir !== cacheDir) {
+        throw new Error("env.cacheDir not mirrored from cache_dir: " + env.cacheDir);
+      }
+      console.log("CACHE_MIRROR_OK");
+    });
+  `;
+  const res = spawnSync(process.execPath, [
+    "--experimental-test-module-mocks",
+    "--input-type=module",
+    "-e",
+    script
+  ], { encoding: "utf8", cwd: fileURLToPath(new URL("..", import.meta.url)) });
+  assert.equal(res.status, 0, `cache-dir mirror child failed:\n${res.stdout}\n${res.stderr}`);
+  assert.match(res.stdout, /CACHE_MIRROR_OK/);
+});

package/test/service-search.test.js

@@ -85,6 +85,31 @@ test("hybrid blend honors configured vector/keyword weights", async () => {
   assert.ok(Math.abs(t.score - 0.9) < 1e-9, `tuned blend ${t.score}`);
 });
 
+test("hybrid fusion clamps blended scores into [0,1]", async () => {
+  // Weights summing above 1 (1.0 + 1.0) push a same-memory blend over 1.0:
+  // title hit (importance 5) = 1 * (0.5 + 0.5) = 1.0, vector cosine = 1.0 →
+  // raw blend 1.0*1 + 1.0*1 = 2.0. The fused score must be clamped so
+  // consumers never see a score outside [0,1].
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {
+    hybridSearchVectorWeight: 1,
+    hybridSearchKeywordWeight: 1,
+    adaptiveThresholdEnabled: false,
+    searchSemanticDedup: false
+  } });
+  const vi = createVectorIndex({ store });
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vi);
+  const m = service.saveWithDedupe({ type: "preference", title: "量子计算", content: "量子计算入门", importance: 5 });
+  vi.saveEmbedding(m.memory.id, [1, 0, 0]);
+
+  const rows = await service.searchMemories("量子计算", { mode: "hybrid", topK: 10 });
+  const hit = rows.find((r) => r.id === m.memory.id);
+  assert.ok(hit, "blended row is recalled");
+  assert.equal(hit.score, 1, `over-weight blend clamped to 1 (got ${hit.score})`);
+  assert.ok(hit.score >= 0 && hit.score <= 1);
+});
+
 test("auto = keyword leads, vector fills the remaining slots", async () => {
   const { service, vectorIndex } = setup();
   const kw = service.saveWithDedupe({ type: "preference", title: "量子计算", content: "量子计算入门" });