@chainlesschain/personal-data-hub 0.3.9 → 0.4.1

package/lib/adapters/weread/api-client.js

@@ -0,0 +1,128 @@
+"use strict";
+
+/**
+ * 微信读书 (WeRead) web API client — cookie-based.
+ *
+ * Reuses the AI-chat HttpClient (cookie inject + rate-limit + retry +
+ * injectable fetch test seam). WeRead's app API host `i.weread.qq.com`
+ * accepts the web login cookie (key cookies: wr_vid, wr_skey, wr_name).
+ *
+ * Endpoints (community-documented; best-effort v0.1 — WeRead occasionally
+ * rotates params / adds light signing on some routes, so each method is
+ * defensive and a failing endpoint degrades to an empty list rather than
+ * aborting the whole sync):
+ *
+ *   GET /user/notebooks                 → 有笔记/划线的书 (notebooks)
+ *   GET /book/bookmarklist?bookId=      → 划线 (highlights)
+ *   GET /review/list?bookId=&listType=11&mine=1&synckey=0 → 想法 (reviews)
+ *   GET /readdata/summary?synckey=0     → 阅读时长汇总 (best-effort)
+ *
+ * The `wr_skey` cookie expires (~hours/days); a 401/403 surfaces as
+ * CookieExpiredError so the UI can prompt re-login.
+ */
+
+const { HttpClient, CookieExpiredError } = require("../ai-chat-history/http-client");
+
+const DEFAULT_BASE = "https://i.weread.qq.com";
+const DEFAULT_UA =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36";
+
+class WeReadApiClient {
+  /**
+   * @param {object} opts
+   * @param {string} opts.cookie            WeRead cookie header string.
+   * @param {string} [opts.baseUrl]         API host. Default i.weread.qq.com.
+   * @param {function} [opts.fetch]         Fetch override (test seam).
+   * @param {object} [opts.rateLimits]
+   */
+  constructor(opts = {}) {
+    if (typeof opts.cookie !== "string" || opts.cookie.length === 0) {
+      throw new Error("WeReadApiClient: opts.cookie required");
+    }
+    this._cookie = opts.cookie;
+    this._base = (opts.baseUrl || DEFAULT_BASE).replace(/\/$/, "");
+    this._http = new HttpClient({
+      vendor: "weread",
+      fetch: opts.fetch,
+      rateLimits: opts.rateLimits || { perMinute: 30, minIntervalMs: 1200 },
+    });
+    this.lastErrorCode = null;
+  }
+
+  _headers() {
+    return { Cookie: this._cookie, "User-Agent": DEFAULT_UA, Accept: "application/json" };
+  }
+
+  async _get(path) {
+    try {
+      return await this._http.getJson(`${this._base}${path}`, { headers: this._headers() });
+    } catch (err) {
+      if (err instanceof CookieExpiredError) {
+        this.lastErrorCode = "COOKIE_EXPIRED";
+        throw err;
+      }
+      this.lastErrorCode = err && err.message ? err.message : String(err);
+      return null; // degrade — caller treats as empty
+    }
+  }
+
+  /** Books that have notes/highlights. Returns array of {bookId, title, author, cover, noteCount, reviewCount}. */
+  async getNotebooks() {
+    const data = await this._get("/user/notebooks");
+    const books = (data && Array.isArray(data.books) && data.books) || [];
+    return books.map((b) => {
+      const book = b.book || b;
+      return {
+        bookId: String(b.bookId || book.bookId || ""),
+        title: book.title || "(未知书名)",
+        author: book.author || null,
+        cover: book.cover || null,
+        category: book.category || null,
+        noteCount: b.noteCount != null ? b.noteCount : null,
+        reviewCount: b.reviewCount != null ? b.reviewCount : null,
+        bookmarkCount: b.bookmarkCount != null ? b.bookmarkCount : null,
+        sort: b.sort != null ? b.sort : null,
+      };
+    });
+  }
+
+  /** Highlights (划线) for one book. */
+  async getBookmarks(bookId) {
+    const data = await this._get(`/book/bookmarklist?bookId=${encodeURIComponent(bookId)}`);
+    const rows = (data && (data.updated || data.bookmarks)) || [];
+    return (Array.isArray(rows) ? rows : []).map((m) => ({
+      bookmarkId: String(m.bookmarkId || ""),
+      bookId: String(m.bookId || bookId),
+      chapterTitle: m.chapterTitle || m.chapterName || null,
+      chapterUid: m.chapterUid != null ? m.chapterUid : null,
+      markText: m.markText || "",
+      createTime: m.createTime != null ? m.createTime : null,
+    }));
+  }
+
+  /** Reviews / thoughts (想法) for one book. */
+  async getReviews(bookId) {
+    const data = await this._get(
+      `/review/list?bookId=${encodeURIComponent(bookId)}&listType=11&mine=1&synckey=0`,
+    );
+    const rows = (data && data.reviews) || [];
+    return (Array.isArray(rows) ? rows : []).map((r) => {
+      const rev = r.review || r;
+      return {
+        reviewId: String(rev.reviewId || ""),
+        bookId: String(rev.bookId || bookId),
+        content: rev.content || "",
+        chapterTitle: rev.chapterTitle || null,
+        createTime: rev.createTime != null ? rev.createTime : null,
+        abstract: rev.abstract || null,
+      };
+    });
+  }
+
+  /** Reading-time summary (best-effort; shape varies). Returns raw object or null. */
+  async getReadSummary() {
+    return await this._get("/readdata/summary?synckey=0");
+  }
+}
+
+module.exports = { WeReadApiClient, DEFAULT_BASE };

