baucli 1.0.152__tar.gz → 1.0.154__tar.gz

{baucli-1.0.152 → baucli-1.0.154}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baucli
-Version: 1.0.152
+Version: 1.0.154
 Summary: Extracts verified business-logic and schema context from Oracle, PostgreSQL, MySQL and SQL Server
 Home-page: https://www.begcloud.com
 Author: BEG Support

{baucli-1.0.152 → baucli-1.0.154}/baucli/__init__.py

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

{baucli-1.0.152 → baucli-1.0.154}/baucli/cli.py

@@ -8843,7 +8843,8 @@ def project_skills(schema, force):
             raise RuntimeError((lr or {}).get("error") or "payload invalido")
         res2 = write_edit_safety_skill(
             proj.root, lr, target,
-            datetime.now().strftime("%Y-%m-%d %H:%M"), force=force)
+            datetime.now().strftime("%Y-%m-%d %H:%M"), force=force,
+            guidelines_payload=guidelines_payload or None)
         console.print(f"[green]Skill gerado em[/green] "
                       f"{res2['dir'].relative_to(proj.root)}")
         console.print(f"  Rotinas CAUTION/UNSAFE no schema: "

{baucli-1.0.152 → baucli-1.0.154}/baucli/mcp_server.py

@@ -1552,12 +1552,29 @@ def build_server():
         usadas, coluna de flag ativo + valores válidos, amostras de nomenclatura
         de FK, domínios semânticos mais comuns, prefixos e o AI_CONTEXT do schema
         (padrão de forms/reports). Use para gerar tabela/coluna/tela que 'parece'
-        o resto do schema."""
+        o resto do schema. Traz também `security_guidelines`: a régua de
+        segurança VIGENTE (OWASP Top 10:2025 — código, regra, referência,
+        escopo) que o DOCREV cobra; leia antes de SQL dinâmico, acesso a
+        dado, chamada HTTP, senha/token ou tratamento de erro."""
         try:
             s = ctx().schema(schema)
-            return ctx().api.conventions(s)
+            out = ctx().api.conventions(s)
         except (BauApiError, ValueError) as e:
             return _err(e)
+        if not isinstance(out, dict):
+            return out
+        out = dict(out)
+        # Best-effort: a régua de segurança nunca derruba as convenções.
+        try:
+            from .skills import security_guidelines
+            gl = ctx().api.code_guidelines(schema=s)
+            if not isinstance(gl, dict) or gl.get("error"):
+                raise RuntimeError((gl or {}).get("error") or "payload inválido")
+            out["security_guidelines"] = security_guidelines(gl)
+        except Exception as e:  # noqa: BLE001
+            out["security_guidelines"] = []
+            out["security_guidelines_error"] = str(e)
+        return out
 
     @mcp.tool()
     def bau_object(object_name: str, schema: str = "", parent: str = "",

{baucli-1.0.152 → baucli-1.0.154}/baucli/skills.py

@@ -140,11 +140,34 @@ def _fmt_guidelines(guidelines: list) -> str:
         for g in sorted(by_cat[cat], key=lambda x: x.get("code") or ""):
             scope = g.get("scope") or "GLOBAL"
             tag = "" if scope == "GLOBAL" else f" _(regra da casa: {scope})_"
-            out.append(f"- **`{g.get('code')}`** — {g.get('guideline')}{tag}")
+            out.append(f"- **`{g.get('code')}`** — {g.get('guideline')}"
+                       f"{_ref_tag(g)}{tag}")
         out.append("")
     return "\n".join(out)
 
 
+def _ref_tag(g: dict) -> str:
+    """Referencia externa da regra (ex.: "OWASP A05:2025 Injeção") como
+    sufixo -- vazio quando ausente ou quando o texto da regra ja a cita."""
+    ref = (g.get("reference") or "").strip()
+    if not ref or ref in (g.get("guideline") or ""):
+        return ""
+    return f" _[{ref}]_"
+
+
+def security_guidelines(payload: dict | None) -> list[dict]:
+    """Regua de seguranca do schema: as diretrizes de categoria SECURITY do
+    payload de `GET /code-guidelines` (mutes/overrides do tenant ja resolvidos
+    no servidor), ordenadas por codigo. Usado pelo MCP (`bau_conventions`) e
+    pela skill bau-edit-safety (`resolved/security.md`)."""
+    items = (payload or {}).get("guidelines") or []
+    sec = [g for g in items if (g.get("category") or "").upper() == "SECURITY"]
+    sec.sort(key=lambda g: g.get("code") or "")
+    return [{"code": g.get("code"), "guideline": g.get("guideline"),
+             "reference": g.get("reference"), "scope": g.get("scope")}
+            for g in sec]
+
+
 def build_guidelines_md(payload: dict, schema: str | None,
                         generated_at: str) -> str:
     guidelines = payload.get("guidelines") or []
@@ -551,6 +574,19 @@ estar em UTC e o BAUCTX em -3h).
   mesmo dominio (`ORA-SIZ-01`, passo "orcamento de tamanho" da skill
   `bau-plsql-header`). O package que ja passou do limite nunca cresce.
 
+## Segurança (OWASP Top 10:2025)
+
+Antes de mexer em SQL dinâmico, acesso a dado, chamada HTTP, senha/token ou
+tratamento de erro, leia `resolved/security.md`: as regras de segurança VIGENTES
+deste schema (mesma régua do DOCREV; ao vivo: `bau_code_guidelines` ou
+`bau_conventions().security_guidelines`). Mínimo que vale sempre:
+- Valor em SQL dinâmico vai por USING, sem exceção por tipo (ORA-INJ-01);
+  identificador, por DBMS_ASSERT na função da posição. NOOP não valida nada.
+- Nada de segredo em literal (ORA-CRY-01); nada de MD5/SHA-1 para senha (ORA-CRY-02).
+- WHEN OTHERS em autorização/autenticação nega, nunca permite (ORA-EXC-02).
+Violação vira achado DOCREV (p133 / `bau_code_findings`). Hoje é alerta (WARN);
+nada bloqueia a liberação.
+
 ## Regras de edicao (cicatrizes de campo -- todas ja custaram um deploy)
 
 - **Fonte VIVO antes de tudo:** nunca edite a partir do script versionado sem
@@ -595,6 +631,7 @@ estar em UTC e o BAUCTX em -3h).
 - Confiar em VALID como prova de deploy aplicado.
 - Editar entre marcadores BAU:HEADER.
 - Deployar corpo de package com QUALQUER coisa depois do `/` no arquivo.
