Skip to content

jacksonemmerich/farmapub / .agents/skills/audio-transcriber

audio-transcriber

Verified

Transform audio recordings into professional Markdown documentation with intelligent summaries using LLM integration

FileKindSize
CHANGELOG.mdmarkdown5.3 KB
SKILL.mdskill md14.9 KB
examples/basic-transcription.shexecutablescript6.3 KB
references/tools-comparison.mdmarkdown8.2 KB
scripts/install-requirements.shexecutablescript6.7 KB
scripts/transcribe.pyexecutablescript17.3 KB

scripts/transcribe.py

View on GitHub
#!/usr/bin/env python3
"""
Audio Transcriber v1.1.0
Transcreve áudio para texto e gera atas/resumos usando LLM.
"""

import os
import sys
import json
import subprocess
import shutil
from datetime import datetime
from pathlib import Path

# Rich for beautiful terminal output
try:
    from rich.console import Console
    from rich.prompt import Prompt
    from rich.panel import Panel
    from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
    from rich import print as rprint
    RICH_AVAILABLE = True
except ImportError:
    RICH_AVAILABLE = False
    print("⚠️  Installing rich for better UI...")
    subprocess.run([sys.executable, "-m", "pip", "install", "--user", "rich"], check=False)
    from rich.console import Console
    from rich.prompt import Prompt
    from rich.panel import Panel
    from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
    from rich import print as rprint

# tqdm for progress bars
try:
    from tqdm import tqdm
except ImportError:
    print("⚠️  Installing tqdm for progress bars...")
    subprocess.run([sys.executable, "-m", "pip", "install", "--user", "tqdm"], check=False)
    from tqdm import tqdm

# Whisper engines
try:
    from faster_whisper import WhisperModel
    TRANSCRIBER = "faster-whisper"
except ImportError:
    try:
        import whisper
        TRANSCRIBER = "whisper"
    except ImportError:
        print("❌ Nenhum engine de transcrição encontrado!")
        print("   Instale: pip install faster-whisper")
        sys.exit(1)

console = Console()

# Template padrão RISEN para fallback
DEFAULT_MEETING_PROMPT = """
Role: Você é um transcritor profissional especializado em documentação.

Instructions: Transforme a transcrição fornecida em um documento estruturado e profissional.

Steps:
1. Identifique o tipo de conteúdo (reunião, palestra, entrevista, etc.)
2. Extraia os principais tópicos e pontos-chave
3. Identifique participantes/speakers (se aplicável)
4. Extraia decisões tomadas e ações definidas (se reunião)
5. Organize em formato apropriado com seções claras
6. Use Markdown para formatação profissional

End Goal: Documento final bem estruturado, legível e pronto para distribuição.

Narrowing: 
- Mantenha objetividade e clareza
- Preserve contexto importante
- Use formatação Markdown adequada
- Inclua timestamps relevantes quando aplicável
"""


def detect_cli_tool():
    """Detecta qual CLI de LLM está disponível (claude > gh copilot)."""
    if shutil.which('claude'):
        return 'claude'
    elif shutil.which('gh'):
        result = subprocess.run(['gh', 'copilot', '--version'], 
                                capture_output=True, text=True)
        if result.returncode == 0:
            return 'gh-copilot'
    return None


def invoke_prompt_engineer(raw_prompt, timeout=90):
    """
    Invoca prompt-engineer skill via CLI para melhorar/gerar prompts.
    
    Args:
        raw_prompt: Prompt a ser melhorado ou meta-prompt
        timeout: Timeout em segundos
    
    Returns:
        str: Prompt melhorado ou DEFAULT_MEETING_PROMPT se falhar
    """
    try:
        # Tentar via gh copilot
        console.print("[dim]   Invocando prompt-engineer...[/dim]")
        
        result = subprocess.run(
            ['gh', 'copilot', 'suggest', '-t', 'shell', raw_prompt],
            capture_output=True,
            text=True,
            timeout=timeout
        )
        
        if result.returncode == 0 and result.stdout.strip():
            return result.stdout.strip()
        else:
            console.print("[yellow]⚠️  prompt-engineer não respondeu, usando template padrão[/yellow]")
            return DEFAULT_MEETING_PROMPT
            
    except subprocess.TimeoutExpired:
        console.print(f"[red]⚠️  Timeout após {timeout}s, usando template padrão[/red]")
        return DEFAULT_MEETING_PROMPT
    except Exception as e:
        console.print(f"[red]⚠️  Erro ao invocar prompt-engineer: {e}[/red]")
        return DEFAULT_MEETING_PROMPT


