Delete app.py

app.py

@@ -1,560 +0,0 @@
-
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-PIPELINE v19 - MOTOR CAUSAL COMPLETO
-Análise reflexiva com causalidade transparente e interface simplificada.
-
-Estrutura:
-1. Engine causal (loop iterativo)
-2. Formulário universal (N0 → CENARIOS → PRINCIPIOS → METACOG → RESPOSTA)
-3. Interface Gradio v19 (chat + progresso + cópia)
-
-Requisitos:
-- pip install gradio google-generativeai
-"""
-
-import json
-import re
-import sys
-from typing import Dict, List, Tuple, Optional
-from datetime import datetime
-import gradio as gr
-
-# ==================== CONFIG ====================
-
-API_KEY = ""  # Preencher com sua chave API Gemini
-MODEL_NAME = "gemini-flash-latest"
-MAX_ITERACOES = 10
-TEMPERATURA_PADRAO = 0.6
-
-# ==================== IMPORTS (google generative AI) ====================
-
-try:
-    import google.generativeai as genai
-    genai.configure(api_key=API_KEY)
-    counselor_model = genai.GenerativeModel(MODEL_NAME)
-except Exception as e:
-    print(f"⚠️ Erro ao configurar Gemini: {e}")
-    print("   Usando mock para testes")
-    counselor_model = None
-
-
-# ==================== DNA SCHEMA ====================
-
-def criar_dna_vazio() -> Dict:
-    """Cria estrutura de DNA vazia para novo chat."""
-    return {
-        "versao": "19.0",
-        "criado_em": datetime.now().isoformat(),
-        
-        "historico_chat": [],
-        
-        "historico_passos": {
-            "passo_causal": [],
-            "passo_verificador": []
-        },
-        
-        "memoria_contextual": {
-            "ultimos_10_turnos": {
-                "memoria_tipo": "clara",
-                "indices_chat": [],
-                "passos_completos": True
-            },
-            "turnos_anteriores": {
-                "memoria_tipo": "vaga",
-                "total_turnos_comprimidos": 0,
-                "resumo_contexto_global": "",
-                "temas_principais": [],
-                "aprendizados_chave": []
-            }
-        },
-        
-        "metadados": {
-            "total_turnos": 0,
-            "ultimo_turno_limpeza": 0,
-            "total_iteracoes": 0,
-            "modo_sabio_enabled": False,
-            "modo_supervisor_enabled": True
-        }
-    }
-
-
-# ==================== CHAMAR MODELO ====================
-
-def chamar_gemini(prompt: str, temperatura: float = 0.6) -> str:
-    """Chama Gemini API com fallback para mock."""
-    
-    if not counselor_model:
-        # Mock para testes
-        return json.dumps({
-            "tipo_input": "subjetiva_aberta",
-            "proximo_passo": "CENARIOS",
-            "cenarios": [
-                {"id": 1, "desc": "Cenário A", "probabilidade": "mais_provavel"},
-                {"id": 2, "desc": "Cenário B", "probabilidade": "menos_provavel"}
-            ]
-        })
-    
-    try:
-        response = counselor_model.generate_content(
-            prompt,
-            generation_config=genai.types.GenerationConfig(temperature=temperatura)
-        )
-        return response.text
-    except Exception as e:
-        print(f"❌ Erro ao chamar Gemini: {e}")
-        return json.dumps({"erro": str(e)})
-
-
-# ==================== FORMULÁRIO CAUSAL ====================
-
-class FormularioCausal:
-    """Schema JSON do formulário universal."""
-    
-    @staticmethod
-    def criar_inicial(
-        input_usuario: str,
-        ultimos_K_turnos: List[Dict],
-        ultimos_5_passos: List[Dict],
-        resumo_contextual: str = ""
-    ) -> Dict:
-        """Inicializa formulário para novo turno."""
-        return {
-            "turno_id": datetime.now().isoformat()[:19],
-            "input_usuario_atual": input_usuario,
-            "tipo_input": None,
-            
-            "contexto": {
-                "ultimos_K_turnos": ultimos_K_turnos[-5:],
-                "ultimos_5_passos": ultimos_5_passos[-5:] if ultimos_5_passos else [],
-                "resumo_contextual": resumo_contextual
-            },
-            
-            "formulario_causal": {
-                "questoes_herdadas": [],
-                "cenarios": [],
-                "principios": [],
-                "principios_ordenados": [],
-                "principio_dominante": None,
-                "solucao_parcial": "",
-                "justificativa": [],
-                "estado_duvida": None,
-                "motivo_nao_resolvida": "",
-                "proximo_passo": "N0",
-                "questoes_para_proximo_passo": [],
-                "o_que_ainda_nao_sei": []
-            },
-            
-            "resposta_cognitiva": None,
-            "iteracao_atual": 0
-        }
-
-
-# ==================== PARSER ====================
-
-class ParserRespostaCausal:
-    """Extrai JSON + RESPOSTA COGNITIVA."""
-    
-    @staticmethod
-    def parsear(resposta_raw: str) -> Tuple[Dict, Optional[str]]:
-        """Extrai formulário preenchido e RESPOSTA COGNITIVA."""
-        
-        formulario_preenchido = {}
-        resposta_cognitiva = None
-        
-        # 1. Extrair JSON
-        try:
-            match_json = re.search(r'\{[\s\S]*\}', resposta_raw)
-            if match_json:
-                json_str = match_json.group(0)
-                formulario_preenchido = json.loads(json_str)
-        except json.JSONDecodeError:
-            pass
-        
-        # 2. Extrair RESPOSTA COGNITIVA
-        if "RESPOSTA COGNITIVA:" in resposta_raw:
-            parts = resposta_raw.split("RESPOSTA COGNITIVA:")
-            if len(parts) > 1:
-                resposta_cognitiva = parts[1].strip()
-        
-        return formulario_preenchido, resposta_cognitiva
-    
-    @staticmethod
-    def extrair_progresso_visual(formulario: Dict, iteracao: int) -> str:
-        """Gera textbox visual do progresso."""
-        form = formulario.get("formulario_causal", {})
-        linhas = []
-        
-        linhas.append(f"📊 TURNO #{formulario.get('iteracao_atual', iteracao)}")
-        linhas.append("=" * 50)
-        
-        # N0
-        tipo = form.get("tipo_input", "?")
-        linhas.append(f"\n🎓 PASSO N0: Aluno")
-        linhas.append(f"   ├─ Tipo: {tipo}")
-        linhas.append(f"   └─ ✓ Próximo: {form.get('proximo_passo', '?')}")
-        
-        # Cenários
-        cenarios = form.get("cenarios", [])
-        if cenarios:
-            linhas.append(f"\n🎯 PASSO CENARIOS: {len(cenarios)} cenário(s)")
-            for i, cen in enumerate(cenarios[:6], 1):
-                prob_icon = "🟢" if cen.get("probabilidade") == "mais_provavel" else "🔵"
-                desc = cen.get('desc', '?')[:40]
-                linhas.append(f"   {prob_icon} C{i}: {desc}...")
-            linhas.append(f"   └─ ✓ Próximo: {form.get('proximo_passo', '?')}")
-        
-        # Princípios
-        princ_ord = form.get("principios_ordenados", [])
-        if princ_ord:
-            linhas.append(f"\n🔀 PASSO PRINCIPIOS: {len(princ_ord)} princípio(s)")
-            medals = ["🥇", "🥈", "🥉"]
-            for i, nome in enumerate(princ_ord[:3], 1):
-                medal = medals[i-1] if i <= 3 else "▪"
-                linhas.append(f"   {medal} {nome}")
-            linhas.append(f"   └─ ✓ Próximo: {form.get('proximo_passo', '?')}")
-        
-        # Metacognição
-        estado = form.get("estado_duvida")
-        if estado:
-            linhas.append(f"\n✨ PASSO METACOG: Avaliando...")
-            linhas.append(f"   ├─ Estado: {estado.upper()}")
-            linhas.append(f"   └─ ✓ Próximo: {form.get('proximo_passo', '?')}")
-        
-        # Status final
-        linhas.append("\n" + "─" * 50)
-        proximo = form.get("proximo_passo", "?")
-        if proximo == "PERGUNTAR_USUARIO":
-            linhas.append("⚠️  AGUARDANDO SUA RESPOSTA...")
-        elif proximo == "SAIDA_FINAL":
-            linhas.append("✅ PREPARANDO RESPOSTA FINAL...")
-        else:
-            linhas.append(f"🔄 Processando: {proximo}...")
-        
-        return "\n".join(linhas)
-
-
-# ==================== CONSTRUTORES DE PROMPT ====================
-
-class ConstrutorPromptsCausal:
-    """Prompts dinâmicos por passo."""
-    
-    @staticmethod
-    def construir(
-        formulario: Dict,
-        modo_sabio: bool = False,
-        tipo_passo: str = "N0"
-    ) -> str:
-        """Constrói prompt para o passo."""
-        
-        form = formulario["formulario_causal"]
-        contexto_str = json.dumps(formulario["contexto"], indent=2, ensure_ascii=False)
-        form_str = json.dumps(form, indent=2, ensure_ascii=False)
-        input_usuario = formulario["input_usuario_atual"]
-        
-        if tipo_passo == "N0":
-            return f"""PASSO N0: ALUNO - CLASSIFICANDO INPUT
-
-INPUT DO USUÁRIO:
-"{input_usuario}"
-
-CONTEXTO:
-{contexto_str}
-
-TAREFA:
-1. Classifique: factual | subjetiva_aberta | correcao | comentario | outro
-2. Próximo passo: N0 | CENARIOS | EXPLORACAO | PRINCIPIOS | METACOG | PERGUNTAR_USUARIO | SAIDA_FINAL
-
-RETORNE JSON:
-{{"tipo_input": "...", "proximo_passo": "..."}}
-"""
-        
-        elif tipo_passo == "CENARIOS":
-            return f"""PASSO CENARIOS: MAPEANDO 1-6 CENÁRIOS
-
-INPUT: "{input_usuario}"
-
-CONTEXTO: {contexto_str}
-
-TAREFA:
-Mapeie 1-6 cenários com: desc, probabilidade (mais_provavel|menos_provavel), certezas, dúvidas.
-
-RETORNE JSON:
-{{"cenarios": [{{"id": 1, "desc": "...", "probabilidade": "...", "certezas": [...], "duvidas": [...]}}], "proximo_passo": "PRINCIPIOS"}}
-"""
-        
-        elif tipo_passo == "PRINCIPIOS":
-            return f"""PASSO PRINCIPIOS: ORDENANDO
-
-CENÁRIOS: {form_str}
-
-TAREFA:
-Identifique princípios (máx 5), atribua peso 1-5, ordene por relevância.
-
-RETORNE JSON:
-{{"principios": [...], "principios_ordenados": [...], "principio_dominante": "...", "proximo_passo": "METACOG"}}
-"""
-        
-        elif tipo_passo == "METACOG":
-            return f"""PASSO METACOG: CERTEZAS vs DÚVIDAS
-
-FORMULÁRIO: {form_str}
-
-TAREFA:
-Aplique princípio dominante. Se houver empate: estado_duvida="parcial", proximo_passo="PERGUNTAR_USUARIO".
-Senão: estado_duvida="resolvida", proximo_passo="SAIDA_FINAL".
-
-RETORNE JSON:
-{{"estado_duvida": "...", "proximo_passo": "...", "pergunta_desempate": "..."}}
-"""
-        
-        elif tipo_passo == "PERGUNTAR_USUARIO":
-            return f"""PASSO PERGUNTAR_USUARIO: DESEMPATE
-
-CENÁRIOS EM QUESTÃO: {form_str}
-
-Formule pergunta clara. Finalize com: RESPOSTA COGNITIVA: [pergunta]
-
-RETORNE JSON:
-{{"proximo_passo": "N0"}}
-
-RESPOSTA:
-"""
-        
-        else:
-            return f"Passo desconhecido: {tipo_passo}"
-
-
-# ==================== ENGINE CAUSAL ====================
-
-class EngineCausal:
-    """Motor iterativo v19."""
-    
-    def __init__(self, dna: Dict, modo_sabio: bool = False, max_iteracoes: int = 10):
-        self.dna = dna
-        self.modo_sabio = modo_sabio
-        self.max_iteracoes = max_iteracoes
-    
-    def processar_turno(self) -> Tuple[str, str, Dict]:
-        """Executa loop causal completo."""
-        
-        if len(self.dna["historico_chat"]) == 0:
-            return "", "Erro: nenhuma mensagem", self.dna
-        
-        mensagem_usuario = self.dna["historico_chat"][-1]["user"]
-        
-        # Inicializar formulário
-        formulario = FormularioCausal.criar_inicial(
-            input_usuario=mensagem_usuario,
-            ultimos_K_turnos=self.dna["historico_chat"][-5:],
-            ultimos_5_passos=self.dna["historico_passos"]["passo_causal"][-5:],
-            resumo_contextual=self.dna["memoria_contextual"]["turnos_anteriores"].get(
-                "resumo_contexto_global", ""
-            )
-        )
-        
-        resposta_final = None
-        progresso_text = ""
-        
-        # Loop iterativo
-        for iteracao in range(1, self.max_iteracoes + 1):
-            formulario["iteracao_atual"] = iteracao
-            
-            print(f"\n🔄 Iteração {iteracao}")
-            print(f"   Passo: {formulario['formulario_causal']['proximo_passo']}")
-            
-            # Construir e chamar
-            prompt = ConstrutorPromptsCausal.construir(
-                formulario=formulario,
-                modo_sabio=self.modo_sabio,
-                tipo_passo=formulario["formulario_causal"]["proximo_passo"]
-            )
-            
-            resposta_raw = chamar_gemini(prompt, temperatura=TEMPERATURA_PADRAO)
-            
-            # Parsear
-            formulario_novo, resposta_cognitiva = ParserRespostaCausal.parsear(resposta_raw)
-            
-            # Mesclar
-            if formulario_novo and "formulario_causal" in formulario_novo:
-                formulario["formulario_causal"].update(formulario_novo["formulario_causal"])
-            
-            # Progresso visual
-            progresso_text = ParserRespostaCausal.extrair_progresso_visual(formulario, iteracao)
-            
-            # Registrar
-            self.dna["historico_passos"]["passo_causal"].append({
-                "iteracao": iteracao,
-                "passo_tipo": formulario["formulario_causal"].get("proximo_passo", "N0"),
-                "timestamp": datetime.now().isoformat()
-            })
-            
-            # Verificar RESPOSTA COGNITIVA
-            if resposta_cognitiva:
-                print(f"   ✅ RESPOSTA COGNITIVA em iteração {iteracao}")
-                resposta_final = resposta_cognitiva
-                break
-        
-        # Fallback
-        if not resposta_final:
-            resposta_final = (
-                "Não consegui chegar a uma resposta dentro do limite. "
-                "Poderia esclarecer melhor sua pergunta?"
-            )
-        
-        # Atualizar chat
-        self.dna["historico_chat"][-1]["assistant"] = resposta_final
-        
-        return resposta_final, progresso_text, self.dna
-
-
-# ==================== INTERFACE GRADIO ====================
-
-def criar_interface_gradio() -> gr.Blocks:
-    """Cria interface Gradio v19."""
-    
-    dna_global = criar_dna_vazio()
-    
-    with gr.Blocks(title="Pipeline v19 - Causal", theme=gr.themes.Soft()) as interface:
-        
-        gr.Markdown("""
-# 🧠 Pipeline v19 - Motor Causal
-
-Análise reflexiva com causalidade transparente.
-O modelo escolhe os próximos passos com base em dúvidas abertas.
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=3):
-                
-                # Chat
-                chat_display = gr.Chatbot(
-                    label="💬 Conversa",
-                    height=400,
-                    show_label=True
-                )
-                
-                # Progresso
-                progresso_text = gr.Textbox(
-                    label="📊 Progresso dos Passos",
-                    lines=8,
-                    interactive=False,
-                    value="Aguardando primeira mensagem..."
-                )
-                
-                with gr.Row():
-                    msg_input = gr.Textbox(
-                        label="Sua mensagem",
-                        placeholder="Digite sua pergunta...",
-                        lines=2,
-                        interactive=True,
-                        scale=9
-                    )
-                    enviar_btn = gr.Button("📤", scale=1, variant="primary")
-            
-            
-        
-        # Botões
-        with gr.Row():
-            #enviar_btn = gr.Button("📤 Enviar", variant="primary")
-            limpar_btn = gr.Button("🗑️ Limpar")
-            copiar_btn = gr.Button("📋 Copiar")
-        
-        # Checkboxes
-        with gr.Row():
-            modo_sabio = gr.Checkbox(label="💚 Modo Sábio", value=True)
-            modo_supervisor = gr.Checkbox(label="🛡️ Supervisor", value=True)
-        
-        # Cópia
-        copia_display = gr.Textbox(
-            label="📄 Cópia da Conversa",
-            lines=6,
-            interactive=True
-        )
-        
-        # Callbacks
-        def processar():
-            msg = msg_input.value
-            if not msg.strip():
-                return chat_display.value, "", ""
-            
-            # Adicionar ao chat
-            chat_list = chat_display.value if chat_display.value else []
-            dna_global["historico_chat"].append({
-                "user": msg,
-                "assistant": None,
-                "timestamp": datetime.now().isoformat()
-            })
-            dna_global["metadados"]["total_turnos"] += 1
-            
-            # Processar
-            engine = EngineCausal(dna_global, modo_sabio=modo_sabio.value)
-            resposta, progresso, _ = engine.processar_turno()
-            
-            # Atualizar displays
-            chat_list.append([msg, resposta])
-            
-            copia_linhas = []
-            for i, (user, bot) in enumerate(chat_list, 1):
-                copia_linhas.append(f"Turno {i}:\n👤 {user}\n🤖 {bot}\n")
-            copia_text = "\n".join(copia_linhas)
-            
-            return chat_list, progresso, copia_text
-        
-        def limpar():
-            nonlocal dna_global
-            dna_global = criar_dna_vazio()
-            return [], "", ""
-        
-        def copiar():
-            chat_list = chat_display.value if chat_display.value else []
-            copia_linhas = []
-            for i, (user, bot) in enumerate(chat_list, 1):
-                copia_linhas.append(f"Turno {i}:\n👤 {user}\n🤖 {bot}\n")
-            return "\n".join(copia_linhas)
-        
-        enviar_btn.click(
-            processar,
-            inputs=[],
-            outputs=[chat_display, progresso_text, copia_display]
-        )
-        
-        msg_input.submit(
-            processar,
-            inputs=[],
-            outputs=[chat_display, progresso_text, copia_display]
-        )
-        
-        limpar_btn.click(
-            limpar,
-            inputs=[],
-            outputs=[chat_display, progresso_text, msg_input, copia_display]
-        )
-        
-        copiar_btn.click(
-            copiar,
-            inputs=[],
-            outputs=[copia_display]
-        )
-    
-    return interface
-
-
-# ==================== MAIN ====================
-
-if __name__ == "__main__":
-    print("\n" + "="*70)
-    print("🚀 PIPELINE v19 - MOTOR CAUSAL")
-    print("="*70)
-    print(f"Modelo: {MODEL_NAME}")
-    print(f"Max iterações: {MAX_ITERACOES}")
-    print("="*70 + "\n")
-    
-    interface = criar_interface_gradio()
-    interface.launch(
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860
-    )