@cloud411716/fancy-webnovel 1.0.46 → 3.0.0

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

@@ -0,0 +1,379 @@
+/**
+ * Plugin command bridge for the storydb-native generation flow.
+ *
+ * `fancy-build scale|macro|cast|rhythm|outline|write` now:
+ *   1. open the story graph, check upstream, build a compact context
+ *   2. close the DB (embedded lock)
+ *   3. send a prompt telling the LLM to use the storydb CLI
+ *   4. wait for the turn, run stage-check, repair with exact DB errors
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { notify, llmFollowup } from '#infra';
+import { openStoryGraph, ensureRootStory } from './client.js';
+import { stageCheck } from './stage.js';
+import { buildStagePrompt, buildRepairPrompt } from './prompts.js';
+import { runStageLoop, waitForTurn } from './driver.js';
+import { readWikiReferences } from '../wiki-references.js';
+import { resolveWorkspace } from '../../../lib/workspace.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const STORYDB_CLI = path.join(__dirname, 'cli.js');
+
+const UPSTREAM = {
+  scale: null,
+  macro: 'scale',
+  cast: 'macro',
+  rhythm: 'cast',
+  outline: 'rhythm',
+  writing: 'outline',
+};
+
+async function withDb(projectRoot, fn) {
+  const sdb = await openStoryGraph(projectRoot);
+  try {
+    return await fn(sdb);
+  } finally {
+    await sdb.close();
+  }
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+async function readScale(sdb) {
+  const scale = await sdb.one('SELECT * FROM scale:main;');
+  const volumes = await sdb.rows(`SELECT * FROM volume WHERE story = story:main ORDER BY chapter_start;`);
+  const acts = await sdb.rows(`SELECT * FROM act WHERE story = story:main ORDER BY chapter_start;`);
+  return {
+    capacity: scale && scale.capacity || null,
+    quotas: scale && scale.quotas || null,
+    volumes: volumes.map((v) => ({
+      volume_id: v.volume_id, title: v.title, chapter_start: v.chapter_start,
+      chapter_end: v.chapter_end, goal: v.goal,
+    })),
+    acts: acts.map((a) => ({
+      act_id: a.act_id, volume_id: a.volume_id, chapter_start: a.chapter_start,
+      chapter_end: a.chapter_end, goal: a.goal,
+    })),
+  };
+}
+
+async function readMacro(sdb) {
+  const world = await sdb.one(`SELECT * FROM world_doc WHERE story = story:main LIMIT 1;`);
+  const story = await sdb.one(`SELECT * FROM story_doc WHERE story = story:main LIMIT 1;`);
+  const lines = await sdb.rows(`SELECT * FROM line WHERE story = story:main ORDER BY kind, line_id;`);
+  const nodes = await sdb.rows(`SELECT * FROM line_node WHERE story = story:main ORDER BY node_id;`);
+  const endings = await sdb.rows(`SELECT * FROM ending WHERE story = story:main ORDER BY ending_id;`);
+  const roles = await sdb.rows(`SELECT * FROM role_slot WHERE story = story:main ORDER BY role_id;`);
+  return {
+    world: world && (world.payload || world) || null,
+    story: story && (story.payload || story) || null,
+    lines: lines.map((l) => ({ line_id: l.line_id, kind: l.kind, name: l.name })),
+    nodes: nodes.map((n) => ({ node_id: n.node_id, line_id: n.line_id, volume: n.volume, act: n.act, goal: n.goal })),
+    endings: endings.map((e) => ({ ending_id: e.ending_id, level: e.level, type: e.type })),
+    roles: roles.map((r) => ({ role_id: r.role_id, name: r.name, slot_function: r.slot_function })),
+  };
+}
+
+async function readCast(sdb) {
+  const rows = await sdb.rows(
+    `SELECT entity_id, name, type, status FROM character WHERE story = story:main ORDER BY entity_id;`,
+  );
+  const factions = await sdb.rows(
+    `SELECT entity_id, name, type FROM faction WHERE story = story:main ORDER BY entity_id;`,
+  );
+  const locations = await sdb.rows(
+    `SELECT entity_id, name, type FROM location WHERE story = story:main ORDER BY entity_id;`,
+  );
+  const foreshadows = await sdb.rows(
+    `SELECT entity_id, name, type, status FROM foreshadow WHERE story = story:main ORDER BY entity_id;`,
+  );
+  const payoffs = await sdb.rows(
+    `SELECT entity_id, name, scale, status FROM payoff WHERE story = story:main ORDER BY entity_id;`,
+  );
+  const conflicts = await sdb.rows(
+    `SELECT entity_id, name, type FROM conflict WHERE story = story:main ORDER BY entity_id;`,
+  );
+  const info = await sdb.rows(
+    `SELECT entity_id, info_name FROM information WHERE story = story:main ORDER BY entity_id;`,
+  );
+  return {
+    counts: {
+      characters: rows.length,
+      factions: factions.length,
+      locations: locations.length,
+      foreshadows: foreshadows.length,
+      payoffs: payoffs.length,
+      conflicts: conflicts.length,
+      information: info.length,
+    },
+    characters: rows.map((r) => ({ id: r.entity_id, name: r.name, type: r.type })),
+    factions: factions.map((r) => ({ id: r.entity_id, name: r.name })),
+    locations: locations.map((r) => ({ id: r.entity_id, name: r.name, type: r.type })),
+    foreshadows: foreshadows.map((r) => ({ id: r.entity_id, name: r.name, type: r.type })),
+    payoffs: payoffs.map((r) => ({ id: r.entity_id, name: r.name, scale: r.scale })),
+    conflicts: conflicts.map((r) => ({ id: r.entity_id, name: r.name, type: r.type })),
+    information: info.map((r) => ({ id: r.entity_id, name: r.info_name })),
+  };
+}
+
+async function readChapterSummary(sdb) {
+  const story = await sdb.one('SELECT * FROM story:main;');
+  const chapters = await sdb.rows(
+    `SELECT chapter_id, display_no, title, volume, act, status FROM chapter WHERE story = story:main ORDER BY display_no;`,
+  );
+  const outlines = await sdb.rows(`SELECT chapter_id FROM outline WHERE story = story:main;`);
+  const texts = await sdb.rows(`SELECT chapter_id, word_count FROM chapter_text WHERE story = story:main;`);
+  const compact = (c) => ({
+    chapter_id: c.chapter_id, display_no: c.display_no, title: c.title,
+    volume: c.volume, act: c.act, status: c.status,
+  });
+  return {
+    target_chapters: story && story.target_chapters || 0,
+    chapter_count: chapters.length,
+    outline_count: outlines.length,
+    text_count: texts.length,
+    missing_outlines: chapters.filter((c) => !outlines.some((o) => o.chapter_id === c.chapter_id)).length,
+    missing_texts: chapters.filter((c) => !texts.some((t) => t.chapter_id === c.chapter_id)).length,
+    first_chapter: chapters.length ? compact(chapters[0]) : null,
+    last_chapter: chapters.length ? compact(chapters[chapters.length - 1]) : null,
+  };
+}
+
+async function buildContext(stage, projectRoot, topicData, sdb, selection = null) {
+  let workspaceRoot = projectRoot;
+  try { workspaceRoot = resolveWorkspace({ cwd: projectRoot, required: true }); } catch { /* legacy root */ }
+  const base = {
+    stage,
+    projectRoot,
+    workspaceRoot,
+    wikiReferences: readWikiReferences(workspaceRoot, stage === 'outline' ? 'rhythm' : stage),
+    cliPath: STORYDB_CLI,
+    topic: topicData || {},
+    selection: selection || null,
+  };
+  if (stage === 'scale') return base;
+  const scale = await readScale(sdb);
+  if (stage === 'macro') return { ...base, scale };
+  const macro = await readMacro(sdb);
+  if (stage === 'cast') return { ...base, quotas: scale.quotas, macro, scale };
+  if (stage === 'rhythm') {
+    const cast = await readCast(sdb);
+    const macro = await readMacro(sdb);
+    return { ...base, scale, cast, macro };
+  }
+  const cast = await readCast(sdb);
+  const summary = await readChapterSummary(sdb);
+  return { ...base, scale, cast: { counts: cast.counts }, summary };
+}
+
+export function parseChapterSelection(rawInput, chapters, stage) {
+  const text = String(rawInput || '').trim();
+  const tokens = text.split(/\s+/).filter(Boolean);
+  if (tokens.length && [stage, stage === 'writing' ? 'write' : '', 'build'].includes(tokens[0].toLowerCase())) tokens.shift();
+  if (!tokens.length || tokens.some((token) => token.toLowerCase() === 'all')) {
+    return { ok: true, all: true, ids: null, displays: [], label: '全部章节' };
+  }
+  const byDisplay = new Map(chapters.map((row) => [Number(row.display_no), row]));
+  const byId = new Map(chapters.map((row) => [String(row.chapter_id).toUpperCase(), row]));
+  const ids = new Set();
+  const displays = [];
+  const add = (row) => {
+    if (row && !ids.has(row.chapter_id)) {
+      ids.add(row.chapter_id);
+      displays.push(Number(row.display_no));
+    }
+  };
+  for (const token of tokens) {
+    const range = /^(?:CH)?(\d+)(?:\s*[-~]\s*(?:CH)?(\d+))?$/i.exec(token);
+    if (range) {
+      const start = Math.min(Number(range[1]), Number(range[2] || range[1]));
+      const end = Math.max(Number(range[1]), Number(range[2] || range[1]));
+      for (let no = start; no <= end; no += 1) {
+        if (!byDisplay.has(no)) return { ok: false, error: '章号不存在：第 ' + no + ' 章' };
+        add(byDisplay.get(no));
+      }
+      continue;
+    }
+    if (/^CH[A-Za-z0-9_-]+$/i.test(token)) {
+      const row = byId.get(token.toUpperCase());
+      if (!row) return { ok: false, error: '章节不存在：' + token };
+      add(row);
+      continue;
+    }
+    return { ok: false, error: '无法识别的章节范围：' + token };
+  }
+  displays.sort((a, b) => a - b);
+  return { ok: true, all: false, ids, displays, label: displays.map((no) => 'CH' + String(no).padStart(3, '0')).join('、') };
+}
+
+function executablePrompt(stage, context) {
+  return buildStagePrompt(stage, context)
+    .replaceAll('<cli>', context.cliPath)
+    .replaceAll('<root>', context.projectRoot);
+}
+
+const STAGE_LABELS = {
+  scale: '规模',
+  macro: '宏观',
+  cast: '实体',
+  rhythm: '章节地图',
+  outline: '细纲',
+  writing: '正文',
+};
+const STAGE_COMMANDS = { scale: 'scale', macro: 'macro', cast: 'cast', rhythm: 'rhythm', outline: 'outline', writing: 'write' };
+const COUNT_LABELS = {
+  volumes: '卷', acts: '幕', covered: '覆盖章节', target: '目标章节',
+  world: '世界观', story: '故事', lines: '线索', nodes: '主线节点', endings: '结局', roles: '角色功能位',
+  characters: '人物', factions: '势力', faction_relations: '势力关系', locations: '地点',
+  items: '道具', conflicts: '冲突', foreshadows: '伏笔', climaxes: '高潮', payoffs: '爽点',
+  information: '信息差', chapters: '章节', missing_chapters: '缺失章节', casts: '出场关系',
+  chapter_locations: '章节地点', chapter_line_nodes: '主线节点落点', chapter_branches: '支线落点',
+  chapter_conflicts: '冲突落点', chapter_climaxes: '高潮落点', chapter_items: '道具落点', ending_actions: '结局动作',
+  foreshadow_actions: '伏笔动作', payoff_actions: '爽点动作', info_actions: '信息差动作',
+  knowledge_events: '知识事件', outlines: '细纲', missing_outlines: '缺失细纲', scenes: '场景',
+  outline_casts: '细纲人物', outline_locations: '细纲地点', outline_foreshadows: '细纲伏笔',
+  texts: '正文', missing_texts: '缺失正文', words: '总字数', handoffs: '章末交接',
+};
+const SUBTYPE_LABELS = {
+  protagonist: '主角', core_supporting: '核心配角', volume_supporting: '卷级配角',
+  core_antagonist: '核心反派', volume_antagonist: '卷级反派',
+  small: '小', medium: '中', large: '大',
+  core: '核心', phase: '阶段', branch: '支线', symbolic: '象征',
+};
+const COUNT_ORDER = [
+  'volumes', 'acts', 'covered', 'target', 'world', 'story', 'lines', 'nodes', 'endings', 'roles',
+  'characters', 'factions', 'faction_relations', 'locations', 'items', 'conflicts', 'foreshadows',
+  'climaxes', 'payoffs', 'information', 'chapters', 'missing_chapters', 'casts',
+  'chapter_locations', 'chapter_line_nodes', 'chapter_branches', 'chapter_conflicts', 'chapter_climaxes', 'chapter_items', 'ending_actions',
+  'foreshadow_actions', 'payoff_actions', 'info_actions', 'knowledge_events',
+  'outlines', 'missing_outlines', 'scenes', 'outline_casts', 'outline_locations', 'outline_foreshadows', 'texts', 'missing_texts', 'words', 'handoffs',
+];
+
+function stageLabel(stage) {
+  return STAGE_LABELS[stage] || stage;
+}
+
+function stageCommand(stage) {
+  return STAGE_COMMANDS[stage] || stage;
+}
+
+function countValue(key, value) {
+  if (typeof value === 'number') {
+    if (key === 'words') return (COUNT_LABELS[key] || key) + '：' + value.toLocaleString('zh-CN');
+    return (COUNT_LABELS[key] || key) + '：' + value;
+  }
+  if (value && typeof value === 'object') {
+    const parts = Object.entries(value)
+      .filter(([, n]) => typeof n === 'number' && n > 0)
+      .map(([name, n]) => (SUBTYPE_LABELS[name] || name) + ' ' + n);
+    if (!parts.length) return null;
+    return (COUNT_LABELS[key] || key) + '：' + parts.join(' / ');
+  }
+  return null;
+}
+
+function summaryLine(stage, check) {
+  const counts = check && check.counts || {};
+  const keys = [...COUNT_ORDER, ...Object.keys(counts)].filter((key, index, all) => all.indexOf(key) === index);
+  const parts = [];
+  for (const key of keys) {
+    if (!(key in counts)) continue;
+    const text = countValue(key, counts[key]);
+    if (text) parts.push(text);
+  }
+  return parts.join(' · ');
+}
+
+function nextStageHint(stage) {
+  const next = stage === 'scale' ? 'macro'
+    : stage === 'macro' ? 'cast'
+      : stage === 'cast' ? 'rhythm'
+        : stage === 'rhythm' ? 'outline all'
+          : stage === 'outline' ? 'write all'
+            : 'deslop';
+  return '/fancy-build ' + next;
+}
+
+export async function runStoryGraphCommand(opts) {
+  const { session, invocation, projectRoot, stage, topicData, rawInput } = opts || {};
+  try {
+    const context = await withDb(projectRoot, async (sdb) => {
+      await ensureRootStory(sdb, {
+        title: topicData && (topicData.book_name || topicData.title),
+        genre: topicData && topicData.genre,
+        platform: topicData && topicData.platform,
+        target_chapters: topicData && topicData.target_chapters,
+        target_words: topicData && topicData.target_words,
+      });
+      const upstream = UPSTREAM[stage];
+      if (upstream) {
+        const report = await stageCheck(sdb, upstream);
+        if (!report.ok) {
+          return { upstreamError: { stage: upstream, report } };
+        }
+      }
+      const chapters = await sdb.rows(`SELECT chapter_id, display_no FROM chapter WHERE story = story:main ORDER BY display_no;`);
+      const selection = parseChapterSelection(rawInput || '', chapters, stage);
+      if (!selection.ok) return { selectionError: selection.error };
+      return buildContext(stage, projectRoot, topicData, sdb, selection);
+    });
+
+    if (context.selectionError) {
+      return notify(session, 'error', '❌ ' + stageLabel(stage) + '阶段范围无效：' + context.selectionError);
+    }
+
+    if (context.upstreamError) {
+      const { stage: up, report } = context.upstreamError;
+      return notify(session, 'error', [
+        '❌ ' + stageLabel(stage) + '的上游阶段「' + stageLabel(up) + '」尚未完成。',
+        '请先运行：`/fancy-build ' + stageCommand(up) + '`',
+        report.errors.length ? '\n问题：\n- ' + report.errors.slice(0, 8).map((e) => e.message).join('\n- ') : '',
+      ].join('\n'));
+    }
+
+    const result = await runStageLoop({
+      stage,
+      context,
+      sendPrompt: async (prompt) => llmFollowup(invocation, prompt),
+      waitTurn: () => waitForTurn(invocation, {
+        timeoutMs: 90 * 60 * 1000,
+        idleGraceMs: 60 * 1000,
+        signal: invocation.signal,
+      }),
+      checkStage: () => withDb(projectRoot, (sdb) => stageCheck(sdb, stage, {
+        chapterIds: context.selection && context.selection.all === false ? context.selection.ids : null,
+      })),
+      buildPrompt: (ctx) => executablePrompt(stage, ctx),
+      buildRepair: (s, check) => buildRepairPrompt(s, check, {
+        cliPath: context.cliPath,
+        projectRoot: context.projectRoot,
+      }),
+      maxRounds: 3,
+    });
+
+    if (result.ok) {
+      const check = result.check || {};
+      const summary = summaryLine(stage, check);
+      return notify(session, 'success', [
+        '✅ ' + stageLabel(stage) + '阶段已完成。',
+        summary ? '完成情况：' + summary : '',
+        check.warnings && check.warnings.length ? '警告：' + check.warnings.length + ' 条（不影响通过）' : '',
+        '下一步：`' + nextStageHint(stage) + '`',
+      ].filter(Boolean).join('\n'));
+    }
+
+    const check = result.check || {};
+    const errors = (check.errors || []).slice(0, 10).map((e) => '- ' + (e.message || e.code));
+    return notify(session, 'error', [
+      '❌ ' + stageLabel(stage) + '阶段未完成：' + (result.error || '完成度校验未通过'),
+      errors.length ? '\n' + errors.join('\n') : '',
+      '\n可重新运行 `/fancy-build ' + stageCommand(stage) + '`；插件将再次执行完成度校验。',
+    ].filter(Boolean).join('\n'));
+  } catch (err) {
+    return notify(session, 'error', '❌ ' + stageLabel(stage) + '阶段执行失败：' + (err && err.message ? err.message : String(err)));
+  }
+}