487 lines
17 KiB
Python
487 lines
17 KiB
Python
#!/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()
|