@cloud411716/fancy-webnovel 2.2.0 → 3.0.3

package/plugins/fancy-material/inventory.js

@@ -0,0 +1,145 @@
+/**
+ * Existing-library inventory for the next generation run.
+ *
+ * The material library is append-only. Before asking the model for a batch we
+ * write a compact index of existing cards so the model can grep candidate
+ * names instead of inventing duplicates. The database also has a UNIQUE index
+ * on (kind, name), so exact duplicates are rejected even if the model misses
+ * one in the index.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { connectMaterial } from '#material-db';
+import { workspacePaths } from '#workspace';
+
+function clean(value) {
+  return String(value == null ? '' : value).replace(/\r?\n/g, ' ').trim();
+}
+
+/**
+ * Write an existing-material index to <workspace>/.tmp.
+ *
+ * One JSON object per line: { kind, name, tags, genres }.
+ * It is intentionally a file, not prompt text: the model can grep/search it
+ * without loading a six-figure line list into the context window.
+ *
+ * @param {string} root workspace directory
+ * @param {string[]} genres selected genres; empty means all
+ * @param {string} stamp run stamp
+ * @returns {Promise<{file: string, count: number}>}
+ */
+export async function buildExistingIndex(root, genres, stamp) {
+  const { db } = await connectMaterial(root);
+  try {
+    const rows = await db.query('SELECT kind, name, tags, genres, source FROM material ORDER BY kind, name;');
+    const records = Array.isArray(rows) && Array.isArray(rows[0]) ? rows[0] : [];
+    const selected = new Set((genres || []).filter(Boolean));
+    const filtered = selected.size
+      ? records.filter((record) => (Array.isArray(record.genres) ? record.genres : [])
+        .some((genre) => selected.has(String(genre))))
+      : records;
+    const file = path.join(
+      workspacePaths(root).tmp,
+      'fancy_material_existing_' + (stamp || String(Date.now())) + '.jsonl',
+    );
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const lines = filtered.map((record) => JSON.stringify({
+      kind: clean(record.kind),
+      name: clean(record.name),
+      tags: Array.isArray(record.tags) ? record.tags.map(clean) : [],
+      genres: Array.isArray(record.genres) ? record.genres.map(clean) : [],
+      source: clean(record.source) || 'builtin',
+    }));
+    fs.writeFileSync(file, lines.length ? lines.join('\n') + '\n' : '', 'utf8');
+    return { file, count: filtered.length };
+  } finally {
+    try { await db.close(); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Count existing materials per kind for the selected genres.
+ *
+ * A material can carry several genres. Counting with CONTAINSANY counts each
+ * material once, unlike summing per-genre counts and double-counting cards.
+ *
+ * @param {string} root workspace directory
+ * @param {string[]} genres selected genres; empty means all
+ * @returns {Promise<Record<string, number>>}
+ */
+export async function countByKind(root, genres) {
+  const { db } = await connectMaterial(root);
+  try {
+    const list = (genres || []).filter(Boolean);
+    // count() over a CONTAINSANY predicate counts every matching array
+    // element, not every record. Count ids through a subquery instead.
+    const rows = list.length
+      ? await db.query(
+        'SELECT kind, count() AS n FROM (SELECT id, kind FROM material WHERE genres CONTAINSANY $genres) GROUP BY kind;',
+        { genres: list },
+      )
+      : await db.query('SELECT kind, count() AS n FROM material GROUP BY kind;');
+    const grouped = Array.isArray(rows) && Array.isArray(rows[0]) ? rows[0] : [];
+    return Object.fromEntries(grouped.map((row) => [String(row.kind), Number(row.n) || 0]));
+  } finally {
+    try { await db.close(); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Count one kind for the selected genres.
+ *
+ * @param {string} root workspace directory
+ * @param {string} kind material kind
+ * @param {string[]} genres selected genres; empty means all
+ * @returns {Promise<number>}
+ */
+export async function countKind(root, kind, genres) {
+  const { db } = await connectMaterial(root);
+  try {
+    const list = (genres || []).filter(Boolean);
+    const rows = list.length
+      ? await db.query(
+        'SELECT count() AS n FROM (SELECT VALUE id FROM material WHERE kind = $kind AND genres CONTAINSANY $genres) GROUP ALL;',
+        { kind, genres: list },
+      )
+      : await db.query(
+        'SELECT count() AS n FROM material WHERE kind = $kind GROUP ALL;',
+        { kind },
+      );
+    const row = Array.isArray(rows) && Array.isArray(rows[0]) ? rows[0][0] : null;
+    return row ? Number(row.n) || 0 : 0;
+  } finally {
+    try { await db.close(); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Count existing materials per genre and kind.
+ *
+ * @param {string} root workspace directory
+ * @param {string[]} genres selected genres; empty means all
+ * @returns {Promise<Record<string, Record<string, number>>|null>}
+ */
+export async function countByGenreKind(root, genres) {
+  const { db } = await connectMaterial(root);
+  try {
+    const list = (genres || []).filter(Boolean);
+    if (!list.length) return null;
+    const out = {};
+    for (const genre of list) {
+      const rows = await db.query(
+        'SELECT kind, count() AS n FROM material WHERE genres CONTAINS $genre GROUP BY kind;',
+        { genre },
+      );
+      const grouped = Array.isArray(rows) && Array.isArray(rows[0]) ? rows[0] : [];
+      out[genre] = Object.fromEntries(grouped.map((row) => [String(row.kind), Number(row.n) || 0]));
+    }
+    return out;
+  } catch {
+    return null;
+  } finally {
+    try { await db.close(); } catch { /* ignore */ }
+  }
+}

package/plugins/fancy-material/kinds.js

@@ -0,0 +1,313 @@
+/**
+ * Atomic material catalog.
+ *
+ * One record is one small block: a name, a trait phrase, a cost sentence, a
+ * color phrase, a rule, a hook, etc. All blocks share the same five fields:
+ * id / kind / name / tags / genres (+ optional note).
+ */
+
+export const KIND_GROUPS = [
+  {
+    title: '命名',
+    kinds: [
+      'surname', 'given_name', 'nickname', 'place_name', 'faction_name',
+      'skill_name', 'ability_name', 'item_name', 'monster_name', 'mythic_being', 'rank_name',
+    ],
+  },
+  {
+    title: '人物',
+    kinds: [
+      'person_appearance', 'person_temperament', 'person_personality', 'person_habit',
+      'person_voice', 'person_background',
+    ],
+  },
+  {
+    title: '关系与情绪',
+    kinds: ['reaction'],
+  },
+  {
+    title: '能力',
+    kinds: [
+      'ability_mechanism', 'ability_activation', 'ability_cost', 'ability_limit',
+      'ability_counter', 'power_source',
+    ],
+  },
+  {
+    title: '物品',
+    kinds: [
+      'item_form', 'item_material', 'item_function',
+      'item_visual',
+    ],
+  },
+  {
+    title: '场景与感官',
+    kinds: [
+      'location_feature', 'weather', 'sensory_taste', 'sensory_visual',
+    ],
+  },
+  {
+    title: '描写词库',
+    kinds: [
+      'color_word', 'light_word', 'sound_word', 'smell_word', 'touch_word',
+      'effect_word', 'speed_word', 'atmosphere_word', 'appearance_word',
+      'expression_word', 'action_verb',
+    ],
+  },
+  {
+    title: '世界与势力',
+    kinds: [
+      'world_rule', 'faction_culture', 'faction_symbol', 'ritual',
+    ],
+  },
+  {
+    title: '剧情与脑洞',
+    kinds: [
+      'brainstorm', 'conflict_seed', 'conflict_escalation', 'plot_twist',
+      'mystery_seed', 'payoff_scene', 'trope',
+    ],
+  },
+];
+
+export const MATERIAL_KINDS = KIND_GROUPS.flatMap((group) => group.kinds);
+
+export const KIND_LABELS = {
+  surname: '姓氏',
+  given_name: '名',
+  nickname: '绰号/代号',
+  place_name: '地名',
+  faction_name: '势力/组织名',
+  skill_name: '功法/招式/技能名',
+  ability_name: '超能力/异能名',
+  item_name: '武器/法宝/道具名',
+  monster_name: '普通怪物/妖兽名（非神话）',
+  mythic_being: '神话人物/上古凶兽/超自然物种/神祇',
+  rank_name: '境界/等级/职位',
+  person_appearance: '外貌特征',
+  person_temperament: '气质',
+  person_personality: '性格/行为模式',
+  person_habit: '习惯/怪癖',
+  person_voice: '说话风格',
+  person_background: '身份/职业/出身',
+  reaction: '反应/微表情',
+  ability_mechanism: '能力机制',
+  ability_activation: '发动条件',
+  ability_cost: '能力代价',
+  ability_limit: '能力限制',
+  ability_counter: '反制方式',
+  power_source: '力量来源',
+  item_form: '物品外形',
+  item_material: '物品材质',
+  item_function: '物品功能',
+  item_visual: '视觉/声音特征',
+  location_feature: '地点特征',
+  weather: '天气',
+  sensory_taste: '味觉',
+  sensory_visual: '视觉画面',
+  color_word: '颜色描述',
+  light_word: '光影描述',
+  sound_word: '声音描述',
+  smell_word: '气味描述',
+  touch_word: '触感描述',
+  effect_word: '特效描述',
+  speed_word: '速度/力量描述',
+  atmosphere_word: '氛围描述',
+  appearance_word: '容貌/体态描述',
+  expression_word: '表情/眼神描述',
+  action_verb: '动作动词',
+  world_rule: '世界规则',
+  faction_culture: '势力文化/规矩',
+  faction_symbol: '标志/信物',
+  ritual: '仪式/习俗',
+  brainstorm: '脑洞/高概念',
+  conflict_seed: '冲突种子',
+  conflict_escalation: '冲突升级',
+  plot_twist: '反转',
+  mystery_seed: '谜题种子',
+  payoff_scene: '爽点/兑现场景',
+  trope: '套路/反套路',
+};
+
+const DEFAULT_HINTS = {
+  surname: '一个姓氏',
+  given_name: '一个名',
+  nickname: '一个绰号或代号',
+  place_name: '一个地名',
+  faction_name: '一个势力/组织名',
+  skill_name: '一个功法/招式/技能名',
+  ability_name: '一个超能力/异能名',
+  item_name: '一个武器/法宝/道具名',
+  monster_name: '一个普通怪物/妖兽名（非神话神祇）',
+  mythic_being: '一个神话人物、上古凶兽、超自然物种或神祇名（不限文化体系）',
+  rank_name: '一个境界/等级/职位名',
+  person_appearance: '一句可观察的外貌特征',
+  person_temperament: '一句气质描述',
+  person_personality: '一句性格或行为模式',
+  person_habit: '一个习惯或怪癖',
+  person_voice: '一句说话风格',
+  person_background: '一句身份/职业/出身',
+  reaction: '一个反应或微表情',
+  ability_mechanism: '一句能力机制',
+  ability_activation: '一句发动条件',
+  ability_cost: '一句能力代价',
+  ability_limit: '一句能力限制',
+  ability_counter: '一句反制方式',
+  power_source: '一句力量来源',
+  item_form: '一句物品外形',
+  item_material: '一句物品材质',
+  item_function: '一句物品功能',
+  item_visual: '一句视觉/声音特征',
+  location_feature: '一句空间/地貌特征',
+  weather: '一句天气',
+  sensory_taste: '一句味觉',
+  sensory_visual: '一句视觉画面',
+  color_word: '一个颜色描述词',
+  light_word: '一个光影描述词',
+  sound_word: '一个声音描述词',
+  smell_word: '一个气味描述词',
+  touch_word: '一个触感描述词',
+  effect_word: '一个特效描述词',
+  speed_word: '一个速度/力量描述词',
+  atmosphere_word: '一个氛围描述词',
+  appearance_word: '一个容貌/体态描述词',
+  expression_word: '一个表情/眼神描述词',
+  action_verb: '一个动作动词或短语',
+  world_rule: '一句世界规则',
+  faction_culture: '一句势力文化/规矩',
+  faction_symbol: '一句标志/信物',
+  ritual: '一句仪式/习俗',
+  brainstorm: '一句脑洞/高概念',
+  conflict_seed: '一句冲突种子',
+  conflict_escalation: '一句冲突升级方式',
+  plot_twist: '一句反转',
+  mystery_seed: '一句谜题种子',
+  payoff_scene: '一句爽点/兑现场景',
+  trope: '一句套路/反套路',
+};
+
+const EXTRA_ALIASES = {
+  命名: ['surname', 'given_name', 'nickname', 'place_name', 'faction_name', 'skill_name', 'ability_name', 'item_name', 'monster_name', 'mythic_being', 'rank_name'],
+  人物: ['person_appearance', 'person_temperament', 'person_personality', 'person_habit', 'person_voice', 'person_background'],
+  人物性格: ['person_personality'],
+  人物外貌: ['person_appearance'],
+  能力: ['ability_name', 'ability_mechanism', 'ability_activation', 'ability_cost', 'ability_limit', 'ability_counter', 'power_source',],
+  物品: ['item_name', 'item_form', 'item_material', 'item_function', 'item_visual'],
+  场景: ['location_feature', 'weather', 'sensory_taste', 'sensory_visual'],
+  描写: ['color_word', 'light_word', 'sound_word', 'smell_word', 'touch_word', 'effect_word', 'speed_word', 'atmosphere_word', 'appearance_word', 'expression_word', 'action_verb'],
+  世界: ['world_rule', 'faction_culture', 'faction_symbol', 'ritual'],
+  剧情: ['brainstorm', 'conflict_seed', 'conflict_escalation', 'plot_twist', 'mystery_seed', 'payoff_scene', 'trope'],
+  姓名: ['surname', 'given_name'],
+  人名: ['surname', 'given_name', 'nickname'],
+  名字: ['given_name'],
+  姓氏: ['surname'],
+  地名: ['place_name'],
+  地点: ['place_name', 'location_feature'],
+  门派: ['faction_name'],
+  组织: ['faction_name'],
+  势力: ['faction_name'],
+  功法: ['skill_name'],
+  招式: ['skill_name'],
+  技能: ['skill_name'],
+  异能: ['ability_name'],
+  超能力: ['ability_name'],
+  金手指: ['ability_name', 'ability_mechanism', 'ability_cost', 'ability_limit'],
+  武器: ['item_name', 'item_form', 'item_function'],
+  道具: ['item_name', 'item_form', 'item_function'],
+  法宝: ['item_name', 'item_form', 'item_function'],
+  怪物: ['monster_name'],
+  妖兽: ['monster_name'],
+  神话: ['mythic_being'],
+  神话人物: ['mythic_being'],
+  神话生物: ['mythic_being'],
+  凶兽: ['mythic_being'],
+  神祇: ['mythic_being'],
+  神明: ['mythic_being'],
+  神灵: ['mythic_being'],
+  超自然物种: ['mythic_being'],
+  境界: ['rank_name',],
+  等级: ['rank_name',],
+  颜色: ['color_word'],
+  颜色词: ['color_word'],
+  光影: ['light_word'],
+  声音: ['sound_word',],
+  气味: ['smell_word',],
+  触感: ['touch_word',],
+  特效: ['effect_word'],
+  外貌: ['person_appearance', 'appearance_word'],
+  性格: ['person_personality'],
+  气质: ['person_temperament'],
+  习惯: ['person_habit'],
+  机制: ['ability_mechanism'],
+  代价: ['ability_cost',],
+  限制: ['ability_limit',],
+  反制: ['ability_counter'],
+  克制: ['ability_counter'],
+  世界规则: ['world_rule'],
+  规则: ['world_rule'],
+  脑洞: ['brainstorm'],
+  冲突: ['conflict_seed'],
+  反转: ['plot_twist'],
+  场景: ['location_feature'],
+};
+
+function normalize(text) {
+  return String(text || '').trim().replace(/[类素材的]/g, '');
+}
+
+/**
+ * Resolve a user focus such as "地名" to one or more atomic kinds.
+ * Unknown values return an empty kind list; the caller can show an error or
+ * put the raw focus in the prompt.
+ */
+export function resolveFocus(raw) {
+  const query = normalize(raw);
+  if (!query) return { query: '', kinds: [] };
+  const lower = query.toLowerCase();
+
+  // Exact kind id.
+  const exactKind = MATERIAL_KINDS.find((kind) => kind === lower);
+  if (exactKind) return { query, kinds: [exactKind] };
+
+  // Exact label.
+  const labelMatches = Object.entries(KIND_LABELS)
+    .filter(([, label]) => label === query)
+    .map(([kind]) => kind);
+  if (labelMatches.length) return { query, kinds: labelMatches };
+
+  // Explicit aliases.
+  if (EXTRA_ALIASES[query]) return { query, kinds: EXTRA_ALIASES[query] };
+
+  // Fuzzy label/kind contains.
+  const fuzzy = MATERIAL_KINDS.filter((kind) => {
+    const label = KIND_LABELS[kind] || '';
+    return kind.includes(lower) || label.includes(query) || query.includes(label);
+  });
+  if (fuzzy.length) return { query, kinds: fuzzy };
+
+  return { query, kinds: [] };
+}
+
+export function renderKindTable() {
+  const lines = [];
+  for (const group of KIND_GROUPS) {
+    lines.push(`**${group.title}**`);
+    lines.push('');
+    lines.push('| kind | 中文名 | name 写什么 |');
+    lines.push('| --- | --- | --- |');
+    for (const kind of group.kinds) {
+      lines.push(`| \`${kind}\` | ${KIND_LABELS[kind] || kind} | ${DEFAULT_HINTS[kind] || ''} |`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n').trim();
+}
+
+export function focusBlock(focus) {
+  if (!focus || !focus.query) {
+    return '本批只生成插件指定的**一个** kind。kind 和条数在「本次运行」里给出；不要在同一批文件里混写其它 kind。插件会把全部 ' + MATERIAL_KINDS.length + ' 个 kind 排成队列，逐个生成到目标数量。';
+  }
+  if (!focus.kinds.length) {
+    return `本批用户指定的重点是「${focus.query}」。请从「素材类型总表」中选择最匹配的一个 kind，只生成这个 kind；如果无法判断，选择最接近的一个 kind。其他质量、题材、追加和查询规则继续适用。`;
+  }
+  const list = focus.kinds.map((kind) => `\`${kind}\`（${KIND_LABELS[kind] || kind}）`).join('、');
+  return `本批用户指定的重点是「${focus.query}」，对应 ${list}。插件会按顺序逐个 kind 排队，每个批次只写一个 kind；不要生成其它 kind。其他质量、题材、追加和查询规则继续适用。`;
+}

package/plugins/fancy-material/queue.js

@@ -0,0 +1,55 @@
+/**
+ * Pure queue planning for a material generation run.
+ *
+ * A run has a quota per kind (50 by default), not a cap on the library. The
+ * generated counts are scoped to this run: a second run starts from zero and
+ * appends another 50 entries per kind. The plugin fills quotas in batches, one
+ * kind at a time.
+ */
+
+/**
+ * @param {Object} opts
+ * @param {string[]} opts.kinds ordered kinds to cover
+ * @param {Record<string, number>} [opts.generated] entries already generated by this run
+ * @param {number} opts.target per-run quota per kind
+ * @returns {{all: Array, pending: Array, completed: Array, target: number}}
+ */
+export function planMaterialQueue({ kinds, generated = {}, target }) {
+  const targetCount = Math.max(1, Number(target) || 1);
+  const all = (kinds || []).map((kind) => {
+    const done = Math.max(0, Number(generated[kind]) || 0);
+    const remaining = Math.max(0, targetCount - done);
+    return {
+      kind,
+      generated: done,
+      target: targetCount,
+      remaining,
+      status: remaining > 0 ? 'pending' : 'done',
+    };
+  });
+  return {
+    all,
+    pending: all.filter((item) => item.remaining > 0),
+    completed: all.filter((item) => item.remaining === 0),
+    target: targetCount,
+  };
+}
+
+/**
+ * How many entries should the next batch ask for?
+ *
+ * @param {Object} opts
+ * @param {number} opts.generated entries already generated by this run
+ * @param {number} opts.target per-run quota per kind
+ * @param {number} opts.batchSize
+ * @returns {{remaining: number, requestCount: number}}
+ */
+export function nextBatchRequest({ generated, target, batchSize }) {
+  const targetCount = Math.max(1, Number(target) || 1);
+  const size = Math.max(1, Number(batchSize) || 1);
+  const remaining = Math.max(0, targetCount - Math.max(0, Number(generated) || 0));
+  return {
+    remaining,
+    requestCount: Math.min(size, remaining),
+  };
+}