recallnest 3.0.0 → 3.0.1

package/src/__tests__/hotness-blend.test.ts

@@ -1,283 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { computeHotnessScore, parseAccessMetadata } from "../access-tracker.js";
-import { TraceCollector } from "../retrieval-trace.js";
-import {
-  createRetriever,
-  DEFAULT_CATEGORY_MIN_SCORES,
-} from "../retriever.js";
-
-function applyHotnessBlend(
-  score: number,
-  accessCount: number,
-  lastAccessedAt: number,
-): number {
-  const retriever = createRetriever({} as any, {} as any, { hotnessWeight: 0.15 });
-  retriever.setAccessTracker({} as any);
-  const results = [{
-    entry: {
-      id: "hotness-test",
-      text: "hotness test",
-      vector: [],
-      category: "events",
-      scope: "test:hotness",
-      importance: 0.5,
-      timestamp: Date.now(),
-      metadata: JSON.stringify({ accessCount, lastAccessedAt }),
-    },
-    score,
-    sources: {},
-  }];
-  return (retriever as any).applyHotnessBlend(results)[0].score;
-}
-
-describe("computeHotnessScore", () => {
-  it("returns 0 for zero accesses", () => {
-    expect(computeHotnessScore(0, Date.now())).toBe(0);
-  });
-
-  it("returns positive score for accessed memories", () => {
-    const score = computeHotnessScore(5, Date.now());
-    expect(score).toBeGreaterThan(0);
-    expect(score).toBeLessThanOrEqual(1);
-  });
-
-  it("higher access count yields higher score", () => {
-    const now = Date.now();
-    const low = computeHotnessScore(1, now);
-    const mid = computeHotnessScore(5, now);
-    const high = computeHotnessScore(50, now);
-    expect(low).toBeLessThan(mid);
-    expect(mid).toBeLessThan(high);
-  });
-
-  it("recent access yields higher score than old access", () => {
-    const now = Date.now();
-    const recent = computeHotnessScore(5, now);
-    const weekAgo = computeHotnessScore(5, now - 7 * 86_400_000);
-    const monthAgo = computeHotnessScore(5, now - 30 * 86_400_000);
-    expect(recent).toBeGreaterThan(weekAgo);
-    expect(weekAgo).toBeGreaterThan(monthAgo);
-  });
-
-  it("decays to near-zero for very old accesses", () => {
-    const score = computeHotnessScore(5, Date.now() - 365 * 86_400_000);
-    expect(score).toBeLessThan(0.01);
-  });
-
-  it("caps at 1.0 even with extreme access counts", () => {
-    const score = computeHotnessScore(10_000, Date.now());
-    expect(score).toBeLessThanOrEqual(1.0);
-  });
-
-  it("respects custom decay rate", () => {
-    const now = Date.now();
-    const fast = computeHotnessScore(5, now - 7 * 86_400_000, 0.5);
-    const slow = computeHotnessScore(5, now - 7 * 86_400_000, 0.01);
-    expect(slow).toBeGreaterThan(fast);
-  });
-});
-
-describe("parseAccessMetadata", () => {
-  it("parses valid metadata", () => {
-    const meta = JSON.stringify({ accessCount: 5, lastAccessedAt: 1234567890 });
-    const result = parseAccessMetadata(meta);
-    expect(result.accessCount).toBe(5);
-    expect(result.lastAccessedAt).toBe(1234567890);
-  });
-
-  it("returns defaults for missing fields", () => {
-    const result = parseAccessMetadata("{}");
-    expect(result.accessCount).toBe(0);
-    expect(result.lastAccessedAt).toBe(0);
-  });
-
-  it("handles undefined input", () => {
-    const result = parseAccessMetadata(undefined);
-    expect(result.accessCount).toBe(0);
-    expect(result.lastAccessedAt).toBe(0);
-  });
-
-  it("handles malformed JSON", () => {
-    const result = parseAccessMetadata("not-json");
-    expect(result.accessCount).toBe(0);
-    expect(result.lastAccessedAt).toBe(0);
-  });
-});
-
-describe("applyHotnessBlend", () => {
-  it("does not penalize a zero-access row", () => {
-    expect(applyHotnessBlend(0.6, 0, 0)).toBe(0.6);
-  });
-
-  it("preserves the existing blend formula for an accessed row", () => {
-    const futureAccess = Date.now() + 60_000;
-    const hotness = computeHotnessScore(5, futureAccess);
-    expect(applyHotnessBlend(0.6, 5, futureAccess)).toBeCloseTo(
-      0.6 * 0.85 + hotness * 0.15,
-      12,
-    );
-  });
-
-  it("still applies the existing penalty when an accessed row's hotness decays to zero", () => {
-    expect(computeHotnessScore(1, 1)).toBe(0);
-    expect(applyHotnessBlend(0.6, 1, 1)).toBeCloseTo(0.6 * 0.85, 12);
-  });
-});
-
-describe("cold-start hotness pipeline regression", () => {
-  it("recalls a78ad478 without dropping control dd05b422", async () => {
-    const query = "owner 模型 任务锁 并发 谁在干活 责任层 资源层";
-    const now = Date.now();
-    const text = `${query} `.repeat(80).slice(0, 1900);
-
-    expect(text).toHaveLength(1900);
-
-    function metadata(
-      source: "agent" | "manual",
-      confidence: number,
-      accessCount: number,
-    ): string {
-      const lastAccessedAt = accessCount > 0 ? now : 0;
-
-      return JSON.stringify({
-        source,
-        confidence: {
-          score: confidence,
-          reliability: source === "manual" ? "direct" : "inferred",
-        },
-        accessCount,
-        lastAccessedAt,
-        boundary: {
-          layer: "durable",
-          authority: "structured-memory",
-          conflictPolicy: "latest-wins",
-          originalCategory: "patterns",
-        },
-        evolution: {
-          status: "active",
-          version: 1,
-          accessCount,
-          lastAccessedAt: accessCount > 0 ? lastAccessedAt : null,
-          validFrom: now,
-          validUntil: null,
-        },
-      });
-    }
-
-    const candidates = [
-      {
-        entry: {
-          id: "a78ad478",
-          text,
-          vector: [1, 0, 0],
-          category: "patterns",
-          scope: "project:hippo-wiki",
-          importance: 0.8,
-          timestamp: now,
-          metadata: metadata("agent", 0.7, 0),
-        },
-        score: 0.8628,
-      },
-      {
-        entry: {
-          id: "dd05b422",
-          text,
-          vector: [0.99, 0.01, 0],
-          category: "patterns",
-          scope: "project:hippo-wiki",
-          importance: 0.8,
-          timestamp: now,
-          metadata: metadata("manual", 0.9, 4),
-        },
-        score: 0.8579,
-      },
-    ];
-
-    let vectorSearchCalls = 0;
-
-    const store = {
-      hasFtsSupport: false,
-      async vectorSearch(
-        _queryVector: number[],
-        limit: number,
-        minScore: number,
-        scopeFilter?: string[],
-      ) {
-        vectorSearchCalls += 1;
-        return candidates
-          .filter(candidate => candidate.score >= minScore)
-          .filter(candidate =>
-            !scopeFilter || scopeFilter.includes(candidate.entry.scope),
-          )
-          .slice(0, limit);
-      },
-    };
-
-    const embedder = {
-      async embedQuery() {
-        return [1, 0, 0];
-      },
-      async embedPassage() {
-        return [1, 0, 0];
-      },
-    };
-
-    const retriever = createRetriever(
-      store as any,
-      embedder as any,
-      {
-        mode: "vector",
-        rerank: "none",
-        candidatePoolSize: 5,
-        minScore: 0.3,
-        hardMinScore: 0.38,
-        recencyHalfLifeDays: 14,
-        recencyWeight: 0.15,
-        lengthNormAnchor: 700,
-        timeDecayHalfLifeDays: 60,
-        hotnessWeight: 0.15,
-        filterNoise: false,
-        enableRIF: false,
-        sourceDiversity: 0,
-        multiHop: false,
-      },
-    );
-
-    retriever.setAccessTracker({
-      computeEffectiveHalfLife(baseHalfLife: number) {
-        return baseHalfLife;
-      },
-      recordAccess() {
-        throw new Error("pipeline regression must not record access");
-      },
-    } as any);
-
-    const trace = new TraceCollector();
-    const results = await retriever.retrieve({
-      query,
-      limit: 5,
-      scopeFilter: ["project:hippo-wiki"],
-      category: "patterns",
-      source: "auto-recall",
-      trace,
-    });
-
-    const ids = results.map(result => result.entry.id);
-    const cold = results.find(result => result.entry.id === "a78ad478");
-    const hardMin = trace
-      .finalize(query, "vector")
-      .stages.find(stage => stage.name === "hard_min_score");
-
-    expect(ids).toContain("a78ad478");
-    expect(ids).toContain("dd05b422");
-    expect(cold?.score).toBeGreaterThanOrEqual(
-      DEFAULT_CATEGORY_MIN_SCORES.patterns,
-    );
-    expect(hardMin).toMatchObject({
-      inputCount: 2,
-      outputCount: 2,
-      droppedCount: 0,
-    });
-    expect(vectorSearchCalls).toBe(1);
-  });
-});