def handle_prompt_workflow(user_prompt, transcript):
    """
    Gerencia fluxo completo de prompts com prompt-engineer.
    
    Cenário A: Usuário forneceu prompt → Melhorar AUTOMATICAMENTE → Confirmar
    Cenário B: Sem prompt → Sugerir tipo → Confirmar → Gerar → Confirmar
    
    Returns:
        str: Prompt final a usar, ou None se usuário recusou processamento
    """
    prompt_engineer_available = os.path.exists(
        os.path.expanduser('~/.copilot/skills/prompt-engineer/SKILL.md')
    )
    
    # ========== CENÁRIO A: USUÁRIO FORNECEU PROMPT ==========
    if user_prompt:
        console.print("\n[cyan]📝 Prompt fornecido pelo usuário[/cyan]")
        console.print(Panel(user_prompt[:300] + ("..." if len(user_prompt) > 300 else ""), 
                           title="Prompt original", border_style="dim"))
        
        if prompt_engineer_available:
            # Melhora AUTOMATICAMENTE (sem perguntar)
            console.print("\n[cyan]🔧 Melhorando prompt com prompt-engineer...[/cyan]")
            
            improved_prompt = invoke_prompt_engineer(
                f"melhore este prompt:\n\n{user_prompt}"
            )
            
            # Mostrar AMBAS versões
            console.print("\n[green]✨ Versão melhorada:[/green]")
            console.print(Panel(improved_prompt[:500] + ("..." if len(improved_prompt) > 500 else ""), 
                               title="Prompt otimizado", border_style="green"))
            
            console.print("\n[dim]📝 Versão original:[/dim]")
            console.print(Panel(user_prompt[:300] + ("..." if len(user_prompt) > 300 else ""), 
                               title="Seu prompt", border_style="dim"))
            
            # Pergunta qual usar
            confirm = Prompt.ask(
                "\n💡 Usar versão melhorada?",
                choices=["s", "n"],
                default="s"
            )
            
            return improved_prompt if confirm == "s" else user_prompt
        else:
            # prompt-engineer não disponível
            console.print("[yellow]⚠️  prompt-engineer skill não disponível[/yellow]")
            console.print("[dim]✅ Usando seu prompt original[/dim]")
            return user_prompt
    
    # ========== CENÁRIO B: SEM PROMPT - AUTO-GERAÇÃO ==========
    else:
        console.print("\n[yellow]⚠️  Nenhum prompt fornecido.[/yellow]")
        
        if not prompt_engineer_available:
            console.print("[yellow]⚠️  prompt-engineer skill não encontrado[/yellow]")
            console.print("[dim]Usando template padrão...[/dim]")
            return DEFAULT_MEETING_PROMPT
        
        # PASSO 1: Perguntar se quer auto-gerar
        console.print("Posso analisar o transcript e sugerir um formato de resumo/ata?")
        
        generate = Prompt.ask(
            "\n💡 Gerar prompt automaticamente?",
            choices=["s", "n"],
            default="s"
        )
        
        if generate == "n":
            console.print("[dim]✅ Ok, gerando apenas transcript.md (sem ata)[/dim]")
            return None  # Sinaliza: não processar com LLM
        
        # PASSO 2: Analisar transcript e SUGERIR tipo
        console.print("\n[cyan]🔍 Analisando transcript...[/cyan]")
        
        suggestion_meta_prompt = f"""
Analise este transcript ({len(transcript)} caracteres) e sugira:

1. Tipo de conteúdo (reunião, palestra, entrevista, etc.)
2. Formato de saída recomendado (ata formal, resumo executivo, notas estruturadas)
3. Framework ideal (RISEN, RODES, STAR, etc.)

Primeiras 1000 palavras do transcript:
{transcript[:4000]}

Responda em 2-3 linhas concisas.
"""
        
        suggested_type = invoke_prompt_engineer(suggestion_meta_prompt)
        
        # PASSO 3: Mostrar sugestão e CONFIRMAR
        console.print("\n[green]💡 Sugestão de formato:[/green]")
        console.print(Panel(suggested_type, title="Análise do transcript", border_style="green"))
        
        confirm_type = Prompt.ask(
            "\n💡 Usar este formato?",
            choices=["s", "n"],
            default="s"
        )
        
        if confirm_type == "n":
            console.print("[dim]Usando template padrão...[/dim]")
            return DEFAULT_MEETING_PROMPT
        
        # PASSO 4: Gerar prompt completo baseado na sugestão
        console.print("\n[cyan]✨ Gerando prompt estruturado...[/cyan]")
        
        final_meta_prompt = f"""
Crie um prompt completo e estruturado (usando framework apropriado) para:

{suggested_type}

O prompt deve instruir uma IA a transformar o transcript em um documento
profissional e bem formatado em Markdown.
"""
        
        generated_prompt = invoke_prompt_engineer(final_meta_prompt)
        
        # PASSO 5: Mostrar prompt gerado e CONFIRMAR
        console.print("\n[green]✅ Prompt gerado:[/green]")
        console.print(Panel(generated_prompt[:600] + ("..." if len(generated_prompt) > 600 else ""), 
                           title="Preview", border_style="green"))
        
        confirm_final = Prompt.ask(
            "\n💡 Usar este prompt?",
            choices=["s", "n"],
            default="s"
        )
        
        if confirm_final == "s":
            return generated_prompt
        else:
            console.print("[dim]Usando template padrão...[/dim]")
            return DEFAULT_MEETING_PROMPT


