Melhorias no metodo Atomico

app.py

@@ -46,6 +46,36 @@ def log_print(message):
     print(f"[DEBUG] {message}", flush=True)
     sys.stdout.flush()
 
+def safe_json_dumps(data):
+    """Função para criar JSON de forma segura, com tratamento de strings muito grandes"""
+    try:
+        json_str = json.dumps(data, ensure_ascii=False)
+        
+        # Se o JSON for muito grande (> 50MB), trunca o conteúdo
+        if len(json_str.encode('utf-8')) > 50 * 1024 * 1024:
+            log_print(f"JSON muito grande ({len(json_str)} chars), truncando...")
+            if 'content' in str(data):
+                # Cria uma versão truncada
+                truncated_data = data.copy() if isinstance(data, dict) else {}
+                if 'final_result' in truncated_data and 'content' in truncated_data['final_result']:
+                    original_content = truncated_data['final_result']['content']
+                    truncated_content = original_content[:10000] + "\n\n[CONTEÚDO TRUNCADO DEVIDO AO TAMANHO - Use o botão 'Copiar' para obter o texto completo]"
+                    truncated_data['final_result']['content'] = truncated_content
+                elif 'partial_result' in truncated_data and 'content' in truncated_data['partial_result']:
+                    original_content = truncated_data['partial_result']['content']
+                    truncated_content = original_content[:10000] + "\n\n[CONTEÚDO TRUNCADO DEVIDO AO TAMANHO - Use o botão 'Copiar' para obter o texto completo]"
+                    truncated_data['partial_result']['content'] = truncated_content
+                
+                return json.dumps(truncated_data, ensure_ascii=False)
+        
+        return json_str
+    except Exception as e:
+        log_print(f"Erro ao criar JSON: {e}")
+        return json.dumps({'error': f'Erro na serialização JSON: {str(e)}'})
+
+# Variável global para armazenar o conteúdo completo do merge
+merge_full_content = ""
+
 # Função para renderização com fallback: tenta MarkdownIt, depois markdown2
 def render_markdown_cascata(texto: str) -> str:
     try:
@@ -97,6 +127,18 @@ def convert():
     converted_html = render_markdown_cascata(text_to_convert)
     return jsonify({'html': converted_html})
 
+# NOVA ROTA: Para obter o conteúdo completo do merge
+@app.route('/get-full-content', methods=['POST'])
+def get_full_content():
+    global merge_full_content
+    data = request.get_json()
+    content_type = data.get('type', 'merge')
+    
+    if content_type == 'merge' and merge_full_content:
+        return jsonify({'content': merge_full_content})
+    else:
+        return jsonify({'error': 'Conteúdo não encontrado'}), 404
+
 @app.route('/process', methods=['POST'])
 def process():
     """Processa a solicitação do usuário nos modos Hierárquico ou Atômico."""
@@ -127,19 +169,24 @@ def process():
         if current_mode == 'test':
             log_print("=== MODO TESTE EXECUTADO ===")
             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"
+            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':
-                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"
+                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:
                 log_print("=== ERRO: SOLICITAÇÃO VAZIA ===")
-                yield f"data: {json.dumps({'error': 'Solicitação não fornecida.'})}\n\n"
+                json_data = safe_json_dumps({'error': 'Solicitação não fornecida.'})
+                yield f"data: {json_data}\n\n"
                 return
 
             try:
                 log_print("=== INICIANDO PROCESSAMENTO REAL ===")
-                yield f"data: {json.dumps({'progress': 0, 'message': 'Processando arquivos e extraindo contexto...'})}\n\n"
+                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)
                 log_print(f"=== RAG CONTEXT OBTIDO: {len(rag_context)} chars ===")
                 
@@ -172,7 +219,8 @@ def process():
                     models = {'grok': grok_llm, 'sonnet': claude_atomic_llm, 'gemini': gemini_llm}
                     
                     prompt = PromptTemplate(template=PROMPT_ATOMICO_INICIAL, input_variables=["solicitacao_usuario", "rag_context"])
-                    yield f"data: {json.dumps({'progress': 15, 'message': 'Iniciando processamento paralelo...'})}\n\n"
+                    json_data = safe_json_dumps({'progress': 15, 'message': 'Iniciando processamento paralelo...'})
+                    yield f"data: {json_data}\n\n"
                     
                     for name, llm in models.items():
                         chain = prompt | llm | output_parser
