Update app.py

app.py

@@ -1,376 +1,178 @@
 import os
 import io
 import re
-import json
 import streamlit as st
 from docx import Document
 from docx.shared import Cm, Pt
 from docx.enum.text import WD_ALIGN_PARAGRAPH
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from google import genai
 from google.genai import types
+from tenacity import retry, stop_after_attempt, wait_exponential
 
-# ─── CONFIGURAÇÃO DA PÁGINA ───────────────────────────────────────────────
-st.set_page_config(page_title="Corretor TCC - UNIFAGOC", page_icon="⚖️", layout="wide")
+# ─── CONFIG ───────────────────────────────────────────────────────────────
+st.set_page_config(page_title="Corretor TCC - UNIFAGOC", page_icon="⚖", layout="wide")
+api_key = st.secrets.get("GEMINI_API_KEY", os.environ.get("GEMINI_API_KEY"))
+if not api_key:
+    st.error("❌ Defina GEMINI_API_KEY nos Secrets do Streamlit.")
+    st.stop()
+client = genai.Client(api_key=api_key)
+MODEL = "gemini-3.5-flash"
 
-# ─── ESQUEMAS DE DADOS (PYDANTIC) ─────────────────────────────────────────
+# ─── MODELOS ──────────────────────────────────────────────────────────────
 class AuditoriaTCC(BaseModel):
-    aderencia_percentual: int
-    diagnostico_geral: str
-    problema_identificado_no_projeto: str
-    tcc_respondeu_ao_problema: bool
-    justificativa_problema: str
-    objetivos_especificos_identificados: list[str]
-    objetivos_nao_cumpridos_no_tcc: list[str]
-    desvios_de_tema_ou_linguica: list[str]
-    indicios_texto_generico_ia: list[str]
-    nota_tema_problema: float
-    nota_introducao_metodo: float
-    nota_estruturacao: float
-    nota_formatacao_abnt: float
-    justificativa_notas_banca: str
+    aderencia_percentual: int = Field(ge=0, le=100)
+    diagnostico_geral: str = ""
+    problema_identificado_no_projeto: str = ""
+    tcc_respondeu_ao_problema: bool = False
+    justificativa_problema: str = ""
+    objetivos_especificos_identificados: list[str] = Field(default_factory=list)
+    objetivos_nao_cumpridos_no_tcc: list[str] = Field(default_factory=list)
+    desvios_de_tema_ou_linguica: list[str] = Field(default_factory=list)
+    indicios_texto_generico_ia: list[str] = Field(default_factory=list)
+    nota_tema_problema: float = 0.0
+    nota_introducao_metodo: float = 0.0
+    nota_estruturacao: float = 0.0
+    nota_formatacao_abnt: float = 0.0
+    justificativa_notas_banca: str = ""
 
 class ErroTexto(BaseModel):
     original: str
     corrigido: str
-    motivo: str
+    motivo: str = ""
 
 class RevisaoInteligente(BaseModel):
-    correcoes: list[ErroTexto]
-    termos_estrangeiros_para_italico: list[str]
-
-# ─── AUTENTICAÇÃO GEMINI ──────────────────────────────────────────────────
-api_key = os.environ.get("GEMINI_API_KEY")
-if not api_key:
-    st.error("❌ ERRO: A variável de ambiente GEMINI_API_KEY não foi encontrada nos Secrets.")
-    st.stop()
-
-client = genai.Client(api_key=api_key)
-
-# ─── FUNÇÕES AUXILIARES ───────────────────────────────────────────────────
-def extrair_texto_docx(arquivo_upload) -> str:
-    doc = Document(arquivo_upload)
-    linhas = [para.text.strip() for para in doc.paragraphs if para.text.strip()]
-    return "\n\n".join(linhas)
-
-def extrair_referencias_docx(doc: Document) -> list:
-    resultado = []
-    em_refs = False
-    for i, para in enumerate(doc.paragraphs):
-        texto = para.text.strip()
-        if not texto: continue
-        if re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", texto, re.IGNORECASE):
-            em_refs = True
-            continue
-        if em_refs:
-            if len(texto) < 120 and texto.isupper() and not texto[0].isdigit(): break
-            resultado.append((i, texto))
-    return resultado
+    correcoes: list[ErroTexto] = Field(default_factory=list)
+    termos_estrangeiros_para_italico: list[str] = Field(default_factory=list)
+
+# ─── HELPERS ──────────────────────────────────────────────────────────────
+@retry(wait=wait_exponential(2, 30), stop=stop_after_attempt(3))
+def chamar_gemini(prompt, schema, temp=0.0):
+    return client.models.generate_content(
+        model=MODEL,
+        contents=prompt,
+        config=types.GenerateContentConfig(
+            temperature=temp,
+            response_mime_type="application/json",
+            response_schema=schema
+        )
+    )
+
+@st.cache_data(show_spinner=False)
+def extrair_texto_docx(_bytes) -> str:
+    doc = Document(io.BytesIO(_bytes))
+    return "\n\n".join(p.text.strip() for p in doc.paragraphs if p.text.strip())
 
 def docx_to_bytes(doc: Document) -> bytes:
