@chainlesschain/personal-data-hub 0.3.9 → 0.4.1

package/__tests__/adapters/weread.test.js

@@ -0,0 +1,123 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const { WeReadAdapter } = require("../../lib/adapters/weread");
+const { WeReadApiClient } = require("../../lib/adapters/weread/api-client");
+const { partitionBatch } = require("../../lib/batch");
+
+// ── stub fetch returning canned WeRead JSON by URL ──────────────────────
+function makeFetch(routes) {
+  return async (url) => {
+    for (const [pat, body] of routes) {
+      if (url.includes(pat)) {
+        return {
+          ok: true,
+          status: 200,
+          headers: { get: () => null },
+          json: async () => body,
+        };
+      }
+    }
+    return { ok: true, status: 200, headers: { get: () => null }, json: async () => ({}) };
+  };
+}
+
+const ROUTES = [
+  ["/user/notebooks", { books: [{ bookId: "b1", book: { title: "人类简史", author: "赫拉利", cover: "c" }, noteCount: 2, reviewCount: 1 }] }],
+  ["/book/bookmarklist", { updated: [{ bookmarkId: "m1", bookId: "b1", markText: "认知革命", chapterTitle: "第一章", createTime: 1700000000 }] }],
+  ["/review/list", { reviews: [{ review: { reviewId: "r1", bookId: "b1", content: "很有启发", chapterTitle: "第一章", createTime: 1700000100 } }] }],
+];
+
+async function collect(iter) {
+  const out = [];
+  for await (const r of iter) out.push(r);
+  return out;
+}
+
+describe("WeReadApiClient (cookie HTTP, stub fetch)", () => {
+  it("parses notebooks / bookmarks / reviews defensively", async () => {
+    const c = new WeReadApiClient({ cookie: "wr_skey=x", fetch: makeFetch(ROUTES) });
+    const books = await c.getNotebooks();
+    expect(books).toHaveLength(1);
+    expect(books[0].title).toBe("人类简史");
+    const marks = await c.getBookmarks("b1");
+    expect(marks[0].markText).toBe("认知革命");
+    const reviews = await c.getReviews("b1");
+    expect(reviews[0].content).toBe("很有启发");
+  });
+
+  it("requires a cookie", () => {
+    expect(() => new WeReadApiClient({})).toThrow(/cookie/);
+  });
+
+  it("degrades a failing endpoint to empty (no throw)", async () => {
+    const c = new WeReadApiClient({
+      cookie: "x",
+      fetch: async () => { throw new Error("network down"); },
+    });
+    expect(await c.getNotebooks()).toEqual([]);
+    expect(c.lastErrorCode).toBeTruthy();
+  });
+});
+
+describe("WeReadAdapter — cookie mode", () => {
+  it("readinessOnly without cookie → INVALID_COOKIE (credential)", async () => {
+    const r = await new WeReadAdapter().authenticate({ readinessOnly: true });
+    expect(r.reason).toBe("INVALID_COOKIE");
+  });
+
+  it("readinessOnly with cookie → configured", async () => {
+    const r = await new WeReadAdapter({ cookie: "x" }).authenticate({ readinessOnly: true });
+    expect(r.ok).toBe(true);
+    expect(r.mode).toBe("configured");
+  });
+
+  it("fetches book + highlight + review and normalizes to a valid batch", async () => {
+    const a = new WeReadAdapter();
+    const raws = await collect(a.sync({ cookie: "wr_skey=x", fetch: makeFetch(ROUTES) }));
+    expect(raws.map((r) => r.kind)).toEqual(["book", "highlight", "review"]);
+    const merged = { events: [], persons: [], places: [], items: [], topics: [] };
+    for (const r of raws) {
+      const n = a.normalize(r);
+      for (const k of Object.keys(merged)) merged[k].push(...n[k]);
+    }
+    const { valid, invalidReasons } = partitionBatch(merged);
+    expect(invalidReasons).toHaveLength(0);
+    expect(valid.events).toHaveLength(3); // book(browse) + highlight(other) + review(post)
+    expect(valid.items).toHaveLength(1); // the book
+    expect(valid.events.find((e) => e.subtype === "browse").content.title).toContain("人类简史");
+    expect(valid.events.find((e) => e.subtype === "post").content.text).toBe("很有启发");
+  });
+
+  it("includeNotes:false yields only book events", async () => {
+    const a = new WeReadAdapter();
+    const raws = await collect(a.sync({ cookie: "x", fetch: makeFetch(ROUTES), includeNotes: false }));
+    expect(raws.map((r) => r.kind)).toEqual(["book"]);
+  });
+});
+
+describe("WeReadAdapter — snapshot mode", () => {
+  const SNAP = {
+    schemaVersion: 1,
+    snapshottedAt: 1700000000000,
+    events: [
+      { kind: "book", id: "b1", bookId: "b1", title: "三体", author: "刘慈欣" },
+      { kind: "highlight", id: "m1", bookId: "b1", bookTitle: "三体", markText: "不要回答", createTime: 1700000001 },
+    ],
+  };
+  function snapAdapter(snap = SNAP, { exists = true } = {}) {
+    const a = new WeReadAdapter();
+    a._deps.fs = { existsSync: () => exists, readFileSync: () => JSON.stringify(snap), accessSync: () => {}, constants: { R_OK: 4 } };
+    return a;
+  }
+
+  it("ingests snapshot events", async () => {
+    const raws = await collect(snapAdapter().sync({ inputPath: "/x" }));
+    expect(raws.map((r) => r.kind)).toEqual(["book", "highlight"]);
+  });
+
+  it("schemaVersion mismatch throws", async () => {
+    await expect(collect(snapAdapter({ schemaVersion: 9, events: [] }).sync({ inputPath: "/x" }))).rejects.toThrow(/schemaVersion/);
+  });
+});

