recallnest 2.2.0 → 2.2.1

package/src/__tests__/access-tracker-novelty.test.ts

@@ -1,228 +0,0 @@
-/**
- * Tests for Tier 3.2: Conditional access reinforcement (prediction error gating).
- *
- * Validates that:
- * 1. High-similarity (low-novelty) results are NOT reinforced
- * 2. Low-similarity (high-novelty) results ARE reinforced
- * 3. Cooldown prevents duplicate reinforcement within the window
- * 4. When no scores provided, all entries are reinforced (backward compat)
- * 5. shouldReinforce() logic is correct in isolation
- */
-import { describe, expect, it, beforeEach } from "bun:test";
-import { AccessTracker, DEFAULT_ACCESS_TRACKER_CONFIG } from "../access-tracker.js";
-import type { MemoryEntry } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEntry(id: string, overrides: Partial<MemoryEntry> = {}): MemoryEntry {
-  return {
-    id,
-    text: `memory-${id}`,
-    vector: [1, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: JSON.stringify({ accessCount: 0, lastAccessedAt: 0 }),
-    ...overrides,
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]) {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  const updates: Array<{ id: string; metadata?: string }> = [];
-
-  return {
-    updates,
-    data,
-    async getById(id: string) {
-      return data.get(id) ?? null;
-    },
-    async update(id: string, upd: { metadata?: 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;
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// shouldReinforce() unit tests
-// ---------------------------------------------------------------------------
-
-describe("shouldReinforce", () => {
-  let tracker: AccessTracker;
-
-  beforeEach(() => {
-    tracker = new AccessTracker(
-      createMockStore([]) as any,
-      { ...DEFAULT_ACCESS_TRACKER_CONFIG, noveltyThreshold: 0.35, cooldownMs: 300_000 },
-    );
-  });
-
-  it("rejects high-similarity (low-novelty) results", () => {
-    // similarity 0.90 → novelty 0.10 < threshold 0.35 → reject
-    expect(tracker.shouldReinforce("a", 0.90)).toBe(false);
-  });
-
-  it("rejects exact match (similarity 1.0)", () => {
-    expect(tracker.shouldReinforce("a", 1.0)).toBe(false);
-  });
-
-  it("accepts low-similarity (high-novelty) results", () => {
-    // similarity 0.50 → novelty 0.50 > threshold 0.35 → accept
-    expect(tracker.shouldReinforce("a", 0.50)).toBe(true);
-  });
-
-  it("accepts borderline novelty (exactly at threshold)", () => {
-    // similarity 0.65 → novelty 0.35 = threshold 0.35 → accept (not strictly less)
-    expect(tracker.shouldReinforce("a", 0.65)).toBe(true);
-  });
-
-  it("rejects same entry within cooldown window", () => {
-    // First call: accepted
-    expect(tracker.shouldReinforce("a", 0.50)).toBe(true);
-    // Simulate recording to set cooldown
-    tracker.recordAccess(["a"], [0.50]);
-    // Second call within cooldown: rejected
-    expect(tracker.shouldReinforce("a", 0.50)).toBe(false);
-  });
-
-  it("accepts different entry even if another is on cooldown", () => {
-    tracker.recordAccess(["a"], [0.50]);
-    expect(tracker.shouldReinforce("b", 0.50)).toBe(true);
-  });
-
-  it("bypasses novelty gate when threshold is 0", () => {
-    const noGateTracker = new AccessTracker(
-      createMockStore([]) as any,
-      { ...DEFAULT_ACCESS_TRACKER_CONFIG, noveltyThreshold: 0, cooldownMs: 0 },
-    );
-    // Even high similarity passes
-    expect(noGateTracker.shouldReinforce("a", 0.99)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// recordAccess() with scores
-// ---------------------------------------------------------------------------
-
-describe("recordAccess with novelty gating", () => {
-  it("only queues novel entries for flush", async () => {
-    const entries = [makeEntry("a"), makeEntry("b"), makeEntry("c")];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 0, // immediate flush for testing
-      noveltyThreshold: 0.35,
-      cooldownMs: 0,
-    });
-
-    // scores: a=0.90 (low novelty, reject), b=0.50 (novel, accept), c=0.40 (novel, accept)
-    tracker.recordAccess(["a", "b", "c"], [0.90, 0.50, 0.40]);
-
-    await tracker.flush();
-
-    // Only b and c should have been updated
-    const updatedIds = store.updates.map(u => u.id);
-    expect(updatedIds).not.toContain("a");
-    expect(updatedIds).toContain("b");
-    expect(updatedIds).toContain("c");
-  });
-
-  it("reinforces all entries when no scores provided (backward compat)", async () => {
-    const entries = [makeEntry("a"), makeEntry("b")];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 0,
-      noveltyThreshold: 0.35,
-      cooldownMs: 0,
-    });
-
-    // No scores → all reinforced
-    tracker.recordAccess(["a", "b"]);
-    await tracker.flush();
-
-    const updatedIds = store.updates.map(u => u.id);
-    expect(updatedIds).toContain("a");
-    expect(updatedIds).toContain("b");
-  });
-
-  it("respects cooldown across multiple recordAccess calls", async () => {
-    const entries = [makeEntry("x")];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 0,
-      noveltyThreshold: 0.35,
-      cooldownMs: 600_000, // 10 min cooldown
-    });
-
-    // First call: novel enough → queued
-    tracker.recordAccess(["x"], [0.50]);
-    await tracker.flush();
-    expect(store.updates.length).toBe(1);
-
-    // Second call: same entry within cooldown → not queued
-    tracker.recordAccess(["x"], [0.50]);
-    await tracker.flush();
-    // Still only 1 update (no new flush)
-    expect(store.updates.length).toBe(1);
-  });
-
-  it("skips flush scheduling when all entries are gated out", () => {
-    const store = createMockStore([]);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 5000,
-      noveltyThreshold: 0.35,
-      cooldownMs: 0,
-    });
-
-    // All scores too high (low novelty) → nothing queued
-    tracker.recordAccess(["a", "b"], [0.95, 0.90]);
-    expect(tracker.pendingCount).toBe(0);
-  });
-
-  it("accessCount increments correctly after novelty-gated flush", async () => {
-    const entries = [makeEntry("m1")];
-    const store = createMockStore(entries);
-    const tracker = new AccessTracker(store as any, {
-      ...DEFAULT_ACCESS_TRACKER_CONFIG,
-      flushIntervalMs: 0,
-      noveltyThreshold: 0.35,
-      cooldownMs: 0,
-    });
-
-    tracker.recordAccess(["m1"], [0.40]); // novel → accepted
-    await tracker.flush();
-
-    const updated = store.data.get("m1")!;
-    const meta = JSON.parse(updated.metadata);
-    expect(meta.accessCount).toBe(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// destroy() cleans cooldown
-// ---------------------------------------------------------------------------
-
-describe("destroy cleans cooldown", () => {
-  it("clears cooldown map on destroy", () => {
-    const tracker = new AccessTracker(
-      createMockStore([]) as any,
-      { ...DEFAULT_ACCESS_TRACKER_CONFIG, cooldownMs: 600_000 },
-    );
-    tracker.recordAccess(["a"], [0.40]);
-    tracker.destroy();
-    // After destroy, same entry should be reinforceable again
-    expect(tracker.shouldReinforce("a", 0.40)).toBe(true);
-  });
-});

package/src/__tests__/activity-counter.test.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { join } from "node:path";
-import { mkdirSync, rmSync, existsSync } from "node:fs";
-import {
-  incrementWriteCount,
-  getWriteCount,
-  resetWriteCount,
-  getDistillTier,
-  type ActivityCounterConfig,
-} from "../activity-counter.js";
-
-const TMP_DIR = join(import.meta.dir, "../../.tmp-activity-test");
-const testConfig: Partial<ActivityCounterConfig> = {
-  statsPath: join(TMP_DIR, "activity-stats.json"),
-  lightThreshold: 3,
-  standardThreshold: 10,
-  deepThreshold: 20,
-};
-
-describe("activity-counter (HP-3)", () => {
-  beforeEach(() => {
-    mkdirSync(TMP_DIR, { recursive: true });
-    // Ensure clean state
-    const p = testConfig.statsPath!;
-    if (existsSync(p)) rmSync(p);
-  });
-
-  afterEach(() => {
-    rmSync(TMP_DIR, { recursive: true, force: true });
-  });
-
-  describe("incrementWriteCount", () => {
-    it("starts at 0 and increments by 1", () => {
-      expect(getWriteCount(testConfig)).toBe(0);
-      expect(incrementWriteCount(1, testConfig)).toBe(1);
-      expect(incrementWriteCount(1, testConfig)).toBe(2);
-      expect(getWriteCount(testConfig)).toBe(2);
-    });
-
-    it("increments by arbitrary n", () => {
-      incrementWriteCount(5, testConfig);
-      expect(getWriteCount(testConfig)).toBe(5);
-      incrementWriteCount(3, testConfig);
-      expect(getWriteCount(testConfig)).toBe(8);
-    });
-  });
-
-  describe("resetWriteCount", () => {
-    it("resets count to 0", () => {
-      incrementWriteCount(7, testConfig);
-      expect(getWriteCount(testConfig)).toBe(7);
-      resetWriteCount(testConfig);
-      expect(getWriteCount(testConfig)).toBe(0);
-    });
-  });
-
-  describe("getDistillTier", () => {
-    it("returns 'none' when below light threshold", () => {
-      incrementWriteCount(2, testConfig);
-      expect(getDistillTier(testConfig)).toBe("none");
-    });
-
-    it("returns 'light' at light threshold", () => {
-      incrementWriteCount(3, testConfig);
-      expect(getDistillTier(testConfig)).toBe("light");
-    });
-
-    it("returns 'standard' at standard threshold", () => {
-      incrementWriteCount(10, testConfig);
-      expect(getDistillTier(testConfig)).toBe("standard");
-    });
-
-    it("returns 'deep' at deep threshold", () => {
-      incrementWriteCount(20, testConfig);
-      expect(getDistillTier(testConfig)).toBe("deep");
-    });
-
-    it("returns 'deep' well above deep threshold", () => {
-      incrementWriteCount(100, testConfig);
-      expect(getDistillTier(testConfig)).toBe("deep");
-    });
-  });
-
-  describe("resilience", () => {
-    it("handles missing stats file gracefully", () => {
-      expect(getWriteCount(testConfig)).toBe(0);
-      expect(getDistillTier(testConfig)).toBe("none");
-    });
-
-    it("handles corrupt stats file gracefully", () => {
-      const { writeFileSync } = require("node:fs");
-      writeFileSync(testConfig.statsPath!, "not-json{{{");
-      expect(getWriteCount(testConfig)).toBe(0);
-    });
-  });
-});

package/src/__tests__/admission-control.test.ts

@@ -1,206 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  checkAdmission,
-  resolveAdmissionConfig,
-  ScopeRateLimiter,
-} from "../admission-control.js";
-
-// ---------------------------------------------------------------------------
-// resolveAdmissionConfig
-// ---------------------------------------------------------------------------
-
-describe("resolveAdmissionConfig", () => {
-  it("returns defaults when no overrides", () => {
-    const cfg = resolveAdmissionConfig();
-    expect(cfg.minTextLength).toBe(10);
-    expect(cfg.noiseFilterEnabled).toBe(true);
-    expect(cfg.minImportance).toBe(0.2);
-    expect(cfg.maxWritesPerScope).toBe(50);
-    expect(cfg.rateLimitWindowMs).toBe(60_000);
-  });
-
-  it("merges partial overrides", () => {
-    const cfg = resolveAdmissionConfig({ minImportance: 0.5 });
-    expect(cfg.minImportance).toBe(0.5);
-    expect(cfg.minTextLength).toBe(10); // unchanged
-  });
-});
-
-// ---------------------------------------------------------------------------
-// checkAdmission — text length
-// ---------------------------------------------------------------------------
-
-describe("checkAdmission — text length", () => {
-  it("rejects text shorter than minTextLength", () => {
-    const result = checkAdmission("short", 0.8, "project:test");
-    expect(result.verdict).toBe("rejected");
-    expect(result.reason).toBe("text_too_short");
-  });
-
-  it("rejects empty text", () => {
-    const result = checkAdmission("", 0.8, "project:test");
-    expect(result.verdict).toBe("rejected");
-    expect(result.reason).toBe("text_too_short");
-  });
-
-  it("rejects whitespace-only text", () => {
-    const result = checkAdmission("         ", 0.8, "project:test");
-    expect(result.verdict).toBe("rejected");
-    expect(result.reason).toBe("text_too_short");
-  });
-
-  it("accepts text at exactly minTextLength", () => {
-    const result = checkAdmission("abcdefghij", 0.8, "project:test");
-    expect(result.verdict).toBe("accepted");
-  });
-
-  it("respects custom minTextLength", () => {
-    const result = checkAdmission("hello world", 0.8, "project:test", undefined, { minTextLength: 20 });
-    expect(result.verdict).toBe("rejected");
-    expect(result.reason).toBe("text_too_short");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// checkAdmission — noise filter
-// ---------------------------------------------------------------------------
-
-describe("checkAdmission — noise filter", () => {
-  it("rejects denial patterns", () => {
-    const result = checkAdmission("I don't have any information about that topic", 0.8, "project:test");
-    expect(result.verdict).toBe("rejected");
-    expect(result.reason).toBe("noise_detected");
-  });
-
-  it("rejects boilerplate greetings", () => {
-    const result = checkAdmission("hello there!", 0.8, "project:test");
-    expect(result.verdict).toBe("rejected");
-    expect(result.reason).toBe("noise_detected");
-  });
-
-  it("can be disabled via config", () => {
-    const result = checkAdmission(
-      "I don't have any information about that topic",
-      0.8,
-      "project:test",
-      undefined,
-      { noiseFilterEnabled: false },
-    );
-    expect(result.verdict).toBe("accepted");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// checkAdmission — importance floor
-// ---------------------------------------------------------------------------
-
-describe("checkAdmission — importance floor", () => {
-  it("rejects importance below default threshold (0.2)", () => {
-    const result = checkAdmission("This is a valid memory text", 0.1, "project:test");
-    expect(result.verdict).toBe("rejected");
-    expect(result.reason).toBe("importance_too_low");
-  });
-
-  it("accepts importance at exactly the threshold", () => {
-    const result = checkAdmission("This is a valid memory text", 0.2, "project:test");
-    expect(result.verdict).toBe("accepted");
-  });
-
-  it("accepts importance above threshold", () => {
-    const result = checkAdmission("This is a valid memory text", 0.8, "project:test");
-    expect(result.verdict).toBe("accepted");
-  });
-
-  it("respects custom minImportance", () => {
-    const result = checkAdmission("This is a valid memory text", 0.4, "project:test", undefined, { minImportance: 0.5 });
-    expect(result.verdict).toBe("rejected");
-    expect(result.reason).toBe("importance_too_low");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// ScopeRateLimiter
-// ---------------------------------------------------------------------------
-
-describe("ScopeRateLimiter", () => {
-  it("allows writes within limit", () => {
-    const limiter = new ScopeRateLimiter();
-    const cfg = resolveAdmissionConfig({ maxWritesPerScope: 3 });
-    expect(limiter.check("s1", cfg)).toBe(true);
-    expect(limiter.check("s1", cfg)).toBe(true);
-    expect(limiter.check("s1", cfg)).toBe(true);
-  });
-
-  it("blocks writes exceeding limit", () => {
-    const limiter = new ScopeRateLimiter();
-    const cfg = resolveAdmissionConfig({ maxWritesPerScope: 2 });
-    expect(limiter.check("s1", cfg)).toBe(true);
-    expect(limiter.check("s1", cfg)).toBe(true);
-    expect(limiter.check("s1", cfg)).toBe(false); // 3rd blocked
-  });
-
-  it("tracks scopes independently", () => {
-    const limiter = new ScopeRateLimiter();
-    const cfg = resolveAdmissionConfig({ maxWritesPerScope: 1 });
-    expect(limiter.check("s1", cfg)).toBe(true);
-    expect(limiter.check("s2", cfg)).toBe(true);
-    expect(limiter.check("s1", cfg)).toBe(false); // s1 exhausted
-    expect(limiter.check("s2", cfg)).toBe(false); // s2 exhausted
-  });
-
-  it("reports correct size", () => {
-    const limiter = new ScopeRateLimiter();
-    const cfg = resolveAdmissionConfig();
-    limiter.check("a", cfg);
-    limiter.check("b", cfg);
-    expect(limiter.size).toBe(2);
-  });
-
-  it("clears all state", () => {
-    const limiter = new ScopeRateLimiter();
-    const cfg = resolveAdmissionConfig();
-    limiter.check("a", cfg);
-    limiter.clear();
-    expect(limiter.size).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// checkAdmission — rate limiting
-// ---------------------------------------------------------------------------
-
-describe("checkAdmission — rate limiting", () => {
-  it("rejects when rate limit exceeded", () => {
-    const limiter = new ScopeRateLimiter();
-    const cfg = { maxWritesPerScope: 2 } as const;
-    // First two pass
-    checkAdmission("valid memory text here", 0.8, "project:test", limiter, cfg);
-    checkAdmission("another valid memory text", 0.8, "project:test", limiter, cfg);
-    // Third is rate limited
-    const result = checkAdmission("yet another valid text", 0.8, "project:test", limiter, cfg);
-    expect(result.verdict).toBe("rejected");
-    expect(result.reason).toBe("rate_limited");
-  });
-
-  it("skips rate limiting when no limiter provided", () => {
-    const result = checkAdmission("valid memory text here", 0.8, "project:test");
-    expect(result.verdict).toBe("accepted");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// checkAdmission — happy path
-// ---------------------------------------------------------------------------
-
-describe("checkAdmission — happy path", () => {
-  it("accepts valid memory with all checks passing", () => {
-    const result = checkAdmission(
-      "User prefers dark mode in all applications",
-      0.8,
-      "project:test",
-    );
-    expect(result.verdict).toBe("accepted");
-    expect(result.reason).toBeUndefined();
-  });
-});

package/src/__tests__/anchor-generator.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { generateAnchor } from "../anchor-generator.js";
-
-describe("generateAnchor", () => {
-  it("returns undefined for short text (≤80 chars)", () => {
-    expect(generateAnchor("轮巡仓库每日检查")).toBeUndefined();
-    expect(generateAnchor("Short text that fits in 80 chars easily")).toBeUndefined();
-  });
-
-  it("extracts first sentence from long text", () => {
-    const text = "每天轮巡4个win4r仓库，检查Issue和PR。" +
-      "包括 ClawTeam-OpenClaw、openclaw-a2a-gateway、memory-lancedb-pro、UltraMemory。" +
-      "Issue 用中文回复，PR 用英文 review。不要重复回复已处理的。";
-    const anchor = generateAnchor(text);
-    expect(anchor).toBeDefined();
-    expect(anchor!.length).toBeLessThanOrEqual(80);
-    expect(anchor).toBe("每天轮巡4个win4r仓库，检查Issue和PR");
-  });
-
-  it("uses workflow pattern title from metadata", () => {
-    const text = "A very long workflow pattern description that spans multiple lines and paragraphs explaining the full procedure";
-    const metadata = {
-      workflowPattern: {
-        title: "Daily repo patrol",
-        trigger: "Every morning",
-      },
-    };
-    const anchor = generateAnchor(text, metadata);
-    expect(anchor).toBe("Daily repo patrol");
-  });
-
-  it("uses case memory title from metadata", () => {
-    const text = "A very long case description that spans multiple lines and paragraphs explaining the full case and its resolution";
-    const metadata = {
-      caseMemory: {
-        title: "Fix dedup over-kill in ingest",
-        problem: "72% of chunks were being dropped",
-      },
-    };
-    const anchor = generateAnchor(text, metadata);
-    expect(anchor).toBe("Fix dedup over-kill in ingest");
-  });
-
-  it("truncates long first sentences at CJK char boundary", () => {
-    const text = "这是一个非常非常非常非常非常非常非常非常非常非常非常非常非常非常长的第一句话，" +
-      "超过了八十个字符的限制需要被截断到合适的长度。" +
-      "第二句话在这里提供更多上下文信息用于测试截断功能是否正常工作。";
-    const anchor = generateAnchor(text);
-    expect(anchor).toBeDefined();
-    expect(anchor!.length).toBeLessThanOrEqual(80);
-  });
-
-  it("truncates long English sentences at word boundary", () => {
-    const text = "This is a very long first sentence that definitely exceeds the eighty character limit by quite a significant margin. Second sentence here.";
-    const anchor = generateAnchor(text);
-    expect(anchor).toBeDefined();
-    expect(anchor!.length).toBeLessThanOrEqual(80);
-    // Should not end mid-word
-    expect(anchor!).not.toMatch(/\s$/);
-  });
-
-  it("handles text with only newline separators", () => {
-    const text = "First line of important information that is a reasonable sentence\nSecond line with more details and context that expands on the first point";
-    const anchor = generateAnchor(text);
-    expect(anchor).toBe("First line of important information that is a reasonable sentence");
-  });
-});