Video a subtítulos y resumen AI

Descripción general

Convierte videos de plataformas de redes sociales (Douyin, Xiaohongshu, Bilibili, YouTube, etc.) o archivos locales de video/audio en texto de subtítulos y genera resúmenes AI.

Flujo principal:

Video en línea: Obtener información del video → Descargar video/capturar subtítulos directamente → Seleccionar backend de subtítulos → Generar subtítulos → Resumen AI
Archivo local: Extraer audio (si es necesario) → Seleccionar backend de subtítulos → Generar subtítulos → Resumen AI

Por defecto se usa faster-whisper local, también admite cambiar a la API de Volc Engine VC mediante variables de entorno. YouTube prioriza el uso de yt-dlp para capturar subtítulos manuales o automáticos directamente; solo cuando no hay subtítulos disponibles, se descarga el audio/video y se recurre a ASR.

Cuándo usarlo

El usuario proporciona un enlace de plataforma de redes sociales (Douyin, Xiaohongshu, Bilibili, YouTube, etc.) y solicita extraer subtítulos o generar un resumen
El usuario proporciona la ruta de un archivo local de video/audio y solicita convertirlo a subtítulos o generar un resumen
El usuario solicita ver su historial de tareas de AI Douyin, tareas recientes o lista de tareas
Necesidad de convertir contenido de video a texto

No aplica para: Reconocimiento de voz en tiempo real, subtítulos en vivo

Dependencias externas

Dependencia	Uso	Obligatorio
Clave API de AI Douyin	Proxy de análisis/descarga de video recomendado; crédito gratuito disponible tras el registro, se descuenta 1 punto tras analizar y descargar el enlace directo	Solo necesario para Douyin/Xiaohongshu/Bilibili
API de TikHub	Solución avanzada/autogestionada opcional: usa tu propio TikHub Token para analizar directamente	Opcional
Python 3.9+	Ejecuta el helper `faster-whisper`	Solo necesario cuando `ASR_BACKEND=faster-whisper`
faster-whisper	Conversión local de voz a texto	Solo necesario cuando `ASR_BACKEND=faster-whisper`
API VC de ByteDance	Conversión en la nube de voz a texto	Solo necesario cuando `ASR_BACKEND=volcengine`
FFmpeg	Extraer audio del video	✅ (se puede omitir para archivos de audio)
yt-dlp	Descargar videos de Bilibili; capturar subtítulos de YouTube	Solo necesario para Bilibili o YouTube
jq	Analizar respuestas JSON de AI Douyin/TikHub	Necesario para el modo de video en línea

Variables de entorno

Se leen a través de variables de entorno, admite cualquiera de las siguientes formas de configuración:

Forma 1: Archivo .env (recomendado) — Crea un archivo .env en el directorio del skill:

ASR_BACKEND="faster-whisper"
VIDEO_INFO_PROVIDER="ai-douyin"
AI_DOUYIN_API_BASE="https://top9.cc"
AI_DOUYIN_API_KEY="tu_clave_api_de_ai_douyin"
TIKHUB_TOKEN=""

FW_MODEL_SIZE="small"
FW_DEVICE="auto"
FW_COMPUTE_TYPE=""
FW_PYTHON=""

BYTEDANCE_VC_TOKEN="tu_token"
BYTEDANCE_VC_APPID="tu_appid"

Forma 2: Configuración de Shell — Añadir a ~/.zshrc o ~/.bashrc:

export ASR_BACKEND="faster-whisper"
export VIDEO_INFO_PROVIDER="ai-douyin"
export AI_DOUYIN_API_BASE="https://top9.cc"
export AI_DOUYIN_API_KEY="tu_clave_api_de_ai_douyin"
export TIKHUB_TOKEN=""

export FW_MODEL_SIZE="small"
export FW_DEVICE="auto"
export FW_COMPUTE_TYPE=""
export FW_PYTHON=""

export BYTEDANCE_VC_TOKEN="tu_token"
export BYTEDANCE_VC_APPID="tu_appid"

Explicación:

ASR_BACKEND: Opcional, por defecto faster-whisper
VIDEO_INFO_PROVIDER: Opcional, por defecto ai-douyin; se puede cambiar a tikhub para usar tu propio TikHub Token
AI_DOUYIN_API_BASE / AI_DOUYIN_API_KEY: Proxy de análisis de video recomendado; necesario para Douyin/Xiaohongshu/Bilibili; no necesario para YouTube
TIKHUB_TOKEN: Solución avanzada/autogestionada opcional; necesario cuando VIDEO_INFO_PROVIDER=tikhub
FW_MODEL_SIZE / FW_DEVICE / FW_COMPUTE_TYPE: Solo se usa con el backend faster-whisper
FW_PYTHON: Opcional, especifica el Python donde está instalado faster-whisper; si se deja vacío, prioriza el venv por defecto creado por el helper de instalación, luego recurre a python3 del sistema
BYTEDANCE_VC_TOKEN / BYTEDANCE_VC_APPID: Solo se usa con el backend volcengine

Las instrucciones de instalación y ejecución se encuentran en Guía de configuración de AI Douyin, Guía de solicitud de TikHub, Guía de instalación de faster-whisper y Guía de activación de Volc Engine

Pasos de ejecución

Paso 0: Determinar el tipo de entrada

Determinar el modo de procesamiento según la entrada del usuario:

Modo video en línea: La entrada es una URL
- Douyin/TikTok: douyin.com, v.douyin.com, tiktok.com
- Xiaohongshu: xiaohongshu.com, xhslink.com
- Bilibili: bilibili.com, b23.tv
- YouTube: youtube.com, youtu.be
Modo archivo local: La entrada es una ruta de archivo local
- Archivo de video local (.mp4, .mov, .avi, .mkv, etc.) → Comenzar desde el paso 3 (extraer audio)
- Archivo de audio local (.mp3, .wav, .m4a, .flac, etc.) → Omitir el paso 3, comenzar directamente desde el paso 4 (transcribir)

Paso 0.5: Leer la configuración del backend

Primero, leer ASR_BACKEND, si no está configurado, usar faster-whisper por defecto:

SKILL_DIR="${SKILL_DIR:-$HOME/.codex/skills/video-to-subtitle-summary}"
[ -d "$SKILL_DIR" ] || SKILL_DIR="$HOME/.claude/skills/video-to-subtitle-summary"
ENV_FILE="$SKILL_DIR/.env"

read_env() {
  local key="$1"
  if [ -f "$ENV_FILE" ]; then
    grep "^${key}=" "$ENV_FILE" | head -1 | cut -d'=' -f2- | tr -d '"' | tr -d "'"
  else
    printenv "$key"
  fi
}

ASR_BACKEND="$(read_env ASR_BACKEND)"
[ -z "$ASR_BACKEND" ] && ASR_BACKEND="faster-whisper"

echo "ASR_BACKEND=$ASR_BACKEND"

Valores admitidos:

faster-whisper
volcengine

Paso 0.6: Verificación del entorno (debe ejecutarse primero)

Antes de comenzar cualquier procesamiento, verificar las dependencias necesarias según el modo actual y el backend de subtítulos actual.

SKILL_DIR="${SKILL_DIR:-$HOME/.codex/skills/video-to-subtitle-summary}"
[ -d "$SKILL_DIR" ] || SKILL_DIR="$HOME/.claude/skills/video-to-subtitle-summary"
ENV_FILE="$SKILL_DIR/.env"

read_env() {
  local key="$1"
  if [ -f "$ENV_FILE" ]; then
    grep "^${key}=" "$ENV_FILE" | head -1 | cut -d'=' -f2- | tr -d '"' | tr -d "'"
  else
    printenv "$key"
  fi
}

ASR_BACKEND="$(read_env ASR_BACKEND)"
[ -z "$ASR_BACKEND" ] && ASR_BACKEND="faster-whisper"
VIDEO_INFO_PROVIDER="$(read_env VIDEO_INFO_PROVIDER)"
[ -z "$VIDEO_INFO_PROVIDER" ] && VIDEO_INFO_PROVIDER="ai-douyin"
AI_DOUYIN_API_BASE="$(read_env AI_DOUYIN_API_BASE)"
[ -z "$AI_DOUYIN_API_BASE" ] && AI_DOUYIN_API_BASE="https://top9.cc"
AI_DOUYIN_API_KEY="$(read_env AI_DOUYIN_API_KEY)"
TIKHUB_TOKEN="$(read_env TIKHUB_TOKEN)"
BYTEDANCE_VC_TOKEN="$(read_env BYTEDANCE_VC_TOKEN)"
BYTEDANCE_VC_APPID="$(read_env BYTEDANCE_VC_APPID)"
FW_PYTHON="$(read_env FW_PYTHON)"
[ -z "$FW_PYTHON" ] && [ -x "$HOME/.cache/video-to-subtitle-summary/faster-whisper-venv/bin/python" ] && FW_PYTHON="$HOME/.cache/video-to-subtitle-summary/faster-whisper-venv/bin/python"
[ -z "$FW_PYTHON" ] && FW_PYTHON="python3"

