Update app.py

app.py

@@ -1,11 +1,13 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║                 PIPELINE v22: ORQUESTRAÇÃO DE AGENTES (JSON-LIST)            ║
-# ║        O Segredo: Uma lista de instruções que governa o pensamento.        ║
+# ║             PIPELINE v25: ORQUESTRAÇÃO COM UPLOAD DE EVIDÊNCIAS              ║
+# ║     Novidade: Upload de arquivos de texto (.txt, .md, .csv) no input         ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
 import json
 import re
+import time
+from datetime import datetime
 import gradio as gr
 import google.generativeai as genai
 
@@ -13,194 +15,192 @@ import google.generativeai as genai
 api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
 genai.configure(api_key=api_key)
 
-# Modelo Flash para raciocínio rápido, Pro para redação final
-model_fast = genai.GenerativeModel("gemini-flash-latest")
-model_pro  = genai.GenerativeModel("gemini-pro-latest")
-
-# ==================== 2. O PROTOCOLO (A "ALMA" DA IA) ====================
-# É aqui que você define a inteligência. O código abaixo apenas obedece esta lista.
-# Adicione ou remova agentes aqui para mudar o comportamento do sistema.
-
-PROTOCOLO_OPERACIONAL = [
-    {
-        "nome": "ESCRIVÃO_DIGITAL",
-        "tipo_saida": "json",
-        "modelo": model_fast,
-        "missao": """
-        Leia o input do Usuário. Sua tarefa é extrair FATOS frios.
-        Extraia:
-        1. Quem são as partes (Vítima/Acusado).
-        2. Cronologia (O que aconteceu e quando).
-        3. Inventário de Provas (O que foi citado: áudio, vídeo, testemunha).
-        Retorne APENAS JSON.
-        """
-    },
-    {
-        "nome": "ANALISTA_COMPORTAMENTAL",
-        "tipo_saida": "json",
-        "modelo": model_fast,
-        "missao": """
-        Leia o input original e os fatos do Escrivão.
-        Sua tarefa é analisar o SUBTEXTO e a PSICOLOGIA.
-        1. Analise o tom de voz descrito ou transcrito.
-        2. Identifique manipulação (Gaslighting, Inversão de Culpa).
-        3. Avalie a coerência emocional (Alguém calmo demais? Alguém desesperado?).
-        Retorne APENAS JSON.
-        """
-    },
-    {
-        "nome": "AUDITOR_INVESTIGATIVO",
-        "tipo_saida": "json",
-        "modelo": model_fast,
-        "missao": """
-        Sua tarefa é encontrar a MENTIRA.
-        Cruze o depoimento do acusado (Fatos) com a análise psicológica (Comportamental).
-        Liste as contradições. Onde a versão dele não bate com a realidade do áudio/texto?
-        Retorne APENAS JSON.
-        """
-    },
-    {
-        "nome": "PROMOTOR_SENIOR",
-        "tipo_saida": "texto", # Gera o relatório final visível
-        "modelo": model_pro,   # Modelo mais potente para escrever bem
-        "missao": """
-        Escreva o PARECER TÉCNICO FINAL (Relatório Jurídico).
-        Use Markdown. Seja detalhado (+600 palavras).
-        Estrutura Obrigatória:
-        1. Cabeçalho (Data/Assunto).
-        2. Sumário dos Fatos (Baseado no Escrivão).
-        3. Análise Forense (Baseado no Analista e Auditor). Explique a manipulação.
-        4. Fundamentação Jurídica (Cite leis: Maria da Penha, Ameaça, Violência Psicológica).
-        5. Conclusão e Pedidos (Prisão? Medida Protetiva?).
-        """
-    }
-]
-
-# ==================== 3. O MOTOR (CÓDIGO AGNÓSTICO) ====================
+model_flash = genai.GenerativeModel("gemini-1.5-flash-latest")
+model_pro   = genai.GenerativeModel("gemini-1.5-pro-latest")
+
+ARQUIVO_CONFIG = "protocolo.json"
+
+# ==================== 2. MANIPULAÇÃO DE ARQUIVOS ====================
+
+def carregar_protocolo_padrao():
+    try:
+        with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f: return f.read()
+    except: return "[]"
+
+def salvar_protocolo_disco(conteudo_json):
+    try:
+        json.loads(conteudo_json) # Valida JSON
+        with open(ARQUIVO_CONFIG, "w", encoding="utf-8") as f: f.write(conteudo_json)
+        return "✅ Salvo!"
+    except Exception as e: return f"❌ Erro: {e}"
+
+def ler_arquivo_input(arquivo):
+    """
+    Lê o conteúdo de um arquivo de texto enviado pelo usuário.
+    """
+    if arquivo is None: 
+        return ""
+    
+    try:
+        # Tenta ler como UTF-8
+        with open(arquivo.name, "r", encoding="utf-8") as f:
+            conteudo = f.read()
+            return f"\n\n=== CONTEÚDO DO ARQUIVO ANEXADO ({os.path.basename(arquivo.name)}) ===\n{conteudo}\n=======================================\n"
+    except UnicodeDecodeError:
+        return "\n\n[ERRO: O arquivo anexado não é um texto válido ou tem codificação desconhecida.]"
+    except Exception as e:
+        return f"\n\n[ERRO AO LER ARQUIVO: {str(e)}]"
+
+# ==================== 3. ENGINE DE EXECUÇÃO ====================
 
 def limpar_json(texto: str) -> dict:
-    """Garante que o JSON venha limpo, sem markdown."""
     try:
-        if "```" in texto: 
-            texto = re.search(r"```json?(.*?)```", texto, re.DOTALL).group(1)
+        if "```" in texto: texto = re.search(r"```json?(.*?)```", texto, re.DOTALL).group(1)
         return json.loads(texto.strip())
-    except:
-        return {"conteudo_bruto": texto}
+    except: return {"conteudo_texto": texto}
 
-def executar_agente(timeline: list, config: dict) -> dict:
-    """Um agente entra na sala, lê a timeline e dá sua opinião."""
+def executar_no(timeline: list, config: dict):
+    modelo_ativo = model_pro if config.get("modelo") == "pro" else model_flash
     
-    # 1. O agente recebe todo o histórico anterior como contexto
     contexto_str = json.dumps(timeline, ensure_ascii=False, indent=2)
-    
-    prompt = f"""
-    --- CONTEXTO DO PROCESSO (TIMELINE) ---
-    {contexto_str}
-    ---------------------------------------
-    
-    VOCÊ É O AGENTE: {config['nome']}
-    SUA MISSÃO: {config['missao']}
-    
-    IMPORTANTE: Não converse. Apenas execute a missão.
+    prompt_bruto = f"""
+--- TIMELINE DO CASO ---
+{contexto_str}
+------------------------
+AGENTE: {config['nome']}
+MISSÃO: {config['missao']}
     """
     
+    log_entry = f"\n{'='*40}\n🔶 EXECUTANDO: {config['nome']}\n{'='*40}\n"
+    log_entry += f"📤 PROMPT:\n{prompt_bruto[:1000]}... [truncado para visualização]\n"
+    
     try:
-        # 2. Chamada à API
-        response = config['modelo'].generate_content(prompt)
-        conteudo_raw = response.text
+        inicio = time.time()
+        response = modelo_ativo.generate_content(prompt_bruto)
+        output_bruto = response.text
+        tempo = time.time() - inicio
         
-        # 3. Processamento da Saída
-        if config['tipo_saida'] == 'json':
-            conteudo_processado = limpar_json(conteudo_raw)
-        else:
-            conteudo_processado = conteudo_raw # Texto/Markdown
+        log_entry += f"📥 OUTPUT ({tempo:.2f}s):\n{output_bruto}\n"
+        
+        if config['tipo_saida'] == 'json': conteudo = limpar_json(output_bruto)
+        else: conteudo = output_bruto
             
-        return {
-            "role": "assistant",
-            "agent_name": config['nome'],
-            "content": conteudo_processado
-        }
+        return {"role": "assistant", "agent": config['nome'], "content": conteudo}, log_entry
         
     except Exception as e:
-        return {"role": "system", "error": str(e)}
+        return {"role": "system", "error": str(e)}, log_entry + f"\n❌ ERRO: {str(e)}\n"
 
-def orquestrador(texto_usuario: str):
-    """Loop principal que roda a lista de agentes."""
-    if not texto_usuario.strip(): return "Insira um caso.", []
+# ==================== 4. ORQUESTRADOR ====================
 
-    # 1. Inicia a Timeline com a entrada do usuário
-    timeline = [
-        {"role": "user", "content": texto_usuario}
-    ]
+def orquestrador(texto_caso, arquivo_anexo, json_protocolo_str):
+    """
+    Recebe texto + arquivo, combina ambos e inicia a pipeline.
+    """
+    # 1. Processa o arquivo anexado
+    conteudo_anexo = ler_arquivo_input(arquivo_anexo)
+    
+    # 2. Combina Inputs
+    input_completo = f"{texto_caso}\n{conteudo_anexo}".strip()
     
-    relatorio_final = ""
+    if not input_completo:
+        yield "⚠️ Erro: Insira texto ou anexe um arquivo.", "", {}
+        return
 
-    # 2. O Loop Mágico (Itera sobre o Protocolo)
-    for passo in PROTOCOLO_OPERACIONAL:
-        # Executa o agente atual
-        resultado = executar_agente(timeline, passo)
-        
-        # Adiciona o resultado à timeline para os próximos agentes verem
+    try:
+        protocolo = json.loads(json_protocolo_str)
+    except Exception as e:
+        yield f"⚠️ Erro no JSON de Configuração: {e}", "", {}
+        return
+
+    # 3. Inicializa
+    info_anexo = "Sim" if conteudo_anexo else "Não"
+    logs_totais = f"🚀 INICIANDO (Anexo: {info_anexo})...\n"
+    timeline = [{"role": "user", "content": input_completo}]
+    relatorio_final = "⏳ Aguardando..."
+    
+    yield logs_totais, relatorio_final, timeline
+
+    # 4. Loop de Agentes
+    for config_agente in protocolo:
+        resultado, log_no = executar_no(timeline, config_agente)
         timeline.append(resultado)
+        logs_totais += log_no
         
-        # Se for o Promotor (texto), salvamos para exibir na tela principal
-        if passo['tipo_saida'] == 'texto':
+        if config_agente['tipo_saida'] == 'texto':
             relatorio_final = resultado['content']
+        else:
+            relatorio_final = f"⏳ {config_agente['nome']} trabalhando..."
+            
+        yield logs_totais, relatorio_final, timeline
 
-    # Retorna o texto formatado e a timeline completa (JSON) para inspeção
-    return relatorio_final, timeline
+    logs_totais += "\n🏁 FINALIZADO."
+    yield logs_totais, relatorio_final, timeline
 
-# ==================== 4. INTERFACE GRÁFICA ====================
+# ==================== 5. INTERFACE ====================
 
-def interface():
-    with gr.Blocks(title="Orquestrador v22", theme=gr.themes.Soft()) as app:
-        
-        gr.Markdown("# ⚖️ Pipeline Cognitiva: Orquestração de Agentes")
-        gr.Markdown("Este sistema não usa um prompt único. Ele usa uma cadeia de especialistas virtuais definidos em JSON.")
-        
-        with gr.Row():
-            # Entrada
-            inp = gr.Textbox(
-                label="Dossiê do Caso (Texto/Transcrições)", 
-                lines=8, 
-                placeholder="Cole aqui o BO, depoimentos e transcrições..."
-            )
-        
-        btn = gr.Button("🚀 INICIAR ORQUESTRAÇÃO", variant="primary", size="lg")
+def construir_interface():
+    config_inicial = carregar_protocolo_padrao()
+    
+    with gr.Blocks(title="Pipeline v25 - Com Upload", theme=gr.themes.Base()) as app:
+        gr.Markdown("# 🕵️‍♂️ Pipeline Forense v25: Input Multimodal (Texto + Arquivo)")
         
-        with gr.Row():
-            # Saída Final (Markdown Renderizado)
-            out_relatorio = gr.Markdown(label="Parecer Final do Promotor")
-            
-            # Saída de Debug (O "Cérebro" da máquina)
-            out_timeline = gr.JSON(label="Timeline de Consciência (Passo a Passo)")
+        with gr.Tabs():
             
-        btn.click(orquestrador, inp, [out_relatorio, out_timeline])
+            # === ABA EXECUÇÃO ===
+            with gr.TabItem("🚀 Execução"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        inp_caso = gr.Textbox(
+                            label="Instruções / Resumo do Caso", 
+                            lines=5, 
+                            placeholder="Digite instruções adicionais aqui..."
+                        )
+                        # NOVO COMPONENTE DE UPLOAD
+                        inp_arquivo = gr.File(
+                            label="Anexar Evidências (Texto/Logs/Transcrições)",
+                            file_types=[".txt", ".md", ".csv", ".json"],
+                            file_count="single"
+                        )
+                        btn_executar = gr.Button("⚡ EXECUTAR ANÁLISE COMPLETA", variant="primary", size="lg")
+                    
+                    with gr.Column(scale=1):
+                        out_logs = gr.Textbox(
+                            label="📟 Console de Logs (Raw I/O)", 
+                            lines=15, 
+                            interactive=False,
+                            elem_id="logs"
+                        )
+                
+                gr.Markdown("---")
+                
+                with gr.Row():
+                    out_relatorio = gr.Markdown(label="📄 Parecer Final")
+                    out_timeline = gr.JSON(label="🧠 Memória JSON")
+
+            # === ABA CONFIGURAÇÃO ===
+            with gr.TabItem("⚙️ Configuração (JSON)"):
+                with gr.Row():
+                    btn_save_config = gr.Button("💾 Salvar Protocolo")
+                    lbl_config = gr.Label()
+                
+                editor_json = gr.Code(
+                    label="protocolo.json", 
+                    language="json", 
+                    value=config_inicial, 
+                    lines=20
+                )
+                
+                btn_save_config.click(salvar_protocolo_disco, editor_json, lbl_config)
+
+        # EVENTO DE EXECUÇÃO
+        btn_executar.click(
+            orquestrador,
+            inputs=[inp_caso, inp_arquivo, editor_json], # Passa Texto + Arquivo + Config
+            outputs=[out_logs, out_relatorio, out_timeline]
+        )
         
     return app
 
-# ==================== PSEUDO-CÓDIGO (DOCUMENTAÇÃO) ====================
-"""
-COMO ESTE CÓDIGO PENSA (Lógica Humanizada):
-
-1. RECEBER(Caso) -> Cria uma Lista: [Caso]
-
-2. PARA CADA Agente NA Lista_de_Instruções:
-    A. O Agente LÊ toda a Lista até agora (memória perfeita).
-    B. O Agente EXECUTA sua instrução específica (ex: "Ache mentiras").
-    C. O Agente ESCREVE sua conclusão no final da Lista.
-    
-    Exemplo Visual da Lista crescendo:
-    [
-      {User: "Ele disse que não bateu..."},
-      {Escrivão: "Fatos: Agressão dia 20..."},
-      {Psicólogo: "Tom: Ele está manipulando..."},
-      {Investigador: "Mentira detectada: Ele nega mas o áudio prova..."},
-      {Promotor: "Relatório Final: Com base na mentira detectada pelo Investigador..."}
-    ]
-
-3. EXIBIR o trabalho do último Agente (Promotor).
-"""
-
 if __name__ == "__main__":
-    interface().launch()
+    print("Iniciando v25...")
+    construir_interface().launch()