+- Concatenar valor em SQL dinâmico (use USING).
 """ + LESSONS_CROSSREF_MD
 
 
@@ -644,12 +681,58 @@ Atualize com `baucli project skills{f' --schema {schema}' if schema else ''}`.
 """
 
 
+def build_security_md(guidelines_payload: dict | None, schema: str | None,
+                      generated_at: str) -> str:
+    """resolved/security.md: a regua de seguranca VIGENTE do schema (so a
+    categoria SECURITY). Sem payload (falha best-effort no chamador), o
+    arquivo existe e diz que a regua nao veio -- nunca fica uma copia velha."""
+    sec = security_guidelines(guidelines_payload)
+    upd = f"baucli project skills{f' --schema {schema}' if schema else ''}"
+    if not (guidelines_payload or {}).get("guidelines"):
+        body = ("_A régua de segurança não veio do BAU nesta geração "
+                "(falha ou payload vazio em `GET /code-guidelines`)._\n\n"
+                "Consulte ao vivo com `bau_code_guidelines` (categoria "
+                "SECURITY) ou `bau_conventions().security_guidelines` antes "
+                f"de editar, e re-rode `{upd}`.\n")
+    elif not sec:
+        body = ("_Nenhuma diretriz de segurança ativa para este schema "
+                "(todas mutadas pelo tenant?)._\n\nConfira ao vivo com "
+                "`bau_code_guidelines`.\n")
+    else:
+        lines = []
+        for g in sec:
+            scope = g.get("scope") or "GLOBAL"
+            tag = "" if scope == "GLOBAL" else f" _(regra da casa: {scope})_"
+            lines.append(f"- **`{g.get('code')}`** — {g.get('guideline')}"
+                         f"{_ref_tag(g)}{tag}")
+        body = "\n".join(lines) + "\n"
+    return f"""{GENERATED_BANNER}
+# Regua de seguranca (OWASP Top 10:2025) -- {schema or '(nivel tenant)'}
+
+As diretrizes de categoria SECURITY VIGENTES para este schema (seeds da
+plataforma + regras da casa, mutes/overrides do tenant ja resolvidos). Mesma
+regua do DOCREV: violacao vira achado em `bau_code_findings`. Ao vivo:
+`bau_code_guidelines` ou `bau_conventions().security_guidelines`.
+
+Total: **{len(sec)}** diretriz(es). Gerado em {generated_at}.
+
+{body}
+---
+Atualize com `{upd}`.
+"""
+
+
 def write_edit_safety_skill(root: Path, payload: dict, schema: str | None,
-                            generated_at: str, force: bool = False) -> dict:
+                            generated_at: str, force: bool = False,
+                            guidelines_payload: dict | None = None) -> dict:
     """Grava o skill em <root>/.claude/skills/bau-edit-safety/.
 
     Mesmo contrato do write_skill: SKILL.md (metodo) so quando ausente ou com
     force=True; resolved/ (dado) sempre reescrito.
+
+    guidelines_payload: o mesmo `GET /code-guidelines` que o write_skill
+    recebe; dele sai resolved/security.md (so a categoria SECURITY). None
+    grava o arquivo avisando que a regua nao veio, sem quebrar o skill.
     """
     base = root / EDIT_SAFETY_SKILL_DIR
     resolved = base / "resolved"
