Youtube Ai Digest

{
  "metadata": {
    "name": "youtube-ai-digest",
    "description": "Claude Code skill for browsing AI-related YouTube videos, fetching transcripts, and generating Markdown reports",
    "owner": "yizhiyanhua-ai",
    "version": "1.0.0",
    "homepage": "https://github.com/yizhiyanhua-ai/youtube-ai-digest"
  },
  "plugins": [
    {
      "name": "youtube-ai-digest",
      "description": "Browses AI-related YouTube videos from subscribed channels, fetches transcripts, generates summaries, and creates Markdown reports. Use when the user mentions YouTube AI videos, video summaries, channel subscriptions, or asks about recent AI content from YouTube creators.",
      "source": "./",
      "strict": false,
      "version": "1.0.0",
      "category": "productivity",
      "keywords": [
        "youtube",
        "ai",
        "video",
        "transcript",
        "summary",
        "digest",
        "markdown",
        "report"
      ],
      "skills": [
        "./"
      ]
    }
  ]
}

# youtube-ai-digest data
data/
!data/channels.json
__pycache__/
*.pyc
.DS_Store
*.png
*.jpg
*.webp

{
  "channels": [
    {"name": "Two Minute Papers", "id": "UCbfYPyITQ-7l4upoX8nvctg", "handle": "@TwoMinutePapers"},
    {"name": "Yannic Kilcher", "id": "UCZHmQk67mN31gbHey6BVyNw", "handle": "@YannicKilcher"},
    {"name": "AI Explained", "id": "UCNJ1Ymd5yFuUPtn21xtRbbw", "handle": "@aiexplained-official"},
    {"name": "Matt Wolfe", "id": "UCJMQpUgSRkRb5M2MqN2BxSg", "handle": "@mreflow"},
    {"name": "The AI Advantage", "id": "UCFg-CGLLDOOsPjnOsMBG14A", "handle": "@theaiadvantage"},
    {"name": "Matthew Berman", "id": "UCRI-Ds5eY90nMJjIEi-67JA", "handle": "@matthewberman"},
    {"name": "Fireship", "id": "UCsBjURrPoezykLs9EqgamOA", "handle": "@Fireship"},
    {"name": "Wes Roth", "id": "UC-jFiJJrIBeb8G0P9MaXJtg", "handle": "@WesRoth"},
    {"name": "David Shapiro", "id": "UCnm23dZMHiAfnLwBiPrGaiQ", "handle": "@DavidShapiroAutomator"},
    {"name": "TheAIGRID", "id": "UCkGRxjibCl-TzpxPMl4bZjg", "handle": "@TheAIGRID"},
    {"name": "WorldofAI", "id": "UCCy7QB8FVDQQJv5IC3uy_HA", "handle": "@WorldofAI"},
    {"name": "Prompt Engineering", "id": "UCDq7SjbgRKty5TgGafW8Clg", "handle": "@engineerprompt"},
    {"name": "All About AI", "id": "UCVc7zR-zw0H3eyzidN-VXlA", "handle": "@AllAboutAI"},
    {"name": "Jeff Su", "id": "UCrXn9a9GXuqWJAMwCHJWQiA", "handle": "@JeffSu"},
    {"name": "NetworkChuck", "id": "UC9x0AN7kwET-E1Me2u-ejXA", "handle": "@NetworkChuck"}
  ]
}

{
  "name": "youtube-ai-digest",
  "version": "1.0.0",
  "description": "Browse, summarize and capture AI-related YouTube videos from subscribed channels. Generates Markdown reports with thumbnails and screenshots.",
  "author": "User",
  "dependencies": {
    "python": ">=3.9",
    "pip_packages": ["yt-dlp", "youtube-transcript-api"]
  },
  "platforms": ["macOS", "Linux"],
  "tags": ["youtube", "ai", "summary", "video", "automation"],
  "triggers": [
    "youtube ai digest",
    "summarize youtube",
    "browse youtube ai",
    "youtube ai summary"
  ]
}

#!/usr/bin/env python3
"""获取关注频道的最新视频列表"""
import json
import os
import subprocess
from datetime import datetime, timedelta
from pathlib import Path
import argparse

