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

Video zu Untertitel und KI-Zusammenfassung Skill

Übersicht

Konvertieren Sie Videos von Kurzvideo-Plattformen (Douyin, Xiaohongshu, Bilibili, YouTube usw.) oder lokale Video-/Audiodateien in Untertiteltext und generieren Sie eine KI-Zusammenfassung.

Kernablauf:

• Online-Video: Videoinformationen abrufen → Video herunterladen/Untertitel direkt extrahieren → Untertitel-Backend auswählen → Untertitel generieren → KI-Zusammenfassung
• Lokale Datei: Audio extrahieren (falls erforderlich) → Untertitel-Backend auswählen → Untertitel generieren → KI-Zusammenfassung

Standardmäßig wird das lokale faster-whisper verwendet. Es wird auch unterstützt, über Umgebungsvariablen auf die Volcano Engine VC API umzuschalten. YouTube verwendet bevorzugt yt-dlp, um manuelle Untertitel oder automatische Untertitel direkt zu extrahieren. Nur wenn keine Untertitel verfügbar sind, muss Audio/Video heruntergeladen und auf ASR zurückgegriffen werden.

Verwendung

• Der Benutzer gibt einen Link zu einer Kurzvideo-Plattform an (Douyin, Xiaohongshu, Bilibili, YouTube usw.) und fordert die Extraktion von Untertiteln oder die Erstellung einer Zusammenfassung an.
• Der Benutzer gibt einen Pfad zu einer lokalen Video-/Audiodatei an und fordert die Umwandlung in Untertitel oder die Erstellung einer Zusammenfassung an.
• Der Benutzer fordert die Anzeige seines eigenen AI Douyin-Verlaufs, der letzten Aufgaben, der Aufgabenliste an.
• Der Videoinhalt muss in Text umgewandelt werden.

Nicht geeignet für: Echtzeit-Spracherkennung, Live-Untertitel

Externe Abhängigkeiten

Abhängigkeit	Verwendung	Erforderlich
AI Douyin API Key	Empfohlener Video-Analyse-/Download-Proxy; nach der Registrierung sind kostenlose Guthaben verfügbar, 1 Punkt wird nach erfolgreicher Analyse und Bereitstellung des Direktdownload-Links abgezogen	Nur für Douyin/Xiaohongshu/Bilibili erforderlich
TikHub API	Optionale Premium-/Self-Hosted-Lösung: Direktanalyse mit eigenem TikHub Token	Optional
Python 3.9+	Ausführen des faster-whisper-Helpers	Nur erforderlich, wenn ASR_BACKEND=faster-whisper
faster-whisper	Lokale Sprach-zu-Text-Umwandlung	Nur erforderlich, wenn ASR_BACKEND=faster-whisper
ByteDance VC API	Cloud-basierte Sprach-zu-Text-Umwandlung	Nur erforderlich, wenn ASR_BACKEND=volcengine
FFmpeg	Audio aus Video extrahieren	✅ (Kann bei Audiodateien übersprungen werden)
yt-dlp	Bilibili-Videos herunterladen; YouTube-Untertitel extrahieren	Nur für Bilibili oder YouTube erforderlich
jq	Parsen von AI Douyin/TikHub JSON-Antworten	Für den Online-Video-Modus erforderlich

Umgebungsvariablen

Wird über Umgebungsvariablen gelesen. Konfiguration auf eine der folgenden Arten unterstützt:

Methode 1: .env-Datei (empfohlen) – Erstellen Sie eine .env-Datei im Skill-Verzeichnis:

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

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

BYTEDANCE_VC_TOKEN="your_token"
BYTEDANCE_VC_APPID="your_appid"

Methode 2: Shell-Konfiguration – Fügen Sie zu ~/.zshrc oder ~/.bashrc hinzu:

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

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

export BYTEDANCE_VC_TOKEN="your_token"
export BYTEDANCE_VC_APPID="your_appid"

Erläuterung:

• ASR_BACKEND: Optional, Standard ist faster-whisper
• VIDEO_INFO_PROVIDER: Optional, Standard ist ai-douyin; kann auf tikhub geändert werden, um Ihren eigenen TikHub Token zu verwenden
• AI_DOUYIN_API_BASE / AI_DOUYIN_API_KEY: Empfohlener Video-Analyse-Proxy; für Douyin/Xiaohongshu/Bilibili erforderlich; für YouTube nicht erforderlich
• TIKHUB_TOKEN: Optionale Premium-/Self-Hosted-Lösung; erforderlich, wenn VIDEO_INFO_PROVIDER=tikhub
• FW_MODEL_SIZE / FW_DEVICE / FW_COMPUTE_TYPE: Nur für das faster-whisper-Backend
• FW_PYTHON: Optional, gibt das Python mit installiertem faster-whisper an; wenn leer, wird zuerst das standardmäßig vom Installationshelper erstellte venv verwendet, dann auf das System-python3 zurückgegriffen
• BYTEDANCE_VC_TOKEN / BYTEDANCE_VC_APPID: Nur für das volcengine-Backend