package/src/__tests__/ingest-chunking.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { groupTurnsIntoChunks } from "../ingest.js";
-import { isNoise } from "../noise-filter.js";
-
-// P1 defence-in-depth: groupTurnsIntoChunks pre-filters whole turns via
-// filterNoiseTurns BEFORE chunking, but long turns then get split — and the
-// split fragments were never re-checked. A long turn whose tail is orphaned
-// context-JSON therefore leaks severed JSON field-lines as standalone chunks.
-// This guards that no chunk survives as noise, without over-deleting real talk.
-
-function userTurn(text: string) {
-  return { role: "user" as const, text, timestamp: "2026-05-21T00:00:00Z", sessionId: "s1" };
-}
-function assistantTurn(text: string) {
-  return { role: "assistant" as const, text, timestamp: "2026-05-21T00:00:01Z", sessionId: "s1" };
-}
-
-describe("groupTurnsIntoChunks — post-split noise filtering (P1)", () => {
-  it("drops severed context-JSON fragments produced by splitting a long turn", () => {
-    // Real-content opener (passes turn-level filterNoiseTurns), then a long tail
-    // of orphaned JSON field-lines that chunking peels into standalone chunks.
-    const opener = "我们今天把记忆系统这周的进展过一遍，重点是噪声治理和召回质量的提升。".repeat(8);
-    const jsonTail = Array.from(
-      { length: 60 },
-      (_, i) => `"time": "2026-05-21T15:${String(i).padStart(2, "0")}:03.796Z",`,
-    ).join("\n");
-    const chunks = groupTurnsIntoChunks([userTurn(`${opener}\n${jsonTail}`)]);
-
-    expect(chunks.length).toBeGreaterThan(0); // real content survives
-    // No chunk may survive as a recognizable noise fragment.
-    expect(chunks.every((c) => !isNoise(c.text))).toBe(true);
-  });
-
-  it("keeps a normal long Q&A conversation intact (no over-deletion)", () => {
-    const longQuestion = "你帮我想想这个方案怎么落地，我担心几个点没考虑周全，得一起捋一捋。".repeat(20);
-    const longAnswer = "可以分三步走，先做最小验证看效果，再逐步扩展覆盖面，最后补回归测试兜底。".repeat(20);
-    const chunks = groupTurnsIntoChunks([userTurn(longQuestion), assistantTurn(longAnswer)]);
-
-    expect(chunks.length).toBeGreaterThan(0);
-    expect(chunks.every((c) => !isNoise(c.text))).toBe(true); // real talk not deleted
-    expect(chunks.some((c) => c.text.includes("最小验证"))).toBe(true); // content retained
-  });
-});

