dsh-novel-writer 6.4.0 → 6.5.0

package/cordis.patch.yml

@@ -1,4 +1,4 @@
-# dsh-novel-writer v6.3.0 bundle patch: 19 tools (incl. novel_semantic_search, novel_lexicon) + local embedding engine.
+# dsh-novel-writer bundle patch: 19 tools (incl. novel_semantic_search, novel_lexicon) + local embedding engine.
 # dsh-novel-writer bundle patch: mounts the novel-writing assistant plugin
 # into the profile's loader tree. The entry's name is the plugin package
 # itself, resolved from the profile's node_modules.

package/lib/core.js

@@ -17,6 +17,7 @@ import { createRequire } from "node:module";
 import { checkForUpdate } from "./update-check.js";
 import { computeBaseline, computeBaselineFromPerChapter, measureStyleMetrics, METRIC_LABELS, METRIC_ORDER } from "./style-metrics.js";
 import { CULTURE_MARKERS, GENRE_MARKERS, THEME_MARKERS, DEFAULT_BANNED_WORDS, SPEECH_STYLE_RULES } from "./lexicons/markers.js";
+import { COLLISION_GUARDS } from "./lexicons/guards.js";
 // v5.0.0：系统提示词的「场景」枚举由 prompts.js 单一持有（core.js 只做合法性校验与持久化）
 import { PROMPT_SCENES } from "./prompts.js";
 import * as embedding from "./embedding.js";
