recallnest 3.0.0 → 3.0.1

package/src/__tests__/ui-server-security.test.ts

@@ -1,93 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  enforceLocalHttpRequestPolicy,
-  LOCAL_HTTP_HOSTNAME,
-  LOCAL_JSON_BODY_LIMIT_BYTES,
-} from "../http-request-policy.js";
-
-function uiRequest({
-  method = "GET",
-  host = "127.0.0.1:4317",
-  headers = {},
-  body,
-}: {
-  method?: string;
-  host?: string;
-  headers?: Record<string, string>;
-  body?: string;
-} = {}): Request {
-  return new Request("http://127.0.0.1:4317/api/search", {
-    method,
-    headers: { host, ...headers },
-    body,
-  });
-}
-
-describe("RecallNest UI local HTTP policy", () => {
-  test("binds the UI to the IPv4 loopback interface", () => {
-    expect(LOCAL_HTTP_HOSTNAME).toBe("127.0.0.1");
-  });
-
-  test("allows same-origin browser requests", async () => {
-    const result = await enforceLocalHttpRequestPolicy(uiRequest({
-      method: "POST",
-      headers: {
-        "content-type": "application/json; charset=utf-8",
-        origin: "http://127.0.0.1:4317",
-        "sec-fetch-site": "same-origin",
-      },
-      body: JSON.stringify({ query: "local" }),
-    }));
-
-    expect(result).toEqual({ allowed: true });
-  });
-
-  test("rejects a non-local Host header", async () => {
-    const result = await enforceLocalHttpRequestPolicy(uiRequest({
-      host: "attacker.example",
-    }));
-
-    expect(result).toEqual({ allowed: false, status: 403, message: "Host is not allowed." });
-  });
-
-  test("rejects cross-origin and cross-site browser requests", async () => {
-    const wrongOrigin = await enforceLocalHttpRequestPolicy(uiRequest({
-      headers: { origin: "https://attacker.example" },
-    }));
-    const crossSite = await enforceLocalHttpRequestPolicy(uiRequest({
-      headers: { "sec-fetch-site": "cross-site" },
-    }));
-
-    expect(wrongOrigin).toEqual({ allowed: false, status: 403, message: "Origin is not allowed." });
-    expect(crossSite).toEqual({ allowed: false, status: 403, message: "Cross-site requests are not allowed." });
-  });
-
-  test("rejects non-JSON POST bodies", async () => {
-    const result = await enforceLocalHttpRequestPolicy(uiRequest({
-      method: "POST",
-      headers: { "content-type": "text/plain" },
-      body: JSON.stringify({ query: "local" }),
-    }));
-
-    expect(result).toEqual({
-      allowed: false,
-      status: 415,
-      message: "Content-Type must be application/json.",
-    });
-  });
-
-  test("rejects streamed JSON bodies over the limit", async () => {
-    const result = await enforceLocalHttpRequestPolicy(uiRequest({
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ query: "x".repeat(LOCAL_JSON_BODY_LIMIT_BYTES) }),
-    }));
-
-    expect(result).toEqual({
-      allowed: false,
-      status: 413,
-      message: `Request body exceeds ${LOCAL_JSON_BODY_LIMIT_BYTES} bytes.`,
-    });
-  });
-});

package/src/__tests__/usage-tracker.test.ts