-    byte_io = io.BytesIO()
-    doc.save(byte_io)
-    return byte_io.getvalue()
+    bio = io.BytesIO()
+    doc.save(bio)
+    return bio.getvalue()
 
 def estimar_paginas(doc: Document) -> int:
-    palavras_totales = 0
-    for para in doc.paragraphs:
-        if re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", para.text, re.IGNORECASE): break 
-        palavras_totales += len(para.text.split())
-    return max(1, palavras_totales // 350)
-
-def aplicar_formatacao_estrutural_unifagoc(doc: Document):
-    """Aplica o template de forma segura, sem corromper o XML original."""
-    # 1. Margens Oficiais da Instituição
-    for section in doc.sections:
-        section.page_height = Cm(29.7)
-        section.page_width = Cm(21.0)
-        section.top_margin = Cm(3.0)
-        section.left_margin = Cm(3.0)
-        section.bottom_margin = Cm(2.0)
-        section.right_margin = Cm(2.0)
-
-    # 2. Configura o estilo "Normal" global para evitar quebra de runs
-    if 'Normal' in doc.styles:
-        style = doc.styles['Normal']
-        if style.font:
-            style.font.name = 'Calibri'
-            style.font.size = Pt(12)
-
-    em_referencias = False
-    em_resumo = False
-
-    # 3. Formatação Segura de Parágrafos
-    for para in doc.paragraphs:
-        texto = para.text.strip()
-        if not texto: continue
-
-        texto_upper = texto.upper()
-        if texto_upper.startswith("RESUMO"): em_resumo = True
-        elif texto_upper.startswith("INTRODUÇÃO"): em_resumo = False
-        elif re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", texto, re.IGNORECASE): em_referencias = True
-
-        # Alinhamento e Recuos
-        if em_referencias:
-            para.alignment = WD_ALIGN_PARAGRAPH.LEFT
-            para.paragraph_format.first_line_indent = Cm(0)
-            para.paragraph_format.space_after = Pt(6)
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(11)
-                
-        elif em_resumo:
-            para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-            para.paragraph_format.first_line_indent = Cm(0)
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(11)
-                if texto_upper != "RESUMO" and not texto_upper.startswith("PALAVRAS-CHAVE"):
-                    run.font.italic = True
-                    
-        elif texto.isupper() and len(texto) < 100: # Identifica prováveis Títulos
-            para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-            para.paragraph_format.first_line_indent = Cm(0)
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(12)
-                
-        else:
-            para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-            para.paragraph_format.first_line_indent = Cm(1.25)
-            # Limpa formatações estranhas para forçar o herdeiro "Normal" (Calibri 12)
-            for run in para.runs:
-                run.font.name = 'Calibri'
-                run.font.size = Pt(12)
-
-# ─── INTERFACE PRINCIPAL (ABAS) ───────────────────────────────────────────
-st.title("⚖️ Assistente Acadêmico - Direito UNIFAGOC")
-aba_auditoria, aba_revisao, aba_abnt = st.tabs(["🔍 Auditoria de Conteúdo e Notas", "🧠 Revisão Textual Inteligente", "📐 Formatação Total ABNT"])
-
-# ==============================================================================
-# ABA 1: AUDITORIA E PONTUAÇÃO UNIFAGOC
-# ==============================================================================
-with aba_auditoria:
-    st.markdown("Cruze o **Pré-Projeto** com o **TCC** para identificar fuga do tema e gerar a **Nota da Banca (80 pontos)**.")
-    fase_tcc = st.radio("Selecione a fase atual do trabalho:", ["TCC 1 (Apenas Introdução e Capítulo 1)", "TCC 2 (TCC Completo com Resumo e Conclusão)"], horizontal=True)
-    
-    col1, col2 = st.columns(2)
-    with col1: arq_projeto = st.file_uploader("1. Envie o Pré-Projeto (.docx)", type=["docx"], key="proj")
-    with col2: arq_tcc = st.file_uploader("2. Envie os Capítulos do TCC (.docx)", type=["docx"], key="tcc_aud")
-
-    if st.button("🔍 Iniciar Auditoria e Avaliação", type="primary"):
-        if not arq_projeto or not arq_tcc:
-            st.warning("⚠️ Envie os DOIS arquivos para realizar a comparação.")
-        else:
-            with st.spinner("Avaliando argumentos e calculando notas da banca..."):
-                texto_projeto = extrair_texto_docx(arq_projeto)
-                texto_tcc = extrair_texto_docx(arq_tcc)
-                regra_fase = "ATENÇÃO: O aluno está em TCC 1 (Apenas Introdução e Capítulo 1). NÃO penalize a ausência de Resumo e Conclusão." if "TCC 1" in fase_tcc else "O aluno está em TCC 2. O trabalho deve estar completo (Resumo, Introdução, Desenvolvimento, Conclusão e Referências)."
-                
-                prompt = f"""Você é um Professor Examinador de Direito da UNIFAGOC.
-                {regra_fase}
-                
-                === PRÉ-PROJETO ===
-                {texto_projeto}
-                
-                === TCC ===
-                {texto_tcc}
-                
-                TAREFA 1: Identifique o Problema, Objetivos e procure por fugas de tema genéricas.
-                TAREFA 2: Avalie o TCC conforme os 80 pontos da FICHA DE AVALIAÇÃO DA UNIFAGOC:
-                - Tema, Delimitação do Problema e Objeto (0 a 20 pts)
-                - Introdução e Método (0 a 20 pts)
-                - Estruturação e Desenvolvimento (0 a 20 pts)
-                - Formatação e ABNT (0 a 20 pts)
-                Seja rigoroso e acadêmico na atribuição das notas.
-                """
-                config = types.GenerateContentConfig(temperature=0.0, response_mime_type="application/json", response_schema=AuditoriaTCC)
-                
-                try:
-                    resposta = client.models.generate_content(model="gemini-3.5-flash", contents=prompt, config=config)
-                    dados = json.loads(resposta.text)
-                    
-                    st.success(f"Auditoria e Avaliação concluídas para {fase_tcc.split(' ')[0]}!")
-                    
-                    st.header("🏆 Avaliação da Banca UNIFAGOC")
-                    st.markdown("*Distribuição de 80 pontos textuais (20 pts de apresentação não inclusos).*")
-                    
-                    nota_total = sum([
-                        dados.get('nota_tema_problema', 0),
-                        dados.get('nota_introducao_metodo', 0),
-                        dados.get('nota_estruturacao', 0),
-                        dados.get('nota_formatacao_abnt', 0)
-                    ])
-                    
-                    c_nota1, c_nota2, c_nota3, c_nota4 = st.columns(4)
-                    c_nota1.metric("Tema/Problema", f"{dados.get('nota_tema_problema')}/20")
-                    c_nota2.metric("Intro/Método", f"{dados.get('nota_introducao_metodo')}/20")
-                    c_nota3.metric("Estrutura/Linguagem", f"{dados.get('nota_estruturacao')}/20")
-                    c_nota4.metric("Formatação/ABNT", f"{dados.get('nota_formatacao_abnt')}/20")
-                    
-                    st.info(f"**NOTA TEXTUAL FINAL: {nota_total}/80 pontos** \n*Justificativa da Banca:* {dados.get('justificativa_notas_banca')}")
-                    st.divider()
-                    
-                    st.metric(label="Índice de Aderência ao Projeto", value=f"{dados.get('aderencia_percentual')}%")
-                    st.write(f"**Diagnóstico:** {dados.get('diagnostico_geral')}")
-                    
-                    c1, c2 = st.columns(2)
-                    with c1:
-                        st.subheader("🎯 Problema de Pesquisa")
-                        st.write(f"**Promessa:** {dados.get('problema_identificado_no_projeto')}")
-                        if dados.get("tcc_respondeu_ao_problema"): st.success(f"✅ O TCC respondeu: {dados.get('justificativa_problema')}")
-                        else: st.error(f"❌ Não respondeu: {dados.get('justificativa_problema')}")
-                    with c2:
-                        st.subheader("📋 Objetivos")
-                        for f in dados.get("objetivos_nao_cumpridos_no_tcc", []): st.error(f"Faltou: {f}")
-                        if not dados.get("objetivos_nao_cumpridos_no_tcc"): st.success("✅ Objetivos abordados.")
-                    st.subheader("🚨 Filtro Anti-Embromação")
-                    for fuga in dados.get("desvios_de_tema_ou_linguica", []): st.warning(f"Fuga de Tema: {fuga}")
-                    for ia in dados.get("indicios_texto_generico_ia", []): st.error(f"Texto Genérico/IA: {ia}")
-                except Exception as e:
-                    if "429" in str(e): st.error("❌ A API está sobrecarregada. Aguarde 1 minuto.")
-                    else: st.error(f"Erro: {e}")
-
-# ==============================================================================
-# ABA 2: REVISÃO TEXTUAL INTELIGENTE
-# ==============================================================================
-with aba_revisao:
-    st.markdown("A IA analisa o contexto para corrigir **Ortografia**, parágrafos indevidamente em **CAIXA ALTA** e aplica **Itálico** em termos estrangeiros/latinos.")
-    arq_revisao = st.file_uploader("Envie o TCC (.docx) para revisão inteligente", type=["docx"], key="rev")
-    
-    if st.button("🧠 Realizar Revisão Inteligente"):
-        if arq_revisao:
-            with st.spinner("Lendo o documento para identificar jargões, caixa alta e erros..."):
-                texto = extrair_texto_docx(arq_revisao)
-                prompt_rev = f"""Analise o texto acadêmico de Direito abaixo e identifique:
-                1. Erros ortográficos e gramaticais.
-                2. Trechos do corpo do texto que estão indevidamente em CAIXA ALTA (retorne a versão corrigida). Ignore títulos.
-                3. Termos estrangeiros ou jargões em latim (ex: habeas corpus, fake news) que necessitam de itálico.
-                TEXTO: {texto[:25000]}"""
-                
-                try:
-                    res = client.models.generate_content(
-                        model="gemini-3.5-flash", 
-                        contents=prompt_rev, 
-                        config=types.GenerateContentConfig(temperature=0.1, response_mime_type="application/json", response_schema=RevisaoInteligente)
-                    )
-                    dados_rev = json.loads(res.text)
-                    correcoes = dados_rev.get("correcoes", [])
-                    italicos = dados_rev.get("termos_estrangeiros_para_italico", [])
-                    
-                    if not correcoes and not italicos:
-                        st.success("🎉 O texto está perfeitamente revisado e sem jargões para formatar.")
-                    else:
-                        doc_rev = Document(arq_revisao)
-                        aplicadas_texto, aplicadas_italico = 0, 0
-                        
-                        if correcoes:
-                            st.subheader("📝 Correções de Texto e Caixa Alta")
-                            for c in correcoes:
-                                orig, corr = c.get("original", ""), c.get("corrigido", "")
-                                st.write(f"❌ `{orig}` ➔ ✅ `{corr}` (*{c.get('motivo')}*)")
-                                for para in doc_rev.paragraphs:
-                                    if orig in para.text:
-                                        for run in para.runs:
-                                            if orig in run.text:
-                                                run.text = run.text.replace(orig, corr, 1)
-                                                aplicadas_texto += 1
-                                                break
-
-                        if italicos:
-                            st.subheader("🪄 Termos Estrangeiros (Itálico Aplicado)")
-                            st.write(", ".join([f"*{i}*" for i in italicos]))
-                            for termo in italicos:
-                                for para in doc_rev.paragraphs:
-                                    matches = list(re.finditer(r'\b' + re.escape(termo) + r'\b', para.text, re.IGNORECASE))
-                                    for match in matches:
-                                        pos_ini, pos_fim, pos_atual = match.start(), match.end(), 0
-                                        for run in para.runs:
-                                            fim_run = pos_atual + len(run.text)
-                                            if pos_atual < pos_fim and fim_run > pos_ini:
-                                                run.italic = True
-                                                aplicadas_italico += 1
-                                            pos_atual += len(run.text)
-                        
-                        st.success(f"✅ {aplicadas_texto} correções de texto e {aplicadas_italico} itálicos aplicados!")
-                        st.download_button("⬇️ Baixar Documento Revisado (.docx)", data=docx_to_bytes(doc_rev), file_name="TCC_Revisado.docx", mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document")
-                except Exception as e:
-                    if "429" in str(e): st.error("❌ A API está sobrecarregada. Aguarde 1 minuto.")
-                    else: st.error(f"Erro ao processar: {e}")
-
-# ==============================================================================
-# ABA 3: FORMATAÇÃO TOTAL E REFERÊNCIAS ABNT
-# ==============================================================================
-with aba_abnt:
-    st.markdown("Varre todo o documento forçando a fonte **Calibri**, Margens **3x2**, Alinhamento e Espaçamentos do edital.")
-    st.warning("⏱️ **Aviso:** Se muitos alunos tentarem formatar ao mesmo tempo, aguarde 60 segundos.")
-    
-    arq_abnt = st.file_uploader("Envie o TCC (.docx) para formatar o layout estrutural", type=["docx"], key="abnt")
-    
-    if st.button("📐 Formatar Layout e Referências"):
-        if arq_abnt:
-            with st.spinner("Padronizando fontes, margens e referências... Isso pode levar um minuto."):
-                doc_abnt = Document(arq_abnt)
-                
-                paginas_estimadas = estimar_paginas(doc_abnt)
-                if paginas_estimadas > 18: st.error(f"🚨 **Atenção:** Seu TCC tem aprox. {paginas_estimadas} páginas. O limite da banca é 18.")
-                else: st.info(f"📄 Extensão estimada: {paginas_estimadas} páginas.")
-                
-                aplicar_formatacao_estrutural_unifagoc(doc_abnt)
-                st.success("✅ Estrutura Física (Margens, Fontes e Alinhamento) salva com sucesso!")
-                
-                referencias = extrair_referencias_docx(doc_abnt)
-                if not referencias:
-                    st.warning("Aviso: Nenhuma seção com o título 'REFERÊNCIAS' foi localizada.")
-                    st.download_button("⬇️ Baixar TCC Formatado", data=docx_to_bytes(doc_abnt), file_name="TCC_Padrao_UNIFAGOC.docx", mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document")
-                else:
-                    texto_refs = "\n".join(f"{i+1}. {texto}" for i, (_, texto) in enumerate(referencias))
-                    prompt_abnt = f"Verifique as referências abaixo seguindo a ABNT NBR 6023:2018. Retorne um JSON:\n{{\"problemas\": [{{\"numero\": int, \"erros\": [\"erro\"], \"elemento_negrito\": \"palavra destaque\"}}]}}\nREFERÊNCIAS:\n{texto_refs}"
-                    
-                    try:
-                        res = client.models.generate_content(
-                            model="gemini-3.5-flash", 
-                            contents=prompt_abnt, 
-                            config=types.GenerateContentConfig(temperature=0.0, response_mime_type="application/json")
-                        )
-                        problemas = json.loads(res.text).get("problemas", [])
-                        
-                        def aplicar_negrito_ref(doc, refs_problematicas):
-                            em_refs, ref_idx = False, 0
-                            for para in doc.paragraphs:
-                                texto = para.text.strip()
-                                if not texto: continue
-                                if re.search(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", texto, re.IGNORECASE):
-                                    em_refs = True
-                                    continue
-                                if not em_refs or len(texto) < 10: continue
-                                
-                                nums_prob = {p.get("numero", 0) - 1 for p in refs_problematicas}
-                                if ref_idx in nums_prob:
-                                    match = re.match(r"^((?:[A-ZÁÉÍÓÚÀÂÊÔÃÕÇ][^.;]+[.;]\s*)+)\s*(.+?)(\.\s+(?:\d+\.\s+ed|[A-Z]).*|$)", para.text)
-                                    if match:
-                                        autoria, titulo = match.group(1).strip(), match.group(2).strip()
-                                        pos_atual, pos_ini = 0, para.text.find(titulo, len(autoria))
-                                        pos_fim = pos_ini + len(titulo)
-                                        for run in para.runs:
-                                            fim_run = pos_atual + len(run.text)
-                                            if pos_atual >= pos_ini and fim_run <= pos_fim: run.bold = True
-                                            elif pos_atual < pos_fim and fim_run > pos_ini: run.bold = True
-                                            pos_atual += len(run.text)
-                                ref_idx += 1
-
-                        aplicar_negrito_ref(doc_abnt, problemas)
-                        
-                        if problemas:
-                            for p in problemas: st.write(f"⚠️ Referência #{p['numero']} ajustada: {', '.join(p['erros'])}")
-                        st.success("✅ Formatação de destaque (negrito) nas referências aplicada!")
-                        
-                        st.download_button(
-                            label="⬇️ Baixar TCC Totalmente Formatado (.docx)",
-                            data=docx_to_bytes(doc_abnt),
-                            file_name="TCC_Padrao_UNIFAGOC.docx",
-                            mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-                        )
-                    except Exception as e:
-                        if "429" in str(e): st.error("❌ A API está sobrecarregada. Aguarde 1 minuto.")
-                        else: st.error(f"Erro na verificação pela IA: {e}")
+    chars = 0
+    for p in doc.paragraphs:
+        if re.search(r"REFER[ÊE]NCIAS", p.text, re.I): break
+        chars += len(p.text)
+    return max(1, chars // 1800)
+
+def extrair_referencias_docx(doc: Document):
+    refs, em_refs = [], False
+    for i, p in enumerate(doc.paragraphs):
+        t = p.text.strip()
+        if not t: continue
+        if re.match(r"^(?:\d+\.?\s*)?REFER[ÊE]NCIAS", t, re.I):
+            em_refs = True; continue
+        if em_refs:
+            if re.match(r"^(ANEXOS?|AP[ÊE]NDICES?|APENDICE)$", t, re.I): break
+            if len(t) < 80 and t.isupper(): break
+            refs.append((i, t))
+    return refs
+
+def aplicar_formatacao_unifagoc(doc: Document):
+    for s in doc.sections:
+        s.top_margin = s.left_margin = Cm(3)
+        s.bottom_margin = s.right_margin = Cm(2)
+    normal = doc.styles['Normal']
+    normal.font.name = 'Calibri'
+    normal.font.size = Pt(12)
+    normal.paragraph_format.line_spacing = 1.5
+    normal.paragraph_format.first_line_indent = Cm(1.25)
+
+    em_ref, em_resumo = False, False
+    for p in doc.paragraphs:
+        txt = p.text.strip()
+        if not txt: continue
+        up = txt.upper()
+        if up.startswith("RESUMO"): em_resumo = True
+        elif up.startswith("INTRODUÇÃO"): em_resumo = False
+        elif re.match(r"REFER[ÊE]NCIAS", txt, re.I): em_ref = True
+
+        if em_ref:
+            p.alignment = WD_ALIGN_PARAGRAPH.LEFT
+            p.paragraph_format.first_line_indent = Cm(0)
+            for r in p.runs: r.font.size = Pt(11)
+        elif em_resumo and up not in ("RESUMO",) and not up.startswith("PALAVRAS"):
+            p.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+            for r in p.runs: r.font.italic = True; r.font.size = Pt(11)
+        elif txt.isupper() and len(txt) < 120:
+            p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            p.paragraph_format.first_line_indent = Cm(0)
+
+def aplicar_italico_seguro(paragrafo, termo):
+    texto = paragrafo.text
+    if not re.search(rf'\b{re.escape(termo)}\b', texto, re.I): return False
+    partes = re.split(rf'(\b{re.escape(termo)}\b)', texto, flags=re.I)
+    paragrafo.clear()
+    for parte in partes:
+        run = paragrafo.add_run(parte)
+        if parte.lower() == termo.lower(): run.italic = True
+    return True
+
+# ─── UI ───────────────────────────────────────────────────────────────────
+st.title("⚖ Assistente Acadêmico - Direito UNIFAGOC")
+aba1, aba2, aba3 = st.tabs(["🔍 Auditoria", "🧠 Revisão", "📐 ABNT"])
+
+with aba1:
+    fase = st.radio("Fase:", ["TCC 1", "TCC 2"], horizontal=True)
+    c1, c2 = st.columns(2)
+    with c1: proj = st.file_uploader("Pré-Projeto", type="docx", key="p1")
+    with c2: tcc = st.file_uploader("TCC", type="docx", key="t1")
+    if st.button("Auditar", type="primary", disabled=not(proj and tcc)):
+        with st.status("Auditando...", expanded=True) as s:
+            txt_p = extrair_texto_docx(proj.getvalue())
+            txt_t = extrair_texto_docx(tcc.getvalue())
+            regra = "TCC 1: não penalize ausência de Resumo/Conclusão." if fase=="TCC 1" else "TCC 2: trabalho completo."
+            prompt = f"Você é examinador UNIFAGOC. {regra}\nPROJETO:\n{txt_p}\n\nTCC:\n{txt_t}\nAvalie 80 pontos."
+            resp = chamar_gemini(prompt, AuditoriaTCC, 0.0)
+            dados: AuditoriaTCC = resp.parsed
+            s.update(label="Concluído", state="complete")
+        st.metric("Aderência", f"{dados.aderencia_percentual}%")
+        total = sum([dados.nota_tema_problema, dados.nota_introducao_metodo, dados.nota_estruturacao, dados.nota_formatacao_abnt])
+        st.info(f"Nota textual: {total}/80 — {dados.justificativa_notas_banca}")
+
+with aba2:
+    arq = st.file_uploader("TCC para revisão", type="docx", key="r1")
+    if st.button("Revisar", disabled=not arq):
+        with st.spinner("Revisando texto integral..."):
+            txt = extrair_texto_docx(arq.getvalue())
+            prompt = f"Revise ortografia, CAIXA ALTA indevida e liste termos latinos/estrangeiros para itálico. Texto:\n{txt}"
+            resp = chamar_gemini(prompt, RevisaoInteligente, 0.1)
+            rev: RevisaoInteligente = resp.parsed
+            doc = Document(io.BytesIO(arq.getvalue()))
+            mapa = {e.original: e.corrigido for e in rev.correcoes}
+            for p in doc.paragraphs:
+                for orig, corr in mapa.items():
+                    if orig in p.text:
+                        for r in p.runs: r.text = r.text.replace(orig, corr)
+            for termo in rev.termos_estrangeiros_para_italico:
+                for p in doc.paragraphs: aplicar_italico_seguro(p, termo)
+            st.download_button("Baixar revisado", docx_to_bytes(doc), "TCC_Revisado.docx")
+
+with aba3:
+    arq3 = st.file_uploader("TCC para ABNT", type="docx", key="a1")
+    if st.button("Formatar", disabled=not arq3):
+        doc = Document(io.BytesIO(arq3.getvalue()))
+        st.write(f"Páginas estimadas: {estimar_paginas(doc)}")
+        aplicar_formatacao_unifagoc(doc)
+        refs = extrair_referencias_docx(doc)
+        st.download_button("Baixar formatado", docx_to_bytes(doc), "TCC_ABNT.docx")