@cloud411716/fancy-webnovel 0.3.12 → 0.3.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud411716/fancy-webnovel",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "type": "module",
   "main": "index.js",
   "exports": {

package/plugins/fancy-scan/scripts/scrapers/fanqie-rank-scraper.cjs

@@ -3,19 +3,16 @@
  * 番茄小说排行榜采集脚本
  *
  * 使用 playwright-core 自己管理浏览器生命周期。
- * 采集策略：从榜单页 __INITIAL_STATE__ 取结构化列表，再逐本请求详情页解码真实
- * 书名/作者/简介/题材/标签（番茄列表页有字体反爬，详情页 HTML 里是明文）。
- * 输出 Markdown 格式匹配 scan-output-format.md 规范。
+ * 采集策略：
+ *   1. 从榜单页 __INITIAL_STATE__ 取书 ID 列表
+ *   2. 逐本打开详情页，用 innerText() 提取渲染后的真实文字（绕过字体加密）
+ *   3. 输出 Markdown 格式
  *
  * 重试机制：每个品类/每个榜单 最多重试3次，每次间隔5秒。
  *
  * 用法：
- *   node fanqie-rank-scraper.cjs --channel 1 --type 2              # 男频阅读榜
- *   node fanqie-rank-scraper.cjs --channel 0 --type 1            # 女频新书榜
- *   node fanqie-rank-scraper.cjs --channel all                    # 全部采集
- *   node fanqie-rank-scraper.cjs --channel 1 --top 15             # 每题材只取前 15 本
- *   node fanqie-rank-scraper.cjs --login-wait 60                  # 打开浏览器后等待用户登录（秒）
- *   node fanqie-rank-scraper.cjs --outdir ./                      # 指定输出目录
+ *   node fanqie-rank-scraper.cjs --channel 1 --type 2
+ *   node fanqie-rank-scraper.cjs --channel all
  */
 
 const fs = require("fs");
@@ -23,9 +20,7 @@ const path = require("path");
 const { chromium } = require("playwright-core");
 const { getArg, localDateStamp, runCli } = require("./cdp-utils.cjs");
 
-// 一次详情请求的并发批大小
-const DETAIL_CHUNK = 5;
-// 重试参数
+const DETAIL_CHUNK = 5;   // 每次并行打开的详情页数量
 const MAX_RETRIES = 3;
 const RETRY_DELAY_MS = 5000;
 
@@ -35,11 +30,7 @@ function sleep(ms) {
 
 /**
  * 重试包装器
- * @param {Function} fn 异步任务函数，返回结果或抛异常
- * @param {number} retries 最大重试次数（含首次）
- * @param {number} delayMs 重试间隔（毫秒）
- * @param {string} label 日志标签
- * @returns {Promise<{_failed:boolean, err:Error, label:string}|*>} 失败时返回特殊标记对象
+ * @returns {{_failed:true, err, label}|*} 失败时返回 _failed=true 的标记对象
  */
 async function withRetry(fn, retries = MAX_RETRIES, delayMs = RETRY_DELAY_MS, label = '') {
   let lastErr;
@@ -54,54 +45,47 @@ async function withRetry(fn, retries = MAX_RETRIES, delayMs = RETRY_DELAY_MS, la
       }
     }
   }
-  // 全部重试失败
   return { _failed: true, err: lastErr, label };
 }
 
 // ---------------------------------------------------------------------------
-// 页面提取
+// 页面提取工具
 // ---------------------------------------------------------------------------
 
-/** 连通性 + 页面就绪自检 */
+/** 连通性自检 */
 async function probePage(page) {
-  return page.evaluate(() => {
-    const s = window.__INITIAL_STATE__ || {};
-    const host = window.location.hostname;
-    const hasState = !!(s.rank || s.rankData || s.page);
-    return { host, hasState };
-  });
+  return page.evaluate(() => ({
+    host: window.location.hostname,
+    hasState: !!(window.__INITIAL_STATE__?.rank || window.__INITIAL_STATE__?.rankData),
+  }));
 }
 
