@mocoto/mahoraga 0.14.0

package/dist/core/messages/pt/analysts/detector-js-ts-messages.js

@@ -0,0 +1,57 @@
+export const DetectorJsTsMensagens = {
+    tipoAnyComUtilidade: (varNome, _tipo) => `Uso de utilitário de tipo com 'any' em '${varNome}' mascara perda de type safety`,
+    tipoAnyComUtilidadeSugestao: (tipo) => `Substitua por: ${tipo.replace('any', 'TipoEspecifico')}`,
+    anyCatchBlock: (varNome) => varNome ? `'any' em catch block '${varNome}' - TypeScript recomenda 'unknown'` : "'any' em catch block - TypeScript recomenda 'unknown'",
+    anyCatchBlockSugestao: "Substitua por: catch (error: unknown) { ... }",
+    callbackAny: (varNome) => varNome ? `Callback '${varNome}' com parâmetro 'any' - tipagem fraca` : "Callback com parâmetro 'any' - tipagem fraca",
+    callbackAnySugestao: 'Defina interface do callback: (param: TipoEspecifico) => void',
+    eventHandlerAny: (varNome) => varNome ? `Event handler '${varNome}' com 'any' - pode usar Event types` : "Event handler com 'any' - pode usar Event types",
+    eventHandlerAnySugestao: 'Use tipos do DOM: MouseEvent, KeyboardEvent, etc ou React.SyntheticEvent<T>',
+    indexSignatureAny: 'Índice extensível com any - muito permissivo',
+    indexSignatureAnySugestao: 'Use: [key: string]: unknown (mais seguro) ou defina union type',
+    recordAny: (varNome) => varNome ? `Record com 'any' em '${varNome}' - sem type safety` : "Record com 'any' - sem type safety",
+    recordAnySugestao: 'Use Record<string, unknown> ou interface específica',
+    arrayAny: (varNome) => varNome ? `Array de 'any' em '${varNome}' - perde tipagem` : "Array de 'any' - perde tipagem",
+    arrayAnySugestao: 'Especifique tipo do array: string[], number[], CustomType[], etc',
+    tipoAnyGenerico: (varNome) => varNome ? `Tipo 'any' em '${varNome}' desabilita verificação de tipos` : "Tipo 'any' desabilita verificação de tipos",
+    tipoAnyGenericoSugestao: 'Analise uso da variável e defina tipo específico ou use unknown com type guards',
+    contextoAdicionalTipos: ' | [AVISO]  Arquivo de tipos - impacta toda base de código',
+    contextoAdicionalCore: ' | [AVISO]  Módulo core/shared - usado por muitos componentes',
+    revisaoManual: ' | [BUSCA] Revisão manual obrigatória',
+    tipoPermissivo: (tipo) => `Tipo '${tipo}' é muito permissivo e pouco útil para type safety`,
+    tipoObjectSugestao: 'Use Record<string, unknown> ou interface específica',
+    tipoVazioSugestao: 'Use Record<string, never> para objetos vazios ou interface específica',
+    typeAssertionAny: "Type assertion 'as any' desabilita verificação de tipos completamente",
+    assertionCastFuncaoSugestao: 'Evite cast de retorno de função - tipar função corretamente ou usar unknown com type guard',
+    assertionCastPropriedadeSugestao: 'Evite cast de propriedade - definir tipo correto no objeto pai',
+    assertionCastParametroSugestao: 'Type assertion em parâmetro - definir tipo correto na assinatura da função chamada',
+    assertionCastGenericoSugestao: 'Substitua por tipo específico ou use unknown com validação runtime',
+    assertionCritico: ' | [ALERT] CRÍTICO: Type safety completamente desabilitado',
+    angleBracketCast: "Type casting '<any>' (sintaxe legada) desabilita type safety | [IDEIA] Use sintaxe 'as' moderna e tipo específico | [ALERT] CRÍTICO: Migrar para sintaxe moderna e tipo correto",
+    unknownLegitimo: (varNome, motivo) => varNome ? `Tipo 'unknown' em '${varNome}': ${motivo}` : `Tipo 'unknown': ${motivo}`,
+    unknownMelhoravel: (varNome, confianca) => varNome ? `Tipo 'unknown' em '${varNome}' pode ser melhorado (${confianca}% confiança)` : `Tipo 'unknown' pode ser melhorado (${confianca}% confiança)`,
+    unknownCorrigir: (varNome, confianca) => varNome ? `Tipo 'unknown' em '${varNome}' deve ser corrigido (${confianca}% confiança)` : `Tipo 'unknown' deve ser corrigido (${confianca}% confiança)`,
+    unknownRevisaoManual: ' | [AVISO]  Revisão manual recomendada',
+    unknownRevisaoObrigatoria: ' | [BUSCA] Revisão manual obrigatória',
+    floatingPromise: (funcName) => `Chamada possivelmente assíncrona '${funcName}' não aguardada (floating promise). Adicione 'await' ou trate com '.catch()'.`,
+    asyncInForEach: (propName) => `Uso de 'async' dentro de '${propName}' não aguarda execução. Prefira iterar com 'for...of'.`,
+    asyncInMap: (_propName) => `Uso de 'async' dentro de 'map'. Certifique-se de envelopar e aguardar com 'Promise.all(...)'.`,
+    setIntervalUnassigned: 'Chamada para setInterval sem guardar a referência. Isso pode levar a um vazamento de memória e processamento.',
+    windowSetIntervalUnassigned: 'Chamada para window.setInterval sem guardar a referência (memory leak).',
+    globalListenerNoCleanup: "Adição de evento global 'addEventListener' detectada em componente React, porém 'removeEventListener' não foi encontrado. Isso causará memory leaks no unmount.",
+    promiseConstructorAntiPattern: "Uso de 'new Promise(() => {})' detectado. Prefira async/await para evitar o antipadrão de Promise explícita.",
+    missingPromiseAll: (calls) => `Detectadas ${calls} chamadas await independentes consecutivas. Use Promise.all() para paralelismo.`,
+    promiseAllWithoutErrorHandling: "Promise.all().then() sem tratamento de erros. Adicione .catch() ou use async/await com try/catch.",
+    asyncWithoutAwait: 'Função async sem nenhum await. Remova o async se não houver operação assíncrona.',
+    promiseNesting: 'Promise aninhada (then dentro de then). Prefira encadeamento plano com return.',
+    unhandledRejection: 'Possível rejeição de Promise não tratada. Adicione .catch() ou use try/catch com await.',
+    returnAwaitMisuse: "Uso de 'return await' desnecessário (fora de try/catch). Apenas 'return' é suficiente.",
+    closureRetainingLargeObject: 'Closure retém referência a objeto grande. Isso pode causar vazamento de memória se a closure persistir.',
+    eventListenerNoCleanup: "addEventListener sem 'removeEventListener' correspondente. Isso causará vazamento de memória.",
+    globalVariableGrowth: 'Adição de propriedade ao objeto global em loop. Isso causa crescimento de memória.',
+    setIntervalWithoutClearInterval: 'setInterval sem clearInterval correspondente. O timer continuará executando indefinidamente.',
+    observerWithoutDisconnect: 'Observer (MutationObserver/IntersectionObserver) sem disconnect(). Isso causa vazamento de memória.',
+    webSocketWithoutClose: 'WebSocket sem chamada close() correspondente. A conexão pode permanecer aberta.',
+    workerWithoutTerminate: 'Worker sem chamada terminate(). O worker continuará executando em segundo plano.',
+};
+//# sourceMappingURL=detector-js-ts-messages.js.map

