Update app.py

app.py

@@ -1,6 +1,6 @@
 # ╔════════════════════════════════════════════════════════════════════════════╗
-# ║ PIPELINE v33: ANALISADOR CONTEXTUAL + PLANEJADOR SÓCRATES ║
-# ║ 1º: CATALOGA contexto → 2º: PLANEJA → 3º: EXECUTA ║
+# ║ PIPELINE v34: SÓCRATES CONTEXTUAL | HF SPACES 100% OK ║
+# ║ FIX: sem gr.State() | sem click_fn | UI compatível ║
 # ╚════════════════════════════════════════════════════════════════════════════╝
 
 import os
@@ -22,10 +22,10 @@ if api_key:
 else:
     model_flash = model_pro = None
 
-ARQUIVO_CONTEXT = "contexto_v33.json"
-ARQUIVO_HISTORY = "history_v33.json"
+ARQUIVO_CONTEXT = "contexto_v34.json"
+ARQUIVO_HISTORY = "history_v34.json"
 
-# ==================== 2. SISTEMA CONTEXTUAL (CORAÇÃO) ====================
+# ==================== 2. ANALISADOR CONTEXTUAL (CORAÇÃO) ====================
 class AnalisadorContextual:
     def __init__(self):
         self.contexto = self.carregar_contexto()
@@ -37,141 +37,95 @@ class AnalisadorContextual:
         except:
             return {
                 "classificacao": [],
-                "fatos": [],  # [tag, peso, input_ref, ultima_atualizacao]
+                "fatos": [],
                 "objetivo_usuario": "",
-                "dúvida_central": "",
+                "duvida_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)
+        try:
+            with open(ARQUIVO_CONTEXT, "w", encoding="utf-8") as f:
+                json.dump(self.contexto, f, ensure_ascii=False, indent=2)
+        except: pass
     
     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]
+        history_resumo = "\n".join([f"👤: {h[0][:80]}..." for h in history[-3:]])[:300]
         
-        prompt_analise = f"""ANALISE CONTEXTUAL v33 - CATALOGUE SEM RESPONDER
-
-INPUT ATUAL: {input_atual}
-HISTÓRICO RECENTE: {history_resumo}
+        prompt = f"""CATALOGUE SEM RESPONDER:
 
-PREENCHA FORMULÁRIO JSON:
+INPUT: {input_atual[:400]}
+HISTÓRICO: {history_resumo}
 
+JSON:
 {{
-  "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()}"
-}}
-
-✅ 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!"""
+  "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_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
+            resp = model_pro.generate_content(prompt, temperature=0.1)
+            raw = re.sub(r'``````|\n\s*\n', '', resp.text.strip())
+            analise = json.loads(raw)
             self.contexto.update(analise)
-            self.aplicar_decainento_fatos()
+            self.aplicar_decainento()
             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()
-        }
+        return {"classificacao": ["dúvida"], "fatos": [], "objetivo_usuario": "Análise geral", "duvida_central": input_atual}
     
-    def aplicar_decainento_fatos(self):
-        """DECAIMENTO: peso *= 0.95 por dia sem menção"""
-        agora = datetime.now().timestamp()
+    def aplicar_decainento(self):
+        agora = time.time()
         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()
-    
-    fatos_top = "\n".join([f"- {f[0]} ({f[1]:.2f})" for f in contexto.get("fatos", [])[:5]])
-    
-    prompt_socrates = f"""PLANEJADOR SÓCRATES v33
+            peso = fato[1] * 0.95
+            if peso > 0.1:
+                novos_fatos.append([fato[0], peso, fato[2], self.contexto["timestamp"]])
+        self.contexto["fatos"] = novos_fatos[:15]
 
-CONTEXTO CATALOGADO:
-• Classificação: {contexto.get('classificacao', [])}
-• Fatos principais: {fatos_top}
-• Objetivo: {contexto.get('objetivo_usuario', '')}
-• Dúvida central: {contexto.get('duvida_central', '')}
+# ==================== 3. PLANEJADOR + EXECUTOR ====================
+analisador = AnalisadorContextual()
 
-INPUT ATUAL: {input_atual}
-
-CRIE PLANO 3-5 agentes para RESOLVER PARADOXO MENON:
-[
-  {{"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"}}
-]
+def fallback_plano():
+    return [
+        {"nome": "Analisador", "missao": "Analise contexto + input", "modelo": "flash", "tipo_saida": "json"},
+        {"nome": "RespostaFinal", "missao": "Resposta clara completa", "modelo": "pro", "tipo_saida": "texto"}
+    ]
 
-APENAS JSON!"""
+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: {contexto}
+INPUT: {input_atual[:200]}
 
+PLANO JSON 3 agentes:
+[{{"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"}}]"""
+    
     try:
-        resp = model_pro.generate_content(prompt_socrates)
+        resp = model_pro.generate_content(prompt)
         plano_raw = re.sub(r'``````', '', resp.text.strip())
         return json.loads(plano_raw)
     except:
         return fallback_plano()
 
-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):
+    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[-8:], ensure_ascii=False)
-    
+    contexto = json.dumps(timeline[-6:], ensure_ascii=False)
     prompt = f"CONTEXTO: {contexto}\nAGENTE: {config['nome']}\nMISSÃO: {config['missao']}"
     
     try:
@@ -180,42 +134,47 @@ def executar_agente(timeline, config):
         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"
+        return {"role": "system", "error": "Erro"}, "ERRO", "Falha"
 
