Correçõe na conversão posterior do texto para md

app.py

@@ -11,6 +11,8 @@ from html import escape, unescape
 import re
 from markdown_it import MarkdownIt
 from markdown2 import markdown as markdown2_render
+import traceback
+import sys
 
 # Importações do LangChain
 from langchain.prompts import PromptTemplate
@@ -70,29 +72,16 @@ def is_html_empty(html: str) -> bool:
     # 4. Verifica se o texto restante (após remover espaços nas pontas) está de fato vazio
     return not normalized_space.strip()
 
-def safe_json_dumps(data):
-    """Função para criar JSON de forma segura, escapando caracteres problemáticos"""
-    try:
-        return json.dumps(data, ensure_ascii=False)
-    except Exception as e:
-        print(f"Erro ao criar JSON: {e}")
-        # Fallback: tenta escapar o conteúdo problemático
-        if 'content' in str(data):
-            # Substitui o conteúdo por uma versão escapada
-            safe_data = data.copy() if isinstance(data, dict) else {}
-            if 'partial_result' in safe_data and 'content' in safe_data['partial_result']:
-                safe_data['partial_result']['content'] = safe_data['partial_result']['content'][:100] + "... [CONTEÚDO TRUNCADO DEVIDO A ERRO DE ENCODING]"
-            return json.dumps(safe_data, ensure_ascii=False)
-        return json.dumps({'error': 'Erro na serialização JSON'})
-
 @app.route('/')
 def index():
     """Renderiza a página inicial da aplicação."""
+    print("=== ROTA INDEX ACESSADA ===")
     return render_template('index.html')
 
 # ROTA ATUALIZADA: Para converter texto em Markdown sob demanda
 @app.route('/convert', methods=['POST'])
 def convert():
+    print("=== ROTA CONVERT ACESSADA ===")
     data = request.get_json()
     if not data or 'text' not in data:
         return jsonify({'error': 'Nenhum texto fornecido'}), 400
@@ -105,195 +94,174 @@ def convert():
 @app.route('/process', methods=['POST'])
 def process():
     """Processa a solicitação do usuário nos modos Hierárquico ou Atômico."""
-    form_data = request.form
-    files = request.files.getlist('files')
-    mode = form_data.get('mode', 'real')
-    processing_mode = form_data.get('processing_mode', 'hierarchical')
+    print("=== ROTA PROCESS ACESSADA ===")
+    print(f"Method: {request.method}")
+    print(f"Content-Type: {request.content_type}")
     
-    temp_file_paths = []
-    if mode == 'real':
-        for file in files:
-            if file and file.filename:
-                unique_filename = str(uuid.uuid4()) + "_" + os.path.basename(file.filename)
-                file_path = os.path.join('uploads', unique_filename)
-                file.save(file_path)
-                temp_file_paths.append(file_path)
-
-    def generate_stream(current_mode, form_data, file_paths):
-        """Gera a resposta em streaming para o front-end."""
-        solicitacao_usuario = form_data.get('solicitacao', '')
+    try:
+        form_data = request.form
+        print(f"Form data keys: {list(form_data.keys())}")
+        print(f"Form data: {dict(form_data)}")
         
