recallnest 2.2.0 → 2.2.1

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

@@ -1,58 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import type { DedupAction, DedupCheckResult } from "../ingest.js";
-
-describe("DedupAction types", () => {
-  it("DedupCheckResult supports secondaryDeletes", () => {
-    const result: DedupCheckResult = {
-      action: "store",
-      reason: "unique",
-      secondaryDeletes: [
-        { id: "abc12345", action: "delete", reason: "outdated by candidate" },
-      ],
-    };
-    expect(result.secondaryDeletes).toHaveLength(1);
-    expect(result.secondaryDeletes![0].action).toBe("delete");
-    expect(result.secondaryDeletes![0].id).toBe("abc12345");
-  });
-
-  it("DedupCheckResult without secondaryDeletes is backward-compatible", () => {
-    const result: DedupCheckResult = {
-      action: "skip",
-      reason: "hard",
-      existingText: "existing memory text",
-    };
-    expect(result.secondaryDeletes).toBeUndefined();
-  });
-
-  it("DedupAction only supports delete", () => {
-    const action: DedupAction = {
-      id: "test-id",
-      action: "delete",
-      reason: "superseded by newer info",
-    };
-    expect(action.action).toBe("delete");
-  });
-
-  it("multiple secondary deletes are valid", () => {
-    const result: DedupCheckResult = {
-      action: "store",
-      reason: "llm-merge",
-      secondaryDeletes: [
-        { id: "id1", action: "delete", reason: "outdated" },
-        { id: "id2", action: "delete", reason: "duplicate of id1" },
-      ],
-    };
-    expect(result.secondaryDeletes).toHaveLength(2);
-  });
-
-  it("empty secondaryDeletes array treated as no actions", () => {
-    const result: DedupCheckResult = {
-      action: "store",
-      reason: "unique",
-      secondaryDeletes: [],
-    };
-    expect(result.secondaryDeletes).toHaveLength(0);
-    // In practice, we check .length before executing
-    expect((result.secondaryDeletes?.length ?? 0) > 0).toBe(false);
-  });
-});

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

@@ -1,39 +0,0 @@
-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__/deterministic-id.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { deterministicId } from "../store.js";
-
-describe("deterministicId", () => {
-  it("same scope+text always produce the same ID", () => {
-    const id1 = deterministicId("project:test", "I prefer TypeScript");
-    const id2 = deterministicId("project:test", "I prefer TypeScript");
-    expect(id1).toBe(id2);
-  });
-
-  it("different text produces different ID", () => {
-    const id1 = deterministicId("project:test", "I prefer TypeScript");
-    const id2 = deterministicId("project:test", "I prefer JavaScript");
-    expect(id1).not.toBe(id2);
-  });
-
-  it("different scope produces different ID", () => {
-    const id1 = deterministicId("project:alpha", "same text");
-    const id2 = deterministicId("project:beta", "same text");
-    expect(id1).not.toBe(id2);
-  });
-
-  it("returns UUID-shaped string (8-4-4-4-12)", () => {
-    const id = deterministicId("project:test", "hello world");
-    expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-  });
-
-  it("handles empty scope gracefully", () => {
-    const id = deterministicId("", "some text");
-    expect(id).toMatch(/^[0-9a-f]{8}-/);
-  });
-
-  it("handles CJK text", () => {
-    const id1 = deterministicId("project:test", "我喜欢用Bun");
-    const id2 = deterministicId("project:test", "我喜欢用Bun");
-    expect(id1).toBe(id2);
-  });
-});

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

@@ -1,176 +0,0 @@
-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);
-  });
-});

package/src/__tests__/doctor.test.ts

