recallnest 2.6.1 → 3.0.1

package/src/__tests__/core-recall-eval.test.ts

@@ -1,235 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { promoteMemory } from "../capture-engine.js";
-import { createRetriever } from "../retriever.js";
-import { buildRetrievalContext, matchesScopeFilter } from "../scope-policy.js";
-
-function cosineSimilarity(a: number[], b: number[]): number {
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i += 1) {
-    dot += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom === 0 ? 0 : dot / denom;
-}
-
-function createCoreRetriever(entries: Array<{
-  id: string;
-  text: string;
-  scope: string;
-  category?: "entities" | "events";
-  vector: number[];
-}>) {
-  return createRetriever({
-    hasFtsSupport: false,
-    async vectorSearch(queryVector: number[], limit = 5, minScore = 0, scopeFilter?: string[]) {
-      return entries
-        .filter((entry) => matchesScopeFilter(entry.scope, scopeFilter))
-        .map((entry) => ({
-          entry: {
-            id: entry.id,
-            text: entry.text,
-            vector: entry.vector,
-            category: entry.category || "entities",
-            scope: entry.scope,
-            importance: 0.8,
-            timestamp: Date.parse("2026-03-17T00:00:00.000Z"),
-            metadata: "{}",
-          },
-          score: cosineSimilarity(queryVector, entry.vector),
-        }))
-        .filter((result) => result.score >= minScore)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, limit);
-    },
-  } as any, {
-    async embedQuery(query: string) {
-      if (/衰减|公式|曲线|weibull/i.test(query)) return [1, 0, 0];
-      if (/部署|deploy|region|在哪/i.test(query)) return [0, 1, 0];
-      return [0, 0, 1];
-    },
-    async embedPassage() {
-      return [0, 0, 1];
-    },
-  } as any, {
-    mode: "vector",
-    rerank: "none",
-    filterNoise: false,
-    hardMinScore: 0,
-    minScore: 0,
-    recencyWeight: 0,
-    timeDecayHalfLifeDays: 0,
-  });
-}
-
-function createCaptureDeps() {
-  const storedEntries: any[] = [];
-  let seq = 1;
-
-  return {
-    storedEntries,
-    deps: {
-      embedder: {
-        async embedPassage(text: string) {
-          return [text.length, 1, 0];
-        },
-      },
-      store: {
-        async store(entry: any) {
-          const stored = {
-            ...entry,
-            id: `00000000-0000-0000-0000-${String(seq).padStart(12, "0")}`,
-            timestamp: 1_700_000_000_000 + seq,
-          };
-          seq += 1;
-          storedEntries.push(stored);
-          return stored;
-        },
-        async list(_scopeFilter?: string[], category?: string, limit = 20, offset = 0) {
-          return storedEntries
-            .filter((entry) => !category || entry.category === category)
-            .slice(offset, offset + limit);
-        },
-        async update(id: string, updates: any) {
-          const index = storedEntries.findIndex((entry) => entry.id === id);
-          if (index < 0) return null;
-          storedEntries[index] = {
-            ...storedEntries[index],
-            ...updates,
-            timestamp: updates.timestamp ?? storedEntries[index].timestamp,
-          };
-          return storedEntries[index];
-        },
-        async get(id: string) {
-          return storedEntries.find((entry) => entry.id === id) || null;
-        },
-        async getById(id: string) {
-          return storedEntries.find((entry) => entry.id === id) || null;
-        },
-      },
-      conflictStore: {
-        async save(record: any) {
-          return record;
-        },
-        async replace(record: any) {
-          return record;
-        },
-        async getOpenByFingerprint() {
-          return null;
-        },
-        async getLatestByFingerprint() {
-          return null;
-        },
-      },
-    },
-  };
-}
-
-describe("core recall eval", () => {
-  it("hits the right memory for a vague associative query within the target scope", async () => {
-    const retriever = createCoreRetriever([
-      {
-        id: "alpha-weibull",
-        text: "RecallNest uses Weibull decay with beta=0.8 for the core tier.",
-        scope: "project:alpha",
-        vector: [1, 0, 0],
-      },
-      {
-        id: "alpha-entity",
-        text: "RecallNest exposes checkpoint_session and resume_context.",
-        scope: "project:alpha",
-        vector: [0, 0, 1],
-      },
-      {
-        id: "beta-deploy",
-        text: "Project beta deploys in us-east-1.",
-        scope: "project:beta",
-        vector: [0, 1, 0],
-      },
-    ]);
-
-    const results = await retriever.retrieve(buildRetrievalContext({
-      query: "那个衰减曲线用的什么公式来着",
-      limit: 5,
-      scope: "project:alpha",
-    }, {
-      operation: "test:associative-recall",
-    }));
-
-    expect(results[0]?.entry.id).toBe("alpha-weibull");
-    expect(results.every((result) => result.entry.scope === "project:alpha")).toBe(true);
-  });
-
-  it("does not leak results from another scope when default scope is inferred", async () => {
-    const retriever = createCoreRetriever([
-      {
-        id: "alpha-note",
-        text: "Project alpha stores its API key outside the memory index.",
-        scope: "project:alpha",
-        vector: [0, 0, 1],
-      },
-      {
-        id: "beta-deploy",
-        text: "Project beta deploys in us-east-1.",
-        scope: "project:beta",
-        vector: [0, 1, 0],
-      },
-    ]);
-
-    const results = await retriever.retrieve(buildRetrievalContext({
-      query: "部署在哪",
-      limit: 5,
-    }, {
-      operation: "test:scope-isolation",
-      env: {
-        RECALLNEST_DEFAULT_SCOPE: "project:alpha",
-      } as NodeJS.ProcessEnv,
-    }));
-
-    expect(results.some((result) => result.entry.id === "beta-deploy")).toBe(false);
-    expect(results.every((result) => result.entry.scope === "project:alpha")).toBe(true);
-  });
-
-  it("preserves text and provenance when promoting evidence into durable memory", async () => {
-    const { deps, storedEntries } = createCaptureDeps();
-    const source = await deps.store.store({
-      text: "RecallNest uses Weibull decay with beta=0.8 for the core tier.",
-      vector: [1, 0, 0],
-      category: "events",
-      scope: "cc:session-alpha",
-      importance: 0.5,
-      metadata: JSON.stringify({
-        source: "cc",
-        boundary: {
-          layer: "evidence",
-          authority: "transcript-ingest",
-          conflictPolicy: "append-only",
-          originalCategory: "entities",
-        },
-      }),
-    });
-
-    const promoted = await promoteMemory(deps as any, {
-      memoryId: source.id,
-      category: "entities",
-      scope: "project:alpha",
-      source: "agent",
-      tags: ["core-eval"],
-    });
-
-    expect(promoted.text).toBe("RecallNest uses Weibull decay with beta=0.8 for the core tier.");
-    expect(promoted.resolvedScope).toBe("project:alpha");
-    expect(storedEntries[1]?.text).toBe("RecallNest uses Weibull decay with beta=0.8 for the core tier.");
-    expect(JSON.parse(storedEntries[1]?.metadata || "{}")).toMatchObject({
-      promotedFrom: {
-        memoryId: source.id,
-        scope: "cc:session-alpha",
-        category: "events",
-      },
-    });
-  });
-});

