@mocoto/mahoraga 0.14.2 → 0.14.3

package/dist/analysts/corrections/analyst-scoring.js

@@ -42,32 +42,35 @@ export const analistaQuickFixes = {
         const uniqueFixes = quickFixes.filter((fix, index, arr) => arr.findIndex(arquivo => arquivo.id === fix.id) === index);
         for (const fixResultado of uniqueFixes) {
             for (const match of fixResultado.matches) {
-                const linha = calcularLinha(src, match.index, match);
-                const previewCorrecao = fixResultado.fix(match, src);
-                const originalLine = src.split('\n')[linha - 1] || '';
-                const fixedLine = previewCorrecao.split('\n')[linha - 1] || '';
-                const sugestao = [fixResultado.description, '', `[CHAVE-INGLESA] Correção sugerida:`, `[ERRO] Antes: ${originalLine.trim()}`, `[OK] Depois: ${fixedLine.trim()}`, '', `Confiança: ${fixResultado.confidence}%`, `Categoria: ${fixResultado.category}`, `ID do Fix: ${fixResultado.id}`].join('\n');
-                const nivel = mapearCategoriaNivel(fixResultado.category);
-                const ocorrencia = criarOcorrencia({
-                    tipo: 'auto-fix-disponivel',
-                    nivel,
-                    mensagem: fixResultado.title,
-                    relPath,
-                    linha
-                });
-                const ocorrenciaGenerica = ocorrencia;
-                ocorrenciaGenerica.sugestao = sugestao;
-                ocorrenciaGenerica.quickFixId = fixResultado.id;
-                ocorrenciaGenerica.confidence = fixResultado.confidence;
-                ocorrenciaGenerica.category = fixResultado.category;
-                ocorrenciaGenerica.matchIndex = match.index;
-                ocorrenciaGenerica.matchLength = match[0].length;
-                ocorrencias.push(ocorrencia);
+                processQuickFixMatchScoring(match, fixResultado, src, relPath, ocorrencias);
             }
         }
         return ocorrencias;
     }
 };