@@ -674,6 +757,11 @@ def write_edit_safety_skill(root: Path, payload: dict, schema: str | None,
                   encoding="utf-8")
     result["resolved_written"].append(rt)
 
+    sec = resolved / "security.md"
+    sec.write_text(build_security_md(guidelines_payload, schema, generated_at),
+                   encoding="utf-8")
+    result["resolved_written"].append(sec)
+
     return result
 
 

{baucli-1.0.152 → baucli-1.0.154}/baucli/sync.py

@@ -48,6 +48,105 @@ def _nome_do_item(obj) -> str:
     return f"{nome} ({tipo})" if tipo else str(nome)
 
 
+def _prefix_tokens(csv: str) -> tuple[list[str], list[str]]:
+    """Tokens de um CSV de prefixos (BAU_SCHEMAS.EXCLUDE_PREFIXES /
+    INCLUDE_PREFIXES): (únicos, na ordem em que aparecem; repetidos)."""
+    seen: list[str] = []
+    dups: list[str] = []
+    for tok in (csv or "").split(","):
+        tok = tok.strip()
+        if not tok:
+            continue
+        if tok.upper() in {t.upper() for t in seen}:
+            if tok.upper() not in {t.upper() for t in dups}:
+                dups.append(tok)
+        else:
+            seen.append(tok)
+    return seen, dups
+
+
+def _em_colunas(tokens: list[str], ncol: int = 3, indent: str = "    ") -> list[str]:
+    """Tokens em N colunas de largura igual, uma linha por fileira: 20 prefixos
+    numa linha só quebravam no meio do terminal de 80 colunas."""
+    if not tokens:
+        return []
+    w = max(len(t) for t in tokens)
+    linhas = []
+    for i in range(0, len(tokens), ncol):
+        fila = tokens[i:i + ncol]
+        linhas.append("[dim]" + indent
+                      + "  ".join(t.ljust(w) for t in fila).rstrip() + "[/dim]")
+    return linhas
+
+
+def prefix_filter_lines(schema: str, exclude_csv: str, include_csv: str) -> list[str]:
+    """Mensagem do filtro de prefixos que o servidor empurra para o sync.
+
+    A versão antiga despejava o CSV cru numa linha só: com 27 tokens (caso
+    COMPIERE) ele quebrava no meio, repetia prefixo e escondia dois fatos que
+    custam uma rodada de suporte: de onde o filtro vem (cadastro do schema no
+    App 601, não do bau.toml) e que ele é SÓ de PREFIXO -- tanto aqui
+    (`_prefix_clause`, LIKE 'TOK%') quanto no servidor
+    (FNC_BAU_NAME_MATCHES_PREFIX_CSV, instr = 1). Um token como `_BKP` não
+    casa nome nenhum; quem quer tirar sufixo ou trecho usa regra de objeto.
+    """
+    out: list[str] = []
+    excl, excl_dups = _prefix_tokens(exclude_csv)
+    incl, incl_dups = _prefix_tokens(include_csv)
+    if not excl and not incl:
+        return out
+    origem = f"    [dim]origem: cadastro do schema {schema} no BAU (App 601 p28)[/dim]"
+    inertes = [t for t in excl + incl if not t[0].isalnum()]
+    excl_ok = [t for t in excl if t[0].isalnum()]
+    incl_ok = [t for t in incl if t[0].isalnum()]
+    if excl_ok:
+        out.append(f"  [dim]Filtro de nomes: {len(excl_ok)} prefixo(s) excluído(s)[/dim]")
+        out.extend(_em_colunas(sorted(excl_ok, key=str.upper)))
+    if incl_ok:
+        out.append(f"  [dim]Filtro de nomes: APENAS {len(incl_ok)} prefixo(s) "
+                   f"(allow-list)[/dim]")
+        out.extend(_em_colunas(sorted(incl_ok, key=str.upper)))
+    out.append(origem)
+    dups = excl_dups + incl_dups
+    if dups:
+        out.append("  [dim]  repetido(s) no cadastro, contado(s) uma vez: "
+                   + ", ".join(dups) + "[/dim]")
+    if inertes:
+        out.append("  [yellow]  ⚠ sem efeito: " + "  ".join(inertes)
+                   + " — o filtro é só de PREFIXO (nome que COMEÇA pelo token); "
+                   "para sufixo ou trecho do nome use regra de objeto "
+                   "(App 601 > Regras de Objetos).[/yellow]")
+    return out
+
+
+def _fora_pelo_filtro(extractor, schema: str, kind: str) -> int:
+    """Quantos objetos/tabelas o filtro de prefixos tirou do escopo: conta sem
+    o filtro e subtrai o `count_*` filtrado. -1 = não dá para saber (engine sem
+    count ou falha no dicionário); o chamador omite o parêntese."""
+    if not (getattr(extractor, "exclude_prefixes", "") or
+            getattr(extractor, "include_prefixes", "")):
+        return -1
+    fn = getattr(extractor, f"count_{kind}", None)
+    if fn is None:
+        return -1
+    ex, inc = extractor.exclude_prefixes, extractor.include_prefixes
+    try:
+        com = fn(schema)
+        extractor.exclude_prefixes = extractor.include_prefixes = ""
+        try:
+            sem = fn(schema)
+        finally:
+            extractor.exclude_prefixes, extractor.include_prefixes = ex, inc
+        return max(sem - com, 0)
+    except Exception:
+        extractor.exclude_prefixes, extractor.include_prefixes = ex, inc
+        return -1
+
+
+def _fora_txt(n: int) -> str:
+    return f" [dim](+{n} fora pelo filtro de prefixos)[/dim]" if n > 0 else ""
+
+
 def _somar_resultados(acc: dict, novo: dict) -> dict:
     """Junta os contadores de dois retornos do /sync/batch."""
     for k, v in (novo or {}).items():
