@waterwx/dsh-novel-forge 1.3.1 → 1.3.2-alpha

package/src/review-policy.ts

@@ -0,0 +1,161 @@
+/**
+ * 审稿规则注册表
+ *
+ * 生成用 compact 模式（核心规则），审稿用 full 模式（全部规则），
+ * 消除 reviewSystemPrompt 内嵌规则与 renderAllAssets() 两套打架的问题。
+ */
+
+/** 通用写作资产规则（兼容 ProjectAssets 中的各类规则） */
+export interface WritingRule {
+  name: string
+  description: string
+  type?: string
+  enabled?: boolean
+}
+
+export interface ReviewRule {
+  id: string
+  /** 规则维度 */
+  dimension: 'character' | 'setting' | 'redline' | 'writing' | 'pacing' | 'logic' | 'anti-ai' | 'presentation' | 'compliance'
+  /** 严重度 */
+  severity: 'high' | 'medium' | 'low'
+  /** 规则类型：forbidden=禁止类（命中即问题），encourage=鼓励类（不命中不算错） */
+  type: 'forbidden' | 'encourage'
+  /** 规则描述 */
+  description: string
+  /** 是否启用 */
+  enabled: boolean
+  /** 作用域 */
+  scope: Array<'writing' | 'review' | 'polish' | 'all'>
+}
+
+/** 内置审稿维度（结构化评分用） */
+export const REVIEW_DIMENSIONS = [
+  { id: 'character', name: '人设一致性', weight: 0.2 },
+  { id: 'setting', name: '设定一致性', weight: 0.15 },
+  { id: 'redline', name: '红线检查', weight: 0.15 },
+  { id: 'writing', name: '文笔质量', weight: 0.15 },
+  { id: 'pacing', name: '节奏与爽点', weight: 0.1 },
+  { id: 'logic', name: '逻辑漏洞', weight: 0.1 },
+  { id: 'anti-ai', name: '反 AI 规则', weight: 0.05 },
+  { id: 'presentation', name: '呈现方式', weight: 0.05 },
+  { id: 'compliance', name: '内容合规', weight: 0.05 },
+] as const
+
+export type ReviewDimensionId = typeof REVIEW_DIMENSIONS[number]['id']
+
+/** 维度结构化评分 */
+export interface DimensionScore {
+  dimension: ReviewDimensionId
+  score: number // 0-100
+  note: string
+}
+
+/**
+ * 渲染审稿规则（compact 或 full 模式）
+ *
+ * compact: 只渲染禁止类 + high 严重度（用于生成时的约束）
+ * full: 渲染全部启用规则（用于审稿时的检查清单）
+ */
+export function renderReviewRules(
+  assets: WritingRule[] | undefined,
+  mode: 'compact' | 'full' = 'full',
+): string {
+  const lines: string[] = []
+
+  // 内置核心规则（所有模式都注入）
+  const coreRules = [
+    { dimension: 'character', desc: '角色行为符合角色卡设定（性格/目标/知情度/说话方式）' },
+    { dimension: 'setting', desc: '金手指规则、战力体系、世界观与道藏一致' },
+    { dimension: 'redline', desc: '不触犯本书写作红线' },
+    { dimension: 'compliance', desc: '不触犯内容合规红线（最高优先级）' },
+    { dimension: 'logic', desc: '无前后矛盾、时间线错误、对话失真' },
+    { dimension: 'presentation', desc: '不纯内心推理铺陈；反派有行动力；重要配角有辨识度' },
+  ]
+
+  if (mode === 'compact') {
+    lines.push('写作约束（核心规则）：')
+    for (const r of coreRules) {
+      lines.push(`- ${r.desc}`)
+    }
+  } else {
+    lines.push('审稿维度（逐条审查）：')
+    REVIEW_DIMENSIONS.forEach((d, i) => {
+      const core = coreRules.find(c => c.dimension === d.id)
+      lines.push(`${i + 1}. ${d.name}：${core?.desc ?? '按维度标准审查'}`)
+    })
+    lines.push('')
+    lines.push('反 AI 规则：逐条核对下方资产规则，命中即列为问题。')
+    lines.push('呈现方式：整章是否纯内心推理铺陈（无对话/无对抗）；反派是否纯背景板；重要配角是否无名标签化——命中即列为问题。')
+    lines.push('内容合规（最高优先级）：逐条核对合规红线，任何一条命中（含影射、暗示、详细描写）必须列为 high。')
+  }
+
+  // 注入用户自定义资产规则
+  if (assets !== undefined && assets.length > 0) {
+    const forbidden = assets.filter(a => a.type === 'forbidden' || a.type === 'rule')
+    const encourage = assets.filter(a => a.type === 'encourage' || a.type === 'style')
+    if (forbidden.length > 0) {
+      lines.push('')
+      lines.push('禁止类规则（命中即问题）：')
+      for (const a of forbidden) {
+        lines.push(`- ${a.name}：${a.description}`)
+      }
+    }
+    if (encourage.length > 0 && mode === 'full') {
+      lines.push('')
+      lines.push('鼓励类规则（不命中不算错，作为低优先级建议）：')
+      for (const a of encourage) {
+        lines.push(`- ${a.name}：${a.description}`)
+      }
+    }
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * 从审稿 issues 中按维度统计
+ * 用于结构化评分和 UI 展示。
+ */
+export function groupIssuesByDimension(
+  issues: Array<{ severity: string; item: string; dimension?: string }>,
+): Record<string, Array<{ severity: string; item: string }>> {
+  const result: Record<string, Array<{ severity: string; item: string }>> = {}
+  for (const issue of issues) {
+    const dim = issue.dimension ?? inferDimension(issue.item)
+    if (result[dim] === undefined) result[dim] = []
+    result[dim]!.push({ severity: issue.severity, item: issue.item })
+  }
+  return result
+}
+
+/** 根据问题描述推断维度（兼容旧报告，没有 dimension 字段时用） */
+function inferDimension(item: string): ReviewDimensionId {
+  if (/人设|角色|性格|口吻|知情|OOC/.test(item)) return 'character'
+  if (/设定|世界观|战力|金手指|规则|道藏/.test(item)) return 'setting'
+  if (/红线|后宫|擦边|碾压|圣母/.test(item)) return 'redline'
+  if (/语病|翻译腔|套话|文笔|流水账|AI/.test(item)) return 'writing'
+  if (/节奏|拖沓|灌水|爽点|钩子|悬念/.test(item)) return 'pacing'
+  if (/矛盾|时间线|逻辑|对话失真/.test(item)) return 'logic'
+  if (/合规|敏感|色情|暴力|政治|未成年/.test(item)) return 'compliance'
+  if (/内心推理|背景板|标签化|瘦高个|灰衣人/.test(item)) return 'presentation'
+  return 'writing'
+}
+
+/**
+ * 计算维度加权总分
+ * 用于审稿报告的结构化评分。
+ */
+export function calculateWeightedScore(
+  dimensions: DimensionScore[],
+): number {
+  let total = 0
+  let weightSum = 0
+  for (const d of dimensions) {
+    const def = REVIEW_DIMENSIONS.find(x => x.id === d.dimension)
+    const weight = def?.weight ?? 0.1
+    total += d.score * weight
+    weightSum += weight
+  }
+  return weightSum > 0 ? Math.round(total / weightSum) : 60
+}

package/src/revision.ts

@@ -0,0 +1,283 @@
+/**
+ * 修订指令合并层（arbitration）。
+ *
+ * 问题：审稿、时间线、张力三条通道各自给建议，如果各自改一轮，会出现「改完 A 又违反 B」
+ * 的互相打脸：同一章可能被改三遍，最后一轮的改动把第一轮的修正覆盖掉。
+ *
+ * 规则（与面板/生产单共享同一份实现，避免两头各写一套）：
+ *  1. 同一章只交付**一份**修订指令（本模块负责汇总，调用方不得自行拼装）。
+ *  2. 固定优先级，不做权重打分（可解释、可复现）：
+ *       0 审稿 high（必改，是硬门）
+ *       1 时间线 high（硬矛盾：时间倒流、地点瞬移）
+ *       2 张力 medium（曲线偏差，建议性最强）
+ *       3 其余（审稿 medium / 时间线 medium）
+ *       4 低优先（审稿 low）
+ *  3. 一次修订最多吃 REVISION_ITEM_CAP 条，超出按优先级截断；截断数量显式回传，不静默丢弃。
+ *  4. 每章修订轮次上限 MAX_REVISION_ROUNDS，超出转人工待办。
+ *  5. 验证基准 = 本轮实际下发的全部条目（审稿 + 时间线 + 张力），
+ *     这样「复核」核对的就是「我们要求改的东西」，而不是只核对审稿那部分。
+ */
+
+import type {
+  ProjectState,
+  ReviewIssue,
+  ReviewReport,
+  RevisionItem,
+  RevisionSource,
+  Severity,
+  TimelineIssue,
+  TensionIssue,
+} from './protocol.js'
+import { detectTimelineIssues } from './timeline.js'
+import { detectTensionIssues } from './tension.js'
+
+/** 每章修订轮次上限：两轮仍不过即转人工，不做「无限自动修改」。 */
+export const MAX_REVISION_ROUNDS = 2
+/** 单次修订指令最多携带的条目数（防止指令过长把正文挤出上下文）。 */
+export const REVISION_ITEM_CAP = 8
+
+export const REVISION_SOURCE_LABELS: Record<RevisionSource, string> = {
+  review: '审稿',
+  timeline: '时间线',
+  tension: '张力',
+}
+
+/** 固定优先级：数值越小越先改。 */
+export function revisionPriority(source: RevisionSource, severity: Severity): number {
+  if (source === 'review') return severity === 'high' ? 0 : severity === 'medium' ? 3 : 4
+  if (source === 'timeline') return severity === 'high' ? 1 : 3
+  // 张力只产出 medium（曲线偏差是建议，不是违规）。
+  return severity === 'high' ? 2 : 2
+}
+
+/** 同优先级的来源次序：审稿 > 时间线 > 张力（同级时先改让本章"判不过"的那一类）。 */
+const SOURCE_RANK: Record<RevisionSource, number> = { review: 0, timeline: 1, tension: 2 }
+
+/**
+ * 条目在**来源内部**的原始序号（id 末段）。
+ * 必须按数值比较：字符串比较会得到 0,1,10,11,2… 的顺序，
+ * 于是截断时先丢「第 3 条意见」却留下「第 11 条」——等于把靠前的意见丢了。
+ */
+function sequenceOf(item: RevisionItem): number {
+  const tail = item.id.slice(item.id.lastIndexOf(':') + 1)
+  const n = Number.parseInt(tail, 10)
+  return Number.isFinite(n) ? n : 0
+}
+
+/** 去重键：同源 + 归一化问题描述（忽略空白与标点差异）。 */
+function dedupeKey(item: RevisionItem): string {
+  return `${item.source}|${item.item.replace(/[\s，。、；：,.!?！？"'"'（）()【】\[\]]/g, '').slice(0, 60)}`
+}
+
+/** 排序 + 去重 + 截断。去重时保留优先级更高的那条，并累加 count。 */
+export function mergeRevisionItems(
+  items: RevisionItem[],
+  cap = REVISION_ITEM_CAP,
+): { items: RevisionItem[]; omitted: number } {
+  const sorted = [...items].sort((a, b) => {
+    const byPriority = revisionPriority(a.source, a.severity) - revisionPriority(b.source, b.severity)
+    if (byPriority !== 0) return byPriority
+    if (a.chapterNo !== b.chapterNo) return a.chapterNo - b.chapterNo
+    if (a.source !== b.source) return SOURCE_RANK[a.source] - SOURCE_RANK[b.source]
+    const bySequence = sequenceOf(a) - sequenceOf(b)
+    if (bySequence !== 0) return bySequence
+    return a.id.localeCompare(b.id)
+  })
+  const seen = new Map<string, RevisionItem>()
+  const unique: RevisionItem[] = []
+  for (const item of sorted) {
+    const key = dedupeKey(item)
+    const dup = seen.get(key)
+    if (dup !== undefined) {
+      dup.count = (dup.count ?? 1) + 1
+      continue
+    }
+    seen.set(key, item)
+    unique.push(item)
+  }
+  const kept = unique.slice(0, cap)
+  return { items: kept, omitted: Math.max(0, unique.length - kept.length) }
+}
+
+/** 时间线/张力问题是否落在目标章上（chapters 为空视为全书级，跟随目标章）。 */
+function matchesChapter(chapters: number[] | undefined, target: number | undefined): boolean {
+  if (target === undefined) return true
+  const list = chapters ?? []
+  if (list.length === 0) return true
+  return list.includes(target)
+}
+
+function pickChapterNo(chapters: number[] | undefined, target: number | undefined, fallback: number): number {
+  if (target !== undefined && matchesChapter(chapters, target)) return target
+  return chapters?.[0] ?? fallback
+}
+
+function timelineToItems(issues: TimelineIssue[], target: number | undefined): RevisionItem[] {
+  const out: RevisionItem[] = []
+  issues.forEach((issue, i) => {
+    if (!matchesChapter(issue.chapters, target)) return
+    out.push({
+      id: `timeline:${i}:${pickChapterNo(issue.chapters, target, 0)}`,
+      source: 'timeline',
+      severity: issue.severity,
+      chapterNo: pickChapterNo(issue.chapters, target, 0),
+      item: issue.item,
+      suggestion: issue.suggestion,
+    })
+  })
+  return out
+}
+
+function tensionToItems(issues: TensionIssue[], target: number | undefined): RevisionItem[] {
+  const out: RevisionItem[] = []
+  issues.forEach((issue, i) => {
+    if (!matchesChapter(issue.chapters, target)) return
+    out.push({
+      id: `tension:${i}:${pickChapterNo(issue.chapters, target, 0)}`,
+      source: 'tension',
+      severity: issue.severity,
+      chapterNo: pickChapterNo(issue.chapters, target, 0),
+      item: issue.item,
+      suggestion: issue.suggestion,
+    })
+  })
+  return out
+}
+
+export interface RevisionCollectOptions {
+  /** 目标章；缺省表示全书（用于整本批量修订）。 */
+  chapterNo?: number
+  /** 显式指定的审稿意见；缺省取该章已落盘的审稿报告。 */
+  reviewIssues?: ReviewIssue[]
+  /** 是否纳入时间线矛盾（默认纳入）。 */
+  includeTimeline?: boolean
+  /** 是否纳入张力偏差（默认纳入）。 */
+  includeTension?: boolean
+}
+
+/** 汇总一章（或全书）的三类建议。纯函数，不改项目状态。 */
+export function collectRevisionItems(project: ProjectState, options: RevisionCollectOptions = {}): RevisionItem[] {
+  const target = options.chapterNo
+  const items: RevisionItem[] = []
+  const chapters = (project.chapters ?? []).filter(c => target === undefined || c.no === target)
+
+  const explicit = options.reviewIssues
+  if (explicit !== undefined) {
+    explicit.forEach((issue, i) => {
+      items.push({
+        id: `review:${target ?? 0}:${i}`,
+        source: 'review',
+        severity: issue.severity,
+        chapterNo: target ?? 0,
+        item: issue.item,
+        suggestion: issue.suggestion,
+      })
+    })
+  } else {
+    for (const chapter of chapters) {
+      for (const [i, issue] of (chapter.review?.issues ?? []).entries()) {
+        items.push({
+          id: `review:${chapter.no}:${i}`,
+          source: 'review',
+          severity: issue.severity,
+          chapterNo: chapter.no,
+          item: issue.item,
+          suggestion: issue.suggestion,
+        })
+      }
+    }
+  }
+
+  if (options.includeTimeline ?? true) items.push(...timelineToItems(detectTimelineIssues(project), target))
+  if (options.includeTension ?? true) items.push(...tensionToItems(detectTensionIssues(project), target))
+  return items
+}
+
+export interface RevisionPlan {
+  /** 已排序、去重、截断后的条目。 */
+  items: RevisionItem[]
+  /** 下发给模型的修订指令（唯一入口，调用方不要自行拼装）。 */
+  instruction: string
+  counts: Record<RevisionSource, number>
+  /** 因超出上限被截断的条数（显式回传，便于提示作者）。 */
+  omitted: number
+  /** 验证基准：把本轮下发的全部条目当作「上一轮意见」，复核时逐条核对。 */
+  baseline: ReviewReport
+}
+
+export interface BuildRevisionPlanOptions extends RevisionCollectOptions {
+  /** 审稿基线报告（提供后 baseline 会保留其分数与时间）。 */
+  baseReport?: ReviewReport
+  /** 指令抬头（默认「按合并建议修订」）。 */
+  title?: string
+  cap?: number
+}
+
+/** 渲染修订指令。格式与历史「按审稿意见修订」保持同族，模型无需重新学习。 */
+export function renderRevisionInstruction(items: RevisionItem[], title = '按合并建议修订'): string {
+  const counts: Record<RevisionSource, number> = { review: 0, timeline: 0, tension: 0 }
+  for (const item of items) counts[item.source] += item.count ?? 1
+  const header = `（审稿 ${counts.review} · 时间线 ${counts.timeline} · 张力 ${counts.tension}）`
+  const lines = items.map(item => {
+    const tag = `【${REVISION_SOURCE_LABELS[item.source]}·${item.severity}】`
+    const where = item.chapterNo > 0 ? `第${item.chapterNo}章 ` : ''
+    const repeat = (item.count ?? 1) > 1 ? `（合并同类 ${item.count} 条）` : ''
+    const suggestion = item.suggestion.trim() === '' ? '' : `\n建议：${item.suggestion.trim()}`
+    return `${tag}${where}${item.item}${repeat}${suggestion}`
+  })
+  return `${title}${header}：\n${lines.join('\n')}`
+}
+
+/**
+ * 构造验证基准：把时间线/张力条目转成「上一轮意见」的编号项，
+ * 与审稿意见合并成一份报告。复核模型据此逐条核对，避免
+ * 「审稿说已解决、时间线说没改」这类互相打架的判定。
+ */
+export function buildRevisionBaseline(items: RevisionItem[], base?: ReviewReport): ReviewReport {
+  const issues: ReviewIssue[] = items.map(item => ({
+    severity: item.severity,
+    item: item.source === 'review' ? item.item : `[${REVISION_SOURCE_LABELS[item.source]}] ${item.item}`,
+    suggestion: item.suggestion,
+  }))
+  return {
+    score: base?.score ?? 0,
+    passed: false,
+    verdict: base?.verdict ?? '本轮修订基准',
+    issues,
+    riskScore: base?.riskScore,
+    aiFlavor: base?.aiFlavor,
+    aiPhrases: base?.aiPhrases,
+    reviewedAt: base?.reviewedAt ?? new Date().toISOString(),
+  }
+}
+
+/** 汇总 → 排序 → 指令 → 基准。面板与生产单都走这里。 */
+export function buildRevisionPlan(project: ProjectState, options: BuildRevisionPlanOptions = {}): RevisionPlan {
+  const collected = collectRevisionItems(project, options)
+  const merged = mergeRevisionItems(collected, options.cap ?? REVISION_ITEM_CAP)
+  const counts: Record<RevisionSource, number> = { review: 0, timeline: 0, tension: 0 }
+  for (const item of merged.items) counts[item.source] += item.count ?? 1
+  return {
+    items: merged.items,
+    instruction: renderRevisionInstruction(merged.items, options.title),
+    counts,
+    omitted: merged.omitted,
+    baseline: buildRevisionBaseline(merged.items, options.baseReport),
+  }
+}
+
+/** 一行摘要，用于日志与面板提示（"审稿 3 · 时间线 1 · 张力 1，另截断 2 条"）。 */
+export function describeRevisionPlan(plan: RevisionPlan): string {
+  const parts: string[] = []
+  if (plan.counts.review > 0) parts.push(`审稿 ${plan.counts.review}`)
+  if (plan.counts.timeline > 0) parts.push(`时间线 ${plan.counts.timeline}`)
+  if (plan.counts.tension > 0) parts.push(`张力 ${plan.counts.tension}`)
+  const head = parts.length === 0 ? '无可修订条目' : parts.join(' · ')
+  return plan.omitted > 0 ? `${head}（另截断 ${plan.omitted} 条）` : head
+}
+
+/** 待办文本（生产单只提示不阻塞时写入项目待办，供作者人工决定）。 */
+export function revisionTodoText(item: RevisionItem): string {
+  const where = item.chapterNo > 0 ? `第${item.chapterNo}章` : '全书'
+  return `[${REVISION_SOURCE_LABELS[item.source]}] ${where}：${item.item}`
+}