Communitygithub.com

runesleo/x-reader

Transcrire et résumer des liens vidéo ou podcast, incluant YouTube, Bilibili, X video, Xiaoyuzhou, Apple Podcasts et les URLs média directes.

Qu'est-ce que x-reader ?

Cette compétence d'agent IA permet de transformer n'importe quel lien vidéo ou podcast en un contenu textuel structuré. Lorsqu'un utilisateur envoie un lien d'une plateforme prise en charge (YouTube, Bilibili, X/Twitter, Xiaoyuzhou, Apple Podcasts ou un fichier média direct), l'agent télécharge les sous-titres ou l'audio, transcrit l'audio via l'API Whisper de Groq, et génère un résumé détaillé avec points clés, citations et éléments d'action. Il gère automatiquement les étapes de détection de type de média, d'extraction de sous-titres (quand disponibles), de téléchargement audio, de segmentation des fichiers volumineux (>25 Mo) et de transcription séquentielle pour éviter les limites de débit de l'API. Cette compétence est idéale pour les développeurs, les chercheurs ou les créateurs de contenu qui souhaitent rapidement digérer du contenu audio/vidéo long sans le regarder ou l'écouter en entier. Elle nécessite une clé API Groq (gratuite) pour la transcription Whisper et les outils `yt-dlp`, `ffmpeg` et `curl` installés sur le système.

Compatible avec~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/runesleo/x-reader/tree/HEAD/skills/video

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Compétence de Résumé Vidéo & Podcast

Envoyez un lien vidéo/podcast → obtenez la transcription complète + un résumé structuré.

Plateformes Prises en Charge

PlateformeTypeSous-titresTranscription Whisper
YouTubeVidéo✅✅
BilibiliVidéo✅✅
X/TwitterVidéo❌✅
Xiaoyuzhou (小宇宙)Podcast❌✅
Apple PodcastsPodcast❌✅
Liens directs (mp3/mp4/m3u8)Quelconque❌✅

Déclencheur

Déclenché automatiquement lorsqu'une URL média est détectée :

  • YouTube : youtube.com, youtu.be
  • Bilibili : bilibili.com, b23.tv
  • X/Twitter : x.com, twitter.com (tweets avec vidéo)
  • Xiaoyuzhou : xiaoyuzhoufm.com
  • Apple Podcasts : podcasts.apple.com
  • Direct : .mp3, .mp4, .m3u8, .m4a, .webm

Pipeline

Étape 0 : Détection du Type de Média

Motif URLTypePipeline
xiaoyuzhoufm.com/episode/Podcast→ Étape 1b (Xiaoyuzhou)
podcasts.apple.comPodcast→ Étape 1c (Apple)
bilibili.com, b23.tvVidéo→ Étape 1d (API Bilibili)
.mp3, .m4a lien directAudio→ Étape 2b (téléchargement direct)
AutreVidéo→ Étape 1a (extraction de sous-titres)

Étape 1a : Vidéo — Extraire les Sous-titres

# Nettoyer les fichiers temporaires
rm -f /tmp/media_sub*.vtt /tmp/media_audio.mp3 /tmp/media_transcript*.json /tmp/media_segment_*.mp3 2>/dev/null || true

# YouTube (préférer anglais, fallback chinois)
yt-dlp --skip-download --write-auto-sub --sub-lang "en,zh-Hans" -o "/tmp/media_sub" "VIDEO_URL"

# Bilibili
yt-dlp --skip-download --write-auto-sub --sub-lang "zh-Hans,zh" -o "/tmp/media_sub" "VIDEO_URL"

Vérification des sous-titres :

