dsh-tingdong 0.3.1 → 0.5.0

package/README.md

@@ -5,7 +5,20 @@
 
 ## 它做什么
 
-1. **导入**：选一个 MP3（或整个文件夹），本机识别出每一句英文和它的起止时间。
+首页有两个入口：**导入音频**（有声书、讲座、引导音频）和**导入文档**（文章、手册、书）。
+
+**导入文档**：直接选文件（或拖进来）——PDF、Word（.docx）、EPUB 电子书、网页（.html）、TXT、Markdown；没有文件也可以粘贴英文。
+
+1. 插件先取出文字，给你一张**确认卡片**：读到了多少词，预计分几课、朗读多长、处理要多久、大约用多少模型 token，并说明「会用 AI 整理文字」。
+2. 你点确定后，在后台：**AI 整理**（去掉页眉页码目录、修好断行、分好章节，原文一个字都不改、不翻译；长文分段、几段同时整理，逐段核对单词数，模型删多了就重来或改用原文）→ **存档**（原文件、取出的原始文字、整理后的文字都留在 `~/.dsh/dsh-tingdong/docs/`，课程概览里能下载）→ **分课**（每个大标题一课，太长的按段落拆开）→ **朗读**（默认微软 Edge，14 种美式 / 英式男女声，可选离线 Kokoro）→ **逐句翻译讲解**。
+3. 做好一课就能先学一课，之后和音频课一样：精听、复习、磨耳朵、连续听、导出。
+
+**大小和耗时**：文件最大 100 MB；文字最多约 6 万个英文单词（40 万字符，相当于 7 小时左右的朗读），再长请拆开导入。真正花时间和 token 的是 AI 整理和翻译：1 万词大约整理 4 万字符、朗读 1 小时多，处理约十几分钟（看模型速度）。扫描版 PDF（每页是图片）读不出文字，要先用 OCR 或 AI 转成文字。
+在 DSH 对话里也可以把 PDF 发给 AI，说「整理后导入听懂」（AI 工具 `tingdong_import_text`）。
+
+**导入音频**：
+
+1. **识别**：选一个 MP3（或整个文件夹），本机识别出每一句英文和它的起止时间。
    识别用的是 DSH 自带语音输入的同一套模型（SenseVoice + Silero VAD），音频不上传；用过 DSH 语音输入就不用再下载。
 2. **讲解**：用你在 DSH 里选的大模型逐句校对英文（修正识别错误，如 "resna tuning" → "resonant tuning"）、
    翻成口语化中文、挑出生词（带音标）、写一句「听音提示」（哪里连读、弱读、吞音），再写全篇概述和关键术语表。
@@ -46,9 +59,9 @@
 
 电脑快捷键：空格 重听 · 回车 下一步 · 1/2/3 评分 · ←/→ 上一句/下一句 · S 变速（1× / 0.85× / 0.7×）· L 单句循环
 
-在 DSH 对话里也可以直接说：「把 /Volumes/…/CD4 导入听懂」「我这课哪些句子总听不懂？给我讲讲」——插件给 AI 注册了 `tingdong_import`、`tingdong_lessons`、`tingdong_sentences` 三个工具。
+在 DSH 对话里也可以直接说：「把 /Volumes/…/CD4 导入听懂」「把这份 PDF 整理后导入听懂」「我这课哪些句子总听不懂？给我讲讲」——插件给 AI 注册了 `tingdong_import`、`tingdong_import_text`、`tingdong_lessons`、`tingdong_sentences` 四个工具。
 
-**更新 / 卸载**：首页标题旁显示版本号，打开时自动查 npm 上有没有新版本；有就出现「更新到 vX」，点一下由 DSH 的插件管理器装好（和插件市场同一套机制），重启 DSH 生效。「卸载」只移除插件，课程和学习进度留在 `~/.dsh/dsh-tingdong`。
+**更新 / 卸载**：在 DSH 的「设置 → 听懂」里。打开时自动查 npm 上有没有新版本；有就出现「更新到 vX」，点一下由 DSH 的插件管理器装好（和插件市场同一套机制），重启 DSH 生效。「卸载」会先确认，只移除插件，课程和学习进度留在 `~/.dsh/dsh-tingdong`。学习面板首页标题旁显示版本号，有新版本时会提醒。
 
 ## 安装
 
@@ -92,6 +105,7 @@ dsh plugin --profile desktop add /path/to/dsh-go
 ```bash
 node bin/dsh-tingdong.js import "/Volumes/kuozhan/门罗/CD4"     # 整个文件夹，每个音频一课
 node bin/dsh-tingdong.js serve                                   # 打开 http://127.0.0.1:4810
+node bin/dsh-tingdong.js import-doc 手册.md --voice en-US-AndrewNeural   # 导入整理好的英文文档
 node bin/dsh-tingdong.js list
 node bin/dsh-tingdong.js voices all --track kokoro --voice am_michael   # 批量生成声音轨
 ```
