Youtube Clipper

# YouTube Clipper 环境变量配置示例
# 复制此文件为 .env 并填入实际值

# ============================================================================
# FFmpeg 配置
# ============================================================================

# FFmpeg 可执行文件路径（可选，留空则自动检测）
# macOS (Apple Silicon): /opt/homebrew/opt/ffmpeg-full/bin/ffmpeg
# macOS (Intel): /usr/local/opt/ffmpeg-full/bin/ffmpeg
# Linux: /usr/bin/ffmpeg
FFMPEG_PATH=

# 字幕烧录样式
SUBTITLE_FONT_SIZE=24
SUBTITLE_MARGIN_V=30

# ============================================================================
# 输出配置
# ============================================================================

# 输出目录（默认: 当前工作目录下的 youtube-clips/）
OUTPUT_DIR=./youtube-clips

# 视频质量限制（最高分辨率）
# 选项: 720, 1080, 1440, 2160 (4K)
MAX_VIDEO_HEIGHT=1080

# ============================================================================
# 字幕翻译配置
# ============================================================================

# 批量翻译大小（每批翻译的字幕条数）
# 推荐: 20-25
TRANSLATION_BATCH_SIZE=20

# 目标翻译语言
# 选项: 中文, 日语, 韩语, 西班牙语, 等
TARGET_LANGUAGE=中文

# ============================================================================
# 章节分析配置
# ============================================================================

# 目标章节时长（秒）
# 推荐: 180 (3分钟) - 300 (5分钟)
TARGET_CHAPTER_DURATION=180

# ============================================================================
# yt-dlp 配置
# ============================================================================

# yt-dlp 代理设置（如果需要）
# 格式: http://proxy-server:port 或 socks5://proxy-server:port
YT_DLP_PROXY=

# yt-dlp 下载速率限制（如果需要）
# 格式: 50K, 4.2M, 等
YT_DLP_RATE_LIMIT=

# ============================================================================
# 高级配置
# ============================================================================

# 临时文件目录（用于解决路径空格问题）
# 留空则使用系统默认临时目录
TEMP_DIR=

# 是否保留临时文件（调试用）
# 选项: true, false
KEEP_TEMP_FILES=false

# 日志级别
# 选项: DEBUG, INFO, WARNING, ERROR
LOG_LEVEL=INFO

# ============================================================================
# 注意事项
# ============================================================================

# 1. 此文件中的配置是可选的，如果不设置，Skill 会使用默认值
# 2. 路径可以使用 ~ 表示用户主目录
# 3. 环境变量值不需要引号
# 4. 以 # 开头的行是注释
# 5. 修改配置后需要重启 Claude Code 才能生效

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
venv/
env/
ENV/
*.egg-info/
.eggs/
dist/
build/

# Environment
.env
.env.local
.env.*.local

# IDE
.vscode/
.idea/
*.swp
*.swo
*~

# OS
.DS_Store
Thumbs.db
Desktop.ini

# Outputs
youtube-clips/
outputs/
downloads/
temp/
tmp/

# Test files
*.mp4
*.webm
*.mkv
*.avi
*.vtt
*.srt
test_*.py
*_test.py

# Logs
*.log
logs/

#!/bin/bash

##############################################################################
# YouTube Clipper - Claude Code Skill 安装脚本
#
# 功能：
# 1. 自动创建 Skill 目录
# 2. 复制所有必要文件
# 3. 安装 Python 依赖
# 4. 检测系统依赖（yt-dlp、FFmpeg）
#
# 使用方法：
#   bash install_as_skill.sh
##############################################################################

set -e  # 遇到错误立即退出

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 打印函数
print_info() {
    echo -e "${BLUE}ℹ️  $1${NC}"
}

print_success() {
    echo -e "${GREEN}✅ $1${NC}"
}

print_warning() {
    echo -e "${YELLOW}⚠️  $1${NC}"
}

print_error() {
    echo -e "${RED}❌ $1${NC}"
}

print_header() {
    echo ""
    echo "========================================"
    echo "$1"
    echo "========================================"
    echo ""
}

# 检查命令是否存在
command_exists() {
    command -v "$1" >/dev/null 2>&1
}

