Upload app_v19_main.py

app_v19_main.py

@@ -0,0 +1,623 @@
+# 🚀 APP v19 COMPLETO - MAIN INTEGRADO
+
+## Arquivo: `app_v19_main.py`
+
+```python
+#!/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-1.5-flash"
+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.Column(scale=1):
+                gr.Markdown("""
+### ⚙️ Configurações
+
+**Modo Sábio**: Empatia
+
+**Modo Supervisor**: Rigor
+                """)
+        
+        # Input
+        msg_input = gr.Textbox(
+            label="Escreva sua pergunta",
+            placeholder="Digite sua pergunta...",
+            lines=2
+        )
+        
+        # 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=False)
+            modo_supervisor = gr.Checkbox(label="🛡️ Supervisor", value=True)
+        
+        # Cópia
+        copia_display = gr.Textbox(
+            label="📄 Cópia da Conversa",
+            lines=6,
+            interactive=False
+        )
+        
+        # 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
+    )
+```
+
+---
+
+## ✅ Como Rodar
+
+```bash
+# 1. Instalar dependências
+pip install gradio google-generativeai
+
+# 2. Preencher API_KEY
+# Editar app_v19_main.py, linha ~30:
+# API_KEY = "sua_chave_aqui"
+
+# 3. Rodar
+python app_v19_main.py
+
+# 4. Acessar
+# http://localhost:7860
+```
+
+---
+
+## 🎯 Resumo da Integração
+
+| Componente | Arquivo | Status |
+|------------|---------|--------|
+| **Engine Causal** | Inline (app_v19_main.py) | ✅ |
+| **Formulário Único** | FormularioCausal class | ✅ |
+| **Prompts Dinâmicos** | ConstrutorPromptsCausal class | ✅ |
+| **Interface Gradio** | criar_interface_gradio() | ✅ |
+| **DNA Schema** | criar_dna_vazio() | ✅ |
+| **Parser JSON** | ParserRespostaCausal class | ✅ |
+
+---
+
+## 📋 Checklist de Funcionalidades v19
+
+- [x] Loop iterativo (MAX 10 iterações)
+- [x] Formulário causal único
+- [x] N0 classifica tipo de input
+- [x] CENARIOS mapeia 1-6 com mais/menos provável
+- [x] PRINCIPIOS ordena por peso
+- [x] METACOG detecta empates → PERGUNTAR_USUARIO
+- [x] Interface limpa (sem DNA JSON)
+- [x] Progresso visual em tempo real
+- [x] Chat + Chatbot
+- [x] Botão copiar conversa
+- [x] Modo Sábio + Supervisor
+
+---
+
+**Pronto para testar! 🚀**
+
+Quer ajustar algo antes de rodar?