@@ -186,30 +234,37 @@ def process():
                     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."
-                            yield f"data: {json.dumps({'error': error_msg})}\n\n"
+                            json_data = safe_json_dumps({'error': error_msg})
+                            yield f"data: {json_data}\n\n"
                             return
 
-                    yield f"data: {json.dumps({'progress': 80, 'message': 'Todos os modelos responderam. Formatando saídas...'})}\n\n"
+                    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', '')
                     log_print(f"--- Resposta Bruta do GROK (Atômico) ---\n{grok_text[:200]}...\n--------------------------------------")
-                    yield f"data: {json.dumps({'partial_result': {'id': 'grok-output', 'content': grok_text}})}\n\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', '')
                     log_print(f"--- Resposta Bruta do Sonnet (Atômico) ---\n{sonnet_text[:200]}...\n----------------------------------------")
-                    yield f"data: {json.dumps({'partial_result': {'id': 'sonnet-output', 'content': sonnet_text}})}\n\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', '')
                     log_print(f"--- Resposta Bruta do Gemini (Atômico) ---\n{gemini_text[:200]}...\n----------------------------------------")
-                    yield f"data: {json.dumps({'partial_result': {'id': 'gemini-output', 'content': gemini_text}})}\n\n"
+                    json_data = safe_json_dumps({'partial_result': {'id': 'gemini-output', 'content': gemini_text}})
+                    yield f"data: {json_data}\n\n"
                     
-                    yield f"data: {json.dumps({'progress': 100, 'message': 'Processamento Atômico concluído!', 'done': True, 'mode': 'atomic'})}\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:
                     log_print("=== MODO HIERÁRQUICO SELECIONADO ===")
                     # --- LÓGICA HIERÁRQUICA (SEQUENCIAL) ---
-                    yield f"data: {json.dumps({'progress': 15, 'message': 'O GROK está processando sua solicitação...'})}\n\n"
+                    json_data = safe_json_dumps({'progress': 15, 'message': 'O GROK está processando sua solicitação...'})
+                    yield f"data: {json_data}\n\n"
                     
                     log_print("=== PROCESSANDO GROK ===")
                     prompt_grok = PromptTemplate(template=PROMPT_HIERARQUICO_GROK, input_variables=["solicitacao_usuario", "rag_context"])
@@ -220,11 +275,13 @@ def process():
                     
                     if not resposta_grok or not resposta_grok.strip():
                         log_print("=== ERRO: GROK VAZIO ===")
-                        yield f"data: {json.dumps({'error': 'Falha no serviço GROK: Sem resposta.'})}\n\n"
+                        json_data = safe_json_dumps({'error': 'Falha no serviço GROK: Sem resposta.'})
+                        yield f"data: {json_data}\n\n"
                         return
                     
                     log_print("=== ENVIANDO RESPOSTA GROK PARA FRONTEND ===")
-                    yield f"data: {json.dumps({'progress': 33, 'message': 'Claude Sonnet está processando...', 'partial_result': {'id': 'grok-output', 'content': resposta_grok}})}\n\n"
+                    json_data = safe_json_dumps({'progress': 33, 'message': 'Claude Sonnet está processando...', 'partial_result': {'id': 'grok-output', 'content': resposta_grok}})
+                    yield f"data: {json_data}\n\n"
                     
                     log_print("=== PROCESSANDO SONNET ===")
                     prompt_sonnet = PromptTemplate(template=PROMPT_HIERARQUICO_SONNET, input_variables=["solicitacao_usuario", "texto_para_analise"])
@@ -236,52 +293,13 @@ def process():
                     
                     if not resposta_sonnet or not resposta_sonnet.strip():
                         log_print("=== ERRO: SONNET VAZIO ===")
-                        yield f"data: {json.dumps({'error': 'Falha no serviço Claude Sonnet: Sem resposta.'})}\n\n"
+                        json_data = safe_json_dumps({'error': 'Falha no serviço Claude Sonnet: Sem resposta.'})
+                        yield f"data: {json_data}\n\n"
                         return
 
