Communitygithub.com

runesleo/x-reader

Transcreva e resuma links de vídeo ou podcast, incluindo YouTube, Bilibili, X video, Xiaoyuzhou, Apple Podcasts e URLs de mídia direta.

O que é x-reader?

Esta skill permite que um agente de IA transcreva e resuma automaticamente o conteúdo de vídeos e podcasts a partir de links, incluindo YouTube, Bilibili, X/Twitter, Xiaoyuzhou, Apple Podcasts e arquivos de mídia diretos (mp3, mp4, m3u8). A skill é acionada automaticamente ao detectar uma URL compatível, extraindo legendas (quando disponíveis) ou baixando o áudio para transcrição via Whisper (Groq). Em seguida, gera um resumo estruturado com visão geral, pontos-chave, citações e itens de ação, adaptando o formato para vídeos curtos ou podcasts longos. Ela lida com erros como limitação de taxa da API, tamanho grande de arquivo (segmentação) e conteúdo sem legendas, garantindo um fluxo robusto para análise de mídia.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Skill de Resumo de Vídeo e Podcast

Envie um link de vídeo/podcast → receba transcrição completa + resumo estruturado

Plataformas Suportadas

PlataformaTipoLegendasTranscrição Whisper
YouTubeVídeo✅✅
BilibiliVídeo✅✅
X/TwitterVídeo❌✅
Xiaoyuzhou (小宇宙)Podcast❌✅
Apple PodcastsPodcast❌✅
Links diretos (mp3/mp4/m3u8)Qualquer❌✅

Gatilho

Acionado automaticamente quando uma URL de mídia é detectada:

  • YouTube: youtube.com, youtu.be
  • Bilibili: bilibili.com, b23.tv
  • X/Twitter: x.com, twitter.com (tweets com vídeo)
  • Xiaoyuzhou: xiaoyuzhoufm.com
  • Apple Podcasts: podcasts.apple.com
  • Direta: .mp3, .mp4, .m3u8, .m4a, .webm

Pipeline

Etapa 0: Detectar Tipo de Mídia

Padrão de URLTipoPipeline
xiaoyuzhoufm.com/episode/Podcast→ Etapa 1b (Xiaoyuzhou)
podcasts.apple.comPodcast→ Etapa 1c (Apple)
bilibili.com, b23.tvVídeo→ Etapa 1d (API do Bilibili)
.mp3, .m4a link diretoÁudio→ Etapa 2b (download direto)
OutrosVídeo→ Etapa 1a (extração de legendas)

Etapa 1a: Vídeo — Extrair Legendas

# Limpar arquivos temporários
rm -f /tmp/media_sub*.vtt /tmp/media_audio.mp3 /tmp/media_transcript*.json /tmp/media_segment_*.mp3 2>/dev/null || true

# YouTube (preferir inglês, fallback chinês)
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"

Verificar se há legendas:

ls /tmp/media_sub*.vtt 2>/dev/null
  • Tem legendas → Ler conteúdo VTT, pular para Etapa 3
  • Sem legendas → Etapa 2a (baixar áudio)

Etapa 1b: Xiaoyuzhou (小宇宙) — Extrair URL de Áudio

# Extrair link CDN direto de __NEXT_DATA__
# Xiaoyuzhou é um SPA Next.js, mas o HTML inicial contém URL de áudio em __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 "Audio URL: $AUDIO_URL"

# Baixar áudio
curl -L -o /tmp/media_audio.mp3 "$AUDIO_URL"

Se a extração via curl estiver vazia (raro), fallback: usar Puppeteer/navegador para obter a página renderizada e extrair.

→ Etapa 2b (verificar tamanho e transcrever)

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

→ Etapa 2b (verificar tamanho e transcrever)

Etapa 1d: Bilibili — Stream de Áudio Direto por API

yt-dlp retorna 412 para o Bilibili mesmo com cookies. Use a API do Bilibili:

# 1. Extrair número BV da URL
BV="BV1xxxxx"  # Substituir pelo número BV real

# 2. Obter informações do vídeo (título, duração, 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\"Title: {d['title']}\nDuration: {d['duration']}s\nCID: {d['cid']}\")"

# 3. Obter URL do stream de áudio
CID=<CID do passo anterior>
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. Baixar áudio (cabeçalho Referer necessário, caso contrário 403)
curl -L -o /tmp/media_audio.m4s \
  -H "User-Agent: Mozilla/5.0" -H "Referer: https://www.bilibili.com/" "$AUDIO_URL"

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

→ Etapa 2b (verificar tamanho e transcrever)

Etapa 2a: Vídeo — Baixar Áudio (quando não há legendas)

# YouTube pode precisar de --cookies-from-browser chrome para contornar detecção 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"

Etapa 2b: Verificar Tamanho do Áudio e Segmentar

FILE_SIZE=$(stat -f%z /tmp/media_audio.* 2>/dev/null || stat -c%s /tmp/media_audio.* 2>/dev/null)
echo "File size: $FILE_SIZE bytes"
  • ≤ 25MB (25000000) → Etapa 2c (transcrever diretamente)
  • > 25MB → Dividir primeiro, depois transcrever cada segmento

