@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/analysts/corrections/type-safety/usage-analyzer.js

@@ -1,21 +1,33 @@
+// SPDX-License-Identifier: MIT
+/**
+ * Analisador de uso de variáveis via AST Babel
+ * Detecta padrões de uso para inferir tipos corretos
+ */
+/**
+ * Encontra todos os usos de uma variável no AST
+ */
 export function findVariableUsages(varNome, ast) {
     const usages = [];
     if (!ast || typeof ast !== 'object') {
         return usages;
     }
+    // Traversar AST recursivamente
     traverseAST(ast, (node) => {
+        // Identifier usage
         if (node.type === 'Identifier' && node.name === varNome) {
             const usage = extractUsageFromNode(node, varNome);
             if (usage) {
                 usages.push(usage);
             }
         }
+        // Member expression (obj.property)
         if (node.type === 'MemberExpression' && node.object?.name === varNome) {
             const usage = extractMemberExpressionUsage(node, varNome);
             if (usage) {
                 usages.push(usage);
             }
         }
+        // Call expression (func())
         if (node.type === 'CallExpression' && node.callee?.object?.name === varNome) {
             const usage = extractCallExpressionUsage(node, varNome);
             if (usage) {
@@ -25,6 +37,9 @@ export function findVariableUsages(varNome, ast) {
     });
     return usages;
 }
+/**
+ * Analisa padrões de uso para inferir tipo
+ */
 export function analyzeUsagePatterns(usages) {
     const pattern = {
         allUsagesAreString: false,
@@ -38,23 +53,32 @@ export function analyzeUsagePatterns(usages) {
     if (usages.length === 0) {
         return pattern;
     }
+    // Detectar métodos de string
     const stringMethods = ['toUpperCase', 'toLowerCase', 'trim', 'substring', 'charAt', 'indexOf'];
     const stringUsages = usages.filter(u => u.operation === 'call' && u.method && stringMethods.includes(u.method));
+    // Detectar métodos de number
     const numberOperations = usages.filter(u => u.operation === 'call' && (u.method === 'toFixed' || u.method === 'toPrecision' || u.context.includes('+') || u.context.includes('-') || u.context.includes('*') || u.context.includes('/')));
+    // Detectar métodos de boolean
     const booleanUsages = usages.filter(u => u.operation === 'comparison' || u.context.includes('===') || u.context.includes('!==') || u.context.includes('&&') || u.context.includes('||'));
+    // Detectar acesso a propriedades (objeto)
     const propertyAccesses = usages.filter(u => u.operation === 'access' && u.property);
+    // Detectar chamadas de função
     const functionCalls = usages.filter(u => u.operation === 'call' && !u.method);
+    // Detectar métodos de array
     const arrayMethods = ['push', 'pop', 'map', 'filter', 'reduce', 'forEach', 'find'];
     const arrayUsages = usages.filter(u => u.operation === 'call' && u.method && arrayMethods.includes(u.method));
+    // Análise final
     pattern.allUsagesAreString = stringUsages.length > 0 && stringUsages.length === usages.length;
     pattern.allUsagesAreNumber = numberOperations.length > 0 && numberOperations.length === usages.length;
     pattern.allUsagesAreBoolean = booleanUsages.length > 0 && booleanUsages.length === usages.length;
     pattern.hasObjectStructure = propertyAccesses.length > 0;
     pattern.isFunction = functionCalls.length > 0;
     pattern.isArray = arrayUsages.length > 0;
+    // Extrair propriedades de objeto
     if (pattern.hasObjectStructure) {
         pattern.objectProperties = extractObjectProperties(usages);
     }
+    // Detectar type guards
     const typeGuards = detectTypeGuards(usages);
     if (typeGuards.length > 0) {
         pattern.hasTypeGuards = true;
@@ -62,12 +86,16 @@ export function analyzeUsagePatterns(usages) {
     }
     return pattern;
 }
+/**
+ * Extrai propriedades de objeto baseado em acessos
+ */
 function extractObjectProperties(usages) {
     const propertiesMap = new Map();
     for (const usage of usages) {
         if (usage.property) {
             const existing = propertiesMap.get(usage.property);
             if (!existing) {
+                // Inferir tipo da propriedade baseado no método chamado
                 let inferredTipo = 'unknown';
                 let confidence = 50;
                 if (usage.method) {
@@ -91,18 +119,23 @@ function extractObjectProperties(usages) {
                 });
             }
             else {
+                // Atualizar métodos chamados
                 if (usage.method && !existing.methodsCalled?.includes(usage.method)) {
-                    existing.methodsCalled = [...(existing.methodsCalled || []), usage.method];
+                    existing.methodsCalled = [...(existing.methodsCalled ?? []), usage.method];
                 }
             }
         }
     }
     return Array.from(propertiesMap.values());
 }
+/**
+ * Detecta type guards no código
+ */
 function detectTypeGuards(usages) {
     const guards = [];
     for (const usage of usages) {
         const context = usage.context.toLowerCase();
+        // typeof guards
         if (context.includes('typeof')) {
             const match = context.match(/typeof\s+\w+\s*===\s*['"](\w+)['"]/);
             if (match) {
@@ -114,6 +147,7 @@ function detectTypeGuards(usages) {
                 });
             }
         }
+        // instanceof guards
         if (context.includes('instanceof')) {
             const match = context.match(/\w+\s+instanceof\s+(\w+)/);
             if (match) {
@@ -125,6 +159,7 @@ function detectTypeGuards(usages) {
                 });
             }
         }
+        // 'in' operator guards
         if (context.includes(' in ')) {
             const match = context.match(/['"](\w+)['"]\s+in\s+\w+/);
             if (match) {
@@ -139,6 +174,9 @@ function detectTypeGuards(usages) {
     }
     return guards;
 }
+/**
+ * Traversa AST recursivamente
+ */
 function traverseAST(node, visitor) {
     if (!node || typeof node !== 'object') {
         return;
@@ -146,7 +184,7 @@ function traverseAST(node, visitor) {
     visitor(node);
     for (const key in node) {
         if (key === 'loc' || key === 'start' || key === 'end' || key === 'range') {
-            continue;
+            continue; // Skip location metadata
         }
         const child = node[key];
         if (Array.isArray(child)) {
@@ -159,53 +197,65 @@ function traverseAST(node, visitor) {
         }
     }
 }
+/**
+ * Extrai informações de uso de um nó Identifier
+ */
 function extractUsageFromNode(node, varNome) {
     return {
         name: varNome,
-        nodeType: node.type || 'unknown',
-        line: node.loc?.start?.line || 0,
-        column: node.loc?.start?.column || 0,
+        nodeType: node.type ?? 'unknown',
+        line: node.loc?.start?.line ?? 0,
+        column: node.loc?.start?.column ?? 0,
         context: extractNodeContext(node),
         operation: 'access'
     };
 }
+/**
+ * Extrai informações de MemberExpression
+ */
 function extractMemberExpressionUsage(node, varNome) {
-    const property = node.property?.name || node.property?.value;
+    const property = node.property?.name ?? String(node.property.value);
     return {
         name: varNome,
         nodeType: 'MemberExpression',
-        line: node.loc?.start?.line || 0,
-        column: node.loc?.start?.column || 0,
+        line: node.loc?.start?.line ?? 0,
+        column: node.loc?.start?.column ?? 0,
         context: extractNodeContext(node),
         operation: 'access',
-        property: property ? String(property) : undefined
+        property: property || undefined
     };
 }
+/**
+ * Extrai informações de CallExpression
+ */
 function extractCallExpressionUsage(node, varNome) {
     const method = node.callee?.property?.name;
     return {
         name: varNome,
         nodeType: 'CallExpression',
-        line: node.loc?.start?.line || 0,
-        column: node.loc?.start?.column || 0,
+        line: node.loc?.start?.line ?? 0,
+        column: node.loc?.start?.column ?? 0,
         context: extractNodeContext(node),
         operation: 'call',
-        method: method ? String(method) : undefined
+        method: method ?? undefined
     };
 }
+/**
+ * Extrai contexto ao redor de um nó (para análise)
+ */
 function extractNodeContext(node) {
+    // Simplificado - em produção, usar gerador de código do Babel
     if (node.type === 'Identifier') {
-        return String(node.name || '');
+        return (node.name ?? '');
     }
     if (node.type === 'MemberExpression') {
-        const obj = node.object?.name || extractNodeContext(node.object);
-        const prop = node.property?.name || node.property?.value;
+        const obj = node.object?.name ?? extractNodeContext(node.object);
+        const prop = node.property?.name ?? String(node.property.value);
         return `${obj}.${prop}`;
     }
     if (node.type === 'CallExpression') {
         const callee = extractNodeContext(node.callee);
         return `${callee}()`;
     }
-    return String(node.type || '');
+    return (node.type ?? '');
 }
-//# sourceMappingURL=usage-analyzer.js.map

package/dist/analysts/css/analysts/analyst-css.js

@@ -1,10 +1,11 @@
-import { messages } from '../../../core/messages/index.js';
-import { isLikelyIntentionalDuplicate, lintCssLikeStylelint } from '../../../shared/formatters/index.js';
+// SPDX-License-Identifier: MIT
 import postcss, {} from 'postcss';
 import postcssSass from 'postcss-sass';
 import postcssScss from 'postcss-scss';
+import { messages } from '../../../core/messages/index.js';
+import { isLikelyIntentionalDuplicate, lintCssLikeStylelint } from '../../../shared/formatters/index.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
-const disableEnv = globalThis.process?.env?.MAHORAGA_DISABLE_PLUGIN_CSS === '1';
+const disableEnv = globalThis.process?.env?.SUKUNA_DISABLE_PLUGIN_CSS === '1';
 function warn(message, relPath, line, nivelArg = messages.SeverityNiveis.warning) {
     return criarOcorrencia({
         relPath,
@@ -18,11 +19,13 @@ function warn(message, relPath, line, nivelArg = messages.SeverityNiveis.warning
 function collectCssIssues(src, relPath) {
     const ocorrencias = [];
     const lines = src.split(/\n/);
+    // Stack de blocos para não misturar propriedades de seletores/frames diferentes
     const stack = [];
     lines.forEach((lineText, idx) => {
         const line = idx + 1;
         const trimmed = lineText.trim();
-        const opens = (trimmed.match(/\{/g) || []).length;
+        // Abre novos blocos antes de analisar propriedades da linha
+        const opens = (trimmed.match(/\{/g) ?? []).length;
         for (let indice = 0; indice < opens; indice++) {
             const ctx = /@font-face/i.test(trimmed) ? 'font-face' : undefined;
             stack.push({
@@ -31,46 +34,52 @@ function collectCssIssues(src, relPath) {
             });
         }
         const current = stack[stack.length - 1];
-        if (current) {
-            const propMatch = /^([a-zA-Z-]+)\s*:\s*([^;]+)?/.exec(trimmed);
-            if (propMatch) {
-                const prop = propMatch[1].toLowerCase();
-                const value = (propMatch[2] || '').trim();
-                const prev = current.props[prop];
-                if (prev) {
-                    const ctx = current.context ? {
-                        currentAtRule: current.context
-                    } : undefined;
-                    if (isLikelyIntentionalDuplicate(prop, prev.value, value, ctx)) {
-                    }
-                    else if (prev.value === value) {
-                        ocorrencias.push(warn(messages.CssMensagens.duplicatePropertySame(prop), relPath, line));
-                    }
-                    else {
-                        ocorrencias.push(warn(messages.CssMensagens.duplicatePropertyDifferent(prop, prev.value, value), relPath, line));
-                    }
+        const propMatch = /^([a-zA-Z-]+)\s*:\s*([^;]+)?/.exec(trimmed);
+        if (propMatch) {
+            const prop = propMatch[1].toLowerCase();
+            const value = (propMatch[2] || '').trim();
+            const prev = current.props[prop];
+            if (prop in current.props) {
+                const ctx = {
+                    currentAtRule: current.context
+                };
+                if (isLikelyIntentionalDuplicate(prop, prev.value, value, ctx)) {
+                    // Duplicata legítima (fallback vendor, viewport, cor, etc)
+                }
+                else if (prev.value === value) {
+                    // Mesma propriedade, mesmo valor = erro claro
+                    ocorrencias.push(warn(messages.CssMensagens.duplicatePropertySame(prop), relPath, line));
                 }
                 else {
-                    current.props[prop] = {
-                        line,
-                        value
-                    };
+                    // Valores diferentes sem padrão claro = possível erro
+                    ocorrencias.push(warn(messages.CssMensagens.duplicatePropertyDifferent(prop, prev.value, value), relPath, line));
                 }
             }
+            else {
+                current.props[prop] = {
+                    line,
+                    value
+                };
+            }
         }
+        // !important
         if (/!important/.test(trimmed)) {
             ocorrencias.push(warn(messages.CssMensagens.importantUsage, relPath, line));
         }
+        // @import/http
         if (/^@import\s+[^;]*http:\/\//i.test(trimmed)) {
             ocorrencias.push(warn(messages.CssMensagens.httpImport, relPath, line));
         }
+        // url(http:)
         if (/url\(\s*['"]?http:\/\//i.test(trimmed)) {
             ocorrencias.push(warn(messages.CssMensagens.httpUrl, relPath, line));
         }
-        const closes = (trimmed.match(/\}/g) || []).length;
+        // Fecha blocos depois de processar a linha
+        const closes = (trimmed.match(/\}/g) ?? []).length;
         for (let indice = 0; indice < closes; indice++) {
-            if (stack.length)
-                stack?.pop();
+            if (stack.length) {
+                stack.pop();
+            }
         }
     });
     return ocorrencias;
@@ -80,8 +89,9 @@ function collectCssIssuesLikeStylelint(src, relPath) {
         code: src,
         relPath
     });
-    if (!warnings.length)
+    if (!warnings.length) {
         return null;
+    }
     return warnings.map(dimensaoLargura => {
         const nivel = dimensaoLargura.severity === 'error' ? messages.SeverityNiveis.error : messages.SeverityNiveis.warning;
         return warn(dimensaoLargura.text, relPath, dimensaoLargura.line, nivel);
@@ -95,8 +105,10 @@ function canonicalizeDecls(decls) {
     decls.forEach(diretorio => {
         const prop = diretorio.prop.trim().toLowerCase();
         const value = normalizeCssValue(diretorio.value);
-        if (!prop || !value)
+        if (!prop || !value) {
             return;
+        }
+        // Mantém a última ocorrência; duplicatas já são tratadas em outra regra.
         map.set(prop, value);
     });
     const sorted = [...map.entries()].sort((arquivo, base) => arquivo[0].localeCompare(base[0]));
@@ -111,8 +123,11 @@ function splitSimpleSelectors(selectorText) {
 function parseWithPostCssRoots(src, relPath) {
     const isScss = /\.scss$/i.test(relPath);
     const isSass = /\.sass$/i.test(relPath);
-    const syntax = isScss ? postcssScss : isSass ? postcssSass : undefined;
+    const rawSyntax = isScss ? postcssScss : isSass ? postcssSass : undefined;
+    const syntax = rawSyntax;
     try {
+        // Importante: `postcss.parse(..., { syntax })` ignora `syntax`.
+        // Para aplicar parser SCSS/SASS corretamente, usamos `postcss().process`.
         const result = postcss().process(src, {
             from: relPath,
             ...(syntax ? {
@@ -121,13 +136,15 @@ function parseWithPostCssRoots(src, relPath) {
         });
         const rootUnknown = result.root;
         const rootAny = rootUnknown;
-        if (rootAny && rootAny.type === 'document' && Array.isArray(rootAny.nodes)) {
+        // Alguns parsers podem retornar `Document` (com múltiplos roots internos)
+        if (rootAny?.type === 'document' && Array.isArray(rootAny.nodes)) {
             const roots = rootAny.nodes.filter((node) => {
                 const textoTitulo = node?.type;
                 return textoTitulo === 'root';
             });
             return roots.length ? roots : null;
         }
+        // Caso padrão: um único Root
         return [result.root];
     }
     catch {
@@ -139,29 +156,40 @@ function getNodeLine(node) {
     return typeof line === 'number' && Number.isFinite(line) ? line : undefined;
 }
 function formatAtRuleContext(node) {
-    const name = String(node.name || '').toLowerCase();
-    const params = String(node.params || '').trim();
+    const name = (node.name || '').toLowerCase();
+    const params = (node.params || '').trim();
     return `@${name}${params ? ` ${params}` : ''}`;
 }
 function normalizePropKey(prop) {
+    // Propriedades CSS são case-insensitive; custom properties são case-sensitive.
     return prop.startsWith('--') ? prop : prop.toLowerCase();
 }
+// Lista conhecida de propriedades CSS válidas (subset comum)
+// Em produção, considere usar uma biblioteca como css-tree ou mdn-data
 const CONHECIDAS_CSS_PROPRIEDADES = new Set([
+    // Layout
     'display', 'position', 'top', 'right', 'bottom', 'left', 'width', 'height', 'margin', 'margin-top', 'margin-right', 'margin-bottom', 'margin-left', 'padding', 'padding-top', 'padding-right', 'padding-bottom', 'padding-left', 'border', 'border-top', 'border-right', 'border-bottom', 'border-left', 'border-width', 'border-style', 'border-color', 'box-sizing', 'float', 'clear', 'overflow', 'overflow-x', 'overflow-y', 'z-index', 'visibility',
+    // Flexbox
     'flex', 'flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'align-items', 'align-content', 'align-self', 'flex-grow', 'flex-shrink', 'flex-basis', 'order',
+    // Grid
     'grid', 'grid-template-columns', 'grid-template-rows', 'grid-template-areas', 'grid-column', 'grid-row', 'grid-area', 'gap', 'row-gap', 'column-gap',
+    // Tipografia
     'font', 'font-family', 'font-size', 'font-weight', 'font-style', 'font-variant', 'line-height', 'letter-spacing', 'word-spacing', 'text-align', 'text-decoration', 'text-transform', 'text-indent', 'white-space', 'word-break', 'word-wrap', 'color', 'background', 'background-color', 'background-image', 'background-repeat', 'background-position', 'background-size',
+    // CSS3 e modernas
     'transform-origin', 'inset', 'background-clip', 'max-width', 'max-height', 'min-height', 'animation-delay', 'pointer-events', 'scroll-behavior', 'background-attachment', 'text-shadow', 'inset-inline', 'inset-block', 'inset-inline-start', 'inset-inline-end', 'inset-block-start', 'inset-block-end',
+    // Outros comuns
     'cursor', 'opacity', 'transform', 'transition', 'animation', 'list-style', 'vertical-align', 'text-overflow', 'box-shadow', 'border-radius', 'outline', 'content', 'counter-reset', 'counter-increment'
 ]);
 function isValidCssProperty(prop) {
     const normalized = prop.toLowerCase();
+    // Permite propriedades custom (--*) e vendor (-webkit-*, -moz-*, etc.)
     if (normalized.startsWith('--') || normalized.startsWith('-')) {
         return true;
     }
     return CONHECIDAS_CSS_PROPRIEDADES.has(normalized);
 }
 function detectCssHacks(value) {
+    // Detecta hacks comuns de CSS
     const hacks = [{
             pattern: /\\9/,
             name: 'backslash-9 hack'
@@ -190,31 +218,35 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
     const seen = new Set();
     const pushOnce = (metrica) => {
         const chave = `${metrica.mensagem}|${metrica.relPath}|${metrica.linha ?? 0}`;
-        if (seen.has(chave))
+        if (seen.has(chave)) {
             return;
+        }
         seen.add(chave);
         ocorrencias.push(metrica);
     };
     const byContextAndSignature = new Map();
     const visit = (container, ctxAtRules, ctxSelectors) => {
+        // 1) Duplicidade / !important / url(http:)
         const props = {};
         const inFontFace = ctxAtRules.some(elem => elem.toLowerCase().startsWith('@font-face'));
         container.nodes?.forEach(node => {
             if (node.type === 'decl') {
                 const decl = node;
-                const propRaw = String(decl.prop || '').trim();
+                const propRaw = (decl.prop || '').trim();
+                // SCSS variável: "$color: ..." (não é propriedade CSS)
                 if (!propRaw || propRaw.startsWith('$')) {
                     return;
                 }
                 const propChave = normalizePropKey(propRaw);
-                const value = normalizeCssValue(`${String(decl.value || '')}${decl.important ? ' !important' : ''}`);
+                const value = normalizeCssValue(`${(decl.value || '')}${decl.important ? ' !important' : ''}`);
                 const line = getNodeLine(decl);
                 const prev = props[propChave];
-                if (prev) {
+                if (propChave in props) {
                     const ctx = inFontFace ? {
                         currentAtRule: 'font-face'
                     } : undefined;
                     if (isLikelyIntentionalDuplicate(propChave, prev.value, value, ctx)) {
+                        // duplicata intencional
                     }
                     else if (prev.value === value) {
                         pushOnce(warn(messages.CssMensagens.duplicatePropertySame(propRaw), relPath, line));
@@ -227,41 +259,47 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
                     value,
                     line
                 };
+                // Validação de propriedade inválida
                 if (!isValidCssProperty(propRaw)) {
                     pushOnce(warn(messages.CssMensagens.invalidProperty(propRaw), relPath, line));
                 }
-                const hack = detectCssHacks(String(decl.value || ''));
+                // Detecta hacks CSS
+                const hack = detectCssHacks((decl.value || ''));
                 if (hack) {
                     pushOnce(warn(messages.CssMensagens.cssHackDetected(hack), relPath, line));
                 }
                 if (decl.important) {
                     pushOnce(warn(messages.CssMensagens.importantUsage, relPath, line));
                 }
-                if (/url\(\s*['"]?http:\/\//i.test(String(decl.value || ''))) {
+                if (/url\(\s*['"]?http:\/\//i.test((decl.value || ''))) {
                     pushOnce(warn(messages.CssMensagens.httpUrl, relPath, line));
                 }
             }
         });
+        // 2) Unificação/centralização (apenas em regras com seletores simples)
         if (container.type === 'rule') {
             const rule = container;
-            const selectorText = String(rule.selector || '');
+            const selectorText = (rule.selector || '');
             const simpleSelectors = splitSimpleSelectors(selectorText);
             if (simpleSelectors.length) {
                 const decls = [];
-                rule.nodes?.forEach(node => {
-                    if (node.type !== 'decl')
+                rule.nodes.forEach(node => {
+                    if (node.type !== 'decl') {
                         return;
+                    }
                     const diretorio = node;
-                    const prop = String(diretorio.prop || '').trim();
-                    if (!prop || prop.startsWith('$'))
+                    const prop = (diretorio.prop || '').trim();
+                    if (!prop || prop.startsWith('$')) {
                         return;
-                    const value = `${String(diretorio.value || '')}${diretorio.important ? ' !important' : ''}`;
+                    }
+                    const value = `${(diretorio.value || '')}${diretorio.important ? ' !important' : ''}`;
                     decls.push({
                         prop,
                         value
                     });
                 });
-                const hasApplyDirective = rule.nodes?.some(node => node.type === 'atrule' && node.name === 'apply') ?? false;
+                // Detecta regras vazias (ignora @apply do Tailwind CSS)
+                const hasApplyDirective = rule.nodes.some(node => node.type === 'atrule' && (node).name === 'apply');
                 if (decls.length === 0 && !hasApplyDirective) {
                     pushOnce(warn(messages.CssMensagens.emptyRule, relPath, getNodeLine(rule)));
                 }
@@ -282,7 +320,9 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
                 }
             }
             else if (selectorText.trim()) {
+                // Verifica seletor malformado (se não conseguiu dividir em seletores simples)
                 try {
+                    // Tenta parsear o seletor com uma regex simples
                     const invalidChars = /[{}[\]()]/;
                     if (invalidChars.test(selectorText)) {
                         pushOnce(warn(messages.CssMensagens.malformedSelector(selectorText.trim()), relPath, getNodeLine(rule)));
@@ -293,22 +333,27 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
                 }
             }
         }
+        // 3) Descer recursivamente para filhos (@rules e regras aninhadas)
         container.nodes?.forEach(node => {
             if (node.type === 'atrule') {
                 const at = node;
-                const name = String(at.name || '').toLowerCase();
+                const name = (at.name || '').toLowerCase();
                 const line = getNodeLine(at);
-                if (name === 'import' && /^\s*(url\()?\s*['"]?http:\/\//i.test(String(at.params || ''))) {
+                // @import http://...
+                if (name === 'import' && /^\s*(url\()?\s*['"]?http:\/\//i.test((at.params || ''))) {
                     pushOnce(warn(messages.CssMensagens.httpImport, relPath, line));
                 }
-                if (at.nodes && at.nodes.length) {
+                // Alguns at-rules tem bloco e nós internos; outros são só linha.
+                if (at.nodes?.length) {
                     visit(at, [...ctxAtRules, formatAtRuleContext(at)], ctxSelectors);
                 }
                 return;
             }
             if (node.type === 'rule') {
                 const raiz = node;
-                const nextSelectors = container.type === 'rule' ? [...ctxSelectors, `sel ${String(container.selector || '').trim()}`] : ctxSelectors;
+                // Contexto de nesting (SCSS): para regras filhas, adiciona o seletor do container atual
+                // (não o seletor da regra filha), evitando misturar árvores de seletores diferentes.
+                const nextSelectors = container.type === 'rule' ? [...ctxSelectors, `sel ${(container.selector || '').trim()}`] : ctxSelectors;
                 visit(raiz, ctxAtRules, nextSelectors);
             }
         });
@@ -316,11 +361,13 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
     visit(root, [], []);
     for (const { declCount, hits } of byContextAndSignature.values()) {
         const selectors = [...new Set(hits.map(hash => hash.selector))];
-        if (selectors.length < 2)
+        if (selectors.length < 2) {
             continue;
+        }
         const hasSemanticNames = selectors.every(sel => /^[.#][A-Z]/.test(sel) || /[A-Z]/.test(sel.replace(/^[.#]/, '')));
-        if (hasSemanticNames && selectors.length === 2)
+        if (hasSemanticNames && selectors.length === 2) {
             continue;
+        }
         const line = hits.map(hash => hash.line).filter((node) => typeof node === 'number' && Number.isFinite(node)).sort((arquivo, base) => arquivo - base)[0];
         pushOnce(warn(messages.CssMensagens.unifySelectors(selectors, declCount), relPath, line));
         const ids = selectors.filter(string => string.startsWith('#'));
@@ -336,28 +383,32 @@ export const analistaCss = criarAnalista({
     descricao: 'Lint de CSS do Mahoraga (com fallback heurístico).',
     global: false,
     test: (relPath) => /\.(css|scss|sass)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
+        }
         const isCss = /\.css$/i.test(relPath);
         const roots = parseWithPostCssRoots(src, relPath);
         const astIssues = roots ? roots.flatMap(raiz => collectCssIssuesFromPostCssAst(raiz, relPath)) : [];
+        // Mantém regras stylelint-like para CSS puro (pipeline atual do Mahoraga).
         const cssLint = isCss ? collectCssIssuesLikeStylelint(src, relPath) ?? [] : [];
         const seen = new Set();
         const merged = [];
         const pushOnce = (metrica) => {
             const chave = `${metrica.mensagem}|${metrica.relPath}|${metrica.linha ?? 0}`;
-            if (seen.has(chave))
+            if (seen.has(chave)) {
                 return;
+            }
             seen.add(chave);
             merged.push(metrica);
         };
         cssLint.forEach(pushOnce);
         astIssues.forEach(pushOnce);
-        if (merged.length)
+        if (merged.length) {
             return merged;
+        }
+        // Fallback: heurístico (útil quando o parser não aceita casos extremos/arquivos quebrados)
         const fallback = collectCssIssues(src, relPath);
         return fallback.length ? fallback : null;
     }
 });
-//# sourceMappingURL=analyst-css.js.map

package/dist/analysts/css/analysts/index.js

@@ -1,2 +1 @@
 export * from './analyst-css.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/css/corrections/correction-css.js

@@ -1,3 +1,12 @@
+// SPDX-License-Identifier: MIT
+/**
+ * [CHAVE-INGLESA] Correções automáticas para CSS
+ *
+ * Fornece correções sugeridas para problemas comuns em CSS:
+ * - Remover !important
+ * - Consolidar seletores duplicados
+ * - Sugerir classes ao invés de IDs
+ */
 import { messages } from '../../../core/messages/index.js';
 import { splitLines } from '../../../shared/helpers/index.js';
 import { criarOcorrencia } from '../../../types/index.js';
@@ -36,8 +45,9 @@ export const correctionCss = {
     descricao: 'Correções automáticas para problemas CSS',
     test: (relPath) => /\.(css|scss|sass)$/i.test(relPath),
     aplicar: (src, relPath) => {
-        if (!src)
+        if (!src) {
             return [];
+        }
         const correcoes = detectarCorrecoesCss(src, relPath);
         return correcoes.map(elem => criarOcorrencia({
             tipo: `correction-${elem.tipo}`,
@@ -49,4 +59,3 @@ export const correctionCss = {
         }));
     }
 };
-//# sourceMappingURL=correction-css.js.map