@waterwx/dsh-novel-forge 1.1.8 → 1.2.0-alpha

package/src/run.ts

@@ -0,0 +1,342 @@
+/**
+ * 生产单（Production Run）：批量章节生产的标准执行器。
+ * 职责：计划补足 → 逐章生成（完整质量门）→ 被拒分级处理（豁免/修订+验证/待人工）→ 断点续跑。
+ * 与路由层解耦：只依赖 engine 导出函数与磁盘状态，自身不碰 HTTP。
+ * 串行纪律：单例执行器 + working 锁；每章重新从磁盘加载，写前合并易变字段。
+ */
+import { existsSync, mkdirSync, readFileSync, copyFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { Context } from '@deepseek-ai/cordis'
+import type { ChapterPlan, NovelConfig, ProjectState, ReviewReport, RunState } from './protocol.ts'
+import {
+  loadProject,
+  saveProject,
+  mergeVolatileFromDisk,
+  planChapters,
+  generateChapterStream,
+  summarizeAndExtractFacts,
+  markForeshadowPlanted,
+  reviewChapter,
+  reviewChapterText,
+  authorReviewChapter,
+  autoLinkPlotlines,
+  readChapterFile,
+  rewriteChapterStream,
+  chapterFileName,
+} from './engine.ts'
+import { countHanzi } from './engine.ts'
+import { loadBookshelf } from './bookshelf.ts'
+
+/** 生产单 checkpoint 文件名（放在书目录下）。 */
+function runStateFile(outputDir: string): string {
+  return join(outputDir, 'run-state.json')
+}
+
+export class ProductionRunner {
+  private state: RunState | null = null
+  private working = false
+  private pauseRequested = false
+  private stopRequested = false
+  /** 生产单绑定目录（start 时快照；所有读写固定用它，防止运行中切书导致写错目录）。 */
+  private bookDir: string | null = null
+
+  constructor(private deps: { ctx: Context; getConfig: () => NovelConfig }) {}
+
+  /** 当前生产单状态（内存优先；web 重启后从磁盘恢复）。 */
+  status(): RunState | null {
+    if (this.state !== null) return this.state
+    // 重启恢复：先找当前激活书目录，再扫书架所有书目录（防切书后找不到）。
+    const candidates: string[] = [this.deps.getConfig().outputDir]
+    const bookshelf = loadBookshelf()
+    for (const b of bookshelf.books) if (!candidates.includes(b.outputDir)) candidates.push(b.outputDir)
+    for (const outputDir of candidates) {
+      const file = runStateFile(outputDir)
+      if (!existsSync(file)) continue
+      try {
+        const raw = readFileSync(file, 'utf8')
+        const parsed = JSON.parse(raw) as RunState
+        if (parsed?.runId === undefined) continue
+        // 重启恢复：若之前 running，则视为可续跑（loop 未在跑）。
+        if (parsed.status === 'running') parsed.status = 'paused'
+        this.state = parsed
+        this.bookDir = outputDir
+        return this.state
+      } catch { /* 该目录 run-state 损坏则跳过 */ }
+    }
+    return null
+  }
+
+  private persist(): void {
+    if (this.state === null) return
+    const outputDir = this.bookDir ?? this.deps.getConfig().outputDir
+    mkdirSync(outputDir, { recursive: true })
+    writeFileSync(runStateFile(outputDir), JSON.stringify(this.state, null, 2), 'utf8')
+  }
+
+  private log(text: string): void {
+    if (this.state === null) return
+    this.state.log.push({ at: new Date().toISOString(), text })
+    if (this.state.log.length > 300) this.state.log = this.state.log.slice(-300)
+    this.state.updatedAt = new Date().toISOString()
+  }
+
+  /** 启动/续跑生产单：startNo..endNo 区间，endNo 超出计划时先自动补计划。 */
+  async start(startNo: number, endNo: number, runDir?: string): Promise<RunState> {
+    const config = this.deps.getConfig()
+    if (this.working) throw new Error('生产单正在运行中，请先暂停或停止')
+    const outputDir = runDir ?? config.outputDir
+    let project = loadProject(outputDir)
+    if (project === undefined) throw new Error('输出目录中没有项目')
+
+    // 计划补足：目标区间超出已有计划 → 续写规划追加。
+    if (endNo > project.chapters.length) {
+      const need = endNo - project.chapters.length
+      this.log(`计划不足，追加 ${need} 章计划…`)
+      const chapters = await planChapters(this.deps.ctx, config, project, need, undefined, outputDir)
+      mergeVolatileFromDisk(outputDir, project)
+      project.chapters.push(...chapters)
+      project.updatedAt = new Date().toISOString()
+      saveProject(outputDir, project)
+      this.log(`计划已追加，全书 ${project.chapters.length} 章`)
+    }
+
+    this.state = {
+      runId: `run-${Date.now().toString(36)}`,
+      startNo,
+      endNo,
+      status: 'running',
+      currentNo: startNo,
+      stats: { generated: 0, revised: 0, exempted: 0, regenerated: 0, error: 0 },
+      pendingManual: [],
+      log: [],
+      startedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }
+    this.pauseRequested = false
+    this.stopRequested = false
+    // 绑定生产单目录（快照）：运行期间切书不影响本单的读写目标。
+    this.bookDir = outputDir
+    this.working = true
+    this.persist()
+    void this.loop()
+    return this.state
+  }
+
+  pause(): void { this.pauseRequested = true }
+  resume(): void {
+    if (this.state === null || this.state.status !== 'paused') return
+    this.state.status = 'running'
+    this.working = true
+    this.pauseRequested = false
+    this.stopRequested = false
+    this.persist()
+    void this.loop()
+  }
+  stop(): void { this.stopRequested = true }
+
+  /** 是否有生产单正在执行（目录迁移等磁盘级操作前须为 false）。 */
+  isWorking(): boolean { return this.working }
+
+  /** 主循环：从 currentNo 扫描到 endNo，逐章处理；支持暂停/停止。 */
+  private async loop(): Promise<void> {
+    // 全部读写固定使用生产单绑定目录（bookDir），绝不跟随当前激活书。
+    const config = this.deps.getConfig()
+    const outputDir = this.bookDir ?? config.outputDir
+    try {
+      while (this.state !== null) {
+        if (this.stopRequested) {
+          this.stopRequested = false
+          this.state.status = 'stopped'
+          this.log('生产单已停止')
+          this.persist()
+          break
+        }
+        if (this.pauseRequested) {
+          this.pauseRequested = false
+          this.state.status = 'paused'
+          this.log('生产单已暂停（随时可继续）')
+          this.persist()
+          break
+        }
+        const project = loadProject(outputDir)
+        if (project === undefined) {
+          this.state.status = 'error'
+          this.state.error = '项目丢失'
+          this.persist()
+          break
+        }
+        // 找下一个需要处理的章（approved 快进）。
+        let next: ChapterPlan | undefined
+        for (let no = this.state.currentNo; no <= this.state.endNo; no++) {
+          const ch = project.chapters.find(c => c.no === no)
+          if (ch === undefined) continue
+          if (ch.status === 'approved') { this.state.currentNo = no; continue }
+          next = ch
+          break
+        }
+        if (next === undefined) {
+          this.state.status = 'done'
+          this.log(`生产单完成：${this.state.startNo}-${this.state.endNo} 章处理完毕`)
+          this.persist()
+          break
+        }
+        this.state.currentNo = next.no
+        await this.processChapter(project, next)
+        this.persist()
+      }
+    } catch (error) {
+      if (this.state !== null) {
+        this.state.status = 'error'
+        this.state.error = (error as Error).message
+        this.log(`生产单异常：${(error as Error).message}`)
+        this.persist()
+      }
+    } finally {
+      this.working = false
+    }
+  }
+
+  private async processChapter(project: ProjectState, chapter: ChapterPlan): Promise<void> {
+    if (chapter.status === 'pending' || chapter.status === 'error' || chapter.status === 'written') {
+      await this.produce(project, chapter)
+    } else if (chapter.status === 'rejected') {
+      await this.handleRejected(project, chapter)
+    } else if (chapter.status === 'generating') {
+      // 中断残留：复位重生成。
+      chapter.status = 'pending'
+      await this.produce(project, chapter)
+    }
+  }
+
+  /** 完整质量门：生成 → 摘要+事实 → 伏笔标记 → 审稿 → 作者复盘。 */
+  private async produce(project: ProjectState, chapter: ChapterPlan): Promise<void> {
+    const { ctx, getConfig } = this.deps
+    const config = getConfig()
+    const outputDir = this.bookDir ?? config.outputDir
+    const no = chapter.no
+    const wasError = chapter.status === 'error'
+    chapter.status = 'generating'
+    chapter.error = undefined
+    chapter.generatingAt = new Date().toISOString()
+    mergeVolatileFromDisk(outputDir, project)
+    saveProject(outputDir, project)
+    this.log(`${wasError ? '重新生成' : '生成'} 第${no}章《${chapter.title}》…（模型 ${config.generateModel || config.model}）`)
+    try {
+      for await (const _step of generateChapterStream(ctx, config, project, outputDir, no)) { /* drain */ }
+      try { await summarizeAndExtractFacts(ctx, config, project, outputDir, no) } catch (e) { console.warn('[dsh-novel-forge] run summary/facts:', (e as Error).message) }
+      try { markForeshadowPlanted(project, outputDir, no) } catch (e) { console.warn('[dsh-novel-forge] run foreshadow:', (e as Error).message) }
+      if (config.autoReview ?? true) {
+        const report = await reviewChapter(ctx, config, project, outputDir, no)
+        if (this.state !== null) this.state.stats[wasError ? 'regenerated' : 'generated']++
+        this.log(`第${no}章 审稿 ${report.score}分 ${report.passed ? ' 通过' : ' 被拒'}（模型 ${config.reviewModel || config.model}）`)
+      } else {
+        chapter.status = 'approved'
+        mergeVolatileFromDisk(outputDir, project)
+        saveProject(outputDir, project)
+      }
+      if (config.autoAuthorReview ?? true) {
+        try {
+          const body = readChapterFile(outputDir, chapter)
+          if (body !== undefined) {
+            let prevTail = ''
+            if (no > 1) {
+              const prev = project.chapters.find(c => c.no === no - 1)
+              if (prev !== undefined) prevTail = (readChapterFile(outputDir, prev) ?? '').replace(/^#.*$/m, '').trim().slice(-600)
+            }
+            const review = await authorReviewChapter(ctx, config, project, no, body, prevTail)
+            chapter.authorReview = review
+            if (review.advancedLines !== undefined) autoLinkPlotlines(project, no, review.advancedLines)
+            // 结果回灌：把本章状态变化/新线索写进编年录事实库，供后续计划与整本控制用。
+            const backfillFacts: string[] = [...(review.stateChanges ?? []), ...(review.clues ?? [])]
+            if (backfillFacts.length > 0) {
+              project.facts ??= []
+              for (const text of backfillFacts) project.facts.push({ chapterNo: no, text })
+            }
+            mergeVolatileFromDisk(outputDir, project)
+            saveProject(outputDir, project)
+          }
+        } catch (e) { console.warn('[dsh-novel-forge] run author review:', (e as Error).message) }
+      }
+    } catch (error) {
+      chapter.status = 'error'
+      chapter.error = (error as Error).message
+      mergeVolatileFromDisk(outputDir, project)
+      saveProject(outputDir, project)
+      if (this.state !== null) this.state.stats.error++
+      this.log(`第${no}章 失败：${(error as Error).message}`)
+    }
+  }
+
+  /** 被拒分级处理：无 high 豁免；有 high 按意见修订（最多 2 轮）+ 验证模式；仍不过 → 待人工。 */
+  private async handleRejected(project: ProjectState, chapter: ChapterPlan): Promise<void> {
+    const { ctx, getConfig } = this.deps
+    const config = getConfig()
+    const outputDir = this.bookDir ?? config.outputDir
+    const no = chapter.no
+    const report = chapter.review
+    const highs = (report?.issues ?? []).filter(i => i.severity === 'high')
+    if (highs.length === 0) {
+      chapter.status = 'approved'
+      project.updatedAt = new Date().toISOString()
+      saveProject(outputDir, project)
+      if (this.state !== null) this.state.stats.exempted++
+      this.log(`第${no}章 豁免通过（无 high）`)
+      return
+    }
+    this.log(`第${no}章 修订（${highs.length} 个 high）…`)
+    for (let round = 1; round <= 2; round++) {
+      const instr = '按审稿意见修订（优先处理）：\n' + highs.map(h => `[${h.severity}] ${h.item}${h.suggestion !== '' ? `\n建议：${h.suggestion}` : ''}`).join('\n\n')
+      try {
+        for await (const _step of rewriteChapterStream(ctx, config, project, outputDir, no, instr, undefined)) { /* drain */ }
+      } catch (error) {
+        this.log(`第${no}章 第${round}轮修订出错：${(error as Error).message}`)
+        continue
+      }
+      // rewrite 已写盘（pendingDraft + saveProject），重载拿最新草稿。
+      const fresh = loadProject(outputDir)
+      const freshCh = fresh?.chapters.find(c => c.no === no)
+      const draft = freshCh?.pendingDraft
+      if (draft === undefined || draft.length < 50) {
+        this.log(`第${no}章 第${round}轮草稿缺失，重试`)
+        continue
+      }
+      const verify = await reviewChapterText(ctx, config, fresh!, draft, chapter.review)
+      const highs2 = (verify.issues ?? []).filter(i => i.severity === 'high')
+      if (verify.passed || highs2.length === 0) {
+        // 应用草稿（与 draft/apply 路由同逻辑）：备份原稿 → 落盘 → 定状态。
+        this.applyDraft(fresh!, freshCh!, draft, verify)
+        if (this.state !== null) this.state.stats.revised++
+        this.log(`第${no}章 第${round}轮修订通过（${verify.score}分）`)
+        return
+      }
+      this.log(`第${no}章 第${round}轮仍不过（${highs2.length} high）`)
+    }
+    if (this.state !== null) this.state.pendingManual.push(no)
+    this.log(`第${no}章  两轮修订仍不过 → 保留草稿待人工`)
+  }
+
+  private applyDraft(project: ProjectState, chapter: ChapterPlan, draft: string, report: ReviewReport): void {
+    const config = this.deps.getConfig()
+    const outputDir = this.bookDir ?? config.outputDir
+    const fileName = chapterFileName(chapter)
+    mkdirSync(outputDir, { recursive: true })
+    const targetPath = join(outputDir, fileName)
+    if (existsSync(targetPath)) {
+      copyFileSync(targetPath, join(outputDir, `${fileName.replace(/\.md$/, '')}.bak.md`))
+    }
+    writeFileSync(targetPath, `# 第${chapter.no}章 ${chapter.title}\n\n${draft}\n`, 'utf8')
+    chapter.pendingDraft = undefined
+    chapter.chars = countHanzi(draft)
+    chapter.file = fileName
+    if (typeof report.score === 'number') {
+      chapter.review = report
+      chapter.status = report.passed === true ? 'approved' : 'rejected'
+    } else {
+      chapter.status = 'written'
+      chapter.review = undefined
+    }
+    chapter.error = undefined
+    project.updatedAt = new Date().toISOString()
+    saveProject(outputDir, project)
+  }
+}

package/src/stage-contract.ts

@@ -0,0 +1,189 @@
+/**
+ * 阶段契约（Stage Contract）——宿主计算的「当前阶段 → 本轮允许的动作」。
+ *
+ * 设计来源（借鉴 dsh-ai-novel-writer 的「作者请求中的当前阶段决定唯一允许命令」）：
+ * 允许的动作必须由宿主根据真实项目状态算出，而不是指望模型记住或自律。
+ * 宿主计算结果同时用于三处：
+ *   1) 注入助手系统提示词：模型知道自己在哪一步、下一步该做什么；
+ *   2) 通用续写指令（「继续 / 下一步」）下的写操作白名单强约束（阶段即唯一命令）；
+ *   3) 拒绝写操作时给出可执行的、阶段相关的理由，而不是一句「不允许」。
+ *
+ * 注意：作者显式点名的写操作永远优先于阶段白名单（作者终审权）；
+ * 阶段强约束只在作者没有指定具体对象（通用续写）时生效。
+ */
+
+import type { ChapterPlan, ProjectState, StageInfo } from './protocol.ts'
+
+/** 创作阶段标识（线上形状见 protocol.ts 的 StageInfo）。 */
+export type BookStageId = StageInfo['id']
+
+/** 一个阶段契约。 */
+export type BookStage = StageInfo
+
+/** 大纲视为「已开书」的最短长度。 */
+const MIN_OUTLINE_CHARS = 50
+
+/** 通用续写指令（作者没有指定具体对象时，阶段白名单成为唯一命令）。 */
+const GENERIC_CONTINUE = /^(继续|下一步|接着来|接着写|往下|往下走|继续吧|go\s*on|continue|next)[。.!！?？\s]*$/i
+
+/**
+ * 作者这一轮是否只说了「继续/下一步」这类没有具体对象的指令。
+ *
+ * @param message 本轮用户消息。
+ * @returns 是通用续写指令时为 true。
+ */
+export function isGenericContinue(message: string): boolean {
+  return GENERIC_CONTINUE.test((message ?? '').trim())
+}
+
+/**
+ * 根据项目真实状态计算当前创作阶段。
+ *
+ * @param project 当前项目（未加载时为 undefined）。
+ * @returns 阶段契约（推荐动作 + 写操作白名单 + 判定理由）。
+ */
+export function computeBookStage(project: ProjectState | undefined): BookStage {
+  if (project === undefined || (project.outline ?? '').trim().length < MIN_OUTLINE_CHARS) {
+    return {
+      id: 'outline',
+      label: '开书',
+      recommend: ['outline_replace'],
+      allow: ['outline_replace'],
+      reason: project === undefined ? '尚无项目' : '大纲为空或过短',
+    }
+  }
+  if (project.bible === undefined) {
+    return {
+      id: 'bible',
+      label: '立设定',
+      recommend: ['bible_set_rule', 'bible_set_redline'],
+      allow: ['bible_set_rule', 'bible_set_redline'],
+      reason: '已有大纲，尚未提炼道藏',
+    }
+  }
+  const chapters = project.chapters ?? []
+  if (chapters.length === 0) {
+    return {
+      id: 'plan',
+      label: '排章节',
+      recommend: [],
+      // 章节规划不在助手的动作集里：通用「继续」不应被解释成改写总纲或设定。
+      allow: [],
+      reason: '有道藏但还没有章节计划（规划在「小说工坊」面板或生产单里执行）',
+    }
+  }
+  const generating = chapters.filter(c => c.status === 'generating')
+  if (generating.length > 0) {
+    return {
+      id: 'wait',
+      label: '等待中',
+      recommend: [],
+      allow: [],
+      reason: `第 ${generating.map(c => c.no).join('、')} 章正在生成，等它结束后再安排下一步`,
+    }
+  }
+  const errored = chapters.filter(c => c.status === 'error')
+  if (errored.length > 0) {
+    return {
+      id: 'write',
+      label: '逐章编译',
+      recommend: ['chapter_generate'],
+      allow: ['chapter_generate', 'chapter_rewrite', 'chapter_review'],
+      reason: `第 ${errored.map(c => c.no).join('、')} 章生成失败，需要重写`,
+    }
+  }
+  const rejected = chapters.filter(c => c.status === 'rejected')
+  if (rejected.length > 0) {
+    return {
+      id: 'revise',
+      label: '修订循环',
+      recommend: ['chapter_rewrite'],
+      allow: ['chapter_rewrite', 'chapter_review'],
+      reason: `第 ${rejected.map(c => c.no).join('、')} 章审稿未过，需要按意见修订`,
+    }
+  }
+  const awaitingReview = chapters.filter(c => c.status === 'written' || c.status === 'reviewing')
+  if (awaitingReview.length > 0) {
+    return {
+      id: 'review',
+      label: '审稿',
+      recommend: ['chapter_review'],
+      allow: ['chapter_review', 'chapter_rewrite'],
+      reason: `第 ${awaitingReview.map(c => c.no).join('、')} 章已写出但尚未审稿`,
+    }
+  }
+  const pending = chapters.filter(c => c.status === 'pending')
+  if (pending.length > 0) {
+    return {
+      id: 'write',
+      label: '逐章编译',
+      recommend: ['chapter_generate'],
+      allow: ['chapter_generate', 'chapter_rewrite', 'chapter_review'],
+      reason: `还有 ${pending.length} 章待写（下一章：第 ${pending[0]!.no} 章）`,
+    }
+  }
+  return {
+    id: 'export',
+    label: '定稿导出',
+    recommend: ['export_txt', 'blurb'],
+    // 全部通过后不再允许在「继续」下改写正文：要改必须由作者点名章节。
+    allow: ['export_txt', 'blurb'],
+    reason: `全书 ${chapters.length} 章均已通过审稿`,
+  }
+}
+
+/**
+ * 判断某写操作是否在当前阶段的允许白名单内。
+ *
+ * @param stage 阶段契约。
+ * @param tool 助手工具名。
+ * @returns 允许时为 true。
+ */
+export function stageAllows(stage: BookStage, tool: string): boolean {
+  return stage.allow.includes(tool)
+}
+
+/**
+ * 按阶段把一组动作分成「本阶段可用」与「阶段外」。
+ *
+ * @param stage 阶段契约。
+ * @param tools 动作名列表（通常是写操作登记表）。
+ * @returns 两个保持输入顺序的子集。
+ */
+export function splitByStage(stage: BookStage, tools: readonly string[]): { available: string[]; outside: string[] } {
+  const available: string[] = []
+  const outside: string[] = []
+  for (const tool of tools) {
+    if (stageAllows(stage, tool)) available.push(tool)
+    else outside.push(tool)
+  }
+  return { available, outside }
+}
+
+/**
+ * 渲染阶段契约为可注入提示词的一段文字。
+ *
+ * @param stage 阶段契约。
+ * @returns 多行文本。
+ */
+export function renderStageContract(stage: BookStage): string {
+  const recommend = stage.recommend.length > 0 ? stage.recommend.join('、') : '无（等待或由作者指定）'
+  const allow = stage.allow.length > 0 ? stage.allow.join('、') : '无'
+  return [
+    '==================== 当前创作阶段（宿主根据项目真实状态计算） ====================',
+    `阶段：${stage.label}（${stage.id}）`,
+    `判定依据：${stage.reason}`,
+    `建议下一步：${recommend}`,
+    `本阶段允许的写操作：${allow}`,
+    '阶段纪律：作者只说了「继续/下一步」而没指定具体对象时，只有上面的写操作会被执行，其余写操作一律拒绝；作者显式点名某个操作时以作者指令为准。',
+  ].join('\n')
+}
+
+/** 汇总章节状态计数（供面板/提示词展示，避免各处重复统计）。 */
+export function summarizeChapters(chapters: ChapterPlan[]): Record<string, number> {
+  const summary: Record<string, number> = {}
+  for (const chapter of chapters) {
+    summary[chapter.status] = (summary[chapter.status] ?? 0) + 1
+  }
+  return summary
+}