Update app.py

app.py

@@ -1,6 +1,6 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║ PIPELINE v35: SÓCRATES v2 | BUGS FIXADOS | HF SPACES OK ║
-# ║ SEM Textbox extra | contexto_fallback fix | 100% input+history ║
+# ║ PIPELINE v28: UI + CONTEXTO GLOBAL                                         ║
+# ║ Layout: Chat | Depuração | Contexto | Config                               ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
@@ -8,253 +8,306 @@ import json
 import re
 import time
 from datetime import datetime
+
 import gradio as gr
 import google.generativeai as genai
-import warnings
-warnings.filterwarnings("ignore")
 
 # ==================== 1. CONFIGURAÇÃO ====================
-api_key = os.getenv("GOOGLE_API_KEY")
-if api_key: 
+
+api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
+if api_key:
     genai.configure(api_key=api_key)
-    model_flash = genai.GenerativeModel("gemini-flash-latest")
-    model_pro = genai.GenerativeModel("gemini-pro-latest")
-else:
-    model_flash = model_pro = None
-
-ARQUIVO_CONTEXT = "contexto_v35.json"
-ARQUIVO_HISTORY = "history_v35.json"
-
-# ==================== 2. ANALISADOR CONTEXTUAL (CORAÇÃO FIXADO) ====================
-class AnalisadorContextual:
-    def __init__(self):
-        self.contexto = self.carregar_contexto()
-    
-    def carregar_contexto(self):
-        try:
-            with open(ARQUIVO_CONTEXT, "r", encoding="utf-8") as f:
-                return json.load(f)
-        except:
-            return {
-                "classificacao": [],
-                "fatos": [],
-                "objetivo_usuario": "",
-                "duvida_central": "",
-                "timestamp": ""
-            }
-    
-    def salvar_contexto(self):
-        try:
-            with open(ARQUIVO_CONTEXT, "w", encoding="utf-8") as f:
-                json.dump(self.contexto, f, ensure_ascii=False, indent=2)
-        except: pass
-    
-    def contexto_fallback(self, input_atual):
-        """FIX: input_atual passado como parâmetro"""
-        return {
-            "classificacao": ["dúvida"],
-            "fatos": [],
-            "objetivo_usuario": "Análise geral",
-            "duvida_central": input_atual[:200],
-            "timestamp": datetime.now().isoformat()
-        }
-    
-    def analisar_input(self, input_atual, history):
-        """TUDO do input + histórico - SEM outros textbox"""
-        if not model_pro: 
-            return self.contexto_fallback(input_atual)
-        
-        history_resumo = "\n".join([f"👤: {h[0][:80]}..." for h in history[-3:]])[:300]
-        
-        prompt = f"""CATALOGUE SEM RESPONDER:
-
-INPUT ATUAL: {input_atual[:400]}
-HISTÓRICO: {history_resumo}
-
-JSON:
-{{
-  "classificacao": ["anexo","dúvida","crítica","pesquisa"],
-  "fatos": [["gpu",0.9,"input1","2025-12-05"]],
-  "objetivo_usuario": "Meta da conversa",
-  "duvida_central": "Foco atual"
-}}"""
-
-        try:
-            resp = model_pro.generate_content(prompt, temperature=0.1)
-            raw = re.sub(r'``````|\n\s*\n', '', resp.text.strip())
-            analise = json.loads(raw)
-            
-            # MERGE + UPDATE
-            self.contexto.update(analise)
-            self.aplicar_decainento()
-            self.contexto["timestamp"] = datetime.now().isoformat()
-            self.salvar_contexto()
-            return self.contexto
-        except:
-            return self.contexto_fallback(input_atual)
-    
-    def aplicar_decainento(self):
-        agora = time.time()
-        novos_fatos = []
-        for fato in self.contexto.get("fatos", []):
-            peso = fato[1] * 0.95
-            if peso > 0.1:
-                novos_fatos.append([fato[0], peso, fato[2], datetime.now().isoformat()])
-        self.contexto["fatos"] = novos_fatos[:15]
-
-# ==================== 3. SINGLETON GLOBAL ====================
-analisador = AnalisadorContextual()
-
-# ==================== 4. PLANEJADOR + EXECUTOR ====================
-def fallback_plano():
-    return [
-        {"nome": "Analisador", "missao": "Analise input+contexto", "modelo": "flash", "tipo_saida": "json"},
-        {"nome": "RespostaFinal", "missao": "Resposta clara completa", "modelo": "pro", "tipo_saida": "texto"}
-    ]
-
-def planejar_socrates(contexto, input_atual):
-    if not model_pro: return fallback_plano()
-    
-    fatos = "\n".join([f"- {f[0]}({f[1]:.1f})" for f in contexto.get("fatos", [])[:4]])
-    prompt = f"""CONTEXTO CATALOGADO: {contexto}
-INPUT: {input_atual[:200]}
-
-PLANO 3 agentes JSON:
-[{{"nome":"Explorador","missao":"Levante possibilidades","modelo":"flash","tipo_saida":"json"}},
- {{"nome":"Validador","missao":"Teste cenários","modelo":"pro","tipo_saida":"json"}},
- {{"nome":"Final","missao":"Resposta final","modelo":"pro","tipo_saida":"texto"}}]"""
-    
+
+model_flash = genai.GenerativeModel("gemini-flash-latest")
+model_pro = genai.GenerativeModel("gemini-pro-latest")
+
+ARQUIVO_CONFIG = "protocolo.json"
+ARQUIVO_CONTEXTO = "contexto.json"
+
+
+# ==================== 2. UTILIDADES ====================
+
+def carregar_protocolo():
     try:
-        resp = model_pro.generate_content(prompt)
-        plano_raw = re.sub(r'``````', '', resp.text.strip())
-        return json.loads(plano_raw)
+        with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f:
+            return f.read()
     except:
-        return fallback_plano()
+        return "[]"
 
-def executar_agente(timeline, config):
-    if not model_pro:
-        return {"role": "system", "error": "Sem API"}, "ERRO", "Sem key"
-    
-    modelo = model_pro if config.get("modelo") == "pro" else model_flash
-    contexto = json.dumps(timeline[-6:], ensure_ascii=False)
-    prompt = f"CONTEXTO: {contexto}\nAGENTE: {config['nome']}\nMISSÃO: {config['missao']}"
-    
+
+def salvar_protocolo(conteudo):
     try:
-        resp = modelo.generate_content(prompt)
-        out = resp.text.strip()
-        content = json.loads(re.sub(r'``````', '', out)) if config.get('tipo_saida') == 'json' else out
-        return {"role": "assistant", "agent": config['nome'], "content": content}, "OK", out
+        json.loads(conteudo)
+        with open(ARQUIVO_CONFIG, "w", encoding="utf-8") as f:
+            f.write(conteudo)
+        return "✅ Salvo"
     except:
-        return {"role": "system", "error": "Erro"}, "ERRO", "Falha"
+        return "❌ Erro JSON"
+
 
-# ==================== 5. ORQUESTRADOR v35 (SIMPLIFICADO) ====================
 def ler_anexo(arquivo):
-    if not arquivo: return ""
+    if arquivo is None:
+        return ""
     try:
         with open(arquivo.name, "r", encoding="utf-8") as f:
-            return f"\n📎 {os.path.basename(arquivo.name)}:\n{f.read()}\n"
-    except: return ""
+            return (
+                f"\n\n[ANEXO SISTEMA: {os.path.basename(arquivo.name)}]\n"
+                f"{f.read()}\n[FIM ANEXO]\n"
+            )
+    except:
+        return ""
+
+
+# -------- CONTEXTO GLOBAL --------
+
+def contexto_vazio():
+    return {
+        "classificacao": "",                  # "duvida" ou "critica"
+        "fatos": [],                          # lista de {descricao, peso, ultima_mencao}
+        "objetivo_usuario": "",
+        "duvida_central_ultimos_input": "",
+        "timestamp": ""
+    }
+
+
+def carregar_contexto():
+    try:
+        with open(ARQUIVO_CONTEXTO, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except:
+        return contexto_vazio()
+
+
+def salvar_contexto(ctx):
+    try:
+        with open(ARQUIVO_CONTEXTO, "w", encoding="utf-8") as f:
+            json.dump(ctx, f, ensure_ascii=False, indent=2)
+        return ctx
+    except:
+        return ctx
+
+
+def atualizar_contexto(full_input, timeline, contexto_antigo):
+    """
+    Versão mínima: atualiza timestamp e última dúvida central
+    a partir do último input do usuário. Pode ser refinado depois
+    com agentes específicos de metacognição.
+    """
+    ctx = contexto_antigo.copy() if contexto_antigo else contexto_vazio()
+
+    # Timestamp sempre atualizado
+    ctx["timestamp"] = datetime.now().isoformat()
+
+    # Heurística simples de classificação inicial
+    texto_lower = full_input.lower()
+    if "?" in full_input:
+        ctx["classificacao"] = "duvida"
+    elif "reclama" in texto_lower or "problema" in texto_lower or "erro" in texto_lower:
+        ctx["classificacao"] = "critica"
+
+    # Último input como "dúvida central" bruta
+    ctx["duvida_central_ultimos_input"] = full_input.strip()
+
+    # Objetivo do usuário (placeholder: pode ser enriquecido por agente)
+    if not ctx.get("objetivo_usuario"):
+        ctx["objetivo_usuario"] = "Inferir objetivo do usuário com base na conversa."
+
+    # TODO futuro: atualizar lista de fatos com pesos e decay
+    # por enquanto apenas preserva ctx["fatos"]
+
+    return ctx
+
+
+# ==================== 3. ENGINE DE EXECUÇÃO ====================
+
+def executar_no(timeline, config, contexto):
+    modelo = model_pro if config.get("modelo") == "pro" else model_flash
+
+    contexto_timeline = json.dumps(timeline, ensure_ascii=False, indent=2)
+    contexto_global = json.dumps(contexto, ensure_ascii=False, indent=2)
+
+    prompt = (
+        f"--- CONTEXTO GLOBAL ---\n{contexto_global}\n"
+        f"--- TIMELINE ---\n{contexto_timeline}\n"
+        f"----------------\n"
+        f"AGENTE: {config['nome']}\n"
+        f"MISSÃO: {config['missao']}"
+    )
+
+    log = f"\n🔸 {config['nome']}..."
+
+    try:
+        inicio = time.time()
+        resp = modelo.generate_content(prompt)
+        out = resp.text
+        tempo = time.time() - inicio
 
-def orquestrador_v35(texto, arquivo, history, json_config=None):
-    """SEM textbox extra - só input+history"""
+        if config.get("tipo_saida") == "json":
+            # Tenta normalizar saída JSON simples
+            cleaned = out.strip().replace("``````", "")
+            content = json.loads(cleaned)
+        else:
+            content = out
+
+        log += f" (OK - {tempo:.2f}s)"
+
+        return {"role": "assistant", "agent": config["nome"], "content": content}, log, out
+
+    except Exception as e:
+        # Em caso de erro, registra no timeline como system
+        return {"role": "system", "error": str(e)}, f" (ERRO: {e})", str(e)
+
+
+# ==================== 4. ORQUESTRADOR ====================
+
+def orquestrador(texto, arquivo, history, json_config):
+    # 1. Input Check
     anexo = ler_anexo(arquivo)
-    full_input = f"{texto}{anexo}".strip()
-    
+    full_input = f"{texto}\n{anexo}".strip()
+
+    contexto = carregar_contexto()
+
     if not full_input:
-        yield history, {}, "Sem input"
+        # Sem input, apenas retorna contexto atual
+        yield history, {}, "Sem input.", contexto
+        return
+
+    # 2. Setup histórico
+    history = history + [[texto + (" 📎" if arquivo else ""), None]]
+
+    try:
+        protocolo = json.loads(json_config)
+    except:
+        history[-1][1] = "❌ Erro no JSON de Configuração."
+        yield history, {}, "Erro JSON", contexto
         return
-    
-    # Adiciona input ao histórico
-    history.append([full_input, "🧠 Catalogando contexto..."])
+
     timeline = [{"role": "user", "content": full_input}]
-    logs = f"🚀 v35: {datetime.now().strftime('%H:%M:%S')}\n"
-    
-    yield history, timeline, logs
-    
-    # 1. ANALISADOR CONTEXTUAL (CORRIGIDO)
-    contexto = analisador.analisar_input(full_input, history)
-    logs += f"📊 {len(contexto.get('fatos',[]))} fatos | {contexto.get('classificacao',[])}\n"
-    timeline.append({"role": "system", "contexto": contexto})
-    
-    history[-1][1] = f"✅ {len(contexto.get('fatos',[]))} fatos | {contexto.get('classificacao', ['dúvida'])[0]}"
-    yield history, timeline, logs
-    
-    # 2. PLANEJADOR SÓCRATES
-    plano = planejar_socrates(contexto, full_input)
-    logs += f"🎯 Plano: {len(plano)} agentes\n"
-    timeline.append({"role": "system", "plano": plano})
-    
-    history[-1][1] = f"🎯 {len(plano)} etapas planejadas"
-    yield history, timeline, logs
-    
-    # 3. EXECUTA PLANO
-    for i, agente in enumerate(plano):
-        history[-1][1] = f"[{i+1}/{len(plano)}] {agente['nome']}..."
-        yield history, timeline, logs
-        
-        res, status, raw = executar_agente(timeline, agente)
+
+    # Atualiza contexto com o novo input inicial
+    contexto = atualizar_contexto(full_input, timeline, contexto)
+    salvar_contexto(contexto)
+
+    logs = f"🚀 START: {datetime.now().strftime('%H:%M:%S')}\n"
+
+    history[-1][1] = "⏳ Iniciando análise..."
+    yield history, timeline, logs, contexto
+
+    # 3. Loop de nós
+    final_response = ""
+
+    for cfg in protocolo:
+        history[-1][1] = f"⚙️ {cfg['nome']} trabalhando..."
+        yield history, timeline, logs, contexto
+
+        res, log_add, raw = executar_no(timeline, cfg, contexto)
         timeline.append(res)
-        logs += f"  {status}\n"
-        
-        if agente.get('tipo_saida') == 'texto' and res.get('content'):
-            history[-1][1] = str(res['content'])[:900]
-            yield history, timeline, logs
-    
-    logs += "✅ Sócrates v35 concluído"
-    yield history, timeline, logs
-
-# ==================== 6. UI SIMPLIFICADA v35 ====================
-def ui_v35():
-    css = "footer {display: none !important;} .contain {border: none !important;}"
-    
-    with gr.Blocks(title="🚀 PIPELINE v35 - SÓCRATES", css=css, theme=gr.themes.Soft()) as app:
-        gr.Markdown("# 🧠 PIPELINE v35 - Input + Histórico = Tudo")
-        
+        logs += log_add + "\n"
+
+        # Atualiza contexto após cada nó com a nova timeline completa
+        contexto = atualizar_contexto(full_input, timeline, contexto)
+        salvar_contexto(contexto)
+
+        if cfg.get("tipo_saida") == "texto" and res.get("role") == "assistant":
+            final_response = res.get("content", "")
+            history[-1][1] = final_response
+            yield history, timeline, logs, contexto
+
+    logs += "✅ FIM."
+    yield history, timeline, logs, contexto
+
+
+# ==================== 5. UI LIMPA (v28) ====================
+
+def ui_clean():
+    css = """
+    footer {display: none !important;}
+    .contain {border: none !important;}
+    """
+
+    config_init = carregar_protocolo()
+
+    with gr.Blocks(title="AI Forensics", css=css, theme=gr.themes.Soft()) as app:
         with gr.Tabs():
-            # ABA PRINCIPAL - SEM textbox extra
-            with gr.Tab("💬 Pipeline"):
-                chatbot = gr.Chatbot(height=600, show_copy_button=True, type="tuples")
-                
+
+            # === ABA 1: CHAT (LIMPO) ===
+            with gr.Tab("💬 Investigador"):
+                chatbot = gr.Chatbot(
+                    label="",
+                    show_label=False,
+                    height=600,
+                    show_copy_button=True,
+                    render_markdown=True
+                )
+
                 with gr.Row():
-                    txt_in = gr.Textbox(placeholder="Digite input... (contexto automático)", 
-                                      lines=3, container=False)
-                    file_in = gr.UploadButton("📎", file_types=[".txt", ".py", ".json"])
-                    btn_send = gr.Button("▶️ Executar", variant="primary")
-                
-                file_status = gr.Markdown("")
-                file_in.upload(lambda x: f"📎 {os.path.basename(x.name) if x else ''}", 
-                             file_in, file_status)
-            
-            # DEBUG
-            with gr.Tab("🔍 Debug"):
-                out_dna = gr.JSON(label="Timeline")
-                out_logs = gr.Textbox(label="Logs", lines=15)
-            
-            # CONTEXTO PERSISTENTE
+                    with gr.Column(scale=10):
+                        txt_in = gr.Textbox(
+                            show_label=False,
+                            placeholder="Descreva o caso ou instrução...",
+                            lines=1,
+                            max_lines=5,
+                            container=False,
+                        )
+                    with gr.Column(scale=1, min_width=50):
+                        file_in = gr.UploadButton(
+                            "📎",
+                            file_types=[".txt", ".md", ".csv", ".json"],
+                            size="sm",
+                        )
+                    with gr.Column(scale=1, min_width=80):
+                        btn_send = gr.Button(
+                            "Enviar",
+                            variant="primary",
+                            size="sm",
+                        )
+
+                # Feedback visual sutil do arquivo
+                file_status = gr.Markdown("", visible=True)
+                file_in.upload(
+                    lambda x: f"📎 Anexo: {os.path.basename(x.name)}",
+                    file_in,
+                    file_status,
+                )
+
+            # === ABA 2: DEPURAÇÃO ===
+            with gr.Tab("🕵️ Depuração"):
+                with gr.Row():
+                    out_dna = gr.JSON(label="DNA (Timeline)")
+                    out_logs = gr.Textbox(label="Logs do Sistema", lines=20)
+
+            # === ABA 3: CONTEXTO GLOBAL ===
             with gr.Tab("🧠 Contexto"):
-                contexto_display = gr.JSON(label="contexto_v35.json", value={})
-                gr.Button("🔄 Refresh").click(lambda: analisador.contexto, outputs=contexto_display)
-        
-        # TRIGGERS SIMPLIFICADOS (sem 4º input)
-        btn_send.click(
-            orquestrador_v35,
-            inputs=[txt_in, file_in, chatbot],
-            outputs=[chatbot, out_dna, out_logs]
-        ).then(lambda: "", outputs=txt_in)
-        
-        txt_in.submit(
-            orquestrador_v35,
-            inputs=[txt_in, file_in, chatbot],
-            outputs=[chatbot, out_dna, out_logs]
-        ).then(lambda: "", outputs=txt_in)
-    
+                contexto_json = gr.JSON(label="Contexto Global (contexto.json)")
+
+            # === ABA 4: CONFIG (TÉCNICO) ===
+            with gr.Tab("⚙️ Config"):
+                with gr.Row():
+                    btn_save = gr.Button("Salvar Config")
+                    lbl_save = gr.Label(show_label=False)
+                code_json = gr.Code(
+                    value=config_init,
+                    language="json",
+                    label="protocolo.json",
+                )
+                btn_save.click(salvar_protocolo, code_json, lbl_save)
+
+            # === TRIGGERS ===
+            # Enter ou Botão Enviar
+            triggers = [btn_send.click, txt_in.submit]
+
+            for trig in triggers:
+                trig(
+                    orquestrador,
+                    inputs=[txt_in, file_in, chatbot, code_json],
+                    outputs=[chatbot, out_dna, out_logs, contexto_json],
+                ).then(
+                    lambda: (None, ""),
+                    outputs=[txt_in, file_status],
+                )
+
     return app
 
+
 if __name__ == "__main__":
-    print("🚀 v35 SÓCRATES - SEM ERROS")
-    print("✅ contexto_fallback fixado")
-    print("✅ Sem textbox extra - só input+history")
-    print("✅ HF Spaces 100% OK")
-    
-    app = ui_v35()
-    app.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    ui_clean().launch()