MISSING=""

if [ "{INPUT_MODE}" = "url" ]; then
  if [ "{PLATFORM}" = "douyin" ] || [ "{PLATFORM}" = "xiaohongshu" ] || [ "{PLATFORM}" = "bilibili" ]; then
    if [ "$VIDEO_INFO_PROVIDER" = "ai-douyin" ]; then
      [ -z "$AI_DOUYIN_API_KEY" ] && MISSING="$MISSING AI_DOUYIN_API_KEY"
    elif [ "$VIDEO_INFO_PROVIDER" = "tikhub" ]; then
      [ -z "$TIKHUB_TOKEN" ] && MISSING="$MISSING TIKHUB_TOKEN"
    else
      MISSING="$MISSING invalid_VIDEO_INFO_PROVIDER"
    fi
  fi
  if [ "$VIDEO_INFO_PROVIDER" = "ai-douyin" ] || [ "$VIDEO_INFO_PROVIDER" = "tikhub" ]; then
    command -v jq >/dev/null 2>&1 || MISSING="$MISSING jq"
  fi
  if [ "${PLATFORM}" = "bilibili" ] || [ "${PLATFORM}" = "youtube" ]; then
    command -v yt-dlp >/dev/null 2>&1 || MISSING="$MISSING yt-dlp"
  fi
fi

if [ "{NEEDS_FFMPEG}" = "yes" ] && [ "{PLATFORM}" != "youtube" ]; then
  command -v ffmpeg >/dev/null 2>&1 || MISSING="$MISSING ffmpeg"
fi

if [ "$ASR_BACKEND" = "faster-whisper" ]; then
  command -v "$FW_PYTHON" >/dev/null 2>&1 || [ -x "$FW_PYTHON" ] || MISSING="$MISSING FW_PYTHON"
  "$FW_PYTHON" - <<'PY' >/dev/null 2>&1 || MISSING="$MISSING faster-whisper"
import faster_whisper
import ctranslate2
PY
elif [ "$ASR_BACKEND" = "volcengine" ]; then
  [ -z "$BYTEDANCE_VC_TOKEN" ] && MISSING="$MISSING BYTEDANCE_VC_TOKEN"
  [ -z "$BYTEDANCE_VC_APPID" ] && MISSING="$MISSING BYTEDANCE_VC_APPID"
else
  MISSING="$MISSING invalid_ASR_BACKEND"
fi

if [ -n "$MISSING" ]; then
  echo "ERROR: Faltan dependencias o configuraciones obligatorias:$MISSING"
  echo "ASR_BACKEND=$ASR_BACKEND VIDEO_INFO_PROVIDER=$VIDEO_INFO_PROVIDER"
  echo "Valores posibles de ASR_BACKEND: faster-whisper / volcengine"
  echo "Valores posibles de VIDEO_INFO_PROVIDER: ai-douyin / tikhub"
  exit 1
else
  echo "OK: Dependencias de ejecución listas (ASR_BACKEND=$ASR_BACKEND)"
fi

Si la verificación falla:

ASR_BACKEND=faster-whisper: Ejecutar preferentemente python3 "$SKILL_DIR/scripts/install_faster_whisper.py", o consultar docs/faster-whisper-setup.md
ASR_BACKEND=volcengine: Consultar docs/bytedance-vc-setup.md
AI_DOUYIN_API_KEY: Registrarse en AI Douyin para obtener crédito gratuito y crear una clave API; recargar puntos si el saldo es insuficiente, o cambiar a VIDEO_INFO_PROVIDER=tikhub + TIKHUB_TOKEN

Paso 1: Obtener información del video / enlace de descarga directa (solo modo video en línea)

Identificar la plataforma según el dominio de la URL:

Plataforma	Característica de la URL	Método de procesamiento predeterminado
Douyin/TikTok	`douyin.com`, `v.douyin.com`, `tiktok.com`	Proxy de `AI Douyin` para analizar enlace de descarga directa; TikHub opcional
Xiaohongshu	`xiaohongshu.com`, `xhslink.com`	Proxy de `AI Douyin` para analizar enlace de descarga directa; TikHub opcional
Bilibili	`bilibili.com`, `b23.tv`	Proxy de `AI Douyin` para analizar enlace de descarga directa; se puede recurrir a `yt-dlp` si es necesario
YouTube	`youtube.com`, `youtu.be`	No llamar a AI Douyin/TikHub, ir directamente al paso 2 para capturar subtítulos

Recomendación predeterminada: Proxy de AI Douyin

AI Douyin es adecuado para usuarios que no quieren registrarse en TikHub por separado. Registrarse en https://top9.cc para obtener crédito gratuito y crear una clave API. Se descuenta 1 punto tras analizar y descargar el enlace directo; no se descuenta si falla. Si el saldo es insuficiente, la interfaz devuelve HTTP 402 / insufficient balance.

SKILL_DIR="${SKILL_DIR:-$HOME/.codex/skills/video-to-subtitle-summary}"
[ -d "$SKILL_DIR" ] || SKILL_DIR="$HOME/.claude/skills/video-to-subtitle-summary"
ENV_FILE="$SKILL_DIR/.env"
read_env() {
  local key="$1"
  if [ -f "$ENV_FILE" ]; then
    grep "^${key}=" "$ENV_FILE" | head -1 | cut -d'=' -f2- | tr -d '"' | tr -d "'"
  else
    printenv "$key"
  fi
}

AI_DOUYIN_API_BASE="$(read_env AI_DOUYIN_API_BASE)"
[ -z "$AI_DOUYIN_API_BASE" ] && AI_DOUYIN_API_BASE="https://top9.cc"
AI_DOUYIN_API_KEY="$(read_env AI_DOUYIN_API_KEY)"

# La API Base admite completar https://top9.cc o https://top9.cc/api/v1
case "$AI_DOUYIN_API_BASE" in
  */api/v1) AI_DOUYIN_DOWNLOAD_URL_ENDPOINT="$AI_DOUYIN_API_BASE/video/download-url" ;;
  */api) AI_DOUYIN_DOWNLOAD_URL_ENDPOINT="$AI_DOUYIN_API_BASE/v1/video/download-url" ;;
  *) AI_DOUYIN_DOWNLOAD_URL_ENDPOINT="${AI_DOUYIN_API_BASE%/}/api/v1/video/download-url" ;;
esac

curl -sS -w '\n%{http_code}' -X POST "$AI_DOUYIN_DOWNLOAD_URL_ENDPOINT" \
  -H "X-API-Key: $AI_DOUYIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d "$(jq -n --arg url "{ORIGINAL_URL}" '{url: $url}')" \
  > /tmp/video_analysis/download_url_response.txt

HTTP_CODE=$(tail -n1 /tmp/video_analysis/download_url_response.txt)
sed '$d' /tmp/video_analysis/download_url_response.txt > /tmp/video_analysis/download_url.json

if [ "$HTTP_CODE" = "402" ]; then
  echo "ERROR: Saldo insuficiente de AI Douyin (insufficient balance). Ve a https://top9.cc para comprar puntos, o cambia a VIDEO_INFO_PROVIDER=tikhub + TIKHUB_TOKEN."
  exit 1
elif [ "$HTTP_CODE" = "401" ]; then
  echo "ERROR: La clave API de AI Douyin falta o no es válida. Verifica AI_DOUYIN_API_KEY."
  exit 1
elif [ "$HTTP_CODE" -lt 200 ] || [ "$HTTP_CODE" -ge 300 ]; then
  echo "ERROR: Falló el análisis de AI Douyin (HTTP $HTTP_CODE)"
  cat /tmp/video_analysis/download_url.json
  exit 1
fi

VIDEO_URL=$(jq -r '.download_url // empty' /tmp/video_analysis/download_url.json)
VIDEO_URL_COUNT=$(jq -r '(.download_urls // [.download_url] | map(select(. != null and . != "")) | length)' /tmp/video_analysis/download_url.json)
EXTRACTED_URL=$(jq -r '.extracted_url // empty' /tmp/video_analysis/download_url.json)
DOWNLOAD_COST=$(jq -r '.cost // 1' /tmp/video_analysis/download_url.json)
[ -z "$VIDEO_URL" ] && echo "ERROR: No se devolvió download_url" && cat /tmp/video_analysis/download_url.json && exit 1