+function processQuickFixMatchScoring(match, fixResultado, src, relPath, ocorrencias) {
+    const linha = calcularLinha(src, match.index, match);
+    const previewCorrecao = fixResultado.fix(match, src);
+    const originalLine = src.split('\n')[linha - 1] || '';
+    const fixedLine = previewCorrecao.split('\n')[linha - 1] || '';
+    const sugestao = [fixResultado.description, '', `[CHAVE-INGLESA] Correção sugerida:`, `[ERRO] Antes: ${originalLine.trim()}`, `[OK] Depois: ${fixedLine.trim()}`, '', `Confiança: ${fixResultado.confidence}%`, `Categoria: ${fixResultado.category}`, `ID do Fix: ${fixResultado.id}`].join('\n');
+    const nivel = mapearCategoriaNivel(fixResultado.category);
+    const ocorrencia = criarOcorrencia({
+        tipo: 'auto-fix-disponivel',
+        nivel,
+        mensagem: fixResultado.title,
+        relPath,
+        linha
+    });
+    const ocorrenciaGenerica = ocorrencia;
+    ocorrenciaGenerica.sugestao = sugestao;
+    ocorrenciaGenerica.quickFixId = fixResultado.id;
+    ocorrenciaGenerica.confidence = fixResultado.confidence;
+    ocorrenciaGenerica.category = fixResultado.category;
+    ocorrenciaGenerica.matchIndex = match.index;
+    ocorrenciaGenerica.matchLength = match[0].length;
+    ocorrencias.push(ocorrencia);
+}
 // ─── analistaPontuacao ────────────────────────────────────────
 export const analistaPontuacao = {
     nome: 'pontuacao-fix',

package/dist/analysts/corrections/corrector-structure.js

@@ -31,41 +31,7 @@ export async function corrigirEstrutura(mapa, fileEntries, baseDir = process.cwd
             log.info(CorretorEstruturaExtraMensagens.simular.replace('{arquivo}', arquivo).replace('{destino}', path.relative(baseDir, destino)));
             return;
         }
-        try {
-            await fs.mkdir(path.dirname(destino), {
-                recursive: true
-            });
-        }
-        catch (err) {
-            const msg = err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err);
-            logAuto.corretorErroCriarDiretorio(destino, msg);
-            return;
-        }
-        try {
-            // Usa flag 'wx' para escrita exclusiva - falha se o arquivo já existir,
-            // eliminando a condição de corrida TOCTOU entre stat e write
-            const conteudo = await fs.readFile(origem, 'utf-8');
-            const { novoConteudo } = reescreverImports(conteudo, path.posix.normalize(arquivo.replace(/\\/g, '/')), path.posix.normalize(path.relative(baseDir, destino).replace(/\\/g, '/')));
-            // Registra o move no mapa de reversão
-            await mapaReversao.registrarMove(arquivo, path.relative(baseDir, destino), entry.motivo ?? 'Reorganização estrutural', conteudo, novoConteudo, true);
-            try {
-                await fs.writeFile(destino, novoConteudo, { encoding: 'utf-8', flag: 'wx' });
-            }
-            catch (err) {
-                const code = err.code;
-                if (code === 'EEXIST') {
-                    logAuto.corretorDestinoExiste(arquivo, path.relative(baseDir, destino));
-                    return;
-                }
-                throw err;
-            }
-            await fs.unlink(origem);
-            log.sucesso(CorretorEstruturaExtraMensagens.movido.replace('{arquivo}', arquivo).replace('{destino}', path.relative(baseDir, destino)));
-        }
-        catch (err) {
-            const msg = err && typeof err === 'object' && 'message' in err ? String((err).message) : String(err);
-            logAuto.corretorErroMover(arquivo, msg);
-        }
+        await moverArquivoComReversao(entry, origem, destino, baseDir, arquivo);
     })));
     for (const pluginRel of PLUGINS) {
         try {
@@ -108,3 +74,37 @@ export async function corrigirEstrutura(mapa, fileEntries, baseDir = process.cwd
         }
     }
 }
+async function moverArquivoComReversao(entry, origem, destino, baseDir, arquivo) {
+    try {
+        await fs.mkdir(path.dirname(destino), {
+            recursive: true
+        });
+    }
+    catch (err) {
+        const msg = err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err);
+        logAuto.corretorErroCriarDiretorio(destino, msg);
+        return;
+    }
+    try {
+        const conteudo = await fs.readFile(origem, 'utf-8');
+        const { novoConteudo } = reescreverImports(conteudo, path.posix.normalize(arquivo.replace(/\\/g, '/')), path.posix.normalize(path.relative(baseDir, destino).replace(/\\/g, '/')));
+        await mapaReversao.registrarMove(arquivo, path.relative(baseDir, destino), entry.motivo ?? 'Reorganização estrutural', conteudo, novoConteudo, true);
+        try {
+            await fs.writeFile(destino, novoConteudo, { encoding: 'utf-8', flag: 'wx' });
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'EEXIST') {
+                logAuto.corretorDestinoExiste(arquivo, path.relative(baseDir, destino));
+                return;
+            }
+            throw err;
+        }
+        await fs.unlink(origem);
+        log.sucesso(CorretorEstruturaExtraMensagens.movido.replace('{arquivo}', arquivo).replace('{destino}', path.relative(baseDir, destino)));
+    }
+    catch (err) {
+        const msg = err && typeof err === 'object' && 'message' in err ? String((err).message) : String(err);
+        logAuto.corretorErroMover(arquivo, msg);
+    }
+}

package/dist/analysts/corrections/fix-alias-imports.js

@@ -13,6 +13,15 @@ export function aplicarFixAliasImports(fileCaminho, content) {
         content: out
     };
 }
