@semacode/cli 1.2.0 → 1.2.11

package/dist/drift.d.ts

@@ -12,7 +12,7 @@ interface RegistroConsumerBridgeDrift {
     simbolo: string;
 }
 export interface DiagnosticoDrift {
-    tipo: "impl_quebrado" | "task_sem_impl" | "rota_divergente" | "recurso_divergente" | "vinculo_quebrado";
+    tipo: "impl_quebrado" | "task_sem_impl" | "rota_divergente" | "recurso_divergente" | "vinculo_quebrado" | "seguranca_frouxa";
     modulo: string;
     task?: string;
     route?: string;
@@ -21,7 +21,7 @@ export interface DiagnosticoDrift {
 interface RegistroImplDrift {
     modulo: string;
     task: string;
-    origem: "ts" | "py" | "dart" | "lua" | "cs" | "java" | "go" | "rust" | "cpp";
+    origem: "ts" | "py" | "dart" | "cs" | "java" | "go" | "rust" | "cpp";
     caminho: string;
     arquivo?: string;
     simbolo?: string;
@@ -47,7 +47,7 @@ interface RegistroRecursoDrift {
     status: "resolvido" | "divergente";
 }
 interface SimboloCandidatoDrift {
-    origem: "ts" | "py" | "dart" | "lua" | "cs" | "java" | "go" | "rust" | "cpp";
+    origem: "ts" | "py" | "dart" | "cs" | "java" | "go" | "rust" | "cpp";
     caminho: string;
     arquivo: string;
     simbolo: string;

package/dist/drift.js

@@ -5,7 +5,6 @@ import { extrairSimbolosCpp } from "./cpp-symbols.js";
 import { extrairRotasDotnet, extrairSimbolosDotnet } from "./dotnet-http.js";
 import { extrairRotasGo, extrairSimbolosGo } from "./go-http.js";
 import { extrairRotasJava, extrairSimbolosJava } from "./java-http.js";
-import { extrairSimbolosLua } from "./lua-symbols.js";
 import { contarIndentacaoPython, extrairRotasFlaskDecoradas, normalizarCaminhoFlask } from "./python-http.js";
 import { extrairRotasRust, extrairSimbolosRust } from "./rust-http.js";
 import { extrairRotasTypeScriptHttp } from "./typescript-http.js";
@@ -118,8 +117,14 @@ function encontrarAncoraSuperficie(ir, superficie, simbolos, mapaImpl, arquivos)
     return undefined;
 }
 function calcularRiscoOperacional(task) {
+    const dadosSensiveis = Boolean(task.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(task.dados.classificacaoPadrao)
+        || task.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao)));
+    const efeitoPrivilegiado = task.efeitosEstruturados.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
+        || ["alta", "critica"].includes(efeito.criticidade ?? ""));
     if (task.execucao.criticidadeOperacional === "alta"
         || task.execucao.criticidadeOperacional === "critica"
+        || dadosSensiveis
+        || efeitoPrivilegiado
         || task.efeitosEstruturados.some((efeito) => efeito.categoria === "persistencia" || efeito.criticidade === "critica")) {
         return "alto";
     }
@@ -154,7 +159,7 @@ function calcularScoreTask(task, implsValidos, implsQuebrados, vinculosValidos,
     }
     return Math.max(0, Math.min(100, score));
 }