@@ -2593,7 +2594,10 @@ export function normalizeSettingEntry(entry) {
   for (const key of ["description", "traits", "relationships", "firstSeen", "notes", "owner", "status", "lastSeen", "day", "event", "chapter", "basis", "ritual"]) {
     if (entry[key] !== void 0 && entry[key] !== null) out[key] = String(entry[key]);
   }
-  for (const key of ["alias", "bannedWords"]) {
+  // v6.5.0：`allowWords`（本书用词豁免）必须进这个白名单——否则它写盘生效、静音也生效，
+  // 但 add/list/scan/detect 的**返回体里看不到它**，用户无从核对自己到底豁免了什么
+  // （独立核对子代理实测：写盘完整、审计静音正常，而返回值里只有条目名）。
+  for (const key of ["alias", "bannedWords", "allowWords"]) {
     if (Array.isArray(entry[key])) out[key] = entry[key].map(String);
   }
   if (entry.recommended !== void 0 && entry.recommended !== null && typeof entry.recommended === "object") {
@@ -2678,7 +2682,7 @@ export function hintCulture(text) {
  *            userBannedWords:string[], defaultEnabled:boolean,
  *            sources:{userCount:number, defaultCount:number, total:number, hint:string|null}}}
  */
-export function resolveStyleRule(settings, chapterTexts = []) {
+export function resolveStyleRule(settings, chapterTexts = [], opts = {}) {
   const worldviewList = Array.isArray(settings?.worldview) ? settings.worldview.filter((e) => e && typeof e === "object") : [];
   const reversed = worldviewList.slice().reverse();
 
@@ -2760,6 +2764,34 @@ export function resolveStyleRule(settings, chapterTexts = []) {
   // 替代词：用户登记的优先（放后面覆盖）
   const recommended = { ...(defaultEnabled ? base.recommended : {}), ...userRecommended };
 
+  // ⑥ v6.5.0：**逐词静音**（本书豁免）。
+  //
+  // 解决什么问题：词表是"猜"这本书的。但有些词在**这本书里就是对的**——
+  // 修仙小说里的「修士」＝修行者（语料 308 次全是这个义）、中文历史小说里真有一座「教堂」。
+  // 此前用户**没有任何办法**告诉插件"这个我知道"：只能每次手动忽略（下次还报）、
+  // 或关掉整个用语检查（别的词也不查了）、或把词从表里删掉（**所有书**都不查了，影响面过大）。
+  //
+  // 静音只作用于**本书**（不提供全局静音）：全局静音会静默削弱所有书的覆盖，
+  // 而人很难记得自己什么时候加过；按书静音最坏只是"这本书里漏"，看得见、摸得着。
+  //
+  // 过滤放在本函数（**单一裁决点**）而不是各消费方——这样开写包 / 审计 / 改稿台
+  // 四个入口自动一致，不会出现"审计静音了但开写包还在警告"的分裂。
+  const allow = new Set([
+    ...(Array.isArray(opts?.allowWords) ? opts.allowWords : []),
+    // 用户登记的豁免：worldview 条目上的 allowWords（并集）。
+    // 复用既有表而不是新开一张，这样 `novel_settings add category=worldview name="用词豁免"
+    // allowWords=["修士"]` 就能静音，且**没有登记过 worldview 的书**也能用（加这一条即可）。
+    // 该条目的 name 不含文化标记词，故不会影响 hintCulture 的基准判定。
+    ...worldviewList.flatMap((e) => (Array.isArray(e.allowWords) ? e.allowWords : []))
+  ].map((w) => String(w ?? "").trim()).filter((w) => w !== ""));
+  const bannedWords = allow.size > 0 ? merged.filter((w) => !allow.has(w)) : merged;
+  const speechStyleFiltered = (() => {
+    if (allow.size === 0 || !speechStyle) return speechStyle;
+    const out = { ...speechStyle };
+    if (Array.isArray(out.honorBad)) out.honorBad = out.honorBad.filter((w) => !allow.has(w));
+    return out;
+  })();
+
   const cultureName = String(bannedEntry?.name ?? "") || String(speechEntry?.name ?? "") || base.culture;
   // 语用规范条目名：沿用 index.js 既有口径（speechEntry.name 优先，缺则回落 cultureName）
   const speechCultureName = String(speechEntry?.name ?? "") || cultureName;
@@ -2768,16 +2800,19 @@ export function resolveStyleRule(settings, chapterTexts = []) {
     cultureSource,
     cultureName,
     speechCultureName,
-    bannedWords: merged,
+    bannedWords,
     recommended,
-    speechStyle,
+    speechStyle: speechStyleFiltered,
     userBannedWords,
     defaultEnabled,
     registered: worldviewList.length > 0,
+    // v6.5.0：把静音结果一并回传——审计文案要能说清"为什么少报了几条"
+    allowedWords: [...allow],
     sources: {
       userCount: userBannedWords.length,
       defaultCount: defaultEnabled ? base.bannedWords.length : 0,
-      total: merged.length,
+      total: bannedWords.length,
+      muted: merged.length - bannedWords.length,
       hint: hint ? hint.culture : null
     }
   };
@@ -3091,6 +3126,328 @@ export async function readBookAllText(root, book, exec, opts) {
   // v3.9.5：opts.withTexts=true 时一并返回逐章文本，供 style_report 六维基线复用（避免全书二次读盘）
   return opts?.withTexts === true ? { text, chapters, texts } : { text, chapters };
 }
+// ============ v6.5.0：用语审计的**定位**与**子串守卫**与**正则安全** ============
+
+/**
+ * 找出包含 needle 的**全部行号**（升序、去重）。
+ *
+ * 行号口径 = **该文件内的真实行号**。这一条有历史教训（见 index.js 里那段
+ * "旧实现把各章首尾拼成一份文本再取行号，报出的 Lx 既不是任何文件的真实行号、也不带章名"）：
+ * 必须先**逐章**取行号，再带章名合并；绝不可把多章拼成一份文本后取偏移。
+ */
+export function linesContaining(rawLines, needle) {
+  const out = [];
+  if (!needle || !Array.isArray(rawLines)) return out;
+  for (let i = 0; i < rawLines.length; i += 1) {
+    if (rawLines[i].includes(needle)) out.push(i + 1);
+  }
+  return out;
+}
+
+/**
+ * 行号数组 → 区间数组（合并相邻/近邻行，避免"第2行，第3行，第5行"这种啰嗦输出）。
+ * `gap` = 允许合并的最大行距：0 表示仅相邻行合并；1 表示隔一行也并进来。
+ * [2,3,5,6,7] gap=0 → [{from:2,to:3},{from:5,to:7}]
+ */
+export function mergeLineRanges(lineNos, gap = 0) {
+  const sorted = [...new Set((Array.isArray(lineNos) ? lineNos : [])
+    .filter((n) => Number.isInteger(n) && n > 0))].sort((a, b) => a - b);
+  const out = [];
+  for (const n of sorted) {
+    const last = out[out.length - 1];
+    if (last && n - last.to <= gap + 1) last.to = n;
+    else out.push({ from: n, to: n });
+  }
+  return out;
+}
+
+/** 区间 → 「第2-10行，第52行」；超出 max 段则截断并注明总段数。 */
+export function formatLineRanges(ranges, max = 8) {
+  const list = Array.isArray(ranges) ? ranges : [];
+  if (list.length === 0) return "";
+  const seg = (r) => "第" + (r.from === r.to ? r.from : r.from + "-" + r.to) + "行";
+  const head = list.slice(0, max).map(seg).join("，");
+  return list.length > max ? head + "，等 " + list.length + " 段" : head;
+}
+
+/**
+ * 该命中是否为**子串巧合**（应当忽略）。
+ *
+ * 判据极简且可审计：词**紧邻的前/后一个字**是否落在守卫表里。
+ * 例：「这[里正]是」的前一字是「这」→ 巧合；「[在下]面」的后一字是「面」→ 巧合。
+ *
+ * 纪律：**错填会吃掉真命中**（静默漏报），所以守卫表只收有实证的字（见 lexicons/guards.js）。
+ */
+export function isGuardedArtifact(word, line, index) {
+  const g = COLLISION_GUARDS[word];
+  if (!g || typeof line !== "string" || !Number.isInteger(index) || index < 0) return false;
+  // ① 单字邻接（最常见：这里+正是 / 在+下面 / 大+人物）
+  if (Array.isArray(g.notBefore) && index > 0) {
+    const before = line[index - 1];
+    if (before && g.notBefore.includes(before)) return true;
+  }
+  if (Array.isArray(g.notAfter)) {
+    const after = line[index + word.length];
+    if (after && g.notAfter.includes(after)) return true;
+  }
+  // ② 多字序列（单字判不到的：如「老夫老妻」——匹配后紧跟的是「老」，而「老夫老矣」是真用法，
+  //    故不能简单把「老」放进 notAfter，必须判完整的「老妻」序列）
+  if (Array.isArray(g.notAfterSeq)) {
+    for (const s of g.notAfterSeq) {
+      if (typeof s === "string" && s !== "" && line.startsWith(s, index + word.length)) return true;
+    }
+  }
+  if (Array.isArray(g.notBeforeSeq)) {
+    for (const s of g.notBeforeSeq) {
+      if (typeof s === "string" && s !== "" && index >= s.length && line.slice(index - s.length, index) === s) return true;
+    }
+  }
+  return false;
+}
+
+/** 从模式里挑几个字面字符做探针输入（最多 max 个，含中英文与数字）。 */
+function pickProbeChars(pattern, max = 4) {
+  const out = [];
+  for (const ch of String(pattern ?? "")) {
+    if (/[\u4e00-\u9fffA-Za-z0-9]/.test(ch) && !out.includes(ch)) out.push(ch);
+    if (out.length >= max) break;
+  }
+  if (out.length === 0) out.push("a", "1");
+  return out;
+}
+
+/** 跑一次模式，返回毫秒（异常返回 -1）。 */
+function timeRegex(pattern, input) {
+  const t0 = process.hrtime.bigint();
+  try {
+    new RegExp(pattern, "g").test(input);
+  } catch {
+    return -1;
+  }
+  return Number(process.hrtime.bigint() - t0) / 1e6;
+}
+
+/**
+ * **深度感知**扫描出「分组 + 紧跟的限定符」。
+ *
+ * 为什么不能用正则做这件事：`[^()\\]` 这类字符类**匹配不了嵌套的括号**，
+ * 于是 `((a)*)*` 这种「括号套括号」的形态会被整体漏掉——独立验证代理找出的 8 个漏网模式里，
+ * 就有 2 个正是这样躲过去的。所以这里手写一个小扫描器（栈 + 跳过转义与字符类）。
+ */
+function scanGroups(pattern) {
+  const out = [];
+  const stack = [];
+  const p = String(pattern ?? "");
+  for (let i = 0; i < p.length; i += 1) {
+    const ch = p[i];
+    if (ch === "\\") { i += 1; continue; }
+    if (ch === "[") {
+      // 跳过整个字符类（内部的 \] 不算结束）
+      i += 1;
+      while (i < p.length && p[i] !== "]") { if (p[i] === "\\") i += 1; i += 1; }
+      continue;
+    }
+    if (ch === "(") { stack.push(i); continue; }
+    if (ch === ")") {
+      const start = stack.pop();
+      if (start === undefined) continue;
+      const q = p.slice(i + 1).match(/^(?:[+*]|\{\d+,?\d*\})/);
+      out.push({ start, end: i, inner: p.slice(start + 1, i), quant: q ? q[0] : "" });
+    }
+  }
+  return out;
+}
+
+/** 分组内的分支是否**可能重叠**（任两个分支首字符相同即视为重叠，如 (a|a)）。 */
+function hasOverlappingAlternation(inner) {
+  const alts = String(inner ?? "").split("|");
+  if (alts.length < 2) return false;
+  const heads = alts.map((a) => a.replace(/^\^/, "").slice(0, 1)).filter((h) => h !== "");
+  return new Set(heads).size < heads.length;
+}
+
+/** 同一个原子被**两个以上无界量词**修饰（如 a*a* / [一二三]+[一二三]*）→ 多项式级回溯。 */
+function hasRepeatedUnboundedAtom(pattern) {
+  const p = String(pattern ?? "");
+  const counts = new Map();
+  const re = /(\\.|\[(?:\\.|[^\]\\])*\]|[A-Za-z0-9\u4e00-\u9fff])([+*])/g;
+  let m = null;
+  while ((m = re.exec(p)) !== null) {
+    const atom = m[1];
+    counts.set(atom, (counts.get(atom) || 0) + 1);
+  }
+  for (const n of counts.values()) if (n >= 2) return true;
+  return false;
+}
+
+/**
+ * **经验探测**：把模式在**短对抗输入**上跑两遍，用耗时增长判定是否存在指数回溯。
+ *
+ * 为什么不能只靠形状黑名单：独立验证代理实测 8 个形状（`(a|a)*b`、`(香|香)*上`、`(a{0,10}){0,10}b`、
+ * `a*a*…*b`、`((a)*)*b`、`(?:a|a)*b` …）**全部绕过了最初的嵌套量词检查**，而它们在 30 字输入上要跑 7.5 秒、
+ * 33 字上超过 45 秒。形状枚举永远追不上——**必须实测**。
+ *
+ * 为什么探测本身不会挂住：指数回溯的代价随长度**指数增长**，而 n=18/22 时最坏也只有 2^21 ≈ 2×10^6 步
+ * （实测同类模式 20 字 ~10ms、24 字 ~120ms、30 字 7.5 秒）。所以短输入上探测是安全的，
+ * 而线性模式的耗时是**微秒级**——两者差三四个数量级，判定极稳。
+ *
+ * 两个判据取其一即拒绝：**22 字耗时 ≥ 5ms**（绝对量级），或 **22 字/18 字增长 ≥ 4 倍**（增长形态）。
+ * 用两条是因为首次测量会含正则编译开销（约 1~3ms），会稀释比值——绝对量级那条把它兜住。
+ *
+ * **已知残留（如实记录）**：多项式级（如 5 个以上 `a*` 串联）在 22 字下确实很快（<1ms），
+ * 本探测抓不到，靠 `hasRepeatedUnboundedAtom` 的结构检查兜。但**两者都不是完备的**——
+ * 理论上仍存在既非指数、又无重复原子、却在长文本上很慢的模式。故运行期还有第三道：逐句扫描 + 长度上限。
+ */
+function probeReDoS(pattern) {
+  let worstMs = 0;
+  let worstRatio = 0;
+  let sample = "";
+  for (const ch of pickProbeChars(pattern)) {
+    const t18 = timeRegex(pattern, ch.repeat(18));
+    const t22 = timeRegex(pattern, ch.repeat(22));
+    if (t18 < 0 || t22 < 0) return { worstMs: 0, worstRatio: 0, sample: ch, failed: true };
+    const ms = Math.max(t18, t22);
+    if (ms > worstMs) { worstMs = ms; sample = ch; }
+    if (t18 >= 1 && t22 >= 1) {
+      const ratio = t22 / t18;
+      if (ratio > worstRatio) worstRatio = ratio;
+    }
+  }
+  return { worstMs, worstRatio, sample, failed: false };
+}
+
+/**
+ * 正则**安全校验**（静态 + 经验，登记时用）。
+ *
+ * 为什么必须有：用户登记的语用模式会被 `new RegExp(p, "g")` 原样编译并执行，
+ * 而 Node 的同步正则**无法中断**——不能在运行期"跑 50ms 就掐掉"。
+ * 实测（29 字符输入）：`/(上+)+香/` 18.4 秒、`/(上*)*香/` **40.8 秒**、`/上{0,20}香/` 0.05 毫秒。
+ * 也就是说一个写法有毒的模式能让宿主长时间无响应，而它只是"世界观里的一条仪式禁式"。
+ *
+ * 三层：① 形状黑名单（嵌套量词 / 量词套在含分支的分组上 / 无界通配）
+ *       ② **经验探测**（形状枚举追不上的那些，靠实测耗时增长抓）
+ *       ③ 运行期逐句扫描（把跨句与单次输入规模限住，见 splitSentences）
+ *
+ * @returns {{ok: boolean, level: "ok"|"warn"|"reject", reason: string, suggestion: string}}
+ */
+export function validatePattern(pattern) {
+  const p = typeof pattern === "string" ? pattern : "";
+  if (p.trim() === "") return { ok: false, level: "reject", reason: "模式为空", suggestion: "" };
+  if (p.length > 200) {
+    return { ok: false, level: "reject", reason: "模式超过 200 字符上限", suggestion: "拆成多条更短的模式" };
+  }
+  try {
+    new RegExp(p, "g");
+  } catch (e) {
+    return { ok: false, level: "reject", reason: "正则语法错误：" + String(e && e.message || e).slice(0, 120), suggestion: "检查括号与转义是否配对" };
+  }
+
+  // ①-a / ①-b 分组上的量词：用**深度感知扫描**（正则匹配不了嵌套括号，会漏掉 ((a)*)* 这类）
+  //   · 分组内含**量词** + 外层有量词 → 嵌套重复（(x+)+ / ((a)*)* / (a{0,10}){0,10}）
+  //   · 分组内含**可能重叠的分支** + 外层有量词 → 重叠分支回溯（(a|a)* / (香|香)*）
+  //     注意 (上|下)+ 这种**不重叠**的分支是安全的，不误拒（判据：任两分支首字符是否相同）
+  for (const g of scanGroups(p)) {
+    if (!g.quant) continue;
+    const innerHasQuant = /[+*]|\{\d+,?\d*\}/.test(g.inner);
+    if (innerHasQuant) {
+      const atom = g.inner.replace(/[+*]|\{\d+,?\d*\}/g, "").replace(/[()]/g, "");
+      const demo = atom ? atom + "{0,20}" : "把内层量词改成有界（如 {0,20}）";
+      return {
+        ok: false, level: "reject",
+        reason: "量词套在含量词的分组上（嵌套重复），会造成指数级回溯——实测同类模式在 29 字符上要跑 40 秒",
+        suggestion: "把内层重复改成有界量词，例如 " + demo + "；或去掉外层的重复"
+      };
+    }
+    if (hasOverlappingAlternation(g.inner)) {
+      return {
+        ok: false, level: "reject",
+        reason: "量词套在**分支重叠**的分组上（如 (a|a)*），会造成指数级回溯——实测同类模式在 30 字符上要跑 7.5 秒",
+        suggestion: "合并重复的分支（(a|a) → a），或把外层量词改成有界（如 {0,20}）"
+      };
+    }
+  }
+
+  // ①-c 同一原子被两个以上无界量词修饰：a*a*…*b 属**多项式**级回溯，
+  //      在 22 字下确实很快（<1ms），经验探测抓不到，但长文本上仍会炸（n^6 量级）
+  if (hasRepeatedUnboundedAtom(p)) {
+    return {
+      ok: false, level: "reject",
+      reason: "同一个原子被两个以上无界量词修饰（如 a*a*a*），长文本上会造成多项式级回溯",
+      suggestion: "合并成一个有界量词，例如 a*a* → a{0,20}"
+    };
+  }
+
+  // ①-d 无界通配：跨句匹配（审计是整章文本，会跨越句号与换行）
+  if (/\.\*|\[\\s\\S\]\*|\[\\s\\S\]\+|\.\{\d+,\}/.test(p)) {
+    return {
+      ok: false, level: "reject",
+      reason: "无界通配（.* / [\\s\\S]* 等）会跨越句号与换行，把不相干的上下文连起来误报",
+      suggestion: "改成句内且有界的间隔，例如 .* → [^。！？\\n]{0,20}"
+    };
+  }
+
+  // ② 经验探测（形状枚举追不上的那些，靠实测抓）
+  const probe = probeReDoS(p);
+  if (probe.failed) {
+    return { ok: false, level: "reject", reason: "模式在执行时抛错，无法用于扫描", suggestion: "检查模式的转义与分组" };
+  }
+  if (probe.worstMs >= 5 || (probe.worstRatio >= 4 && probe.worstMs >= 1)) {
+    return {
+      ok: false, level: "reject",
+      reason: "实测该模式存在回溯爆炸（对抗输入 22 字耗时 " + probe.worstMs.toFixed(1) + "ms" +
+        (probe.worstRatio >= 4 ? "、增长 " + probe.worstRatio.toFixed(1) + " 倍" : "") + "），长文本上会让检查长时间卡住",
+      suggestion: "把重复改成有界量词（如 {0,20}）、去掉重叠的分支（(a|a) → a）、或避免量词套量词"
+    };
+  }
+
+  // ③ 顶层无界重复：线性但不封顶，长文本上代价不可控
+  if (/\{\d+,\}/.test(p)) {
+    return {
+      ok: false, level: "warn",
+      reason: "存在无上界的重复次数（{n,}），长文本上代价不可控",
+      suggestion: "给出上界，例如 {1,} → {1,20}"
+    };
+  }
+
+  // ④ 边界锚：本审计是"在正文里找可疑片段"，锚定整串的模式几乎必然匹配不到
+  if (/^\^|\$$/.test(p)) {
+    return { ok: false, level: "warn", reason: "模式带有整串锚定（^ / $），在正文扫描里通常匹配不到", suggestion: "去掉 ^ 与 $，或改用更小的片段作为模式" };
+  }
+
+  return { ok: true, level: "ok", reason: "", suggestion: "" };
+}
+
+/**
+ * 把章节文本切成**句级**片段（正则扫描的单位）。
+ *
+ * 为什么必须逐句：模式若含 `.` 类通配，在整章文本上会跨越句号与换行——
+ * 实测 `/上.*香/` 在一段 121 字的文本上命中了 115 字（跨 3 句）。逐句后这种跨句在结构上不可能。
+ * 同时它把单次匹配的输入规模限住，是 ReDoS 的第二道防线（第一道是 validatePattern 的静态+经验校验）。
+ *
+ * 超长"句子"（无标点的长段落）按 `hardLimit` 硬切。**硬切必须带重叠**：
+ * 独立验证代理实测，不带重叠时「上……香 相距 6 字但跨过 1000 字切点」的那条命中**整条丢失**
+ * （对照组正常命中）。重叠 `overlap` 字即可让跨切点的模式在相邻窗口里被完整看到；
+ * 重复命中由调用方按行号去重（locations 是行号区间，天然去重）。
+ *
+ * 上限从 1000 收到 400：句子通常远短于此，而更小的单位让"万一漏过校验的有毒模式"
+ * 也炸不起来（同步正则无法中断，只能靠限制输入规模）。
+ */
+export function splitSentences(text, hardLimit = 400, overlap = 32) {
+  const src = typeof text === "string" ? text : "";
+  if (src === "") return [];
+  const step = Math.max(1, hardLimit - overlap);
+  const out = [];
+  for (const raw of src.split(/(?<=[。！？!?；;\n])/)) {
+    if (raw === "") continue;
+    if (raw.length <= hardLimit) { out.push(raw); continue; }
+    for (let i = 0; i < raw.length; i += step) {
+      out.push(raw.slice(i, i + hardLimit));
+      if (i + hardLimit >= raw.length) break;
+    }
+  }
+  return out;
+}
+
 export async function buildStyleAnchorPackage(root, book, chapters, exec, preloadedText) {
   // v4.3.0 修正：预读文本是必需契约（root/book/chapters 形参保留仅为兼容 index.js 的位置调用，函数内已不用）。
   // 选择"删除磁盘兜底 + assert"而不是"补测试覆盖"：唯一可达的兜底场景是 preloadedText === ""（整本书都是