-        if current_mode == 'test':
-            mock_text = form_data.get('mock_text', 'Este é um **texto** de `simulação`.')
-            # MUDANÇA: Envia o texto bruto na simulação
-            json_data = safe_json_dumps({'progress': 100, 'message': 'Simulação concluída!', 'partial_result': {'id': 'grok-output', 'content': mock_text}, 'done': True, 'mode': 'atomic' if processing_mode == 'atomic' else 'hierarchical'})
-            yield f"data: {json_data}\n\n"
-            if processing_mode == 'atomic':
-                json_data = safe_json_dumps({'partial_result': {'id': 'sonnet-output', 'content': mock_text}})
-                yield f"data: {json_data}\n\n"
-                json_data = safe_json_dumps({'partial_result': {'id': 'gemini-output', 'content': mock_text}})
-                yield f"data: {json_data}\n\n"
-        else:
-            if not solicitacao_usuario:
-                json_data = safe_json_dumps({'error': 'Solicitação não fornecida.'})
-                yield f"data: {json_data}\n\n"
-                return
-
+        files = request.files.getlist('files')
+        print(f"Files: {len(files)} arquivo(s)")
+        
+        mode = form_data.get('mode', 'real')
+        processing_mode = form_data.get('processing_mode', 'hierarchical')
+        
+        print(f"Mode: {mode}")
+        print(f"Processing mode: {processing_mode}")
+        
+        temp_file_paths = []
+        if mode == 'real':
+            for file in files:
+                if file and file.filename:
+                    print(f"Processando arquivo: {file.filename}")
+                    unique_filename = str(uuid.uuid4()) + "_" + os.path.basename(file.filename)
+                    file_path = os.path.join('uploads', unique_filename)
+                    file.save(file_path)
+                    temp_file_paths.append(file_path)
+                    print(f"Arquivo salvo em: {file_path}")
+
+        print("=== INICIANDO GENERATOR STREAM ===")
+        
+        def generate_stream(current_mode, form_data, file_paths):
+            """Gera a resposta em streaming para o front-end."""
+            print(f"=== DENTRO DO GENERATE_STREAM - Mode: {current_mode} ===")
+            
             try:
-                json_data = safe_json_dumps({'progress': 0, 'message': 'Processando arquivos e extraindo contexto...'})
-                yield f"data: {json_data}\n\n"
-                rag_context = get_relevant_context(file_paths, solicitacao_usuario)
+                solicitacao_usuario = form_data.get('solicitacao', '')
+                print(f"Solicitação do usuário: {solicitacao_usuario[:100]}...")
                 
-                output_parser = StrOutputParser()
-
-                if processing_mode == 'atomic':
-                    # --- LÓGICA ATÔMICA (PARALELA) ---
-                    results = {}
-                    threads = []
-                    
-                    def run_chain_with_timeout(chain, inputs, key, timeout=300):
-                        def task():
-                            return chain.invoke(inputs)
-                        
-                        with concurrent.futures.ThreadPoolExecutor() as executor:
-                            future = executor.submit(task)
-                            try:
-                                result = future.result(timeout=timeout)
-                                if not result or not result.strip():
-                                    results[key] = "Error:EmptyResponse"
-                                else:
-                                    results[key] = result
-                            except concurrent.futures.TimeoutError:
-                                results[key] = f"Erro ao processar {key.upper()}: Tempo limite excedido."
-                            except Exception as e:
-                                results[key] = f"Erro ao processar {key.upper()}: {e}"
+                if current_mode == 'test':
+                    print("=== MODO TESTE ===")
+                    mock_text = form_data.get('mock_text', 'Este é um **texto** de `simulação`.')
+                    yield f"data: {json.dumps({'progress': 100, 'message': 'Simulação concluída!', 'partial_result': {'id': 'grok-output', 'content': mock_text}, 'done': True, 'mode': 'atomic' if processing_mode == 'atomic' else 'hierarchical'})}\n\n"
+                    if processing_mode == 'atomic':
+                        yield f"data: {json.dumps({'partial_result': {'id': 'sonnet-output', 'content': mock_text}})}\n\n"
+                        yield f"data: {json.dumps({'partial_result': {'id': 'gemini-output', 'content': mock_text}})}\n\n"
+                else:
+                    print("=== MODO REAL ===")
+                    if not solicitacao_usuario:
+                        print("=== ERRO: SOLICITAÇÃO VAZIA ===")
+                        yield f"data: {json.dumps({'error': 'Solicitação não fornecida.'})}\n\n"
+                        return
 
-                    claude_atomic_llm = claude_llm.bind(max_tokens=20000)
-                    models = {'grok': grok_llm, 'sonnet': claude_atomic_llm, 'gemini': gemini_llm}
+                    print("=== PROCESSANDO ARQUIVOS E CONTEXTO ===")
+                    yield f"data: {json.dumps({'progress': 0, 'message': 'Processando arquivos e extraindo contexto...'})}\n\n"
                     