+async function processTypeFileForAlias(fileCaminho) {
+    const src = await fs.readFile(fileCaminho, 'utf8');
+    const { changed: wasChanged, content } = aplicarFixAliasImports(fileCaminho, src);
+    if (wasChanged) {
+        await fs.writeFile(fileCaminho, content, 'utf8');
+        return 1;
+    }
+    return 0;
+}
 export async function scanAndApplyFix(root) {
     let changed = 0;
     async function walk(dir) {
@@ -26,12 +35,7 @@ export async function scanAndApplyFix(root) {
                     await walk(fileCaminho);
                 }
                 else if (entry.isFile() && fileCaminho.endsWith('.ts')) {
-                    const src = await fs.readFile(fileCaminho, 'utf8');
-                    const { changed: wasChanged, content } = aplicarFixAliasImports(fileCaminho, src);
-                    if (wasChanged) {
-                        await fs.writeFile(fileCaminho, content, 'utf8');
-                        changed++;
-                    }
+                    changed += await processTypeFileForAlias(fileCaminho);
                 }
             }
         }

package/dist/analysts/corrections/fix-md-fences.js

@@ -48,33 +48,33 @@ export function fixFences(content) {
     }
     return out.join('\n');
 }
-export async function scanAndApplyFixMdFences(root) {
-    let changed = 0;
-    async function listMarkdown(dir) {
-        const out = [];
-        try {
-            const entries = await fs.readdir(dir, {
-                withFileTypes: true
-            });
-            for (const entry of entries) {
-                const fullCaminho = path.join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    if (/^(node_modules|dist|coverage|pre-public|preview-mahoraga|\.git)$/i.test(entry.name)) {
-                        continue;
-                    }
-                    out.push(...(await listMarkdown(fullCaminho)));
-                }
-                else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
-                    out.push(fullCaminho);
+async function listMarkdownFiles(dir) {
+    const out = [];
+    try {
+        const entries = await fs.readdir(dir, {
+            withFileTypes: true
+        });
+        for (const entry of entries) {
+            const fullCaminho = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (/^(node_modules|dist|coverage|pre-public|preview-mahoraga|\.git)$/i.test(entry.name)) {
+                    continue;
                 }
+                out.push(...(await listMarkdownFiles(fullCaminho)));
+            }
+            else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
+                out.push(fullCaminho);
             }
-            return out;
-        }
-        catch {
-            return out;
         }
+        return out;
+    }
+    catch {
+        return out;
     }
-    const files = await listMarkdown(root);
+}
+export async function scanAndApplyFixMdFences(root) {
+    let changed = 0;
+    const files = await listMarkdownFiles(root);
     for (const fileCaminho of files) {
         const rel = path.relative(root, fileCaminho).replace(/\\/g, '/');
         if (rel.startsWith('pre-public/') || rel.includes('/legado/')) {

package/dist/analysts/corrections/map-reversion.js

@@ -172,57 +172,8 @@ export class GerenciadorMapaReversao {
                 recursive: true
             });
             // Move o arquivo de volta
-            if (move.importsReescritos && move.conteudoOriginal) {
-                // Usa flag 'wx' para escrita exclusiva - falha se o arquivo já existir,
-                // eliminando a condição de corrida TOCTOU entre stat e write
-                try {
-                    await fs.writeFile(origemCaminho, move.conteudoOriginal, {
-                        encoding: 'utf-8',
-                        flag: 'wx'
-                    });
-                }
-                catch (err) {
-                    const code = err.code;
-                    if (code === 'EEXIST') {
-                        logAuto.mapaReversaoArquivoExisteOrigem(move.origem);
-                        return false;
-                    }
-                    if (err.code && err.code !== 'ENOENT') {
-                        logAuto.mapaReversaoErroReverter(err.message);
-                        return false;
-                    }
-                    throw err;
-                }
-                try {
-                    await fs.unlink(destinoCaminho);
-                }
-                catch (err) {
-                    if (err.code === 'ENOENT') {
-                        logAuto.mapaReversaoArquivoDestinoNaoEncontrado(move.destino);
-                        return false;
-                    }
-                    throw err;
-                }
-                log.sucesso(MapaReversaoExtraMensagens.arquivoRevertidoConteudo.replace('{destino}', move.destino).replace('{origem}', move.origem));
-            }
-            else {
-                // Usa rename atômico - se destino não existir, falha com ENOENT
-                try {
-                    await fs.rename(destinoCaminho, origemCaminho);
-                }
-                catch (err) {
-                    const code = err.code;
-                    if (code === 'ENOENT') {
-                        logAuto.mapaReversaoArquivoDestinoNaoEncontrado(move.destino);
-                        return false;
-                    }
-                    if (code === 'EEXIST') {
-                        logAuto.mapaReversaoArquivoExisteOrigem(move.origem);
-                        return false;
-                    }
-                    throw err;
-                }
-                log.sucesso(MapaReversaoExtraMensagens.arquivoRevertido.replace('{destino}', move.destino).replace('{origem}', move.origem));
+            if (!await this.reverterComConteudo(move, origemCaminho, destinoCaminho)) {
+                return false;
             }
             // Remove o move do mapa
             await this.removerMove(id);
@@ -295,6 +246,58 @@ export class GerenciadorMapaReversao {
             logAuto.mapaReversaoErroSalvar(err.message);
         }
     }
+    async reverterComConteudo(move, origemCaminho, destinoCaminho) {
+        if (move.importsReescritos && move.conteudoOriginal) {
+            try {
+                await fs.writeFile(origemCaminho, move.conteudoOriginal, {
+                    encoding: 'utf-8',
+                    flag: 'wx'
+                });
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === 'EEXIST') {
+                    logAuto.mapaReversaoArquivoExisteOrigem(move.origem);
+                    return false;
+                }
+                if (err.code && err.code !== 'ENOENT') {
+                    logAuto.mapaReversaoErroReverter(err.message);
+                    return false;
+                }
+                throw err;
+            }
+            try {
+                await fs.unlink(destinoCaminho);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    logAuto.mapaReversaoArquivoDestinoNaoEncontrado(move.destino);
+                    return false;
+                }
+                throw err;
+            }
+            log.sucesso(MapaReversaoExtraMensagens.arquivoRevertidoConteudo.replace('{destino}', move.destino).replace('{origem}', move.origem));
+        }
+        else {
+            try {
+                await fs.rename(destinoCaminho, origemCaminho);
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === 'ENOENT') {
+                    logAuto.mapaReversaoArquivoDestinoNaoEncontrado(move.destino);
+                    return false;
+                }
+                if (code === 'EEXIST') {
+                    logAuto.mapaReversaoArquivoExisteOrigem(move.origem);
+                    return false;
+                }
+                throw err;
+            }
+            log.sucesso(MapaReversaoExtraMensagens.arquivoRevertido.replace('{destino}', move.destino).replace('{origem}', move.origem));
+        }
+        return true;
+    }
 }
 // Instância global
 export const mapaReversao = new GerenciadorMapaReversao();