package/src/__tests__/core-summary.test.ts

@@ -1,109 +0,0 @@
-/**
- * Tests for Tier 3.1: Core Summary — LLM summaries replace raw text in context output.
- *
- * Validates:
- * 1. bestSummaryText() priority chain: core_summary > l1 > l0 > raw text
- * 2. formatStableResult uses bestSummaryText
- * 3. formatTaskResult uses bestSummaryText
- * 4. generateCoreSummary method on LLM client
- * 5. buildIngestedEntry includes core_summary in metadata when provided
- */
-import { describe, expect, it } from "bun:test";
-import { bestSummaryText, stripConversationMarkers } from "../context-composer-text.js";
-
-// ---------------------------------------------------------------------------
-// bestSummaryText() priority chain
-// ---------------------------------------------------------------------------
-
-describe("bestSummaryText", () => {
-  const rawText = "[用户] I am a developer working on memory systems for AI agents";
-
-  it("returns core_summary when available", () => {
-    const meta = JSON.stringify({
-      core_summary: "Developer building AI agent memory systems",
-      l1_overview: "Longer L1 overview text here",
-      l0_abstract: "Short L0",
-    });
-    expect(bestSummaryText(rawText, meta)).toBe("Developer building AI agent memory systems");
-  });
-
-  it("falls back to l1_overview when no core_summary", () => {
-    const meta = JSON.stringify({
-      l1_overview: "L1: Developer working on AI memory",
-      l0_abstract: "Short L0",
-    });
-    expect(bestSummaryText(rawText, meta)).toBe("L1: Developer working on AI memory");
-  });
-
-  it("falls back to l0_abstract when no core_summary or l1", () => {
-    const meta = JSON.stringify({
-      l0_abstract: "Dev + AI memory",
-    });
-    expect(bestSummaryText(rawText, meta)).toBe("Dev + AI memory");
-  });
-
-  it("falls back to stripped raw text when no summaries", () => {
-    const meta = JSON.stringify({});
-    expect(bestSummaryText(rawText, meta)).toBe(stripConversationMarkers(rawText));
-  });
-
-  it("falls back to stripped raw text when metadata is undefined", () => {
-    expect(bestSummaryText(rawText, undefined)).toBe(stripConversationMarkers(rawText));
-  });
-
-  it("falls back to stripped raw text when metadata is invalid JSON", () => {
-    expect(bestSummaryText(rawText, "not-json")).toBe(stripConversationMarkers(rawText));
-  });
-
-  it("skips empty core_summary string", () => {
-    const meta = JSON.stringify({
-      core_summary: "",
-      l1_overview: "L1 text",
-    });
-    expect(bestSummaryText(rawText, meta)).toBe("L1 text");
-  });
-
-  it("skips empty l1_overview string", () => {
-    const meta = JSON.stringify({
-      core_summary: "",
-      l1_overview: "",
-      l0_abstract: "L0 text",
-    });
-    expect(bestSummaryText(rawText, meta)).toBe("L0 text");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Metadata integration
-// ---------------------------------------------------------------------------
-
-describe("core_summary in metadata", () => {
-  it("buildIngestedEntry includes core_summary when provided", () => {
-    // We test the metadata structure directly since buildIngestedEntry
-    // is a private function — we verify through the metadata shape
-    const metadata = JSON.stringify({
-      source: "test",
-      l0_abstract: "Short summary",
-      l1_overview: "Medium summary",
-      l2_content: "Full text content",
-      core_summary: "Core distilled summary ≤200 chars",
-      tier: "working",
-      boundary: { layer: "durable", authority: "derived" },
-    });
-
-    const parsed = JSON.parse(metadata);
-    expect(parsed.core_summary).toBe("Core distilled summary ≤200 chars");
-    expect(bestSummaryText("raw fallback", metadata)).toBe("Core distilled summary ≤200 chars");
-  });
-
-  it("metadata without core_summary falls back correctly", () => {
-    const metadata = JSON.stringify({
-      source: "test",
-      l0_abstract: "Short",
-      l1_overview: "Medium length overview",
-      l2_content: "Full text",
-    });
-
-    expect(bestSummaryText("raw text", metadata)).toBe("Medium length overview");
-  });
-});

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

@@ -1,276 +0,0 @@
-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" | "getVectors"> {
-  return {
-    // 复刻真实 store:list() 为性能不返回向量(vector: []),维度/干扰检查需经 getVectors 补回。
-    // 旧 mock 直接返回带向量的 entry,与生产行为不符,曾掩盖维度检查在生产假报健康的 bug。
-    async list() { return entries.map(e => ({ ...e, vector: [] })); },
-    async stats() {
-      return { totalCount: entries.length, scopeCounts: {}, categoryCounts: {} };
-    },
-    async getVectors(ids: string[]) {
-      const map = new Map<string, number[]>();
-      for (const e of entries) {
-        if (ids.includes(e.id) && e.vector.length > 0) map.set(e.id, e.vector);
-      }
-      return map;
-    },
-  } as Pick<MemoryStore, "list" | "stats" | "getVectors">;
-}
-
-// ---------------------------------------------------------------------------
-// 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(8);
-    expect(report.checks.every(c => c.status === "ok")).toBe(true);
-    expect(report.totalEntries).toBe(3);
-  });
-
-  it("reports usage distribution with cold top list (P0 B-1, flag on)", async () => {
-    process.env.RECALLNEST_CONSTRUCTIVE_RETRIEVAL = "true";
-    try {
-    const coldMeta = JSON.stringify({
-      accessCount: 10, // injection >= 6, no usage.useCount -> cold
-      evolution: { status: "active", version: 1 },
-    });
-    const entries = [
-      makeEntry({ id: "cold-1", metadata: coldMeta }),
-      makeEntry({ id: "ok-1" }),
-      makeEntry({ id: "ok-2" }),
-    ];
-
-    const report = await runDataCheckup({
-      store: createMockStore(entries),
-      openConflictCount: 0,
-    });
-
-    const usage = report.checks.find(c => c.name === "usage_distribution");
-    expect(usage).toBeTruthy();
-    expect(usage!.detail).toContain("cold=1");
-    expect(usage!.detail).toContain("cold-1".slice(0, 6)); // top list shows the id prefix
-    // 1/3 = 33% cold > 10% -> warning
-    expect(usage!.status).toBe("warning");
-    } finally {
-      delete process.env.RECALLNEST_CONSTRUCTIVE_RETRIEVAL;
-    }
-  });
-
-  it("reports use-signal-inactive instead of fake cold when flag is off", async () => {
-    delete process.env.RECALLNEST_CONSTRUCTIVE_RETRIEVAL;
-    const coldishMeta = JSON.stringify({ accessCount: 10, evolution: { status: "active", version: 1 } });
-    const report = await runDataCheckup({
-      store: createMockStore([makeEntry({ id: "a", metadata: coldishMeta })]),
-      openConflictCount: 0,
-    });
-    const usage = report.checks.find(c => c.name === "usage_distribution");
-    expect(usage!.status).toBe("ok");
-    expect(usage!.detail).toContain("use signal inactive");
-  });
-
-  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,
-      totalAvailable: 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");
-  });
-});