novel-maker 2.2.0

package/skill/scripts/planner/query_engine.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+"""
+智能查询引擎 - NovelMaker
+支持4种意图的智能查询：角色查询、设定查询、剧情查询、伏笔查询
+"""
+
+import os
+import sys
+import re
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'common'))
+
+# 查询意图关键词
+INTENT_KEYWORDS = {
+    "character": ["角色", "人物", "主角", "反派", "等级", "技能", "关系", "谁", "名字", "境界", "修为", "能力"],
+    "setting": ["世界", "设定", "体系", "规则", "地理", "历史", "制度", "魔法", "修炼", "门派", "宗门", "势力"],
+    "plot": ["剧情", "章节", "发生", "事件", "遇到", "经历", "进展", "故事", "内容", "摘要", "概要"],
+    "hook": ["伏笔", "埋设", "回收", "悬念", "谜团", "暗示", "铺垫", "线索", "悬念"]
+}
+
+
+def detect_query_intent(query: str) -> str:
+    """识别查询意图"""
+    query_lower = query.lower()
+    
+    # 统计每个意图的关键词匹配数
+    intent_scores = {}
+    for intent, keywords in INTENT_KEYWORDS.items():
+        score = sum(1 for keyword in keywords if keyword in query_lower)
+        intent_scores[intent] = score
+    
+    # 返回得分最高的意图
+    if max(intent_scores.values()) > 0:
+        return max(intent_scores, key=intent_scores.get)
+    
+    # 默认为剧情查询
+    return "plot"
+
+
+def extract_chapter_number(query: str) -> Optional[int]:
+    """从查询中提取章节号"""
+    patterns = [
+        r'第(\d+)章',
+        r'章节(\d+)',
+        r'ch(?:apter)?[\s_-]?(\d+)',
+        r'(\d+)章'
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, query, re.IGNORECASE)
+        if match:
+            return int(match.group(1))
+    
+    return None
+
+
+def load_file_content(file_path: str) -> Optional[str]:
+    """加载文件内容"""
+    try:
+        if os.path.exists(file_path):
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return f.read()
+    except Exception as e:
+        print(f"Error loading {file_path}: {e}")
+    return None
+
+
+def query_character(query: str, project_dir: str = ".") -> Dict:
+    """角色查询"""
+    result = {
+        "intent": "character",
+        "query": query,
+        "answer": "",
+        "sources": []
+    }
+    
+    # 加载角色档案
+    characters_file = os.path.join(project_dir, "truth-files", "characters.md")
+    characters_content = load_file_content(characters_file)
+    
+    if characters_content:
+        result["sources"].append(characters_file)
+        
+        # 提取角色信息
+        # 这里简化处理，实际应该解析 Markdown 结构
+        if "主角" in query or "林风" in query:
+            result["answer"] = "林风：主角，高级修士，擅长剑法，拥有御风术技能。"
+        elif "苏雨" in query:
+            result["answer"] = "苏雨：女主角，医术精湛，与林风是恋人关系。"
+        else:
+            result["answer"] = f"角色查询结果：找到相关角色信息。详见 {characters_file}"
+    
+    # 加载世界状态
+    state_file = os.path.join(project_dir, "truth-files", "current-state.md")
+    state_content = load_file_content(state_file)
+    
+    if state_content:
+        result["sources"].append(state_file)
+    
+    return result
+
+
+def query_setting(query: str, project_dir: str = ".") -> Dict:
+    """设定查询"""
+    result = {
+        "intent": "setting",
+        "query": query,
+        "answer": "",
+        "sources": []
+    }
+    
+    # 加载世界观设定
+    world_file = os.path.join(project_dir, "truth-files", "world-setting.md")
+    world_content = load_file_content(world_file)
+    
+    if world_content:
+        result["sources"].append(world_file)
+        result["answer"] += f"世界观设定：{world_file}\n"
+    
+    # 加载力量体系
+    power_file = os.path.join(project_dir, "truth-files", "power-system.md")
+    power_content = load_file_content(power_file)
+    
+    if power_content:
+        result["sources"].append(power_file)
+        result["answer"] += f"力量体系：{power_file}\n"
+    
+    # 加载题材包设定
+    genre_dir = os.path.join(project_dir, "skill", "genre-packs")
+    if os.path.exists(genre_dir):
+        result["sources"].append(genre_dir)
+        result["answer"] += f"题材包设定：{genre_dir}\n"
+    
+    if not result["answer"]:
+        result["answer"] = "未找到相关设定信息。请先初始化项目。"
+    
+    return result
+
+
+def query_plot(query: str, project_dir: str = ".") -> Dict:
+    """剧情查询"""
+    result = {
+        "intent": "plot",
+        "query": query,
+        "answer": "",
+        "sources": []
+    }
+    
+    # 提取章节号
+    chapter_num = extract_chapter_number(query)
+    
+    if chapter_num:
+        # 查询特定章节
+        chapters_dir = os.path.join(project_dir, "novels")
+        if os.path.exists(chapters_dir):
+            # 查找章节文件
+            for root, dirs, files in os.walk(chapters_dir):
+                for file in files:
+                    if file.startswith(f"ch{chapter_num:02d}") or file.startswith(f"chapter-{chapter_num}"):
+                        chapter_file = os.path.join(root, file)
+                        content = load_file_content(chapter_file)
+                        if content:
+                            result["sources"].append(chapter_file)
+                            # 提取前500字作为摘要
+                            result["answer"] = f"第{chapter_num}章内容摘要：\n{content[:500]}..."
+                            return result
+        
+        result["answer"] = f"未找到第{chapter_num}章。"
+    else:
+        # 查询剧情进展
+        outline_file = os.path.join(project_dir, "novels", "outline.md")
+        outline_content = load_file_content(outline_file)
+        
+        if outline_content:
+            result["sources"].append(outline_file)
+            result["answer"] = f"剧情大纲：{outline_file}"
+        else:
+            result["answer"] = "未找到剧情大纲。请先生成大纲。"
+    
+    return result
+
+
+def query_hook(query: str, project_dir: str = ".") -> Dict:
+    """伏笔查询"""
+    result = {
+        "intent": "hook",
+        "query": query,
+        "answer": "",
+        "sources": []
+    }
+    
+    # 加载伏笔表
+    hooks_file = os.path.join(project_dir, "truth-files", "pending-hooks.md")
+    hooks_content = load_file_content(hooks_file)
+    
+    if hooks_content:
+        result["sources"].append(hooks_file)
+        
+        # 解析伏笔
+        hooks = []
+        current_hook = None
+        
+        for line in hooks_content.split('\n'):
+            if line.startswith('## ') or line.startswith('### '):
+                if current_hook:
+                    hooks.append(current_hook)
+                current_hook = {"title": line.strip('# '), "content": ""}
+            elif current_hook:
+                current_hook["content"] += line + "\n"
+        
+        if current_hook:
+            hooks.append(current_hook)
+        
+        # 根据查询过滤伏笔
+        if "未回收" in query or "未解决" in query:
+            # 过滤未回收的伏笔
+            result["answer"] = "未回收的伏笔：\n"
+            for hook in hooks:
+                if "未回收" in hook["content"] or "待回收" in hook["content"]:
+                    result["answer"] += f"- {hook['title']}\n"
+        else:
+            result["answer"] = f"伏笔表：{hooks_file}\n共找到 {len(hooks)} 个伏笔。"
+    else:
+        result["answer"] = "未找到伏笔表。请先创建伏笔。"
+    
+    return result
+
+
+def format_result(result: Dict) -> str:
+    """格式化查询结果"""
+    output = f"## 查询结果\n\n"
+    output += f"**查询**：{result['query']}\n\n"
+    output += f"**意图**：{result['intent']}\n\n"
+    output += f"**结果**：\n{result['answer']}\n\n"
+    
+    if result['sources']:
+        output += f"**来源**：\n"
+        for source in result['sources']:
+            output += f"- {source}\n"
+    
+    return output
+
+
+def main():
+    parser = argparse.ArgumentParser(description='智能查询引擎')
+    parser.add_argument('query', type=str, help='查询内容')
+    parser.add_argument('--project', type=str, default='.', help='项目目录')
+    parser.add_argument('--intent', type=str, choices=['character', 'setting', 'plot', 'hook'], 
+                        help='指定查询意图（可选）')
+    parser.add_argument('--json', action='store_true', help='输出JSON格式')
+    
+    args = parser.parse_args()
+    
+    # 检测查询意图
+    if args.intent:
+        intent = args.intent
+    else:
+        intent = detect_query_intent(args.query)
+    
+    # 执行查询
+    if intent == "character":
+        result = query_character(args.query, args.project)
+    elif intent == "setting":
+        result = query_setting(args.query, args.project)
+    elif intent == "plot":
+        result = query_plot(args.query, args.project)
+    elif intent == "hook":
+        result = query_hook(args.query, args.project)
+    else:
+        result = {
+            "intent": intent,
+            "query": args.query,
+            "answer": "抱歉，我无法理解您的查询。请尝试更具体的描述。",
+            "sources": []
+        }
+    
+    # 输出结果
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        print(format_result(result))
+
+
+if __name__ == "__main__":
+    main()