package/lib/adapters/weread/index.js

@@ -0,0 +1,337 @@
+"use strict";
+
+/**
+ * 微信读书 (WeRead) adapter — cookie 模式 + snapshot 模式.
+ *
+ * 知识阅读类数据源。WeRead 没有像微信/QQ 那样的本地加密大库；最可靠的个人
+ * 路径是 **cookie web API**（登录 weread.qq.com 后用 cookie 拉自己的笔记本/
+ * 划线/想法/阅读时长）。
+ *
+ *   1. cookie 模式 (opts.cookie): 用 WeReadApiClient 直接拉 → 产出
+ *      book / highlight / review 事件。一键友好（UI 抓 cookie 后传入）。
+ *   2. snapshot 模式 (opts.inputPath): 消费预先抓好的 JSON（Android 采集器 /
+ *      可测）。schema 与 cookie 模式产出的 kinds 对齐。
+ *
+ * 实体映射：
+ *   book      → ITEM(document《书名》) + EVENT(browse 读了《书名》)
+ *   highlight → EVENT(other, 划线文本)          extra.kind=highlight
+ *   review    → EVENT(post, 想法文本)            extra.kind=review
+ *
+ * snapshot schema (schemaVersion 1):
+ *   { schemaVersion:1, snapshottedAt, account:{vid,name},
+ *     events:[ {kind:"book",id,bookId,title,author,noteCount},
+ *              {kind:"highlight",id,bookId,bookTitle,markText,chapterTitle,createTime},
+ *              {kind:"review",id,bookId,bookTitle,content,chapterTitle,createTime} ] }
+ */
+
+const fs = require("node:fs");
+const { newId } = require("../../ids");
+const {
+  ENTITY_TYPES,
+  EVENT_SUBTYPES,
+  ITEM_SUBTYPES,
+  CAPTURED_BY,
+} = require("../../constants");
+
+const NAME = "weread";
+const VERSION = "0.1.0";
+const SNAPSHOT_SCHEMA_VERSION = 1;
+
+const KIND_BOOK = "book";
+const KIND_HIGHLIGHT = "highlight";
+const KIND_REVIEW = "review";
+const VALID_KINDS = Object.freeze([KIND_BOOK, KIND_HIGHLIGHT, KIND_REVIEW]);
+
+function parseTime(v) {
+  if (Number.isFinite(v)) return v > 1e12 ? v : v * 1000;
+  if (typeof v === "string" && /^\d+$/.test(v)) {
+    const n = parseInt(v, 10);
+    return n > 1e12 ? n : n * 1000;
+  }
+  return null;
+}
+
+function stableOriginalId(kind, id) {
+  const safe =
+    (typeof id === "string" && id.length > 0 && id) ||
+    (typeof id === "number" && Number.isFinite(id) && String(id)) ||
+    `unknown-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return `weread:${kind}:${safe}`;
+}
+
+class WeReadAdapter {
+  constructor(opts = {}) {
+    this._cookie = opts.cookie || null;
+    this._dataPath = opts.inputPath || null;
+    this._apiClientFactory = opts.apiClientFactory || null; // test seam
+
+    this.name = NAME;
+    this.version = VERSION;
+    this.capabilities = [
+      "sync:cookie",
+      "sync:snapshot",
+      "parse:weread-book",
+      "parse:weread-highlight",
+      "parse:weread-review",
+    ];
+    this.extractMode = "web-api";
+    this.rateLimits = { perMinute: 30 };
+    this.dataDisclosure = {
+      fields: [
+        "weread:book (书名 / 作者 / 笔记数)",
+        "weread:highlight (划线文本 / 章节)",
+        "weread:review (想法文本 / 章节)",
+      ],
+      sensitivity: "medium",
+      legalGate: false,
+    };
+
+    this._deps = { fs };
+  }
+
+  async authenticate(ctx = {}) {
+    if (ctx && ctx.readinessOnly) {
+      if (this._cookie) return { ok: true, mode: "configured" };
+      return {
+        ok: false,
+        reason: "INVALID_COOKIE",
+        message: "weread: 需登录微信读书网页版抓取 cookie（或选择已采集的快照文件）",
+      };
+    }
+    if (ctx && typeof ctx.inputPath === "string" && ctx.inputPath.length > 0) {
+      try {
+        this._deps.fs.accessSync(ctx.inputPath, this._deps.fs.constants.R_OK);
+      } catch (err) {
+        return { ok: false, reason: "INPUT_PATH_UNREADABLE", message: `snapshot not readable: ${err.message}` };
+      }
+      return { ok: true, mode: "snapshot-file" };
+    }
+    if (ctx.cookie || this._cookie) return { ok: true, mode: "cookie" };
+    return {
+      ok: false,
+      reason: "INVALID_COOKIE",
+      message: "weread.authenticate: needs opts.cookie (cookie mode) OR opts.inputPath (snapshot)",
+    };
+  }
+
+  async healthCheck() {
+    return { ok: true, lastChecked: Date.now() };
+  }
+
+  async *sync(opts = {}) {
+    const inputPath = opts.inputPath || this._dataPath;
+    if (inputPath && this._deps.fs.existsSync(inputPath)) {
+      yield* this._syncViaSnapshot({ ...opts, inputPath });
+      return;
+    }
+    const cookie = opts.cookie || this._cookie;
+    if (cookie) {
+      yield* this._syncViaCookie({ ...opts, cookie });
+      return;
+    }
+    throw new Error("weread.sync: needs opts.cookie (cookie mode) OR opts.inputPath (snapshot)");
+  }
+
+  async *_syncViaCookie(opts) {
+    const client = this._apiClientFactory
+      ? this._apiClientFactory(opts)
+      : new (require("./api-client").WeReadApiClient)({
+          cookie: opts.cookie,
+          fetch: opts.fetch,
+          baseUrl: opts.baseUrl,
+        });
+    const emit = (phase, extra) => {
+      if (typeof opts.onProgress === "function") {
+        try { opts.onProgress({ phase, adapter: NAME, ...extra }); } catch (_e) { /* best-effort */ }
+      }
+    };
+
+    const maxBooks = Number.isInteger(opts.maxBooks) && opts.maxBooks > 0 ? opts.maxBooks : 500;
+    const includeNotes = opts.includeNotes !== false; // pull highlights/reviews per book
+    const books = await client.getNotebooks();
+    emit("notebooks", { count: books.length });
+
+    let bookN = 0;
+    for (const b of books) {
+      if (bookN >= maxBooks) break;
+      bookN += 1;
+      yield {
+        adapter: NAME,
+        kind: KIND_BOOK,
+        originalId: stableOriginalId(KIND_BOOK, b.bookId),
+        capturedAt: Date.now(),
+        payload: { kind: KIND_BOOK, ...b },
+      };
+
+      if (!includeNotes || !b.bookId) continue;
+      // Highlights
+      const marks = await client.getBookmarks(b.bookId);
+      for (const m of marks) {
+        yield {
+          adapter: NAME,
+          kind: KIND_HIGHLIGHT,
+          originalId: stableOriginalId(KIND_HIGHLIGHT, m.bookmarkId || `${b.bookId}-${m.createTime}`),
+          capturedAt: parseTime(m.createTime) || Date.now(),
+          payload: { kind: KIND_HIGHLIGHT, ...m, bookTitle: b.title },
+        };
+      }
+      // Reviews / thoughts
+      const reviews = await client.getReviews(b.bookId);
+      for (const r of reviews) {
+        yield {
+          adapter: NAME,
+          kind: KIND_REVIEW,
+          originalId: stableOriginalId(KIND_REVIEW, r.reviewId || `${b.bookId}-${r.createTime}`),
+          capturedAt: parseTime(r.createTime) || Date.now(),
+          payload: { kind: KIND_REVIEW, ...r, bookTitle: b.title },
+        };
+      }
+      emit("book-done", { bookId: b.bookId, marks: marks.length, reviews: reviews.length });
+    }
+  }
+
+  async *_syncViaSnapshot(opts) {
+    const snapshot = JSON.parse(this._deps.fs.readFileSync(opts.inputPath, "utf-8"));
+    if (!snapshot || snapshot.schemaVersion !== SNAPSHOT_SCHEMA_VERSION) {
+      throw new Error(
+        `weread.sync: snapshot schemaVersion mismatch (got ${snapshot && snapshot.schemaVersion}, expected ${SNAPSHOT_SCHEMA_VERSION})`,
+      );
+    }
+    const fallback =
+      Number.isFinite(snapshot.snapshottedAt) && snapshot.snapshottedAt > 0
+        ? Math.floor(snapshot.snapshottedAt)
+        : Date.now();
+    const include = opts.include || {};
+    const limit = Number.isInteger(opts.limit) && opts.limit > 0 ? opts.limit : Infinity;
+    const events = Array.isArray(snapshot.events) ? snapshot.events : [];
+    let emitted = 0;
+    for (const ev of events) {
+      if (emitted >= limit) return;
+      if (!ev || typeof ev !== "object" || !VALID_KINDS.includes(ev.kind)) continue;
+      if (include[ev.kind] === false) continue;
+      const id = (typeof ev.id === "string" && ev.id) || ev.bookId || ev.bookmarkId || ev.reviewId || null;
+      yield {
+        adapter: NAME,
+        kind: ev.kind,
+        originalId: stableOriginalId(ev.kind, id),
+        capturedAt: parseTime(ev.capturedAt) || parseTime(ev.createTime) || fallback,
+        payload: { ...ev },
+      };
+      emitted += 1;
+    }
+  }
+
+  normalize(raw) {
+    if (!raw || !raw.payload) throw new Error("WeReadAdapter.normalize: payload missing");
+    const kind = raw.kind || raw.payload.kind;
+    const ingestedAt = Date.now();
+    if (kind === KIND_BOOK) return normalizeBook(raw.payload, raw, ingestedAt);
+    if (kind === KIND_HIGHLIGHT) return normalizeHighlight(raw.payload, raw, ingestedAt);
+    if (kind === KIND_REVIEW) return normalizeReview(raw.payload, raw, ingestedAt);
+    throw new Error(`WeReadAdapter.normalize: unknown kind ${kind}`);
+  }
+}
+
+function buildSource(raw, occurredAt) {
+  return {
+    adapter: NAME,
+    adapterVersion: VERSION,
+    originalId: raw.originalId,
+    capturedAt: raw.capturedAt || occurredAt,
+    capturedBy: CAPTURED_BY.API,
+  };
+}
+
+function bookItemId(bookId) {
+  return bookId ? `item-weread-book-${bookId}` : `item-weread-book-${newId()}`;
+}
+
+function normalizeBook(p, raw, ingestedAt) {
+  const occurredAt = raw.capturedAt || ingestedAt;
+  const source = buildSource(raw, occurredAt);
+  const title = p.title || "(未知书名)";
+  const itemId = bookItemId(p.bookId);
+  return {
+    events: [{
+      id: newId(),
+      type: ENTITY_TYPES.EVENT,
+      subtype: EVENT_SUBTYPES.BROWSE,
+      occurredAt,
+      actor: "person-self",
+      content: { title: `读《${title}》`, text: title },
+      ingestedAt,
+      source,
+      extra: {
+        platform: "weread", kind: "book",
+        bookId: p.bookId || null, author: p.author || null,
+        noteCount: p.noteCount != null ? p.noteCount : null,
+        reviewCount: p.reviewCount != null ? p.reviewCount : null,
+        itemRef: itemId,
+      },
+    }],
+    items: [{
+      id: itemId,
+      type: ENTITY_TYPES.ITEM,
+      subtype: ITEM_SUBTYPES.DOCUMENT,
+      name: p.author ? `${title} - ${p.author}` : title,
+      ingestedAt,
+      source,
+      extra: { platform: "weread", kind: "book", bookId: p.bookId || null, author: p.author || null, cover: p.cover || null, category: p.category || null },
+    }],
+    persons: [], places: [], topics: [],
+  };
+}
+
+function normalizeHighlight(p, raw, ingestedAt) {
+  const occurredAt = parseTime(p.createTime) || raw.capturedAt || ingestedAt;
+  const source = buildSource(raw, occurredAt);
+  const text = p.markText || "";
+  const book = p.bookTitle || "";
+  return {
+    events: [{
+      id: newId(),
+      type: ENTITY_TYPES.EVENT,
+      subtype: EVENT_SUBTYPES.OTHER,
+      occurredAt,
+      actor: "person-self",
+      content: { title: `划线${book ? "《" + book + "》" : ""}: ${text.slice(0, 60)}`, text },
+      ingestedAt,
+      source,
+      extra: {
+        platform: "weread", kind: "highlight",
+        bookId: p.bookId || null, bookTitle: book || null,
+        chapterTitle: p.chapterTitle || null,
+        itemRef: p.bookId ? bookItemId(p.bookId) : null,
+      },
+    }],
+    persons: [], places: [], items: [], topics: [],
+  };
+}
+
+function normalizeReview(p, raw, ingestedAt) {
+  const occurredAt = parseTime(p.createTime) || raw.capturedAt || ingestedAt;
+  const source = buildSource(raw, occurredAt);
+  const text = p.content || "";
+  const book = p.bookTitle || "";
+  return {
+    events: [{
+      id: newId(),
+      type: ENTITY_TYPES.EVENT,
+      subtype: EVENT_SUBTYPES.POST,
+      occurredAt,
+      actor: "person-self",
+      content: { title: `想法${book ? "《" + book + "》" : ""}: ${text.slice(0, 60)}`, text },
+      ingestedAt,
+      source,
+      extra: {
+        platform: "weread", kind: "review",
+        bookId: p.bookId || null, bookTitle: book || null,
+        chapterTitle: p.chapterTitle || null,
+        itemRef: p.bookId ? bookItemId(p.bookId) : null,
+      },
+    }],
+    persons: [], places: [], items: [], topics: [],
+  };
+}
+
+module.exports = { WeReadAdapter, NAME, VERSION, SNAPSHOT_SCHEMA_VERSION, VALID_KINDS };

package/lib/analysis.js

@@ -41,6 +41,13 @@ const DEFAULT_MAX_QUERY_LIMIT = 200;
 // through to the default broader path — see _gatherFacts.
 const LATEST_INTENT_FACT_LIMIT = 3;
 
+// intent=count illustrative-sample cap. The TOTALS block (vault.stats per-table
+// counts) is the authoritative count and Rule 6 tells the LLM to quote it, NOT
+// count FACTS — so a count question only needs a few example rows, not the full
+// ≤80 sample. Hard-cap to keep prompt budget free on local small models (2-4K
+// token window). See _gatherFacts intent=count branch.
+const COUNT_INTENT_FACT_LIMIT = 5;
+
 // intent=list FTS5 augmentation cap. When the question carries a probable
 // entity-name ("提到王老板的消息", "苹果的订单") we run an extra
 // vault.searchEvents(q=term) and append non-duplicate hits to FACTS. Cap
@@ -214,6 +221,8 @@ class AnalysisEngine {
       timeWindow: parsed.timeWindow,
       maxFacts: effMaxFacts,
       vaultTotals: this._gatherVaultTotals(),
+      amountSummary:
+        parsed.intent === "sum-amount" ? this._gatherAmountSummary(parsed) : undefined,
     });
 
     // Telemetry: post-cap prompt size + truncation count. If `truncated` > 0
@@ -377,6 +386,8 @@ class AnalysisEngine {
       timeWindow: parsed.timeWindow,
       maxFacts: effMaxFacts,
       vaultTotals: this._gatherVaultTotals(),
+      amountSummary:
+        parsed.intent === "sum-amount" ? this._gatherAmountSummary(parsed) : undefined,
     });
 
     const durationMs = Date.now() - startedAt;
@@ -529,6 +540,33 @@ class AnalysisEngine {
       }
     }
 
+    // intent=count routing — "我有多少订单 / 多少条记录". The TOTALS block
+    // (vault.stats per-table counts) already carries the authoritative number
+    // and Rule 6 tells the LLM to quote it, NOT count FACTS. Pulling the full
+    // effMaxFacts (≤80) event sample is wasted prompt budget — expensive on
+    // local small models (2-4K token window). Hard-cap to COUNT_INTENT_FACT_LIMIT
+    // illustrative rows so the model can cite a couple examples without burning
+    // the budget.
+    //
+    // Adapter + time window pass through (reliable filters); subtype does NOT
+    // (keyword classifier too crude — same rationale as sum-amount). Skip
+    // persons/items: count of contacts / apps routes via entityFocus above.
+    //
+    // 0 hits → fall through to the default broader path (safety net for a
+    // low-confidence count misclassification of a list question), same as the
+    // latest branch.
+    if (parsed.intent === "count") {
+      const countQ = { limit: Math.min(COUNT_INTENT_FACT_LIMIT, effMaxFacts) };
+      if (parsed.filters && parsed.filters.adapter) countQ.adapter = parsed.filters.adapter;
+      if (parsed.timeWindow) {
+        if (Number.isFinite(parsed.timeWindow.since)) countQ.since = parsed.timeWindow.since;
+        if (Number.isFinite(parsed.timeWindow.until)) countQ.until = parsed.timeWindow.until;
+      }
+      const countEvents = this.vault.queryEvents(countQ);
+      if (countEvents.length > 0) return countEvents;
+      // 0 results → fall through to default broader path below.
+    }
+
     // intent=sum-amount routing — "总共花了多少" / "在淘宝花了多少钱"
     // only needs events from amount-bearing subtypes (order/payment/
     // transfer/income). Pulling messages / visits / browses wastes
@@ -737,6 +775,32 @@ class AnalysisEngine {
    * not expose `stats()`; falling back to undefined makes prompt-builder
    * skip the block entirely.
    */
+  /**
+   * intent=sum-amount Phase 2: pull the authoritative amount total from the
+   * vault (SQL SUM, not a FACTS sample) so prompt-builder can emit an
+   * AMOUNT_SUM block. Scoped by adapter + time window (same reliable filters
+   * _gatherFacts uses; subtype is intentionally NOT passed — the keyword
+   * classifier is too crude, and non-amount events are excluded by the SUM
+   * anyway). Returns undefined when there's nothing to sum (count===0) so the
+   * block is omitted rather than showing a misleading ¥0.
+   */
+  _gatherAmountSummary(parsed) {
+    if (typeof this.vault.sumEventAmount !== "function") return undefined;
+    try {
+      const f = {};
+      if (parsed.filters && parsed.filters.adapter) f.adapter = parsed.filters.adapter;
+      if (parsed.timeWindow) {
+        if (Number.isFinite(parsed.timeWindow.since)) f.since = parsed.timeWindow.since;
+        if (Number.isFinite(parsed.timeWindow.until)) f.until = parsed.timeWindow.until;
+      }
+      const r = this.vault.sumEventAmount(f);
+      if (!r || !r.count) return undefined;
+      return r;
+    } catch (_e) {
+      return undefined;
+    }
+  }
+
   _gatherVaultTotals() {
     if (typeof this.vault.stats !== "function") return undefined;
     try {
@@ -761,6 +825,7 @@ module.exports = {
   DEFAULT_MAX_FACTS,
   DEFAULT_MAX_QUERY_LIMIT,
   LATEST_INTENT_FACT_LIMIT,
+  COUNT_INTENT_FACT_LIMIT,
   LIST_INTENT_FTS_LIMIT,
   SUM_AMOUNT_SUBTYPES,
   SUM_AMOUNT_MIN_PER_SUBTYPE,

package/lib/index.js

@@ -22,6 +22,8 @@ const migrations = require("./migrations");
 const keyProviders = require("./key-providers");
 const { LocalVault } = require("./vault");
 const adapterSpec = require("./adapter-spec");
+const adapterReadiness = require("./adapter-readiness");
+const adapterGuide = require("./adapter-guide");
 const kgDerive = require("./kg-derive");
 const ragDerive = require("./rag-derive");
 const { AdapterRegistry, DEFAULT_BATCH_SIZE } = require("./registry");
@@ -51,7 +53,20 @@ const { DouyinAdapter } = require("./adapters/social-douyin");
 const { XiaohongshuAdapter } = require("./adapters/social-xiaohongshu");
 const { ToutiaoAdapter } = require("./adapters/social-toutiao");
 const { KuaishouAdapter } = require("./adapters/social-kuaishou");
+// FAMILY-23 v0.1 — 家庭守护 telemetry collectors (cookie-scrape placeholder).
+const { GenshinAdapter } = require("./adapters/game-genshin");
+const { HonorOfKingsAdapter } = require("./adapters/game-honor-of-kings");
+const { ZuoyebangAdapter } = require("./adapters/edu-zuoyebang");
+const { AlipayAdapter } = require("./adapters/finance-alipay");
+const { HuaweiLearningAdapter } = require("./adapters/edu-huawei-learning");
 const { QQAdapter } = require("./adapters/messaging-qq");
+const { WeChatPcAdapter } = require("./adapters/wechat-pc");
+const { QQPcAdapter } = require("./adapters/qq-pc");
+const { AppleHealthAdapter } = require("./adapters/apple-health");
+const { NeteaseMusicAdapter } = require("./adapters/netease-music");
+const { WeReadAdapter } = require("./adapters/weread");
+const { DingTalkPcAdapter } = require("./adapters/dingtalk-pc");
+const { FeishuPcAdapter } = require("./adapters/feishu-pc");
 const { TelegramAdapter } = require("./adapters/messaging-telegram");
 const { WhatsAppAdapter } = require("./adapters/messaging-whatsapp");
 const entityResolver = require("./entity-resolver");
@@ -111,6 +126,18 @@ module.exports = {
   SENSITIVITY_LEVELS: adapterSpec.SENSITIVITY_LEVELS,
   assertAdapter: adapterSpec.assertAdapter,
 
+  // Adapter readiness (why-can't-I-collect descriptors)
+  describeReadiness: adapterReadiness.describeReadiness,
+  categoryForMode: adapterReadiness.categoryForMode,
+  READINESS_CATEGORY: adapterReadiness.READINESS_CATEGORY,
+  READINESS_STATUS: adapterReadiness.READINESS_STATUS,
+  READINESS_REASONS: adapterReadiness.READINESS_REASONS,
+
+  // Adapter import guides (step-by-step "how to import this source")
+  getAdapterGuide: adapterGuide.getAdapterGuide,
+  ADAPTER_DISPLAY_NAMES: adapterGuide.DISPLAY_NAMES,
+  ADAPTER_CATEGORY_GUIDES: adapterGuide.CATEGORY_GUIDES,
+
   // KG + RAG derivation
   triple: kgDerive.triple,
   deriveEventTriples: kgDerive.deriveEventTriples,
@@ -256,7 +283,19 @@ module.exports = {
   XiaohongshuAdapter,
   ToutiaoAdapter,
   KuaishouAdapter,
+  GenshinAdapter,
+  HonorOfKingsAdapter,
+  ZuoyebangAdapter,
+  AlipayAdapter,
+  HuaweiLearningAdapter,
   QQAdapter,
+  WeChatPcAdapter,
+  QQPcAdapter,
+  AppleHealthAdapter,
+  NeteaseMusicAdapter,
+  WeReadAdapter,
+  DingTalkPcAdapter,
+  FeishuPcAdapter,
   TelegramAdapter,
   WhatsAppAdapter,