Update app.py

app.py

@@ -1,46 +1,4 @@
-def select_segments(
-    transcript_txt: str,
-    use_llm: bool,
-    num_segments: int,
-    custom_keywords: str,
-    manual_timecodes: str,
-    natural_instructions: str,
-    weight_emotion: float,
-    weight_break: float,
-    weight_learn: float,
-    weight_viral: float,
-    fps: int,
-    progress_callback=None
-) -> List[Segment]:
-
-    # 1) Manual
-    manual = parse_manual_timecodes(manual_timecodes)
-    if manual:
-        result = []
-        for start_tc, end_tc in manual:
-            try:
-                result.append(Segment(
-                    start_tc=frames_to_timecode(parse_timecode_to_frames(start_tc, fps), fps),
-                    end_tc=frames_to_timecode(parse_timecode_to_frames(end_tc, fps), fps),
-                    start_f=parse_timecode_to_frames(start_tc, fps),
-                    end_f=parse_timecode_to_frames(end_tc, fps),
-                    text=f"Manual: {start_tc} - {end_tc}",
-                    score=100.0
-                ))
-            except Exception:
-                pass
-        return result
-
-    # 2) Parser de transcrição
-    segs = parse_transcript(transcript_txt, fps) if transcript_txt else []
-
-    # 3) Linguagem natural COM IA
-    if natural_instructions.strip():
-        if use_llm and LLM_AVAILABLE and segs:
-            # USA IA PARA ANÁLISE COMPLETA
-            return ai_analyze_and_select(segs, natural_instructions, fps, progress_callback)
-        elif segs:
-            # Fallback semimport os
+import os
 import re
 import json
 import xml.etree.ElementTree as ET
@@ -51,7 +9,7 @@ import gradio as gr
 # =========================
 # Configurações Gerais
 # =========================
-DEFAULT_FPS = 24  # FPS padrão, mas será configurável na interface
+FPS = 24
 OUTPUT_DIR = "./Output"
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
@@ -92,7 +50,7 @@ class Segment:
 # =========================
 # Funções de Timecode
 # =========================
-def _tc_to_hmsf(tc: str, fps: int) -> Tuple[int, int, int, int]:
+def _tc_to_hmsf(tc: str, fps: int = FPS) -> Tuple[int, int, int, int]:
     """Converte timecode para (hh, mm, ss, ff)."""
     s = tc.strip()
 
@@ -118,12 +76,12 @@ def _tc_to_hmsf(tc: str, fps: int) -> Tuple[int, int, int, int]:
     raise ValueError(f"Timecode inválido: {tc}")
 
 
-def parse_timecode_to_frames(tc: str, fps: int) -> int:
+def parse_timecode_to_frames(tc: str, fps: int = FPS) -> int:
     hh, mm, ss, ff = _tc_to_hmsf(tc, fps)
     return hh * 3600 * fps + mm * 60 * fps + ss * fps + ff
 
 
-def frames_to_timecode(frames: int, fps: int) -> str:
+def frames_to_timecode(frames: int, fps: int = FPS) -> str:
     hh = frames // (3600 * fps)
     rem = frames % (3600 * fps)
     mm = rem // (60 * fps)
@@ -136,7 +94,7 @@ def frames_to_timecode(frames: int, fps: int) -> str:
 # =========================
 # Parser de Transcrição
 # =========================
-def parse_transcript(txt: str, fps: int) -> List[Segment]:
+def parse_transcript(txt: str) -> List[Segment]:
     """Parser robusto para múltiplos formatos."""
     if not txt or not txt.strip():
         return []
@@ -146,2049 +104,67 @@ def parse_transcript(txt: str, fps: int) -> List[Segment]:
 
     line_range = re.compile(
         r'^\s*\[?\s*(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)\s*[-—–]\s*'
-        r'(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)\s*\]?\s*(.*)
-
+        r'(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)\s*\]?\s*(.*)$'
+    )
+    arrow = re.compile(
+        r'(\d{1,2}:\d{2}:\d{2}(?:[.,]\d{1,3}|[:;]\d{2})?)\s*-->\s*'
+        r'(\d{1,2}:\d{2}:\d{2}(?:[.,]\d{1,3}|[:;]\d{2})?)'
+    )
 
-# =========================
-# Minutagens Manuais
-# =========================
-def parse_manual_timecodes(manual_input: str) -> List[Tuple[str, str]]:
-    if not manual_input or not manual_input.strip():
-        return []
+    i = 0
+    while i < len(lines):
+        raw = lines[i].strip()
+        if not raw or raw.lower() == "desconhecido":
+            i += 1
+            continue
 
-    manual_ranges = []
-    lines = manual_input.replace(",", "\n").splitlines()
-    pattern = re.compile(r'(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)\s*[-–—]\s*(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)')
-    for line in lines:
-        m = pattern.search(line.strip())
+        m = line_range.match(raw)
         if m:
-            manual_ranges.append((m.group(1), m.group(2)))
-    return manual_ranges
-
-
-# =========================
-# IA: Análise Inteligente com Gemini
-# =========================
-def ai_analyze_and_select(segments: List[Segment], command: str, fps: int, progress_callback=None) -> List[Segment]:
-    """
-    Usa Gemini para analisar a transcrição completa e identificar os melhores trechos.
-    Processo em 2 etapas para máxima precisão.
-    """
-    if not LLM_AVAILABLE or not segments:
-        raise ValueError("IA não disponível ou sem segmentos para analisar")
-    
-    if progress_callback:
-        progress_callback("🤖 Etapa 1/3: Preparando dados para análise...")
-    
-    # Prepara a transcrição completa com índices
-    transcript_data = []
-    for i, seg in enumerate(segments):
-        duration_sec = (seg.end_f - seg.start_f) / fps
-        transcript_data.append({
-            "index": i,
-            "timecode": seg.start_tc,
-            "duration_sec": round(duration_sec, 1),
-            "text": seg.text[:200]  # Limita texto para não estourar tokens
-        })
-    
-    # Converte para JSON para análise estruturada
-    transcript_json = json.dumps(transcript_data, ensure_ascii=False, indent=2)
-    
-    if progress_callback:
-        progress_callback(f"🤖 Etapa 2/3: Analisando {len(segments)} segmentos com IA (pode levar 30-60s)...")
-    
-    # Prompt detalhado para análise completa
-    prompt = f"""Você é um especialista em edição de vídeo. Analise a transcrição e identifique os MELHORES trechos baseado no comando do usuário.
-
-COMANDO DO USUÁRIO:
-{command}
-
-TRANSCRIÇÃO COMPLETA (formato JSON com index, timecode, duração e texto):
-{transcript_json}
-
-INSTRUÇÕES:
-1. Leia o comando com atenção e identifique:
-   - Quantidade de cortes desejada
-   - Duração de cada corte (em segundos)
-   - Tema/assunto/palavras-chave mencionados
-   - Timecode de início (se mencionado)
-
-2. Analise TODA a transcrição e identifique os segmentos que melhor correspondem ao comando
-
-3. Para cada corte, retorne no formato JSON:
-{{
-  "cuts": [
-    {{
-      "start_index": <índice do segmento inicial>,
-      "duration_seconds": <duração desejada em segundos>,
-      "reason": "<breve explicação de por que escolheu este trecho>"
-    }}
-  ]
-}}
-
-IMPORTANTE:
-- Seja PRECISO na identificação dos trechos
-- Considere o contexto completo ao redor das palavras-chave
-- Se o comando pedir "sobre X", encontre onde X é realmente discutido
-- Se houver timecode, priorize começar próximo a ele
-- Retorne APENAS o JSON, sem texto adicional
-
-Responda com o JSON:"""
+            start_tc, end_tc, trailing_text = m.groups()
+            text_parts = []
 
-    try:
-        response = LLM.generate_content(
-            prompt,
-            generation_config={
-                "temperature": 0.2,
-                "max_output_tokens": 2000,
-            }
-        )
-        
-        response_text = response.text.strip()
-        
-        if progress_callback:
-            progress_callback("🤖 Etapa 3/3: Processando resposta da IA...")
-        
-        # Extrai JSON da resposta
-        json_match = re.search(r'\{[\s\S]*"cuts"[\s\S]*\}', response_text)
-        if not json_match:
-            raise ValueError("IA não retornou JSON válido")
-        
-        result = json.loads(json_match.group(0))
-        cuts_data = result.get("cuts", [])
-        
-        if not cuts_data:
-            raise ValueError("IA não encontrou cortes adequados")
-        
-        # Cria os segmentos baseado na análise da IA
-        selected_segments = []
-        
-        for cut_info in cuts_data:
-            start_idx = cut_info.get("start_index", 0)
-            duration_sec = cut_info.get("duration_seconds", 60)
-            reason = cut_info.get("reason", "")
-            
-            if start_idx < 0 or start_idx >= len(segments):
-                continue
-            
-            start_seg = segments[start_idx]
-            start_frame = start_seg.start_f
-            duration_frames = int(duration_sec * fps)
-            end_frame = start_frame + duration_frames
-            
-            # Coleta texto dos segmentos envolvidos
-            text_parts = [f"[IA: {reason}]"] if reason else []
-            for seg in segments[start_idx:]:
-                if seg.start_f < end_frame:
-                    if seg.text:
-                        text_parts.append(seg.text[:150])
-                else:
-                    break
-            
-            combined_text = " [...] ".join(text_parts)[:500]
-            
-            selected_segments.append(Segment(
-                start_tc=frames_to_timecode(start_frame, fps),
-                end_tc=frames_to_timecode(end_frame, fps),
-                start_f=start_frame,
-                end_f=end_frame,
-                text=combined_text,
-                score=100.0
-            ))
-        
-        return selected_segments
-        
-    except json.JSONDecodeError as e:
-        raise ValueError(f"Erro ao processar resposta da IA (JSON inválido): {str(e)}\nResposta: {response_text[:300]}")
-    except Exception as e:
-        raise ValueError(f"Erro na análise da IA: {str(e)}")
+            if trailing_text.strip():
+                text_parts.append(trailing_text.strip())
+            else:
+                j = i + 1
+                while j < len(lines):
+                    nxt = lines[j].strip()
+                    if not nxt or line_range.match(nxt) or re.match(r'^\d+\s*$', nxt) or arrow.search(nxt):
+                        break
+                    text_parts.append(nxt)
+                    j += 1
+                i = j - 1
 