package/dist/core/messages/pt/analysts/detector-js-ts-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-js-ts-messages.js","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-js-ts-messages.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,mBAAmB,EAAE,CAAC,OAAe,EAAE,KAAa,EAAE,EAAE,CAAC,2CAA2C,OAAO,gCAAgC;IAC3I,2BAA2B,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,kBAAkB,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,gBAAgB,CAAC,EAAE;IACxG,aAAa,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,yBAAyB,OAAO,oCAAoC,CAAC,CAAC,CAAC,uDAAuD;IAC7K,qBAAqB,EAAE,+CAA+C;IACtE,WAAW,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,OAAO,uCAAuC,CAAC,CAAC,CAAC,8CAA8C;IACzJ,mBAAmB,EAAE,+DAA+D;IACpF,eAAe,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,kBAAkB,OAAO,qCAAqC,CAAC,CAAC,CAAC,iDAAiD;IACnK,uBAAuB,EAAE,6EAA6E;IACtG,iBAAiB,EAAE,8CAA8C;IACjE,yBAAyB,EAAE,gEAAgE;IAC3F,SAAS,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,wBAAwB,OAAO,qBAAqB,CAAC,CAAC,CAAC,oCAAoC;IACtI,iBAAiB,EAAE,qDAAqD;IACxE,QAAQ,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,sBAAsB,OAAO,mBAAmB,CAAC,CAAC,CAAC,gCAAgC;IAC7H,gBAAgB,EAAE,kEAAkE;IACpF,eAAe,EAAE,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,kBAAkB,OAAO,mCAAmC,CAAC,CAAC,CAAC,4CAA4C;IAC5J,uBAAuB,EAAE,iFAAiF;IAC1G,sBAAsB,EAAE,4DAA4D;IACpF,qBAAqB,EAAE,+DAA+D;IACtF,aAAa,EAAE,uCAAuC;IACtD,cAAc,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,SAAS,IAAI,oDAAoD;IACnG,kBAAkB,EAAE,qDAAqD;IACzE,iBAAiB,EAAE,uEAAuE;IAC1F,gBAAgB,EAAE,uEAAuE;IACzF,2BAA2B,EAAE,4FAA4F;IACzH,gCAAgC,EAAE,gEAAgE;IAClG,8BAA8B,EAAE,oFAAoF;IACpH,6BAA6B,EAAE,oEAAoE;IACnG,gBAAgB,EAAE,4DAA4D;IAC9E,gBAAgB,EAAE,iLAAiL;IACnM,eAAe,EAAE,CAAC,OAAgB,EAAE,MAAe,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,sBAAsB,OAAO,MAAM,MAAM,EAAE,CAAC,CAAC,CAAC,mBAAmB,MAAM,EAAE;IAC3I,iBAAiB,EAAE,CAAC,OAAgB,EAAE,SAAkB,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,sBAAsB,OAAO,yBAAyB,SAAS,cAAc,CAAC,CAAC,CAAC,sCAAsC,SAAS,cAAc;IACpN,eAAe,EAAE,CAAC,OAAgB,EAAE,SAAkB,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,sBAAsB,OAAO,yBAAyB,SAAS,cAAc,CAAC,CAAC,CAAC,sCAAsC,SAAS,cAAc;IAClN,oBAAoB,EAAE,wCAAwC;IAC9D,yBAAyB,EAAE,uCAAuC;IAClE,eAAe,EAAE,CAAC,QAAgB,EAAE,EAAE,CAAC,qCAAqC,QAAQ,+EAA+E;IACnK,cAAc,EAAE,CAAC,QAAgB,EAAE,EAAE,CAAC,6BAA6B,QAAQ,wDAAwD;IACnI,UAAU,EAAE,CAAC,SAAiB,EAAE,EAAE,CAAC,+FAA+F;IAClI,qBAAqB,EAAE,+GAA+G;IACtI,2BAA2B,EAAE,yEAAyE;IACtG,uBAAuB,EAAE,iKAAiK;IAC1L,6BAA6B,EAAE,8GAA8G;IAC7I,iBAAiB,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,cAAc,KAAK,iFAAiF;IAC1I,8BAA8B,EAAE,mGAAmG;IACnI,iBAAiB,EAAE,kFAAkF;IACrG,cAAc,EAAE,gFAAgF;IAChG,kBAAkB,EAAE,yFAAyF;IAC7G,iBAAiB,EAAE,wFAAwF;IAC3G,2BAA2B,EAAE,yGAAyG;IACtI,sBAAsB,EAAE,+FAA+F;IACvH,oBAAoB,EAAE,oFAAoF;IAC1G,+BAA+B,EAAE,8FAA8F;IAC/H,yBAAyB,EAAE,qGAAqG;IAChI,qBAAqB,EAAE,iFAAiF;IACxG,sBAAsB,EAAE,kFAAkF;CAClG,CAAC","sourcesContent":["// SPDX-License-Identifier: MIT\n\nexport const DetectorJsTsMensagens = {\n  tipoAnyComUtilidade: (varNome: string, _tipo: string) => `Uso de utilitário de tipo com 'any' em '${varNome}' mascara perda de type safety`,\n  tipoAnyComUtilidadeSugestao: (tipo: string) => `Substitua por: ${tipo.replace('any', 'TipoEspecifico')}`,\n  anyCatchBlock: (varNome?: string) => varNome ? `'any' em catch block '${varNome}' - TypeScript recomenda 'unknown'` : \"'any' em catch block - TypeScript recomenda 'unknown'\",\n  anyCatchBlockSugestao: \"Substitua por: catch (error: unknown) { ... }\",\n  callbackAny: (varNome?: string) => varNome ? `Callback '${varNome}' com parâmetro 'any' - tipagem fraca` : \"Callback com parâmetro 'any' - tipagem fraca\",\n  callbackAnySugestao: 'Defina interface do callback: (param: TipoEspecifico) => void',\n  eventHandlerAny: (varNome?: string) => varNome ? `Event handler '${varNome}' com 'any' - pode usar Event types` : \"Event handler com 'any' - pode usar Event types\",\n  eventHandlerAnySugestao: 'Use tipos do DOM: MouseEvent, KeyboardEvent, etc ou React.SyntheticEvent<T>',\n  indexSignatureAny: 'Índice extensível com any - muito permissivo',\n  indexSignatureAnySugestao: 'Use: [key: string]: unknown (mais seguro) ou defina union type',\n  recordAny: (varNome?: string) => varNome ? `Record com 'any' em '${varNome}' - sem type safety` : \"Record com 'any' - sem type safety\",\n  recordAnySugestao: 'Use Record<string, unknown> ou interface específica',\n  arrayAny: (varNome?: string) => varNome ? `Array de 'any' em '${varNome}' - perde tipagem` : \"Array de 'any' - perde tipagem\",\n  arrayAnySugestao: 'Especifique tipo do array: string[], number[], CustomType[], etc',\n  tipoAnyGenerico: (varNome?: string) => varNome ? `Tipo 'any' em '${varNome}' desabilita verificação de tipos` : \"Tipo 'any' desabilita verificação de tipos\",\n  tipoAnyGenericoSugestao: 'Analise uso da variável e defina tipo específico ou use unknown com type guards',\n  contextoAdicionalTipos: ' | [AVISO]  Arquivo de tipos - impacta toda base de código',\n  contextoAdicionalCore: ' | [AVISO]  Módulo core/shared - usado por muitos componentes',\n  revisaoManual: ' | [BUSCA] Revisão manual obrigatória',\n  tipoPermissivo: (tipo: string) => `Tipo '${tipo}' é muito permissivo e pouco útil para type safety`,\n  tipoObjectSugestao: 'Use Record<string, unknown> ou interface específica',\n  tipoVazioSugestao: 'Use Record<string, never> para objetos vazios ou interface específica',\n  typeAssertionAny: \"Type assertion 'as any' desabilita verificação de tipos completamente\",\n  assertionCastFuncaoSugestao: 'Evite cast de retorno de função - tipar função corretamente ou usar unknown com type guard',\n  assertionCastPropriedadeSugestao: 'Evite cast de propriedade - definir tipo correto no objeto pai',\n  assertionCastParametroSugestao: 'Type assertion em parâmetro - definir tipo correto na assinatura da função chamada',\n  assertionCastGenericoSugestao: 'Substitua por tipo específico ou use unknown com validação runtime',\n  assertionCritico: ' | [ALERT] CRÍTICO: Type safety completamente desabilitado',\n  angleBracketCast: \"Type casting '<any>' (sintaxe legada) desabilita type safety | [IDEIA] Use sintaxe 'as' moderna e tipo específico | [ALERT] CRÍTICO: Migrar para sintaxe moderna e tipo correto\",\n  unknownLegitimo: (varNome?: string, motivo?: string) => varNome ? `Tipo 'unknown' em '${varNome}': ${motivo}` : `Tipo 'unknown': ${motivo}`,\n  unknownMelhoravel: (varNome?: string, confianca?: number) => varNome ? `Tipo 'unknown' em '${varNome}' pode ser melhorado (${confianca}% confiança)` : `Tipo 'unknown' pode ser melhorado (${confianca}% confiança)`,\n  unknownCorrigir: (varNome?: string, confianca?: number) => varNome ? `Tipo 'unknown' em '${varNome}' deve ser corrigido (${confianca}% confiança)` : `Tipo 'unknown' deve ser corrigido (${confianca}% confiança)`,\n  unknownRevisaoManual: ' | [AVISO]  Revisão manual recomendada',\n  unknownRevisaoObrigatoria: ' | [BUSCA] Revisão manual obrigatória',\n  floatingPromise: (funcName: string) => `Chamada possivelmente assíncrona '${funcName}' não aguardada (floating promise). Adicione 'await' ou trate com '.catch()'.`,\n  asyncInForEach: (propName: string) => `Uso de 'async' dentro de '${propName}' não aguarda execução. Prefira iterar com 'for...of'.`,\n  asyncInMap: (_propName: string) => `Uso de 'async' dentro de 'map'. Certifique-se de envelopar e aguardar com 'Promise.all(...)'.`,\n  setIntervalUnassigned: 'Chamada para setInterval sem guardar a referência. Isso pode levar a um vazamento de memória e processamento.',\n  windowSetIntervalUnassigned: 'Chamada para window.setInterval sem guardar a referência (memory leak).',\n  globalListenerNoCleanup: \"Adição de evento global 'addEventListener' detectada em componente React, porém 'removeEventListener' não foi encontrado. Isso causará memory leaks no unmount.\",\n  promiseConstructorAntiPattern: \"Uso de 'new Promise(() => {})' detectado. Prefira async/await para evitar o antipadrão de Promise explícita.\",\n  missingPromiseAll: (calls: number) => `Detectadas ${calls} chamadas await independentes consecutivas. Use Promise.all() para paralelismo.`,\n  promiseAllWithoutErrorHandling: \"Promise.all().then() sem tratamento de erros. Adicione .catch() ou use async/await com try/catch.\",\n  asyncWithoutAwait: 'Função async sem nenhum await. Remova o async se não houver operação assíncrona.',\n  promiseNesting: 'Promise aninhada (then dentro de then). Prefira encadeamento plano com return.',\n  unhandledRejection: 'Possível rejeição de Promise não tratada. Adicione .catch() ou use try/catch com await.',\n  returnAwaitMisuse: \"Uso de 'return await' desnecessário (fora de try/catch). Apenas 'return' é suficiente.\",\n  closureRetainingLargeObject: 'Closure retém referência a objeto grande. Isso pode causar vazamento de memória se a closure persistir.',\n  eventListenerNoCleanup: \"addEventListener sem 'removeEventListener' correspondente. Isso causará vazamento de memória.\",\n  globalVariableGrowth: 'Adição de propriedade ao objeto global em loop. Isso causa crescimento de memória.',\n  setIntervalWithoutClearInterval: 'setInterval sem clearInterval correspondente. O timer continuará executando indefinidamente.',\n  observerWithoutDisconnect: 'Observer (MutationObserver/IntersectionObserver) sem disconnect(). Isso causa vazamento de memória.',\n  webSocketWithoutClose: 'WebSocket sem chamada close() correspondente. A conexão pode permanecer aberta.',\n  workerWithoutTerminate: 'Worker sem chamada terminate(). O worker continuará executando em segundo plano.',\n} as const;\n"]}

package/dist/core/messages/pt/analysts/detector-python-messages.d.ts

@@ -0,0 +1,17 @@
+export declare const DetectorPythonMensagens: {
+    readonly bareExcept: "Bare except detectado - captura todas exceções incluindo SystemExit";
+    readonly bareExceptSugestao: "Use except Exception: ou exceção específica";
+    readonly evalUsage: "eval() detectado - risco de execução de código arbitrário";
+    readonly evalUsageSugestao: "Use ast.literal_eval() para dados seguros";
+    readonly execUsage: "exec() detectado - risco de execução de código arbitrário";
+    readonly execUsageSugestao: "Evite exec(), refatore para funções dinâmicas seguras";
+    readonly mutableDefault: "Argumento default mutável detectado";
+    readonly mutableDefaultSugestao: "Use None como default e inicialize dentro da função";
+    readonly printInsteadLog: "print() usado ao invés de logging";
+    readonly printInsteadLogSugestao: "Use logging.info(), logging.debug(), etc.";
+    readonly missingTypeHints: "Função sem type hints";
+    readonly missingTypeHintsSugestao: "Adicione type hints para parâmetros e retorno";
+    readonly subprocessShell: "subprocess com shell=True - risco de injection";
+    readonly subprocessShellSugestao: "Passe lista de argumentos ao invés de string com shell=True";
+};
+//# sourceMappingURL=detector-python-messages.d.ts.map

