@semacode/cli 1.3.7 → 1.4.0

package/dist/drift.js

@@ -28,6 +28,340 @@ const DIRETORIOS_IGNORADOS = new Set([
 function normalizarFragmentoArquivo(valor) {
     return valor.replace(/\\/g, "/").replace(/^\.?\//, "").trim().toLowerCase();
 }
+const NOMES_RECURSO_IGNORADOS = new Set([
+    "all",
+    "and",
+    "as",
+    "by",
+    "create",
+    "delete",
+    "from",
+    "group",
+    "inner",
+    "into",
+    "join",
+    "left",
+    "limit",
+    "offset",
+    "on",
+    "or",
+    "order",
+    "outer",
+    "returning",
+    "right",
+    "select",
+    "set",
+    "table",
+    "update",
+    "values",
+    "view",
+    "where",
+]);
+const OPERACOES_REDIS_KEYSPACE = [
+    "append",
+    "decr",
+    "del",
+    "expire",
+    "expireat",
+    "get",
+    "getdel",
+    "getex",
+    "getrange",
+    "hdel",
+    "hexists",
+    "hget",
+    "hgetall",
+    "hincrby",
+    "hkeys",
+    "hlen",
+    "hmget",
+    "hmset",
+    "hrandfield",
+    "hscan",
+    "hset",
+    "hsetnx",
+    "hvals",
+    "incr",
+    "incrby",
+    "lindex",
+    "llen",
+    "lpop",
+    "lpush",
+    "lrange",
+    "lrem",
+    "lset",
+    "rpop",
+    "rpush",
+    "sadd",
+    "scard",
+    "set",
+    "setex",
+    "setnx",
+    "smembers",
+    "spop",
+    "srem",
+    "ttl",
+    "type",
+    "zadd",
+    "zcard",
+    "zrange",
+    "zrem",
+];
+const OPERACOES_REDIS_STREAM = [
+    "xadd",
+    "xdel",
+    "xgroupcreate",
+    "xgroupdestroy",
+    "xlen",
+    "xrange",
+    "xread",
+    "xreadgroup",
+    "xrevrange",
+    "xtrim",
+];
+function limparLiteralRecurso(valor) {
+    return valor
+        .trim()
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .replace(/\$\{[^}]+\}/g, "")
+        .replace(/\{[^}]+\}/g, "")
+        .replace(/%[sdifjo]/gi, "")
+        .trim();
+}
+function fecharPrefixoRecurso(valor) {
+    return valor.replace(/[:/_\-.]+$/g, "").trim();
+}
+function normalizarNomeRecursoDrift(valor) {
+    return fecharPrefixoRecurso(limparLiteralRecurso(valor))
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/["'`]/g, "")
+        .replace(/\s+/g, "");
+}
+function variantesNomeRecursoDrift(valor) {
+    const base = fecharPrefixoRecurso(limparLiteralRecurso(valor));
+    if (!base) {
+        return [];
+    }
+    const variantes = new Set();
+    const registrar = (candidato) => {
+        if (!candidato) {
+            return;
+        }
+        const normalizado = normalizarNomeRecursoDrift(candidato);
+        if (normalizado) {
+            variantes.add(normalizado);
+        }
+    };
+    registrar(base);
+    registrar(base.replace(/[.:/_-]+/g, "_"));
+    registrar(base.replace(/[.:/_-]+/g, ""));
+    const partes = base.split(/[.:/_-]+/).filter(Boolean);
+    if (partes.length > 1) {
+        registrar(partes.join("_"));
+        registrar(partes.join(""));
+    }
+    const singular = base.replace(/s$/i, "");
+    if (singular && singular !== base) {
+        registrar(singular);
+    }
+    else if (!/s$/i.test(base)) {
+        registrar(`${base}s`);
+    }
+    return [...variantes];
+}
+function recursoEhIgnorado(nome) {
+    const normalizado = normalizarNomeRecursoDrift(nome);
+    if (!normalizado || normalizado.length < 2) {
+        return true;
+    }
+    return NOMES_RECURSO_IGNORADOS.has(normalizado);
+}
+function registrarRecursoDrift(recursos, origem, tipo, nome, arquivo, simbolo) {
+    const nomeLimpo = fecharPrefixoRecurso(limparLiteralRecurso(nome));
+    if (!nomeLimpo || recursoEhIgnorado(nomeLimpo)) {
+        return;
+    }
+    const chave = `${origem}:${tipo}:${normalizarNomeRecursoDrift(nomeLimpo)}:${arquivo}:${simbolo ?? ""}`;
+    if (!recursos.has(chave)) {
+        recursos.set(chave, {
+            origem,
+            nome: nomeLimpo,
+            arquivo,
+            simbolo,
+            tipo,
+        });
+    }
+}
+function inferirMotoresRelacionais(codigo, arquivo) {
+    const motores = new Set();
+    const caminho = normalizarFragmentoArquivo(arquivo);
+    if (/\b(?:from|require)\s*\(?["'`]pg["'`]/i.test(codigo)
+        || /\bpostgres(?:ql)?\b/i.test(codigo)
+        || /\bon\s+conflict\b/i.test(codigo)
+        || /\breturning\b/i.test(codigo)
+        || /\bjsonb\b/i.test(codigo)
+        || /\bilike\b/i.test(codigo)
+        || /(?:^|\/)(?:postgres|pgsql)(?:\/|[-_.])/i.test(caminho)) {
+        motores.add("postgres");
+    }
+    if (/\b(?:from|require)\s*\(?["'`](?:mysql2?(?:\/promise)?|mysql)["'`]/i.test(codigo)
+        || /\bon\s+duplicate\s+key\b/i.test(codigo)
+        || /\bauto_increment\b/i.test(codigo)
+        || /\binnodb\b/i.test(codigo)
+        || /\bunsigned\b/i.test(codigo)
+        || /(?:^|\/)mysql(?:\/|[-_.])/i.test(caminho)) {
+        motores.add("mysql");
+    }
+    if (/\b(?:from|require)\s*\(?["'`](?:sqlite3|better-sqlite3|bun:sqlite|sqlite)["'`]/i.test(codigo)
+        || /\bpragma\b/i.test(codigo)
+        || /\bwithout\s+rowid\b/i.test(codigo)
+        || /\bsqlite\b/i.test(codigo)
+        || /(?:^|\/)sqlite(?:\/|[-_.])/i.test(caminho)) {
+        motores.add("sqlite");
+    }
+    const temSqlGenerico = /\b(?:select\b[\s\S]*?\bfrom\b|insert\s+into|update\s+[A-Za-z_][\w$.-]*\s+set|delete\s+from|create\s+(?:table|view)|alter\s+table|drop\s+(?:table|view)|join\s+[A-Za-z_][\w$.-]*)/i.test(codigo)
+        || /\.(?:from|into|table)\s*\(\s*["'`]/i.test(codigo)
+        || /\b(?:knex|db|trx)\s*\(\s*["'`][A-Za-z_][^"'`]+["'`]\s*\)/i.test(codigo)
+        || /\bprisma\.[A-Za-z_]\w*\.(?:find\w+|create|update|delete|upsert|aggregate|count)\b/i.test(codigo);
+    if (temSqlGenerico && motores.size === 0) {
+        motores.add("postgres");
+        motores.add("mysql");
+        motores.add("sqlite");
+    }
+    return [...motores];
+}
+function extrairRecursosSql(arquivo, codigo) {
+    const recursos = new Map();
+    const motores = inferirMotoresRelacionais(codigo, arquivo);
+    if (motores.length === 0) {
+        return [];
+    }
+    const registrarParaMotores = (tipo, nome) => {
+        for (const motor of motores) {
+            registrarRecursoDrift(recursos, motor, tipo, nome, arquivo);
+        }
+    };
+    const registrarTextoSql = (texto) => {
+        if (!/\b(?:select\b[\s\S]*?\bfrom\b|insert\s+into|update\s+[A-Za-z_][\w$.-]*\s+set|delete\s+from|create\s+(?:table|view)|alter\s+table|drop\s+(?:table|view)|join\s+[A-Za-z_][\w$.-]*|create\s+(?:unique\s+)?index)\b/i.test(texto)) {
+            return;
+        }
+        for (const match of texto.matchAll(/\bcreate\s+(?:or\s+replace\s+)?(table|view)\s+(?:if\s+not\s+exists\s+)?["'`]?([A-Za-z_][\w$.-]*)["'`]?/gi)) {
+            registrarParaMotores(match[1].toLowerCase(), match[2]);
+        }
+        for (const match of texto.matchAll(/\bcreate\s+(?:unique\s+)?index\s+(?:if\s+not\s+exists\s+)?["'`]?([A-Za-z_][\w$.-]*)["'`]?/gi)) {
+            registrarParaMotores("index", match[1]);
+        }
+        for (const match of texto.matchAll(/\b(?:insert\s+into|update|from|join|delete\s+from|truncate\s+table)\s+["'`]?([A-Za-z_][\w$.-]*)["'`]?/gi)) {
+            registrarParaMotores("table", match[1]);
+        }
+    };
+    if (/\.(?:sql|psql|ddl)$/i.test(arquivo)) {
+        registrarTextoSql(codigo);
+    }
+    else {
+        for (const literal of codigo.matchAll(/(["'`])([\s\S]*?)\1/g)) {
+            registrarTextoSql(literal[2] ?? "");
+        }
+    }
+    for (const match of codigo.matchAll(/\.(?:from|into|table)\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi)) {
+        registrarParaMotores("table", match[1]);
+    }
+    for (const match of codigo.matchAll(/\b(?:knex|db|trx)\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi)) {
+        registrarParaMotores("table", match[1]);
+    }
+    for (const match of codigo.matchAll(/\bprisma\.([A-Za-z_]\w*)\.(?:find\w+|create|update|delete|upsert|aggregate|count)\b/gi)) {
+        registrarParaMotores("table", match[1]);
+    }
+    return [...recursos.values()];
+}
+function extrairRecursosMongoDb(arquivo, codigo) {
+    const recursos = new Map();
+    const contextoMongo = /\b(?:mongodb|mongoose|mongoclient|objectid)\b/i.test(codigo)
+        || /\bdb\.collection\s*\(/i.test(codigo)
+        || /(?:^|\/)mongo(?:db)?(?:\/|[-_.])/i.test(normalizarFragmentoArquivo(arquivo));
+    if (!contextoMongo) {
+        return [];
+    }
+    for (const match of codigo.matchAll(/\b(?:db\.)?collection\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi)) {
+        registrarRecursoDrift(recursos, "mongodb", "collection", match[1], arquivo);
+    }
+    for (const match of codigo.matchAll(/\bgetCollection\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/gi)) {
+        registrarRecursoDrift(recursos, "mongodb", "collection", match[1], arquivo);
+    }
+    for (const match of codigo.matchAll(/\bmongoose\.model\s*\(\s*["'`]([^"'`]+)["'`](?:\s*,[\s\S]*?,\s*["'`]([^"'`]+)["'`])?/gi)) {
+        registrarRecursoDrift(recursos, "mongodb", "document", match[1], arquivo);
+        if (match[2]) {
+            registrarRecursoDrift(recursos, "mongodb", "collection", match[2], arquivo);
+        }
+    }
+    for (const match of codigo.matchAll(/\bdb\.([A-Za-z_]\w*)\.(?:find|findOne|aggregate|insertOne|insertMany|updateOne|updateMany|deleteOne|deleteMany|countDocuments)\b/gi)) {
+        registrarRecursoDrift(recursos, "mongodb", "collection", match[1], arquivo);
+    }
+    return [...recursos.values()];
+}
+function extrairRecursosRedis(arquivo, codigo) {
+    const recursos = new Map();
+    const contextoRedis = /\b(?:from|require)\s*\(?["'`](?:redis|ioredis)["'`]/i.test(codigo)
+        || /\bcreateClient\s*\(/i.test(codigo)
+        || /\bx(?:add|read|readgroup|groupcreate|groupdestroy)\s*\(/i.test(codigo)
+        || /(?:^|\/)redis(?:\/|[-_.])/i.test(normalizarFragmentoArquivo(arquivo));
+    if (!contextoRedis) {
+        return [];
+    }
+    const operacoesKeyspace = OPERACOES_REDIS_KEYSPACE.join("|");
+    const operacoesStream = OPERACOES_REDIS_STREAM.join("|");
+    const padraoKeyspace = new RegExp(`\\b(?:${operacoesKeyspace})\\s*\\(\\s*['"\\\`]([^'"\\\`]+)['"\\\`]`, "gi");
+    const padraoStream = new RegExp(`\\b(?:${operacoesStream})\\s*\\(\\s*['"\\\`]([^'"\\\`]+)['"\\\`]`, "gi");
+    for (const match of codigo.matchAll(padraoKeyspace)) {
+        registrarRecursoDrift(recursos, "redis", "keyspace", match[1], arquivo);
+    }
+    for (const match of codigo.matchAll(padraoStream)) {
+        registrarRecursoDrift(recursos, "redis", "stream", match[1], arquivo);
+    }
+    return [...recursos.values()];
+}
+function extrairRecursosPersistenciaCodigoVivo(arquivo, codigo) {
+    const recursos = new Map();
+    for (const recurso of extrairColecoesFirebase(arquivo, codigo)) {
+        registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+    }
+    for (const recurso of extrairRecursosSql(arquivo, codigo)) {
+        registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+    }
+    for (const recurso of extrairRecursosMongoDb(arquivo, codigo)) {
+        registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+    }
+    for (const recurso of extrairRecursosRedis(arquivo, codigo)) {
+        registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+    }
+    return [...recursos.values()];
+}
+function extrairRecursosPrisma(arquivo, codigo) {
+    const recursos = new Map();
+    const provider = codigo.match(/\bprovider\s*=\s*["'`](postgresql|mysql|sqlite)["'`]/i)?.[1]?.toLowerCase();
+    const origem = provider === "postgresql"
+        ? "postgres"
+        : provider === "mysql"
+            ? "mysql"
+            : provider === "sqlite"
+                ? "sqlite"
+                : undefined;
+    if (!origem) {
+        return [];
+    }
+    for (const match of codigo.matchAll(/\bmodel\s+([A-Za-z_]\w*)\s*\{([\s\S]*?)\n\}/g)) {
+        const nomeModelo = match[1];
+        const corpo = match[2] ?? "";
+        const tabelaMapeada = corpo.match(/@@map\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/)?.[1];
+        registrarRecursoDrift(recursos, origem, "table", tabelaMapeada ?? nomeModelo, arquivo);
+        if (tabelaMapeada) {
+            registrarRecursoDrift(recursos, origem, "table", nomeModelo, arquivo);
+        }
+    }
+    return [...recursos.values()];
+}
 function escolherArquivoPorVinculo(arquivos, valor) {
     const normalizado = normalizarFragmentoArquivo(valor);
     const exato = arquivos.find((arquivo) => normalizarFragmentoArquivo(arquivo) === normalizado);
@@ -701,8 +1035,8 @@ async function indexarTypeScript(diretorios) {
             const sourceFile = ts.createSourceFile(arquivo, codigo, ts.ScriptTarget.Latest, true, scriptKind);
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
             const relacao = path.relative(diretorio, arquivo);
-            for (const recurso of extrairColecoesFirebase(arquivo, codigo)) {
-                recursos.set(`${recurso.nome}:${recurso.arquivo}:${recurso.tipo}`, recurso);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
             }
             for (const rota of extrairRotasTypeScriptHttp(sourceFile, relacao)) {
                 rotas.push({
@@ -889,6 +1223,7 @@ function registrarRotasPython(rotas, decoratorsPendentes, prefixo, arquivo, nome
 async function indexarPython(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".py"]))
             .filter((arquivo) => !arquivo.endsWith("__init__.py") && !/tests?[\\/]/i.test(arquivo));
@@ -896,6 +1231,9 @@ async function indexarPython(diretorios) {
             const texto = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
             const prefixo = texto.match(/APIRouter\s*\(\s*prefix\s*=\s*["']([^"']+)["']/)?.[1];
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, texto)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const rota of extrairRotasFlaskDecoradas(texto)) {
                 rotas.push({
                     origem: "flask",
@@ -947,11 +1285,12 @@ async function indexarPython(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarDart(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     const consumerSurfaces = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".dart"]))
@@ -960,6 +1299,9 @@ async function indexarDart(diretorios) {
             const texto = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
             const relacao = path.relative(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, texto)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const match of texto.matchAll(/(?:Future<[^\n]+>|[\w?<>.,\s]+)\s+(\w+)\(([^)]*)\)\s*(?:async\s*)?\{/g)) {
                 const nome = match[1];
                 if (["build", "toString"].includes(nome)) {
@@ -1006,6 +1348,7 @@ async function indexarDart(diretorios) {
     return {
         simbolos: [...simbolos.values()],
         rotas,
+        recursos: [...recursos.values()],
         consumerSurfaces: [...consumerSurfaces.values()].sort((a, b) => a.rota.localeCompare(b.rota, "pt-BR")
             || a.tipoArquivo.localeCompare(b.tipoArquivo, "pt-BR")
             || a.arquivo.localeCompare(b.arquivo, "pt-BR")),
@@ -1037,12 +1380,16 @@ function registrarSimboloGenerico(simbolos, origem, basesSimbolicas, arquivo, si
 async function indexarDotnet(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".cs"]))
             .filter((arquivo) => !/(^|[\\/])(bin|obj|Test[s]?)([\\/]|$)/i.test(arquivo));
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosDotnet(codigo)) {
                 registrarSimboloGenerico(simbolos, "cs", basesSimbolicas, arquivo, simbolo.simbolo);
             }
@@ -1057,17 +1404,21 @@ async function indexarDotnet(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarJava(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".java"]))
             .filter((arquivo) => !/(^|[\\/])(target|build|out|Test[s]?)([\\/]|$)/i.test(arquivo));
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosJava(codigo)) {
                 registrarSimboloGenerico(simbolos, "java", basesSimbolicas, arquivo, simbolo.simbolo);
             }
@@ -1082,16 +1433,20 @@ async function indexarJava(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarGo(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = await listarArquivosRecursivos(diretorio, [".go"]);
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosGo(codigo)) {
                 registrarSimboloGenerico(simbolos, "go", basesSimbolicas, arquivo, simbolo.simbolo);
             }
@@ -1106,16 +1461,20 @@ async function indexarGo(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarRust(diretorios) {
     const simbolos = new Map();
     const rotas = [];
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = await listarArquivosRecursivos(diretorio, [".rs"]);
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosRust(codigo)) {
                 registrarSimboloGenerico(simbolos, "rust", basesSimbolicas, arquivo, simbolo.simbolo);
             }
@@ -1130,22 +1489,45 @@ async function indexarRust(diretorios) {
             }
         }
     }
-    return { simbolos: [...simbolos.values()], rotas };
+    return { simbolos: [...simbolos.values()], rotas, recursos: [...recursos.values()] };
 }
 async function indexarCpp(diretorios) {
     const simbolos = new Map();
+    const recursos = new Map();
     for (const diretorio of diretorios) {
         const arquivos = (await listarArquivosRecursivos(diretorio, [".cpp", ".cc", ".cxx", ".hpp", ".h"]))
             .filter((arquivo) => !/(^|[\\/])(windows|linux|macos|runner|flutter|ephemeral|build|vendor)([\\/]|$)/i.test(arquivo));
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
+            for (const recurso of extrairRecursosPersistenciaCodigoVivo(arquivo, codigo)) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
             for (const simbolo of extrairSimbolosCpp(codigo)) {
                 registrarSimboloGenerico(simbolos, "cpp", basesSimbolicas, arquivo, simbolo.simbolo);
             }
         }
     }
-    return [...simbolos.values()];
+    return {
+        simbolos: [...simbolos.values()],
+        recursos: [...recursos.values()],
+    };
+}
+async function indexarPersistenciaDeclarativa(diretorios) {
+    const recursos = new Map();
+    for (const diretorio of diretorios) {
+        const arquivos = await listarArquivosRecursivos(diretorio, [".sql", ".psql", ".ddl", ".prisma"]);
+        for (const arquivo of arquivos) {
+            const codigo = await readFile(arquivo, "utf8");
+            const extracoes = arquivo.endsWith(".prisma")
+                ? extrairRecursosPrisma(arquivo, codigo)
+                : extrairRecursosPersistenciaCodigoVivo(arquivo, codigo);
+            for (const recurso of extracoes) {
+                registrarRecursoDrift(recursos, recurso.origem, recurso.tipo, recurso.nome, recurso.arquivo, recurso.simbolo);
+            }
+        }
+    }
+    return { recursos: [...recursos.values()] };
 }
 function normalizarCaminhoRota(caminho) {
     if (!caminho) {
@@ -1337,16 +1719,121 @@ function escolherRotasEsperadas(task, fontesLegado) {
 function taskEhBridgeFirebase(task) {
     return task.implementacoesExternas.some((impl) => impl.origem === "ts" && /sema_contract_bridge|collections?|apps\.worker/i.test(impl.caminho));
 }
-function extrairRecursosEsperados(task) {
-    if (!taskEhBridgeFirebase(task)) {
-        return [];
+function tiposAceitosParaRecursoPersistencia(recurso) {
+    switch (recurso.resourceKind) {
+        case "table":
+        case "view":
+        case "query":
+        case "index":
+        case "collection":
+        case "document":
+        case "keyspace":
+        case "stream":
+            return [recurso.resourceKind];
+        default:
+            return [];
+    }
+}
+function nomesRecursoPersistencia(recurso) {
+    return [...new Set([
+            recurso.nome,
+            recurso.table,
+            recurso.collection,
+            recurso.entity,
+            recurso.path,
+            recurso.surface,
+        ].filter((item) => Boolean(item)))];
+}
+function recursoPersistenciaCombinaAlvo(recurso, alvo) {
+    const alvoVariantes = new Set(variantesNomeRecursoDrift(alvo));
+    if (alvoVariantes.size === 0) {
+        return false;
+    }
+    return nomesRecursoPersistencia(recurso).some((nome) => variantesNomeRecursoDrift(nome).some((variacao) => alvoVariantes.has(variacao)));
+}
+function extrairRecursosEsperados(task, ir) {
+    const esperados = new Map();
+    const registrar = (esperado) => {
+        const chave = `${esperado.origem ?? "qualquer"}:${esperado.tiposAceitos.join(",")}:${esperado.nomes.join("|")}:${esperado.alvo}`;
+        if (!esperados.has(chave)) {
+            esperados.set(chave, esperado);
+        }
+    };
+    if (taskEhBridgeFirebase(task)) {
+        for (const efeito of task.efeitosEstruturados.filter((item) => item.categoria === "persistencia" && Boolean(item.alvo))) {
+            registrar({
+                categoria: "persistencia",
+                alvo: efeito.alvo,
+                origem: "firebase",
+                tiposAceitos: ["colecao"],
+                nomes: [efeito.alvo],
+            });
+        }
+    }
+    const efeitosPersistencia = task.efeitosEstruturados.filter((efeito) => ["persistencia", "db.read", "db.write"].includes(efeito.categoria) && Boolean(efeito.alvo));
+    if (efeitosPersistencia.length === 0 || ir.databases.length === 0) {
+        return [...esperados.values()];
     }
-    return task.efeitosEstruturados
-        .filter((efeito) => efeito.categoria === "persistencia" && Boolean(efeito.alvo))
-        .map((efeito) => ({
-        categoria: "persistencia",
-        alvo: efeito.alvo,
-    }));
+    for (const efeito of efeitosPersistencia) {
+        for (const database of ir.databases) {
+            for (const recurso of database.resources) {
+                const tiposAceitos = tiposAceitosParaRecursoPersistencia(recurso);
+                if (tiposAceitos.length === 0 || !recursoPersistenciaCombinaAlvo(recurso, efeito.alvo)) {
+                    continue;
+                }
+                registrar({
+                    categoria: "persistencia",
+                    alvo: efeito.alvo,
+                    origem: database.engine,
+                    tiposAceitos,
+                    nomes: nomesRecursoPersistencia(recurso),
+                });
+            }
+        }
+    }
+    return [...esperados.values()];
+}
+function construirMapaRecursos(recursos) {
+    const mapa = new Map();
+    for (const recurso of recursos) {
+        for (const variante of variantesNomeRecursoDrift(recurso.nome)) {
+            const existentes = mapa.get(variante) ?? [];
+            if (!existentes.some((item) => item.origem === recurso.origem
+                && item.tipo === recurso.tipo
+                && item.arquivo === recurso.arquivo
+                && item.nome === recurso.nome
+                && item.simbolo === recurso.simbolo)) {
+                existentes.push(recurso);
+                mapa.set(variante, existentes);
+            }
+        }
+    }
+    return mapa;
+}
+function recursoResolvidoCombinaEsperado(recurso, esperado) {
+    if (esperado.origem && recurso.origem !== esperado.origem) {
+        return false;
+    }
+    if (esperado.tiposAceitos.length > 0 && !esperado.tiposAceitos.includes(recurso.tipo)) {
+        return false;
+    }
+    const recursoVariantes = new Set(variantesNomeRecursoDrift(recurso.nome));
+    return esperado.nomes.some((nome) => variantesNomeRecursoDrift(nome).some((variante) => recursoVariantes.has(variante)));
+}
+function resolverRecursoEsperado(mapaRecursos, esperado, arquivosPreferidos) {
+    const candidatos = new Map();
+    for (const nome of esperado.nomes) {
+        for (const variante of variantesNomeRecursoDrift(nome)) {
+            for (const recurso of mapaRecursos.get(variante) ?? []) {
+                if (recursoResolvidoCombinaEsperado(recurso, esperado)) {
+                    candidatos.set(`${recurso.origem}:${recurso.tipo}:${recurso.nome}:${recurso.arquivo}:${recurso.simbolo ?? ""}`, recurso);
+                }
+            }
+        }
+    }
+    return [...candidatos.values()].sort((a, b) => Number(Boolean(arquivosPreferidos?.has(b.arquivo))) - Number(Boolean(arquivosPreferidos?.has(a.arquivo)))
+        || a.arquivo.localeCompare(b.arquivo, "pt-BR")
+        || a.nome.localeCompare(b.nome, "pt-BR"))[0];
 }
 function coletarVinculosIr(ir) {
     return [
@@ -1365,6 +1852,7 @@ export async function analisarDriftLegado(contexto) {
     const indexJava = await indexarJava(contexto.diretoriosCodigo);
     const indexGo = await indexarGo(contexto.diretoriosCodigo);
     const indexRust = await indexarRust(contexto.diretoriosCodigo);
+    const indexPersistencia = await indexarPersistenciaDeclarativa(contexto.diretoriosCodigo);
     const indexCpp = await indexarCpp(contexto.diretoriosCodigo);
     const todosSimbolos = [
         ...indexTs.simbolos,
@@ -1374,7 +1862,7 @@ export async function analisarDriftLegado(contexto) {
         ...indexJava.simbolos,
         ...indexGo.simbolos,
         ...indexRust.simbolos,
-        ...indexCpp,
+        ...indexCpp.simbolos,
     ];
     const mapaImpl = new Map([
         ...indexTs.simbolos.map((item) => [item.caminho, item]),
@@ -1384,9 +1872,20 @@ export async function analisarDriftLegado(contexto) {
         ...indexJava.simbolos.map((item) => [item.caminho, item]),
         ...indexGo.simbolos.map((item) => [item.caminho, item]),
         ...indexRust.simbolos.map((item) => [item.caminho, item]),
-        ...indexCpp.map((item) => [item.caminho, item]),
+        ...indexCpp.simbolos.map((item) => [item.caminho, item]),
     ]);
-    const mapaRecursos = new Map(indexTs.recursos.map((item) => [item.nome, item]));
+    const todosRecursos = [
+        ...indexTs.recursos,
+        ...indexPy.recursos,
+        ...indexDart.recursos,
+        ...indexDotnet.recursos,
+        ...indexJava.recursos,
+        ...indexGo.recursos,
+        ...indexRust.recursos,
+        ...indexCpp.recursos,
+        ...indexPersistencia.recursos,
+    ];
+    const mapaRecursos = construirMapaRecursos(todosRecursos);
     const todasRotasIndexadas = [
         ...indexTs.rotas,
         ...indexPy.rotas,
@@ -1399,7 +1898,7 @@ export async function analisarDriftLegado(contexto) {
     const todosArquivosConhecidos = [...new Set([
             ...todosSimbolos.map((item) => item.arquivo),
             ...todasRotasIndexadas.map((item) => item.arquivo),
-            ...indexTs.recursos.map((item) => item.arquivo),
+            ...todosRecursos.map((item) => item.arquivo),
         ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
     const implsValidos = [];
     const implsQuebrados = [];
@@ -1550,16 +2049,16 @@ export async function analisarDriftLegado(contexto) {
                 candidatosImpl: ordenarCandidatos([...candidatosTask.values()]).slice(0, 5),
                 checksSugeridos: [],
             });
-            for (const recursoEsperado of extrairRecursosEsperados(task)) {
-                const resolvido = mapaRecursos.get(recursoEsperado.alvo);
+            for (const recursoEsperado of extrairRecursosEsperados(task, ir)) {
+                const resolvido = resolverRecursoEsperado(mapaRecursos, recursoEsperado, arquivosReferenciados);
                 const registro = {
                     modulo: ir.nome,
                     task: task.nome,
                     categoria: recursoEsperado.categoria,
                     alvo: recursoEsperado.alvo,
                     arquivo: resolvido?.arquivo ?? "",
-                    origem: "firebase",
-                    tipo: "colecao",
+                    origem: resolvido?.origem ?? recursoEsperado.origem ?? "firebase",
+                    tipo: resolvido?.tipo ?? recursoEsperado.tiposAceitos[0] ?? "query",
                     status: resolvido ? "resolvido" : "divergente",
                 };
                 if (resolvido) {
@@ -1568,11 +2067,12 @@ export async function analisarDriftLegado(contexto) {
                 }
                 else {
                     recursosDivergentes.push(registro);
+                    const escopo = recursoEsperado.origem ? `${recursoEsperado.origem}` : "persistencia declarada";
                     diagnosticos.push({
                         tipo: "recurso_divergente",
                         modulo: ir.nome,
                         task: task.nome,
-                        mensagem: `Recurso vivo "${recursoEsperado.alvo}" nao foi encontrado nos bridges/configuracoes Firebase do codigo legado.`,
+                        mensagem: `Recurso vivo "${recursoEsperado.alvo}" nao foi encontrado no codigo legado para ${escopo}.`,
                     });
                 }
             }
@@ -1689,7 +2189,12 @@ export async function analisarDriftLegado(contexto) {
                 registro.arquivo = resolucaoArquivo.arquivo;
             }
             else if (recursoDeclarado) {
-                const recurso = mapaRecursos.get(recursoDeclarado);
+                const recurso = resolverRecursoEsperado(mapaRecursos, {
+                    categoria: "persistencia",
+                    alvo: recursoDeclarado,
+                    tiposAceitos: [],
+                    nomes: [recursoDeclarado],
+                });
                 if (recurso) {
                     registro.status = "resolvido";
                     registro.confianca = "alta";