Dividir áudio grande (>25MB)):

# Obter duração total
DURATION=$(ffprobe -v error -show_entries format=duration -of csv=p=0 /tmp/media_audio.* | head -1)

# Dividir em segmentos de 10 minutos (mantém cada um abaixo de 25MB)
SEGMENT_SEC=600
SEGMENTS=$(python3 -c "import math; print(math.ceil(float('$DURATION')/$SEGMENT_SEC))")

# Cortar segmentos
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

→ Chamar Etapa 2c para cada segmento sequencialmente (paralelo causa timeout 524 do Groq), concatenar resultados

Etapa 2c: Transcrição Whisper

Pré-requisito: Variável de ambiente GROQ_API_KEY

# Verificar chave de API
if [ -z "$GROQ_API_KEY" ]; then
  echo "❌ GROQ_API_KEY não definida. Obtenha uma em: https://console.groq.com/keys"
  exit 1
fi

# Transcrever arquivo único (substituir AUDIO_FILE pelo caminho real)
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

# Extrair texto simples
python3 -c "import json; print(json.load(open('/tmp/media_transcript.json'))['text'])"

Opções do modelo Whisper:

ModeloVelocidadePrecisãoCaso de Uso
whisper-large-v3-turbo10x tempo realAltaEscolha padrão
whisper-large-v35x tempo realMais altaConteúdo profissional/ruidoso

Parâmetro de idioma:

  • Chinês: language=zh
  • Inglês: language=en
  • Detecção automática: omitir parâmetro language

Etapa 3: Resumo Estruturado

Escolher o formato de saída com base no tipo de mídia:

Vídeo (≤20 min):

  1. Visão Geral (1-2 frases)
  2. Pontos-Chave (3-5 marcadores)
  3. Citações Notáveis (se houver)
  4. Itens de Ação (se aplicável)

Podcast (>20 min):

  1. Visão Geral (2-3 frases: quem discutiu o quê)
  2. Resumo por Capítulo (segmentado por tópico, 2-3 frases cada)
  3. Pontos-Chave (5-8 marcadores)
  4. Citações Notáveis
  5. Itens de Ação (se aplicável)

Formato de Saída

Vídeo

## 📺 Resumo de Vídeo

**Título**: [Título do Vídeo]
**Duração**: [x minutos]
**Idioma**: [Chinês/Inglês]

### Visão Geral
[Resumo de 1-2 frases]

### Pontos-Chave
1. [Ponto 1]
2. [Ponto 2]
...

### Citações Notáveis
> "xxx" — [timestamp]

### Itens de Ação
- [se aplicável]

Podcast

## 🎙️ Resumo de Podcast

**Programa**: [Nome do Podcast]
**Episódio**: [Título do Episódio]
**Duração**: [x minutos]
**Convidados**: [se houver]

### Visão Geral
[2-3 frases: quem discutiu o quê, conclusões principais]

### Resumo por Capítulo
#### 1. [Tópico] (~xx:xx-xx:xx)
[2-3 frases do conteúdo central]

#### 2. [Tópico] (~xx:xx-xx:xx)
[2-3 frases do conteúdo central]
...

### Pontos-Chave
1. [Ponto 1]
2. [Ponto 2]
...

### Citações Notáveis
> "xxx"

### Itens de Ação
- [se aplicável]

Tratamento de Erros

SituaçãoAção
Sem legendas + sem GROQ_API_KEYSolicitar ao usuário que defina a chave de API
Sem legendas + tem chave de APITranscrição Whisper automática
Extração Xiaoyuzhou via curl vaziaUsar Puppeteer/navegador para obter HTML renderizado
Áudio >25MBSegmentação com ffmpeg (10min/segmento), transcrever sequencialmente
Podcast >2 horasAvisar o usuário sobre a duração, confirmar antes de prosseguir
Groq timeout 524NÃO paralelizar — transcrever sequencialmente, aguardar 5-8s entre segmentos
Groq limite de taxa 429Limite de 7200s/hora, aguardar cabeçalho retry-after e tentar novamente
yt-dlp Bilibili 412Usar API do Bilibili em vez disso (Etapa 1d)
yt-dlp detecção de bot no YouTubeAdicionar --cookies-from-browser chrome
Timeout de redeTentar novamente uma vez
Links do SpotifyInformar o usuário: não suportado (protegido por DRM)

Limites do Groq Whisper

  • Máximo 25MB por requisição
  • Camada gratuita: 7200 segundos de áudio/hora (janela contínua), ~20 horas/dia
  • Formatos suportados: mp3, mp4, mpeg, mpga, m4a, wav, webm

Dependências

  • yt-dlp: download de vídeo + extração de legendas
  • ffmpeg: conversão de áudio + segmentação
  • curl: download de áudio do Xiaoyuzhou, API do Bilibili
  • GROQ_API_KEY: API de transcrição Whisper (gratuita em https://console.groq.com/keys)

Habilidades Relacionadas