@@ -1039,12 +1138,9 @@ def sync_database(db_name: str, db_config: dict, api: BauApi,
             db_config["include_prefixes"] = _incl
             extractor.exclude_prefixes = _excl
             extractor.include_prefixes = _incl
-            if extractor.exclude_prefixes:
-                console.print(f"  [dim]prefixos excluídos (BAU): "
-                              f"{extractor.exclude_prefixes}[/dim]")
-            if extractor.include_prefixes:
-                console.print(f"  [dim]APENAS prefixos (BAU): "
-                              f"{extractor.include_prefixes}[/dim]")
+            for _line in prefix_filter_lines(schema, extractor.exclude_prefixes,
+                                             extractor.include_prefixes):
+                console.print(_line)
 
             # === Step 2: Extract ===
             objects = []
@@ -1102,7 +1198,12 @@ def sync_database(db_name: str, db_config: dict, api: BauApi,
                                else len(eff_table_name) if isinstance(eff_table_name, list)
                                else extractor.count_tables(schema))
                     if cnt_obj >= 0 and cnt_tbl >= 0:
-                        console.print(f"    Scope: [cyan]{cnt_obj}[/cyan] objects + [cyan]{cnt_tbl}[/cyan] tables/views")
+                        _fora = -1
+                        if not object_name and not table_name and not isinstance(eff_table_name, list):
+                            _fora = _fora_pelo_filtro(extractor, schema, "objects")
+                            _ft = _fora_pelo_filtro(extractor, schema, "tables")
+                            _fora = (max(_fora, 0) + max(_ft, 0)) if (_fora >= 0 or _ft >= 0) else -1
+                        console.print(f"    Scope: [cyan]{cnt_obj}[/cyan] objects + [cyan]{cnt_tbl}[/cyan] tables/views{_fora_txt(_fora)}")
                 except Exception:
                     pass
 
@@ -1226,10 +1327,17 @@ def sync_database(db_name: str, db_config: dict, api: BauApi,
                                    else len(eff_table_name) if isinstance(eff_table_name, list)
                                    else extractor.count_tables(schema))
                     parts = []
-                    if cnt_obj >= 0: parts.append(f"[cyan]{cnt_obj}[/cyan] objects")
-                    if cnt_tbl >= 0: parts.append(f"[cyan]{cnt_tbl}[/cyan] tables/views")
+                    _fora = 0
+                    if cnt_obj >= 0:
+                        parts.append(f"[cyan]{cnt_obj}[/cyan] objects")
+                        if not object_name and not isinstance(eff_object_name, list):
+                            _fora += max(_fora_pelo_filtro(extractor, schema, "objects"), 0)
+                    if cnt_tbl >= 0:
+                        parts.append(f"[cyan]{cnt_tbl}[/cyan] tables/views")
+                        if not table_name and not isinstance(eff_table_name, list):
+                            _fora += max(_fora_pelo_filtro(extractor, schema, "tables"), 0)
                     if parts:
-                        console.print(f"    Scope: {' + '.join(parts)}")
+                        console.print(f"    Scope: {' + '.join(parts)}{_fora_txt(_fora)}")
                 except Exception:
                     pass
 

{baucli-1.0.152 → baucli-1.0.154}/baucli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baucli
-Version: 1.0.152
+Version: 1.0.154
 Summary: Extracts verified business-logic and schema context from Oracle, PostgreSQL, MySQL and SQL Server
 Home-page: https://www.begcloud.com
 Author: BEG Support

{baucli-1.0.152 → baucli-1.0.154}/baucli.egg-info/SOURCES.txt

@@ -100,6 +100,7 @@ tests/test_docmig_support_objects.py
 tests/test_docrev_dismiss.py
 tests/test_doctab_split.py
 tests/test_documentation_list_db_label.py
+tests/test_mcp_conventions.py
 tests/test_mcp_doc_changeset.py
 tests/test_mcp_doc_tags.py
 tests/test_mcp_doctab_text.py
@@ -115,9 +116,11 @@ tests/test_scope_scan_owner.py
 tests/test_scope_scan_pkg_func_from.py
 tests/test_skills_apex_domain.py
 tests/test_skills_lessons.py
+tests/test_skills_security.py
 tests/test_skills_size_budget.py
 tests/test_spec_sem_beg.py
 tests/test_sync_413.py
 tests/test_sync_charset.py
+tests/test_sync_prefix_msg.py
 tests/test_table_status.py
 tests/test_uikit_scope.py

baucli-1.0.154/tests/test_mcp_conventions.py

@@ -0,0 +1,87 @@
+"""bau_conventions acrescenta a regua de seguranca (categoria SECURITY do
+GET code-guidelines) ao dict do servidor -- best-effort: erro na regua nao
+derruba a tool."""
+import asyncio
+import json
+
+import pytest
+
+from baucli import mcp_server as M
+from baucli.api import BauApiError
+
+PAYLOAD = {"guidelines": [
+    {"code": "ORA-SET-01", "category": "PERFORMANCE", "guideline": "x"},
+    {"code": "ORA-INJ-01", "category": "SECURITY",
+     "guideline": "y [OWASP A05:2025 Injeção]",
+     "reference": "OWASP A05:2025 Injeção", "scope": "GLOBAL"},
+    {"code": "ORA-ACL-01", "category": "SECURITY", "guideline": "z",
+     "reference": None},
+]}
+
+
+class _Api:
+    def __init__(self, gl_exc=None):
+        self.gl_exc = gl_exc
+        self.calls = []
+
+    def conventions(self, schema):
+        self.calls.append(("conventions", schema))
+        return {"schema": schema, "pk_style": "surrogate:ID_<TABLE>"}
+
+    def code_guidelines(self, schema=None):
+        self.calls.append(("code_guidelines", schema))
+        if self.gl_exc:
+            raise self.gl_exc
+        return PAYLOAD
+
+
+class _Ctx:
+    def __init__(self, api):
+        self.api = api
+
+    def schema(self, override=""):
+        return (override or "S").upper()
+
+
+@pytest.fixture
+def use(monkeypatch):
+    def _use(api):
+        monkeypatch.setattr(M, "_ctx", _Ctx(api))
+        return api
+    return _use
+
+
+def _call(name, **args):
+    res = asyncio.run(M.build_server().call_tool(name, args))
+    if isinstance(res, tuple):
+        res = res[1] if isinstance(res[1], dict) else res[0]
+    if isinstance(res, dict):
+        return res.get("result", res)
+    return json.loads(res[0].text)
+
+
+def test_bau_conventions_acrescenta_security(use):
+    api = use(_Api())
+    out = _call("bau_conventions")
+    assert out["schema"] == "S"
+    assert out["pk_style"] == "surrogate:ID_<TABLE>"
+    assert [g["code"] for g in out["security_guidelines"]] == ["ORA-ACL-01", "ORA-INJ-01"]
+    assert "security_guidelines_error" not in out
+    assert ("code_guidelines", "S") in api.calls
+
+
+def test_bau_conventions_sobrevive_erro_guidelines(use):
+    use(_Api(gl_exc=BauApiError("boom", 500)))
+    out = _call("bau_conventions")
+    assert out["schema"] == "S"
+    assert out["pk_style"] == "surrogate:ID_<TABLE>"
+    assert out["security_guidelines"] == []
+    assert "boom" in out["security_guidelines_error"]
+
+
+def test_bau_conventions_payload_com_error(use, monkeypatch):
+    api = use(_Api())
+    monkeypatch.setattr(api, "code_guidelines", lambda schema=None: {"error": "sem acesso"})
+    out = _call("bau_conventions")
+    assert out["security_guidelines"] == []
+    assert "sem acesso" in out["security_guidelines_error"]

baucli-1.0.154/tests/test_skills_security.py

@@ -0,0 +1,79 @@
+"""Regua de seguranca OWASP Top 10:2025 nas skills geradas: security_guidelines
+filtra a categoria SECURITY do GET code-guidelines, guidelines.md mostra a
+referencia OWASP e a skill bau-edit-safety ganha resolved/security.md."""
+from baucli import skills
+from baucli.skills import (EDIT_SAFETY_SKILL_MD, _fmt_guidelines,
+                           security_guidelines, write_edit_safety_skill)
+
+PAYLOAD = {"guidelines": [
+    {"code": "ORA-SET-01", "category": "PERFORMANCE", "guideline": "x"},
+    {"code": "ORA-INJ-01", "category": "SECURITY",
+     "guideline": "y [OWASP A05:2025 Injeção]",
+     "reference": "OWASP A05:2025 Injeção", "scope": "GLOBAL"},
+    {"code": "ORA-ACL-01", "category": "SECURITY", "guideline": "z",
+     "reference": None},
+]}
+
+
+def test_security_guidelines_filtra_e_ordena():
+    out = security_guidelines(PAYLOAD)
+    assert [g["code"] for g in out] == ["ORA-ACL-01", "ORA-INJ-01"]
+    assert set(out[0]) == {"code", "guideline", "reference", "scope"}
+    assert out[1]["reference"] == "OWASP A05:2025 Injeção"
+
+
+def test_security_guidelines_payload_vazio():
+    assert security_guidelines({}) == []
+    assert security_guidelines(None) == []
+
+
+def test_fmt_guidelines_mostra_referencia():
+    md = _fmt_guidelines(PAYLOAD["guidelines"])
+    inj = next(ln for ln in md.splitlines() if "ORA-INJ-01" in ln)
+    acl = next(ln for ln in md.splitlines() if "ORA-ACL-01" in ln)
+    assert "OWASP A05:2025 Injeção" in inj
+    assert "None" not in acl
+
+
+def test_edit_safety_md_tem_secao_seguranca():
+    md = EDIT_SAFETY_SKILL_MD
+    assert "## Segurança (OWASP Top 10:2025)" in md
+    assert "resolved/security.md" in md
+    assert "bau_code_guidelines" in md
+    assert "ORA-INJ-01" in md
+    assert "USING" in md
+    assert md.index("## Segurança (OWASP Top 10:2025)") < md.index("## Regras de edicao")
+    nunca = md[md.index("## NUNCA"):]
+    assert "Concatenar valor em SQL dinâmico (use USING)." in nunca
+
+
+def test_write_edit_safety_grava_security_md(tmp_path):
+    res = write_edit_safety_skill(tmp_path, {"routines": []}, "S",
+                                  "2026-10-22 10:00",
+                                  guidelines_payload=PAYLOAD)
+    sec = tmp_path / skills.EDIT_SAFETY_SKILL_DIR / "resolved" / "security.md"
+    assert sec in res["resolved_written"]
+    txt = sec.read_text(encoding="utf-8")
+    assert "ORA-INJ-01" in txt and "ORA-ACL-01" in txt
+    assert "ORA-SET-01" not in txt
+    assert "OWASP A05:2025 Injeção" in txt
+    assert "None" not in txt
+
+
+def test_write_edit_safety_sem_payload_nao_quebra(tmp_path):
+    write_edit_safety_skill(tmp_path, {"routines": []}, "S", "2026-10-22 10:00")
+    sec = tmp_path / skills.EDIT_SAFETY_SKILL_DIR / "resolved" / "security.md"
+    assert sec.exists()
+    txt = sec.read_text(encoding="utf-8")
+    assert "não veio" in txt
+    assert "bau_code_guidelines" in txt
+
+
+def test_fmt_guidelines_acrescenta_referencia_ausente_do_texto():
+    md = _fmt_guidelines([{"code": "ORA-CRY-01", "category": "SECURITY",
+                           "guideline": "Nada de segredo em literal.",
+                           "reference": "OWASP A04:2025 Falhas criptográficas"}])
+    assert "OWASP A04:2025 Falhas criptográficas" in md
+    # nao duplica quando o texto ja cita a referencia
+    md2 = _fmt_guidelines(PAYLOAD["guidelines"])
+    assert md2.count("OWASP A05:2025 Injeção") == 1

baucli-1.0.154/tests/test_sync_prefix_msg.py

@@ -0,0 +1,72 @@
+"""Mensagem do filtro de prefixos do sync (BAU_SCHEMAS.EXCLUDE/INCLUDE_PREFIXES)."""
+from baucli.sync import _fora_pelo_filtro, _prefix_tokens, prefix_filter_lines
+
+
+def test_sem_filtro_nao_imprime_nada():
+    assert prefix_filter_lines("X", "", "") == []
+    assert prefix_filter_lines("X", None, None) == []
+
+
+def test_tokens_dedup_ignora_caixa_e_espacos():
+    toks, dups = _prefix_tokens(" AD_, c_ ,AD_,,C_")
+    assert toks == ["AD_", "c_"]
+    assert dups == ["AD_", "C_"]   # C_ repete c_ (caixa ignorada); um por token
+
+
+def test_lista_ordenada_com_contagem_e_origem():
+    out = "\n".join(prefix_filter_lines("COMPIERE", "M_,AD_,C_", ""))
+    assert "3 prefixo(s) excluído(s)" in out
+    assert "schema COMPIERE" in out and "App 601" in out
+    assert "AD_  C_   M_" in out           # 3 por linha, colunas alinhadas
+    assert "⚠" not in out
+
+
+def test_token_de_sufixo_vira_aviso_e_sai_da_lista():
+    out = prefix_filter_lines("S", "BKP_,_BKP,_OLD,BKP_", "")
+    txt = "\n".join(out)
+    assert "1 prefixo(s) excluído(s)" in txt          # so BKP_ conta
+    assert "sem efeito: _BKP  _OLD" in txt
+    assert "regra de objeto" in txt
+    assert "repetido(s) no cadastro" in txt and "BKP_" in txt
+    assert not any("  BKP_  " in l and "_BKP" in l for l in out)
+
+
+def test_allow_list_tem_rotulo_proprio():
+    txt = "\n".join(prefix_filter_lines("S", "", "NAC_,BEG_"))
+    assert "APENAS 2 prefixo(s)" in txt and "BEG_  NAC_" in txt
+
+
+def test_lista_em_tres_colunas_alinhadas():
+    from baucli.sync import _em_colunas
+    linhas = _em_colunas(["AD_", "A_", "BKP_", "B_", "C_", "FACT_", "GL_"])
+    assert len(linhas) == 3                       # 3 + 3 + 1
+    assert linhas[0] == "[dim]    AD_    A_     BKP_[/dim]"
+    assert linhas[2] == "[dim]    GL_[/dim]"      # ultima fileira sem espaco sobrando
+    assert _em_colunas([]) == []
+
+
+class _Ext:
+    def __init__(self, com, sem):
+        self.exclude_prefixes = "AD_"
+        self.include_prefixes = ""
+        self._com, self._sem = com, sem
+        self.calls = []
+
+    def count_tables(self, schema):
+        self.calls.append((self.exclude_prefixes, self.include_prefixes))
+        return self._com if self.exclude_prefixes else self._sem
+
+
+def test_fora_pelo_filtro_conta_sem_o_filtro_e_restaura():
+    e = _Ext(com=3272, sem=3894)
+    assert _fora_pelo_filtro(e, "COMPIERE", "tables") == 622
+    assert e.exclude_prefixes == "AD_"
+    assert e.calls == [("AD_", ""), ("", "")]
+
+
+def test_fora_pelo_filtro_sem_filtro_ou_sem_count_devolve_menos_um():
+    e = _Ext(1, 1)
+    e.exclude_prefixes = ""
+    assert _fora_pelo_filtro(e, "S", "tables") == -1
+    e.exclude_prefixes = "AD_"
+    assert _fora_pelo_filtro(e, "S", "objects") == -1   # sem count_objects