-function resumirLacunasTask(task, semImplementacao, implsQuebrados, vinculosQuebrados) {
+function resumirLacunasTask(task, semImplementacao, implsQuebrados, vinculosQuebrados, guardrails) {
     const lacunas = [];
     if (semImplementacao) {
         lacunas.push("sem_impl");
@@ -171,6 +176,33 @@ function resumirLacunasTask(task, semImplementacao, implsQuebrados, vinculosQueb
     if (!task.execucao.explicita) {
         lacunas.push("execucao_implicita");
     }
+    if (guardrails.publica && !task.execucao.explicita) {
+        lacunas.push("superficie_publica_sem_execucao");
+    }
+    if (guardrails.sensivel && !task.execucao.explicita) {
+        lacunas.push("execucao_critica_sem_bloco");
+    }
+    if ((guardrails.publica || guardrails.sensivel) && semImplementacao && task.vinculos.length === 0) {
+        lacunas.push("rastreabilidade_fraca");
+    }
+    if (guardrails.publica && !guardrails.auth) {
+        lacunas.push("auth_ausente");
+    }
+    if ((guardrails.publica || guardrails.sensivel || guardrails.efeitoPrivilegiado || guardrails.dadosSensiveis) && !guardrails.authz) {
+        lacunas.push("authz_frouxa");
+    }
+    if ((guardrails.publica || guardrails.sensivel || guardrails.efeitoPrivilegiado) && !guardrails.dados) {
+        lacunas.push("dados_nao_classificados");
+    }
+    if ((guardrails.publica || guardrails.sensivel || guardrails.efeitoPrivilegiado || guardrails.dadosSensiveis) && !guardrails.audit) {
+        lacunas.push("audit_ausente");
+    }
+    if (guardrails.exigeSegredos && !guardrails.segredos) {
+        lacunas.push("segredo_sem_governanca");
+    }
+    if ((guardrails.efeitoPrivilegiado || guardrails.dadosSensiveis) && !guardrails.forbidden) {
+        lacunas.push("proibicoes_ausentes");
+    }
     return lacunas;
 }
 function resumirOperacional(resultado) {
@@ -979,22 +1011,6 @@ async function indexarDart(diretorios) {
             || a.arquivo.localeCompare(b.arquivo, "pt-BR")),
     };
 }
-async function indexarLua(diretorios) {
-    const simbolos = new Map();
-    for (const diretorio of diretorios) {
-        const arquivos = (await listarArquivosRecursivos(diretorio, [".lua"]))
-            .filter((arquivo) => !/(^|[\\/])(spec|specs|test|tests)([\\/]|$)/i.test(arquivo))
-            .filter((arquivo) => !/[_-](spec|test)\.lua$/i.test(arquivo));
-        for (const arquivo of arquivos) {
-            const texto = await readFile(arquivo, "utf8");
-            const basesSimbolicas = caminhosSimbolicos(diretorio, arquivo);
-            for (const simbolo of extrairSimbolosLua(texto)) {
-                registrarSimboloGenerico(simbolos, "lua", basesSimbolicas, arquivo, simbolo.simbolo);
-            }
-        }
-    }
-    return { simbolos: [...simbolos.values()], rotas: [] };
-}
 function registrarSimboloGenerico(simbolos, origem, basesSimbolicas, arquivo, simbolo) {
     for (const baseSimbolica of basesSimbolicas) {
         const caminho = `${baseSimbolica}.${simbolo}`;
@@ -1345,7 +1361,6 @@ export async function analisarDriftLegado(contexto) {
     const indexTs = await indexarTypeScript(contexto.diretoriosCodigo);
     const indexPy = await indexarPython(contexto.diretoriosCodigo);
     const indexDart = await indexarDart(contexto.diretoriosCodigo);
-    const indexLua = await indexarLua(contexto.diretoriosCodigo);
     const indexDotnet = await indexarDotnet(contexto.diretoriosCodigo);
     const indexJava = await indexarJava(contexto.diretoriosCodigo);
     const indexGo = await indexarGo(contexto.diretoriosCodigo);
@@ -1355,7 +1370,6 @@ export async function analisarDriftLegado(contexto) {
         ...indexTs.simbolos,
         ...indexPy.simbolos,
         ...indexDart.simbolos,
-        ...indexLua.simbolos,
         ...indexDotnet.simbolos,
         ...indexJava.simbolos,
         ...indexGo.simbolos,
@@ -1366,7 +1380,6 @@ export async function analisarDriftLegado(contexto) {
         ...indexTs.simbolos.map((item) => [item.caminho, item]),
         ...indexPy.simbolos.map((item) => [item.caminho, item]),
         ...indexDart.simbolos.map((item) => [item.caminho, item]),
-        ...indexLua.simbolos.map((item) => [item.caminho, item]),
         ...indexDotnet.simbolos.map((item) => [item.caminho, item]),
         ...indexJava.simbolos.map((item) => [item.caminho, item]),
         ...indexGo.simbolos.map((item) => [item.caminho, item]),
@@ -1398,6 +1411,7 @@ export async function analisarDriftLegado(contexto) {
     const diagnosticos = [];
     const tasksResumo = [];
     const taskPorChave = new Map();
+    const guardrailsPorTask = new Map();
     const resumoVinculosPorTask = new Map();
     for (const item of contexto.modulosSelecionados) {
         const ir = item.resultado.ir;
@@ -1405,6 +1419,69 @@ export async function analisarDriftLegado(contexto) {
             continue;
         }
         const superficiesPorChave = new Map(ir.superficies.map((superficie) => [`${superficie.tipo}:${superficie.nome}`, superficie]));
+        for (const task of ir.tasks) {
+            guardrailsPorTask.set(`${ir.nome}:${task.nome}`, {
+                publica: false,
+                sensivel: calcularRiscoOperacional(task) === "alto",
+                auth: task.auth.explicita,
+                authz: task.authz.explicita,
+                dados: task.dados.explicita,
+                audit: task.audit.explicita,
+                segredos: task.segredos.explicita,
+                forbidden: task.forbidden.explicita,
+                dadosSensiveis: Boolean(task.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(task.dados.classificacaoPadrao)
+                    || task.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao))),
+                efeitoPrivilegiado: task.efeitosEstruturados.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
+                    || ["alta", "critica"].includes(efeito.criticidade ?? "")),
+                exigeSegredos: task.efeitosEstruturados.some((efeito) => efeito.categoria === "secret.read")
+                    || Boolean(task.dados.classificacaoPadrao && ["credencial", "segredo"].includes(task.dados.classificacaoPadrao)
+                        || task.dados.campos.some((campo) => ["credencial", "segredo"].includes(campo.classificacao))),
+            });
+        }
+        for (const route of ir.routes) {
+            if (!route.task || route.perfilCompatibilidade !== "publico") {
+                continue;
+            }
+            const guardrails = guardrailsPorTask.get(`${ir.nome}:${route.task}`);
+            if (guardrails) {
+                guardrails.publica = true;
+                guardrails.auth = guardrails.auth || route.auth.explicita;
+                guardrails.authz = guardrails.authz || route.authz.explicita;
+                guardrails.dados = guardrails.dados || route.dados.explicita;
+                guardrails.audit = guardrails.audit || route.audit.explicita;
+                guardrails.segredos = guardrails.segredos || route.segredos.explicita;
+                guardrails.forbidden = guardrails.forbidden || route.forbidden.explicita;
+                guardrails.dadosSensiveis = guardrails.dadosSensiveis || Boolean(route.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(route.dados.classificacaoPadrao)
+                    || route.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao)));
+                guardrails.efeitoPrivilegiado = guardrails.efeitoPrivilegiado || route.efeitosPublicos.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
+                    || ["alta", "critica"].includes(efeito.criticidade ?? ""));
+                guardrails.exigeSegredos = guardrails.exigeSegredos || route.efeitosPublicos.some((efeito) => efeito.categoria === "secret.read")
+                    || Boolean(route.dados.classificacaoPadrao && ["credencial", "segredo"].includes(route.dados.classificacaoPadrao)
+                        || route.dados.campos.some((campo) => ["credencial", "segredo"].includes(campo.classificacao)));
+            }
+        }
+        for (const superficie of ir.superficies) {
+            if (!superficie.task || superficie.perfilCompatibilidade !== "publico") {
+                continue;
+            }
+            const guardrails = guardrailsPorTask.get(`${ir.nome}:${superficie.task}`);
+            if (guardrails) {
+                guardrails.publica = true;
+                guardrails.auth = guardrails.auth || superficie.auth.explicita;
+                guardrails.authz = guardrails.authz || superficie.authz.explicita;
+                guardrails.dados = guardrails.dados || superficie.dados.explicita;
+                guardrails.audit = guardrails.audit || superficie.audit.explicita;
+                guardrails.segredos = guardrails.segredos || superficie.segredos.explicita;
+                guardrails.forbidden = guardrails.forbidden || superficie.forbidden.explicita;
+                guardrails.dadosSensiveis = guardrails.dadosSensiveis || Boolean(superficie.dados.classificacaoPadrao && ["pii", "financeiro", "credencial", "segredo"].includes(superficie.dados.classificacaoPadrao)
+                    || superficie.dados.campos.some((campo) => ["pii", "financeiro", "credencial", "segredo"].includes(campo.classificacao)));
+                guardrails.efeitoPrivilegiado = guardrails.efeitoPrivilegiado || superficie.effects.some((efeito) => ["db.read", "db.write", "queue.publish", "queue.consume", "fs.read", "fs.write", "network.egress", "secret.read", "shell.exec"].includes(efeito.categoria)
+                    || ["alta", "critica"].includes(efeito.criticidade ?? ""));
+                guardrails.exigeSegredos = guardrails.exigeSegredos || superficie.effects.some((efeito) => efeito.categoria === "secret.read")
+                    || Boolean(superficie.dados.classificacaoPadrao && ["credencial", "segredo"].includes(superficie.dados.classificacaoPadrao)
+                        || superficie.dados.campos.some((campo) => ["credencial", "segredo"].includes(campo.classificacao)));
+            }
+        }
         for (const task of ir.tasks) {
             taskPorChave.set(`${ir.nome}:${task.nome}`, task);
             let validos = 0;
@@ -1520,6 +1597,29 @@ export async function analisarDriftLegado(contexto) {
                     criticidadeOperacional: "media",
                     explicita: false,
                 },
+                auth: {
+                    explicita: false,
+                },
+                authz: {
+                    explicita: false,
+                    papeis: [],
+                    escopos: [],
+                },
+                dados: {
+                    explicita: false,
+                    campos: [],
+                },
+                audit: {
+                    explicita: false,
+                },
+                segredos: {
+                    explicita: false,
+                    itens: [],
+                },
+                forbidden: {
+                    explicita: false,
+                    regras: [],
+                },
                 guarantees: [],
                 garantiasEstruturadas: [],
                 errors: {},
@@ -1664,6 +1764,19 @@ export async function analisarDriftLegado(contexto) {
     for (const resumo of tasksResumo) {
         const chaveTask = `${resumo.modulo}:${resumo.task}`;
         const task = taskPorChave.get(chaveTask);
+        const guardrails = guardrailsPorTask.get(chaveTask) ?? {
+            publica: false,
+            sensivel: false,
+            auth: false,
+            authz: false,
+            dados: false,
+            audit: false,
+            segredos: false,
+            forbidden: false,
+            dadosSensiveis: false,
+            efeitoPrivilegiado: false,
+            exigeSegredos: false,
+        };
         const resumoVinculos = resumoVinculosPorTask.get(chaveTask) ?? {
             validos: 0,
             quebrados: 0,
@@ -1674,7 +1787,7 @@ export async function analisarDriftLegado(contexto) {
         }
         resumo.confiancaVinculo = calcularConfiancaTask(task, resumo.implsValidos, resumo.implsQuebrados, resumoVinculos.validos, resumoVinculos.quebrados);
         resumo.riscoOperacional = calcularRiscoOperacional(task);
-        resumo.lacunas = resumirLacunasTask(task, resumo.semImplementacao, resumo.implsQuebrados, resumoVinculos.quebrados);
+        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.arquivosProvaveisEditar = [...new Set([
                 ...resumo.arquivosReferenciados,
@@ -1685,7 +1798,85 @@ export async function analisarDriftLegado(contexto) {
                 ...task.resumoAgente.checks,
                 resumo.riscoOperacional !== "baixo" ? "revisar efeitos operacionais" : "",
                 resumo.lacunas.includes("vinculo_quebrado") ? "corrigir vinculos rastreaveis" : "",
+                resumo.lacunas.some((lacuna) => ["superficie_publica_sem_execucao", "execucao_critica_sem_bloco", "rastreabilidade_fraca"].includes(lacuna))
+                    ? "endurecer execucao e rastreabilidade para producao"
+                    : "",
+                resumo.lacunas.some((lacuna) => ["auth_ausente", "authz_frouxa", "dados_nao_classificados", "audit_ausente", "segredo_sem_governanca", "proibicoes_ausentes"].includes(lacuna))
+                    ? "explicitar contratos de seguranca semantica"
+                    : "",
             ].filter(Boolean))];
+        if (resumo.lacunas.includes("superficie_publica_sem_execucao")) {
+            diagnosticos.push({
+                tipo: "seguranca_frouxa",
+                modulo: resumo.modulo,
+                task: resumo.task,
+                mensagem: `Task "${resumo.task}" alimenta superficie publica, mas ainda depende de execucao implicita.`,
+            });
+        }
+        if (resumo.lacunas.includes("execucao_critica_sem_bloco")) {
+            diagnosticos.push({
+                tipo: "seguranca_frouxa",
+                modulo: resumo.modulo,
+                task: resumo.task,
+                mensagem: `Task "${resumo.task}" opera com risco alto, mas ainda nao declarou execucao explicita.`,
+            });
+        }
+        if (resumo.lacunas.includes("rastreabilidade_fraca")) {
+            diagnosticos.push({
+                tipo: "seguranca_frouxa",
+                modulo: resumo.modulo,
+                task: resumo.task,
+                mensagem: `Task "${resumo.task}" exige producao mais rastreavel, mas ainda nao declara impl nem vinculos.`,
+            });
+        }
+        if (resumo.lacunas.includes("auth_ausente")) {
+            diagnosticos.push({
+                tipo: "seguranca_frouxa",
+                modulo: resumo.modulo,
+                task: resumo.task,
+                mensagem: `Task "${resumo.task}" chega em superficie publica sem auth explicita em task, route ou superficie associada.`,
+            });
+        }
+        if (resumo.lacunas.includes("authz_frouxa")) {
+            diagnosticos.push({
+                tipo: "seguranca_frouxa",
+                modulo: resumo.modulo,
+                task: resumo.task,
+                mensagem: `Task "${resumo.task}" opera com risco ou exposicao, mas ainda nao explicita authz suficiente.`,
+            });
+        }
+        if (resumo.lacunas.includes("dados_nao_classificados")) {
+            diagnosticos.push({
+                tipo: "seguranca_frouxa",
+                modulo: resumo.modulo,
+                task: resumo.task,
+                mensagem: `Task "${resumo.task}" ainda nao classifica dados de entrada/saida de forma semantica.`,
+            });
+        }
+        if (resumo.lacunas.includes("audit_ausente")) {
+            diagnosticos.push({
+                tipo: "seguranca_frouxa",
+                modulo: resumo.modulo,
+                task: resumo.task,
+                mensagem: `Task "${resumo.task}" ainda nao declara audit explicita para operacao sensivel ou publica.`,
+            });
+        }
+        if (resumo.lacunas.includes("segredo_sem_governanca")) {
+            diagnosticos.push({
+                tipo: "seguranca_frouxa",
+                modulo: resumo.modulo,
+                task: resumo.task,
+                mensagem: `Task "${resumo.task}" toca segredo ou credencial sem bloco segredos governando origem, escopo e rotacao.`,
+            });
+        }
+        if (resumo.lacunas.includes("proibicoes_ausentes")) {
+            diagnosticos.push({
+                tipo: "seguranca_frouxa",
+                modulo: resumo.modulo,
+                task: resumo.task,
+                mensagem: `Task "${resumo.task}" opera com efeito privilegiado ou dado sensivel sem forbidden explicito para conter abuso e vazamento.`,
+            });
+        }
     }
     const consumerSurfaces = [...indexTs.consumerSurfaces, ...indexDart.consumerSurfaces].sort((a, b) => a.rota.localeCompare(b.rota, "pt-BR")
         || a.tipoArquivo.localeCompare(b.tipoArquivo, "pt-BR")