-# ==================== 5. ORQUESTRADOR v33 ====================
-analisador = AnalisadorContextual()  # GLOBAL SINGLETON
+# ==================== 4. ORQUESTRADOR v34 ====================
+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 ""
 
-def orquestrador_v33(texto, arquivo, history, json_config):
+def orquestrador_v34(texto, arquivo, history, json_config):
     anexo = ler_anexo(arquivo)
-    full_input = f"{texto}\n{anexo}".strip()
+    full_input = f"{texto}{anexo}".strip()
     
     if not full_input:
-        yield history, {}, "Sem input."
+        yield history, {}, "Sem input"
         return
     
-    history.append([full_input, "🧠 Catalogando contexto..."])
+    history.append([full_input, "🧠 Catalogando..."])
     timeline = [{"role": "user", "content": full_input}]
-    logs = f"🚀 v33 SÓCRATES: {datetime.now().strftime('%H:%M:%S')}\n"
+    logs = f"🚀 v34: {datetime.now().strftime('%H:%M:%S')}\n"
     
     yield history, timeline, logs
     
-    # 1º PASSO: ANALISADOR CONTEXTUAL (CORAÇÃO)
+    # 1. ANALISADOR CONTEXTUAL
     contexto = analisador.analisar_input(full_input, history)
-    logs += f"📊 Contexto: {len(contexto.get('fatos', []))} fatos | {contexto.get('classificacao', [])} | {contexto.get('objetivo_usuario', '')[:50]}...\n"
+    logs += f"📊 {len(contexto.get('fatos',[]))} fatos | {contexto.get('classificacao')}\n"
     timeline.append({"role": "system", "contexto": contexto})
     
-    history[-1][1] = f"✅ Catálogo: {len(contexto.get('fatos', []))} fatos catalogados"
+    history[-1][1] = f"✅ {len(contexto.get('fatos',[]))} fatos catalogados"
     yield history, timeline, logs
     
-    # 2º PASSO: PLANEJADOR SÓCRATES
-    plano = planejar_socrates(contexto, full_input, history)
+    # 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"🎯 Plano Sócrates: {len(plano)} etapas"
+    history[-1][1] = f"🎯 {len(plano)} etapas planejadas"
     yield history, timeline, logs
     
-    # 3º PASSO: EXECUTA PLANO
+    # 3. EXECUTA
     for i, agente in enumerate(plano):
         history[-1][1] = f"[{i+1}/{len(plano)}] {agente['nome']}..."
         yield history, timeline, logs
@@ -224,57 +183,63 @@ def orquestrador_v33(texto, arquivo, history, json_config):
         timeline.append(res)
         logs += f"  {status}\n"
         
-        if agente.get('tipo_saida') == 'texto':
-            history[-1][1] = str(res.get('content', ''))[:900]
+        if agente.get('tipo_saida') == 'texto' and res.get('content'):
+            history[-1][1] = str(res['content'])[:900]
             yield history, timeline, logs
     
-    logs += "✅ Pipeline Sócrates concluído"
+    logs += "✅ Sócrates concluído"
     yield history, timeline, logs
 
-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():
+# ==================== 5. UI v34 (100% COMPATÍVEL) ====================
+def ui_v34():
     css = "footer {display: none !important;} .contain {border: none !important;}"
     
-    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*")
+    config_init = "[]"
+    
+    with gr.Blocks(title="🚀 PIPELINE v34 - SÓCRATES", css=css, theme=gr.themes.Soft()) as app:
+        gr.Markdown("# 🧠 PIPELINE v34 - ANALISADOR + SÓCRATES")
         
         with gr.Tabs():
             with gr.Tab("💬 Pipeline"):
                 chatbot = gr.Chatbot(height=600, show_copy_button=True, type="tuples")
                 
                 with gr.Row():
-                    txt_in = gr.Textbox(placeholder="Seu input...", lines=3, container=False)
+                    txt_in = gr.Textbox(placeholder="Digite input...", 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)
             
             with gr.Tab("🔍 Debug"):
                 out_dna = gr.JSON(label="Timeline")
                 out_logs = gr.Textbox(label="Logs", lines=15)
             
             with gr.Tab("📊 Contexto"):
-                contexto_display = gr.JSON(label="contexto_v33.json", value=analisador.contexto)
-                gr.Button("Atualizar", variant="secondary")
+                contexto_json = gr.JSON(label="contexto_v34.json", value={})
+                gr.Button("Atualizar", variant="secondary").click(
+                    lambda: analisador.contexto, outputs=contexto_json
+                )
         
-        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])
+        # TRIGGERS CORRIGIDOS
+        btn_send.click(
+            orquestrador_v34,
+            inputs=[txt_in, file_in, chatbot, gr.Textbox(value="[]")],
+            outputs=[chatbot, out_dna, out_logs]
+        ).then(lambda: "", outputs=txt_in)
+        
+        txt_in.submit(
+            orquestrador_v34,
+            inputs=[txt_in, file_in, chatbot, gr.Textbox(value="[]")],
+            outputs=[chatbot, out_dna, out_logs]
+        ).then(lambda: "", outputs=txt_in)
     
     return app
 
 if __name__ == "__main__":
-    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)
+    print("🚀 v34 SÓCRATES - 100% HF SPACES OK")
+    print("✅ Sem gr.State() | Sem click_fn")
+    print("📊 contexto_v34.json persiste memória")
+    
+    app = ui_v34()
+    app.launch(server_name="0.0.0.0", server_port=7860, share=False)