package/dist/core/messages/pt/analysts/detector-python-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-python-messages.d.ts","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-python-messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;CAe1B,CAAC"}

package/dist/core/messages/pt/analysts/detector-python-messages.js

@@ -0,0 +1,17 @@
+export const DetectorPythonMensagens = {
+    bareExcept: 'Bare except detectado - captura todas exceções incluindo SystemExit',
+    bareExceptSugestao: 'Use except Exception: ou exceção específica',
+    evalUsage: 'eval() detectado - risco de execução de código arbitrário',
+    evalUsageSugestao: 'Use ast.literal_eval() para dados seguros',
+    execUsage: 'exec() detectado - risco de execução de código arbitrário',
+    execUsageSugestao: 'Evite exec(), refatore para funções dinâmicas seguras',
+    mutableDefault: 'Argumento default mutável detectado',
+    mutableDefaultSugestao: 'Use None como default e inicialize dentro da função',
+    printInsteadLog: 'print() usado ao invés de logging',
+    printInsteadLogSugestao: 'Use logging.info(), logging.debug(), etc.',
+    missingTypeHints: 'Função sem type hints',
+    missingTypeHintsSugestao: 'Adicione type hints para parâmetros e retorno',
+    subprocessShell: 'subprocess com shell=True - risco de injection',
+    subprocessShellSugestao: 'Passe lista de argumentos ao invés de string com shell=True',
+};
+//# sourceMappingURL=detector-python-messages.js.map

package/dist/core/messages/pt/analysts/detector-python-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-python-messages.js","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-python-messages.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,UAAU,EAAE,qEAAqE;IACjF,kBAAkB,EAAE,6CAA6C;IACjE,SAAS,EAAE,2DAA2D;IACtE,iBAAiB,EAAE,2CAA2C;IAC9D,SAAS,EAAE,2DAA2D;IACtE,iBAAiB,EAAE,uDAAuD;IAC1E,cAAc,EAAE,qCAAqC;IACrD,sBAAsB,EAAE,qDAAqD;IAC7E,eAAe,EAAE,mCAAmC;IACpD,uBAAuB,EAAE,2CAA2C;IACpE,gBAAgB,EAAE,uBAAuB;IACzC,wBAAwB,EAAE,+CAA+C;IACzE,eAAe,EAAE,gDAAgD;IACjE,uBAAuB,EAAE,6DAA6D;CAC9E,CAAC","sourcesContent":["// SPDX-License-Identifier: MIT\n\nexport const DetectorPythonMensagens = {\n  bareExcept: 'Bare except detectado - captura todas exceções incluindo SystemExit',\n  bareExceptSugestao: 'Use except Exception: ou exceção específica',\n  evalUsage: 'eval() detectado - risco de execução de código arbitrário',\n  evalUsageSugestao: 'Use ast.literal_eval() para dados seguros',\n  execUsage: 'exec() detectado - risco de execução de código arbitrário',\n  execUsageSugestao: 'Evite exec(), refatore para funções dinâmicas seguras',\n  mutableDefault: 'Argumento default mutável detectado',\n  mutableDefaultSugestao: 'Use None como default e inicialize dentro da função',\n  printInsteadLog: 'print() usado ao invés de logging',\n  printInsteadLogSugestao: 'Use logging.info(), logging.debug(), etc.',\n  missingTypeHints: 'Função sem type hints',\n  missingTypeHintsSugestao: 'Adicione type hints para parâmetros e retorno',\n  subprocessShell: 'subprocess com shell=True - risco de injection',\n  subprocessShellSugestao: 'Passe lista de argumentos ao invés de string com shell=True',\n} as const;\n"]}

package/dist/core/messages/pt/analysts/detector-react-messages.d.ts

@@ -0,0 +1,60 @@
+export declare const DetectorReactMensagens: {
+    readonly dangerousHtml: "dangerouslySetInnerHTML detectado - risco de XSS";
+    readonly dangerousHtmlSugestao: "Use DOMPurify ou sanitize-html para sanitizar o conteúdo";
+    readonly inlineHandler: "Handler inline detectado - pode causar re-renders";
+    readonly inlineHandlerSugestao: "Extraia o handler para uma função nomeada ou useCallback";
+    readonly indexAsKey: "Índice usado como key - pode causar problemas de renderização";
+    readonly indexAsKeySugestao: "Use um ID único do item como key";
+    readonly deprecatedLifecycle: "Lifecycle method deprecated detectado";
+    readonly deprecatedLifecycleSugestao: "Use getDerivedStateFromProps ou componentDidUpdate";
+    readonly imgWithoutAlt: "Imagem sem atributo alt - problema de acessibilidade";
+    readonly imgWithoutAltSugestao: "Adicione alt descritivo ou aria-hidden=\"true\" para imagens decorativas";
+    readonly hookConditionalCall: "Hook chamado condicionalmente";
+    readonly hookConditionalCallSugestao: "Hooks devem ser chamados incondicionalmente";
+    readonly hookInsideCallback: "Hook chamado dentro de callback/handler aninhado";
+    readonly hookInsideCallbackSugestao: "Mova hooks para o nível superior do componente";
+    readonly hookBeforeReturn: "Hook após return statement";
+    readonly hookBeforeReturnSugestao: "Sempre chame hooks antes de early returns";
+    readonly missingUseCallbackDeps: "useCallback com dependências faltando";
+    readonly missingUseCallbackDepsSugestao: "Adicione todas as dependências ao array";
+    readonly missingUseMemoDeps: "useMemo com dependências faltando";
+    readonly missingUseMemoDepsSugestao: "Adicione todas as dependências ao array";
+    readonly staleClosure: "Closure desatualizado em callback de useEffect";
+    readonly staleClosureSugestao: "Inclua todas as variáveis referenciadas no array de deps";
+    readonly unnecessaryUseState: "Estado que não precisa ser estado (valor derivado)";
+    readonly unnecessaryUseStateSugestao: "Compute o valor diretamente ao invés de armazenar em estado";
+    readonly inlineFunctionInRender: "Função inline passada como prop";
+    readonly inlineFunctionInRenderSugestao: "Extraia com useCallback";
+    readonly inlineObjectInRender: "Objeto/array inline passado como prop";
+    readonly inlineObjectInRenderSugestao: "Extraia com useMemo";
+    readonly keyIndexUsage: "Usando índice como key";
+    readonly keyIndexUsageSugestao: "Use um ID único e estável como key";
+    readonly largeListWithoutVirtualization: "Lista longa renderizada sem virtualização";
+    readonly largeListWithoutVirtualizationSugestao: "Use react-window ou FlatList";
+    readonly unnecessaryFragment: "Fragment envolvendo elemento único";
+    readonly directDomManipulation: "Manipulação direta do DOM em componente React";
+    readonly directDomManipulationSugestao: "Use refs e padrões React";
+    readonly stateMutation: "Mutação direta de estado detectada";
+    readonly stateMutationSugestao: "Use setState de forma imutável";
+    readonly missingCleanupEffect: "useEffect sem cleanup para subscriptions";
+    readonly missingCleanupEffectSugestao: "Retorne função de cleanup do useEffect";
+    readonly synchronousSideEffect: "Efeito colateral fora do useEffect (no corpo do render)";
+    readonly synchronousSideEffectSugestao: "Mova efeitos colaterais para useEffect ou event handler";
+    readonly complexUseEffect: "useEffect único lidando com muitas responsabilidades";
+    readonly complexUseEffectSugestao: "Separe em effects distintos por responsabilidade";
+    readonly infiniteLoopPattern: "Effect que dispara state que dispara effect";
+    readonly infiniteLoopPatternSugestao: "Revise as dependências do effect para evitar loops";
+    readonly propDrilling: "Prop drilling através de múltiplos níveis (4+)";
+    readonly propDrillingSugestao: "Use context ou composição";
+    readonly missingAriaInInteractive: "Elemento interativo sem atributos aria";
+    readonly missingAriaInInteractiveSugestao: "Adicione aria-label ou aria-labelledby";
+    readonly onClickWithoutKeyDown: "onClick sem onKeyDown em elemento não-button";
+    readonly onClickWithoutKeyDownSugestao: "Adicione handler de teclado para acessibilidade";
+    readonly contextRecreatingValue: "Valor de contexto recriado a cada render";
+    readonly contextRecreatingValueSugestao: "Memoize o valor do contexto com useMemo";
+    readonly contextTooBroad: "Contexto que re-renderiza muitos componentes";
+    readonly contextTooBroadSugestao: "Divida em contextos menores";
+    readonly liftingStateTooHigh: "Estado elevado mais níveis que o necessário";
+    readonly liftingStateTooHighSugestao: "Considere context ou estado local";
+};
+//# sourceMappingURL=detector-react-messages.d.ts.map

package/dist/core/messages/pt/analysts/detector-react-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-react-messages.d.ts","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-react-messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DzB,CAAC"}

package/dist/core/messages/pt/analysts/detector-react-messages.js

