plugadvpl 0.4.2__tar.gz → 0.4.3__tar.gz

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugadvpl
-Version: 0.4.2
+Version: 0.4.3
 Summary: CLI que indexa fontes ADVPL/Protheus em SQLite com FTS5 para análise por LLM (companheiro do plugin Claude Code plugadvpl)
 Project-URL: Homepage, https://github.com/JoniPraia/plugadvpl
 Project-URL: Issues, https://github.com/JoniPraia/plugadvpl/issues

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/plugadvpl/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.4.2'
-__version_tuple__ = version_tuple = (0, 4, 2)
+__version__ = version = '0.4.3'
+__version_tuple__ = version_tuple = (0, 4, 3)
 
 __commit_id__ = commit_id = None

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/plugadvpl/cli.py

@@ -60,6 +60,7 @@ from plugadvpl.query import (
     execauto_calls_query,
     execution_triggers_query,
     find_any,
+    protheus_doc_homonyms,
     protheus_doc_show,
     protheus_docs_orphans,
     protheus_docs_query,
@@ -1305,10 +1306,28 @@ def docs(
     formatado em Markdown. Use ``--orphans`` pra ver funções sem header.
     """
     if show:
-        d = _with_ro_db(ctx, lambda c: protheus_doc_show(c, show))
-        if d is None:
+        # v0.4.3 (I2): com homônimos, --arquivo desambiguar; sem --arquivo,
+        # avisa em stderr e mostra o primeiro alfabeticamente.
+        homonyms = _with_ro_db(ctx, lambda c: protheus_doc_homonyms(c, show))
+        if not homonyms:
             typer.echo(f"Nenhum Protheus.doc encontrado pra função '{show}'.", err=True)
             raise typer.Exit(code=1)
+        if len(homonyms) > 1 and not arquivo:
+            typer.echo(
+                f"Aviso: '{show}' tem doc em {len(homonyms)} fontes: "
+                f"{', '.join(homonyms)}. Mostrando '{homonyms[0]}'. "
+                f"Use --arquivo <nome> pra escolher.",
+                err=True,
+            )
+        d = _with_ro_db(
+            ctx, lambda c: protheus_doc_show(c, show, arquivo=arquivo)
+        )
+        if d is None:
+            typer.echo(
+                f"Nenhum Protheus.doc encontrado pra '{show}' em '{arquivo}'.",
+                err=True,
+            )
+            raise typer.Exit(code=1)
         typer.echo(render_pdoc_markdown(d))
         return
 

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/plugadvpl/db.py

@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from pathlib import Path
 
-SCHEMA_VERSION = "7"
+SCHEMA_VERSION = "8"
 
 
 # Mapeamento {filename JSON -> (tabela, colunas em ordem)}.

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/plugadvpl/lookups/execauto_routines.json

@@ -16,6 +16,16 @@
       "source_url": "https://tdn.totvs.com",
       "verified": true
     },
+    {
+      "routine": "MATA020",
+      "module": "SIGACOM",
+      "type": "cadastro",
+      "label": "Cadastro de Fornecedores",
+      "tables_primary": ["SA2"],
+      "tables_secondary": [],
+      "source_url": "https://tdn.totvs.com",
+      "verified": true
+    },
     {
       "routine": "MATA030",
       "module": "SIGAFIN",
@@ -26,6 +36,16 @@
       "source_url": "https://tdn.totvs.com",
       "verified": true
     },
+    {
+      "routine": "MATA040",
+      "module": "SIGAFIN",
+      "type": "cadastro",
+      "label": "Cadastro de Bancos",
+      "tables_primary": ["SA6"],
+      "tables_secondary": [],
+      "source_url": "https://tdn.totvs.com",
+      "verified": true
+    },
     {
       "routine": "MATA050",
       "module": "SIGAFAT",
@@ -66,6 +86,16 @@
       "source_url": "https://tdn.totvs.com/pages/viewpage.action?pageId=318605213",
       "verified": true
     },
+    {
+      "routine": "MATA112",
+      "module": "SIGAFIN",
+      "type": "cadastro",
+      "label": "Plano de Pagamento",
+      "tables_primary": ["SE4"],
+      "tables_secondary": [],
+      "source_url": "https://tdn.totvs.com",
+      "verified": false
+    },
     {
       "routine": "MATA120",
       "module": "SIGACOM",
@@ -166,6 +196,26 @@
       "source_url": "https://tdn.totvs.com/pages/releaseview.action?pageId=6784012",
       "verified": true
     },
+    {
+      "routine": "FATA010",
+      "module": "SIGAFAT",
+      "type": "cadastro",
+      "label": "Cadastro de Bandeira de Cartao",
+      "tables_primary": ["AE1"],
+      "tables_secondary": [],
+      "source_url": "https://tdn.totvs.com",
+      "verified": false
+    },
+    {
+      "routine": "FATA050",
+      "module": "SIGAFAT",
+      "type": "movimento",
+      "label": "Liberacao de Pedidos de Venda",
+      "tables_primary": ["SC9"],
+      "tables_secondary": [],
+      "source_url": "https://tdn.totvs.com",
+      "verified": false
+    },
     {
       "routine": "MATA460",
       "module": "SIGAFAT",

plugadvpl-0.4.3/plugadvpl/migrations/008_universo3_funcao_indexes.sql

@@ -0,0 +1,11 @@
+-- v0.4.3 (I6) — indices em `funcao` nas 3 tabelas Universo 3.
+-- Antes: queries cross-ref ("quais funcoes no fonte X chamam ExecAuto?")
+-- forcavam scan + filter Python. Agora idx cobre `funcao` nas 3 tables.
+
+CREATE INDEX IF NOT EXISTS idx_exec_funcao
+  ON execution_triggers(funcao);
+
+CREATE INDEX IF NOT EXISTS idx_execauto_funcao
+  ON execauto_calls(funcao);
+
+-- protheus_docs ja tem idx_pdoc_funcao (criado em migration 007), nao precisa.

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/plugadvpl/parsing/protheus_doc.py

@@ -30,8 +30,11 @@ _PDOC_BLOCK_RE = re.compile(
     r"[ \t]*"  # SEM \s — id, se houver, fica na MESMA linha do opening
     r"(?P<id>[\w:]+)?"
     r"(?P<body>.*?)"
-    r"/\*/",
-    re.IGNORECASE | re.DOTALL,
+    # v0.4.3 (C2): fechamento ANCORADO a start-of-line. `/*/` em meio a comentário
+    # de @example não fecha bloco (padrão oficial TOTVS — fechamento fica sozinho
+    # na própria linha).
+    r"^[ \t]*/\*/[ \t]*$",
+    re.IGNORECASE | re.DOTALL | re.MULTILINE,
 )
 
 # Próxima decl de função/método após o fechamento.
@@ -95,15 +98,13 @@ def infer_module(arquivo: str, funcao: str | None) -> str | None:
         # 1. Exact match (rotina exata no catálogo).
         if funcao_upper in idx:
             return idx[funcao_upper]["module"]
-        # 2. Prefix match (4 primeiros chars). Determinístico: ordena por
-        # nome de rotina e pega o primeiro alfabético entre os matches.
+        # 2. Prefix match (4 primeiros chars). v0.4.3 (C5): só aceita se TODOS
+        # os matches do prefixo apontam pro MESMO módulo. Ambiguidade → None
+        # (não inventar). Antes retornava SIGAEST silenciosamente para MATA*.
         prefix4 = funcao_upper[:4]
-        matches = sorted(
-            (e for k, e in idx.items() if k.startswith(prefix4)),
-            key=lambda e: e["routine"],
-        )
-        if matches:
-            return matches[0]["module"]
+        matched_modules = {e["module"] for k, e in idx.items() if k.startswith(prefix4)}
+        if len(matched_modules) == 1:
+            return matched_modules.pop()
     return None
 
 
@@ -200,15 +201,28 @@ def _line_at(content: str, offset: int) -> int:
     return content.count("\n", 0, offset) + 1
 
 
+_PDOC_ORPHAN_LINE_CAP = 80  # v0.4.3 (C4): cap de proximidade pra associar bloco→decl
+
+
 def _resolve_next_decl(
     content: str, after_offset: int
 ) -> tuple[str | None, int | None]:
-    """Acha próxima decl de função/método após offset. Retorna (nome, linha_1based)."""
+    """Acha próxima decl de função/método após offset. Retorna (nome, linha_1based).
+
+    v0.4.3 (C4): cap de ``_PDOC_ORPHAN_LINE_CAP`` linhas entre o offset (fim do
+    bloco) e a decl encontrada. Acima disso retorna (None, None) — bloco é
+    tratado como órfão (preserva sinal de cobertura BP-007 e impede que função
+    distante ganhe doc errada associada).
+    """
     m = _NEXT_DECL_RE.search(content, after_offset)
     if not m:
         return None, None
+    block_end_line = _line_at(content, max(0, after_offset - 1))
+    decl_line = _line_at(content, m.start())
+    if decl_line - block_end_line > _PDOC_ORPHAN_LINE_CAP:
+        return None, None
     name = m.group(1) or m.group(2)
-    return name, _line_at(content, m.start())
+    return name, decl_line
 
 
 def _parse_body(body: str) -> tuple[str, list[tuple[str, str]]]:

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/plugadvpl/parsing/triggers.py

@@ -75,14 +75,9 @@ _JOB_MAIN_RE = re.compile(
     r"^[ \t]*Main\s+Function\s+(\w+)\s*\(",
     re.IGNORECASE | re.MULTILINE,
 )
-# RpcSetEnv qualquer formato (literal ou variável).
-_JOB_RPCSETENV_RE = re.compile(
-    r"\bRpcSetEnv\s*\(\s*"
-    r"(?:['\"]([^'\"]*)['\"]|(\w+))\s*,\s*"        # emp
-    r"(?:['\"]([^'\"]*)['\"]|(\w+))"               # fil
-    r"(?:[^)]*?['\"](\w*)['\"])?",                 # módulo (5º arg, opcional)
-    re.IGNORECASE,
-)
+# RpcSetEnv — só localiza o início; args extraídos via _parse_rpcsetenv_args
+# (v0.4.3 C3: regex única era frágil quando os 6 args vinham literais consecutivos).
+_JOB_RPCSETENV_RE = re.compile(r"\bRpcSetEnv\s*\(", re.IGNORECASE)
 # RpcSetType(3) — sem licença.
 _JOB_RPCSETTYPE_RE = re.compile(r"\bRpcSetType\s*\(\s*3\s*\)", re.IGNORECASE)
 # Sleep(N*1000) ou Sleep(N) em ms — extrai segundos.
@@ -102,6 +97,10 @@ _MAIL_UDC_CONNECT_RE = re.compile(r"^\s*CONNECT\s+SMTP\b", re.IGNORECASE | re.MU
 _MAIL_TMAILMANAGER_RE = re.compile(r"\bTMailManager\s*\(", re.IGNORECASE)
 _MAIL_TMAILMESSAGE_RE = re.compile(r"\bTMailMessage\s*\(", re.IGNORECASE)
 _MAIL_SEND_METHOD_RE = re.compile(r":\s*Send\s*\(", re.IGNORECASE)
+# v0.4.3 (I1): TMailManager:SendMail/SmtpConnect — variantes legadas (sem TMailMessage).
+_MAIL_TMM_SEND_METHODS_RE = re.compile(
+    r":\s*(?:SendMail|SmtpConnect|Send)\s*\(", re.IGNORECASE,
+)
 # Anexo: ATTACHMENT (UDC) ou :AttachFile(
 _MAIL_ATTACH_RE = re.compile(
     r"\bATTACHMENT\b|:\s*AttachFile\s*\(", re.IGNORECASE,
@@ -127,6 +126,89 @@ def _snippet_at(content: str, linha: int, max_len: int = 200) -> str:
     return ""
 
 
+# --- Helpers ----------------------------------------------------------------
+
+
+def _split_top_level_commas(s: str) -> list[str]:
+    """Split por vírgulas top-level (ignora dentro de (), {}, []).
+
+    Usado pra extrair args de chamadas com aridade variável onde regex única
+    fica frágil (vide RpcSetEnv com 6 literais consecutivos — C3 v0.4.3).
+    Caller espera passar conteúdo já stripado (strings → spaces).
+    """
+    parts: list[str] = []
+    depth_paren = depth_brace = depth_bracket = 0
+    last = 0
+    for i, c in enumerate(s):
+        if c == "(":
+            depth_paren += 1
+        elif c == ")":
+            depth_paren -= 1
+        elif c == "{":
+            depth_brace += 1
+        elif c == "}":
+            depth_brace -= 1
+        elif c == "[":
+            depth_bracket += 1
+        elif c == "]":
+            depth_bracket -= 1
+        elif (
+            c == ","
+            and depth_paren == 0
+            and depth_brace == 0
+            and depth_bracket == 0
+        ):
+            parts.append(s[last:i])
+            last = i + 1
+    parts.append(s[last:])
+    return parts
+
+
+def _find_balanced_paren(s: str, open_idx: int) -> int:
+    """Dado idx de `(`, retorna idx do `)` casado. -1 se não casar."""
+    depth = 0
+    for i in range(open_idx, len(s)):
+        c = s[i]
+        if c == "(":
+            depth += 1
+        elif c == ")":
+            depth -= 1
+            if depth == 0:
+                return i
+    return -1
+
+
+def _parse_rpcsetenv_args(content: str, original: str, open_paren_offset: int) -> dict[str, str]:
+    """Extrai (empresa, filial, modulo) de uma chamada RpcSetEnv pelos args
+    posicionais. v0.4.3 (C3): substitui regex frágil que falhava com 6 args
+    literais consecutivos.
+
+    Args:
+        content: source stripado (strings → spaces) onde o match foi encontrado.
+        original: source original (não usado aqui — kept simples).
+        open_paren_offset: índice do `(` em ``content``.
+    """
+    close = _find_balanced_paren(content, open_paren_offset)
+    if close == -1:
+        return {"empresa": "", "filial": "", "modulo": ""}
+    args = _split_top_level_commas(content[open_paren_offset + 1 : close])
+
+    def _arg(idx: int) -> str:
+        if idx >= len(args):
+            return ""
+        token = args[idx].strip()
+        # Remove aspas se literal; caso contrário devolve identificador (variável).
+        if len(token) >= 2 and token[0] == token[-1] and token[0] in ("'", '"'):
+            return token[1:-1]
+        return token
+
+    return {
+        "empresa": _arg(0),
+        "filial": _arg(1),
+        "modulo": _arg(4),  # 5º arg (0-indexed)
+    }
+
+
 # --- Detectores -------------------------------------------------------------
 
 
@@ -134,13 +216,21 @@ def _detect_workflow(content: str, stripped: str) -> list[dict[str, Any]]:
     """Detecta `TWFProcess`, `MsWorkflow`, `WFPrepEnv` + extrai metadata."""
     out: list[dict[str, Any]] = []
     # TWFProcess (moderno) — emite 1 trigger por chamada com process_id.
-    for m in _WF_TWFPROCESS_RE.finditer(stripped):
+    # v0.4.3 (C1): coleta TODAS as posições primeiro pra calcular scope_end como
+    # próxima instanciação (vs janela fixa de 5000 chars que misturava callbacks
+    # entre TWFProcess vizinhos no mesmo fonte).
+    twfprocess_matches = list(_WF_TWFPROCESS_RE.finditer(stripped))
+    for i, m in enumerate(twfprocess_matches):
         process_id = m.group(1) or ""
         description = m.group(2) or ""
         linha = _line_at(stripped, m.start())
-        # Buscar callbacks no contexto da função (até 50 linhas pra frente).
         scope_start = m.start()
-        scope_end = min(len(stripped), scope_start + 5000)
+        if i + 1 < len(twfprocess_matches):
+            # Cap pelo próximo TWFProcess (preserva isolamento entre workflows).
+            scope_end = twfprocess_matches[i + 1].start()
+        else:
+            # Último — vai até EOF (mas com cap defensivo de 5000 chars).
+            scope_end = min(len(stripped), scope_start + 5000)
         scope = stripped[scope_start:scope_end]
         callbacks: dict[str, str] = {}
         for cm in _WF_CALLBACK_RE.finditer(scope):
@@ -263,9 +353,13 @@ def _detect_job_standalone(content: str, stripped: str) -> list[dict[str, Any]]:
             continue
         empresa = filial = modulo = ""
         if rpc_match:
-            empresa = rpc_match.group(1) or rpc_match.group(2) or ""
-            filial = rpc_match.group(3) or rpc_match.group(4) or ""
-            modulo = rpc_match.group(5) or ""
+            # v0.4.3 (C3): args via paren-balanced split (regex única era frágil
+            # quando 6 args vinham literais consecutivos sem vírgulas vazias).
+            # rpc_match.end() é offset em `body` (slice de `stripped`).
+            parsed_args = _parse_rpcsetenv_args(body, body, rpc_match.end() - 1)
+            empresa = parsed_args["empresa"]
+            filial = parsed_args["filial"]
+            modulo = parsed_args["modulo"]
         # Sleep — extrai intervalo em segundos (assume Sleep(N*1000) = N segundos).
         sleep_seconds = 0
         sm = _JOB_SLEEP_RE.search(body)
@@ -335,6 +429,14 @@ def _detect_mail_send(content: str, stripped: str) -> list[dict[str, Any]]:
     # TMailMessage:Send (preferido — TMailManager sozinho é só conexão).
     for m in _MAIL_TMAILMESSAGE_RE.finditer(stripped):
         _emit(m.start(), "TMailManager")
+    # v0.4.3 (I1): TMailManager solo (sem TMailMessage) — legacy. Detecta se há
+    # TMailManager + chamada de envio (`:SendMail`/`:Send`) no mesmo fonte e
+    # ainda nao temos trigger no fonte.
+    if not any(t["target"] == "TMailManager" for t in out):
+        tmm_match = _MAIL_TMAILMANAGER_RE.search(stripped)
+        send_match = _MAIL_TMM_SEND_METHODS_RE.search(stripped)
+        if tmm_match and send_match:
+            _emit(tmm_match.start(), "TMailManager")
     return out
 
 

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/plugadvpl/query.py

@@ -1132,20 +1132,45 @@ def protheus_docs_orphans(conn: sqlite3.Connection) -> list[dict[str, Any]]:
 
 
 def protheus_doc_show(
-    conn: sqlite3.Connection, funcao: str
+    conn: sqlite3.Connection,
+    funcao: str,
+    *,
+    arquivo: str | None = None,
 ) -> dict[str, Any] | None:
     """Retorna doc completo de uma função (modo `--show`).
 
-    Se há múltiplos docs (raro — função homônima em fontes diferentes),
-    retorna o primeiro. Match case-insensitive.
+    v0.4.3 (I2): aceita ``arquivo`` opcional pra desambiguar quando há
+    homônimos. Caller pode usar :func:`protheus_doc_homonyms` antes pra
+    detectar e listar opções.
     """
     sql = f"SELECT {_PDOC_COLUMNS} FROM protheus_docs WHERE funcao = ? COLLATE NOCASE"
-    row = conn.execute(sql, (funcao,)).fetchone()
+    params: list[Any] = [funcao]
+    if arquivo:
+        sql += " AND arquivo = ? COLLATE NOCASE"
+        params.append(arquivo)
+    sql += " ORDER BY arquivo, linha_bloco_inicio LIMIT 1"
+    row = conn.execute(sql, params).fetchone()
     if row is None:
         return None
     return _row_to_pdoc(row)
 
 
+def protheus_doc_homonyms(
+    conn: sqlite3.Connection, funcao: str
+) -> list[str]:
+    """v0.4.3 (I2): lista arquivos com Protheus.doc pra ``funcao``.
+
+    Usado por `docs --show` pra avisar quando há ambiguidade. Retorna lista
+    ordenada de basenames.
+    """
+    rows = conn.execute(
+        "SELECT DISTINCT arquivo FROM protheus_docs "
+        "WHERE funcao = ? COLLATE NOCASE ORDER BY arquivo",
+        (funcao,),
+    ).fetchall()
+    return [r[0] for r in rows]
+
+
 def render_pdoc_markdown(d: dict[str, Any]) -> str:
     """Renderiza um doc em Markdown estruturado pra modo `--show`."""
     lines: list[str] = []

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/tests/integration/test_cli.py

@@ -1068,6 +1068,39 @@ class TestDocs:
         funcs = {r["funcao"] for r in rows}
         assert "MT460NEW" in funcs
 
+    def test_docs_show_homonym_warns_and_supports_arquivo(
+        self, tmp_path: Path, runner: CliRunner
+    ) -> None:
+        """v0.4.3 (I2): 2 fontes com mesma funcao -> --show avisa em stderr
+        e --arquivo desambiguar."""
+        src = tmp_path / "src"
+        src.mkdir()
+        (src / "FnA.prw").write_bytes(
+            b'/*/{Protheus.doc} HomFn\nDoc do A.\n@author Anna\n/*/\n'
+            b'User Function HomFn()\nReturn\n'
+        )
+        (src / "FnB.prw").write_bytes(
+            b'/*/{Protheus.doc} HomFn\nDoc do B.\n@author Beto\n/*/\n'
+            b'User Function HomFn()\nReturn\n'
+        )
+        runner.invoke(app, ["--root", str(src), "init"])
+        runner.invoke(app, ["--root", str(src), "ingest"])
+
+        # Sem --arquivo: aviso em stderr + mostra primeiro alfabeticamente
+        result = runner.invoke(
+            app, ["--root", str(src), "docs", "--show", "HomFn"]
+        )
+        assert result.exit_code == 0
+        assert "2 fontes" in result.stderr or "Aviso" in result.stderr
+        assert "Anna" in result.stdout  # FnA.prw vem antes alfabeticamente
+
+        # Com --arquivo FnB.prw: mostra o do Beto
+        result2 = runner.invoke(
+            app, ["--root", str(src), "docs", "--show", "HomFn", "--arquivo", "FnB.prw"]
+        )
+        assert result2.exit_code == 0
+        assert "Beto" in result2.stdout
+
     def test_docs_persisted_in_db(self, docs_project: Path) -> None:
         """Sanity: tabela protheus_docs existe e tem 2 rows."""
         db = docs_project / ".plugadvpl" / "index.db"

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/tests/unit/test_execauto.py

@@ -256,6 +256,24 @@ class TestCatalog:
         assert "SC5" in mata410["tables_primary"]
         assert "SC6" in mata410["tables_primary"]
 
+    def test_catalog_no_duplicate_routines(self) -> None:
+        """v0.4.3 (I5): nome de rotina deve ser unico no catalogo.
+
+        Permite o lookup determinístico (`_routines_index` faz dict[upper_name]).
+        Duplicata silenciosa faria a 2a entrada sobrescrever a 1a sem warning.
+        """
+        cat = load_execauto_catalog()
+        names = [r["routine"].upper() for r in cat["routines"]]
+        dups = [n for n in set(names) if names.count(n) > 1]
+        assert not dups, f"Rotinas duplicadas no catalogo: {dups}"
+
+    def test_catalog_has_v043_additions(self) -> None:
+        """v0.4.3 (I5): novas rotinas comuns adicionadas — 6 entradas extras."""
+        cat = load_execauto_catalog()
+        names = {r["routine"] for r in cat["routines"]}
+        for novo in ("MATA020", "MATA040", "MATA112", "FATA010", "FATA050"):
+            assert novo in names, f"Esperado {novo} no catalogo v0.4.3"
+
 
 # --- arg_count + linha + snippet ------------------------------------------
 

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/tests/unit/test_protheus_doc.py

@@ -213,6 +213,19 @@ class TestModuleInference:
         """Path SIGAFIN deve vencer prefixo MATA*."""
         assert infer_module("src/SIGAFIN/MATA410.prw", "MATA410") == "SIGAFIN"
 
+    def test_module_ambiguous_prefix_returns_none(self) -> None:
+        """v0.4.3 (C5): prefix `MATA` casa rotinas de SIGAEST/SIGAFAT/SIGACOM.
+
+        Antes: retornava SIGAEST silenciosamente (sort alfabético favorecia).
+        Agora: ambiguidade real → None (não inventar). MATA999 não existe no
+        catálogo e o prefixo é ambíguo entre 3 módulos.
+        """
+        assert infer_module("X.prw", "MATA999") is None
+
+    def test_module_unambiguous_prefix_still_resolves(self) -> None:
+        """Prefixo `FINA` mapeia 100% pra SIGAFIN — sem ambiguidade, resolve."""
+        assert infer_module("X.prw", "FINA999") == "SIGAFIN"
+
 
 # --- Edge cases -----------------------------------------------------------
 
@@ -236,6 +249,40 @@ class TestEdgeCases:
         assert len(docs) == 1
         assert docs[0]["linha_funcao"] is None
 
+    def test_orphan_block_with_distant_function_treated_as_orphan(self) -> None:
+        """v0.4.3 (C4): bloco órfão NÃO deve "puxar" função muito longe.
+
+        Cap: max 80 linhas entre /*/ fechamento e próxima decl. Acima disso
+        funcao=None, linha_funcao=None (preserva sinal de "órfão" e impede
+        que a função seguinte ganhe doc errada).
+        """
+        # 100 linhas vazias entre /*/ e a decl
+        spacer = "\n".join(["// linha de filler"] * 100)
+        src = (
+            '/*/{Protheus.doc} Soltinho\nDoc.\n/*/\n'
+            f'{spacer}\n'
+            'User Function MuitoDepois()\n'
+            'Return\n'
+        )
+        docs = extract_protheus_docs(src)
+        assert len(docs) == 1
+        d = docs[0]
+        assert d["funcao"] is None, (
+            "Esperado funcao=None pra bloco com decl 100+ linhas adiante"
+        )
+        assert d["linha_funcao"] is None
+
+    def test_block_with_function_within_cap_resolves(self) -> None:
+        """Sanity: decl dentro do cap (5 linhas) ainda resolve."""
+        src = (
+            '/*/{Protheus.doc} Fn\nDoc.\n/*/\n'
+            '// 1\n// 2\n// 3\n'
+            'User Function Fn()\nReturn\n'
+        )
+        d = extract_protheus_docs(src)[0]
+        assert d["funcao"] == "Fn"
+        assert d["linha_funcao"] is not None
+
     def test_summary_stops_at_first_tag(self) -> None:
         """Summary = linhas até primeira @tag, não inclui tags."""
         src = (
@@ -278,6 +325,35 @@ class TestEdgeCases:
         assert d["history"][0]["user"] == "fvernier"
         assert "Refactor" in d["history"][0]["desc"]
 
+    def test_example_with_inline_close_marker_does_not_close(self) -> None:
+        """v0.4.3 (C2): `/*/` literal em meio de comentário no @example NÃO
+        deve fechar o bloco prematuramente.
+
+        Antes (bug): regex non-greedy `(?P<body>.*?)/\\*/` casava o primeiro
+        `/*/` que aparecesse — mesmo dentro do exemplo. Agora o fechamento
+        exige start-of-line (padrão oficial TOTVS — `/*/` fica sozinho na
+        própria linha).
+        """
+        src = (
+            '/*/{Protheus.doc} Fn\n'
+            'Doc.\n'
+            '@example\n'
+            '   //  /*/ exemplo dentro do comentario\n'
+            '   Local x := 1\n'
+            '/*/\n'
+            'User Function Fn()\n'
+            'Return\n'
+        )
+        docs = extract_protheus_docs(src)
+        assert len(docs) == 1
+        d = docs[0]
+        assert d["funcao"] == "Fn"
+        # O exemplo deve incluir o código completo (incluindo a linha do `/*/` interno).
+        assert d["examples"], "esperado pelo menos 1 example"
+        ex = d["examples"][0]
+        assert "Local x" in ex
+        assert "exemplo dentro" in ex
+
     def test_example_with_at_inside_code(self) -> None:
         """@example com '@' dentro do código não conta como nova tag."""
         src = (

{plugadvpl-0.4.2 → plugadvpl-0.4.3}/tests/unit/test_triggers.py

@@ -65,6 +65,30 @@ class TestWorkflowTrigger:
         triggers = extract_execution_triggers(src)
         assert "workflow" not in _kinds(triggers)
 
+    def test_two_twfprocess_distinct_callbacks(self) -> None:
+        """v0.4.3 (C1): 2 TWFProcess no mesmo arquivo nao devem misturar callbacks.
+
+        Antes (bug): scope_end fixo de 5000 chars capturava callback do segundo
+        TWFProcess e atribuia ao primeiro. Agora scope eh limitado pelo proximo
+        TWFProcess (ou EOF se nao houver).
+        """
+        src = (
+            'User Function W1()\n'
+            '   oWF1 := TWFProcess():New("P1", "D1")\n'
+            '   oWF1:bReturn := {|o| Cb1(o)}\n'
+            'Return\n'
+            'User Function W2()\n'
+            '   oWF2 := TWFProcess():New("P2", "D2")\n'
+            '   oWF2:bReturn := {|o| Cb2(o)}\n'
+            'Return\n'
+        )
+        triggers = extract_execution_triggers(src)
+        wf = [t for t in triggers if t["kind"] == "workflow" and t["metadata"].get("process_id")]
+        assert len(wf) == 2
+        by_pid = {t["metadata"]["process_id"]: t for t in wf}
+        assert by_pid["P1"]["metadata"]["return_callback"].lower() == "cb1"
+        assert by_pid["P2"]["metadata"]["return_callback"].lower() == "cb2"
+
 
 # --- Schedule ---------------------------------------------------------------
 
@@ -142,6 +166,27 @@ class TestJobStandaloneTrigger:
         assert meta["stop_flag"] == "/stop_nfe.flg"
         assert meta["no_license"] is True
 
+    def test_rpcsetenv_six_literal_args_extracts_modulo(self) -> None:
+        """v0.4.3 (C3): RpcSetEnv com 6 args literais consecutivos extrai modulo.
+
+        Antes (bug): regex `(?:[^)]*?['\"](\\w*)['\"])?` consumia args 3 e 4
+        sem alcancar o 5o. Agora usa split top-level pra pegar o 5o exato.
+        """
+        src = (
+            'Main Function J()\n'
+            '   RpcSetEnv("01","01","","","FAT","J")\n'
+            '   While !File("/stop_j.flg")\n'
+            '      Sleep(60000)\n'
+            '   EndDo\n'
+            'Return\n'
+        )
+        triggers = extract_execution_triggers(src)
+        jobs = [t for t in triggers if t["kind"] == "job_standalone"]
+        assert len(jobs) == 1
+        assert jobs[0]["metadata"]["empresa"] == "01"
+        assert jobs[0]["metadata"]["filial"] == "01"
+        assert jobs[0]["metadata"]["modulo"] == "FAT"
+
     def test_negative_main_function_without_rpcsetenv(self) -> None:
         """Main Function sem RpcSetEnv (entry point standalone) — NAO eh job."""
         src = (
@@ -200,6 +245,27 @@ class TestMailSendTrigger:
         mails = [t for t in triggers if t["kind"] == "mail_send"]
         assert any(m["metadata"]["variant"] == "UDC" for m in mails)
 
+    def test_positive_tmailmanager_solo_without_tmailmessage(self) -> None:
+        """v0.4.3 (I1): TMailManager + :Send sem TMailMessage (legacy padrao).
+
+        Antes: detector exigia TMailMessage; fontes legados (anteriores ao
+        TMailMessage) eram ignorados. Agora TMailManager + :Send no mesmo
+        scope tambem vira trigger.
+        """
+        src = (
+            'User Function ZLegacy()\n'
+            '   Local oSrv := TMailManager():New()\n'
+            '   oSrv:Init("", SuperGetMv("MV_RELSERV"), SuperGetMv("MV_RELACNT"), "", 0, 587)\n'
+            '   oSrv:SmtpConnect()\n'
+            '   oSrv:SendMail(cFrom, aTo, cSubject, cBody)\n'
+            '   oSrv:Disconnect()\n'
+            'Return\n'
+        )
+        triggers = extract_execution_triggers(src)
+        mails = [t for t in triggers if t["kind"] == "mail_send"]
+        assert len(mails) >= 1
+        assert mails[0]["metadata"]["variant"] == "TMailManager"
+
     def test_negative_mail_in_comment(self) -> None:
         """MailAuto em comentario nao dispara."""
         src = (