Update app.py

app.py

@@ -1,181 +1,168 @@
-# --- INÍCIO DO CÓDIGO COMPLETO E FINAL ---
-
 import gradio as gr
-import os
-import google.generativeai as genai
-import json
-
-# --- 1. CONFIGURAÇÃO DA API GEMINI ---
-# É mais seguro usar variáveis de ambiente, mas para testes, você pode inserir a chave aqui.
-api_key = os.getenv("GOOGLE_API_KEY")
-if not api_key:
-    # ⚠️ SUBSTITUA "SUA_API_KEY_AQUI" PELA SUA CHAVE REAL ANTES DE EXECUTAR
-    api_key = "SUA_API_KEY_AQUI"
-
-genai.configure(api_key=api_key)
-model = genai.GenerativeModel('gemini-flash-latest')
-
-# --- 2. PROMPT DE SISTEMA MESTRE (O "CÉREBRO" DO PROTOCOLO) ---
-PROMPT_SISTEMA = """
-Você é um especialista em análise de intenções que opera sob um protocolo de 6 passos.
-Sua função é conduzir uma conversa para entender 100% da dúvida de um usuário ANTES de respondê-la.
-Sua SAÍDA DEVE SER SEMPRE E SOMENTE um objeto JSON válido, sem nenhum texto adicional.
-
-**PROTOCOLO DE EXECUÇÃO OBRIGATÓRIO:**
-
-Analise o `estado_pipeline` atual e o `historico_conversa`. Decida qual passo executar. Sua resposta em JSON deve conter o estado COMPLETAMENTE ATUALIZADO da pipeline.
-
----
-**Passo 1: Análise Primária (Clareza)**
-- **Meta:** A dúvida é compreensível?
-- **Decisão:** Se a clareza for 'baixa', pergunte por mais contexto. Senão, defina `proximo_passo` como `"passo_2_proposito"`.
-
----
-**Passo 2: Análise de Propósito (Para Que)**
-- **Meta:** Para qual fim a resposta servirá?
-- **Decisão:** Se a confiança no propósito for 'baixa', pergunte sobre o objetivo. Senão, defina `proximo_passo` como `"passo_3_motivacao"`.
-
----
-**Passo 3: Análise de Motivação (Porquê) e Interesses**
-- **Meta:** Por que o usuário precisa da resposta agora?
-- **Decisão:** Se a confiança na motivação for 'baixa', pergunte sobre o que despertou o interesse. Senão, defina `proximo_passo` como `"passo_4_coerencia"`.
-
----
-**Passo 4: Análise de Coerência**
-- **Meta:** As informações coletadas fazem sentido juntas?
-- **Decisão:** Se a coerência for 'baixa', pergunte para resolver a contradição. Senão, defina `proximo_passo` como `"passo_5_ambiguidade"`.
-
----
-**Passo 5: Análise de Ambiguidade de Cenário (Validação de Perspectiva)**
-- **Meta:** A dúvida pode ter múltiplas respostas válidas dependendo de uma perspectiva oculta?
-- **Ação:** Revise o contexto completo. Pense se a resposta muda se o usuário for um estudante, um profissional, um entusiasta, etc.
-- **Decisão:**
-  - Se existem vários cenários de resposta válidos (confiança 'baixa'), formule uma pergunta que force o usuário a escolher uma perspectiva. Defina `proximo_passo` como `"aguardando_usuario"`.
-    - **Exemplo:** Se a dúvida é "Como otimizar um banco de dados?", pergunte: "Você está focando em otimização para velocidade de leitura, redução de custos de armazenamento, ou para escalabilidade?"
-  - Se o cenário de resposta é único e claro (confiança 'alta'), defina `proximo_passo` como `"passo_6_resposta_final"`.
-
----
-**Passo 6: Geração da Resposta Final**
-- **Meta:** Tenho 100% de clareza para dar uma resposta definitiva e sem subjetividade.
-- **Ação:** Verifique se TODOS os passos anteriores têm confiança 'alta'.
-- **Decisão:**
-  - Se sim, construa a resposta final, objetiva e completa, adaptada a todo o contexto coletado. Coloque-a em `"resposta_final"`. Defina `"proximo_passo"` como `"concluido"`.
-  - Se não, volte ao passo com a confiança mais baixa e reformule a pergunta.
-
-**ESTRUTURA JSON DE SAÍDA OBRIGATÓRIA:**
-{
-  "raciocinio_do_passo": "Sua breve justificativa interna para a decisão tomada.",
-  "proximo_passo": "string",
-  "pergunta_para_usuario": "string | null",
-  "estado_pipeline_atualizado": {
-    "passo_atual": "string",
-    "duvida_inicial": "string | null",
-    "clareza": {"confianca": "baixa|media|alta"},
-    "proposito": {"valor": "string | null", "confianca": "baixa|media|alta"},
-    "motivacao": {"valor": "string | null", "confianca": "baixa|media|alta"},
-    "coerencia": {"confianca": "baixa|media|alta"},
-    "ambiguidade": {"confianca": "baixa|media|alta"}
-  },
-  "resposta_final": "string | null"
-}
-"""
-
-# --- 3. GERENCIAMENTO DE ESTADO ---
-def resetar_estado():
-    """Inicializa ou reseta o dicionário de estado da pipeline."""
-    print("Resetando o estado da pipeline para uma nova conversa.")
-    return {
-        "passo_atual": "passo_1_clareza",
-        "duvida_inicial": None,
-        "clareza": {"confianca": "baixa"},
-        "proposito": {"valor": None, "confianca": "baixa"},
-        "motivacao": {"valor": None, "confianca": "baixa"},
-        "coerencia": {"confianca": "baixa"},
-        "ambiguidade": {"confianca": "baixa"}
-    }
+from typing import List, Dict
+import pandas as pd
+import io
+
+# --- 1. Estrutura do Dicionário Estoico (Exemplo simplificado para demonstração) ---
+# Em um ambiente de produção, este DataFrame/Dicionário seria carregado
+# do arquivo .md na inicialização do serviço.
+# Para este exemplo, vamos manter a tabela inteira como o conteúdo do arquivo
+# a ser processado.
+
+def parse_md_table(md_content: str) -> pd.DataFrame:
+    """Analisa o conteúdo de uma tabela Markdown e o retorna como um DataFrame."""
+    lines = [line.strip() for line in md_content.split('\n') if line.strip()]
+    
+    # 1. Encontra a linha do cabeçalho
+    header_line_index = next((i for i, line in enumerate(lines) if line.startswith('| :--')), None)
+    if header_line_index is None:
+        raise ValueError("Formato de tabela Markdown não reconhecido (cabeçalho de alinhamento ausente).")
+
+    # 2. Extrai o cabeçalho (a linha anterior à linha de alinhamento)
+    if header_line_index > 0:
+        header_line = lines[header_line_index - 1]
+        headers = [h.strip() for h in header_line.strip('|').split('|')]
+    else:
+        raise ValueError("Cabeçalho não encontrado antes da linha de alinhamento.")
+    
+    # 3. Extrai os dados (linhas após a linha de alinhamento)
+    data_lines = lines[header_line_index + 1:]
+    data = []
+    for line in data_lines:
+        if not line.startswith('|'): continue
+        # Remove as barras iniciais e finais, e divide
+        row_data = [item.strip() for item in line.strip('|').split('|')]
+        if len(row_data) == len(headers):
+            data.append(row_data)
+            
+    return pd.DataFrame(data, columns=headers)
 