package/dist/analysts/corrections/pruning.js

@@ -91,21 +91,24 @@ function moverArquivosSimulado(lista, base) {
 async function moverArquivos(lista, base, historico) {
     const limitar = pLimit(CONCORRENCIA);
     await Promise.all(lista.map(pend => limitar(async () => {
-        const src = path.join(base, pend.arquivo);
-        const dest = path.join(base, DIR_ABANDONADOS, pend.arquivo);
-        try {
-            const fs = await import('node:fs');
-            await ensureDir(dest);
-            await fs.promises.rename(src, dest);
-            historico.push({
-                arquivo: pend.arquivo,
-                movidoEm: new Date().toISOString(),
-                motivo: pend.motivo
-            });
-            logAuto.podaArquivoMovido(pend.arquivo);
-        }
-        catch (err) {
-            log.erro(`[ERRO] Falha ao mover ${pend.arquivo}: ${typeof err === 'object' && err && 'message' in err ? err.message : String(err)}`);
-        }
+        await moverArquivoIndividual(pend, base, historico);
     })));
 }
+async function moverArquivoIndividual(pend, base, historico) {
+    const src = path.join(base, pend.arquivo);
+    const dest = path.join(base, DIR_ABANDONADOS, pend.arquivo);
+    try {
+        const fs = await import('node:fs');
+        await ensureDir(dest);
+        await fs.promises.rename(src, dest);
+        historico.push({
+            arquivo: pend.arquivo,
+            movidoEm: new Date().toISOString(),
+            motivo: pend.motivo
+        });
+        logAuto.podaArquivoMovido(pend.arquivo);
+    }
+    catch (err) {
+        log.erro(`[ERRO] Falha ao mover ${pend.arquivo}: ${typeof err === 'object' && err && 'message' in err ? err.message : String(err)}`);
+    }
+}

package/dist/analysts/corrections/quick-fixes/fix-any-to-proper-type.js

@@ -10,9 +10,10 @@ import { analyzeTypeUsage } from '../type-safety/type-analyzer.js';
 import { createTypeDefinition } from '../type-safety/type-creator.js';
 import { validateTypeReplacement } from '../type-safety/type-validator.js';
 const { MENSAGENS_CORRECAO_TIPOS } = getMessages();
+const CONFIANCA_MEDIA = 60;
 const CONFIANCA_NIVEIS = {
     HIGH: 85,
-    MEDIUM: 60,
+    MEDIUM: CONFIANCA_MEDIA,
     DEFAULT: 70
 };
 export const fixAnyToProperTipo = {
@@ -62,66 +63,7 @@ export async function fixAnyToProperTypeAsync(match, fullCode, fileCaminho, ast)
         const typeAnalise = analyzeTypeUsage(match, fullCode, fileCaminho, ast);
         // 2. Estratégia baseada em confiança
         if (typeAnalise.confidence >= CONFIANCA_NIVEIS.HIGH) {
-            // ALTA CONFIANÇA: Aplicar tipo automaticamente
-            if (typeAnalise.isSimpleType) {
-                // Tipo primitivo: substituir diretamente
-                const fixedCodigo = fullCode.replace(match[0], `: ${typeAnalise.inferredTipo}`);
-                // Validar resultado
-                const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
-                if (!validation.isCompatible) {
-                    return {
-                        code: fullCode,
-                        applied: false,
-                        reason: `Validação falhou: ${validation.errors.join(', ')}`,
-                        warnings: validation.warnings.map(dimensaoLargura => ({
-                            type: 'unsafe-type',
-                            message: dimensaoLargura,
-                            suggestion: 'Revise manualmente'
-                        }))
-                    };
-                }
-                return {
-                    code: fixedCodigo,
-                    applied: true,
-                    warnings: validation.warnings.map(dimensaoLargura => ({
-                        type: 'type-suggestion',
-                        message: dimensaoLargura,
-                        suggestion: MENSAGENS_CORRECAO_TIPOS.validacao.revisar
-                    }))
-                };
-            }
-            else {
-                // Tipo complexo: criar interface
-                const typeCaminho = await createTypeDefinition(typeAnalise, fileCaminho);
-                const importStatement = `import type { ${typeAnalise.typeName} } from '${typeCaminho}';\n`;
-                // Adicionar import no topo e substituir any
-                const lines = fullCode.split('\n');
-                const importIndex = findImportInsertionPoint(lines);
-                lines.splice(importIndex, 0, importStatement);
-                let fixedCodigo = lines.join('\n');
-                fixedCodigo = fixedCodigo.replace(match[0], `: ${typeAnalise.typeName}`);
-                // Validar resultado
-                const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
-                if (!validation.isCompatible) {
-                    return {
-                        code: fullCode,
-                        applied: false,
-                        reason: `Validação falhou: ${validation.errors.join(', ')}`
-                    };
-                }
-                return {
-                    code: fixedCodigo,
-                    applied: true,
-                    additionalChanges: [{
-                            type: 'add-import',
-                            content: importStatement
-                        }, {
-                            type: 'create-type-file',
-                            content: typeAnalise.typeDefinition,
-                            path: buildTypesRelPathPosix(typeAnalise.suggestedPath)
-                        }]
-                };
-            }
+            return await applyHighConfidenceAnyFix(match, fullCode, fileCaminho, typeAnalise);
         }
         else if (typeAnalise.confidence >= CONFIANCA_NIVEIS.MEDIUM) {
             // MÉDIA CONFIANÇA: Sugerir mas não aplicar
@@ -162,6 +104,60 @@ export async function fixAnyToProperTypeAsync(match, fullCode, fileCaminho, ast)
         };
     }
 }