Installations- und Laufzeithinweise finden Sie im AI Douyin Konfigurationsleitfaden, TikHub Antragsleitfaden, faster-whisper Installationsleitfaden und Volcano Engine Aktivierungsleitfaden

Ausführungsschritte

Schritt 0: Eingabetyp bestimmen

Bestimmen Sie den Verarbeitungsmodus basierend auf der Benutzereingabe:

• Online-Video-Modus: Eingabe ist eine 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
• Lokaler Datei-Modus: Eingabe ist ein Pfad zu einer lokalen Datei
  • Lokale Video-Dateien (.mp4, .mov, .avi, .mkv usw.) → Start bei Schritt 3 (Audio extrahieren)
  • Lokale Audio-Dateien (.mp3, .wav, .m4a, .flac usw.) → Schritt 3 überspringen, direkt bei Schritt 4 (Transkription) beginnen

Schritt 0.5: Backend-Konfiguration lesen

Lesen Sie zuerst ASR_BACKEND. Wenn nicht konfiguriert, wird standardmäßig faster-whisper verwendet:

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"

Unterstützte Werte:

• faster-whisper
• volcengine

Schritt 0.6: Umgebungsprüfung (muss zuerst ausgeführt werden)

Überprüfen Sie vor Beginn der Verarbeitung die für den aktuellen Modus und das aktuelle Untertitel-Backend erforderlichen Abhängigkeiten.

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 "FEHLER: Fehlende erforderliche Abhängigkeiten/Konfiguration:$MISSING"
  echo "ASR_BACKEND=$ASR_BACKEND VIDEO_INFO_PROVIDER=$VIDEO_INFO_PROVIDER"
  echo "ASR_BACKEND mögliche Werte: faster-whisper / volcengine"
  echo "VIDEO_INFO_PROVIDER mögliche Werte: ai-douyin / tikhub"
  exit 1
else
  echo "OK: Laufzeitabhängigkeiten bereit (ASR_BACKEND=$ASR_BACKEND)"
fi

Wenn die Prüfung fehlschlägt:

• ASR_BACKEND=faster-whisper: Führen Sie zuerst python3 "$SKILL_DIR/scripts/install_faster_whisper.py" aus, oder lesen Sie docs/faster-whisper-setup.md
• ASR_BACKEND=volcengine: Lesen Sie docs/bytedance-vc-setup.md
• AI_DOUYIN_API_KEY: Registrieren Sie sich bei AI Douyin, um kostenloses Guthaben zu erhalten und einen API Key zu erstellen; bei unzureichendem Guthaben Punkte aufladen oder auf VIDEO_INFO_PROVIDER=tikhub + TIKHUB_TOKEN umstellen

Schritt 1: Videoinformationen abrufen/Direktdownload-Link (nur Online-Video-Modus)

Plattform anhand der URL-Domain identifizieren:

Plattform	URL-Merkmal	Standardverarbeitungsmethode
Douyin/TikTok	douyin.com, v.douyin.com, tiktok.com	AI Douyin Proxy analysiert und stellt Direktdownload-Link bereit; TikHub optional
Xiaohongshu	xiaohongshu.com, xhslink.com	AI Douyin Proxy analysiert und stellt Direktdownload-Link bereit; TikHub optional
Bilibili	bilibili.com, b23.tv	AI Douyin Proxy analysiert und stellt Direktdownload-Link bereit; falls nötig, auf yt-dlp zurückgreifen
YouTube	youtube.com, youtu.be	AI Douyin/TikHub nicht aufrufen, direkt zu Schritt 2 (Untertitel extrahieren) gehen

Standardempfehlung: AI Douyin Proxy

AI Douyin ist für Benutzer geeignet, die sich nicht separat bei TikHub registrieren möchten. Registrieren Sie sich bei https://top9.cc, um kostenloses Guthaben zu erhalten und einen API Key zu erstellen. Nach erfolgreicher Analyse und Bereitstellung des Direktdownload-Links wird 1 Punkt abgezogen; bei Fehlschlag keine Abbuchung. Bei unzureichendem Guthaben gibt die Schnittstelle HTTP 402 / insufficient balance zurück.

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)"