@@ -120,7 +134,7 @@ npm test
 - `lib/translate.js` 校对 + 翻译 + 生词 + 听音提示；缺句自动缩小批次重试，失败的留空，之后可「补全翻译」
 - `lib/tracks.js` 声音轨：原声按句截取拼接；朗读交给 `lib/tts-worker.js` 子进程（Kokoro / macOS say），`lib/pcm.js` 统一拼接编码并出时间表
 - `lib/srs.js` 间隔复习；`lib/store.js` 原子写入的 JSON 存储；`lib/today.js` 今日学习（按用户时区算日期）
-- `lib/export.js` 文字导出；`lib/edge.js` Edge 语音组件（edge-tts）的安装和调用
+- `lib/doc.js` 文档：切句、分章、整理要求；`lib/export.js` 文字导出；`lib/edge.js` Edge 语音组件（edge-tts）的安装和调用
 - `lib/drill.js` 磨耳朵音频；`lib/lookup.js` 点词查意思、重新讲解；`lib/vps.js` 经 SSH 发送到 VPS
 - `plugin/` DSH 宿主端（路由、AI 工具）和界面入口（右侧栏、设置）；路由先过 DSH 的 `connection.requestRejection()` 登录校验
 - `web/` 学习面板（原生 JS 模块，无构建）：`panel.js` 路由和首页 · `study.js` 精听、复习、今日学习 · `listen.js` 连续听、磨耳朵、词汇 · `edit.js` 改句子、查词 · `core.js` 播放器和公共状态

package/bin/dsh-tingdong.js

@@ -4,6 +4,7 @@
 //   dsh-tingdong import <文件或文件夹> [--title 标题]   识别 + 翻译，做成课
 //   dsh-tingdong serve [--port 4810]                    在浏览器里打开学习面板
 //   dsh-tingdong list                                   看有哪些课
+//   dsh-tingdong import-doc <文档>                       导入英文文档：AI 整理 → 分课 → Edge 朗读 + 翻译
 //   dsh-tingdong voices <课程id|all> [--track clean,cleannr,say,kokoro] [--voice 名字] [--speed 0.9]
 //                                                       生成声音轨（去空白原声 / 压背景 / 系统朗读 / Kokoro）
 //
@@ -50,6 +51,34 @@ async function main() {
     return
   }
 