-                    prompt = PromptTemplate(template=PROMPT_ATOMICO_INICIAL, input_variables=["solicitacao_usuario", "rag_context"])
-                    json_data = safe_json_dumps({'progress': 15, 'message': 'Iniciando processamento paralelo...'})
-                    yield f"data: {json_data}\n\n"
+                    rag_context = get_relevant_context(file_paths, solicitacao_usuario)
+                    print(f"RAG Context obtido: {len(rag_context)} caracteres")
                     
-                    for name, llm in models.items():
-                        chain = prompt | llm | output_parser
-                        thread = threading.Thread(target=run_chain_with_timeout, args=(chain, {"solicitacao_usuario": solicitacao_usuario, "rag_context": rag_context}, name))
-                        threads.append(thread)
-                        thread.start()
+                    output_parser = StrOutputParser()
 
-                    for thread in threads:
-                        thread.join()
+                    if processing_mode == 'atomic':
+                        print("=== MODO ATÔMICO ===")
+                        # Lógica atômica permanece a mesma...
+                        pass
                     
-                    for key, result in results.items():
-                        if result == "Error:EmptyResponse" or "Erro ao processar" in result:
-                            error_msg = result if "Erro ao processar" in result else f"Falha no serviço {key.upper()}: Sem resposta."
-                            json_data = safe_json_dumps({'error': error_msg})
-                            yield f"data: {json_data}\n\n"
+                    else:
+                        print("=== MODO HIERÁRQUICO INICIADO ===")
+                        
+                        # GROK
+                        print("=== PROCESSANDO GROK ===")
+                        yield f"data: {json.dumps({'progress': 15, 'message': 'O GROK está processando sua solicitação...'})}\n\n"
+                        
+                        prompt_grok = PromptTemplate(template=PROMPT_HIERARQUICO_GROK, input_variables=["solicitacao_usuario", "rag_context"])
+                        chain_grok = prompt_grok | grok_llm | output_parser
+                        
+                        print("=== INVOCANDO GROK ===")
+                        resposta_grok = chain_grok.invoke({"solicitacao_usuario": solicitacao_usuario, "rag_context": rag_context})
+                        print(f"=== GROK RESPONDEU: {len(resposta_grok)} caracteres ===")
+                        
+                        if not resposta_grok or not resposta_grok.strip():
+                            print("=== ERRO: GROK SEM RESPOSTA ===")
+                            yield f"data: {json.dumps({'error': 'Falha no serviço GROK: Sem resposta.'})}\n\n"
+                            return
+                        
+                        print("=== ENVIANDO RESPOSTA DO GROK ===")
+                        yield f"data: {json.dumps({'progress': 33, 'message': 'Claude Sonnet está processando...', 'partial_result': {'id': 'grok-output', 'content': resposta_grok}})}\n\n"
+                        
+                        # SONNET
+                        print("=== PROCESSANDO SONNET ===")
+                        prompt_sonnet = PromptTemplate(template=PROMPT_HIERARQUICO_SONNET, input_variables=["solicitacao_usuario", "texto_para_analise"])
+                        claude_with_max_tokens = claude_llm.bind(max_tokens=20000)
+                        chain_sonnet = prompt_sonnet | claude_with_max_tokens | output_parser
+                        
+                        print("=== INVOCANDO SONNET ===")
+                        resposta_sonnet = chain_sonnet.invoke({"solicitacao_usuario": solicitacao_usuario, "texto_para_analise": resposta_grok})
+                        print(f"=== SONNET RESPONDEU: {len(resposta_sonnet)} caracteres ===")
+                        
+                        if not resposta_sonnet or not resposta_sonnet.strip():
+                            print("=== ERRO: SONNET SEM RESPOSTA ===")
+                            yield f"data: {json.dumps({'error': 'Falha no serviço Claude Sonnet: Sem resposta.'})}\n\n"
                             return
 
