@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/analysts/js-ts/detectors/detector-constructions-syntactic.js

@@ -26,23 +26,24 @@ export const analistaConstrucoesSintaticas = {
                     const kind = path.node.kind;
                     incrementarContagem(construcoes, kind);
                     for (const declarator of path.node.declarations) {
-                        if (declarator.id?.type === 'Identifier') {
+                        if (declarator.id.type === 'Identifier') {
                             detalhes.push({
                                 tipo: kind,
                                 nome: declarator.id.name,
                                 contexto: extrairContexto(path),
-                                linha: path.node.loc?.start.line || 1,
-                                coluna: path.node.loc?.start.column || 0,
-                                codigo: src.slice(path.node.start || 0, path.node.end || 0)
+                                linha: path.node.loc?.start.line ?? 1,
+                                coluna: path.node.loc?.start.column ?? 0,
+                                codigo: src.slice(path.node.start ?? 0, path.node.end ?? 0)
                             });
                         }
                     }
+                    // Destructuring without defaults
                     for (const declarator of path.node.declarations) {
-                        if (declarator.id && textoTitulo.isObjectPattern(declarator.id)) {
+                        if (textoTitulo.isObjectPattern(declarator.id)) {
                             for (const prop of declarator.id.properties) {
-                                if (textoTitulo.isObjectProperty(prop) && prop.value && textoTitulo.isIdentifier(prop.value) && !prop.value.typeAnnotation) {
+                                if (textoTitulo.isObjectProperty(prop) && textoTitulo.isIdentifier(prop.value) && !prop.value.typeAnnotation) {
                                     if (!prop.value.optional) {
-                                        pushExtra('destructuring-without-default', 'info', messages.DetectorConstrucoesSintaticasMensagens.destructuringWithoutDefault, path.node.loc?.start.line || 1);
+                                        pushExtra('destructuring-without-default', 'info', messages.DetectorConstrucoesSintaticasMensagens.destructuringWithoutDefault, path.node.loc?.start.line ?? 1);
                                     }
                                 }
                             }
@@ -53,11 +54,11 @@ export const analistaConstrucoesSintaticas = {
                     incrementarContagem(construcoes, 'function');
                     detalhes.push({
                         tipo: 'function',
-                        nome: path.node.id?.name || 'anonymous',
+                        nome: path.node.id?.name ?? 'anonymous',
                         contexto: path.node.async ? 'async' : 'sync',
-                        linha: path.node.loc?.start.line || 1,
-                        coluna: path.node.loc?.start.column || 0,
-                        codigo: src.slice(path.node.start || 0, path.node.end || 0)
+                        linha: path.node.loc?.start.line ?? 1,
+                        coluna: path.node.loc?.start.column ?? 0,
+                        codigo: src.slice(path.node.start ?? 0, path.node.end ?? 0)
                     });
                     if (path.node.async) {
                         incrementarContagem(construcoes, 'async');
@@ -68,9 +69,9 @@ export const analistaConstrucoesSintaticas = {
                     detalhes.push({
                         tipo: 'arrow',
                         contexto: path.node.async ? 'async' : 'sync',
-                        linha: path.node.loc?.start.line || 1,
-                        coluna: path.node.loc?.start.column || 0,
-                        codigo: src.slice(path.node.start || 0, path.node.end || 0)
+                        linha: path.node.loc?.start.line ?? 1,
+                        coluna: path.node.loc?.start.column ?? 0,
+                        codigo: src.slice(path.node.start ?? 0, path.node.end ?? 0)
                     });
                     if (path.node.async) {
                         incrementarContagem(construcoes, 'async');
@@ -83,10 +84,10 @@ export const analistaConstrucoesSintaticas = {
                     incrementarContagem(construcoes, 'class');
                     detalhes.push({
                         tipo: 'class',
-                        nome: path.node.id?.name || 'anonymous',
-                        linha: path.node.loc?.start.line || 1,
-                        coluna: path.node.loc?.start.column || 0,
-                        codigo: src.slice(path.node.start || 0, path.node.end || 0)
+                        nome: path.node.id?.name ?? 'anonymous',
+                        linha: path.node.loc?.start.line ?? 1,
+                        coluna: path.node.loc?.start.column ?? 0,
+                        codigo: src.slice(path.node.start ?? 0, path.node.end ?? 0)
                     });
                 },
                 ImportDeclaration(path) {
@@ -95,9 +96,9 @@ export const analistaConstrucoesSintaticas = {
                         tipo: 'import',
                         nome: path.node.source.value,
                         contexto: `${path.node.specifiers.length.toString()} imports`,
-                        linha: path.node.loc?.start.line || 1,
-                        coluna: path.node.loc?.start.column || 0,
-                        codigo: src.slice(path.node.start || 0, path.node.end || 0)
+                        linha: path.node.loc?.start.line ?? 1,
+                        coluna: path.node.loc?.start.column ?? 0,
+                        codigo: src.slice(path.node.start ?? 0, path.node.end ?? 0)
                     });
                 },
                 ExportNamedDeclaration() {
@@ -116,9 +117,9 @@ export const analistaConstrucoesSintaticas = {
                     detalhes.push({
                         tipo: 'interface',
                         nome: path.node.id.name,
-                        linha: path.node.loc?.start.line || 1,
-                        coluna: path.node.loc?.start.column || 0,
-                        codigo: src.slice(path.node.start || 0, path.node.end || 0)
+                        linha: path.node.loc?.start.line ?? 1,
+                        coluna: path.node.loc?.start.column ?? 0,
+                        codigo: src.slice(path.node.start ?? 0, path.node.end ?? 0)
                     });
                 },
                 TSTypeAliasDeclaration(path) {
@@ -126,9 +127,9 @@ export const analistaConstrucoesSintaticas = {
                     detalhes.push({
                         tipo: 'type',
                         nome: path.node.id.name,
-                        linha: path.node.loc?.start.line || 1,
-                        coluna: path.node.loc?.start.column || 0,
-                        codigo: src.slice(path.node.start || 0, path.node.end || 0)
+                        linha: path.node.loc?.start.line ?? 1,
+                        coluna: path.node.loc?.start.column ?? 0,
+                        codigo: src.slice(path.node.start ?? 0, path.node.end ?? 0)
                     });
                 },
                 TSEnumDeclaration(path) {
@@ -136,53 +137,61 @@ export const analistaConstrucoesSintaticas = {
                     detalhes.push({
                         tipo: 'enum',
                         nome: path.node.id.name,
-                        linha: path.node.loc?.start.line || 1,
-                        coluna: path.node.loc?.start.column || 0,
-                        codigo: src.slice(path.node.start || 0, path.node.end || 0)
+                        linha: path.node.loc?.start.line ?? 1,
+                        coluna: path.node.loc?.start.column ?? 0,
+                        codigo: src.slice(path.node.start ?? 0, path.node.end ?? 0)
                     });
                 },
                 LogicalExpression(path) {
+                    // Nullish coalescing vs OR misuse: detecting if (x || defaultValue) where x could be '' or 0
                     if (path.node.operator === '||') {
                         const left = path.node.left;
-                        if (left && (textoTitulo.isMemberExpression(left) || textoTitulo.isIdentifier(left))) {
+                        if (textoTitulo.isMemberExpression(left) || textoTitulo.isIdentifier(left)) {
                             const right = path.node.right;
-                            if (right && (textoTitulo.isStringLiteral(right) || textoTitulo.isNumericLiteral(right))) {
-                                pushExtra('nullish-vs-or', 'info', messages.DetectorConstrucoesSintaticasMensagens.nullishVsOrMisuse, path.node.loc?.start.line || 1);
+                            if (textoTitulo.isStringLiteral(right) || textoTitulo.isNumericLiteral(right)) {
+                                pushExtra('nullish-vs-or', 'info', messages.DetectorConstrucoesSintaticasMensagens.nullishVsOrMisuse, path.node.loc?.start.line ?? 1);
                             }
                         }
                     }
                 },
+                // ES2025: Promise.withResolvers
+                // ES2025: RegExp.escape
+                // ES2026: Error.isError
+                // ES2026: Array.fromAsync
                 OptionalMemberExpression(path) {
-                    if (path.node.optional) {
+                    // Optional chaining where not needed: obj?.prop where obj is always defined
+                    if ('optional' in path.node && path.node.optional) {
                         const obj = path.node.object;
                         if (textoTitulo.isIdentifier(obj)) {
                             const binding = path.scope.getBinding(obj.name);
-                            if (binding && binding.path.isVariableDeclarator()) {
+                            if (binding?.path.isVariableDeclarator()) {
                                 const init = binding.path.node.init;
                                 if (init && (textoTitulo.isObjectExpression(init) || textoTitulo.isNewExpression(init))) {
-                                    pushExtra('optional-chaining-unneeded', 'info', messages.DetectorConstrucoesSintaticasMensagens.optionalChainingNotNeeded, path.node.loc?.start.line || 1);
+                                    pushExtra('optional-chaining-unneeded', 'info', messages.DetectorConstrucoesSintaticasMensagens.optionalChainingNotNeeded, path.node.loc?.start.line ?? 1);
                                 }
                             }
                         }
                     }
                 },
                 SpreadElement(path) {
+                    // Unnecessary object spread: {...obj, prop: val} could be obj.prop = val
                     const parent = path.parentPath;
-                    if (parent && textoTitulo.isObjectExpression(parent.node)) {
+                    if (textoTitulo.isObjectExpression(parent.node)) {
                         const arg = path.node.argument;
                         if (textoTitulo.isIdentifier(arg) && parent.node.properties.length >= 2) {
                             const otherSpread = parent.node.properties.filter(p => textoTitulo.isSpreadElement(p) && p !== path.node);
                             const hasProperty = parent.node.properties.some(p => textoTitulo.isObjectProperty(p));
                             if (otherSpread.length === 0 && hasProperty) {
-                                pushExtra('unnecessary-object-spread', 'info', messages.DetectorConstrucoesSintaticasMensagens.unnecessaryObjectSpread, path.node.loc?.start.line || 1);
+                                pushExtra('unnecessary-object-spread', 'info', messages.DetectorConstrucoesSintaticasMensagens.unnecessaryObjectSpread, path.node.loc?.start.line ?? 1);
                             }
                         }
                     }
                 },
                 ClassMethod(path) {
+                    // Getter/setter without validation
                     if (path.node.kind === 'set') {
                         const body = path.node.body;
-                        if (body && textoTitulo.isBlockStatement(body)) {
+                        if (textoTitulo.isBlockStatement(body)) {
                             let hasValidation = false;
                             for (const stmt of body.body) {
                                 if (textoTitulo.isIfStatement(stmt)) {
@@ -191,20 +200,47 @@ export const analistaConstrucoesSintaticas = {
                                 }
                             }
                             if (!hasValidation) {
-                                pushExtra('getter-setter-no-validation', 'info', messages.DetectorConstrucoesSintaticasMensagens.getterSetterWithoutValidation, path.node.loc?.start.line || 1);
+                                pushExtra('getter-setter-no-validation', 'info', messages.DetectorConstrucoesSintaticasMensagens.getterSetterWithoutValidation, path.node.loc?.start.line ?? 1);
                             }
                         }
                     }
                 }
             });
+            // Text-based detection for ES2025/ES2026 patterns
+            const esPatterns = [
+                [/\busing\s+\w+\s*=\s*new\s+/g, 'explicit-resource-management', (linha) => pushExtra('explicit-resource-management', 'info', 'Explicit Resource Management with "using" (ES2026)', linha)],
+                [/\bawait\s+using\s+/g, 'explicit-resource-management-async', (linha) => pushExtra('explicit-resource-management-async', 'info', 'Async Resource Management with "await using" (ES2026)', linha)],
+                [/\bTemporal\.\w+/g, 'temporal-api-usage', (linha) => pushExtra('temporal-api-usage', 'info', 'Temporal API usage (ES2026)', linha)],
+                [/Promise\.withResolvers\s*\(/g, 'promise-with-resolvers', (linha) => pushExtra('promise-with-resolvers', 'info', 'Promise.withResolvers() (ES2025)', linha)],
+                [/Promise\.try\s*\(/g, 'promise-try', (linha) => pushExtra('promise-try', 'info', 'Promise.try() (ES2025)', linha)],
+                [/RegExp\.escape\s*\(/g, 'regexp-escape', (linha) => pushExtra('regexp-escape', 'info', 'RegExp.escape() (ES2025)', linha)],
+                [/Error\.isError\s*\(/g, 'error-is-error', (linha) => pushExtra('error-is-error', 'info', 'Error.isError() (ES2026)', linha)],
+                [/Array\.fromAsync\s*\(/g, 'array-from-async', (linha) => pushExtra('array-from-async', 'info', 'Array.fromAsync() (ES2026)', linha)],
+                [/\bIterator\.from\s*\(/g, 'iterator-from', (linha) => pushExtra('iterator-from', 'info', 'Iterator.from() (ES2025)', linha)],
+            ];
+            for (const [pattern, , fn] of esPatterns) {
+                let m;
+                while ((m = pattern.exec(src)) !== null) {
+                    const position = m.index;
+                    if (position == null) {
+                        continue;
+                    }
+                    if (!isInStringOrComment(src, position)) {
+                        const linha = src.substring(0, position).split('\n').length;
+                        fn(linha);
+                    }
+                }
+            }
+            // Template literal overuse detection via text fallback
             const templateLiteralPadrao = /`([^`]{0,10})`/g;
             let match;
             while ((match = templateLiteralPadrao.exec(src)) !== null) {
                 const content = match[1];
                 if (content && !content.includes('${') && content.length < 10) {
                     const position = match.index;
-                    if (position == null)
+                    if (position == null) {
                         continue;
+                    }
                     if (!isInStringOrComment(src, position)) {
                         const linha = src.substring(0, position).split('\n').length;
                         pushExtra('template-literal-overuse', 'info', messages.DetectorConstrucoesSintaticasMensagens.templateLiteralOveruse, linha);
@@ -228,36 +264,45 @@ export const analistaConstrucoesSintaticas = {
     }
 };
 function incrementarContagem(map, key) {
-    map.set(key, (map.get(key) || 0) + 1);
+    map.set(key, (map.get(key) ?? 0) + 1);
 }
 function extrairContexto(path) {
-    if (path.isProgram())
+    if (path.isProgram()) {
         return 'global';
-    if (path.getFunctionParent())
+    }
+    if (path.getFunctionParent()) {
         return 'function';
-    if (path.getStatementParent()?.isBlockStatement())
+    }
+    if (path.getStatementParent().isBlockStatement()) {
         return 'block';
+    }
     return 'other';
 }
 function isInStringOrComment(src, position) {
+    // Check if position is inside a string or comment
     const before = src.substring(0, position);
     const lines = before.split('\n');
     const lastLine = lines[lines.length - 1];
+    // Check single-line comments
     if (lastLine.includes('//')) {
         const commentIdx = lastLine.indexOf('//');
         const quoteIdx = Math.max(lastLine.lastIndexOf("'"), lastLine.lastIndexOf('"'), lastLine.lastIndexOf('`'));
-        if (commentIdx > quoteIdx)
+        if (commentIdx > quoteIdx) {
             return true;
+        }
     }
+    // Check multi-line comments
     const openComment = before.lastIndexOf('/*');
     const closeComment = before.lastIndexOf('*/');
-    if (openComment > closeComment)
+    if (openComment > closeComment) {
         return true;
-    const singleQuotes = (before.match(/'/g) || []).length;
-    const doubleQuotes = (before.match(/"/g) || []).length;
-    const backticks = (before.match(/`/g) || []).length;
-    if (singleQuotes % 2 !== 0 || doubleQuotes % 2 !== 0 || backticks % 2 !== 0)
+    }
+    // Simple string check (not comprehensive but good enough)
+    const singleQuotes = (before.match(/'/g) ?? []).length;
+    const doubleQuotes = (before.match(/"/g) ?? []).length;
+    const backticks = (before.match(/`/g) ?? []).length;
+    if (singleQuotes % 2 !== 0 || doubleQuotes % 2 !== 0 || backticks % 2 !== 0) {
         return true;
+    }
     return false;
 }
-//# sourceMappingURL=detector-constructions-syntactic.js.map

package/dist/analysts/js-ts/detectors/detector-context-smart.js

@@ -1,6 +1,20 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Sistema Inteligente de Detecção de Arquétipos por Contexto
+ *
+ * Combina múltiplas evidências para inferir corretamente o tipo de projeto:
+ * - Análise de dependências (package.json)
+ * - Padrões de código (imports, exports, funcionalidades)
+ * - Estrutura de arquivos e nomenclatura
+ * - Configurações específicas de tecnologia
+ * - Contexto de execução e entry points
+ */
 import { config, traverse } from '../../../core/config/index.js';
 import { getMessages } from '../../../core/messages/index.js';
 const { DetectorContextoExtraMensagens } = getMessages();
+/**
+ * Padrões específicos de detecção por tecnologia
+ */
 const PADROES_TECNOLOGIA = {
     'discord-bot': {
         dependencias: ['discord.js', '@discordjs/builders', '@discordjs/rest'],
@@ -10,10 +24,14 @@ const PADROES_TECNOLOGIA = {
         configs: ['bot.js', 'bot.ts', 'config/bot'],
         scripts: ['start:bot', 'dev:bot'],
         codigoPatterns: [/Client\(\s*\{[\s\S]*intents/i, /\.login\s*\(\s*process\.env/i, /interaction\.reply/i, /message\.reply/i],
+        // Sinais que indicam que NÃO é um bot Discord (é uma CLI)
         antiPatterns: [/new\s+Command\(/i,
+            // Commander.js
             /program\.parse/i,
+            // CLI parsing
             /\.option\s*\(/i,
-            /bin\/index\.(js|ts)/i
+            // CLI options
+            /bin\/index\.(js|ts)/i // Binary entry point
         ]
     },
     'telegram-bot': {
@@ -24,6 +42,7 @@ const PADROES_TECNOLOGIA = {
         configs: ['bot.js', 'bot.ts'],
         scripts: ['start:bot'],
         codigoPatterns: [/new\s+Telegraf/i, /bot\.command/i, /ctx\.reply/i, /\.telegram\.sendMessage/i],
+        // Sinais que indicam que NÃO é um bot Telegram
         antiPatterns: [/new\s+Command\(/i, /program\.parse/i, /\.option\s*\(/i, /bin\/index\.(js|ts)/i]
     },
     'express-api': {
@@ -54,11 +73,16 @@ const PADROES_TECNOLOGIA = {
         configs: ['cli.js', 'cli.ts', 'bin/', 'bin/index.js', 'bin/index.ts'],
         scripts: ['build', 'start', 'dev'],
         codigoPatterns: [/new\s+Command\(/i, /\.command\s*\(/i, /\.option\s*\(/i, /process\.argv/i, /\.parse\s*\(/i, /\.action\s*\(/i, /\.version\s*\(/i, /\.description\s*\(/i],
+        // Sinais que indicam que NÃO é um bot
         antiPatterns: [/Client\(\s*\{[\s\S]*intents/i,
+            // Discord client
             /new\s+Telegraf/i,
+            // Telegram bot
             /bot\.command/i,
+            // Bot commands
             /interaction\.reply/i,
-            /ctx\.reply/i
+            // Discord interactions
+            /ctx\.reply/i // Telegram context
         ]
     },
     'electron-app': {
@@ -79,13 +103,20 @@ const PADROES_TECNOLOGIA = {
         configs: ['next.config.js', 'next.config.ts', 'next.config.mjs', 'next-env.d.ts', 'tailwind.config.js'],
         scripts: ['dev', 'build', 'start', 'lint', 'type-check'],
         codigoPatterns: [/export\s+default\s+function.*Page/i, /getServerSideProps/i, /getStaticProps/i, /getStaticPaths/i, /NextApiRequest/i, /NextApiResponse/i, /useRouter/i, /next\/head/i, /next\/link/i, /export\s+default\s+function\s+Page/i,
+            // App Router
             /export\s+default\s+function\s+Layout/i,
+            // App Router Layout
             /export\s+default\s+function\s+Loading/i,
+            // App Router Loading
             /export\s+default\s+function\s+Error/i,
+            // App Router Error
             /export\s+default\s+function\s+NotFound/i,
+            // App Router Not Found
             /metadata\s*=/i,
+            // App Router metadata
             /generateStaticParams/i,
-            /generateMetadata/i
+            // App Router static generation
+            /generateMetadata/i // App Router metadata generation
         ],
         antiPatterns: []
     },
@@ -222,11 +253,12 @@ const PADROES_TECNOLOGIA = {
 };
 function analisarDependencias(packageJson) {
     const evidencias = [];
-    if (!packageJson)
+    if (!packageJson) {
         return evidencias;
+    }
     const deps = {
-        ...(packageJson.dependencies || {}),
-        ...(packageJson.devDependencies || {})
+        ...(packageJson.dependencies ?? {}),
+        ...(packageJson.devDependencies ?? {})
     };
     if (config.VERBOSE) {
         console.log(DetectorContextoExtraMensagens.debugDependencias, Object.keys(deps));
@@ -248,12 +280,13 @@ function analisarDependencias(packageJson) {
 }
 function analisarScripts(packageJson) {
     const evidencias = [];
-    if (!packageJson)
+    if (!packageJson) {
         return evidencias;
-    const scripts = packageJson.scripts || {};
+    }
+    const scripts = packageJson.scripts ?? {};
     for (const [tecnologia, padroes] of Object.entries(PADROES_TECNOLOGIA)) {
         for (const script of padroes.scripts) {
-            if (Object.keys(scripts).some(key => key.includes(script) || scripts[key]?.includes(script))) {
+            if (Object.keys(scripts).some(key => key.includes(script) || scripts[key].includes(script))) {
                 evidencias.push({
                     tipo: 'script',
                     valor: script,
@@ -270,22 +303,35 @@ function analisarEstrutura(estruturaDetectada) {
     const evidencias = [];
     for (const [tecnologia, padroes] of Object.entries(PADROES_TECNOLOGIA)) {
         for (const estrutura of padroes.estrutura) {
+            // Verificação mais rigorosa para evitar falsos positivos
             const matchExato = estruturaDetectada?.find(dir => {
-                if (dir === estrutura)
+                // Match exato do caminho
+                if (dir === estrutura) {
                     return true;
-                if (dir.endsWith(`/${estrutura}`))
+                }
+                // Match no final do caminho (ex: src/cli/commands matcheia 'commands')
+                if (dir.endsWith(`/${estrutura}`)) {
                     return true;
-                if (dir.startsWith(`${estrutura}/`))
+                }
+                // Match no início seguido de / (ex: commands/subdir matcheia 'commands')
+                if (dir.startsWith(`${estrutura}/`)) {
                     return true;
+                }
+                // Para padrões que incluem /, verificar match rigoroso de subcaminho
                 if (estrutura.includes('/')) {
+                    // Normalizar separadores para comparação
                     const estruturaNorm = estrutura.replace(/\\/g, '/');
                     const dirNorm = dir.replace(/\\/g, '/');
-                    if (dirNorm === estruturaNorm)
+                    // Verificar se é subcaminho exato
+                    if (dirNorm === estruturaNorm) {
                         return true;
-                    if (dirNorm.endsWith(`/${estruturaNorm}`))
+                    }
+                    if (dirNorm.endsWith(`/${estruturaNorm}`)) {
                         return true;
-                    if (dirNorm.startsWith(`${estruturaNorm}/`))
+                    }
+                    if (dirNorm.startsWith(`${estruturaNorm}/`)) {
                         return true;
+                    }
                 }
                 return false;
             });
@@ -305,8 +351,9 @@ function analisarEstrutura(estruturaDetectada) {
 function analisarImportsExports(arquivos) {
     const evidencias = [];
     for (const arquivo of arquivos) {
-        if (!arquivo.ast || !('node' in arquivo.ast) || !arquivo.ast.node || arquivo.ast.node.type !== 'Program')
+        if (!arquivo.ast || !('node' in arquivo.ast) || arquivo.ast.node.type !== 'Program') {
             continue;
+        }
         const programa = arquivo.ast.node;
         const imports = [];
         const exports = [];
@@ -319,14 +366,17 @@ function analisarImportsExports(arquivos) {
             },
             ExportDeclaration(path) {
                 const node = path.node;
+                // Analisa exports nomeados e padrão
                 if ('declaration' in node && node.declaration) {
                     if ('id' in node.declaration && node.declaration.id && 'name' in node.declaration.id) {
-                        if (typeof node.declaration.id.name === 'string')
+                        if (typeof node.declaration.id.name === 'string') {
                             exports.push(node.declaration.id.name);
+                        }
                     }
                 }
             }
         });
+        // Verifica evidências nos imports
         for (const [tecnologia, padroes] of Object.entries(PADROES_TECNOLOGIA)) {
             for (const importEsperado of padroes.imports) {
                 if (imports.some(imp => imp.includes(importEsperado))) {
@@ -357,8 +407,9 @@ function analisarImportsExports(arquivos) {
 function analisarPadroesCodigo(arquivos) {
     const evidencias = [];
     for (const arquivo of arquivos) {
-        if (!arquivo.content)
+        if (!arquivo.content) {
             continue;
+        }
         for (const [tecnologia, padroes] of Object.entries(PADROES_TECNOLOGIA)) {
             for (const pattern of padroes.codigoPatterns) {
                 if (pattern.test(arquivo.content)) {
@@ -375,21 +426,27 @@ function analisarPadroesCodigo(arquivos) {
     }
     return evidencias;
 }
+/**
+ * Verifica se anti-patterns estão presentes no código
+ * Anti-patterns indicam que a tecnologia detectada está INCORRETA
+ */
 function verificarAntiPatterns(arquivos, tecnologia) {
     const padraoTecnologia = PADROES_TECNOLOGIA[tecnologia];
-    if (!padraoTecnologia || !padraoTecnologia.antiPatterns) {
-        return false;
+    if (padraoTecnologia.antiPatterns.length === 0) {
+        return false; // Sem anti-patterns definidos
     }
     for (const arquivo of arquivos) {
-        if (!arquivo.content)
+        if (!arquivo.content) {
             continue;
+        }
+        // Se encontrar qualquer anti-pattern, retorna true (detecção incorreta)
         for (const antiPadrao of padraoTecnologia.antiPatterns) {
             if (antiPadrao.test(arquivo.content)) {
-                return true;
+                return true; // Anti-pattern encontrado!
             }
         }
     }
-    return false;
+    return false; // Nenhum anti-pattern encontrado
 }
 function gerarSugestoesMelhoria(tecnologia, evidencias) {
     const sugestoes = [];
@@ -446,6 +503,7 @@ function detectarProblemas(tecnologia, evidencias, arquivos) {
     const problemas = [];
     switch (tecnologia) {
         case 'discord-bot':
+            // Verifica se token está hardcoded
             for (const arquivo of arquivos) {
                 if (arquivo.content?.includes('token') && !arquivo.content.includes('process.env')) {
                     problemas.push(`[ALERT] Possível token hardcoded em ${arquivo.relPath}`);
@@ -453,6 +511,7 @@ function detectarProblemas(tecnologia, evidencias, arquivos) {
             }
             break;
         case 'express-api':
+            // Verifica middleware de segurança
             const temHelmet = evidencias.some(erro => erro.valor.includes('helmet'));
             const temCors = evidencias.some(erro => erro.valor.includes('cors'));
             if (!temHelmet) {
@@ -463,6 +522,7 @@ function detectarProblemas(tecnologia, evidencias, arquivos) {
             }
             break;
         case 'electron-app':
+            // Verifica configurações de segurança
             for (const arquivo of arquivos) {
                 if (arquivo.content?.includes('nodeIntegration: true')) {
                     problemas.push(`[ALERT] nodeIntegration habilitado em ${arquivo.relPath} - risco de segurança`);
@@ -476,8 +536,9 @@ function detectarProblemas(tecnologia, evidencias, arquivos) {
     return problemas;
 }
 function calcularConfiancaTotal(evidencias) {
-    if (evidencias.length === 0)
+    if (evidencias.length === 0) {
         return 0;
+    }
     const pesosPorTipo = {
         dependencia: 1.0,
         import: 0.9,
@@ -497,6 +558,7 @@ function calcularConfiancaTotal(evidencias) {
     return somaPesos > 0 ? somaConfianca / somaPesos : 0;
 }
 export function detectarContextoInteligente(estruturaDetectada, arquivos, packageJson, options) {
+    // DEBUG: Log simples para verificar se está sendo chamado
     if (!options?.quiet && config.VERBOSE) {
         console.log(DetectorContextoExtraMensagens.debugPackageCompleto, JSON.stringify(packageJson, null, 2));
         if (packageJson?.dependencies?.vue) {
@@ -504,9 +566,10 @@ export function detectarContextoInteligente(estruturaDetectada, arquivos, packag
         }
     }
     const todasEvidencias = [...analisarDependencias(packageJson), ...analisarScripts(packageJson), ...analisarEstrutura(estruturaDetectada), ...analisarImportsExports(arquivos), ...analisarPadroesCodigo(arquivos)];
+    // Agrupa evidências por tecnologia
     const evidenciasPorTecnologia = new Map();
     for (const evidencia of todasEvidencias) {
-        const tec = evidencia.tecnologia || 'desconhecido';
+        const tec = evidencia.tecnologia ?? 'desconhecido';
         if (!evidenciasPorTecnologia.has(tec)) {
             evidenciasPorTecnologia.set(tec, []);
         }
@@ -515,28 +578,36 @@ export function detectarContextoInteligente(estruturaDetectada, arquivos, packag
             tecEvidencias.push(evidencia);
         }
     }
+    // Calcula resultados por tecnologia
     const resultados = [];
     for (const [tecnologia, evidencias] of evidenciasPorTecnologia) {
         let confiancaTotal = calcularConfiancaTotal(evidencias);
+        // Verificação de dependências obrigatórias para evitar falsos positivos
         const padraoTecnologia = PADROES_TECNOLOGIA[tecnologia];
-        if (padraoTecnologia && padraoTecnologia.dependencias.length > 0) {
+        if (padraoTecnologia.dependencias.length > 0) {
             const temDependenciaObrigatoria = evidencias.some(erro => erro.tipo === 'dependencia' && padraoTecnologia.dependencias.includes(erro.valor));
+            // Se não tem nenhuma dependência obrigatória, penalizar severamente
             if (!temDependenciaObrigatoria) {
-                confiancaTotal *= 0.1;
+                confiancaTotal *= 0.1; // Reduz confiança para 10%
             }
         }
+        // [ALERT] VERIFICAÇÃO DE ANTI-PATTERNS: Se anti-patterns estão presentes, ELIMINAR detecção
         const temAntiPadrao = verificarAntiPatterns(arquivos, tecnologia);
         if (temAntiPadrao) {
+            // Anti-pattern detectado = detecção FALSA, eliminar confiança
             confiancaTotal = 0;
+            // Opcional: Adicionar evidência negativa
             evidencias.push({
                 tipo: 'codigo',
                 valor: 'anti-pattern-detectado',
                 confianca: -1.0,
+                // Negativa
                 tecnologia,
                 localizacao: 'código'
             });
         }
         if (confiancaTotal > 0.3) {
+            // Threshold mínimo para considerar
             resultados.push({
                 tecnologia,
                 confiancaTotal,
@@ -546,13 +617,16 @@ export function detectarContextoInteligente(estruturaDetectada, arquivos, packag
             });
         }
     }
+    // Ordena por confiança decrescente
     return resultados.sort((arquivo, base) => base.confiancaTotal - arquivo.confiancaTotal);
 }
 export function inferirArquetipoInteligente(estruturaDetectada, arquivos, packageJson, options) {
     const resultados = detectarContextoInteligente(estruturaDetectada, arquivos, packageJson, options);
-    if (resultados.length === 0)
+    if (resultados.length === 0) {
         return 'generico';
+    }
     const melhorResultado = resultados[0];
+    // Mapeia tecnologias para arquétipos oficiais
     const mapeamentoArquetipos = {
         'discord-bot': 'bot',
         'telegram-bot': 'bot',
@@ -570,6 +644,5 @@ export function inferirArquetipoInteligente(estruturaDetectada, arquivos, packag
         'nuxt-app': 'vue-spa',
         'vite-vue': 'vue-spa'
     };
-    return mapeamentoArquetipos[melhorResultado.tecnologia || 'generico'] || 'generico';
+    return mapeamentoArquetipos[melhorResultado.tecnologia ?? 'generico'] || 'generico';
 }
-//# sourceMappingURL=detector-context-smart.js.map