+  if (cmd === 'import-doc') {
+    if (!rest[0]) throw new Error('用法：dsh-tingdong import-doc <PDF / Word / EPUB / 网页 / TXT / MD> [--title 标题] [--voice en-US-AndrewNeural] [--engine edge|kokoro]')
+    const llm = await cliLlm(flags)
+    console.log(llm ? `翻译模型：${llm.label()}（${llm.via}）` : '没有可用的大模型：只朗读英文')
+    const importer = new Importer({ llm: () => llm, options, log: m => console.error(m) })
+    let last = ''
+    importer.onChange(() => {
+      for (const j of importer.list()) {
+        if (j.state !== 'running') continue
+        const key = `${j.id}|${j.stage}|${j.total ? Math.floor(j.done / j.total * 4) : 0}`
+        if (key !== last) { last = key; console.log(`${j.title}：${j.stage}${j.total ? ` ${j.done}/${j.total}` : ''}`) }
+      }
+    })
+    // 和界面一样：取出文字、预估 → 确认 → AI 整理、存档 → 分课 → 朗读、翻译
+    const { basename } = await import('node:path')
+    const doc = await importer.prepareDoc(rest[0], { name: basename(rest[0]) })
+    const e = doc.estimate
+    console.log(`${doc.name}：${doc.type}${doc.pages ? ` ${doc.pages} 页` : ''}，约 ${e.words} 词 → 约 ${e.lessons} 课，朗读约 ${e.audioMinutes} 分钟，处理约 ${e.minutes} 分钟，约 ${e.tokens} token；${doc.needsCleanup ? 'AI 整理' : '已是整理好的格式'}`)
+    await importer.confirmDoc(doc.docId, { title: typeof flags.title === 'string' ? flags.title : doc.title, engine: flags.engine === 'kokoro' ? 'kokoro' : 'edge', voice: typeof flags.voice === 'string' ? flags.voice : undefined })
+    await new Promise(resolve => {
+      const check = () => { if (!importer.running && !importer.jobs.some(j => j.state === 'queued')) resolve() }
+      importer.onChange(() => setImmediate(check))
+      check()
+    })
+    for (const j of importer.list()) console.log(`${j.state === 'done' ? '✓' : '✗'} ${j.title}${j.error ? '：' + j.error : ''}`)
+    return
+  }
+
   if (cmd === 'voices') {
     const which = rest[0]
     if (!which) throw new Error('用法：dsh-tingdong voices <课程id|all> [--track clean,cleannr,say,kokoro]')
@@ -132,6 +161,7 @@ async function main() {
   dsh-tingdong import <文件或文件夹> [--title 标题]
   dsh-tingdong serve [--port 4810]
   dsh-tingdong list
+  dsh-tingdong import-doc <PDF / Word / EPUB / 网页 / TXT / MD> [--title 标题] [--voice en-US-AndrewNeural]
   dsh-tingdong voices <课程id|all> [--track clean,cleannr,say,kokoro] [--voice 名字] [--speed 0.9]
 
   模型：--base-url URL --api-key KEY --model ID（或 TINGDONG_BASE_URL / TINGDONG_API_KEY / TINGDONG_MODEL）

package/lib/doc.js

@@ -0,0 +1,132 @@
+// lib/doc.js — 导入英文文档：整理好的纯文本 → 一章一课，每课是一句一句的英文
+//
+// 约定的格式（让别的 AI 先整理好，界面上有现成的整理指令可以复制）：
+//   # 章节标题        一行「# 」开头：新的一章，做成一课
+//   ## 小标题         小标题也读出来，算一句
+//   段落之间空一行；段落内部的换行会被接起来（硬换行、断词的连字符都能处理）
+// 没有任何「# 」时整篇算一章；一章太长（超过 MAX_SENTENCES 句）就按段落拆成几课。
+
+export const MAX_CHARS = 400000
+export const MAX_SENTENCES = 160
+
+// 句点后面不算句子结束的缩写
+const ABBR = new Set(['mr', 'mrs', 'ms', 'dr', 'prof', 'sr', 'jr', 'st', 'vs', 'etc', 'e.g', 'i.e', 'fig', 'no', 'vol', 'p', 'pp', 'ch', 'u.s', 'u.k', 'a.m', 'p.m', 'inc', 'ltd', 'co', 'approx', 'dept', 'est', 'mt', 'jan', 'feb', 'mar', 'apr', 'jun', 'jul', 'aug', 'sep', 'sept', 'oct', 'nov', 'dec'])
+
+/** 文本清理：统一换行、去掉不可见字符、接上断词 */
+export function normalize(text) {
+  return String(text || '')
+    .replace(/\r\n?/g, '\n')
+    .replace(/[­​]/g, '')
+    .replace(/‐|‑/g, '-')
+    .replace(/(\w)-\n(\w)/g, '$1$2') // 行尾断词
+    .replace(/[ \t]+/g, ' ')
+}
+
+/** 一段文字切成句子 */
+export function splitSentences(paragraph) {
+  const p = paragraph.replace(/\s*\n\s*/g, ' ').replace(/\s+/g, ' ').trim()
+  if (!p) return []
+  const out = []
+  let start = 0
+  const re = /([.!?…]+)(["'”’)\]]*)(\s+)(?=["'“‘(\[]?[A-Z0-9])/g
+  let m
+  while ((m = re.exec(p))) {
+    const end = m.index + m[1].length + m[2].length
+    const before = p.slice(start, m.index)
+    const lastWord = (/([A-Za-z.]+)$/.exec(before) || [])[1] || ''
+    // 缩写（Mr. / e.g.）和单个大写字母（A. Monroe）后面的句点不断句
+    if (m[1] === '.' && (ABBR.has(lastWord.toLowerCase().replace(/\.$/, '')) || /^[A-Z]$/.test(lastWord))) continue
+    out.push(p.slice(start, end).trim())
+    start = end + m[3].length
+  }
+  out.push(p.slice(start).trim())
+  return out.filter(Boolean).flatMap(splitLong)
+}
+
+/** 太长的句子听起来累：超过 220 个字符的，在分号、冒号、破折号处拆开 */
+function splitLong(s) {
+  if (s.length <= 220) return [s]
+  const parts = s.split(/(?<=[;:])\s+|\s+[—–]\s+|(?<=—)/).map(x => x.trim()).filter(Boolean)
+  if (parts.length < 2) return [s]
+  // 拆得太碎的再并回去
+  const merged = []
+  for (const x of parts) {
+    const last = merged[merged.length - 1]
+    if (last && (last.length < 60 || x.length < 40)) merged[merged.length - 1] = `${last} ${x}`
+    else merged.push(x)
+  }
+  return merged
+}
+
+/**
+ * @returns {{title:string, chapters:{title:string, sentences:{text:string, heading?:boolean, para:number}[]}[]}}
+ */
+export function parseDoc(text, { title = '' } = {}) {
+  const src = normalize(text)
+  if (!src.trim()) throw Object.assign(new Error('没有内容'), { status: 400 })
+  if (src.length > MAX_CHARS) throw Object.assign(new Error(`太长了（${src.length} 字符）：一次最多 ${MAX_CHARS} 字符，拆成几份导入`), { status: 400 })
+  if (/[一-鿿]/.test(src) && (src.match(/[一-鿿]/g) || []).length > src.length * 0.2) {
+    throw Object.assign(new Error('看起来大部分是中文：这里导入英文原文，中文由 AI 翻译'), { status: 400 })
+  }
+  const chapters = []
+  let cur = null
+  let para = 0
+  const newChapter = t => { cur = { title: t, sentences: [] }; chapters.push(cur) }
+  for (const block of src.split(/\n\s*\n/)) {
+    const lines = block.split('\n')
+    let buf = []
+    const flush = () => {
+      if (!buf.length) return
+      if (!cur) newChapter('')
+      para++
+      for (const s of splitSentences(buf.join('\n'))) cur.sentences.push({ text: s, para })
+      buf = []
+    }
+    for (const raw of lines) {
+      const line = raw.trim()
+      const h1 = /^#\s+(.+)$/.exec(line)
+      const h2 = /^#{2,6}\s+(.+)$/.exec(line)
+      if (h1) { flush(); newChapter(h1[1].trim()); continue }
+      if (h2) {
+        flush()
+        if (!cur) newChapter('')
+        para++
+        cur.sentences.push({ text: h2[1].trim().replace(/[*_`]/g, ''), heading: true, para })
+        continue
+      }
+      // Markdown 的列表符号、强调符号不读
+      buf.push(line.replace(/^[-*+]\s+|^\d+[.)]\s+/, '').replace(/[*_`]+/g, ''))
+    }
+    flush()
+  }
+  const docTitle = title.trim() || (chapters[0] && chapters[0].title) || firstWords(chapters)
+  // 去掉空章；没标题的章用文档标题；太长的章按段落拆开
+  const out = []
+  for (const [k, c] of chapters.filter(c => c.sentences.length).entries()) {
+    const t = c.title || (chapters.length > 1 ? `${docTitle} · 第 ${k + 1} 部分` : docTitle)
+    if (c.sentences.length <= MAX_SENTENCES) { out.push({ title: t, sentences: c.sentences }); continue }
+    let part = []
+    let n = 1
+    for (const [j, s] of c.sentences.entries()) {
+      part.push(s)
+      const paraEnds = !c.sentences[j + 1] || c.sentences[j + 1].para !== s.para
+      if (part.length >= MAX_SENTENCES * 0.8 && paraEnds) { out.push({ title: `${t}（${n++}）`, sentences: part }); part = [] }
+    }
+    if (part.length) out.push({ title: n > 1 ? `${t}（${n}）` : t, sentences: part })
+  }
+  if (!out.length) throw Object.assign(new Error('没找到英文句子'), { status: 400 })
+  return { title: docTitle, chapters: out }
+}
+
+function firstWords(chapters) {
+  const s = chapters[0] && chapters[0].sentences[0]
+  return s ? s.text.split(/\s+/).slice(0, 6).join(' ') : '英文文档'
+}
+
+/** 给别的 AI 的整理指令：用户复制过去，连同 PDF / 网页 / 电子书一起发给它 */
+export const PREP_PROMPT = `请把我发给你的英文材料整理成纯文本，用来导入英语听力学习软件。要求：
+1. 只保留正文英文，删掉页眉、页脚、页码、目录、脚注编号、图片说明、网址和联系方式。
+2. 修好因为换行断开的单词（比如 "resonant-" 换行接 "tuning"），段落内部不要硬换行；每个段落一行，段落之间空一行。
+3. 每一章单独起一行「# 章节标题」。原文没有章节的，按内容大约每 800–1500 个英文单词分一章，自己起个简短的英文标题。章里的小标题用「## 小标题」。
+4. 不要翻译、不要改写、不要总结，原文一个字都不要改；也不要加任何说明。
+5. 直接输出整理好的文本（Markdown 纯文本），我会保存成 .txt 或 .md 文件导入。`

package/lib/docprep.js

@@ -0,0 +1,178 @@
+// lib/docprep.js — 用 AI 把从文档里取出的原始文字整理成能导入的格式（# 章节、段落、只留正文）
+//
+// 原始文字按约 1 万字符分段，几段同时整理；每段都告诉模型上一段的结尾和当前章节，接缝处才连得上。
+// 整理完逐段核对英文单词数：模型删掉太多（少于 60%）就重来一次，还不行就用原文简单接好断行——宁可难看，不能丢内容。
+
+import { normalize } from './doc.js'
+
+export const CHUNK_CHARS = 10000
+
+const SYSTEM = `你是文字整理员。给你的是从 PDF / Word / 电子书 / 网页里取出的英文原始文字（其中一段），要整理成英语听力软件能导入的纯文本。规则：
+1. 只保留正文英文：删掉页眉、页脚、页码、目录、版权声明、联系方式、网址和邮箱、图片说明、脚注编号，以及 ® ™ 这类符号。
+2. 修好断行：行尾被拆开的单词接回去；同一段落的多行接成一行；段落之间空一行。
+3. 章节：原文的大标题（一章的开头）单独一行写成「# 标题」，小标题写成「## 小标题」。原文没有章节的长文，大约每 800–1500 个英文单词加一个「# 」标题，用几个英文单词概括。
+4. 原文的句子一个字都不要改：不要翻译、改写、总结、补充，也不要加任何解释或前后说明。
+5. 这一段可能从段落中间开始、在段落中间结束，照原样整理，不要补写缺的部分。
+6. 格式必须严格：标题前后各空一行，段落和段落之间空一行。原文里单独成行、很短、没有句号的行（如 "Cautions and Warnings"、"Chapter 3—Free Flow"）就是标题，一定要加「# 」或「## 」。
+输出示例：
+# The First Chapter
+
+First paragraph. Its second sentence.
+
+## A Section Title
+
+Another paragraph.
+
+只输出整理后的文字。`
+
+const words = t => (String(t).match(/[A-Za-z][A-Za-z'’-]*/g) || []).length
+
+/** 按行切成约 CHUNK_CHARS 的几段，尽量在空行处切 */
+export function chunkText(raw, size = CHUNK_CHARS) {
+  const lines = normalize(raw).split('\n')
+  const chunks = []
+  let cur = []
+  let len = 0
+  for (const line of lines) {
+    cur.push(line)
+    len += line.length + 1
+    const blank = line.trim() === ''
+    if (len >= size && (blank || len >= size * 1.3)) { chunks.push(cur.join('\n').trim()); cur = []; len = 0 }
+  }
+  if (cur.join('').trim()) chunks.push(cur.join('\n').trim())
+  return chunks.filter(Boolean)
+}
+
+/** 原文简单整理（模型靠不住时的退路）：接断行、段落空一行 */
+export function plainTidy(raw) {
+  return normalize(raw)
+    .split(/\n\s*\n/)
+    .map(p => p.replace(/\s*\n\s*/g, ' ').trim())
+    .filter(Boolean)
+    .join('\n\n')
+}
+
+/** 像标题的行：不长、没有句末标点、多数词首字母大写（"Cautions and Warnings: Please Read"） */
+function looksLikeHeading(line, next) {
+  if (line.length > 90 || /[.!?,;]$/.test(line) || !/^[A-Z0-9"“‘'(]/.test(line)) return false
+  const ws = line.split(/\s+/).filter(Boolean)
+  if (ws.length > 12) return false
+  // 只看以字母开头的实词（「#4—NVC」「12」这种不算）
+  const big = ws.filter(w => w.length > 3 && /^["“‘'(]?[A-Za-z]/.test(w))
+  if (big.length && big.filter(w => /^["“‘'(]?[A-Z0-9]/.test(w)).length / big.length < 0.6) return false
+  // 下一行以小写开头：这是被断开的句子，不是标题
+  return !next || !/^[a-z]/.test(next)
+}
+
+/**
+ * 把模型的输出（或原文）规整成导入格式，不管它守没守规矩：
+ * 认出标题加「## 」，句子中途断开的行接回去，每段之间空一行。已经合格的文字过一遍不变。
+ */
+export function ensureStructure(text) {
+  const lines = String(text).split('\n').map(l => l.trim())
+  const blocks = []
+  let para = ''
+  const flush = () => { if (para) { blocks.push(para); para = '' } }
+  for (let k = 0; k < lines.length; k++) {
+    const line = lines[k]
+    if (!line) { flush(); continue }
+    if (/^#{1,6}\s/.test(line)) { flush(); blocks.push(line); continue }
+    const next = lines.slice(k + 1).find(Boolean) || ''
+    if (!para && looksLikeHeading(line, next)) { blocks.push(`## ${line}`); continue }
+    para = para ? `${para} ${line}` : line
+    // 这一行说完了（句末标点）、下一行另起：就是一段的结尾
+    if (/[.!?…"”’)]$/.test(line) && !/^[a-z]/.test(next)) flush()
+  }
+  flush()
+  return blocks.join('\n\n')
+}
+
+/** 去掉模型偶尔加上的代码块围栏和开场白 */
+function stripWrapper(t) {
+  return String(t || '').replace(/^```[a-z]*\n?|```\s*$/gi, '').trim()
+}
+
+/**
+ * 预估：词数、朗读时长、大约几课、要多久、多少 token
+ * 粗算：朗读每分钟 150 词；一课最多 160 句（约 2000 词）；
+ * 模型输出 token：整理 ≈ 字符数 / 4，翻译讲解 ≈ 每句 120
+ */
+export function estimate(text, { needsCleanup = true } = {}) {
+  const w = words(text)
+  const chars = text.length
+  const sentences = Math.max(1, Math.round(w / 16))
+  const chunks = needsCleanup ? Math.max(1, Math.ceil(chars / CHUNK_CHARS)) : 0
+  const tokens = Math.round((needsCleanup ? chars / 4 : 0) + sentences * 120)
+  // 整理：每段约 40 秒、3 段并行；朗读（Edge）约为时长的 1/4；翻译：每 20 句一批约 15 秒、3 批并行
+  const seconds = Math.ceil(chunks / 3) * 40 + (w / 150) * 60 / 4 + Math.ceil(sentences / 20 / 3) * 15
+  return {
+    words: w, chars, sentences,
+    audioMinutes: Math.max(1, Math.round(w / 150)),
+    lessons: Math.max(1, Math.ceil(sentences / 130)),
+    chunks, tokens,
+    minutes: Math.max(1, Math.round(seconds / 60)),
+  }
+}
+
+/**
+ * @param {object} llm complete() 接口
+ * @param {string} raw 原始文字
+ * @param {{title?:string, signal?:AbortSignal, concurrency?:number, chunkChars?:number, onProgress?(done,total):void}} o
+ * @returns {Promise<{text:string, warnings:string[]}>}
+ */
+export async function cleanupText(llm, raw, o = {}) {
+  const chunks = chunkText(raw, o.chunkChars || CHUNK_CHARS)
+  const out = new Array(chunks.length)
+  const warnings = []
+  let done = 0
+  let next = 0
+  const one = async (k) => {
+    const chunk = chunks[k]
+    const prev = k > 0 ? chunks[k - 1].slice(-300).replace(/\s+/g, ' ') : ''
+    const user = [
+      o.title ? `材料：${o.title}` : '',
+      `这是第 ${k + 1} / ${chunks.length} 段。`,
+      prev ? `上一段原文的结尾是：「…${prev}」（只用来接上下文，不要输出）` : '这是开头。',
+      '',
+      '原始文字：',
+      chunk,
+    ].filter(x => x !== null).join('\n')
+    const want = words(chunk)
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (o.signal && o.signal.aborted) throw new Error('已取消')
+      try {
+        const text = stripWrapper(await llm.complete({ system: SYSTEM, user, maxTokens: 16000, signal: o.signal }))
+        const got = words(text)
+        if (want < 30 || got >= want * 0.6) { out[k] = ensureStructure(text); return }
+      } catch (e) {
+        if (o.signal && o.signal.aborted) throw e
+        if (attempt === 1) warnings.push(`第 ${k + 1} 段整理失败（${e.message}），用了原文`)
+      }
+    }
+    if (!out[k]) {
+      out[k] = ensureStructure(plainTidy(chunk))
+      if (!warnings.some(w => w.startsWith(`第 ${k + 1} 段`))) warnings.push(`第 ${k + 1} 段 AI 整理后少了很多内容，改用原文（可能留有页眉页码）`)
+    }
+  }
+  const workers = Array.from({ length: Math.min(o.concurrency || 3, chunks.length) }, async () => {
+    while (next < chunks.length) {
+      const k = next++
+      await one(k)
+      done++
+      if (o.onProgress) o.onProgress(done, chunks.length)
+    }
+  })
+  await Promise.all(workers)
+  // 接缝：下一段开头重复了上一段最后的章节标题就去掉
+  const parts = []
+  let lastHeading = ''
+  for (const t of out) {
+    let s = t
+    const first = /^#\s+(.+)$/m.exec(s)
+    if (first && s.trimStart().startsWith('#') && first[1].trim() === lastHeading) s = s.replace(/^\s*#\s+.+\n?/, '')
+    const hs = [...s.matchAll(/^#\s+(.+)$/gm)]
+    if (hs.length) lastHeading = hs[hs.length - 1][1].trim()
+    parts.push(s.trim())
+  }
+  return { text: parts.filter(Boolean).join('\n\n'), warnings }
+}

package/lib/edge.js

@@ -29,6 +29,25 @@ export const EDGE_ZH_VOICES = [
 ]
 export const edgeVoice = id => EDGE_ZH_VOICES.find(v => v.id === id) || EDGE_ZH_VOICES[0]
 
+/** 英文（导入文档时朗读用；默认 Andrew） */
+export const EDGE_EN_VOICES = [
+  { id: 'en-US-AndrewNeural', label: 'Andrew（美式男声 · 温和）', gender: 'm' },
+  { id: 'en-US-BrianNeural', label: 'Brian（美式男声 · 随和）', gender: 'm' },
+  { id: 'en-US-ChristopherNeural', label: 'Christopher（美式男声 · 沉稳）', gender: 'm' },
+  { id: 'en-US-GuyNeural', label: 'Guy（美式男声）', gender: 'm' },
+  { id: 'en-US-EricNeural', label: 'Eric（美式男声）', gender: 'm' },
+  { id: 'en-GB-RyanNeural', label: 'Ryan（英式男声）', gender: 'm' },
+  { id: 'en-GB-ThomasNeural', label: 'Thomas（英式男声）', gender: 'm' },
+  { id: 'en-US-AvaNeural', label: 'Ava（美式女声 · 亲切）', gender: 'f' },
+  { id: 'en-US-EmmaNeural', label: 'Emma（美式女声 · 清晰）', gender: 'f' },
+  { id: 'en-US-JennyNeural', label: 'Jenny（美式女声）', gender: 'f' },
+  { id: 'en-US-AriaNeural', label: 'Aria（美式女声 · 播音）', gender: 'f' },
+  { id: 'en-US-MichelleNeural', label: 'Michelle（美式女声）', gender: 'f' },
+  { id: 'en-GB-SoniaNeural', label: 'Sonia（英式女声）', gender: 'f' },
+  { id: 'en-GB-LibbyNeural', label: 'Libby（英式女声）', gender: 'f' },
+]
+export const edgeEnVoice = id => EDGE_EN_VOICES.find(v => v.id === id) || EDGE_EN_VOICES[0]
+
 export const edgeDir = () => join(dataRoot(), 'edge-tts')
 const win = process.platform === 'win32'
 const venvBin = name => join(edgeDir(), win ? 'Scripts' : 'bin', win ? `${name}.exe` : name)

package/lib/extract.js

@@ -0,0 +1,139 @@
+// lib/extract.js — 从文档里取出文字：PDF、Word（.docx）、EPUB 电子书、网页（.html）、TXT / Markdown
+//
+// 只取文字，不管排版：页眉页码、断行这些交给后面的 AI 整理（lib/docprep.js）。
+// docx / epub 本质是 zip：这里用 Node 自带的 zlib 读，不另加依赖；PDF 用 unpdf（纯 JS）。
+
+import { readFile } from 'node:fs/promises'
+import { extname } from 'node:path'
+import { inflateRawSync } from 'node:zlib'
+
+export const DOC_EXT = ['.pdf', '.docx', '.epub', '.html', '.htm', '.txt', '.md', '.markdown']
+
+// ———————— zip ————————
+
+/** 读 zip 的目录，返回 name → 取内容的函数 */
+export function readZip(buf) {
+  let eocd = -1
+  for (let i = buf.length - 22; i >= Math.max(0, buf.length - 65557); i--) {
+    if (buf.readUInt32LE(i) === 0x06054b50) { eocd = i; break }
+  }
+  if (eocd < 0) throw new Error('不是有效的 zip 文件')
+  const count = buf.readUInt16LE(eocd + 10)
+  let p = buf.readUInt32LE(eocd + 16)
+  const files = new Map()
+  for (let k = 0; k < count; k++) {
+    if (buf.readUInt32LE(p) !== 0x02014b50) break
+    const method = buf.readUInt16LE(p + 10)
+    const size = buf.readUInt32LE(p + 20)
+    const nameLen = buf.readUInt16LE(p + 28)
+    const extraLen = buf.readUInt16LE(p + 30)
+    const commentLen = buf.readUInt16LE(p + 32)
+    const local = buf.readUInt32LE(p + 42)
+    const name = buf.toString('utf8', p + 46, p + 46 + nameLen)
+    files.set(name, () => {
+      const start = local + 30 + buf.readUInt16LE(local + 26) + buf.readUInt16LE(local + 28)
+      const data = buf.subarray(start, start + size)
+      if (method === 0) return data
+      if (method === 8) return inflateRawSync(data)
+      throw new Error(`zip 里用了不支持的压缩方式（${method}）`)
+    })
+    p += 46 + nameLen + extraLen + commentLen
+  }
+  return files
+}
+
+// ———————— HTML / XML → 文字 ————————
+
+const ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', mdash: '—', ndash: '–', hellip: '…', lsquo: '‘', rsquo: '’', ldquo: '“', rdquo: '”' }
+export function decodeEntities(s) {
+  return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => {
+    if (e[0] === '#') return String.fromCodePoint(e[1].toLowerCase() === 'x' ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10))
+    return ENTITIES[e.toLowerCase()] ?? m
+  })
+}
+
+/** 网页 / EPUB 章节 → 文字：标题变成「# 」「## 」，段落之间空一行 */
+export function htmlToText(html) {
+  return decodeEntities(String(html)
+    .replace(/<(script|style|head|nav|footer|aside)[\s\S]*?<\/\1>/gi, '')
+    .replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, (_, t) => `\n\n# ${t.replace(/<[^>]+>/g, '').trim()}\n\n`)
+    .replace(/<h[2-6][^>]*>([\s\S]*?)<\/h[2-6]>/gi, (_, t) => `\n\n## ${t.replace(/<[^>]+>/g, '').trim()}\n\n`)
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/(p|div|li|blockquote|section|article|tr)>/gi, '\n\n')
+    .replace(/<[^>]+>/g, ''))
+    .replace(/[ \t]+/g, ' ')
+    .replace(/\n[ \t]+/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+}
+
+/** Word：word/document.xml 里一个 <w:p> 是一段，标题样式变成「# / ## 」 */
+export function docxToText(buf) {
+  const zip = readZip(buf)
+  const doc = zip.get('word/document.xml')
+  if (!doc) throw new Error('这个 Word 文件里没有正文')
+  const xml = doc().toString('utf8')
+  const paras = []
+  for (const m of xml.matchAll(/<w:p[ >][\s\S]*?<\/w:p>/g)) {
+    const p = m[0]
+    const style = (/<w:pStyle w:val="([^"]+)"/.exec(p) || [])[1] || ''
+    const text = decodeEntities([...p.matchAll(/<w:t(?: [^>]*)?>([\s\S]*?)<\/w:t>|<w:tab\/>|<w:br\/>/g)].map(t => (t[1] !== undefined ? t[1] : ' ')).join('')).trim()
+    if (!text) continue
+    const h = /^(Heading|标题)\s*(\d)/i.exec(style) || (/^Title$/i.test(style) ? [0, 0, '1'] : null)
+    paras.push(h ? `${h[2] === '1' ? '#' : '##'} ${text}` : text)
+  }
+  return paras.join('\n\n')
+}
+
+/** EPUB：按目录（spine）的顺序把各章 XHTML 接起来 */
+export function epubToText(buf) {
+  const zip = readZip(buf)
+  const container = zip.get('META-INF/container.xml')
+  const opfPath = container && (/full-path="([^"]+)"/.exec(container().toString('utf8')) || [])[1]
+  if (!opfPath || !zip.get(opfPath)) throw new Error('这个 EPUB 文件不完整')
+  const opf = zip.get(opfPath)().toString('utf8')
+  const base = opfPath.includes('/') ? opfPath.slice(0, opfPath.lastIndexOf('/') + 1) : ''
+  const items = new Map([...opf.matchAll(/<item\b[^>]*>/g)].map(m => [(/id="([^"]+)"/.exec(m[0]) || [])[1], (/href="([^"]+)"/.exec(m[0]) || [])[1]]))
+  const parts = []
+  for (const m of opf.matchAll(/<itemref\b[^>]*idref="([^"]+)"/g)) {
+    const href = items.get(m[1])
+    if (!href) continue
+    const name = decodeURIComponent(base + href.split('#')[0])
+    const f = zip.get(name)
+    if (f) parts.push(htmlToText(f().toString('utf8')))
+  }
+  return parts.filter(Boolean).join('\n\n')
+}
+
+/** TXT：UTF-8 / UTF-16（带 BOM）都认 */
+function decodeText(buf) {
+  if (buf[0] === 0xff && buf[1] === 0xfe) return buf.subarray(2).toString('utf16le')
+  if (buf[0] === 0xfe && buf[1] === 0xff) return Buffer.from(buf.subarray(2)).swap16().toString('utf16le')
+  return buf.toString('utf8').replace(/^/, '')
+}
+
+async function pdfToText(buf) {
+  const { extractText, getDocumentProxy } = await import('unpdf')
+  const pdf = await getDocumentProxy(new Uint8Array(buf))
+  const { totalPages, text } = await extractText(pdf, { mergePages: false })
+  return { text: text.join('\n\n'), pages: totalPages, perPage: text.map(t => t.trim().length) }
+}
+
+/**
+ * @returns {Promise<{type:string, text:string, pages?:number, scanned?:boolean}>}
+ */
+export async function extractText(file, name = file) {
+  const ext = extname(name).toLowerCase()
+  if (!DOC_EXT.includes(ext)) throw Object.assign(new Error('不支持这种文件：可以导入 PDF、Word（.docx）、EPUB、网页（.html）、TXT、Markdown'), { status: 400 })
+  const buf = await readFile(file)
+  if (ext === '.pdf') {
+    const r = await pdfToText(buf)
+    // 每页平均不到 80 个字：多半是扫描版（整页是图片），读不出文字
+    const scanned = r.pages > 0 && r.text.replace(/\s/g, '').length / r.pages < 80
+    return { type: 'PDF', text: r.text, pages: r.pages, scanned }
+  }
+  if (ext === '.docx') return { type: 'Word', text: docxToText(buf) }
+  if (ext === '.epub') return { type: 'EPUB', text: epubToText(buf) }
+  if (ext === '.html' || ext === '.htm') return { type: '网页', text: htmlToText(decodeText(buf)) }
+  return { type: ext === '.txt' ? 'TXT' : 'Markdown', text: decodeText(buf) }
+}