Update app.py

app.py

@@ -1,5 +1,5 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║             PIPELINE v29: ANÁLISE EPISTÊMICA (COM LÓGICA REAL PYPDF)       ║
+# ║             PIPELINE v31: FRAGMENTAÇÃO, TRANSCRIÇÃO (LOOP) E CATALOGAÇÃO   ║
 # ║        Layout: Chat (Aba 1) | Debug (Aba 2) | Config (Aba 3)               ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
@@ -10,7 +10,7 @@ import time
 from datetime import datetime
 import gradio as gr
 import google.generativeai as genai
-import pypdf # <--- BIBLIOTECA NECESSÁRIA AGORA
+import pypdf # Usando pypdf para a lógica de fragmentação real.
 
 # ==================== 1. CONFIGURAÇÃO ====================
 api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
@@ -19,36 +19,32 @@ if api_key: genai.configure(api_key=api_key)
 model_flash = genai.GenerativeModel("gemini-flash-latest")
 model_pro   = genai.GenerativeModel("gemini-pro-latest")
 
-# Usando o nome do protocolo de análise epistêmica
-ARQUIVO_CONFIG = "protocolo_epistemico_forense.json"
+# **ATUALIZAÇÃO: Novo protocolo de fragmentação/catalogação**
+ARQUIVO_CONFIG = "protocolo_fragmentacao_transcricao.json"
 
 # ==================== 2. UTILIDADES ====================
 
 def carregar_protocolo():
     try:
+        # Tenta carregar o protocolo que está sendo usado
         with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f: return f.read()
     except: return "[]"
 
 def salvar_protocolo(conteudo):
     try:
         json.loads(conteudo)
-        # Assumindo que o Gradio salva como 'protocolo.json'
         with open("protocolo.json", "w", encoding="utf-8") as f: f.write(conteudo) 
         return "✅ Salvo"
     except: return "❌ Erro JSON"
 
 # **FUNÇÃO REAL: Lógica de Fragmentação de PDF com pypdf**
 def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
-    """Lê o anexo. Se for PDF, usa pypdf para dividir em fragmentos de X páginas. 
-       Se for TXT/Outro, retorna o texto completo em uma lista de 1 fragmento."""
+    """Lê o anexo. Se for PDF, usa pypdf para dividir em fragmentos de X páginas."""
     if arquivo is None: return [], ""
     filename = arquivo.name
-    anexo_info = f"\n\n[ANEXO SISTEMA: {os.path.basename(filename)}]\n"
+    anexo_info = f"[ANEXO SISTEMA: {os.path.basename(filename)}]"
     
-    # Lógica REAL para PDF
     if filename.lower().endswith(".pdf"):
-        print(f"DEBUG: Arquivo PDF detectado. Iniciando fragmentação de {paginas_por_fragmento} páginas.")
-        
         fragments = []
         try:
             reader = pypdf.PdfReader(filename)
@@ -60,19 +56,20 @@ def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
                 end_page = min(i + paginas_por_fragmento, total_pages)
                 
                 for j in range(start_page, end_page):
-                    # pypdf usa índice 0, então página N é reader.pages[N-1]
                     try:
-                        fragment_text.append(reader.pages[j].extract_text())
+                        # Extrai o texto; se vazio (OCR ou complexo), o LLM tentará limpá-lo
+                        text = reader.pages[j].extract_text() or f"[PAG {j+1}: EXTRAÇÃO VAZIA - OCR NECESSÁRIO]"
+                        fragment_text.append(text)
                     except Exception as e:
-                        fragment_text.append(f"[ERRO DE EXTRAÇÃO NA PÁGINA {j+1}: {e}]")
+                        fragment_text.append(f"[PAG {j+1}: ERRO DE EXTRAÇÃO/ENCODING - {e}]")
                 
-                fragment_header = f"FRAGMENTO (Pgs {start_page+1}-{end_page} / Total {total_pages}):\n"
+                # Monta o input para o LLM: cabeçalho + texto extraído (mesmo que vazio)
+                fragment_header = f"Fragmento {i//paginas_por_fragmento + 1} (Pgs {start_page+1}-{end_page} / Total {total_pages}):\n"
                 fragments.append(fragment_header + "\n".join(fragment_text))
 
             return fragments, anexo_info
             
         except Exception as e:
-            # Em caso de erro na leitura/extração do PDF
             return [f"ERRO CRÍTICO NA LEITURA DE PDF: {e}"], anexo_info
     
     # Para arquivos não PDF, lê o conteúdo como um único fragmento.
@@ -84,13 +81,15 @@ def ler_anexo_e_fragmentar(arquivo, paginas_por_fragmento=5):
 
 # ==================== 3. ENGINE DE EXECUÇÃO ====================
 
-# Funções inalteradas, pois a lógica de loop foi centralizada no ORQUESTRADOR
+# Modificada para aceitar um fragmento de texto como input (apenas para o Agente de Loop)
 def executar_no(timeline, config, fragmento_input=None):
     modelo = model_pro if config.get("modelo") == "pro" else model_flash
     
     if fragmento_input is not None:
+        # Se for o Agente de Loop (Passo 0), o prompt é apenas a missão + o fragmento
         input_para_prompt = fragmento_input
     else:
+        # Para os agentes sequenciais, o prompt é a timeline completa (que inclui as transcrições)
         contexto = json.dumps(timeline, ensure_ascii=False, indent=2)
         input_para_prompt = contexto
 
@@ -103,13 +102,15 @@ def executar_no(timeline, config, fragmento_input=None):
         out = resp.text
         tempo = time.time() - inicio
         
