tutanus 0.12.0

package/dist/analysts/detectors/detector-architecture.js

@@ -0,0 +1,665 @@
+import { traverse } from '../../core/config/index.js';
+import { messages } from '../../core/messages/index.js';
+import * as path from 'path';
+import { criarOcorrencia } from '../../types/index.js';
+export const analistaArquitetura = {
+    nome: 'arquitetura',
+    categoria: 'estrutura',
+    descricao: 'Analisa padrões arquiteturais e detecta violações de design',
+    test: (relPath) => {
+        return /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(relPath);
+    },
+    aplicar: async (src, relPath, ast, fullCaminho, contexto) => {
+        if (!ast || !src || !contexto) {
+            return [];
+        }
+        try {
+            const estatisticasArquivo = analisarArquivo(ast, relPath, src);
+            let analiseCompleta;
+            const ocorrencias = [];
+            try {
+                analiseCompleta = await analisarArquiteturaCompleta(contexto, estatisticasArquivo);
+            }
+            catch (erro) {
+                if (typeof contexto.report === 'function') {
+                    contexto.report({
+                        code: 'ARQ_ERRO',
+                        tipo: 'erro-analise',
+                        nivel: 'aviso',
+                        relPath,
+                        linha: 1,
+                        data: {
+                            erro
+                        },
+                        origem: 'arquitetura'
+                    });
+                    return [];
+                }
+                const { DetectorArquiteturaMensagens } = messages;
+                return [criarOcorrencia({
+                        tipo: 'erro-analise',
+                        nivel: 'aviso',
+                        mensagem: DetectorArquiteturaMensagens.erroAnalisarArquitetura(erro),
+                        relPath,
+                        linha: 1
+                    })];
+            }
+            if (typeof contexto.report === 'function') {
+                contexto.report({
+                    code: 'ARQ_PADRAO',
+                    tipo: 'analise-arquitetura',
+                    nivel: (analiseCompleta.violacoes?.length ?? 0) > 0 ? 'aviso' : 'info',
+                    relPath,
+                    linha: 1,
+                    data: {
+                        padraoIdentificado: analiseCompleta.padraoIdentificado,
+                        confianca: analiseCompleta.confianca ?? 0
+                    },
+                    origem: 'arquitetura'
+                });
+            }
+            else {
+                const { DetectorArquiteturaMensagens } = messages;
+                ocorrencias.push(criarOcorrencia({
+                    tipo: 'analise-arquitetura',
+                    nivel: (analiseCompleta.violacoes?.length ?? 0) > 0 ? 'aviso' : 'info',
+                    mensagem: DetectorArquiteturaMensagens.padraoArquitetural(analiseCompleta.padraoIdentificado, analiseCompleta.confianca ?? 0),
+                    relPath,
+                    linha: 1
+                }));
+            }
+            if ((analiseCompleta.caracteristicas?.length ?? 0) > 0) {
+                if (typeof contexto.report === 'function') {
+                    contexto.report({
+                        code: 'ARQ_CARACTERISTICAS',
+                        tipo: 'caracteristicas-arquitetura',
+                        nivel: 'info',
+                        relPath,
+                        linha: 1,
+                        data: {
+                            caracteristicas: analiseCompleta.caracteristicas || []
+                        },
+                        origem: 'arquitetura'
+                    });
+                }
+                else {
+                    const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
+                    ocorrencias.push(criarOcorrencia({
+                        tipo: 'caracteristicas-arquitetura',
+                        nivel: 'info',
+                        mensagem: DetectorArquiteturaMensagens.caracteristicas(analiseCompleta.caracteristicas || []),
+                        relPath,
+                        linha: 1
+                    }));
+                }
+            }
+            for (const violacao of (analiseCompleta.violacoes ?? []).slice(0, 3)) {
+                if (typeof contexto.report === 'function') {
+                    contexto.report({
+                        code: 'ARQ_VIOLACAO',
+                        tipo: 'violacao-arquitetura',
+                        nivel: 'aviso',
+                        relPath,
+                        linha: 1,
+                        data: {
+                            violacao
+                        },
+                        origem: 'arquitetura'
+                    });
+                }
+                else {
+                    const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
+                    ocorrencias.push(criarOcorrencia({
+                        tipo: 'violacao-arquitetura',
+                        nivel: 'aviso',
+                        mensagem: DetectorArquiteturaMensagens.violacao(violacao),
+                        relPath,
+                        linha: 1
+                    }));
+                }
+            }
+            const metricas = analiseCompleta.metricas;
+            if (metricas && typeof metricas === 'object' && 'acoplamento' in metricas && 'coesao' in metricas) {
+                if ((metricas.acoplamento ?? 0) > 0.7 || (metricas.coesao ?? 1) < 0.3) {
+                    if (typeof contexto.report === 'function') {
+                        contexto.report({
+                            code: 'ARQ_METRICAS',
+                            tipo: 'metricas-arquitetura',
+                            nivel: 'aviso',
+                            relPath,
+                            linha: 1,
+                            data: {
+                                acoplamento: metricas.acoplamento ?? 0,
+                                coesao: metricas.coesao ?? 0
+                            },
+                            origem: 'arquitetura'
+                        });
+                    }
+                    else {
+                        const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
+                        ocorrencias.push(criarOcorrencia({
+                            tipo: 'metricas-arquitetura',
+                            nivel: 'aviso',
+                            mensagem: DetectorArquiteturaMensagens.metricas(metricas.acoplamento ?? 0, metricas.coesao ?? 0),
+                            relPath,
+                            linha: 1
+                        }));
+                    }
+                }
+            }
+            return ocorrencias;
+        }
+        catch (erro) {
+            if (typeof contexto.report === 'function') {
+                contexto.report({
+                    code: 'ARQ_ERRO',
+                    tipo: 'erro-analise',
+                    nivel: 'aviso',
+                    relPath,
+                    linha: 1,
+                    data: {
+                        erro
+                    },
+                    origem: 'arquitetura'
+                });
+                return [];
+            }
+            const { DetectorArquiteturaMensagens } = await import('../../core/messages/pt/analysts/detector-architecture-messages.js');
+            return [criarOcorrencia({
+                    tipo: 'erro-analise',
+                    nivel: 'aviso',
+                    mensagem: DetectorArquiteturaMensagens.erroAnalisarArquitetura(erro),
+                    relPath,
+                    linha: 1
+                })];
+        }
+    }
+};
+function analisarArquivo(ast, relPath, _src) {
+    const imports = [];
+    const exports = [];
+    const dependenciasExternas = [];
+    const dependenciasInternas = [];
+    const aliases = {};
+    let complexidade = 0;
+    traverse(ast.node, {
+        ImportDeclaration(path) {
+            const origem = path.node.source.value;
+            const items = path.node.specifiers.map((spec) => {
+                if (spec.type === 'ImportDefaultSpecifier')
+                    return 'default';
+                if (spec.type === 'ImportNamespaceSpecifier')
+                    return '*';
+                return spec.local.name;
+            });
+            let tipo = 'external';
+            if (origem.startsWith('@')) {
+                tipo = 'alias';
+                const alias = origem.split('/')[0];
+                aliases[alias] = (aliases[alias] || 0) + 1;
+                dependenciasInternas.push(origem);
+            }
+            else if (origem.startsWith('.')) {
+                tipo = 'relative';
+                dependenciasInternas.push(origem);
+            }
+            else {
+                dependenciasExternas.push(origem);
+            }
+            imports.push({
+                origem,
+                tipo,
+                items
+            });
+        },
+        ExportNamedDeclaration(path) {
+            if (path.node.declaration) {
+                const decl = path.node.declaration;
+                if ('id' in decl && decl.id && 'name' in decl.id) {
+                    exports.push({
+                        nome: decl.id.name,
+                        tipo: 'named'
+                    });
+                }
+                else if ('declarations' in decl && decl.declarations) {
+                    for (const declarator of decl.declarations) {
+                        if (declarator.id && 'name' in declarator.id) {
+                            exports.push({
+                                nome: declarator.id.name,
+                                tipo: 'named'
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                for (const spec of path.node.specifiers) {
+                    const name = 'exported' in spec && spec.exported.type === 'Identifier' && 'name' in spec.exported ? spec.exported.name : 'exported';
+                    exports.push({
+                        nome: name,
+                        tipo: 'named'
+                    });
+                }
+            }
+        },
+        ExportDefaultDeclaration() {
+            exports.push({
+                nome: 'default',
+                tipo: 'default'
+            });
+        },
+        'IfStatement|WhileStatement|ForStatement|DoWhileStatement|SwitchCase|CatchClause'() {
+            complexidade++;
+        },
+        'ConditionalExpression|LogicalExpression'() {
+            complexidade++;
+        }
+    });
+    return {
+        caminho: relPath,
+        imports,
+        exports,
+        dependenciasExternas,
+        dependenciasInternas,
+        aliases,
+        complexidade: complexidade || 1
+    };
+}
+async function analisarArquiteturaCompleta(contexto, arquivoAtual) {
+    const todasEstatisticas = [];
+    for (const arquivo of contexto.arquivos.slice(0, 50)) {
+        if (arquivo.ast && arquivo.content && arquivo.relPath.match(/\.(js|jsx|ts|tsx)$/)) {
+            if ('parent' in arquivo.ast && 'node' in arquivo.ast) {
+                const stats = analisarArquivo(arquivo.ast, arquivo.relPath, arquivo.content);
+                todasEstatisticas.push(stats);
+            }
+        }
+    }
+    todasEstatisticas.push(arquivoAtual);
+    const padraoDetectado = detectarPadraoArquitetural(todasEstatisticas);
+    const cleanArchResultado = detectarCleanArchitecture(contexto, todasEstatisticas, arquivoAtual);
+    const distributedArchResultado = detectarArquiteturaDistribuida(contexto, todasEstatisticas, arquivoAtual);
+    const melhoresPadroes = [
+        { tipo: cleanArchResultado.tipo, confianca: cleanArchResultado.confianca },
+        { tipo: distributedArchResultado.tipo, confianca: distributedArchResultado.confianca },
+        padraoDetectado
+    ].sort((a, b) => b.confianca - a.confianca);
+    const padraoFinal = melhoresPadroes[0];
+    const metricas = calcularMetricas(todasEstatisticas);
+    const violacoes = detectarViolacoes(todasEstatisticas, padraoDetectado);
+    const caracteristicas = [
+        ...gerarCaracteristicas(todasEstatisticas),
+        ...cleanArchResultado.caracteristicas,
+        ...distributedArchResultado.caracteristicas
+    ];
+    const recomendacoes = [];
+    if (cleanArchResultado.confianca >= 50) {
+        recomendacoes.push(...cleanArchResultado.recomendacoes);
+    }
+    if (distributedArchResultado.confianca >= 50) {
+        recomendacoes.push(...distributedArchResultado.recomendacoes);
+    }
+    return {
+        padraoIdentificado: padraoFinal.tipo || padraoDetectado.tipo,
+        confianca: padraoFinal.confianca || padraoDetectado.confianca,
+        caracteristicas,
+        violacoes,
+        recomendacoes,
+        metricas,
+        imports: [],
+        exports: [],
+        stats: arquivoAtual
+    };
+}
+function detectarPadraoArquitetural(estatisticas) {
+    const aliases = new Set();
+    let temNucleo = false;
+    let temAnalistas = false;
+    let temShared = false;
+    let temTipos = false;
+    for (const stats of estatisticas) {
+        if (stats.aliases) {
+            Object.keys(stats.aliases).forEach(alias => aliases.add(alias));
+            if (stats.aliases['@nucleo'])
+                temNucleo = true;
+            if (stats.aliases['@analistas'])
+                temAnalistas = true;
+            if (stats.aliases['@shared'])
+                temShared = true;
+            if (stats.aliases['@types'])
+                temTipos = true;
+        }
+    }
+    const temDependenciasCirculares = detectarDependenciasCirculares(estatisticas);
+    if (temNucleo && temAnalistas && !temDependenciasCirculares) {
+        if (temShared && temTipos) {
+            return {
+                tipo: 'Arquitetura Hexagonal com Clean Architecture',
+                confianca: 90
+            };
+        }
+        return {
+            tipo: 'Arquitetura Hexagonal (Ports and Adapters)',
+            confianca: 85
+        };
+    }
+    if (aliases.size >= 4 && temTipos) {
+        return {
+            tipo: 'Arquitetura Modular Bem Estruturada',
+            confianca: 80
+        };
+    }
+    if (aliases.size >= 2) {
+        return {
+            tipo: 'Arquitetura Modular',
+            confianca: 70
+        };
+    }
+    if (temDependenciasCirculares) {
+        return {
+            tipo: 'Arquitetura com Problemas de Acoplamento',
+            confianca: 60
+        };
+    }
+    return {
+        tipo: 'Arquitetura Simples ou Monolítica',
+        confianca: 50
+    };
+}
+function calcularMetricas(estatisticas) {
+    if (estatisticas.length === 0) {
+        return {
+            modularidade: 0,
+            acoplamento: 0,
+            coesao: 0,
+            complexidadeMedia: 0
+        };
+    }
+    const totalImports = estatisticas.reduce((sum, string) => {
+        if (Array.isArray(string.imports)) {
+            return sum + string.imports.length;
+        }
+        else if (typeof string.imports === 'number') {
+            return sum + string.imports;
+        }
+        return sum;
+    }, 0);
+    const importsAlias = estatisticas.reduce((sum, string) => {
+        if (Array.isArray(string.imports)) {
+            return sum + string.imports.filter((indice) => indice.tipo === 'alias').length;
+        }
+        return sum;
+    }, 0);
+    const modularidade = totalImports > 0 ? importsAlias / totalImports : 0;
+    const totalDeps = estatisticas.reduce((sum, string) => {
+        const externas = string.dependenciasExternas?.length ?? 0;
+        const internas = string.dependenciasInternas?.length ?? 0;
+        return sum + externas + internas;
+    }, 0);
+    const depsExternas = estatisticas.reduce((sum, string) => {
+        return sum + (string.dependenciasExternas?.length ?? 0);
+    }, 0);
+    const acoplamento = totalDeps > 0 ? depsExternas / totalDeps : 0;
+    const totalExports = estatisticas.reduce((sum, string) => {
+        if (Array.isArray(string.exports)) {
+            return sum + string.exports.length;
+        }
+        else if (typeof string.exports === 'number') {
+            return sum + string.exports;
+        }
+        return sum;
+    }, 0);
+    const ratio = totalImports > 0 ? totalExports / totalImports : 0;
+    const coesao = ratio > 0 ? Math.min(ratio, 1 / ratio) : 0;
+    const complexidadeMedia = estatisticas.reduce((sum, string) => sum + (string.complexidade ?? 0), 0) / estatisticas.length;
+    return {
+        modularidade: Math.max(0, Math.min(1, modularidade)),
+        acoplamento: Math.max(0, Math.min(1, acoplamento)),
+        coesao: Math.max(0, Math.min(1, coesao)),
+        complexidadeMedia
+    };
+}
+function detectarViolacoes(estatisticas, _padrao) {
+    const violacoes = [];
+    const totalImports = estatisticas.reduce((sum, string) => {
+        if (Array.isArray(string.imports)) {
+            return sum + string.imports.length;
+        }
+        else if (typeof string.imports === 'number') {
+            return sum + string.imports;
+        }
+        return sum;
+    }, 0);
+    const importsRelativos = estatisticas.reduce((sum, string) => {
+        if (Array.isArray(string.imports)) {
+            return sum + string.imports.filter((indice) => indice.tipo === 'relative').length;
+        }
+        return sum;
+    }, 0);
+    if (totalImports > 0 && importsRelativos / totalImports > 0.3) {
+        violacoes.push('Uso excessivo de imports relativos (>30%)');
+    }
+    for (const stats of estatisticas) {
+        const importsContagem = Array.isArray(stats.imports) ? stats.imports.length : typeof stats.imports === 'number' ? stats.imports : 0;
+        if (importsContagem > 20) {
+            const caminho = stats.caminho ?? 'arquivo-desconhecido';
+            violacoes.push(`Arquivo ${path.basename(caminho)} com muitas dependências (${importsContagem})`);
+        }
+    }
+    return violacoes;
+}
+function gerarCaracteristicas(estatisticas) {
+    const caracteristicas = [];
+    const aliases = new Set();
+    estatisticas.forEach(string => {
+        if (string.aliases) {
+            Object.keys(string.aliases).forEach(arquivo => aliases.add(arquivo));
+        }
+    });
+    if (aliases.size > 0) {
+        caracteristicas.push(`Uso de ${aliases.size} aliases de importação`);
+    }
+    const mediaComplexidade = estatisticas.reduce((sum, string) => sum + (string.complexidade ?? 0), 0) / estatisticas.length;
+    caracteristicas.push(`Complexidade média: ${mediaComplexidade.toFixed(1)}`);
+    const totalExports = estatisticas.reduce((sum, string) => {
+        if (Array.isArray(string.exports)) {
+            return sum + string.exports.length;
+        }
+        else if (typeof string.exports === 'number') {
+            return sum + string.exports;
+        }
+        return sum;
+    }, 0);
+    caracteristicas.push(`${totalExports} exports públicos`);
+    return caracteristicas;
+}
+function detectarDependenciasCirculares(estatisticas) {
+    const dependencias = new Map();
+    for (const stats of estatisticas) {
+        const caminho = stats.caminho ?? 'arquivo-desconhecido';
+        const deps = new Set();
+        if (stats.dependenciasInternas) {
+            stats.dependenciasInternas.forEach(dep => deps.add(dep));
+        }
+        dependencias.set(caminho, deps);
+    }
+    for (const [arquivo, deps] of dependencias) {
+        for (const dep of deps) {
+            const depsDoDepdep = dependencias.get(dep);
+            if (depsDoDepdep?.has(arquivo)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function detectarCleanArchitecture(contexto, _estatisticas, _arquivoAtual) {
+    const caracteristicas = [];
+    const recomendacoes = [];
+    let pontuacao = 0;
+    const totalChecagens = 10;
+    const caminhos = contexto.arquivos.map(a => a.relPath.toLowerCase());
+    const temEntities = caminhos.some(c => c.includes('/domain/') || c.includes('/entities/') || c.endsWith('entity.ts') || c.endsWith('entity.js'));
+    const temValueObjects = caminhos.some(c => c.includes('/value-object') || c.includes('value-object'));
+    const temRepoInterfaces = caminhos.some(c => c.includes('/domain/') && (c.includes('repository') || c.includes('port')));
+    if (temEntities) {
+        pontuacao++;
+        caracteristicas.push('Camada de domínio com entidades detectada');
+    }
+    if (temValueObjects) {
+        pontuacao++;
+        caracteristicas.push('Value Objects presentes no domínio');
+    }
+    if (temRepoInterfaces) {
+        pontuacao++;
+        caracteristicas.push('Interfaces de repositório no domínio');
+    }
+    const temUseCases = caminhos.some(c => c.includes('/use-case') || c.includes('/use-cases/') || c.includes('/application/'));
+    const temDtos = caminhos.some(c => c.includes('/dto') || c.endsWith('.dto.ts') || c.endsWith('.dto.js'));
+    const temPorts = caminhos.some(c => c.includes('/ports') || c.includes('/application/port'));
+    if (temUseCases) {
+        pontuacao++;
+        caracteristicas.push('Casos de uso (use-cases) detectados');
+    }
+    if (temDtos) {
+        pontuacao++;
+        caracteristicas.push('DTOs na camada de aplicação');
+    }
+    if (temPorts) {
+        pontuacao++;
+        caracteristicas.push('Ports de aplicação detectados');
+    }
+    const temInfra = caminhos.some(c => c.includes('/infrastructure/') || c.includes('/infra/'));
+    const temReposImpl = caminhos.some(c => c.includes('/infrastructure/repositories') || c.includes('/infra/repositories'));
+    if (temInfra) {
+        pontuacao++;
+        caracteristicas.push('Camada de infraestrutura presente');
+    }
+    if (temReposImpl) {
+        pontuacao++;
+        caracteristicas.push('Implementações de repositórios na infra');
+    }
+    const temPresentation = caminhos.some(c => c.includes('/presentation/') || c.includes('/presenters/'));
+    const temControllers = caminhos.some(c => c.includes('/presentation/controllers') || c.includes('/controllers'));
+    if (temPresentation || temControllers) {
+        pontuacao++;
+        caracteristicas.push('Camada de apresentação/controllers detectada');
+    }
+    const temDependencyInversion = caminhos.some(c => c.includes('/domain/') && (c.includes('repository') || c.includes('port') || c.includes('interface')));
+    if (temDependencyInversion) {
+        pontuacao++;
+        caracteristicas.push('Princípio de Inversão de Dependência identificado');
+    }
+    for (const stats of _estatisticas) {
+        if (stats.caminho?.includes('/domain/') && stats.dependenciasInternas) {
+            const importsParaInfra = stats.dependenciasInternas.filter(d => d.includes('infrastructure') || d.includes('infra') || d.includes('presentation'));
+            if (importsParaInfra.length > 0) {
+                pontuacao -= 2;
+                recomendacoes.push('Domínio não deve importar camadas de infraestrutura (violação da Clean Architecture)');
+            }
+        }
+    }
+    if (!temEntities && !temValueObjects) {
+        recomendacoes.push('Considere criar uma camada de domínio com entidades e value-objects');
+    }
+    if (!temUseCases) {
+        recomendacoes.push('Adicione casos de uso (use-cases) na camada de aplicação para orquestrar regras de negócio');
+    }
+    if (!temRepoInterfaces && temReposImpl) {
+        recomendacoes.push('Defina interfaces de repositório no domínio e implemente na infraestrutura');
+    }
+    if (!temInfra && (temReposImpl || temControllers)) {
+        recomendacoes.push('Organize implementações concretas em uma camada de infraestrutura separada');
+    }
+    const confianca = Math.min(100, Math.round((pontuacao / totalChecagens) * 100));
+    return {
+        tipo: confianca >= 70 ? 'Clean Architecture (Arquitetura Limpa)' : 'Clean Architecture Parcial',
+        confianca,
+        caracteristicas,
+        recomendacoes
+    };
+}
+function detectarArquiteturaDistribuida(contexto, _estatisticas, _arquivoAtual) {
+    const caracteristicas = [];
+    const recomendacoes = [];
+    let pontuacao = 0;
+    const totalChecagens = 10;
+    const caminhos = contexto.arquivos.map(a => a.relPath.toLowerCase());
+    const conteudos = contexto.arquivos.map(a => a.content?.toLowerCase() || '');
+    const temMultiplosServicos = caminhos.some(c => c.includes('/services/') || c.includes('/service-') || c.includes('/microservice'));
+    const temServicosSeparados = new Set(caminhos.filter(c => c.includes('/services/'))
+        .map(c => c.split('/services/')[1]?.split('/')[0])
+        .filter(Boolean)).size > 1;
+    if (temMultiplosServicos) {
+        pontuacao++;
+        caracteristicas.push('Múltiplos serviços/módulos detectados');
+    }
+    if (temServicosSeparados) {
+        pontuacao++;
+        caracteristicas.push(`${temServicosSeparados} boundaries de serviço identificados`);
+    }
+    const temMensageria = caminhos.some(c => c.includes('message-queue') || c.includes('event-bus') || c.includes('rabbitmq') ||
+        c.includes('kafka') || c.includes('nats') || c.includes('sqs') || c.includes('pub-sub'));
+    const temMensageriaDeps = conteudos.some(c => c.includes('kafkajs') || c.includes('amqplib') || c.includes('ioredis') ||
+        c.includes('bull') || c.includes('bullmq') || c.includes('nats') || c.includes('grpc'));
+    if (temMensageria || temMensageriaDeps) {
+        pontuacao++;
+        caracteristicas.push('Sistema de mensageria/eventos detectado');
+    }
+    const temGateway = caminhos.some(c => c.includes('/gateway') || c.includes('/api-gateway') || c.includes('gateway.ts') || c.includes('gateway.js'));
+    if (temGateway) {
+        pontuacao++;
+        caracteristicas.push('API Gateway presente');
+    }
+    const temDiscovery = caminhos.some(c => c.includes('/discovery') || c.includes('service-discovery') || c.includes('consul') || c.includes('eureka'));
+    if (temDiscovery) {
+        pontuacao++;
+        caracteristicas.push('Service Discovery detectado');
+    }
+    const temDocker = caminhos.some(c => c.endsWith('dockerfile') || c.includes('docker-compose'));
+    const temK8s = caminhos.some(c => c.includes('kubernetes') || c.includes('k8s') || c.includes('.yaml') || c.includes('.yml'));
+    if (temDocker) {
+        pontuacao++;
+        caracteristicas.push('Docker presente para conteinerização');
+    }
+    if (temK8s) {
+        pontuacao++;
+        caracteristicas.push('Kubernetes para orquestração');
+    }
+    const temEventos = caminhos.some(c => c.includes('/events/') || c.includes('/event-handlers') || c.includes('/handlers/'));
+    const temAsyncPatterns = conteudos.filter(c => c.includes('eventemitter') || c.includes('observable') || c.includes('pubsub') ||
+        c.includes('publish') || c.includes('subscribe') || c.includes('webhook')).length > 2;
+    if (temEventos || temAsyncPatterns) {
+        pontuacao++;
+        caracteristicas.push('Padrões de comunicação assíncrona detectados');
+    }
+    const temShared = caminhos.some(c => c.includes('/shared/'));
+    const temMonitoring = caminhos.some(c => c.includes('/monitoring') || c.includes('/health') || c.includes('/metrics'));
+    if (temShared) {
+        pontuacao += 0;
+    }
+    if (temMonitoring) {
+        pontuacao++;
+        caracteristicas.push('Monitoramento/health checks detectados');
+    }
+    if (!temMensageria && !temMensageriaDeps && temMultiplosServicos) {
+        recomendacoes.push('Considere adicionar mensageria (Kafka, RabbitMQ) para comunicação assíncrona entre serviços');
+    }
+    if (!temGateway && temServicosSeparados) {
+        recomendacoes.push('Implemente um API Gateway para rotear requisições aos serviços');
+    }
+    if (!temDocker && temMultiplosServicos) {
+        recomendacoes.push('Adicione Docker para conteinerizar os serviços e facilitar deploy');
+    }
+    if (temMultiplosServicos && !temMonitoring) {
+        recomendacoes.push('Implemente health checks e monitoramento centralizado');
+    }
+    const confianca = Math.min(100, Math.round((pontuacao / totalChecagens) * 100));
+    return {
+        tipo: confianca >= 60 ? 'Arquitetura Distribuída / Microsserviços' : 'Arquitetura Monolítica com Tendências Distribuídas',
+        confianca,
+        caracteristicas,
+        recomendacoes
+    };
+}
+//# sourceMappingURL=detector-architecture.js.map