-/** 从 DOM 提取品类菜单 */
+/** 从榜单页 __INITIAL_STATE__ 提取品类列表 */
 async function extractCategories(page, channel, type) {
   return page.evaluate(({ channel, type }) => {
-    // 尝试从 __INITIAL_STATE__ 取品类列表
     const s = window.__INITIAL_STATE__ || {};
     let cats = null;
     const cands = [
-      s.rank && s.rank.categories,
-      s.rank && s.rank.categoryList,
-      s.rankData && s.rankData.categories,
-      s.page && s.page.categories,
+      s.rank?.categories, s.rank?.categoryList,
+      s.rankData?.categories, s.page?.categories,
     ];
     for (const c of cands) {
       if (Array.isArray(c) && c.length) { cats = c; break; }
     }
     if (!cats) {
-      // 降级：从 DOM 提取
-      const links = Array.from(document.querySelectorAll('a[href*="/rank/' + channel + '_' + type + '_"]'));
+      const links = Array.from(document.querySelectorAll(`a[href*="/rank/${channel}_${type}_"]`));
       const seen = new Set();
       cats = links
         .map(a => ({ name: a.innerText.trim() || a.textContent.trim(), href: a.getAttribute('href') }))
         .filter(c => c.name && c.href && !seen.has(c.href) && seen.add(c.href));
     }
-    return cats.slice(0, 20);
+    return (cats || []).slice(0, 20);
   }, { channel, type });
 }
 
