recallnest 2.2.0 → 2.2.1

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

@@ -1,168 +0,0 @@
-import { describe, expect, it, beforeEach } from "bun:test";
-
-import {
-  maybeConsolidate,
-  resetConsolidationState,
-  DEFAULT_AUTO_CONSOLIDATION_CONFIG,
-  type AutoConsolidationConfig,
-} from "../auto-consolidation.js";
-import type { MemoryEntry, MemorySearchResult } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEntry(id: string, text: string, overrides: Partial<MemoryEntry> = {}): MemoryEntry {
-  return {
-    id,
-    text,
-    vector: [1, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: "{}",
-    ...overrides,
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]) {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  return {
-    async list(scopeFilter?: string[], _category?: string, limit = 500, _offset = 0) {
-      return [...data.values()]
-        .filter(e => !scopeFilter || scopeFilter.some(s => e.scope === s))
-        .slice(0, limit);
-    },
-    async getById(id: string) {
-      return data.get(id) ?? null;
-    },
-    async vectorSearch(_vector: number[], _limit = 5, _minScore = 0.3, _scopeFilter?: string[]) {
-      return [] as MemorySearchResult[];
-    },
-    async update(id: string, updates: any, _scopeFilter?: string[]) {
-      const entry = data.get(id);
-      if (!entry) return null;
-      Object.assign(entry, updates);
-      return entry;
-    },
-    async stats(scopeFilter?: string[]) {
-      const filtered = [...data.values()].filter(
-        e => !scopeFilter || scopeFilter.some(s => e.scope === s),
-      );
-      return { total: filtered.length, byCategory: {}, byScope: {} };
-    },
-    hasFtsSupport: false,
-  } as any;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("auto-consolidation", () => {
-  beforeEach(() => {
-    resetConsolidationState();
-  });
-
-  it("skips when not enough new memories", async () => {
-    const entries = Array.from({ length: 10 }, (_, i) =>
-      makeEntry(`id-${i}`, `memory ${i}`),
-    );
-    const store = createMockStore(entries);
-
-    const result = await maybeConsolidate(store, "project:test");
-    expect(result.triggered).toBe(false);
-    expect(result.reason).toBe("insufficient_new_memories");
-  });
-
-  it("skips when too soon since last run", async () => {
-    // Start with 60 entries, trigger first run, then grow to 120 so
-    // the memory-count gate passes but the time gate blocks.
-    const data: MemoryEntry[] = Array.from({ length: 60 }, (_, i) =>
-      makeEntry(`id-${i}`, `memory ${i}`),
-    );
-    const store = createMockStore(data);
-
-    const config: AutoConsolidationConfig = {
-      minNewMemories: 50,
-      minHoursSinceLastRun: 12,
-      consolidation: DEFAULT_AUTO_CONSOLIDATION_CONFIG.consolidation,
-    };
-
-    // First run: triggers (never run before, 60 > 50 new memories)
-    const first = await maybeConsolidate(store, "project:test", config);
-    expect(first.triggered).toBe(true);
-
-    // Grow the store so memory-count gate would pass
-    for (let i = 60; i < 120; i++) {
-      data.push(makeEntry(`id-${i}`, `memory ${i}`));
-    }
-    const bigStore = createMockStore(data);
-
-    // Second run immediately: time gate blocks (< 12 hours)
-    const second = await maybeConsolidate(bigStore, "project:test", config);
-    expect(second.triggered).toBe(false);
-    expect(second.reason).toBe("too_soon");
-  });
-
-  it("triggers when both conditions met", async () => {
-    const entries = Array.from({ length: 60 }, (_, i) =>
-      makeEntry(`id-${i}`, `memory ${i}`),
-    );
-    const store = createMockStore(entries);
-
-    const config: AutoConsolidationConfig = {
-      minNewMemories: 50,
-      minHoursSinceLastRun: 0, // disable time gate for test
-      consolidation: {
-        clusterThreshold: 0.82,
-        mergeThreshold: 0.92,
-        maxEntriesPerRun: 500,
-      },
-    };
-
-    const result = await maybeConsolidate(store, "project:test", config);
-    expect(result.triggered).toBe(true);
-    expect(result.consolidation).toBeDefined();
-    expect(result.consolidation!.scope).toBe("project:test");
-  });
-
-  it("returns consolidation result when triggered", async () => {
-    const entries = Array.from({ length: 60 }, (_, i) =>
-      makeEntry(`id-${i}`, `memory ${i}`),
-    );
-    const store = createMockStore(entries);
-
-    const config: AutoConsolidationConfig = {
-      minNewMemories: 50,
-      minHoursSinceLastRun: 0,
-      consolidation: {
-        clusterThreshold: 0.82,
-        mergeThreshold: 0.92,
-        maxEntriesPerRun: 500,
-      },
-    };
-
-    const result = await maybeConsolidate(store, "project:test", config);
-    expect(result.triggered).toBe(true);
-    expect(result.consolidation!.originalCount).toBe(60);
-  });
-
-  it("respects custom thresholds", async () => {
-    const entries = Array.from({ length: 200 }, (_, i) =>
-      makeEntry(`id-${i}`, `memory ${i}`),
-    );
-    const store = createMockStore(entries);
-
-    const config: AutoConsolidationConfig = {
-      minNewMemories: 300, // higher than available
-      minHoursSinceLastRun: 0,
-      consolidation: DEFAULT_AUTO_CONSOLIDATION_CONFIG.consolidation,
-    };
-
-    const result = await maybeConsolidate(store, "project:test", config);
-    expect(result.triggered).toBe(false);
-    expect(result.reason).toBe("insufficient_new_memories");
-  });
-});

package/src/__tests__/auto-recall.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { runAutoRecall } from "../auto-recall.js";
-import type { RetrievalContext, RetrievalResult } from "../retriever.js";
-import type { SessionCheckpointRecord } from "../session-schema.js";
-
-function buildResult(id: string, category: "profile" | "preferences" | "entities" | "patterns" | "cases" | "events", text: string, scope = "project:test"): RetrievalResult {
-  return {
-    entry: {
-      id,
-      text,
-      vector: [],
-      category,
-      scope,
-      importance: 0.8,
-      timestamp: Date.parse("2026-03-17T00:00:00.000Z"),
-      metadata: "{}",
-    },
-    score: 0.9,
-    sources: {
-      fused: { score: 0.9 },
-    },
-  };
-}
-
-describe("runAutoRecall", () => {
-  it("reuses an explicit scope for focused recall after composing resume context", async () => {
-    const calls: RetrievalContext[] = [];
-    const retriever = {
-      async retrieve(context: RetrievalContext): Promise<RetrievalResult[]> {
-        calls.push(context);
-        if (context.category === "profile") {
-          return [buildResult("profile-1", "profile", "Profile: RecallNest maintainer.", "project:alpha")];
-        }
-        if (!context.category) {
-          return [buildResult("event-1", "events", "RecallNest uses Weibull decay.", "project:alpha")];
-        }
-        return [];
-      },
-    };
-
-    const response = await runAutoRecall({
-      retriever,
-      checkpointStore: { async getLatest() { return null; } },
-      listPins: () => [],
-    }, {
-      message: "那个衰减曲线用的什么公式来着",
-      scope: "project:alpha",
-      limit: 5,
-      profile: "default",
-      operation: "test:auto-recall",
-    });
-
-    expect(response.mode).toBe("resume+search");
-    expect(response.resolvedScope).toBe("project:alpha");
-    expect(response.results[0]?.entry.id).toBe("event-1");
-    const searchCall = calls.find((call) => !call.category);
-    expect(searchCall?.scopeFilter).toEqual(["project:alpha"]);
-    expect(searchCall?.source).toBe("auto-recall");
-  });
-
-  it("uses the checkpoint-resolved scope when the request only carries sessionId", async () => {
-    const calls: RetrievalContext[] = [];
-    const checkpoint: SessionCheckpointRecord = {
-      checkpointId: "checkpoint-1",
-      sessionId: "session-123",
-      resolvedScope: "project:recallnest",
-      summary: "Continue proactive recall work.",
-      task: "Implement auto recall route",
-      decisions: [],
-      openLoops: [],
-      nextActions: [],
-      entities: [],
-      files: [],
-      updatedAt: "2026-03-17T10:00:00.000Z",
-    };
-
-    const retriever = {
-      async retrieve(context: RetrievalContext): Promise<RetrievalResult[]> {
-        calls.push(context);
-        if (!context.category) {
-          return [buildResult("event-1", "events", "Add a true auto recall route.", "project:recallnest")];
-        }
-        return [];
-      },
-    };
-
-    const response = await runAutoRecall({
-      retriever,
-      checkpointStore: {
-        async getLatest(query?: { sessionId?: string }) {
-          return query?.sessionId === "session-123" ? checkpoint : null;
-        },
-      },
-      listPins: () => [],
-    }, {
-      message: "继续做主动 recall",
-      sessionId: "session-123",
-      operation: "test:auto-recall",
-    });
-
-    expect(response.resolvedScope).toBe("project:recallnest");
-    expect(response.resume.latestCheckpoint?.resolvedScope).toBe("project:recallnest");
-    const searchCall = calls.find((call) => !call.category);
-    expect(searchCall?.scopeFilter).toEqual(["project:recallnest"]);
-  });
-
-  it("falls back to resume-only mode when no scope can be inferred for focused search", async () => {
-    const calls: RetrievalContext[] = [];
-    const retriever = {
-      async retrieve(context: RetrievalContext): Promise<RetrievalResult[]> {
-        calls.push(context);
-        return [];
-      },
-    };
-
-    const response = await runAutoRecall({
-      retriever,
-      checkpointStore: { async getLatest() { return null; } },
-      listPins: () => [],
-    }, {
-      message: "what do you remember about this",
-      operation: "test:auto-recall",
-    });
-
-    expect(response.mode).toBe("resume-only");
-    expect(response.results).toHaveLength(0);
-    expect(response.searchSkippedReason).toContain("No explicit or inferred scope");
-    expect(calls.some((call) => !call.category)).toBe(false);
-  });
-});

package/src/__tests__/babel-integration.test.ts

@@ -1,139 +0,0 @@
-import { describe, expect, test, beforeAll, afterAll } from "bun:test";
-import {
-  detectLanguage,
-  tokenizeForFts,
-  initTokenizer,
-  getKgPrompt,
-  getSessionPrompt,
-} from "babel-memory";
-import { MemoryStore } from "../store.js";
-import { rmSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-beforeAll(async () => {
-  await initTokenizer();
-});
-
-describe("babel-memory integration", () => {
-  test("Chinese memory: language detected + fts_text tokenized", () => {
-    const text = "RecallNest 是一个基于 LanceDB 的 AI 记忆系统";
-    const language = detectLanguage(text);
-    const fts_text = tokenizeForFts(text, language);
-
-    expect(language).toBe("zh");
-    expect(fts_text).toContain("RecallNest");
-    expect(fts_text.includes(" ")).toBe(true);
-  });
-
-  test("English memory: language detected + fts_text unchanged", () => {
-    const text = "RecallNest is an AI memory system built on LanceDB";
-    const language = detectLanguage(text);
-    const fts_text = tokenizeForFts(text, language);
-
-    expect(language).toBe("en");
-    expect(fts_text).toBe(text);
-  });
-
-  test("BM25 query symmetry: tokenized query matches tokenized stored text", () => {
-    const storedText = "机器学习在自然语言处理中的应用";
-    const storedLang = detectLanguage(storedText);
-    const storedFts = tokenizeForFts(storedText, storedLang);
-
-    const query = "机器学习";
-    const queryLang = detectLanguage(query);
-    const queryFts = tokenizeForFts(query, queryLang);
-
-    const queryTerms = queryFts
-      .split(" ")
-      .filter((t) => t.length > 0);
-    const matchedTerms = queryTerms.filter((term) =>
-      storedFts.includes(term),
-    );
-    expect(matchedTerms.length).toBeGreaterThan(0);
-  });
-
-  test("KG prompt routes correctly for Chinese input", () => {
-    const text = "RecallNest 使用 LanceDB 存储记忆";
-    const lang = detectLanguage(text);
-    const { system } = getKgPrompt(lang);
-    expect(system).toContain("知识图谱");
-  });
-
-  test("Session prompt routes correctly for Chinese input", () => {
-    const text = "用户今天讨论了多语言支持方案";
-    const lang = detectLanguage(text);
-    const { dimensionLabels } = getSessionPrompt(lang);
-    expect(dimensionLabels.user_intent).toContain("用户意图");
-  });
-
-  test("backward compat: missing language defaults to en", () => {
-    const entry = { text: "some old text", language: undefined };
-    const lang = entry.language || "en";
-    const fts = tokenizeForFts(entry.text, lang);
-    expect(lang).toBe("en");
-    expect(fts).toBe(entry.text);
-  });
-});
-
-describe("store.update() preserves language + fts_text", () => {
-  const dbPath = join(tmpdir(), `recallnest-update-lang-test-${Date.now()}`);
-  let store: MemoryStore;
-
-  beforeAll(async () => {
-    mkdirSync(dbPath, { recursive: true });
-    store = new MemoryStore({ dbPath, vectorDim: 3 });
-    await (store as any).ensureInitialized();
-  });
-
-  afterAll(() => {
-    try { rmSync(dbPath, { recursive: true, force: true }); } catch {}
-  });
-
-  test("update preserves language and fts_text when not in updates", async () => {
-    const entry = await store.store({
-      text: "这是一条中文记忆",
-      vector: [0.1, 0.2, 0.3],
-      category: "events",
-      scope: "test:lang",
-      importance: 0.7,
-      metadata: "{}",
-      language: "zh",
-      fts_text: "这是 一条 中文 记忆",
-    });
-
-    // Update only text — language and fts_text should be preserved from old row
-    const updated = await store.update(entry.id, {
-      importance: 0.9,
-    });
-
-    expect(updated).not.toBeNull();
-    expect(updated!.language).toBe("zh");
-    expect(updated!.fts_text).toBe("这是 一条 中文 记忆");
-    expect(updated!.importance).toBe(0.9);
-  });
-
-  test("update overwrites language and fts_text when provided", async () => {
-    const entry = await store.store({
-      text: "old english text",
-      vector: [0.4, 0.5, 0.6],
-      category: "events",
-      scope: "test:lang",
-      importance: 0.6,
-      metadata: "{}",
-      language: "en",
-      fts_text: "old english text",
-    });
-
-    const updated = await store.update(entry.id, {
-      text: "新的中文文本",
-      language: "zh",
-      fts_text: "新的 中文 文本",
-    });
-
-    expect(updated).not.toBeNull();
-    expect(updated!.language).toBe("zh");
-    expect(updated!.fts_text).toBe("新的 中文 文本");
-    expect(updated!.text).toBe("新的中文文本");
-  });
-});

package/src/__tests__/batch-dedup.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { batchInternalDedup } from "../ingest.js";
-
-describe("batchInternalDedup", () => {
-  it("keeps all entries when vectors are dissimilar", () => {
-    const vectors = [
-      [1, 0, 0],
-      [0, 1, 0],
-      [0, 0, 1],
-    ];
-    const importances = [0.8, 0.7, 0.6];
-    const kept = batchInternalDedup(vectors, importances);
-    expect(kept).toEqual([0, 1, 2]);
-  });
-
-  it("drops lower-importance duplicate when vectors are near-identical", () => {
-    const vectors = [
-      [1, 0, 0],    // importance 0.6
-      [1, 0.01, 0], // importance 0.9 — nearly identical to [0]
-      [0, 1, 0],    // importance 0.7 — dissimilar
-    ];
-    const importances = [0.6, 0.9, 0.7];
-    const kept = batchInternalDedup(vectors, importances);
-    // [1] has higher importance and is near-identical to [0], so [0] gets dropped
-    expect(kept).toContain(1);
-    expect(kept).toContain(2);
-    expect(kept).not.toContain(0);
-  });
-
-  it("returns single-item batch unchanged", () => {
-    expect(batchInternalDedup([[1, 0, 0]], [0.5])).toEqual([0]);
-  });
-
-  it("returns empty for empty input", () => {
-    expect(batchInternalDedup([], [])).toEqual([]);
-  });
-
-  it("preserves original order in output", () => {
-    const vectors = [
-      [0, 1, 0],    // idx 0, imp 0.9
-      [1, 0, 0],    // idx 1, imp 0.5
-      [0, 0, 1],    // idx 2, imp 0.7
-    ];
-    const importances = [0.9, 0.5, 0.7];
-    const kept = batchInternalDedup(vectors, importances);
-    // All dissimilar, all kept, in original order
-    expect(kept).toEqual([0, 1, 2]);
-  });
-
-  it("respects custom threshold", () => {
-    const vectors = [
-      [1, 0, 0],
-      [0.95, 0.31, 0], // cosine ~0.95 with [0]
-    ];
-    const importances = [0.8, 0.7];
-
-    // Default threshold 0.85 → should dedup
-    const strictKept = batchInternalDedup(vectors, importances, 0.85);
-    expect(strictKept).toHaveLength(1);
-
-    // Loose threshold 0.99 → should keep both
-    const looseKept = batchInternalDedup(vectors, importances, 0.99);
-    expect(looseKept).toHaveLength(2);
-  });
-});