@ihelpee/prumo-plugin-go-gin 0.0.0-stage → 0.9.0

package/dist/rules.js

@@ -0,0 +1,718 @@
+import { rule, definePlugin, } from '@ihelpee/prumo/invariants';
+import { startsWithAny } from '@ihelpee/prumo/core';
+import { runGoExtractor, DEFAULT_AUTH_SYMBOLS, DEFAULT_PUBLIC_SYMBOLS, DEFAULT_KNOWN_ERR_RETURNING, DEFAULT_ORACLE_DIRS, } from './ast.js';
+import pkg from '../package.json' with { type: 'json' };
+/**
+ * Invariantes Go/Gin (spec `docs/especificacao-prumo-go-gin.md` §2 e §3).
+ *
+ * A LEI mora aqui, no core Node (DECISÃO §4.2 — anti-bifurcação): o
+ * extrator Go é só parser; a decisão "isto é violação?" é 100% daqui. Se a
+ * lógica de violação fosse reimplementada em Go, nasceria um segundo oráculo
+ * da mesma regra — e dois implementadores da mesma lei driftam, o que é
+ * auto-refutação para uma ferramenta que caça drift.
+ *
+ * Severidade segue a política do core: só `error` bloqueia; heurística é
+ * `warn` (promovível via `--fail-on-warn`). Cada regra declara o que NÃO
+ * pega (fronteira honesta, Art. IV).
+ */
+const MUTATING = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
+/** Bindings de BODY: sem tag é `error` (R3.12). */
+const BODY_BINDINGS = new Set([
+    'ShouldBindJSON',
+    'BindJSON',
+    'ShouldBind',
+    'Bind',
+    'ShouldBindWith',
+    'BindWith',
+    'ShouldBindXML',
+    'BindXML',
+    'ShouldBindYAML',
+    'BindYAML',
+    'ShouldBindMsgPack',
+    'BindMsgPack',
+]);
+/** Bindings de QUERY/URI/HEADER/FORM: sem tag é `warn` (R3.12). */
+const QUERY_BINDINGS = new Set([
+    'ShouldBindQuery',
+    'BindQuery',
+    'ShouldBindQueryWith',
+    'BindQueryWith',
+    'ShouldBindUri',
+    'BindUri',
+    'ShouldBindUriWith',
+    'BindUriWith',
+    'ShouldBindHeader',
+    'BindHeader',
+    'ShouldBindForm',
+    'BindForm',
+]);
+const MONETARY_NAME = /(amount|price|total|cost|value|balance|fee|valor|preco|custo|saldo)/i;
+const FLOAT_TYPE = /^(float32|float64)$/;
+function hasCentsSuffix(name) {
+    return /Cents$|Centavos$/i.test(name);
+}
+function goState(ctx) {
+    const raw = ctx.get('go');
+    if (raw && raw.result)
+        return raw;
+    // Extractor não rodou (regra sem needsData('go')): estado vazio, nunca crash.
+    return { result: { status: 'error', message: 'extractor go não executado' } };
+}
+function model(ctx) {
+    const r = goState(ctx).result;
+    return r.status === 'ok' ? r.model : null;
+}
+/**
+ * R1.4: `go` ausente no host NÃO é skip silencioso. As regras `error`
+ * retornam vazio (não podem avaliar), e esta regra dedicada emite um achado
+ * `warn` nomeado que o relatório destaca. Um gate que pula mudo reporta mais
+ * saúde do que existe; um gate que bloqueia por ferramenta ausente é gate
+ * que o time desliga. `--fail-on-warn` promove a bloqueio.
+ */
+export function goToolchainMissing(opts = {}) {
+    return rule('go-toolchain-missing')
+        .severity('warn')
+        .needsData('go')
+        .message("toolchain 'go' ausente ou extrator falhou: invariantes Go não avaliados. Instale Go >= 1.21 ou trate o skip — skip silencioso é o defeito que o gate existe para caçar")
+        .assert((ctx) => {
+        const r = goState(ctx).result;
+        // Só sinaliza quando HÁ arquivos .go (repo Go de verdade).
+        if (r.status === 'ok')
+            return [];
+        return [{ target: `go-extractor indisponível (${statusLabel(r)})` }];
+    })
+        .build();
+}
+function statusLabel(r) {
+    if (r.status === 'missing-go')
+        return "'go' ausente no PATH";
+    if (r.status === 'timeout')
+        return `go-parse-timeout após ${r.timeoutMs}ms`;
+    if (r.status === 'error')
+        return r.message;
+    return 'ok';
+}
+/** R1.3: arquivo com erro de parse vira achado `go-parse-error` (nunca mudo). */
+export function goParseError() {
+    return rule('go-parse-error')
+        .severity('error')
+        .needsData('go')
+        .message('arquivo .go com erro de parse: ignorado pelas regras — corrija o arquivo ou exclua-o do escopo')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return [];
+        return parseErrorTargets(m);
+    })
+        .build();
+}
+function parseErrorTargets(m) {
+    const out = [];
+    for (const f of m.files) {
+        if (f.error === 'parse') {
+            out.push({ target: `${f.path} (erro de parse Go — arquivo ignorado pelas regras)`, location: f.path });
+        }
+    }
+    return out;
+}
+function buildGuardIndex(files) {
+    const engines = new Set();
+    const groups = new Map();
+    const useByReceiver = new Map();
+    for (const f of files) {
+        for (const e of f.engineRoots)
+            engines.add(e.name);
+        for (const g of f.groupDefs) {
+            const prev = groups.get(g.var);
+            groups.set(g.var, {
+                parent: g.parent,
+                guards: [...(prev?.guards ?? []), ...g.guards],
+            });
+        }
+        for (const u of f.useCalls) {
+            const list = useByReceiver.get(u.receiver) ?? [];
+            list.push(...u.guards);
+            useByReceiver.set(u.receiver, list);
+        }
+    }
+    return { engines, groups, useByReceiver };
+}
+/**
+ * Guards herdados por um receiver: sobe a cadeia de grupos até a engine raiz
+ * (R3.4 — resolução transitiva de parent) e coleta os Use() de cada nível
+ * (R3.2 grupo, R3.3 engine).
+ */
+function inheritedGuards(receiver, idx) {
+    const out = [];
+    const seen = new Set();
+    let cur = receiver;
+    while (cur && !seen.has(cur)) {
+        seen.add(cur);
+        out.push(...(idx.useByReceiver.get(cur) ?? []));
+        const g = idx.groups.get(cur);
+        if (g) {
+            out.push(...g.guards);
+            cur = g.parent;
+        }
+        else {
+            cur = undefined;
+        }
+    }
+    return out;
+}
+function makeAuthMatcher(authSymbols, publicSymbols) {
+    const auth = new Set(authSymbols);
+    const isAuth = (sym) => {
+        // `gin.Auth` e `Auth` contam igual: compara o último segmento.
+        const leaf = sym.includes('.') ? sym.slice(sym.lastIndexOf('.') + 1) : sym;
+        return auth.has(leaf);
+    };
+    const isPublic = (sym) => {
+        const leaf = sym.includes('.') ? sym.slice(sym.lastIndexOf('.') + 1) : sym;
+        return publicSymbols.includes(leaf);
+    };
+    return { isAuth, isPublic };
+}
+// ---------------------------------------------------------------------------
+// R3.1–R3.6 — mutation-routes-guarded
+// ---------------------------------------------------------------------------
+/**
+ * Rota de mutação (POST/PUT/PATCH/DELETE) registrada em gin.Engine ou
+ * gin.RouterGroup sem middleware de auth em NENHUMA camada (inline,
+ * Group.Use, Engine.Use). A camada de grupo é a maior fonte de
+ * falso-negativo; a resolução transitiva (R3.2/R3.4) é obrigatória.
+ *
+ * Fronteira honesta: Recovery/Logger/CORS NÃO são auth (R3.5); rota de
+ * leitura (GET/HEAD/OPTIONS) nunca é alvo; `NoAuth()` explícito marca
+ * público intencional (R3.6).
+ */
+export function mutationRoutesGuarded(opts = {}) {
+    const { isAuth, isPublic } = makeAuthMatcher(opts.authSymbols ?? DEFAULT_AUTH_SYMBOLS, opts.publicSymbols ?? DEFAULT_PUBLIC_SYMBOLS);
+    return rule('mutation-routes-guarded')
+        .severity('error')
+        .needsData('go')
+        .message('rota de mutação Gin (POST/PUT/PATCH/DELETE) sem middleware de auth/autorização em nenhuma camada (inline, Group.Use, Engine.Use); Recovery/Logger/CORS não são auth')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return []; // toolchain ausente: regra irmã `go-toolchain-missing` sinaliza (nunca mudo)
+        const out = [];
+        const idx = buildGuardIndex(m.files);
+        for (const f of m.files) {
+            if (f.error)
+                continue;
+            for (const r of f.routes) {
+                if (!MUTATING.has(r.method))
+                    continue;
+                const inline = [...r.inlineGuards];
+                if (inline.some(isPublic))
+                    continue; // público intencional (R3.6)
+                if (inline.some(isAuth))
+                    continue; // protegida inline (R3.1)
+                const inherited = inheritedGuards(r.receiver, idx);
+                if (inherited.some(isAuth))
+                    continue; // protegida em grupo/engine (R3.2/R3.3/R3.4)
+                out.push({
+                    target: `${r.method} ${r.path} (${r.handler || 'handler'})`,
+                    location: `${f.path}:${r.line}`,
+                });
+            }
+        }
+        return out;
+    })
+        .build();
+}
+// ---------------------------------------------------------------------------
+// R3.7/R3.8 — error-handling-enforced
+// ---------------------------------------------------------------------------
+/**
+ * O anti-padrão mais perigoso em Go: erro silenciosamente descartado.
+ *
+ * - R3.7 (error): descarte EXPLÍCITO — `_ = err`, `x, _ := f()`. Decisão
+ *   deliberada de ignorar falha → bloqueia.
+ * - R3.8 (warn): chamada cujo último retorno é error aparece como ExprStmt
+ *   puro (`db.Save(o)` sozinho). Sem type info o parser NÃO sabe quais
+ *   funções retornam error, então é HEURÍSTICO: só `knownErrReturning` ou
+ *   função que já aparece com `err` no mesmo arquivo. Por isso `warn`.
+ *
+ * Fronteira honesta: `if err := f(); err != nil` não é achado; `fmt.Println`
+ * (não retorna error) não é achado.
+ */
+export function errorHandlingEnforced(_opts = {}) {
+    return rule('error-handling-enforced')
+        .severity('error')
+        .needsData('go')
+        .message('erro de retorno descartado (_ = err, x, _ := f()) ou chamado sem if err != nil — o modo de falha silenciosa mais comum em Go')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return []; // toolchain ausente: regra irmã `go-toolchain-missing` sinaliza (nunca mudo)
+        const out = [];
+        for (const f of m.files) {
+            if (f.error)
+                continue;
+            // R3.7 — descarte explícito: severity error (a regra é error).
+            for (const d of f.errorHandling.explicitDiscards) {
+                out.push({ target: `${d.expr} (erro descartado)`, location: `${f.path}:${d.line}` });
+            }
+            // R3.8 heurística vive na regra irmã `error-handling-unchecked`
+            // (warn): misturar heurística nesta regra `error` violaria a
+            // política do core ("check que falha por heurística é o que o time
+            // desliga na segunda semana").
+        }
+        return out;
+    })
+        .build();
+}
+/**
+ * R3.8 isolado — chamada que retorna error sem check, como `warn` (heurística
+ * sem type info). Separada de `error-handling-enforced` (que é `error`) para
+ * respeitar a política do core: heurística que bloqueia é heurística que o
+ * time desliga na segunda semana.
+ *
+ * Redução de falso-positivo: só `knownErrReturning` OU função que já aparece
+ * com `err` noutra linha do mesmo arquivo.
+ */
+export function errorHandlingUnchecked(opts = {}) {
+    const known = new Set(opts.knownErrReturning ?? DEFAULT_KNOWN_ERR_RETURNING);
+    return rule('error-handling-unchecked')
+        .severity('warn')
+        .needsData('go')
+        .message('chamada que retorna error usada como statement sem if err != nil (heurística: função em knownErrReturning ou vista com err no arquivo)')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return []; // heurística: sem toolchain, sem achado (não é skip mudo — a regra error irmã já sinaliza)
+        const out = [];
+        for (const f of m.files) {
+            if (f.error)
+                continue;
+            // Funções que já aparecem com `err` neste arquivo (fator de
+            // redução de falso-positivo R3.8; a decisão de violar é daqui).
+            const checkedHere = new Set(f.checkedCallees.map(leafOf));
+            for (const c of f.errorHandling.uncheckedErrCalls) {
+                const fnName = calleeLeaf(c.expr);
+                if (!fnName)
+                    continue;
+                const whitelisted = known.has(fnName);
+                const seenWithErr = checkedHere.has(fnName);
+                // R3.8: só heurística quando a função é conhecida por retornar
+                // error OU já aparece com err no mesmo arquivo.
+                if (!whitelisted && !seenWithErr)
+                    continue;
+                out.push({ target: `${c.expr} (retorno de error ignorado)`, location: `${f.path}:${c.line}` });
+            }
+        }
+        return out;
+    })
+        .build();
+}
+/** Extrai o leaf de um nome possivelmente qualificado: `db.Save` -> `Save`. */
+function leafOf(name) {
+    return name.includes('.') ? name.slice(name.lastIndexOf('.') + 1) : name;
+}
+/** Extrai o nome do método/função chamado de uma expressão `a.B(...)` / `b(...)`. */
+function calleeLeaf(expr) {
+    const m = expr.match(/^([\w.*]+)\(/);
+    if (!m)
+        return null;
+    const callee = m[1];
+    const leaf = callee.includes('.') ? callee.slice(callee.lastIndexOf('.') + 1) : callee;
+    return leaf;
+}
+// ---------------------------------------------------------------------------
+// R3.9–R3.12 — payload-validation-bound
+// ---------------------------------------------------------------------------
+/**
+ * Handler Gin que faz binding de payload para struct cujos campos não
+ * declaram tags `binding:"..."` de validação.
+ *
+ * R3.9: resolve o tipo da struct por heurística SINTÁTICA (var req T, req :=
+ * T{}, parâmetro func(req *T)). Se o tipo não for resolvível no arquivo,
+ * NÃO reporta (nunca adivinha).
+ * R3.10: qualquer campo de dados (exportado) com hasBinding==false é achado.
+ * R3.11: `binding:"-"` é ignorado (não faz parte do payload validável).
+ * R3.12: body (ShouldBindJSON/Bind/...) é `error`; query/uri é `warn`.
+ */
+export function payloadValidationBound() {
+    return rule('payload-validation-bound')
+        .severity('error')
+        .needsData('go')
+        .message('binding de payload (ShouldBindJSON/Bind) numa struct com campo de dados sem tag binding:"..." de validação')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return []; // toolchain ausente: regra irmã `go-toolchain-missing` sinaliza (nunca mudo)
+        const out = [];
+        for (const f of m.files) {
+            if (f.error)
+                continue;
+            const structsByName = new Map(f.structs.map((s) => [s.name, s]));
+            const varType = new Map(f.varTypes.map((v) => [v.var, v.type]));
+            for (const b of f.bindings) {
+                if (!BODY_BINDINGS.has(b.func))
+                    continue; // query/uri é warn (regra irmã)
+                const rawType = varType.get(b.varName);
+                if (!rawType)
+                    continue; // R3.9: tipo não resolvível → não reporta
+                const typeName = rawType.replace(/^\*/, '').replace(/^[\w.]+\./, ''); // *db.Order -> Order? não: mantém leaf só p/ tipos locais
+                // só resolve structs LOCAIS (sem pacote): payload de entrada é local.
+                if (rawType.replace(/^\*/, '').includes('.'))
+                    continue;
+                const st = structsByName.get(typeName);
+                if (!st)
+                    continue;
+                const unvalidated = st.fields.filter((fl) => fl.bindingTag !== '-' && !fl.hasBinding && isExported(fl.name));
+                if (unvalidated.length === 0)
+                    continue;
+                out.push({
+                    target: `${typeName}.${unvalidated.map((fl) => fl.name).join(', ')} (sem binding)`,
+                    location: `${f.path}:${b.line}`,
+                });
+            }
+        }
+        return out;
+    })
+        .build();
+}
+/** R3.12 — binding de query/uri sem tag é `warn` (validação de query é frequentemente opcional). */
+export function payloadValidationQuery(opts = {}) {
+    void opts;
+    return rule('payload-validation-query')
+        .severity('warn')
+        .needsData('go')
+        .message('binding de query/uri (ShouldBindQuery/ShouldBindUri) numa struct sem tag binding:"..." (validação de query é frequentemente opcional — warn)')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return [];
+        const out = [];
+        for (const f of m.files) {
+            if (f.error)
+                continue;
+            const structsByName = new Map(f.structs.map((s) => [s.name, s]));
+            const varType = new Map(f.varTypes.map((v) => [v.var, v.type]));
+            for (const b of f.bindings) {
+                if (!QUERY_BINDINGS.has(b.func))
+                    continue;
+                const rawType = varType.get(b.varName);
+                if (!rawType || rawType.replace(/^\*/, '').includes('.'))
+                    continue;
+                const typeName = rawType.replace(/^\*/, '');
+                const st = structsByName.get(typeName);
+                if (!st)
+                    continue;
+                const unvalidated = st.fields.filter((fl) => fl.bindingTag !== '-' && !fl.hasBinding && isExported(fl.name));
+                if (unvalidated.length === 0)
+                    continue;
+                out.push({
+                    target: `${typeName}.${unvalidated.map((fl) => fl.name).join(', ')} (query sem binding)`,
+                    location: `${f.path}:${b.line}`,
+                });
+            }
+        }
+        return out;
+    })
+        .build();
+}
+function isExported(name) {
+    return /^[A-Z]/.test(name);
+}
+// ---------------------------------------------------------------------------
+// R2.x — isolamento de oráculo em Go (regras nativas; o check de core só
+// entende import de TypeScript, então Go precisa de arestas próprias).
+// ---------------------------------------------------------------------------
+function srcPrefixes(opts) {
+    return opts.srcDirs ?? ['internal', 'pkg', 'cmd'];
+}
+function oraclePrefixes(opts) {
+    return opts.oracleDirs ?? [...DEFAULT_ORACLE_DIRS];
+}
+/** Import interno do alvo resolvido contra o module path do go.mod. */
+function isInternalImport(importPath, module) {
+    if (!module)
+        return false;
+    const rel = importPath.startsWith(module + '/')
+        ? importPath.slice(module.length + 1)
+        : null;
+    if (rel === null)
+        return false; // import externo (outro módulo)
+    return rel.startsWith('internal/') || rel.includes('/internal/');
+}
+/**
+ * R2.1/R2.2/R2.3/R2.4 — teste de oráculo que importa pacote interno da
+ * aplicação (resolvido contra o module path) é espelho. Cobre import
+ * absoluto, alias, dot e blank: a burla por alias está bloqueada porque a
+ * resolução é por path, não por nome.
+ */
+export function oracleNoSrc(opts = {}) {
+    return rule('oracle-no-src')
+        .severity('error')
+        .needsData('go')
+        .message('teste de oráculo importa pacote interno da aplicação (resolvido contra o module do go.mod): é espelho, não oráculo')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return [];
+        const out = [];
+        const oracleDirs = oraclePrefixes(opts);
+        for (const f of m.files) {
+            if (f.error)
+                continue;
+            if (!isUnderAny(f.path, oracleDirs))
+                continue;
+            for (const imp of f.imports) {
+                if (isInternalImport(imp.path, m.module)) {
+                    out.push({
+                        target: `${f.path} -> ${imp.path}`,
+                        location: `${f.path}:${imp.line}`,
+                    });
+                }
+            }
+        }
+        return out;
+    })
+        .build();
+}
+/**
+ * R2.5 — regra nativa de Go: um `_test.go` DENTRO da árvore internal/ (ou
+ * layout.src) que declara `package foo` (e não `package foo_test`) acessa
+ * símbolos não-exportados da implementação: é espelho branco por construção,
+ * mesmo sem import. `package foo_test` é black-box e NÃO viola.
+ */
+export function oracleWhiteboxTest(opts = {}) {
+    return rule('oracle-whitebox-test')
+        .severity('error')
+        .needsData('go')
+        .message("_test.go dentro de internal/ que declara `package foo` (não `package foo_test`) acessa símbolos não-exportados: espelho branco por construção")
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return [];
+        const out = [];
+        for (const f of m.files) {
+            if (f.error || !f.isTest)
+                continue;
+            const inSrcTree = f.isInternal || isUnderAny(f.path, srcPrefixes(opts));
+            if (!inSrcTree)
+                continue;
+            // package foo_test é black-box; package foo é white-box.
+            if (f.package.endsWith('_test'))
+                continue;
+            out.push({
+                target: `${f.path} (package ${f.package} white-box em árvore de implementação)`,
+                location: f.path,
+            });
+        }
+        return out;
+    })
+        .build();
+}
+/**
+ * R2.7 — fronteira reversa: produção (internal/ ou layout.src) importando o
+ * diretório de oráculo é espelho invertido (fixture vazando para produção).
+ */
+export function srcNoOracle(opts = {}) {
+    return rule('src-no-oracle')
+        .severity('error')
+        .needsData('go')
+        .message('implementação importa diretório de oráculo: fixture de teste vazando para produção')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return [];
+        const out = [];
+        const src = srcPrefixes(opts);
+        const oracleDirs = oraclePrefixes(opts);
+        for (const f of m.files) {
+            if (f.error)
+                continue;
+            const inSrc = f.isInternal || isUnderAny(f.path, src);
+            if (!inSrc)
+                continue;
+            for (const imp of f.imports) {
+                const rel = m.module && imp.path.startsWith(m.module + '/')
+                    ? imp.path.slice(m.module.length + 1)
+                    : imp.path;
+                if (isUnderAny(rel, oracleDirs)) {
+                    out.push({ target: `${f.path} -> ${imp.path}`, location: `${f.path}:${imp.line}` });
+                }
+            }
+        }
+        return out;
+    })
+        .build();
+}
+/**
+ * R2.8 — em topologia de módulo separado, `oracle/go.mod` não pode
+ * require/replace o módulo da aplicação: se contém, a fronteira do
+ * compilador foi desativada de propósito.
+ *
+ * Lido direto do filesystem (o extrator Go não parseia go.mod de submódulo):
+ * é um tripwire textual, não AST — suficiente para o `require`/`replace`.
+ */
+export function oracleModuleCouplesApp() {
+    return rule('oracle-module-couples-app')
+        .severity('error')
+        .needsData('go')
+        .message('oracle/go.mod contém require/replace do módulo da aplicação: a fronteira imposta pelo compilador foi desativada de propósito')
+        .assert(async (ctx) => {
+        const m = model(ctx);
+        if (!m || !m.module)
+            return [];
+        const { readFile } = await import('node:fs/promises');
+        const { resolve } = await import('node:path');
+        const out = [];
+        // Procura oracle/go.mod (e variantes) sob os diretórios de oráculo.
+        const candidates = await findOracleGoMods(ctx);
+        for (const rel of candidates) {
+            let text = '';
+            try {
+                text = await readFile(resolve(ctx.root, rel), 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const mod = m.module;
+            const re = new RegExp(`^\\s*(require|replace)\\s+${escapeRe(mod)}(\\s|/|$)`, 'm');
+            if (re.test(text)) {
+                out.push({ target: `${rel} (${mod} requerido/trocado pelo oráculo)`, location: rel });
+                break; // um achado por go.mod: o alvo é o arquivo, não a linha
+            }
+        }
+        return out;
+    })
+        .build();
+}
+async function findOracleGoMods(ctx) {
+    // Heurística: qualquer go.mod cujo caminho contenha 'oracle'.
+    const all = await walkGoMod(ctx.root);
+    return all.filter((rel) => /(^|\/)oracle(\/|$)/.test(rel));
+}
+async function walkGoMod(root) {
+    const { walk } = await import('@ihelpee/prumo/core');
+    return walk(root, '.', {
+        extensions: ['.mod'],
+        ignoreDirs: new Set(['node_modules', '.git', 'vendor']),
+    });
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// ---------------------------------------------------------------------------
+// R3.13/R3.14 — invariantes Go adicionais (alto valor, baixo custo)
+// ---------------------------------------------------------------------------
+/**
+ * R3.13 — `internal/<featureA>/` importando `internal/<featureB>/`
+ * (fronteira de contexto). Heurística `featureOf` adaptada ao layout Go.
+ * `warn` no MVP (layouts Go variam).
+ */
+export function noCrossFeatureImport(opts = {}) {
+    return rule('no-cross-feature-import')
+        .severity('warn')
+        .needsData('go')
+        .message('feature interna importa outra feature (internal/<A> -> internal/<B>): fronteira de contexto violada')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m || !m.module)
+            return [];
+        const out = [];
+        const featureOf = (rel) => {
+            const mm = rel.match(/^internal\/([^/]+)\//);
+            return mm ? mm[1] : null;
+        };
+        for (const f of m.files) {
+            if (f.error)
+                continue;
+            const from = featureOf(f.path);
+            if (!from)
+                continue;
+            for (const imp of f.imports) {
+                if (!imp.path.startsWith(m.module + '/'))
+                    continue;
+                const rel = imp.path.slice(m.module.length + 1);
+                const to = featureOf(rel);
+                if (to && to !== from) {
+                    out.push({ target: `${f.path} -> ${imp.path} (${from} importa ${to})`, location: `${f.path}:${imp.line}` });
+                }
+            }
+        }
+        return out;
+    })
+        .build();
+}
+/**
+ * R3.14 — campo monetário tipado como float32/float64. Em Go o anti-padrão
+ * é float64 para dinheiro; int64 (centavos) ou shopspring/decimal é aceitável.
+ * `warn`.
+ */
+export function monetaryIsInteger() {
+    return rule('monetary-is-integer')
+        .severity('warn')
+        .needsData('go')
+        .message('campo monetário tipado como float32/float64; use int64 (centavos) ou decimal')
+        .assert((ctx) => {
+        const m = model(ctx);
+        if (!m)
+            return [];
+        const out = [];
+        for (const f of m.files) {
+            if (f.error)
+                continue;
+            for (const s of f.structs) {
+                for (const fl of s.fields) {
+                    if (hasCentsSuffix(fl.name))
+                        continue;
+                    if (!MONETARY_NAME.test(fl.name))
+                        continue;
+                    if (!FLOAT_TYPE.test(fl.type))
+                        continue;
+                    out.push({ target: `${s.name}.${fl.name} ${fl.type}`, location: `${f.path}:${s.line}` });
+                }
+            }
+        }
+        return out;
+    })
+        .build();
+}
+function isUnderAny(p, prefixes) {
+    return startsWithAny(p, prefixes);
+}
+// ---------------------------------------------------------------------------
+// O plugin
+// ---------------------------------------------------------------------------
+/**
+ * O Plugin oficial de Go/Gin para o Prumo (spec §4.5).
+ *
+ * Analisa, nunca executa: o extrator Go é stdlib-only e só faz
+ * `parser.ParseFile` — o app analisado nunca dá boot, o parser nunca herda o
+ * drift do que analisa (R1.2). A lei vive 100% neste arquivo Node (§4.2).
+ */
+export function goGinPlugin(opts = {}) {
+    return definePlugin({
+        name: 'go-gin',
+        version: pkg.version,
+        description: 'Go/Gin invariants: mutation route guards (inline/Group.Use/Engine.Use transitivo), error-handling enforcement, payload binding validation, oracle isolation nativa de Go (internal/, white-box, módulo separado).',
+        extractors: {
+            go: async (ctx) => ({ result: await runGoExtractor(ctx.root, opts) }),
+        },
+        rules: [
+            goToolchainMissing(opts),
+            goParseError(),
+            mutationRoutesGuarded(opts),
+            errorHandlingEnforced(opts),
+            errorHandlingUnchecked(opts),
+            payloadValidationBound(),
+            payloadValidationQuery(opts),
+            oracleNoSrc(opts),
+            oracleWhiteboxTest(opts),
+            srcNoOracle(opts),
+            oracleModuleCouplesApp(),
+            noCrossFeatureImport(opts),
+            monetaryIsInteger(),
+        ],
+    });
+}
+/** Preset pronto para `invariants: [goGinPreset]` / `.prumo/invariants/rules.ts`. */
+export const goGinPreset = goGinPlugin().rules;
+export default goGinPlugin;