package/src/__tests__/ingest-scope-prefix.test.ts

@@ -1,69 +0,0 @@
-/**
- * 每个会话来源的 scope 前缀必须在 memory-boundaries 的清单里登记。
- *
- * 这条约束是承重的，不是整洁问题：TRANSCRIPT_SCOPE_PREFIXES 决定了会话碎片
- * 会不会被降权到 evidence 层。漏登记一个前缀，那个端的 shell 输出就会被当成
- * 「用户说过的话」提炼成 durable 结论——kimi 与 antigravity 就这么漏过
- * （2026-07 进栈，直到 2026-08-01 才发现库里一直被当结论对待）。
- *
- * 所以加新 ingest 源时，这个测试会在你只改了 config.json / cli.ts 却忘了
- * 登记前缀的时候变红。
- */
-import { describe, expect, it } from "bun:test";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { isTranscriptIngestSource, isTranscriptScope } from "../memory-boundaries.js";
-
-const config = JSON.parse(
-  readFileSync(join(import.meta.dir, "..", "..", "config.json"), "utf8"),
-) as { sources: Record<string, { path: string; glob: string; description?: string }> };
-
-// config 源名 → 它写进库的 scope 前缀。
-// desktop 沿用 cc 前缀是历史行为（Claude Desktop 导出的就是 CC 格式对话）。
-const SOURCE_SCOPE_PREFIX: Record<string, string | null> = {
-  cc: "cc",
-  codex: "codex",
-  gemini: "gemini",
-  kimi: "kimi",
-  desktop: "cc",
-  minis: "minis",
-  memory: null, // markdown 记忆文件，不是会话记录，不走 transcript 降权
-};
-
-describe("ingest 源的 scope 前缀登记", () => {
-  it("config.json 里每个源都在本测试的映射表里有交代", () => {
-    for (const name of Object.keys(config.sources)) {
-      expect(
-        Object.prototype.hasOwnProperty.call(SOURCE_SCOPE_PREFIX, name),
-      ).toBe(true);
-    }
-  });
-
-  it("每个会话类来源的 scope 都被判定为 transcript 证据（会被降权）", () => {
-    for (const [name, prefix] of Object.entries(SOURCE_SCOPE_PREFIX)) {
-      if (prefix === null) continue;
-      // 断言里带上源名，红的时候直接看得出是哪个源漏登记
-      expect(`${name}:${isTranscriptScope(`${prefix}:abcd1234`)}`).toBe(`${name}:true`);
-    }
-  });
-
-  it("minis 源已接线：config 有条目且前缀被降权识别", () => {
-    expect(config.sources.minis).toBeDefined();
-    expect(config.sources.minis.glob).toBe("*.jsonl");
-    expect(isTranscriptScope("minis:9f3e7a21")).toBe(true);
-  });
-
-  it("同一个前缀也必须在 source 清单里登记（两道闸，漏一道就静默失真）", () => {
-    // isTranscriptScope 看 scope、isTranscriptSource 看条目的 source 字段。
-    // 只登记前者时降权仍然生效，错误不会报出来，只会让「按来源过滤」查不准。
-    for (const [name, prefix] of Object.entries(SOURCE_SCOPE_PREFIX)) {
-      if (prefix === null) continue;
-      expect(`${name}:${isTranscriptIngestSource(prefix)}`).toBe(`${name}:true`);
-    }
-  });
-
-  it("一条反向断言：没登记过的前缀不会被误判成 transcript", () => {
-    expect(isTranscriptScope("project:recallnest")).toBe(false);
-    expect(isTranscriptScope("memory:pivot")).toBe(false);
-  });
-});