-# Variáveis globais para manter o estado e o histórico durante a sessão
-estado_pipeline_global = resetar_estado()
-historico_conversa_llm = []
+# --- 2. Lógica de Busca e Aplicação (Simulação de um LLM Estoico) ---
 
-# --- 4. FUNÇÃO PRINCIPAL DO CHATBOT ---
-def handle_chat(mensagem, historico_chat_gradio):
+def apply_stoic_logic(user_prompt: str, table_content: str) -> str:
     """
-    Esta função é chamada a cada mensagem do usuário.
-    Ela gerencia o estado, constrói o prompt, chama a API e retorna a resposta.
-    """
-    global estado_pipeline_global, historico_conversa_llm
-
-    # Detecta o início de uma nova conversa (quando a UI é limpa) e reseta o estado interno.
-    if not historico_chat_gradio:
-        estado_pipeline_global = resetar_estado()
-        historico_conversa_llm = []
-
-    historico_conversa_llm.append({"role": "user", "parts": [mensagem]})
+    Simula o raciocínio de um LLM Estoico usando a tabela de princípios.
     
-    if estado_pipeline_global["duvida_inicial"] is None:
-        estado_pipeline_global["duvida_inicial"] = mensagem
-
-    # Monta o super-prompt com todas as instruções, o histórico e o estado atual.
-    prompt_completo = f"""
-    {PROMPT_SISTEMA}
-    ---
-    **HISTÓRICO DA CONVERSA PARA O LLM:**
-    {json.dumps(historico_conversa_llm, indent=2)}
-    ---
-    **ESTADO ATUAL DA PIPELINE:**
-    {json.dumps(estado_pipeline_global, indent=2)}
-    ---
-    **Instrução Final:** Baseado no estado e no histórico, execute o próximo passo do protocolo e gere o JSON de saída.
+    Args:
+        user_prompt: A pergunta do usuário.
+        table_content: O conteúdo Markdown da tabela dos princípios.
+        
+    Returns:
+        Uma resposta formatada com base no princípio mais relevante.
     """