package/__tests__/analysis.test.js

@@ -354,6 +354,75 @@ describe("AnalysisEngine emits TOTALS preamble", () => {
   });
 });
 
+// ─── intent=sum-amount Phase 2 — AMOUNT_SUM authoritative total ──────────
+describe("AnalysisEngine emits AMOUNT_SUM preamble (intent=sum-amount Phase 2)", () => {
+  const baseVault = (over) => ({
+    queryEvents: () => [],
+    queryPersons: () => [],
+    queryItems: () => [],
+    stats: () => ({ events: 5, persons: 0, places: 0, items: 0, topics: 0 }),
+    getEvent: () => null,
+    audit: () => {},
+    ...over,
+  });
+  const captureLlm = (calls) => ({
+    isLocal: true,
+    chat: async (msgs) => {
+      calls.push(msgs);
+      return { text: "ok", usage: {} };
+    },
+  });
+
+  it("calls sumEventAmount for sum-amount intent and puts AMOUNT_SUM in prompt", async () => {
+    const sumCalls = [];
+    const fakeVault = baseVault({
+      sumEventAmount: (f) => {
+        sumCalls.push(f);
+        return { total: 888.8, currency: "CNY", count: 5, byDirection: { out: 888.8, in: 0 } };
+      },
+    });
+    const chatCalls = [];
+    const engine = new AnalysisEngine({ vault: fakeVault, llm: captureLlm(chatCalls) });
+    await engine.ask("我总共花了多少钱");
+    expect(sumCalls.length).toBe(1);
+    const userMsg = chatCalls[0][1].content;
+    expect(userMsg).toContain("AMOUNT_SUM");
+    expect(userMsg).toContain('"total": 888.8');
+    expect(chatCalls[0][0].content).toMatch(/AMOUNT_SUM.*authoritative/i);
+  });
+
+  it("does NOT call sumEventAmount for non-sum-amount intent", async () => {
+    const sumCalls = [];
+    const fakeVault = baseVault({
+      sumEventAmount: (f) => {
+        sumCalls.push(f);
+        return { total: 0, currency: "CNY", count: 0, byDirection: { out: 0, in: 0 } };
+      },
+    });
+    const engine = new AnalysisEngine({ vault: fakeVault, llm: captureLlm([]) });
+    await engine.ask("列出我的联系人"); // intent=list
+    expect(sumCalls.length).toBe(0);
+  });
+
+  it("omits AMOUNT_SUM block when sumEventAmount returns count 0", async () => {
+    const fakeVault = baseVault({
+      sumEventAmount: () => ({ total: 0, currency: "CNY", count: 0, byDirection: { out: 0, in: 0 } }),
+    });
+    const chatCalls = [];
+    const engine = new AnalysisEngine({ vault: fakeVault, llm: captureLlm(chatCalls) });
+    await engine.ask("我总共花了多少钱");
+    expect(chatCalls[0][1].content).not.toContain("AMOUNT_SUM");
+  });
+
+  it("legacy vault without sumEventAmount falls back gracefully", async () => {
+    const fakeVault = baseVault({}); // no sumEventAmount
+    const chatCalls = [];
+    const engine = new AnalysisEngine({ vault: fakeVault, llm: captureLlm(chatCalls) });
+    await engine.ask("我总共花了多少钱");
+    expect(chatCalls[0][1].content).not.toContain("AMOUNT_SUM");
+  });
+});
+
 // ─── Cache bypass — PDH ask must always go to LLM, never cached ───────
 //
 // Bug 2026-05-21: desktop ResponseCache (7-day TTL) served a stale
