@cloud411716/fancy-webnovel 1.0.46 → 3.0.0

package/plugins/fancy-story-builder/storydb/stage.js

@@ -0,0 +1,426 @@
+/**
+ * Stage completion checks for the story graph.
+ *
+ * These are the "is this stage done enough to move on?" queries. The LLM can
+ * call them via `storydb stage-check <stage>` after writing.
+ */
+
+import { validate } from './store.js';
+
+const STORY = 'story:main';
+
+const CHAR_TYPE_TO_QUOTA = {
+  主角: 'protagonist',
+  核心配角: 'core_supporting',
+  贯穿级核心配角: 'core_supporting',
+  卷级配角: 'volume_supporting',
+  卷级重要配角: 'volume_supporting',
+  核心反派: 'core_antagonist',
+  贯穿级核心反派: 'core_antagonist',
+  卷级反派: 'volume_antagonist',
+};
+
+const SIZE_ALIASES = {
+  small: 'small', 小: 'small', 小型: 'small',
+  medium: 'medium', 中: 'medium', 中型: 'medium',
+  large: 'large', 大: 'large', 大型: 'large',
+};
+
+function num(value) {
+  return Number(value) || 0;
+}
+
+function addMissing(errors, label, actual, expected) {
+  if (num(actual) < num(expected)) {
+    errors.push({
+      code: 'STAGE_INCOMPLETE',
+      message: label + '数量不足：' + actual + ' / ' + expected,
+      expected: num(expected),
+      actual: num(actual),
+    });
+  }
+}
+
+async function count(sdb, table, where = '') {
+  const rows = await sdb.rows(
+    `SELECT count() FROM ${table} WHERE story = ${STORY}${where ? ' AND ' + where : ''} GROUP ALL;`,
+  );
+  return num(rows[0] && rows[0].count);
+}
+
+async function checkScale(sdb) {
+  const errors = [];
+  const scale = await sdb.one('SELECT * FROM scale:main;');
+  if (!scale) {
+    errors.push({ code: 'SCALE_MISSING', message: '尚无 scale 记录' });
+    return { errors, warnings: [], pending: [], counts: {} };
+  }
+  const story = await sdb.one('SELECT * FROM story:main;');
+  const target = num(story.target_chapters);
+  const volumes = await sdb.rows(`SELECT * FROM volume WHERE story = ${STORY} ORDER BY chapter_start;`);
+  const acts = await sdb.rows(`SELECT * FROM act WHERE story = ${STORY} ORDER BY chapter_start;`);
+  if (!volumes.length) errors.push({ code: 'SCALE_VOLUMES', message: '没有卷' });
+  if (!acts.length) errors.push({ code: 'SCALE_ACTS', message: '没有幕' });
+  const covered = volumes.reduce((sum, v) => sum + Math.max(0, num(v.chapter_end) - num(v.chapter_start) + 1), 0);
+  if (target && covered < target) {
+    errors.push({ code: 'SCALE_RANGE', message: '卷覆盖章节不足：' + covered + ' / ' + target });
+  }
+  for (const v of volumes) {
+    if (num(v.chapter_start) > num(v.chapter_end)) {
+      errors.push({ code: 'SCALE_RANGE', message: '卷 ' + v.volume_id + ' 起止倒置' });
+    }
+  }
+  return {
+    errors,
+    warnings: [],
+    pending: [],
+    counts: { volumes: volumes.length, acts: acts.length, covered, target },
+  };
+}
+
+async function checkMacro(sdb) {
+  const errors = [];
+  const world = await count(sdb, 'world_doc');
+  const storyDoc = await count(sdb, 'story_doc');
+  const lines = await count(sdb, 'line');
+  const nodes = await count(sdb, 'line_node');
+  const endings = await count(sdb, 'ending');
+  const roles = await count(sdb, 'role_slot');
+  if (!world) errors.push({ code: 'MACRO_WORLD', message: '缺少世界观' });
+  if (!storyDoc) errors.push({ code: 'MACRO_STORY', message: '缺少故事文档' });
+  if (!lines) errors.push({ code: 'MACRO_LINE', message: '缺少主线/支线' });
+  if (!nodes) errors.push({ code: 'MACRO_NODES', message: '缺少主线节点' });
+  if (!endings) errors.push({ code: 'MACRO_ENDING', message: '缺少结局' });
+  if (!roles) errors.push({ code: 'MACRO_ROLES', message: '缺少角色功能位' });
+  return {
+    errors,
+    warnings: [],
+    pending: [],
+    counts: { world, story: storyDoc, lines, nodes, endings, roles },
+  };
+}
+
+async function checkCast(sdb) {
+  const errors = [];
+  const scale = await sdb.one('SELECT * FROM scale:main;');
+  const quotas = (scale && scale.quotas) || {};
+  const characters = await sdb.rows(
+    `SELECT type, count() AS n FROM character WHERE story = ${STORY} GROUP BY type;`,
+  );
+  const charCounts = {};
+  for (const row of characters) {
+    const key = CHAR_TYPE_TO_QUOTA[row.type] || row.type;
+    charCounts[key] = (charCounts[key] || 0) + num(row.n);
+  }
+  const charQuotas = quotas.characters || {};
+  for (const [key, expected] of Object.entries(charQuotas)) {
+    addMissing(errors, '人物（' + key + '）', charCounts[key] || 0, expected);
+  }
+
+  addMissing(errors, '势力', await count(sdb, 'faction'), quotas.factions);
+  addMissing(errors, '势力关系', await count(sdb, 'faction_relation'), quotas.faction_relations);
+  addMissing(errors, '地点', await count(sdb, 'location'), quotas.locations);
+  addMissing(errors, '结局', await count(sdb, 'ending'), quotas.endings);
+
+  const items = await sdb.rows(`SELECT category, count() AS n FROM item WHERE story = ${STORY} GROUP BY category;`);
+  const itemQuotas = quotas.items || {};
+  const itemCounts = {};
+  for (const row of items) {
+    const key = { 核心: 'core', 支线: 'branch', 象征: 'symbolic' }[row.category] || row.category;
+    itemCounts[key] = (itemCounts[key] || 0) + num(row.n);
+  }
+  for (const [key, expected] of Object.entries(itemQuotas)) addMissing(errors, '道具（' + key + '）', itemCounts[key] || 0, expected);
+
+  const conflicts = await sdb.rows(`SELECT type, count() AS n FROM conflict WHERE story = ${STORY} GROUP BY type;`);
+  const conflictQuotas = quotas.conflicts || {};
+  const conflictCounts = {};
+  for (const row of conflicts) {
+    const key = { 核心: 'core', 阶段: 'phase', 交织: 'branch' }[row.type] || row.type;
+    conflictCounts[key] = (conflictCounts[key] || 0) + num(row.n);
+  }
+  for (const [key, expected] of Object.entries(conflictQuotas)) addMissing(errors, '冲突（' + key + '）', conflictCounts[key] || 0, expected);
+
+  const foreshadows = await sdb.rows(`SELECT type, count() AS n FROM foreshadow WHERE story = ${STORY} GROUP BY type;`);
+  const fsQuotas = quotas.foreshadows || {};
+  const fsCounts = {};
+  for (const row of foreshadows) {
+    const key = SIZE_ALIASES[row.type] || row.type;
+    fsCounts[key] = (fsCounts[key] || 0) + num(row.n);
+  }
+  for (const [key, expected] of Object.entries(fsQuotas)) addMissing(errors, '伏笔（' + key + '）', fsCounts[key] || 0, expected);
+
+  const climaxes = await sdb.rows(`SELECT type, count() AS n FROM climax WHERE story = ${STORY} GROUP BY type;`);
+  const clQuotas = quotas.climaxes || {};
+  const clCounts = {};
+  for (const row of climaxes) {
+    const key = SIZE_ALIASES[row.type] || row.type;
+    clCounts[key] = (clCounts[key] || 0) + num(row.n);
+  }
+  for (const [key, expected] of Object.entries(clQuotas)) addMissing(errors, '高潮（' + key + '）', clCounts[key] || 0, expected);
+
+  const payoffs = await sdb.rows(`SELECT scale, count() AS n FROM payoff WHERE story = ${STORY} GROUP BY scale;`);
+  const payQuotas = quotas.pleasures || {};
+  const payCounts = {};
+  for (const row of payoffs) {
+    const key = SIZE_ALIASES[row.scale] || row.scale;
+    payCounts[key] = (payCounts[key] || 0) + num(row.n);
+  }
+  for (const [key, expected] of Object.entries(payQuotas)) addMissing(errors, '爽点（' + key + '）', payCounts[key] || 0, expected);
+
+  const roles = await count(sdb, 'role_slot');
+  if (!roles) errors.push({ code: 'CAST_ROLES', message: '缺少角色功能位' });
+
+  return {
+    errors,
+    warnings: [],
+    pending: [],
+    counts: {
+      characters: charCounts,
+      factions: await count(sdb, 'faction'),
+      faction_relations: await count(sdb, 'faction_relation'),
+      locations: await count(sdb, 'location'),
+      items: itemCounts,
+      conflicts: conflictCounts,
+      foreshadows: fsCounts,
+      climaxes: clCounts,
+      payoffs: payCounts,
+      information: await count(sdb, 'information'),
+      endings: await count(sdb, 'ending'),
+    },
+  };
+}
+
+async function checkRhythm(sdb) {
+  const errors = [];
+  const story = await sdb.one('SELECT * FROM story:main;');
+  const target = num(story.target_chapters);
+  const chapters = await sdb.rows(
+    `SELECT chapter_id, display_no FROM chapter WHERE story = ${STORY} ORDER BY display_no;`,
+  );
+  if (target && chapters.length < target) {
+    errors.push({ code: 'RHYTHM_CHAPTERS', message: '章节数不足：' + chapters.length + ' / ' + target });
+  }
+  const seen = new Set(chapters.map((c) => num(c.display_no)));
+  for (let i = 1; i <= Math.max(target, chapters.length); i += 1) {
+    if (!seen.has(i)) {
+      errors.push({ code: 'RHYTHM_GAP', message: '缺少第 ' + i + ' 章' });
+      break;
+    }
+  }
+  const noCast = await sdb.rows(
+    `SELECT chapter_id, display_no FROM chapter
+     WHERE story = ${STORY} AND array::len(->chapter_cast) = 0 ORDER BY display_no LIMIT 10;`,
+  );
+  for (const c of noCast) {
+    errors.push({ code: 'RHYTHM_CAST', message: '第 ' + c.display_no + ' 章没有出场人物' });
+  }
+
+  const report = await validate(sdb);
+  for (const error of report.errors) {
+    if (error.code === 'REQUIREMENT_PENDING') continue;
+    errors.push(error);
+  }
+  return {
+    errors,
+    warnings: report.warnings,
+    pending: [],
+    counts: {
+      chapters: chapters.length,
+      target,
+      missing_chapters: Math.max(0, target - chapters.length),
+      casts: await count(sdb, 'chapter_cast'),
+      chapter_locations: await count(sdb, 'chapter_location'),
+      chapter_line_nodes: await count(sdb, 'chapter_line_node'),
+      chapter_branches: await count(sdb, 'chapter_branch'),
+      chapter_conflicts: await count(sdb, 'chapter_conflict'),
+      chapter_climaxes: await count(sdb, 'chapter_climax'),
+      chapter_items: await count(sdb, 'chapter_item'),
+      ending_actions: await count(sdb, 'ending_action'),
+      foreshadow_actions: await count(sdb, 'foreshadow_action'),
+      payoff_actions: await count(sdb, 'payoff_action'),
+      info_actions: await count(sdb, 'info_action'),
+      knowledge_events: await count(sdb, 'knowledge_event'),
+    },
+  };
+}
+
+async function checkOutline(sdb, opts = {}) {
+  const errors = [];
+  const allChapters = await sdb.rows(
+    `SELECT chapter_id, display_no FROM chapter WHERE story = ${STORY} ORDER BY display_no;`,
+  );
+  const chapters = opts.chapterIds
+    ? allChapters.filter((row) => opts.chapterIds.has(row.chapter_id))
+    : allChapters;
+  const allOutlines = await sdb.rows(
+    `SELECT chapter_id FROM outline WHERE story = ${STORY};`,
+  );
+  const outlines = opts.chapterIds
+    ? allOutlines.filter((row) => opts.chapterIds.has(row.chapter_id))
+    : allOutlines;
+  const outlineSet = new Set(outlines.map((o) => o.chapter_id));
+  const missing = chapters.filter((c) => !outlineSet.has(c.chapter_id));
+  for (const c of missing.slice(0, 10)) {
+    errors.push({ code: 'OUTLINE_MISSING', message: '第 ' + c.display_no + ' 章缺少细纲' });
+  }
+  if (missing.length > 10) errors.push({ code: 'OUTLINE_MISSING', message: '还有 ' + (missing.length - 10) + ' 章缺少细纲' });
+
+  const allEmpty = await sdb.rows(
+    `SELECT chapter_id FROM outline WHERE story = ${STORY} AND array::len(->outline_scene) = 0 LIMIT 10;`,
+  );
+  const empty = opts.chapterIds
+    ? allEmpty.filter((row) => opts.chapterIds.has(row.chapter_id))
+    : allEmpty;
+  for (const o of empty.slice(0, 10)) {
+    errors.push({ code: 'OUTLINE_SCENES', message: o.chapter_id + ' 没有场景' });
+  }
+
+  const report = await validate(sdb);
+  const allOutlineRows = await sdb.rows(
+    `SELECT chapter_id, must_write FROM outline WHERE story = ${STORY};`,
+  );
+  const outlineRows = opts.chapterIds
+    ? allOutlineRows.filter((row) => opts.chapterIds.has(row.chapter_id))
+    : allOutlineRows;
+  const sceneCounts = new Map(
+    (await sdb.rows(
+      `SELECT in, count() AS n FROM outline_scene WHERE story = ${STORY} GROUP BY in;`,
+    )).map((row) => [String(row.in).split(':').pop().replace(/[⟨⟩]/g, ''), Number(row.n) || 0]),
+  );
+  const warnings = reportWarnings(report).filter((item) => !opts.chapterIds
+    || !item.scope || !String(item.scope).startsWith('chapter:')
+    || opts.chapterIds.has(String(item.scope).split(':').pop()));
+  for (const row of outlineRows) {
+    const sceneCount = sceneCounts.get(String(row.chapter_id)) || 0;
+    if (sceneCount < 2) {
+      warnings.push({
+        code: 'OUTLINE_THIN_SCENES',
+        severity: 'warning',
+        scope: 'outline:' + row.chapter_id,
+        message: row.chapter_id + ' 只有 ' + sceneCount + ' 个场景；一般应有 2-4 个',
+      });
+    }
+    if (!Array.isArray(row.must_write) || row.must_write.length < 3) {
+      warnings.push({
+        code: 'OUTLINE_THIN_BEATS',
+        severity: 'warning',
+        scope: 'outline:' + row.chapter_id,
+        message: row.chapter_id + ' 的 must_write 少于 3 条',
+      });
+    }
+  }
+
+  for (const error of report.errors) {
+    if (error.code === 'REQUIREMENT_PENDING') continue;
+    if (opts.chapterIds && error.scope && String(error.scope).startsWith('chapter:')
+      && !opts.chapterIds.has(String(error.scope).split(':').pop())) continue;
+    errors.push(error);
+  }
+  const selectedOutlineIds = new Set(outlines.map((row) => row.chapter_id));
+  const countForOutlines = async (table) => {
+    if (!opts.chapterIds) return count(sdb, table);
+    const rows = await sdb.rows(`SELECT in FROM ${table} WHERE story = ${STORY};`);
+    return rows.filter((row) => selectedOutlineIds.has(String(row.in).split(':').pop().replace(/[⟨⟩]/g, ''))).length;
+  };
+  const scenesForSelection = opts.chapterIds
+    ? [...selectedOutlineIds].reduce((sum, id) => sum + (sceneCounts.get(String(id)) || 0), 0)
+    : await count(sdb, 'scene');
+  return {
+    errors,
+    warnings,
+    pending: [],
+    counts: {
+      chapters: chapters.length,
+      outlines: outlines.length,
+      missing_outlines: missing.length,
+      scenes: scenesForSelection,
+      outline_casts: await countForOutlines('outline_cast'),
+      outline_locations: await countForOutlines('outline_location'),
+      outline_foreshadows: await countForOutlines('outline_foreshadow'),
+    },
+  };
+}
+
+function reportWarnings(report) {
+  return report && Array.isArray(report.warnings) ? report.warnings : [];
+}
+
+async function checkWriting(sdb, opts = {}) {
+  const errors = [];
+  const allChapters = await sdb.rows(
+    `SELECT chapter_id, display_no, word_target FROM chapter WHERE story = ${STORY} ORDER BY display_no;`,
+  );
+  const chapters = opts.chapterIds
+    ? allChapters.filter((row) => opts.chapterIds.has(row.chapter_id))
+    : allChapters;
+  const allTexts = await sdb.rows(
+    `SELECT chapter_id, display_no, word_count FROM chapter_text WHERE story = ${STORY};`,
+  );
+  const texts = opts.chapterIds
+    ? allTexts.filter((row) => opts.chapterIds.has(row.chapter_id))
+    : allTexts;
+  const textSet = new Set(texts.map((t) => t.chapter_id));
+  const missing = chapters.filter((c) => !textSet.has(c.chapter_id));
+  for (const c of missing.slice(0, 10)) {
+    errors.push({ code: 'WRITING_MISSING', message: '第 ' + c.display_no + ' 章缺少正文' });
+  }
+  if (missing.length > 10) errors.push({ code: 'WRITING_MISSING', message: '还有 ' + (missing.length - 10) + ' 章缺少正文' });
+  const chapterById = new Map(chapters.map((row) => [row.chapter_id, row]));
+  const warnings = [];
+  for (const text of texts) {
+    if (num(text.word_count) <= 0) {
+      errors.push({ code: 'WRITING_EMPTY', message: '第 ' + text.display_no + ' 章正文为空' });
+      continue;
+    }
+    const target = num(chapterById.get(text.chapter_id)?.word_target);
+    if (target && num(text.word_count) < target * 0.8) {
+      warnings.push({
+        code: 'WRITING_SHORT',
+        severity: 'warning',
+        scope: 'chapter:' + text.chapter_id,
+        message: '第 ' + text.display_no + ' 章正文 ' + text.word_count + ' 字，低于目标 ' + target + ' 的 80%',
+      });
+    }
+  }
+  const report = await validate(sdb);
+  for (const error of report.errors) {
+    if (error.code === 'REQUIREMENT_PENDING') continue;
+    if (opts.chapterIds && error.scope && String(error.scope).startsWith('chapter:')
+      && !opts.chapterIds.has(String(error.scope).split(':').pop())) continue;
+    errors.push(error);
+  }
+  return {
+    errors,
+    warnings: [
+      ...report.warnings.filter((item) => !opts.chapterIds
+        || !item.scope || !String(item.scope).startsWith('chapter:')
+        || opts.chapterIds.has(String(item.scope).split(':').pop())),
+      ...warnings,
+    ],
+    pending: [],
+    counts: {
+      chapters: chapters.length,
+      texts: texts.length,
+      missing_texts: missing.length,
+      words: texts.reduce((sum, text) => sum + (Number(text.word_count) || 0), 0),
+      handoffs: await count(sdb, 'handoff'),
+    },
+  };
+}
+
+const CHECKS = {
+  scale: checkScale,
+  macro: checkMacro,
+  cast: checkCast,
+  rhythm: checkRhythm,
+  outline: checkOutline,
+  writing: checkWriting,
+};
+
+export async function stageCheck(sdb, stage, opts = {}) {
+  const check = CHECKS[stage];
+  if (!check) throw new Error('未知阶段：' + stage);
+  const result = await check(sdb, opts);
+  const ok = result.errors.length === 0;
+  return { ok, stage, ...result };
+}