def process_with_llm(transcript, prompt, cli_tool='claude', timeout=300):
    """
    Processa transcript com LLM usando prompt fornecido.
    
    Args:
        transcript: Texto transcrito
        prompt: Prompt instruindo como processar
        cli_tool: 'claude' ou 'gh-copilot'
        timeout: Timeout em segundos
    
    Returns:
        str: Ata/resumo processado
    """
    full_prompt = f"{prompt}\n\n---\n\nTranscrição:\n\n{transcript}"
    
    try:
        with Progress(
            SpinnerColumn(),
            TextColumn("[progress.description]{task.description}"),
            transient=True
        ) as progress:
            progress.add_task(description=f"🤖 Processando com {cli_tool}...", total=None)
            
            if cli_tool == 'claude':
                result = subprocess.run(
                    ['claude', '-'],
                    input=full_prompt,
                    capture_output=True,
                    text=True,
                    timeout=timeout
                )
            elif cli_tool == 'gh-copilot':
                result = subprocess.run(
                    ['gh', 'copilot', 'suggest', '-t', 'shell', full_prompt],
                    capture_output=True,
                    text=True,
                    timeout=timeout
                )
            else:
                raise ValueError(f"CLI tool desconhecido: {cli_tool}")
        
        if result.returncode == 0:
            return result.stdout.strip()
        else:
            console.print(f"[red]❌ Erro ao processar com {cli_tool}[/red]")
            console.print(f"[dim]{result.stderr[:200]}[/dim]")
            return None
            
    except subprocess.TimeoutExpired:
        console.print(f"[red]❌ Timeout após {timeout}s[/red]")
        return None
    except Exception as e:
        console.print(f"[red]❌ Erro: {e}[/red]")
        return None


