@remixmate/cli 0.9.71 → 0.9.73

package/skills/video-parser/scripts/analyze_video.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
-"""
-解构产物 → 视频结构分析报告
 
-从 deconstruction.json（video-parser 的输出）提取钩子、叙事结构、文案节奏、
-场景编排等关键元素，输出结构化的分析报告 analysis.json。
 
-用法:
-  python analyze_video.py -i ./deconstructed_xxx/deconstruction.json
-  python analyze_video.py -i ./deconstructed_xxx/ -o ./reports/
-"""
+
+
+
+
+
+
+
+
 
 import argparse
 import json
@@ -19,9 +19,9 @@ import sys
 QUIET = False
 
 
-# ---------------------------------------------------------------------------
-# Logging
-# ---------------------------------------------------------------------------
+
+
+
 
 def log(msg: str) -> None:
     if not QUIET:
@@ -32,12 +32,12 @@ def log_err(msg: str) -> None:
     print(msg, file=sys.stderr, flush=True)
 
 
-# ---------------------------------------------------------------------------
-# Load
-# ---------------------------------------------------------------------------
+
+
+
 
 def load_deconstruction(input_path: str):
-    """Load deconstruction.json, return (dict, input_dir)."""
+
     if os.path.isdir(input_path):
         json_path = os.path.join(input_path, "deconstruction.json")
     else:
@@ -54,27 +54,27 @@ def load_deconstruction(input_path: str):
     return data, input_dir
 
 
-# ---------------------------------------------------------------------------
-# Language detection
-# ---------------------------------------------------------------------------
+
+
+
 
 def detect_language(text: str) -> str:
-    """Simple heuristic: if >30% CJK chars, treat as zh-CN, else en."""
+
     if not text:
         return "zh-CN"
     cjk_count = sum(1 for ch in text if '\u4e00' <= ch <= '\u9fff')
     return "zh-CN" if cjk_count > len(text) * 0.3 else "en"
 
 
-# ---------------------------------------------------------------------------
-# Utterance ↔ scene matching
-# ---------------------------------------------------------------------------
+
+
+
 
 def match_utterances_to_scenes(scenes: list, utterances: list) -> dict:
-    """Assign ASR utterances to scenes by time overlap.
 
-    Returns {scene_index: [utterance, ...]}
-    """
+
+
+
     result = {s["index"]: [] for s in scenes}
     for utt in utterances:
         utt_start = utt.get("startTime", 0) / 1000.0
@@ -90,15 +90,15 @@ def match_utterances_to_scenes(scenes: list, utterances: list) -> dict:
     return result
 
 
-# ---------------------------------------------------------------------------
-# Scene roles
-# ---------------------------------------------------------------------------
+
+
+
 
 def infer_scene_roles(scene_count: int) -> list:
-    """Infer role labels from scene count.
 
-    Returns list like ["opening", "point", ..., "ending"].
-    """
+
+
+
     if scene_count <= 0:
         return ["opening"]
     if scene_count == 1:
@@ -114,21 +114,21 @@ def infer_scene_roles(scene_count: int) -> list:
     return roles
 
 
-# ---------------------------------------------------------------------------
-# Hook extraction
-# ---------------------------------------------------------------------------
+
+
+
 
 def analyze_hook(scenes: list, utterance_map: dict, asr: dict) -> dict:
-    """Extract hook from the first 3 seconds of the first scene."""
+
     if not scenes:
         return {"text": "", "durationSec": 0.0, "strategy": "none"}
 
     first_scene = scenes[0]
     hook_end = first_scene["startTimeSec"] + 3.0
 
-    # Collect words that fall within the hook window.
-    # Space tokens (startTime == -1) are included between valid words
-    # to preserve natural text spacing.
+
+
+
     hook_words = []
     utterances = asr.get("utterances", [])
     exceeded = False
@@ -138,7 +138,7 @@ def analyze_hook(scenes: list, utterance_map: dict, asr: dict) -> dict:
         for w in utt.get("words", []):
             w_start = w.get("startTime", -1) / 1000.0
             if w_start < 0:
-                # Space/punctuation token — include if we haven't exceeded the window
+
                 hook_words.append(w["text"])
                 continue
             if w_start >= hook_end:
@@ -148,12 +148,12 @@ def analyze_hook(scenes: list, utterance_map: dict, asr: dict) -> dict:
 
     hook_text = "".join(hook_words).strip()
     if not hook_text:
-        # Fallback: use the first utterance text in the first scene
+
         first_utts = utterance_map.get(first_scene["index"], [])
         if first_utts:
             hook_text = first_utts[0].get("text", "")
 
-    # Determine hook duration (end of last word in hook window)
+
     hook_duration = 3.0
     for utt in utterances:
         for w in utt.get("words", []):
@@ -162,7 +162,7 @@ def analyze_hook(scenes: list, utterance_map: dict, asr: dict) -> dict:
             if 0 <= w_start < hook_end and w_end > 0:
                 hook_duration = min(3.0, w_end)
 
-    # Classify hook strategy
+
     strategy = "none"
     if hook_text:
         stripped = hook_text.strip()
@@ -173,7 +173,7 @@ def analyze_hook(scenes: list, utterance_map: dict, asr: dict) -> dict:
         else:
             strategy = "direct-content"
 
-    # Word count: non-space characters for CJK, space-separated tokens for English
+
     hook_word_count = len(hook_text.replace(" ", "")) if any(
         '\u4e00' <= ch <= '\u9fff' for ch in hook_text
     ) else len(hook_text.split())
@@ -186,12 +186,12 @@ def analyze_hook(scenes: list, utterance_map: dict, asr: dict) -> dict:
     }
 
 
-# ---------------------------------------------------------------------------
-# Narrative structure
-# ---------------------------------------------------------------------------
+
+
+
 
 def build_narrative_structure(scenes: list, utterance_map: dict, total_duration: float) -> list:
-    """Build per-scene narrative structure entries."""
+
     roles = infer_scene_roles(len(scenes))
     structure = []
     for i, scene in enumerate(scenes):
@@ -215,12 +215,12 @@ def build_narrative_structure(scenes: list, utterance_map: dict, total_duration:
     return structure
 
 
-# ---------------------------------------------------------------------------
-# Pacing analysis
-# ---------------------------------------------------------------------------
+
+
+
 
 def analyze_pacing(scenes: list, total_duration: float) -> dict:
-    """Analyze scene pacing / rhythm."""
+
     durations = []
     for s in scenes:
         d = round(s["endTimeSec"] - s["startTimeSec"], 1)
@@ -239,7 +239,7 @@ def analyze_pacing(scenes: list, total_duration: float) -> dict:
     mn = min(durations)
     mx = max(durations)
 
-    # Determine rhythm
+
     if len(durations) == 1:
         rhythm = "uniform"
     elif mx - mn < 1.0:
@@ -272,23 +272,23 @@ def analyze_pacing(scenes: list, total_duration: float) -> dict:
     }
 
 
-# ---------------------------------------------------------------------------
-# Keywords & silence detection
-# ---------------------------------------------------------------------------
+
+
+
 
 def extract_keywords(words: list, full_text: str, language: str) -> list:
-    """Extract meaningful keywords from ASR data.
 
-    For English: use word-level tokens, filter stopwords and punctuation.
-    For Chinese: split full text on punctuation into phrases, then extract
-    multi-character content tokens (simple segmentation by punctuation boundaries).
-    """
+
+
+
+
+
     if language.startswith("zh"):
         return _extract_keywords_zh(full_text)
     return _extract_keywords_en(words)
 
 