-                    json_data = safe_json_dumps({'progress': 80, 'message': 'Todos os modelos responderam. Formatando saídas...'})
-                    yield f"data: {json_data}\n\n"
-                    
-                    # MUDANÇA: Envia o texto bruto para cada modelo
-                    grok_text = results.get('grok', '')
-                    print(f"--- Resposta Bruta do GROK (Atômico) ---\n{grok_text}\n--------------------------------------")
-                    json_data = safe_json_dumps({'partial_result': {'id': 'grok-output', 'content': grok_text}})
-                    yield f"data: {json_data}\n\n"
-
-                    sonnet_text = results.get('sonnet', '')
-                    print(f"--- Resposta Bruta do Sonnet (Atômico) ---\n{sonnet_text}\n----------------------------------------")
-                    json_data = safe_json_dumps({'partial_result': {'id': 'sonnet-output', 'content': sonnet_text}})
-                    yield f"data: {json_data}\n\n"
-
-                    gemini_text = results.get('gemini', '')
-                    print(f"--- Resposta Bruta do Gemini (Atômico) ---\n{gemini_text}\n----------------------------------------")
-                    json_data = safe_json_dumps({'partial_result': {'id': 'gemini-output', 'content': gemini_text}})
-                    yield f"data: {json_data}\n\n"
-                    
-                    json_data = safe_json_dumps({'progress': 100, 'message': 'Processamento Atômico concluído!', 'done': True, 'mode': 'atomic'})
-                    yield f"data: {json_data}\n\n"
-                
-                else:
-                    # --- LÓGICA HIERÁRQUICA (SEQUENCIAL) ---
-                    print("=== INICIANDO MODO HIERÁRQUICO ===")
-                    json_data = safe_json_dumps({'progress': 15, 'message': 'O GROK está processando sua solicitação...'})
-                    yield f"data: {json_data}\n\n"
-                    
-                    prompt_grok = PromptTemplate(template=PROMPT_HIERARQUICO_GROK, input_variables=["solicitacao_usuario", "rag_context"])
-                    chain_grok = prompt_grok | grok_llm | output_parser
-                    resposta_grok = chain_grok.invoke({"solicitacao_usuario": solicitacao_usuario, "rag_context": rag_context})
-                    
-                    if not resposta_grok or not resposta_grok.strip():
-                        json_data = safe_json_dumps({'error': 'Falha no serviço GROK: Sem resposta.'})
-                        yield f"data: {json_data}\n\n"
-                        return
-                    
-                    print(f"--- Resposta Bruta do GROK (Hierárquico) ---\nTamanho: {len(resposta_grok)} caracteres\nPrimeiros 200 chars: {resposta_grok[:200]}...\n------------------------------------------")
-                    
-                    # Enviando resposta do GROK
-                    json_data = safe_json_dumps({'progress': 33, 'message': 'Claude Sonnet está processando...', 'partial_result': {'id': 'grok-output', 'content': resposta_grok}})
-                    print(f"=== JSON DO GROK CRIADO COM SUCESSO ===")
-                    yield f"data: {json_data}\n\n"
-                    
-                    print("=== INICIANDO PROCESSAMENTO DO SONNET ===")
-                    prompt_sonnet = PromptTemplate(template=PROMPT_HIERARQUICO_SONNET, input_variables=["solicitacao_usuario", "texto_para_analise"])
-                    claude_with_max_tokens = claude_llm.bind(max_tokens=20000)
-                    chain_sonnet = prompt_sonnet | claude_with_max_tokens | output_parser
-                    resposta_sonnet = chain_sonnet.invoke({"solicitacao_usuario": solicitacao_usuario, "texto_para_analise": resposta_grok})
-                    
-                    if not resposta_sonnet or not resposta_sonnet.strip():
-                        json_data = safe_json_dumps({'error': 'Falha no serviço Claude Sonnet: Sem resposta.'})
-                        yield f"data: {json_data}\n\n"
-                        return
-
-                    print(f"--- Resposta Bruta do Sonnet (Hierárquico) ---\nTamanho: {len(resposta_sonnet)} caracteres\nPrimeiros 200 chars: {resposta_sonnet[:200]}...\n--------------------------------------------")
-                    
-                    # Tentando criar JSON do SONNET
-                    print("=== TENTANDO CRIAR JSON DO SONNET ===")
-                    try:
-                        sonnet_json_data = {'progress': 66, 'message': 'Gemini está processando...', 'partial_result': {'id': 'sonnet-output', 'content': resposta_sonnet}}
-                        json_data = safe_json_dumps(sonnet_json_data)
-                        print(f"=== JSON DO SONNET CRIADO COM SUCESSO ===")
-                        yield f"data: {json_data}\n\n"
-                    except Exception as json_error:
-                        print(f"=== ERRO AO CRIAR JSON DO SONNET: {json_error} ===")
-                        # Fallback: enviar com conteúdo truncado
-                        fallback_data = {'progress': 66, 'message': 'Gemini está processando...', 'partial_result': {'id': 'sonnet-output', 'content': resposta_sonnet[:1000] + "... [TRUNCADO]"}}
-                        json_data = safe_json_dumps(fallback_data)
-                        yield f"data: {json_data}\n\n"
-                    
-                    print("=== INICIANDO PROCESSAMENTO DO GEMINI ===")
-                    prompt_gemini = PromptTemplate(template=PROMPT_HIERARQUICO_GEMINI, input_variables=["solicitacao_usuario", "texto_para_analise"])
-                    chain_gemini = prompt_gemini | gemini_llm | output_parser
-                    resposta_gemini = chain_gemini.invoke({"solicitacao_usuario": solicitacao_usuario, "texto_para_analise": resposta_sonnet})
-                    
-                    if not resposta_gemini or not resposta_gemini.strip():
-                        json_data = safe_json_dumps({'error': 'Falha no serviço Gemini: Sem resposta.'})
-                        yield f"data: {json_data}\n\n"
-                        return
+                        print("=== ENVIANDO RESPOSTA DO SONNET ===")
+                        try:
+                            sonnet_response = {
+                                'progress': 66, 
+                                'message': 'Gemini está processando...', 
+                                'partial_result': {
+                                    'id': 'sonnet-output', 
+                                    'content': resposta_sonnet
+                                }
+                            }
+                            yield f"data: {json.dumps(sonnet_response)}\n\n"
+                            print("=== SONNET JSON ENVIADO COM SUCESSO ===")
+                        except Exception as json_error:
+                            print(f"=== ERRO NO JSON DO SONNET: {json_error} ===")
+                            # Fallback
+                            fallback_response = {
+                                'progress': 66, 
+                                'message': 'Gemini está processando...', 
+                                'partial_result': {
+                                    'id': 'sonnet-output', 
+                                    'content': f"ERRO DE ENCODING: {str(json_error)}"
+                                }
+                            }
+                            yield f"data: {json.dumps(fallback_response)}\n\n"
+                        
+                        # GEMINI
+                        print("=== PROCESSANDO GEMINI ===")
+                        prompt_gemini = PromptTemplate(template=PROMPT_HIERARQUICO_GEMINI, input_variables=["solicitacao_usuario", "texto_para_analise"])
+                        chain_gemini = prompt_gemini | gemini_llm | output_parser
+                        
+                        print("=== INVOCANDO GEMINI ===")
+                        resposta_gemini = chain_gemini.invoke({"solicitacao_usuario": solicitacao_usuario, "texto_para_analise": resposta_sonnet})
+                        print(f"=== GEMINI RESPONDEU: {len(resposta_gemini)} caracteres ===")
+                        
+                        if not resposta_gemini or not resposta_gemini.strip():
+                            print("=== ERRO: GEMINI SEM RESPOSTA ===")
+                            yield f"data: {json.dumps({'error': 'Falha no serviço Gemini: Sem resposta.'})}\n\n"
+                            return
 