+    try:
+        df = parse_md_table(table_content)
+    except ValueError as e:
+        return f"Erro ao analisar o arquivo de princípios: {e}"
 
+    # --- SIMULAÇÃO DA BUSCA DE PRINCÍPIO RELEVANTE ---
+    
+    # Simula a relevância baseada em palavras-chave para o prompt do usuário
+    if any(word in user_prompt.lower() for word in ["culpa", "sofrimento", "tranquilidade"]):
+        relevant_row = df[df['Id'] == 'I'].iloc[0]
+    elif any(word in user_prompt.lower() for word in ["perda", "morte", "apego"]):
+        relevant_row = df[df['Id'] == 'III'].iloc[0]
+    elif any(word in user_prompt.lower() for word in ["insulto", "ofensa", "raiva"]):
+        # Combinação de Va e XX
+        relevant_row = df[df['Id'] == 'Va'].iloc[0]
+        supplementary_row = df[df['Id'] == 'XX'].iloc[0]
+    elif any(word in user_prompt.lower() for word in ["futuro", "aceitar", "serenidade"]):
+        relevant_row = df[df['Id'] == 'VIII'].iloc[0]
+    else:
+        # Padrão para qualquer outra pergunta
+        relevant_row = df[df['Id'] == 'I'].iloc[0]
+
+    # --- CONSTRUÇÃO DA RESPOSTA ESTOICA ---
+    
+    response = f"**Análise Estoica para: '{user_prompt}'**\n\n"
+    
+    response += f"### Princípio Estoico Central (ID: {relevant_row['Id']})\n"
+    response += f"**Preceito:** *{relevant_row['Resumo']}*\n\n"
+    
+    if relevant_row['Id'] in ['Va', 'XX']:
+        # Lógica especial para ofensas/insultos
+        response += (
+            "A chave para lidar com isso reside em distinguir o evento de sua interpretação.\n"
+            f"O estoico Epicteto ensina: {relevant_row['Resumo']} "
+            f"({relevant_row['Porquês']}).\n"
+            f"Complementarmente, lembre-se: '{supplementary_row['Resumo']}', "
+            f"para **{supplementary_row['Porquês']}**."
+        )
+    else:
+        # Lógica padrão
+        response += (
+            "**O que fazer:** Focar neste princípio permite que você se beneficie de "
+            f"seus **{relevant_row['Tags']}**.\n"
+            "**O Porquê:** O objetivo é **"
+            f"{relevant_row['Porquês']}**."
+        )
+
+    return response.replace('#', '').replace('*', '').replace('"', '')
+
+# --- 3. Interface Gradio ---
+
+def process_file_and_prompt(file_obj, prompt: str):
+    """Lê o arquivo, extrai a tabela e aplica a lógica estoica."""
+    if file_obj is None:
+        return "⚠️ Por favor, envie o arquivo de princípios Markdown (tabela)."
+    
+    # 1. Lê o conteúdo do arquivo
     try:
-        # Envia a requisição para a API do Gemini
-        response = model.generate_content(prompt_completo)
+        file_path = file_obj.name
+        with open(file_path, 'r', encoding='utf-8') as f:
+            table_content = f.read()
+    except Exception as e:
+        return f"Erro ao ler o arquivo: {e}"
         
