recallnest 1.4.1 → 2.2.0

package/src/__tests__/data-checkup.test.ts

@@ -0,0 +1,225 @@
+import { describe, expect, it } from "bun:test";
+import { runDataCheckup, formatCheckupReport, type CheckupReport } from "../data-checkup.js";
+import type { MemoryEntry, MemoryStore } from "../store.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeEntry(overrides: Partial<MemoryEntry> & { id: string }): MemoryEntry {
+  return {
+    text: "test memory",
+    vector: [1, 0, 0, 0, 0],
+    category: "events",
+    scope: "project:test",
+    importance: 0.7,
+    timestamp: Date.now(),
+    metadata: JSON.stringify({
+      evolution: {
+        status: "active",
+        version: 1,
+        accessCount: 0,
+        lastAccessedAt: null,
+        supersededBy: null,
+        consolidatedInto: null,
+        contributedToPattern: null,
+        sourceMemories: [],
+        validFrom: Date.now(),
+        validUntil: null,
+      },
+    }),
+    ...overrides,
+  };
+}
+
+function createMockStore(entries: MemoryEntry[]): Pick<MemoryStore, "list" | "stats"> {
+  return {
+    async list() { return entries; },
+    async stats() {
+      return { totalCount: entries.length, scopeCounts: {}, categoryCounts: {} };
+    },
+  } as Pick<MemoryStore, "list" | "stats">;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("runDataCheckup", () => {
+  it("returns all-ok for healthy data", async () => {
+    const entries = [
+      makeEntry({ id: "a" }),
+      makeEntry({ id: "b" }),
+      makeEntry({ id: "c" }),
+    ];
+
+    const report = await runDataCheckup({
+      store: createMockStore(entries),
+      openConflictCount: 0,
+    });
+
+    expect(report.checks.length).toBe(6);
+    expect(report.checks.every(c => c.status === "ok")).toBe(true);
+    expect(report.totalEntries).toBe(3);
+  });
+
+  it("detects vector dimension inconsistency", async () => {
+    const entries = [
+      makeEntry({ id: "a", vector: [1, 0, 0, 0, 0] }),
+      makeEntry({ id: "b", vector: [1, 0, 0] }), // wrong dim
+      makeEntry({ id: "c", vector: [1, 0, 0, 0, 0] }),
+    ];
+
+    const report = await runDataCheckup({
+      store: createMockStore(entries),
+      openConflictCount: 0,
+    });
+
+    const dimCheck = report.checks.find(c => c.name === "vector_dimensions")!;
+    expect(dimCheck.status).toBe("error");
+    expect(dimCheck.detail).toContain("1 entries have wrong dimension");
+  });
+
+  it("detects orphan memories with empty scope", async () => {
+    const entries = [
+      makeEntry({ id: "a", scope: "project:test" }),
+      makeEntry({ id: "b", scope: "" }),
+      makeEntry({ id: "c", scope: "__schema__" }),
+    ];
+
+    const report = await runDataCheckup({
+      store: createMockStore(entries),
+      openConflictCount: 0,
+    });
+
+    const orphanCheck = report.checks.find(c => c.name === "orphan_memories")!;
+    expect(orphanCheck.status).toBe("warning");
+    expect(orphanCheck.detail).toContain("2 memories");
+  });
+
+  it("warns about unhealthy tier distribution — too many core", async () => {
+    // Make 501 core entries (tier resolved from metadata top-level importance >= 0.95)
+    const entries = Array.from({ length: 501 }, (_, i) =>
+      makeEntry({
+        id: `core-${i}`,
+        importance: 0.99,
+        metadata: JSON.stringify({
+          importance: 0.99,
+          accessCount: 10,
+          evolution: { status: "active", version: 1, accessCount: 10, lastAccessedAt: null, supersededBy: null, consolidatedInto: null, contributedToPattern: null, sourceMemories: [], validFrom: Date.now(), validUntil: null },
+        }),
+      })
+    );
+
+    const report = await runDataCheckup({
+      store: createMockStore(entries),
+      openConflictCount: 0,
+    });
+
+    const tierCheck = report.checks.find(c => c.name === "tier_distribution")!;
+    expect(tierCheck.status).toBe("warning");
+    expect(tierCheck.detail).toContain("core tier has 501");
+  });
+
+  it("reports conflict backlog levels", async () => {
+    // 0 = ok
+    const r0 = await runDataCheckup({ store: createMockStore([]), openConflictCount: 0 });
+    expect(r0.checks.find(c => c.name === "conflict_backlog")!.status).toBe("ok");
+
+    // 3 = still ok
+    const r3 = await runDataCheckup({ store: createMockStore([]), openConflictCount: 3 });
+    expect(r3.checks.find(c => c.name === "conflict_backlog")!.status).toBe("ok");
+
+    // 10 = warning
+    const r10 = await runDataCheckup({ store: createMockStore([]), openConflictCount: 10 });
+    expect(r10.checks.find(c => c.name === "conflict_backlog")!.status).toBe("warning");
+
+    // 25 = error
+    const r25 = await runDataCheckup({ store: createMockStore([]), openConflictCount: 25 });
+    expect(r25.checks.find(c => c.name === "conflict_backlog")!.status).toBe("error");
+  });
+
+  it("detects version group issues — single-member group", async () => {
+    const entries = [
+      makeEntry({
+        id: "a",
+        metadata: JSON.stringify({
+          version_group: "vg-abc",
+          version_rank: 2.5,
+          evolution: { status: "active", version: 1, accessCount: 0, lastAccessedAt: null, supersededBy: null, consolidatedInto: null, contributedToPattern: null, sourceMemories: [], validFrom: Date.now(), validUntil: null },
+        }),
+      }),
+      // vg-abc has only 1 member — suspicious
+    ];
+
+    const report = await runDataCheckup({
+      store: createMockStore(entries),
+      openConflictCount: 0,
+    });
+
+    const vgCheck = report.checks.find(c => c.name === "version_groups")!;
+    expect(vgCheck.status).toBe("warning");
+    expect(vgCheck.detail).toContain("only 1 member");
+  });
+
+  it("detects version group with missing rank", async () => {
+    const entries = [
+      makeEntry({
+        id: "a",
+        metadata: JSON.stringify({
+          version_group: "vg-xyz",
+          version_rank: 2.0,
+          evolution: { status: "active", version: 1, accessCount: 0, lastAccessedAt: null, supersededBy: null, consolidatedInto: null, contributedToPattern: null, sourceMemories: [], validFrom: Date.now(), validUntil: null },
+        }),
+      }),
+      makeEntry({
+        id: "b",
+        metadata: JSON.stringify({
+          version_group: "vg-xyz",
+          // version_rank missing
+          evolution: { status: "active", version: 1, accessCount: 0, lastAccessedAt: null, supersededBy: null, consolidatedInto: null, contributedToPattern: null, sourceMemories: [], validFrom: Date.now(), validUntil: null },
+        }),
+      }),
+    ];
+
+    const report = await runDataCheckup({
+      store: createMockStore(entries),
+      openConflictCount: 0,
+    });
+
+    const vgCheck = report.checks.find(c => c.name === "version_groups")!;
+    expect(vgCheck.status).toBe("warning");
+    expect(vgCheck.detail).toContain("missing rank");
+  });
+
+  it("handles empty database", async () => {
+    const report = await runDataCheckup({
+      store: createMockStore([]),
+      openConflictCount: 0,
+    });
+
+    expect(report.totalEntries).toBe(0);
+    expect(report.checks.every(c => c.status === "ok")).toBe(true);
+  });
+});
+
+describe("formatCheckupReport", () => {
+  it("formats report with mix of statuses", () => {
+    const report: CheckupReport = {
+      checks: [
+        { name: "check_a", status: "ok", detail: "all good" },
+        { name: "check_b", status: "warning", detail: "minor issue" },
+        { name: "check_c", status: "error", detail: "big problem" },
+      ],
+      totalEntries: 100,
+      timestamp: "2026-04-03T12:00:00.000Z",
+    };
+
+    const output = formatCheckupReport(report);
+    expect(output).toContain("[OK] check_a");
+    expect(output).toContain("[WARN] check_b");
+    expect(output).toContain("[ERR] check_c");
+    expect(output).toContain("1 error(s), 1 warning(s), 1 ok");
+    expect(output).toContain("Total entries scanned: 100");
+  });
+});

package/src/__tests__/decay-exemption.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect } from "bun:test";
+import { isDecayExempt } from "../decay-engine.js";
+
+describe("HP-7: Decay exemption rules", () => {
+  describe("Rule 1: core tier + importance ≥ 0.95", () => {
+    it("exempts explicit core with high importance", () => {
+      const meta = JSON.stringify({ tier: "core", importance: 0.95 });
+      expect(isDecayExempt(meta, 0.95)).toBe(true);
+    });
+
+    it("exempts inferred core (importance ≥ 0.95)", () => {
+      const meta = JSON.stringify({ importance: 0.96 });
+      expect(isDecayExempt(meta, 0.96)).toBe(true);
+    });
+
+    it("does NOT exempt core with importance < 0.95", () => {
+      const meta = JSON.stringify({ tier: "core", importance: 0.90 });
+      expect(isDecayExempt(meta, 0.90)).toBe(false);
+    });
+
+    it("does NOT exempt working tier even with high importance", () => {
+      const meta = JSON.stringify({ tier: "working", importance: 0.96 });
+      expect(isDecayExempt(meta, 0.96)).toBe(false);
+    });
+  });
+
+  describe("Rule 2: recently accessed (within 7 days)", () => {
+    it("exempts memory accessed 1 day ago", () => {
+      const meta = JSON.stringify({
+        lastAccessedAt: Date.now() - 1 * 86_400_000,
+      });
+      expect(isDecayExempt(meta, 0.50)).toBe(true);
+    });
+
+    it("does NOT exempt memory accessed 8 days ago", () => {
+      const meta = JSON.stringify({
+        lastAccessedAt: Date.now() - 8 * 86_400_000,
+      });
+      expect(isDecayExempt(meta, 0.50)).toBe(false);
+    });
+
+    it("does NOT exempt when lastAccessedAt is 0", () => {
+      const meta = JSON.stringify({ lastAccessedAt: 0 });
+      expect(isDecayExempt(meta, 0.50)).toBe(false);
+    });
+  });
+
+  describe("Rule 3: pinned tag", () => {
+    it("exempts memory with pinned tag", () => {
+      const meta = JSON.stringify({ tags: ["workflow", "pinned"] });
+      expect(isDecayExempt(meta, 0.40)).toBe(true);
+    });
+
+    it("does NOT exempt without pinned tag", () => {
+      const meta = JSON.stringify({ tags: ["workflow", "pattern"] });
+      expect(isDecayExempt(meta, 0.40)).toBe(false);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("returns false for undefined metadata", () => {
+      expect(isDecayExempt(undefined, 0.95)).toBe(false);
+    });
+
+    it("returns false for empty metadata", () => {
+      expect(isDecayExempt("{}", 0.50)).toBe(false);
+    });
+
+    it("returns false for corrupt metadata", () => {
+      expect(isDecayExempt("not-json", 0.95)).toBe(false);
+    });
+
+    it("multiple rules: first match wins", () => {
+      // Core + pinned + recent — all three rules match
+      const meta = JSON.stringify({
+        tier: "core",
+        importance: 0.98,
+        lastAccessedAt: Date.now() - 3600000,
+        tags: ["pinned"],
+      });
+      expect(isDecayExempt(meta, 0.98)).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "bun:test";
+import { isTemporalOrActionContent } from "../ingest.js";
+
+describe("Dedup guard: isTemporalOrActionContent", () => {
+  describe("date-stamped events (must NOT be deduped)", () => {
+    it("ISO date", () => expect(isTemporalOrActionContent("2026-03-25 部署了新版本")).toBe(true));
+    it("今天", () => expect(isTemporalOrActionContent("今天跑了 benchmark")).toBe(true));
+    it("昨天", () => expect(isTemporalOrActionContent("昨天讨论了架构")).toBe(true));
+    it("上次", () => expect(isTemporalOrActionContent("上次的方案不行")).toBe(true));
+    it("刚才", () => expect(isTemporalOrActionContent("刚才改了配置")).toBe(true));
+  });
+
+  describe("file operations (must NOT be deduped)", () => {
+    it("file path", () => expect(isTemporalOrActionContent("修改了 /Users/xxx/src/foo.ts")).toBe(true));
+    it("home path", () => expect(isTemporalOrActionContent("保存到 ~/recallnest/data/")).toBe(true));
+    it("md file", () => expect(isTemporalOrActionContent("更新了 README.md")).toBe(true));
+    it("mv command", () => expect(isTemporalOrActionContent("mv old.json new.json")).toBe(true));
+    it("归档", () => expect(isTemporalOrActionContent("把旧文件归档了")).toBe(true));
+  });
+
+  describe("memory instructions (must NOT be deduped)", () => {
+    it("记住", () => expect(isTemporalOrActionContent("记住不要用 rm")).toBe(true));
+    it("remember", () => expect(isTemporalOrActionContent("remember to check tests")).toBe(true));
+    it("别忘了", () => expect(isTemporalOrActionContent("别忘了跑测试")).toBe(true));
+    it("务必", () => expect(isTemporalOrActionContent("务必先备份")).toBe(true));
+  });
+
+  describe("feedback/corrections (must NOT be deduped)", () => {
+    it("不要再", () => expect(isTemporalOrActionContent("不要再用这个方法")).toBe(true));
+    it("stop doing", () => expect(isTemporalOrActionContent("stop doing that")).toBe(true));
+    it("don't", () => expect(isTemporalOrActionContent("don't mock the database")).toBe(true));
+  });
+
+  describe("generic content (CAN be deduped normally)", () => {
+    it("plain description", () => expect(isTemporalOrActionContent("RecallNest 是一个记忆服务")).toBe(false));
+    it("technical fact", () => expect(isTemporalOrActionContent("LanceDB 支持向量搜索")).toBe(false));
+    it("preference without instruction marker", () => expect(isTemporalOrActionContent("我喜欢用 dark mode")).toBe(false));
+  });
+});

package/src/__tests__/distill-lock.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test";
+import { existsSync, writeFileSync, mkdirSync, statSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  acquireLock,
+  releaseLock,
+  rollbackLock,
+  shouldDistill,
+  getLastDistillTime,
+  type DistillLockConfig,
+} from "../distill-lock.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let tempDir: string;
+let lockPath: string;
+
+function cfg(overrides?: Partial<DistillLockConfig>): Partial<DistillLockConfig> {
+  return { lockPath, ...overrides };
+}
+
+beforeEach(() => {
+  tempDir = join(tmpdir(), `distill-lock-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(tempDir, { recursive: true });
+  lockPath = join(tempDir, "distill.lock");
+});
+
+afterEach(() => {
+  // Clean up lock file if it exists
+  if (existsSync(lockPath)) {
+    try {
+      const { unlinkSync } = require("node:fs");
+      unlinkSync(lockPath);
+    } catch { /* ignore */ }
+  }
+});
+
+// ---------------------------------------------------------------------------
+// acquireLock
+// ---------------------------------------------------------------------------
+
+describe("acquireLock", () => {
+  it("creates lock file and returns true when no lock exists", () => {
+    const result = acquireLock(cfg());
+    expect(result).toBe(true);
+    expect(existsSync(lockPath)).toBe(true);
+  });
+
+  it("writes current PID into lock file", () => {
+    acquireLock(cfg());
+    const { readFileSync } = require("node:fs");
+    const content = readFileSync(lockPath, "utf-8").trim();
+    expect(content).toBe(String(process.pid));
+  });
+
+  it("returns false when lock held by alive PID and not expired", () => {
+    // Write current process PID (which is alive)
+    writeFileSync(lockPath, String(process.pid), "utf-8");
+
+    const result = acquireLock(cfg());
+    expect(result).toBe(false);
+  });
+
+  it("overwrites lock when PID is dead", () => {
+    // PID 999999 is almost certainly not running
+    writeFileSync(lockPath, "999999", "utf-8");
+
+    const result = acquireLock(cfg());
+    expect(result).toBe(true);
+
+    const { readFileSync } = require("node:fs");
+    const content = readFileSync(lockPath, "utf-8").trim();
+    expect(content).toBe(String(process.pid));
+  });
+
+  it("overwrites lock when mtime is expired even if PID alive", () => {
+    writeFileSync(lockPath, String(process.pid), "utf-8");
+    // Set mtime to 2 hours ago
+    const twoHoursAgo = new Date(Date.now() - 7_200_000);
+    utimesSync(lockPath, twoHoursAgo, twoHoursAgo);
+
+    const result = acquireLock(cfg({ expireMs: 3_600_000 }));
+    expect(result).toBe(true);
+  });
+
+  it("creates parent directories if missing", () => {
+    const deepPath = join(tempDir, "nested", "dir", "distill.lock");
+    const result = acquireLock(cfg({ lockPath: deepPath }));
+    expect(result).toBe(true);
+    expect(existsSync(deepPath)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// releaseLock
+// ---------------------------------------------------------------------------
+
+describe("releaseLock", () => {
+  it("deletes lock file", () => {
+    writeFileSync(lockPath, String(process.pid), "utf-8");
+    expect(existsSync(lockPath)).toBe(true);
+
+    releaseLock(cfg());
+    expect(existsSync(lockPath)).toBe(false);
+  });
+
+  it("is a no-op when lock file does not exist", () => {
+    expect(() => releaseLock(cfg())).not.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// rollbackLock
+// ---------------------------------------------------------------------------
+
+describe("rollbackLock", () => {
+  it("sets lock mtime to the given previous value", () => {
+    writeFileSync(lockPath, String(process.pid), "utf-8");
+    const pastDate = new Date(Date.now() - 600_000); // 10 min ago
+
+    rollbackLock(pastDate, cfg());
+
+    const st = statSync(lockPath);
+    // Allow 1 second tolerance for filesystem granularity
+    expect(Math.abs(st.mtimeMs - pastDate.getTime())).toBeLessThan(1000);
+  });
+
+  it("is a no-op when lock file does not exist", () => {
+    expect(() => rollbackLock(new Date(), cfg())).not.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// shouldDistill
+// ---------------------------------------------------------------------------
+
+describe("shouldDistill", () => {
+  it("returns true when checkpoint count >= minCheckpoints (default 3)", () => {
+    expect(shouldDistill(3, cfg())).toBe(true);
+    expect(shouldDistill(5, cfg())).toBe(true);
+  });
+
+  it("returns false when checkpoint count < minCheckpoints", () => {
+    expect(shouldDistill(0, cfg())).toBe(false);
+    expect(shouldDistill(1, cfg())).toBe(false);
+    expect(shouldDistill(2, cfg())).toBe(false);
+  });
+
+  it("respects custom minCheckpoints", () => {
+    expect(shouldDistill(4, cfg({ minCheckpoints: 5 }))).toBe(false);
+    expect(shouldDistill(5, cfg({ minCheckpoints: 5 }))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getLastDistillTime
+// ---------------------------------------------------------------------------
+
+describe("getLastDistillTime", () => {
+  it("returns lock file mtime when lock exists", () => {
+    writeFileSync(lockPath, String(process.pid), "utf-8");
+    const st = statSync(lockPath);
+
+    const result = getLastDistillTime(cfg());
+    expect(Math.abs(result - st.mtimeMs)).toBeLessThan(100);
+  });
+
+  it("returns 0 when lock file does not exist", () => {
+    const result = getLastDistillTime(cfg());
+    expect(result).toBe(0);
+  });
+});