+            text = " ".join(text_parts).strip()
+            try:
+                sf = parse_timecode_to_frames(start_tc)
+                ef = parse_timecode_to_frames(end_tc)
+                if ef > sf:
+                    results.append(Segment(
+                        start_tc=frames_to_timecode(sf),
+                        end_tc=frames_to_timecode(ef),
+                        start_f=sf,
+                        end_f=ef,
+                        text=text if text else f"{start_tc} - {end_tc}",
+                        score=0.0
+                    ))
+            except Exception:
+                pass
+            i += 1
+            continue
 
-# =========================
-# Processamento com Comando Manual (sem IA)
-# =========================
-def manual_command_processing(segments: List[Segment], command: str, fps: int) -> List[Segment]:
-    """Fallback: processamento básico sem IA para comandos simples."""
-    s = command.lower()
-    
-    count = 1
-    m = re.search(r'(\d+)\s*(?:cortes?|clipes?|segmentos?)', s)
-    if m:
-        count = int(m.group(1))
-    
-    duration_sec = 60
-    m = re.search(r'(\d+)\s*(?:segundos?|s\b)', s)
-    if m:
-        duration_sec = int(m.group(1))
-    else:
-        m = re.search(r'(\d+)\s*(?:minutos?|min\b)', s)
-        if m:
-            duration_sec = int(m.group(1)) * 60
-    
-    start_frame = 0
-    m = re.search(r'(?:começando|a partir de)\s+(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)', s)
-    if m:
-        try:
-            start_frame = parse_timecode_to_frames(m.group(1), fps)
-        except:
-            pass
-    
-    results = []
-    base_frame = start_frame
-    
-    for i in range(count):
-        duration_frames = duration_sec * fps
-        end_frame = base_frame + duration_frames
-        
-        text_parts = []
-        for seg in segments:
-            if seg.start_f >= base_frame and seg.start_f < end_frame:
-                if seg.text:
-                    text_parts.append(seg.text[:100])
-        
-        combined_text = " [...] ".join(text_parts[:10])[:400]
-        
-        results.append(Segment(
-            start_tc=frames_to_timecode(base_frame, fps),
-            end_tc=frames_to_timecode(end_frame, fps),
-            start_f=base_frame,
-            end_f=end_frame,
-            text=combined_text if combined_text else f"Corte {i+1}",
-            score=50.0
-        ))
-        
-        base_frame = end_frame
-    
-    return results
-
-
-# =========================
-# Modo Automático
-# =========================
-def auto_score_segments(
-    segs: List[Segment],
-    num_segments: int,
-    custom_keywords: str,
-    weight_emotion: float,
-    weight_break: float,
-    weight_learn: float,
-    weight_viral: float
-) -> List[Segment]:
-    """Sistema de pontuação automática."""
-    emotion_words = ['medo', 'coragem', 'amor', 'ódio', 'paixão', 'alegria', 'tristeza']
-    break_words = ['nunca', 'de repente', 'surpreendente', 'inesperado', 'incrível']
-    learn_words = ['aprendi', 'descobri', 'entendi', 'percebi', 'lição']
-    viral_words = ['segredo', 'verdade', 'revelação', 'exclusivo', 'confissão']
-    
-    for s in segs:
-        score = 0.0
-        text = (s.text or "").lower()
-        
-        for word in emotion_words:
-            if word in text:
-                score += weight_emotion
-        
-        for word in break_words:
-            if word in text:
-                score += weight_break
-        
-        for word in learn_words:
-            if word in text:
-                score += weight_learn
-        
-        for word in viral_words:
-            if word in text:
-                score += weight_viral
-        
-        if custom_keywords:
-            for kw in custom_keywords.split(","):
-                kw_clean = kw.strip().lower()
-                if kw_clean and kw_clean in text:
-                    score += 5.0
-        
-        s.score = score
-    
-    segs.sort(key=lambda x: x.score, reverse=True)
-    return segs[:num_segments]
-
-
-# =========================
-# Edição de XML
-# =========================
-def deep_copy_element(elem: ET.Element) -> ET.Element:
-    new = ET.Element(elem.tag, attrib=dict(elem.attrib))
-    new.text = elem.text
-    new.tail = elem.tail
-    for child in elem:
-        new.append(deep_copy_element(child))
-    return new
-
-
-def edit_xml(tree: ET.ElementTree, segs: List[Segment]) -> ET.ElementTree:
-    root = tree.getroot()
-    seq = root.find(".//sequence")
-    if seq is None:
-        raise ValueError("Sequence não encontrada no XML")
-
-    v_track = seq.find(".//media/video/track")
-    a_track = seq.find(".//media/audio/track")
-    if not v_track or not a_track:
-        raise ValueError("Trilhas de vídeo/áudio não encontradas")
-
-    v_template = v_track.find("./clipitem")
-    a_template = a_track.find("./clipitem")
-
-    for clip in list(v_track.findall("./clipitem")):
-        v_track.remove(clip)
-    for clip in list(a_track.findall("./clipitem")):
-        a_track.remove(clip)
-
-    timeline_pos = 0
-    for i, seg in enumerate(segs, 1):
-        duration = seg.end_f - seg.start_f
-        if duration <= 0:
-            continue
-
-        v_clip = ET.Element("clipitem", {"id": f"clip-v{i}"})
-        ET.SubElement(v_clip, "name").text = f"Clip {i}"
-        ET.SubElement(v_clip, "start").text = str(timeline_pos)
-        ET.SubElement(v_clip, "end").text = str(timeline_pos + duration)
-        ET.SubElement(v_clip, "in").text = str(seg.start_f)
-        ET.SubElement(v_clip, "out").text = str(seg.end_f)
-
-        if v_template is not None:
-            rate = v_template.find("rate")
-            if rate is not None:
-                v_clip.append(deep_copy_element(rate))
-            file_elem = v_template.find("file")
-            if file_elem is not None:
-                v_clip.append(deep_copy_element(file_elem))
-
-        a_clip = ET.Element("clipitem", {"id": f"clip-a{i}"})
-        ET.SubElement(a_clip, "name").text = f"Clip {i}"
-        ET.SubElement(a_clip, "start").text = str(timeline_pos)
-        ET.SubElement(a_clip, "end").text = str(timeline_pos + duration)
-        ET.SubElement(a_clip, "in").text = str(seg.start_f)
-        ET.SubElement(a_clip, "out").text = str(seg.end_f)
-
-        if a_template is not None:
-            rate = a_template.find("rate")
-            if rate is not None:
-                a_clip.append(deep_copy_element(rate))
-            file_elem = a_template.find("file")
-            if file_elem is not None:
-                a_clip.append(deep_copy_element(file_elem))
-
-        v_track.append(v_clip)
-        a_track.append(a_clip)
-        timeline_pos += duration
-
-    return tree
-
-
-# =========================
-# Seleção (orquestração)
-# =========================
-def select_segments(
-    transcript_txt: str,
-    use_llm: bool,
-    num_segments: int,
-    custom_keywords: str,
-    manual_timecodes: str,
-    natural_instructions: str,
-    weight_emotion: float,
-    weight_break: float,
-    weight_learn: float,
-    weight_viral: float,
-    progress_callback=None
-) -> List[Segment]:
-
-    # 1) Manual
-    manual = parse_manual_timecodes(manual_timecodes)
-    if manual:
-        result = []
-        for start_tc, end_tc in manual:
-            try:
-                result.append(Segment(
-                    start_tc=frames_to_timecode(parse_timecode_to_frames(start_tc)),
-                    end_tc=frames_to_timecode(parse_timecode_to_frames(end_tc)),
-                    start_f=parse_timecode_to_frames(start_tc),
-                    end_f=parse_timecode_to_frames(end_tc),
-                    text=f"Manual: {start_tc} - {end_tc}",
-                    score=100.0
-                ))
-            except Exception:
-                pass
-        return result
-
-    # 2) Parser de transcrição
-    segs = parse_transcript(transcript_txt) if transcript_txt else []
-
-    # 3) Linguagem natural COM IA
-    if natural_instructions.strip():
-        if use_llm and LLM_AVAILABLE and segs:
-            # USA IA PARA ANÁLISE COMPLETA
-            return ai_analyze_and_select(segs, natural_instructions, progress_callback)
-        elif segs:
-            # Fallback sem IA
-            return manual_command_processing(segs, natural_instructions)
-        else:
-            raise ValueError("Para usar comandos em linguagem natural, forneça uma transcrição ou ative as minutagens manuais.")
-
-    # 4) Automático
-    if not segs:
-        raise ValueError("Nenhum segmento encontrado. Forneça uma transcrição, minutagens ou um comando em linguagem natural.")
-    return auto_score_segments(
-        segs, num_segments, custom_keywords,
-        weight_emotion, weight_break, weight_learn, weight_viral
-    )
-
-
-# =========================
-# Pipeline principal
-# =========================
-def process_files(
-    xml_file, txt_file, use_llm, num_segments,
-    custom_keywords, manual_timecodes, natural_instructions,
-    weight_emotion, weight_break, weight_learn, weight_viral,
-    progress=gr.Progress()
-):
-    if not xml_file:
-        return "⚠️ Envie o XML do Premiere", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-
-    try:
-        debug_info = []
-        
-        def progress_callback(msg):
-            progress(0.5, desc=msg)
-            debug_info.append(msg)
-        
-        progress(0.1, desc="📂 Carregando arquivos...")
-        
-        transcript = ""
-        manual = parse_manual_timecodes(manual_timecodes)
-
-        if not manual and txt_file:
-            with open(txt_file.name, "r", encoding="utf-8-sig") as f:
-                transcript = f.read()
-            debug_info.append(f"📄 Transcrição: {len(transcript)} caracteres")
-
-        progress(0.2, desc="🔍 Selecionando segmentos...")
-        
-        segments = select_segments(
-            transcript, use_llm and LLM_AVAILABLE, num_segments,
-            custom_keywords, manual_timecodes, natural_instructions,
-            weight_emotion, weight_break, weight_learn, weight_viral,
-            progress_callback
-        )
-
-        if not segments:
-            return "⚠️ Nenhum segmento selecionado", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-
-        valid_segments = []
-        for seg in segments:
-            if seg.end_f > seg.start_f and seg.end_f - seg.start_f >= FPS:
-                valid_segments.append(seg)
-        
-        if not valid_segments:
-            return "⚠️ Segmentos inválidos (duração muito curta)", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-        
-        segments = valid_segments
-        debug_info.append(f"✓ {len(segments)} segmento(s) válido(s)")
-
-        progress(0.7, desc="✂️ Editando XML...")
-        
-        tree = ET.parse(xml_file.name)
-        tree = edit_xml(tree, segments)
-
-        basename = os.path.splitext(os.path.basename(xml_file.name))[0]
-        output = os.path.join(OUTPUT_DIR, f"{basename}_EDITADO.xml")
-        tree.write(output, encoding="utf-8", xml_declaration=True)
-
-        progress(0.9, desc="📊 Gerando resumo...")
-        
-        total_sec = sum((s.end_f - s.start_f) / FPS for s in segments)
-        total_min = total_sec / 60.0
-        
-        if manual:
-            mode = "🎯 MANUAL"
-        elif natural_instructions.strip() and use_llm and LLM_AVAILABLE:
-            mode = "🤖 IA COMPLETA (Gemini)"
-        elif natural_instructions.strip():
-            mode = "📐 BÁSICO (sem IA)"
-        else:
-            mode = "⚙️ AUTOMÁTICO"
-
-        summary_lines = [
-            "═" * 70,
-            f"✨ RESULTADO: {len(segments)} corte(s) | {total_min:.1f} min total",
-            f"📊 Modo: {mode}",
-            "═" * 70,
-            ""
-        ]
-        
-        for i, seg in enumerate(segments, 1):
-            dur_sec = (seg.end_f - seg.start_f) / FPS
-            dur_min = dur_sec / 60.0
-            
-            line = f"🎬 Corte {i}:"
-            line += f"\n   ⏱️  {seg.start_tc} → {seg.end_tc} ({dur_min:.2f} min / {dur_sec:.0f}s)"
-            
-            if seg.text and len(seg.text.strip()) > 10:
-                text_preview = seg.text[:200].strip()
-                if len(seg.text) > 200:
-                    text_preview += "..."
-                line += f"\n   💬 {text_preview}"
-            
-            summary_lines.append(line)
-            summary_lines.append("")
-        
-        if debug_info:
-            summary_lines.append("═" * 70)
-            summary_lines.append("🔍 Log do Processamento:")
-            summary_lines.extend(f"   {info}" for info in debug_info)
-        
-        summary = "\n".join(summary_lines)
-        status = f"✅ Sucesso | {mode} | {total_min:.1f} min | LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-        
-        progress(1.0, desc="✅ Concluído!")
-        return summary, output, status
-
-    except Exception as e:
-        import traceback
-        error_trace = traceback.format_exc()
-        print(error_trace)
-        
-        error_msg = f"❌ Erro: {str(e)}\n\n🔍 Detalhes:\n{error_trace[:800]}"
-        return error_msg, None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-
-
-# =========================
-# Interface Gradio
-# =========================
-with gr.Blocks(theme=gr.themes.Soft(), title="Editor XML Premiere - IA") as demo:
-    gr.Markdown("# 🎬 Editor XML Premiere - IA Completa (Gemini)")
-    gr.Markdown("Sistema que **REALMENTE ENTENDE** seu comando usando análise completa com IA.")
-    
-    status_inicial = f"{'🟢 IA Gemini Ativa - Análise Completa Habilitada' if LLM_AVAILABLE else '🔴 IA Desabilitada - Configure GEMINI_API_KEY para análise inteligente'}"
-    gr.Markdown(f"**Status:** {status_inicial}")
-    
-    if LLM_AVAILABLE:
-        gr.Markdown("""
-        ### 🚀 Como funciona a IA:
-        1. **Você descreve** o que quer em linguagem natural
-        2. **IA analisa** toda a transcrição (pode levar 30-60s)
-        3. **IA identifica** os trechos exatos que correspondem ao seu pedido
-        4. **Sistema cria** os cortes precisos automaticamente
-        
-        ⚡ **Mais lento, mas MUITO mais preciso!**
-        """)
-    else:
-        gr.Markdown("""
-        ### ⚠️ IA Desabilitada
-        Configure a variável de ambiente `GEMINI_API_KEY` para ativar análise inteligente.
-        No modo básico, apenas comandos simples e timecodes manuais funcionam bem.
-        """)
-
-    with gr.Row():
-        xml_in = gr.File(label="📄 XML do Premiere", file_types=[".xml"])
-        txt_in = gr.File(label="📝 Transcrição (.txt) - OBRIGATÓRIA para IA", file_types=[".txt"])
-
-    with gr.Row():
-        use_llm = gr.Checkbox(
-            label="🤖 Usar IA Gemini (análise completa - RECOMENDADO)", 
-            value=USE_LLM_DEFAULT and LLM_AVAILABLE,
-            interactive=LLM_AVAILABLE,
-            info="Quando ativo, a IA lê TODA a transcrição e encontra os melhores trechos"
-        )
-        num_segments = gr.Slider(2, 20, 5, 1, label="📊 Segmentos (apenas modo automático)")
-
-    with gr.Accordion("💬 Comando em Linguagem Natural (MODO PRINCIPAL)", open=True):
-        gr.Markdown("""
-        ### ✨ Exemplos de comandos que a IA entende:
-        
-        **📌 Simples:**
-        - "Crie 3 cortes de 30 segundos sobre futebol"
-        - "Quero 2 clipes de 1 minuto falando sobre Maria"
-        - "Faça 5 cortes de 45s sobre o tema educação"
-        
-        **🎯 Específicos:**
-        - "1 corte de 10 minutos da parte onde ele fala sobre a infância"
-        - "3 cortes de 30s sobre os momentos engraçados"
-        - "2 clipes de 1min sobre superação e disciplina"
-        
-        **📍 Com timecode:**
-        - "Corte de 5 minutos começando em 00:02:00:00 sobre tecnologia"
-        - "3 cortes de 45s a partir de 00:10:00 falando sobre amor"
-        
-        **🔍 Busca temática:**
-        - "Os melhores momentos sobre família, cada um com 40s"
-        - "Trechos emocionantes de 1 minuto cada"
-        - "Partes onde menciona desafios e conquistas"
-        
-        ### 💡 Dicas para melhores resultados:
-        - ✅ Seja específico sobre o tema/assunto
-        - ✅ Especifique duração e quantidade
-        - ✅ Use a transcrição completa
-        - ✅ Deixe a IA trabalhar (30-60s de análise)
-        - ❌ Evite comandos vagos como "faça algo legal"
-        """)
-        natural_instructions = gr.Textbox(
-            label="Digite seu comando aqui",
-            placeholder='Ex: "Crie 3 cortes de 45 segundos sobre os momentos onde ele fala de disciplina e superação"',
-            lines=4
-        )
-
-    with gr.Accordion("🎯 Minutagens Manuais (precisão total)", open=False):
-        gr.Markdown("Use quando souber exatamente os timecodes. Ignora IA e outros modos.")
-        manual_timecodes = gr.Textbox(
-            label="Timecodes (um por linha)",
-            placeholder="00:21:18:09 - 00:31:18:09\n00:45:20:15 - 00:50:10:22",
-            lines=4
-        )
-
-    with gr.Accordion("⚙️ Modo Automático (sem comando)", open=False):
-        gr.Markdown("Sistema de pontuação simples. **Não recomendado** - use comandos em linguagem natural.")
-        custom_keywords = gr.Textbox(
-            label="Palavras-chave (separadas por vírgula)",
-            placeholder="coragem, superação, vitória"
-        )
-        with gr.Row():
-            weight_emotion = gr.Slider(0, 5, 2.0, 0.1, label="⚡ Peso: emoção")
-            weight_break = gr.Slider(0, 5, 1.5, 0.1, label="💥 Peso: quebra")
-        with gr.Row():
-            weight_learn = gr.Slider(0, 5, 1.2, 0.1, label="🎓 Peso: aprendizado")
-            weight_viral = gr.Slider(0, 5, 1.0, 0.1, label="🔥 Peso: viral")
-
-    btn = gr.Button("🚀 Processar com IA (pode levar 30-60s)", variant="primary", size="lg")
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            summary_out = gr.Textbox(label="📋 Resumo dos Cortes", lines=20, max_lines=30)
-        with gr.Column(scale=1):
-            status_out = gr.Textbox(label="📊 Status", lines=3)
-            file_out = gr.File(label="⬇️ Download XML Editado")
-
-    btn.click(
-        process_files,
-        [xml_in, txt_in, use_llm, num_segments, custom_keywords,
-         manual_timecodes, natural_instructions,
-         weight_emotion, weight_break, weight_learn, weight_viral],
-        [summary_out, file_out, status_out]
-    )
-    
-    gr.Markdown("""
----
-### 📚 Guia Rápido:
-
-**🎯 Para melhores resultados:**
-1. ✅ Envie XML + Transcrição completa
-2. ✅ Ative a IA (checkbox)
-3. ✅ Escreva comando claro e específico
-4. ✅ Aguarde 30-60s para análise completa
-5. ✅ Baixe e importe no Premiere
-
-**⚡ Ordem de prioridade:**
-1. **Minutagens Manuais** (ignora tudo, máxima precisão)
-2. **Comando + IA** (análise completa, muito preciso)
-3. **Comando sem IA** (básico, menos preciso)
-4. **Modo Automático** (não recomendado)
-
-**🔧 Troubleshooting:**
-- Erro "IA não disponível": Configure `GEMINI_API_KEY`
-- Cortes errados: Seja mais específico no comando
-- Demora muito: Normal para IA completa (30-60s)
-- Sem transcrição: Use minutagens manuais
-    """)
-
-if __name__ == "__main__":
-    demo.launch()
-    )
-    arrow = re.compile(
-        r'(\d{1,2}:\d{2}:\d{2}(?:[.,]\d{1,3}|[:;]\d{2})?)\s*-->\s*'
-        r'(\d{1,2}:\d{2}:\d{2}(?:[.,]\d{1,3}|[:;]\d{2})?)'
-    )
-
-    i = 0
-    while i < len(lines):
-        raw = lines[i].strip()
-        if not raw or raw.lower() == "desconhecido":
-            i += 1
-            continue
-
-        m = line_range.match(raw)
-        if m:
-            start_tc, end_tc, trailing_text = m.groups()
-            text_parts = []
-
-            if trailing_text.strip():
-                text_parts.append(trailing_text.strip())
-            else:
-                j = i + 1
-                while j < len(lines):
-                    nxt = lines[j].strip()
-                    if not nxt or line_range.match(nxt) or re.match(r'^\d+\s*
-
-
-# =========================
-# Minutagens Manuais
-# =========================
-def parse_manual_timecodes(manual_input: str) -> List[Tuple[str, str]]:
-    if not manual_input or not manual_input.strip():
-        return []
-
-    manual_ranges = []
-    lines = manual_input.replace(",", "\n").splitlines()
-    pattern = re.compile(r'(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)\s*[-–—]\s*(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)')
-    for line in lines:
-        m = pattern.search(line.strip())
-        if m:
-            manual_ranges.append((m.group(1), m.group(2)))
-    return manual_ranges
-
-
-# =========================
-# IA: Análise Inteligente com Gemini
-# =========================
-def ai_analyze_and_select(segments: List[Segment], command: str, progress_callback=None) -> List[Segment]:
-    """
-    Usa Gemini para analisar a transcrição completa e identificar os melhores trechos.
-    Processo em 2 etapas para máxima precisão.
-    """
-    if not LLM_AVAILABLE or not segments:
-        raise ValueError("IA não disponível ou sem segmentos para analisar")
-    
-    if progress_callback:
-        progress_callback("🤖 Etapa 1/3: Preparando dados para análise...")
-    
-    # Prepara a transcrição completa com índices
-    transcript_data = []
-    for i, seg in enumerate(segments):
-        duration_sec = (seg.end_f - seg.start_f) / FPS
-        transcript_data.append({
-            "index": i,
-            "timecode": seg.start_tc,
-            "duration_sec": round(duration_sec, 1),
-            "text": seg.text[:200]  # Limita texto para não estourar tokens
-        })
-    
-    # Converte para JSON para análise estruturada
-    transcript_json = json.dumps(transcript_data, ensure_ascii=False, indent=2)
-    
-    if progress_callback:
-        progress_callback(f"🤖 Etapa 2/3: Analisando {len(segments)} segmentos com IA (pode levar 30-60s)...")
-    
-    # Prompt detalhado para análise completa
-    prompt = f"""Você é um especialista em edição de vídeo. Analise a transcrição e identifique os MELHORES trechos baseado no comando do usuário.
-
-COMANDO DO USUÁRIO:
-{command}
-
-TRANSCRIÇÃO COMPLETA (formato JSON com index, timecode, duração e texto):
-{transcript_json}
-
-INSTRUÇÕES:
-1. Leia o comando com atenção e identifique:
-   - Quantidade de cortes desejada
-   - Duração de cada corte (em segundos)
-   - Tema/assunto/palavras-chave mencionados
-   - Timecode de início (se mencionado)
-
-2. Analise TODA a transcrição e identifique os segmentos que melhor correspondem ao comando
-
-3. Para cada corte, retorne no formato JSON:
-{{
-  "cuts": [
-    {{
-      "start_index": <índice do segmento inicial>,
-      "duration_seconds": <duração desejada em segundos>,
-      "reason": "<breve explicação de por que escolheu este trecho>"
-    }}
-  ]
-}}
-
-IMPORTANTE:
-- Seja PRECISO na identificação dos trechos
-- Considere o contexto completo ao redor das palavras-chave
-- Se o comando pedir "sobre X", encontre onde X é realmente discutido
-- Se houver timecode, priorize começar próximo a ele
-- Retorne APENAS o JSON, sem texto adicional
-
-Responda com o JSON:"""
-
-    try:
-        response = LLM.generate_content(
-            prompt,
-            generation_config={
-                "temperature": 0.2,
-                "max_output_tokens": 2000,
-            }
-        )
-        
-        response_text = response.text.strip()
-        
-        if progress_callback:
-            progress_callback("🤖 Etapa 3/3: Processando resposta da IA...")
-        
-        # Extrai JSON da resposta
-        json_match = re.search(r'\{[\s\S]*"cuts"[\s\S]*\}', response_text)
-        if not json_match:
-            raise ValueError("IA não retornou JSON válido")
-        
-        result = json.loads(json_match.group(0))
-        cuts_data = result.get("cuts", [])
-        
-        if not cuts_data:
-            raise ValueError("IA não encontrou cortes adequados")
-        
-        # Cria os segmentos baseado na análise da IA
-        selected_segments = []
-        
-        for cut_info in cuts_data:
-            start_idx = cut_info.get("start_index", 0)
-            duration_sec = cut_info.get("duration_seconds", 60)
-            reason = cut_info.get("reason", "")
-            
-            if start_idx < 0 or start_idx >= len(segments):
-                continue
-            
-            start_seg = segments[start_idx]
-            start_frame = start_seg.start_f
-            duration_frames = int(duration_sec * FPS)
-            end_frame = start_frame + duration_frames
-            
-            # Coleta texto dos segmentos envolvidos
-            text_parts = [f"[IA: {reason}]"] if reason else []
-            for seg in segments[start_idx:]:
-                if seg.start_f < end_frame:
-                    if seg.text:
-                        text_parts.append(seg.text[:150])
-                else:
-                    break
-            
-            combined_text = " [...] ".join(text_parts)[:500]
-            
-            selected_segments.append(Segment(
-                start_tc=frames_to_timecode(start_frame),
-                end_tc=frames_to_timecode(end_frame),
-                start_f=start_frame,
-                end_f=end_frame,
-                text=combined_text,
-                score=100.0
-            ))
-        
-        return selected_segments
-        
-    except json.JSONDecodeError as e:
-        raise ValueError(f"Erro ao processar resposta da IA (JSON inválido): {str(e)}\nResposta: {response_text[:300]}")
-    except Exception as e:
-        raise ValueError(f"Erro na análise da IA: {str(e)}")
-
-
-# =========================
-# Processamento com Comando Manual (sem IA)
-# =========================
-def manual_command_processing(segments: List[Segment], command: str) -> List[Segment]:
-    """
-    Fallback: processamento básico sem IA para comandos simples.
-    """
-    s = command.lower()
-    
-    # Extrai quantidade
-    count = 1
-    m = re.search(r'(\d+)\s*(?:cortes?|clipes?|segmentos?)', s)
-    if m:
-        count = int(m.group(1))
-    
-    # Extrai duração
-    duration_sec = 60
-    m = re.search(r'(\d+)\s*(?:segundos?|s\b)', s)
-    if m:
-        duration_sec = int(m.group(1))
-    else:
-        m = re.search(r'(\d+)\s*(?:minutos?|min\b)', s)
-        if m:
-            duration_sec = int(m.group(1)) * 60
-    
-    # Extrai timecode inicial
-    start_frame = 0
-    m = re.search(r'(?:começando|a partir de)\s+(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)', s)
-    if m:
-        try:
-            start_frame = parse_timecode_to_frames(m.group(1))
-        except:
-            pass
-    
-    # Cria cortes contínuos
-    results = []
-    base_frame = start_frame
-    
-    for i in range(count):
-        duration_frames = duration_sec * FPS
-        end_frame = base_frame + duration_frames
-        
-        # Coleta texto
-        text_parts = []
-        for seg in segments:
-            if seg.start_f >= base_frame and seg.start_f < end_frame:
-                if seg.text:
-                    text_parts.append(seg.text[:100])
-        
-        combined_text = " [...] ".join(text_parts[:10])[:400]
-        
-        results.append(Segment(
-            start_tc=frames_to_timecode(base_frame),
-            end_tc=frames_to_timecode(end_frame),
-            start_f=base_frame,
-            end_f=end_frame,
-            text=combined_text if combined_text else f"Corte {i+1}",
-            score=50.0
-        ))
-        
-        base_frame = end_frame
-    
-    return results
-
-
-# =========================
-# Modo Automático
-# =========================
-def auto_score_segments(
-    segs: List[Segment],
-    num_segments: int,
-    custom_keywords: str,
-    weight_emotion: float,
-    weight_break: float,
-    weight_learn: float,
-    weight_viral: float
-) -> List[Segment]:
-    """Sistema de pontuação automática."""
-    emotion_words = ['medo', 'coragem', 'amor', 'ódio', 'paixão', 'alegria', 'tristeza']
-    break_words = ['nunca', 'de repente', 'surpreendente', 'inesperado', 'incrível']
-    learn_words = ['aprendi', 'descobri', 'entendi', 'percebi', 'lição']
-    viral_words = ['segredo', 'verdade', 'revelação', 'exclusivo', 'confissão']
-    
-    for s in segs:
-        score = 0.0
-        text = (s.text or "").lower()
-        
-        for word in emotion_words:
-            if word in text:
-                score += weight_emotion
-        
-        for word in break_words:
-            if word in text:
-                score += weight_break
-        
-        for word in learn_words:
-            if word in text:
-                score += weight_learn
-        
-        for word in viral_words:
-            if word in text:
-                score += weight_viral
-        
-        if custom_keywords:
-            for kw in custom_keywords.split(","):
-                kw_clean = kw.strip().lower()
-                if kw_clean and kw_clean in text:
-                    score += 5.0
-        
-        s.score = score
-    
-    segs.sort(key=lambda x: x.score, reverse=True)
-    return segs[:num_segments]
-
-
-# =========================
-# Edição de XML
-# =========================
-def deep_copy_element(elem: ET.Element) -> ET.Element:
-    new = ET.Element(elem.tag, attrib=dict(elem.attrib))
-    new.text = elem.text
-    new.tail = elem.tail
-    for child in elem:
-        new.append(deep_copy_element(child))
-    return new
-
-
-def edit_xml(tree: ET.ElementTree, segs: List[Segment]) -> ET.ElementTree:
-    root = tree.getroot()
-    seq = root.find(".//sequence")
-    if seq is None:
-        raise ValueError("Sequence não encontrada no XML")
-
-    v_track = seq.find(".//media/video/track")
-    a_track = seq.find(".//media/audio/track")
-    if not v_track or not a_track:
-        raise ValueError("Trilhas de vídeo/áudio não encontradas")
-
-    v_template = v_track.find("./clipitem")
-    a_template = a_track.find("./clipitem")
-
-    for clip in list(v_track.findall("./clipitem")):
-        v_track.remove(clip)
-    for clip in list(a_track.findall("./clipitem")):
-        a_track.remove(clip)
-
-    timeline_pos = 0
-    for i, seg in enumerate(segs, 1):
-        duration = seg.end_f - seg.start_f
-        if duration <= 0:
-            continue
-
-        v_clip = ET.Element("clipitem", {"id": f"clip-v{i}"})
-        ET.SubElement(v_clip, "name").text = f"Clip {i}"
-        ET.SubElement(v_clip, "start").text = str(timeline_pos)
-        ET.SubElement(v_clip, "end").text = str(timeline_pos + duration)
-        ET.SubElement(v_clip, "in").text = str(seg.start_f)
-        ET.SubElement(v_clip, "out").text = str(seg.end_f)
-
-        if v_template is not None:
-            rate = v_template.find("rate")
-            if rate is not None:
-                v_clip.append(deep_copy_element(rate))
-            file_elem = v_template.find("file")
-            if file_elem is not None:
-                v_clip.append(deep_copy_element(file_elem))
-
-        a_clip = ET.Element("clipitem", {"id": f"clip-a{i}"})
-        ET.SubElement(a_clip, "name").text = f"Clip {i}"
-        ET.SubElement(a_clip, "start").text = str(timeline_pos)
-        ET.SubElement(a_clip, "end").text = str(timeline_pos + duration)
-        ET.SubElement(a_clip, "in").text = str(seg.start_f)
-        ET.SubElement(a_clip, "out").text = str(seg.end_f)
-
-        if a_template is not None:
-            rate = a_template.find("rate")
-            if rate is not None:
-                a_clip.append(deep_copy_element(rate))
-            file_elem = a_template.find("file")
-            if file_elem is not None:
-                a_clip.append(deep_copy_element(file_elem))
-
-        v_track.append(v_clip)
-        a_track.append(a_clip)
-        timeline_pos += duration
-
-    return tree
-
-
-# =========================
-# Seleção (orquestração)
-# =========================
-def select_segments(
-    transcript_txt: str,
-    use_llm: bool,
-    num_segments: int,
-    custom_keywords: str,
-    manual_timecodes: str,
-    natural_instructions: str,
-    weight_emotion: float,
-    weight_break: float,
-    weight_learn: float,
-    weight_viral: float,
-    progress_callback=None
-) -> List[Segment]:
-
-    # 1) Manual
-    manual = parse_manual_timecodes(manual_timecodes)
-    if manual:
-        result = []
-        for start_tc, end_tc in manual:
-            try:
-                result.append(Segment(
-                    start_tc=frames_to_timecode(parse_timecode_to_frames(start_tc)),
-                    end_tc=frames_to_timecode(parse_timecode_to_frames(end_tc)),
-                    start_f=parse_timecode_to_frames(start_tc),
-                    end_f=parse_timecode_to_frames(end_tc),
-                    text=f"Manual: {start_tc} - {end_tc}",
-                    score=100.0
-                ))
-            except Exception:
-                pass
-        return result
-
-    # 2) Parser de transcrição
-    segs = parse_transcript(transcript_txt) if transcript_txt else []
-
-    # 3) Linguagem natural COM IA
-    if natural_instructions.strip():
-        if use_llm and LLM_AVAILABLE and segs:
-            # USA IA PARA ANÁLISE COMPLETA
-            return ai_analyze_and_select(segs, natural_instructions, progress_callback)
-        elif segs:
-            # Fallback sem IA
-            return manual_command_processing(segs, natural_instructions)
-        else:
-            raise ValueError("Para usar comandos em linguagem natural, forneça uma transcrição ou ative as minutagens manuais.")
-
-    # 4) Automático
-    if not segs:
-        raise ValueError("Nenhum segmento encontrado. Forneça uma transcrição, minutagens ou um comando em linguagem natural.")
-    return auto_score_segments(
-        segs, num_segments, custom_keywords,
-        weight_emotion, weight_break, weight_learn, weight_viral
-    )
-
-
-# =========================
-# Pipeline principal
-# =========================
-def process_files(
-    xml_file, txt_file, use_llm, num_segments,
-    custom_keywords, manual_timecodes, natural_instructions,
-    weight_emotion, weight_break, weight_learn, weight_viral,
-    progress=gr.Progress()
-):
-    if not xml_file:
-        return "⚠️ Envie o XML do Premiere", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-
-    try:
-        debug_info = []
-        
-        def progress_callback(msg):
-            progress(0.5, desc=msg)
-            debug_info.append(msg)
-        
-        progress(0.1, desc="📂 Carregando arquivos...")
-        
-        transcript = ""
-        manual = parse_manual_timecodes(manual_timecodes)
-
-        if not manual and txt_file:
-            with open(txt_file.name, "r", encoding="utf-8-sig") as f:
-                transcript = f.read()
-            debug_info.append(f"📄 Transcrição: {len(transcript)} caracteres")
-
-        progress(0.2, desc="🔍 Selecionando segmentos...")
-        
-        segments = select_segments(
-            transcript, use_llm and LLM_AVAILABLE, num_segments,
-            custom_keywords, manual_timecodes, natural_instructions,
-            weight_emotion, weight_break, weight_learn, weight_viral,
-            progress_callback
-        )
-
-        if not segments:
-            return "⚠️ Nenhum segmento selecionado", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-
-        valid_segments = []
-        for seg in segments:
-            if seg.end_f > seg.start_f and seg.end_f - seg.start_f >= FPS:
-                valid_segments.append(seg)
-        
-        if not valid_segments:
-            return "⚠️ Segmentos inválidos (duração muito curta)", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-        
-        segments = valid_segments
-        debug_info.append(f"✓ {len(segments)} segmento(s) válido(s)")
-
-        progress(0.7, desc="✂️ Editando XML...")
-        
-        tree = ET.parse(xml_file.name)
-        tree = edit_xml(tree, segments)
-
-        basename = os.path.splitext(os.path.basename(xml_file.name))[0]
-        output = os.path.join(OUTPUT_DIR, f"{basename}_EDITADO.xml")
-        tree.write(output, encoding="utf-8", xml_declaration=True)
-
-        progress(0.9, desc="📊 Gerando resumo...")
-        
-        total_sec = sum((s.end_f - s.start_f) / FPS for s in segments)
-        total_min = total_sec / 60.0
-        
-        if manual:
-            mode = "🎯 MANUAL"
-        elif natural_instructions.strip() and use_llm and LLM_AVAILABLE:
-            mode = "🤖 IA COMPLETA (Gemini)"
-        elif natural_instructions.strip():
-            mode = "📐 BÁSICO (sem IA)"
-        else:
-            mode = "⚙️ AUTOMÁTICO"
-
-        summary_lines = [
-            "═" * 70,
-            f"✨ RESULTADO: {len(segments)} corte(s) | {total_min:.1f} min total",
-            f"📊 Modo: {mode}",
-            "═" * 70,
-            ""
-        ]
-        
-        for i, seg in enumerate(segments, 1):
-            dur_sec = (seg.end_f - seg.start_f) / FPS
-            dur_min = dur_sec / 60.0
-            
-            line = f"🎬 Corte {i}:"
-            line += f"\n   ⏱️  {seg.start_tc} → {seg.end_tc} ({dur_min:.2f} min / {dur_sec:.0f}s)"
-            
-            if seg.text and len(seg.text.strip()) > 10:
-                text_preview = seg.text[:200].strip()
-                if len(seg.text) > 200:
-                    text_preview += "..."
-                line += f"\n   💬 {text_preview}"
-            
-            summary_lines.append(line)
-            summary_lines.append("")
-        
-        if debug_info:
-            summary_lines.append("═" * 70)
-            summary_lines.append("🔍 Log do Processamento:")
-            summary_lines.extend(f"   {info}" for info in debug_info)
-        
-        summary = "\n".join(summary_lines)
-        status = f"✅ Sucesso | {mode} | {total_min:.1f} min | LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-        
-        progress(1.0, desc="✅ Concluído!")
-        return summary, output, status
-
-    except Exception as e:
-        import traceback
-        error_trace = traceback.format_exc()
-        print(error_trace)
-        
-        error_msg = f"❌ Erro: {str(e)}\n\n🔍 Detalhes:\n{error_trace[:800]}"
-        return error_msg, None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-
-
-# =========================
-# Interface Gradio
-# =========================
-with gr.Blocks(theme=gr.themes.Soft(), title="Editor XML Premiere - IA") as demo:
-    gr.Markdown("# 🎬 Editor XML Premiere - IA Completa (Gemini)")
-    gr.Markdown("Sistema que **REALMENTE ENTENDE** seu comando usando análise completa com IA.")
-    
-    status_inicial = f"{'🟢 IA Gemini Ativa - Análise Completa Habilitada' if LLM_AVAILABLE else '🔴 IA Desabilitada - Configure GEMINI_API_KEY para análise inteligente'}"
-    gr.Markdown(f"**Status:** {status_inicial}")
-    
-    if LLM_AVAILABLE:
-        gr.Markdown("""
-        ### 🚀 Como funciona a IA:
-        1. **Você descreve** o que quer em linguagem natural
-        2. **IA analisa** toda a transcrição (pode levar 30-60s)
-        3. **IA identifica** os trechos exatos que correspondem ao seu pedido
-        4. **Sistema cria** os cortes precisos automaticamente
-        
-        ⚡ **Mais lento, mas MUITO mais preciso!**
-        """)
-    else:
-        gr.Markdown("""
-        ### ⚠️ IA Desabilitada
-        Configure a variável de ambiente `GEMINI_API_KEY` para ativar análise inteligente.
-        No modo básico, apenas comandos simples e timecodes manuais funcionam bem.
-        """)
-
-    with gr.Row():
-        xml_in = gr.File(label="📄 XML do Premiere", file_types=[".xml"])
-        txt_in = gr.File(label="📝 Transcrição (.txt) - OBRIGATÓRIA para IA", file_types=[".txt"])
-
-    with gr.Row():
-        use_llm = gr.Checkbox(
-            label="🤖 Usar IA Gemini (análise completa - RECOMENDADO)", 
-            value=USE_LLM_DEFAULT and LLM_AVAILABLE,
-            interactive=LLM_AVAILABLE,
-            info="Quando ativo, a IA lê TODA a transcrição e encontra os melhores trechos"
-        )
-        num_segments = gr.Slider(2, 20, 5, 1, label="📊 Segmentos (apenas modo automático)")
-
-    with gr.Accordion("💬 Comando em Linguagem Natural (MODO PRINCIPAL)", open=True):
-        gr.Markdown("""
-        ### ✨ Exemplos de comandos que a IA entende:
-        
-        **📌 Simples:**
-        - "Crie 3 cortes de 30 segundos sobre futebol"
-        - "Quero 2 clipes de 1 minuto falando sobre Maria"
-        - "Faça 5 cortes de 45s sobre o tema educação"
-        
-        **🎯 Específicos:**
-        - "1 corte de 10 minutos da parte onde ele fala sobre a infância"
-        - "3 cortes de 30s sobre os momentos engraçados"
-        - "2 clipes de 1min sobre superação e disciplina"
-        
-        **📍 Com timecode:**
-        - "Corte de 5 minutos começando em 00:02:00:00 sobre tecnologia"
-        - "3 cortes de 45s a partir de 00:10:00 falando sobre amor"
-        
-        **🔍 Busca temática:**
-        - "Os melhores momentos sobre família, cada um com 40s"
-        - "Trechos emocionantes de 1 minuto cada"
-        - "Partes onde menciona desafios e conquistas"
-        
-        ### 💡 Dicas para melhores resultados:
-        - ✅ Seja específico sobre o tema/assunto
-        - ✅ Especifique duração e quantidade
-        - ✅ Use a transcrição completa
-        - ✅ Deixe a IA trabalhar (30-60s de análise)
-        - ❌ Evite comandos vagos como "faça algo legal"
-        """)
-        natural_instructions = gr.Textbox(
-            label="Digite seu comando aqui",
-            placeholder='Ex: "Crie 3 cortes de 45 segundos sobre os momentos onde ele fala de disciplina e superação"',
-            lines=4
-        )
-
-    with gr.Accordion("🎯 Minutagens Manuais (precisão total)", open=False):
-        gr.Markdown("Use quando souber exatamente os timecodes. Ignora IA e outros modos.")
-        manual_timecodes = gr.Textbox(
-            label="Timecodes (um por linha)",
-            placeholder="00:21:18:09 - 00:31:18:09\n00:45:20:15 - 00:50:10:22",
-            lines=4
-        )
-
-    with gr.Accordion("⚙️ Modo Automático (sem comando)", open=False):
-        gr.Markdown("Sistema de pontuação simples. **Não recomendado** - use comandos em linguagem natural.")
-        custom_keywords = gr.Textbox(
-            label="Palavras-chave (separadas por vírgula)",
-            placeholder="coragem, superação, vitória"
-        )
-        with gr.Row():
-            weight_emotion = gr.Slider(0, 5, 2.0, 0.1, label="⚡ Peso: emoção")
-            weight_break = gr.Slider(0, 5, 1.5, 0.1, label="💥 Peso: quebra")
-        with gr.Row():
-            weight_learn = gr.Slider(0, 5, 1.2, 0.1, label="🎓 Peso: aprendizado")
-            weight_viral = gr.Slider(0, 5, 1.0, 0.1, label="🔥 Peso: viral")
-
-    btn = gr.Button("🚀 Processar com IA (pode levar 30-60s)", variant="primary", size="lg")
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            summary_out = gr.Textbox(label="📋 Resumo dos Cortes", lines=20, max_lines=30)
-        with gr.Column(scale=1):
-            status_out = gr.Textbox(label="📊 Status", lines=3)
-            file_out = gr.File(label="⬇️ Download XML Editado")
-
-    btn.click(
-        process_files,
-        [xml_in, txt_in, use_llm, num_segments, custom_keywords,
-         manual_timecodes, natural_instructions,
-         weight_emotion, weight_break, weight_learn, weight_viral],
-        [summary_out, file_out, status_out]
-    )
-    
-    gr.Markdown("""
----
-### 📚 Guia Rápido:
-
-**🎯 Para melhores resultados:**
-1. ✅ Envie XML + Transcrição completa
-2. ✅ Ative a IA (checkbox)
-3. ✅ Escreva comando claro e específico
-4. ✅ Aguarde 30-60s para análise completa
-5. ✅ Baixe e importe no Premiere
-
-**⚡ Ordem de prioridade:**
-1. **Minutagens Manuais** (ignora tudo, máxima precisão)
-2. **Comando + IA** (análise completa, muito preciso)
-3. **Comando sem IA** (básico, menos preciso)
-4. **Modo Automático** (não recomendado)
-
-**🔧 Troubleshooting:**
-- Erro "IA não disponível": Configure `GEMINI_API_KEY`
-- Cortes errados: Seja mais específico no comando
-- Demora muito: Normal para IA completa (30-60s)
-- Sem transcrição: Use minutagens manuais
-    """)
-
-if __name__ == "__main__":
-    demo.launch(), nxt) or arrow.search(nxt):
-                        break
-                    text_parts.append(nxt)
-                    j += 1
-                i = j - 1
-
-            text = " ".join(text_parts).strip()
-            try:
-                sf = parse_timecode_to_frames(start_tc, fps)
-                ef = parse_timecode_to_frames(end_tc, fps)
-                if ef > sf:
-                    results.append(Segment(
-                        start_tc=frames_to_timecode(sf, fps),
-                        end_tc=frames_to_timecode(ef, fps),
-                        start_f=sf,
-                        end_f=ef,
-                        text=text if text else f"{start_tc} - {end_tc}",
-                        score=0.0
-                    ))
-            except Exception:
-                pass
-            i += 1
-            continue
-
-        if arrow.search(raw) or (i + 1 < len(lines) and arrow.search(lines[i + 1])):
-            line_with_tc = raw if arrow.search(raw) else lines[i + 1]
-            mm = arrow.search(line_with_tc)
-            if mm:
-                start_tc, end_tc = mm.groups()
-                j = i + 1 if line_with_tc == raw else i + 2
-                text_parts = []
-                while j < len(lines):
-                    nxt = lines[j].strip()
-                    if not nxt:
-                        break
-                    if re.match(r'^\d+\s*
-
-
-# =========================
-# Minutagens Manuais
-# =========================
-def parse_manual_timecodes(manual_input: str) -> List[Tuple[str, str]]:
-    if not manual_input or not manual_input.strip():
-        return []
-
-    manual_ranges = []
-    lines = manual_input.replace(",", "\n").splitlines()
-    pattern = re.compile(r'(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)\s*[-–—]\s*(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)')
-    for line in lines:
-        m = pattern.search(line.strip())
-        if m:
-            manual_ranges.append((m.group(1), m.group(2)))
-    return manual_ranges
-
-
-# =========================
-# IA: Análise Inteligente com Gemini
-# =========================
-def ai_analyze_and_select(segments: List[Segment], command: str, progress_callback=None) -> List[Segment]:
-    """
-    Usa Gemini para analisar a transcrição completa e identificar os melhores trechos.
-    Processo em 2 etapas para máxima precisão.
-    """
-    if not LLM_AVAILABLE or not segments:
-        raise ValueError("IA não disponível ou sem segmentos para analisar")
-    
-    if progress_callback:
-        progress_callback("🤖 Etapa 1/3: Preparando dados para análise...")
-    
-    # Prepara a transcrição completa com índices
-    transcript_data = []
-    for i, seg in enumerate(segments):
-        duration_sec = (seg.end_f - seg.start_f) / FPS
-        transcript_data.append({
-            "index": i,
-            "timecode": seg.start_tc,
-            "duration_sec": round(duration_sec, 1),
-            "text": seg.text[:200]  # Limita texto para não estourar tokens
-        })
-    
-    # Converte para JSON para análise estruturada
-    transcript_json = json.dumps(transcript_data, ensure_ascii=False, indent=2)
-    
-    if progress_callback:
-        progress_callback(f"🤖 Etapa 2/3: Analisando {len(segments)} segmentos com IA (pode levar 30-60s)...")
-    
-    # Prompt detalhado para análise completa
-    prompt = f"""Você é um especialista em edição de vídeo. Analise a transcrição e identifique os MELHORES trechos baseado no comando do usuário.
-
-COMANDO DO USUÁRIO:
-{command}
-
-TRANSCRIÇÃO COMPLETA (formato JSON com index, timecode, duração e texto):
-{transcript_json}
-
-INSTRUÇÕES:
-1. Leia o comando com atenção e identifique:
-   - Quantidade de cortes desejada
-   - Duração de cada corte (em segundos)
-   - Tema/assunto/palavras-chave mencionados
-   - Timecode de início (se mencionado)
-
-2. Analise TODA a transcrição e identifique os segmentos que melhor correspondem ao comando
-
-3. Para cada corte, retorne no formato JSON:
-{{
-  "cuts": [
-    {{
-      "start_index": <índice do segmento inicial>,
-      "duration_seconds": <duração desejada em segundos>,
-      "reason": "<breve explicação de por que escolheu este trecho>"
-    }}
-  ]
-}}
-
-IMPORTANTE:
-- Seja PRECISO na identificação dos trechos
-- Considere o contexto completo ao redor das palavras-chave
-- Se o comando pedir "sobre X", encontre onde X é realmente discutido
-- Se houver timecode, priorize começar próximo a ele
-- Retorne APENAS o JSON, sem texto adicional
-
-Responda com o JSON:"""
-
-    try:
-        response = LLM.generate_content(
-            prompt,
-            generation_config={
-                "temperature": 0.2,
-                "max_output_tokens": 2000,
-            }
-        )
-        
-        response_text = response.text.strip()
-        
-        if progress_callback:
-            progress_callback("🤖 Etapa 3/3: Processando resposta da IA...")
-        
-        # Extrai JSON da resposta
-        json_match = re.search(r'\{[\s\S]*"cuts"[\s\S]*\}', response_text)
-        if not json_match:
-            raise ValueError("IA não retornou JSON válido")
-        
-        result = json.loads(json_match.group(0))
-        cuts_data = result.get("cuts", [])
-        
-        if not cuts_data:
-            raise ValueError("IA não encontrou cortes adequados")
-        
-        # Cria os segmentos baseado na análise da IA
-        selected_segments = []
-        
-        for cut_info in cuts_data:
-            start_idx = cut_info.get("start_index", 0)
-            duration_sec = cut_info.get("duration_seconds", 60)
-            reason = cut_info.get("reason", "")
-            
-            if start_idx < 0 or start_idx >= len(segments):
-                continue
-            
-            start_seg = segments[start_idx]
-            start_frame = start_seg.start_f
-            duration_frames = int(duration_sec * FPS)
-            end_frame = start_frame + duration_frames
-            
-            # Coleta texto dos segmentos envolvidos
-            text_parts = [f"[IA: {reason}]"] if reason else []
-            for seg in segments[start_idx:]:
-                if seg.start_f < end_frame:
-                    if seg.text:
-                        text_parts.append(seg.text[:150])
-                else:
-                    break
-            
-            combined_text = " [...] ".join(text_parts)[:500]
-            
-            selected_segments.append(Segment(
-                start_tc=frames_to_timecode(start_frame),
-                end_tc=frames_to_timecode(end_frame),
-                start_f=start_frame,
-                end_f=end_frame,
-                text=combined_text,
-                score=100.0
-            ))
-        
-        return selected_segments
-        
-    except json.JSONDecodeError as e:
-        raise ValueError(f"Erro ao processar resposta da IA (JSON inválido): {str(e)}\nResposta: {response_text[:300]}")
-    except Exception as e:
-        raise ValueError(f"Erro na análise da IA: {str(e)}")
-
-
-# =========================
-# Processamento com Comando Manual (sem IA)
-# =========================
-def manual_command_processing(segments: List[Segment], command: str) -> List[Segment]:
-    """
-    Fallback: processamento básico sem IA para comandos simples.
-    """
-    s = command.lower()
-    
-    # Extrai quantidade
-    count = 1
-    m = re.search(r'(\d+)\s*(?:cortes?|clipes?|segmentos?)', s)
-    if m:
-        count = int(m.group(1))
-    
-    # Extrai duração
-    duration_sec = 60
-    m = re.search(r'(\d+)\s*(?:segundos?|s\b)', s)
-    if m:
-        duration_sec = int(m.group(1))
-    else:
-        m = re.search(r'(\d+)\s*(?:minutos?|min\b)', s)
-        if m:
-            duration_sec = int(m.group(1)) * 60
-    
-    # Extrai timecode inicial
-    start_frame = 0
-    m = re.search(r'(?:começando|a partir de)\s+(\d{1,2}:\d{2}:\d{2}(?:[:;]\d{2}|[.,]\d{1,3})?)', s)
-    if m:
-        try:
-            start_frame = parse_timecode_to_frames(m.group(1))
-        except:
-            pass
-    
-    # Cria cortes contínuos
-    results = []
-    base_frame = start_frame
-    
-    for i in range(count):
-        duration_frames = duration_sec * FPS
-        end_frame = base_frame + duration_frames
-        
-        # Coleta texto
-        text_parts = []
-        for seg in segments:
-            if seg.start_f >= base_frame and seg.start_f < end_frame:
-                if seg.text:
-                    text_parts.append(seg.text[:100])
-        
-        combined_text = " [...] ".join(text_parts[:10])[:400]
-        
-        results.append(Segment(
-            start_tc=frames_to_timecode(base_frame),
-            end_tc=frames_to_timecode(end_frame),
-            start_f=base_frame,
-            end_f=end_frame,
-            text=combined_text if combined_text else f"Corte {i+1}",
-            score=50.0
-        ))
-        
-        base_frame = end_frame
-    
-    return results
-
-
-# =========================
-# Modo Automático
-# =========================
-def auto_score_segments(
-    segs: List[Segment],
-    num_segments: int,
-    custom_keywords: str,
-    weight_emotion: float,
-    weight_break: float,
-    weight_learn: float,
-    weight_viral: float
-) -> List[Segment]:
-    """Sistema de pontuação automática."""
-    emotion_words = ['medo', 'coragem', 'amor', 'ódio', 'paixão', 'alegria', 'tristeza']
-    break_words = ['nunca', 'de repente', 'surpreendente', 'inesperado', 'incrível']
-    learn_words = ['aprendi', 'descobri', 'entendi', 'percebi', 'lição']
-    viral_words = ['segredo', 'verdade', 'revelação', 'exclusivo', 'confissão']
-    
-    for s in segs:
-        score = 0.0
-        text = (s.text or "").lower()
-        
-        for word in emotion_words:
-            if word in text:
-                score += weight_emotion
-        
-        for word in break_words:
-            if word in text:
-                score += weight_break
-        
-        for word in learn_words:
-            if word in text:
-                score += weight_learn
-        
-        for word in viral_words:
-            if word in text:
-                score += weight_viral
-        
-        if custom_keywords:
-            for kw in custom_keywords.split(","):
-                kw_clean = kw.strip().lower()
-                if kw_clean and kw_clean in text:
-                    score += 5.0
-        
-        s.score = score
-    
-    segs.sort(key=lambda x: x.score, reverse=True)
-    return segs[:num_segments]
-
-
-# =========================
-# Edição de XML
-# =========================
-def deep_copy_element(elem: ET.Element) -> ET.Element:
-    new = ET.Element(elem.tag, attrib=dict(elem.attrib))
-    new.text = elem.text
-    new.tail = elem.tail
-    for child in elem:
-        new.append(deep_copy_element(child))
-    return new
-
-
-def edit_xml(tree: ET.ElementTree, segs: List[Segment]) -> ET.ElementTree:
-    root = tree.getroot()
-    seq = root.find(".//sequence")
-    if seq is None:
-        raise ValueError("Sequence não encontrada no XML")
-
-    v_track = seq.find(".//media/video/track")
-    a_track = seq.find(".//media/audio/track")
-    if not v_track or not a_track:
-        raise ValueError("Trilhas de vídeo/áudio não encontradas")
-
-    v_template = v_track.find("./clipitem")
-    a_template = a_track.find("./clipitem")
-
-    for clip in list(v_track.findall("./clipitem")):
-        v_track.remove(clip)
-    for clip in list(a_track.findall("./clipitem")):
-        a_track.remove(clip)
-
-    timeline_pos = 0
-    for i, seg in enumerate(segs, 1):
-        duration = seg.end_f - seg.start_f
-        if duration <= 0:
-            continue
-
-        v_clip = ET.Element("clipitem", {"id": f"clip-v{i}"})
-        ET.SubElement(v_clip, "name").text = f"Clip {i}"
-        ET.SubElement(v_clip, "start").text = str(timeline_pos)
-        ET.SubElement(v_clip, "end").text = str(timeline_pos + duration)
-        ET.SubElement(v_clip, "in").text = str(seg.start_f)
-        ET.SubElement(v_clip, "out").text = str(seg.end_f)
-
-        if v_template is not None:
-            rate = v_template.find("rate")
-            if rate is not None:
-                v_clip.append(deep_copy_element(rate))
-            file_elem = v_template.find("file")
-            if file_elem is not None:
-                v_clip.append(deep_copy_element(file_elem))
-
-        a_clip = ET.Element("clipitem", {"id": f"clip-a{i}"})
-        ET.SubElement(a_clip, "name").text = f"Clip {i}"
-        ET.SubElement(a_clip, "start").text = str(timeline_pos)
-        ET.SubElement(a_clip, "end").text = str(timeline_pos + duration)
-        ET.SubElement(a_clip, "in").text = str(seg.start_f)
-        ET.SubElement(a_clip, "out").text = str(seg.end_f)
-
-        if a_template is not None:
-            rate = a_template.find("rate")
-            if rate is not None:
-                a_clip.append(deep_copy_element(rate))
-            file_elem = a_template.find("file")
-            if file_elem is not None:
-                a_clip.append(deep_copy_element(file_elem))
-
-        v_track.append(v_clip)
-        a_track.append(a_clip)
-        timeline_pos += duration
-
-    return tree
-
-
-# =========================
-# Seleção (orquestração)
-# =========================
-def select_segments(
-    transcript_txt: str,
-    use_llm: bool,
-    num_segments: int,
-    custom_keywords: str,
-    manual_timecodes: str,
-    natural_instructions: str,
-    weight_emotion: float,
-    weight_break: float,
-    weight_learn: float,
-    weight_viral: float,
-    progress_callback=None
-) -> List[Segment]:
-
-    # 1) Manual
-    manual = parse_manual_timecodes(manual_timecodes)
-    if manual:
-        result = []
-        for start_tc, end_tc in manual:
-            try:
-                result.append(Segment(
-                    start_tc=frames_to_timecode(parse_timecode_to_frames(start_tc)),
-                    end_tc=frames_to_timecode(parse_timecode_to_frames(end_tc)),
-                    start_f=parse_timecode_to_frames(start_tc),
-                    end_f=parse_timecode_to_frames(end_tc),
-                    text=f"Manual: {start_tc} - {end_tc}",
-                    score=100.0
-                ))
-            except Exception:
-                pass
-        return result
-
-    # 2) Parser de transcrição
-    segs = parse_transcript(transcript_txt) if transcript_txt else []
-
-    # 3) Linguagem natural COM IA
-    if natural_instructions.strip():
-        if use_llm and LLM_AVAILABLE and segs:
-            # USA IA PARA ANÁLISE COMPLETA
-            return ai_analyze_and_select(segs, natural_instructions, progress_callback)
-        elif segs:
-            # Fallback sem IA
-            return manual_command_processing(segs, natural_instructions)
-        else:
-            raise ValueError("Para usar comandos em linguagem natural, forneça uma transcrição ou ative as minutagens manuais.")
-
-    # 4) Automático
-    if not segs:
-        raise ValueError("Nenhum segmento encontrado. Forneça uma transcrição, minutagens ou um comando em linguagem natural.")
-    return auto_score_segments(
-        segs, num_segments, custom_keywords,
-        weight_emotion, weight_break, weight_learn, weight_viral
-    )
-
-
-# =========================
-# Pipeline principal
-# =========================
-def process_files(
-    xml_file, txt_file, use_llm, num_segments,
-    custom_keywords, manual_timecodes, natural_instructions,
-    weight_emotion, weight_break, weight_learn, weight_viral,
-    progress=gr.Progress()
-):
-    if not xml_file:
-        return "⚠️ Envie o XML do Premiere", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-
-    try:
-        debug_info = []
-        
-        def progress_callback(msg):
-            progress(0.5, desc=msg)
-            debug_info.append(msg)
-        
-        progress(0.1, desc="📂 Carregando arquivos...")
-        
-        transcript = ""
-        manual = parse_manual_timecodes(manual_timecodes)
-
-        if not manual and txt_file:
-            with open(txt_file.name, "r", encoding="utf-8-sig") as f:
-                transcript = f.read()
-            debug_info.append(f"📄 Transcrição: {len(transcript)} caracteres")
-
-        progress(0.2, desc="🔍 Selecionando segmentos...")
-        
-        segments = select_segments(
-            transcript, use_llm and LLM_AVAILABLE, num_segments,
-            custom_keywords, manual_timecodes, natural_instructions,
-            weight_emotion, weight_break, weight_learn, weight_viral,
-            progress_callback
-        )
-
-        if not segments:
-            return "⚠️ Nenhum segmento selecionado", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-
-        valid_segments = []
-        for seg in segments:
-            if seg.end_f > seg.start_f and seg.end_f - seg.start_f >= FPS:
-                valid_segments.append(seg)
-        
-        if not valid_segments:
-            return "⚠️ Segmentos inválidos (duração muito curta)", None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-        
-        segments = valid_segments
-        debug_info.append(f"✓ {len(segments)} segmento(s) válido(s)")
-
-        progress(0.7, desc="✂️ Editando XML...")
-        
-        tree = ET.parse(xml_file.name)
-        tree = edit_xml(tree, segments)
-
-        basename = os.path.splitext(os.path.basename(xml_file.name))[0]
-        output = os.path.join(OUTPUT_DIR, f"{basename}_EDITADO.xml")
-        tree.write(output, encoding="utf-8", xml_declaration=True)
-
-        progress(0.9, desc="📊 Gerando resumo...")
-        
-        total_sec = sum((s.end_f - s.start_f) / FPS for s in segments)
-        total_min = total_sec / 60.0
-        
-        if manual:
-            mode = "🎯 MANUAL"
-        elif natural_instructions.strip() and use_llm and LLM_AVAILABLE:
-            mode = "🤖 IA COMPLETA (Gemini)"
-        elif natural_instructions.strip():
-            mode = "📐 BÁSICO (sem IA)"
-        else:
-            mode = "⚙️ AUTOMÁTICO"
-
-        summary_lines = [
-            "═" * 70,
-            f"✨ RESULTADO: {len(segments)} corte(s) | {total_min:.1f} min total",
-            f"📊 Modo: {mode}",
-            "═" * 70,
-            ""
-        ]
-        
-        for i, seg in enumerate(segments, 1):
-            dur_sec = (seg.end_f - seg.start_f) / FPS
-            dur_min = dur_sec / 60.0
-            
-            line = f"🎬 Corte {i}:"
-            line += f"\n   ⏱️  {seg.start_tc} → {seg.end_tc} ({dur_min:.2f} min / {dur_sec:.0f}s)"
-            
-            if seg.text and len(seg.text.strip()) > 10:
-                text_preview = seg.text[:200].strip()
-                if len(seg.text) > 200:
-                    text_preview += "..."
-                line += f"\n   💬 {text_preview}"
-            
-            summary_lines.append(line)
-            summary_lines.append("")
-        
-        if debug_info:
-            summary_lines.append("═" * 70)
-            summary_lines.append("🔍 Log do Processamento:")
-            summary_lines.extend(f"   {info}" for info in debug_info)
-        
-        summary = "\n".join(summary_lines)
-        status = f"✅ Sucesso | {mode} | {total_min:.1f} min | LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-        
-        progress(1.0, desc="✅ Concluído!")
-        return summary, output, status
-
-    except Exception as e:
-        import traceback
-        error_trace = traceback.format_exc()
-        print(error_trace)
-        
-        error_msg = f"❌ Erro: {str(e)}\n\n🔍 Detalhes:\n{error_trace[:800]}"
-        return error_msg, None, f"LLM: {'✓' if LLM_AVAILABLE else '✗'}"
-
-
-# =========================
-# Interface Gradio
-# =========================
-with gr.Blocks(theme=gr.themes.Soft(), title="Editor XML Premiere - IA") as demo:
-    gr.Markdown("# 🎬 Editor XML Premiere - IA Completa (Gemini)")
-    gr.Markdown("Sistema que **REALMENTE ENTENDE** seu comando usando análise completa com IA.")
-    
-    status_inicial = f"{'🟢 IA Gemini Ativa - Análise Completa Habilitada' if LLM_AVAILABLE else '🔴 IA Desabilitada - Configure GEMINI_API_KEY para análise inteligente'}"
-    gr.Markdown(f"**Status:** {status_inicial}")
-    
-    if LLM_AVAILABLE:
-        gr.Markdown("""
-        ### 🚀 Como funciona a IA:
-        1. **Você descreve** o que quer em linguagem natural
-        2. **IA analisa** toda a transcrição (pode levar 30-60s)
-        3. **IA identifica** os trechos exatos que correspondem ao seu pedido
-        4. **Sistema cria** os cortes precisos automaticamente
-        
-        ⚡ **Mais lento, mas MUITO mais preciso!**
-        """)
-    else:
-        gr.Markdown("""
-        ### ⚠️ IA Desabilitada
-        Configure a variável de ambiente `GEMINI_API_KEY` para ativar análise inteligente.
-        No modo básico, apenas comandos simples e timecodes manuais funcionam bem.
-        """)
-
-    with gr.Row():
-        xml_in = gr.File(label="📄 XML do Premiere", file_types=[".xml"])
-        txt_in = gr.File(label="📝 Transcrição (.txt) - OBRIGATÓRIA para IA", file_types=[".txt"])
-
-    with gr.Row():
-        use_llm = gr.Checkbox(
-            label="🤖 Usar IA Gemini (análise completa - RECOMENDADO)", 
-            value=USE_LLM_DEFAULT and LLM_AVAILABLE,
-            interactive=LLM_AVAILABLE,
-            info="Quando ativo, a IA lê TODA a transcrição e encontra os melhores trechos"
-        )
-        num_segments = gr.Slider(2, 20, 5, 1, label="📊 Segmentos (apenas modo automático)")
-
-    with gr.Accordion("💬 Comando em Linguagem Natural (MODO PRINCIPAL)", open=True):
-        gr.Markdown("""
-        ### ✨ Exemplos de comandos que a IA entende:
-        
-        **📌 Simples:**
-        - "Crie 3 cortes de 30 segundos sobre futebol"
-        - "Quero 2 clipes de 1 minuto falando sobre Maria"
-        - "Faça 5 cortes de 45s sobre o tema educação"
-        
-        **🎯 Específicos:**
-        - "1 corte de 10 minutos da parte onde ele fala sobre a infância"
-        - "3 cortes de 30s sobre os momentos engraçados"
-        - "2 clipes de 1min sobre superação e disciplina"
-        
-        **📍 Com timecode:**
-        - "Corte de 5 minutos começando em 00:02:00:00 sobre tecnologia"
-        - "3 cortes de 45s a partir de 00:10:00 falando sobre amor"
-        
-        **🔍 Busca temática:**
-        - "Os melhores momentos sobre família, cada um com 40s"
-        - "Trechos emocionantes de 1 minuto cada"
-        - "Partes onde menciona desafios e conquistas"
-        
-        ### 💡 Dicas para melhores resultados:
-        - ✅ Seja específico sobre o tema/assunto
-        - ✅ Especifique duração e quantidade
-        - ✅ Use a transcrição completa
-        - ✅ Deixe a IA trabalhar (30-60s de análise)
-        - ❌ Evite comandos vagos como "faça algo legal"
-        """)
-        natural_instructions = gr.Textbox(
-            label="Digite seu comando aqui",
-            placeholder='Ex: "Crie 3 cortes de 45 segundos sobre os momentos onde ele fala de disciplina e superação"',
-            lines=4
-        )
-
-    with gr.Accordion("🎯 Minutagens Manuais (precisão total)", open=False):
-        gr.Markdown("Use quando souber exatamente os timecodes. Ignora IA e outros modos.")
-        manual_timecodes = gr.Textbox(
-            label="Timecodes (um por linha)",
-            placeholder="00:21:18:09 - 00:31:18:09\n00:45:20:15 - 00:50:10:22",
-            lines=4
-        )
-
-    with gr.Accordion("⚙️ Modo Automático (sem comando)", open=False):
-        gr.Markdown("Sistema de pontuação simples. **Não recomendado** - use comandos em linguagem natural.")
-        custom_keywords = gr.Textbox(
-            label="Palavras-chave (separadas por vírgula)",
-            placeholder="coragem, superação, vitória"
-        )
-        with gr.Row():
-            weight_emotion = gr.Slider(0, 5, 2.0, 0.1, label="⚡ Peso: emoção")
-            weight_break = gr.Slider(0, 5, 1.5, 0.1, label="💥 Peso: quebra")
-        with gr.Row():
-            weight_learn = gr.Slider(0, 5, 1.2, 0.1, label="🎓 Peso: aprendizado")
-            weight_viral = gr.Slider(0, 5, 1.0, 0.1, label="🔥 Peso: viral")
-
-    btn = gr.Button("🚀 Processar com IA (pode levar 30-60s)", variant="primary", size="lg")
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            summary_out = gr.Textbox(label="📋 Resumo dos Cortes", lines=20, max_lines=30)
-        with gr.Column(scale=1):
-            status_out = gr.Textbox(label="📊 Status", lines=3)
-            file_out = gr.File(label="⬇️ Download XML Editado")
-
-    btn.click(
-        process_files,
-        [xml_in, txt_in, use_llm, num_segments, custom_keywords,
-         manual_timecodes, natural_instructions,
-         weight_emotion, weight_break, weight_learn, weight_viral],
-        [summary_out, file_out, status_out]
-    )
-    
-    gr.Markdown("""
----
-### 📚 Guia Rápido:
-
-**🎯 Para melhores resultados:**
-1. ✅ Envie XML + Transcrição completa
-2. ✅ Ative a IA (checkbox)
-3. ✅ Escreva comando claro e específico
-4. ✅ Aguarde 30-60s para análise completa
-5. ✅ Baixe e importe no Premiere
-
-**⚡ Ordem de prioridade:**
-1. **Minutagens Manuais** (ignora tudo, máxima precisão)
-2. **Comando + IA** (análise completa, muito preciso)
-3. **Comando sem IA** (básico, menos preciso)
-4. **Modo Automático** (não recomendado)
-
-**🔧 Troubleshooting:**
-- Erro "IA não disponível": Configure `GEMINI_API_KEY`
-- Cortes errados: Seja mais específico no comando
-- Demora muito: Normal para IA completa (30-60s)
-- Sem transcrição: Use minutagens manuais
-    """)
-
-if __name__ == "__main__":
-    demo.launch(), nxt) and (j + 1 < len(lines) and arrow.search(lines[j + 1])):
+        if arrow.search(raw) or (i + 1 < len(lines) and arrow.search(lines[i + 1])):
+            line_with_tc = raw if arrow.search(raw) else lines[i + 1]
+            mm = arrow.search(line_with_tc)
+            if mm:
+                start_tc, end_tc = mm.groups()
+                j = i + 1 if line_with_tc == raw else i + 2
+                text_parts = []
+                while j < len(lines):
+                    nxt = lines[j].strip()
+                    if not nxt:
+                        break
+                    if re.match(r'^\d+\s*$', nxt) and (j + 1 < len(lines) and arrow.search(lines[j + 1])):
                         break
                     if arrow.search(nxt):
                         break
@@ -2197,12 +173,12 @@ if __name__ == "__main__":
 
                 text = " ".join(text_parts).strip()
                 try:
-                    sf = parse_timecode_to_frames(start_tc, fps)
-                    ef = parse_timecode_to_frames(end_tc, fps)
+                    sf = parse_timecode_to_frames(start_tc)
+                    ef = parse_timecode_to_frames(end_tc)
                     if ef > sf:
                         results.append(Segment(
-                            start_tc=frames_to_timecode(sf, fps),
-                            end_tc=frames_to_timecode(ef, fps),
+                            start_tc=frames_to_timecode(sf),
+                            end_tc=frames_to_timecode(ef),
                             start_f=sf,
                             end_f=ef,
                             text=text,