Extraer campos clave:

jq '{download_url, download_urls_count: (.download_urls // [] | length), extracted_url, cost}' /tmp/video_analysis/download_url.json

Esquema de obtención de interfaz de video opcional: TikHub Token propio

Cuando VIDEO_INFO_PROVIDER=tikhub, se usa el propio TikHub Token para analizar directamente. No escribir el Token real en registros o respuestas.

Douyin/TikTok:

curl -s -X GET "https://api.tikhub.io/api/v1/hybrid/video_data?url={ENCODED_URL}&minimal=true" \
  -H "Authorization: Bearer tu_token_de_tikhub" \
  -H "Accept: application/json"

Extraer preferentemente la dirección sin marca de agua:

jq -r '.data.video_data.nwm_video_url // .data.video.play_addr.url_list[0] // empty'

Xiaohongshu:

curl -s -X GET "https://api.tikhub.io/api/v1/xiaohongshu/web/get_note_info_v7?share_text={ENCODED_URL}" \
  -H "Authorization: Bearer tu_token_de_tikhub" \
  -H "Accept: application/json"

Bilibili:

curl -s -X GET "https://api.tikhub.io/api/v1/bilibili/web/fetch_one_video_v3?url={ENCODED_URL}" \
  -H "Authorization: Bearer tu_token_de_tikhub" \
  -H "Accept: application/json"

Si no se obtiene un enlace de descarga directa para Bilibili, se puede usar yt-dlp en el paso 2 para descargar.

Paso 1.5: Consultar las tareas históricas propias de AI Douyin (según sea necesario)

Cuando el usuario solicita ver su propio historial de tareas / tareas recientes / lista de tareas, llamar a GET /api/v1/tasks de AI Douyin. Esta interfaz usa autenticación X-API-Key y solo devuelve las tareas del usuario correspondiente a la clave API actual.

SKILL_DIR="${SKILL_DIR:-$HOME/.codex/skills/video-to-subtitle-summary}"
[ -d "$SKILL_DIR" ] || SKILL_DIR="$HOME/.claude/skills/video-to-subtitle-summary"

python3 "$SKILL_DIR/scripts/list_ai_douyin_tasks.py" \
  --page 1 \
  --page-size 20

Filtrado opcional:

python3 "$SKILL_DIR/scripts/list_ai_douyin_tasks.py" --status completed --page 1 --page-size 10
python3 "$SKILL_DIR/scripts/list_ai_douyin_tasks.py" --search "palabra clave" --json

El script lee por defecto AI_DOUYIN_API_BASE / AI_DOUYIN_API_KEY del archivo $SKILL_DIR/.env o las variables de entorno. Al mostrar al usuario, no revelar la clave API real.

Paso 2: Descargar video (solo modo video en línea)

Usar diferentes métodos de descarga según la plataforma:

YouTube (priorizar captura directa de subtítulos, no descargar video):

mkdir -p /tmp/video_analysis/{VIDEO_ID}
SKILL_DIR="${SKILL_DIR:-$HOME/.codex/skills/video-to-subtitle-summary}"
[ -d "$SKILL_DIR" ] || SKILL_DIR="$HOME/.claude/skills/video-to-subtitle-summary"
python3 "$SKILL_DIR/scripts/download_youtube_subtitles.py" \
  "https://www.youtube.com/watch?v={VIDEO_ID}" \
  --output-dir /tmp/video_analysis/{VIDEO_ID} \
  --languages zh-Hans,zh-Hant,zh,en

Los archivos de salida son fijos:

/tmp/video_analysis/{VIDEO_ID}/subtitle.srt
/tmp/video_analysis/{VIDEO_ID}/text.txt

Si el comando indica que no hay subtítulos disponibles, usar yt-dlp para descargar audio o video, y continuar desde el paso 3 con ASR_BACKEND.

Douyin / TikTok / Xiaohongshu / Bilibili (cuando ya hay enlace de descarga directa VIDEO_URL):

