novel-maker 2.2.0

package/skill/scripts/auditor/chapter_transition.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+章节衔接检查脚本
+检测章节之间的衔接问题：时间跳跃、地点突变、角色消失、情绪断裂等。
+供审计师在审查时使用，或写手在连续写作时自查。
+
+用法:
+    python scripts/auditor/chapter_transition.py 章节目录 --json
+    python scripts/auditor/chapter_transition.py 章节目录 --recent 5
+"""
+
+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, extract_locations,
+    detect_hook, count_chinese, generate_summary
+)
+
+# ─── 时间表达关键词 ───────────────────────────────
+TIME_EXPRESSIONS = {
+    '瞬间': ['突然', '忽然', '刹那间', '瞬间', '立刻', '马上'],
+    '短期': ['第二天', '次日', '当晚', '傍晚', '清晨', '午后', '片刻', '一会儿'],
+    '中期': ['几天后', '一周后', '半月后', '一个月后', '数月后'],
+    '长期': ['一年后', '数年后', '多年后', '几年后', '十年后']
+}
+
+# ─── 地点转换关键词 ───────────────────────────────
+LOCATION_TRANSITIONS = ['来到', '到达', '回到', '前往', '进入', '离开', '返回', '抵达']
+
+
+def analyze_chapter_ending(filepath, last_n=500):
+    """Analyze the ending of a chapter."""
+    raw, title, clean, wc = read_chapter(filepath)
+    tail = clean[-last_n:] if len(clean) > last_n else clean
+
+    # Extract ending characters
+    ending_chars = extract_characters(tail)
+
+    # Extract ending locations
+    ending_locs = extract_locations(tail)
+
+    # Detect hook
+    hook = detect_hook(raw)
+
+    # Detect time expressions
+    time_expressions = []
+    for category, keywords in TIME_EXPRESSIONS.items():
+        for kw in keywords:
+            if kw in tail:
+                time_expressions.append({'category': category, 'keyword': kw})
+
+    return {
+        'title': title,
+        'word_count': wc,
+        'ending_chars': ending_chars[:5],
+        'ending_locations': ending_locs[:3],
+        'hook': hook['type'],
+        'time_expressions': time_expressions,
+        'tail_preview': tail[-100:]
+    }
+
+
+def analyze_chapter_beginning(filepath, first_n=500):
+    """Analyze the beginning of a chapter."""
+    raw, title, clean, wc = read_chapter(filepath)
+    head = clean[:first_n] if len(clean) > first_n else clean
+
+    # Extract beginning characters
+    beginning_chars = extract_characters(head)
+
+    # Extract beginning locations
+    beginning_locs = extract_locations(head)
+
+    # Detect time expressions
+    time_expressions = []
+    for category, keywords in TIME_EXPRESSIONS.items():
+        for kw in keywords:
+            if kw in head:
+                time_expressions.append({'category': category, 'keyword': kw})
+
+    # Detect location transitions
+    location_transitions = []
+    for transition in LOCATION_TRANSITIONS:
+        if transition in head:
+            location_transitions.append(transition)
+
+    return {
+        'title': title,
+        'word_count': wc,
+        'beginning_chars': beginning_chars[:5],
+        'beginning_locations': beginning_locs[:3],
+        'time_expressions': time_expressions,
+        'location_transitions': location_transitions,
+        'head_preview': head[:100]
+    }
+
+
+def check_transition(chapter_files):
+    """Check transitions between consecutive chapters."""
+    transitions = []
+
+    for i in range(len(chapter_files) - 1):
+        curr_file = chapter_files[i]
+        next_file = chapter_files[i + 1]
+
+        curr_ending = analyze_chapter_ending(curr_file)
+        next_beginning = analyze_chapter_beginning(next_file)
+
+        issues = []
+
+        # 1. Character continuity check
+        curr_chars = set(curr_ending['ending_chars'])
+        next_chars = set(next_beginning['beginning_chars'])
+        if curr_chars and not (curr_chars & next_chars):
+            issues.append({
+                'type': '角色断裂',
+                'message': f"上章结尾角色({', '.join(curr_ending['ending_chars'][:3])})未在下章开头出现",
+                'severity': 'warning'
+            })
+
+        # 2. Location continuity check
+        curr_locs = set(curr_ending['ending_locations'])
+        next_locs = set(next_beginning['beginning_locations'])
+        if curr_locs and not (curr_locs & next_locs) and not next_beginning['location_transitions']:
+            issues.append({
+                'type': '地点突变',
+                'message': f"上章地点({', '.join(curr_ending['ending_locations'][:2])})到下章地点({', '.join(next_beginning['beginning_locations'][:2])})无过渡",
+                'severity': 'info'
+            })
+
+        # 3. Time expression check
+        if next_beginning['time_expressions']:
+            time_cats = [t['category'] for t in next_beginning['time_expressions']]
+            if '长期' in time_cats:
+                issues.append({
+                    'type': '时间跳跃',
+                    'message': f"下章开头有长期时间跳跃（{', '.join(t['keyword'] for t in next_beginning['time_expressions'] if t['category']=='长期')}）",
+                    'severity': 'info'
+                })
+
+        # 4. Hook resolution check
+        if curr_ending['hook'] != '未检测':
+            issues.append({
+                'type': '钩子待回收',
+                'message': f"上章钩子类型: {curr_ending['hook']}",
+                'severity': 'info'
+            })
+
+        transitions.append({
+            'from_chapter': curr_ending['title'],
+            'to_chapter': next_beginning['title'],
+            'issues': issues,
+            'issue_count': len(issues)
+        })
+
+    return transitions
+
+
+def main():
+    parser = argparse.ArgumentParser(description='章节衔接检查脚本')
+    parser.add_argument('chapters_dir', 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)
+
+    chapter_files = list_chapters(args.chapters_dir, args.recent)
+    if len(chapter_files) < 2:
+        print("错误: 至少需要2个章节才能检查衔接", file=sys.stderr)
+        sys.exit(1)
+
+    transitions = check_transition(chapter_files)
+
+    # Calculate summary
+    total_issues = sum(t['issue_count'] for t in transitions)
+    warning_count = sum(1 for t in transitions for i in t['issues'] if i['severity'] == 'warning')
+
+    result = {
+        'total_chapters': len(chapter_files),
+        'transitions_checked': len(transitions),
+        'total_issues': total_issues,
+        'warning_count': warning_count,
+        'transitions': transitions
+    }
+
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        print(f"\n=== 章节衔接检查 ===\n")
+        print(f"章节数: {result['total_chapters']}")
+        print(f"检查衔接数: {result['transitions_checked']}")
+        print(f"问题总数: {result['total_issues']}")
+        print(f"警告数: {result['warning_count']}")
+
+        print(f"\n衔接详情:")
+        for trans in transitions:
+            if trans['issues']:
+                print(f"\n  {trans['from_chapter']} → {trans['to_chapter']}:")
+                for issue in trans['issues']:
+                    icon = '⚠' if issue['severity'] == 'warning' else 'ℹ'
+                    print(f"    {icon} {issue['type']}: {issue['message']}")
+            else:
+                print(f"\n  ✓ {trans['from_chapter']} → {trans['to_chapter']}: 无问题")
+
+
+if __name__ == '__main__':
+    main()

package/skill/scripts/auditor/consistency_scan.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+一致性扫描
+提取章节中的角色、等级、地点，与真相文件比对，输出冲突报告。
+"""
+
+import os
+import sys
+import json
+import re
+from collections import Counter
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'common'))
+from nm_utils import (
+    list_chapters, read_chapter, extract_characters, extract_locations
+)
+
+
+def read_truth_file(filepath):
+    """Read a truth file and return its content."""
+    if not os.path.exists(filepath):
+        return None
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return f.read()
+    except Exception:
+        return None
+
+
+def extract_characters_from_truth(text):
+    """Extract character names from truth files."""
+    if not text:
+        return set()
+    names = set()
+    for m in re.finditer(r'[#|*\-]*\s*([\u4e00-\u9fff]{2,4})(?:[：:]\s*[^\n]*|的角色)', text):
+        name = m.group(1)
+        if not name.startswith(('#', '!', ' ', '-', '|', '*')):
+            names.add(name)
+    return names
+
+
+def extract_power_levels(text):
+    """Extract power level mentions from text."""
+    levels = {}
+    for m in re.finditer(r'([\u4e00-\u9fff]{2,4})[：:]?\s*([\u4e00-\u9fff]+(?:[初期|中期|后期|巅峰|大圆满]*))', text):
+        name, level = m.group(1), m.group(2)
+        if len(name) >= 2 and len(name) <= 4:
+            levels[name] = level
+    return levels
+
+
+def extract_power_mentions(text):
+    """Extract power level mentions from chapter."""
+    mentions = {}
+    for m in re.finditer(r'([\u4e00-\u9fff]{2,4})(?:已是|达到|突破到|升至|晋升为|修为|境界)\s*([\u4e00-\u9fff]{2,10})', text):
+        mentions[m.group(1)] = m.group(2)
+    return mentions
+
+
+def scan_volume(chapters_dir, truth_dir, recent_n=None):
+    """Scan all chapters and compare with truth files."""
+    chapter_files = list_chapters(chapters_dir, recent_n)
+    if not chapter_files:
+        return {'error': f'No chapters found in {chapters_dir}'}
+
+    characters_md = read_truth_file(os.path.join(truth_dir, 'characters.md'))
+    current_state = read_truth_file(os.path.join(truth_dir, 'current-state.md'))
+
+    truth_text = ""
+    if characters_md:
+        truth_text += characters_md
+    if current_state:
+        truth_text += "\n" + current_state
+
+    truth_chars = extract_characters_from_truth(truth_text)
+    truth_levels = extract_power_levels(truth_text)
+
+    results = []
+    total_issues = []
+    new_chars_all = set()
+    level_conflicts_all = []
+
+    for idx, filepath in enumerate(chapter_files):
+        raw, title, clean, wc = read_chapter(filepath)
+        chapter_chars = extract_characters(clean)
+        power_mentions = extract_power_mentions(raw)
+
+        issues = []
+        new_chars = [c for c in chapter_chars if c not in truth_chars]
+        level_conflicts = []
+        for char, level in power_mentions.items():
+            if char in truth_levels and truth_levels[char] != level:
+                level_conflicts.append({
+                    "character": char,
+                    "truth_level": truth_levels[char],
+                    "mentioned_level": level
+                })
+
+        if new_chars:
+            issues.append({
+                "type": "new_character",
+                "severity": "info",
+                "message": f"新角色出场: {', '.join(new_chars[:5])}"
+            })
+
+        for lc in level_conflicts:
+            issues.append({
+                "type": "level_conflict",
+                "severity": "warning",
+                "message": f"{lc['character']} 等级冲突: 真相文件={lc['truth_level']}, 正文={lc['mentioned_level']}"
+            })
+
+        results.append({
+            "chapter": idx + 1,
+            "title": title,
+            "word_count": wc,
+            "characters": chapter_chars[:10],
+            "issues": issues,
+            "new_characters": new_chars,
+            "level_conflicts": level_conflicts,
+        })
+        total_issues.extend(issues)
+        new_chars_all.update(new_chars)
+        level_conflicts_all.extend(level_conflicts)
+
+    return {
+        "total_chapters": len(results),
+        "truth_files_available": {
+            "characters.md": characters_md is not None,
+            "current-state.md": current_state is not None,
+        },
+        "truth_characters_count": len(truth_chars),
+        "truth_levels_count": len(truth_levels),
+        "chapters": [{"chapter": r["chapter"], "title": r["title"], "word_count": r["word_count"],
+                      "characters": r["characters"], "issues": r["issues"]} for r in results],
+        "summary": {
+            "total_issues": len(total_issues),
+            "new_characters": sorted(new_chars_all),
+            "level_conflicts": level_conflicts_all,
+            "warnings": [i for i in total_issues if i["severity"] == "warning"],
+            "info": [i for i in total_issues if i["severity"] == "info"],
+        }
+    }
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Consistency scan")
+    parser.add_argument("chapters_dir", help="Chapters directory")
+    parser.add_argument("truth_dir", nargs='?', default=None, help="Truth files directory")
+    parser.add_argument("--recent", type=int, help="Only scan last N chapters")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    args = parser.parse_args()
+
+    if not os.path.isdir(args.chapters_dir):
+        print(f"Error: {args.chapters_dir} is not a directory", file=sys.stderr)
+        sys.exit(1)
+
+    truth_dir = args.truth_dir
+    if truth_dir is None:
+        truth_dir = os.path.join(os.path.dirname(args.chapters_dir.rstrip('/')), 'truth-files')
+
+    result = scan_volume(args.chapters_dir, truth_dir, recent_n=args.recent)
+
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        print(f"=== 一致性扫描报告 (最近{result.get('total_chapters', 0)}章) ===\n")
+        if 'error' in result:
+            print(result['error'])
+            return
+        chars_ok = '✅' if result['truth_files_available']['characters.md'] else '❌'
+        state_ok = '✅' if result['truth_files_available']['current-state.md'] else '❌'
+        print(f"真相文件: characters.md={chars_ok}  current-state.md={state_ok}")
+        print(f"已知角色: {result['truth_characters_count']}个 | 已知等级: {result['truth_levels_count']}条\n")
+        if result["summary"]["warnings"]:
+            print("⚠ 等级冲突:")
+            for w in result["summary"]["warnings"]:
+                print(f"  {w['message']}")
+        if result["summary"]["new_characters"]:
+            print(f"\n📝 新角色 ({len(result['summary']['new_characters'])}个):")
+            for c in result["summary"]["new_characters"][:10]:
+                print(f"  {c}")
+        if not result["summary"]["warnings"] and not result["summary"]["new_characters"]:
+            print("✅ 无一致性问题")
+        print()
+        for ch in result["chapters"]:
+            issues_str = f" [{len(ch['issues'])} issue(s)]" if ch["issues"] else ""
+            print(f"  第{ch['chapter']}章: {ch['title']} ({ch['word_count']}字, 角色: {', '.join(ch['characters'][:3])}){issues_str}")
+
+
+if __name__ == "__main__":
+    main()