+async function applyHighConfidenceAnyFix(match, fullCode, fileCaminho, typeAnalise) {
+    if (typeAnalise.isSimpleType) {
+        const fixedCodigo = fullCode.replace(match[0], `: ${typeAnalise.inferredTipo}`);
+        const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
+        if (!validation.isCompatible) {
+            return {
+                code: fullCode,
+                applied: false,
+                reason: `Validação falhou: ${validation.errors.join(', ')}`,
+                warnings: validation.warnings.map(dimensaoLargura => ({
+                    type: 'unsafe-type',
+                    message: dimensaoLargura,
+                    suggestion: 'Revise manualmente'
+                }))
+            };
+        }
+        return {
+            code: fixedCodigo,
+            applied: true,
+            warnings: validation.warnings.map(dimensaoLargura => ({
+                type: 'type-suggestion',
+                message: dimensaoLargura,
+                suggestion: MENSAGENS_CORRECAO_TIPOS.validacao.revisar
+            }))
+        };
+    }
+    const typeCaminho = await createTypeDefinition(typeAnalise, fileCaminho);
+    const importStatement = `import type { ${typeAnalise.typeName} } from '${typeCaminho}';\n`;
+    const lines = fullCode.split('\n');
+    const importIndex = findImportInsertionPoint(lines);
+    lines.splice(importIndex, 0, importStatement);
+    let fixedCodigo = lines.join('\n');
+    fixedCodigo = fixedCodigo.replace(match[0], `: ${typeAnalise.typeName}`);
+    const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
+    if (!validation.isCompatible) {
+        return {
+            code: fullCode,
+            applied: false,
+            reason: `Validação falhou: ${validation.errors.join(', ')}`
+        };
+    }
+    return {
+        code: fixedCodigo,
+        applied: true,
+        additionalChanges: [{
+                type: 'add-import',
+                content: importStatement
+            }, {
+                type: 'create-type-file',
+                content: typeAnalise.typeDefinition,
+                path: buildTypesRelPathPosix(typeAnalise.suggestedPath)
+            }]
+    };
+}
 /**
  * Encontra ponto de inserção para import
  */