DATA_DIR = Path(__file__).parent.parent / "data"
CHANNELS_FILE = DATA_DIR / "channels.json"
OUTPUT_FILE = DATA_DIR / "videos.json"

AI_KEYWORDS = [
    "ai", "artificial intelligence", "machine learning", "deep learning",
    "llm", "gpt", "claude", "gemini", "neural", "openai", "anthropic",
    "transformer", "diffusion", "reinforcement", "chatbot", "agent",
    "deepmind", "nvidia", "autonomous", "robot", "cursor", "copilot",
    "sora", "midjourney", "stable diffusion", "vibe coding"
]

# 传递代理到子进程的环境变量
def get_env():
    """继承当前环境（含 HTTPS_PROXY 等代理变量）"""
    return {**os.environ}


def load_channels():
    if not CHANNELS_FILE.exists():
        return []
    with open(CHANNELS_FILE) as f:
        return json.load(f).get("channels", [])\


def fetch_channel_videos(channel, days=3):
    """
    使用 yt-dlp flat-playlist + approximate_date 获取频道最近视频。
    优先用 @handle 格式（能获取到 upload_date），回退到 channel_id。
    """
    date_after = (datetime.now() - timedelta(days=days)).strftime("%Y%m%d")

    # 优先用 @handle，回退到 channel_id URL
    handle = channel.get("handle")
    channel_id = channel.get("id")
    if handle:
        url = f"https://www.youtube.com/{handle}/videos"
    else:
        url = f"https://www.youtube.com/channel/{channel_id}/videos"

    cmd = [
        "yt-dlp",
        "--flat-playlist",
        "--dump-json",
        "--playlist-end", "10",
        "--extractor-args", "youtubetab:approximate_date",  # 关键：让 flat-playlist 返回 upload_date
        url
    ]

    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            timeout=60,
            env=get_env()  # 传递代理环境变量
        )
        videos = []
        for line in result.stdout.strip().split("\n"):
            if not line:
                continue
            try:
                v = json.loads(line)
            except json.JSONDecodeError:
                continue

            upload_date = v.get("upload_date") or ""
            # 日期过滤（approximate_date 是近似值，允许多1天容差）
            if upload_date and upload_date < date_after:
                continue

            videos.append({
                "id": v.get("id"),
                "title": v.get("title"),
                "url": f"https://www.youtube.com/watch?v={v.get('id')}",
                "channel_id": channel_id,
                "channel_name": channel.get("name"),
                "upload_date": upload_date,
                "duration": v.get("duration_string", ""),
                "view_count": v.get("view_count", 0),
                "description": v.get("description", "")[:300] if v.get("description") else "",
            })
        return videos
    except subprocess.TimeoutExpired:
        print(f"  Timeout: {channel.get('name')}")
        return []
    except Exception as e:
        print(f"  Error fetching {channel.get('name')}: {e}")
        return []


def is_ai_related(video, extra_keyword=None):
    """判断视频是否与 AI 相关"""
    text = (video.get("title", "") + " " + video.get("description", "")).lower()
    if extra_keyword:
        return extra_keyword.lower() in text
    return any(kw in text for kw in AI_KEYWORDS)


