@cloud411716/fancy-webnovel 1.0.45 → 2.2.0

package/plugins/fancy-analyze/scripts/split_source.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+/**
+ * fancy-analyze split_source.js — 拆分长文本源文件
+ *
+ * 按"章"切分源文件，生成多份 .txt 分片，方便 LLM 分批读取。
+ *
+ * 切分逻辑：
+ * - 按 "第N章" / "第 N 章" / "Chapter N" / "chapter N" 等正则匹配
+ * - 每章单独输出到一个分片文件
+ * - 文件名格式: split_<3位零填充>_<章号>_<章标题>.txt
+ *
+ * CLI 模式 A（按书名查找）:
+ *   node split_source.js \
+ *     --project-root <abs> \
+ *     --book-name <书名>
+ *
+ * CLI 模式 B（直接指定源文件）:
+ *   node split_source.js \
+ *     --source <abs-path-to-file> \
+ *     --output-dir <abs-path-to-output-dir>
+ *
+ * 输出:
+ *   <output-dir>/split_<NNN>.txt
+ */
+
+import { readFileSync, writeFileSync, readdirSync, mkdirSync, statSync, unlinkSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+import { cnToNumber } from '../../../lib/chinese-num.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// 多种章标记正则（按优先级）
+const CHAPTER_PATTERNS = [
+  /^\s*第\s*([零〇一二两三四五六七八九十百千万亿\d]+)\s*章\s*[、\.\s　]*(.*)$/mgu,
+  /^\s*Chapter\s*(\d+)\s*[、\.\s:]*(.*)$/mgu,
+  /^\s*chapter\s*(\d+)\s*[、\.\s:]*(.*)$/mgu,
+  /^\s*CHAPTER\s*(\d+)\s*[、\.\s:]*(.*)$/mgu,
+];
+
+/**
+ * 中文数字 → 阿拉伯数字。
+ *
+ * 2026-10-27：这份转换原本是本文件私有的，而且比仓库里其它地方弱 ——
+ * 只认到"千"、没有"两"、算法也不对（"十二万"会算成 20010）。
+ * 现在统一走 lib/chinese-num.js 的 cnToNumber，全仓库一个口径。
+ */
+const CN_DIGIT_CHARS = '零〇一二两三四五六七八九十百千万亿';
+
+function findChapterStarts(text) {
+  const starts = [];
+  for (const pat of CHAPTER_PATTERNS) {
+    for (const m of text.matchAll(pat)) {
+      const numStr = m[1];
+      const num = cnToNumber(numStr);
+      if (num !== null && num > 0) {
+        const title = m[2] ? m[2].trim() : '';
+        starts.push({ pos: m.index, num, title });
+      }
+    }
+  }
+  // 去重 + 排序
+  const seen = new Set();
+  const unique = [];
+  for (const item of starts.sort((a, b) => a.pos - b.pos)) {
+    const key = `${item.num}_${Math.floor(item.pos / 100)}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(item);
+    }
+  }
+  return unique;
+}
+
+function safeFilename(name) {
+  // 去掉所有标点符号和空白字符
+  return name.replace(/[\\/:*?"<>|\s.,，、。；;‘’""【】《》()（）!！?？_]/g, '').substring(0, 30);
+}
+
+function outputJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+/** 单个分片的最小字符数。小于这个值的分片对 LLM 没有意义，
+ *  而且 <1000 会让"第 0 章""abc"这类脏参数变成 0 → 无限循环。 */
+const MIN_CHARS_PER_SPLIT = 1000;
+
+/**
+ * 本脚本产出的分片文件名。
+ *
+ * 清理旧分片时**只删这些**，不能删目录下所有 .txt ——
+ * 输出目录有可能就是用户的资料目录/旧稿目录，
+ * 删光 .txt 等于替用户把资料删了。
+ */
+const OWNED_SPLIT_FILE_RE = /^(\d{3}\.txt|第\d+章.*\.txt)$/;
+
+function main() {
+  const args = process.argv.slice(2);
+  let sourcePath = null;
+  let projectRoot = null;
+  let outputDir = null;
+  let maxCharsPerSplit = 80000;
+
+  // 简单参数解析
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--source' && i + 1 < args.length) {
+      sourcePath = resolve(args[++i]);
+    } else if (args[i] === '--project-root' && i + 1 < args.length) {
+      projectRoot = resolve(args[++i]);
+    } else if (args[i] === '--book-name' && i + 1 < args.length) {
+      // 从项目根找书名的逻辑在调用方处理，这里不重复
+      i++;
+    } else if (args[i] === '--output-dir' && i + 1 < args.length) {
+      outputDir = resolve(args[++i]);
+    } else if (args[i] == '--max-chars-per-split' && i + 1 < args.length) {
+      const raw = args[++i];
+      const n = Number(raw);
+      // 必须严格校验：旧实现用 parseInt，'0abc' 会变成 0，
+      // 而分片循环是 `for (let i = 0; i < total; i += chunkSize)` ——
+      // chunkSize=0 就是**无限循环**，一直写文件直到磁盘满。
+      // 负数同理（i 递减）。NaN 则写出空文件。
+      if (!Number.isInteger(n) || n < MIN_CHARS_PER_SPLIT) {
+        outputJson({
+          ok: false,
+          error: {
+            code: 6,
+            code_name: 'EC_BAD_USAGE',
+            message: '--max-chars-per-split 必须是 >= ' + MIN_CHARS_PER_SPLIT + ' 的整数（当前：' + raw + '）'
+          }
+        });
+        process.exit(6);
+      }
+      maxCharsPerSplit = n;
+    }
+  }
+
+  // 至少需要 source + output-dir
+  if (!sourcePath || !outputDir) {
+    outputJson({
+      ok: false,
+      error: { code: 6, code_name: 'EC_BAD_USAGE', message: '必须传 --source 和 --output-dir' }
+    });
+    process.exit(6);
+  }
+
+  // 检查源文件
+  let stat;
+  try {
+    stat = statSync(sourcePath);
+  } catch {
+    outputJson({ ok: false, error: { code: 1, code_name: 'EC_SOURCE_MISSING', message: `源文件不存在: ${sourcePath}` } });
+    process.exit(1);
+  }
+  if (!stat.isFile()) {
+    outputJson({ ok: false, error: { code: 1, code_name: 'EC_SOURCE_MISSING', message: `源文件不是文件: ${sourcePath}` } });
+    process.exit(1);
+  }
+
+  // 输出目录不能就是源文件所在的目录 ——
+  // 清理旧分片会把源文件一起删掉（源文件通常也是 .txt），
+  // 然后 readFileSync 失败，用户的旧稿就这么没了。
+  const sourceDir = dirname(sourcePath);
+  if (sourceDir === outputDir) {
+    outputJson({
+      ok: false,
+      error: {
+        code: 6,
+        code_name: 'EC_BAD_USAGE',
+        message: '--output-dir 不能和源文件在同一目录（会把源文件当旧分片删掉）：' + outputDir
+      }
+    });
+    process.exit(6);
+  }
+
+  // 创建输出目录
+  mkdirSync(outputDir, { recursive: true });
+
+  // 清掉上一次拆分留下的分片。
+  //
+  // 这个目录是 llm_wiki 的 ingest 输入，"重新分析同一本书"时如果不清，
+  // 上一版的旧分片会一直躺在里面 —— 目录内容和源文件对不上，
+  // 用户以为在分析新版，拿到的却是新旧混合的产物（实测：源文件从
+  // 3 章改成 1 章后重跑，目录里仍然是 3 个文件）。
+  //
+  // **只删本脚本产出的文件**（OWNED_SPLIT_FILE_RE）：
+  // 旧实现删的是目录下**所有** .txt —— 输出目录如果是用户的资料目录，
+  // 这一删就是替用户把资料全删了。
+  try {
+    for (const f of readdirSync(outputDir)) {
+      if (OWNED_SPLIT_FILE_RE.test(f)) {
+        try { unlinkSync(join(outputDir, f)); } catch { /* 单个删不掉就跳过 */ }
+      }
+    }
+  } catch {
+    // 目录读不到就当没有旧分片
+  }
+
+  // 读取文件并统一转为 UTF-8
+  let text;
+  try {
+    const raw = readFileSync(sourcePath); // 读取原始字节
+    // 检测是否为有效 UTF-8：尝试用 UTF-8 解码
+    try {
+      const decoder = new TextDecoder('utf-8', { fatal: true });
+      text = decoder.decode(raw);
+    } catch {
+      // UTF-8 解码失败（fatal），说明是 GBK 编码
+      text = new TextDecoder('gbk').decode(raw);
+    }
+  } catch (err) {
+    outputJson({ ok: false, error: { code: 7, code_name: 'EC_READ_ERROR', message: `读取源文件失败: ${err.message}` } });
+    process.exit(7);
+  }
+
+  if (!text.trim()) {
+    outputJson({ ok: false, error: { code: 2, code_name: 'EC_SOURCE_EMPTY', message: '来源文件为空' } });
+    process.exit(2);
+  }
+
+  // 找章节起始
+  const chapterStarts = findChapterStarts(text);
+  const written = [];
+
+  if (chapterStarts.length === 0) {
+    // 没找到章标记 → 按 maxCharsPerSplit 切分
+    const chunkSize = maxCharsPerSplit;
+    const total = text.length;
+    for (let i = 0; i < total; i += chunkSize) {
+      const partNum = written.length + 1;
+      const partPath = join(outputDir, `${String(partNum).padStart(3, '0')}.txt`);
+      writeFileSync(partPath, text.slice(i, i + chunkSize), 'utf-8');
+      written.push(`${String(partNum).padStart(3, '0')}.txt`);
+    }
+  } else {
+    // 按章节切分
+    for (let i = 0; i < chapterStarts.length; i++) {
+      const { pos, num, title } = chapterStarts[i];
+      const end = i + 1 < chapterStarts.length ? chapterStarts[i + 1].pos : text.length;
+      // 去掉开头的空白行和章节标题行（如"第一章 xxx"）
+      const rawText = text.slice(pos, end);
+      const lines = rawText.split('\n');
+      let startIndex = 0;
+      for (let j = 0; j < lines.length; j++) {
+        if (lines[j].trim() === '') {
+          startIndex = j + 1;
+        } else {
+          break;
+        }
+      }
+      // 跳过章节标题行（第一行非空白内容）
+      const chapterText = lines.slice(startIndex + 1).join('\n');
+      const safeTitle = safeFilename(title);
+      let base = '';
+      if (safeTitle) {
+        base = `第${num}章-${safeTitle}`;
+      } else {
+        base = `第${num}章`;
+      }
+      // 超长的章要按 maxCharsPerSplit **二次切分** ——
+      // 旧实现只看 chapterStarts 的章边界，一个 20 万字的章会原样写成一个
+      // 分片，仍然远超 LLM 上下文，ingest 时照样被截断。
+      const pieces = [];
+      if (chapterText.length <= maxCharsPerSplit) {
+        pieces.push(chapterText);
+      } else {
+        for (let j = 0; j < chapterText.length; j += maxCharsPerSplit) {
+          pieces.push(chapterText.slice(j, j + maxCharsPerSplit));
+        }
+      }
+      for (let k = 0; k < pieces.length; k++) {
+        const suffix = pieces.length > 1 ? '-' + String(k + 1) : '';
+        const filename = base + suffix + '.txt';
+        const partPath = join(outputDir, filename);
+        writeFileSync(partPath, pieces[k], 'utf-8');
+        written.push(filename);
+      }
+    }
+  }
+
+  outputJson({
+    ok: true,
+    operation: 'split-source',
+    source_path: sourcePath,
+    source_chars: text.length,
+    chapter_count: chapterStarts.length,
+    split_files: written,
+    split_count: written.length,
+  });
+}
+
+main();