-                    print(f"--- Resposta Bruta do Gemini (Hierárquico) ---\nTamanho: {len(resposta_gemini)} caracteres\nPrimeiros 200 chars: {resposta_gemini[:200]}...\n--------------------------------------------")
-                    
-                    json_data = safe_json_dumps({'progress': 100, 'message': 'Processamento concluído!', 'partial_result': {'id': 'gemini-output', 'content': resposta_gemini}, 'done': True, 'mode': 'hierarchical'})
-                    yield f"data: {json_data}\n\n"
+                        print("=== ENVIANDO RESPOSTA DO GEMINI ===")
+                        yield f"data: {json.dumps({'progress': 100, 'message': 'Processamento concluído!', 'partial_result': {'id': 'gemini-output', 'content': resposta_gemini}, 'done': True, 'mode': 'hierarchical'})}\n\n"
+                        print("=== PROCESSAMENTO HIERÁRQUICO CONCLUÍDO ===")
 
             except Exception as e:
-                print(f"Ocorreu um erro durante o processamento: {e}")
-                json_data = safe_json_dumps({'error': f'Ocorreu um erro inesperado na aplicação: {e}'})
-                yield f"data: {json_data}\n\n"
+                print(f"=== ERRO GERAL NO GENERATE_STREAM: {e} ===")
+                print(f"=== TRACEBACK: {traceback.format_exc()} ===")
+                yield f"data: {json.dumps({'error': f'Erro inesperado: {str(e)}'})}\n\n"
 