mkdir -p /tmp/video_analysis/{VIDEO_ID}
SKILL_DIR="${SKILL_DIR:-$HOME/.codex/skills/video-to-subtitle-summary}"
[ -d "$SKILL_DIR" ] || SKILL_DIR="$HOME/.claude/skills/video-to-subtitle-summary"
python3 "$SKILL_DIR/scripts/download_video_candidates.py" \
  --response-json /tmp/video_analysis/download_url.json \
  --output /tmp/video_analysis/{VIDEO_ID}/video.mp4 \
  --timeout 30

Bilibili (recurrir cuando no hay enlace de descarga directa):

mkdir -p /tmp/video_analysis/{BVID}
yt-dlp -o /tmp/video_analysis/{BVID}/video.mp4 "https://www.bilibili.com/video/{BVID}/"

Paso 3: Extraer audio (se puede omitir para archivos de audio locales)

En el modo de archivo local, si la entrada es un archivo de video local, reemplazar {VIDEO_ID} por el nombre del archivo (sin extensión) y la ruta de entrada por la ruta real del video.

ffmpeg -i /tmp/video_analysis/{VIDEO_ID}/video.mp4 -q:a 0 -map a -y /tmp/video_analysis/{VIDEO_ID}/audio.mp3

Paso 4: Seleccionar backend de subtítulos según `ASR_BACKEND`

Si la plataforma es YouTube y el paso 2 ya generó con éxito subtitle.srt y text.txt, omitir este paso e ir directamente al paso 5 para el resumen.

Opción A: `ASR_BACKEND=faster-whisper` (predeterminado)

Ruta del helper:

$SKILL_DIR/scripts/transcribe_faster_whisper.py

Comando de ejecución:

SKILL_DIR="${SKILL_DIR:-$HOME/.codex/skills/video-to-subtitle-summary}"
[ -d "$SKILL_DIR" ] || SKILL_DIR="$HOME/.claude/skills/video-to-subtitle-summary"
FW_PYTHON="${FW_PYTHON:-$HOME/.cache/video-to-subtitle-summary/faster-whisper-venv/bin/python}"
[ -x "$FW_PYTHON" ] || FW_PYTHON="python3"
"$FW_PYTHON" "$SKILL_DIR/scripts/transcribe_faster_whisper.py" \
  /tmp/video_analysis/{VIDEO_ID}/audio.mp3 \
  --output-dir /tmp/video_analysis/{VIDEO_ID}

Explicación:

El helper lee automáticamente FW_MODEL_SIZE, FW_DEVICE, FW_COMPUTE_TYPE
Cuando FW_DEVICE=auto, solo se usa device="cuda" si se detecta NVIDIA/CUDA
Los archivos de salida son fijos:
- /tmp/video_analysis/{VIDEO_ID}/subtitle.srt
- /tmp/video_analysis/{VIDEO_ID}/text.txt

Opción B: `ASR_BACKEND=volcengine`

Enviar tarea:

SKILL_DIR="${SKILL_DIR:-$HOME/.codex/skills/video-to-subtitle-summary}"
[ -d "$SKILL_DIR" ] || SKILL_DIR="$HOME/.claude/skills/video-to-subtitle-summary"
python3 "$SKILL_DIR/scripts/submit_volcengine_task.py" \
  --audio-file /tmp/video_analysis/{VIDEO_ID}/audio.mp3 \
  --output-dir /tmp/video_analysis/{VIDEO_ID}

Explicación:

El helper lee automáticamente BYTEDANCE_VC_TOKEN y BYTEDANCE_VC_APPID del archivo .env o las variables de entorno
Tras enviar, sondea hasta que la tarea se complete (con un tiempo de espera máximo de 5 minutos)
Los archivos de salida son fijos:
- /tmp/video_analysis/{VIDEO_ID}/subtitle.srt
- /tmp/video_analysis/{VIDEO_ID}/text.txt

Paso 5: Resumen AI

SKILL_DIR="${SKILL_DIR:-$HOME/.codex/skills/video-to-subtitle-summary}"
[ -d "$SKILL_DIR" ] || SKILL_DIR="$HOME/.claude/skills/video-to-subtitle-summary"
python3 "$SKILL_DIR/scripts/summarize_subtitle.py" \
  /tmp/video_analysis/{VIDEO_ID}/text.txt \
  --output-dir /tmp/video_analysis/{VIDEO_ID}

Los archivos de salida son:

/tmp/video_analysis/{VIDEO_ID}/summary.md: Resumen en markdown
/tmp/video_analysis/{VIDEO_ID}/summary.txt: Resumen en texto plano (incluye contenido de subtítulos y resumen AI)
/tmp/video_analysis/{VIDEO_ID}/summary.json: Resumen en formato JSON (contiene subtítulos y resumen AI)

Instalación

Requisitos previos

FFmpeg:

macOS: brew install ffmpeg
Ubuntu/Debian: sudo apt install ffmpeg
Windows: Descargar de ffmpeg.org y añadir al PATH

yt-dlp:

pip3 install yt-dlp

jq:

macOS: brew install jq
Ubuntu/Debian: sudo apt install jq

Instalar el backend de ASR

Opción 1: Instalación automática (recomendada)

Ejecutar:

python3 "$HOME/.codex/skills/video-to-subtitle-summary/scripts/install_faster_whisper.py"

El script descargará automáticamente el modelo <500MB, creará un entorno virtual y completará la instalación.

Opción 2: Instalación manual

python3 -m venv "$HOME/.cache/video-to-subtitle-summary/faster-whisper-venv"
source "$HOME/.cache/video-to-subtitle-summary/faster-whisper-venv/bin/activate"
pip install faster-whisper
pip install "faster-whisper[ctranslate2]"  # Opcional, aceleración por GPU

Opción 3: Usar Volc Engine

Solicitar Volc Engine VC API y configurar BYTEDANCE_VC_TOKEN y BYTEDANCE_VC_APPID. Ver bytedance-vc-setup.md.

video-to-subtitle-summary — URL→captions Whisper

¿Qué es video-to-subtitle-summary — URL→captions Whisper?

Preguntar en tu IA favorita

Documentación

Video a subtítulos y resumen AI

Descripción general

Cuándo usarlo

Dependencias externas

Variables de entorno

Pasos de ejecución

Paso 0: Determinar el tipo de entrada

Paso 0.5: Leer la configuración del backend

Paso 0.6: Verificación del entorno (debe ejecutarse primero)

Paso 1: Obtener información del video / enlace de descarga directa (solo modo video en línea)

Recomendación predeterminada: Proxy de AI Douyin

Esquema de obtención de interfaz de video opcional: TikHub Token propio

Paso 1.5: Consultar las tareas históricas propias de AI Douyin (según sea necesario)

Paso 2: Descargar video (solo modo video en línea)

Paso 3: Extraer audio (se puede omitir para archivos de audio locales)

Paso 4: Seleccionar backend de subtítulos según `ASR_BACKEND`

Opción A: `ASR_BACKEND=faster-whisper` (predeterminado)

Opción B: `ASR_BACKEND=volcengine`

Paso 5: Resumen AI

Instalación

Requisitos previos

Instalar el backend de ASR

Skills relacionados

steipete/video-frames

steipete/summarize

openclaw/openclaw

obra/superpowers

affaan-m/ECC

affaan-m/everything-claude-code

Preguntar en tu IA favorita

Documentación

Video a subtítulos y resumen AI

Descripción general

Cuándo usarlo

Dependencias externas

Variables de entorno

Pasos de ejecución

Paso 0: Determinar el tipo de entrada

Paso 0.5: Leer la configuración del backend

Paso 0.6: Verificación del entorno (debe ejecutarse primero)

Paso 1: Obtener información del video / enlace de descarga directa (solo modo video en línea)

Recomendación predeterminada: Proxy de AI Douyin

Esquema de obtención de interfaz de video opcional: TikHub Token propio

Paso 1.5: Consultar las tareas históricas propias de AI Douyin (según sea necesario)

Paso 2: Descargar video (solo modo video en línea)

Paso 3: Extraer audio (se puede omitir para archivos de audio locales)

Paso 4: Seleccionar backend de subtítulos según ASR_BACKEND

Opción A: ASR_BACKEND=faster-whisper (predeterminado)

Opción B: ASR_BACKEND=volcengine

Paso 5: Resumen AI

Instalación

Requisitos previos

Instalar el backend de ASR

Skills relacionados

steipete/video-frames

steipete/summarize

openclaw/openclaw

obra/superpowers

affaan-m/ECC

affaan-m/everything-claude-code

Paso 4: Seleccionar backend de subtítulos según `ASR_BACKEND`

Opción A: `ASR_BACKEND=faster-whisper` (predeterminado)

Opción B: `ASR_BACKEND=volcengine`