# 主函数
main() {
    print_header "YouTube Clipper - Claude Code Skill 安装"

    # 1. 确定 Skill 目录
    SKILL_DIR="$HOME/.claude/skills/youtube-clipper"
    print_info "目标目录: $SKILL_DIR"

    # 2. 检查是否已存在
    if [ -d "$SKILL_DIR" ]; then
        print_warning "Skill 目录已存在: $SKILL_DIR"
        read -p "是否覆盖安装？(y/N) " -n 1 -r
        echo
        if [[ ! $REPLY =~ ^[Yy]$ ]]; then
            print_info "安装已取消"
            exit 0
        fi
        print_info "删除旧版本..."
        rm -rf "$SKILL_DIR"
    fi

    # 3. 创建目录
    print_info "创建 Skill 目录..."
    mkdir -p "$SKILL_DIR"
    print_success "目录已创建"

    # 4. 复制文件
    print_info "复制项目文件..."

    # 获取当前脚本所在目录（即项目根目录）
    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

    # 复制所有必要文件
    cp -r "$SCRIPT_DIR"/* "$SKILL_DIR/"

    # 排除不需要的文件
    if [ -d "$SKILL_DIR/.git" ]; then
        rm -rf "$SKILL_DIR/.git"
    fi
    if [ -d "$SKILL_DIR/venv" ]; then
        rm -rf "$SKILL_DIR/venv"
    fi
    if [ -d "$SKILL_DIR/__pycache__" ]; then
        rm -rf "$SKILL_DIR/__pycache__"
    fi
    if [ -d "$SKILL_DIR/youtube-clips" ]; then
        rm -rf "$SKILL_DIR/youtube-clips"
    fi
    if [ -f "$SKILL_DIR/.env" ]; then
        rm "$SKILL_DIR/.env"
    fi

    print_success "文件复制完成"

    # 5. 检查 Python
    print_info "检查 Python 环境..."
    if ! command_exists python3; then
        print_error "未找到 Python 3，请先安装 Python 3.8+"
        exit 1
    fi

    PYTHON_VERSION=$(python3 --version)
    print_success "Python 已安装: $PYTHON_VERSION"

    # 6. 检查 pip
    if ! command_exists pip3 && ! command_exists pip; then
        print_error "未找到 pip，请先安装 pip"
        exit 1
    fi
    print_success "pip 已安装"

    # 7. 安装 Python 依赖
    print_info "安装 Python 依赖..."
    cd "$SKILL_DIR"

    # 尝试使用 pip3，如果不存在则使用 pip
    if command_exists pip3; then
        pip3 install -q yt-dlp pysrt python-dotenv
    else
        pip install -q yt-dlp pysrt python-dotenv
    fi

    print_success "Python 依赖安装完成（yt-dlp、pysrt、python-dotenv）"

    # 8. 检查 yt-dlp
    print_info "检查 yt-dlp..."
    if command_exists yt-dlp; then
        YT_DLP_VERSION=$(yt-dlp --version)
        print_success "yt-dlp 已安装: $YT_DLP_VERSION"
    else
        print_warning "yt-dlp 命令行工具未安装"
        print_info "安装方法:"
        print_info "  macOS:  brew install yt-dlp"
        print_info "  Ubuntu: sudo apt-get install yt-dlp"
        print_info "  或: pip3 install -U yt-dlp"
    fi

    # 9. 检查 FFmpeg（关键：需要 libass 支持）
    print_header "检查 FFmpeg（字幕烧录需要）"

    FFMPEG_FOUND=false
    LIBASS_SUPPORTED=false

    # 检查 ffmpeg-full（macOS 推荐）
    if [ -f "/opt/homebrew/opt/ffmpeg-full/bin/ffmpeg" ]; then
        print_success "ffmpeg-full 已安装（Apple Silicon）"
        FFMPEG_FOUND=true
        LIBASS_SUPPORTED=true
    elif [ -f "/usr/local/opt/ffmpeg-full/bin/ffmpeg" ]; then
        print_success "ffmpeg-full 已安装（Intel Mac）"
        FFMPEG_FOUND=true
        LIBASS_SUPPORTED=true
    elif command_exists ffmpeg; then
        FFMPEG_VERSION=$(ffmpeg -version | head -n 1)
        print_success "FFmpeg 已安装: $FFMPEG_VERSION"
        FFMPEG_FOUND=true

        # 检查 libass 支持
        if ffmpeg -filters 2>&1 | grep -q "subtitles"; then
            print_success "FFmpeg 支持 libass（字幕烧录可用）"
            LIBASS_SUPPORTED=true
        else
            print_warning "FFmpeg 不支持 libass（字幕烧录不可用）"
        fi
    fi

    if [ "$FFMPEG_FOUND" = false ]; then
        print_error "FFmpeg 未安装"
        print_info "安装方法:"
        print_info "  macOS:  brew install ffmpeg-full  # 推荐，包含 libass"
        print_info "  Ubuntu: sudo apt-get install ffmpeg libass-dev"
    elif [ "$LIBASS_SUPPORTED" = false ]; then
        print_warning "FFmpeg 缺少 libass 支持，字幕烧录功能将不可用"
        print_info "解决方法（macOS）:"
        print_info "  brew uninstall ffmpeg"
        print_info "  brew install ffmpeg-full"
    fi

    # 10. 创建 .env 文件
    print_header "配置环境变量"

    if [ -f "$SKILL_DIR/.env.example" ]; then
        print_info "创建 .env 文件..."
        cp "$SKILL_DIR/.env.example" "$SKILL_DIR/.env"
        print_success ".env 文件已创建"
        echo ""
        print_info "配置文件位置: $SKILL_DIR/.env"
        print_info "如需自定义配置，可编辑："
        print_info "  nano $SKILL_DIR/.env"
        print_info "  或"
        print_info "  code $SKILL_DIR/.env"
    else
        print_warning "未找到 .env.example 文件"
    fi

    # 11. 完成
    print_header "安装完成！"

    print_success "YouTube Clipper 已成功安装为 Claude Code Skill"
    echo ""
    print_info "安装位置: $SKILL_DIR"
    echo ""

    # 检查依赖状态
    if [ "$FFMPEG_FOUND" = false ] || [ "$LIBASS_SUPPORTED" = false ]; then
        print_warning "系统依赖不完整，部分功能可能不可用"
        echo ""
    fi

    print_info "使用方法："
    print_info "  在 Claude Code 中输入："
    print_info "  \"剪辑这个 YouTube 视频：https://youtube.com/watch?v=VIDEO_ID\""
    echo ""
    print_info "详细文档："
    print_info "  - Skill 使用指南: $SKILL_DIR/SKILL.md"
    print_info "  - 项目文档: $SKILL_DIR/README.md"
    print_info "  - 技术说明: $SKILL_DIR/TECHNICAL_NOTES.md"
    echo ""
    print_success "祝使用愉快！ 🎉"
    echo ""
}

# 错误处理
trap 'print_error "安装过程中发生错误"; exit 1' ERR

# 运行主函数
main

MIT License

Copyright (c) 2026 op7418

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

#!/usr/bin/env python3
"""
YouTube 视频智能剪辑工具 - Scripts 包
"""

__version__ = "1.0.0"
__author__ = "Claude Code"

#!/usr/bin/env python3
"""
分析字幕并生成章节
解析 VTT 字幕文件，准备数据供 Claude AI 分析
"""

import sys
import re
import json
from pathlib import Path
from typing import List, Dict

from utils import (
    time_to_seconds,
    seconds_to_time,
    get_video_duration_display
)


def parse_vtt(vtt_path: str) -> List[Dict]:
    """
    解析 VTT 字幕文件

    Args:
        vtt_path: VTT 文件路径

    Returns:
        List[Dict]: 字幕列表，每项包含 {start, end, text}

    Example:
        [
            {'start': 0.0, 'end': 3.5, 'text': 'Hello world'},
            {'start': 3.5, 'end': 7.2, 'text': 'This is a test'},
            ...
        ]
    """
    vtt_path = Path(vtt_path)

    if not vtt_path.exists():
        raise FileNotFoundError(f"Subtitle file not found: {vtt_path}")

    print(f"📊 解析字幕文件: {vtt_path.name}")

    subtitles = []

    with open(vtt_path, 'r', encoding='utf-8') as f:
        content = f.read()

    # 移除 WEBVTT 头部和样式信息
    content = re.sub(r'^WEBVTT.*?\n\n', '', content, flags=re.DOTALL)
    content = re.sub(r'STYLE.*?-->', '', content, flags=re.DOTALL)

    # 分割字幕块
    blocks = content.strip().split('\n\n')

    for block in blocks:
        lines = block.strip().split('\n')

        if len(lines) < 2:
            continue

        # 查找时间戳行
        timestamp_line = None
        text_lines = []

        for line in lines:
            # 匹配时间戳格式: 00:00:00.000 --> 00:00:03.000
            if '-->' in line:
                timestamp_line = line
            elif line and not line.isdigit():  # 跳过序号
                text_lines.append(line)

        if not timestamp_line or not text_lines:
            continue

        # 解析时间戳
        try:
            # 移除可能的位置信息（如 align:start position:0%）
            timestamp_line = re.sub(r'align:.*|position:.*', '', timestamp_line).strip()

            times = timestamp_line.split('-->')
            start_str = times[0].strip()
            end_str = times[1].strip()

            start = time_to_seconds(start_str)
            end = time_to_seconds(end_str)

            # 合并文本行
            text = ' '.join(text_lines)

            # 清理 HTML 标签（如果有）
            text = re.sub(r'<[^>]+>', '', text)

            # 清理特殊字符
            text = text.strip()

            if text:
                subtitles.append({
                    'start': start,
                    'end': end,
                    'text': text
                })

        except Exception as e:
            # 跳过无法解析的字幕块
            continue

    print(f"   找到 {len(subtitles)} 条字幕")

    if subtitles:
        total_duration = subtitles[-1]['end']
        print(f"   总时长: {get_video_duration_display(total_duration)}")

    return subtitles


def prepare_analysis_data(subtitles: List[Dict], target_chapter_duration: int = 180) -> Dict:
    """
    准备数据供 Claude AI 分析

    Args:
        subtitles: 字幕列表
        target_chapter_duration: 目标章节时长（秒），默认 180 秒（3 分钟）

    Returns:
        Dict: {
            'subtitle_text': 带时间戳的完整字幕文本,
            'total_duration': 总时长,
            'subtitle_count': 字幕条数,
            'target_chapter_duration': 目标章节时长,
            'estimated_chapters': 预估章节数
        }
    """
    if not subtitles:
        raise ValueError("No subtitles to analyze")

    print(f"\n📝 准备分析数据...")

    # 将字幕合并为带时间戳的完整文本
    full_text_lines = []

    for sub in subtitles:
        time_str = seconds_to_time(sub['start'], include_hours=True, use_comma=False)
        full_text_lines.append(f"[{time_str}] {sub['text']}")

    full_text = '\n'.join(full_text_lines)

    total_duration = subtitles[-1]['end']
    estimated_chapters = max(1, int(total_duration / target_chapter_duration))

    print(f"   总时长: {get_video_duration_display(total_duration)}")
    print(f"   字幕条数: {len(subtitles)}")
    print(f"   目标章节时长: {target_chapter_duration} 秒 ({target_chapter_duration // 60} 分钟)")
    print(f"   预估章节数: {estimated_chapters}")

    return {
        'subtitle_text': full_text,
        'total_duration': total_duration,
        'subtitle_count': len(subtitles),
        'target_chapter_duration': target_chapter_duration,
        'estimated_chapters': estimated_chapters,
        'subtitles_raw': subtitles  # 保留原始数据供后续使用
    }


def save_analysis_data(data: Dict, output_path: str):
    """
    保存分析数据到 JSON 文件

    Args:
        data: 分析数据
        output_path: 输出文件路径
    """
    output_path = Path(output_path)

    # 创建输出目录
    output_path.parent.mkdir(parents=True, exist_ok=True)

    # 保存为 JSON
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(data, f, indent=2, ensure_ascii=False)

    print(f"✅ 分析数据已保存: {output_path}")


def main():
    """命令行入口"""
    if len(sys.argv) < 2:
        print("Usage: python analyze_subtitles.py <vtt_file> [target_duration] [output_json]")
        print("\nArguments:")
        print("  vtt_file         - VTT 字幕文件路径")
        print("  target_duration  - 目标章节时长（秒），默认 180")
        print("  output_json      - 输出 JSON 文件路径（可选）")
        print("\nExample:")
        print("  python analyze_subtitles.py video.en.vtt")
        print("  python analyze_subtitles.py video.en.vtt 240")
        print("  python analyze_subtitles.py video.en.vtt 240 analysis.json")
        sys.exit(1)

    vtt_file = sys.argv[1]
    target_duration = int(sys.argv[2]) if len(sys.argv) > 2 else 180
    output_json = sys.argv[3] if len(sys.argv) > 3 else None

    try:
        # 解析字幕
        subtitles = parse_vtt(vtt_file)

        if not subtitles:
            print("❌ 未找到有效字幕")
            sys.exit(1)

        # 准备分析数据
        analysis_data = prepare_analysis_data(subtitles, target_duration)

        # 输出字幕文本（供 Claude 分析）
        print("\n" + "="*60)
        print("字幕文本（前 50 行预览）:")
        print("="*60)
        lines = analysis_data['subtitle_text'].split('\n')
        preview_lines = lines[:50]
        print('\n'.join(preview_lines))
        if len(lines) > 50:
            print(f"\n... （还有 {len(lines) - 50} 行）")

        # 保存到文件（如果指定）
        if output_json:
            save_analysis_data(analysis_data, output_json)

        # 输出摘要信息
        print("\n" + "="*60)
        print("分析摘要:")
        print("="*60)
        print(json.dumps({
            'total_duration': analysis_data['total_duration'],
            'total_duration_display': get_video_duration_display(analysis_data['total_duration']),
            'subtitle_count': analysis_data['subtitle_count'],
            'target_chapter_duration': analysis_data['target_chapter_duration'],
            'estimated_chapters': analysis_data['estimated_chapters']
        }, indent=2, ensure_ascii=False))

        print("\n💡 提示：现在可以使用 Claude AI 分析上述字幕文本，生成精细章节")

    except Exception as e:
        print(f"\n❌ 错误: {str(e)}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
烧录字幕到视频
处理 FFmpeg libass 支持和路径空格问题
"""

import sys
import os
import shutil
import subprocess
import tempfile
import platform
from pathlib import Path
from typing import Dict, Optional

from utils import format_file_size


def detect_ffmpeg_variant() -> Dict:
    """
    检测 FFmpeg 版本和 libass 支持

    Returns:
        Dict: {
            'type': 'full' | 'standard' | 'none',
            'path': FFmpeg 可执行文件路径,
            'has_libass': 是否支持 libass
        }
    """
    print("🔍 检测 FFmpeg 环境...")

    # 优先检查 ffmpeg-full（macOS）
    if platform.system() == 'Darwin':
        # Apple Silicon
        full_path_arm = '/opt/homebrew/opt/ffmpeg-full/bin/ffmpeg'
        # Intel
        full_path_intel = '/usr/local/opt/ffmpeg-full/bin/ffmpeg'

        for full_path in [full_path_arm, full_path_intel]:
            if Path(full_path).exists():
                has_libass = check_libass_support(full_path)
                print(f"   找到 ffmpeg-full: {full_path}")
                print(f"   libass 支持: {'✅ 是' if has_libass else '❌ 否'}")
                return {
                    'type': 'full',
                    'path': full_path,
                    'has_libass': has_libass
                }

    # 检查标准 FFmpeg
    standard_path = shutil.which('ffmpeg')
    if standard_path:
        has_libass = check_libass_support(standard_path)
        variant_type = 'full' if has_libass else 'standard'
        print(f"   找到 FFmpeg: {standard_path}")
        print(f"   类型: {variant_type}")
        print(f"   libass 支持: {'✅ 是' if has_libass else '❌ 否'}")
        return {
            'type': variant_type,
            'path': standard_path,
            'has_libass': has_libass
        }

    # 未找到 FFmpeg
    print("   ❌ 未找到 FFmpeg")
    return {
        'type': 'none',
        'path': None,
        'has_libass': False
    }


def check_libass_support(ffmpeg_path: str) -> bool:
    """
    检查 FFmpeg 是否支持 libass（字幕烧录必需）

    Args:
        ffmpeg_path: FFmpeg 可执行文件路径

    Returns:
        bool: 是否支持 libass
    """
    try:
        # 检查是否有 subtitles 滤镜
        result = subprocess.run(
            [ffmpeg_path, '-filters'],
            capture_output=True,
            text=True,
            timeout=5
        )

        # 查找 subtitles 滤镜
        return 'subtitles' in result.stdout.lower()

    except Exception:
        return False


def install_ffmpeg_full_guide():
    """
    显示安装 ffmpeg-full 的指南
    """
    print("\n" + "="*60)
    print("⚠️  需要安装 ffmpeg-full 才能烧录字幕")
    print("="*60)

    if platform.system() == 'Darwin':
        print("\nmacOS 安装方法:")
        print("  brew install ffmpeg-full")
        print("\n安装后，FFmpeg 路径:")
        print("  /opt/homebrew/opt/ffmpeg-full/bin/ffmpeg  (Apple Silicon)")
        print("  /usr/local/opt/ffmpeg-full/bin/ffmpeg     (Intel)")
    else:
        print("\n其他系统:")
        print("  请从源码编译 FFmpeg，确保包含 libass 支持")
        print("  参考: https://trac.ffmpeg.org/wiki/CompilationGuide")

    print("\n验证安装:")
    print("  ffmpeg -filters 2>&1 | grep subtitles")
    print("="*60)


def burn_subtitles(
    video_path: str,
    subtitle_path: str,
    output_path: str,
    ffmpeg_path: str = None,
    font_size: int = 24,
    margin_v: int = 30
) -> str:
    """
    烧录字幕到视频（使用临时目录解决路径空格问题）

    Args:
        video_path: 输入视频路径
        subtitle_path: 字幕文件路径（SRT 格式）
        output_path: 输出视频路径
        ffmpeg_path: FFmpeg 可执行文件路径（可选）
        font_size: 字体大小，默认 24
        margin_v: 底部边距，默认 30

    Returns:
        str: 输出视频路径

    Raises:
        FileNotFoundError: 输入文件不存在
        RuntimeError: FFmpeg 执行失败
    """
    video_path = Path(video_path)
    subtitle_path = Path(subtitle_path)
    output_path = Path(output_path)

    # 验证输入文件
    if not video_path.exists():
        raise FileNotFoundError(f"Video file not found: {video_path}")
    if not subtitle_path.exists():
        raise FileNotFoundError(f"Subtitle file not found: {subtitle_path}")

    # 检测 FFmpeg
    if ffmpeg_path is None:
        ffmpeg_info = detect_ffmpeg_variant()

        if ffmpeg_info['type'] == 'none':
            install_ffmpeg_full_guide()
            raise RuntimeError("FFmpeg not found")

        if not ffmpeg_info['has_libass']:
            install_ffmpeg_full_guide()
            raise RuntimeError("FFmpeg does not support libass (subtitles filter)")

        ffmpeg_path = ffmpeg_info['path']

    print(f"\n🎬 烧录字幕到视频...")
    print(f"   视频: {video_path.name}")
    print(f"   字幕: {subtitle_path.name}")
    print(f"   输出: {output_path.name}")
    print(f"   FFmpeg: {ffmpeg_path}")

    # 创建临时目录（解决路径空格问题）
    temp_dir = tempfile.mkdtemp(prefix='youtube_clipper_')
    print(f"   使用临时目录: {temp_dir}")

    try:
        # 复制文件到临时目录（路径无空格）
        temp_video = os.path.join(temp_dir, 'video.mp4')
        temp_subtitle = os.path.join(temp_dir, 'subtitle.srt')
        temp_output = os.path.join(temp_dir, 'output.mp4')

        print(f"   复制文件到临时目录...")
        shutil.copy(video_path, temp_video)
        shutil.copy(subtitle_path, temp_subtitle)

        # 构建 FFmpeg 命令
        # 使用 subtitles 滤镜烧录字幕
        subtitle_filter = f"subtitles={temp_subtitle}:force_style='FontSize={font_size},MarginV={margin_v}'"

        cmd = [
            ffmpeg_path,
            '-i', temp_video,
            '-vf', subtitle_filter,
            '-c:a', 'copy',  # 音频直接复制，不重新编码
            '-y',  # 覆盖输出文件
            temp_output
        ]

        print(f"   执行 FFmpeg...")
        print(f"   命令: {' '.join(cmd)}")

        # 执行 FFmpeg
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True
        )

        if result.returncode != 0:
            print(f"\n❌ FFmpeg 执行失败:")
            print(result.stderr)
            raise RuntimeError(f"FFmpeg failed with return code {result.returncode}")

        # 验证输出文件
        if not Path(temp_output).exists():
            raise RuntimeError("Output file not created")

        # 移动输出文件到目标位置
        print(f"   移动输出文件...")
        output_path.parent.mkdir(parents=True, exist_ok=True)
        shutil.move(temp_output, output_path)

        # 获取文件大小
        output_size = output_path.stat().st_size
        print(f"✅ 字幕烧录完成")
        print(f"   输出文件: {output_path}")
        print(f"   文件大小: {format_file_size(output_size)}")

        return str(output_path)

    finally:
        # 清理临时目录
        try:
            shutil.rmtree(temp_dir, ignore_errors=True)
            print(f"   清理临时目录")
        except Exception:
            pass


def main():
    """命令行入口"""
    if len(sys.argv) < 4:
        print("Usage: python burn_subtitles.py <video> <subtitle> <output> [font_size] [margin_v]")
        print("\nArguments:")
        print("  video      - 输入视频文件路径")
        print("  subtitle   - 字幕文件路径（SRT 格式）")
        print("  output     - 输出视频文件路径")
        print("  font_size  - 字体大小，默认 24")
        print("  margin_v   - 底部边距，默认 30")
        print("\nExample:")
        print("  python burn_subtitles.py input.mp4 subtitle.srt output.mp4")
        print("  python burn_subtitles.py input.mp4 subtitle.srt output.mp4 28 40")
        sys.exit(1)

    video_path = sys.argv[1]
    subtitle_path = sys.argv[2]
    output_path = sys.argv[3]
    font_size = int(sys.argv[4]) if len(sys.argv) > 4 else 24
    margin_v = int(sys.argv[5]) if len(sys.argv) > 5 else 30

    try:
        result_path = burn_subtitles(
            video_path,
            subtitle_path,
            output_path,
            font_size=font_size,
            margin_v=margin_v
        )

        print(f"\n✨ 完成！输出文件: {result_path}")

    except Exception as e:
        print(f"\n❌ 错误: {str(e)}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
剪辑视频片段
使用 FFmpeg 精确剪辑视频，保持原始质量
"""

import sys
import shutil
import subprocess
from pathlib import Path
from typing import Union

from utils import (
    time_to_seconds,
    seconds_to_time,
    format_file_size,
    get_video_duration_display
)


def clip_video(
    video_path: str,
    start_time: Union[str, float],
    end_time: Union[str, float],
    output_path: str,
    ffmpeg_path: str = None
) -> str:
    """
    剪辑视频片段

    Args:
        video_path: 输入视频路径
        start_time: 起始时间（秒数或时间字符串，如 "00:01:30"）
        end_time: 结束时间（秒数或时间字符串）
        output_path: 输出视频路径
        ffmpeg_path: FFmpeg 可执行文件路径（可选）

    Returns:
        str: 输出视频路径

    Raises:
        FileNotFoundError: 输入文件不存在
        RuntimeError: FFmpeg 执行失败
    """
    video_path = Path(video_path)
    output_path = Path(output_path)

    # 验证输入文件
    if not video_path.exists():
        raise FileNotFoundError(f"Video file not found: {video_path}")

    # 转换时间为秒数
    if isinstance(start_time, str):
        start_seconds = time_to_seconds(start_time)
    else:
        start_seconds = float(start_time)

    if isinstance(end_time, str):
        end_seconds = time_to_seconds(end_time)
    else:
        end_seconds = float(end_time)

    # 验证时间范围
    if start_seconds >= end_seconds:
        raise ValueError(f"Start time ({start_seconds}s) must be before end time ({end_seconds}s)")

    duration = end_seconds - start_seconds

    # 检测 FFmpeg
    if ffmpeg_path is None:
        ffmpeg_path = shutil.which('ffmpeg')
        if not ffmpeg_path:
            raise RuntimeError("FFmpeg not found. Please install FFmpeg.")

    print(f"\n✂️  剪辑视频片段...")
    print(f"   输入: {video_path.name}")
    print(f"   起始时间: {seconds_to_time(start_seconds)} ({start_seconds}s)")
    print(f"   结束时间: {seconds_to_time(end_seconds)} ({end_seconds}s)")
    print(f"   片段时长: {get_video_duration_display(duration)}")
    print(f"   输出: {output_path.name}")

    # 创建输出目录
    output_path.parent.mkdir(parents=True, exist_ok=True)

    # 构建 FFmpeg 命令
    # 使用 -ss 和 -t 进行精确剪辑
    # -c copy: 直接复制流，不重新编码（快速且无损）
    cmd = [
        ffmpeg_path,
        '-ss', str(start_seconds),  # 起始时间
        '-i', str(video_path),       # 输入文件
        '-t', str(duration),         # 持续时间
        '-c', 'copy',                # 直接复制，不重新编码
        '-y',                        # 覆盖输出文件
        str(output_path)
    ]

    print(f"   执行 FFmpeg...")

    # 执行 FFmpeg
    result = subprocess.run(
        cmd,
        capture_output=True,
        text=True
    )

    if result.returncode != 0:
        print(f"\n❌ FFmpeg 执行失败:")
        print(result.stderr)
        raise RuntimeError(f"FFmpeg failed with return code {result.returncode}")

    # 验证输出文件
    if not output_path.exists():
        raise RuntimeError("Output file not created")

    # 获取文件大小
    output_size = output_path.stat().st_size
    print(f"✅ 剪辑完成")
    print(f"   输出文件: {output_path}")
    print(f"   文件大小: {format_file_size(output_size)}")

    return str(output_path)


def extract_subtitle_segment(
    subtitles: list,
    start_time: float,
    end_time: float,
    adjust_timestamps: bool = True
) -> list:
    """
    从完整字幕中提取指定时间段的字幕

    Args:
        subtitles: 完整字幕列表（每项包含 {start, end, text}）
        start_time: 起始时间（秒）
        end_time: 结束时间（秒）
        adjust_timestamps: 是否调整时间戳（减去起始时间）

    Returns:
        list: 提取的字幕列表
    """
    segment_subtitles = []

    for sub in subtitles:
        # 字幕在时间范围内
        if sub['start'] >= start_time and sub['end'] <= end_time:
            if adjust_timestamps:
                # 调整时间戳（相对于片段起始时间）
                adjusted_sub = {
                    'start': sub['start'] - start_time,
                    'end': sub['end'] - start_time,
                    'text': sub['text']
                }
                segment_subtitles.append(adjusted_sub)
            else:
                segment_subtitles.append(sub.copy())

        # 字幕跨越时间范围边界（部分重叠）
        elif sub['start'] < end_time and sub['end'] > start_time:
            if adjust_timestamps:
                adjusted_sub = {
                    'start': max(0, sub['start'] - start_time),
                    'end': min(end_time - start_time, sub['end'] - start_time),
                    'text': sub['text']
                }
                segment_subtitles.append(adjusted_sub)
            else:
                segment_subtitles.append(sub.copy())

    return segment_subtitles


def save_subtitles_as_srt(subtitles: list, output_path: str):
    """
    保存字幕为 SRT 格式

    Args:
        subtitles: 字幕列表
        output_path: 输出文件路径
    """
    output_path = Path(output_path)
    output_path.parent.mkdir(parents=True, exist_ok=True)

    with open(output_path, 'w', encoding='utf-8') as f:
        for i, sub in enumerate(subtitles, 1):
            # SRT 序号
            f.write(f"{i}\n")

            # SRT 时间戳（使用逗号分隔毫秒）
            start_time = seconds_to_time(sub['start'], include_hours=True, use_comma=True)
            end_time = seconds_to_time(sub['end'], include_hours=True, use_comma=True)
            f.write(f"{start_time} --> {end_time}\n")

            # 字幕文本
            f.write(f"{sub['text']}\n")

            # 空行分隔
            f.write("\n")

    print(f"✅ 字幕已保存: {output_path}")


def main():
    """命令行入口"""
    if len(sys.argv) < 5:
        print("Usage: python clip_video.py <video> <start_time> <end_time> <output>")
        print("\nArguments:")
        print("  video      - 输入视频文件路径")
        print("  start_time - 起始时间（秒数或时间字符串，如 00:01:30）")
        print("  end_time   - 结束时间（秒数或时间字符串）")
        print("  output     - 输出视频文件路径")
        print("\nExample:")
        print("  python clip_video.py input.mp4 0 195 output.mp4")
        print("  python clip_video.py input.mp4 00:00:00 00:03:15 output.mp4")
        print("  python clip_video.py input.mp4 01:30:00 01:33:15 output.mp4")
        sys.exit(1)

    video_path = sys.argv[1]
    start_time = sys.argv[2]
    end_time = sys.argv[3]
    output_path = sys.argv[4]

    try:
        result_path = clip_video(video_path, start_time, end_time, output_path)
        print(f"\n✨ 完成！输出文件: {result_path}")

    except Exception as e:
        print(f"\n❌ 错误: {str(e)}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
下载 YouTube 视频和字幕
使用 yt-dlp 下载视频（最高 1080p）和英文字幕
"""

import sys
import json
from pathlib import Path

try:
    import yt_dlp
except ImportError:
    print("❌ Error: yt-dlp not installed")
    print("Please install: pip install yt-dlp")
    sys.exit(1)

from utils import (
    validate_url,
    sanitize_filename,
    format_file_size,
    get_video_duration_display,
    ensure_directory
)


def download_video(url: str, output_dir: str = None) -> dict:
    """
    下载 YouTube 视频和字幕

    Args:
        url: YouTube URL
        output_dir: 输出目录，默认为当前目录

    Returns:
        dict: {
            'video_path': 视频文件路径,
            'subtitle_path': 字幕文件路径,
            'title': 视频标题,
            'duration': 视频时长（秒）,
            'file_size': 文件大小（字节）
        }

    Raises:
        ValueError: 无效的 URL
        Exception: 下载失败
    """
    # 验证 URL
    if not validate_url(url):
        raise ValueError(f"Invalid YouTube URL: {url}")

    # 设置输出目录
    if output_dir is None:
        output_dir = Path.cwd()
    else:
        output_dir = Path(output_dir)

    output_dir = ensure_directory(output_dir)

    print(f"🎬 开始下载视频...")
    print(f"   URL: {url}")
    print(f"   输出目录: {output_dir}")

    # 配置 yt-dlp 选项
    ydl_opts = {
        # 视频格式：最高 1080p，优先 mp4
        'format': 'bestvideo[height<=1080][ext=mp4]+bestaudio[ext=m4a]/best[height<=1080][ext=mp4]/best',

        # 输出模板：包含视频 ID（避免特殊字符问题）
        'outtmpl': str(output_dir / '%(id)s.%(ext)s'),

        # 下载字幕
        'writesubtitles': True,
        'writeautomaticsub': True,  # 自动字幕作为备选
        'subtitleslangs': ['en'],   # 英文字幕
        'subtitlesformat': 'vtt',   # VTT 格式

        # 不下载缩略图
        'writethumbnail': False,

        # 静默模式（减少输出）
        'quiet': False,
        'no_warnings': False,

        # 进度钩子
        'progress_hooks': [_progress_hook],
    }

    try:
        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
            # 提取信息
            print("\n📊 获取视频信息...")
            info = ydl.extract_info(url, download=False)

            title = info.get('title', 'Unknown')
            duration = info.get('duration', 0)
            video_id = info.get('id', 'unknown')

            print(f"   标题: {title}")
            print(f"   时长: {get_video_duration_display(duration)}")
            print(f"   视频ID: {video_id}")

            # 下载视频
            print(f"\n📥 开始下载...")
            info = ydl.extract_info(url, download=True)

            # 获取下载的文件路径
            video_filename = ydl.prepare_filename(info)
            video_path = Path(video_filename)

            # 查找字幕文件
            subtitle_path = None
            subtitle_exts = ['.en.vtt', '.vtt']
            for ext in subtitle_exts:
                potential_sub = video_path.with_suffix(ext)
                # 处理带语言代码的字幕文件
                if not potential_sub.exists():
                    # 尝试 <filename>.en.vtt 格式
                    stem = video_path.stem
                    potential_sub = video_path.parent / f"{stem}.en.vtt"

                if potential_sub.exists():
                    subtitle_path = potential_sub
                    break

            # 获取文件大小
            file_size = video_path.stat().st_size if video_path.exists() else 0

            # 验证下载结果
            if not video_path.exists():
                raise Exception("Video file not found after download")

            print(f"\n✅ 视频下载完成: {video_path.name}")
            print(f"   大小: {format_file_size(file_size)}")

            if subtitle_path and subtitle_path.exists():
                print(f"✅ 字幕下载完成: {subtitle_path.name}")
            else:
                print(f"⚠️  未找到英文字幕")
                print(f"   提示：某些视频可能没有字幕或需要自动生成")

            return {
                'video_path': str(video_path),
                'subtitle_path': str(subtitle_path) if subtitle_path else None,
                'title': title,
                'duration': duration,
                'file_size': file_size,
                'video_id': video_id
            }

    except Exception as e:
        print(f"\n❌ 下载失败: {str(e)}")
        raise


def _progress_hook(d):
    """下载进度回调"""
    if d['status'] == 'downloading':
        # 显示下载进度
        if 'downloaded_bytes' in d and 'total_bytes' in d and d['total_bytes']:
            percent = d['downloaded_bytes'] / d['total_bytes'] * 100
            downloaded = format_file_size(d['downloaded_bytes'])
            total = format_file_size(d['total_bytes'])
            speed = d.get('speed', 0)
            speed_str = format_file_size(speed) + '/s' if speed else 'N/A'

            # 使用 \r 实现进度条覆盖
            bar_length = 30
            filled = int(bar_length * percent / 100)
            bar = '█' * filled + '░' * (bar_length - filled)

            print(f"\r   [{bar}] {percent:.1f}% - {downloaded}/{total} - {speed_str}", end='', flush=True)
        elif 'downloaded_bytes' in d:
            # 无总大小信息时，只显示已下载
            downloaded = format_file_size(d['downloaded_bytes'])
            speed = d.get('speed', 0)
            speed_str = format_file_size(speed) + '/s' if speed else 'N/A'
            print(f"\r   下载中... {downloaded} - {speed_str}", end='', flush=True)

    elif d['status'] == 'finished':
        print()  # 换行


def main():
    """命令行入口"""
    if len(sys.argv) < 2:
        print("Usage: python download_video.py <youtube_url> [output_dir]")
        print("\nExample:")
        print("  python download_video.py https://youtube.com/watch?v=Ckt1cj0xjRM")
        print("  python download_video.py https://youtube.com/watch?v=Ckt1cj0xjRM ~/Downloads")
        sys.exit(1)

    url = sys.argv[1]
    output_dir = sys.argv[2] if len(sys.argv) > 2 else None

    try:
        result = download_video(url, output_dir)

        # 输出 JSON 结果（供其他脚本使用）
        print("\n" + "="*60)
        print("下载结果 (JSON):")
        print(json.dumps(result, indent=2, ensure_ascii=False))

    except Exception as e:
        print(f"\n❌ 错误: {str(e)}")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
提取字幕片段并转换为 SRT 格式
"""

import sys
import re
from datetime import timedelta

def parse_vtt_time(time_str):
    """解析 VTT 时间格式为秒"""
    parts = time_str.strip().split(':')
    if len(parts) == 3:
        hours = int(parts[0])
        minutes = int(parts[1])
        seconds = float(parts[2])
        return hours * 3600 + minutes * 60 + seconds
    elif len(parts) == 2:
        minutes = int(parts[0])
        seconds = float(parts[1])
        return minutes * 60 + seconds
    return 0

def format_srt_time(seconds):
    """格式化为 SRT 时间格式"""
    td = timedelta(seconds=seconds)
    hours = int(td.total_seconds() // 3600)
    minutes = int((td.total_seconds() % 3600) // 60)
    secs = int(td.total_seconds() % 60)
    millis = int((td.total_seconds() % 1) * 1000)
    return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"

def extract_subtitle_clip(vtt_file, start_time, end_time, output_file):
    """提取字幕片段"""
    # 解析时间
    start_seconds = parse_vtt_time(start_time)
    end_seconds = parse_vtt_time(end_time)

    print(f"📝 提取字幕片段...")
    print(f"   输入: {vtt_file}")
    print(f"   时间范围: {start_time} - {end_time}")
    print(f"   时间范围（秒）: {start_seconds:.1f}s - {end_seconds:.1f}s")

    # 读取 VTT 文件
    with open(vtt_file, 'r', encoding='utf-8') as f:
        lines = f.readlines()

    # 解析字幕
    subtitles = []
    i = 0
    while i < len(lines):
        line = lines[i].strip()

        # 查找时间戳行
        if '-->' in line:
            # 解析时间戳
            time_parts = line.split('-->')
            sub_start_str = time_parts[0].strip().split()[0]
            sub_end_str = time_parts[1].strip().split()[0]

            sub_start = parse_vtt_time(sub_start_str)
            sub_end = parse_vtt_time(sub_end_str)

            # 检查是否在目标时间范围内
            if sub_start >= start_seconds and sub_end <= end_seconds:
                # 收集字幕文本
                i += 1
                text_lines = []
                while i < len(lines) and lines[i].strip() != '':
                    text_lines.append(lines[i].strip())
                    i += 1

                text = ' '.join(text_lines)

                # 调整时间戳（减去起始时间）
                adjusted_start = sub_start - start_seconds
                adjusted_end = sub_end - start_seconds

                subtitles.append({
                    'start': adjusted_start,
                    'end': adjusted_end,
                    'text': text
                })

        i += 1

    print(f"   找到 {len(subtitles)} 条字幕")

    # 写入 SRT 格式
    with open(output_file, 'w', encoding='utf-8') as f:
        for idx, sub in enumerate(subtitles, 1):
            f.write(f"{idx}\n")
            f.write(f"{format_srt_time(sub['start'])} --> {format_srt_time(sub['end'])}\n")
            f.write(f"{sub['text']}\n")
            f.write("\n")

    print(f"✅ 字幕提取完成")
    print(f"   输出文件: {output_file}")
    print(f"   字幕条数: {len(subtitles)}")

    return subtitles

if __name__ == '__main__':
    if len(sys.argv) != 5:
        print("用法: python extract_subtitle_clip.py <vtt_file> <start_time> <end_time> <output_file>")
        print("示例: python extract_subtitle_clip.py input.vtt 00:05:47 00:09:19 output.srt")
        sys.exit(1)

    vtt_file = sys.argv[1]
    start_time = sys.argv[2]
    end_time = sys.argv[3]
    output_file = sys.argv[4]

    extract_subtitle_clip(vtt_file, start_time, end_time, output_file)

#!/usr/bin/env python3
"""
生成总结文案
基于章节信息生成适合社交媒体的文案
"""

import sys
import json
from pathlib import Path
from typing import Dict


def generate_summary(
    chapter_info: Dict,
    output_path: str = None
) -> str:
    """
    生成总结文案

    注意：此函数需要在 Claude Code Skill 环境中调用
    Claude 会自动处理文案生成逻辑

    Args:
        chapter_info: 章节信息，包含：
            - title: 章节标题
            - time_range: 时间范围
            - summary: 核心摘要
            - keywords: 关键词列表
        output_path: 输出文件路径（可选）

    Returns:
        str: 生成的文案
    """
    print(f"\n📝 生成总结文案...")
    print(f"   章节: {chapter_info.get('title', 'Unknown')}")

    # 输出章节信息（供 Claude 分析）
    print("\n" + "="*60)
    print("章节信息（JSON 格式）:")
    print("="*60)
    print(json.dumps(chapter_info, indent=2, ensure_ascii=False))

    print("\n" + "="*60)
    print("文案生成要求:")
    print("="*60)
    print("""
请基于上述章节信息生成适合社交媒体的文案。

文案要求：
1. 吸引人的标题（10-20字）
2. 核心观点（3-5个要点，每个1-2句话）
3. 适合平台：
   - 小红书：口语化，有emoji，1000字以内
   - 抖音：精炼，突出金句，300字以内
   - 微信公众号：详细，结构清晰，不限字数

输出格式（Markdown）：

# [标题]

## 核心观点

1. 观点1
2. 观点2
3. 观点3

## 适合平台

### 小红书版本（1000字）
[文案内容]

### 抖音版本（300字）
[文案内容]

### 微信公众号版本
[文案内容]

## 标签

#标签1 #标签2 #标签3
""")

    # 生成基础文案（占位符）
    summary_template = f"""# {chapter_info.get('title', '未命名章节')}

## 章节信息

- 时间范围: {chapter_info.get('time_range', 'N/A')}
- 核心摘要: {chapter_info.get('summary', 'N/A')}
- 关键词: {', '.join(chapter_info.get('keywords', []))}

## 核心观点

[待生成 - Claude 会在 Skill 执行时自动填充]

## 适合平台

### 小红书版本

[待生成]

### 抖音版本

[待生成]

### 微信公众号版本

[待生成]

## 标签

{' '.join(['#' + kw for kw in chapter_info.get('keywords', [])])}

---

生成时间: {chapter_info.get('generated_at', 'N/A')}
"""

    # 保存到文件（如果指定）
    if output_path:
        output_path = Path(output_path)
        output_path.parent.mkdir(parents=True, exist_ok=True)

        with open(output_path, 'w', encoding='utf-8') as f:
            f.write(summary_template)

        print(f"✅ 文案已保存: {output_path}")

    return summary_template


def load_chapter_info(json_path: str) -> Dict:
    """
    从 JSON 文件加载章节信息

    Args:
        json_path: JSON 文件路径

    Returns:
        Dict: 章节信息
    """
    json_path = Path(json_path)
    if not json_path.exists():
        raise FileNotFoundError(f"JSON file not found: {json_path}")

    print(f"📂 加载章节信息: {json_path.name}")

    with open(json_path, 'r', encoding='utf-8') as f:
        chapter_info = json.load(f)

    return chapter_info


def create_chapter_info(
    title: str,
    time_range: str,
    summary: str,
    keywords: list
) -> Dict:
    """
    创建章节信息字典

    Args:
        title: 章节标题
        time_range: 时间范围（如 "00:00 - 03:15"）
        summary: 核心摘要
        keywords: 关键词列表

    Returns:
        Dict: 章节信息
    """
    from datetime import datetime

    return {
        'title': title,
        'time_range': time_range,
        'summary': summary,
        'keywords': keywords,
        'generated_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    }


def main():
    """命令行入口"""
    if len(sys.argv) < 2:
        print("Usage: python generate_summary.py <chapter_info_json> [output_file]")
        print("   or: python generate_summary.py --create <title> <time_range> <summary> <keywords> [output_file]")
        print("\nArguments:")
        print("  chapter_info_json - 章节信息 JSON 文件路径")
        print("  output_file       - 输出文件路径（可选，默认为 summary.md）")
        print("\nCreate mode arguments:")
        print("  --create    - 创建模式")
        print("  title       - 章节标题")
        print("  time_range  - 时间范围（如 '00:00 - 03:15'）")
        print("  summary     - 核心摘要")
        print("  keywords    - 关键词（逗号分隔）")
        print("\nExample:")
        print("  python generate_summary.py chapter.json")
        print("  python generate_summary.py chapter.json summary.md")
        print("  python generate_summary.py --create 'AGI指数曲线' '00:00-03:15' '核心摘要' 'AGI,指数增长,Claude' summary.md")
        sys.exit(1)

    try:
        if sys.argv[1] == '--create':
            # 创建模式
            if len(sys.argv) < 6:
                print("❌ 创建模式需要提供: title, time_range, summary, keywords")
                sys.exit(1)

            title = sys.argv[2]
            time_range = sys.argv[3]
            summary = sys.argv[4]
            keywords = sys.argv[5].split(',')
            output_file = sys.argv[6] if len(sys.argv) > 6 else 'summary.md'

            chapter_info = create_chapter_info(title, time_range, summary, keywords)

        else:
            # JSON 模式
            json_file = sys.argv[1]
            output_file = sys.argv[2] if len(sys.argv) > 2 else 'summary.md'

            chapter_info = load_chapter_info(json_file)

        # 生成文案
        summary = generate_summary(chapter_info, output_file)

        print("\n" + "="*60)
        print("生成的文案预览:")
        print("="*60)
        print(summary)

        print("\n⚠️  提示：此脚本需要在 Claude Code Skill 中运行")
        print("   Claude 会自动生成详细的文案内容")
        print("   当前仅输出模板")

    except Exception as e:
        print(f"\n❌ 错误: {str(e)}")
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    main()