def transcribe_audio(audio_file, model="base"):
    """
    Transcreve áudio usando Whisper com barra de progresso.
    
    Returns:
        dict: {language, duration, segments: [{start, end, text}]}
    """
    console.print(f"\n[cyan]🎙️  Transcrevendo áudio com {TRANSCRIBER}...[/cyan]")
    
    try:
        if TRANSCRIBER == "faster-whisper":
            model_obj = WhisperModel(model, device="cpu", compute_type="int8")
            segments, info = model_obj.transcribe(
                audio_file,
                language=None,
                vad_filter=True,
                word_timestamps=True
            )
            
            data = {
                "language": info.language,
                "language_probability": round(info.language_probability, 2),
                "duration": info.duration,
                "segments": []
            }
            
            # Converter generator em lista com progresso
            console.print("[dim]Processando segmentos...[/dim]")
            for segment in tqdm(segments, desc="Segmentos", unit="seg"):
                data["segments"].append({
                    "start": round(segment.start, 2),
                    "end": round(segment.end, 2),
                    "text": segment.text.strip()
                })
        
        else:  # whisper original
            import whisper
            model_obj = whisper.load_model(model)
            result = model_obj.transcribe(audio_file, word_timestamps=True)
            
            data = {
                "language": result["language"],
                "duration": result["segments"][-1]["end"] if result["segments"] else 0,
                "segments": result["segments"]
            }
        
        console.print(f"[green]✅ Transcrição completa! Idioma: {data['language'].upper()}[/green]")
        console.print(f"[dim]   {len(data['segments'])} segmentos processados[/dim]")
        
        return data
        
    except Exception as e:
        console.print(f"[red]❌ Erro na transcrição: {e}[/red]")
        sys.exit(1)


def save_outputs(transcript_text, ata_text, audio_file, output_dir="."):
    """
    Salva transcript e ata em arquivos .md com timestamp.
    
    Returns:
        tuple: (transcript_path, ata_path or None)
    """
    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
    base_name = Path(audio_file).stem
    
    # Sempre salva transcript
    transcript_filename = f"transcript-{timestamp}.md"
    transcript_path = Path(output_dir) / transcript_filename
    
    with open(transcript_path, 'w', encoding='utf-8') as f:
        f.write(transcript_text)
    
    console.print(f"[green]✅ Transcript salvo:[/green] {transcript_filename}")
    
    # Salva ata se existir
    ata_path = None
    if ata_text:
        ata_filename = f"ata-{timestamp}.md"
        ata_path = Path(output_dir) / ata_filename
        
        with open(ata_path, 'w', encoding='utf-8') as f:
            f.write(ata_text)
        
        console.print(f"[green]✅ Ata salva:[/green] {ata_filename}")
    
    return str(transcript_path), str(ata_path) if ata_path else None


