baucli 1.0.149__tar.gz → 1.0.151__tar.gz

{baucli-1.0.149 → baucli-1.0.151}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baucli
-Version: 1.0.149
+Version: 1.0.151
 Summary: Extracts verified business-logic and schema context from Oracle, PostgreSQL, MySQL and SQL Server
 Home-page: https://www.begcloud.com
 Author: BEG Support
@@ -27,6 +27,7 @@ Requires-Dist: mysql-connector-python>=8.0
 Requires-Dist: psycopg>=3.0
 Requires-Dist: python-tds>=1.12
 Requires-Dist: jsonschema>=4.18
+Requires-Dist: reportlab>=4.0
 Requires-Dist: tomli>=1.1; python_version < "3.11"
 Requires-Dist: mcp<2,>=1.2
 Provides-Extra: keyring

{baucli-1.0.149 → baucli-1.0.151}/baucli/__init__.py

@@ -3,6 +3,6 @@
 import warnings
 warnings.filterwarnings("ignore", message="urllib3 v2 only supports OpenSSL")
 
-__version__ = "1.0.149"
+__version__ = "1.0.151"
 __product__ = "BAUCLI"
 __author__ = "BEG Support"

{baucli-1.0.149 → baucli-1.0.151}/baucli/cli.py

@@ -5788,15 +5788,17 @@ def db_profile(db_name, schema, source, tables_csv):
 @click.option("-v", "--verbose", "verbose", is_flag=True, default=False,
               help="Mostra o SQL de cada etapa junto do tempo — para levar a "
                    "query lenta ao EXPLAIN PLAN.")
-@click.option("--format", "fmt", type=click.Choice(["terminal", "json", "html"], case_sensitive=False),
+@click.option("--format", "fmt", type=click.Choice(["terminal", "json", "html", "pdf"], case_sensitive=False),
               default="terminal", show_default=True,
               help="terminal = tabelas na tela (como sempre); json = contrato versionado "
                    "com TODOS os objetos (ignora --top), para CI/scripts; html = um "
-                   "arquivo só, para enviar ao cliente ou imprimir em PDF pelo navegador.")
+                   "arquivo só, para enviar ao cliente; pdf = o relatório pronto para o "
+                   "cliente (capa, resumo, seções com os nomes inteiros).")
 @click.option("--output", "out_file", default=None,
-              help="Arquivo de saída para --format json|html (default: stdout).")
+              help="Arquivo de saída para --format json|html (default: stdout) e pdf "
+                   "(default: prevoo_<SCHEMA>.pdf na pasta atual).")
 @click.option("--client", "client_name", default=None,
-              help="Nome do cliente no cabeçalho do HTML (opcional).")
+              help="Nome do cliente no cabeçalho do HTML e na capa do PDF (opcional).")
 def db_check(db_name: str, schema: str, top: int, src_max: int,
              max_cols: int, strict: bool, verbose: bool,
              fmt: str = "terminal", out_file: str = None, client_name: str = None):
@@ -5855,7 +5857,14 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
     from baucli.db_check_report import empty_report, to_json, to_html
     from baucli import __version__ as _baucli_ver
     fmt = (fmt or "terminal").lower()
-    _structured = fmt in ("json", "html")
+    _structured = fmt in ("json", "html", "pdf")
+    if fmt == "pdf":
+        # Falha ANTES de gastar minutos no banco se o reportlab não estiver aí.
+        try:
+            import reportlab  # noqa: F401
+        except ImportError:
+            raise click.ClickException("`--format pdf` precisa do reportlab: pip install reportlab "
+                                       "(instalação por pipx: pipx inject baucli reportlab)")
     report = empty_report()
     report["baucli_version"] = _baucli_ver
     if _structured:
@@ -6688,14 +6697,20 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
                          "aviso": findings["AVISO"]}
     if _structured:
         console.quiet = False
-        payload = to_json(report) if fmt == "json" else to_html(report, client=client_name)
-        if out_file:
-            Path(out_file).write_text(payload, encoding="utf-8")
-            console.print(f"[green]{fmt} gravado em {out_file}[/green] "
-                          f"[dim]({findings['CRÍTICO']} crítico, {findings['ATENÇÃO']} atenção, "
-                          f"{findings['AVISO']} aviso)[/dim]")
+        tally = (f"[dim]({findings['CRÍTICO']} crítico, {findings['ATENÇÃO']} atenção, "
+                 f"{findings['AVISO']} aviso)[/dim]")
+        if fmt == "pdf":
+            from baucli.db_check_pdf import to_pdf
+            out_file = out_file or f"prevoo_{(report.get('schema') or schema or 'schema').upper()}.pdf"
+            Path(out_file).write_bytes(to_pdf(report, client=client_name))
+            console.print(f"[green]pdf gravado em {out_file}[/green] {tally}")
         else:
-            click.echo(payload)
+            payload = to_json(report) if fmt == "json" else to_html(report, client=client_name)
+            if out_file:
+                Path(out_file).write_text(payload, encoding="utf-8")
+                console.print(f"[green]{fmt} gravado em {out_file}[/green] {tally}")
+            else:
+                click.echo(payload)
 
     if strict and findings["CRÍTICO"]:
         raise SystemExit(2)

baucli-1.0.151/baucli/db_check_pdf.py

@@ -0,0 +1,342 @@
+"""PDF do `baucli db check` (pré-voo de IA) a partir do MESMO dict do JSON/HTML.
+
+É o relatório que vai para o cliente antes da primeira carga: capa com a marca
+BAU e os KPIs, resumo executivo, as seções do diagnóstico com os nomes
+inteiros dos objetos e os próximos passos. A fonte é o dict de
+`db_check_report.empty_report` (schema_version 1); não há parse de terminal.
+
+Motor: reportlab (A4, Helvetica/Courier embutidas, sem recurso externo). O
+import é tardio para que `db_check_report` continue leve para quem só quer
+JSON/HTML; sem o reportlab instalado, `to_pdf` explica como instalar.
+"""
+from __future__ import annotations
+
+from datetime import datetime
+from io import BytesIO
+from xml.sax.saxutils import escape as _xml_escape
+
+from baucli.db_check_report import _LOGO_FILE, _n
+
+_RED, _BLACK, _DARK = "#C8102E", "#0A0A0A", "#1A1A1A"
+_GRAY, _LIGHT, _AMBER = "#6B7280", "#F3F4F6", "#B45309"
+
+
+def _esc(v) -> str:
+    return _xml_escape("" if v is None else str(v))
+
+
+def _when(iso: str | None) -> str:
+    """generated_at ISO (UTC) → 'dd/mm/aaaa hh:mm UTC'; devolve o texto cru se não parsear."""
+    if not iso:
+        return "—"
+    try:
+        return datetime.fromisoformat(iso).strftime("%d/%m/%Y %H:%M UTC")
+    except ValueError:
+        return str(iso)
+
+
+def to_pdf(report: dict, client: str | None = None) -> bytes:
+    """Renderiza o pré-voo em PDF e devolve os bytes do arquivo."""
+    try:
+        from reportlab.lib.colors import HexColor, white
+        from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+        from reportlab.lib.units import cm
+        from reportlab.platypus import (Image, PageBreak, Paragraph, SimpleDocTemplate,
+                                        Spacer, Table, TableStyle)
+    except ImportError as e:  # pragma: no cover - depende do ambiente
+        raise ImportError("`--format pdf` precisa do reportlab: pip install reportlab "
+                          "(instalação por pipx: pipx inject baucli reportlab)") from e
+
+    W, H = A4
+    cw = W - 4 * cm
+    C_RED, C_BLACK, C_DARK = HexColor(_RED), HexColor(_BLACK), HexColor(_DARK)
+    C_GRAY, C_LIGHT = HexColor(_GRAY), HexColor(_LIGHT)
+
+    base = getSampleStyleSheet()
+    st = {}
+
+    def S(name, parent, **kw):
+        st[name] = ParagraphStyle(name, parent=base[parent], **kw)
+
+    S("CoverTitle", "Title", fontSize=28, leading=34, textColor=C_BLACK, alignment=TA_CENTER, spaceAfter=6)
+    S("CoverSub", "Normal", fontSize=15, leading=19, textColor=C_RED, alignment=TA_CENTER, spaceAfter=6)
+    S("CoverInfo", "Normal", fontSize=10.5, leading=14, textColor=C_GRAY, alignment=TA_CENTER)
+    S("H1", "Heading1", fontSize=17, leading=21, textColor=C_RED, spaceBefore=16, spaceAfter=6)
+    S("H2", "Heading2", fontSize=12.5, leading=16, textColor=C_BLACK, spaceBefore=10, spaceAfter=4)
+    S("Body", "Normal", fontSize=10, leading=14, textColor=C_DARK, alignment=TA_JUSTIFY, spaceAfter=6)
+    S("Bullet", "Normal", fontSize=10, leading=13, textColor=C_DARK, leftIndent=16, bulletIndent=5, spaceAfter=2)
+    S("Small", "Normal", fontSize=8, leading=10.5, textColor=C_GRAY, spaceAfter=4)
+    S("Cell", "Normal", fontSize=7.5, leading=9.5, textColor=C_DARK)
+    S("CellMono", "Normal", fontSize=7, leading=9, textColor=C_DARK, fontName="Courier")
+    S("KpiN", "Normal", fontSize=20, leading=24, textColor=C_RED, alignment=TA_CENTER, fontName="Helvetica-Bold")
+    S("KpiL", "Normal", fontSize=8, leading=10, textColor=C_GRAY, alignment=TA_CENTER)
+
+    def P(text, style="Body"):
+        return Paragraph(text, st[style])
+
+    def B(text):
+        return Paragraph(f"<bullet>&bull;</bullet> {text}", st["Bullet"])
+
+    def mono(v):
+        return f'<font face="Courier">{_esc(v)}</font>'
+
+    def lvl(level):
+        color = {"CRÍTICO": _RED, "ATENÇÃO": _AMBER}.get(level or "", _GRAY)
+        return f'<font color="{color}"><b>{_esc(level)}</b></font>'
+
+    def tbl(header, rows, widths, right=()):
+        """Tabela com cabeçalho preto repetido a cada página; células já em markup."""
+        data = [[Paragraph(f'<b><font color="white">{_esc(h)}</font></b>', st["Cell"]) for h in header]]
+        for r in rows:
+            data.append([Paragraph(c, st["Cell"]) for c in r])
+        t = Table(data, colWidths=widths, repeatRows=1)
+        style = [("BACKGROUND", (0, 0), (-1, 0), C_BLACK), ("TEXTCOLOR", (0, 0), (-1, 0), white),
+                 ("VALIGN", (0, 0), (-1, -1), "TOP"), ("GRID", (0, 0), (-1, -1), 0.3, C_GRAY),
+                 ("ROWBACKGROUNDS", (0, 1), (-1, -1), [white, C_LIGHT]),
+                 ("TOPPADDING", (0, 0), (-1, -1), 2), ("BOTTOMPADDING", (0, 0), (-1, -1), 2),
+                 ("LEFTPADDING", (0, 0), (-1, -1), 3), ("RIGHTPADDING", (0, 0), (-1, -1), 3)]
+        for j in right:
+            style.append(("ALIGN", (j, 1), (j, -1), "RIGHT"))
+        t.setStyle(TableStyle(style))
+        return t
+
+    def compact(items, per_row=3):
+        """Lista longa de nomes em N colunas (strings cruas, escapadas aqui)."""
+        items = list(items)
+        if not items:
+            return Spacer(1, 0)
+        rows = [items[i:i + per_row] for i in range(0, len(items), per_row)]
+        rows[-1] += [""] * (per_row - len(rows[-1]))
+        data = [[Paragraph(_esc(c), st["CellMono"]) for c in r] for r in rows]
+        t = Table(data, colWidths=[cw / per_row] * per_row)
+        t.setStyle(TableStyle([("VALIGN", (0, 0), (-1, -1), "TOP"), ("GRID", (0, 0), (-1, -1), 0.2, C_LIGHT),
+                               ("ROWBACKGROUNDS", (0, 0), (-1, -1), [white, C_LIGHT]),
+                               ("TOPPADDING", (0, 0), (-1, -1), 1), ("BOTTOMPADDING", (0, 0), (-1, -1), 1),
+                               ("LEFTPADDING", (0, 0), (-1, -1), 3)]))
+        return t
+
+    def kpis(items):
+        cells = [[Paragraph(str(n), st["KpiN"]) for n, _ in items],
+                 [Paragraph(label, st["KpiL"]) for _, label in items]]
+        t = Table(cells, colWidths=[cw / len(items)] * len(items))
+        t.setStyle(TableStyle([("BOX", (0, 0), (-1, -1), 0.5, C_GRAY), ("INNERGRID", (0, 0), (-1, -1), 0.3, C_LIGHT),
+                               ("TOPPADDING", (0, 0), (-1, -1), 6), ("BOTTOMPADDING", (0, 0), (-1, -1), 6)]))
+        return t
+
+    def page_frame(canvas, doc):
+        canvas.saveState()
+        canvas.setFont("Helvetica", 7.5)
+        canvas.setFillColor(C_GRAY)
+        canvas.drawString(2 * cm, 1.2 * cm, "BAU - BEG Application Utilities  ·  Pré-voo de documentação  ·  uso restrito ao cliente")
+        canvas.drawRightString(W - 2 * cm, 1.2 * cm, f"página {doc.page}")
+        canvas.setStrokeColor(C_RED)
+        canvas.setLineWidth(0.8)
+        canvas.line(2 * cm, H - 1.5 * cm, W - 2 * cm, H - 1.5 * cm)
+        canvas.restoreState()
+
+    # ── dados ──
+    r = report
+    db = r.get("database") or {}
+    th = r.get("thresholds") or {}
+    s = r.get("summary") or {}
+    schema = r.get("schema") or "?"
+    pl = r.get("plsql") or {"total": 0, "flagged": []}
+    w = r.get("wide_tables") or {"items": []}
+    npk = r.get("no_pk") or {"items": []}
+    bv = r.get("big_views") or {"items": []}
+    inv = r.get("invalid") or {"broken": [], "stale": []}
+    nb = r.get("packages_no_body") or {"declaring": [], "spec_only": []}
+    orr = r.get("object_rules") or {}
+    enc = r.get("encoding") or {}
+    crit, aten, aviso = s.get("critico", 0), s.get("atencao", 0), s.get("aviso", 0)
+    title = f"Pré-voo de documentação - {schema}" + (f" - {client}" if client else "")
+
+    buf = BytesIO()
+    doc = SimpleDocTemplate(buf, pagesize=A4, leftMargin=2 * cm, rightMargin=2 * cm,
+                            topMargin=2 * cm, bottomMargin=2 * cm, title=title, author="BEG Support",
+                            subject="baucli db check")
+    out = []
+
+    # ── capa ──
+    out.append(Spacer(1, 2.2 * cm))
+    if _LOGO_FILE.exists():
+        out.append(Image(str(_LOGO_FILE), width=3.5 * cm, height=3.5 * cm, hAlign="CENTER"))
+        out.append(Spacer(1, 0.9 * cm))
+    out.append(P("Pré-voo de documentação", "CoverTitle"))
+    out.append(P(f"Schema {_esc(schema)}" + (f" - {_esc(client)}" if client else ""), "CoverSub"))
+    out.append(Spacer(1, 0.5 * cm))
+    out.append(P(f"Banco {_esc(db.get('alias'))} ({_esc(db.get('host'))}:{_esc(db.get('port'))}/{_esc(db.get('service'))}, "
+                 f"usuário {_esc(db.get('user'))})", "CoverInfo"))
+    out.append(P(f"Diagnóstico do <b>baucli db check</b> {_esc(r.get('baucli_version') or '')} em {_esc(_when(r.get('generated_at')))}",
+                 "CoverInfo"))
+    out.append(Spacer(1, 1.1 * cm))
+    out.append(kpis([(crit, "CRÍTICO"), (aten, "ATENÇÃO"), (aviso, "AVISO"),
+                     (_n(pl.get("total")), "objetos PL/SQL"), (_n(npk.get("total")), "tabelas sem PK")]))
+    out.append(Spacer(1, 1.3 * cm))
+    out.append(P("O que este relatório é: a leitura, somente de catálogo e sem alterar nada nem ler dados da base, do que o "
+                 "schema tem hoje e que influencia a documentação assistida por IA. Cada seção diz o que foi encontrado e "
+                 "qual o efeito prático."))
+    out.append(P("BEG Support · www.begcloud.com", "CoverInfo"))
+    out.append(PageBreak())
+
+    # ── resumo executivo ──
+    out.append(P("Resumo executivo", "H1"))
+    out.append(P(f"O schema <b>{_esc(schema)}</b> tem <b>{_n(pl.get('total'))}</b> objetos PL/SQL. O pré-voo classificou os "
+                 "achados em três níveis:"))
+    out.append(B(f"<b>{crit} CRÍTICO</b>: rotinas que não cabem numa chamada de IA (limite de {_n(th.get('source_max_chars'))} "
+                 "caracteres) ou grandes demais para edição assistida com segurança. Precisam de fatiamento por subprograma, "
+                 "refatoração ou provedor com janela maior."))
+    out.append(B(f"<b>{aten} ATENÇÃO</b>: documenta normalmente, mas o resultado deve ser revisado com cuidado (tabelas largas, "
+                 "tabelas sem chave primária, objetos inválidos com erro de compilação, packages sem corpo)."))
+    out.append(B(f"<b>{aviso} AVISO</b>: só registro; sem impedimento."))
+    out.append(Spacer(1, 0.2 * cm))
+    out.append(P(f"Limiares aplicados: {_n(th.get('source_max_chars'))} caracteres por chamada de IA · tabela até "
+                 f"{_esc(th.get('max_columns'))} colunas no prompt · corpo de package com {_n(th.get('lines_unsafe'))} linhas ou "
+                 f"mais é edição insegura · fonte dos limiares: {_esc(th.get('source'))}.", "Small"))
+    if not any((crit, aten, aviso)):
+        out.append(P("<b>Nada sinalizado</b>: o schema está dentro dos limites de IA."))
+
+    # ── 1. PL/SQL ──
+    out.append(P("1. Rotinas PL/SQL sinalizadas", "H1"))
+    out.append(P(f"{_n(pl.get('total'))} objetos no schema, <b>{len(pl['flagged'])}</b> sinalizados."))
+    if pl["flagged"]:
+        out.append(tbl(["Nível", "Tipo", "Objeto", "Linhas", "KB", "~tokens", "Por quê"],
+                       [[lvl(f.get("level")), _esc(f.get("type")), mono(f.get("name")), _n(f.get("lines")),
+                         _n(round((f.get("chars") or 0) / 1024)), _n(f.get("tokens")), _esc(f.get("reason"))]
+                        for f in pl["flagged"]],
+                       [1.6 * cm, 2.0 * cm, 5.0 * cm, 1.4 * cm, 1.2 * cm, 1.8 * cm, cw - 13.0 * cm], right=(3, 4, 5)))
+
+    # ── 2. tabelas largas ──
+    out.append(P("2. Tabelas largas", "H1"))
+    out.append(P(f"<b>{len(w['items'])}</b> tabelas com mais de {_esc(w.get('max_columns'))} colunas: a IA documenta coluna a "
+                 "coluna (fan-out), multiplicando chamadas e revisão. Tabelas com centenas de colunas costumam ser planilhas "
+                 "importadas ou estruturas desnormalizadas; vale confirmar se interessam ao catálogo."))
+    if w["items"]:
+        out.append(P("Formato: TABELA (colunas; LOBs quando houver), em ordem decrescente de colunas.", "Small"))
+        out.append(compact([f"{i['table']} ({i['columns']}{'; ' + str(i['lobs']) + ' LOB' if i.get('lobs') else ''})"
+                            for i in w["items"]]))
+
+    # ── 3. sem PK ──
+    out.append(P("3. Tabelas sem chave primária", "H1"))
+    out.append(P(f"<b>{_n(npk.get('total'))}</b> tabelas sem PK: {_n(npk.get('no_identity'))} sem nenhuma identidade de linha e "
+                 f"{_n(npk.get('with_unique'))} com chave ou índice único (caso leve). Sem chave, formulários e relatórios "
+                 "gerados não têm como apontar o registro e a ordenação de colunas perde o primeiro critério."))
+    com = [i for i in npk["items"] if i.get("has_identity")]
+    sem = [i for i in npk["items"] if not i.get("has_identity")]
+
+    def _pk(i):
+        rows_est = _n(i["rows_est"]) if i.get("rows_est") is not None else "—"
+        return f"{i['table']} ({i['columns']} col, {rows_est} lin)"
+
+    if com:
+        out.append(P(f"Com chave ou índice único ({len(com)}), caso leve:", "H2"))
+        out.append(compact([_pk(i) for i in com]))
+    if sem:
+        out.append(P(f"Sem identidade de linha ({len(sem)}). Formato: TABELA (colunas, linhas estimadas):", "H2"))
+        out.append(compact([_pk(i) for i in sem]))
+
+    # ── 4. views ──
+    out.append(P("4. Views grandes", "H1"))
+    out.append(P(f"{len(bv['items'])} acima de {_n(bv.get('limit_chars'))} caracteres."))
+    if bv["items"]:
+        out.append(tbl(["View", "Chars", "~tokens"],
+                       [[mono(i.get("view")), _n(i.get("chars")), _n(i.get("tokens"))] for i in bv["items"]],
+                       [9 * cm, 3 * cm, 3 * cm], right=(1, 2)))
+
+    # ── 5. inválidos ──
+    out.append(P("5. Objetos inválidos", "H1"))
+    out.append(P(f"<b>{_n(inv.get('total'))}</b> objetos INVALID: {len(inv['broken'])} com erro de compilação e "
+                 f"{len(inv['stale'])} invalidados em cascata. O sync extrai só objetos VALID: tudo o que está aqui fica fora "
+                 "da documentação até ser resolvido."))
+    if inv["broken"]:
+        out.append(P("Com erro de compilação", "H2"))
+        out.append(tbl(["Tipo", "Objeto", "DDL", "1º erro"],
+                       [[_esc(i.get("type")), mono(i.get("name")), _esc(i.get("last_ddl")), _esc(i.get("first_error"))]
+                        for i in inv["broken"]],
+                       [2.4 * cm, 5.6 * cm, 2.4 * cm, cw - 10.4 * cm]))
+    if inv["stale"]:
+        out.append(P(f"Só recompilar ({len(inv['stale'])})", "H2"))
+        out.append(compact([i.get("name") for i in inv["stale"]]))
+        out.append(P(f"Resolve com {mono(f'EXEC DBMS_UTILITY.COMPILE_SCHEMA({chr(39)}{schema}{chr(39)}, FALSE)')}.", "Small"))
+
+    # ── 6. packages sem corpo ──
+    out.append(P("6. Packages sem corpo", "H1"))
+    out.append(P(f"{_n(nb.get('total'))} packages só com especificação: {len(nb['declaring'])} declaram subprogramas sem "
+                 "corpo (falham em runtime; a documentação por subprograma fica sem fonte) e "
+                 f"{len(nb['spec_only'])} são só constantes e tipos (legítimo)."))
+    if nb["declaring"]:
+        out.append(tbl(["Package", "Subprogramas", "Spec", "DDL"],
+                       [[mono(i.get("package")), _n(i.get("subprograms")), _esc(i.get("spec_status")), _esc(i.get("last_ddl"))]
+                        for i in nb["declaring"]],
+                       [7 * cm, 2.6 * cm, 2 * cm, cw - 11.6 * cm], right=(1,)))
+    if nb["spec_only"]:
+        out.append(P("Spec-only: " + ", ".join(_esc(x) for x in nb["spec_only"]), "Small"))
+
+    # ── 7. regras ──
+    out.append(P("7. Objetos fora da cobertura (regras de nome)", "H1"))
+    if orr.get("skipped"):
+        out.append(P(f"Seção pulada: {_esc(orr['skipped'])}.", "Small"))
+    else:
+        out.append(P(f"{_esc(orr.get('rules'))} regras de nome classificam objetos como não produtivos. "
+                     f"<b>{_n(orr.get('excluded'))}</b> de {_n(orr.get('total_objects'))} objetos saem da cobertura. "
+                     "Confirme se alguma classe está errada para o seu padrão de nomes; a lista é ajustável por cliente."))
+        for kind, names in sorted((orr.get("by_kind") or {}).items()):
+            out.append(P(f"{_esc(kind)} ({len(names)})", "H2"))
+            out.append(compact(names))
+
+    # ── 8. codificação ──
+    out.append(P("8. Codificação e acentuação", "H1"))
+    if not enc.get("available", True):
+        out.append(P("Checagem indisponível.", "Small"))
+    else:
+        out.append(P(f"Charset do banco: <b>{_esc(enc.get('charset'))}</b>"
+                     + (" (UTF-8)." if enc.get("is_utf8") else ". Não é UTF-8: o BAU emite anotações sem acento neste banco; "
+                        "COMMENT ON não sofre dessa limitação.")))
+        src = enc.get("source_objects") or []
+        cmt = enc.get("comments") or []
+        if src:
+            out.append(P(f"{len(src)} objeto(s) PL/SQL com texto UTF-8 gravado como single-byte:"))
+            out.append(tbl(["Objeto", "Tipo", "Linhas"],
+                           [[mono(i.get("name")), _esc(i.get("type")), _n(i.get("lines"))] for i in src],
+                           [7 * cm, 3 * cm, 2 * cm], right=(2,)))
+        if cmt:
+            out.append(P(f"{len(cmt)} comentário(s) com sinal de acentuação quebrada:"))
+            out.append(tbl(["Onde", "Tabela", "Coluna", "Sinal", "Trecho"],
+                           [[_esc(i.get("where")), mono(i.get("table")), mono(i.get("column")), _esc(i.get("signals")),
+                             _esc((i.get("text") or "")[:90])] for i in cmt],
+                           [1.6 * cm, 4.6 * cm, 4.2 * cm, 2.2 * cm, cw - 12.6 * cm]))
+        if src or cmt:
+            out.append(P("Estes problemas estão no banco de origem agora, antes de o BAU escrever qualquer coisa; o sync os "
+                         "registra como pré-existentes. A documentação gerada pela IA, aplicada de volta, os corrige.", "Small"))
+        elif enc.get("is_utf8"):
+            out.append(P("Nenhum sinal de acentuação quebrada."))
+
+    # ── 9. próximos passos ──
+    out.append(P("9. Próximos passos", "H1"))
+    for t in (
+        "Corrigir ou descartar os objetos inválidos com erro de compilação (seção 5); recompilar os invalidados em cascata.",
+        "Decidir o destino dos packages sem corpo que declaram subprogramas (seção 6): implementar, remover ou "
+        "classificar como legado.",
+        "Confirmar as classes de objetos fora da cobertura (seção 7) e o padrão de nomes de temporários e backups.",
+        "Carga do catálogo pelo BAU (sem IA) e documentação assistida por fases, começando por um módulo piloto, com "
+        "revisão humana por responsável de área.",
+        "Tratar as tabelas sem chave primária como achados de modelagem, por módulo, na auditoria do BAU.",
+    ):
+        out.append(B(t))
+
+    # ── tempos e avisos ──
+    timings = r.get("timings") or []
+    if timings:
+        tot = sum(t.get("seconds", 0) for t in timings)
+        out.append(Spacer(1, 0.3 * cm))
+        out.append(P(f"Tempo do diagnóstico: {tot:.1f}s em {len(timings)} etapas. Fonte: baucli db check (leitura de "
+                     "catálogo; nenhum dado da base foi lido).", "Small"))
+    if r.get("errors"):
+        out.append(P("Avisos", "H2"))
+        for x in r["errors"]:
+            out.append(B(_esc(x)))
+
+    doc.build(out, onFirstPage=page_frame, onLaterPages=page_frame)
+    return buf.getvalue()

