Youtube Chapter Generator

Auto-generate YouTube video chapters from subtitles. Parses VTT/SRT files, identifies topic transitions, and produces timestamped chapter markers. Triggers:...

Security Scan

The skill's purpose (generate YouTube chapters from subtitles) is plausible, but the instructions reference missing artifacts and undeclared dependencies (yt-dlp and generate_chapters.py), which is an incoherence that requires caution before installing or running.

Purpose & Capability

The README/usage requires running yt-dlp and python3 generate_chapters.py to download and process subtitles, but the skill declares no required binaries and provides no generate_chapters.py file. Asking the user/agent to run an external downloader and a non-existent script is inconsistent with the skill metadata.

Instruction Scope

Instructions are narrowly scoped to downloading subtitles and parsing VTT, which fits the stated purpose. However, the usage commands expect an external tool (yt-dlp) and a local script that are not included or declared. This gives the agent broad discretion (e.g., to create or fetch a script) and could lead to running code that wasn't reviewed.

Install Mechanism

No install spec and no code files are provided, so nothing is written to disk by an installer step. This minimizes install-time risk, but runtime instructions still rely on external tools.

Credentials

The skill requests no environment variables, secrets, or config paths — consistent with a local subtitle-processing tool.

Persistence & Privilege

The skill is not always-enabled and doesn't request persistent privileges or modify other skills. Autonomous invocation is allowed (platform default) but not by itself a problem.

What to consider before installing

This skill appears to do what it says, but there are important inconsistencies you should resolve before use: - Missing binary and script: The SKILL.md expects yt-dlp and a file named generate_chapters.py, but the skill metadata does not declare required binaries and the script is not included. Do not run commands from the SKILL.md until you (a) have yt-dlp installed from a trusted source and (b) have inspected or provided the generate_chapters.py code yourself. The included Python snippet is only partial and may not be the actual script the agent would run. - Trust and provenance: The skill's Source/Homepage are unknown. Running an external downloader (yt-dlp) and arbitrary Python scripts found or created at runtime can execute code on your machine. Only run these in a sandbox or after reviewing the script's contents. - What to check/steps to take: - Verify yt-dlp is installed from the official project and up-to-date. - Ask the skill author (or inspect the skill bundle) for the full generate_chapters.py. Review it for network calls, file writes, or subprocess.exec usage. - If you must proceed without the script, consider implementing your own chapter-generation script using the provided snippet and review it carefully. - Run initial tests on non-sensitive VM or container with sample subtitle files. - Functional note (non-security): The provided timestamp parsing is simplistic (ignores milliseconds in output selection and uses gap-only logic), so review accuracy requirements for your videos. If the author can supply the missing script or update the metadata to list yt-dlp and python3 as required, re-evaluate; until then treat this skill as suspicious.

Auto-generate YouTube video chapters from subtitles. Parses VTT/SRT files, identifies topic transitions, and produces timestamped chapter markers.

Usage

# Download subtitles first
yt-dlp --write-sub --write-auto-sub \
  --sub-lang "zh-Hans,zh,en" \
  --convert-subs vtt \
  --skip-download \
  -o "/tmp/%(id)s" \
  "https://www.youtube.com/watch?v=VIDEO_ID"

# Generate chapters from subtitle file
python3 generate_chapters.py "/tmp/VIDEO_ID.zh-Hans.vtt"

Chapter Generation Logic

import re

def parse_vtt_timestamps(vtt_content):
    """Extract timestamps and text from VTT file"""
    timestamps = []
    for match in re.finditer(r'(\d{2}:\d{2}:\d{2})\.\d{3}\s*-->\s*\d{2}:\d{2}:\d{2}\.\d{3}', vtt_content):
        timestamps.append(match.group(1))
    return timestamps

def generate_chapters(vtt_file, min_gap_seconds=30):
    """Generate chapters from VTT subtitle file"""
    with open(vtt_file) as f:
        content = f.read()
    
    timestamps = parse_vtt_timestamps(content)
    if len(timestamps) < 2:
        return []
    
    # Find natural breaks (gaps > min_gap_seconds)
    chapters = []
    last_ts = timestamps[0]
    
    for ts in timestamps[1:]:
        gap = parse_ts(ts) - parse_ts(last_ts)
        if gap >= min_gap_seconds:
            chapters.append(last_ts)
            last_ts = ts
    
    chapters.append(timestamps[-1])
    return chapters

def parse_ts(ts_str):
    """Parse HH:MM:SS to seconds"""
    parts = ts_str.split(":")
    return int(parts[0])*3600 + int(parts[1])*60 + int(parts[2])

# Output format: "00:00 Introduction\n00:45 Main Topic\n..."

YouTube Chapter Requirements

• Minimum 3 chapters for YouTube to auto-display
• First chapter must start at 0:00
• Chapters must be at least 10 seconds apart
• Maximum 12 chapters recommended

Tags

youtube chapters video timestamps subtitles automation