def format_date(upload_date):
    if len(upload_date) == 8:
        return f"{upload_date[:4]}-{upload_date[4:6]}-{upload_date[6:]}"
    return upload_date


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--days", type=int, default=3, help="获取最近 N 天的视频")
    parser.add_argument("--keyword", default=None, help="额外关键词过滤")
    parser.add_argument("--all", action="store_true", help="不过滤，返回所有视频")
    args = parser.parse_args()

    channels = load_channels()
    if not channels:
        print("No channels configured. Edit data/channels.json")
        return

    all_videos = []
    for ch in channels:
        print(f"Fetching: {ch['name']}...", flush=True)
        videos = fetch_channel_videos(ch, args.days)
        all_videos.extend(videos)
        if videos:
            print(f"  -> {len(videos)} video(s)")

    # 过滤 AI 相关
    if args.all:
        filtered = all_videos
    else:
        filtered = [v for v in all_videos if is_ai_related(v, args.keyword)]

    # 按上传日期+播放量排序（最新优先，同日按播放量降序）
    filtered.sort(key=lambda v: (v.get("upload_date", ""), v.get("view_count", 0)), reverse=True)

    OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
    with open(OUTPUT_FILE, "w") as f:
        json.dump({
            "videos": filtered,
            "fetched_at": datetime.now().isoformat(),
            "days": args.days,
            "total": len(filtered)
        }, f, indent=2, ensure_ascii=False)

    print(f"\nFound {len(filtered)} AI-related videos (last {args.days} days)")
    for i, v in enumerate(filtered, 1):
        date = format_date(v.get("upload_date", ""))
        vc = f"{v['view_count']:,}" if v.get("view_count") else "?"
        print(f"  {i}. [{date}] 👁 {vc} | {v['title']} ({v['channel_name']}) {v['duration']}")
        print(f"     {v['url']}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""生成 Markdown 报告"""
import json
import argparse
import subprocess
from datetime import datetime
from pathlib import Path

DATA_DIR = Path(__file__).parent.parent / "data"
OUTPUT_DIR = DATA_DIR / "output"

def get_video_info(video_id):
    """使用 yt-dlp 获取视频信息"""
    cmd = ["yt-dlp", "--dump-json", "--no-download", f"https://www.youtube.com/watch?v={video_id}"]
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
        return json.loads(result.stdout)
    except (subprocess.TimeoutExpired, json.JSONDecodeError, FileNotFoundError) as e:
        print(f"Error fetching video info: {e}")
        return {}

def download_thumbnail(video_id, output_path):
    """下载视频封面"""
    cmd = ["yt-dlp", "--write-thumbnail", "--skip-download", "-o", str(output_path / "thumbnail"),
           f"https://www.youtube.com/watch?v={video_id}"]
    subprocess.run(cmd, capture_output=True)

def generate_markdown(video_id, info, transcript_file, screenshots=None, summary=None):
    """生成 Markdown 报告"""
    title = info.get("title", "Unknown")
    channel = info.get("channel", "Unknown")
    upload_date = info.get("upload_date", "")
    duration = info.get("duration_string", "")
    url = f"https://www.youtube.com/watch?v={video_id}"

    md = f"""# {title}

![封面](thumbnail.webp)

## 视频信息
- 频道: {channel}
- 发布时间: {upload_date}
- 时长: {duration}
- 链接: {url}

## 内容摘要
{summary or "[请使用 Claude 根据字幕生成摘要]"}

"""
    # 添加字幕内容
    if transcript_file and Path(transcript_file).exists():
        md += "## 字幕内容\n\n"
        md += "```\n"
        md += Path(transcript_file).read_text()[:3000]  # 限制长度
        md += "\n```\n\n"

    # 添加截图
    if screenshots:
        md += "## 关键截图\n\n"
        for i, ss in enumerate(screenshots, 1):
            md += f"![截图{i}]({ss})\n\n"

    return md

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--video-id", required=True)
    parser.add_argument("--output", default=str(OUTPUT_DIR))
    parser.add_argument("--summary", help="摘要内容")
    args = parser.parse_args()

    output_dir = Path(args.output) / args.video_id
    output_dir.mkdir(parents=True, exist_ok=True)

    print(f"获取视频信息: {args.video_id}")
    info = get_video_info(args.video_id)

    print("下载封面...")
    download_thumbnail(args.video_id, output_dir)

    transcript_file = DATA_DIR / f"transcript_{args.video_id}.txt"

    md = generate_markdown(args.video_id, info, transcript_file, summary=args.summary)

    report_file = output_dir / "report.md"
    report_file.write_text(md, encoding="utf-8")
    print(f"报告已生成: {report_file}")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""获取视频字幕 - 使用 yt-dlp，支持代理和 Cookie"""
import json
import os
import argparse
import subprocess
from pathlib import Path

DATA_DIR = Path(__file__).parent.parent / "data"


def get_env():
    """继承当前环境（含 HTTPS_PROXY 等代理变量）"""
    return {**os.environ}


def get_transcript_ytdlp(video_id):
    """
    使用 yt-dlp 获取字幕。
    策略：
      1. 先不带 cookie 尝试（部分视频无需登录）
      2. 失败后自动加 --cookies-from-browser chrome 重试
    """
    url = f"https://www.youtube.com/watch?v={video_id}"
    output_template = str(DATA_DIR / f"sub_{video_id}")

    base_cmd = [
        "yt-dlp", "--skip-download",
        "--write-auto-sub", "--write-sub",
        "--sub-lang", "en,zh",
        "--sub-format", "vtt",
        "-o", output_template,
    ]

    # 第一次尝试：不带 cookie
    print("  尝试无 cookie 获取字幕...", flush=True)
    subprocess.run(base_cmd + [url], capture_output=True, env=get_env(), timeout=60)

    result = _find_vtt(video_id)
    if result[0]:
        return result

    # 第二次尝试：带 Chrome cookie
    print("  重试：使用 Chrome cookie...", flush=True)
    subprocess.run(
        base_cmd + ["--cookies-from-browser", "chrome", url],
        capture_output=True,
        env=get_env(),
        timeout=60
    )

    result = _find_vtt(video_id)
    if result[0]:
        return result

    # 第三次尝试：带 Firefox cookie（部分用户用 Firefox 登录 YouTube）
    print("  重试：使用 Firefox cookie...", flush=True)
    subprocess.run(
        base_cmd + ["--cookies-from-browser", "firefox", url],
        capture_output=True,
        env=get_env(),
        timeout=60
    )

    return _find_vtt(video_id)


def _find_vtt(video_id):
    """在 data 目录下查找已生成的字幕文件"""
    for suffix in [".en.vtt", ".zh.vtt", ".en-orig.vtt", ".zh-Hans.vtt"]:
        sub_file = DATA_DIR / f"sub_{video_id}{suffix}"
        if sub_file.exists():
            lang = suffix.split(".")[1]  # "en" / "zh"
            return parse_vtt(sub_file), lang
    return None, None


def parse_vtt(vtt_file):
    """解析 VTT 字幕文件，去重并合并"""
    content = vtt_file.read_text(encoding="utf-8")
    lines = content.split("\n")
    transcript = []
    seen_texts = set()
    i = 0
    while i < len(lines):
        line = lines[i].strip()
        if "-->" in line:
            parts = line.split("-->")
            start_time = parts[0].strip()
            time_parts = start_time.replace(",", ".").split(":")
            if len(time_parts) == 3:
                h, m, s = time_parts
                start_seconds = int(h) * 3600 + int(m) * 60 + float(s.split(".")[0])
            else:
                start_seconds = 0
            i += 1
            text_lines = []
            while i < len(lines) and lines[i].strip() and "-->" not in lines[i]:
                text = lines[i].strip()
                if not text.isdigit() and "<" not in text and text not in seen_texts:
                    text_lines.append(text)
                    seen_texts.add(text)
                i += 1
            if text_lines:
                transcript.append({"start": start_seconds, "text": " ".join(text_lines)})
        else:
            i += 1
    return transcript


def format_transcript(transcript):
    """格式化字幕为带时间戳的纯文本"""
    lines = []
    for entry in transcript:
        start = int(entry["start"])
        mins, secs = divmod(start, 60)
        lines.append(f"[{mins:02d}:{secs:02d}] {entry['text']}")
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="获取 YouTube 视频字幕")
    parser.add_argument("--video-id", required=True, help="YouTube 视频 ID")
    parser.add_argument("--output", help="自定义输出文件路径")
    args = parser.parse_args()

    print(f"获取字幕: {args.video_id}", flush=True)
    transcript, lang = get_transcript_ytdlp(args.video_id)

    if not transcript:
        print("❌ 无法获取字幕（可能需要登录 YouTube 或视频无字幕）")
        return

    formatted = format_transcript(transcript)
    print(f"✅ 字幕语言: {lang}，共 {len(transcript)} 条")

    output_file = Path(args.output) if args.output else DATA_DIR / f"transcript_{args.video_id}.txt"
    output_file.write_text(formatted, encoding="utf-8")
    print(f"已保存到: {output_file}")

    json_file = DATA_DIR / f"transcript_{args.video_id}.json"
    with open(json_file, "w", encoding="utf-8") as f:
        json.dump(transcript, f, ensure_ascii=False, indent=2)


if __name__ == "__main__":
    main()