-        content = json.loads(out.strip().replace('```json','').replace('```','')) if config['tipo_saida']=='json' and fragmento_input is None else out
+        # O Agente de Transcrição retorna 'texto', os outros retornam 'json'
+        content = json.loads(out.strip().replace('```json','').replace('```','')) if config['tipo_saida']=='json' else out
         log += f" (OK - {tempo:.2f}s)"
         return {"role": "assistant", "agent": config['nome'], "content": content}, log, out
     except Exception as e:
         return {"role": "system", "error": str(e)}, f" (ERRO: {e})", str(e)
 
-# ==================== 4. ORQUESTRADOR (LÓGICA DO LOOP/FRAGMENTAÇÃO) ====================
+
+# ==================== 4. ORQUESTRADOR (LÓGICA DO LOOP) ====================
 
 def orquestrador(texto, arquivo, history, json_config):
     # 1. Input Check e Fragmentação
@@ -127,33 +128,56 @@ def orquestrador(texto, arquivo, history, json_config):
         yield history, {}, "Erro JSON"
         return
 
-    # A TIMELINE começa com o input do usuário (a pergunta/instrução)
+    # A TIMELINE começa com o input do usuário (pergunta/instrução)
     timeline = [{"role": "user", "content": texto}]
     logs = f"🚀 START: {datetime.now().strftime('%H:%M:%S')}\n"
     history[-1][1] = "⏳ Iniciando análise..."
     yield history, timeline, logs
 
-    # 3. Lógica de Pré-processamento/Conciliação de Fragmentos
+    # --- NOVO: Lógica de Loop/Transcrição (PASSO 0) ---
+    concatenated_transcription = anexo_info + "\n\n"
     
-    if len(fragmentos) > 0:
-        concatenated_input = anexo_info + "\n\n" + "\n\n".join(fragmentos)
-        full_input_to_pass = f"{texto}\n{concatenated_input}".strip()
+    if protocolo and protocolo[0]['nome'] == 'TRANSCRITOR_FRAGMENTO (PASSO 0 - LOOP)' and len(fragmentos) > 0:
         
-        # O full_input_to_pass torna-se o 'content' do primeiro item da timeline
-        timeline[0]['content'] = full_input_to_pass
-        history[-1][1] = "✅ Pré-processamento: Anexo lido e concatenado. Iniciando FASE 0..."
-        yield history, timeline, logs
+        cfg_transcricao = protocolo.pop(0) # Remove o Agente de Loop da lista principal
         
-    else:
-        # Se não há anexo ou só a pergunta
-        pass
+        for i, fragmento in enumerate(fragmentos):
+            history[-1][1] = f"⚙️ {cfg_transcricao['nome']} trabalhando no fragmento {i+1}/{len(fragmentos)} (5 Pgs)..."
+            yield history, timeline, logs
+            
+            # Executa o LLM no fragmento ATUAL, não na timeline
+            # Isso força o Gemini a focar APENAS nas 5 páginas para transcrever/limpar
+            res, log_add, raw = executar_no(timeline, cfg_transcricao, fragmento_input=fragmento)
+            logs += log_add + "\n"
+            
+            if 'error' in res:
+                timeline.append(res)
+                yield history, timeline, logs
+                return
+            
+            # Concatenamos o texto limpo retornado pelo LLM
+            concatenated_transcription += res['content'] + "\n"
 
+        logs += "\n✅ TRANSCRIÇÃO FRAGMENTADA E CONCATENADA CONCLUÍDA.\n"
+        
+        # Adiciona o resultado da transcrição concatenada à timeline para os próximos agentes
+        timeline.append({
+            "role": "system", 
+            "agent": "TEXTO_DOCUMENTO_COMPLETO", 
+            "content": concatenated_transcription
+        })
+        history[-1][1] = "✅ Transcrição completa. Iniciando Catalogação (Passo 1)..."
+        yield history, timeline, logs
+        
+    elif len(fragmentos) > 0:
+        # Se não há Passo 0 (Transcrição), injeta o texto extraído cru como um bloco
+        timeline.append({"role": "system", "agent": "TEXTO_DOCUMENTO_COMPLETO", "content": concatenated_transcription + "\n".join(fragmentos)})
 
-    # 4. PASSOS SEGUINTES: EXECUÇÃO SEQUENCIAL (Protocolo Epistêmico)
+    # 5. PASSOS SEGUINTES: EXECUÇÃO SEQUENCIAL (Catalogação)
     final_response = ""
-    for cfg in protocolo: 
+    for cfg in protocolo: # Iteramos sobre a lista (agora começa do BIBLIOTECARIO_CATALOGADOR)
         
-        history[-1][1] = f"⚙️ FASE {cfg.get('fase', '?')}: {cfg['nome']} trabalhando..."
+        history[-1][1] = f"⚙️ {cfg['nome']} trabalhando..."
         yield history, timeline, logs
         
         res, log_add, raw = executar_no(timeline, cfg)
@@ -166,10 +190,11 @@ def orquestrador(texto, arquivo, history, json_config):
         
         yield history, timeline, logs
 
-    logs += "✅ FIM. (Análise Epistêmica Concluída)"
+    logs += "✅ FIM."
     yield history, timeline, logs
 
-# ==================== 5. UI LIMPA (v27) ====================
+# ==================== 5. UI LIMPA (v31) ====================
+# (A UI permanece a mesma)
 
 def ui_clean():
     css = """
@@ -179,7 +204,7 @@ def ui_clean():
     
     config_init = carregar_protocolo()
 
-    with gr.Blocks(title="Protocolo Epistêmico Forense", css=css, theme=gr.themes.Soft()) as app:
+    with gr.Blocks(title="Protocolo Fragmentação/Transcrição", css=css, theme=gr.themes.Soft()) as app:
         
         with gr.Tabs():