import { config, traverse } from '../../../core/config/index.js';
import { getMessages } from '../../../core/messages/index.js';
const { DetectorContextoExtraMensagens } = getMessages();
const PADROES_TECNOLOGIA = {
    'discord-bot': {
        dependencias: ['discord.js', '@discordjs/builders', '@discordjs/rest'],
        imports: ['discord.js', 'discord-api-types'],
        exports: [],
        estrutura: ['commands', 'events', 'handlers'],
        configs: ['bot.js', 'bot.ts', 'config/bot'],
        scripts: ['start:bot', 'dev:bot'],
        codigoPatterns: [/Client\(\s*\{[\s\S]*intents/i, /\.login\s*\(\s*process\.env/i, /interaction\.reply/i, /message\.reply/i],
        antiPatterns: [/new\s+Command\(/i,
            /program\.parse/i,
            /\.option\s*\(/i,
            /bin\/index\.(js|ts)/i
        ]
    },
    'telegram-bot': {
        dependencias: ['telegraf', 'grammy', 'node-telegram-bot-api'],
        imports: ['telegraf', 'grammy'],
        exports: [],
        estrutura: ['scenes', 'handlers', 'middleware'],
        configs: ['bot.js', 'bot.ts'],
        scripts: ['start:bot'],
        codigoPatterns: [/new\s+Telegraf/i, /bot\.command/i, /ctx\.reply/i, /\.telegram\.sendMessage/i],
        antiPatterns: [/new\s+Command\(/i, /program\.parse/i, /\.option\s*\(/i, /bin\/index\.(js|ts)/i]
    },
    'express-api': {
        dependencias: ['express', 'cors', 'helmet', 'joi', 'swagger', 'express-validator', 'multer', 'compression'],
        imports: ['express', 'cors', 'helmet', 'body-parser', 'cookie-parser'],
        exports: ['app', 'server', 'router'],
        estrutura: ['routes', 'controllers', 'middleware', 'models', 'services', 'utils', 'config'],
        configs: ['server.js', 'app.js', 'index.js', 'src/server.js', 'src/app.js'],
        scripts: ['start', 'dev', 'serve', 'test'],
        codigoPatterns: [/express\(\)/i, /app\.use\(/i, /app\.(get|post|put|delete|patch)\(/i, /res\.(json|send|status|sendStatus)/i, /req\.(body|params|query|headers)/i, /router\.(get|post|put|delete)/i, /middleware/i, /cors\(/i, /helmet\(/i],
        antiPatterns: []
    },
    'fastify-api': {
        dependencias: ['fastify', '@fastify/cors', '@fastify/helmet', '@fastify/jwt', '@fastify/rate-limit', '@fastify/swagger'],
        imports: ['fastify', '@fastify/cors', '@fastify/helmet'],
        exports: ['app', 'server', 'fastify'],
        estrutura: ['routes', 'plugins', 'handlers', 'schemas', 'services', 'utils'],
        configs: ['server.js', 'app.js', 'index.js', 'src/server.js', 'src/app.js'],
        scripts: ['start', 'dev', 'serve', 'test'],
        codigoPatterns: [/fastify\(\)/i, /\.register\(/i, /reply\.(send|code)/i, /\.listen\(\s*\d+/i, /fastify\.(get|post|put|delete|patch)/i, /request\.(body|params|query|headers)/i, /addHook/i, /setValidatorCompiler/i, /setSerializerCompiler/i],
        antiPatterns: []
    },
    'cli-modular': {
        dependencias: ['commander', 'yargs', 'inquirer', 'chalk', 'ora', 'prompts'],
        imports: ['commander', 'yargs', 'inquirer'],
        exports: [],
        estrutura: ['cli', 'cli/commands', 'bin', 'commands'],
        configs: ['cli.js', 'cli.ts', 'bin/', 'bin/index.js', 'bin/index.ts'],
        scripts: ['build', 'start', 'dev'],
        codigoPatterns: [/new\s+Command\(/i, /\.command\s*\(/i, /\.option\s*\(/i, /process\.argv/i, /\.parse\s*\(/i, /\.action\s*\(/i, /\.version\s*\(/i, /\.description\s*\(/i],
        antiPatterns: [/Client\(\s*\{[\s\S]*intents/i,
            /new\s+Telegraf/i,
            /bot\.command/i,
            /interaction\.reply/i,
            /ctx\.reply/i
        ]
    },
    'electron-app': {
        dependencias: ['electron', 'electron-builder', 'electron-updater'],
        imports: ['electron'],
        exports: [],
        estrutura: ['src/main', 'src/renderer', 'src/preload'],
        configs: ['main.js', 'main.ts', 'electron.js'],
        scripts: ['electron', 'build:electron', 'pack'],
        codigoPatterns: [/new\s+BrowserWindow/i, /app\.whenReady/i, /ipcMain\.handle/i, /contextBridge\.exposeInMainWorld/i],
        antiPatterns: []
    },
    'next-fullstack': {
        dependencias: ['next', 'react', 'react-dom', '@types/react', '@types/node', 'typescript'],
        imports: ['next', 'react', 'next/router', 'next/link', 'next/head'],
        exports: [],
        estrutura: ['pages', 'app', 'api', 'components', 'lib', 'utils', 'styles', 'public', 'prisma'],
        configs: ['next.config.js', 'next.config.ts', 'next.config.mjs', 'next-env.d.ts', 'tailwind.config.js'],
        scripts: ['dev', 'build', 'start', 'lint', 'type-check'],
        codigoPatterns: [/export\s+default\s+function.*Page/i, /getServerSideProps/i, /getStaticProps/i, /getStaticPaths/i, /NextApiRequest/i, /NextApiResponse/i, /useRouter/i, /next\/head/i, /next\/link/i, /export\s+default\s+function\s+Page/i,
            /export\s+default\s+function\s+Layout/i,
            /export\s+default\s+function\s+Loading/i,
            /export\s+default\s+function\s+Error/i,
            /export\s+default\s+function\s+NotFound/i,
            /metadata\s*=/i,
            /generateStaticParams/i,
            /generateMetadata/i
        ],
        antiPatterns: []
    },
    'react-spa': {
        dependencias: ['react', 'react-dom', 'react-router', 'vite'],
        imports: ['react', 'react-dom'],
        exports: [],
        estrutura: ['src/components', 'src/pages', 'src/hooks'],
        configs: ['vite.config.js', 'webpack.config.js'],
        scripts: ['dev', 'build', 'preview'],
        codigoPatterns: [/ReactDOM\.render/i, /createRoot/i, /useState/i, /useEffect/i],
        antiPatterns: []
    },
    'nest-api': {
        dependencias: ['@nestjs/core', '@nestjs/common', '@nestjs/platform-express'],
        imports: ['@nestjs/core', '@nestjs/common'],
        exports: [],
        estrutura: ['src/modules', 'src/controllers', 'src/services'],
        configs: ['main.ts', 'app.module.ts'],
        scripts: ['start', 'start:dev', 'build'],
        codigoPatterns: [/@Controller\(/i, /@Injectable\(/i, /@Module\(/i, /NestFactory\.create/i],
        antiPatterns: []
    },
    'koa-api': {
        dependencias: ['koa', 'koa-router', 'koa-cors', 'koa-helmet', 'koa-bodyparser'],
        imports: ['koa', 'koa-router', 'koa-cors', 'koa-helmet'],
        exports: ['app', 'server'],
        estrutura: ['routes', 'controllers', 'middleware', 'models', 'services'],
        configs: ['server.js', 'app.js', 'index.js'],
        scripts: ['start', 'dev', 'serve'],
        codigoPatterns: [/new\s+Koa\(\)/i, /app\.use\(/i, /router\.(get|post|put|delete)/i, /ctx\.(body|status|set)/i, /next\(\)/i, /middleware/i],
        antiPatterns: []
    },
    'hapi-api': {
        dependencias: ['@hapi/hapi', 'joi', 'boom'],
        imports: ['@hapi/hapi', 'joi', 'boom'],
        exports: ['server', 'routes'],
        estrutura: ['routes', 'controllers', 'plugins', 'models'],
        configs: ['server.js', 'index.js'],
        scripts: ['start', 'dev', 'serve'],
        codigoPatterns: [/Hapi\.server/i, /server\.route/i, /handler:\s*async/i, /request\.(payload|params|query)/i, /h\.response/i, /Joi\.object/i],
        antiPatterns: []
    },
    'serverless-api': {
        dependencias: ['serverless', 'serverless-offline', '@types/aws-lambda', 'aws-sdk'],
        imports: ['aws-lambda', 'aws-sdk'],
        exports: ['handler'],
        estrutura: ['src/handlers', 'src/functions', 'src/lib'],
        configs: ['serverless.yml', 'serverless.ts'],
        scripts: ['deploy', 'offline', 'invoke'],
        codigoPatterns: [/exports\.handler/i, /APIGatewayProxyEvent/i, /APIGatewayProxyResult/i, /Context/i, /Callback/i, /async\s+\(event/i],
        antiPatterns: []
    },
    'vue-spa': {
        dependencias: ['vue', '@vue/cli-service', 'vue-router', 'vuex', 'pinia'],
        imports: ['vue', 'vue-router', 'vuex', 'pinia'],
        exports: [],
        estrutura: ['src/components', 'src/views', 'src/router', 'src/store', 'src/composables', 'public'],
        configs: ['vue.config.js', 'vue.config.ts'],
        scripts: ['serve', 'build', 'lint'],
        codigoPatterns: [/createApp\(/i, /<template>/i, /<script>/i, /<style/i, /defineComponent/i, /setup\(\)/i, /ref\(/i, /reactive\(/i, /computed\(/i, /watch\(/i, /onMounted/i, /onUnmounted/i],
        antiPatterns: []
    },
    'nuxt-app': {
        dependencias: ['nuxt', 'nuxt3', '@nuxt/devtools', '@nuxtjs/tailwindcss'],
        imports: ['nuxt', '@nuxt/kit'],
        exports: [],
        estrutura: ['pages', 'components', 'layouts', 'plugins', 'middleware', 'composables', 'server/api'],
        configs: ['nuxt.config.js', 'nuxt.config.ts'],
        scripts: ['dev', 'build', 'generate', 'preview'],
        codigoPatterns: [/defineNuxtConfig/i, /useHead/i, /useState/i, /useFetch/i, /useAsyncData/i, /navigateTo/i, /<NuxtPage/i, /<NuxtLink/i, /definePageMeta/i, /server\/api/i],
        antiPatterns: []
    },
    'vite-vue': {
        dependencias: ['vue', 'vite', '@vitejs/plugin-vue', 'vue-router', 'pinia'],
        imports: ['vue', 'vite', '@vitejs/plugin-vue'],
        exports: [],
        estrutura: ['src/components', 'src/views', 'src/router', 'src/stores', 'src/composables', 'src/assets'],
        configs: ['vite.config.js', 'vite.config.ts', 'index.html'],
        scripts: ['dev', 'build', 'preview'],
        codigoPatterns: [/createApp\(/i, /<template>/i, /<script setup/i, /<style scoped/i, /defineComponent/i, /setup\(\)/i, /ref\(/i, /reactive\(/i, /computed\(/i],
        antiPatterns: []
    },
    'hono-api': {
        dependencias: ['hono', '@hono/node-server', '@hono/zod-validator'],
        imports: ['hono', 'hono/cors', 'hono/logger'],
        exports: ['app'],
        estrutura: ['src/routes', 'src/middleware'],
        configs: ['src/index.ts', 'src/index.js'],
        scripts: ['dev', 'start'],
        codigoPatterns: [/new\s+Hono\(\)/i, /app\.(get|post|put|delete|patch|use)\(/i, /c\.(json|text|html|redirect)/i, /return\s+c\.json/i],
        antiPatterns: []
    },
    'prisma-orm': {
        dependencias: ['@prisma/client', 'prisma'],
        imports: ['@prisma/client'],
        exports: ['prisma'],
        estrutura: ['prisma', 'prisma/schema.prisma'],
        configs: ['schema.prisma'],
        scripts: ['prisma:generate', 'prisma:migrate'],
        codigoPatterns: [/new\s+PrismaClient\(\)/i, /prisma\.\w+\.(findMany|findUnique|create|update|delete)/i],
        antiPatterns: []
    },
    'trpc-api': {
        dependencias: ['@trpc/server', '@trpc/client', '@trpc/react-query'],
        imports: ['@trpc/server', '@trpc/client'],
        exports: ['appRouter', 't'],
        estrutura: ['src/server/trpc', 'src/trpc'],
        configs: [],
        scripts: [],
        codigoPatterns: [/initTRPC\.create\(\)/i, /t\.router\(\{/i, /t\.procedure/i, /publicProcedure/i],
        antiPatterns: []
    },
    'zod-validation': {
        dependencias: ['zod'],
        imports: ['zod'],
        exports: [],
        estrutura: [],
        configs: [],
        scripts: [],
        codigoPatterns: [/z\.object\(\{/i, /z\.string\(\)/i, /z\.infer<typeof/i, /\.parse\(/i, /\.safeParse\(/i],
        antiPatterns: []
    },
    'vitest-testing': {
        dependencias: ['vitest', '@vitest/ui', '@vitest/coverage-v8'],
        imports: ['vitest'],
        exports: [],
        estrutura: ['tests', '__tests__', 'src/__tests__'],
        configs: ['vitest.config.ts', 'vitest.config.js'],
        scripts: ['test', 'test:ui', 'coverage'],
        codigoPatterns: [/describe\(/i, /it\(/i, /test\(/i, /expect\(/i, /vi\.fn\(\)/i, /vi\.mock\(/i],
        antiPatterns: []
    }
};
function analisarDependencias(packageJson) {
    const evidencias = [];
    if (!packageJson)
        return evidencias;
    const deps = {
        ...(packageJson.dependencies || {}),
        ...(packageJson.devDependencies || {})
    };
    if (config.VERBOSE) {
        console.log(DetectorContextoExtraMensagens.debugDependencias, Object.keys(deps));
    }
    for (const [tecnologia, padroes] of Object.entries(PADROES_TECNOLOGIA)) {
        for (const dep of padroes.dependencias) {
            if (deps[dep]) {
                evidencias.push({
                    tipo: 'dependencia',
                    valor: dep,
                    confianca: 0.8,
                    tecnologia,
                    localizacao: 'package.json'
                });
            }
        }
    }
    return evidencias;
}
function analisarScripts(packageJson) {
    const evidencias = [];
    if (!packageJson)
        return evidencias;
    const scripts = packageJson.scripts || {};
    for (const [tecnologia, padroes] of Object.entries(PADROES_TECNOLOGIA)) {
        for (const script of padroes.scripts) {
            if (Object.keys(scripts).some(key => key.includes(script) || scripts[key]?.includes(script))) {
                evidencias.push({
                    tipo: 'script',
                    valor: script,
                    confianca: 0.6,
                    tecnologia,
                    localizacao: 'package.json'
                });
            }
        }
    }
    return evidencias;
}
function analisarEstrutura(estruturaDetectada) {
    const evidencias = [];
    for (const [tecnologia, padroes] of Object.entries(PADROES_TECNOLOGIA)) {
        for (const estrutura of padroes.estrutura) {
            const matchExato = estruturaDetectada?.find(dir => {
                if (dir === estrutura)
                    return true;
                if (dir.endsWith(`/${estrutura}`))
                    return true;
                if (dir.startsWith(`${estrutura}/`))
                    return true;
                if (estrutura.includes('/')) {
                    const estruturaNorm = estrutura.replace(/\\/g, '/');
                    const dirNorm = dir.replace(/\\/g, '/');
                    if (dirNorm === estruturaNorm)
                        return true;
                    if (dirNorm.endsWith(`/${estruturaNorm}`))
                        return true;
                    if (dirNorm.startsWith(`${estruturaNorm}/`))
                        return true;
                }
                return false;
            });
            if (matchExato) {
                evidencias.push({
                    tipo: 'estrutura',
                    valor: estrutura,
                    confianca: 0.7,
                    tecnologia,
                    localizacao: matchExato
                });
            }
        }
    }
    return evidencias;
}
function analisarImportsExports(arquivos) {
    const evidencias = [];
    for (const arquivo of arquivos) {
        if (!arquivo.ast || !('node' in arquivo.ast) || !arquivo.ast.node || arquivo.ast.node.type !== 'Program')
            continue;
        const programa = arquivo.ast.node;
        const imports = [];
        const exports = [];
        traverse(programa, {
            ImportDeclaration(path) {
                const node = path.node;
                if (typeof node.source.value === 'string') {
                    imports.push(node.source.value);
                }
            },
            ExportDeclaration(path) {
                const node = path.node;
                if ('declaration' in node && node.declaration) {
                    if ('id' in node.declaration && node.declaration.id && 'name' in node.declaration.id) {
                        if (typeof node.declaration.id.name === 'string')
                            exports.push(node.declaration.id.name);
                    }
                }
            }
        });
        for (const [tecnologia, padroes] of Object.entries(PADROES_TECNOLOGIA)) {
            for (const importEsperado of padroes.imports) {
                if (imports.some(imp => imp.includes(importEsperado))) {
                    evidencias.push({
                        tipo: 'import',
                        valor: importEsperado,
                        confianca: 0.9,
                        tecnologia,
                        localizacao: arquivo.relPath
                    });
                }
            }
            for (const exportEsperado of padroes.exports) {
                if (exports.some(exp => exp.includes(exportEsperado))) {
                    evidencias.push({
                        tipo: 'export',
                        valor: exportEsperado,
                        confianca: 0.8,
                        tecnologia,
                        localizacao: arquivo.relPath
                    });
                }
            }
        }
    }
    return evidencias;
}
function analisarPadroesCodigo(arquivos) {
    const evidencias = [];
    for (const arquivo of arquivos) {
        if (!arquivo.content)
            continue;
        for (const [tecnologia, padroes] of Object.entries(PADROES_TECNOLOGIA)) {
            for (const pattern of padroes.codigoPatterns) {
                if (pattern.test(arquivo.content)) {
                    evidencias.push({
                        tipo: 'codigo',
                        valor: pattern.source,
                        confianca: 0.85,
                        tecnologia,
                        localizacao: arquivo.relPath
                    });
                }
            }
        }
    }
    return evidencias;
}
function verificarAntiPatterns(arquivos, tecnologia) {
    const padraoTecnologia = PADROES_TECNOLOGIA[tecnologia];
    if (!padraoTecnologia || !padraoTecnologia.antiPatterns) {
        return false;
    }
    for (const arquivo of arquivos) {
        if (!arquivo.content)
            continue;
        for (const antiPadrao of padraoTecnologia.antiPatterns) {
            if (antiPadrao.test(arquivo.content)) {
                return true;
            }
        }
    }
    return false;
}
function gerarSugestoesMelhoria(tecnologia, evidencias) {
    const sugestoes = [];
    const _arquivosEncontrados = evidencias.map(erro => erro.localizacao).filter(Boolean);
    switch (tecnologia) {
        case 'discord-bot':
            if (!evidencias.some(erro => erro.valor.includes('intents'))) {
                sugestoes.push('[CHAVE-INGLESA] Configurar intents específicos no Discord Client para melhor performance');
            }
            if (!evidencias.some(erro => erro.valor.includes('command'))) {
                sugestoes.push('[FOLDER] Estruturar commands em pasta dedicada para organização');
            }
            if (!evidencias.some(erro => erro.valor.includes('rate'))) {
                sugestoes.push('[BOLT] Implementar rate limiting para evitar banimento por spam');
            }
            break;
        case 'express-api':
            if (!evidencias.some(erro => erro.valor.includes('helmet'))) {
                sugestoes.push('[SHIELD] Adicionar helmet para headers de segurança');
            }
            if (!evidencias.some(erro => erro.valor.includes('cors'))) {
                sugestoes.push('[GLOBE] Configurar CORS adequadamente para APIs');
            }
            if (!evidencias.some(erro => erro.valor.includes('joi') && erro.valor.includes('swagger'))) {
                sugestoes.push('[LIST] Implementar validação com Joi e documentação Swagger');
            }
            break;
        case 'cli-modular':
            if (!evidencias.some(erro => erro.valor.includes('help'))) {
                sugestoes.push('[PERGUNTA] Implementar comando --help abrangente');
            }
            if (!evidencias.some(erro => erro.valor.includes('version'))) {
                sugestoes.push('[PACOTE] Adicionar comando --version');
            }
            if (!evidencias.some(erro => erro.valor.includes('config'))) {
                sugestoes.push('[CONFIG] Considerar arquivo de configuração para usuários');
            }
            break;
        case 'electron-app':
            if (!evidencias.some(erro => erro.valor.includes('preload'))) {
                sugestoes.push('[BLOQUEADO] Implementar preload script para comunicação segura');
            }
            if (!evidencias.some(erro => erro.valor.includes('contextIsolation'))) {
                sugestoes.push('[SHIELD] Habilitar context isolation para segurança');
            }
            if (!evidencias.some(erro => erro.valor.includes('updater'))) {
                sugestoes.push('[REFRESH] Implementar auto-updater para atualizações automáticas');
            }
            break;
    }
    return sugestoes;
}
function detectarProblemas(tecnologia, evidencias, arquivos) {
    const problemas = [];
    switch (tecnologia) {
        case 'discord-bot':
            for (const arquivo of arquivos) {
                if (arquivo.content?.includes('token') && !arquivo.content.includes('process.env')) {
                    problemas.push(`[ALERT] Possível token hardcoded em ${arquivo.relPath}`);
                }
            }
            break;
        case 'express-api':
            const temHelmet = evidencias.some(erro => erro.valor.includes('helmet'));
            const temCors = evidencias.some(erro => erro.valor.includes('cors'));
            if (!temHelmet) {
                problemas.push('[AVISO] API sem helmet - vulnerável a ataques de header');
            }
            if (!temCors) {
                problemas.push('[AVISO] API sem CORS configurado - possíveis problemas de origem');
            }
            break;
        case 'electron-app':
            for (const arquivo of arquivos) {
                if (arquivo.content?.includes('nodeIntegration: true')) {
                    problemas.push(`[ALERT] nodeIntegration habilitado em ${arquivo.relPath} - risco de segurança`);
                }
                if (arquivo.content?.includes('contextIsolation: false')) {
                    problemas.push(`[ALERT] contextIsolation desabilitado em ${arquivo.relPath} - vulnerabilidade`);
                }
            }
            break;
    }
    return problemas;
}
function calcularConfiancaTotal(evidencias) {
    if (evidencias.length === 0)
        return 0;
    const pesosPorTipo = {
        dependencia: 1.0,
        import: 0.9,
        codigo: 0.85,
        export: 0.8,
        estrutura: 0.7,
        script: 0.6,
        config: 0.5
    };
    let somaConfianca = 0;
    let somaPesos = 0;
    for (const evidencia of evidencias) {
        const peso = pesosPorTipo[evidencia.tipo] || 0.5;
        somaConfianca += evidencia.confianca * peso;
        somaPesos += peso;
    }
    return somaPesos > 0 ? somaConfianca / somaPesos : 0;
}
export function detectarContextoInteligente(estruturaDetectada, arquivos, packageJson, options) {
    if (!options?.quiet && config.VERBOSE) {
        console.log(DetectorContextoExtraMensagens.debugPackageCompleto, JSON.stringify(packageJson, null, 2));
        if (packageJson?.dependencies?.vue) {
            console.log(DetectorContextoExtraMensagens.debugPackageVue, packageJson.dependencies.vue);
        }
    }
    const todasEvidencias = [...analisarDependencias(packageJson), ...analisarScripts(packageJson), ...analisarEstrutura(estruturaDetectada), ...analisarImportsExports(arquivos), ...analisarPadroesCodigo(arquivos)];
    const evidenciasPorTecnologia = new Map();
    for (const evidencia of todasEvidencias) {
        const tec = evidencia.tecnologia || 'desconhecido';
        if (!evidenciasPorTecnologia.has(tec)) {
            evidenciasPorTecnologia.set(tec, []);
        }
        const tecEvidencias = evidenciasPorTecnologia.get(tec);
        if (tecEvidencias) {
            tecEvidencias.push(evidencia);
        }
    }
    const resultados = [];
    for (const [tecnologia, evidencias] of evidenciasPorTecnologia) {
        let confiancaTotal = calcularConfiancaTotal(evidencias);
        const padraoTecnologia = PADROES_TECNOLOGIA[tecnologia];
        if (padraoTecnologia && padraoTecnologia.dependencias.length > 0) {
            const temDependenciaObrigatoria = evidencias.some(erro => erro.tipo === 'dependencia' && padraoTecnologia.dependencias.includes(erro.valor));
            if (!temDependenciaObrigatoria) {
                confiancaTotal *= 0.1;
            }
        }
        const temAntiPadrao = verificarAntiPatterns(arquivos, tecnologia);
        if (temAntiPadrao) {
            confiancaTotal = 0;
            evidencias.push({
                tipo: 'codigo',
                valor: 'anti-pattern-detectado',
                confianca: -1.0,
                tecnologia,
                localizacao: 'código'
            });
        }
        if (confiancaTotal > 0.3) {
            resultados.push({
                tecnologia,
                confiancaTotal,
                evidencias,
                sugestoesMelhoria: gerarSugestoesMelhoria(tecnologia, evidencias),
                problemasDetectados: detectarProblemas(tecnologia, evidencias, arquivos)
            });
        }
    }
    return resultados.sort((arquivo, base) => base.confiancaTotal - arquivo.confiancaTotal);
}
export function inferirArquetipoInteligente(estruturaDetectada, arquivos, packageJson, options) {
    const resultados = detectarContextoInteligente(estruturaDetectada, arquivos, packageJson, options);
    if (resultados.length === 0)
        return 'generico';
    const melhorResultado = resultados[0];
    const mapeamentoArquetipos = {
        'discord-bot': 'bot',
        'telegram-bot': 'bot',
        'express-api': 'api-rest-express',
        'fastify-api': 'api-rest-express',
        'nest-api': 'api-rest-express',
        'koa-api': 'api-rest-express',
        'hapi-api': 'api-rest-express',
        'serverless-api': 'api-rest-express',
        'cli-modular': 'cli-modular',
        'electron-app': 'electron',
        'next-fullstack': 'fullstack',
        'react-spa': 'landing-page',
        'vue-spa': 'vue-spa',
        'nuxt-app': 'vue-spa',
        'vite-vue': 'vue-spa'
    };
    return mapeamentoArquetipos[melhorResultado.tecnologia || 'generico'] || 'generico';
}
//# sourceMappingURL=detector-context-smart.js.map