# API Base unterstützt https://top9.cc oder 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 "FEHLER: AI Douyin Guthaben unzureichend (insufficient balance). Bitte kaufen Sie Punkte auf https://top9.cc oder wechseln Sie zu VIDEO_INFO_PROVIDER=tikhub + TIKHUB_TOKEN."
  exit 1
elif [ "$HTTP_CODE" = "401" ]; then
  echo "FEHLER: AI Douyin API Key fehlt oder ist ungültig. Bitte überprüfen Sie AI_DOUYIN_API_KEY."
  exit 1
elif [ "$HTTP_CODE" -lt 200 ] || [ "$HTTP_CODE" -ge 300 ]; then
  echo "FEHLER: AI Douyin Analyse fehlgeschlagen (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 "FEHLER: download_url nicht zurückgegeben" && cat /tmp/video_analysis/download_url.json && exit 1

Schlüsselfelder extrahieren:

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

Optionale Video-Schnittstellen-Abrufmethode: Eigener TikHub Token

Wenn VIDEO_INFO_PROVIDER=tikhub, verwenden Sie Ihren eigenen TikHub Token für die direkte Analyse. Achten Sie darauf, den echten Token nicht in Protokolle oder Antworten zu schreiben.

Douyin/TikTok:

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

Bevorzugen Sie die Adresse ohne Wasserzeichen:

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 your_tikhub_api_token" \
  -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 your_tikhub_api_token" \
  -H "Accept: application/json"

Wenn für Bilibili kein herunterladbarer Direktlink erhalten wurde, kann in Schritt 2 yt-dlp zum Herunterladen verwendet werden.

Schritt 1.5: Eigene AI Douyin Aufgabenhistorie abfragen (bei Bedarf)

Wenn der Benutzer seine eigenen historischen Tasks / letzten Aufgaben / Aufgabenliste einsehen möchte, rufen Sie die AI Douyin GET /api/v1/tasks-Schnittstelle auf. Diese Schnittstelle verwendet die X-API-Key-Authentifizierung und gibt nur die Aufgaben des Benutzers zurück, der dem aktuellen API Key zugeordnet ist.

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

Optionaler Filter:

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 "Stichwort" --json

Das Skript liest standardmäßig AI_DOUYIN_API_BASE / AI_DOUYIN_API_KEY aus $SKILL_DIR/.env oder den Umgebungsvariablen. Zeigen Sie dem Benutzer nicht den echten API Key an.

Schritt 2: Video herunterladen (nur Online-Video-Modus)

Verwenden Sie je nach Plattform unterschiedliche Download-Methoden:

YouTube (bevorzugt direkte Untertitelextraktion, kein Video-Download):

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

Ausgabedateien sind festgelegt auf:

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

Wenn der Befehl angibt, dass keine Untertitel verfügbar sind, dann verwenden Sie yt-dlp, um Audio oder Video herunterzuladen, und fahren Sie ab Schritt 3 mit dem ASR_BACKEND fort.

Douyin / TikTok / Xiaohongshu / Bilibili (wenn VIDEO_URL Direktdownload-Link vorhanden ist):

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 (Rückfall, wenn kein Direktdownload-Link vorhanden):

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

Schritt 3: Audio extrahieren (kann bei lokalen Audiodateien übersprungen werden)

Im lokalen Datei-Modus, wenn die Eingabe eine lokale Videodatei ist, ersetzen Sie {VIDEO_ID} durch den Dateinamen (ohne Erweiterung), und den Eingabepfad durch den tatsächlichen Videopfad.

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

Schritt 4: Untertitel-Backend basierend auf ASR_BACKEND auswählen

Wenn die Plattform YouTube ist und Schritt 2 erfolgreich subtitle.srt und text.txt generiert hat, überspringen Sie diesen Schritt und gehen Sie direkt zu Schritt 5 (Zusammenfassung).

Option A: ASR_BACKEND=faster-whisper (Standard)

Helper-Pfad:

$SKILL_DIR/scripts/transcribe_faster_whisper.py

Ausführungsbefehl:

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}

Erläuterung:

• Der Helper liest automatisch FW_MODEL_SIZE, FW_DEVICE, FW_COMPUTE_TYPE
• Wenn FW_DEVICE=auto, wird device="cuda" nur verwendet, wenn NVIDIA/CUDA erkannt wird
• Ausgabedateien sind festgelegt auf:
  • /tmp/video_analysis/{VIDEO_ID}/subtitle.srt
  • /tmp/video_analysis/{VIDEO_ID}/text.txt

Option B: ASR_BACKEND=volcengine

Aufgabe einreichen:

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

# Aufgaben-ID aus Antwort extrahieren
TASK_ID=$(jq -r '.id // empty' /tmp/volc_submit.json)
[ -z "$TASK_ID" ] && echo