-                    log_print("=== TENTANDO ENVIAR RESPOSTA SONNET ===")
-                    
-                    # Aqui vamos testar se o problema é no JSON
-                    try:
-                        # Primeiro, vamos testar criar o JSON sem enviar
-                        test_data = {
-                            'progress': 66, 
-                            'message': 'Gemini está processando...', 
-                            'partial_result': {
-                                'id': 'sonnet-output', 
-                                'content': resposta_sonnet
-                            }
-                        }
-                        test_json = json.dumps(test_data)
-                        log_print(f"=== JSON SONNET CRIADO COM SUCESSO: {len(test_json)} chars ===")
-                        
-                        # Agora vamos enviar
-                        yield f"data: {test_json}\n\n"
-                        log_print("=== JSON SONNET ENVIADO COM SUCESSO ===")
-                        
-                    except Exception as json_error:
-                        log_print(f"=== ERRO JSON SONNET: {json_error} ===")
-                        log_print(f"=== TIPO DA RESPOSTA SONNET: {type(resposta_sonnet)} ===")
-                        log_print(f"=== PRIMEIROS 500 CHARS SONNET: {repr(resposta_sonnet[:500])} ===")
-                        
-                        # Vamos tentar limpar a string
-                        try:
-                            # Remove caracteres problemáticos
-                            cleaned_response = resposta_sonnet.encode('utf-8', errors='ignore').decode('utf-8')
-                            fallback_data = {
-                                'progress': 66, 
-                                'message': 'Gemini está processando...', 
-                                'partial_result': {
-                                    'id': 'sonnet-output', 
-                                    'content': cleaned_response
-                                }
-                            }
-                            yield f"data: {json.dumps(fallback_data)}\n\n"
-                            log_print("=== FALLBACK SONNET ENVIADO ===")
-                        except Exception as fallback_error:
-                            log_print(f"=== FALLBACK TAMBÉM FALHOU: {fallback_error} ===")
-                            yield f"data: {json.dumps({'error': f'Erro ao processar resposta do Sonnet: {str(json_error)}'})}\n\n"
-                            return
+                    log_print("=== ENVIANDO RESPOSTA SONNET ===")
+                    json_data = safe_json_dumps({'progress': 66, 'message': 'Gemini está processando...', 'partial_result': {'id': 'sonnet-output', 'content': resposta_sonnet}})
+                    yield f"data: {json_data}\n\n"
                     
                     log_print("=== PROCESSANDO GEMINI ===")
                     prompt_gemini = PromptTemplate(template=PROMPT_HIERARQUICO_GEMINI, input_variables=["solicitacao_usuario", "texto_para_analise"])
@@ -292,30 +310,40 @@ def process():
                     
                     if not resposta_gemini or not resposta_gemini.strip():
                         log_print("=== ERRO: GEMINI VAZIO ===")
-                        yield f"data: {json.dumps({'error': 'Falha no serviço Gemini: Sem resposta.'})}\n\n"
+                        json_data = safe_json_dumps({'error': 'Falha no serviço Gemini: Sem resposta.'})
+                        yield f"data: {json_data}\n\n"
                         return
 
                     log_print("=== ENVIANDO RESPOSTA 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"
+                    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"
                     log_print("=== PROCESSAMENTO COMPLETO ===")
 
             except Exception as e:
                 log_print(f"Ocorreu um erro durante o processamento: {e}")
                 import traceback
                 log_print(f"Traceback: {traceback.format_exc()}")
-                yield f"data: {json.dumps({'error': f'Ocorreu um erro inesperado na aplicação: {e}'})}\n\n"
+                json_data = safe_json_dumps({'error': f'Ocorreu um erro inesperado na aplicação: {e}'})
+                yield f"data: {json_data}\n\n"
 
     return Response(generate_stream(mode, form_data, temp_file_paths), mimetype='text/event-stream')
 
 @app.route('/merge', methods=['POST'])
 def merge():
     """Recebe os textos do modo Atômico e os consolida usando um LLM."""
+    global merge_full_content
+    
     data = request.get_json()
+    log_print("=== ROTA MERGE ACESSADA ===")
     
     def generate_merge_stream():
         """Gera a resposta do merge em streaming."""
+        global merge_full_content
+        
         try:
-            yield f"data: {json.dumps({'progress': 0, 'message': 'Iniciando o processo de merge...'})}\n\n"
+            log_print("=== INICIANDO MERGE STREAM ===")
+            json_data = safe_json_dumps({'progress': 0, 'message': 'Iniciando o processo de merge...'})
+            yield f"data: {json_data}\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"])
@@ -323,7 +351,9 @@ def merge():
             grok_with_max_tokens = grok_llm.bind(max_tokens=20000)
             chain_merge = prompt_merge | grok_with_max_tokens | output_parser
 