@@ -0,0 +1,60 @@
+export const DetectorReactMensagens = {
+    dangerousHtml: 'dangerouslySetInnerHTML detectado - risco de XSS',
+    dangerousHtmlSugestao: 'Use DOMPurify ou sanitize-html para sanitizar o conteúdo',
+    inlineHandler: 'Handler inline detectado - pode causar re-renders',
+    inlineHandlerSugestao: 'Extraia o handler para uma função nomeada ou useCallback',
+    indexAsKey: 'Índice usado como key - pode causar problemas de renderização',
+    indexAsKeySugestao: 'Use um ID único do item como key',
+    deprecatedLifecycle: 'Lifecycle method deprecated detectado',
+    deprecatedLifecycleSugestao: 'Use getDerivedStateFromProps ou componentDidUpdate',
+    imgWithoutAlt: 'Imagem sem atributo alt - problema de acessibilidade',
+    imgWithoutAltSugestao: 'Adicione alt descritivo ou aria-hidden="true" para imagens decorativas',
+    hookConditionalCall: 'Hook chamado condicionalmente',
+    hookConditionalCallSugestao: 'Hooks devem ser chamados incondicionalmente',
+    hookInsideCallback: 'Hook chamado dentro de callback/handler aninhado',
+    hookInsideCallbackSugestao: 'Mova hooks para o nível superior do componente',
+    hookBeforeReturn: 'Hook após return statement',
+    hookBeforeReturnSugestao: 'Sempre chame hooks antes de early returns',
+    missingUseCallbackDeps: 'useCallback com dependências faltando',
+    missingUseCallbackDepsSugestao: 'Adicione todas as dependências ao array',
+    missingUseMemoDeps: 'useMemo com dependências faltando',
+    missingUseMemoDepsSugestao: 'Adicione todas as dependências ao array',
+    staleClosure: 'Closure desatualizado em callback de useEffect',
+    staleClosureSugestao: 'Inclua todas as variáveis referenciadas no array de deps',
+    unnecessaryUseState: 'Estado que não precisa ser estado (valor derivado)',
+    unnecessaryUseStateSugestao: 'Compute o valor diretamente ao invés de armazenar em estado',
+    inlineFunctionInRender: 'Função inline passada como prop',
+    inlineFunctionInRenderSugestao: 'Extraia com useCallback',
+    inlineObjectInRender: 'Objeto/array inline passado como prop',
+    inlineObjectInRenderSugestao: 'Extraia com useMemo',
+    keyIndexUsage: 'Usando índice como key',
+    keyIndexUsageSugestao: 'Use um ID único e estável como key',
+    largeListWithoutVirtualization: 'Lista longa renderizada sem virtualização',
+    largeListWithoutVirtualizationSugestao: 'Use react-window ou FlatList',
+    unnecessaryFragment: 'Fragment envolvendo elemento único',
+    directDomManipulation: 'Manipulação direta do DOM em componente React',
+    directDomManipulationSugestao: 'Use refs e padrões React',
+    stateMutation: 'Mutação direta de estado detectada',
+    stateMutationSugestao: 'Use setState de forma imutável',
+    missingCleanupEffect: 'useEffect sem cleanup para subscriptions',
+    missingCleanupEffectSugestao: 'Retorne função de cleanup do useEffect',
+    synchronousSideEffect: 'Efeito colateral fora do useEffect (no corpo do render)',
+    synchronousSideEffectSugestao: 'Mova efeitos colaterais para useEffect ou event handler',
+    complexUseEffect: 'useEffect único lidando com muitas responsabilidades',
+    complexUseEffectSugestao: 'Separe em effects distintos por responsabilidade',
+    infiniteLoopPattern: 'Effect que dispara state que dispara effect',
+    infiniteLoopPatternSugestao: 'Revise as dependências do effect para evitar loops',
+    propDrilling: 'Prop drilling através de múltiplos níveis (4+)',
+    propDrillingSugestao: 'Use context ou composição',
+    missingAriaInInteractive: 'Elemento interativo sem atributos aria',
+    missingAriaInInteractiveSugestao: 'Adicione aria-label ou aria-labelledby',
+    onClickWithoutKeyDown: 'onClick sem onKeyDown em elemento não-button',
+    onClickWithoutKeyDownSugestao: 'Adicione handler de teclado para acessibilidade',
+    contextRecreatingValue: 'Valor de contexto recriado a cada render',
+    contextRecreatingValueSugestao: 'Memoize o valor do contexto com useMemo',
+    contextTooBroad: 'Contexto que re-renderiza muitos componentes',
+    contextTooBroadSugestao: 'Divida em contextos menores',
+    liftingStateTooHigh: 'Estado elevado mais níveis que o necessário',
+    liftingStateTooHighSugestao: 'Considere context ou estado local',
+};
+//# sourceMappingURL=detector-react-messages.js.map

package/dist/core/messages/pt/analysts/detector-react-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-react-messages.js","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-react-messages.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,aAAa,EAAE,kDAAkD;IACjE,qBAAqB,EAAE,0DAA0D;IACjF,aAAa,EAAE,mDAAmD;IAClE,qBAAqB,EAAE,0DAA0D;IACjF,UAAU,EAAE,+DAA+D;IAC3E,kBAAkB,EAAE,kCAAkC;IACtD,mBAAmB,EAAE,uCAAuC;IAC5D,2BAA2B,EAAE,oDAAoD;IACjF,aAAa,EAAE,sDAAsD;IACrE,qBAAqB,EAAE,wEAAwE;IAE/F,mBAAmB,EAAE,+BAA+B;IACpD,2BAA2B,EAAE,6CAA6C;IAC1E,kBAAkB,EAAE,kDAAkD;IACtE,0BAA0B,EAAE,gDAAgD;IAC5E,gBAAgB,EAAE,4BAA4B;IAC9C,wBAAwB,EAAE,2CAA2C;IACrE,sBAAsB,EAAE,uCAAuC;IAC/D,8BAA8B,EAAE,yCAAyC;IACzE,kBAAkB,EAAE,mCAAmC;IACvD,0BAA0B,EAAE,yCAAyC;IACrE,YAAY,EAAE,gDAAgD;IAC9D,oBAAoB,EAAE,0DAA0D;IAEhF,mBAAmB,EAAE,oDAAoD;IACzE,2BAA2B,EAAE,6DAA6D;IAC1F,sBAAsB,EAAE,iCAAiC;IACzD,8BAA8B,EAAE,yBAAyB;IACzD,oBAAoB,EAAE,uCAAuC;IAC7D,4BAA4B,EAAE,qBAAqB;IACnD,aAAa,EAAE,wBAAwB;IACvC,qBAAqB,EAAE,oCAAoC;IAC3D,8BAA8B,EAAE,2CAA2C;IAC3E,sCAAsC,EAAE,8BAA8B;IACtE,mBAAmB,EAAE,oCAAoC;IAEzD,qBAAqB,EAAE,+CAA+C;IACtE,6BAA6B,EAAE,0BAA0B;IACzD,aAAa,EAAE,oCAAoC;IACnD,qBAAqB,EAAE,gCAAgC;IACvD,oBAAoB,EAAE,0CAA0C;IAChE,4BAA4B,EAAE,wCAAwC;IACtE,qBAAqB,EAAE,yDAAyD;IAChF,6BAA6B,EAAE,yDAAyD;IACxF,gBAAgB,EAAE,sDAAsD;IACxE,wBAAwB,EAAE,kDAAkD;IAC5E,mBAAmB,EAAE,6CAA6C;IAClE,2BAA2B,EAAE,oDAAoD;IACjF,YAAY,EAAE,gDAAgD;IAC9D,oBAAoB,EAAE,2BAA2B;IAEjD,wBAAwB,EAAE,wCAAwC;IAClE,gCAAgC,EAAE,wCAAwC;IAC1E,qBAAqB,EAAE,8CAA8C;IACrE,6BAA6B,EAAE,iDAAiD;IAEhF,sBAAsB,EAAE,0CAA0C;IAClE,8BAA8B,EAAE,yCAAyC;IACzE,eAAe,EAAE,8CAA8C;IAC/D,uBAAuB,EAAE,6BAA6B;IACtD,mBAAmB,EAAE,6CAA6C;IAClE,2BAA2B,EAAE,mCAAmC;CACxD,CAAC","sourcesContent":["// SPDX-License-Identifier: MIT\n\nexport const DetectorReactMensagens = {\n  dangerousHtml: 'dangerouslySetInnerHTML detectado - risco de XSS',\n  dangerousHtmlSugestao: 'Use DOMPurify ou sanitize-html para sanitizar o conteúdo',\n  inlineHandler: 'Handler inline detectado - pode causar re-renders',\n  inlineHandlerSugestao: 'Extraia o handler para uma função nomeada ou useCallback',\n  indexAsKey: 'Índice usado como key - pode causar problemas de renderização',\n  indexAsKeySugestao: 'Use um ID único do item como key',\n  deprecatedLifecycle: 'Lifecycle method deprecated detectado',\n  deprecatedLifecycleSugestao: 'Use getDerivedStateFromProps ou componentDidUpdate',\n  imgWithoutAlt: 'Imagem sem atributo alt - problema de acessibilidade',\n  imgWithoutAltSugestao: 'Adicione alt descritivo ou aria-hidden=\"true\" para imagens decorativas',\n\n  hookConditionalCall: 'Hook chamado condicionalmente',\n  hookConditionalCallSugestao: 'Hooks devem ser chamados incondicionalmente',\n  hookInsideCallback: 'Hook chamado dentro de callback/handler aninhado',\n  hookInsideCallbackSugestao: 'Mova hooks para o nível superior do componente',\n  hookBeforeReturn: 'Hook após return statement',\n  hookBeforeReturnSugestao: 'Sempre chame hooks antes de early returns',\n  missingUseCallbackDeps: 'useCallback com dependências faltando',\n  missingUseCallbackDepsSugestao: 'Adicione todas as dependências ao array',\n  missingUseMemoDeps: 'useMemo com dependências faltando',\n  missingUseMemoDepsSugestao: 'Adicione todas as dependências ao array',\n  staleClosure: 'Closure desatualizado em callback de useEffect',\n  staleClosureSugestao: 'Inclua todas as variáveis referenciadas no array de deps',\n\n  unnecessaryUseState: 'Estado que não precisa ser estado (valor derivado)',\n  unnecessaryUseStateSugestao: 'Compute o valor diretamente ao invés de armazenar em estado',\n  inlineFunctionInRender: 'Função inline passada como prop',\n  inlineFunctionInRenderSugestao: 'Extraia com useCallback',\n  inlineObjectInRender: 'Objeto/array inline passado como prop',\n  inlineObjectInRenderSugestao: 'Extraia com useMemo',\n  keyIndexUsage: 'Usando índice como key',\n  keyIndexUsageSugestao: 'Use um ID único e estável como key',\n  largeListWithoutVirtualization: 'Lista longa renderizada sem virtualização',\n  largeListWithoutVirtualizationSugestao: 'Use react-window ou FlatList',\n  unnecessaryFragment: 'Fragment envolvendo elemento único',\n\n  directDomManipulation: 'Manipulação direta do DOM em componente React',\n  directDomManipulationSugestao: 'Use refs e padrões React',\n  stateMutation: 'Mutação direta de estado detectada',\n  stateMutationSugestao: 'Use setState de forma imutável',\n  missingCleanupEffect: 'useEffect sem cleanup para subscriptions',\n  missingCleanupEffectSugestao: 'Retorne função de cleanup do useEffect',\n  synchronousSideEffect: 'Efeito colateral fora do useEffect (no corpo do render)',\n  synchronousSideEffectSugestao: 'Mova efeitos colaterais para useEffect ou event handler',\n  complexUseEffect: 'useEffect único lidando com muitas responsabilidades',\n  complexUseEffectSugestao: 'Separe em effects distintos por responsabilidade',\n  infiniteLoopPattern: 'Effect que dispara state que dispara effect',\n  infiniteLoopPatternSugestao: 'Revise as dependências do effect para evitar loops',\n  propDrilling: 'Prop drilling através de múltiplos níveis (4+)',\n  propDrillingSugestao: 'Use context ou composição',\n\n  missingAriaInInteractive: 'Elemento interativo sem atributos aria',\n  missingAriaInInteractiveSugestao: 'Adicione aria-label ou aria-labelledby',\n  onClickWithoutKeyDown: 'onClick sem onKeyDown em elemento não-button',\n  onClickWithoutKeyDownSugestao: 'Adicione handler de teclado para acessibilidade',\n\n  contextRecreatingValue: 'Valor de contexto recriado a cada render',\n  contextRecreatingValueSugestao: 'Memoize o valor do contexto com useMemo',\n  contextTooBroad: 'Contexto que re-renderiza muitos componentes',\n  contextTooBroadSugestao: 'Divida em contextos menores',\n  liftingStateTooHigh: 'Estado elevado mais níveis que o necessário',\n  liftingStateTooHighSugestao: 'Considere context ou estado local',\n} as const;\n"]}

