recallnest 3.0.0 → 3.0.1

package/src/__tests__/pivot-apply.test.ts

@@ -1,373 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  PIVOT_APPLY_CAPTURE,
-  PIVOT_APPLY_SOURCE,
-  PIVOT_SCOPE,
-  PivotCandidateInputSchema,
-  persistPivotBatch,
-  persistPivotCandidate,
-} from "../pivot-apply.js";
-
-const REPORT_ID = "00b609834309b7b44d1e36fc7c93169e083abb66487073bfd64d8c5bafc337fa";
-
-function candHash(seed: string): string {
-  // Deterministic 64-hex filler for tests — content-addressing is the runner's job.
-  return seed.repeat(64).slice(0, 64);
-}
-
-function makeCandidate(overrides: Record<string, unknown> = {}): Record<string, unknown> {
-  return {
-    kind: "preference_rule",
-    text: "用户确立了外部项目学习的标准化工作流：分析链接后必须记录到 learnings 并同步更新借鉴审计目录。",
-    anchor: "你要记住了，以后都是，甩链接，学习，记录。",
-    canonicalKey: "pivot-preference-rule-learning-audit-workflow",
-    evidence: ["你要记住了，以后都是，甩链接，学习，记录，如果借鉴了就要记到审计这里。"],
-    proposedScope: PIVOT_SCOPE,
-    proposedCategory: "preferences",
-    tags: ["src:bb8af0b7", "date:2026-04-12", "harness:claude-code", "raw:claude"],
-    sessionId: "bb8af0b7-cc58-4bb2-8e35-9744537e5854",
-    reportId: REPORT_ID,
-    candidateHash: candHash("a"),
-    batchId: "test-batch-1",
-    importance: 0.7,
-    ...overrides,
-  };
-}
-
-function createDeps() {
-  const storedEntries: Array<Record<string, unknown>> = [];
-  const auditLines: Array<Record<string, unknown>> = [];
-  let seq = 1;
-
-  const store = {
-    async store(entry: Record<string, unknown>) {
-      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: Record<string, unknown>) {
-      const index = storedEntries.findIndex((entry) => entry.id === id);
-      if (index < 0) return null;
-      storedEntries[index] = { ...storedEntries[index], ...updates };
-      return storedEntries[index];
-    },
-    async upsert(entry: Record<string, unknown>) {
-      const index = storedEntries.findIndex((item) => item.id === entry.id);
-      if (index >= 0) storedEntries[index] = { ...entry };
-      else storedEntries.push({ ...entry });
-      return entry;
-    },
-    async get(id: string) {
-      return storedEntries.find((entry) => entry.id === id) ?? null;
-    },
-  };
-
-  return {
-    storedEntries,
-    auditLines,
-    deps: {
-      store,
-      embedder: {
-        async embedPassage(text: string) {
-          return [text.length, 1, 0];
-        },
-      },
-      auditLogger: {
-        log(line: Record<string, unknown>) {
-          auditLines.push(line);
-        },
-      },
-    },
-  };
-}
-
-describe("PivotCandidateInputSchema", () => {
-  it("accepts a corpus-shaped candidate", () => {
-    expect(() => PivotCandidateInputSchema.parse(makeCandidate())).not.toThrow();
-  });
-
-  it("rejects kind/category mismatch (corpus mapping violated)", () => {
-    expect(() =>
-      PivotCandidateInputSchema.parse(makeCandidate({ kind: "case", proposedCategory: "events" })),
-    ).toThrow();
-  });
-
-  it("rejects a wrong scope, missing identity keys, and malformed hashes", () => {
-    expect(() => PivotCandidateInputSchema.parse(makeCandidate({ proposedScope: "memory:other" }))).toThrow();
-    const missing = makeCandidate();
-    delete missing.candidateHash;
-    expect(() => PivotCandidateInputSchema.parse(missing)).toThrow();
-    expect(() => PivotCandidateInputSchema.parse(makeCandidate({ reportId: "not-hex" }))).toThrow();
-  });
-});
-
-describe("persistPivotCandidate", () => {
-  it("stores a clean candidate with session_distill identity and full pivot metadata", async () => {
-    const { deps, storedEntries, auditLines } = createDeps();
-    const outcome = await persistPivotCandidate(deps as never, makeCandidate());
-
-    expect(outcome.disposition).toBe("stored");
-    expect(outcome.memoryId).not.toBeNull();
-    expect(outcome.verified).toBe(true);
-
-    expect(storedEntries.length).toBe(1);
-    const meta = JSON.parse(String(storedEntries[0].metadata)) as Record<string, unknown>;
-    expect(meta.source).toBe(PIVOT_APPLY_SOURCE);
-    expect(meta.capture).toBe(PIVOT_APPLY_CAPTURE);
-    expect(meta.anchor).toBe("你要记住了，以后都是，甩链接，学习，记录。");
-    expect((meta.confidence as Record<string, unknown>).score).toBe(0.6);
-    expect((meta.confidence as Record<string, unknown>).reliability).toBe("inferred");
-    const pivotApply = meta.pivotApply as Record<string, unknown>;
-    expect(pivotApply.kind).toBe("preference_rule");
-    expect(pivotApply.reportId).toBe(REPORT_ID);
-    expect(pivotApply.candidateHash).toBe(candHash("a"));
-    expect(pivotApply.batchId).toBe("test-batch-1");
-    expect(pivotApply.sessionId).toBe("bb8af0b7-cc58-4bb2-8e35-9744537e5854");
-    expect(pivotApply.evidence).toEqual([
-      "你要记住了，以后都是，甩链接，学习，记录，如果借鉴了就要记到审计这里。",
-    ]);
-    const tags = meta.tags as string[];
-    expect(tags).toContain("pivot-apply");
-    expect(tags).toContain("batch:test-batch-1");
-    expect((meta.evolution as Record<string, unknown>).status).toBe("active");
-    expect((meta.boundary as Record<string, unknown>).layer).toBe("durable");
-
-    expect(auditLines.some((line) => line.operation === "store")).toBe(true);
-  });
-
-  it("runs without any LLM in deps (the channel must be LLM-free)", async () => {
-    const { deps } = createDeps();
-    // deps deliberately has no llm / kgExtractor / rateLimiter keys at all.
-    const outcome = await persistPivotCandidate(deps as never, makeCandidate());
-    expect(outcome.disposition).toBe("stored");
-  });
-
-  it("dedupes an identical re-apply (same key, same normalized text) without writing twice", async () => {
-    const { deps, storedEntries } = createDeps();
-    const first = await persistPivotCandidate(deps as never, makeCandidate());
-    const second = await persistPivotCandidate(deps as never, makeCandidate({ candidateHash: candHash("b") }));
-
-    expect(first.disposition).toBe("stored");
-    expect(second.disposition).toBe("deduped");
-    expect(second.memoryId).toBe(first.memoryId);
-    expect(storedEntries.length).toBe(1);
-  });
-
-  it("supersedes on same-key different-text for preferences (latest-wins revision)", async () => {
-    const { deps, storedEntries } = createDeps();
-    const first = await persistPivotCandidate(deps as never, makeCandidate());
-    const second = await persistPivotCandidate(
-      deps as never,
-      makeCandidate({
-        candidateHash: candHash("c"),
-        text: "修订版：外部项目学习工作流新增 hippo-wiki 归档要求，三写缺一不可。",
-      }),
-    );
-
-    expect(first.disposition).toBe("stored");
-    expect(second.disposition).toBe("updated");
-    // latest-wins updates the canonical row in place: same id stays live with V2
-    // text, while V1 is copied out into a separate superseded history row.
-    expect(second.memoryId).toBe(first.memoryId);
-    const canonicalRow = storedEntries.find((entry) => entry.id === first.memoryId);
-    expect(String(canonicalRow?.text)).toContain("修订版");
-    const historyRow = storedEntries.find((entry) => {
-      if (entry.id === first.memoryId) return false;
-      try {
-        const meta = JSON.parse(String(entry.metadata)) as Record<string, unknown>;
-        return (meta.evolution as Record<string, unknown> | undefined)?.status === "superseded";
-      } catch {
-        return false;
-      }
-    });
-    expect(historyRow).toBeDefined();
-  });
-
-  it("appends (stores) on same-key different-text for cases — append-only category", async () => {
-    const { deps, storedEntries } = createDeps();
-    const base = {
-      kind: "case",
-      proposedCategory: "cases",
-      canonicalKey: "cases-append-only-probe",
-    };
-    const first = await persistPivotCandidate(
-      deps as never,
-      makeCandidate({ ...base, candidateHash: candHash("d"), text: "Case: 第一次踩坑的完整记录，包含问题与解法细节。" }),
-    );
-    const second = await persistPivotCandidate(
-      deps as never,
-      makeCandidate({ ...base, candidateHash: candHash("e"), text: "Case: 第二次同主题踩坑，但情境不同，应作为新行追加保存。" }),
-    );
-
-    expect(first.disposition).toBe("stored");
-    expect(second.disposition).toBe("stored");
-    expect(storedEntries.filter((e) => e.category === "cases").length).toBe(2);
-  });
-
-  it("reports conflict (and writes nothing) when the key collides across categories", async () => {
-    const conflictRecords: Array<Record<string, unknown>> = [];
-    const { deps, storedEntries } = createDeps();
-    const depsWithConflict = {
-      ...deps,
-      conflictStore: {
-        async save(record: Record<string, unknown>) {
-          conflictRecords.push(record);
-          return record;
-        },
-        async getOpenByFingerprint() {
-          return null;
-        },
-        async getLatestByFingerprint() {
-          return null;
-        },
-        async replace(record: Record<string, unknown>) {
-          conflictRecords.push(record);
-          return record;
-        },
-      },
-    };
-    const first = await persistPivotCandidate(
-      depsWithConflict as never,
-      makeCandidate({ canonicalKey: "pivot-cross-category-probe" }),
-    );
-    const crossCategory = await persistPivotCandidate(
-      depsWithConflict as never,
-      makeCandidate({
-        kind: "decision",
-        proposedCategory: "events",
-        canonicalKey: "pivot-cross-category-probe",
-        candidateHash: candHash("f"),
-        text: "决策：同一个 canonicalKey 被另一类目引用，应触发 conflict 而非写入。",
-      }),
-    );
-
-    expect(first.disposition).toBe("stored");
-    expect(crossCategory.disposition).toBe("conflict");
-    expect(crossCategory.conflictId).toBeDefined();
-    expect(storedEntries.length).toBe(1);
-  });
-
-  it("retries transient 429 embedding errors and succeeds", async () => {
-    const { deps } = createDeps();
-    let calls = 0;
-    const flakyDeps = {
-      ...deps,
-      embedder: {
-        async embedPassage(text: string) {
-          calls++;
-          if (calls === 1) throw new Error("Request failed with status 429: rate limit exceeded");
-          return [text.length, 1, 0];
-        },
-      },
-    };
-    const outcome = await persistPivotCandidate(flakyDeps as never, makeCandidate());
-    expect(outcome.disposition).toBe("stored");
-    expect(calls).toBe(2);
-  });
-
-  it("fails closed when the embedder returns an empty vector (store never validates shape)", async () => {
-    const { deps, storedEntries } = createDeps();
-    const emptyDeps = {
-      ...deps,
-      embedder: {
-        async embedPassage() {
-          return [] as number[];
-        },
-      },
-    };
-    await expect(persistPivotCandidate(emptyDeps as never, makeCandidate())).rejects.toThrow(/empty vector/);
-    expect(storedEntries.length).toBe(0);
-  });
-
-  it("rejects noise via rule-based admission with a null memoryId and an audit line", async () => {
-    const { deps, storedEntries, auditLines } = createDeps();
-    const outcome = await persistPivotCandidate(
-      deps as never,
-      makeCandidate({ text: "好的好的，收到收到。", candidateHash: candHash("9") }),
-    );
-
-    expect(outcome.disposition).toBe("rejected");
-    expect(outcome.memoryId).toBeNull();
-    expect(outcome.rejectionReason).toBeDefined();
-    expect(storedEntries.length).toBe(0);
-    expect(auditLines.some((line) => line.operation === "reject")).toBe(true);
-  });
-});
-
-describe("persistPivotBatch", () => {
-  it("writes a clean batch fully and reports written = total", async () => {
-    const { deps } = createDeps();
-    const batch = [
-      makeCandidate({ candidateHash: candHash("1"), canonicalKey: "pivot-batch-key-1" }),
-      makeCandidate({
-        candidateHash: candHash("2"),
-        canonicalKey: "pivot-batch-key-2",
-        text: "第二条独立候选：批内不同 key 不同文本，应正常写入。",
-      }),
-    ];
-    const report = await persistPivotBatch(deps as never, "test-batch-1", batch);
-
-    expect(report.halted).toBe(false);
-    expect(report.total).toBe(2);
-    expect(report.written).toBe(2);
-    expect(report.outcomes.every((o) => o.disposition === "stored")).toBe(true);
-  });
-
-  it("halts fail-closed on the first unexpected disposition and keeps prior outcomes", async () => {
-    const { deps, storedEntries } = createDeps();
-    const batch = [
-      makeCandidate({ candidateHash: candHash("1"), canonicalKey: "pivot-batch-key-1" }),
-      // Same key + same text as row 1 → deduped → unexpected → halt.
-      makeCandidate({ candidateHash: candHash("2"), canonicalKey: "pivot-batch-key-1" }),
-      makeCandidate({ candidateHash: candHash("3"), canonicalKey: "pivot-batch-key-3" }),
-    ];
-    const report = await persistPivotBatch(deps as never, "test-batch-1", batch);
-
-    expect(report.halted).toBe(true);
-    expect(report.haltReason).toContain("deduped");
-    expect(report.outcomes.length).toBe(2);
-    expect(report.written).toBe(1);
-    // Third candidate must never have been attempted.
-    expect(storedEntries.length).toBe(1);
-  });
-
-  it("halts before writing when a candidate claims a different batchId", async () => {
-    const { deps, storedEntries } = createDeps();
-    const report = await persistPivotBatch(deps as never, "test-batch-1", [
-      makeCandidate({ batchId: "other-batch" }),
-    ]);
-
-    expect(report.halted).toBe(true);
-    expect(report.haltReason).toContain("other-batch");
-    expect(report.outcomes.length).toBe(0);
-    expect(storedEntries.length).toBe(0);
-  });
-
-  it("halts when post-write verification fails (store.get returns null)", async () => {
-    const { deps } = createDeps();
-    const brokenDeps = {
-      ...deps,
-      store: {
-        ...deps.store,
-        async get() {
-          return null;
-        },
-      },
-    };
-    const report = await persistPivotBatch(brokenDeps as never, "test-batch-1", [makeCandidate()]);
-
-    expect(report.halted).toBe(true);
-    expect(report.haltReason).toContain("verification failed");
-  });
-});