-            yield f"data: {json.dumps({'progress': 50, 'message': 'Enviando textos para o GROK para consolidação...'})}\n\n"
+            json_data = safe_json_dumps({'progress': 50, 'message': 'Enviando textos para o GROK para consolidação...'})
+            yield f"data: {json_data}\n\n"
+            log_print("=== INVOCANDO CHAIN DE MERGE ===")
 
             resposta_merge = chain_merge.invoke({
                 "solicitacao_usuario": data.get('solicitacao_usuario'),
@@ -332,19 +362,39 @@ def merge():
                 "texto_para_analise_gemini": data.get('gemini_text')
             })
             
+            log_print(f"=== MERGE CONCLUÍDO: {len(resposta_merge)} chars ===")
+            
             if not resposta_merge or not resposta_merge.strip():
-                yield f"data: {json.dumps({'error': 'Falha no serviço de Merge (GROK): Sem resposta.'})}\n\n"
+                json_data = safe_json_dumps({'error': 'Falha no serviço de Merge (GROK): Sem resposta.'})
+                yield f"data: {json_data}\n\n"
                 return
             
-            log_print(f"--- Resposta Bruta do Merge (GROK) ---\n{resposta_merge}\n------------------------------------")
+            # Armazena o conteúdo completo na variável global
+            merge_full_content = resposta_merge
             word_count = len(resposta_merge.split())
             
-            # MUDANÇA: Envia o texto bruto do merge em vez de HTML
-            yield f"data: {json.dumps({'progress': 100, 'message': 'Merge concluído!', 'final_result': {'content': resposta_merge, 'word_count': word_count}, 'done': True})}\n\n"
+            log_print(f"=== CRIANDO JSON DE RESPOSTA DO MERGE ===")
+            # Usa a função safe para evitar problemas com JSON muito grande
+            json_data = safe_json_dumps({
+                'progress': 100, 
+                'message': 'Merge concluído!', 
+                'final_result': {
+                    'content': resposta_merge, 
+                    'word_count': word_count
+                }, 
+                'done': True
+            })
+            
+            log_print(f"=== JSON CRIADO: {len(json_data)} chars ===")
+            yield f"data: {json_data}\n\n"
+            log_print("=== MERGE STREAM FINALIZADO ===")
 
         except Exception as e:
             log_print(f"Erro no processo de merge: {e}")
-            yield f"data: {json.dumps({'error': str(e)})}\n\n"
+            import traceback
+            log_print(f"Traceback: {traceback.format_exc()}")
+            json_data = safe_json_dumps({'error': str(e)})
+            yield f"data: {json_data}\n\n"
             
     return Response(generate_merge_stream(), mimetype='text/event-stream')
 

config.py

@@ -89,6 +89,7 @@ PROMPT_HIERARQUICO_SONNET = """
     
     <restricoes>
         <proibido>fazer reduções do texto</proibido>
+        <proibido>elaborar um texto com mais de 30000 caracteres</proibido>
         <proibido>fazer resumos</proibido>
         <proibido>encurtar o conteúdo original</proibido>
         <proibido>usar expressões características de IA como "Não é mera..., mas é..."</proibido>
@@ -152,6 +153,7 @@ PROMPT_HIERARQUICO_GEMINI = """
         <proibido>fazer reduções do texto</proibido>
         <proibido>fazer resumos</proibido>
         <proibido>encurtar o conteúdo original</proibido>
+        <proibido>elaborar um texto com mais de 30000 caracteres</proibido>
         <proibido>usar expressões características de IA como "Não é mera..., mas é..."</proibido>
     </restricoes>
     

templates/index.html

