Update app.py

app.py

@@ -1,6 +1,6 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║ PIPELINE v32: 100% COMPATÍVEL HF SPACES | ZERO WARNINGS ║
-# ║ Corrige: Chatbot type='messages' | JSON sem 'lines' ║
+# ║ PIPELINE v33: ANALISADOR CONTEXTUAL + PLANEJADOR SÓCRATES ║
+# ║ 1º: CATALOGA contexto → 2º: PLANEJA → 3º: EXECUTA ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
@@ -14,7 +14,7 @@ import warnings
 warnings.filterwarnings("ignore")
 
 # ==================== 1. CONFIGURAÇÃO ====================
-api_key = os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI")
+api_key = os.getenv("GOOGLE_API_KEY")
 if api_key: 
     genai.configure(api_key=api_key)
     model_flash = genai.GenerativeModel("gemini-flash-latest")
@@ -22,112 +22,170 @@ if api_key:
 else:
     model_flash = model_pro = None
 
-ARQUIVO_CONFIG = "protocolo.json"
-ARQUIVO_HISTORY = "history_v32.json"
+ARQUIVO_CONTEXT = "contexto_v33.json"
+ARQUIVO_HISTORY = "history_v33.json"
 
-# ==================== 2. UTILIDADES ====================
-def carregar_protocolo():
-    try:
-        with open(ARQUIVO_CONFIG, "r", encoding="utf-8") as f: 
-            return f.read()
-    except: 
-        return "[]"
+# ==================== 2. SISTEMA CONTEXTUAL (CORAÇÃO) ====================
+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": [],  # [tag, peso, input_ref, ultima_atualizacao]
+                "objetivo_usuario": "",
+                "dúvida_central": "",
+                "timestamp": ""
+            }
+    
+    def salvar_contexto(self):
+        with open(ARQUIVO_CONTEXT, "w", encoding="utf-8") as f:
+            json.dump(self.contexto, f, ensure_ascii=False, indent=2)
+    
+    def analisar_input(self, input_atual, history):
+        """CORAÇÃO: CATALOGA + ATUALIZA CONTEXTUAL"""
+        if not model_pro: 
+            return self.contexto_fallback()
+        
+        history_resumo = "\n".join([f"👤: {h[0][:100]}... 🤖: {h[1][:100]}..." 
+                                   for h in history[-4:]])[:400]
+        
+        prompt_analise = f"""ANALISE CONTEXTUAL v33 - CATALOGUE SEM RESPONDER
 
-def salvar_protocolo(conteudo):
-    try:
-        json.loads(conteudo)
-        with open(ARQUIVO_CONFIG, "w", encoding="utf-8") as f: 
-            f.write(conteudo)
-        return "✅ Salvo"
-    except: 
-        return "❌ Erro JSON"
-
-def carregar_history():
-    try:
-        with open(ARQUIVO_HISTORY, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except: 
-        return []
+INPUT ATUAL: {input_atual}
+HISTÓRICO RECENTE: {history_resumo}
 
-def salvar_history(history):
-    try:
-        with open(ARQUIVO_HISTORY, "w", encoding="utf-8") as f:
-            json.dump(history, f, ensure_ascii=False, indent=2)
-        return True
-    except: 
-        return False
+PREENCHA FORMULÁRIO JSON:
 
-def ler_anexo(arquivo):
-    if arquivo is None: return ""
-    try:
-        with open(arquivo.name, "r", encoding="utf-8") as f:
-            return f"\n\n[ANEXO: {os.path.basename(arquivo.name)}]\n{f.read()}\n[FIM ANEXO]\n"
-    except: return ""
+{{
+  "classificacao": ["anexo", "dúvida", "crítica", "pesquisa"],
+  "fatos": [
+    ["gpu-l40s", 0.9, "input_001", "2025-12-05"],
+    ["ltxv-video", 0.7, "input_002", "2025-12-04"]
+  ],
+  "objetivo_usuario": "Objetivo principal da conversa",
+  "duvida_central": "Ponto específico atual",
+  "timestamp": "{datetime.now().isoformat()}"
+}}
 
-# ==================== 3. PLANEJADOR ROBUSTO ====================
-def criar_plano_auto(full_input, history_contexto):
-    if not model_pro: 
-        return fallback_plano(), "⚠️ Demo mode"
+✅ CATALOGUE FATOS com PESO (0.0-1.0)
+✅ DECAIMENTO: fatos antigos perdem peso
+✅ OBJETIVO: meta da conversa inteira
+✅ DÚVIDA: foco imediato
+
+APENAS JSON VÁLIDO!"""
+
+        try:
+            resp = model_pro.generate_content(prompt_analise, temperature=0.1)
+            raw = resp.text.strip()
+            clean = re.sub(r'``````|\n\s*\n', '', raw)
+            clean = re.sub(r'^.*?\[{2}', '[{', clean)
+            clean = re.sub(r'\]{2}.*?$', '}]', clean)
+            
+            analise = json.loads(clean)
+            
+            # MERGE + DECAIMENTO
+            self.contexto.update(analise)
+            self.aplicar_decainento_fatos()
+            self.contexto["timestamp"] = datetime.now().isoformat()
+            
+            self.salvar_contexto()
+            return self.contexto
+            
+        except:
+            return self.contexto_fallback()
+    
+    def contexto_fallback(self):
+        return {
+            "classificacao": ["dúvida"],
+            "fatos": [],
+            "objetivo_usuario": "Análise técnica/ML/legal",
+            "duvida_central": "Processar input atual",
+            "timestamp": datetime.now().isoformat()
+        }
     