package/dist/core/messages/pt/analysts/detector-shell-messages.d.ts

@@ -0,0 +1,59 @@
+export declare const DetectorShellMensagens: {
+    readonly missingShebang: "Script sem shebang";
+    readonly missingShebangSugestao: "Adicione #!/bin/bash ou #!/bin/sh";
+    readonly missingSetE: "Script sem \"set -e\" - erros não interrompem execução";
+    readonly missingSetESugestao: "Adicione set -e no início do script";
+    readonly evalUsage: "eval() detectado - risco de execução arbitrária";
+    readonly evalUsageSugestao: "Evite eval - use arrays ou outras construções";
+    readonly rmRfRoot: "COMANDO EXTREMAMENTE PERIGOSO: rm -rf /";
+    readonly rmRfRootSugestao: "Remova este comando imediatamente!";
+    readonly curlPipeSh: "curl/wget piped para shell - risco de segurança";
+    readonly curlPipeShSugestao: "Baixe, inspecione e execute separadamente";
+    readonly hardcodedPassword: "Credencial hardcoded em variável";
+    readonly hardcodedPasswordSugestao: "Use variáveis de ambiente";
+    readonly unquotedVariable: "Variável sem aspas - problemas com espaços";
+    readonly unquotedVariableSugestao: "Use \"$VAR\" ao invés de $VAR";
+    readonly sudoUsage: "Uso de sudo detectado";
+    readonly sudoUsageSugestao: "Projete scripts que rodem sem root";
+    readonly unsafePipefail: "Pipeline sem pipefail - erros no pipe ignorados";
+    readonly unsafePipefailSugestao: "Adicione \"set -o pipefail\" para capturar erros em pipes";
+    readonly unsafeCdWithoutCheck: "cd sem verificação de erro";
+    readonly unsafeCdWithoutCheckSugestao: "Verifique o código de saída do cd ou use \"|| exit\"";
+    readonly unsafeTmpFile: "Uso de /tmp sem nome aleatório";
+    readonly unsafeTmpFileSugestao: "Use mktemp para arquivos temporários";
+    readonly insecurePermissions: "Permissões inseguras detectadas (chmod 777 ou umask 000)";
+    readonly insecurePermissionsSugestao: "Use permissões restritivas (755/644)";
+    readonly dangerousFlags: "Flags de comando perigosas detectadas (rm -rf /*, chown -R)";
+    readonly dangerousFlagsSugestao: "Verifique se as flags são intencionais e escopo limitado";
+    readonly unsafeReadWithoutR: "read sem -r (barras invertidas são interpretadas)";
+    readonly unsafeReadWithoutRSugestao: "Use \"read -r\" para preservar barras invertidas";
+    readonly missingLocalVar: "Variável em função não declarada como local";
+    readonly missingLocalVarSugestao: "Use a palavra-chave \"local\" para escopar variáveis";
+    readonly uppercaseLocalVar: "Variável local nomeada com MAIÚSCULAS";
+    readonly uppercaseLocalVarSugestao: "Use minúsculas para variáveis locais (convenção)";
+    readonly backtickCmdSub: "Substituição de comando com crases";
+    readonly backtickCmdSubSugestao: "Use $(...) em vez de crases";
+    readonly doubleBracketMissing: "[ usado em vez de [[ no Bash";
+    readonly doubleBracketMissingSugestao: "Use [[ ]] para comparações de string mais seguras";
+    readonly unsafeArithmeticEval: "$(( )) vs let vs expr detectado";
+    readonly unsafeArithmeticEvalSugestao: "Use $(( )) para aritmética";
+    readonly functionDeclStyle: "Palavra-chave function usada (não portável)";
+    readonly functionDeclStyleSugestao: "Use a sintaxe \"nome()\" para conformidade POSIX";
+    readonly missingDefaultCase: "Case sem *)";
+    readonly missingDefaultCaseSugestao: "Adicione o caso padrão *) por segurança";
+    readonly emptyCatchBlock: "Bloco then/else vazio";
+    readonly emptyCatchBlockSugestao: "Adicione um comentário ou remova o bloco vazio";
+    readonly bashismDetected: "Funcionalidade específica do Bash em script #!/bin/sh";
+    readonly bashismDetectedSugestao: "Use sintaxe compatível com POSIX para scripts sh";
+    readonly platformSpecificPath: "Caminho específico de plataforma (/usr/bin vs /bin)";
+    readonly platformSpecificPathSugestao: "Use command -v ou which para descoberta";
+    readonly missingQuoteArrays: "Expansão de array sem aspas";
+    readonly missingQuoteArraysSugestao: "Use \"${arr[@]}\" para preservar espaços";
+    readonly uselessCat: "cat arquivo | comando em vez de comando < arquivo";
+    readonly uselessCatSugestao: "Use redirecionamento de entrada em vez de cat com pipe";
+    readonly loopOverCommandOutput: "for arquivo in $(ls) em vez de for arquivo in *";
+    readonly loopOverCommandOutputSugestao: "Use padrões glob em vez de analisar ls";
+    readonly pipeOverTempfile: "Pipeline poderia substituir arquivo temporário";
+    readonly pipeOverTempfileSugestao: "Use pipes em vez de arquivos temporários";
+};
+//# sourceMappingURL=detector-shell-messages.d.ts.map

package/dist/core/messages/pt/analysts/detector-shell-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-shell-messages.d.ts","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-shell-messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DzB,CAAC"}

package/dist/core/messages/pt/analysts/detector-shell-messages.js

@@ -0,0 +1,59 @@
+export const DetectorShellMensagens = {
+    missingShebang: 'Script sem shebang',
+    missingShebangSugestao: 'Adicione #!/bin/bash ou #!/bin/sh',
+    missingSetE: 'Script sem "set -e" - erros não interrompem execução',
+    missingSetESugestao: 'Adicione set -e no início do script',
+    evalUsage: 'eval() detectado - risco de execução arbitrária',
+    evalUsageSugestao: 'Evite eval - use arrays ou outras construções',
+    rmRfRoot: 'COMANDO EXTREMAMENTE PERIGOSO: rm -rf /',
+    rmRfRootSugestao: 'Remova este comando imediatamente!',
+    curlPipeSh: 'curl/wget piped para shell - risco de segurança',
+    curlPipeShSugestao: 'Baixe, inspecione e execute separadamente',
+    hardcodedPassword: 'Credencial hardcoded em variável',
+    hardcodedPasswordSugestao: 'Use variáveis de ambiente',
+    unquotedVariable: 'Variável sem aspas - problemas com espaços',
+    unquotedVariableSugestao: 'Use "$VAR" ao invés de $VAR',
+    sudoUsage: 'Uso de sudo detectado',
+    sudoUsageSugestao: 'Projete scripts que rodem sem root',
+    unsafePipefail: 'Pipeline sem pipefail - erros no pipe ignorados',
+    unsafePipefailSugestao: 'Adicione "set -o pipefail" para capturar erros em pipes',
+    unsafeCdWithoutCheck: 'cd sem verificação de erro',
+    unsafeCdWithoutCheckSugestao: 'Verifique o código de saída do cd ou use "|| exit"',
+    unsafeTmpFile: 'Uso de /tmp sem nome aleatório',
+    unsafeTmpFileSugestao: 'Use mktemp para arquivos temporários',
+    insecurePermissions: 'Permissões inseguras detectadas (chmod 777 ou umask 000)',
+    insecurePermissionsSugestao: 'Use permissões restritivas (755/644)',
+    dangerousFlags: 'Flags de comando perigosas detectadas (rm -rf /*, chown -R)',
+    dangerousFlagsSugestao: 'Verifique se as flags são intencionais e escopo limitado',
+    unsafeReadWithoutR: 'read sem -r (barras invertidas são interpretadas)',
+    unsafeReadWithoutRSugestao: 'Use "read -r" para preservar barras invertidas',
+    missingLocalVar: 'Variável em função não declarada como local',
+    missingLocalVarSugestao: 'Use a palavra-chave "local" para escopar variáveis',
+    uppercaseLocalVar: 'Variável local nomeada com MAIÚSCULAS',
+    uppercaseLocalVarSugestao: 'Use minúsculas para variáveis locais (convenção)',
+    backtickCmdSub: 'Substituição de comando com crases',
+    backtickCmdSubSugestao: 'Use $(...) em vez de crases',
+    doubleBracketMissing: '[ usado em vez de [[ no Bash',
+    doubleBracketMissingSugestao: 'Use [[ ]] para comparações de string mais seguras',
+    unsafeArithmeticEval: '$(( )) vs let vs expr detectado',
+    unsafeArithmeticEvalSugestao: 'Use $(( )) para aritmética',
+    functionDeclStyle: 'Palavra-chave function usada (não portável)',
+    functionDeclStyleSugestao: 'Use a sintaxe "nome()" para conformidade POSIX',
+    missingDefaultCase: 'Case sem *)',
+    missingDefaultCaseSugestao: 'Adicione o caso padrão *) por segurança',
+    emptyCatchBlock: 'Bloco then/else vazio',
+    emptyCatchBlockSugestao: 'Adicione um comentário ou remova o bloco vazio',
+    bashismDetected: 'Funcionalidade específica do Bash em script #!/bin/sh',
+    bashismDetectedSugestao: 'Use sintaxe compatível com POSIX para scripts sh',
+    platformSpecificPath: 'Caminho específico de plataforma (/usr/bin vs /bin)',
+    platformSpecificPathSugestao: 'Use command -v ou which para descoberta',
+    missingQuoteArrays: 'Expansão de array sem aspas',
+    missingQuoteArraysSugestao: 'Use "${arr[@]}" para preservar espaços',
+    uselessCat: 'cat arquivo | comando em vez de comando < arquivo',
+    uselessCatSugestao: 'Use redirecionamento de entrada em vez de cat com pipe',
+    loopOverCommandOutput: 'for arquivo in $(ls) em vez de for arquivo in *',
+    loopOverCommandOutputSugestao: 'Use padrões glob em vez de analisar ls',
+    pipeOverTempfile: 'Pipeline poderia substituir arquivo temporário',
+    pipeOverTempfileSugestao: 'Use pipes em vez de arquivos temporários',
+};
+//# sourceMappingURL=detector-shell-messages.js.map