-/** 从 __INITIAL_STATE__ 提取当前品类页的作品列表 */
-async function extractBookList(page) {
-  // 等 __INITIAL_STATE__ 有书单数据后再提取（防止网络慢时页面 JS 还没注数据）
+/** 从榜单页 __INITIAL_STATE__ 提取书籍 ID 列表 */
+async function extractBookIds(page) {
+  // 等 __INITIAL_STATE__ 有书单数据
   try {
     await page.waitForFunction(
       () => {
@@ -114,101 +98,88 @@ async function extractBookList(page) {
       },
       { timeout: 15000 }
     );
-  } catch (waitErr) {
-    // 超时返回空数组（由调用方判断是否重试）
-    return [];
-  }
+  } catch (_) { return []; }
+
   return page.evaluate(() => {
     const s = window.__INITIAL_STATE__ || {};
-    const cands = [
-      s.rank && s.rank.book_list,
-      s.rank && s.rank.bookList,
-      s.rank && s.rank.rankList,
-      s.rankData && s.rankData.book_list,
-      s.page && s.page.book_list,
-    ];
-    var list = null;
-    for (var i = 0; i < cands.length; i++) {
-      if (Array.isArray(cands[i]) && cands[i].length) {
-        list = cands[i];
-        break;
-      }
+    let list = null;
+    for (const c of [s.rank, s.rankData, s.page]) {
+      if (c?.book_list) { list = c.book_list; break; }
+      if (c?.bookList)  { list = c.bookList;  break; }
+      if (c?.rankList)  { list = c.rankList;  break; }
     }
     if (!list) {
-      var found = null;
+      let found = null;
       (function walk(o, d) {
         if (found || !o || d > 6) return;
-        if (Array.isArray(o)) {
-          if (o.length && o[0] && typeof o[0] === "object" && (o[0].bookId || o[0].book_id)) {
-            found = o;
-            return;
-          }
-          for (var j = 0; j < o.length && !found; j++) walk(o[j], d + 1);
-          return;
+        if (Array.isArray(o) && o.length && o[0] && (o[0].bookId || o[0].book_id)) {
+          found = o; return;
         }
-        if (typeof o === "object") {
-          for (var k in o) {
-            if (found) break;
-            try { walk(o[k], d + 1); } catch (e) {}
-          }
+        if (typeof o === 'object') {
+          for (const k in o) { try { walk(o[k], d + 1); } catch (_) {} }
         }
       })(s, 0);
       list = found || [];
     }
-    return list.map((b) => ({
-      bookId: String(b.bookId || b.book_id || ""),
-      read_count: b.read_count || b.readCount || b.read || "",
-      wordNumber: b.wordNumber || b.word_number || b.wordCount || "",
-      creationStatus:
-        b.creationStatus != null
-          ? b.creationStatus
-          : b.creation_status != null
-            ? b.creation_status
-            : b.status,
-      lastChapterTitle: b.lastChapterTitle || b.last_chapter_title || b.lastChapter || "",
-      category: b.category || b.categoryName || b.category_name || "",
-    }));
+    return (list || []).map(b => String(b.bookId || b.book_id || '')).filter(Boolean);
   });
 }
 
-/** 分批解码，避免单次 eval 超时 */
-async function fetchDetailsChunk(page, ids) {
-  return page.evaluate((ids) => {
-    const base = "https://fanqienovel.com";
-    const map = {};
-    ids.forEach((id) => {
-      try {
-        const el = document.querySelector(`[data-bookid="${id}"]`) ||
-                   document.querySelector(`[href*="/page/${id}"]`) ||
-                   document.querySelector(`[href*="/book/${id}"]`);
-        if (!el) { map[id] = {}; return; }
-        const card = el.closest(".rank-book-item") || el.closest(".book-card") || el;
-        const titleEl = card.querySelector(".book-title") || card.querySelector(".book-name") || card.querySelector("a");
-        const authorEl = card.querySelector(".author-name") || card.querySelector(".author") || card.querySelector(".writer");
-        const descEl = card.querySelector(".book-desc") || card.querySelector(".description");
-        const categoryEl = card.querySelector(".category") || card.querySelector(".tag");
-        const title = titleEl ? (titleEl.innerText || titleEl.textContent || "").trim() : "";
-        const author = authorEl ? (authorEl.innerText || authorEl.textContent || "").replace(/^作者：/, "").trim() : "";
-        const desc = descEl ? (descEl.innerText || descEl.textContent || "").trim() : "";
-        const category = categoryEl ? (categoryEl.innerText || categoryEl.textContent || "").trim() : "";
-        // 尝试从 href 提取标签
-        const tags = (desc.match(/#[^\s，,。]+/g) || []).slice(0, 6).join("、");
-        map[id] = { title, author, desc, category, tags };
-      } catch (e) {
-        map[id] = { title: "", author: "", desc: "", category: "", tags: "", err: String(e && e.message || e) };
-      }
-    });
-    return map;
-  }, ids);
-}
-
-/** 分批并行请求详情 */
-async function fetchDetails(page, bookIds) {
+/**
+ * 打开书籍详情页，提取渲染后的干净文字
+ * @param {object} browser
+ * @param {string[]} bookIds
+ * @returns {Promise<object>} { bookId: { title, author, category, desc } }
+ */
+async function fetchBookDetails(browser, bookIds) {
   const map = {};
-  for (let i = 0; i < bookIds.length; i += DETAIL_CHUNK) {
-    const chunk = bookIds.slice(i, i + DETAIL_CHUNK);
-    const part = await fetchDetailsChunk(page, chunk);
-    Object.assign(map, part);
+  // 复用同一个 context 批量开详情页（比每次新建 context 快）
+  const context = await browser.newContext();
+  try {
+    for (let i = 0; i < bookIds.length; i += DETAIL_CHUNK) {
+      const chunk = bookIds.slice(i, i + DETAIL_CHUNK);
+      // 并行打开多个详情页
+      const pages = await Promise.all(
+        chunk.map(id => context.newPage())
+      );
+      await Promise.all(
+        pages.map((p, idx) =>
+          p.goto(`https://fanqienovel.com/page/${chunk[idx]}`, { waitUntil: 'domcontentloaded' })
+            .catch(() => {})
+        )
+      );
+      // 等待所有页面的主要元素加载
+      await Promise.all(
+        pages.map(p => p.waitForTimeout(1500))
+      );
+      // 批量提取
+      const results = await Promise.all(
+        pages.map((p, idx) =>
+          p.evaluate(({ id }) => {
+            const sel = '.info-wrapper .title, .book-title, h1, .book-name';
+            const titleEl = document.querySelector(sel);
+            const title = titleEl ? (titleEl.innerText || titleEl.textContent || '').trim() : '';
+            // 作者可能在多个位置
+            const authorEl = document.querySelector('.author-name, .author, .writer') ||
+                             document.querySelector(`a[href*="/author/"]`);
+            const author = authorEl ? (authorEl.innerText || authorEl.textContent || '').replace(/^作者：/, '').trim() : '';
+            // 题材/分类
+            const catEl = document.querySelector('.category, .tag, .book-tag');
+            const category = catEl ? (catEl.innerText || catEl.textContent || '').trim() : '';
+            // 简介
+            const descEl = document.querySelector('.description, .book-desc, .intro');
+            const desc = descEl ? (descEl.innerText || descEl.textContent || '').trim().slice(0, 200) : '';
+            return { id, title, author, category, desc };
+          }, { id: chunk[idx] }).catch(() => ({ id: chunk[idx], title: '', author: '', category: '', desc: '' }))
+        )
+      );
+      for (const r of results) {
+        map[r.id] = r;
+      }
+      await Promise.all(pages.map(p => p.close()));
+    }
+  } finally {
+    await context.close();
   }
   return map;
 }
@@ -220,37 +191,9 @@ async function scrollLoad(page, times, interval = 1000) {
   }
 }
 
-function fmtReads(count) {
-  if (!count && count !== 0) return "";
-  const n = Number(count);
-  if (isNaN(n)) return String(count);
-  if (n >= 100000000) return (n / 100000000).toFixed(1) + "亿";
-  if (n >= 10000) return (n / 10000).toFixed(1) + "万";
-  return String(n);
-}
-
-function fmtWords(count) {
-  if (!count && count !== 0) return "";
-  const n = Number(count);
-  if (isNaN(n)) return String(count);
-  if (n >= 100000000) return (n / 100000000).toFixed(1) + "亿字";
-  if (n >= 10000) return (n / 10000).toFixed(0) + "万字";
-  return String(n) + "字";
-}
-
-function fmtStatus(s) {
-  if (s === 1 || s === "1" || s === "连载") return "连载";
-  if (s === 2 || s === "2" || s === "完结") return "完结";
-  return "未知";
-}
-
-function cleanDesc(raw) {
-  if (!raw) return "";
-  let d = raw.replace(/\s+/g, " ").trim();
-  if (d.length <= 100) return d;
-  const cut = d.slice(0, 100);
-  const m = cut.match(/[\s\S]*[。！？]/);
-  return (m ? m[0] : cut) + "...";
+function localDate() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
 }
 
 // ---------------------------------------------------------------------------
@@ -258,32 +201,49 @@ function cleanDesc(raw) {
 // ---------------------------------------------------------------------------
 
 const args = process.argv.slice(2);
-const PROBE = getArg(args, "--probe") !== null;
-const LOGIN_WAIT = parseInt(getArg(args, "--login-wait") || "0", 10);
-const OUTDIR = getArg(args, "--outdir") || ".";
-const CHANNEL = getArg(args, "--channel") || "1";
-const TYPE = getArg(args, "--type") || "2";
-const TOP = parseInt(getArg(args, "--top") || "20", 10);
+const PROBE   = getArg(args, '--probe') !== null;
+const LOGIN_WAIT = parseInt(getArg(args, '--login-wait') || '0', 10);
+const OUTDIR  = getArg(args, '--outdir') || '.';
+const CHANNEL = getArg(args, '--channel') || '1';
+const TYPE    = getArg(args, '--type')    || '2';
+const TOP     = parseInt(getArg(args, '--top') || '20', 10);
 
 function channelLabel(ch) {
-  return ch === "1" ? "男频" : ch === "0" ? "女频" : ch;
+  return ch === '1' ? '男频' : ch === '0' ? '女频' : ch;
 }
-
 function typeLabel(t) {
-  return t === "2" ? "阅读榜" : t === "1" ? "新书榜" : t;
+  return t === '2' ? '阅读榜' : t === '1' ? '新书榜' : t;
 }
 
-async function scrapeCategoryWithRetry(page, cat) {
+async function scrapeCategory(browser, page, cat, chLabel) {
   return withRetry(async () => {
-    await page.goto(`https://fanqienovel.com${cat.href}`, { waitUntil: "networkidle" });
-    await page.waitForTimeout(2500);
+    await page.goto(`https://fanqienovel.com${cat.href}`, { waitUntil: 'domcontentloaded' });
+    await page.waitForTimeout(2000);
     await scrollLoad(page, 2);
 
-    const books = await extractBookList(page);
-    if (!books || !Array.isArray(books)) {
-      throw new Error("extractBookList 返回异常");
+    const bookIds = await extractBookIds(page);
+    if (!bookIds || !bookIds.length) {
+      throw new Error('extractBookIds 返回空');
     }
-    return books;
+
+    // 打开详情页提取渲染后文字
+    const details = await fetchBookDetails(browser, bookIds.slice(0, TOP));
+
+    const lines = [];
+    for (const id of bookIds.slice(0, TOP)) {
+      const info = details[id] || {};
+      const title    = info.title    || `（标题待解析 ${id}）`;
+      const author   = info.author   || '未知';
+      const category = info.category || cat.name;
+      const desc     = info.desc     ? `简介：${info.desc}` : '';
+      lines.push(`书名：${title}`);
+      lines.push(`题材：${category}`);
+      lines.push(`作者：${author}`);
+      if (desc) lines.push(desc);
+      lines.push(`作品页：https://fanqienovel.com/page/${id}`);
+      lines.push('');
+    }
+    return lines;
   }, MAX_RETRIES, RETRY_DELAY_MS, `品类[${cat.name}]`);
 }
 
@@ -292,106 +252,82 @@ async function scrapeChannel(ch, type) {
   const tyLabel = typeLabel(type);
   console.log(`\n→ 采集 ${chLabel}${tyLabel}...`);
 
-  const initCatId = ch === "1" ? "1141" : "1139"; // 男频:西方奇幻 / 女频:古风世情
-  const initUrl = `https://fanqienovel.com/rank/${ch}_${type}_${initCatId}`;
+  const initCatId = ch === '1' ? '1141' : '1139';
+  const initUrl   = `https://fanqienovel.com/rank/${ch}_${type}_${initCatId}`;
 
-  const browser = await chromium.launch({ headless: false, args: ["--no-sandbox", "--disable-dev-shm-usage", "--start-maximized"] });
+  const browser = await chromium.launch({
+    headless: false,
+    args: ['--no-sandbox', '--disable-dev-shm-usage', '--start-maximized'],
+  });
   const context = await browser.newContext();
-  const page = await context.newPage();
+  const page    = await context.newPage();
 
-  // CDP 强制窗口最大化
+  // CDP 窗口最大化
   try {
     const cdp = await context.newCDPSession(page);
     const { windowId } = await cdp.send('Browser.getWindowForTarget', { target: page.target() });
     await cdp.send('Browser.setWindowBounds', { windowId, bounds: { state: 'maximized' } });
-  } catch (_) { }
+  } catch (_) {}
 
   let scraped = null;
 
   try {
-    // 打开入口页（带重试）
+    // 入口页（带重试）
     const homeResult = await withRetry(async () => {
-      await page.goto(initUrl, { waitUntil: "networkidle" });
+      await page.goto(initUrl, { waitUntil: 'domcontentloaded' });
       const probe = await probePage(page);
-      if (!probe.host || probe.host.indexOf("fanqie") === -1) {
-        throw new Error(`非番茄页面（host=${probe.host}），可能被重定向到登录/验证页`);
+      if (!probe.host || probe.host.indexOf('fanqie') === -1) {
+        throw new Error(`非番茄页面（host=${probe.host}）`);
       }
       return probe;
-    }, MAX_RETRIES, RETRY_DELAY_MS, `打开入口页`);
+    }, MAX_RETRIES, RETRY_DELAY_MS, '打开入口页');
 
     if (homeResult._failed) {
-      console.log(`  ✗ 入口页采集连续失败：${homeResult.err.message}`);
+      console.log(`  ✗ 入口页连续失败：${homeResult.err.message}`);
       return null;
     }
 
-    // 等待登录（用户可在此时手动登录）
     if (LOGIN_WAIT > 0) {
       console.log(`  ⏳ 等待 ${LOGIN_WAIT}s 供用户登录...`);
       await page.waitForTimeout(LOGIN_WAIT * 1000);
     }
 
-    // ─── 调试模式：拦截所有请求，找出真实数据接口 ───
+    // PROBE 调试模式（保留原有逻辑）
     if (PROBE) {
       const intercepted = [];
       const seen = new Set();
-
-      context.on("request", req => {
+      context.on('request', req => {
         const url = req.url();
-        if (seen.has(url)) return;
-        if (/\.(css|woff|jpg|png|ico)/.test(url)) return;
-        if (!url.includes("fanqie")) return;
+        if (seen.has(url) || /\.(css|woff|jpg|png|ico)/.test(url) || !url.includes('fanqie')) return;
         seen.add(url);
         console.log(`[REQ] ${url}`);
       });
-
-      page.on("response", async (resp) => {
+      page.on('response', async resp => {
         const url = resp.url();
-        const ct = (resp.headers()["content-type"] || "").toLowerCase();
         if (seen.has(url)) return;
-        if (!ct.includes("json") && !ct.includes("text") && !url.includes("api")) return;
-        if (/\.(css|woff|jpg|png|ico)/.test(url)) return;
+        const ct = (resp.headers()['content-type'] || '').toLowerCase();
+        if (!ct.includes('json') && !ct.includes('text') && !url.includes('api')) return;
         try {
           const body = await resp.text();
           if (!body || body.length < 50) return;
-          let parsed;
-          try { parsed = JSON.parse(body); } catch { return; }
-          const str = JSON.stringify(parsed);
-          if (str.includes("bookId") || str.includes("book_name") || str.includes("bookName") || str.includes("authorName")) {
+          const str = JSON.stringify(JSON.parse(body));
+          if (str.includes('bookId') || str.includes('book_name')) {
             console.log(`[JSON] ${url}`);
-            console.log(`  预览: ${str.slice(0, 300)}`);
-            intercepted.push({ url, preview: str.slice(0, 400) });
+            intercepted.push({ url, preview: str.slice(0, 300) });
           }
-        } catch {}
+        } catch (_) {}
       });
-
       const cats = await extractCategories(page, ch, type);
       if (!cats.length) {
         await page.goto(`https://fanqienovel.com/rank/${ch}_${type}_${initCatId}`);
         await page.waitForTimeout(3000);
-        const moreCats = await extractCategories(page, ch, type);
-        if (moreCats.length) {
-          console.log(`  发现 ${moreCats.length} 个品类`);
-          for (const c of moreCats.slice(0, 3)) {
-            console.log(`  探测品类: ${c.name} → ${c.href}`);
-            await page.goto(`https://fanqienovel.com${c.href}`);
-            await page.waitForTimeout(2000);
-          }
-        }
-      } else {
-        console.log(`  发现 ${cats.length} 个品类`);
-        for (const c of cats.slice(0, 3)) {
-          console.log(`  探测品类: ${c.name} → ${c.href}`);
-          await page.goto(`https://fanqienovel.com${c.href}`);
-          await page.waitForTimeout(2000);
-        }
       }
-
-      console.log(`\n=== 共拦截到 ${intercepted.length} 个含书籍数据的接口 ===`);
+      console.log(`\n=== 共拦截 ${intercepted.length} 个含书籍数据的接口 ===`);
       await browser.close();
       return null;
     }
 
-    // 提取品类菜单
+    // 提取品类
     let categories = await extractCategories(page, ch, type);
     if (!categories.length) {
       await scrollLoad(page, 2);
@@ -399,72 +335,50 @@ async function scrapeChannel(ch, type) {
       categories = await extractCategories(page, ch, type);
     }
     if (!categories.length) {
-      console.log(`  ⚠ 未提取到品类菜单，降级为单题材采集（入口页）`);
-      categories = [{ name: "全部（入口页）", href: `/rank/${ch}_${type}_${initCatId}` }];
+      categories = [{ name: '全部（入口页）', href: `/rank/${ch}_${type}_${initCatId}` }];
     } else {
       console.log(`  发现 ${categories.length} 个品类`);
     }
 
-    const now = new Date().toISOString();
+    const now   = new Date().toISOString();
     const lines = [
       `# 番茄 · ${chLabel}${tyLabel} · 全 ${categories.length} 题材`,
-      "",
+      '',
       `- 频道参数：channel=${ch}，type=${type}`,
       `- 抓取时间：${now}`,
-      "",
-      "---",
-      "",
+      '',
+      '---',
+      '',
     ];
 
-    let totalBooks = 0;
-    const failedCategories = []; // { name, err }
+    const failedCategories = [];
 
     for (let ci = 0; ci < categories.length; ci++) {
       const cat = categories[ci];
       console.log(`  [${ci + 1}/${categories.length}] ${cat.name}`);
 
-      const booksResult = await scrapeCategoryWithRetry(page, cat);
+      const result = await scrapeCategory(browser, page, cat, chLabel);
 
-      if (booksResult._failed) {
-        console.log(`  ✗ 品类[${cat.name}]连续${MAX_RETRIES}次失败：${booksResult.err.message}`);
-        failedCategories.push({ name: cat.name, err: booksResult.err.message });
-        lines.push(`## ${cat.name} — 采集失败（已重试${MAX_RETRIES}次）`, "", "---", "");
+      if (result._failed) {
+        console.log(`  ✗ 品类[${cat.name}]连续${MAX_RETRIES}次失败：${result.err.message}`);
+        failedCategories.push({ name: cat.name, err: result.err.message });
+        lines.push(`## ${cat.name} — 采集失败（已重试${MAX_RETRIES}次）`, '', '---', '');
         continue;
       }
 
-      let books = booksResult;
-      if (!books.length) {
-        lines.push(`## ${cat.name} — 0 本`, "", "---", "");
+      const bookLines = result;
+      if (!bookLines.length) {
+        lines.push(`## ${cat.name} — 0 本`, '', '---', '');
         continue;
       }
-      if (books.length > TOP) books = books.slice(0, TOP);
-
-      const bookIds = books.map((b) => String(b.bookId));
-      const details = await fetchDetails(page, bookIds);
-
-      lines.push(`## ${cat.name} — ${books.length} 本`, "");
-
-      for (let i = 0; i < books.length; i++) {
-        const b = books[i];
-        const info = details[String(b.bookId)] || {};
-        totalBooks++;
-        const title = info.title || "（标题待解析）";
-        const author = info.author || "未知";
-        const category = info.category || b.category || "";
-
-        lines.push(`书名：${title}`);
-        lines.push(`题材：${category}`);
-        lines.push(`作者：${author}`);
-        lines.push(`作品页：https://fanqienovel.com/page/${b.bookId}`);
-        lines.push("");
-      }
 
-      lines.push("---", "");
+      lines.push(`## ${cat.name} — ${bookLines.filter(l => l.startsWith('书名：')).length} 本`, '');
+      lines.push(...bookLines);
+      lines.push('---', '');
     }
 
-    scraped = lines.join("\n");
+    scraped = lines.join('\n');
 
-    // 输出失败品类汇总
     if (failedCategories.length > 0) {
       console.log(`\n⚠️  以下品类采集失败（共 ${failedCategories.length} 项）：`);
       for (const f of failedCategories) {
@@ -480,31 +394,27 @@ async function scrapeChannel(ch, type) {
 }
 
 async function main() {
-  if (!["0", "1", "all"].includes(CHANNEL)) {
-    throw new Error(`未知 --channel: ${CHANNEL}`);
-  }
-  if (!["1", "2", "all"].includes(TYPE)) {
-    throw new Error(`未知 --type: ${TYPE}`);
-  }
-  const channels = CHANNEL === "all" ? ["1", "0"] : [CHANNEL];
-  const types = TYPE === "all" ? ["2", "1"] : [TYPE];
-  let written = 0;
-  const failedChannels = []; // { ch, ty, err }
+  if (!['0', '1', 'all'].includes(CHANNEL)) throw new Error(`未知 --channel: ${CHANNEL}`);
+  if (!['1', '2', 'all'].includes(TYPE))    throw new Error(`未知 --type: ${TYPE}`);
+
+  const channels = CHANNEL === 'all' ? ['1', '0'] : [CHANNEL];
+  const types    = TYPE    === 'all' ? ['2', '1'] : [TYPE];
+  let written    = 0;
+  const failedChannels = [];
 
   for (const ch of channels) {
     for (const ty of types) {
       try {
         const content = await scrapeChannel(ch, ty);
         if (!content) {
-          failedChannels.push({ ch, ty, err: "采集返回空" });
+          failedChannels.push({ ch, ty, err: '采集返回空' });
           continue;
         }
-
-        const date = localDateStamp();
+        const date     = localDateStamp();
         const filename = `番茄${channelLabel(ch)}${typeLabel(ty)}_全题材_${date}.md`;
         fs.mkdirSync(OUTDIR, { recursive: true });
         const filepath = path.join(OUTDIR, filename);
-        fs.writeFileSync(filepath, content, "utf-8");
+        fs.writeFileSync(filepath, content, 'utf-8');
         written++;
         console.log(`  ✓ 已保存: ${filepath}`);
       } catch (chErr) {
@@ -514,7 +424,6 @@ async function main() {
     }
   }
 
-  // 输出失败榜单汇总
   if (failedChannels.length > 0) {
     console.log(`\n⚠️  以下榜单采集失败（共 ${failedChannels.length} 项）：`);
     for (const f of failedChannels) {
@@ -526,13 +435,7 @@ async function main() {
 }
 
 if (require.main === module) {
-  runCli(main, "番茄采集");
+  runCli(main, '番茄采集');
 }
 
-// 导出纯函数/JS 构建器
-module.exports = {
-  fmtReads,
-  fmtWords,
-  fmtStatus,
-  cleanDesc,
-};
+module.exports = {};