@cloud411716/fancy-webnovel 1.0.45 → 2.2.0

package/plugins/fancy-scan/scripts/scrapers/qimao-rank-scraper.js

@@ -0,0 +1,611 @@
+#!/usr/bin/env node
+/**
+ * 七猫小说排行榜采集脚本
+ *
+ * 使用 playwright-core 直接控制浏览器采集。
+ * 采集策略：滚动加载后从页面文本解析结构化数据。
+ * 输出 Markdown 格式到 --outdir 目录。
+ *
+ * 用法：
+ *   node qimao-rank-scraper.js --channel boy --type hot --period month    # 男生大热榜月榜
+ *   node qimao-rank-scraper.js --channel boy --type hot --period day     # 男生大热榜日榜
+ *   node qimao-rank-scraper.js --channel girl --type new --period month  # 女生新书榜月榜
+ *   node qimao-rank-scraper.js --channel girl --type new                 # 女生新书榜日榜
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { chromium } from 'playwright-core';
+import { getArg, localDateStamp, runCli } from '#scraper-utils';
+
+const RANK_URL = "https://www.qimao.com/paihang";
+
+// ---------------------------------------------------------------------------
+// 命令行参数解析
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+const OUTDIR = getArg(args, "--outdir") || ".";
+const CHANNEL = getArg(args, "--channel") || "boy";
+const RANKTYPE = getArg(args, "--type") || "hot";
+const PERIOD = getArg(args, "--period") || "day";
+
+const CHANNELS = [
+  { id: "boy", label: "男生", tab: "男生榜", path: "boy" },
+  { id: "girl", label: "女生", tab: "女生榜", path: "girl" },
+];
+
+const RANK_TYPES = [
+  { id: "hot", label: "大热", path: "hot" },
+  { id: "new", label: "新书", path: "new" },
+  { id: "finish", label: "完结", path: "over" },
+  { id: "collect", label: "收藏", path: "collect" },
+  { id: "update", label: "更新", path: "update" },
+];
+
+const PERIODS = [
+  { id: "day", label: "日榜", path: "date" },
+  { id: "month", label: "月榜", path: "month" },
+];
+
+/**
+ * 详情页并发上限。
+ *
+ * 七猫对密集请求会返回半成品页（页面能打开但内容是空的）。
+ * 实测并发 3 / 5 各抓 20 本均 20/20 成功，单轮 15~22 秒；取 4 留余量。
+ */
+const DETAIL_CONCURRENCY = 4;
+
+/**
+ * 哪些榜单类型真的有"月榜"。
+ *
+ * 实测依据（2026-10-21，逐个请求官网榜单页 + 核对站内导航与书名条目数）：
+ *   大热榜 / 新书榜 / 完结榜 → 日榜 + 月榜（官网页内有月榜 tab 入口）
+ *   收藏榜 / 更新榜          → 只有日榜
+ *
+ * 收藏榜/更新榜的月榜 URL（/paihang/{频道}/collect/month/ 等）虽然返回 HTTP 200，
+ * 但页面只有约 26KB 的壳、**0 条书名链接** —— 是空榜，不是"月榜=日榜同数据"。
+ *
+ * 之前只有 hot 才展开周期（其它类型的 period 被置 null，rankUrl 回落到日榜），
+ * 于是"新书月榜"实际抓的是日榜数据，而产物文件名还不带"月"——
+ * 用户全程看不出来。现在按本表决定周期是否生效。
+ *
+ * 注意：这里用的是 RANK_TYPES 的 **id**（完结榜的 id 是 finish、path 才是 over）。
+ */
+const MONTH_RANK_TYPES = new Set(["hot", "new", "finish"]);
+
+/**
+ * 该「榜单类型 × 周期」组合在七猫官网上是否真实存在。
+ *
+ * 收藏榜/更新榜只有日榜：它们的月榜 URL 返回 HTTP 200，但页面是空壳
+ * （约 26KB、0 条书名链接），扫出来必然是"无有效数据"。
+ * 提前判掉，别让用户等一次浏览器往返才拿到一句无数据。
+ */
+function rankPeriodExists(rankTypeId, periodId) {
+  if (periodId !== "month") return true;
+  return MONTH_RANK_TYPES.has(rankTypeId);
+}
+
+// ---------------------------------------------------------------------------
+// 页面操作
+// ---------------------------------------------------------------------------
+
+function rankUrl(channelId, rankTypeId, periodId) {
+  const channel = CHANNELS.find((item) => item.id === channelId);
+  const rankType = RANK_TYPES.find((item) => item.id === rankTypeId);
+  const period = PERIODS.find((item) => item.id === (periodId || "day"));
+  if (!channel || !rankType || !period) return "";
+  return `${RANK_URL}/${channel.path}/${rankType.path}/${period.path}/`;
+}
+
+/**
+ * 从页面 innerText 解析结构化书籍数据。
+ */
+async function extractBooksFromText(page) {
+  return await page.evaluate(() => {
+    var text = document.body.innerText || '';
+    // 找到榜单数据起始位置
+    var start = -1;
+    ['日榜', '月榜'].forEach(function(m) {
+      if (start < 0) start = text.indexOf(m)
+    });
+    if (start < 0) return [];
+    var lines = text.substring(start).split(/\n/);
+    var books = [];
+    var cur = null;
+    var fieldIdx = 0;
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i].trim();
+      if (!line) continue;
+      // 分页器截断
+      if (/^(上一页|下一页|跳转|友情链接[:：]?)$/.test(line)) {
+        if (cur && cur.title) books.push(cur);
+        cur = null;
+        break
+      }
+      // 排名标记：独立数字 1-99
+      if (/^\d{1,2}$/.test(line) && parseInt(line) < 100) {
+        if (cur && cur.title) books.push(cur);
+        cur = {
+          rank: parseInt(line),
+          title: '',
+          author: '',
+          genre: '',
+          subGenre: '',
+          status: '',
+          words: '',
+          heat: '',
+          update: '',
+          desc: ''
+        };
+        fieldIdx = 0;
+        continue
+      }
+      if (!cur) continue;
+      // 跳过 UI 文字
+      if (/^(加入书架|立即阅读|蝉联|榜首)/.test(line)) continue;
+      // 热度
+      var hm = line.match(/([\d.]+)\s*万\s*热度/);
+      if (hm) {
+        cur.heat = hm[1] + '万';
+        continue
+      }
+      // 最新更新
+      if (line.indexOf('最近更新') === 0) {
+        cur.update = line.replace(/^最近更新\s*/, '');
+        continue
+      }
+      // 状态
+      if (/^(连载中|已完结)$/.test(line)) {
+        cur.status = line;
+        continue
+      }
+      // 字数
+      if (/^[\d.]+万字$/.test(line)) {
+        cur.words = line;
+        continue
+      }
+      // 按序填充：书名→作者→题材→子分类
+      if (fieldIdx === 0) {
+        cur.title = line;
+        fieldIdx = 1;
+        continue
+      }
+      if (fieldIdx === 1) {
+        cur.author = line;
+        fieldIdx = 2;
+        continue
+      }
+      if (fieldIdx === 2) {
+        cur.genre = line;
+        fieldIdx = 3;
+        continue
+      }
+      if (fieldIdx === 3) {
+        cur.subGenre = line;
+        fieldIdx = 4;
+        continue
+      }
+      // 其余为简介
+      cur.desc += (cur.desc ? ' ' : '') + line
+    }
+    if (cur && cur.title) books.push(cur);
+    return books
+  });
+}
+
+/**
+ * 从书名链接元素直接提取 href，避免全页遍历+标题匹配。
+ * 对每个书籍容器，找到其中的书名链接，取其 href。
+ */
+async function extractBookUrls(page) {
+  return await page.evaluate(() => {
+    var results = [];
+    // 常见书籍列表容器
+    var selectors = [
+      '.book-list li',
+      '.rank-list .rank-item',
+      '[class*="book-item"]',
+      '[class*="rank-item"]',
+      '.bookshelf-list li',
+      'ul li',
+    ];
+    var container = null;
+    for (var s of selectors) {
+      var el = document.querySelector(s);
+      if (el) { container = s; break; }
+    }
+    if (!container) return results;
+
+    var items = document.querySelectorAll(container);
+    items.forEach(function(item) {
+      // 找书名链接（常见选择器）
+      var titleEl = item.querySelector('a[class*="title"], h3 a, a.title, .book-title a, [class*="title"] a');
+      if (!titleEl) {
+        // 备选：找包含非 UI 文本的有意义链接
+        var links = item.querySelectorAll('a');
+        for (var i = 0; i < links.length; i++) {
+          var t = (links[i].innerText || links[i].textContent || '').trim();
+          if (t && t.length > 2 && t.length < 50 &&
+              !/^(上一页|下一页|跳转|加入书架|立即阅读)$/.test(t)) {
+            titleEl = links[i];
+            break;
+          }
+        }
+      }
+      if (!titleEl) return;
+
+      var title = (titleEl.innerText || titleEl.textContent || '').replace(/\s+/g, '').trim();
+      var rawHref = titleEl.getAttribute('href') || '';
+      var fullUrl = rawHref.startsWith('http')
+        ? rawHref
+        : 'https://www.qimao.com' + rawHref;
+
+      if (title) results.push({ title, url: fullUrl });
+    });
+    return results;
+  });
+}
+
+/**
+ * 详情页的"简介"元素。
+ *
+ * 榜单页只给列表视图的短简介（有的书只有第一句，40 字上下），
+ * 详情页的 <p class="intro"> 才是完整简介（实测 38~333 字、分段）。
+ *
+ * 取 textContent 而不是 innerText：innerText 会受 CSS 裁剪影响，
+ * textContent 拿到的始终是完整文本。
+ * 兜底读 Nuxt 状态里的 bookIntroData.intro（与页面同源）。
+ */
+async function extractDetailIntro(page) {
+  return await page.evaluate(() => {
+    var el = document.querySelector('.intro');
+    if (el) {
+      var t = (el.textContent || '').trim();
+      if (t) return t;
+    }
+    try {
+      var n = window.__NUXT__;
+      var info = (n && n.state && n.state.common && n.state.common.bookRelatedInfo)
+        || (n && n.state && n.state.modules && n.state.modules.common && n.state.modules.common.bookRelatedInfo);
+      var t2 = info && info.bookIntroData && info.bookIntroData.intro;
+      if (t2) return String(t2).trim();
+    } catch (_) {}
+    return '';
+  });
+}
+
+/**
+ * 逐本访问详情页，取回完整简介。
+ *
+ * 与起点（run-scan.js 的 fetchBookDetail）同一套做法：
+ * 榜单页拿基础字段，详情页补简介。
+ *
+ * 并发上限 DETAIL_CONCURRENCY：七猫对密集请求会返回"半成品页"
+ * （页面能打开但内容是空的）。实测并发 3/5 各抓 20 本均 20/20 成功、
+ * 单轮 15~22 秒，取 4 作为安全值。
+ *
+ * 单本失败不中断整个榜单：
+ *   - 失败原因记入 reasons，由 receipt 的 partialReasons 一路带到
+ *     插件层的失败清单（用户能看见"哪本没取到"）；
+ *   - 同时**保留榜单页的简介**——它至少不是空的，不让用户拿到空简介。
+ */
+async function fetchDetailIntros(browser, books) {
+  const reasons = [];
+  const targets = books.filter((b) => b.url);
+  let cursor = 0;
+
+  async function worker() {
+    while (cursor < targets.length) {
+      const book = targets[cursor++];
+      let page = null;
+      try {
+        page = await browser.newPage();
+        await page.goto(book.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+        const intro = await extractDetailIntro(page);
+        if (intro) {
+          book.desc = intro;
+        } else {
+          reasons.push(`${book.title} 详情页没有简介（保留榜单页简介）`);
+        }
+      } catch (err) {
+        reasons.push(`${book.title} 简介获取失败: ${err.message}`);
+      } finally {
+        if (page) {
+          try { await page.close(); } catch (_) {}
+        }
+      }
+    }
+  }
+
+  const workers = Math.min(DETAIL_CONCURRENCY, Math.max(1, targets.length));
+  await Promise.all(Array.from({ length: workers }, worker));
+  return reasons;
+}
+
+function isUsableBook(book) {
+  return !!(
+    book &&
+    Number.isInteger(book.rank) &&
+    book.rank > 0 &&
+    book.title &&
+    book.author &&
+    !/^(上一页|下一页|跳转)$/.test(book.title) &&
+    !/^(上一页|下一页|跳转|友情链接[:：]?)$/.test(book.author)
+  );
+}
+
+function cleanDesc(value) {
+  // 只压行内空白，**保留换行** —— 详情页的简介是分段的，
+  // 压成一行会看不出段落结构。
+  return String(value || "")
+    .replace(/\s*(?:飙升|上升|下降)\s*\d+\s*名\s*$/g, "")
+    .replace(/\s*(?:上一页|下一页)\s*$/g, "")
+    .replace(/[ \t　]+/g, " ")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function summarizeQuality(books, rawCount) {
+  const linked = books.filter((book) => book.url).length;
+  const heated = books.filter((book) => book.heat).length;
+  const fieldCounts = [
+    ["题材", "genre"],
+    ["子分类", "subGenre"],
+    ["状态", "status"],
+    ["字数", "words"],
+    ["热度", "heat"],
+    ["简介", "desc"],
+  ].map(([label, field]) => ({
+    label,
+    missing: books.filter((book) => !book[field]).length,
+  }));
+  const problems = [];
+  if (rawCount > books.length) problems.push(`移除无效/UI条目 ${rawCount - books.length} 条`);
+  if (linked < books.length) problems.push(`作品页链接缺失 ${books.length - linked} 条`);
+  for (const field of fieldCounts) {
+    if (field.missing) problems.push(`${field.label}缺失 ${field.missing} 条`);
+  }
+  if (books.length < 15) problems.push(`[数据稀疏] 实际采集 ${books.length} 条`);
+  return {
+    linked,
+    heated,
+    problems,
+    quality: problems.length ? "[存在问题]" : "[OK]",
+  };
+}
+
+function renderMarkdown(ch, rt, period, url, books, rawCount, now = new Date().toISOString()) {
+  const periodLabel = period ? period.label : "";
+  const summary = summarizeQuality(books, rawCount);
+  const lines = [
+    `# 七猫 · ${ch.label} · ${rt.label}${periodLabel}`,
+    "",
+    `- 数据质量：${summary.quality}`,
+    `- 有效条目：${books.length} / ${rawCount}`,
+    `- 问题摘要：${summary.problems.length ? summary.problems.join("；") : "无"}`,
+    `- 作品页链接：${summary.linked} / ${books.length}`,
+    `- 热度命中：${summary.heated} / ${books.length}`,
+    `- 来源：${url}`,
+    `- 抓取时间：${now}`,
+    `- 条目数：${books.length}`,
+    "",
+    "---",
+    "",
+  ];
+
+  for (const b of books) {
+    try {
+      lines.push(`### #${b.rank} ${b.title}`);
+      if (b.author) lines.push(`**作者：** ${b.author}`);
+      if (b.genre) lines.push(`**题材：** ${b.genre}`);
+      if (b.subGenre) lines.push(`**子分类：** ${b.subGenre}`);
+      if (b.status) lines.push(`**状态：** ${b.status}`);
+      if (b.words) lines.push(`**字数：** ${b.words}`);
+      if (b.heat) lines.push(`**热度：** ${b.heat}`);
+      if (b.url) lines.push(`[作品页](${b.url})`);
+      const desc = cleanDesc(b.desc);
+      if (desc) {
+        lines.push("");
+        lines.push(`**简介**`);
+        // 详情页的简介是分段的（单换行分隔），markdown 里要空行才算分段
+        const paras = desc.split(/\n+/).map((p) => p.trim()).filter(Boolean);
+        lines.push(paras[0]);
+        for (const p of paras.slice(1)) lines.push("", p);
+      }
+      lines.push("", "---", "");
+    } catch (bookErr) {
+      lines.push("", "---", "");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// 主流程
+// ---------------------------------------------------------------------------
+
+async function scrapeRank(browser, channelId, rankTypeId, periodId) {
+  const ch = CHANNELS.find((c) => c.id === channelId);
+  const rt = RANK_TYPES.find((r) => r.id === rankTypeId);
+  const period = periodId ? PERIODS.find((p) => p.id === periodId) : null;
+  if (!ch || !rt) {
+    console.error("  ⚠ 未知频道或榜单类型");
+    return null;
+  }
+
+  const periodLabel = period ? period.label : "";
+  const url = rankUrl(channelId, rankTypeId, periodId);
+
+  const page = await browser.newPage();
+  let books = [];
+  let rawCount = 0;
+  let partialReasons = [];
+
+  try {
+    await page.goto(url, { waitUntil: 'networkidle', timeout: 30000 });
+
+    // 滚动加载更多
+    for (let s = 0; s < 5; s++) {
+      await page.mouse.wheel(0, 800);
+      await page.waitForTimeout(300);
+    }
+
+    // 文本解析获取书籍数据 + DOM 获取链接
+    const rawBooks = await extractBooksFromText(page);
+    rawCount = rawBooks.length;
+    books = rawBooks.filter(isUsableBook);
+    const urls = await extractBookUrls(page);
+
+    // 按标题匹配 URL
+    const norm = (s) => (s || "").replace(/\s+/g, "");
+    for (const b of books) {
+      const matched = urls.find((u) => norm(u.title) === norm(b.title));
+      if (matched) b.url = matched.url;
+    }
+  } catch (err) {
+    console.error(`❌ 七猫-${ch.label}${rt.label}${periodLabel}采集失败：${err.message}`);
+    await page.close();
+    return null;
+  }
+
+  await page.close();
+
+  if (!books.length) {
+    console.error(`❌ 七猫采集失败：无有效数据`);
+    return null;
+  }
+
+  // 逐本访问详情页补完整简介（榜单页给的只是列表视图的短版）
+  partialReasons = await fetchDetailIntros(browser, books);
+  if (partialReasons.length) {
+    console.error(`  ⚠ 详情页简介 ${partialReasons.length} 本未取到（已保留榜单页简介）`);
+  }
+
+  const summary = summarizeQuality(books, rawCount);
+  console.error(
+    `  ✓ 提取 ${books.length} 本（链接 ${summary.linked}/${books.length}，热度 ${summary.heated}/${books.length}）`
+  );
+  return {
+    content: renderMarkdown(ch, rt, period, url, books, rawCount),
+    partialReasons,
+  };
+}
+
+function buildTargets(channel, rankType, period) {
+  const channels = channel === "all" ? CHANNELS.map((item) => item.id) : [channel];
+  const rankTypes = rankType === "all" ? RANK_TYPES.map((item) => item.id) : [rankType];
+  const targets = [];
+  for (const channelId of channels) {
+    for (const rankTypeId of rankTypes) {
+      // 显式指定周期就照用；all 则只展开该类型**真实存在**的周期
+      // （收藏榜/更新榜没有月榜，不展开，免得扫出一堆空榜）
+      const periodIds = period === "all"
+        ? PERIODS.map((item) => item.id)
+            .filter((pid) => rankPeriodExists(rankTypeId, pid))
+        : [period];
+      for (const periodId of periodIds) {
+        targets.push({ channel: channelId, rankType: rankTypeId, period: periodId });
+      }
+    }
+  }
+  return targets;
+}
+
+function outputFilename(channelId, rankTypeId, periodId, date) {
+  const channel = CHANNELS.find((item) => item.id === channelId);
+  const rankType = RANK_TYPES.find((item) => item.id === rankTypeId);
+  const period = periodId ? PERIODS.find((item) => item.id === periodId) : null;
+  return `七猫${channel.label}${rankType.label}${period ? period.label : ""}_${date}.md`;
+}
+
+async function main() {
+  if (CHANNEL !== "all" && !CHANNELS.some((channel) => channel.id === CHANNEL)) {
+    throw new Error(`未知 --channel: ${CHANNEL}`);
+  }
+  if (RANKTYPE !== "all" && !RANK_TYPES.some((rank) => rank.id === RANKTYPE)) {
+    throw new Error(`未知 --type: ${RANKTYPE}`);
+  }
+  if (PERIOD !== "all" && !PERIODS.some((p) => p.id === PERIOD)) {
+    throw new Error(`未知 --period: ${PERIOD}`);
+  }
+  // 收藏榜/更新榜没有月榜：直接说清楚，别悄悄回落到日榜
+  // （悄悄回落 = 用户以为扫的是月榜，拿到的却是日榜，文件名还不带"月"）
+  if (RANKTYPE !== "all" && !rankPeriodExists(RANKTYPE, PERIOD)) {
+    const rt = RANK_TYPES.find((rank) => rank.id === RANKTYPE);
+    throw new Error(`七猫${rt ? rt.label : RANKTYPE}榜没有月榜（只有日榜），请改用 --period day`);
+  }
+  const targets = buildTargets(CHANNEL, RANKTYPE, PERIOD);
+  let written = 0;
+  let failed = 0;
+  const files = [];
+  const partialReasons = [];
+
+  let browser;
+  // 被 SIGTERM 杀时（上游超时或中断）主动关掉浏览器，
+  // 否则 chromium 会留在系统里继续占 CPU/内存。
+  // close 必须带超时兜底：浏览器正在导航时 close() 可能挂住，
+  // 无超时的话进程会卡住不退出（实测过）。
+  process.on('SIGTERM', async () => {
+    try {
+      if (browser) {
+        await Promise.race([
+          browser.close(),
+          new Promise((_, reject) => setTimeout(() => reject(new Error('close timeout')), 5000)),
+        ]);
+      }
+    } catch (_) {}
+    process.exit(143);
+  });
+  try {
+    browser = await chromium.launch({ headless: true, timeout: 30000 });
+  } catch (launchErr) {
+    console.log(JSON.stringify({ ok: false, error: `七猫采集失败：浏览器启动失败：${launchErr.message}` }));
+    process.exit(1);
+  }
+  try {
+    for (const target of targets) {
+      const result = await scrapeRank(browser, target.channel, target.rankType, target.period);
+      if (!result) {
+        failed++;
+        continue;
+      }
+
+      const date = localDateStamp();
+      const filename = outputFilename(target.channel, target.rankType, target.period, date);
+      fs.mkdirSync(OUTDIR, { recursive: true });
+      const filepath = path.join(OUTDIR, filename);
+      fs.writeFileSync(filepath, result.content, "utf-8");
+      written++;
+      files.push(filepath);
+      // 详情页没取到简介的书：原因进 partialReasons，一路带到插件层的失败清单
+      if (Array.isArray(result.partialReasons)) partialReasons.push(...result.partialReasons);
+      console.error(`  ✓ 已保存: ${filepath}`);
+    }
+  } finally {
+    await browser.close();
+  }
+
+  return {
+    planned: targets.length,
+    written,
+    failed,
+    partial: failed > 0 || partialReasons.length > 0,
+    partialReasons,
+    files,
+  };
+}
+
+// import.meta.main 需要 Node >= 22.19（package.json 声明支持 node >=18.0.0）。
+// 旧版本上它是 undefined，必须回落到 argv[1] 比对 —— 否则整个脚本静默空跑：
+// exit 0、无 stdout、没有任何采集文件，调用方只看到"采集失败"。
+const isMain = import.meta.main ??
+  (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href);
+
+if (isMain) {
+  runCli(main(), "七猫采集");
+}
+
+export { extractBooksFromText, isUsableBook, cleanDesc };