package/dist/core/messages/pt/analysts/detector-shell-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-shell-messages.js","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-shell-messages.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,cAAc,EAAE,oBAAoB;IACpC,sBAAsB,EAAE,mCAAmC;IAC3D,WAAW,EAAE,sDAAsD;IACnE,mBAAmB,EAAE,qCAAqC;IAC1D,SAAS,EAAE,iDAAiD;IAC5D,iBAAiB,EAAE,+CAA+C;IAClE,QAAQ,EAAE,yCAAyC;IACnD,gBAAgB,EAAE,oCAAoC;IACtD,UAAU,EAAE,iDAAiD;IAC7D,kBAAkB,EAAE,2CAA2C;IAC/D,iBAAiB,EAAE,kCAAkC;IACrD,yBAAyB,EAAE,2BAA2B;IACtD,gBAAgB,EAAE,4CAA4C;IAC9D,wBAAwB,EAAE,6BAA6B;IACvD,SAAS,EAAE,uBAAuB;IAClC,iBAAiB,EAAE,oCAAoC;IAEvD,cAAc,EAAE,iDAAiD;IACjE,sBAAsB,EAAE,yDAAyD;IACjF,oBAAoB,EAAE,4BAA4B;IAClD,4BAA4B,EAAE,oDAAoD;IAClF,aAAa,EAAE,gCAAgC;IAC/C,qBAAqB,EAAE,sCAAsC;IAC7D,mBAAmB,EAAE,0DAA0D;IAC/E,2BAA2B,EAAE,sCAAsC;IACnE,cAAc,EAAE,6DAA6D;IAC7E,sBAAsB,EAAE,0DAA0D;IAClF,kBAAkB,EAAE,mDAAmD;IACvE,0BAA0B,EAAE,gDAAgD;IAE5E,eAAe,EAAE,6CAA6C;IAC9D,uBAAuB,EAAE,oDAAoD;IAC7E,iBAAiB,EAAE,uCAAuC;IAC1D,yBAAyB,EAAE,kDAAkD;IAC7E,cAAc,EAAE,oCAAoC;IACpD,sBAAsB,EAAE,6BAA6B;IACrD,oBAAoB,EAAE,8BAA8B;IACpD,4BAA4B,EAAE,mDAAmD;IACjF,oBAAoB,EAAE,iCAAiC;IACvD,4BAA4B,EAAE,4BAA4B;IAC1D,iBAAiB,EAAE,6CAA6C;IAChE,yBAAyB,EAAE,gDAAgD;IAC3E,kBAAkB,EAAE,aAAa;IACjC,0BAA0B,EAAE,yCAAyC;IACrE,eAAe,EAAE,uBAAuB;IACxC,uBAAuB,EAAE,gDAAgD;IAEzE,eAAe,EAAE,uDAAuD;IACxE,uBAAuB,EAAE,kDAAkD;IAC3E,oBAAoB,EAAE,qDAAqD;IAC3E,4BAA4B,EAAE,yCAAyC;IACvE,kBAAkB,EAAE,6BAA6B;IACjD,0BAA0B,EAAE,wCAAwC;IAEpE,UAAU,EAAE,mDAAmD;IAC/D,kBAAkB,EAAE,wDAAwD;IAC5E,qBAAqB,EAAE,iDAAiD;IACxE,6BAA6B,EAAE,wCAAwC;IACvE,gBAAgB,EAAE,gDAAgD;IAClE,wBAAwB,EAAE,0CAA0C;CAC5D,CAAC","sourcesContent":["// SPDX-License-Identifier: MIT\n\nexport const DetectorShellMensagens = {\n  missingShebang: 'Script sem shebang',\n  missingShebangSugestao: 'Adicione #!/bin/bash ou #!/bin/sh',\n  missingSetE: 'Script sem \"set -e\" - erros não interrompem execução',\n  missingSetESugestao: 'Adicione set -e no início do script',\n  evalUsage: 'eval() detectado - risco de execução arbitrária',\n  evalUsageSugestao: 'Evite eval - use arrays ou outras construções',\n  rmRfRoot: 'COMANDO EXTREMAMENTE PERIGOSO: rm -rf /',\n  rmRfRootSugestao: 'Remova este comando imediatamente!',\n  curlPipeSh: 'curl/wget piped para shell - risco de segurança',\n  curlPipeShSugestao: 'Baixe, inspecione e execute separadamente',\n  hardcodedPassword: 'Credencial hardcoded em variável',\n  hardcodedPasswordSugestao: 'Use variáveis de ambiente',\n  unquotedVariable: 'Variável sem aspas - problemas com espaços',\n  unquotedVariableSugestao: 'Use \"$VAR\" ao invés de $VAR',\n  sudoUsage: 'Uso de sudo detectado',\n  sudoUsageSugestao: 'Projete scripts que rodem sem root',\n  // Security (enhanced)\n  unsafePipefail: 'Pipeline sem pipefail - erros no pipe ignorados',\n  unsafePipefailSugestao: 'Adicione \"set -o pipefail\" para capturar erros em pipes',\n  unsafeCdWithoutCheck: 'cd sem verificação de erro',\n  unsafeCdWithoutCheckSugestao: 'Verifique o código de saída do cd ou use \"|| exit\"',\n  unsafeTmpFile: 'Uso de /tmp sem nome aleatório',\n  unsafeTmpFileSugestao: 'Use mktemp para arquivos temporários',\n  insecurePermissions: 'Permissões inseguras detectadas (chmod 777 ou umask 000)',\n  insecurePermissionsSugestao: 'Use permissões restritivas (755/644)',\n  dangerousFlags: 'Flags de comando perigosas detectadas (rm -rf /*, chown -R)',\n  dangerousFlagsSugestao: 'Verifique se as flags são intencionais e escopo limitado',\n  unsafeReadWithoutR: 'read sem -r (barras invertidas são interpretadas)',\n  unsafeReadWithoutRSugestao: 'Use \"read -r\" para preservar barras invertidas',\n  // Best Practices\n  missingLocalVar: 'Variável em função não declarada como local',\n  missingLocalVarSugestao: 'Use a palavra-chave \"local\" para escopar variáveis',\n  uppercaseLocalVar: 'Variável local nomeada com MAIÚSCULAS',\n  uppercaseLocalVarSugestao: 'Use minúsculas para variáveis locais (convenção)',\n  backtickCmdSub: 'Substituição de comando com crases',\n  backtickCmdSubSugestao: 'Use $(...) em vez de crases',\n  doubleBracketMissing: '[ usado em vez de [[ no Bash',\n  doubleBracketMissingSugestao: 'Use [[ ]] para comparações de string mais seguras',\n  unsafeArithmeticEval: '$(( )) vs let vs expr detectado',\n  unsafeArithmeticEvalSugestao: 'Use $(( )) para aritmética',\n  functionDeclStyle: 'Palavra-chave function usada (não portável)',\n  functionDeclStyleSugestao: 'Use a sintaxe \"nome()\" para conformidade POSIX',\n  missingDefaultCase: 'Case sem *)',\n  missingDefaultCaseSugestao: 'Adicione o caso padrão *) por segurança',\n  emptyCatchBlock: 'Bloco then/else vazio',\n  emptyCatchBlockSugestao: 'Adicione um comentário ou remova o bloco vazio',\n  // Portability\n  bashismDetected: 'Funcionalidade específica do Bash em script #!/bin/sh',\n  bashismDetectedSugestao: 'Use sintaxe compatível com POSIX para scripts sh',\n  platformSpecificPath: 'Caminho específico de plataforma (/usr/bin vs /bin)',\n  platformSpecificPathSugestao: 'Use command -v ou which para descoberta',\n  missingQuoteArrays: 'Expansão de array sem aspas',\n  missingQuoteArraysSugestao: 'Use \"${arr[@]}\" para preservar espaços',\n  // Performance\n  uselessCat: 'cat arquivo | comando em vez de comando < arquivo',\n  uselessCatSugestao: 'Use redirecionamento de entrada em vez de cat com pipe',\n  loopOverCommandOutput: 'for arquivo in $(ls) em vez de for arquivo in *',\n  loopOverCommandOutputSugestao: 'Use padrões glob em vez de analisar ls',\n  pipeOverTempfile: 'Pipeline poderia substituir arquivo temporário',\n  pipeOverTempfileSugestao: 'Use pipes em vez de arquivos temporários',\n} as const;\n"]}

package/dist/core/messages/pt/analysts/detector-sql-messages.d.ts