@@ -276,6 +276,18 @@ Use o botão `Converter para MD` para ver a mágica.</textarea>
                 // Processa qualquer dado restante no buffer
                 if (buffer.trim()) {
                     debugLog(`Buffer final: ${buffer}`);
+                    // Tenta processar o buffer final como uma linha completa
+                    if (buffer.startsWith('data: ')) {
+                        const jsonData = buffer.substring(6).trim();
+                        if (jsonData) {
+                            try {
+                                const data = JSON.parse(jsonData);
+                                processStreamData(data, false);
+                            } catch (e) {
+                                console.error("Erro ao parsear JSON do buffer final:", jsonData.substring(0, 200));
+                            }
+                        }
+                    }
                 }
 
             } catch (error) {
@@ -301,7 +313,7 @@ Use o botão `Converter para MD` para ver a mágica.</textarea>
                 sonnet_text: rawTexts['sonnet-output'] || '',
                 gemini_text: rawTexts['gemini-output'] || '',
             };
-            debugLog(`Payload do merge: ${JSON.stringify({...payload, grok_length: payload.grok_text.length, sonnet_length: payload.sonnet_text.length, gemini_length: payload.gemini_text.length})}`);
+            debugLog(`Payload do merge preparado com textos de tamanho: G=${payload.grok_text.length}, S=${payload.sonnet_text.length}, G=${payload.gemini_text.length}`);
 
             try {
                 const response = await fetch('/merge', {
@@ -311,25 +323,62 @@ Use o botão `Converter para MD` para ver a mágica.</textarea>
                 });
                 if (!response.ok || !response.body) throw new Error(`Erro na resposta do servidor: ${response.statusText}`);
                 
+                debugLog("=== MERGE FETCH REALIZADO COM SUCESSO, INICIANDO STREAM ===");
                 const reader = response.body.getReader();
                 const decoder = new TextDecoder();
+                let buffer = ''; // Buffer para dados incompletos do merge
+
                 while (true) {
                     const { done, value } = await reader.read();
-                    if (done) break;
+                    if (done) {
+                        debugLog("=== MERGE STREAM FINALIZADO ===");
+                        break;
+                    }
+                    
                     const chunk = decoder.decode(value, { stream: true });
-                    const lines = chunk.split('\n\n');
+                    buffer += chunk;
+                    debugLog(`Merge chunk recebido: ${chunk.length} chars`);
+                    
+                    // Processa todas as linhas completas no buffer
+                    let lines = buffer.split('\n\n');
+                    buffer = lines.pop(); // Mantém a última linha (possivelmente incompleta) no buffer
+                    
                     lines.forEach(line => {
                         if (line.startsWith('data: ')) {
-                            const jsonData = line.substring(6);
-                            if (jsonData.trim()) {
+                            const jsonData = line.substring(6).trim();
+                            if (jsonData) {
+                                debugLog(`Merge JSON recebido: ${jsonData.substring(0, 200)}...`);
                                 try {
                                     const data = JSON.parse(jsonData);
+                                    debugLog(`Merge dados processados: ${JSON.stringify({progress: data.progress, message: data.message, hasFinalResult: !!data.final_result, error: data.error})}`);
                                     processStreamData(data, true); // true = é merge
-                                } catch (e) { console.error("Erro ao parsear JSON do merge:", jsonData); }
+                                } catch (e) {
+                                    console.error("Erro ao parsear JSON do merge:", jsonData.substring(0, 500));
+                                    console.error("Erro:", e);
+                                }
                             }
                         }
                     });
                 }
+
+                // Processa qualquer dado restante no buffer do merge
+                if (buffer.trim()) {
+                    debugLog(`Merge buffer final: ${buffer.substring(0, 200)}...`);
+                    if (buffer.startsWith('data: ')) {
+                        const jsonData = buffer.substring(6).trim();
+                        if (jsonData) {
+                            try {
+                                const data = JSON.parse(jsonData);
+                                debugLog("Processando buffer final do merge");
+                                processStreamData(data, true);
+                            } catch (e) {
+                                console.error("Erro ao parsear JSON do merge buffer final:", jsonData.substring(0, 500));
+                                console.error("Erro:", e);
+                            }
+                        }
+                    }
+                }
+
             } catch (error) {
                 debugLog(`ERRO NO MERGE: ${error.message}`);
                 showError("A conexão falhou ao tentar processar o merge.");
@@ -467,5 +516,6 @@ Use o botão `Converter para MD` para ver a mágica.</textarea>
             }
         }
     </script>
+
 </body>
 </html>