plugadvpl 0.4.2__tar.gz → 0.4.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugadvpl
-Version: 0.4.2
+Version: 0.4.4
 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.4}/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.4'
+__version_tuple__ = version_tuple = (0, 4, 4)
 
 __commit_id__ = commit_id = None

{plugadvpl-0.4.2 → plugadvpl-0.4.4}/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,
@@ -114,6 +115,29 @@ class TableMode(StrEnum):
     reclock = "reclock"
 
 
+# v0.4.4 (UX #4): Enums pros filtros enumeráveis dos comandos Universo 3.
+# Typer rejeita valores fora do enum antes de chegar na query (com mensagem
+# clara listando as opções válidas) — substitui o comportamento antigo de
+# silenciosamente retornar vazio em `--op invalida` / `--kind tipoinexistente`.
+
+
+class WorkflowKind(StrEnum):
+    """Kinds do comando ``workflow`` (Universo 3 Feature A)."""
+
+    workflow = "workflow"
+    schedule = "schedule"
+    job_standalone = "job_standalone"
+    mail_send = "mail_send"
+
+
+class ExecAutoOp(StrEnum):
+    """Operações do filtro ``--op`` em ``execauto`` (Universo 3 Feature B)."""
+
+    inc = "inc"
+    alt = "alt"
+    exc = "exc"
+
+
 # ---------------------------------------------------------------------------
 # Callback global — popula ctx.obj com flags compartilhadas.
 # ---------------------------------------------------------------------------
@@ -243,6 +267,41 @@ def _with_ro_db(
         conn.close()
 
 
+def _empty_result_hints(
+    filters_applied: bool,
+    *,
+    table_label: str,
+    extra_when_filtered: list[str] | None = None,
+) -> list[str]:
+    """Sugestões para resultado vazio (v0.4.4 UX #3).
+
+    Diferencia 2 cenários:
+
+    - ``filters_applied=True``: filtro semanticamente vazio (ex.: --arquivo
+      inexistente) → sugere verificar o filtro, NÃO sugere reingest caro.
+    - ``filters_applied=False``: tabela realmente vazia → sugere reingest.
+
+    Args:
+        filters_applied: True se o usuário passou pelo menos 1 filtro.
+        table_label: rótulo amigável da tabela (ex.: "triggers", "calls").
+        extra_when_filtered: hints adicionais úteis quando filtrado
+            (ex.: ``--dynamic`` pra execauto).
+    """
+    if filters_applied:
+        hints = [
+            "Filtro retornou vazio. Verifique se os argumentos batem com o índice:",
+            "  plugadvpl find <termo>           # confirma nome",
+            "  plugadvpl status                  # ver contadores",
+        ]
+        if extra_when_filtered:
+            hints.extend(extra_when_filtered)
+        return hints
+    return [
+        f"Nenhum {table_label} no índice. Rode:",
+        "  plugadvpl ingest --no-incremental",
+    ]
+
+
 # ---------------------------------------------------------------------------
 # version
 # ---------------------------------------------------------------------------
@@ -934,7 +993,24 @@ def grep(
     """Busca textual no conteúdo dos chunks (FTS5 / LIKE / identifier)."""
 
     limit = ctx.obj["limit"] or 50
-    rows = _with_ro_db(ctx, lambda c: grep_fts(c, pattern, mode=mode.value, limit=limit))
+    try:
+        rows = _with_ro_db(ctx, lambda c: grep_fts(c, pattern, mode=mode.value, limit=limit))
+    except sqlite3.OperationalError as exc:
+        # v0.4.4 (BUG #1): FTS5 rejeita caracteres como `/`, `(`, `)`. Antes
+        # propagava traceback completo vazando paths internos. Agora mensagem
+        # amigável + sugestão de modo alternativo.
+        if mode == GrepMode.fts and "fts5" in str(exc).lower():
+            typer.echo(
+                f"Padrão FTS5 inválido: {pattern!r}.\n"
+                f"FTS5 não aceita caracteres como '/', '(', ')', '[', ']'. "
+                f"Operadores válidos: '+', '*', '\"frase\"', 'OR', 'AND', 'NEAR'.\n"
+                f"Alternativas:\n"
+                f"  plugadvpl grep {pattern!r} -m literal      (substring exata via LIKE)\n"
+                f"  plugadvpl grep <termo> -m identifier        (busca por símbolo)",
+                err=True,
+            )
+            raise typer.Exit(code=2) from exc
+        raise
     _render_from_ctx(
         ctx,
         rows,
@@ -1110,11 +1186,12 @@ def sx_status_cmd(ctx: typer.Context) -> None:
 def workflow(
     ctx: typer.Context,
     kind: Annotated[
-        str | None,
+        WorkflowKind | None,
         typer.Option(
             "--kind",
             "-k",
             help="Filtra por tipo: workflow|schedule|job_standalone|mail_send",
+            case_sensitive=False,
         ),
     ] = None,
     target: Annotated[
@@ -1163,9 +1240,12 @@ def workflow(
             + (f" (arquivo={arquivo})" if arquivo else "")
         ),
         next_steps=(
-            [f"plugadvpl find {target}" for target in {r["target"] for r in rows[:3] if r["target"]}]
+            [f"plugadvpl find {t}" for t in {r["target"] for r in rows[:3] if r["target"]}]
             if rows
-            else ["plugadvpl ingest --no-incremental  # se nada detectado"]
+            else _empty_result_hints(
+                bool(kind or target or arquivo),
+                table_label="execution trigger",
+            )
         ),
     )
 
@@ -1191,8 +1271,13 @@ def execauto(
         typer.Option("--arquivo", "-a", help="Filtra por arquivo (basename, case-insensitive)."),
     ] = None,
     op: Annotated[
-        str | None,
-        typer.Option("--op", "-o", help="Filtra por operação: inc|alt|exc (op_code 3/4/5)."),
+        ExecAutoOp | None,
+        typer.Option(
+            "--op",
+            "-o",
+            help="Filtra por operação: inc|alt|exc (op_code 3/4/5).",
+            case_sensitive=False,
+        ),
     ] = None,
     dynamic: Annotated[
         bool | None,
@@ -1249,10 +1334,13 @@ def execauto(
                 for arq in {r["arquivo"] for r in rows[:3]}
             ]
             if rows
-            else [
-                "plugadvpl ingest --no-incremental  # se esperava findings",
-                "plugadvpl execauto --dynamic       # ver calls não-resolvíveis",
-            ]
+            else _empty_result_hints(
+                bool(routine or modulo or arquivo or op or dynamic is not None),
+                table_label="execauto call",
+                extra_when_filtered=[
+                    "  plugadvpl execauto --dynamic     # ver calls não-resolvíveis",
+                ],
+            )
         ),
     )
 
@@ -1305,10 +1393,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
 
@@ -1368,10 +1474,13 @@ def docs(
                 for r in rows[:3] if r.get("funcao")
             ]
             if rows
-            else [
-                "plugadvpl docs --orphans  # funções sem header",
-                "plugadvpl ingest --no-incremental  # se esperava docs",
-            ]
+            else _empty_result_hints(
+                bool(modulo or author or funcao or arquivo or deprecated is not None or tipo),
+                table_label="Protheus.doc",
+                extra_when_filtered=[
+                    "  plugadvpl docs --orphans         # funções sem header (BP-007)",
+                ],
+            )
         ),
     )
 

{plugadvpl-0.4.2 → plugadvpl-0.4.4}/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.4}/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.4/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.4}/plugadvpl/parsing/protheus_doc.py