package/dist/analysts/corrections/quick-fixes/fix-unknown-to-specific-type.js

@@ -51,36 +51,7 @@ export async function fixUnknownToSpecificTypeAsync(match, fullCode, fileCaminho
         const typeAnalise = await analyzeUnknownUsage(match, fullCode, fileCaminho, ast);
         // 2. Estratégia mais conservadora (requer >= 90% confiança)
         if (typeAnalise.confidence >= 90) {
-            // ALTA CONFIANÇA: Criar interface dedicada
-            const typeCaminho = await createTypeDefinition(typeAnalise, fileCaminho);
-            const importStatement = `import type { ${typeAnalise.typeName} } from '${typeCaminho}';\n`;
-            // Adicionar import e substituir unknown
-            const lines = fullCode.split('\n');
-            const importIndex = findImportInsertionPoint(lines);
-            lines.splice(importIndex, 0, importStatement);
-            let fixedCodigo = lines.join('\n');
-            fixedCodigo = fixedCodigo.replace(match[0], `: ${typeAnalise.typeName}`);
-            // Validar
-            const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
-            if (!validation.isCompatible) {
-                return {
-                    code: fullCode,
-                    applied: false,
-                    reason: `Validação falhou: ${validation.errors.join(', ')}`
-                };
-            }
-            return {
-                code: fixedCodigo,
-                applied: true,
-                additionalChanges: [{
-                        type: 'add-import',
-                        content: importStatement
-                    }, {
-                        type: 'create-type-file',
-                        content: typeAnalise.typeDefinition,
-                        path: buildTypesRelPathPosix(typeAnalise.suggestedPath)
-                    }]
-            };
+            return await applyHighConfidenceUnknownFix(match, fullCode, fileCaminho, typeAnalise);
         }
         else if (typeAnalise.confidence >= 70) {
             // MÉDIA CONFIANÇA: Sugerir tipo
@@ -120,6 +91,35 @@ export async function fixUnknownToSpecificTypeAsync(match, fullCode, fileCaminho
         };
     }
 }
