@semacode/cli 1.5.4 → 1.5.6

package/dist/drift.js

@@ -1,6 +1,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
+import { coletarSuperficiesAngularStandaloneConsumer } from "./angular-consumer-standalone.js";
 import { extrairSimbolosCpp } from "./cpp-symbols.js";
 import { extrairRotasDotnet, extrairSimbolosDotnet } from "./dotnet-http.js";
 import { extrairRotasGo, extrairSimbolosGo } from "./go-http.js";
@@ -677,6 +678,8 @@ function extrairRecursosArquivoLocal(arquivo, codigo) {
     const contextoArquivoLocal = /\b(?:json|jsonl|ndjson)\b/i.test(codigo)
         || /\b(?:read_text|write_text|readFile(?:Sync)?|writeFile(?:Sync)?|open)\b/i.test(codigo)
         || /\.(?:json|jsonl|ndjson|db|sqlite|sqlite3)\b/i.test(codigo)
+        || /@capacitor\/preferences|Preferences\.(?:get|set|remove)\s*\(/i.test(codigo)
+        || /\b(?:localStorage|sessionStorage)\.(?:getItem|setItem|removeItem)\s*\(/i.test(codigo)
         || /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(normalizarFragmentoArquivo(arquivo));
     if (!contextoArquivoLocal) {
         return [];
@@ -693,6 +696,12 @@ function extrairRecursosArquivoLocal(arquivo, codigo) {
     if (nomeStore && /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(nomeArquivo)) {
         registrarRecursoDrift(recursos, "arquivo", "arquivo_local", nomeStore, arquivo);
     }
+    for (const match of codigo.matchAll(/Preferences\.(?:get|set|remove)\s*\(\s*\{[\s\S]{0,160}?key\s*:\s*["'`]([^"'`]+)["'`]/gi)) {
+        registrarRecursoDrift(recursos, "arquivo", "arquivo_local", match[1], arquivo);
+    }
+    for (const match of codigo.matchAll(/\b(?:localStorage|sessionStorage)\.(?:getItem|setItem|removeItem)\s*\(\s*["'`]([^"'`]+)["'`]/gi)) {
+        registrarRecursoDrift(recursos, "arquivo", "arquivo_local", match[1], arquivo);
+    }
     return [...recursos.values()];
 }
 function extrairRecursosPersistenciaCodigoVivo(arquivo, codigo) {
@@ -1445,7 +1454,10 @@ function inferirConsumerFrameworkPrincipal(fontesLegado, consumerSurfaces, consu
         || /(?:^|\/)(?:src\/)?(?:app\/)?(?:router|routes)\.(?:ts|tsx|js|jsx)$/i.test(arquivo))) {
         return "react-vite-consumer";
     }
-    if (arquivos.some((arquivo) => /(?:^|\/)(?:src\/)?app\/.+\.component\.(?:ts|js)$/i.test(arquivo) || arquivoEhRotasAngularConsumer(arquivo))) {
+    if (arquivos.some((arquivo) => /(?:^|\/)(?:src\/)?app\.component\.(?:ts|js)$/i.test(arquivo)
+        || /(?:^|\/)(?:src\/)?app\/.+\.component\.(?:ts|js)$/i.test(arquivo)
+        || /(?:^|\/)(?:src\/)?components\/.+\.component\.(?:ts|js)$/i.test(arquivo)
+        || arquivoEhRotasAngularConsumer(arquivo))) {
         return "angular-consumer";
     }
     if (arquivos.some((arquivo) => /(?:^|\/)(?:lib\/)?(?:screens|pages)\/.+\.dart$/i.test(arquivo)
@@ -1501,6 +1513,7 @@ async function indexarTypeScript(diretorios) {
             .filter((arquivo) => arquivoEhRotasAngularConsumerRaiz(path.relative(diretorio, arquivo)))
             .map((arquivo) => path.resolve(arquivo)));
         const usarApenasRotasAngularRaiz = arquivosRotasAngularRaiz.size > 0;
+        let encontrouSuperficieAngularPorRotas = false;
         for (const arquivo of arquivos) {
             const codigo = await readFile(arquivo, "utf8");
             const scriptKind = arquivo.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
@@ -1578,6 +1591,7 @@ async function indexarTypeScript(diretorios) {
                 }
             }
             if (arquivoEhRotasAngularConsumer(relacao) && (!usarApenasRotasAngularRaiz || arquivosRotasAngularRaiz.has(path.resolve(arquivo)))) {
+                encontrouSuperficieAngularPorRotas = true;
                 for (const rotaAngular of await extrairRotasAngularConsumer(diretorio, relacao)) {
                     const arquivoRotasAngular = path.join(diretorio, rotaAngular.arquivoRotas);
                     consumerSurfaces.set(`${rotaAngular.rota}:${arquivoRotasAngular}:routes`, {
@@ -1673,6 +1687,23 @@ async function indexarTypeScript(diretorios) {
                 }
             }
         }
+        if (!encontrouSuperficieAngularPorRotas) {
+            for (const superficie of await coletarSuperficiesAngularStandaloneConsumer(diretorio, arquivos)) {
+                const arquivoSuperficie = path.join(diretorio, superficie.arquivo);
+                consumerSurfaces.set(`${superficie.rota}:${arquivoSuperficie}:${superficie.tipoArquivo}`, {
+                    rota: superficie.rota,
+                    arquivo: arquivoSuperficie,
+                    tipoArquivo: superficie.tipoArquivo,
+                });
+                rotas.push({
+                    origem: "angular-consumer",
+                    metodo: "VIEW",
+                    caminho: superficie.rota,
+                    arquivo: arquivoSuperficie,
+                    simbolo: superficie.tipoArquivo,
+                });
+            }
+        }
     }
     return {
         simbolos: [...simbolos.values()],
@@ -2190,12 +2221,18 @@ function extrairCamposArquivoLocalDetalhados(arquivo, codigo) {
             registrarCampo(recurso.nome, bloco[1] ?? "");
         }
     }
+    for (const match of codigo.matchAll(/Preferences\.(?:get|set|remove)\s*\(\s*\{[\s\S]{0,160}?key\s*:\s*["'`]([^"'`]+)["'`]/gi)) {
+        registrarColunaPersistenciaDrift(colunas, "arquivo", match[1], match[1], arquivo);
+    }
+    for (const match of codigo.matchAll(/\b(?:localStorage|sessionStorage)\.(?:getItem|setItem|removeItem)\s*\(\s*["'`]([^"'`]+)["'`]/gi)) {
+        registrarColunaPersistenciaDrift(colunas, "arquivo", match[1], match[1], arquivo);
+    }
     return [...colunas.values()];
 }
 function registrarRepositoriosPorRecursos(repositorios, arquivo, codigo, recursos) {
     const contextoRepositorio = /(?:repository|repositories|repositorio|repositorios|repo|dao|store|queries|persistence|persistencia)/i.test(arquivo)
         || /\b(?:Repository|Repositories|Dao|Store)\b/.test(codigo);
-    const contextoAcesso = /\b(?:select|insert|update|delete|aggregate|findOne|findMany|findUnique|findFirst|prisma\.|db\.collection|createClient|hset|hget|xadd|xread|json\.(?:load|loads|dump|dumps)|JSON\.(?:parse|stringify)|read_text|write_text|readFile(?:Sync)?|writeFile(?:Sync)?|open)\b/i.test(codigo)
+    const contextoAcesso = /\b(?:select|insert|update|delete|aggregate|findOne|findMany|findUnique|findFirst|prisma\.|db\.collection|createClient|hset|hget|xadd|xread|json\.(?:load|loads|dump|dumps)|JSON\.(?:parse|stringify)|read_text|write_text|readFile(?:Sync)?|writeFile(?:Sync)?|open|Preferences\.(?:get|set|remove)|localStorage\.(?:getItem|setItem|removeItem)|sessionStorage\.(?:getItem|setItem|removeItem))\b/i.test(codigo)
         || /\.(?:json|jsonl|ndjson|db|sqlite|sqlite3)\b/i.test(codigo);
     if (!contextoRepositorio && !contextoAcesso) {
         return;
@@ -2255,7 +2292,7 @@ function arquivoCombinaDeclaradoDrift(arquivoReal, arquivoDeclarado) {
     const declarado = normalizarArquivoDeclaradoDrift(arquivoDeclarado);
     return real === declarado || real.endsWith(declarado) || declarado.endsWith(real);
 }
-function coletarArquivosPreferidosPersistenciaTask(task) {
+function coletarArquivosPreferidosPersistenciaTask(task, mapaImpl) {
     const arquivos = new Set();
     for (const vinculo of task.vinculos) {
         if (vinculo.arquivo) {
@@ -2265,17 +2302,45 @@ function coletarArquivosPreferidosPersistenciaTask(task) {
             arquivos.add(vinculo.valor);
         }
     }
+    if (mapaImpl) {
+        for (const impl of task.implementacoesExternas) {
+            const resolvido = mapaImpl.get(impl.caminho);
+            if (resolvido?.arquivo) {
+                arquivos.add(resolvido.arquivo);
+            }
+        }
+    }
     return arquivos;
 }
-function resolverPersistenciaLocalPorTask(mapaRecursos, task, ir, esperado) {
+function resolverPersistenciaLocalPorTask(mapaRecursos, task, ir, esperado, mapaImpl) {
     const todosRecursos = deduplicarRecursosResolvidos([...mapaRecursos.values()].flat());
-    const arquivosPreferidos = [...coletarArquivosPreferidosPersistenciaTask(task)];
+    const arquivosPreferidos = [...coletarArquivosPreferidosPersistenciaTask(task, mapaImpl)];
     const candidatosPorArquivo = arquivosPreferidos.length > 0
         ? todosRecursos.filter((recurso) => recurso.origem === "arquivo"
             && arquivosPreferidos.some((arquivo) => arquivoCombinaDeclaradoDrift(recurso.arquivo, arquivo)))
         : [];
+    const variantesAlvo = new Set(variantesNomeRecursoDrift(esperado.alvo));
+    const normalizarBusca = (valor) => valor.toLowerCase().replace(/[^a-z0-9]+/g, "_");
+    const pontuarCandidato = (recurso) => {
+        let score = 0;
+        if (recursoResolvidoCombinaEsperado(recurso, esperado)) {
+            score += 4;
+        }
+        if (variantesNomeRecursoDrift(recurso.nome).some((variacao) => variantesAlvo.has(variacao))) {
+            score += 2;
+        }
+        const nomeNormalizado = normalizarBusca(recurso.nome);
+        const alvoNormalizado = normalizarBusca(esperado.alvo);
+        if (nomeNormalizado.includes(alvoNormalizado) || alvoNormalizado.includes(nomeNormalizado)) {
+            score += 1;
+        }
+        return score;
+    };
+    const ordenarCandidatos = (candidatos) => [...candidatos].sort((a, b) => pontuarCandidato(b) - pontuarCandidato(a)
+        || a.nome.localeCompare(b.nome, "pt-BR")
+        || a.arquivo.localeCompare(b.arquivo, "pt-BR"));
     if (candidatosPorArquivo.length > 0) {
-        return candidatosPorArquivo;
+        return ordenarCandidatos(candidatosPorArquivo);
     }
     const termos = new Set([
         ...quebrarTermosEscopo(ir.nome),
@@ -2285,8 +2350,8 @@ function resolverPersistenciaLocalPorTask(mapaRecursos, task, ir, esperado) {
     if (termos.size === 0) {
         return [];
     }
-    return todosRecursos.filter((recurso) => recurso.origem === "arquivo"
-        && [...termos].some((termo) => variantesNomeRecursoDrift(recurso.nome).some((variacao) => variacao.includes(termo))));
+    return ordenarCandidatos(todosRecursos.filter((recurso) => recurso.origem === "arquivo"
+        && [...termos].some((termo) => variantesNomeRecursoDrift(recurso.nome).some((variacao) => variacao.includes(termo)))));
 }
 function detalhePersistenciaCombinaOrigem(origemDetalhe, recursoReal) {
     if (!recursoReal) {
@@ -2334,7 +2399,7 @@ function localizarCompatibilidadePersistencia(bancos, esperado, recursoReal) {
         tipo: recursoReal?.tipo ?? esperado.tiposAceitos[0] ?? "query",
     };
 }
-export async function analisarPersistenciaReal(contexto, mapaRecursos, detalhesPersistencia, opcoes) {
+export async function analisarPersistenciaReal(contexto, mapaRecursos, detalhesPersistencia, opcoes, mapaImpl) {
     const opcoesResolvidas = resolverOpcoesDrift(opcoes);
     const diretoriosCodigoAtivos = resolverDiretoriosCodigoEscopoReal(contexto, opcoesResolvidas);
     const mapa = mapaRecursos ?? construirMapaRecursos((await indexarPersistenciaDeclarativa(diretoriosCodigoAtivos)).recursos);
@@ -2346,12 +2411,12 @@ export async function analisarPersistenciaReal(contexto, mapaRecursos, detalhesP
             continue;
         }
         for (const task of ir.tasks) {
-            for (const esperado of extrairRecursosEsperados(task, ir)) {
+            for (const esperado of extrairRecursosEsperados(task, ir, mapa, mapaImpl)) {
                 const correspondencias = esperado.nomes.flatMap((nome) => variantesNomeRecursoDrift(nome).flatMap((variante) => (mapa.get(variante) ?? []).filter((recurso) => recursoResolvidoCombinaEsperado(recurso, esperado))));
                 let recursosReais = deduplicarRecursosResolvidos(correspondencias);
-                const arquivosPreferidos = [...coletarArquivosPreferidosPersistenciaTask(task)];
+                const arquivosPreferidos = [...coletarArquivosPreferidosPersistenciaTask(task, mapaImpl)];
                 if (recursosReais.length === 0) {
-                    recursosReais = resolverPersistenciaLocalPorTask(mapa, task, ir, esperado);
+                    recursosReais = resolverPersistenciaLocalPorTask(mapa, task, ir, esperado, mapaImpl);
                 }
                 const compatibilidade = localizarCompatibilidadePersistencia(ir.databases, esperado, recursosReais[0]);
                 let colunas = [...new Set(detalhes.colunas
@@ -2624,11 +2689,25 @@ function recursoPersistenciaCombinaAlvo(recurso, alvo) {
     }
     return nomesRecursoPersistencia(recurso).some((nome) => variantesNomeRecursoDrift(nome).some((variacao) => alvoVariantes.has(variacao)));
 }
-function taskSugerePersistenciaSemBanco(task) {
-    return task.vinculos.some((vinculo) => /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(`${vinculo.valor} ${vinculo.arquivo ?? ""} ${vinculo.simbolo ?? ""}`))
-        || task.implementacoesExternas.some((impl) => /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(impl.caminho));
+function taskSugerePersistenciaSemBanco(task, mapaRecursos, mapaImpl) {
+    if (task.vinculos.some((vinculo) => /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(`${vinculo.valor} ${vinculo.arquivo ?? ""} ${vinculo.simbolo ?? ""}`))) {
+        return true;
+    }
+    if (task.implementacoesExternas.some((impl) => /(?:repository|repositories|repositorio|repo|store|storage|persist|cache)/i.test(impl.caminho))) {
+        return true;
+    }
+    if (!mapaRecursos || !mapaImpl) {
+        return false;
+    }
+    const arquivosPreferidos = [...coletarArquivosPreferidosPersistenciaTask(task, mapaImpl)];
+    if (arquivosPreferidos.length === 0) {
+        return false;
+    }
+    const recursos = deduplicarRecursosResolvidos([...mapaRecursos.values()].flat());
+    return recursos.some((recurso) => recurso.origem === "arquivo"
+        && arquivosPreferidos.some((arquivo) => arquivoCombinaDeclaradoDrift(recurso.arquivo, arquivo)));
 }
-function extrairRecursosEsperados(task, ir) {
+function extrairRecursosEsperados(task, ir, mapaRecursos, mapaImpl) {
     const esperados = new Map();
     const registrar = (esperado) => {
         const chave = `${esperado.origem ?? "qualquer"}:${esperado.tiposAceitos.join(",")}:${esperado.nomes.join("|")}:${esperado.alvo}`;
@@ -2652,9 +2731,9 @@ function extrairRecursosEsperados(task, ir) {
         return [...esperados.values()];
     }
     if (ir.databases.length === 0) {
-        const sugerePersistenciaLocal = taskSugerePersistenciaSemBanco(task);
+        const sugerePersistenciaLocal = taskSugerePersistenciaSemBanco(task, mapaRecursos, mapaImpl);
         for (const efeito of efeitosPersistencia) {
-            if (efeito.categoria !== "persistencia" || !sugerePersistenciaLocal) {
+            if (!sugerePersistenciaLocal) {
                 continue;
             }
             if ([...esperados.values()].some((item) => item.alvo === efeito.alvo)) {
@@ -2819,12 +2898,24 @@ export async function analisarDriftLegado(contexto, opcoes) {
         const taskPorChave = new Map();
         const guardrailsPorTask = new Map();
         const resumoVinculosPorTask = new Map();
+        const arquivosAncoraHerdadosPorTask = new Map();
         for (const item of contexto.modulosSelecionados) {
             const ir = item.resultado.ir;
             if (!ir) {
                 continue;
             }
             const superficiesPorChave = new Map(ir.superficies.map((superficie) => [`${superficie.tipo}:${superficie.nome}`, superficie]));
+            const routesPorNome = new Map(ir.routes.map((route) => [route.nome, route]));
+            const flowsPorNome = new Map(ir.flows.map((flow) => [flow.nome, flow]));
+            const registrarArquivoAncoraHerdado = (taskNome, arquivo) => {
+                if (!arquivo) {
+                    return;
+                }
+                const chaveTask = `${ir.nome}:${taskNome}`;
+                const arquivos = arquivosAncoraHerdadosPorTask.get(chaveTask) ?? new Set();
+                arquivos.add(arquivo);
+                arquivosAncoraHerdadosPorTask.set(chaveTask, arquivos);
+            };
             for (const task of ir.tasks) {
                 guardrailsPorTask.set(`${ir.nome}:${task.nome}`, {
                     publica: false,
@@ -2950,16 +3041,18 @@ export async function analisarDriftLegado(contexto, opcoes) {
                     confiancaVinculo: "baixa",
                     riscoOperacional: "baixo",
                     lacunas: [],
+                    ancoragemVinculo: "ausente",
                     arquivosReferenciados: [...arquivosReferenciados].sort((a, b) => a.localeCompare(b, "pt-BR")),
+                    arquivosAncoraHerdados: [],
                     arquivosProvaveisEditar: [],
                     simbolosReferenciados: [...simbolosReferenciados].sort((a, b) => a.localeCompare(b, "pt-BR")),
                     candidatosImpl: ordenarCandidatos([...candidatosTask.values()]).slice(0, 5),
                     checksSugeridos: [],
                 });
-                for (const recursoEsperado of extrairRecursosEsperados(task, ir)) {
+                for (const recursoEsperado of extrairRecursosEsperados(task, ir, mapaRecursos, mapaImpl)) {
                     let resolvido = resolverRecursoEsperado(mapaRecursos, recursoEsperado, arquivosReferenciados);
                     if (!resolvido) {
-                        resolvido = resolverPersistenciaLocalPorTask(mapaRecursos, task, ir, recursoEsperado)[0];
+                        resolvido = resolverPersistenciaLocalPorTask(mapaRecursos, task, ir, recursoEsperado, mapaImpl)[0];
                     }
                     const registro = {
                         modulo: ir.nome,
@@ -3155,6 +3248,29 @@ export async function analisarDriftLegado(contexto, opcoes) {
                 }
                 else {
                     vinculosValidos.push(registro);
+                    if (itemVinculo.donoTipo === "modulo") {
+                        for (const task of ir.tasks) {
+                            registrarArquivoAncoraHerdado(task.nome, registro.arquivo);
+                        }
+                    }
+                    else if (itemVinculo.donoTipo === "flow") {
+                        const flow = flowsPorNome.get(itemVinculo.dono);
+                        for (const taskNome of flow?.tasksReferenciadas ?? []) {
+                            registrarArquivoAncoraHerdado(taskNome, registro.arquivo);
+                        }
+                    }
+                    else if (itemVinculo.donoTipo === "route") {
+                        const route = routesPorNome.get(itemVinculo.dono);
+                        if (route?.task) {
+                            registrarArquivoAncoraHerdado(route.task, registro.arquivo);
+                        }
+                    }
+                    else if (itemVinculo.donoTipo === "superficie") {
+                        const superficie = superficiesPorChave.get(itemVinculo.dono);
+                        if (superficie?.task) {
+                            registrarArquivoAncoraHerdado(superficie.task, registro.arquivo);
+                        }
+                    }
                 }
                 if (itemVinculo.donoTipo === "task") {
                     const chaveTask = `${ir.nome}:${itemVinculo.dono}`;
@@ -3197,6 +3313,9 @@ export async function analisarDriftLegado(contexto, opcoes) {
                 quebrados: 0,
                 arquivos: new Set(),
             };
+            const arquivosAncoraHerdados = [...(arquivosAncoraHerdadosPorTask.get(chaveTask) ?? new Set())]
+                .filter((arquivo) => !resumoVinculos.arquivos.has(arquivo))
+                .sort((a, b) => a.localeCompare(b, "pt-BR"));
             if (!task) {
                 continue;
             }
@@ -3204,8 +3323,15 @@ export async function analisarDriftLegado(contexto, opcoes) {
             resumo.riscoOperacional = calcularRiscoOperacional(task);
             resumo.lacunas = resumirLacunasTask(task, resumo.semImplementacao, resumo.implsQuebrados, resumoVinculos.quebrados, guardrails);
             resumo.scoreSemantico = calcularScoreTask(task, resumo.implsValidos, resumo.implsQuebrados, resumoVinculos.validos, resumoVinculos.quebrados, resumo.semImplementacao);
+            resumo.ancoragemVinculo = task.vinculos.length > 0
+                ? "propria"
+                : arquivosAncoraHerdados.length > 0
+                    ? "herdada_modulo"
+                    : "ausente";
+            resumo.arquivosAncoraHerdados = arquivosAncoraHerdados;
             resumo.arquivosProvaveisEditar = [...new Set([
                     ...resumo.arquivosReferenciados,
+                    ...arquivosAncoraHerdados,
                     ...resumo.candidatosImpl.map((candidato) => candidato.arquivo),
                     ...resumoVinculos.arquivos,
                 ])].sort((a, b) => a.localeCompare(b, "pt-BR"));
@@ -3312,7 +3438,7 @@ export async function analisarDriftLegado(contexto, opcoes) {
         const appRoutes = [...new Set(consumerSurfaces.map((surface) => surface.rota))]
             .sort((a, b) => a.localeCompare(b, "pt-BR"));
         const consumerFramework = inferirConsumerFrameworkPrincipal(contexto.fontesLegado, consumerSurfaces, consumerBridges);
-        const persistenciaReal = await analisarPersistenciaReal(contexto, mapaRecursos, detalhesPersistencia, opcoesResolvidas);
+        const persistenciaReal = await analisarPersistenciaReal(contexto, mapaRecursos, detalhesPersistencia, opcoesResolvidas, mapaImpl);
         for (const item of persistenciaReal) {
             if (item.status === "divergente") {
                 diagnosticos.push({