recallnest 3.0.0 → 3.0.1

package/src/__tests__/llm-consolidation.test.ts

@@ -1,226 +0,0 @@
-/**
- * Tests for Tier 3.7: LLM-Driven Consolidation
- *
- * Validates:
- * 1. evaluateCluster returns merge decisions from LLM
- * 2. evaluateCluster falls back conservatively on LLM failure
- * 3. executeMergeDecisions creates version groups for merge groups
- * 4. executeMergeDecisions handles empty merge groups
- * 5. isLLMConsolidationEnabled respects env var
- */
-import { describe, expect, it, afterEach } from "bun:test";
-import {
-  evaluateCluster,
-  executeMergeDecisions,
-  isLLMConsolidationEnabled,
-} from "../llm-consolidation.js";
-import type { MemoryEntry } from "../store.js";
-import type { LLMClient } from "../llm-client.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEntry(id: string, text: string, importance = 0.7): MemoryEntry {
-  return {
-    id,
-    text,
-    vector: [1, 0, 0],
-    category: "preferences",
-    scope: "project:test",
-    importance,
-    timestamp: Date.now(),
-    metadata: JSON.stringify({ confidence: 0.7, accessCount: 0 }),
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]) {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  const updates: Array<{ id: string; metadata: string }> = [];
-
-  return {
-    data,
-    updates,
-    async getById(id: string) { return data.get(id) ?? null; },
-    async update(id: string, upd: { metadata?: string }, _scope?: string[]) {
-      const entry = data.get(id);
-      if (!entry) return null;
-      if (upd.metadata) {
-        entry.metadata = upd.metadata;
-        updates.push({ id, metadata: upd.metadata });
-      }
-      return entry;
-    },
-  };
-}
-
-function createMockLLM(response: string): LLMClient {
-  return {
-    async synthesizeFragments() {
-      return response;
-    },
-  } as any;
-}
-
-// ---------------------------------------------------------------------------
-// evaluateCluster
-// ---------------------------------------------------------------------------
-
-describe("evaluateCluster", () => {
-  it("returns merge groups from LLM response", async () => {
-    const entries = [
-      makeEntry("a", "User prefers dark mode"),
-      makeEntry("b", "User likes dark theme"),
-      makeEntry("c", "User uses vim keybindings"),
-    ];
-
-    const llm = createMockLLM(JSON.stringify({
-      mergeGroups: [[0, 1]],
-      keepSeparate: [2],
-      reasoning: "0 and 1 express same preference, 2 is different",
-    }));
-
-    const decision = await evaluateCluster(llm, entries);
-
-    expect(decision.mergeGroups.length).toBe(1);
-    expect(decision.mergeGroups[0]).toEqual([0, 1]);
-    expect(decision.keepSeparate).toEqual([2]);
-  });
-
-  it("returns conservative fallback on LLM failure", async () => {
-    const entries = [makeEntry("a", "text a"), makeEntry("b", "text b")];
-    const llm = {
-      async synthesizeFragments() { throw new Error("LLM down"); },
-    } as any;
-
-    const decision = await evaluateCluster(llm, entries);
-
-    expect(decision.mergeGroups.length).toBe(0);
-    expect(decision.keepSeparate.length).toBe(2);
-  });
-
-  it("returns conservative fallback on null response", async () => {
-    const entries = [makeEntry("a", "text a"), makeEntry("b", "text b")];
-    const llm = createMockLLM("");
-
-    // Empty string → null synthesis → fallback
-    const decision = await evaluateCluster({ async synthesizeFragments() { return null; } } as any, entries);
-
-    expect(decision.mergeGroups.length).toBe(0);
-  });
-
-  it("handles single entry", async () => {
-    const entries = [makeEntry("a", "only one")];
-    const llm = createMockLLM("{}");
-
-    const decision = await evaluateCluster(llm, entries);
-
-    expect(decision.mergeGroups.length).toBe(0);
-    expect(decision.keepSeparate).toEqual([0]);
-  });
-
-  it("filters invalid indices from LLM response", async () => {
-    const entries = [makeEntry("a", "text a"), makeEntry("b", "text b")];
-    const llm = createMockLLM(JSON.stringify({
-      mergeGroups: [[0, 5]], // index 5 out of range
-      keepSeparate: [0, 1],
-      reasoning: "test",
-    }));
-
-    const decision = await evaluateCluster(llm, entries);
-
-    // Invalid group should be filtered out
-    expect(decision.mergeGroups.length).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// executeMergeDecisions
-// ---------------------------------------------------------------------------
-
-describe("executeMergeDecisions", () => {
-  it("creates version groups for merge groups", async () => {
-    const entries = [
-      makeEntry("a", "dark mode pref", 0.9),
-      makeEntry("b", "dark theme pref", 0.5),
-      makeEntry("c", "vim pref", 0.7),
-    ];
-    const store = createMockStore(entries);
-
-    const decision = {
-      mergeGroups: [[0, 1]],
-      keepSeparate: [2],
-      reasoning: "similar preferences",
-    };
-
-    const mergeCount = await executeMergeDecisions(store as any, entries, decision, "project:test");
-
-    expect(mergeCount).toBe(1);
-    // Both a and b should now have version_group
-    const metaA = JSON.parse(store.data.get("a")!.metadata);
-    const metaB = JSON.parse(store.data.get("b")!.metadata);
-    expect(metaA.version_group).toBeTruthy();
-    expect(metaB.version_group).toBe(metaA.version_group);
-  });
-
-  it("handles empty merge groups", async () => {
-    const entries = [makeEntry("a", "text a")];
-    const store = createMockStore(entries);
-
-    const decision = {
-      mergeGroups: [],
-      keepSeparate: [0],
-      reasoning: "nothing to merge",
-    };
-
-    const mergeCount = await executeMergeDecisions(store as any, entries, decision, "project:test");
-
-    expect(mergeCount).toBe(0);
-  });
-
-  it("handles multi-entry merge group", async () => {
-    const entries = [
-      makeEntry("a", "pref 1", 0.9),
-      makeEntry("b", "pref 2", 0.7),
-      makeEntry("c", "pref 3", 0.5),
-    ];
-    const store = createMockStore(entries);
-
-    const decision = {
-      mergeGroups: [[0, 1, 2]],
-      keepSeparate: [],
-      reasoning: "all same",
-    };
-
-    const mergeCount = await executeMergeDecisions(store as any, entries, decision, "project:test");
-
-    // a is canonical, b and c are members → 2 merges
-    expect(mergeCount).toBe(2);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// isLLMConsolidationEnabled
-// ---------------------------------------------------------------------------
-
-describe("isLLMConsolidationEnabled", () => {
-  const originalEnv = process.env.RECALLNEST_LLM_CONSOLIDATION;
-
-  afterEach(() => {
-    if (originalEnv !== undefined) {
-      process.env.RECALLNEST_LLM_CONSOLIDATION = originalEnv;
-    } else {
-      delete process.env.RECALLNEST_LLM_CONSOLIDATION;
-    }
-  });
-
-  it("returns false when not set", () => {
-    delete process.env.RECALLNEST_LLM_CONSOLIDATION;
-    expect(isLLMConsolidationEnabled()).toBe(false);
-  });
-
-  it("returns true when set to 'true'", () => {
-    process.env.RECALLNEST_LLM_CONSOLIDATION = "true";
-    expect(isLLMConsolidationEnabled()).toBe(true);
-  });
-});

package/src/__tests__/maintenance-locks.test.ts

@@ -1,197 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-
-import { runDream } from "../dream-pipeline.js";
-import { maybeRunGc, resetGcTimestamp, type AutoGcConfig, DEFAULT_AUTO_GC_CONFIG } from "../auto-gc.js";
-import { lockPathForKey } from "../distill-lock.js";
-import { incrementWriteCount, getWriteCount } from "../activity-counter.js";
-
-// Isolate dream's activity-counter reads/writes to a temp file so tests never touch the
-// repo's data/activity-stats.json (which the production dream scheduler reads).
-const DREAM_STATS = join(mkdtempSync(join(tmpdir(), "rn-dream-stats-")), "activity-stats.json");
-
-/**
- * P0-1 接线回归：dream/gc 维护入口接了跨进程锁。用「预写一个当前进程 PID 的锁文件」
- * 模拟「另一进程持有锁」（同进程 PID 恒活，acquireLock 判定为被占）。
- */
-
-const createdLocks: string[] = [];
-function holdLock(key: string): string {
-  const p = lockPathForKey(key);
-  mkdirSync(dirname(p), { recursive: true });
-  writeFileSync(p, String(process.pid), "utf-8"); // current pid ⇒ acquireLock sees it as a live holder
-  createdLocks.push(p);
-  return p;
-}
-
-afterEach(() => {
-  while (createdLocks.length > 0) {
-    try {
-      rmSync(createdLocks.pop()!, { force: true });
-    } catch {
-      /* ignore */
-    }
-  }
-  resetGcTimestamp();
-});
-
-describe("runDream cross-process lock", () => {
-  it("skips (ran:false, locked) and does not run the body when the scope lock is held", async () => {
-    const scope = "project:dream-lock-test";
-    holdLock(`dream-${scope}`);
-
-    let bodyRan = false;
-    const store = {
-      stats: async () => {
-        bodyRan = true;
-        return { totalCount: 100, scopeCounts: {}, categoryCounts: {} };
-      },
-      repairSingletonVersionGroups: async () => 0,
-      list: async () => [],
-      listPage: async () => [],
-      update: async () => null,
-      patchMetadataBatch: async (patches: Array<{ id: string; patchFn: unknown }>) => patches.length,
-      patchMetadata: async () => null,
-    };
-
-    const result = await runDream({
-      store: store as any,
-      llm: null,
-      embedder: { embedPassage: async () => [0, 0, 0] },
-      scope,
-      force: true,
-      activityStatsPath: DREAM_STATS,
-    });
-
-    expect(result.ran).toBe(false);
-    expect(result.reason).toBe("locked_by_another_process");
-    expect(bodyRan).toBe(false); // runDreamInner never entered
-  });
-
-  it("skips its consolidation phase when the scope's consolidate lock is held", async () => {
-    const scope = "project:dream-consolidate-test";
-    holdLock(`consolidate-${scope}`); // simulate a standalone consolidate_memories running
-    // 2026-08-12：预置写计数，用于在末尾断言「锁被占 = 没真正处理 = 计数必须留着」。
-    incrementWriteCount(scope, 15, { statsPath: DREAM_STATS });
-
-    const activeMeta = JSON.stringify({
-      evolution: { status: "active", version: 1, accessCount: 0, lastAccessedAt: null, validFrom: Date.now(), validUntil: null },
-    });
-    const entries = [1, 2, 3].map((i) => ({
-      id: `dc-e${i}`, text: `t${i}`, vector: [1, 0, 0], category: "events", scope,
-      importance: 0.5, timestamp: Date.now(), metadata: activeMeta, language: "en", fts_text: `t${i}`,
-    }));
-    const store = {
-      stats: async () => ({ totalCount: 100, scopeCounts: {}, categoryCounts: {} }),
-      repairSingletonVersionGroups: async () => 0,
-      list: async () => entries,
-      listPage: async () => [],
-      update: async () => null,
-      patchMetadataBatch: async (patches: Array<{ id: string; patchFn: unknown }>) => patches.length,
-      patchMetadata: async () => null,
-      getById: async () => null,
-      vectorSearch: async () => [],
-    };
-
-    const result = await runDream({
-      store: store as any,
-      llm: null,
-      embedder: { embedPassage: async () => [0, 0, 0] },
-      scope,
-      force: true,
-      activityStatsPath: DREAM_STATS,
-    });
-
-    // Dream itself ran (its own dream lock was free), but the consolidation phase saw the
-    // held consolidate lock and skipped rather than running concurrently.
-    expect(result.ran).toBe(true);
-    const consolidatePhase = result.phases.find((p) => p.phase === "consolidate");
-    expect(consolidatePhase?.detail).toContain("skipped");
-
-    // 2026-08-12 防「修过头」：末尾的 reset 必须是 `if (consolidateOutcome.ran)` 条件式。
-    // 锁被占时这个 scope 并没有被真正处理完，若无条件清计数，它会被当成「已处理」而
-    // 丢掉本轮积累的写入，下次要重新攒够阈值才轮得到 —— 是比原 bug 更隐蔽的数据损失。
-    // 注意本条不是必红测试：修复前的无参 resetWriteCount() 什么也不清，同样是绿。
-    // 它守的是修复的形状，不是修复的存在（存在性由 dream-pipeline.test.ts 那条守）。
-    expect(getWriteCount(scope, { statsPath: DREAM_STATS })).toBe(15);
-  });
-
-  it("resets the scope's write counter after a run (no perpetual self-triggering)", async () => {
-    const scope = "project:dream-reset-test";
-    const statsPath = join(mkdtempSync(join(tmpdir(), "rn-reset-")), "activity-stats.json");
-    // Pre-load above threshold, standing in for accumulated writes (incl. any dream self-writes).
-    incrementWriteCount(scope, 15, { statsPath });
-    expect(getWriteCount(scope, { statsPath })).toBe(15);
-
-    const store = {
-      stats: async () => ({ totalCount: 5, scopeCounts: {}, categoryCounts: {} }),
-      repairSingletonVersionGroups: async () => 0,
-      // ⚠️ 2026-08-12 标注：这里 list 返回空数组，走的是 **completed_early 早退路径**，
-      // 而早退路径 (dream-pipeline.ts:226) 的 resetWriteCount(scope, statsCfg) 一直是对的。
-      // 本条测试因此从未覆盖「完整跑完」那条路径 —— 而 bug 恰恰在那条路径上（:301 漏传 scope）。
-      // 测试名 "resets the scope's write counter after a run" 读起来像覆盖了 reset 全部行为，
-      // 实际只覆盖了两条路径中正确的那一条，于是 bug 在有测试的情况下活了 41 天。
-      // 完整路径的覆盖已补在 dream-pipeline.test.ts「清空已处理 scope 的写计数」一条。
-      list: async () => [], // no active entries → completed_early path (still resets)
-      listPage: async () => [],
-      update: async () => null,
-      patchMetadataBatch: async (patches: Array<{ id: string; patchFn: unknown }>) => patches.length,
-      patchMetadata: async () => null,
-      getById: async () => null,
-      vectorSearch: async () => [],
-    };
-    const result = await runDream({
-      store: store as any,
-      llm: null,
-      embedder: { embedPassage: async () => [0, 0, 0] },
-      scope,
-      force: true,
-      activityStatsPath: statsPath,
-    });
-
-    expect(result.ran).toBe(true);
-    // Reset at dream's end clears the counter, so dream won't immediately self-retrigger —
-    // fresh external writes must accumulate past the threshold again.
-    expect(getWriteCount(scope, { statsPath })).toBe(0);
-  });
-});
-
-describe("maybeRunGc cross-process lock + throttle", () => {
-  function makeStore(totalCount: number) {
-    return {
-      stats: async () => ({ totalCount, scopeCounts: {}, categoryCounts: {} }),
-      repairSingletonVersionGroups: async () => 0,
-      listPage: async () => [] as unknown[],
-      update: async () => null,
-      patchMetadataBatch: async (patches: Array<{ id: string; patchFn: unknown }>) => patches.length,
-      list: async () => [],
-    } as any;
-  }
-
-  it("skips (locked) when another process holds the gc run lock", async () => {
-    resetGcTimestamp();
-    holdLock("gc-run");
-    const config: AutoGcConfig = { ...DEFAULT_AUTO_GC_CONFIG, minMemoryCount: 1, minHoursSinceLastGc: 24 };
-    const result = await maybeRunGc(makeStore(10), config);
-    expect(result.triggered).toBe(false);
-    expect(result.reason).toBe("locked_by_another_process");
-  });
-
-  it("throttles a second run within the window, then runs again after reset", async () => {
-    resetGcTimestamp();
-    const config: AutoGcConfig = { ...DEFAULT_AUTO_GC_CONFIG, minMemoryCount: 1, minHoursSinceLastGc: 24 };
-
-    const first = await maybeRunGc(makeStore(10), config);
-    expect(first.triggered).toBe(true);
-
-    const second = await maybeRunGc(makeStore(10), config);
-    expect(second.triggered).toBe(false);
-    expect(second.reason).toBe("too_soon");
-
-    resetGcTimestamp();
-    const third = await maybeRunGc(makeStore(10), config);
-    expect(third.triggered).toBe(true);
-  });
-});