def main():
    """Função principal."""
    import argparse
    
    parser = argparse.ArgumentParser(description="Audio Transcriber v1.1.0")
    parser.add_argument("audio_file", help="Arquivo de áudio para transcrever")
    parser.add_argument("--prompt", help="Prompt customizado para processar transcript")
    parser.add_argument("--model", default="base", help="Modelo Whisper (tiny/base/small/medium/large)")
    parser.add_argument("--output-dir", default=".", help="Diretório de saída")
    
    args = parser.parse_args()
    
    # Verificar arquivo existe
    if not os.path.exists(args.audio_file):
        console.print(f"[red]❌ Arquivo não encontrado: {args.audio_file}[/red]")
        sys.exit(1)
    
    console.print("[bold cyan]🎵 Audio Transcriber v1.1.0[/bold cyan]\n")
    
    # Step 1: Transcrever
    transcription_data = transcribe_audio(args.audio_file, model=args.model)
    
    # Gerar texto do transcript
    transcript_text = f"# Transcrição de Áudio\n\n"
    transcript_text += f"**Arquivo:** {Path(args.audio_file).name}\n"
    transcript_text += f"**Idioma:** {transcription_data['language'].upper()}\n"
    transcript_text += f"**Data:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
    transcript_text += "---\n\n## Transcrição Completa\n\n"
    
    for seg in transcription_data["segments"]:
        start_min = int(seg["start"] // 60)
        start_sec = int(seg["start"] % 60)
        end_min = int(seg["end"] // 60)
        end_sec = int(seg["end"] % 60)
        transcript_text += f"**[{start_min:02d}:{start_sec:02d} → {end_min:02d}:{end_sec:02d}]**  \n{seg['text']}\n\n"
    
    # Step 2: Detectar CLI
    cli_tool = detect_cli_tool()
    
    if not cli_tool:
        console.print("\n[yellow]⚠️  Nenhuma CLI de IA detectada (Claude ou GitHub Copilot)[/yellow]")
        console.print("[dim]ℹ️  Salvando apenas transcript.md...[/dim]")
        
        save_outputs(transcript_text, None, args.audio_file, args.output_dir)

        console.print("\n[cyan]💡 Para gerar ata/resumo:[/cyan]")
        console.print("  - Instale Claude CLI: pip install claude-cli")
        console.print("  - Ou GitHub Copilot CLI já está instalado (gh copilot)")
        return
    
    console.print(f"\n[green]✅ CLI detectada: {cli_tool}[/green]")
    
    # Step 3: Workflow de prompt
    final_prompt = handle_prompt_workflow(args.prompt, transcript_text)
    
    if final_prompt is None:
        # Usuário recusou processamento
        save_outputs(transcript_text, None, args.audio_file, args.output_dir)
        return
    
    # Step 4: Processar com LLM
    ata_text = process_with_llm(transcript_text, final_prompt, cli_tool)
    
    if ata_text:
        console.print("[green]✅ Ata gerada com sucesso![/green]")
    else:
        console.print("[yellow]⚠️  Falha ao gerar ata, salvando apenas transcript[/yellow]")
    
    # Step 5: Salvar arquivos
    console.print("\n[cyan]💾 Salvando arquivos...[/cyan]")
    save_outputs(transcript_text, ata_text, args.audio_file, args.output_dir)

    console.print("\n[bold green]✅ Concluído![/bold green]")


if __name__ == "__main__":
    main()
rea-changelog-updatemorluto/reaPrepare or rewrite REA release changelogs and GitHub release notes from pinned Git history, with verified contributor thanks and Release Please synchronization.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
academy-guideanthropics/skillsStop and check this skill before finishing any reply to a question about how to use Claude or a Claude product — it recommends matching courses, tutorials, and use cases from Claude Academy (academy.claude.com), Anthropic's learning hub. Trigger on: "how do I", "how can I", "getting started with", "what can Claude do", "teach me", "learn to use"; questions about artifacts, projects, skills, plugins, connectors, MCP; requests about rolling Claude out to a team, class, or organization; and any ask for training materials, onboarding content, or learning resources. Use it when the user is learning how to use a feature or product — not when they are mid-task and just want the task done. This skill composes with other skills: after consulting product documentation to answer how a Claude feature works, also check here for a matching course or tutorial — a docs-grounded answer and an Academy recommendation belong together. Only recommend on a strong match; never invent Academy content.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
claude-apianthropics/skillsReference for the Claude API / Anthropic SDK — model ids, pricing, params, streaming, tool use, MCP, agents, caching, token counting, model migration. TRIGGER — read BEFORE opening the target file; don't skip because it "looks like a one-liner" — whenever: the prompt names Claude/Anthropic in any form (Claude, Anthropic, Fable, Opus, Sonnet, Haiku, `anthropic`, `@anthropic-ai`, `claude-*`, `us.anthropic.*`, `[1m]`); the user asks about an LLM (pricing/model choice/limits/caching) — never answer from memory; OR the task is LLM-shaped with provider unstated (agent/MCP/tool-definition/multi-agent/RAG/LLM-judge/computer-use; generate/summarize/extract/classify/rewrite/converse over NL; debugging refusals/cutoffs/streaming/tool-calls/tokens). SKIP only when another provider is being worked on (overrides all triggers): OpenAI/GPT/Gemini/Llama/Mistral/Cohere/Ollama named in the query; OR `grep -rE 'openai|langchain_openai|google.generativeai|genai|mistralai|cohere|ollama'` over the project hits (run this grep FIRST if no provider named — don't Read the file).Stars: 198kUpdated Claude CodeCodexUnverifiedInstall
doc-coauthoringanthropics/skillsGuide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.Stars: 198kUpdated Claude CodeCodexVerifiedInstall