@mocoto/mahoraga 0.14.8 → 0.15.0

package/dist/analysts/corrections/type-safety/type-inference.js

@@ -1,14 +1,4 @@
-// SPDX-License-Identifier: MIT
-// @mahoraga-disable tipo-literal-inline-complexo
-// Justificativa: tipos locais para inferência de tipos
-/**
- * Módulo de inferência de tipos
- * Infere tipos primitivos e cria interfaces para objetos complexos
- */
 import { toKebabCase } from './context-analyzer.js';
-/**
- * Infere tipo baseado em padrões de uso
- */
 export function inferTypeFromUsage(varNome, patterns, _filePath) {
     const result = {
         confidence: 0,
@@ -18,37 +8,31 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         typeDefinition: '',
         suggestedPath: ''
     };
-    // Tipo primitivo: string
     if (patterns.allUsagesAreString) {
         result.inferredTipo = 'string';
         result.isSimpleType = true;
         result.confidence = 95;
         return result;
     }
-    // Tipo primitivo: number
     if (patterns.allUsagesAreNumber) {
         result.inferredTipo = 'number';
         result.isSimpleType = true;
         result.confidence = 95;
         return result;
     }
-    // Tipo primitivo: boolean
     if (patterns.allUsagesAreBoolean) {
         result.inferredTipo = 'boolean';
         result.isSimpleType = true;
         result.confidence = 95;
         return result;
     }
-    // Array
     if (patterns.isArray) {
-        // Tentar inferir tipo do array
         const elementTipo = inferArrayElementType(patterns);
         result.inferredTipo = `${elementTipo}[]`;
         result.isSimpleType = elementTipo === 'string' || elementTipo === 'number' || elementTipo === 'boolean';
         result.confidence = 85;
         return result;
     }
-    // Function
     if (patterns.isFunction) {
         result.inferredTipo = 'Function';
         result.isSimpleType = true;
@@ -56,7 +40,6 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         result.suggestion = 'Considere usar tipo de função específico: (param: T) => R';
         return result;
     }
-    // Objeto complexo
     if (patterns.hasObjectStructure && patterns.objectProperties) {
         const inferredInterface = inferInterfaceFromProperties(varNome, patterns.objectProperties);
         result.inferredTipo = inferredInterface.name;
@@ -69,7 +52,6 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         result.requiresImport = true;
         return result;
     }
-    // Type guards encontrados
     if (patterns.hasTypeGuards && patterns.typeGuards) {
         const guardTipo = extractTypeFromGuards(patterns.typeGuards);
         result.inferredTipo = guardTipo.type;
@@ -77,7 +59,6 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         result.confidence = guardTipo.confidence;
         return result;
     }
-    // União de tipos detectada
     if (patterns.unionTypes && patterns.unionTypes.length > 0) {
         result.inferredTipo = patterns.unionTypes.join(' | ');
         result.isSimpleType = false;
@@ -85,15 +66,11 @@ export function inferTypeFromUsage(varNome, patterns, _filePath) {
         result.suggestion = 'Considere criar type alias para união complexa';
         return result;
     }
-    // Não conseguiu inferir
     result.inferredTipo = 'unknown';
     result.confidence = 30;
     result.suggestion = 'Adicione type guards ou crie tipo dedicado manualmente';
     return result;
 }
-/**
- * Cria interface baseado em propriedades detectadas
- */
 export function inferInterfaceFromProperties(varNome, properties) {
     const interfaceNome = toPascalCase(varNome);
     const confidence = calculateInterfaceConfidence(properties);
@@ -109,9 +86,6 @@ export function inferInterfaceFromProperties(varNome, properties) {
         properties
     };
 }
-/**
- * Extrai tipo de type guards
- */
 export function extractTypeFromGuards(typeGuards) {
     if (typeGuards.length === 0) {
         return {
@@ -119,7 +93,6 @@ export function extractTypeFromGuards(typeGuards) {
             confidence: 0
         };
     }
-    // Se todos os guards apontam para o mesmo tipo
     const types = typeGuards.map(grupo => grupo.inferredTipo);
     const uniqueTipos = [...new Set(types)];
     if (uniqueTipos.length === 1) {
@@ -129,23 +102,17 @@ export function extractTypeFromGuards(typeGuards) {
             confidence: avgConfidence
         };
     }
-    // Múltiplos tipos - criar união
     const avgConfidence = typeGuards.reduce((sum, grupo) => sum + grupo.confidence, 0) / typeGuards.length;
     return {
         type: uniqueTipos.join(' | '),
         confidence: avgConfidence * 0.9
-    }; // Penalizar união
+    };
 }
-/**
- * Calcula confiança da interface baseado nas propriedades
- */
 function calculateInterfaceConfidence(properties) {
     if (properties.length === 0) {
         return 30;
     }
-    // Média da confiança das propriedades
     const avgConfidence = properties.reduce((sum, prop) => sum + prop.confidence, 0) / properties.length;
-    // Bonus por número de propriedades (mais propriedades = mais confiável)
     let bonus = 0;
     if (properties.length >= 3) {
         bonus = 5;
@@ -155,11 +122,7 @@ function calculateInterfaceConfidence(properties) {
     }
     return Math.min(100, Math.round(avgConfidence + bonus));
 }
-/**
- * Infere tipo de elemento de array
- */
 function inferArrayElementType(patterns) {
-    // Simplificado - em produção, analisar elementos do array
     if (patterns.allUsagesAreString) {
         return 'string';
     }
@@ -171,16 +134,10 @@ function inferArrayElementType(patterns) {
     }
     return 'unknown';
 }
-/**
- * Verifica se é tipo primitivo
- */
 function isPrimitiveType(type) {
     const primitives = ['string', 'number', 'boolean', 'null', 'undefined', 'symbol', 'bigint'];
     return primitives.includes(type.toLowerCase());
 }
-/**
- * Converte string para PascalCase
- */
 function toPascalCase(str) {
     return str.replace(/([a-z])([A-Z])/g, '$1 $2').split(/[\s_-]+/).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join('');
 }

package/dist/analysts/corrections/type-safety/type-validator.js

@@ -1,13 +1,5 @@
-// SPDX-License-Identifier: MIT
-/**
- * Validação de tipos criados/modificados
- * Verifica compatibilidade e compilação TypeScript
- */
 import { findExistingType, isSameType } from './type-creator.js';
 const CONFIANCA_MINIMA = 60;
-/**
- * Valida substituição de tipo (any/unknown → specific)
- */
 export async function validateTypeReplacement(originalCode, fixedCodigo, typeAnalise) {
     const result = {
         isCompatible: true,
@@ -15,20 +7,17 @@ export async function validateTypeReplacement(originalCode, fixedCodigo, typeAna
         errors: [],
         warnings: []
     };
-    // 1. Verificar se tipo criado já existe com definição diferente
     if (typeAnalise.createdNewType) {
         const existingTipo = await findExistingType(typeAnalise.typeName);
         if (existingTipo && !isSameType(existingTipo, typeAnalise.typeDefinition)) {
             result.warnings.push(`Tipo ${typeAnalise.typeName} já existe com definição diferente. Verifique conflito em ${existingTipo.path}`);
         }
     }
-    // 2. Verificar se tipo inferido é compatível com uso
     const usageValidation = validateTypeUsageCompatibility(fixedCodigo, typeAnalise);
     if (!usageValidation.isCompatible) {
         result.errors.push(`Tipo inferido ${typeAnalise.inferredTipo} incompatível com uso detectado. Esperado: ${usageValidation.expectedType}`);
         result.isCompatible = false;
     }
-    // 3. Verificar se import foi adicionado corretamente
     if (typeAnalise.requiresImport) {
         const hasCorrectImport = fixedCodigo.includes(`import type { ${typeAnalise.typeName} }`) || fixedCodigo.includes(`import { type ${typeAnalise.typeName} }`);
         if (!hasCorrectImport) {
@@ -36,11 +25,9 @@ export async function validateTypeReplacement(originalCode, fixedCodigo, typeAna
             result.isCompatible = false;
         }
     }
-    // 4. Verificar confiança mínima
     if (typeAnalise.confidence < CONFIANCA_MINIMA) {
         result.warnings.push(`Confiança muito baixa (${typeAnalise.confidence}%). Considere revisão manual.`);
     }
-    // 5. Validar sintaxe básica do código modificado
     const syntaxValidation = validateBasicSyntax(fixedCodigo);
     if (!syntaxValidation.isValid) {
         result.errors.push(...syntaxValidation.errors);
@@ -48,35 +35,23 @@ export async function validateTypeReplacement(originalCode, fixedCodigo, typeAna
     }
     return result;
 }
-/**
- * Valida compatibilidade do tipo inferido com uso real
- */
 function validateTypeUsageCompatibility(code, typeAnalise) {
-    // Simplificado - em produção, usar TypeScript compiler API
-    // para verificação completa
-    // Por enquanto, considerar compatível se confiança >= 70%
     const isCompatible = typeAnalise.confidence >= 70;
     return {
         isCompatible,
         expectedType: typeAnalise.inferredTipo
     };
 }
-/**
- * Valida sintaxe básica do código
- */
 function validateBasicSyntax(code) {
     const errors = [];
-    // Verificar balanceamento de chaves
     const braceContagem = (code.match(/{/g) ?? []).length - (code.match(/}/g) ?? []).length;
     if (braceContagem !== 0) {
         errors.push(`Chaves desbalanceadas: diferença de ${Math.abs(braceContagem)}`);
     }
-    // Verificar balanceamento de parênteses
     const parenContagem = (code.match(/\(/g) ?? []).length - (code.match(/\)/g) ?? []).length;
     if (parenContagem !== 0) {
         errors.push(`Parênteses desbalanceados: diferença de ${Math.abs(parenContagem)}`);
     }
-    // Verificar balanceamento de colchetes
     const bracketContagem = (code.match(/\[/g) ?? []).length - (code.match(/\]/g) ?? []).length;
     if (bracketContagem !== 0) {
         errors.push(`Colchetes desbalanceados: diferença de ${Math.abs(bracketContagem)}`);
@@ -86,25 +61,17 @@ function validateBasicSyntax(code) {
         errors
     };
 }
-/**
- * Simula compilação TypeScript (simplificado)
- * Em produção, usar TypeScript compiler API
- */
 export function runTypeScriptCompiler(code) {
-    // Simplificado - validações básicas
     const errors = [];
-    // Verificar imports malformados
     const importLines = code.split('\n').filter(line => line.trim().startsWith('import'));
     for (const line of importLines) {
         if (!line.includes('from') && !line.includes('=')) {
             errors.push(`Import malformado: ${line.trim()}`);
         }
     }
-    // Verificar sintaxe de interface
     const interfaceRegex = /interface\s+\w+\s*{[^}]*}/g;
     const interfaces = code.match(interfaceRegex) ?? [];
     for (const iface of interfaces) {
-        // Verificar propriedades
         const properties = iface.match(/\w+\s*\??\s*:\s*[\w\[\]<>|&\s]+;/g);
         if (!properties) {
             errors.push(`Interface malformada: ${iface.substring(0, 50)}...`);

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

@@ -1,34 +1,21 @@
-// @mahoraga-disable ml-deep-nesting
-// 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) {
@@ -38,9 +25,6 @@ export function findVariableUsages(varNome, ast) {
     });
     return usages;
 }
-/**
- * Analisa padrões de uso para inferir tipo
- */
 export function analyzeUsagePatterns(usages) {
     const pattern = {
         allUsagesAreString: false,
@@ -54,32 +38,23 @@ 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;
@@ -87,16 +62,12 @@ 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) {
@@ -120,7 +91,6 @@ function extractObjectProperties(usages) {
                 });
             }
             else {
-                // Atualizar métodos chamados
                 if (usage.method && !existing.methodsCalled?.includes(usage.method)) {
                     existing.methodsCalled = [...(existing.methodsCalled ?? []), usage.method];
                 }
@@ -172,9 +142,6 @@ function detectTypeGuards(usages) {
     }
     return guards;
 }
-/**
- * Traversa AST recursivamente
- */
 function traverseAST(node, visitor) {
     if (!node || typeof node !== 'object') {
         return;
@@ -182,7 +149,7 @@ function traverseAST(node, visitor) {
     visitor(node);
     for (const key in node) {
         if (key === 'loc' || key === 'start' || key === 'end' || key === 'range') {
-            continue; // Skip location metadata
+            continue;
         }
         const child = node[key];
         if (Array.isArray(child)) {
@@ -195,9 +162,6 @@ function traverseAST(node, visitor) {
         }
     }
 }
-/**
- * Extrai informações de uso de um nó Identifier
- */
 function extractUsageFromNode(node, varNome) {
     return {
         name: varNome,
@@ -208,9 +172,6 @@ function extractUsageFromNode(node, varNome) {
         operation: 'access'
     };
 }
-/**
- * Extrai informações de MemberExpression
- */
 function extractMemberExpressionUsage(node, varNome) {
     const property = node.property?.name ?? String(node.property.value);
     return {
@@ -223,9 +184,6 @@ function extractMemberExpressionUsage(node, varNome) {
         property: property || undefined
     };
 }
-/**
- * Extrai informações de CallExpression
- */
 function extractCallExpressionUsage(node, varNome) {
     const method = node.callee?.property?.name;
     return {
@@ -238,11 +196,7 @@ function extractCallExpressionUsage(node, varNome) {
         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 (node.name ?? '');
     }

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

@@ -1,12 +1,10 @@
-// @mahoraga-disable ml-deep-nesting
-// 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?.SUKUNA_DISABLE_PLUGIN_CSS === '1';
+const disableEnv = globalThis.process?.env?.MAHORAGA_DISABLE_PLUGIN_CSS === '1';
 function warn(message, relPath, line, nivelArg = messages.SeverityNiveis.warning) {
     return criarOcorrencia({
         relPath,
@@ -20,12 +18,10 @@ 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();
-        // 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;
@@ -45,14 +41,11 @@ function collectCssIssues(src, relPath) {
                     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 {
-                    // Valores diferentes sem padrão claro = possível erro
                     ocorrencias.push(warn(messages.CssMensagens.duplicatePropertyDifferent(prop, prev.value, value), relPath, line));
                 }
             }
@@ -63,19 +56,15 @@ function collectCssIssues(src, relPath) {
                 };
             }
         }
-        // !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));
         }
-        // Fecha blocos depois de processar a linha
         const closes = (trimmed.match(/\}/g) ?? []).length;
         for (let indice = 0; indice < closes; indice++) {
             if (stack.length) {
@@ -109,7 +98,6 @@ function canonicalizeDecls(decls) {
         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]));
@@ -127,8 +115,6 @@ function parseWithPostCssRoots(src, relPath) {
     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 ? {
@@ -137,7 +123,6 @@ function parseWithPostCssRoots(src, relPath) {
         });
         const rootUnknown = result.root;
         const rootAny = rootUnknown;
-        // 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;
@@ -145,7 +130,6 @@ function parseWithPostCssRoots(src, relPath) {
             });
             return roots.length ? roots : null;
         }
-        // Caso padrão: um único Root
         return [result.root];
     }
     catch {
@@ -162,25 +146,15 @@ function formatAtRuleContext(node) {
     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',
-    // CSS modernas (propriedades válidas e amplamente suportadas — ver feedback.md 1.4)
     'clip-path', 'backdrop-filter', 'aspect-ratio', 'accent-color', 'appearance', 'user-select',
     'object-fit', 'object-position', 'mix-blend-mode', 'filter', 'backdrop', 'will-change',
     'place-items', 'place-content', 'place-self', 'grid-auto-flow', 'grid-auto-columns', 'grid-auto-rows',
@@ -192,14 +166,12 @@ const CONHECIDAS_CSS_PROPRIEDADES = new Set([
 ]);
 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'
@@ -248,14 +220,12 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
     };
     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 = (decl.prop || '').trim();
-                // SCSS variável: "$color: ..." (não é propriedade CSS)
                 if (!propRaw || propRaw.startsWith('$')) {
                     return;
                 }
@@ -270,11 +240,9 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
                     value,
                     line
                 };
-                // Validação de propriedade inválida
                 if (!isValidCssProperty(propRaw)) {
                     pushOnce(warn(messages.CssMensagens.invalidProperty(propRaw), relPath, line));
                 }
-                // Detecta hacks CSS
                 const hack = detectCssHacks((decl.value || ''));
                 if (hack) {
                     pushOnce(warn(messages.CssMensagens.cssHackDetected(hack), relPath, line));
@@ -287,7 +255,6 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
                 }
             }
         });
-        // 2) Unificação/centralização (apenas em regras com seletores simples)
         if (container.type === 'rule') {
             const rule = container;
             const selectorText = rule.selector;
@@ -309,7 +276,6 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
                         value
                     });
                 });
-                // 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)));
@@ -331,9 +297,7 @@ 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)));
@@ -344,17 +308,14 @@ 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 = (at.name || '').toLowerCase();
                 const line = getNodeLine(at);
-                // @import http://...
                 if (name === 'import' && /^\s*(url\()?\s*['"]?http:\/\//i.test((at.params || ''))) {
                     pushOnce(warn(messages.CssMensagens.httpImport, relPath, line));
                 }
-                // Alguns at-rules tem bloco e nós internos; outros são só linha.
                 if (at.nodes?.length) {
                     visit(at, [...ctxAtRules, formatAtRuleContext(at)], ctxSelectors);
                 }
@@ -362,8 +323,6 @@ function collectCssIssuesFromPostCssAst(root, relPath) {
             }
             if (node.type === 'rule') {
                 const raiz = node;
-                // 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);
             }
@@ -401,7 +360,6 @@ export const analistaCss = criarAnalista({
         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 = [];
@@ -418,7 +376,6 @@ export const analistaCss = criarAnalista({
         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;
     }

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

@@ -1,13 +1,3 @@
-// @mahoraga-disable ml-deep-nesting
-// 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';

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

@@ -1,2 +1 @@
-// SPDX-License-Identifier: MIT
 export * from './correction-css.js';