watch — Assistente de Vídeo (Frame a Frame + Transcrição)

watch — Claude assiste a um vídeo do início ao fim

Divide um vídeo no que o Claude lê nativamente: imagens dos quadros (vistas com a ferramenta Read) + uma transcrição (texto). O resultado é a compreensão não apenas das palavras, mas do que está acontecendo na tela.

Bilíngue. Esta é a versão em inglês. Um espelho completo em russo é SKILL.ru.md. Trabalhe no idioma que o usuário usar; o fluxo de trabalho e os comandos são idênticos.

Dependências (instaladas uma vez via install.sh)

Verifique com: command -v yt-dlp ffmpeg whisper node.

• yt-dlp → ~/.local/bin/yt-dlp (no Python 3.12 em ~/.local/python312 — o Python do sistema geralmente é muito antigo; versões recentes do yt-dlp precisam de 3.10+);
• ffmpeg → a partir de imageio-ffmpeg, link simbólico para ~/.local/bin/ffmpeg;
• whisper → openai-whisper (no Python do sistema; o modelo é baixado no primeiro uso);
• node → ~/.local/node (v24) — necessário para contornar as defesas do YouTube.

Para YouTube especificamente, install.sh também configura:

• um provedor de PO-token (bgutil), construído em modo script sob ~/.local/bgutil-pot/server/build/;
• um runtime Node.js + um componente EJS, para resolver o n-challenge do YouTube;
• cookies de uma conta logada do YouTube, em ~/.config/watch/cookies.txt.

Se os cookies ficarem desatualizados (o YouTube começar a pedir "confirme que você não é um robô" novamente), peça ao usuário para reexportar cookies.txt com uma extensão de navegador como "Get cookies.txt LOCALLY" e colocar em ~/.config/watch/cookies.txt.

Sempre baixe através do wrapper bash ~/.claude/skills/watch/yt.sh … — ele adiciona automaticamente as flags corretas do YouTube. Para URLs diretas de mp4/Loom/Zoom, as flags extras são inofensivas.

Fluxo de trabalho

1. Configuração

• Crie uma pasta de trabalho: mkdir -p /tmp/watch/<slug> (slug = um nome curto a partir da URL/tópico).
• Analise a URL (YouTube / Loom / link de compartilhamento do Zoom / arquivo de vídeo direto). Um arquivo local pula as etapas de download — trabalhe diretamente com ele.

2. Transcrição — legendas primeiro (grátis, quando disponíveis)

bash ~/.claude/skills/watch/yt.sh --write-subs --write-auto-subs --sub-langs "en,ru" \
  --skip-download --convert-subs srt -o "/tmp/watch/<slug>/subs.%(ext)s" "<URL>"

Se um arquivo .srt aparecer, essa é uma transcrição pronta com timestamps — use-a.

3. Baixar o vídeo (necessário tanto para os quadros quanto como fallback do Whisper)

bash ~/.claude/skills/watch/yt.sh -f "bv*[height<=480]+ba/b[height<=480]/18/best" \
  -o "/tmp/watch/<slug>/video.%(ext)s" "<URL>"

Você obterá um .mp4 ou .webm — use o nome de arquivo real daqui em diante (video.*). Se não houver legendas, transcreva o áudio com Whisper (modelo small; base é mais rápido para um teste rápido):

whisper "/tmp/watch/<slug>/video.webm" --model small --language en \
  --output_format srt --output_dir "/tmp/watch/<slug>/"

A primeira execução baixa o modelo (~460 MB para small) — é normal, ocorre uma única vez. Remova --language en para áudio que não seja em inglês, ou defina o código de idioma correto. Whisper é lento: um clipe de 34 minutos leva vários minutos — execute-o em segundo plano.

4. Quadros POR MUDANÇA DE CENA (a etapa principal — não por temporizador)

ffmpeg -i "/tmp/watch/<slug>/video.webm" -vf "select='gt(scene,0.3)',showinfo" \
  -vsync vfr "/tmp/watch/<slug>/frames/frame_%04d.png" 2> "/tmp/watch/<slug>/scenes.log"

• Limiar 0.3 — ajuste entre 0.2–0.4 para densidade de cena (um limiar menor = mais quadros).
• Obtenha o timestamp de cada quadro a partir do log showinfo (pts_time) em scenes.log.
• Se houver muitos quadros (um vídeo longo), mantenha cerca de 60–150 dos mais informativos, eliminando quadros que estão próximos no tempo. Decodificar um vídeo longo leva um tempo — execute-o em segundo plano.

FALLBACK — se houver poucas cenas (0–2 quadros). Imagens suaves e sem cortes (um único take contínuo, um drone, um cabeça falante) produzem poucas mudanças de cena. Nesse caso, amostre em um intervalo fixo:

ffmpeg -i "/tmp/watch/<slug>/video.webm" -vf "fps=1/5,scale=960:-1,showinfo" \
  -vsync vfr "/tmp/watch/<slug>/frames/frame_%04d.png" 2> "/tmp/watch/<slug>/scenes.log"

Ajuste o intervalo (1/5 = um quadro a cada 5s) de acordo com a duração do vídeo para que você fique por volta de ~150 quadros. O timestamp do i-ésimo quadro = i × intervalo.

4a. YouTube: por que tudo passa pelo yt.sh

O YouTube (2025+) exige todos os três itens a seguir ao mesmo tempo, caso contrário você obtém HTTP 403 / "não é um robô" / "apenas imagens":

1. cookies de uma conta logada (~/.config/watch/cookies.txt);
2. um PO-token (prova de origem) — gerado localmente pelo bgutil (modo script, Node);
3. resolver o n-challenge — um runtime Node + um componente EJS (--remote-components ejs:github). Tudo isso já está embutido no yt.sh — basta chamá-lo. Fontes diretas de mp4/Loom/Zoom não têm essas defesas. Se pedir "confirme que você não é um robô" novamente, os cookies ficaram desatualizados — peça um cookies.txt novo.

5. Análise

• Leia a transcrição (.srt).
• Observe os quadros extraídos (visão, através da ferramenta Read): slides, código, demonstrações, gráficos.
• Relacione os visuais à transcrição usando os timestamps.

6. Relatório

Entregue:

• um Resumo Executivo (3–5 linhas);
• conceitos-chave com timestamps;
• o que é MOSTRADO NA TELA que não está no texto (gráficos, UIs, demonstrações);
• momentos / citações notáveis com timestamps.

7. Salvar em uma base de conhecimento (pergunte primeiro)

Pergunte: "Salvar esta análise na sua base de conhecimento (Obsidian)?" Se sim, escreva uma nota em markdown na pasta correta com links para notas relacionadas. Não salve sem confirmação.

Regras

• Os arquivos de trabalho vão para uma pasta temporária /tmp/watch/<slug> — não polua o projeto.
• Não publique ou envie nada externamente sem uma solicitação explícita.
• Não ignore um vídeo privado com exigência de login — avise o usuário.