@cloud411716/fancy-webnovel 2.2.0 → 3.0.0

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

@@ -0,0 +1,458 @@
+#!/usr/bin/env node
+/**
+ * storydb CLI — the LLM-facing workbench for the story graph.
+ *
+ * Usage:
+ *   storydb schema [table]
+ *   storydb get character C001
+ *   storydb search character --where status=draft --limit 20
+ *   storydb context --chapter 341 --prev 3
+ *   storydb context --entity foreshadow:FS012
+ *   storydb create foreshadow '{"id":"FS012","name":"空白的来源栏"}'
+ *   storydb update foreshadow FS012 '{"status":"draft"}'
+ *   storydb link foreshadow_action chapter:CH341 foreshadow:FS012 '{"action":"plant"}'
+ *   storydb unlink foreshadow_action chapter:CH341 foreshadow:FS012 --action plant
+ *   storydb apply ops.json
+ *   storydb validate --scope chapter:CH341
+ *   storydb next --limit 20
+ *   storydb why foreshadow:FS012
+ *   storydb history foreshadow:FS012
+ *   storydb query "SELECT ..."
+ *   storydb impact relation C001 C002 --to 对立 --from 341
+ *   storydb impact foreshadow FS012 --action reveal --chapter 400
+ *   storydb export md 30-cast
+ *   storydb export decisions
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { openStoryGraph, ensureRootStory, StoryDbError, flattenError } from './client.js';
+import {
+  apply,
+  createEntity,
+  updateEntity,
+  getEntity,
+  searchEntities,
+  linkEdge,
+  unlinkEdge,
+  validate,
+  nextWork,
+  decisionsFor,
+  readQuery,
+} from './store.js';
+import { schemaCard, allSchemaCards } from './compile.js';
+import { ENTITIES, EDGES } from './definitions.js';
+import { chapterContext, entityContext } from './context.js';
+import { impactRelation, impactForeshadow } from './impact.js';
+import { exportMarkdown } from './export.js';
+import { importStage } from './import.js';
+import { stageCheck } from './stage.js';
+
+function parseArgs(argv) {
+  const args = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token.startsWith('--')) {
+      const key = token.slice(2);
+      if (key === 'per-chapter' || key === 'memory') {
+        flags[key] = true;
+        continue;
+      }
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        flags[key] = next;
+        i += 1;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      args.push(token);
+    }
+  }
+  return { args, flags };
+}
+
+function readJson(file) {
+  if (file === '-' || file === '/dev/stdin') {
+    return JSON.parse(fs.readFileSync(0, 'utf8'));
+  }
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function print(value) {
+  process.stdout.write(JSON.stringify(value, null, 2) + '\n');
+}
+
+function projectRoot(flags) {
+  return path.resolve(flags.db || flags.project || process.cwd());
+}
+
+async function withDb(flags, fn) {
+  const root = projectRoot(flags);
+  const sdb = await openStoryGraph(root, {
+    memory: Boolean(flags.memory),
+    workspace: flags.workspace && flags.workspace !== true ? flags.workspace : undefined,
+    project: flags.project && flags.project !== true ? flags.project : undefined,
+    admin: Boolean(flags.admin),
+  });
+  try {
+    await ensureRootStory(sdb, {});
+    return await fn(sdb, root);
+  } finally {
+    await sdb.close();
+  }
+}
+
+function decisionFrom(flags, subject) {
+  if (!flags.decision || flags.decision === true) return [];
+  return [{ subject, scope: subject, text: String(flags.decision) }];
+}
+
+async function main() {
+  const { args, flags } = parseArgs(process.argv.slice(2));
+  const command = (args[0] || 'help').toLowerCase();
+
+  if (command === 'help' || command === '--help' || command === '-h') {
+    print({
+      commands: [
+        'init', 'schema', 'get', 'search', 'context', 'create', 'update',
+        'link', 'unlink', 'apply', 'validate', 'next', 'why', 'history',
+        'query', 'impact', 'export', 'import', 'stage-check',
+      ],
+      flags: ['--db <project-dir>', '--workspace <workspace>', '--project <name|uuid>', '--memory'],
+      examples: [
+        'storydb schema --list (列出全部表名)',
+        'storydb schema (不带表名时列出全部字段卡片)',
+        'storydb schema foreshadow',
+        'storydb context --chapter 341 --prev 3',
+        'storydb create foreshadow \'{"id":"FS012","name":"空白的来源栏"}\'',
+        'storydb link foreshadow_action chapter:CH341 foreshadow:FS012 \'{"action":"plant"}\'',
+        'storydb apply --per-chapter chapters.json',
+        'storydb validate --scope chapter:CH341',
+        'storydb stage-check rhythm',
+      ],
+    });
+    return;
+  }
+
+  if (command === 'init') {
+    return withDb(flags, async (sdb) => {
+      const story = await sdb.one('SELECT * FROM story:main;');
+      print({ ok: true, story });
+    });
+  }
+
+  if (command === 'schema') {
+    if (flags.list) {
+      print({ ok: true, entities: Object.keys(ENTITIES), edges: Object.keys(EDGES) });
+      return;
+    }
+    const table = args[1];
+    if (table) {
+      const card = schemaCard(table);
+      if (!card) throw new StoryDbError('UNKNOWN_TABLE', '未知表：' + table);
+      print({ ok: true, table, card });
+    } else {
+      print({ ok: true, cards: allSchemaCards() });
+    }
+    return;
+  }
+
+  if (command === 'get') {
+    return withDb(flags, async (sdb) => {
+      const kind = args[1];
+      const id = args[2];
+      if (!kind || !id) throw new StoryDbError('USAGE', '用法：storydb get <kind> <id>');
+      print({ ok: true, entity: await getEntity(sdb, kind, id) });
+    });
+  }
+
+  if (command === 'search') {
+    return withDb(flags, async (sdb) => {
+      const kind = args[1];
+      if (!kind) throw new StoryDbError('USAGE', '用法：storydb search <kind> [--where k=v]');
+      const where = {};
+      for (const [key, value] of Object.entries(flags)) {
+        if (key.startsWith('where.')) where[key.slice(6)] = value;
+      }
+      if (flags.where && flags.where !== true) {
+        for (const pair of String(flags.where).split(',')) {
+          const idx = pair.indexOf('=');
+          if (idx > 0) where[pair.slice(0, idx)] = pair.slice(idx + 1);
+        }
+      }
+      print({ ok: true, rows: await searchEntities(sdb, kind, { where, limit: flags.limit }) });
+    });
+  }
+
+  if (command === 'context') {
+    return withDb(flags, async (sdb) => {
+      if (flags.entity) {
+        const [kind, id] = String(flags.entity).split(':');
+        if (!kind || !id) throw new StoryDbError('USAGE', '--entity 需要 kind:id');
+        print({ ok: true, context: await entityContext(sdb, kind, id) });
+        return;
+      }
+      if (!flags.chapter) throw new StoryDbError('USAGE', '用法：storydb context --chapter N [--prev K]');
+      print({
+        ok: true,
+        context: await chapterContext(sdb, Number(flags.chapter), {
+          prev: Number(flags.prev) || 0,
+          tailChars: Number(flags.tail) || 600,
+          search: flags.search && flags.search !== true ? String(flags.search) : '',
+        }),
+      });
+    });
+  }
+
+  if (command === 'create') {
+    return withDb(flags, async (sdb) => {
+      const kind = args[1];
+      if (!kind) throw new StoryDbError('USAGE', '用法：storydb create <kind> \'<json>\'');
+      const raw = args.slice(2).join(' ') || (flags.file ? fs.readFileSync(flags.file, 'utf8') : '{}');
+      const data = JSON.parse(raw);
+      const id = data.id || data.entity_id || data.chapter_id;
+      print({ ok: true, result: await apply(sdb, {
+        workflow: flags.workflow || 'manual',
+        summary: flags.summary || ('create ' + kind + ' ' + (id || '')),
+        ops: [{ op: 'create', kind, data }],
+        decisions: decisionFrom(flags, kind + ':' + id),
+      }) });
+    });
+  }
+
+  if (command === 'update') {
+    return withDb(flags, async (sdb) => {
+      const kind = args[1];
+      const id = args[2];
+      if (!kind || !id) throw new StoryDbError('USAGE', '用法：storydb update <kind> <id> \'<json>\'');
+      const raw = args.slice(3).join(' ') || (flags.file ? fs.readFileSync(flags.file, 'utf8') : '{}');
+      print({ ok: true, result: await apply(sdb, {
+        workflow: flags.workflow || 'manual',
+        summary: flags.summary || ('update ' + kind + ' ' + id),
+        ops: [{ op: 'update', kind, id, data: JSON.parse(raw) }],
+        decisions: decisionFrom(flags, kind + ':' + id),
+      }) });
+    });
+  }
+
+  if (command === 'link') {
+    return withDb(flags, async (sdb) => {
+      const edge = args[1];
+      const from = args[2];
+      const to = args[3];
+      if (!edge || !from || !to) throw new StoryDbError('USAGE', '用法：storydb link <edge> <from> <to> \'<json>\'');
+      const data = args[4] ? JSON.parse(args.slice(4).join(' ')) : (flags.file ? JSON.parse(fs.readFileSync(flags.file, 'utf8')) : {});
+      print({ ok: true, result: await apply(sdb, {
+        workflow: flags.workflow || 'manual',
+        summary: flags.summary || ('link ' + edge + ' ' + from + ' -> ' + to),
+        ops: [{ op: 'link', edge, from, to, data }],
+        decisions: decisionFrom(flags, from),
+      }) });
+    });
+  }
+
+  if (command === 'unlink') {
+    return withDb(flags, async (sdb) => {
+      const edge = args[1];
+      const from = args[2];
+      const to = args[3];
+      if (!edge || !from || !to) throw new StoryDbError('USAGE', '用法：storydb unlink <edge> <from> <to>');
+      print({ ok: true, result: await apply(sdb, {
+        workflow: flags.workflow || 'manual',
+        summary: flags.summary || ('unlink ' + edge),
+        ops: [{ op: 'unlink', edge, from, to, data: flags.action ? { action: flags.action } : {} }],
+        decisions: decisionFrom(flags, from),
+      }) });
+    });
+  }
+
+  if (command === 'apply') {
+    return withDb(flags, async (sdb) => {
+      const file = args[1] || flags.file;
+      if (!file) throw new StoryDbError('USAGE', '用法：storydb apply <ops.json> 或 apply -');
+      const payload = readJson(file);
+      if (flags['per-chapter'] || flags.perChapter) payload.perChapter = true;
+      const result = await apply(sdb, payload);
+      print({ ok: result.ok !== false, result });
+      if (result.ok === false) process.exitCode = 1;
+    });
+  }
+
+  if (command === 'validate') {
+    return withDb(flags, async (sdb) => {
+      const report = await validate(sdb, { scope: flags.scope !== true ? flags.scope : null });
+      print({ ok: report.errors.length === 0, report });
+    });
+  }
+
+  if (command === 'next') {
+    return withDb(flags, async (sdb) => {
+      print({ ok: true, work: await nextWork(sdb, Number(flags.limit) || 20) });
+    });
+  }
+
+  if (command === 'why' || command === 'history') {
+    return withDb(flags, async (sdb) => {
+      const subject = args[1];
+      if (!subject) throw new StoryDbError('USAGE', '用法：storydb why <kind:id>');
+      print({ ok: true, decisions: await decisionsFor(sdb, subject, { activeOnly: command === 'why' }) });
+    });
+  }
+
+  if (command === 'query') {
+    return withDb(flags, async (sdb) => {
+      const text = args.slice(1).join(' ') || (flags.sql !== true ? flags.sql : '');
+      const tokens = String(text || '').trim().split(/\s+/).filter(Boolean);
+      const head = (tokens[0] || '').toLowerCase();
+      if (!head || head === 'status') {
+        const tables = ['volume', 'act', 'character', 'faction', 'location', 'conflict', 'foreshadow', 'payoff', 'chapter', 'outline', 'chapter_text', 'knowledge_event'];
+        const counts = {};
+        for (const table of tables) {
+          const rows = await sdb.rows(`SELECT count() FROM ${table} WHERE story = story:main GROUP ALL;`);
+          counts[table] = Number(rows[0] && rows[0].count) || 0;
+        }
+        print({ ok: true, counts });
+        return;
+      }
+      if (head === 'foreshadow') {
+        if (!tokens[1]) throw new StoryDbError('USAGE', '用法：query foreshadow <ID>');
+        print({ ok: true, context: await entityContext(sdb, 'foreshadow', tokens[1]) });
+        return;
+      }
+      if (head === 'character' || head === 'relations') {
+        if (!tokens[1]) throw new StoryDbError('USAGE', '用法：query character <ID>');
+        print({ ok: true, context: await entityContext(sdb, 'character', tokens[1]) });
+        return;
+      }
+      if (head === 'chapter') {
+        const range = /^(\d+)(?:\s*[-~]\s*(\d+))?$/.exec(tokens[1] || '');
+        if (!range) throw new StoryDbError('USAGE', '用法：query chapter <起>[-<止>]');
+        const from = Number(range[1]);
+        const to = Number(range[2] || range[1]);
+        const rows = await sdb.rows(
+          `SELECT chapter_id, display_no, title, volume, act, pov, word_target, emotion_value, hook_strength, status
+           FROM chapter WHERE story = story:main AND display_no >= $from AND display_no <= $to ORDER BY display_no;`,
+          { from, to },
+        );
+        print({ ok: true, chapters: rows });
+        return;
+      }
+      if (head === 'knowledge') {
+        const id = tokens[1];
+        if (!id) throw new StoryDbError('USAGE', '用法：query knowledge <人物ID> [--chapter N]');
+        const chapterFlag = tokens.indexOf('--chapter');
+        const chapterNo = chapterFlag >= 0 ? Number(tokens[chapterFlag + 1]) : null;
+        const character = await sdb.one(
+          `SELECT * FROM character WHERE story = story:main AND (entity_id = $q OR name = $q) LIMIT 1;`,
+          { q: id },
+        );
+        if (!character) throw new StoryDbError('NOT_FOUND', '未找到人物：' + id);
+        const subject = `type::record(${JSON.stringify('character:⟨' + String(character.entity_id) + '⟩')})`;
+        if (!chapterNo) {
+          const rows = await sdb.rows(
+            `SELECT subject_type, subject_id, state FROM knowledge_state
+             WHERE story = story:main AND character = ${subject} ORDER BY subject_type, subject_id;`,
+          );
+          print({ ok: true, character: character.entity_id, knowledge: rows });
+          return;
+        }
+        const events = await sdb.rows(
+          `SELECT chapter_no, subject_type, subject_id, change, coverage FROM knowledge_event
+           WHERE story = story:main AND character_id = $id AND chapter_no <= $chapter ORDER BY chapter_no, id;`,
+          { id: character.entity_id, chapter: chapterNo },
+        );
+        const latest = new Map();
+        for (const event of events) latest.set(event.subject_type + ':' + event.subject_id, event);
+        print({ ok: true, character: character.entity_id, at: chapterNo, knowledge: [...latest.values()] });
+        return;
+      }
+      if (head === 'sql') {
+        print({ ok: true, rows: await readQuery(sdb, tokens.slice(1).join(' ')) });
+        return;
+      }
+      if (/^(select|info|return|show|describe|explain)\b/i.test(text)) {
+        print({ ok: true, rows: await readQuery(sdb, text) });
+        return;
+      }
+      throw new StoryDbError('USAGE', '未知查询：' + text);
+    });
+  }
+
+  if (command === 'impact') {
+    return withDb(flags, async (sdb) => {
+      const kind = args[1];
+      if (kind === 'relation') {
+        print({ ok: true, impact: await impactRelation(sdb, args[2], args[3], {
+          newKind: flags.to !== true ? flags.to : null,
+          fromChapter: Number(flags.from) || 1,
+        }) });
+        return;
+      }
+      if (kind === 'foreshadow') {
+        print({ ok: true, impact: await impactForeshadow(sdb, args[2], {
+          action: flags.action !== true ? flags.action : null,
+          chapter: flags.chapter !== true ? Number(flags.chapter) : null,
+        }) });
+        return;
+      }
+      throw new StoryDbError('USAGE', '用法：storydb impact relation|foreshadow ...');
+    });
+  }
+
+  if (command === 'stage-check') {
+    return withDb(flags, async (sdb) => {
+      const stage = args[1];
+      if (!stage) throw new StoryDbError('USAGE', '用法：storydb stage-check <scale|macro|cast|rhythm|outline|writing>');
+      const report = await stageCheck(sdb, stage);
+      print({ ok: report.ok, report });
+      if (!report.ok) process.exitCode = 1;
+    });
+  }
+
+  if (command === 'import') {
+    return withDb(flags, async (sdb, root) => {
+      const stage = args[1] || 'all';
+      const stages = stage === 'all'
+        ? ['scale', 'macro', 'cast', 'rhythm', 'outline', 'writing']
+        : [stage];
+      const results = [];
+      for (const name of stages) {
+        try {
+          const result = await importStage(sdb, name, root, {
+            onProgress: (info) => {
+              if (flags.verbose) process.stderr.write(JSON.stringify({ stage: name, ...info }) + '\n');
+            },
+          });
+          results.push({ stage: name, ok: true, result });
+        } catch (err) {
+          results.push({ stage: name, ok: false, error: err.message, code: err.code });
+          if (!flags.continue) break;
+        }
+      }
+      print({ ok: results.every((r) => r.ok), results });
+    });
+  }
+
+  if (command === 'export') {
+    return withDb(flags, async (sdb, root) => {
+      const sub = args[1] || 'all';
+      const what = sub === 'md' ? (args[2] || 'all') : (args[2] || sub);
+      if (what === 'decisions' || sub === 'decisions') {
+        print({ ok: true, result: await exportMarkdown(sdb, root, 'decisions') });
+        return;
+      }
+      print({ ok: true, result: await exportMarkdown(sdb, root, what) });
+    });
+  }
+
+  throw new StoryDbError('UNKNOWN_COMMAND', '未知命令：' + command);
+}
+
+main().catch((err) => {
+  const code = err && err.code ? err.code : 'ERROR';
+  const message = err && err.message ? err.message : String(err);
+  process.stderr.write(JSON.stringify({ ok: false, error: { code, message, detail: err && err.detail || null } }, null, 2) + '\n');
+  process.exitCode = 1;
+});