-    def fallback_plano():
-        return [
-            {"nome": "Analisador", "missao": "Analise o input principal", "modelo": "flash", "tipo_saida": "json"},
-            {"nome": "RespostaFinal", "missao": "Crie resposta clara e completa", "modelo": "pro", "tipo_saida": "texto"}
-        ]
+    def aplicar_decainento_fatos(self):
+        """DECAIMENTO: peso *= 0.95 por dia sem menção"""
+        agora = datetime.now().timestamp()
+        novos_fatos = []
+        
+        for fato in self.contexto.get("fatos", []):
+            tag, peso, input_ref, ultima = fato
+            ultima_ts = datetime.fromisoformat(ultima).timestamp()
+            dias = (agora - ultima_ts) / 86400  # dias desde ultima menção
+            peso_decay = peso * (0.95 ** dias)
+            if peso_decay > 0.1:  # Mantém fatos relevantes
+                novos_fatos.append([tag, max(0.1, peso_decay), input_ref, self.contexto["timestamp"]])
+        
+        self.contexto["fatos"] = novos_fatos[:20]  # Top 20 fatos
+
+# ==================== 3. PLANEJADOR SÓCRATES ====================
+def planejar_socrates(contexto, input_atual, history):
+    """PLANEJA baseado em CONTEXTUAL + input"""
+    if not model_pro: 
+        return fallback_plano()
     
-    history_resumo = "\n".join([f"👤: {h[0][:80]}..." for h in history_contexto[-2:]])[:150] if history_contexto else ""
+    fatos_top = "\n".join([f"- {f[0]} ({f[1]:.2f})" for f in contexto.get("fatos", [])[:5]])
     
-    prompt = f"""INPUT: {full_input[:350]}
-HISTÓRICO: {history_resumo}
+    prompt_socrates = f"""PLANEJADOR SÓCRATES v33
+
+CONTEXTO CATALOGADO:
+• Classificação: {contexto.get('classificacao', [])}
+• Fatos principais: {fatos_top}
+• Objetivo: {contexto.get('objetivo_usuario', '')}
+• Dúvida central: {contexto.get('duvida_central', '')}
 
-CRIE PLANO JSON (2-4 agentes):
+INPUT ATUAL: {input_atual}
+
+CRIE PLANO 3-5 agentes para RESOLVER PARADOXO MENON:
 [
-  {{"nome": "Analisador", "missao": "Analise input", "modelo": "flash", "tipo_saida": "json"}},
-  {{"nome": "Final", "missao": "Resposta final", "modelo": "pro", "tipo_saida": "texto"}}
-]"""
+  {{"nome": "Explorador", "missao": "Levante possibilidades", "modelo": "flash", "tipo_saida": "json"}},
+  {{"nome": "Validador", "missao": "Teste cenários", "modelo": "pro", "tipo_saida": "json"}},
+  {{"nome": "Sintetizador", "missao": "Resposta final clara", "modelo": "pro", "tipo_saida": "texto"}}
+]
+
+APENAS JSON!"""
 
     try:
-        resp = model_pro.generate_content(prompt, temperature=0.1)
-        raw = resp.text.strip()
-        clean = re.sub(r'``````|\n\s*\n', '', raw)
-        clean = re.sub(r'^.*?\[', '[', clean)
-        clean = re.sub(r'\].*?$', ']', clean)
-        
-        plano = json.loads(clean)
-        if isinstance(plano, list) and len(plano) >= 2:
-            return plano, f"✅ {len(plano)} agentes"
-        return fallback_plano(), "⚠️ Plano padrão"
+        resp = model_pro.generate_content(prompt_socrates)
+        plano_raw = re.sub(r'``````', '', resp.text.strip())
+        return json.loads(plano_raw)
     except:
-        return fallback_plano(), "⚠️ Fallback ativo"
+        return fallback_plano()
 
-# ==================== 4. EXECUTOR ====================
-def executar_no(timeline, config):
+def fallback_plano():
+    return [
+        {"nome": "Analisador", "missao": "Analise contexto + input", "modelo": "flash", "tipo_saida": "json"},
+        {"nome": "RespostaFinal", "missao": "Resposta clara e completa", "modelo": "pro", "tipo_saida": "texto"}
+    ]
+
+# ==================== 4. EXECUTOR (REUTILIZADO) ====================
+def executar_agente(timeline, config):
     if not (model_flash or model_pro):
-        return {"role": "system", "error": "Sem API"}, "(ERRO)", "Sem key"
+        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)
+    contexto = json.dumps(timeline[-8:], ensure_ascii=False)
     
-    prompt = f"TIMELINE: {contexto}\nAGENTE: {config['nome']}\nMISSÃO: {config['missao']}"
+    prompt = f"CONTEXTO: {contexto}\nAGENTE: {config['nome']}\nMISSÃO: {config['missao']}"
     
-    log = f"🔸 {config['nome']}..."
     try:
         resp = modelo.generate_content(prompt)
         out = resp.text.strip()
-        
-        if config.get('tipo_saida') == 'json':
-            out = re.sub(r'``````', '', out)
-            content = json.loads(out) if out.startswith('{') else {"resumo": out}
-        else:
-            content = out
-            
-        log += " ✓ OK"
-        return {"role": "assistant", "agent": config['nome'], "content": content}, log, out
-    except Exception as e:
-        return {"role": "system", "error": str(e)}, f"{log} ✗", str(e)
+        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
+    except:
+        return {"role": "system", "error": "Falha"}, "ERRO", "Erro agente"
+
+# ==================== 5. ORQUESTRADOR v33 ====================
+analisador = AnalisadorContextual()  # GLOBAL SINGLETON
 
-# ==================== 5. ORQUESTRADOR ====================
-def orquestrador(texto, arquivo, history, json_config):
+def orquestrador_v33(texto, arquivo, history, json_config):
     anexo = ler_anexo(arquivo)
     full_input = f"{texto}\n{anexo}".strip()
     
@@ -135,114 +193,88 @@ def orquestrador(texto, arquivo, history, json_config):
         yield history, {}, "Sem input."
         return
     
-    # Formato MESSAGES para chatbot
-    history.append([full_input, "🎯 Criando plano..."])
+    history.append([full_input, "🧠 Catalogando contexto..."])
     timeline = [{"role": "user", "content": full_input}]
-    logs = f"🚀 v32: {datetime.now().strftime('%H:%M:%S')}\n"
+    logs = f"🚀 v33 SÓCRATES: {datetime.now().strftime('%H:%M:%S')}\n"
     
     yield history, timeline, logs
     
-    plano, log_plano = criar_plano_auto(full_input, history)
-    logs += f"PLANO: {log_plano}\n"
+    # 1º PASSO: ANALISADOR CONTEXTUAL (CORAÇÃO)
+    contexto = analisador.analisar_input(full_input, history)
+    logs += f"📊 Contexto: {len(contexto.get('fatos', []))} fatos | {contexto.get('classificacao', [])} | {contexto.get('objetivo_usuario', '')[:50]}...\n"
+    timeline.append({"role": "system", "contexto": contexto})
+    
+    history[-1][1] = f"✅ Catálogo: {len(contexto.get('fatos', []))} fatos catalogados"
+    yield history, timeline, logs
+    
+    # 2º PASSO: PLANEJADOR SÓCRATES
+    plano = planejar_socrates(contexto, full_input, history)
+    logs += f"🎯 Plano: {len(plano)} agentes\n"
     timeline.append({"role": "system", "plano": plano})
     
-    history[-1][1] = f"✅ {log_plano}"
+    history[-1][1] = f"🎯 Plano Sócrates: {len(plano)} etapas"
     yield history, timeline, logs
     
-    for i, cfg in enumerate(plano):
-        history[-1][1] = f"[{i+1}/{len(plano)}] {cfg['nome']}..."
+    # 3º PASSO: EXECUTA PLANO
+    for i, agente in enumerate(plano):
+        history[-1][1] = f"[{i+1}/{len(plano)}] {agente['nome']}..."
         yield history, timeline, logs
         
-        res, log_add, raw = executar_no(timeline, cfg)
+        res, status, raw = executar_agente(timeline, agente)
         timeline.append(res)
-        logs += f"  {log_add}\n"
+        logs += f"  {status}\n"
         