@@ -1569,9 +1638,15 @@ describe("AnalysisEngine._gatherFacts intent=sum-amount routing", () => {
 // 2026-05-24 — `intent=count` ("几个 X" / "多少个 Y") is handled by the
 // TOTALS preamble (commit 19c11920e): vault.stats() is rendered before
 // FACTS so the LLM quotes the real number instead of FACTS array length.
-// FACTS itself still goes through the default broader path (no narrow
-// routing). This block isolates the count-specific behavior into its
-// own describe so the audit gap is closed.
+//
+// 2026-06-02 — FACTS now ALSO hard-caps to COUNT_INTENT_FACT_LIMIT (5)
+// illustrative rows instead of the full ≤80 default sample: TOTALS already
+// carries the authoritative count (Rule 6), so a count question only needs a
+// few examples — saves prompt budget on local small models. Scoped by reliable
+// adapter+time filters; persons/items skipped (count-of-contacts/apps routes
+// via entityFocus). 0 hits → fall through to the default broader path (safety
+// net for a count misclassification of a list question). Memory:
+// pdh_analysis_engine_intent_routing.md.
 
 describe("AnalysisEngine._gatherFacts intent=count routing", () => {
   const mkEvent = (id, subtype = "order", adapter = "taobao") => ({
@@ -1580,28 +1655,56 @@ describe("AnalysisEngine._gatherFacts intent=count routing", () => {
     source: { adapter, adapterVersion: "0", capturedAt: Date.now(), capturedBy: "api" },
   });
 
-  it("(a) intent=count goes through default broader path (no narrow query)", async () => {
+  it("(a) intent=count → ≤5 illustrative events (capped), persons/items NOT queried", async () => {
+    const queryEventsCalls = [];
+    const fakeVault = {
+      queryEvents: (q) => {
+        queryEventsCalls.push(q);
+        return Array.from({ length: 20 }, (_, i) => mkEvent("e-" + i)).slice(0, q.limit);
+      },
+      queryPersons: vi.fn(() => []),
+      queryItems: vi.fn(() => []),
+      getEvent: () => null,
+      audit: () => {},
+      stats: () => ({ events: 20, persons: 0, places: 0, items: 0, topics: 0 }),
+    };
+    const llm = new MockLLMClient({ reply: "ok" });
+    const engine = new AnalysisEngine({ vault: fakeVault, llm });
+    const r = await engine.ask("我有多少个订单");
+
+    expect(r.parsed.intent).toBe("count");
+    // Capped to COUNT_INTENT_FACT_LIMIT (5), NOT the old default 200 — TOTALS
+    // carries the authoritative count, FACTS is just a few examples.
+    expect(queryEventsCalls).toHaveLength(1);
+    expect(queryEventsCalls[0].limit).toBe(5);
+    expect(queryEventsCalls[0].subtype).toBeUndefined(); // subtype NOT passed (unreliable)
+    expect(r.facts).toHaveLength(5);
+    // count-of-events doesn't need contacts/apps — skipped (those route via entityFocus).
+    expect(fakeVault.queryPersons).not.toHaveBeenCalled();
+    expect(fakeVault.queryItems).not.toHaveBeenCalled();
+  });
+
+  it("(a2) intent=count with adapter scope → adapter passed through on the capped query", async () => {
     const queryEventsCalls = [];
     const fakeVault = {
       queryEvents: (q) => {
         queryEventsCalls.push(q);
-        return [mkEvent("e-1"), mkEvent("e-2")];
+        return [mkEvent("e-1")];
       },
       queryPersons: () => [],
       queryItems: () => [],
       getEvent: () => null,
       audit: () => {},
-      stats: () => ({ events: 2, persons: 500, places: 0, items: 0, topics: 0 }),
+      stats: () => ({ events: 1, persons: 0, places: 0, items: 0, topics: 0 }),
     };
-    const llm = new MockLLMClient({ reply: "你有 500 个联系人" });
+    const llm = new MockLLMClient({ reply: "ok" });
     const engine = new AnalysisEngine({ vault: fakeVault, llm });
-    const r = await engine.ask("我有几个联系人");
+    const r = await engine.ask("我在淘宝有多少个订单");
 
     expect(r.parsed.intent).toBe("count");
-    // Single default queryEvents call (limit=200, no subtype filter, no narrow).
     expect(queryEventsCalls).toHaveLength(1);
-    expect(queryEventsCalls[0].limit).toBe(200);
-    expect(queryEventsCalls[0].subtype).toBeUndefined();
+    expect(queryEventsCalls[0].limit).toBe(5);
+    expect(queryEventsCalls[0].adapter).toBe("taobao");
   });
 
   it("(b) intent=count emits TOTALS block in prompt (authoritative ground truth)", async () => {
@@ -1661,12 +1764,14 @@ describe("AnalysisEngine._gatherFacts intent=count routing", () => {
     const llm = new MockLLMClient({ reply: "ok" });
     const engine = new AnalysisEngine({ vault: fakeVault, llm });
     await engine.ask("几个订单");
-    // Single default call — NOT 4 subtype calls (those are sum-amount only).
-    expect(queryEventsCalls).toHaveLength(1);
-    expect(queryEventsCalls[0].subtype).toBeUndefined();
+    // count branch (limit 5, 0 hits) → fall through to default (limit 200).
+    // Neither call carries a subtype filter — NOT the 4 subtype-narrowed calls
+    // that are sum-amount only.
+    expect(queryEventsCalls.map((q) => q.limit)).toEqual([5, 200]);
+    expect(queryEventsCalls.every((q) => q.subtype === undefined)).toBe(true);
   });
 
-  it("(e) intent=count pulls persons + items in FACTS (default path behavior)", async () => {
+  it("(e) intent=count with 0 events falls through → persons + items in FACTS (safety net)", async () => {
     const fakeVault = {
       queryEvents: () => [],
       queryPersons: ({ limit }) => Array.from({ length: Math.min(limit, 5) }, (_, i) => ({