@@ -1,303 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  assessContinuityBaseline,
-  assessScopeInventoryReport,
-  formatDoctorResults,
-  loadContinuityBaselineEntries,
-} from "../doctor.js";
-import type { MemoryEntry } from "../store.js";
-
-function buildEntry(
-  id: string,
-  category: MemoryEntry["category"],
-  text: string,
-  scope: string,
-  metadata: Record<string, unknown> = {},
-): MemoryEntry {
-  return {
-    id,
-    text,
-    vector: [],
-    category,
-    scope,
-    importance: 0.8,
-    timestamp: Date.parse("2026-03-17T00:00:00.000Z"),
-    metadata: JSON.stringify(metadata),
-  };
-}
-
-describe("assessContinuityBaseline", () => {
-  it("reports full coverage when all canonical continuity seeds are present", () => {
-    const seeds = {
-      patterns: [
-        {
-          title: "Cross-window continuity handoff",
-          trigger: "When opening a fresh terminal window",
-          steps: ["Call resume_context before coding."],
-          outcome: "Fresh windows recover stable context.",
-          tools: ["resume_context"],
-          importance: 0.9,
-          source: "agent",
-        },
-      ],
-      cases: [
-        {
-          title: "Continuity eval checkpoint isolation",
-          problem: "Eval reads live checkpoints.",
-          solutionSteps: ["Use fixture checkpoints instead."],
-          outcome: "Continuity eval becomes deterministic.",
-          tools: ["eval:continuity"],
-          source: "agent",
-          scope: "recallnest",
-          importance: 0.85,
-        },
-      ],
-      memories: [
-        {
-          text: "RecallNest is the shared memory layer for Claude Code, Codex, and Gemini CLI.",
-          category: "entities",
-          scope: "recallnest",
-          source: "agent",
-          importance: 0.9,
-          canonicalKey: "entities:recallnest:shared-memory-layer",
-        },
-      ],
-    };
-
-    const entries: MemoryEntry[] = [
-      buildEntry(
-        "pattern-1",
-        "patterns",
-        "Workflow pattern: Cross-window continuity handoff",
-        "memory:agent",
-        { workflowPattern: { title: "Cross-window continuity handoff" } },
-      ),
-      buildEntry(
-        "case-1",
-        "cases",
-        "Case: Continuity eval checkpoint isolation",
-        "recallnest",
-        { caseMemory: { title: "Continuity eval checkpoint isolation" } },
-      ),
-      buildEntry(
-        "memory-1",
-        "entities",
-        "RecallNest is the shared memory layer for Claude Code, Codex, and Gemini CLI.",
-        "recallnest",
-        { canonicalKey: "entities:recallnest:shared-memory-layer" },
-      ),
-    ];
-
-    const assessment = assessContinuityBaseline(entries, seeds as any);
-
-    expect(assessment.found).toEqual({ patterns: 1, cases: 1, memories: 1 });
-    expect(assessment.missing).toEqual({ patterns: [], cases: [], memories: [] });
-  });
-
-  it("reports missing canonical seeds by category", () => {
-    const seeds = {
-      patterns: [
-        {
-          title: "Recall before repo exploration",
-          trigger: "When startup context is sparse",
-          steps: ["Run search_memory before local repo exploration."],
-          outcome: "Fresh windows recover task-specific continuity.",
-          tools: ["resume_context", "search_memory"],
-          importance: 0.9,
-          source: "agent",
-        },
-      ],
-      cases: [
-        {
-          title: "RecallNest scope fallback cleanup",
-          problem: "Project continuity prefers raw transcript notes.",
-          solutionSteps: ["Prefer durable cases and patterns."],
-          outcome: "Stable project continuity becomes cleaner.",
-          tools: ["resume_context"],
-          source: "agent",
-          scope: "recallnest",
-          importance: 0.85,
-        },
-      ],
-      memories: [
-        {
-          text: "RecallNest continuity revolves around three primitives.",
-          category: "entities",
-          scope: "recallnest",
-          source: "agent",
-          importance: 0.9,
-          canonicalKey: "entities:recallnest:continuity-primitives",
-        },
-      ],
-    };
-
-    const entries: MemoryEntry[] = [
-      buildEntry(
-        "pattern-1",
-        "patterns",
-        "Workflow pattern: Cross-window continuity handoff",
-        "memory:agent",
-        { workflowPattern: { title: "Cross-window continuity handoff" } },
-      ),
-    ];
-
-    const assessment = assessContinuityBaseline(entries, seeds as any);
-
-    expect(assessment.found).toEqual({ patterns: 0, cases: 0, memories: 0 });
-    expect(assessment.missing.patterns).toEqual(["Recall before repo exploration"]);
-    expect(assessment.missing.cases).toEqual(["RecallNest scope fallback cleanup"]);
-    expect(assessment.missing.memories).toEqual(["entities:recallnest:continuity-primitives"]);
-  });
-
-  it("loads enough entries for baseline checks when the index is larger than the legacy 5000-entry window", async () => {
-    const targetEntry = buildEntry(
-      "pattern-target",
-      "patterns",
-      "Workflow pattern: RecallNest MCP transport rollout",
-      "project:recallnest",
-      { workflowPattern: { title: "RecallNest MCP transport rollout" } },
-    );
-    const entries: MemoryEntry[] = [
-      ...Array.from({ length: 5000 }, (_, index) => buildEntry(
-        `noise-${index}`,
-        "patterns",
-        `Workflow pattern: Noise ${index}`,
-        "memory:agent",
-        { workflowPattern: { title: `Noise ${index}` } },
-      )),
-      targetEntry,
-    ];
-    const listCalls: Array<[string[] | undefined, string | undefined, number | undefined, number | undefined]> = [];
-    const store = {
-      async list(scopeFilter?: string[], category?: string, limit = 20, offset = 0): Promise<MemoryEntry[]> {
-        listCalls.push([scopeFilter, category, limit, offset]);
-        return entries.slice(offset, offset + limit);
-      },
-    };
-
-    const loaded = await loadContinuityBaselineEntries(store as any, entries.length);
-    const assessment = assessContinuityBaseline(loaded, {
-      patterns: [
-        {
-          title: "RecallNest MCP transport rollout",
-          trigger: "When RecallNest continuity work touches MCP transport wiring under project scope",
-          steps: ["Call resume_context with project:recallnest before transport changes."],
-          outcome: "RecallNest transport changes stay project-scoped.",
-          tools: ["resume_context", "search_memory", "eval:continuity"],
-          source: "agent",
-          scope: "project:recallnest",
-          importance: 0.87,
-        },
-      ],
-      cases: [],
-      memories: [],
-    } as any);
-
-    expect(listCalls).toEqual([[undefined, undefined, 5001, 0]]);
-    expect(assessment.found.patterns).toBe(1);
-    expect(assessment.missing.patterns).toEqual([]);
-  });
-});
-
-describe("assessScopeInventoryReport", () => {
-  it("reports a clean scope inventory when no unresolved anomalies remain", () => {
-    const result = assessScopeInventoryReport({
-      generatedAt: "2026-03-19T08:20:00.000Z",
-      sampleLimit: 5,
-      totalScannedCount: 42,
-      totalAnomalyCount: 0,
-      totalInvalidCount: 0,
-      totalReviewedCount: 1,
-      layers: [
-        {
-          layer: "memories",
-          scannedCount: 40,
-          anomalyCount: 0,
-          invalidCount: 0,
-          reviewedCount: 0,
-          counts: { missing: 0, empty: 0, global: 0 },
-          samples: [],
-          recommendation: "ok",
-        },
-        {
-          layer: "workflow-observations",
-          scannedCount: 2,
-          anomalyCount: 0,
-          invalidCount: 0,
-          reviewedCount: 1,
-          counts: { missing: 0, empty: 0, global: 0 },
-          samples: [],
-          recommendation: "ok",
-        },
-      ],
-    });
-
-    expect(result).toEqual({
-      name: "Scope inventory",
-      status: "pass",
-      message: "0 unresolved anomalies across 42 records; reviewed keeps 1",
-    });
-  });
-
-  it("warns when scope inventory still has unresolved anomalies or invalid files", () => {
-    const result = assessScopeInventoryReport({
-      generatedAt: "2026-03-19T08:20:00.000Z",
-      sampleLimit: 5,
-      totalScannedCount: 12,
-      totalAnomalyCount: 2,
-      totalInvalidCount: 1,
-      totalReviewedCount: 0,
-      layers: [
-        {
-          layer: "pins",
-          scannedCount: 4,
-          anomalyCount: 1,
-          invalidCount: 0,
-          reviewedCount: 0,
-          counts: { missing: 0, empty: 0, global: 1 },
-          samples: [{
-            layer: "pins",
-            id: "pin-legacy-1234",
-            kind: "global",
-            scope: "global",
-            context: "pin",
-            preview: "Legacy pin",
-            recordedAt: "2026-03-19T08:00:00.000Z",
-          }],
-          recommendation: "re-pin",
-        },
-        {
-          layer: "workflow-observations",
-          scannedCount: 8,
-          anomalyCount: 1,
-          invalidCount: 1,
-          reviewedCount: 0,
-          counts: { missing: 1, empty: 0, global: 0 },
-          samples: [],
-          recommendation: "review",
-        },
-      ],
-    });
-
-    expect(result.status).toBe("warn");
-    expect(result.name).toBe("Scope inventory");
-    expect(result.message).toContain("2 unresolved anomalies, 1 invalid file(s) across 12 records");
-    expect(result.message).toContain("pins:1");
-    expect(result.message).toContain("workflow-observations:1 invalid 1");
-    expect(result.message).toContain("sample pins:global:pin-lega");
-    expect(result.fix).toBe("bun run scope-inventory");
-  });
-});
-
-describe("formatDoctorResults", () => {
-  it("does not claim all clear when warnings are present", () => {
-    const output = formatDoctorResults([
-      { name: "Bun runtime", status: "pass", message: "ok" },
-      { name: "Scope inventory", status: "warn", message: "1 unresolved anomaly", fix: "bun run scope-inventory" },
-    ]);
-
-    expect(output).toContain("Review the ⚠️ items above before relying on this environment as a clean baseline.");
-    expect(output).not.toContain("All clear.");
-  });
-});