-        if cfg.get('tipo_saida') == 'texto' and isinstance(res.get('content'), str):
-            history[-1][1] = res['content'][:850]
+        if agente.get('tipo_saida') == 'texto':
+            history[-1][1] = str(res.get('content', ''))[:900]
             yield history, timeline, logs
     
-    salvar_history(history)
-    logs += "✅ Concluído"
+    logs += "✅ Pipeline Sócrates concluído"
     yield history, timeline, logs
 
-# ==================== 6. UI 100% COMPATÍVEL HF SPACES ====================
-def ui_clean():
-    css = """
-    footer {display: none !important;}
-    .contain {border: none !important;}
-    """
-    
-    config_init = carregar_protocolo()
+def ler_anexo(arquivo):
+    if not arquivo: 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 ""
+
+# ==================== 6. UI v33 ====================
+def ui_v33():
+    css = "footer {display: none !important;} .contain {border: none !important;}"
     
-    with gr.Blocks(title="🚀 PIPELINE v32 - ZERO WARNINGS", css=css, theme=gr.themes.Soft()) as app:
-        gr.Markdown("# PIPELINE v32 - Auto-Plan Inteligente")
+    with gr.Blocks(title="🚀 PIPELINE v33 - SÓCRATES", css=css, theme=gr.themes.Soft()) as app:
+        gr.Markdown("# 🧠 PIPELINE v33 - ANALISADOR CONTEXTUAL + SÓCRATES")
+        gr.Markdown("*Cataloga → Planeja → Resolve paradoxo Menon*")
         
         with gr.Tabs():
-            # ABA 1: CHAT (type='messages')
             with gr.Tab("💬 Pipeline"):
-                chatbot = gr.Chatbot(
-                    height=600,
-                    show_copy_button=True,
-                    type="tuples",  # Compatível antigo
-                    label=""
-                )
+                chatbot = gr.Chatbot(height=600, show_copy_button=True, type="tuples")
                 
                 with gr.Row():
-                    with gr.Column(scale=10):
-                        txt_in = gr.Textbox(
-                            placeholder="Digite qualquer input...",
-                            lines=2,
-                            container=False,
-                            show_label=False
-                        )
-                    with gr.Column(scale=1):
-                        file_in = gr.UploadButton(
-                            "📎",
-                            file_types=[".txt", ".md", ".json", ".py"]
-                        )
-                    with gr.Column(scale=1):
-                        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
-                )
+                    txt_in = gr.Textbox(placeholder="Seu input...", lines=3, container=False)
+                    file_in = gr.UploadButton("📎", file_types=[".txt", ".py", ".json"])
+                    btn_send = gr.Button("▶️ Executar", variant="primary")
             
-            # ABA 2: DEBUG (sem 'lines')
             with gr.Tab("🔍 Debug"):
-                with gr.Row():
-                    out_dna = gr.JSON(label="Timeline")
-                    out_logs = gr.Textbox(label="Logs", lines=15)
+                out_dna = gr.JSON(label="Timeline")
+                out_logs = gr.Textbox(label="Logs", lines=15)
             
-            # ABA 3: CONFIG
-            with gr.Tab("⚙️ Config"):
-                code_json = gr.Code(
-                    value=config_init, 
-                    language="json", 
-                    label="Config (não usada)"
-                )
-                gr.Button("Salvar", variant="secondary")
+            with gr.Tab("📊 Contexto"):
+                contexto_display = gr.JSON(label="contexto_v33.json", value=analisador.contexto)
+                gr.Button("Atualizar", variant="secondary")
         
-        # TRIGGERS
-        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]
-            ).then(
-                lambda: gr.update(value=""),
-                outputs=[txt_in]
-            )
+        btn_send.click(orquestrador_v33, 
+                      [txt_in, file_in, chatbot, gr.State({})], 
+                      [chatbot, out_dna, out_logs]).then(
+            lambda: gr.update(value=""), txt_in
+        )
+        txt_in.submit(btn_send.click_fn, [txt_in, file_in, chatbot, gr.State({})], 
+                     [chatbot, out_dna, out_logs])
     
     return app
 
 if __name__ == "__main__":
-    print("🚀 PIPELINE v32 - 100% HF SPACES COMPATÍVEL")
-    print("✅ Sem warnings Gradio")
-    print("✅ Sem erros JSON plano")
-    print("✅ Python 3.10 OK")
-    
-    app = ui_clean()
-    app.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    print("🚀 v33 SÓCRATES - ANALISADOR CONTEXTUAL ATIVO")
+    print("📊 contexto_v33.json persiste fatos + pesos")
+    app = ui_v33()
+    app.launch(server_name="0.0.0.0", server_port=7860)