ls /tmp/media_sub*.vtt 2>/dev/null
  • A des sous-titres → Lire le contenu VTT, passer à l'Étape 3
  • Pas de sous-titres → Étape 2a (télécharger l'audio)

Étape 1b : Xiaoyuzhou (小宇宙) — Extraire l'URL Audio

# Extraire le lien CDN direct depuis __NEXT_DATA__
# Xiaoyuzhou est une SPA Next.js, mais le HTML initial contient l'URL audio dans __NEXT_DATA__
AUDIO_URL=$(curl -sL -H "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36" \
  "EPISODE_URL" \
  | grep -oE 'https://media\.xyzcdn\.net/[^"]+\.(m4a|mp3)' \
  | head -1)

echo "URL Audio : $AUDIO_URL"

# Télécharger l'audio
curl -L -o /tmp/media_audio.mp3 "$AUDIO_URL"

Si l'extraction par curl est vide (rare), solution de repli : utiliser Puppeteer/navigateur pour obtenir la page rendue et extraire.

→ Étape 2b (vérifier la taille et transcrire)

Étape 1c : Apple Podcasts — via yt-dlp

yt-dlp -f "ba[ext=m4a]/ba/b" --extract-audio --audio-format mp3 --audio-quality 5 \
  -o "/tmp/media_audio.%(ext)s" "APPLE_PODCAST_URL"

→ Étape 2b (vérifier la taille et transcrire)

Étape 1d : Bilibili — Flux Audio Direct via API

yt-dlp renvoie 412 pour Bilibili même avec des cookies. Utilisez plutôt l'API de Bilibili :

# 1. Extraire le numéro BV de l'URL
BV="BV1xxxxx"  # Remplacer par le vrai numéro BV

# 2. Obtenir les infos vidéo (titre, durée, CID)
curl -s "https://api.bilibili.com/x/web-interface/view?bvid=$BV" \
  -H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" \
  | python3 -c "import json,sys; d=json.load(sys.stdin)['data']; print(f\"Titre: {d['title']}\nDurée: {d['duration']}s\nCID: {d['cid']}\")"

# 3. Obtenir l'URL du flux audio
CID=<CID de l'étape précédente>
AUDIO_URL=$(curl -s "https://api.bilibili.com/x/player/playurl?bvid=$BV&cid=$CID&fnval=16&qn=64" \
  -H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" \
  | python3 -c "import json,sys; print(json.load(sys.stdin)['data']['dash']['audio'][0]['baseUrl'])")

# 4. Télécharger l'audio (l'en-tête Referer est requis, sinon 403)
curl -L -o /tmp/media_audio.m4s \
  -H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" "$AUDIO_URL"

# 5. Convertir en mp3
ffmpeg -y -i /tmp/media_audio.m4s -acodec libmp3lame -q:a 5 /tmp/media_audio.mp3

→ Étape 2b (vérifier la taille et transcrire)

Étape 2a : Vidéo — Télécharger l'Audio (quand pas de sous-titres)

# YouTube peut nécessiter --cookies-from-browser chrome pour contourner la détection de bot
yt-dlp --cookies-from-browser chrome -f "ba[ext=m4a]/ba/b" --extract-audio --audio-format mp3 --audio-quality 5 \
  -o "/tmp/media_audio.%(ext)s" "VIDEO_URL"

Étape 2b : Vérifier la Taille Audio et Segmenter

FILE_SIZE=$(stat -f%z /tmp/media_audio.* 2>/dev/null || stat -c%s /tmp/media_audio.* 2>/dev/null)
echo "Taille du fichier : $FILE_SIZE octets"
  • ≤ 25 Mo (25000000) → Étape 2c (transcrire directement)
  • > 25 Mo → Segmenter d'abord, puis transcrire chaque segment

Segmentation d'audio volumineux (>25 Mo) :

# Obtenir la durée totale
DURATION=$(ffprobe -v error -show_entries format=duration -of csv=p=0 /tmp/media_audio.* | head -1)

# Segmenter en morceaux de 10 minutes (chacun reste sous 25 Mo)
SEGMENT_SEC=600
SEGMENTS=$(python3 -c "import math; print(math.ceil(float('$DURATION')/$SEGMENT_SEC))")

# Découper les segments
for i in $(seq 0 $((SEGMENTS-1))); do
  START=$((i * SEGMENT_SEC))
  ffmpeg -y -i /tmp/media_audio.* -ss $START -t $SEGMENT_SEC -acodec libmp3lame -q:a 5 \
    "/tmp/media_segment_${i}.mp3" 2>/dev/null
done

→ Appeler l'Étape 2c pour chaque segment séquentiellement (le parallélisme déclenche le timeout 524 de Groq), concaténer les résultats.

Étape 2c : Transcription Whisper

Prérequis : Variable d'environnement GROQ_API_KEY

# Vérifier la clé API
if [ -z "$GROQ_API_KEY" ]; then
  echo "❌ GROQ_API_KEY non définie. Obtenez-en une sur : https://console.groq.com/keys"
  exit 1
fi

# Transcrire un seul fichier (remplacer AUDIO_FILE par le chemin réel)
curl -s -X POST "https://api.groq.com/openai/v1/audio/transcriptions" \
  -H "Authorization: Bearer $GROQ_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F "file=@AUDIO_FILE" \
  -F "model=whisper-large-v3-turbo" \
  -F "response_format=verbose_json" \
  -F "language=zh" \
  > /tmp/media_transcript.json

# Extraire le texte brut
python3 -c "import json; print(json.load(open('/tmp/media_transcript.json'))['text'])"

Options du modèle Whisper :

ModèleVitessePrécisionCas d'utilisation
whisper-large-v3-turbo10x temps réelÉlevéeChoix par défaut
whisper-large-v35x temps réelMaximaleContenu professionnel/bruyant

Paramètre de langue :

  • Chinois : language=zh
  • Anglais : language=en
  • Détection automatique : omettre le paramètre language

Étape 3 : Résumé Structuré

Choisir le format de sortie en fonction du type de média :

Vidéo (≤20 min) :

  1. Aperçu (1-2 phrases)
  2. Points clés (3-5 points)
  3. Citations notables (si présentes)
  4. Éléments d'action (si applicables)

Podcast (>20 min) :

  1. Aperçu (2-3 phrases : qui a discuté de quoi)
  2. Résumé des chapitres (segmenté par sujet, 2-3 phrases chacun)
  3. Points clés (5-8 points)
  4. Citations notables
  5. Éléments d'action (si applicables)

Format de Sortie

Vidéo

## 📺 Résumé Vidéo

**Titre** : [Titre de la vidéo]
**Durée** : [x minutes]
**Langue** : [Chinois/Anglais]

### Aperçu
[Résumé en 1-2 phrases]

### Points clés
1. [Point 1]
2. [Point 2]
...

### Citations notables
> "xxx" — [horodatage]

### Éléments d'action
- [si applicables]

Podcast

## 🎙️ Résumé Podcast

**Émission** : [Nom du podcast]
**Épisode** : [Titre de l'épisode]
**Durée** : [x minutes]
**Invités** : [si présents]

### Aperçu
[2-3 phrases : qui a discuté de quoi, conclusions principales]

### Résumé des chapitres
#### 1. [Sujet] (~xx:xx-xx:xx)
[2-3 phrases du contenu principal]

#### 2. [Sujet] (~xx:xx-xx:xx)
[2-3 phrases du contenu principal]
...

### Points clés
1. [Point 1]
2. [Point 2]
...

### Citations notables
> "xxx"

### Éléments d'action
- [si applicables]

Gestion des Erreurs

SituationAction
Pas de sous-titres + pas de GROQ_API_KEYInviter l'utilisateur à définir la clé API
Pas de sous-titres + clé API présenteTranscription Whisper automatique
Extraction Xiaoyuzhou curl videUtiliser Puppeteer/navigateur pour obtenir le HTML rendu
Audio >25 MoSegmenter avec ffmpeg (10 min/segment), transcrire séquentiellement
Podcast >2 heuresAvertir l'utilisateur sur la durée, confirmer avant de continuer
Timeout 524 de GroqNE PAS paralléliser — transcrire séquentiellement, attendre 5 à 8 s entre les segments
Limite de débit 429 de GroqLimite de 7200 s/heure, attendre l'en-tête retry-after, puis réessayer
yt-dlp Bilibili 412Utiliser l'API Bilibili à la place (Étape 1d)
Détection de bot YouTubeAjouter --cookies-from-browser chrome
Timeout réseauRéessayer une fois
Liens SpotifyInformer l'utilisateur : non pris en charge (protégé par DRM)

Limites de Groq Whisper

  • Maximum 25 Mo par requête
  • Niveau gratuit : 7200 secondes d'audio/heure (fenêtre glissante), ~20 heures/jour
  • Formats pris en charge : mp3, mp4, mpeg, mpga, m4a, wav, webm

Dépendances

  • yt-dlp : téléchargement vidéo + extraction de sous-titres
  • ffmpeg : conversion audio + segmentation
  • curl : téléchargement audio Xiaoyuzhou, API Bilibili
  • GROQ_API_KEY : API de transcription Whisper (gratuite sur https://console.groq.com/keys)

Skills associés