@@ -0,0 +1,63 @@
+export declare const DetectorSqlMensagens: {
+    readonly missingWhere: "DELETE/UPDATE sem cláusula WHERE";
+    readonly missingWhereSugestao: "Adicione WHERE para restringir o impacto";
+    readonly selectStar: "SELECT * detectado";
+    readonly selectStarSugestao: "Liste explicitamente as colunas necessárias";
+    readonly hardcodedCredential: "Credencial hardcoded em SQL";
+    readonly hardcodedCredentialSugestao: "Use variáveis de ambiente ou secrets manager";
+    readonly truncate: "TRUNCATE TABLE detectado - operação irreversível";
+    readonly truncateSugestao: "Use DELETE com WHERE se precisar de reversibilidade";
+    readonly missingIfNotExists: "CREATE sem IF NOT EXISTS";
+    readonly missingIfNotExistsSugestao: "Use CREATE ... IF NOT EXISTS para idempotência";
+    readonly varcharWithoutSize: "VARCHAR sem tamanho definido";
+    readonly varcharWithoutSizeSugestao: "Defina tamanho máximo: VARCHAR(255)";
+    readonly sqlInjectionDynamic: "SQL dinâmico com concatenação de strings detectado";
+    readonly sqlInjectionDynamicSugestao: "Use consultas parametrizadas (prepared statements)";
+    readonly dynamicWhere: "Cláusula WHERE construída com concatenação de strings";
+    readonly dynamicWhereSugestao: "Use cláusula WHERE parametrizada";
+    readonly passwordStoring: "Armazenamento de senhas sem função hash detectado";
+    readonly passwordStoringSugestao: "Use bcrypt/argon2 para armazenamento de senhas";
+    readonly sqlWithoutTransaction: "Múltiplas instruções sem transação";
+    readonly sqlWithoutTransactionSugestao: "Encapsule em BEGIN/COMMIT ou use transações da ORM";
+    readonly grantAllPrivileges: "GRANT ALL PRIVILEGES detectado";
+    readonly grantAllPrivilegesSugestao: "Conceda apenas privilégios específicos necessários";
+    readonly unsafeConcatInQuery: "Interpolação de variável em consulta SQL";
+    readonly unsafeConcatInQuerySugestao: "Use consultas parametrizadas";
+    readonly likeWithoutEscape: "Padrão LIKE com entrada do usuário sem ESCAPE";
+    readonly likeWithoutEscapeSugestao: "Adicione cláusula ESCAPE ou sanitize a entrada";
+    readonly orderByInjection: "ORDER BY com nome de coluna dinâmico";
+    readonly orderByInjectionSugestao: "Valide o nome da coluna contra uma whitelist";
+    readonly limitOffsetInjection: "LIMIT/OFFSET com valores dinâmicos";
+    readonly limitOffsetInjectionSugestao: "Converta para inteiro ou use consulta parametrizada";
+    readonly noIndexColumns: "Colunas em WHERE sem índice (heurística)";
+    readonly noIndexColumnsSugestao: "Considere adicionar índices";
+    readonly functionOnColumn: "Função aplicada à coluna no WHERE (impede uso de índice)";
+    readonly functionOnColumnSugestao: "Evite encapsular colunas em funções no WHERE";
+    readonly selectNPlusOne: "Possível padrão N+1 de consulta";
+    readonly selectNPlusOneSugestao: "Use JOIN ou eager loading";
+    readonly joinWithoutIndex: "Coluna de JOIN sem índice";
+    readonly joinWithoutIndexSugestao: "Garanta que as colunas de JOIN sejam indexadas";
+    readonly notInSubquery: "NOT IN com subconsulta (lento)";
+    readonly notInSubquerySugestao: "Use NOT EXISTS em vez de NOT IN";
+    readonly orWithMultipleConditions: "Múltiplas condições OR (pode não usar índice)";
+    readonly orWithMultipleConditionsSugestao: "Considere UNION ou refatore a consulta";
+    readonly missingNotNull: "Coluna sem restrição NOT NULL";
+    readonly missingNotNullSugestao: "Adicione NOT NULL se aplicável";
+    readonly missingDefault: "Coluna com NULL default poderia ter default explícito";
+    readonly missingDefaultSugestao: "Defina um valor DEFAULT explícito";
+    readonly autoIncrementWithoutPK: "AUTO_INCREMENT não usado como chave primária";
+    readonly autoIncrementWithoutPKSugestao: "Garanta que AUTO_INCREMENT seja PRIMARY KEY";
+    readonly textInsteadOfVarchar: "TEXT usado onde VARCHAR seria suficiente";
+    readonly textInsteadOfVarcharSugestao: "Use VARCHAR(n) com limite explícito";
+    readonly missingUniqueConstraint: "Colunas que parecem identificadores únicos sem UNIQUE";
+    readonly missingUniqueConstraintSugestao: "Adicione restrição UNIQUE";
+    readonly floatForCurrency: "FLOAT usado para valores monetários";
+    readonly floatForCurrencySugestao: "Use DECIMAL para valores monetários precisos";
+    readonly missingForeignKey: "Possível relação sem chave estrangeira";
+    readonly missingForeignKeySugestao: "Adicione restrição FOREIGN KEY";
+    readonly eagerLoadingMissing: "Carregamento lazy em loop (N+1)";
+    readonly eagerLoadingMissingSugestao: "Use .with_() ou .include() para eager loading";
+    readonly transactionTooLarge: "Transação única com muitas operações";
+    readonly transactionTooLargeSugestao: "Divida operações em transações menores";
+};
+//# sourceMappingURL=detector-sql-messages.d.ts.map

package/dist/core/messages/pt/analysts/detector-sql-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-sql-messages.d.ts","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-sql-messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEvB,CAAC"}

package/dist/core/messages/pt/analysts/detector-sql-messages.js

@@ -0,0 +1,63 @@
+export const DetectorSqlMensagens = {
+    missingWhere: 'DELETE/UPDATE sem cláusula WHERE',
+    missingWhereSugestao: 'Adicione WHERE para restringir o impacto',
+    selectStar: 'SELECT * detectado',
+    selectStarSugestao: 'Liste explicitamente as colunas necessárias',
+    hardcodedCredential: 'Credencial hardcoded em SQL',
+    hardcodedCredentialSugestao: 'Use variáveis de ambiente ou secrets manager',
+    truncate: 'TRUNCATE TABLE detectado - operação irreversível',
+    truncateSugestao: 'Use DELETE com WHERE se precisar de reversibilidade',
+    missingIfNotExists: 'CREATE sem IF NOT EXISTS',
+    missingIfNotExistsSugestao: 'Use CREATE ... IF NOT EXISTS para idempotência',
+    varcharWithoutSize: 'VARCHAR sem tamanho definido',
+    varcharWithoutSizeSugestao: 'Defina tamanho máximo: VARCHAR(255)',
+    sqlInjectionDynamic: 'SQL dinâmico com concatenação de strings detectado',
+    sqlInjectionDynamicSugestao: 'Use consultas parametrizadas (prepared statements)',
+    dynamicWhere: 'Cláusula WHERE construída com concatenação de strings',
+    dynamicWhereSugestao: 'Use cláusula WHERE parametrizada',
+    passwordStoring: 'Armazenamento de senhas sem função hash detectado',
+    passwordStoringSugestao: 'Use bcrypt/argon2 para armazenamento de senhas',
+    sqlWithoutTransaction: 'Múltiplas instruções sem transação',
+    sqlWithoutTransactionSugestao: 'Encapsule em BEGIN/COMMIT ou use transações da ORM',
+    grantAllPrivileges: 'GRANT ALL PRIVILEGES detectado',
+    grantAllPrivilegesSugestao: 'Conceda apenas privilégios específicos necessários',
+    unsafeConcatInQuery: 'Interpolação de variável em consulta SQL',
+    unsafeConcatInQuerySugestao: 'Use consultas parametrizadas',
+    likeWithoutEscape: 'Padrão LIKE com entrada do usuário sem ESCAPE',
+    likeWithoutEscapeSugestao: 'Adicione cláusula ESCAPE ou sanitize a entrada',
+    orderByInjection: 'ORDER BY com nome de coluna dinâmico',
+    orderByInjectionSugestao: 'Valide o nome da coluna contra uma whitelist',
+    limitOffsetInjection: 'LIMIT/OFFSET com valores dinâmicos',
+    limitOffsetInjectionSugestao: 'Converta para inteiro ou use consulta parametrizada',
+    noIndexColumns: 'Colunas em WHERE sem índice (heurística)',
+    noIndexColumnsSugestao: 'Considere adicionar índices',
+    functionOnColumn: 'Função aplicada à coluna no WHERE (impede uso de índice)',
+    functionOnColumnSugestao: 'Evite encapsular colunas em funções no WHERE',
+    selectNPlusOne: 'Possível padrão N+1 de consulta',
+    selectNPlusOneSugestao: 'Use JOIN ou eager loading',
+    joinWithoutIndex: 'Coluna de JOIN sem índice',
+    joinWithoutIndexSugestao: 'Garanta que as colunas de JOIN sejam indexadas',
+    notInSubquery: 'NOT IN com subconsulta (lento)',
+    notInSubquerySugestao: 'Use NOT EXISTS em vez de NOT IN',
+    orWithMultipleConditions: 'Múltiplas condições OR (pode não usar índice)',
+    orWithMultipleConditionsSugestao: 'Considere UNION ou refatore a consulta',
+    missingNotNull: 'Coluna sem restrição NOT NULL',
+    missingNotNullSugestao: 'Adicione NOT NULL se aplicável',
+    missingDefault: 'Coluna com NULL default poderia ter default explícito',
+    missingDefaultSugestao: 'Defina um valor DEFAULT explícito',
+    autoIncrementWithoutPK: 'AUTO_INCREMENT não usado como chave primária',
+    autoIncrementWithoutPKSugestao: 'Garanta que AUTO_INCREMENT seja PRIMARY KEY',
+    textInsteadOfVarchar: 'TEXT usado onde VARCHAR seria suficiente',
+    textInsteadOfVarcharSugestao: 'Use VARCHAR(n) com limite explícito',
+    missingUniqueConstraint: 'Colunas que parecem identificadores únicos sem UNIQUE',
+    missingUniqueConstraintSugestao: 'Adicione restrição UNIQUE',
+    floatForCurrency: 'FLOAT usado para valores monetários',
+    floatForCurrencySugestao: 'Use DECIMAL para valores monetários precisos',
+    missingForeignKey: 'Possível relação sem chave estrangeira',
+    missingForeignKeySugestao: 'Adicione restrição FOREIGN KEY',
+    eagerLoadingMissing: 'Carregamento lazy em loop (N+1)',
+    eagerLoadingMissingSugestao: 'Use .with_() ou .include() para eager loading',
+    transactionTooLarge: 'Transação única com muitas operações',
+    transactionTooLargeSugestao: 'Divida operações em transações menores',
+};
+//# sourceMappingURL=detector-sql-messages.js.map