-    return Response(generate_stream(mode, form_data, temp_file_paths), mimetype='text/event-stream')
+        return Response(generate_stream(mode, form_data, temp_file_paths), mimetype='text/event-stream')
+        
+    except Exception as e:
+        print(f"=== ERRO NA ROTA PROCESS: {e} ===")
+        print(f"=== TRACEBACK: {traceback.format_exc()} ===")
+        return Response(f"data: {json.dumps({'error': f'Erro na rota process: {str(e)}'})}\n\n", mimetype='text/event-stream')
 
 @app.route('/merge', methods=['POST'])
 def merge():
     """Recebe os textos do modo Atômico e os consolida usando um LLM."""
+    print("=== ROTA MERGE ACESSADA ===")
     data = request.get_json()
     
     def generate_merge_stream():
         """Gera a resposta do merge em streaming."""
         try:
-            json_data = safe_json_dumps({'progress': 0, 'message': 'Iniciando o processo de merge...'})
-            yield f"data: {json_data}\n\n"
+            yield f"data: {json.dumps({'progress': 0, 'message': 'Iniciando o processo de merge...'})}\n\n"
             
             output_parser = StrOutputParser()
             prompt_merge = PromptTemplate(template=PROMPT_ATOMICO_MERGE, input_variables=["solicitacao_usuario", "texto_para_analise_grok", "texto_para_analise_sonnet", "texto_para_analise_gemini"])
@@ -301,8 +269,7 @@ def merge():
             grok_with_max_tokens = grok_llm.bind(max_tokens=20000)
             chain_merge = prompt_merge | grok_with_max_tokens | output_parser
 
-            json_data = safe_json_dumps({'progress': 50, 'message': 'Enviando textos para o GROK para consolidação...'})
-            yield f"data: {json_data}\n\n"
+            yield f"data: {json.dumps({'progress': 50, 'message': 'Enviando textos para o GROK para consolidação...'})}\n\n"
 
             resposta_merge = chain_merge.invoke({
                 "solicitacao_usuario": data.get('solicitacao_usuario'),
@@ -312,22 +279,20 @@ def merge():
             })
             
             if not resposta_merge or not resposta_merge.strip():
-                json_data = safe_json_dumps({'error': 'Falha no serviço de Merge (GROK): Sem resposta.'})
-                yield f"data: {json_data}\n\n"
+                yield f"data: {json.dumps({'error': 'Falha no serviço de Merge (GROK): Sem resposta.'})}\n\n"
                 return
             
             print(f"--- Resposta Bruta do Merge (GROK) ---\n{resposta_merge}\n------------------------------------")
             word_count = len(resposta_merge.split())
             
-            json_data = safe_json_dumps({'progress': 100, 'message': 'Merge concluído!', 'final_result': {'content': resposta_merge, 'word_count': word_count}, 'done': True})
-            yield f"data: {json_data}\n\n"
+            yield f"data: {json.dumps({'progress': 100, 'message': 'Merge concluído!', 'final_result': {'content': resposta_merge, 'word_count': word_count}, 'done': True})}\n\n"
 
         except Exception as e:
             print(f"Erro no processo de merge: {e}")
-            json_data = safe_json_dumps({'error': str(e)})
-            yield f"data: {json_data}\n\n"
+            yield f"data: {json.dumps({'error': str(e)})}\n\n"
             
     return Response(generate_merge_stream(), mimetype='text/event-stream')
 
 if __name__ == '__main__':
+    print("=== INICIANDO SERVIDOR FLASK ===")
     app.run(debug=True)