package/skill/scripts/auditor/dialogue_checker.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+对话质量检查脚本
+检测对话中的常见问题：重复用词、AI味表达、角色声音不一致等。
+供审计师在审查时使用，或写手自查。
+
+用法:
+    python scripts/auditor/dialogue_checker.py 章节文件 --json
+    python scripts/auditor/dialogue_checker.py 章节文件 --verbose
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+from collections import Counter
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'common'))
+from nm_utils import read_chapter, extract_characters
+
+
+# ─── 对话提取 ───────────────────────────────
+def extract_dialogues(text):
+    """Extract all dialogues from text."""
+    dialogues = []
+    # 匹配 "xxx" 或 "xxx" 格式
+    for m in re.finditer(r'["\u201c]([^"\u201d]+)["\u201d]', text):
+        content = m.group(1).strip()
+        if content:
+            dialogues.append(content)
+    return dialogues
+
+
+# ─── 重复用词检测 ──────────────────────────────
+def check_repetitive_words(dialogues, threshold=3):
+    """Check for repetitive words in dialogues."""
+    word_counter = Counter()
+    for dialogue in dialogues:
+        # 分词（简单按2-3字切分）
+        words = re.findall(r'[\u4e00-\u9fff]{2,3}', dialogue)
+        word_counter.update(words)
+
+    repetitive = []
+    for word, count in word_counter.most_common():
+        if count >= threshold and word not in ['说道', '问道', '笑道']:
+            repetitive.append({'word': word, 'count': count})
+
+    return repetitive[:10]  # 返回前10个
+
+
+# ─── AI味表达检测 ───────────────────────────────
+_AI_PATTERNS = [
+    (r'(?:心中|暗[自]?|心[中里])\s*(?:想|道|思忖|思虑)', '内心独白过多'),
+    (r'(?:嘴角|唇角)\s*(?:勾起|上扬|微[微扬])', '嘴角勾起套路'),
+    (r'(?:眼眸|眼睛)\s*(?:闪过|掠过)\s*(?:一丝|一抹)', '眼眸闪过套路'),
+    (r'(?:淡淡|冷冷|微微)\s*(?:一笑|说道|道)', '副词+动词套路'),
+    (r'(?:不禁|不由得)\s*(?:心中|感到)', '不禁/不由得套路'),
+    (r'(?:只见|但见)', '只见/但见套路'),
+    (r'(?:原来|竟然|居然)\s*(?:是|如此)', '原来/竟然套路'),
+]
+
+
+def check_ai_patterns(dialogues):
+    """Check for AI-style patterns in dialogues."""
+    issues = []
+    for pattern, description in _AI_PATTERNS:
+        for i, dialogue in enumerate(dialogues):
+            if re.search(pattern, dialogue):
+                issues.append({
+                    'pattern': description,
+                    'example': dialogue[:50],
+                    'index': i
+                })
+    return issues[:10]  # 返回前10个
+
+
+# ─── 对话长度分析 ───────────────────────────────
+def analyze_dialogue_length(dialogues):
+    """Analyze dialogue length distribution."""
+    if not dialogues:
+        return {'error': '未检测到对话'}
+
+    lengths = [len(d) for d in dialogues]
+    avg_length = sum(lengths) / len(lengths)
+
+    # 统计分布
+    short = sum(1 for l in lengths if l < 10)
+    medium = sum(1 for l in lengths if 10 <= l < 30)
+    long = sum(1 for l in lengths if 30 <= l < 60)
+    very_long = sum(1 for l in lengths if l >= 60)
+
+    return {
+        'total_dialogues': len(dialogues),
+        'avg_length': round(avg_length, 1),
+        'distribution': {
+            'short(<10字)': short,
+            'medium(10-30字)': medium,
+            'long(30-60字)': long,
+            'very_long(>60字)': very_long
+        },
+        'warnings': []
+    }
+
+
+# ─── 主检查函数 ───────────────────────────────
+def check_dialogue_quality(filepath, verbose=False):
+    """Check dialogue quality in a chapter file."""
+    if not os.path.exists(filepath):
+        return {'error': f'文件不存在: {filepath}'}
+
+    raw, title, clean, wc = read_chapter(filepath)
+    dialogues = extract_dialogues(clean)
+
+    result = {
+        'file': os.path.basename(filepath),
+        'title': title,
+        'word_count': wc,
+        'dialogue_count': len(dialogues),
+        'dialogue_ratio': round(len(dialogues) / max(wc, 1) * 100, 1),
+        'checks': {}
+    }
+
+    # 1. 重复用词检测
+    repetitive = check_repetitive_words(dialogues)
+    result['checks']['repetitive_words'] = {
+        'count': len(repetitive),
+        'items': repetitive,
+        'severity': 'warning' if len(repetitive) > 3 else 'info'
+    }
+
+    # 2. AI味表达检测
+    ai_patterns = check_ai_patterns(dialogues)
+    result['checks']['ai_patterns'] = {
+        'count': len(ai_patterns),
+        'items': ai_patterns,
+        'severity': 'warning' if len(ai_patterns) > 5 else 'info'
+    }
+
+    # 3. 对话长度分析
+    length_analysis = analyze_dialogue_length(dialogues)
+    result['checks']['length_analysis'] = length_analysis
+
+    # 4. 总体评估
+    total_issues = len(repetitive) + len(ai_patterns)
+    result['overall'] = {
+        'score': max(0, 100 - total_issues * 5),
+        'grade': '优秀' if total_issues < 5 else '良好' if total_issues < 10 else '需改进',
+        'issue_count': total_issues
+    }
+
+    if verbose:
+        result['sample_dialogues'] = dialogues[:5]
+
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description='对话质量检查脚本')
+    parser.add_argument('filepath', help='章节文件路径')
+    parser.add_argument('--json', action='store_true', help='JSON输出')
+    parser.add_argument('--verbose', '-v', action='store_true', help='显示详细信息')
+    args = parser.parse_args()
+
+    result = check_dialogue_quality(args.filepath, args.verbose)
+
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        if 'error' in result:
+            print(result['error'])
+            return
+
+        print(f"\n=== 对话质量检查: {result['title']} ===\n")
+        print(f"字数: {result['word_count']}")
+        print(f"对话数: {result['dialogue_count']}")
+        print(f"对话占比: {result['dialogue_ratio']}%")
+
+        print(f"\n检查结果:")
+        for check_name, check_result in result['checks'].items():
+            count = check_result.get('count', 0)
+            severity = check_result.get('severity', 'info')
+            icon = '⚠' if severity == 'warning' else '✓'
+            print(f"  {icon} {check_name}: {count}个问题")
+
+        print(f"\n总体评估:")
+        print(f"  得分: {result['overall']['score']}/100")
+        print(f"  等级: {result['overall']['grade']}")
+        print(f"  问题总数: {result['overall']['issue_count']}")
+
+
+if __name__ == '__main__':
+    main()