-        # Limpa e decodifica a resposta JSON do modelo
-        resposta_texto = response.text.strip().replace("```json", "").replace("```", "")
-        decisao_json = json.loads(resposta_texto)
-
-        # O LLM é a fonte da verdade: o estado local é substituído pelo estado retornado pela API.
-        estado_pipeline_global = decisao_json.get("estado_pipeline_atualizado", estado_pipeline_global)
+    # 2. Processa e aplica a lógica
+    return apply_stoic_logic(prompt, table_content)
+
+# Define a interface do Gradio
+with gr.Blocks(title="Consultor Estoico do Enchiridion") as demo:
+    gr.Markdown("# 📜 Consultor Estoico do Enchiridion")
+    gr.Markdown("Anexe o arquivo Markdown contendo a tabela de princípios e faça sua pergunta.")
+
+    with gr.Row():
+        # Componente para upload de arquivo
+        principles_file = gr.File(
+            label="1. Enviar Arquivo de Princípios (Tabela Markdown)",
+            type="filepath",
+            file_types=[".md", ".txt"],
+            value="epct0.md" # Preenche com o caminho do arquivo fornecido
+        )
         
-        # Decide o que mostrar ao usuário
-        if decisao_json.get("resposta_final"):
-            resposta_para_usuario = decisao_json["resposta_final"]
-            historico_conversa_llm.append({"role": "model", "parts": [resposta_para_usuario]})
-            return resposta_para_usuario
-
-        elif decisao_json.get("pergunta_para_usuario"):
-            resposta_para_usuario = decisao_json["pergunta_para_usuario"]
-            historico_conversa_llm.append({"role": "model", "parts": [resposta_para_usuario]})
-            return resposta_para_usuario
-            
-        else:
-            # Fallback para caso o JSON seja válido mas não tenha uma ação clara
-            return "Ocorreu um erro no meu raciocínio. Poderia tentar reformular?"
-
-    except (json.JSONDecodeError, AttributeError, Exception) as e:
-        print(f"Erro ao processar resposta da API: {e}")
-        try:
-            print(f"Resposta recebida (pode ter causado o erro): {response.text}")
-        except:
-            print("Não foi possível extrair o texto da resposta do erro.")
-        return "Desculpe, tive um problema técnico. Por favor, clique no botão 'Limpar' e tente novamente."
+    with gr.Row():
+        # Componente para a pergunta do usuário
+        user_prompt_input = gr.Textbox(
+            label="2. Sua Pergunta (Ex: 'Estou com raiva por um comentário ofensivo no trabalho.')",
+            lines=2,
+            placeholder="O que Epicteto diria sobre meu problema?"
+        )
+        
+    # Botão de execução
+    run_button = gr.Button("3. Consultar a Sabedoria Estoica", variant="primary")
+    
+    # Componente de saída
+    stoic_response = gr.Markdown(label="Resposta do Consultor Estoico")
 
-# --- 5. INTERFACE GRÁFICA COM GRADIO ---
-iface = gr.ChatInterface(
-    fn=handle_chat,
-    title="🤖 Protótipo Protocolo de Tom v2 Theory of Mind",
-    description="Este chatbot segue um protocolo para eliminar todas as ambiguidades antes de fornecer uma resposta 100% contextualizada. Antes da resposta o modelo pergunta o porque da pergunta.",
-    chatbot=gr.Chatbot(height=600),
-    textbox=gr.Textbox(placeholder="Qual é a sua dúvida?", container=False, scale=7),
-    theme="soft",
-    examples=[["O que é violência domestica?"], ["Como posso investir meu dinheiro?"], ["Me explique a computação quântica."]],
-)
+    # Ação do botão
+    run_button.click(
+        fn=process_file_and_prompt,
+        inputs=[principles_file, user_prompt_input],
+        outputs=[stoic_response]
+    )
 
-# --- 6. EXECUÇÃO DA APLICAÇÃO ---
+# Executa a interface
 if __name__ == "__main__":
-    iface.launch()
-
-# --- FIM DO CÓDIGO ---```
+    # Garante que o arquivo de exemplo exista na pasta Test4
+    try:
+        # A pasta Test4/epct0 (1).md é um caminho virtual na execução do LLM, 
+        # mas o Gradio tenta acessá-lo. 
+        # Como o arquivo foi fornecido no prompt, assumimos que ele está disponível 
+        # para a execução do Gradio.
+        # Não é necessário criar o arquivo fisicamente no script aqui.
+        pass
+    except Exception:
+        pass
+        
+    demo.launch()