@@ -30,14 +30,21 @@ _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.
+# v0.4.4 (BUG #2): inclui construtos de Web Service (WSSTRUCT/WSSERVICE/
+# WSRESTFUL/WSMETHOD) que não têm parens. Antes ficavam órfãos e
+# `docs --funcao`/`docs --show` não encontrava.
 _NEXT_DECL_RE = re.compile(
     r"^\s*(?:User\s+|Static\s+|Main\s+)?Function\s+(\w+)\s*\("
-    r"|^\s*Method\s+(\w+)\s*\(",
+    r"|^\s*Method\s+(\w+)\s*\("
+    r"|^\s*WS(?:STRUCT|SERVICE|RESTFUL|METHOD)\s+(\w+)\b",
     re.IGNORECASE | re.MULTILINE,
 )
 
@@ -95,15 +102,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 +205,29 @@ 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
-    name = m.group(1) or m.group(2)
-    return name, _line_at(content, m.start())
+    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
+    # v0.4.4 (BUG #2): grupo 3 cobre WS constructs (WSSTRUCT/WSSERVICE/etc).
+    name = m.group(1) or m.group(2) or m.group(3)
+    return name, decl_line
 
 
 def _parse_body(body: str) -> tuple[str, list[tuple[str, str]]]:

{plugadvpl-0.4.2 → plugadvpl-0.4.4}/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.4}/plugadvpl/query.py

@@ -1088,8 +1088,11 @@ def protheus_docs_query(
         where.append("author LIKE ? COLLATE NOCASE")
         params.append(f"%{author}%")
     if funcao:
-        where.append("funcao = ? COLLATE NOCASE")
-        params.append(funcao)
+        # v0.4.4 (BUG #2): fallback pra funcao_id quando a coluna funcao
+        # ficou NULL (ex.: bloco órfão, ou DB indexado em versão antiga
+        # que não conhecia WSSTRUCT/WSSERVICE/etc).
+        where.append("(funcao = ? COLLATE NOCASE OR funcao_id = ? COLLATE NOCASE)")
+        params.extend([funcao, funcao])
     if arquivo:
         where.append("arquivo = ? COLLATE NOCASE")
         params.append(arquivo)
@@ -1132,20 +1135,56 @@ 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.
+
+    v0.4.4 (BUG #2): match também via ``funcao_id`` quando coluna ``funcao``
+    está NULL (DBs antigos com WSSTRUCT/WSSERVICE não-resolvidos, ou
+    blocos órfãos cuja decl seguinte ficou > 80 linhas adiante).
     """
-    sql = f"SELECT {_PDOC_COLUMNS} FROM protheus_docs WHERE funcao = ? COLLATE NOCASE"
-    row = conn.execute(sql, (funcao,)).fetchone()
+    sql = (
+        f"SELECT {_PDOC_COLUMNS} FROM protheus_docs "
+        "WHERE (funcao = ? COLLATE NOCASE OR funcao_id = ? COLLATE NOCASE)"
+    )
+    params: list[Any] = [funcao, 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.
+
+    v0.4.4 (BUG #2): match também via ``funcao_id`` (cobertura de blocos
+    órfãos e WS constructs em DBs antigos).
+    """
+    rows = conn.execute(
+        "SELECT DISTINCT arquivo FROM protheus_docs "
+        "WHERE funcao = ? COLLATE NOCASE OR funcao_id = ? COLLATE NOCASE "
+        "ORDER BY arquivo",
+        (funcao, 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] = []