{baucli-1.0.149 → baucli-1.0.151}/baucli/db_check_report.py

@@ -3,8 +3,9 @@
 O comando sempre montou o diagnóstico em memória e o despejava em tabelas do
 rich. Este módulo recebe o MESMO diagnóstico como dict (ver `empty_report`)
 e o devolve em JSON (para CI, scripts, outro programa) ou HTML (um arquivo
-só, sem dependência externa, que o cliente abre no navegador e imprime em
-PDF). Não há parse de terminal em lugar nenhum: a fonte é o dict.
+só, sem dependência externa, que o cliente abre no navegador). O PDF pronto
+para o cliente sai do mesmo dict em `db_check_pdf.to_pdf`. Não há parse de
+terminal em lugar nenhum: a fonte é o dict.
 
 Contrato do dict (schema_version 1): chaves fixas, listas sempre presentes
 (vazias quando nada foi encontrado), números como int, nomes de objeto como
@@ -12,12 +13,25 @@ vieram do dicionário Oracle.
 """
 from __future__ import annotations
 
+import base64
 import html as _html
 import json
 from datetime import datetime, timezone
+from pathlib import Path
 
 SCHEMA_VERSION = 1
 
+# Logotipo BAU (quadrado preto) embutido como data: URI: o HTML continua um
+# arquivo só, sem recurso externo, e abre com a marca em qualquer lugar.
+_LOGO_FILE = Path(__file__).parent / "templates" / "logo-bau.jpg"
+
+
+def _logo_data_uri() -> str | None:
+    try:
+        return "data:image/jpeg;base64," + base64.b64encode(_LOGO_FILE.read_bytes()).decode("ascii")
+    except OSError:
+        return None
+
 
 def empty_report() -> dict:
     return {
@@ -52,7 +66,8 @@ _CSS = """
 :root{--red:#C8102E;--ink:#111;--muted:#6B7280;--line:#E5E7EB;--soft:#F7F7F8}
 *{box-sizing:border-box}body{font-family:-apple-system,Segoe UI,Helvetica,Arial,sans-serif;
 color:var(--ink);margin:0;background:#fff}main{max-width:1100px;margin:0 auto;padding:32px 24px}
-header{border-bottom:3px solid var(--red);padding-bottom:12px;margin-bottom:20px}
+header{border-bottom:3px solid var(--red);padding-bottom:12px;margin-bottom:20px;display:flex;gap:16px;align-items:center}
+header img.logo{width:64px;height:64px;border-radius:8px;flex:none}
 h1{font-size:26px;margin:0 0 4px}h2{font-size:18px;color:var(--red);margin:32px 0 8px;
 border-left:4px solid var(--red);padding-left:10px}h3{font-size:14px;margin:18px 0 6px}
 .sub{color:var(--muted);font-size:14px}.kpis{display:grid;grid-template-columns:repeat(5,1fr);
@@ -113,9 +128,11 @@ def to_html(report: dict, client: str | None = None) -> str:
     out = [f"<!doctype html><html lang='pt-BR'><head><meta charset='utf-8'>"
            f"<meta name='viewport' content='width=device-width,initial-scale=1'>"
            f"<title>{title}</title><style>{_CSS}</style></head><body><main>"]
-    out.append(f"<header><h1>{title}</h1><div class='sub'>Banco {_e(db.get('alias'))} "
+    logo = _logo_data_uri()
+    out.append("<header>" + (f"<img class='logo' src='{logo}' alt='BAU'>" if logo else "")
+               + f"<div><h1>{title}</h1><div class='sub'>Banco {_e(db.get('alias'))} "
                f"({_e(db.get('host'))}:{_e(db.get('port'))}/{_e(db.get('service'))}, usuário {_e(db.get('user'))}) · "
-               f"gerado em {_e(r.get('generated_at'))} · baucli {_e(r.get('baucli_version'))}</div></header>")
+               f"gerado em {_e(r.get('generated_at'))} · baucli {_e(r.get('baucli_version'))}</div></div></header>")
     out.append("<div class='kpis'>"
                f"<div class='kpi'><b>{s.get('critico', 0)}</b><span>crítico</span></div>"
                f"<div class='kpi'><b>{s.get('atencao', 0)}</b><span>atenção</span></div>"

{baucli-1.0.149 → baucli-1.0.151}/baucli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baucli
-Version: 1.0.149
+Version: 1.0.151
 Summary: Extracts verified business-logic and schema context from Oracle, PostgreSQL, MySQL and SQL Server
 Home-page: https://www.begcloud.com
 Author: BEG Support
@@ -27,6 +27,7 @@ Requires-Dist: mysql-connector-python>=8.0
 Requires-Dist: psycopg>=3.0
 Requires-Dist: python-tds>=1.12
 Requires-Dist: jsonschema>=4.18
+Requires-Dist: reportlab>=4.0
 Requires-Dist: tomli>=1.1; python_version < "3.11"
 Requires-Dist: mcp<2,>=1.2
 Provides-Extra: keyring

{baucli-1.0.149 → baucli-1.0.151}/baucli.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ baucli/api.py
 baucli/canon.py
 baucli/cli.py
 baucli/config.py
+baucli/db_check_pdf.py
 baucli/db_check_report.py
 baucli/democrm.py
 baucli/diffenvs.py
@@ -58,6 +59,7 @@ baucli/legacy/delphi.py
 baucli/legacy/delphi_canon.py
 baucli/legacy/delphi_evidence.py
 baucli/legacy/magic.py
+baucli/templates/logo-bau.jpg
 baucli/templates/app_shell/.apex/apexlang.json
 baucli/templates/app_shell/pages/login.apx.tpl
 baucli/templates/app_shell/shared-components/lists/navigation-bar.apx
@@ -68,6 +70,7 @@ tests/test_apexlint_dominio.py
 tests/test_api_request_db.py
 tests/test_canon_anchored_markers.py
 tests/test_canon_multiengine.py
+tests/test_db_check_pdf.py
 tests/test_db_check_report.py
 tests/test_db_tenant_guard.py
 tests/test_delphi_canon.py

{baucli-1.0.149 → baucli-1.0.151}/baucli.egg-info/requires.txt

@@ -6,6 +6,7 @@ mysql-connector-python>=8.0
 psycopg>=3.0
 python-tds>=1.12
 jsonschema>=4.18
+reportlab>=4.0
 mcp<2,>=1.2
 
 [:python_version < "3.11"]

{baucli-1.0.149 → baucli-1.0.151}/setup.py

@@ -42,6 +42,7 @@ setup(
         "psycopg>=3.0",                # PostgreSQL v3 (pure Python)
         "python-tds>=1.12",            # SQL Server (pure Python, replaces pymssql)
         "jsonschema>=4.18",            # docmig-spec/1.0: forma das secoes da spec validada antes de gravar
+        "reportlab>=4.0",              # `db check --format pdf`: pré-voo em PDF para o cliente (wheels para todas as plataformas)
         # bau.toml: tomllib so existe a partir do 3.11; sem tomli o baucli e o MCP
         # caem com "no TOML parser available" em qualquer projeto com bau.toml.
         'tomli>=1.1; python_version < "3.11"',

baucli-1.0.151/tests/test_db_check_pdf.py

@@ -0,0 +1,45 @@
+"""db check --format pdf: o dict do pré-voo vira PDF sem banco."""
+import re
+
+import pytest
+
+from baucli.db_check_pdf import to_pdf
+from baucli.db_check_report import empty_report
+from test_db_check_report import _sample
+
+pytest.importorskip("reportlab")
+
+
+def _pages(pdf: bytes) -> int:
+    # Os dicionários de página não são comprimidos: contar /Type /Page (sem o "s" de /Pages).
+    return len(re.findall(rb"/Type\s*/Page[^s]", pdf))
+
+
+def test_pdf_is_valid_and_has_pages():
+    pdf = to_pdf(_sample(), client="Ziz Performance")
+    assert pdf.startswith(b"%PDF-")
+    assert pdf.rstrip().endswith(b"%%EOF")
+    assert _pages(pdf) >= 2          # capa + corpo
+    assert len(pdf) > 10_000         # logotipo embutido + texto
+
+
+def test_pdf_metadata_and_logo():
+    pdf = to_pdf(_sample(), client="Ziz Performance")
+    assert b"BEG Support" in pdf     # /Author
+    assert b"/DCTDecode" in pdf      # o JPEG do logotipo foi embutido
+
+
+def test_empty_report_renders():
+    pdf = to_pdf(empty_report())
+    assert pdf.startswith(b"%PDF-") and _pages(pdf) >= 2
+
+
+def test_text_content_when_pypdf_available():
+    pypdf = pytest.importorskip("pypdf")
+    from io import BytesIO
+    reader = pypdf.PdfReader(BytesIO(to_pdf(_sample(), client="Ziz Performance")))
+    text = "\n".join(p.extract_text() for p in reader.pages)
+    for name in ("NAC_PCK_MKT_CAMPANHA", "NAC_RH_CST_GESTAX", "AD_ORG_BKP", "BEG_FNC_RETORNA_IPI",
+                 "NAC_PRC_B2B_REC_ITENS", "PCK_IMPORTACAO_MULTINAC", "PKG_URLS", "NAC_TMP", "FNC_LIMPA_STR",
+                 "BEG_CPG_RENEG", "Ziz Performance", "WE8ISO8859P1"):
+        assert name in text, name

{baucli-1.0.149 → baucli-1.0.151}/tests/test_db_check_report.py

@@ -68,5 +68,6 @@ def test_html_lists_full_names_and_escapes():
     assert "WE8ISO8859P1" in html
     # o "<ambígua>" do erro Oracle vira entidade, não tag
     assert "&lt;ambígua&gt;" in html and "<ambígua>" not in html
-    # sem recurso externo: um arquivo só
+    # sem recurso externo: um arquivo só — o logotipo vai embutido como data: URI
     assert "http" not in html.split("<footer>")[0].replace("http-equiv", "")
+    assert "<img class='logo' src='data:image/jpeg;base64," in html