-# Common Chinese stopwords (function words with little semantic value)
+
 _ZH_STOPWORDS = {
     "的", "了", "在", "是", "我", "们", "有", "和", "就", "不", "人", "都",
     "一", "一个", "上", "也", "很", "到", "说", "要", "去", "你", "会", "着",
@@ -301,8 +301,8 @@ _ZH_STOPWORDS = {
 
 
 def _extract_keywords_zh(full_text: str) -> list:
-    """Extract Chinese keywords by splitting on punctuation and filtering."""
-    # Split on common punctuation to get phrase segments
+
+
     segments = re.split(r'[,，。、！？!?.…:：;；\-—–\s\'\"()（）\[\]【】]+', full_text)
 
     keywords = []
@@ -311,8 +311,8 @@ def _extract_keywords_zh(full_text: str) -> list:
         seg = seg.strip()
         if not seg:
             continue
-        # Extract multi-char tokens from each segment using a simple greedy approach:
-        # scan for runs of CJK characters (2+ chars) and non-CJK tokens (e.g. "1V1", "3500")
+
+
         tokens = re.findall(r'[\u4e00-\u9fff]{2,}|[A-Za-z0-9]+(?:[A-Za-z0-9]+)*', seg)
         for tok in tokens:
             lower = tok.lower()
@@ -320,7 +320,7 @@ def _extract_keywords_zh(full_text: str) -> list:
                 continue
             if tok in _ZH_STOPWORDS:
                 continue
-            # Skip very short CJK tokens that are likely function words
+
             if len(tok) == 2 and all('\u4e00' <= c <= '\u9fff' for c in tok) and tok in _ZH_STOPWORDS:
                 continue
             seen.add(lower)
@@ -329,7 +329,7 @@ def _extract_keywords_zh(full_text: str) -> list:
 
 
 def _extract_keywords_en(words: list) -> list:
-    """Extract English keywords from word-level ASR data."""
+
     stop_pattern = re.compile(r'^[\s,，。、！？!?.…:：;；\-—–\'\"()（）\[\]【】]+$')
     en_stopwords = {
         "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
@@ -362,12 +362,12 @@ def _extract_keywords_en(words: list) -> list:
 
 
 def detect_silence_segments(utterances: list, total_duration: float) -> list:
-    """Find gaps between utterances longer than 1 second."""
+
     if not utterances:
         return []
 
     segments = []
-    # Gap before first utterance
+
     first_start = utterances[0].get("startTime", 0) / 1000.0
     if first_start > 1.0:
         segments.append({
@@ -376,7 +376,7 @@ def detect_silence_segments(utterances: list, total_duration: float) -> list:
             "durationSec": round(first_start, 1),
         })
 
-    # Gaps between utterances
+
     for i in range(len(utterances) - 1):
         cur_end = utterances[i].get("endTime", 0) / 1000.0
         next_start = utterances[i + 1].get("startTime", 0) / 1000.0
@@ -388,7 +388,7 @@ def detect_silence_segments(utterances: list, total_duration: float) -> list:
                 "durationSec": round(gap, 1),
             })
 
-    # Gap after last utterance
+
     last_end = utterances[-1].get("endTime", 0) / 1000.0
     if total_duration - last_end > 1.0:
         segments.append({
@@ -400,37 +400,37 @@ def detect_silence_segments(utterances: list, total_duration: float) -> list:
     return segments
 
 
-# ---------------------------------------------------------------------------
-# Text structure
-# ---------------------------------------------------------------------------
+
+
+
 
 def analyze_text_structure(asr: dict, scenes: list, utterance_map: dict, total_duration: float) -> dict:
-    """Analyze text structure: speech rate, silence segments, keywords."""
+
     full_text = asr.get("text", "")
     utterances = asr.get("utterances", [])
 
-    # Collect all words from all utterances
+
     all_words = []
     for utt in utterances:
         all_words.extend(utt.get("words", []))
 
-    # Speech duration (sum of utterance durations)
+
     speech_duration = 0.0
     for utt in utterances:
         s = utt.get("startTime", 0) / 1000.0
         e = utt.get("endTime", 0) / 1000.0
         speech_duration += max(0, e - s)
 
-    # Text length (non-space characters)
+
     text_len = len(full_text.replace(" ", ""))
 
-    # Speech rate: chars per second of speech
+
     speech_rate = round(text_len / speech_duration, 1) if speech_duration > 0 else 0.0
 
-    # Silence segments
+
     silence_segments = detect_silence_segments(utterances, total_duration)
 
-    # Keywords
+
     keywords = extract_keywords(all_words, full_text, detect_language(full_text))
 
     return {
@@ -441,18 +441,18 @@ def analyze_text_structure(asr: dict, scenes: list, utterance_map: dict, total_d
     }
 
 
-# ---------------------------------------------------------------------------
-# Audio pattern
-# ---------------------------------------------------------------------------
+
+
+
 
 def analyze_audio_pattern(asr: dict, audio: dict, total_duration: float) -> dict:
-    """Analyze audio pattern: narration presence, speech/silence ratio."""
+
     utterances = asr.get("utterances", [])
     has_narration = len(utterances) > 0
 
     narration_url = audio.get("url", "")
 
-    # Total speech duration
+
     speech_duration = 0.0
     for utt in utterances:
         s = utt.get("startTime", 0) / 1000.0
@@ -470,15 +470,15 @@ def analyze_audio_pattern(asr: dict, audio: dict, total_duration: float) -> dict
     }
 
 
-# ---------------------------------------------------------------------------
-# CTA detection
-# ---------------------------------------------------------------------------
+
+
+
 
 CTA_KEYWORDS = [
-    # English
+
     "subscribe", "like", "follow", "share", "comment", "click", "link",
     "sign up", "buy now", "check out", "tap", "swipe up", "join",
-    # Chinese — verbs / phrases commonly used in CTA
+
     "关注", "点赞", "转发", "评论", "订阅", "分享", "点击", "链接",
     "扫码", "加入", "报名", "下单", "购买", "赶紧", "抓紧", "安排",
     "左下角", "右下角", "小黄车", "橱窗", "主页", "私信", "留言",
@@ -486,26 +486,26 @@ CTA_KEYWORDS = [
 
 
 def analyze_cta(scenes: list, utterance_map: dict, utterances: list) -> dict:
-    """Detect call-to-action in the ending portion of the video.
 
-    When there are multiple scenes, check the last scene's text.
-    When there is only one scene, check the last utterance(s) to avoid
-    treating the entire video text as the ending.
-    """
+
+
+
+
+
     if not scenes:
         return {"hasExplicitCta": False, "endingText": "", "endingDurationSec": 0.0}
 
     last_scene = scenes[-1]
     scene_duration = round(last_scene["endTimeSec"] - last_scene["startTimeSec"], 1)
 
-    # Determine ending text: use last scene's utterances,
-    # but if there's only one scene, narrow down to the last utterance(s)
+
+
     utts = utterance_map.get(last_scene["index"], [])
     if len(scenes) == 1 and len(utts) > 1:
-        # Single-scene video: take the last 1-2 utterances as ending
+
         ending_utts = utts[-2:] if len(utts) >= 2 else utts[-1:]
         ending_text = " ".join(u.get("text", "") for u in ending_utts).strip()
-        # Approximate ending duration from last utterance timestamps
+
         first_end_utt = ending_utts[0]
         ending_duration = round(
             (last_scene["endTimeSec"] - first_end_utt.get("startTime", 0) / 1000.0), 1
@@ -514,12 +514,12 @@ def analyze_cta(scenes: list, utterance_map: dict, utterances: list) -> dict:
         ending_text = " ".join(u.get("text", "") for u in utts).strip()
         ending_duration = scene_duration
 
-    # Keyword matching
+
     lower_text = ending_text.lower()
     matched_count = sum(1 for kw in CTA_KEYWORDS if kw in lower_text)
     has_cta = matched_count > 0
 
-    # Strength: none / weak / strong
+
     if matched_count == 0:
         strength = "none"
     elif matched_count == 1:
@@ -535,12 +535,12 @@ def analyze_cta(scenes: list, utterance_map: dict, utterances: list) -> dict:
     }
 
 
-# ---------------------------------------------------------------------------
-# Utterance metrics
-# ---------------------------------------------------------------------------
+
+
+
 
 def analyze_utterance_metrics(utterances: list) -> dict:
-    """Compute per-utterance statistics: char counts, durations, density."""
+
     if not utterances:
         return {
             "count": 0,
@@ -587,13 +587,13 @@ def analyze_utterance_metrics(utterances: list) -> dict:
     }
 
 
-# ---------------------------------------------------------------------------
-# Speech rhythm
-# ---------------------------------------------------------------------------
+
+
+
 
 def analyze_speech_rhythm(utterances: list) -> dict:
-    """Analyze word-level micro-rhythm: gaps, pauses, tempo profile."""
-    # Collect all words with valid timestamps across all utterances
+
+
     all_words = []
     for utt in utterances:
         for w in utt.get("words", []):
@@ -608,7 +608,7 @@ def analyze_speech_rhythm(utterances: list) -> dict:
             "tempoProfile": "steady",
         }
 
-    # Sort words by start time
+
     all_words.sort(key=lambda w: w["startTime"])
 
     gaps = []
@@ -630,7 +630,7 @@ def analyze_speech_rhythm(utterances: list) -> dict:
     avg_gap = int(sum(gaps) / len(gaps)) if gaps else 0
     max_gap = int(max(gaps)) if gaps else 0
 
-    # Tempo profile: compare first-half vs second-half avg gap
+
     if len(gaps) < 4:
         tempo = "steady"
     else:
@@ -654,16 +654,16 @@ def analyze_speech_rhythm(utterances: list) -> dict:
     }
 
 
-# ---------------------------------------------------------------------------
-# Repetition analysis
-# ---------------------------------------------------------------------------
+
+
+
 
 def analyze_repetition(full_text: str, words: list, language: str) -> dict:
-    """Detect repeated words/phrases and compute repetition ratio."""
+
     from collections import Counter
 
     if language.startswith("zh"):
-        # Chinese: tokenize via punctuation-split + CJK/alphanum extraction (no dedup)
+
         segments = re.split(r'[,，。、！？!?.…:：;；\-—–\s\'\"()（）\[\]【】]+', full_text)
         tokens = []
         for seg in segments:
@@ -675,7 +675,7 @@ def analyze_repetition(full_text: str, words: list, language: str) -> dict:
                 if tok not in _ZH_STOPWORDS:
                     tokens.append(tok)
     else:
-        # English: use word-level tokens, filter stopwords
+
         en_stopwords = {
             "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
             "have", "has", "had", "do", "does", "did", "will", "would", "could",
@@ -720,9 +720,9 @@ def analyze_repetition(full_text: str, words: list, language: str) -> dict:
     }
 
 
-# ---------------------------------------------------------------------------
-# Sentence type classification
-# ---------------------------------------------------------------------------
+
+
+
 
 _IMPERATIVE_STARTERS_ZH = [
     "点", "看", "赶紧", "抓紧", "快", "记得", "一定", "别忘",
@@ -738,8 +738,8 @@ _IMPERATIVE_STARTERS_EN = [
 
 
 def analyze_sentence_types(full_text: str, language: str) -> dict:
-    """Classify sentences by type: declarative, interrogative, imperative, exclamatory."""
-    # Split into sentences by sentence-ending punctuation
+
+
     sentences = re.split(r'[。！？!?.]', full_text)
     sentences = [s.strip() for s in sentences if s.strip()]
 
@@ -757,10 +757,10 @@ def analyze_sentence_types(full_text: str, language: str) -> dict:
             },
         }
 
-    # To classify we need the original ending punctuation, so re-scan full_text
-    # Build list of (sentence_text, ending_punctuation)
+
+
     parts = re.findall(r'([^。！？!?.]+)([。！？!?.])', full_text)
-    # If regex didn't capture all, fallback to simple classification
+
     if not parts:
         parts = [(s, "。") for s in sentences]
 
@@ -792,12 +792,12 @@ def analyze_sentence_types(full_text: str, language: str) -> dict:
     }
 
 
-# ---------------------------------------------------------------------------
-# Assets summary
-# ---------------------------------------------------------------------------
+
+
+
 
 def build_assets_summary(decon: dict) -> dict:
-    """Build assets summary from deconstruction data."""
+
     audio = decon.get("audio", {})
     keyframes = decon.get("keyframes", [])
 
@@ -824,9 +824,9 @@ def build_assets_summary(decon: dict) -> dict:
     return result
 
 
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
+
+
+
 
 def main():
     parser = argparse.ArgumentParser(
@@ -862,9 +862,9 @@ Examples:
     global QUIET
     QUIET = args.json_output
 
-    # ------------------------------------------------------------------
-    # [1] Load deconstruction
-    # ------------------------------------------------------------------
+
+
+
     log("[1/13] Loading deconstruction data...")
     decon, input_dir = load_deconstruction(args.input)
     log(f"   loaded: {input_dir}/deconstruction.json")
@@ -872,9 +872,9 @@ Examples:
     output_dir = args.output_dir or input_dir
     os.makedirs(output_dir, exist_ok=True)
 
-    # ------------------------------------------------------------------
-    # [2] Basic info
-    # ------------------------------------------------------------------
+
+
+
     log("[2/13] Basic analysis...")
     source = decon.get("source", {})
     duration_ms = source.get("durationMs", 0)
@@ -909,76 +909,76 @@ Examples:
 
     log(f"   duration: {duration_sec:.1f}s, scenes: {len(scenes)}, language: {language}")
 
-    # ------------------------------------------------------------------
-    # [3] Scene structure (utterance mapping)
-    # ------------------------------------------------------------------
+
+
+
     log("[3/13] Scene-structure analysis...")
     utterance_map = match_utterances_to_scenes(scenes, utterances) if scenes and utterances else {}
     narrative = build_narrative_structure(scenes, utterance_map, duration_sec)
     for ns in narrative:
         log(f"   scene {ns['sceneIndex']}: {ns['role']} ({ns['durationSec']}s, {ns['durationPct']}%)")
 
-    # ------------------------------------------------------------------
-    # [4] Hook extraction
-    # ------------------------------------------------------------------
+
+
+
     log("[4/13] Hook extraction...")
     hook = analyze_hook(scenes, utterance_map, asr)
     log(f"   strategy: {hook['strategy']}, word count: {hook['wordCount']}, text: {hook['text'][:40]}...")
 
-    # ------------------------------------------------------------------
-    # [5] Pacing analysis
-    # ------------------------------------------------------------------
+
+
+
     log("[5/13] Pacing analysis...")
     pacing = analyze_pacing(scenes, duration_sec)
     log(f"   rhythm: {pacing['rhythm']}, scene durations: {pacing['sceneDurations']}")
 
-    # ------------------------------------------------------------------
-    # [6] Text structure
-    # ------------------------------------------------------------------
+
+
+
     log("[6/13] Copy-structure analysis...")
     text_structure = analyze_text_structure(asr, scenes, utterance_map, duration_sec)
     log(f"   speech rate: {text_structure['speechRate']} chars/sec, "
         f"关键词: {len(text_structure['keywords'])} 个, "
         f"静默段: {len(text_structure['silenceSegments'])} 处")
 
-    # ------------------------------------------------------------------
-    # [7] Audio pattern
-    # ------------------------------------------------------------------
+
+
+
     log("[7/13] Audio-pattern analysis...")
     audio_pattern = analyze_audio_pattern(asr, audio, duration_sec)
     log(f"   speech ratio: {audio_pattern['speechRatio']}, "
         f"静默比例: {audio_pattern['silenceRatio']}")
 
-    # ------------------------------------------------------------------
-    # [8] CTA detection
-    # ------------------------------------------------------------------
+
+
+
     log("[8/13] CTA detection...")
     cta = analyze_cta(scenes, utterance_map, utterances)
     log(f"   explicit CTA: {cta['hasExplicitCta']}, "
         f"强度: {cta['strength']}, "
         f"结尾文案: {cta['endingText'][:30]}")
 
-    # ------------------------------------------------------------------
-    # [9] Utterance metrics
-    # ------------------------------------------------------------------
+
+
+
     log("[9/13] Sentence statistics...")
     utterance_metrics = analyze_utterance_metrics(utterances)
     log(f"   sentences: {utterance_metrics['count']}, "
         f"平均字数: {utterance_metrics['avgCharCount']}, "
         f"平均时长: {utterance_metrics['avgDurationSec']}s")
 
-    # ------------------------------------------------------------------
-    # [10] Speech rhythm
-    # ------------------------------------------------------------------
+
+
+
     log("[10/13] Speech rhythm...")
     speech_rhythm = analyze_speech_rhythm(utterances)
     log(f"   avg word gap: {speech_rhythm['avgWordGapMs']}ms, "
         f"有意停顿: {len(speech_rhythm['intentionalPauses'])} 处, "
         f"节奏: {speech_rhythm['tempoProfile']}")
 
-    # ------------------------------------------------------------------
-    # [11] Repetition
-    # ------------------------------------------------------------------
+
+
+
     log("[11/13] Repetition patterns...")
     all_words = []
     for utt in utterances:
@@ -988,9 +988,9 @@ Examples:
     log(f"   repetition ratio: {repetition['repetitionRatio']}, "
         f"高频词: {top3 or '无'}")
 
-    # ------------------------------------------------------------------
-    # [12] Sentence types
-    # ------------------------------------------------------------------
+
+
+
     log("[12/13] Sentence-type distribution...")
     sentence_types = analyze_sentence_types(full_text, language)
     log(f"   declarative: {sentence_types['declarative']}, "
@@ -998,9 +998,9 @@ Examples:
         f"祈使: {sentence_types['imperative']}, "
         f"感叹: {sentence_types['exclamatory']}")
 
-    # ------------------------------------------------------------------
-    # [13] Output
-    # ------------------------------------------------------------------
+
+
+
     log("[13/13] Writing analysis report...")
     assets = build_assets_summary(decon)