+async function applyHighConfidenceUnknownFix(match, fullCode, fileCaminho, typeAnalise) {
+    const typeCaminho = await createTypeDefinition(typeAnalise, fileCaminho);
+    const importStatement = `import type { ${typeAnalise.typeName} } from '${typeCaminho}';\n`;
+    const lines = fullCode.split('\n');
+    const importIndex = findImportInsertionPoint(lines);
+    lines.splice(importIndex, 0, importStatement);
+    let fixedCodigo = lines.join('\n');
+    fixedCodigo = fixedCodigo.replace(match[0], `: ${typeAnalise.typeName}`);
+    const validation = await validateTypeReplacement(fullCode, fixedCodigo, typeAnalise);
+    if (!validation.isCompatible) {
+        return {
+            code: fullCode,
+            applied: false,
+            reason: `Validação falhou: ${validation.errors.join(', ')}`
+        };
+    }
+    return {
+        code: fixedCodigo,
+        applied: true,
+        additionalChanges: [{
+                type: 'add-import',
+                content: importStatement
+            }, {
+                type: 'create-type-file',
+                content: typeAnalise.typeDefinition,
+                path: buildTypesRelPathPosix(typeAnalise.suggestedPath)
+            }]
+    };
+}
 /**
  * Encontra ponto de inserção para import
  */

package/dist/analysts/corrections/reorganize-barrels.js

@@ -28,6 +28,15 @@ function resolverImportRelativo(arquivoRel, importSpec) {
     const dir = path.posix.dirname(normalizarRel(arquivoRel));
     return path.posix.normalize(path.posix.join(dir, importSpec));
 }
+function resolverImportSpec(spec, rel) {
+    if (spec.startsWith('@/')) {
+        return semExt(normalizarRel(`src/${spec.slice(2)}`));
+    }
+    if (spec.startsWith('@')) {
+        return semExt(normalizarRel(`src/${spec.slice(1)}`)).replace(/^src\//, '');
+    }
+    return semExt(resolverImportRelativo(rel, spec));
+}
 function criarMapaMovimentos(mapa, _baseDir) {
     const movimentos = new Map();
     for (const entry of mapa) {
@@ -231,16 +240,7 @@ async function atualizarImportsGlobais(srcDir, movimentos) {
                     if (!isRelative && !isAlias) {
                         continue;
                     }
-                    let resolved;
-                    if (spec.startsWith('@/')) {
-                        resolved = semExt(normalizarRel(`src/${spec.slice(2)}`));
-                    }
-                    else if (spec.startsWith('@')) {
-                        resolved = semExt(normalizarRel(`src/${spec.slice(1)}`)).replace(/^src\//, '');
-                    }
-                    else {
-                        resolved = semExt(resolverImportRelativo(rel, spec));
-                    }
+                    const resolved = resolverImportSpec(spec, rel);
                     const moveDestino = movimentos.get(resolved);
                     if (!moveDestino) {
                         continue;