package/dist/core/messages/pt/analysts/detector-sql-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-sql-messages.js","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-sql-messages.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAElC,YAAY,EAAE,kCAAkC;IAChD,oBAAoB,EAAE,0CAA0C;IAChE,UAAU,EAAE,oBAAoB;IAChC,kBAAkB,EAAE,6CAA6C;IACjE,mBAAmB,EAAE,6BAA6B;IAClD,2BAA2B,EAAE,8CAA8C;IAC3E,QAAQ,EAAE,kDAAkD;IAC5D,gBAAgB,EAAE,qDAAqD;IACvE,kBAAkB,EAAE,0BAA0B;IAC9C,0BAA0B,EAAE,gDAAgD;IAC5E,kBAAkB,EAAE,8BAA8B;IAClD,0BAA0B,EAAE,qCAAqC;IAGjE,mBAAmB,EAAE,oDAAoD;IACzE,2BAA2B,EAAE,oDAAoD;IACjF,YAAY,EAAE,uDAAuD;IACrE,oBAAoB,EAAE,kCAAkC;IACxD,eAAe,EAAE,mDAAmD;IACpE,uBAAuB,EAAE,gDAAgD;IACzE,qBAAqB,EAAE,oCAAoC;IAC3D,6BAA6B,EAAE,oDAAoD;IACnF,kBAAkB,EAAE,gCAAgC;IACpD,0BAA0B,EAAE,oDAAoD;IAGhF,mBAAmB,EAAE,0CAA0C;IAC/D,2BAA2B,EAAE,8BAA8B;IAC3D,iBAAiB,EAAE,+CAA+C;IAClE,yBAAyB,EAAE,gDAAgD;IAC3E,gBAAgB,EAAE,sCAAsC;IACxD,wBAAwB,EAAE,8CAA8C;IACxE,oBAAoB,EAAE,oCAAoC;IAC1D,4BAA4B,EAAE,qDAAqD;IAGnF,cAAc,EAAE,0CAA0C;IAC1D,sBAAsB,EAAE,6BAA6B;IACrD,gBAAgB,EAAE,0DAA0D;IAC5E,wBAAwB,EAAE,8CAA8C;IACxE,cAAc,EAAE,iCAAiC;IACjD,sBAAsB,EAAE,2BAA2B;IACnD,gBAAgB,EAAE,2BAA2B;IAC7C,wBAAwB,EAAE,gDAAgD;IAC1E,aAAa,EAAE,gCAAgC;IAC/C,qBAAqB,EAAE,iCAAiC;IACxD,wBAAwB,EAAE,+CAA+C;IACzE,gCAAgC,EAAE,wCAAwC;IAG1E,cAAc,EAAE,+BAA+B;IAC/C,sBAAsB,EAAE,gCAAgC;IACxD,cAAc,EAAE,uDAAuD;IACvE,sBAAsB,EAAE,mCAAmC;IAC3D,sBAAsB,EAAE,8CAA8C;IACtE,8BAA8B,EAAE,6CAA6C;IAC7E,oBAAoB,EAAE,0CAA0C;IAChE,4BAA4B,EAAE,qCAAqC;IACnE,uBAAuB,EAAE,uDAAuD;IAChF,+BAA+B,EAAE,2BAA2B;IAC5D,gBAAgB,EAAE,qCAAqC;IACvD,wBAAwB,EAAE,8CAA8C;IACxE,iBAAiB,EAAE,wCAAwC;IAC3D,yBAAyB,EAAE,gCAAgC;IAG3D,mBAAmB,EAAE,iCAAiC;IACtD,2BAA2B,EAAE,+CAA+C;IAC5E,mBAAmB,EAAE,sCAAsC;IAC3D,2BAA2B,EAAE,wCAAwC;CAC7D,CAAC","sourcesContent":["// SPDX-License-Identifier: MIT\n\nexport const DetectorSqlMensagens = {\n  // ── Existentes ────────────────────────────────────────────────────────────\n  missingWhere: 'DELETE/UPDATE sem cláusula WHERE',\n  missingWhereSugestao: 'Adicione WHERE para restringir o impacto',\n  selectStar: 'SELECT * detectado',\n  selectStarSugestao: 'Liste explicitamente as colunas necessárias',\n  hardcodedCredential: 'Credencial hardcoded em SQL',\n  hardcodedCredentialSugestao: 'Use variáveis de ambiente ou secrets manager',\n  truncate: 'TRUNCATE TABLE detectado - operação irreversível',\n  truncateSugestao: 'Use DELETE com WHERE se precisar de reversibilidade',\n  missingIfNotExists: 'CREATE sem IF NOT EXISTS',\n  missingIfNotExistsSugestao: 'Use CREATE ... IF NOT EXISTS para idempotência',\n  varcharWithoutSize: 'VARCHAR sem tamanho definido',\n  varcharWithoutSizeSugestao: 'Defina tamanho máximo: VARCHAR(255)',\n\n  // ── Security ──────────────────────────────────────────────────────────────\n  sqlInjectionDynamic: 'SQL dinâmico com concatenação de strings detectado',\n  sqlInjectionDynamicSugestao: 'Use consultas parametrizadas (prepared statements)',\n  dynamicWhere: 'Cláusula WHERE construída com concatenação de strings',\n  dynamicWhereSugestao: 'Use cláusula WHERE parametrizada',\n  passwordStoring: 'Armazenamento de senhas sem função hash detectado',\n  passwordStoringSugestao: 'Use bcrypt/argon2 para armazenamento de senhas',\n  sqlWithoutTransaction: 'Múltiplas instruções sem transação',\n  sqlWithoutTransactionSugestao: 'Encapsule em BEGIN/COMMIT ou use transações da ORM',\n  grantAllPrivileges: 'GRANT ALL PRIVILEGES detectado',\n  grantAllPrivilegesSugestao: 'Conceda apenas privilégios específicos necessários',\n\n  // ── Injection Patterns ────────────────────────────────────────────────────\n  unsafeConcatInQuery: 'Interpolação de variável em consulta SQL',\n  unsafeConcatInQuerySugestao: 'Use consultas parametrizadas',\n  likeWithoutEscape: 'Padrão LIKE com entrada do usuário sem ESCAPE',\n  likeWithoutEscapeSugestao: 'Adicione cláusula ESCAPE ou sanitize a entrada',\n  orderByInjection: 'ORDER BY com nome de coluna dinâmico',\n  orderByInjectionSugestao: 'Valide o nome da coluna contra uma whitelist',\n  limitOffsetInjection: 'LIMIT/OFFSET com valores dinâmicos',\n  limitOffsetInjectionSugestao: 'Converta para inteiro ou use consulta parametrizada',\n\n  // ── Performance ───────────────────────────────────────────────────────────\n  noIndexColumns: 'Colunas em WHERE sem índice (heurística)',\n  noIndexColumnsSugestao: 'Considere adicionar índices',\n  functionOnColumn: 'Função aplicada à coluna no WHERE (impede uso de índice)',\n  functionOnColumnSugestao: 'Evite encapsular colunas em funções no WHERE',\n  selectNPlusOne: 'Possível padrão N+1 de consulta',\n  selectNPlusOneSugestao: 'Use JOIN ou eager loading',\n  joinWithoutIndex: 'Coluna de JOIN sem índice',\n  joinWithoutIndexSugestao: 'Garanta que as colunas de JOIN sejam indexadas',\n  notInSubquery: 'NOT IN com subconsulta (lento)',\n  notInSubquerySugestao: 'Use NOT EXISTS em vez de NOT IN',\n  orWithMultipleConditions: 'Múltiplas condições OR (pode não usar índice)',\n  orWithMultipleConditionsSugestao: 'Considere UNION ou refatore a consulta',\n\n  // ── Best Practices ────────────────────────────────────────────────────────\n  missingNotNull: 'Coluna sem restrição NOT NULL',\n  missingNotNullSugestao: 'Adicione NOT NULL se aplicável',\n  missingDefault: 'Coluna com NULL default poderia ter default explícito',\n  missingDefaultSugestao: 'Defina um valor DEFAULT explícito',\n  autoIncrementWithoutPK: 'AUTO_INCREMENT não usado como chave primária',\n  autoIncrementWithoutPKSugestao: 'Garanta que AUTO_INCREMENT seja PRIMARY KEY',\n  textInsteadOfVarchar: 'TEXT usado onde VARCHAR seria suficiente',\n  textInsteadOfVarcharSugestao: 'Use VARCHAR(n) com limite explícito',\n  missingUniqueConstraint: 'Colunas que parecem identificadores únicos sem UNIQUE',\n  missingUniqueConstraintSugestao: 'Adicione restrição UNIQUE',\n  floatForCurrency: 'FLOAT usado para valores monetários',\n  floatForCurrencySugestao: 'Use DECIMAL para valores monetários precisos',\n  missingForeignKey: 'Possível relação sem chave estrangeira',\n  missingForeignKeySugestao: 'Adicione restrição FOREIGN KEY',\n\n  // ── ORM-specific ──────────────────────────────────────────────────────────\n  eagerLoadingMissing: 'Carregamento lazy em loop (N+1)',\n  eagerLoadingMissingSugestao: 'Use .with_() ou .include() para eager loading',\n  transactionTooLarge: 'Transação única com muitas operações',\n  transactionTooLargeSugestao: 'Divida operações em transações menores',\n} as const;\n"]}

package/dist/core/messages/pt/analysts/detector-structure-messages.d.ts

@@ -0,0 +1,21 @@
+type EntrypointsAgrupadosArgs = {
+    previewGrupos: string;
+    sufixoOcultos?: string;
+};
+export declare const DetectorEstruturaMensagens: {
+    readonly monorepoDetectado: "Estrutura de monorepo detectada.";
+    readonly monorepoSemPackages: "Monorepo sem pasta packages/.";
+    readonly fullstackDetectado: "Estrutura fullstack detectada.";
+    readonly pagesSemApi: "Projeto possui pages/ mas não possui api/.";
+    readonly estruturaMista: "Projeto possui src/ e packages/ (monorepo) ao mesmo tempo. Avalie a organização.";
+    readonly muitosArquivosRaiz: "Muitos arquivos na raiz do projeto. Considere organizar em pastas.";
+    readonly sinaisBackend: "Sinais de backend detectados (controllers/, prisma/, api/).";
+    readonly sinaisFrontend: "Sinais de frontend detectados (components/, pages/).";
+    readonly projetoGrandeSemSrc: "Projeto grande sem pasta src/. Considere organizar o código fonte.";
+    readonly arquivosConfigDetectados: (detectados: string[]) => string;
+    readonly multiplosEntrypointsAgrupados: ({ previewGrupos, sufixoOcultos }: EntrypointsAgrupadosArgs) => string;
+    readonly multiplosEntrypointsLista: (preview: string[], resto: number) => string;
+    readonly nomeDiretorioNaoConforme: (atual: string, esperado: string) => string;
+};
+export {};
+//# sourceMappingURL=detector-structure-messages.d.ts.map

package/dist/core/messages/pt/analysts/detector-structure-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-structure-messages.d.ts","sourceRoot":"","sources":["../../../../../src/core/messages/pt/analysts/detector-structure-messages.ts"],"names":[],"mappings":"AASA,KAAK,wBAAwB,GAAG;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,eAAO,MAAM,0BAA0B;;;;;;;;;;oDAUE,MAAM,EAAE;+EAI5C,wBAAwB;kDACU,MAAM,EAAE,SAAS,MAAM;+CAC1B,MAAM,YAAY,MAAM;CAClD,CAAC"}