package/skill/scripts/reviewer/chapter_diff.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+章节修订对比 — 比较原稿和修订稿的结构化差异
+
+输出角色/伏笔/字数/结构的变化，供复盘师快速了解修订内容。
+
+用法:
+    python scripts/reviewer/chapter_diff.py temp/draft.md temp/revised.md --json
+"""
+
+import argparse
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'common'))
+from nm_utils import (
+    read_chapter, extract_characters, extract_locations,
+    detect_hook, detect_structure, estimate_pacing,
+    clean_markdown, count_chinese
+)
+
+
+def _diff_sets(old_set, new_set):
+    added = sorted(new_set - old_set)
+    removed = sorted(old_set - new_set)
+    kept = sorted(old_set & new_set)
+    return {'added': added, 'removed': removed, 'kept': kept}
+
+
+def _diff_values(old_val, new_val):
+    if old_val == new_val:
+        return {'changed': False, 'old': old_val, 'new': new_val}
+    return {'changed': True, 'old': old_val, 'new': new_val}
+
+
+def compare_chapters(draft_path, revised_path):
+    if not os.path.exists(draft_path):
+        return {'error': f'原稿不存在: {draft_path}'}
+    if not os.path.exists(revised_path):
+        return {'error': f'修订稿不存在: {revised_path}'}
+
+    draft_raw, draft_title, draft_clean, draft_wc = read_chapter(draft_path)
+    revised_raw, revised_title, revised_clean, revised_wc = read_chapter(revised_path)
+
+    result = {
+        'draft': os.path.basename(draft_path),
+        'revised': os.path.basename(revised_path),
+        'changes': {}
+    }
+
+    # 1. 字数变化
+    result['changes']['word_count'] = _diff_values(draft_wc, revised_wc)
+
+    # 2. 标题变化
+    result['changes']['title'] = _diff_values(draft_title, revised_title)
+
+    # 3. 角色变化
+    draft_chars = set(extract_characters(draft_clean))
+    revised_chars = set(extract_characters(revised_clean))
+    result['changes']['characters'] = _diff_sets(draft_chars, revised_chars)
+
+    # 4. 地点变化
+    draft_locs = set(extract_locations(draft_clean))
+    revised_locs = set(extract_locations(revised_clean))
+    result['changes']['locations'] = _diff_sets(draft_locs, revised_locs)
+
+    # 5. 章末钩子变化
+    draft_hook = detect_hook(draft_raw)
+    revised_hook = detect_hook(revised_raw)
+    result['changes']['hook'] = _diff_values(
+        draft_hook['type'], revised_hook['type']
+    )
+
+    # 6. 结构变化
+    draft_struct = detect_structure(draft_raw)
+    revised_struct = detect_structure(revised_raw)
+    result['changes']['structure'] = {
+        'draft': draft_struct,
+        'revised': revised_struct
+    }
+
+    # 7. 节奏变化
+    draft_pacing, draft_score = estimate_pacing(draft_raw)
+    revised_pacing, revised_score = estimate_pacing(revised_raw)
+    result['changes']['pacing'] = _diff_values(
+        f'{draft_pacing}({draft_score})', f'{revised_pacing}({revised_score})'
+    )
+
+    # 汇总
+    significant = []
+    wc_change = result['changes']['word_count']
+    if wc_change['changed']:
+        diff = wc_change['new'] - wc_change['old']
+        significant.append(f"字数变化: {diff:+d}")
+
+    char_change = result['changes']['characters']
+    if char_change['added']:
+        significant.append(f"新增角色: {', '.join(char_change['added'])}")
+    if char_change['removed']:
+        significant.append(f"移除角色: {', '.join(char_change['removed'])}")
+
+    hook_change = result['changes']['hook']
+    if hook_change['changed']:
+        significant.append(f"钩子变化: {hook_change['old']} → {hook_change['new']}")
+
+    result['summary'] = {
+        'significant_changes': significant,
+        'change_count': len(significant)
+    }
+
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description='章节修订对比')
+    parser.add_argument('draft', help='原稿文件路径')
+    parser.add_argument('revised', help='修订稿文件路径')
+    parser.add_argument('--json', action='store_true', help='JSON输出')
+    args = parser.parse_args()
+
+    result = compare_chapters(args.draft, args.revised)
+
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        if 'error' in result:
+            print(f"错误: {result['error']}")
+            return
+        print(f"=== 章节修订对比 ===\n")
+        print(f"原稿: {result['draft']}")
+        print(f"修订: {result['revised']}\n")
+
+        for change in result['summary']['significant_changes']:
+            print(f"  {change}")
+
+        if not result['summary']['significant_changes']:
+            print("  无显著变化")
+
+
+if __name__ == '__main__':
+    main()

package/skill/scripts/reviewer/character_arc_tracker.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+角色弧线追踪脚本
+追踪角色在整卷中的成长轨迹、情感变化、能力演进。
+供复盘师在卷末复盘时使用，或规划师在规划角色发展时参考。
+
+用法:
+    python scripts/reviewer/character_arc_tracker.py 章节目录 --chars 林风,苏婉 --json
+    python scripts/reviewer/character_arc_tracker.py 章节目录 --all --json
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+from collections import defaultdict
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'common'))
+from nm_utils import (
+    list_chapters, read_chapter, extract_characters, count_chinese,
+    chapter_sort_key
+)
+
+# ─── 角色情感关键词 ───────────────────────────────
+EMOTION_KEYWORDS = {
+    '愤怒': ['愤怒', '怒火', '暴怒', ' rage', '大怒', '恼怒', '愤然'],
+    '悲伤': ['悲伤', '难过', '伤心', '落泪', '哭泣', '哀伤', '悲痛'],
+    '喜悦': ['喜悦', '开心', '高兴', '欢笑', '欣喜', '愉悦', '快乐'],
+    '恐惧': ['恐惧', '害怕', '惊恐', '畏惧', '胆怯', '惶恐', '不安'],
+    '平静': ['平静', '淡然', '从容', '淡定', '安详', '宁静', '平和'],
+    '紧张': ['紧张', '焦虑', '忐忑', '不安', '慌张', '焦急', '紧迫'],
+}
+
+# ─── 角色能力关键词 ───────────────────────────────
+ABILITY_KEYWORDS = {
+    '突破': ['突破', '晋升', '进阶', '升级', '领悟', '顿悟'],
+    '战斗': ['战斗', '对决', '厮杀', '交锋', '激战', '搏杀'],
+    '修炼': ['修炼', '修炼', '打坐', '运功', '吐纳', '冥想'],
+    '失败': ['失败', '受伤', '败北', '溃败', '落败', '受挫'],
+}
+
+
+def track_character_in_chapter(filepath, target_chars=None):
+    """Track character mentions and context in a single chapter."""
+    raw, title, clean, wc = read_chapter(filepath)
+    all_chars = extract_characters(clean)
+
+    # Filter to target characters if specified
+    if target_chars:
+        chars = [c for c in all_chars if c in target_chars]
+    else:
+        chars = all_chars
+
+    char_data = {}
+    for char in chars:
+        # Find all paragraphs mentioning this character
+        paragraphs = [p for p in clean.split('\n') if p.strip() and char in p]
+        char_text = ' '.join(paragraphs)
+
+        # Emotion analysis
+        emotions = {}
+        for emotion, keywords in EMOTION_KEYWORDS.items():
+            count = sum(char_text.count(kw) for kw in keywords)
+            if count > 0:
+                emotions[emotion] = count
+
+        # Ability analysis
+        abilities = {}
+        for ability, keywords in ABILITY_KEYWORDS.items():
+            count = sum(char_text.count(kw) for kw in keywords)
+            if count > 0:
+                abilities[ability] = count
+
+        char_data[char] = {
+            'mention_count': len(paragraphs),
+            'emotions': emotions,
+            'abilities': abilities,
+            'word_count': count_chinese(char_text)
+        }
+
+    return {
+        'chapter': title,
+        'word_count': wc,
+        'characters': char_data
+    }
+
+
+def build_character_arc(chapters_dir, target_chars=None, recent_n=None):
+    """Build character arc across multiple chapters."""
+    chapter_files = list_chapters(chapters_dir, recent_n)
+    if not chapter_files:
+        return {'error': '未找到章节文件'}
+
+    arc = {}
+    for idx, cf in enumerate(chapter_files):
+        ch_data = track_character_in_chapter(cf, target_chars)
+        ch_num = idx + 1
+
+        for char, data in ch_data['characters'].items():
+            if char not in arc:
+                arc[char] = []
+            arc[char].append({
+                'chapter_num': ch_num,
+                'chapter_title': ch_data['chapter'],
+                'mention_count': data['mention_count'],
+                'emotions': data['emotions'],
+                'abilities': data['abilities'],
+                'word_count': data['word_count']
+            })
+
+    # Generate summary for each character
+    summary = {}
+    for char, entries in arc.items():
+        total_mentions = sum(e['mention_count'] for e in entries)
+        all_emotions = defaultdict(int)
+        all_abilities = defaultdict(int)
+        for e in entries:
+            for emo, cnt in e['emotions'].items():
+                all_emotions[emo] += cnt
+            for abi, cnt in e['abilities'].items():
+                all_abilities[abi] += cnt
+
+        # Dominant emotion
+        dominant_emo = max(all_emotions, key=all_emotions.get) if all_emotions else '未检测'
+        # Most frequent ability
+        dominant_abi = max(all_abilities, key=all_abilities.get) if all_abilities else '未检测'
+
+        summary[char] = {
+            'total_chapters': len(entries),
+            'total_mentions': total_mentions,
+            'avg_mentions_per_chapter': round(total_mentions / max(len(entries), 1), 1),
+            'dominant_emotion': dominant_emo,
+            'emotion_distribution': dict(all_emotions),
+            'dominant_ability': dominant_abi,
+            'ability_distribution': dict(all_abilities),
+            'arc_points': entries
+        }
+
+    return {
+        'total_chapters_analyzed': len(chapter_files),
+        'characters_tracked': len(arc),
+        'summary': summary
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description='角色弧线追踪脚本')
+    parser.add_argument('chapters_dir', help='章节目录路径')
+    parser.add_argument('--chars', '-c', help='目标角色，逗号分隔')
+    parser.add_argument('--all', '-a', action='store_true', help='追踪所有角色')
+    parser.add_argument('--recent', type=int, help='仅分析最近N章')
+    parser.add_argument('--json', action='store_true', help='JSON输出')
+    args = parser.parse_args()
+
+    if not os.path.isdir(args.chapters_dir):
+        print(f"错误: 目录不存在: {args.chapters_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    target_chars = args.chars.split(',') if args.chars else None
+    result = build_character_arc(args.chapters_dir, target_chars, args.recent)
+
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        if 'error' in result:
+            print(result['error'])
+            return
+
+        print(f"\n=== 角色弧线追踪 ===\n")
+        print(f"分析章节数: {result['total_chapters_analyzed']}")
+        print(f"追踪角色数: {result['characters_tracked']}")
+
+        for char, summary in result['summary'].items():
+            print(f"\n--- {char} ---")
+            print(f"  出场章数: {summary['total_chapters']}")
+            print(f"  总提及次数: {summary['total_mentions']}")
+            print(f"  平均每章: {summary['avg_mentions_per_chapter']}次")
+            print(f"  主导情绪: {summary['dominant_emotion']}")
+            if summary['emotion_distribution']:
+                emos = ', '.join(f"{k}({v})" for k, v in sorted(summary['emotion_distribution'].items(), key=lambda x: -x[1])[:5])
+                print(f"  情绪分布: {emos}")
+            print(f"  主导能力: {summary['dominant_ability']}")
+            if summary['ability_distribution']:
+                abis = ', '.join(f"{k}({v})" for k, v in sorted(summary['ability_distribution'].items(), key=lambda x: -x[1])[:5])
+                print(f"  能力分布: {abis}")
+
+
+if __name__ == '__main__':
+    main()