@@ -1,287 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  getUsageMetadata,
-  computeUsageStatus,
-  buildUsagePatch,
-  recordMemoryUsage,
-  recordReconstructionUsage,
-  deriveUsageStatus,
-  USAGE_COLD_INJECTION_THRESHOLD,
-  type UsageMetadata,
-  type UsageStorePort,
-} from "../usage-tracker.js";
-import type { MemoryEntry } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const ID = "11111111-1111-1111-1111-111111111111";
-
-function makeEntry(id: string, meta: Record<string, unknown> = {}): MemoryEntry {
-  return {
-    id,
-    text: "t",
-    vector: [1, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: 1000,
-    metadata: JSON.stringify(meta),
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]): {
-  store: UsageStorePort;
-  data: Map<string, MemoryEntry>;
-  updates: Array<{ id: string; metadata: string }>;
-} {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  const updates: Array<{ id: string; metadata: string }> = [];
-  // 模拟 store.patchMetadata 的真实语义:读最新 metadata → patchFn → 写回。
-  const store: UsageStorePort = {
-    async patchMetadata(id, patchFn, _scopeFilter) {
-      const entry = data.get(id);
-      if (!entry) return null;
-      let meta: Record<string, unknown>;
-      try {
-        const parsed: unknown = JSON.parse(entry.metadata || "{}");
-        meta = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
-          ? (parsed as Record<string, unknown>)
-          : {};
-      } catch {
-        meta = {};
-      }
-      const patched = patchFn(meta, entry);
-      entry.metadata = JSON.stringify(patched);
-      updates.push({ id, metadata: entry.metadata });
-      return entry;
-    },
-  };
-  return { store, data, updates };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("usage-tracker", () => {
-  describe("getUsageMetadata", () => {
-    it("returns useCount 0 for entry without usage", () => {
-      expect(getUsageMetadata(makeEntry(ID)).useCount).toBe(0);
-    });
-
-    it("returns 0 for malformed metadata", () => {
-      const e: MemoryEntry = { ...makeEntry(ID), metadata: "not-json" };
-      expect(getUsageMetadata(e).useCount).toBe(0);
-    });
-
-    it("reads stored usage fields", () => {
-      const e = makeEntry(ID, { usage: { useCount: 3, firstUsedAt: 1, lastUsedAt: 5, usageStatus: "warm" } });
-      const u = getUsageMetadata(e);
-      expect(u.useCount).toBe(3);
-      expect(u.lastUsedAt).toBe(5);
-      expect(u.usageStatus).toBe("warm");
-    });
-
-    it("ignores invalid usageStatus value", () => {
-      const e = makeEntry(ID, { usage: { useCount: 1, usageStatus: "bogus" } });
-      expect(getUsageMetadata(e).usageStatus).toBeUndefined();
-    });
-
-    it("malformed metadata='null' does not crash", () => {
-      const e: MemoryEntry = { ...makeEntry(ID), metadata: "null" };
-      expect(getUsageMetadata(e).useCount).toBe(0);
-      expect(() => buildUsagePatch(e, 100)).not.toThrow();
-    });
-
-    it("malformed array metadata does not crash", () => {
-      const e: MemoryEntry = { ...makeEntry(ID), metadata: "[1,2,3]" };
-      expect(getUsageMetadata(e).useCount).toBe(0);
-      expect(deriveUsageStatus(e)).toBe("unused");
-    });
-  });
-
-  describe("computeUsageStatus (复刻 Orb decay_tick)", () => {
-    it("unused: no injections, no uses", () => {
-      expect(computeUsageStatus(0, 0)).toBe("unused");
-    });
-
-    it("unused: just below cold threshold, zero uses", () => {
-      expect(computeUsageStatus(USAGE_COLD_INJECTION_THRESHOLD - 1, 0)).toBe("unused");
-    });
-
-    it("cold: AT injection threshold with zero uses (核心边界 inj=6 & use=0)", () => {
-      expect(computeUsageStatus(USAGE_COLD_INJECTION_THRESHOLD, 0)).toBe("cold");
-    });
-
-    it("cold: well above threshold, zero uses", () => {
-      expect(computeUsageStatus(20, 0)).toBe("cold");
-    });
-
-    it("warm: used but ratio below hot (1/10=0.1)", () => {
-      expect(computeUsageStatus(10, 1)).toBe("warm");
-    });
-
-    it("hot: use/injection ratio meets HOT_RATIO (3/10=0.3)", () => {
-      expect(computeUsageStatus(10, 3)).toBe("hot");
-    });
-
-    it("warm: used with zero injections (no div-by-zero → hot)", () => {
-      expect(computeUsageStatus(0, 2)).toBe("warm");
-    });
-  });
-
-  describe("buildUsagePatch", () => {
-    it("returns null for null entry", () => {
-      expect(buildUsagePatch(null, 100)).toBeNull();
-    });
-
-    it("first use: 0 -> 1, sets first/lastUsedAt", () => {
-      const patch = buildUsagePatch(makeEntry(ID), 100);
-      expect(patch).not.toBeNull();
-      const usage = patch!.metadata.usage as UsageMetadata;
-      expect(usage.useCount).toBe(1);
-      expect(usage.firstUsedAt).toBe(100);
-      expect(usage.lastUsedAt).toBe(100);
-      expect(patch!.update.oldUseCount).toBe(0);
-      expect(patch!.update.newUseCount).toBe(1);
-    });
-
-    it("accumulates useCount, preserves firstUsedAt, updates lastUsedAt", () => {
-      const e = makeEntry(ID, { usage: { useCount: 2, firstUsedAt: 50 } });
-      const patch = buildUsagePatch(e, 200);
-      const usage = patch!.metadata.usage as UsageMetadata;
-      expect(usage.useCount).toBe(3);
-      expect(usage.firstUsedAt).toBe(50);
-      expect(usage.lastUsedAt).toBe(200);
-    });
-
-    it("双计数互不污染：不动 accessCount / confidence / evolution / tier", () => {
-      const e = makeEntry(ID, {
-        accessCount: 9,
-        confidence: 0.9,
-        evolution: { accessCount: 4 },
-        tier: "core",
-      });
-      const m = buildUsagePatch(e, 100)!.metadata;
-      expect(m.accessCount).toBe(9);
-      expect(m.confidence).toBe(0.9);
-      expect((m.evolution as { accessCount: number }).accessCount).toBe(4);
-      expect(m.tier).toBe("core");
-    });
-
-    it("不写 usageStatus（status 留 deriveUsageStatus 离线算，避免假 cold）", () => {
-      const e = makeEntry(ID, { accessCount: 8 });
-      const patch = buildUsagePatch(e, 100);
-      const usage = patch!.metadata.usage as UsageMetadata;
-      expect(usage.usageStatus).toBeUndefined();
-      expect("status" in patch!.update).toBe(false);
-    });
-
-    it("does not emit any ranking multiplier / score field (影子定位)", () => {
-      const patch = buildUsagePatch(makeEntry(ID), 100);
-      const update = patch!.update as Record<string, unknown>;
-      expect(update.scoreMultiplier).toBeUndefined();
-      expect(update.weight).toBeUndefined();
-    });
-  });
-
-  describe("deriveUsageStatus (离线按需，cold 可达)", () => {
-    it("cold: accessCount>=6 且从未被引用（无 usage 字段）", () => {
-      expect(deriveUsageStatus(makeEntry(ID, { accessCount: 8 }))).toBe("cold");
-    });
-    it("cold: accessCount=6 边界 + useCount 0", () => {
-      expect(deriveUsageStatus(makeEntry(ID, { accessCount: 6, usage: { useCount: 0 } }))).toBe("cold");
-    });
-    it("unused: 低 injection 从未被引用", () => {
-      expect(deriveUsageStatus(makeEntry(ID, { accessCount: 2 }))).toBe("unused");
-    });
-    it("warm: 被引用但比例低", () => {
-      expect(deriveUsageStatus(makeEntry(ID, { accessCount: 10, usage: { useCount: 1 } }))).toBe("warm");
-    });
-    it("hot: use/injection 达标", () => {
-      expect(deriveUsageStatus(makeEntry(ID, { accessCount: 10, usage: { useCount: 3 } }))).toBe("hot");
-    });
-  });
-
-  describe("recordMemoryUsage", () => {
-    it("returns null and skips update when entry not found", async () => {
-      const { store, updates } = createMockStore([]);
-      const res = await recordMemoryUsage(store, "missing", 100);
-      expect(res).toBeNull();
-      expect(updates.length).toBe(0);
-    });
-
-    it("writes full metadata back with usage, preserving other fields", async () => {
-      const e = makeEntry(ID, { accessCount: 3, confidence: 0.8 });
-      const { store, updates, data } = createMockStore([e]);
-      const res = await recordMemoryUsage(store, ID, 100);
-      expect(res!.newUseCount).toBe(1);
-      expect(updates.length).toBe(1);
-      const written = JSON.parse(updates[0].metadata) as Record<string, unknown>;
-      expect((written.usage as UsageMetadata).useCount).toBe(1);
-      expect(written.accessCount).toBe(3);
-      expect(written.confidence).toBe(0.8);
-      const persisted = JSON.parse(data.get(ID)!.metadata ?? "{}") as Record<string, unknown>;
-      expect((persisted.usage as UsageMetadata).useCount).toBe(1);
-    });
-
-    it("second call accumulates useCount to 2", async () => {
-      const { store } = createMockStore([makeEntry(ID)]);
-      await recordMemoryUsage(store, ID, 100);
-      const res2 = await recordMemoryUsage(store, ID, 200);
-      expect(res2!.newUseCount).toBe(2);
-    });
-
-    it("passes scope through to store.patchMetadata when provided", async () => {
-      const captured: Array<string[] | undefined> = [];
-      const base = createMockStore([makeEntry(ID)]);
-      const store: UsageStorePort = {
-        async patchMetadata(id, patchFn, scopeFilter) {
-          captured.push(scopeFilter);
-          return base.store.patchMetadata(id, patchFn, scopeFilter);
-        },
-      };
-      await recordMemoryUsage(store, ID, 100, "project:test");
-      expect(captured[0]).toEqual(["project:test"]);
-    });
-  });
-
-  describe("recordReconstructionUsage (批量影子)", () => {
-    it("no-op on empty array", async () => {
-      const { store, updates } = createMockStore([]);
-      await recordReconstructionUsage(store, [], 100);
-      expect(updates.length).toBe(0);
-    });
-
-    it("records useCount=1 for each distinct cited id", async () => {
-      const { store, data } = createMockStore([makeEntry("mem-a"), makeEntry("mem-b")]);
-      await recordReconstructionUsage(store, ["mem-a", "mem-b"], 100);
-      const a = JSON.parse(data.get("mem-a")!.metadata ?? "{}") as Record<string, unknown>;
-      const b = JSON.parse(data.get("mem-b")!.metadata ?? "{}") as Record<string, unknown>;
-      expect((a.usage as UsageMetadata).useCount).toBe(1);
-      expect((b.usage as UsageMetadata).useCount).toBe(1);
-    });
-
-    it("dedupes repeated ids within one call (writes once)", async () => {
-      const { store, updates } = createMockStore([makeEntry(ID)]);
-      await recordReconstructionUsage(store, [ID, ID, ID], 100);
-      expect(updates.length).toBe(1);
-    });
-
-    it("one failing id does not block others (allSettled, no throw)", async () => {
-      const base = createMockStore([makeEntry(ID)]);
-      const store: UsageStorePort = {
-        async patchMetadata(id, patchFn, scopeFilter) {
-          if (id === "bad") throw new Error("boom");
-          return base.store.patchMetadata(id, patchFn, scopeFilter);
-        },
-      };
-      await recordReconstructionUsage(store, ["bad", ID], 100);
-      const good = JSON.parse(base.data.get(ID)!.metadata ?? "{}") as Record<string, unknown>;
-      expect((good.usage as UsageMetadata).useCount).toBe(1);
-    });
-  });
-});

package/src/__tests__/utility-weight.test.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { createRetriever } from "../retriever.js";
-import { UTILITY_FIELD } from "../memory-utility.js";
-
-function run(utilityWeight: number, utilities: Array<number | null>): number[] {
-  const retriever = createRetriever({} as any, {} as any, { utilityWeight });
-  const results = utilities.map((u, i) => ({
-    entry: {
-      id: `u-${i}`,
-      text: "utility test",
-      vector: [],
-      category: "cases",
-      scope: "test:utility",
-      importance: 0.7,
-      timestamp: Date.now(),
-      metadata: JSON.stringify(u === null ? { tier: "peripheral" } : { [UTILITY_FIELD]: u }),
-    },
-    score: 0.5,
-    sources: {},
-  }));
-  const out = (retriever as any).applyUtilityWeight(results) as Array<{ entry: { id: string }; score: number }>;
-  // 按原顺序取回分数（该 stage 会重排）
-  return utilities.map((_, i) => out.find(r => r.entry.id === `u-${i}`)!.score);
-}
-
-describe("applyUtilityWeight", () => {
-  it("is a no-op at the default weight of 0", () => {
-    expect(run(0, [0.8, -0.8, null])).toEqual([0.5, 0.5, 0.5]);
-  });
-
-  it("lifts positive utility and sinks negative utility", () => {
-    const [positive, negative, absent] = run(0.2, [0.8, -0.8, null]);
-    expect(positive).toBeGreaterThan(0.5);
-    expect(negative).toBeLessThan(0.5);
-    // 没有 utility 的条目原样放行 —— 「没数据」不该被当成差评（bonus-only 冷启动）。
-    expect(absent).toBe(0.5);
-  });
-
-  it("keeps scores inside [0,1] even at weight 1 with the most negative utility", () => {
-    const [score] = run(1, [-0.8]);
-    expect(score).toBeGreaterThanOrEqual(0);
-    expect(score).toBeLessThanOrEqual(1);
-  });
-
-  it("ignores broken metadata instead of throwing", () => {
-    const retriever = createRetriever({} as any, {} as any, { utilityWeight: 0.3 });
-    const results = [{
-      entry: {
-        id: "broken", text: "x", vector: [], category: "cases", scope: "s",
-        importance: 0.5, timestamp: Date.now(), metadata: "{not json",
-      },
-      score: 0.42,
-      sources: {},
-    }];
-    expect((retriever as any).applyUtilityWeight(results)[0].score).toBe(0.42);
-  });
-});